use crate::audio::AudioSpec;
use crate::error::DecodeError;
pub trait Decoder: Send {
fn output_spec(&self) -> AudioSpec;
fn feed(&mut self, input: &[u8]) -> Result<usize, DecodeError>;
fn decode(&mut self, output: &mut Vec<f32>) -> Result<usize, DecodeError>;
fn flush(&mut self, output: &mut Vec<f32>) -> Result<usize, DecodeError>;
fn reset(&mut self);
}
#[cfg(test)]
mod tests {
use super::*;
use crate::audio::AudioBuffer;
struct PassThrough {
spec: AudioSpec,
pending: Vec<u8>,
ready: Vec<f32>,
finished: bool,
}
impl PassThrough {
fn new(spec: AudioSpec) -> Self {
Self {
spec,
pending: Vec::new(),
ready: Vec::new(),
finished: false,
}
}
}
impl Decoder for PassThrough {
fn output_spec(&self) -> AudioSpec {
self.spec
}
fn feed(&mut self, input: &[u8]) -> Result<usize, DecodeError> {
if self.finished {
return Ok(0);
}
self.pending.extend_from_slice(input);
let whole = self.pending.len() / 4 * 4;
for chunk in self.pending[..whole].chunks_exact(4) {
let bytes: [u8; 4] = chunk.try_into().expect("chunks_exact(4) yields 4 bytes");
self.ready.push(f32::from_ne_bytes(bytes));
}
self.pending.drain(..whole);
Ok(input.len())
}
fn decode(&mut self, output: &mut Vec<f32>) -> Result<usize, DecodeError> {
if self.finished {
return Ok(0);
}
let produced = self.ready.len();
output.append(&mut self.ready);
Ok(produced)
}
fn flush(&mut self, output: &mut Vec<f32>) -> Result<usize, DecodeError> {
if self.finished {
return Ok(0);
}
self.finished = true;
if !self.pending.is_empty() {
return Err(DecodeError::Truncated {
expected: 4,
available: self.pending.len() as u64,
});
}
let produced = self.ready.len();
output.append(&mut self.ready);
Ok(produced)
}
fn reset(&mut self) {
self.pending.clear();
self.ready.clear();
self.finished = false;
}
}
fn encode(samples: &[f32]) -> Vec<u8> {
samples.iter().flat_map(|s| s.to_ne_bytes()).collect()
}
fn drive(
decoder: &mut dyn Decoder,
input: &[u8],
chunk: usize,
) -> Result<AudioBuffer, DecodeError> {
let mut samples = Vec::new();
for piece in input.chunks(chunk) {
let mut offset = 0;
while offset < piece.len() {
offset += decoder.feed(&piece[offset..])?;
while decoder.decode(&mut samples)? > 0 {}
}
}
decoder.flush(&mut samples)?;
Ok(AudioBuffer::from_samples(decoder.output_spec(), samples))
}
#[test]
fn the_trait_is_object_safe() {
let boxed: Box<dyn Decoder> = Box::new(PassThrough::new(AudioSpec::mono(16_000)));
assert_eq!(boxed.output_spec(), AudioSpec::mono(16_000));
let mut decoders: Vec<Box<dyn Decoder>> =
vec![Box::new(PassThrough::new(AudioSpec::new(48_000, 2)))];
let by_ref: &mut dyn Decoder = decoders[0].as_mut();
assert_eq!(by_ref.output_spec().channels, 2);
}
#[test]
fn a_decoder_can_be_moved_between_threads() {
fn assert_send<T: Send>() {}
assert_send::<PassThrough>();
assert_send::<Box<dyn Decoder>>();
}
#[test]
fn samples_survive_the_round_trip() {
let expected = [0.0_f32, 1.0, -1.0, 0.5, -0.25];
let mut decoder = PassThrough::new(AudioSpec::mono(16_000));
let decoded = drive(&mut decoder, &encode(&expected), 1024).expect("decode");
assert_eq!(decoded.samples(), expected);
assert_eq!(decoded.sample_rate(), 16_000);
assert_eq!(decoded.frames(), 5);
}
#[test]
fn the_chunk_boundary_is_invisible() {
let expected: Vec<f32> = (0..64).map(|i| i as f32 / 64.0).collect();
let encoded = encode(&expected);
for chunk in [1, 3, 4, 7, 256] {
let mut decoder = PassThrough::new(AudioSpec::mono(8_000));
let decoded = drive(&mut decoder, &encoded, chunk).expect("decode");
assert_eq!(
decoded.samples(),
expected.as_slice(),
"output changed with a {chunk}-byte feed size"
);
}
}
#[test]
fn the_sample_count_is_exact() {
let frames = 100;
let spec = AudioSpec::new(44_100, 2);
let encoded = encode(&vec![0.125_f32; frames * spec.channels as usize]);
let mut decoder = PassThrough::new(spec);
let decoded = drive(&mut decoder, &encoded, 13).expect("decode");
assert_eq!(decoded.samples().len(), frames * spec.channels as usize);
assert_eq!(decoded.frames(), frames);
}
#[test]
fn a_starved_decoder_reports_zero_rather_than_end_of_stream() {
let mut decoder = PassThrough::new(AudioSpec::mono(16_000));
let mut out = Vec::new();
assert_eq!(decoder.decode(&mut out).expect("decode"), 0);
assert_eq!(decoder.feed(&[1, 2, 3]).expect("feed"), 3);
assert_eq!(decoder.decode(&mut out).expect("decode"), 0);
assert!(out.is_empty());
assert_eq!(decoder.feed(&[4]).expect("feed"), 1);
assert_eq!(decoder.decode(&mut out).expect("decode"), 1);
}
#[test]
fn a_partial_frame_at_end_of_stream_is_truncated() {
let mut decoder = PassThrough::new(AudioSpec::mono(16_000));
decoder.feed(&[0, 0, 0]).expect("feed");
let mut out = Vec::new();
let error = decoder.flush(&mut out).expect_err("flush must reject");
assert!(
matches!(
error,
DecodeError::Truncated {
expected: 4,
available: 3
}
),
"unexpected error: {error}"
);
}
#[test]
fn feeding_after_flush_is_quiet_until_reset() {
let mut decoder = PassThrough::new(AudioSpec::mono(16_000));
let mut out = Vec::new();
assert_eq!(decoder.flush(&mut out).expect("flush"), 0);
assert_eq!(decoder.flush(&mut out).expect("second flush"), 0);
assert_eq!(decoder.feed(&encode(&[1.0])).expect("feed"), 0);
assert_eq!(decoder.decode(&mut out).expect("decode"), 0);
assert!(out.is_empty());
decoder.reset();
assert_eq!(decoder.feed(&encode(&[1.0])).expect("feed"), 4);
assert_eq!(decoder.decode(&mut out).expect("decode"), 1);
assert_eq!(out, [1.0]);
}
#[test]
fn reset_drops_a_held_partial_frame() {
let mut decoder = PassThrough::new(AudioSpec::mono(16_000));
decoder.feed(&[9, 9, 9]).expect("feed");
decoder.reset();
let mut out = Vec::new();
assert_eq!(decoder.flush(&mut out).expect("flush after reset"), 0);
}
}