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
17pub 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 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 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 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 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 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 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}