feat(TS) Migrate modules\detection\VADNoiseDetection.ts to TS (#2854)

Author: naman9271

modules/detection/VADNoiseDetection.js renamed to modules/detection/VADNoiseDetection.ts

@@ -2,41 +2,68 @@ import EventEmitter from '../util/EventEmitter';
 import { calculateAverage, filterPositiveValues } from '../util/MathUtil';
 
 import { DetectionEvents } from './DetectionEvents';
+import { IVADScore } from './VADAudioAnalyser';
 
 /**
  * The average value VAD needs to be under over a period of time to be considered noise.
  * @type {number}
  */
-const VAD_NOISE_AVG_THRESHOLD = 0.2;
+const VAD_NOISE_AVG_THRESHOLD: number = 0.2;
 
 /**
  * The average values that audio input need to be over to be considered loud.
  * @type {number}
  */
-const NOISY_AUDIO_LEVEL_THRESHOLD = 0.040;
+const NOISY_AUDIO_LEVEL_THRESHOLD: number = 0.040;
 
 /**
  * The value that a VAD score needs to be under in order for processing to begin.
  * @type {number}
  */
-const VAD_SCORE_TRIGGER = 0.2;
+const VAD_SCORE_TRIGGER: number = 0.2;
 
 /**
  * The value that a VAD score needs to be under in order for processing to begin.
  * @type {number}
  */
-const AUDIO_LEVEL_SCORE_TRIGGER = 0.020;
+const AUDIO_LEVEL_SCORE_TRIGGER: number = 0.020;
 
 /**
  * Time span over which we calculate an average score used to determine if we trigger the event.
  * @type {number}
  */
-const PROCESS_TIME_FRAME_SPAN_MS = 1500;
+const PROCESS_TIME_FRAME_SPAN_MS: number = 1500;
 
 /**
  * Detect if provided VAD score and PCM data is considered noise.
  */
 export default class VADNoiseDetection extends EventEmitter {
+    /**
+     * Flag which denotes the current state of the detection service i.e.if there is already a processing operation
+     * ongoing.
+     */
+    private _processing: boolean;
+
+    /**
+     * Buffer that keeps the VAD scores for a period of time.
+     */
+    private _scoreArray: number[];
+
+    /**
+     * Buffer that keeps audio level samples for a period of time.
+     */
+    private _audioLvlArray: number[];
+
+    /**
+     * Current state of the service, if it's not active no processing will occur.
+     */
+    private _active: boolean;
+
+    /**
+     * Timeout reference for processing VAD scores.
+     */
+    private _processTimeout?: NodeJS.Timeout;
+
     /**
      * Creates <tt>VADNoiseDetection</tt>
      *
@@ -66,6 +93,11 @@ export default class VADNoiseDetection extends EventEmitter {
          */
         this._active = false;
 
+        /**
+         * Timeout reference for processing VAD scores.
+         */
+        this._processTimeout = null;
+
         this._calculateNoisyScore = this._calculateNoisyScore.bind(this);
     }
 
@@ -75,9 +107,9 @@ export default class VADNoiseDetection extends EventEmitter {
      * @returns {void}
      * @fires VAD_NOISY_DEVICE
      */
-    _calculateNoisyScore() {
-        const scoreAvg = calculateAverage(this._scoreArray);
-        const audioLevelAvg = calculateAverage(this._audioLvlArray);
+    private _calculateNoisyScore(): void {
+        const scoreAvg = calculateAverage(new Float32Array(this._scoreArray));
+        const audioLevelAvg = calculateAverage(new Float32Array(this._audioLvlArray));
 
         if (scoreAvg < VAD_NOISE_AVG_THRESHOLD && audioLevelAvg > NOISY_AUDIO_LEVEL_THRESHOLD) {
             this.emit(DetectionEvents.VAD_NOISY_DEVICE);
@@ -89,34 +121,34 @@ export default class VADNoiseDetection extends EventEmitter {
         this.reset();
     }
 
-    /**
-     * Record the vad score and average volume in the appropriate buffers.
-     *
-     * @param {number} vadScore
-     * @param {number} avgAudioLvl - average audio level of the PCM sample associated with the VAD score.s
-     */
-    _recordValues(vadScore, avgAudioLvl) {
-        this._scoreArray.push(vadScore);
-        this._audioLvlArray.push(avgAudioLvl);
-    }
-
     /**
      * Set the active state of the detection service and notify any listeners.
      *
      * @param {boolean} active
      * @fires DETECTOR_STATE_CHANGE
      */
-    _setActiveState(active) {
+    private _setActiveState(active: boolean): void {
         this._active = active;
         this.emit(DetectionEvents.DETECTOR_STATE_CHANGE, this._active);
     }
 
+    /**
+     * Record the vad score and average volume in the appropriate buffers.
+     *
+     * @param {number} vadScore
+     * @param {number} avgAudioLvl - average audio level of the PCM sample associated with the VAD score.s
+     */
+    private _recordValues(vadScore: number, avgAudioLvl: number): void {
+        this._scoreArray.push(vadScore);
+        this._audioLvlArray.push(avgAudioLvl);
+    }
+
     /**
      * Change the state according to the muted status of the tracked device.
      *
      * @param {boolean} isMuted - Is the device muted or not.
      */
-    changeMuteState(isMuted) {
+    public changeMuteState(isMuted: boolean): void {
         // This service only needs to run when the microphone is not muted.
         this._setActiveState(!isMuted);
         this.reset();
@@ -127,22 +159,10 @@ export default class VADNoiseDetection extends EventEmitter {
      *
      * @returns {boolean}
      */
-    isActive() {
+    public isActive(): boolean {
         return this._active;
     }
 
-    /**
-     * Reset the processing context, clear buffers, cancel the timeout trigger.
-     *
-     * @returns {void}
-     */
-    reset() {
-        this._processing = false;
-        this._scoreArray = [];
-        this._audioLvlArray = [];
-        clearTimeout(this._processTimeout);
-    }
-
     /**
      * Listens for {@link TrackVADEmitter} events and processes them.
      *
@@ -153,26 +173,28 @@ export default class VADNoiseDetection extends EventEmitter {
      * @param {string} vadScore.deviceId - Device id of the associated track.
      * @listens VAD_SCORE_PUBLISHED
      */
-    processVADScore(vadScore) {
+    public processVADScore(vadScore: IVADScore): void {
         if (!this._active) {
             return;
         }
 
         // There is a processing phase on going, add score to buffer array.
         if (this._processing) {
-            // Filter and calculate sample average so we don't have to process one large array at a time.
-            const posAudioLevels = filterPositiveValues(vadScore.pcmData);
+        // Filter and calculate sample average so we don't have to process one large array at a time.
+            const pcmDataArray = Array.isArray(vadScore.pcmData) ? new Float32Array(vadScore.pcmData) : vadScore.pcmData;
+            const posAudioLevels = filterPositiveValues(pcmDataArray);
 
-            this._recordValues(vadScore.score, calculateAverage(posAudioLevels));
+            this._recordValues(vadScore.score, calculateAverage(new Float32Array(posAudioLevels)));
 
             return;
         }
 
         // If the VAD score for the sample is low and audio level has a high enough level we can start listening for
         // noise
         if (vadScore.score < VAD_SCORE_TRIGGER) {
-            const posAudioLevels = filterPositiveValues(vadScore.pcmData);
-            const avgAudioLvl = calculateAverage(posAudioLevels);
+            const pcmDataArray = Array.isArray(vadScore.pcmData) ? new Float32Array(vadScore.pcmData) : vadScore.pcmData;
+            const posAudioLevels = filterPositiveValues(pcmDataArray);
+            const avgAudioLvl = calculateAverage(new Float32Array(posAudioLevels));
 
             if (avgAudioLvl > AUDIO_LEVEL_SCORE_TRIGGER) {
                 this._processing = true;
@@ -183,4 +205,19 @@ export default class VADNoiseDetection extends EventEmitter {
             }
         }
     }
+
+    /**
+     * Reset the processing context, clear buffers, cancel the timeout trigger.
+     *
+     * @returns {void}
+     */
+    public reset(): void {
+        this._processing = false;
+        this._scoreArray = [];
+        this._audioLvlArray = [];
+        if (this._processTimeout) {
+            clearTimeout(this._processTimeout);
+            this._processTimeout = null;
+        }
+    }
 }