use std::fmt;
use crate::aiff::{AiffFormat, AiffReader, AiffStreamDecoder};
use crate::audio::{AudioBuffer, AudioSpec};
use crate::codec::FourCc;
use crate::error::DecodeError;
use crate::flac::{FlacReader, FlacStreamDecoder, FlacStreamInfo, Md5Check};
use crate::source::StreamSource;
use crate::wav::{WavFormat, WavReader, WavStreamDecoder};
use crate::{aiff, riff};
pub(crate) const FLAC_MAGIC: FourCc = FourCc(*b"fLaC");
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum Container {
Wav,
Aiff,
Flac,
}
impl Container {
pub const PROBE_BYTES: usize = 12;
}
impl fmt::Display for Container {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let name = match self {
Self::Wav => "WAV",
Self::Aiff => "AIFF",
Self::Flac => "FLAC",
};
f.write_str(name)
}
}
pub fn identify(bytes: &[u8]) -> Result<Container, DecodeError> {
let (Some(magic), Some(form)) = (riff::four_cc_at(bytes, 0), riff::four_cc_at(bytes, 8)) else {
return Err(DecodeError::Truncated {
expected: Container::PROBE_BYTES as u64,
available: bytes.len() as u64,
});
};
if magic == FLAC_MAGIC {
return Ok(Container::Flac);
}
if magic == riff::RIFF || magic == riff::RF64 {
return if form == riff::WAVE {
Ok(Container::Wav)
} else {
Err(DecodeError::UnsupportedContainer { tag: form })
};
}
if magic == aiff::FORM {
return if form == aiff::AIFF || form == aiff::AIFC {
Ok(Container::Aiff)
} else {
Err(DecodeError::UnsupportedContainer { tag: form })
};
}
Err(DecodeError::UnsupportedContainer { tag: magic })
}
pub fn decode(bytes: &[u8]) -> Result<AudioBuffer, DecodeError> {
match identify(bytes)? {
Container::Wav => Ok(WavReader::new(bytes)?.decode_to_end()),
Container::Aiff => Ok(AiffReader::new(bytes)?.decode_to_end()),
Container::Flac => FlacReader::new(bytes)?.decode_to_end(),
}
}
#[derive(Debug)]
enum Inner {
Wav(WavStreamDecoder),
Aiff(AiffStreamDecoder),
Flac(Box<FlacStreamDecoder>),
}
impl Inner {
fn new(container: Container) -> Self {
match container {
Container::Wav => Self::Wav(WavStreamDecoder::new()),
Container::Aiff => Self::Aiff(AiffStreamDecoder::new()),
Container::Flac => Self::Flac(Box::default()),
}
}
fn source(&mut self) -> &mut dyn StreamSource {
match self {
Self::Wav(reader) => reader,
Self::Aiff(reader) => reader,
Self::Flac(reader) => reader.as_mut(),
}
}
fn source_ref(&self) -> &dyn StreamSource {
match self {
Self::Wav(reader) => reader,
Self::Aiff(reader) => reader,
Self::Flac(reader) => reader.as_ref(),
}
}
}
#[derive(Debug)]
pub struct AudioStreamDecoder {
inner: Option<Inner>,
header: Vec<u8>,
fed: usize,
container: Option<Container>,
finished: bool,
}
impl Default for AudioStreamDecoder {
fn default() -> Self {
Self::new()
}
}
impl AudioStreamDecoder {
pub fn new() -> Self {
Self {
inner: None,
header: Vec::with_capacity(Container::PROBE_BYTES),
fed: 0,
container: None,
finished: false,
}
}
pub const fn container(&self) -> Option<Container> {
self.container
}
pub const fn wav_format(&self) -> Option<WavFormat> {
match &self.inner {
Some(Inner::Wav(reader)) => reader.format(),
_ => None,
}
}
pub const fn aiff_format(&self) -> Option<AiffFormat> {
match &self.inner {
Some(Inner::Aiff(reader)) => reader.format(),
_ => None,
}
}
pub fn flac_stream_info(&self) -> Option<FlacStreamInfo> {
match &self.inner {
Some(Inner::Flac(reader)) => reader.stream_info(),
_ => None,
}
}
pub fn flac_md5_check(&self) -> Option<Md5Check> {
match &self.inner {
Some(Inner::Flac(reader)) => reader.md5_check(),
_ => None,
}
}
fn feed_header(&mut self) -> Result<(), DecodeError> {
while self.fed < self.header.len() {
let Some(inner) = self.inner.as_mut() else {
return Ok(());
};
let taken = inner.source().push(&self.header[self.fed..])?;
if taken == 0 {
break;
}
self.fed += taken;
}
Ok(())
}
fn push_inner(&mut self, bytes: &[u8]) -> Result<usize, DecodeError> {
if self.inner.is_none() {
let want = Container::PROBE_BYTES - self.header.len();
let take = want.min(bytes.len());
self.header.extend_from_slice(&bytes[..take]);
if self.header.len() < Container::PROBE_BYTES {
return Ok(take);
}
let container = identify(&self.header)?;
self.container = Some(container);
self.inner = Some(Inner::new(container));
self.feed_header()?;
if self.fed < self.header.len() {
return Ok(take);
}
let Some(inner) = self.inner.as_mut() else {
return Ok(take);
};
return Ok(take + inner.source().push(&bytes[take..])?);
}
self.feed_header()?;
if self.fed < self.header.len() {
return Ok(0);
}
let Some(inner) = self.inner.as_mut() else {
return Ok(0);
};
inner.source().push(bytes)
}
}
impl StreamSource for AudioStreamDecoder {
fn push(&mut self, bytes: &[u8]) -> Result<usize, DecodeError> {
if self.finished {
return Ok(0);
}
let result = self.push_inner(bytes);
if result.is_err() {
self.finished = true;
}
result
}
fn pull(&mut self, output: &mut Vec<f32>, max_frames: usize) -> Result<usize, DecodeError> {
match self.inner.as_mut() {
Some(inner) => inner.source().pull(output, max_frames),
None => Ok(0),
}
}
fn spec(&self) -> Option<AudioSpec> {
self.inner
.as_ref()
.and_then(|inner| inner.source_ref().spec())
}
fn buffered_bytes(&self) -> usize {
(self.header.len() - self.fed)
+ self
.inner
.as_ref()
.map_or(0, |inner| inner.source_ref().buffered_bytes())
}
fn finish(&mut self, output: &mut Vec<f32>) -> Result<usize, DecodeError> {
if self.finished {
return Ok(0);
}
self.finished = true;
self.feed_header()?;
let Some(inner) = self.inner.as_mut() else {
return Err(DecodeError::Truncated {
expected: Container::PROBE_BYTES as u64,
available: self.header.len() as u64,
});
};
inner.source().finish(output)
}
fn reset(&mut self) {
*self = Self::new();
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::wav::{WavCodec, WavWriter};
fn header(magic: &[u8; 4], form: &[u8; 4]) -> Vec<u8> {
let mut bytes = magic.to_vec();
bytes.extend_from_slice(&64u32.to_le_bytes());
bytes.extend_from_slice(form);
bytes
}
#[test]
fn the_three_carried_formats_are_identified_by_content() {
assert_eq!(identify(&header(b"RIFF", b"WAVE")).unwrap(), Container::Wav);
assert_eq!(identify(&header(b"RF64", b"WAVE")).unwrap(), Container::Wav);
assert_eq!(
identify(&header(b"FORM", b"AIFF")).unwrap(),
Container::Aiff
);
assert_eq!(
identify(&header(b"FORM", b"AIFC")).unwrap(),
Container::Aiff
);
assert_eq!(
identify(&header(b"fLaC", b"\0\0\0\0")).unwrap(),
Container::Flac
);
}
#[test]
fn a_riff_that_is_not_wave_is_rejected_by_its_form_type() {
for form in [b"AVI ", b"ACON", b"RMID", b"CDXA"] {
let error = identify(&header(b"RIFF", form)).unwrap_err();
let DecodeError::UnsupportedContainer { tag } = error else {
panic!("a RIFF of form {form:?} was not rejected as a container: {error}");
};
assert_eq!(tag.as_bytes(), form, "the error names the form type found");
}
}
#[test]
fn a_form_that_is_not_aiff_or_aifc_is_rejected_by_its_form_type() {
for form in [b"8SVX", b"ILBM", b"ANBM", b"AIFZ"] {
let error = identify(&header(b"FORM", form)).unwrap_err();
let DecodeError::UnsupportedContainer { tag } = error else {
panic!("a FORM of type {form:?} was not rejected as a container: {error}");
};
assert_eq!(tag.as_bytes(), form);
}
}
#[test]
fn an_unknown_magic_is_named_by_its_leading_bytes() {
let error = identify(&header(b"OggS", b"\0\0\0\0")).unwrap_err();
let DecodeError::UnsupportedContainer { tag } = error else {
panic!("an Ogg page was not rejected as a container: {error}");
};
assert_eq!(tag.as_bytes(), b"OggS");
}
#[test]
fn every_length_under_the_probe_length_is_truncated_not_a_guess() {
let full = header(b"RIFF", b"WAVE");
for length in 0..Container::PROBE_BYTES {
let error = identify(&full[..length]).unwrap_err();
assert!(
matches!(
error,
DecodeError::Truncated { expected, available }
if expected == Container::PROBE_BYTES as u64
&& available == length as u64
),
"{length} bytes gave {error} rather than a truncation"
);
}
}
#[test]
fn a_prefix_that_would_identify_still_needs_the_whole_probe() {
assert!(matches!(
identify(b"fLaC"),
Err(DecodeError::Truncated { .. })
));
}
#[test]
fn the_container_names_itself_for_a_report() {
assert_eq!(Container::Wav.to_string(), "WAV");
assert_eq!(Container::Aiff.to_string(), "AIFF");
assert_eq!(Container::Flac.to_string(), "FLAC");
}
#[test]
fn the_whole_file_path_matches_the_reader_it_chose() {
let samples = [0.0, 0.25, -0.25, 0.5];
let file = WavWriter::new(AudioSpec::new(16_000, 2), WavCodec::PcmI16)
.to_bytes(&samples)
.expect("a two-channel 16-bit WAV writes");
let direct = WavReader::new(&file)
.expect("the file opens")
.decode_to_end();
let probed = decode(&file).expect("the file opens through the probe");
assert_eq!(probed, direct);
}
#[test]
fn the_streaming_path_reports_what_it_identified_and_nothing_before() {
let file = WavWriter::new(AudioSpec::mono(8_000), WavCodec::PcmU8)
.to_bytes(&[0.0, 0.5])
.expect("an 8-bit WAV writes");
let mut stream = AudioStreamDecoder::new();
assert_eq!(stream.container(), None);
assert_eq!(stream.spec(), None);
assert_eq!(stream.push(&file[..11]).expect("eleven bytes"), 11);
assert_eq!(stream.container(), None);
assert_eq!(stream.buffered_bytes(), 11);
assert_eq!(stream.push(&file[11..12]).expect("the twelfth"), 1);
assert_eq!(stream.container(), Some(Container::Wav));
assert_eq!(stream.spec(), None);
assert_eq!(stream.buffered_bytes(), 0);
}
#[test]
fn a_stream_that_ends_before_identification_is_truncated() {
let mut stream = AudioStreamDecoder::new();
assert_eq!(stream.push(b"RIFF\x40\x00").expect("six bytes"), 6);
let mut samples = Vec::new();
let error = stream.finish(&mut samples).unwrap_err();
assert!(
matches!(
error,
DecodeError::Truncated {
expected: 12,
available: 6
}
),
"a stream cut inside the probe reported {error}"
);
assert_eq!(stream.finish(&mut samples).expect("second finish"), 0);
}
#[test]
fn a_failed_stream_stays_failed() {
let mut stream = AudioStreamDecoder::new();
let mut avi = b"RIFF".to_vec();
avi.extend_from_slice(&2048u32.to_le_bytes());
avi.extend_from_slice(b"AVI ");
assert!(stream.push(&avi).is_err());
assert_eq!(
stream.push(&avi).expect("a finished stream takes nothing"),
0
);
}
#[test]
fn reset_returns_the_stream_to_its_just_constructed_state() {
let file = WavWriter::new(AudioSpec::mono(8_000), WavCodec::PcmI16)
.to_bytes(&[0.0, 0.5])
.expect("a 16-bit WAV writes");
let mut stream = AudioStreamDecoder::new();
stream.push(&file).expect("the whole file at once");
assert_eq!(stream.container(), Some(Container::Wav));
stream.reset();
assert_eq!(stream.container(), None);
assert_eq!(stream.spec(), None);
assert_eq!(stream.buffered_bytes(), 0);
}
}