1use crate::{media::AudioFrame, media::PcmBuf, media::Samples};
2use audio_codec::{
3 CodecType, Decoder, Encoder, Resampler, bytes_to_samples,
4 g722::{G722Decoder, G722Encoder},
5 pcma::{PcmaDecoder, PcmaEncoder},
6 pcmu::{PcmuDecoder, PcmuEncoder},
7 samples_to_bytes,
8};
9use std::collections::HashMap;
10
11use audio_codec::g729::{G729Decoder, G729Encoder};
12#[cfg(feature = "opus")]
13use audio_codec::opus::{OpusDecoder, OpusEncoder};
14
15pub struct TrackCodec {
16 pcmu_encoder: PcmuEncoder,
17 pcmu_decoder: PcmuDecoder,
18 pcma_encoder: PcmaEncoder,
19 pcma_decoder: PcmaDecoder,
20
21 g722_encoder: Option<Box<G722Encoder>>,
22 g722_decoder: Option<Box<G722Decoder>>,
23
24 g729_encoder: Option<Box<G729Encoder>>,
25 g729_decoder: Option<Box<G729Decoder>>,
26
27 #[cfg(feature = "opus")]
28 opus_encoder: Option<OpusEncoder>,
29 #[cfg(feature = "opus")]
30 opus_decoder: Option<OpusDecoder>,
31
32 resampler: Option<Resampler>,
33 resampler_in_rate: u32,
34 resampler_out_rate: u32,
35 pub payload_type_map: HashMap<u8, CodecType>,
36}
37
38impl Clone for TrackCodec {
39 fn clone(&self) -> Self {
40 let mut new = Self::new();
41 new.payload_type_map = self.payload_type_map.clone();
42 new
43 }
44}
45
46impl TrackCodec {
47 pub fn new() -> Self {
48 let mut payload_type_map = HashMap::new();
49 payload_type_map.insert(0, CodecType::PCMU);
50 payload_type_map.insert(8, CodecType::PCMA);
51 payload_type_map.insert(9, CodecType::G722);
52 payload_type_map.insert(18, CodecType::G729);
53 payload_type_map.insert(101, CodecType::TelephoneEvent);
54 payload_type_map.insert(111, CodecType::Opus);
55
56 Self {
57 pcmu_encoder: PcmuEncoder::new(),
58 pcmu_decoder: PcmuDecoder::new(),
59 pcma_encoder: PcmaEncoder::new(),
60 pcma_decoder: PcmaDecoder::new(),
61 g722_encoder: None,
62 g722_decoder: None,
63 g729_encoder: None,
64 g729_decoder: None,
65 #[cfg(feature = "opus")]
66 opus_encoder: None,
67 #[cfg(feature = "opus")]
68 opus_decoder: None,
69 resampler: None,
70 resampler_in_rate: 0,
71 resampler_out_rate: 0,
72 payload_type_map,
73 }
74 }
75
76 pub fn set_payload_type(&mut self, pt: u8, codec: CodecType) {
77 self.payload_type_map.insert(pt, codec);
78 }
79
80 pub fn is_audio(payload_type: u8) -> bool {
81 match payload_type {
82 0 | 8 | 9 | 18 | 111 => true,
83 101 => false, pt if pt >= 96 && pt <= 127 => true,
85 _ => false,
86 }
87 }
88
89 pub fn decode(
90 &mut self,
91 payload_type: u8,
92 payload: &[u8],
93 target_sample_rate: u32,
94 ) -> (u32, u16, PcmBuf) {
95 let codec = self
96 .payload_type_map
97 .get(&payload_type)
98 .cloned()
99 .unwrap_or_else(|| match payload_type {
100 0 => CodecType::PCMU,
101 8 => CodecType::PCMA,
102 9 => CodecType::G722,
103 18 => CodecType::G729,
104 111 => CodecType::Opus,
105 _ => CodecType::PCMU,
106 });
107
108 let pcm = match codec {
109 CodecType::PCMU => self.pcmu_decoder.decode(payload),
110 CodecType::PCMA => self.pcma_decoder.decode(payload),
111 CodecType::G722 => self
112 .g722_decoder
113 .get_or_insert_with(|| Box::new(G722Decoder::new()))
114 .decode(payload),
115 CodecType::G729 => self
116 .g729_decoder
117 .get_or_insert_with(|| Box::new(G729Decoder::new()))
118 .decode(payload),
119 #[cfg(feature = "opus")]
120 CodecType::Opus => self
121 .opus_decoder
122 .get_or_insert_with(OpusDecoder::new_default)
123 .decode(payload),
124 _ => bytes_to_samples(payload),
125 };
126
127 let (in_rate, channels) = match codec {
128 CodecType::PCMU => (8000, 1),
129 CodecType::PCMA => (8000, 1),
130 CodecType::G722 => (16000, 1),
131 CodecType::G729 => (8000, 1),
132 #[cfg(feature = "opus")]
133 CodecType::Opus => {
134 if pcm.len() >= 1920 {
135 (48000, 2)
136 } else {
137 (48000, 1)
138 }
139 }
140 _ => (8000, 1),
141 };
142
143 (
144 target_sample_rate,
145 channels,
146 self.resample(pcm, in_rate, target_sample_rate),
147 )
148 }
149
150 pub fn resample(&mut self, pcm: PcmBuf, in_rate: u32, out_rate: u32) -> PcmBuf {
151 if in_rate == out_rate {
152 return pcm;
153 }
154
155 if self.resampler.is_none()
156 || self.resampler_in_rate != in_rate
157 || self.resampler_out_rate != out_rate
158 {
159 self.resampler = Some(Resampler::new(in_rate as usize, out_rate as usize));
160 self.resampler_in_rate = in_rate;
161 self.resampler_out_rate = out_rate;
162 }
163 self.resampler.as_mut().unwrap().resample(&pcm)
164 }
165
166 pub fn encode(&mut self, payload_type: u8, frame: AudioFrame) -> (u8, Vec<u8>) {
167 match frame.samples {
168 Samples::PCM { samples: mut pcm } => {
169 let target_samplerate = match payload_type {
170 0 => 8000,
171 8 => 8000,
172 9 => 16000,
173 18 => 8000,
174 111 => 48000, _ => 8000,
176 };
177
178 if frame.sample_rate != target_samplerate {
179 if self.resampler.is_none()
180 || self.resampler_in_rate != frame.sample_rate
181 || self.resampler_out_rate != target_samplerate
182 {
183 self.resampler = Some(Resampler::new(
184 frame.sample_rate as usize,
185 target_samplerate as usize,
186 ));
187 self.resampler_in_rate = frame.sample_rate;
188 self.resampler_out_rate = target_samplerate;
189 }
190 pcm = self.resampler.as_mut().unwrap().resample(&pcm);
191 }
192
193 let payload = match payload_type {
194 0 => self.pcmu_encoder.encode(&pcm),
195 8 => self.pcma_encoder.encode(&pcm),
196 9 => self
197 .g722_encoder
198 .get_or_insert_with(|| Box::new(G722Encoder::new()))
199 .encode(&pcm),
200 18 => self
201 .g729_encoder
202 .get_or_insert_with(|| Box::new(G729Encoder::new()))
203 .encode(&pcm),
204 #[cfg(feature = "opus")]
205 111 => self
206 .opus_encoder
207 .get_or_insert_with(OpusEncoder::new_default)
208 .encode(&pcm),
209 _ => samples_to_bytes(&pcm),
210 };
211 (payload_type, payload)
212 }
213 Samples::RTP {
214 payload_type,
215 payload,
216 ..
217 } => (payload_type, payload),
218 _ => (payload_type, vec![]),
219 }
220 }
221}