pito_codecs/aac/
mod.rs

1#![allow(clippy::needless_range_loop)]
2
3mod bits;
4mod config;
5mod decoder;
6mod encoder;
7mod huffman;
8mod huffman_tables;
9mod ics;
10mod mdct;
11mod pcm;
12mod tables;
13mod tns;
14
15pub use config::{AdtsHeader, AudioSpecificConfig, split_adts};
16pub use pcm::{Resampler, downmix_stereo, gain, mono, resample};
17
18use crate::media::{AudioBuffer, Error, Packet, Result};
19
20pub const FRAME_LEN: usize = 1024;
21
22pub const RATES: [u32; 13] = tables::SAMPLE_RATES;
23
24fn wave_order(channel_config: u8) -> Option<&'static [usize]> {
25    match channel_config {
26        3 => Some(&[1, 2, 0]),
27        4 => Some(&[1, 2, 0, 3]),
28        5 => Some(&[1, 2, 0, 3, 4]),
29        6 => Some(&[1, 2, 0, 5, 3, 4]),
30        7 => Some(&[1, 2, 0, 7, 5, 6, 3, 4]),
31        _ => None,
32    }
33}
34
35fn aac_order(channels: usize) -> Option<&'static [usize]> {
36    match channels {
37        3 => Some(&[2, 0, 1]),
38        4 => Some(&[2, 0, 1, 3]),
39        5 => Some(&[2, 0, 1, 3, 4]),
40        6 => Some(&[2, 0, 1, 4, 5, 3]),
41        7 => Some(&[2, 0, 1, 5, 6, 4, 3]),
42        8 => Some(&[2, 0, 1, 6, 7, 4, 5, 3]),
43        _ => None,
44    }
45}
46
47pub struct Decoder {
48    core: decoder::Decoder,
49    order: Option<&'static [usize]>,
50}
51
52impl Decoder {
53    pub fn new(extradata: &[u8]) -> Result<Self> {
54        let asc = AudioSpecificConfig::parse(extradata)?;
55        let order = wave_order(asc.channel_config);
56        Ok(Self {
57            core: decoder::Decoder::from_config(asc)?,
58            order,
59        })
60    }
61
62    pub fn from_adts(header: &AdtsHeader) -> Result<Self> {
63        Self::new(&header.to_asc().to_bytes())
64    }
65
66    pub fn rate(&self) -> u32 {
67        self.core.sample_rate()
68    }
69
70    pub fn channels(&self) -> u16 {
71        self.core.channels() as u16
72    }
73
74    pub fn reset(&mut self) {
75        self.core.reset();
76    }
77
78    pub fn decode(&mut self, packet: &Packet) -> Result<AudioBuffer> {
79        self.decode_frame(&packet.data)
80    }
81
82    pub fn decode_frame(&mut self, data: &[u8]) -> Result<AudioBuffer> {
83        let planar = self.core.decode(data)?;
84        let channels = planar.len();
85        let frames = planar.first().map_or(0, Vec::len);
86        let mut out = AudioBuffer::new(self.rate(), channels as u16);
87        out.samples.reserve(frames * channels);
88        for i in 0..frames {
89            for c in 0..channels {
90                let src = self.order.and_then(|o| o.get(c)).copied().unwrap_or(c);
91                out.samples.push(planar[src][i]);
92            }
93        }
94        Ok(out)
95    }
96}
97
98#[derive(Debug, Clone, Copy, PartialEq, Eq)]
99pub struct EncoderConfig {
100    pub rate: u32,
101    pub channels: u16,
102    pub bitrate: u32,
103}
104
105pub struct Encoder {
106    core: encoder::Encoder,
107    config: EncoderConfig,
108    order: Option<&'static [usize]>,
109    planar: Vec<Vec<f32>>,
110    next: i64,
111}
112
113impl Encoder {
114    pub fn new(config: EncoderConfig) -> Result<Self> {
115        if !RATES.contains(&config.rate) {
116            return Err(Error::Unsupported(format!(
117                "AAC sample rate {} (resample to 48000 first)",
118                config.rate
119            )));
120        }
121        let channels = config.channels as usize;
122        let core = encoder::Encoder::new(if config.bitrate == 0 {
123            encoder::EncoderConfig::vbr(config.rate, channels, 3.0)
124        } else {
125            encoder::EncoderConfig::cbr(config.rate, channels, config.bitrate)
126        })?;
127        Ok(Self {
128            core,
129            config,
130            order: aac_order(config.channels as usize),
131            planar: vec![Vec::new(); config.channels as usize],
132            next: 0,
133        })
134    }
135
136    pub fn config(&self) -> EncoderConfig {
137        self.config
138    }
139
140    pub fn extradata(&self) -> Vec<u8> {
141        self.core.audio_specific_config()
142    }
143
144    pub fn priming(&self) -> u32 {
145        self.core.priming_samples()
146    }
147
148    pub fn encode(&mut self, audio: &AudioBuffer) -> Result<Vec<Packet>> {
149        if audio.channels != self.config.channels || audio.rate != self.config.rate {
150            return Err(Error::Invalid(format!(
151                "audio is {} Hz {} ch, the encoder takes {} Hz {} ch",
152                audio.rate, audio.channels, self.config.rate, self.config.channels
153            )));
154        }
155        let channels = self.config.channels as usize;
156        for (c, plane) in self.planar.iter_mut().enumerate() {
157            let src = self.order.and_then(|o| o.get(c)).copied().unwrap_or(c);
158            plane.clear();
159            plane.extend(audio.samples.chunks_exact(channels).map(|f| f[src]));
160        }
161        let planes: Vec<&[f32]> = self.planar.iter().map(Vec::as_slice).collect();
162        let units = self.core.encode(&planes);
163        Ok(self.packets(units))
164    }
165
166    pub fn flush(&mut self) -> Vec<Packet> {
167        let units = self.core.flush();
168        self.packets(units)
169    }
170
171    fn packets(&mut self, units: Vec<Vec<u8>>) -> Vec<Packet> {
172        units
173            .into_iter()
174            .map(|data| {
175                let pts = self.next;
176                self.next += FRAME_LEN as i64;
177                Packet {
178                    data,
179                    pts,
180                    dts: pts,
181                    keyframe: true,
182                }
183            })
184            .collect()
185    }
186}
187
188#[cfg(test)]
189mod malformed;
190#[cfg(test)]
191mod tests;
pito_codecs/aac/mod.rs

pito_codecs/aac/
mod.rs
