v1.17.2

fix(proxy-engine): use negotiated SDP payload types when wiring SIP legs and enable default nnnoiseless features for telephony denoising
v1.17.1
2026-04-10 17:14:14 +00:00 · 2026-04-10 17:14:14 +00:00 · 2026-04-10 16:57:07 +00:00 · 2026-04-10 16:57:07 +00:00
22 changed files with 511 additions and 91 deletions
--- a/changelog.md
+++ b/changelog.md
@@ -1,5 +1,20 @@
 # Changelog

+## 2026-04-10 - 1.17.2 - fix(proxy-engine)
+use negotiated SDP payload types when wiring SIP legs and enable default nnnoiseless features for telephony denoising
+
+- Select the negotiated codec payload type from SDP answers instead of always using the first offered codec
+- Preserve the device leg's preferred payload type from its own INVITE SDP when attaching it to the mixer
+- Enable default nnnoiseless features in codec-lib and proxy-engine dependencies
+
+## 2026-04-10 - 1.17.1 - fix(proxy-engine,codec-lib,sip-proto,ts)
+preserve negotiated media details and improve RTP audio handling across call legs
+
+- Use native Opus float encode/decode to avoid unnecessary i16 quantization in the f32 audio path.
+- Parse full RTP headers including extensions and sequence numbers, then sort inbound packets before decoding to keep codec state stable for out-of-order audio.
+- Capture negotiated codec payload types from SDP offers and answers and include codec, RTP port, remote media, and metadata in leg_added events.
+- Emit leg_state_changed and leg_removed events more consistently so the dashboard reflects leg lifecycle updates accurately.
+
 ## 2026-04-10 - 1.17.0 - feat(proxy-engine)
 upgrade the internal audio bus to 48kHz f32 with per-leg denoising and improve SIP leg routing

--- a/nogit/voicemail/default/msg-1775840000387.wav
+++ b/nogit/voicemail/default/msg-1775840000387.wav
--- a/nogit/voicemail/default/msg-1775840014276.wav
+++ b/nogit/voicemail/default/msg-1775840014276.wav
--- a/nogit/voicemail/default/msg-1775840439400.wav
+++ b/nogit/voicemail/default/msg-1775840439400.wav
--- a/nogit/voicemail/default/msg-1775840447441.wav
+++ b/nogit/voicemail/default/msg-1775840447441.wav
--- a/nogit/voicemail/default/msg-1775840454835.wav
+++ b/nogit/voicemail/default/msg-1775840454835.wav
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
  "name": "siprouter",
-  "version": "1.17.0",
+  "version": "1.17.2",
  "private": true,
  "type": "module",
  "scripts": {
--- a/rust/Cargo.lock
+++ b/rust/Cargo.lock
@@ -237,6 +237,17 @@ version = "1.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0"

+[[package]]
+name = "atty"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
+dependencies = [
+ "hermit-abi",
+ "libc",
+ "winapi",
+]
+
 [[package]]
 name = "audiopus"
 version = "0.3.0-rc.0"
@@ -487,6 +498,31 @@ dependencies = [
 "inout",
 ]

+[[package]]
+name = "clap"
+version = "3.2.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ea181bf566f71cb9a5d17a59e1871af638180a18fb0035c92ae62b705207123"
+dependencies = [
+ "atty",
+ "bitflags 1.3.2",
+ "clap_lex",
+ "indexmap 1.9.3",
+ "once_cell",
+ "strsim",
+ "termcolor",
+ "textwrap",
+]
+
+[[package]]
+name = "clap_lex"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2850f2f5a82cbf437dd5af4d49848fbdfc27c157c3d010345776f952765261c5"
+dependencies = [
+ "os_str_bytes",
+]
+
 [[package]]
 name = "cmake"
 version = "0.1.58"
@@ -700,6 +736,125 @@ version = "0.3.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "06d2e3287df1c007e74221c49ca10a95d557349e54b3a75dc2fb14712c751f04"

+[[package]]
+name = "dasp"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7381b67da416b639690ac77c73b86a7b5e64a29e31d1f75fb3b1102301ef355a"
+dependencies = [
+ "dasp_envelope",
+ "dasp_frame",
+ "dasp_interpolate",
+ "dasp_peak",
+ "dasp_ring_buffer",
+ "dasp_rms",
+ "dasp_sample",
+ "dasp_signal",
+ "dasp_slice",
+ "dasp_window",
+]
+
+[[package]]
+name = "dasp_envelope"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ec617ce7016f101a87fe85ed44180839744265fae73bb4aa43e7ece1b7668b6"
+dependencies = [
+ "dasp_frame",
+ "dasp_peak",
+ "dasp_ring_buffer",
+ "dasp_rms",
+ "dasp_sample",
+]
+
+[[package]]
+name = "dasp_frame"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2a3937f5fe2135702897535c8d4a5553f8b116f76c1529088797f2eee7c5cd6"
+dependencies = [
+ "dasp_sample",
+]
+
+[[package]]
+name = "dasp_interpolate"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7fc975a6563bb7ca7ec0a6c784ead49983a21c24835b0bc96eea11ee407c7486"
+dependencies = [
+ "dasp_frame",
+ "dasp_ring_buffer",
+ "dasp_sample",
+]
+
+[[package]]
+name = "dasp_peak"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5cf88559d79c21f3d8523d91250c397f9a15b5fc72fbb3f87fdb0a37b79915bf"
+dependencies = [
+ "dasp_frame",
+ "dasp_sample",
+]
+
+[[package]]
+name = "dasp_ring_buffer"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "07d79e19b89618a543c4adec9c5a347fe378a19041699b3278e616e387511ea1"
+
+[[package]]
+name = "dasp_rms"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6c5dcb30b7e5014486e2822537ea2beae50b19722ffe2ed7549ab03774575aa"
+dependencies = [
+ "dasp_frame",
+ "dasp_ring_buffer",
+ "dasp_sample",
+]
+
+[[package]]
+name = "dasp_sample"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c87e182de0887fd5361989c677c4e8f5000cd9491d6d563161a8f3a5519fc7f"
+
+[[package]]
+name = "dasp_signal"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aa1ab7d01689c6ed4eae3d38fe1cea08cba761573fbd2d592528d55b421077e7"
+dependencies = [
+ "dasp_envelope",
+ "dasp_frame",
+ "dasp_interpolate",
+ "dasp_peak",
+ "dasp_ring_buffer",
+ "dasp_rms",
+ "dasp_sample",
+ "dasp_window",
+]
+
+[[package]]
+name = "dasp_slice"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4e1c7335d58e7baedafa516cb361360ff38d6f4d3f9d9d5ee2a2fc8e27178fa1"
+dependencies = [
+ "dasp_frame",
+ "dasp_sample",
+]
+
+[[package]]
+name = "dasp_window"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "99ded7b88821d2ce4e8b842c9f1c86ac911891ab89443cc1de750cae764c5076"
+dependencies = [
+ "dasp_sample",
+]
+
 [[package]]
 name = "data-encoding"
 version = "2.10.0"
@@ -1214,6 +1369,12 @@ dependencies = [
 "subtle",
 ]

+[[package]]
+name = "hashbrown"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
+
 [[package]]
 name = "hashbrown"
 version = "0.15.5"
@@ -1246,6 +1407,15 @@ version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"

+[[package]]
+name = "hermit-abi"
+version = "0.1.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "hex"
 version = "0.4.3"
@@ -1446,6 +1616,16 @@ dependencies = [
 "zstd",
 ]

+[[package]]
+name = "indexmap"
+version = "1.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bd070e393353796e801d209ad339e89596eb4c8d430d18ede6a1cced8fafbd99"
+dependencies = [
+ "autocfg",
+ "hashbrown 0.12.3",
+]
+
 [[package]]
 name = "indexmap"
 version = "2.14.0"
@@ -1739,7 +1919,13 @@ version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "805d5964d1e7a0006a7fdced7dae75084d66d18b35f1dfe81bd76929b1f8da0c"
 dependencies = [
+ "anyhow",
+ "clap",
+ "dasp",
+ "dasp_interpolate",
+ "dasp_ring_buffer",
 "easyfft",
+ "hound",
 "once_cell",
 ]

@@ -1905,6 +2091,12 @@ dependencies = [
 "ureq",
 ]

+[[package]]
+name = "os_str_bytes"
+version = "6.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2355d85b9a3786f481747ced0e0ff2ba35213a1f9bd406ed906554d7af805a1"
+
 [[package]]
 name = "p256"
 version = "0.11.1"
@@ -2883,6 +3075,21 @@ dependencies = [
 "windows-sys",
 ]

+[[package]]
+name = "termcolor"
+version = "1.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06794f8f6c5c898b3275aebefa6b8a1cb24cd2c6c79397ab15774837a0bc5755"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "textwrap"
+version = "0.16.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c13547615a44dc9c452a8a534638acdf07120d4b6847c8178705da06306a3057"
+
 [[package]]
 name = "thiserror"
 version = "1.0.69"
@@ -3244,7 +3451,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bb0e353e6a2fbdc176932bbaab493762eb1255a7900fe0fea1a2f96c296cc909"
 dependencies = [
 "anyhow",
- "indexmap",
+ "indexmap 2.14.0",
 "wasm-encoder",
 "wasmparser",
 ]
@@ -3257,7 +3464,7 @@ checksum = "47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe"
 dependencies = [
 "bitflags 2.11.0",
 "hashbrown 0.15.5",
- "indexmap",
+ "indexmap 2.14.0",
 "semver",
 ]

@@ -3515,6 +3722,15 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"

+[[package]]
+name = "winapi-util"
+version = "0.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
+dependencies = [
+ "windows-sys",
+]
+
 [[package]]
 name = "winapi-x86_64-pc-windows-gnu"
 version = "0.4.0"
@@ -3564,7 +3780,7 @@ checksum = "b7c566e0f4b284dd6561c786d9cb0142da491f46a9fbed79ea69cdad5db17f21"
 dependencies = [
 "anyhow",
 "heck",
- "indexmap",
+ "indexmap 2.14.0",
 "prettyplease",
 "syn 2.0.117",
 "wasm-metadata",
@@ -3595,7 +3811,7 @@ checksum = "9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2"
 dependencies = [
 "anyhow",
 "bitflags 2.11.0",
- "indexmap",
+ "indexmap 2.14.0",
 "log",
 "serde",
 "serde_derive",
@@ -3614,7 +3830,7 @@ checksum = "ecc8ac4bc1dc3381b7f59c34f00b67e18f910c2c0f50015669dde7def656a736"
 dependencies = [
 "anyhow",
 "id-arena",
- "indexmap",
+ "indexmap 2.14.0",
 "log",
 "semver",
 "serde",
--- a/rust/crates/codec-lib/Cargo.toml
+++ b/rust/crates/codec-lib/Cargo.toml
@@ -7,4 +7,4 @@ edition = "2021"
 audiopus = "0.3.0-rc.0"
 ezk-g722 = "0.1"
 rubato = "0.14"
-nnnoiseless = { version = "0.5", default-features = false }
+nnnoiseless = "0.5"
--- a/rust/crates/codec-lib/src/lib.rs
+++ b/rust/crates/codec-lib/src/lib.rs
@@ -301,19 +301,59 @@ impl TranscodeState {

    /// Decode an encoded audio payload to f32 PCM samples in [-1.0, 1.0].
    /// Returns (samples, sample_rate).
+    ///
+    /// For Opus, uses native float decode (no i16 quantization).
+    /// For G.722/G.711, decodes to i16 then converts (codec is natively i16).
    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))
+        match pt {
+            PT_OPUS => {
+                let mut pcm = vec![0.0f32; 5760]; // up to 120ms at 48kHz
+                let packet =
+                    OpusPacket::try_from(data).map_err(|e| format!("opus packet: {e}"))?;
+                let out =
+                    MutSignals::try_from(&mut pcm[..]).map_err(|e| format!("opus signals: {e}"))?;
+                let n: usize = self
+                    .opus_dec
+                    .decode_float(Some(packet), out, false)
+                    .map_err(|e| format!("opus decode_float: {e}"))?
+                    .into();
+                pcm.truncate(n);
+                Ok((pcm, 48000))
+            }
+            _ => {
+                // G.722, PCMU, PCMA: natively i16 codecs — decode then convert.
+                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.
+    ///
+    /// For Opus, uses native float encode (no i16 quantization).
+    /// For G.722/G.711, converts to i16 then encodes (codec is natively i16).
    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)
+        match pt {
+            PT_OPUS => {
+                let mut buf = vec![0u8; 4000];
+                let n: usize = self
+                    .opus_enc
+                    .encode_float(pcm, &mut buf)
+                    .map_err(|e| format!("opus encode_float: {e}"))?
+                    .into();
+                buf.truncate(n);
+                Ok(buf)
+            }
+            _ => {
+                // G.722, PCMU, PCMA: natively i16 codecs.
+                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.
--- a/rust/crates/proxy-engine/Cargo.toml
+++ b/rust/crates/proxy-engine/Cargo.toml
@@ -10,7 +10,7 @@ path = "src/main.rs"
 [dependencies]
 codec-lib = { path = "../codec-lib" }
 sip-proto = { path = "../sip-proto" }
-nnnoiseless = { version = "0.5", default-features = false }
+nnnoiseless = "0.5"
 tokio = { version = "1", features = ["full"] }
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
--- a/rust/crates/proxy-engine/src/call_manager.rs
+++ b/rust/crates/proxy-engine/src/call_manager.rs
@@ -20,6 +20,35 @@ use std::net::SocketAddr;
 use std::sync::Arc;
 use tokio::net::UdpSocket;

+/// Emit a `leg_added` event with full leg information.
+/// Free function (not a method) to avoid `&self` borrow conflicts when `self.calls` is borrowed.
+fn emit_leg_added_event(tx: &OutTx, call_id: &str, leg: &LegInfo) {
+    let metadata: serde_json::Value = if leg.metadata.is_empty() {
+        serde_json::json!({})
+    } else {
+        serde_json::Value::Object(
+            leg.metadata
+                .iter()
+                .map(|(k, v)| (k.clone(), v.clone()))
+                .collect(),
+        )
+    };
+    emit_event(
+        tx,
+        "leg_added",
+        serde_json::json!({
+            "call_id": call_id,
+            "leg_id": leg.id,
+            "kind": leg.kind.as_str(),
+            "state": leg.state.as_str(),
+            "codec": sip_proto::helpers::codec_name(leg.codec_pt),
+            "rtpPort": leg.rtp_port,
+            "remoteMedia": leg.remote_media.map(|a| format!("{}:{}", a.ip(), a.port())),
+            "metadata": metadata,
+        }),
+    );
+}
+
 pub struct CallManager {
    /// All active calls, keyed by internal call ID.
    pub calls: HashMap<String, Call>,
@@ -167,7 +196,17 @@ impl CallManager {
        };
        // Mutable borrow on call/leg is now released.

-        let sip_pt = codecs.first().copied().unwrap_or(9);
+        let mut sip_pt = codecs.first().copied().unwrap_or(9);
+
+        // If the message has SDP (e.g., 200 OK answer), use the negotiated codec
+        // instead of the offered one.
+        if msg.has_sdp_body() {
+            if let Some(ep) = parse_sdp_endpoint(&msg.body) {
+                if let Some(pt) = ep.codec_pt {
+                    sip_pt = pt;
+                }
+            }
+        }

        match action {
            SipLegAction::None => {}
@@ -265,14 +304,27 @@ impl CallManager {
                                    dev_leg.state = LegState::Connected;
                                }
                            }
+                            emit_event(
+                                &self.out_tx,
+                                "leg_state_changed",
+                                serde_json::json!({ "call_id": call_id, "leg_id": dev_leg_id, "state": "connected" }),
+                            );

                            // Wire device leg to mixer.
+                            // Use the device's preferred codec from its INVITE SDP,
+                            // not the provider's negotiated codec.
+                            let dev_pt = device_invite
+                                .has_sdp_body()
+                                .then(|| parse_sdp_endpoint(&device_invite.body))
+                                .flatten()
+                                .and_then(|ep| ep.codec_pt)
+                                .unwrap_or(sip_pt);
                            if let Some(dev_remote_addr) = dev_remote {
                                let dev_channels = create_leg_channels();
                                spawn_sip_inbound(dev_rtp_socket.clone(), dev_channels.inbound_tx);
                                spawn_sip_outbound(dev_rtp_socket, dev_remote_addr, dev_channels.outbound_rx);
                                if let Some(call) = self.calls.get(call_id) {
-                                    call.add_leg_to_mixer(&dev_leg_id, sip_pt, dev_channels.inbound_rx, dev_channels.outbound_tx)
+                                    call.add_leg_to_mixer(&dev_leg_id, dev_pt, dev_channels.inbound_rx, dev_channels.outbound_tx)
                                        .await;
                                }
                            }
@@ -324,6 +376,8 @@ impl CallManager {
                        leg.state = LegState::Terminated;
                    }
                }
+                emit_event(&self.out_tx, "leg_state_changed",
+                    serde_json::json!({ "call_id": call_id, "leg_id": leg_id, "state": "terminated" }));
                emit_event(&self.out_tx, "call_ended",
                    serde_json::json!({ "call_id": call_id, "reason": reason, "duration": duration }));
                self.terminate_call(call_id).await;
@@ -529,21 +583,30 @@ impl CallManager {
                    if let Some(leg) = call.legs.get_mut(this_leg_id) {
                        leg.state = LegState::Ringing;
                    }
+                    emit_event(&self.out_tx, "leg_state_changed",
+                        serde_json::json!({ "call_id": call_id, "leg_id": this_leg_id, "state": "ringing" }));
                } else if code >= 200 && code < 300 {
                    let mut needs_wiring = false;
                    if let Some(leg) = call.legs.get_mut(this_leg_id) {
                        leg.state = LegState::Connected;
-                        // Learn remote media from SDP.
+                        // Learn remote media and negotiated codec from SDP answer.
                        if msg.has_sdp_body() {
                            if let Some(ep) = parse_sdp_endpoint(&msg.body) {
                                if let Ok(addr) = format!("{}:{}", ep.address, ep.port).parse() {
                                    leg.remote_media = Some(addr);
                                }
+                                // Use the codec from the SDP answer (what the remote actually selected).
+                                if let Some(pt) = ep.codec_pt {
+                                    leg.codec_pt = pt;
+                                }
                            }
                        }
                        needs_wiring = true;
                    }

+                    emit_event(&self.out_tx, "leg_state_changed",
+                        serde_json::json!({ "call_id": call_id, "leg_id": this_leg_id, "state": "connected" }));
+
                    if call.state != CallState::Connected {
                        call.state = CallState::Connected;
                        emit_event(&self.out_tx, "call_answered", serde_json::json!({ "call_id": call_id }));
@@ -689,15 +752,19 @@ impl CallManager {
        call.callee_number = Some(called_number);
        call.state = CallState::Ringing;

-        let codec_pt = provider_config.codecs.first().copied().unwrap_or(9);
+        let mut codec_pt = provider_config.codecs.first().copied().unwrap_or(9);

-        // Provider leg — extract media from SDP.
+        // Provider leg — extract media and negotiated codec from SDP.
        let mut provider_media: Option<SocketAddr> = None;
        if invite.has_sdp_body() {
            if let Some(ep) = parse_sdp_endpoint(&invite.body) {
                if let Ok(addr) = format!("{}:{}", ep.address, ep.port).parse() {
                    provider_media = Some(addr);
                }
+                // Use the codec from the provider's SDP offer (what they actually want to use).
+                if let Some(pt) = ep.codec_pt {
+                    codec_pt = pt;
+                }
            }
        }

@@ -767,6 +834,16 @@ impl CallManager {
        // Store the call.
        self.calls.insert(call_id.clone(), call);

+        // Emit leg_added for both initial legs.
+        if let Some(call) = self.calls.get(&call_id) {
+            if let Some(leg) = call.legs.get(&provider_leg_id) {
+                emit_leg_added_event(&self.out_tx, &call_id, leg);
+            }
+            if let Some(leg) = call.legs.get(&device_leg_id) {
+                emit_leg_added_event(&self.out_tx, &call_id, leg);
+            }
+        }
+
        Some(call_id)
    }

@@ -854,6 +931,14 @@ impl CallManager {
            .insert(sip_call_id, (call_id.clone(), leg_id));

        self.calls.insert(call_id.clone(), call);
+
+        // Emit leg_added for the provider leg.
+        if let Some(call) = self.calls.get(&call_id) {
+            for leg in call.legs.values() {
+                emit_leg_added_event(&self.out_tx, &call_id, leg);
+            }
+        }
+
        Some(call_id)
    }

@@ -1002,6 +1087,14 @@ impl CallManager {
            .insert(provider_sip_call_id, (call_id.clone(), provider_leg_id));

        self.calls.insert(call_id.clone(), call);
+
+        // Emit leg_added for both initial legs (device + provider).
+        if let Some(call) = self.calls.get(&call_id) {
+            for leg in call.legs.values() {
+                emit_leg_added_event(&self.out_tx, &call_id, leg);
+            }
+        }
+
        Some(call_id)
    }

@@ -1069,17 +1162,11 @@ impl CallManager {
        let call = self.calls.get_mut(call_id).unwrap();
        call.legs.insert(leg_id.clone(), leg_info);

-        emit_event(
-            &self.out_tx,
-            "leg_added",
-            serde_json::json!({
-                "call_id": call_id,
-                "leg_id": leg_id,
-                "kind": "sip-provider",
-                "state": "inviting",
-                "number": number,
-            }),
-        );
+        if let Some(call) = self.calls.get(call_id) {
+            if let Some(leg) = call.legs.get(&leg_id) {
+                emit_leg_added_event(&self.out_tx, call_id, leg);
+            }
+        }

        Some(leg_id)
    }
@@ -1145,17 +1232,11 @@ impl CallManager {
        let call = self.calls.get_mut(call_id).unwrap();
        call.legs.insert(leg_id.clone(), leg_info);

-        emit_event(
-            &self.out_tx,
-            "leg_added",
-            serde_json::json!({
-                "call_id": call_id,
-                "leg_id": leg_id,
-                "kind": "sip-device",
-                "state": "inviting",
-                "device_id": device_id,
-            }),
-        );
+        if let Some(call) = self.calls.get(call_id) {
+            if let Some(leg) = call.legs.get(&leg_id) {
+                emit_leg_added_event(&self.out_tx, call_id, leg);
+            }
+        }

        Some(leg_id)
    }
@@ -1242,6 +1323,13 @@ impl CallManager {
            None => return false,
        };

+        // Emit leg_removed for source call.
+        emit_event(
+            &self.out_tx,
+            "leg_removed",
+            serde_json::json!({ "call_id": source_call_id, "leg_id": leg_id }),
+        );
+
        // Update SIP index to point to the target call.
        if let Some(sip_cid) = &leg_info.sip_call_id {
            self.sip_index.insert(
@@ -1274,15 +1362,12 @@ impl CallManager {
        let target_call = self.calls.get_mut(target_call_id).unwrap();
        target_call.legs.insert(leg_id.to_string(), leg_info);

-        emit_event(
-            &self.out_tx,
-            "leg_transferred",
-            serde_json::json!({
-                "leg_id": leg_id,
-                "source_call_id": source_call_id,
-                "target_call_id": target_call_id,
-            }),
-        );
+        // Emit leg_added for target call.
+        if let Some(target) = self.calls.get(target_call_id) {
+            if let Some(leg) = target.legs.get(leg_id) {
+                emit_leg_added_event(&self.out_tx, target_call_id, leg);
+            }
+        }

        // Check if source call has too few legs remaining.
        let source_call = self.calls.get(source_call_id).unwrap();
@@ -1385,6 +1470,11 @@ impl CallManager {
                }
            }
            leg.state = LegState::Terminated;
+            emit_event(
+                &self.out_tx,
+                "leg_state_changed",
+                serde_json::json!({ "call_id": call_id, "leg_id": leg.id, "state": "terminated" }),
+            );
        }

        emit_event(
@@ -1503,6 +1593,13 @@ impl CallManager {
        );
        self.calls.insert(call_id.to_string(), call);

+        // Emit leg_added for the provider leg.
+        if let Some(call) = self.calls.get(call_id) {
+            for leg in call.legs.values() {
+                emit_leg_added_event(&self.out_tx, call_id, leg);
+            }
+        }
+
        // Build recording path.
        let timestamp = std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
--- a/rust/crates/proxy-engine/src/leg_io.rs
+++ b/rust/crates/proxy-engine/src/leg_io.rs
@@ -35,7 +35,8 @@ pub fn create_leg_channels() -> LegChannels {
 }

 /// Spawn the inbound I/O task for a SIP leg.
-/// Reads RTP from the socket, strips the 12-byte header, sends payload to the mixer.
+/// Reads RTP from the socket, parses the variable-length header (RFC 3550),
+/// and sends the payload to the mixer.
 /// Returns the JoinHandle (exits when the inbound_tx channel is dropped).
 pub fn spawn_sip_inbound(
    rtp_socket: Arc<UdpSocket>,
@@ -51,12 +52,29 @@ pub fn spawn_sip_inbound(
                    }
                    let pt = buf[1] & 0x7F;
                    let marker = (buf[1] & 0x80) != 0;
+                    let seq = u16::from_be_bytes([buf[2], buf[3]]);
                    let timestamp = u32::from_be_bytes([buf[4], buf[5], buf[6], buf[7]]);
-                    let payload = buf[12..n].to_vec();
+
+                    // RFC 3550: header length = 12 + (CC * 4) + optional extension.
+                    let cc = (buf[0] & 0x0F) as usize;
+                    let has_extension = (buf[0] & 0x10) != 0;
+                    let mut offset = 12 + cc * 4;
+                    if has_extension {
+                        if offset + 4 > n {
+                            continue; // Malformed: extension header truncated.
+                        }
+                        let ext_len = u16::from_be_bytes([buf[offset + 2], buf[offset + 3]]) as usize;
+                        offset += 4 + ext_len * 4;
+                    }
+                    if offset >= n {
+                        continue; // No payload after header.
+                    }
+
+                    let payload = buf[offset..n].to_vec();
                    if payload.is_empty() {
                        continue;
                    }
-                    if inbound_tx.send(RtpPacket { payload, payload_type: pt, marker, timestamp }).await.is_err() {
+                    if inbound_tx.send(RtpPacket { payload, payload_type: pt, marker, seq, timestamp }).await.is_err() {
                        break; // Channel closed — leg removed.
                    }
                }
--- a/rust/crates/proxy-engine/src/main.rs
+++ b/rust/crates/proxy-engine/src/main.rs
@@ -677,6 +677,10 @@ async fn handle_webrtc_link(
            "leg_id": session_id,
            "kind": "webrtc",
            "state": "connected",
+            "codec": "Opus",
+            "rtpPort": 0,
+            "remoteMedia": null,
+            "metadata": {},
        }));

        respond_ok(out_tx, &cmd.id, serde_json::json!({
@@ -1125,8 +1129,11 @@ async fn handle_add_tool_leg(
            "call_id": call_id,
            "leg_id": tool_leg_id,
            "kind": "tool",
-            "tool_type": tool_type_str,
            "state": "connected",
+            "codec": null,
+            "rtpPort": 0,
+            "remoteMedia": null,
+            "metadata": { "tool_type": tool_type_str },
        }),
    );

--- a/rust/crates/proxy-engine/src/mixer.rs
+++ b/rust/crates/proxy-engine/src/mixer.rs
@@ -35,6 +35,8 @@ pub struct RtpPacket {
    pub payload_type: u8,
    /// RTP marker bit (first packet of a DTMF event, etc.).
    pub marker: bool,
+    /// RTP sequence number for reordering.
+    pub seq: u16,
    /// RTP timestamp from the original packet header.
    pub timestamp: u32,
 }
@@ -319,16 +321,18 @@ async fn mixer_loop(
            continue;
        }

-        // ── 2. Drain inbound packets, decode to 16kHz PCM. ─────────
+        // ── 2. Drain inbound packets, decode to 48kHz f32 PCM. ────
        //    DTMF (PT 101) packets are collected separately.
+        //    Audio packets are sorted by sequence number and decoded
+        //    in order to maintain codec state (critical for G.722 ADPCM).
        let leg_ids: Vec<String> = legs.keys().cloned().collect();
        let mut dtmf_forward: Vec<(String, RtpPacket)> = Vec::new();

        for lid in &leg_ids {
            let slot = legs.get_mut(lid).unwrap();

-            // Drain channel — collect DTMF packets separately, keep latest audio.
-            let mut latest_audio: Option<RtpPacket> = None;
+            // Drain channel — collect DTMF separately, collect ALL audio packets.
+            let mut audio_packets: Vec<RtpPacket> = Vec::new();
            loop {
                match slot.inbound_rx.try_recv() {
                    Ok(pkt) => {
@@ -336,35 +340,47 @@ async fn mixer_loop(
                            // DTMF telephone-event: collect for processing.
                            dtmf_forward.push((lid.clone(), pkt));
                        } else {
-                            latest_audio = Some(pkt);
+                            audio_packets.push(pkt);
                        }
                    }
                    Err(_) => break,
                }
            }

-            if let Some(pkt) = latest_audio {
+            if !audio_packets.is_empty() {
                slot.silent_ticks = 0;
-                match slot.transcoder.decode_to_f32(&pkt.payload, pkt.payload_type) {
-                    Ok((pcm, rate)) => {
-                        // Resample to 48kHz mixing rate if needed.
-                        let pcm_48k = if rate == MIX_RATE {
-                            pcm
-                        } else {
-                            slot.transcoder
-                                .resample_f32(&pcm, rate, MIX_RATE)
-                                .unwrap_or_else(|_| vec![0.0f32; MIX_FRAME_SIZE])
-                        };
-                        // Per-leg inbound denoising at 48kHz.
-                        let denoised = TranscodeState::denoise_f32(&mut slot.denoiser, &pcm_48k);
-                        // Pad or truncate to exactly MIX_FRAME_SIZE.
-                        let mut frame = denoised;
-                        frame.resize(MIX_FRAME_SIZE, 0.0);
-                        slot.last_pcm_frame = frame;
-                    }
-                    Err(_) => {
-                        // Decode failed — use silence.
-                        slot.last_pcm_frame = vec![0.0f32; MIX_FRAME_SIZE];
+
+                // Sort by sequence number for correct codec state progression.
+                // This prevents G.722 ADPCM state corruption from out-of-order packets.
+                audio_packets.sort_by_key(|p| p.seq);
+
+                // Decode ALL packets in order (maintains codec state),
+                // but only keep the last decoded frame for mixing.
+                for pkt in &audio_packets {
+                    match slot.transcoder.decode_to_f32(&pkt.payload, pkt.payload_type) {
+                        Ok((pcm, rate)) => {
+                            // Resample to 48kHz mixing rate if needed.
+                            let pcm_48k = if rate == MIX_RATE {
+                                pcm
+                            } else {
+                                slot.transcoder
+                                    .resample_f32(&pcm, rate, MIX_RATE)
+                                    .unwrap_or_else(|_| vec![0.0f32; MIX_FRAME_SIZE])
+                            };
+                            // Per-leg inbound denoising at 48kHz.
+                            // Only for SIP telephony legs — WebRTC browsers
+                            // already apply noise suppression via getUserMedia.
+                            let processed = if slot.codec_pt != codec_lib::PT_OPUS {
+                                TranscodeState::denoise_f32(&mut slot.denoiser, &pcm_48k)
+                            } else {
+                                pcm_48k
+                            };
+                            // Pad or truncate to exactly MIX_FRAME_SIZE.
+                            let mut frame = processed;
+                            frame.resize(MIX_FRAME_SIZE, 0.0);
+                            slot.last_pcm_frame = frame;
+                        }
+                        Err(_) => {}
                    }
                }
            } else if dtmf_forward.iter().any(|(src, _)| src == lid) {
--- a/rust/crates/proxy-engine/src/webrtc_engine.rs
+++ b/rust/crates/proxy-engine/src/webrtc_engine.rs
@@ -290,8 +290,9 @@ async fn browser_to_mixer_loop(
                        .send(RtpPacket {
                            payload: payload.to_vec(),
                            payload_type: PT_OPUS,
-                            marker: false,
-                            timestamp: 0,
+                            marker: rtp_packet.header.marker,
+                            seq: rtp_packet.header.sequence_number,
+                            timestamp: rtp_packet.header.timestamp,
                        })
                        .await;
                }
--- a/rust/crates/sip-proto/src/helpers.rs
+++ b/rust/crates/sip-proto/src/helpers.rs
@@ -197,10 +197,11 @@ pub fn compute_digest_auth(

 use crate::Endpoint;

-/// Parse the audio media port and connection address from an SDP body.
+/// Parse the audio media port, connection address, and preferred codec from an SDP body.
 pub fn parse_sdp_endpoint(sdp: &str) -> Option<Endpoint> {
    let mut addr: Option<&str> = None;
    let mut port: Option<u16> = None;
+    let mut codec_pt: Option<u8> = None;

    let normalized = sdp.replace("\r\n", "\n");
    for raw in normalized.split('\n') {
@@ -208,10 +209,16 @@ pub fn parse_sdp_endpoint(sdp: &str) -> Option<Endpoint> {
        if let Some(rest) = line.strip_prefix("c=IN IP4 ") {
            addr = Some(rest.trim());
        } else if let Some(rest) = line.strip_prefix("m=audio ") {
+            // m=audio <port> RTP/AVP <pt1> [<pt2> ...]
            let parts: Vec<&str> = rest.split_whitespace().collect();
            if !parts.is_empty() {
                port = parts[0].parse().ok();
            }
+            // parts[1] is "RTP/AVP" or similar, parts[2..] are payload types.
+            // The first PT is the preferred codec.
+            if parts.len() > 2 {
+                codec_pt = parts[2].parse::<u8>().ok();
+            }
        }
    }

@@ -219,6 +226,7 @@ pub fn parse_sdp_endpoint(sdp: &str) -> Option<Endpoint> {
        (Some(a), Some(p)) => Some(Endpoint {
            address: a.to_string(),
            port: p,
+            codec_pt,
        }),
        _ => None,
    }
--- a/rust/crates/sip-proto/src/lib.rs
+++ b/rust/crates/sip-proto/src/lib.rs
@@ -9,9 +9,11 @@ pub mod dialog;
 pub mod helpers;
 pub mod rewrite;

-/// Network endpoint (address + port).
+/// Network endpoint (address + port + optional negotiated codec).
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Endpoint {
    pub address: String,
    pub port: u16,
+    /// First payload type from the SDP `m=audio` line (the preferred codec).
+    pub codec_pt: Option<u8>,
 }
--- a/rust/crates/sip-proto/src/rewrite.rs
+++ b/rust/crates/sip-proto/src/rewrite.rs
@@ -92,7 +92,7 @@ pub fn rewrite_sdp(body: &str, ip: &str, port: u16) -> (String, Option<Endpoint>
        .collect();

    let original = match (orig_addr, orig_port) {
-        (Some(a), Some(p)) => Some(Endpoint { address: a, port: p }),
+        (Some(a), Some(p)) => Some(Endpoint { address: a, port: p, codec_pt: None }),
        _ => None,
    };

--- a/ts/00_commitinfo_data.ts
+++ b/ts/00_commitinfo_data.ts
@@ -3,6 +3,6 @@
 */
 export const commitinfo = {
  name: 'siprouter',
-  version: '1.17.0',
+  version: '1.17.2',
  description: 'undefined'
 }
--- a/ts/sipproxy.ts
+++ b/ts/sipproxy.ts
@@ -425,9 +425,9 @@ async function startProxyEngine(): Promise<void> {
        id: data.leg_id,
        type: data.kind,
        state: data.state,
-        codec: null,
-        rtpPort: null,
-        remoteMedia: null,
+        codec: data.codec ?? null,
+        rtpPort: data.rtpPort ?? null,
+        remoteMedia: data.remoteMedia ?? null,
        metadata: data.metadata || {},
      });
    }
--- a/ts_web/00_commitinfo_data.ts
+++ b/ts_web/00_commitinfo_data.ts
@@ -3,6 +3,6 @@
 */
 export const commitinfo = {
  name: 'siprouter',
-  version: '1.17.0',
+  version: '1.17.2',
  description: 'undefined'
 }
Author	SHA1	Message	Date
Juergen Kunz	f543ff1568	v1.17.2	2026-04-10 17:14:14 +00:00
Juergen Kunz	c63a759689	fix(proxy-engine): use negotiated SDP payload types when wiring SIP legs and enable default nnnoiseless features for telephony denoising	2026-04-10 17:14:14 +00:00
Juergen Kunz	a02146633b	v1.17.1	2026-04-10 16:57:07 +00:00
Juergen Kunz	f78639dd19	fix(proxy-engine,codec-lib,sip-proto,ts): preserve negotiated media details and improve RTP audio handling across call legs	2026-04-10 16:57:07 +00:00