mod bits;
pub(crate) mod encoder;
mod huffman;
mod mdct;
#[rustfmt::skip]
mod tables;
#[cfg(test)]
mod tests;
use crate::error::{Error, Result};
pub const FRAME_LEN: usize = 1024;
const RATES: [u32; 12] = [
96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000,
];
pub struct Encoder {
core: encoder::Core,
sample_rate: u32,
channels: u8,
fs_index: u8,
}
impl Encoder {
pub fn new(sample_rate: u32, channels: u8, bitrate_bps: u32) -> Result<Encoder> {
let fs_index = RATES
.iter()
.position(|&r| r == sample_rate)
.ok_or_else(|| Error::unsupported(format!("aacenc: sample rate {sample_rate}")))?
as u8;
if !(1..=2).contains(&channels) {
return Err(Error::unsupported(format!("aacenc: {channels} channels")));
}
let max = (6144u64 * sample_rate as u64 / FRAME_LEN as u64) * channels as u64;
let min = 8000 * channels as u64;
if (bitrate_bps as u64) < min || bitrate_bps as u64 > max {
return Err(Error::unsupported(format!(
"aacenc: bitrate {bitrate_bps} outside {min}..={max}"
)));
}
Ok(Encoder {
core: encoder::Core::new(
fs_index as usize,
sample_rate,
channels as usize,
bitrate_bps,
),
sample_rate,
channels,
fs_index,
})
}
pub fn sample_rate(&self) -> u32 {
self.sample_rate
}
pub fn channels(&self) -> u8 {
self.channels
}
pub fn encode(&mut self, pcm: &[i16]) -> Result<Vec<u8>> {
let want = FRAME_LEN * self.channels as usize;
if pcm.len() != want {
return Err(Error::malformed(format!(
"aacenc: got {} samples, want {want}",
pcm.len()
)));
}
Ok(self.core.encode(pcm))
}
pub fn flush(&mut self) -> Vec<Vec<u8>> {
let zeros = vec![0i16; FRAME_LEN * self.channels as usize];
(0..self.delay_samples() / FRAME_LEN)
.map(|_| self.core.encode(&zeros))
.collect()
}
pub fn delay_samples(&self) -> usize {
2 * FRAME_LEN
}
pub fn audio_specific_config(&self) -> Vec<u8> {
let v: u16 = (2 << 11) | ((self.fs_index as u16) << 7) | ((self.channels as u16) << 3);
v.to_be_bytes().to_vec()
}
pub fn adts(&self, au: &[u8]) -> Vec<u8> {
adts_header(self.fs_index, self.channels, au)
}
}
fn adts_header(fs_index: u8, channels: u8, au: &[u8]) -> Vec<u8> {
let len = (au.len() + 7).min(0x1fff) as u32;
let mut w = bits::BitWriter::new();
use bits::BitSink;
w.put(0xfff, 12); w.put(0, 1); w.put(0, 2); w.put(1, 1); w.put(1, 2); w.put(fs_index as u32, 4);
w.put(0, 1); w.put(channels as u32, 3);
w.put(0, 4); w.put(len, 13);
w.put(0x7ff, 11); w.put(0, 2); let mut out = w.finish();
out.extend_from_slice(au);
out
}