feat: enhance voice call handling and improve RNNoise integration

- Implement deterministic caller election to prevent double-dial glare.
- Introduce a pendingCallsRef to manage outbound connections and avoid duplicates.
- Add ICE connection state handling to restart failed connections.
- Refactor RNNoise processor to use synchronous WASM loading for improved performance.
- Optimize audio processing by managing input and output buffers more efficiently.
- Ensure proper handling of audio frames and maintain audio quality during processing.

Author: BerkayDuzey

.firebase/hosting.ZGlzdA.cache

@@ -1,6 +1,8 @@
-index.html,1774280652987,8bf40e82c66c3dbe4ab83e2124fdd143380352e1332b4bd32b36a1ecf4b4c6fb
-icons.svg,1774280652923,cc5ba1c58a9496115441b46650182deb0169982e8a98d605d965ce966ff37184
-assets/index-fNcAj_4k.css,1774280652987,6e390470412f0266335552c453978fad3072729804604a7fe73635c9e040ebbd
-favicon.svg,1774280652922,201714848d2eaecc14a9e2c9db2694646f7a53af7e7cce941c8bf103b38b4895
-logo.svg,1774280652923,2790afba95ebe7a2f9cd57ee6ec7cd7e76763b200544f2dc5bdbbe55b6a2434e
-assets/index-si1sbIgS.js,1774280652987,c02b499744a56fdeda9377a571827dc24ac3dbb9d825467b5a61dd73cef8a76c
+rnnoise-processor.js,1774286653481,c211d82a0892275db26800afcaab794a451303eab185cee632fac141bd0b81d3
+index.html,1774286653551,5b762a8b00f6f27d0991b38330b6cf2af48d0d9d80e15be7cb5da81430693fe2
+icons.svg,1774286653480,cc5ba1c58a9496115441b46650182deb0169982e8a98d605d965ce966ff37184
+assets/index-fNcAj_4k.css,1774286653551,6e390470412f0266335552c453978fad3072729804604a7fe73635c9e040ebbd
+favicon.svg,1774286653480,201714848d2eaecc14a9e2c9db2694646f7a53af7e7cce941c8bf103b38b4895
+logo.svg,1774286653481,2790afba95ebe7a2f9cd57ee6ec7cd7e76763b200544f2dc5bdbbe55b6a2434e
+assets/index-Dlofa59Z.js,1774286653550,04b37edd3b31b7e2f2d54eef4cb595c71a80486e1735585ce05badb6d9ca0f54
+rnnoise-sync.js,1774286653482,8cfb899a29432fd32db3a0d343adc756e59614c46d00494d8579215dea778085

public/rnnoise-processor.js

@@ -1,104 +1,123 @@
 /**
  * RNNoise AudioWorklet Processor
- * Processes audio in real-time using RNNoise WASM for noise suppression
+ * Uses the sync wasm loader so WorkletGlobalScope can initialize synchronously.
  */
 
-import { RNNoise } from '@jitsi/rnnoise-wasm';
+import createRNNWasmModuleSync from '/rnnoise-sync.js';
 
 class RNNoiseProcessor extends AudioWorkletProcessor {
   constructor() {
     super();
-    
-    this.rnnoise = null;
+
+    this.module = null;
+    this.statePtr = 0;
+    this.inPtr = 0;
+    this.outPtr = 0;
     this.isInitialized = false;
-    this.frameSize = 480; // RNNoise frame size for 48kHz (10ms)
+    this.enabled = true;
+
+    this.frameSize = 480; // RNNoise frame size for 48kHz / 10ms
     this.inputBuffer = new Float32Array(this.frameSize);
     this.outputBuffer = new Float32Array(this.frameSize);
     this.bufferIndex = 0;
+    this.pendingOutput = [];
+    this.pendingOutputReadIndex = 0;
 
-    // Initialize RNNoise
-    this.initRNNoise();
-
-    // Listen for messages from main thread
     this.port.onmessage = (event) => {
-      if (event.data.type === 'enable') {
+      if (event.data?.type === 'enable') {
         this.enabled = event.data.enabled;
       }
     };
 
-    this.enabled = true;
+    this.initRNNoise();
   }
 
   async initRNNoise() {
     try {
-      // Initialize the RNNoise WASM module
-      await RNNoise.initWasm();
-      this.rnnoise = new RNNoise();
+      this.module = createRNNWasmModuleSync();
+      await this.module.ready;
+
+      this.module._rnnoise_init();
+      this.statePtr = this.module._rnnoise_create();
+      this.inPtr = this.module._malloc(this.frameSize * 4);
+      this.outPtr = this.module._malloc(this.frameSize * 4);
+
       this.isInitialized = true;
-      console.log('RNNoise initialized successfully');
       this.port.postMessage({ type: 'initialized' });
     } catch (error) {
       console.error('Failed to initialize RNNoise:', error);
-      this.port.postMessage({ type: 'error', message: error.message });
+      this.port.postMessage({ type: 'error', message: error?.message || 'RNNoise init failed' });
     }
   }
 
-  process(inputs, outputs, parameters) {
-    if (!this.isInitialized || !this.enabled) {
-      // Pass through if not initialized or disabled
-      if (inputs[0] && inputs[0][0]) {
-        outputs[0][0].set(inputs[0][0]);
+  denoiseFrame(inputFrame) {
+    const heapOffsetIn = this.inPtr >> 2;
+    const heapOffsetOut = this.outPtr >> 2;
+
+    this.module.HEAPF32.set(inputFrame, heapOffsetIn);
+    this.module._rnnoise_process_frame(this.statePtr, this.outPtr, this.inPtr);
+
+    const denoised = this.module.HEAPF32.subarray(heapOffsetOut, heapOffsetOut + this.frameSize);
+    this.outputBuffer.set(denoised);
+  }
+
+  enqueueFrame(frame) {
+    for (let i = 0; i < frame.length; i++) {
+      this.pendingOutput.push(frame[i]);
+    }
+  }
+
+  dequeueSample(fallback) {
+    if (this.pendingOutputReadIndex < this.pendingOutput.length) {
+      const sample = this.pendingOutput[this.pendingOutputReadIndex];
+      this.pendingOutputReadIndex += 1;
+
+      if (this.pendingOutputReadIndex > 4096 && this.pendingOutputReadIndex * 2 > this.pendingOutput.length) {
+        this.pendingOutput = this.pendingOutput.slice(this.pendingOutputReadIndex);
+        this.pendingOutputReadIndex = 0;
       }
-      return true;
+
+      return sample;
     }
 
-    const input = inputs[0][0];
-    const output = outputs[0][0];
+    return fallback;
+  }
+
+  process(inputs, outputs) {
+    const input = inputs[0]?.[0];
+    const output = outputs[0]?.[0];
 
-    if (!input) {
-      output.fill(0);
+    if (!output) return true;
+
+    if (!input || !this.isInitialized || !this.enabled) {
+      if (input) output.set(input);
+      else output.fill(0);
       return true;
     }
 
-    // Process audio frame by frame (RNNoise requires fixed 480-sample frames)
+    // First, ingest input and process complete RNNoise frames.
     let inputIndex = 0;
-
     while (inputIndex < input.length) {
-      // Fill the input buffer
-      const samplesToRead = Math.min(
-        this.frameSize - this.bufferIndex,
-        input.length - inputIndex
-      );
-
-      this.inputBuffer.set(
-        input.subarray(inputIndex, inputIndex + samplesToRead),
-        this.bufferIndex
-      );
-
+      const samplesToRead = Math.min(this.frameSize - this.bufferIndex, input.length - inputIndex);
+      this.inputBuffer.set(input.subarray(inputIndex, inputIndex + samplesToRead), this.bufferIndex);
       this.bufferIndex += samplesToRead;
       inputIndex += samplesToRead;
 
-      // Process when we have a complete frame
       if (this.bufferIndex === this.frameSize) {
         try {
-          // Apply RNNoise denoising
-          this.rnnoise.denoise(this.inputBuffer, this.outputBuffer);
-
-          // Write output
-          output.set(this.outputBuffer, inputIndex - this.frameSize);
+          this.denoiseFrame(this.inputBuffer);
+          this.enqueueFrame(this.outputBuffer);
         } catch (error) {
           console.error('RNNoise processing error:', error);
-          output.set(this.inputBuffer, inputIndex - this.frameSize);
+          this.enqueueFrame(this.inputBuffer);
         }
-
-        // Reset buffer index for next frame
         this.bufferIndex = 0;
       }
     }
 
-    // If there's remaining audio less than a full frame, pass it through
-    if (this.bufferIndex > 0) {
-      output.set(this.inputBuffer.subarray(0, this.bufferIndex), input.length - this.bufferIndex);
+    // Then, render exactly one output quantum from the queued denoised samples.
+    for (let i = 0; i < output.length; i++) {
+      output[i] = this.dequeueSample(input[i] ?? 0);
     }
 
     return true;