use rff_codec::{Codec, CodecParams, CodecRegistry, Decoder};
use rff_core::{AudioFrame, CodecId, Error, Frame, MediaType, Packet, Result, SampleFormat};
pub fn register(registry: &mut CodecRegistry) {
registry.register(Codec {
id: CodecId::Alac,
name: "alac",
long_name: "ALAC (Apple Lossless Audio Codec)",
media_type: MediaType::Audio,
decoder: Some(|| Box::new(AlacDecoder::default())),
encoder: None,
});
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct AlacConfig {
pub frame_length: u32,
pub bit_depth: u8,
pub pb: u8,
pub mb: u8,
pub kb: u8,
pub channels: u8,
pub sample_rate: u32,
}
impl AlacConfig {
fn at(b: &[u8]) -> Option<AlacConfig> {
if b.len() < 24 {
return None;
}
let c = AlacConfig {
frame_length: u32::from_be_bytes([b[0], b[1], b[2], b[3]]),
bit_depth: b[5],
pb: b[6],
mb: b[7],
kb: b[8],
channels: b[9],
sample_rate: u32::from_be_bytes([b[20], b[21], b[22], b[23]]),
};
let ok = matches!(c.bit_depth, 16 | 20 | 24 | 32)
&& (1..=8).contains(&c.channels)
&& (1..=1 << 20).contains(&c.frame_length)
&& (1..=32).contains(&c.kb);
ok.then_some(c)
}
pub fn from_cookie(cookie: &[u8]) -> Option<AlacConfig> {
let mut i = 0;
while i + 12 <= cookie.len() && i < 64 {
if &cookie[i + 4..i + 8] == b"alac" {
if let Some(c) = cookie.get(i + 12..).and_then(AlacConfig::at) {
return Some(c);
}
}
let size = u32::from_be_bytes([cookie[i], cookie[i + 1], cookie[i + 2], cookie[i + 3]])
as usize;
if size < 8 {
break;
}
i += size;
}
AlacConfig::at(cookie).or_else(|| cookie.get(4..).and_then(AlacConfig::at))
}
}
const OFFSETS: [[u8; 8]; 8] = [
[0, 0, 0, 0, 0, 0, 0, 0],
[0, 1, 0, 0, 0, 0, 0, 0],
[2, 0, 1, 0, 0, 0, 0, 0],
[2, 0, 1, 3, 0, 0, 0, 0],
[2, 0, 1, 3, 4, 0, 0, 0],
[2, 0, 1, 4, 5, 3, 0, 0],
[2, 0, 1, 4, 5, 6, 3, 0],
[2, 6, 7, 0, 1, 4, 5, 3],
];
struct Bits<'a> {
data: &'a [u8],
pos: usize, }
impl<'a> Bits<'a> {
fn new(data: &'a [u8]) -> Bits<'a> {
Bits { data, pos: 0 }
}
fn left(&self) -> isize {
(self.data.len() * 8) as isize - self.pos as isize
}
#[inline(always)]
fn window(&self) -> u64 {
let at = self.pos >> 3;
let word = match self.data.get(at..at + 8) {
Some(w) => u64::from_be_bytes(w.try_into().unwrap()),
None => self.window_tail(at),
};
word << (self.pos & 7)
}
#[cold]
#[inline(never)]
fn window_tail(&self, at: usize) -> u64 {
let mut w = [0u8; 8];
if let Some(rest) = self.data.get(at..) {
w[..rest.len()].copy_from_slice(rest);
}
u64::from_be_bytes(w)
}
#[inline(always)]
fn peek(&self, n: u32) -> u32 {
if n == 0 {
return 0;
}
(self.window() >> (64 - n)) as u32
}
#[inline(always)]
fn read(&mut self, n: u32) -> u32 {
let v = self.peek(n);
self.pos += n as usize;
v
}
#[inline(always)]
fn skip(&mut self, n: u32) {
self.pos += n as usize;
}
fn sbits(&mut self, n: u32) -> i32 {
sign_extend(self.read(n) as i32, n)
}
}
#[inline(always)]
fn sign_extend(v: i32, bits: u32) -> i32 {
debug_assert!(bits <= 32);
let s = 32u32.wrapping_sub(bits) & 31;
(v << s) >> s
}
#[inline(always)]
fn decode_scalar(b: &mut Bits, k: u32, bps: u32) -> u32 {
let w = b.window();
let x = (!w).leading_zeros().min(9);
if x > 8 {
b.skip(9);
return b.read(bps);
}
if k == 1 {
b.skip(x + 1);
return x;
}
let extra = ((w << (x + 1)) >> (64 - k)) as u32;
let base = (x << k).wrapping_sub(x);
if extra > 1 {
b.skip(x + 1 + k);
base.wrapping_add(extra - 1)
} else {
b.skip(x + k);
base
}
}
fn log2(v: u32) -> u32 {
if v == 0 {
0
} else {
31 - v.leading_zeros()
}
}
fn rice_decompress(
b: &mut Bits,
out: &mut [i32],
bps: u32,
history_mult: u32,
initial_history: u32,
limit: u32,
) -> Result<()> {
let n = out.len();
let mut history = initial_history;
let mut sign_modifier = 0u32;
let mut i = 0;
while i < n {
if b.left() <= 0 {
return Err(Error::invalid("alac: residuals run past the packet"));
}
let k = log2((history >> 9) + 3).min(limit);
let x = decode_scalar(b, k, bps).wrapping_add(sign_modifier);
sign_modifier = 0;
out[i] = ((x >> 1) as i32) ^ -((x & 1) as i32);
if x > 0xffff {
history = 0xffff;
} else {
history = history
.wrapping_add(x.wrapping_mul(history_mult))
.wrapping_sub(history.wrapping_mul(history_mult) >> 9);
}
if history < 128 && i + 1 < n {
let k = (7 - log2(history) + ((history + 16) >> 6)).min(limit);
let block = decode_scalar(b, k, 16) as usize;
if block > 0 {
if block >= n - i {
return Err(Error::invalid("alac: zero run past the frame"));
}
out[i + 1..i + 1 + block].fill(0);
i += block;
}
if block <= 0xffff {
sign_modifier = 1;
}
history = 0;
}
i += 1;
}
Ok(())
}
fn sign_only(v: i32) -> i32 {
v.signum()
}
fn lpc_prediction(
err: &[i32],
out: &mut [i32],
bps: u32,
coefs: &mut [i16],
order: usize,
quant: u32,
) {
let n = err.len();
if n == 0 {
return;
}
out[0] = err[0];
if n <= 1 {
return;
}
if order == 0 {
out[1..n].copy_from_slice(&err[1..n]);
return;
}
if order == 31 {
for i in 1..n {
out[i] = sign_extend(out[i - 1].wrapping_add(err[i]), bps);
}
return;
}
let mut i = 1;
while i <= order && i < n {
out[i] = sign_extend(out[i - 1].wrapping_add(err[i]), bps);
i += 1;
}
if i >= n {
return;
}
match order {
4 => lpc_fixed::<4>(err, out, bps, &mut coefs[..4], quant),
8 => lpc_fixed::<8>(err, out, bps, &mut coefs[..8], quant),
_ => lpc_adaptive(err, out, bps, &mut coefs[..order], order, quant),
}
}
fn first_order(buf: &mut [i32], bps: u32) {
let Some((first, rest)) = buf.split_first_mut() else {
return;
};
let mut prev = *first;
for v in rest {
prev = sign_extend(prev.wrapping_add(*v), bps);
*v = prev;
}
}
#[inline(always)]
fn lpc_fixed<const N: usize>(
err: &[i32],
out: &mut [i32],
bps: u32,
coefs: &mut [i16],
quant: u32,
) {
let n = err.len().min(out.len());
if n <= N + 1 {
return;
}
let round = 1i64 << (quant - 1);
let mut c: [i16; N] = coefs[..N].try_into().unwrap();
let mut d = out[0];
let mut past: [i32; N] = out[1..=N].try_into().unwrap();
for (o, &e) in out[N + 1..n].iter_mut().zip(&err[N + 1..n]) {
let mut val: i32 = 0;
for j in 0..N {
val = val.wrapping_add(past[j].wrapping_sub(d).wrapping_mul(i32::from(c[j])));
}
let rounded = ((i64::from(val) + round) >> quant) as i32;
let y = sign_extend(rounded.wrapping_add(d).wrapping_add(e), bps);
*o = y;
let mut error_val = e;
if e > 0 {
for j in 0..N {
let v = d.wrapping_sub(past[j]);
let sign = sign_only(v);
c[j] = c[j].wrapping_sub(sign as i16);
error_val = error_val
.wrapping_sub((v.wrapping_mul(sign) >> quant).wrapping_mul(j as i32 + 1));
if error_val <= 0 {
break;
}
}
} else if e.wrapping_neg() > 0 {
for j in 0..N {
let v = d.wrapping_sub(past[j]);
let sign = sign_only(v);
c[j] = c[j].wrapping_add(sign as i16);
error_val = error_val
.wrapping_sub((v.wrapping_mul(-sign) >> quant).wrapping_mul(j as i32 + 1));
if error_val.wrapping_neg() <= 0 {
break;
}
}
}
d = past[0];
past.copy_within(1.., 0);
past[N - 1] = y;
}
coefs[..N].copy_from_slice(&c);
}
#[inline(always)]
fn lpc_adaptive(
err: &[i32],
out: &mut [i32],
bps: u32,
coefs: &mut [i16],
order: usize,
quant: u32,
) {
let n = err.len().min(out.len());
let round = 1i64 << (quant - 1);
for i in order + 1..n {
let (head, tail) = out.split_at_mut(i);
let win = &head[i - order - 1..];
let d = win[0];
let past = &win[1..=order];
let val = past.iter().zip(coefs.iter()).fold(0i32, |acc, (&o, &c)| {
acc.wrapping_add(o.wrapping_sub(d).wrapping_mul(i32::from(c)))
});
let rounded = ((i64::from(val) + round) >> quant) as i32;
let mut error_val = err[i] as u32;
tail[0] = sign_extend(rounded.wrapping_add(d).wrapping_add(error_val as i32), bps);
let error_sign = sign_only(error_val as i32);
if error_sign != 0 {
for (j, (&o, c)) in past.iter().zip(coefs.iter_mut()).enumerate() {
if (error_val.wrapping_mul(error_sign as u32) as i32) <= 0 {
break;
}
let v = d.wrapping_sub(o);
let sign = sign_only(v) * error_sign;
*c = c.wrapping_sub(sign as i16);
error_val = error_val.wrapping_sub(
((v.wrapping_mul(sign) >> quant) as u32).wrapping_mul(j as u32 + 1),
);
}
}
}
}
fn decode_frame(
cfg: &AlacConfig,
data: &[u8],
out: &mut [Vec<i32>],
extra_buf: &mut Vec<u32>,
residual: &mut Vec<i32>,
) -> Result<usize> {
let channels = cfg.channels as usize;
let mut b = Bits::new(data);
let mut ch = 0usize;
let mut nb_samples: Option<usize> = None;
while ch < channels && b.left() >= 3 {
let element = b.read(3);
if element == 7 {
break; }
if !matches!(element, 0 | 1 | 3) {
return Err(Error::unsupported(format!("alac: element type {element}")));
}
let elem_ch = if element == 1 { 2 } else { 1 };
if ch + elem_ch > channels || OFFSETS[channels - 1][ch] as usize + elem_ch > channels {
return Err(Error::invalid("alac: more channel elements than channels"));
}
let at = OFFSETS[channels - 1][ch] as usize;
let n = decode_element(
cfg,
&mut b,
elem_ch,
nb_samples,
&mut out[at..at + elem_ch],
extra_buf,
residual,
)?;
nb_samples = Some(n);
ch += elem_ch;
}
if ch < channels {
return Err(Error::invalid("alac: frame ends before every channel"));
}
Ok(nb_samples.unwrap_or(0))
}
fn decode_element(
cfg: &AlacConfig,
b: &mut Bits,
channels: usize,
expected: Option<usize>,
out: &mut [Vec<i32>],
extra_buf: &mut Vec<u32>,
residual: &mut Vec<i32>,
) -> Result<usize> {
b.skip(4); b.skip(12); let has_size = b.read(1) == 1;
let extra_bits = b.read(2) * 8;
let sample_size = cfg.bit_depth as u32;
let bps = (sample_size + channels as u32 - 1)
.checked_sub(extra_bits)
.filter(|&v| (1..=32).contains(&v))
.ok_or_else(|| Error::invalid("alac: bad shifted-byte count"))?;
let is_compressed = b.read(1) == 0;
let n = if has_size {
b.read(32) as usize
} else {
cfg.frame_length as usize
};
if n == 0 || n > cfg.frame_length as usize {
return Err(Error::invalid(format!("alac: {n} samples in a frame")));
}
if expected.is_some_and(|e| e != n) {
return Err(Error::invalid("alac: elements disagree on the frame size"));
}
for o in out.iter_mut() {
o.resize(n, 0);
}
let mut decorr_shift = 0u32;
let mut decorr_left_weight = 0i32;
let mut extra = 0u32;
if is_compressed {
decorr_shift = b.read(8);
decorr_left_weight = b.read(8) as i32;
if channels == 2 && decorr_left_weight != 0 && decorr_shift > 31 {
return Err(Error::invalid("alac: decorrelation shift past 31"));
}
let mut pred_type = [0u32; 2];
let mut quant = [0u32; 2];
let mut hist_mult = [0u32; 2];
let mut order = [0usize; 2];
let mut coefs = [[0i16; 32]; 2];
for c in 0..channels {
pred_type[c] = b.read(4);
quant[c] = b.read(4);
hist_mult[c] = b.read(3);
order[c] = b.read(5) as usize;
if order[c] >= n || quant[c] == 0 {
return Err(Error::invalid("alac: bad predictor"));
}
for i in (0..order[c]).rev() {
coefs[c][i] = b.sbits(16) as i16;
}
}
extra = extra_bits;
if extra > 0 {
if b.left() < (n * channels * extra as usize) as isize {
return Err(Error::invalid("alac: shifted bytes run past the packet"));
}
extra_buf.clear();
extra_buf.extend((0..n * channels).map(|_| b.read(extra)));
}
residual.resize(n, 0);
for c in 0..channels {
let buf = &mut residual[..n];
rice_decompress(
b,
buf,
bps,
hist_mult[c] * cfg.pb as u32 / 4,
cfg.mb as u32,
cfg.kb as u32,
)?;
if pred_type[c] == 15 {
first_order(buf, bps);
}
lpc_prediction(buf, &mut out[c], bps, &mut coefs[c], order[c], quant[c]);
}
} else {
for i in 0..n {
for o in out.iter_mut() {
o[i] = b.sbits(sample_size);
}
}
}
if channels == 2 && decorr_left_weight != 0 {
let (l, r) = out.split_at_mut(1);
for i in 0..n {
let mut a = l[0][i];
let mut bb = r[0][i];
a = a.wrapping_sub(bb.wrapping_mul(decorr_left_weight) >> decorr_shift);
bb = bb.wrapping_add(a);
l[0][i] = bb;
r[0][i] = a;
}
}
if extra > 0 {
for (c, o) in out.iter_mut().enumerate() {
for (s, e) in o.iter_mut().zip(extra_buf[c..].iter().step_by(channels)) {
*s = ((*s as u32) << extra | e) as i32;
}
}
}
Ok(n)
}
fn interleave<const W: usize>(
bufs: &[Vec<i32>],
n: usize,
conv: impl Fn(i32) -> [u8; W],
) -> Vec<u8> {
let ch = bufs.len();
let mut out = vec![0u8; n * ch * W];
match bufs {
[m] => {
for (d, &s) in out.chunks_exact_mut(W).zip(&m[..n]) {
d.copy_from_slice(&conv(s));
}
}
[l, r] => {
for (d, (&a, &b)) in out.chunks_exact_mut(2 * W).zip(l[..n].iter().zip(&r[..n])) {
d[..W].copy_from_slice(&conv(a));
d[W..].copy_from_slice(&conv(b));
}
}
_ => {
for (i, d) in out.chunks_exact_mut(ch * W).enumerate() {
for (b, o) in bufs.iter().zip(d.chunks_exact_mut(W)) {
o.copy_from_slice(&conv(b[i]));
}
}
}
}
out
}
#[derive(Default)]
struct AlacDecoder {
config: Option<AlacConfig>,
sample_rate: u32,
buffers: Vec<Vec<i32>>,
extra_buf: Vec<u32>,
residual: Vec<i32>,
frame: Option<Frame>,
eof: bool,
}
impl Decoder for AlacDecoder {
fn configure(&mut self, params: &CodecParams) -> Result<()> {
let cfg = AlacConfig::from_cookie(¶ms.extradata)
.ok_or_else(|| Error::invalid("alac: no usable magic cookie in extradata"))?;
self.sample_rate = if params.sample_rate > 0 {
params.sample_rate
} else {
cfg.sample_rate
};
self.buffers = vec![Vec::new(); cfg.channels as usize];
self.config = Some(cfg);
Ok(())
}
fn send_packet(&mut self, packet: &Packet) -> Result<()> {
let cfg = self
.config
.ok_or_else(|| Error::invalid("alac: not configured"))?;
let n = decode_frame(
&cfg,
&packet.data,
&mut self.buffers,
&mut self.extra_buf,
&mut self.residual,
)?;
let (format, data) = if cfg.bit_depth == 16 {
let data = interleave(&self.buffers, n, |s| (s as i16).to_le_bytes());
(SampleFormat::S16, data)
} else {
let shift = 32 - cfg.bit_depth as u32;
let data = interleave(&self.buffers, n, |s| {
let v = (s as u32).wrapping_shl(shift) as i32;
(v as f32 * (1.0 / 2_147_483_648.0)).to_le_bytes()
});
(SampleFormat::F32, data)
};
self.frame = Some(Frame::Audio(AudioFrame {
sample_rate: self.sample_rate,
channels: cfg.channels as u16,
format,
planes: vec![data],
samples: n,
pts: packet.pts,
}));
Ok(())
}
fn receive_frame(&mut self) -> Result<Frame> {
if let Some(f) = self.frame.take() {
return Ok(f);
}
if self.eof {
Err(Error::Eof)
} else {
Err(Error::Again)
}
}
fn flush(&mut self) {
self.eof = true;
}
}
#[cfg(test)]
mod tests;