feat(proxy-engine): upgrade the internal audio bus to 48kHz f32 with per-leg denoising and improve SIP leg routing

rust/crates/codec-lib/src/lib.rs

@@ -104,6 +104,8 @@ pub struct TranscodeState {
     g722_dec: libg722::decoder::Decoder,
     /// Cached FFT resamplers keyed by (from_rate, to_rate, chunk_size).
     resamplers: HashMap<(u32, u32, usize), FftFixedIn<f64>>,
+    /// Cached f32 FFT resamplers keyed by (from_rate, to_rate, chunk_size).
+    resamplers_f32: HashMap<(u32, u32, usize), FftFixedIn<f32>>,
     /// ML noise suppression for the SIP-bound direction.
     denoiser_to_sip: Box<DenoiseState<'static>>,
     /// ML noise suppression for the browser-bound direction.
@@ -133,6 +135,7 @@ impl TranscodeState {
             g722_enc,
             g722_dec,
             resamplers: HashMap::new(),
+            resamplers_f32: HashMap::new(),
             denoiser_to_sip: DenoiseState::new(),
             denoiser_to_browser: DenoiseState::new(),
         })
@@ -293,6 +296,86 @@ impl TranscodeState {
             _ => Err(format!("unsupported target PT {pt}")),
         }
     }
+
+    // ---- f32 API for high-quality internal bus ----------------------------
+
+    /// Decode an encoded audio payload to f32 PCM samples in [-1.0, 1.0].
+    /// Returns (samples, sample_rate).
+    pub fn decode_to_f32(&mut self, data: &[u8], pt: u8) -> Result<(Vec<f32>, u32), String> {
+        let (pcm_i16, rate) = self.decode_to_pcm(data, pt)?;
+        let pcm_f32 = pcm_i16.iter().map(|&s| s as f32 / 32768.0).collect();
+        Ok((pcm_f32, rate))
+    }
+
+    /// Encode f32 PCM samples ([-1.0, 1.0]) to an audio codec.
+    pub fn encode_from_f32(&mut self, pcm: &[f32], pt: u8) -> Result<Vec<u8>, String> {
+        let pcm_i16: Vec<i16> = pcm
+            .iter()
+            .map(|&s| (s * 32767.0).round().clamp(-32768.0, 32767.0) as i16)
+            .collect();
+        self.encode_from_pcm(&pcm_i16, pt)
+    }
+
+    /// High-quality sample rate conversion for f32 PCM using rubato FFT resampler.
+    /// Uses a separate cache from the i16 resampler.
+    pub fn resample_f32(
+        &mut self,
+        pcm: &[f32],
+        from_rate: u32,
+        to_rate: u32,
+    ) -> Result<Vec<f32>, String> {
+        if from_rate == to_rate || pcm.is_empty() {
+            return Ok(pcm.to_vec());
+        }
+
+        let chunk = pcm.len();
+        let key = (from_rate, to_rate, chunk);
+
+        if !self.resamplers_f32.contains_key(&key) {
+            let r =
+                FftFixedIn::<f32>::new(from_rate as usize, to_rate as usize, chunk, 1, 1)
+                    .map_err(|e| format!("resampler f32 {from_rate}->{to_rate}: {e}"))?;
+            self.resamplers_f32.insert(key, r);
+        }
+        let resampler = self.resamplers_f32.get_mut(&key).unwrap();
+
+        let input = vec![pcm.to_vec()];
+        let result = resampler
+            .process(&input, None)
+            .map_err(|e| format!("resample f32 {from_rate}->{to_rate}: {e}"))?;
+
+        Ok(result[0].clone())
+    }
+
+    /// Apply RNNoise ML noise suppression to 48kHz f32 PCM audio.
+    /// Processes in 480-sample (10ms) frames. State persists across calls.
+    /// Operates natively in f32 — no i16 conversion overhead.
+    pub fn denoise_f32(denoiser: &mut DenoiseState, pcm: &[f32]) -> Vec<f32> {
+        let frame_size = DenoiseState::FRAME_SIZE; // 480
+        let total = pcm.len();
+        let whole = (total / frame_size) * frame_size;
+        let mut output = Vec::with_capacity(total);
+        let mut out_buf = [0.0f32; 480];
+
+        // nnnoiseless expects f32 samples scaled as i16 range (-32768..32767).
+        for offset in (0..whole).step_by(frame_size) {
+            let input: Vec<f32> = pcm[offset..offset + frame_size]
+                .iter()
+                .map(|&s| s * 32768.0)
+                .collect();
+            denoiser.process_frame(&mut out_buf, &input);
+            output.extend(out_buf.iter().map(|&s| s / 32768.0));
+        }
+        if whole < total {
+            output.extend_from_slice(&pcm[whole..]);
+        }
+        output
+    }
+}
+
+/// Create a new standalone denoiser for per-leg inbound processing.
+pub fn new_denoiser() -> Box<DenoiseState<'static>> {
+    DenoiseState::new()
 }
 
 #[cfg(test)]