Skip to main content

active_call/media/track/
track_codec.rs

1use crate::{media::AudioFrame, media::PcmBuf, media::Samples};
2use audio_codec::{
3    BoxedResampler, CodecType, Decoder, Encoder, bytes_to_samples,
4    g722::{G722Decoder, G722Encoder},
5    pcma::{PcmaDecoder, PcmaEncoder},
6    pcmu::{PcmuDecoder, PcmuEncoder},
7    samples_to_bytes,
8};
9use std::collections::HashMap;
10use std::sync::{Arc, RwLock};
11use std::time::Duration;
12use tracing::warn;
13
14use audio_codec::g729::{G729Decoder, G729Encoder};
15use audio_codec::opus::{OpusDecoder, OpusEncoder};
16
17/// Convert an audio duration to RTP clock ticks.
18pub fn duration_to_rtp_ticks(duration: Duration, clock_rate: u32) -> u32 {
19    (duration.as_nanos() * clock_rate as u128 / 1_000_000_000) as u32
20}
21
22pub struct TrackCodec {
23    pcmu_encoder: PcmuEncoder,
24    pcmu_decoder: PcmuDecoder,
25    pcma_encoder: PcmaEncoder,
26    pcma_decoder: PcmaDecoder,
27
28    g722_encoder: Option<Box<G722Encoder>>,
29    g722_decoder: Option<Box<G722Decoder>>,
30
31    g729_encoder: Option<Box<G729Encoder>>,
32    g729_decoder: Option<Box<G729Decoder>>,
33
34    opus_encoder: Option<OpusEncoder>,
35    opus_decoder: Option<OpusDecoder>,
36
37    resampler: Option<BoxedResampler>,
38    resampler_in_rate: u32,
39    resampler_out_rate: u32,
40    pub payload_type_map: Arc<RwLock<HashMap<u8, CodecType>>>,
41}
42
43impl Clone for TrackCodec {
44    fn clone(&self) -> Self {
45        let mut new = Self::new();
46        // Share the same underlying map so reinvite PT updates are visible to all clones.
47        new.payload_type_map = Arc::clone(&self.payload_type_map);
48        new
49    }
50}
51
52impl TrackCodec {
53    pub fn new() -> Self {
54        let mut map = HashMap::new();
55        map.insert(0, CodecType::PCMU);
56        map.insert(8, CodecType::PCMA);
57        map.insert(9, CodecType::G722);
58        map.insert(18, CodecType::G729);
59        map.insert(101, CodecType::TelephoneEvent);
60        map.insert(111, CodecType::Opus);
61        let payload_type_map = Arc::new(RwLock::new(map));
62
63        Self {
64            pcmu_encoder: PcmuEncoder::new(),
65            pcmu_decoder: PcmuDecoder::new(),
66            pcma_encoder: PcmaEncoder::new(),
67            pcma_decoder: PcmaDecoder::new(),
68            g722_encoder: None,
69            g722_decoder: None,
70            g729_encoder: None,
71            g729_decoder: None,
72            opus_encoder: None,
73            opus_decoder: None,
74            resampler: None,
75            resampler_in_rate: 0,
76            resampler_out_rate: 0,
77            payload_type_map,
78        }
79    }
80
81    pub fn set_payload_type(&mut self, pt: u8, codec: CodecType) {
82        self.payload_type_map.write().unwrap().insert(pt, codec);
83    }
84
85    /// Look up the codec for a given RTP payload type, consulting the negotiated map first
86    /// and falling back to the static payload type registry.
87    pub fn get_codec_for_pt(&self, pt: u8) -> Option<CodecType> {
88        self.payload_type_map
89            .read()
90            .unwrap()
91            .get(&pt)
92            .cloned()
93            .or_else(|| CodecType::try_from(pt).ok())
94    }
95
96    /// Decode an RTP payload into PCM at the codec's native sample rate.
97    /// Returns `(native_sample_rate, channels, samples)`; resampling to the
98    /// pipeline rate is the caller's responsibility (see ProcessorChain).
99    pub fn decode(&mut self, payload_type: u8, payload: &[u8]) -> (u32, u16, PcmBuf) {
100        let codec = self
101            .payload_type_map
102            .read()
103            .unwrap()
104            .get(&payload_type)
105            .cloned()
106            .unwrap_or_else(|| match payload_type {
107                0 => CodecType::PCMU,
108                8 => CodecType::PCMA,
109                9 => CodecType::G722,
110                18 => CodecType::G729,
111                111 => CodecType::Opus,
112                _ => CodecType::PCMU,
113            });
114
115        let pcm = match codec {
116            CodecType::PCMU => self.pcmu_decoder.decode(payload),
117            CodecType::PCMA => self.pcma_decoder.decode(payload),
118            CodecType::G722 => self
119                .g722_decoder
120                .get_or_insert_with(|| Box::new(G722Decoder::new()))
121                .decode(payload),
122            CodecType::G729 => self
123                .g729_decoder
124                .get_or_insert_with(|| Box::new(G729Decoder::new()))
125                .decode(payload),
126            CodecType::Opus => self
127                .opus_decoder
128                .get_or_insert_with(OpusDecoder::new_default)
129                .decode(payload),
130            _ => bytes_to_samples(payload),
131        };
132
133        let (in_rate, channels) = match codec {
134            CodecType::PCMU => (8000, 1),
135            CodecType::PCMA => (8000, 1),
136            CodecType::G722 => (16000, 1),
137            CodecType::G729 => (8000, 1),
138            CodecType::Opus => {
139                if pcm.len() >= 1920 {
140                    (48000, 2)
141                } else {
142                    (48000, 1)
143                }
144            }
145            _ => (8000, 1),
146        };
147
148        (in_rate, channels, pcm)
149    }
150
151    pub fn resample(&mut self, pcm: PcmBuf, in_rate: u32, out_rate: u32) -> PcmBuf {
152        // A zero rate means the caller has no valid source rate (e.g. a
153        // media-pass track created without an explicit input sample rate).
154        // There is nothing sensible to resample from, so pass the samples
155        // through instead of panicking: `BoxedResampler::new` rejects zero
156        // rates, and unwinding here poisons the `ProcessorChain` mutex,
157        // permanently breaking every subsequent frame on the track.
158        if in_rate == 0 || out_rate == 0 || in_rate == out_rate {
159            return pcm;
160        }
161
162        if self.resampler.is_none()
163            || self.resampler_in_rate != in_rate
164            || self.resampler_out_rate != out_rate
165        {
166            match BoxedResampler::new(in_rate as usize, out_rate as usize) {
167                Ok(resampler) => {
168                    self.resampler = Some(resampler);
169                    self.resampler_in_rate = in_rate;
170                    self.resampler_out_rate = out_rate;
171                }
172                Err(e) => {
173                    warn!(in_rate, out_rate, "failed to build resampler: {e}");
174                    self.resampler = None;
175                    self.resampler_in_rate = 0;
176                    self.resampler_out_rate = 0;
177                    return pcm;
178                }
179            }
180        }
181        self.resampler.as_mut().unwrap().resample(&pcm)
182    }
183
184    pub fn encode(&mut self, payload_type: u8, frame: AudioFrame) -> (u8, Vec<u8>) {
185        match frame.samples {
186            Samples::PCM { samples: mut pcm } => {
187                let codec = self
188                    .payload_type_map
189                    .read()
190                    .unwrap()
191                    .get(&payload_type)
192                    .cloned()
193                    .or_else(|| CodecType::try_from(payload_type).ok());
194
195                let target_samplerate = codec.map(|c| c.samplerate()).unwrap_or(8000);
196                if frame.sample_rate != target_samplerate {
197                    pcm = self.resample(pcm, frame.sample_rate, target_samplerate);
198                }
199
200                let payload = match codec {
201                    Some(CodecType::PCMU) => self.pcmu_encoder.encode(&pcm),
202                    Some(CodecType::PCMA) => self.pcma_encoder.encode(&pcm),
203                    Some(CodecType::G722) => self
204                        .g722_encoder
205                        .get_or_insert_with(|| Box::new(G722Encoder::new()))
206                        .encode(&pcm),
207                    Some(CodecType::G729) => self
208                        .g729_encoder
209                        .get_or_insert_with(|| Box::new(G729Encoder::new()))
210                        .encode(&pcm),
211                    Some(CodecType::Opus) => self
212                        .opus_encoder
213                        .get_or_insert_with(OpusEncoder::new_default)
214                        .encode(&pcm),
215                    _ => samples_to_bytes(&pcm),
216                };
217                (payload_type, payload)
218            }
219            Samples::RTP {
220                payload_type,
221                payload,
222                ..
223            } => (payload_type, payload),
224            _ => (payload_type, vec![]),
225        }
226    }
227}
228
229#[cfg(test)]
230mod tests {
231    use super::*;
232
233    #[test]
234    fn test_encode_dynamic_opus_payload_type_uses_opus_encoder() {
235        let mut codec = TrackCodec::new();
236        codec.set_payload_type(96, CodecType::Opus);
237
238        let frame = AudioFrame {
239            samples: Samples::PCM {
240                // 20ms @ 16k mono
241                samples: vec![0; 320],
242            },
243            sample_rate: 16000,
244            channels: 1,
245            ..Default::default()
246        };
247
248        let (pt, payload) = codec.encode(96, frame);
249        assert_eq!(pt, 96);
250        assert!(!payload.is_empty());
251        // If this were raw PCM bytes, it would be 640 bytes.
252        assert!(payload.len() < 640);
253    }
254
255    #[test]
256    fn test_resample_zero_rate_passes_through_without_panic() {
257        let mut codec = TrackCodec::new();
258        let samples = vec![1000i16; 160];
259
260        assert_eq!(codec.resample(samples.clone(), 0, 16000), samples);
261        assert_eq!(codec.resample(samples.clone(), 16000, 0), samples);
262        assert_eq!(codec.resample(samples.clone(), 0, 0), samples);
263    }
264}
265
266#[cfg(test)]
267mod duration_tests {
268    use super::*;
269
270    #[test]
271    fn test_duration_to_rtp_ticks() {
272        assert_eq!(duration_to_rtp_ticks(Duration::from_millis(20), 8000), 160);
273        assert_eq!(duration_to_rtp_ticks(Duration::from_millis(20), 48000), 960);
274        assert_eq!(
275            duration_to_rtp_ticks(Duration::from_micros(2_500), 48000),
276            120
277        );
278    }
279}