use crate::audio::{AudioBuffer, AudioSpec};
use crate::codec::{CodecId, FourCc};
use crate::error::DecodeError;
use crate::g711::G711Law;
use crate::payload::Payload;
use crate::riff::{self, ChunkWalker};
use crate::sample::SampleFormat;
use crate::source::StreamSource;
const TAG_PCM: u16 = 1;
const TAG_FLOAT: u16 = 3;
const TAG_ALAW: u16 = 6;
const TAG_MULAW: u16 = 7;
const TAG_EXTENSIBLE: u16 = 0xFFFE;
const SUBFORMAT_TAIL: [u8; 14] = [
0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71,
];
const FMT_BYTES_PLAIN: u64 = 16;
const FMT_BYTES_EXTENSIBLE: u64 = 40;
const MAX_FMT_BYTES: u64 = 18 + u16::MAX as u64;
const DS64_BODY_BYTES: u64 = 28;
const READY_LIMIT: usize = 65_536;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum WavCodec {
PcmU8,
PcmI16,
PcmI24,
PcmI32,
Float32,
Float64,
ALaw,
MuLaw,
}
impl WavCodec {
pub fn resolve(tag: u16, bits_per_sample: u16) -> Result<Self, DecodeError> {
match (tag, bits_per_sample) {
(TAG_PCM, 8) => Ok(Self::PcmU8),
(TAG_PCM, 16) => Ok(Self::PcmI16),
(TAG_PCM, 24) => Ok(Self::PcmI24),
(TAG_PCM, 32) => Ok(Self::PcmI32),
(TAG_FLOAT, 32) => Ok(Self::Float32),
(TAG_FLOAT, 64) => Ok(Self::Float64),
(TAG_ALAW, 8) => Ok(Self::ALaw),
(TAG_MULAW, 8) => Ok(Self::MuLaw),
(TAG_PCM | TAG_FLOAT | TAG_ALAW | TAG_MULAW, _) => {
Err(DecodeError::UnsupportedSampleFormat {
format: CodecId::WaveFormatTag(tag),
bits_per_sample,
})
}
_ => Err(DecodeError::UnsupportedCodec {
codec: CodecId::WaveFormatTag(tag),
}),
}
}
pub const fn format_tag(self) -> u16 {
match self {
Self::PcmU8 | Self::PcmI16 | Self::PcmI24 | Self::PcmI32 => TAG_PCM,
Self::Float32 | Self::Float64 => TAG_FLOAT,
Self::ALaw => TAG_ALAW,
Self::MuLaw => TAG_MULAW,
}
}
pub const fn bits_per_sample(self) -> u16 {
match self {
Self::PcmU8 | Self::ALaw | Self::MuLaw => 8,
Self::PcmI16 => 16,
Self::PcmI24 => 24,
Self::PcmI32 | Self::Float32 => 32,
Self::Float64 => 64,
}
}
pub const fn bytes_per_sample(self) -> usize {
match self {
Self::PcmU8 | Self::ALaw | Self::MuLaw => 1,
Self::PcmI16 => 2,
Self::PcmI24 => 3,
Self::PcmI32 | Self::Float32 => 4,
Self::Float64 => 8,
}
}
pub const fn sample_format(self) -> Option<SampleFormat> {
match self {
Self::PcmU8 => Some(SampleFormat::U8),
Self::PcmI16 => Some(SampleFormat::I16Le),
Self::PcmI24 => Some(SampleFormat::I24Le),
Self::PcmI32 => Some(SampleFormat::I32Le),
Self::Float32 => Some(SampleFormat::F32Le),
Self::Float64 => Some(SampleFormat::F64Le),
Self::ALaw | Self::MuLaw => None,
}
}
pub const fn law(self) -> Option<G711Law> {
match self {
Self::ALaw => Some(G711Law::ALaw),
Self::MuLaw => Some(G711Law::MuLaw),
_ => None,
}
}
pub fn decode(self, bytes: &[u8], output: &mut Vec<f32>) -> usize {
match (self.sample_format(), self.law()) {
(Some(format), _) => format.decode(bytes, output),
(_, Some(law)) => law.decode(bytes, output),
_ => 0,
}
}
pub fn encode(self, samples: &[f32], output: &mut Vec<u8>) -> usize {
match (self.sample_format(), self.law()) {
(Some(format), _) => format.encode(samples, output),
(_, Some(law)) => law.encode(samples, output),
_ => 0,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub struct WavFormat {
pub spec: AudioSpec,
pub codec: WavCodec,
pub format_tag: u16,
pub bits_per_sample: u16,
pub block_align: u16,
pub byte_rate: u32,
}
impl WavFormat {
pub const fn frame_bytes(&self) -> usize {
self.spec.channels as usize * self.codec.bytes_per_sample()
}
pub const fn is_extensible(&self) -> bool {
self.format_tag == TAG_EXTENSIBLE
}
}
fn check_fmt_size(size: u64, offset: u64) -> Result<(), DecodeError> {
if size < FMT_BYTES_PLAIN {
return Err(DecodeError::Malformed {
expected: "a fmt chunk of at least 16 bytes",
offset,
});
}
if size > MAX_FMT_BYTES {
return Err(DecodeError::Malformed {
expected: "a fmt chunk of at most 65553 bytes, which is all cbSize can count",
offset,
});
}
Ok(())
}
fn format_guid(guid: &[u8; 16]) -> String {
const HEX: [u8; 16] = *b"0123456789abcdef";
let data1 = u32::from_le_bytes([guid[0], guid[1], guid[2], guid[3]]);
let data2 = u16::from_le_bytes([guid[4], guid[5]]);
let data3 = u16::from_le_bytes([guid[6], guid[7]]);
let mut text = format!("{data1:08x}-{data2:04x}-{data3:04x}-");
for (index, byte) in guid[8..].iter().enumerate() {
if index == 2 {
text.push('-');
}
text.push(HEX[usize::from(byte >> 4)] as char);
text.push(HEX[usize::from(byte & 0x0F)] as char);
}
text
}
fn parse_fmt(body: &[u8], offset: u64) -> Result<WavFormat, DecodeError> {
let body_at = offset + riff::CHUNK_HEADER_BYTES;
let (
Some(declared_tag),
Some(channels),
Some(sample_rate),
Some(byte_rate),
Some(block_align),
Some(bits_per_sample),
) = (
riff::u16_at(body, 0),
riff::u16_at(body, 2),
riff::u32_at(body, 4),
riff::u32_at(body, 8),
riff::u16_at(body, 12),
riff::u16_at(body, 14),
)
else {
return Err(DecodeError::Malformed {
expected: "a fmt chunk of at least 16 bytes",
offset,
});
};
if channels == 0 {
return Err(DecodeError::UnsupportedChannelLayout { channels });
}
if sample_rate == 0 {
return Err(DecodeError::Malformed {
expected: "a non-zero sample rate",
offset: body_at + 4,
});
}
let tag = if declared_tag == TAG_EXTENSIBLE {
resolve_subformat(body, body_at)?
} else {
declared_tag
};
Ok(WavFormat {
spec: AudioSpec::new(sample_rate, channels),
codec: WavCodec::resolve(tag, bits_per_sample)?,
format_tag: declared_tag,
bits_per_sample,
block_align,
byte_rate,
})
}
fn resolve_subformat(body: &[u8], body_at: u64) -> Result<u16, DecodeError> {
const MIN_EXTENSION: u16 = 22;
let inconsistent = DecodeError::Malformed {
expected: "a 22-byte WAVE_FORMAT_EXTENSIBLE extension after cbSize",
offset: body_at + 16,
};
let Some(cb_size) = riff::u16_at(body, 16) else {
return Err(inconsistent);
};
if cb_size < MIN_EXTENSION {
return Err(inconsistent);
}
let Some(guid) = body.get(24..40) else {
return Err(inconsistent);
};
let mut bytes = [0u8; 16];
bytes.copy_from_slice(guid);
if bytes[2..] == SUBFORMAT_TAIL {
Ok(u16::from_le_bytes([bytes[0], bytes[1]]))
} else {
Err(DecodeError::UnsupportedCodec {
codec: CodecId::Name(format_guid(&bytes)),
})
}
}
fn check_whole_frames(data_len: u64, frame_bytes: usize) -> Result<(), DecodeError> {
let remainder = data_len % frame_bytes as u64;
if remainder != 0 {
return Err(DecodeError::Truncated {
expected: frame_bytes as u64,
available: remainder,
});
}
Ok(())
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct WavReader<'a> {
format: WavFormat,
data: &'a [u8],
rf64: bool,
}
impl<'a> WavReader<'a> {
pub fn new(bytes: &'a [u8]) -> Result<Self, DecodeError> {
let header = riff::read_riff_header(bytes)?;
if header.form != riff::WAVE {
return Err(DecodeError::UnsupportedContainer { tag: header.form });
}
let mut walker = ChunkWalker::new(bytes, riff::ByteOrder::Little);
let rf64 = header.magic == riff::RF64;
if rf64 {
let Some(first) = walker.next().transpose()? else {
return Err(DecodeError::Truncated {
expected: riff::HEADER_BYTES + riff::CHUNK_HEADER_BYTES,
available: bytes.len() as u64,
});
};
if first.id != riff::DS64 {
return Err(DecodeError::Malformed {
expected: "a ds64 chunk immediately after the RF64 form type",
offset: first.offset,
});
}
if first.body.len() as u64 > riff::MAX_DS64_BYTES {
return Err(DecodeError::Malformed {
expected: "a ds64 chunk of at most 65536 bytes",
offset: first.offset,
});
}
walker.set_overrides(riff::parse_ds64(first.body, first.offset)?);
}
let mut format: Option<WavFormat> = None;
let mut data: Option<&[u8]> = None;
while format.is_none() || data.is_none() {
let Some(chunk) = walker.next().transpose()? else {
break;
};
if chunk.id == riff::FMT && format.is_none() {
check_fmt_size(chunk.body.len() as u64, chunk.offset)?;
format = Some(parse_fmt(chunk.body, chunk.offset)?);
} else if chunk.id == riff::DATA && data.is_none() {
data = Some(chunk.body);
}
}
let Some(format) = format else {
return Err(DecodeError::Malformed {
expected: "a fmt chunk",
offset: riff::HEADER_BYTES,
});
};
let Some(data) = data else {
return Err(DecodeError::Malformed {
expected: "a data chunk",
offset: riff::HEADER_BYTES,
});
};
check_whole_frames(data.len() as u64, format.frame_bytes())?;
Ok(Self { format, data, rf64 })
}
pub const fn format(&self) -> &WavFormat {
&self.format
}
pub const fn spec(&self) -> AudioSpec {
self.format.spec
}
pub const fn data(&self) -> &'a [u8] {
self.data
}
pub const fn frames(&self) -> u64 {
self.data.len() as u64 / self.format.frame_bytes() as u64
}
pub const fn is_rf64(&self) -> bool {
self.rf64
}
pub fn decode(&self, output: &mut Vec<f32>) -> usize {
self.format.codec.decode(self.data, output)
}
pub fn decode_to_end(&self) -> AudioBuffer {
let mut samples =
Vec::with_capacity(self.data.len() / self.format.codec.bytes_per_sample());
self.decode(&mut samples);
AudioBuffer::from_samples(self.format.spec, samples)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum State {
Riff,
ChunkHeader,
Body {
id: FourCc,
size: usize,
offset: u64,
},
Skip { size: u64, left: u64 },
Pad,
Data,
Done,
}
#[derive(Debug)]
pub struct WavStreamDecoder {
state: State,
pending: Vec<u8>,
offset: u64,
overrides: Vec<(FourCc, u64)>,
expect_ds64: bool,
format: Option<WavFormat>,
payload: Option<Payload>,
ready: Vec<f32>,
ready_read: usize,
data_size: u64,
data_left: u64,
finished: bool,
}
impl Default for WavStreamDecoder {
fn default() -> Self {
Self::new()
}
}
impl WavStreamDecoder {
pub fn new() -> Self {
Self {
state: State::Riff,
pending: Vec::new(),
offset: 0,
overrides: Vec::new(),
expect_ds64: false,
format: None,
payload: None,
ready: Vec::new(),
ready_read: 0,
data_size: 0,
data_left: 0,
finished: false,
}
}
pub const fn format(&self) -> Option<WavFormat> {
self.format
}
pub fn ready_samples(&self) -> usize {
self.ready.len() - self.ready_read
}
fn accumulate(&mut self, bytes: &[u8], need: usize, taken: &mut usize) -> bool {
let want = need.saturating_sub(self.pending.len()).min(bytes.len());
self.pending.extend_from_slice(&bytes[..want]);
*taken += want;
self.offset += want as u64;
self.pending.len() >= need
}
fn start_file(&mut self) -> Result<(), DecodeError> {
let header = riff::read_riff_header(&self.pending)?;
if header.form != riff::WAVE {
return Err(DecodeError::UnsupportedContainer { tag: header.form });
}
self.expect_ds64 = header.magic == riff::RF64;
self.pending.clear();
self.state = State::ChunkHeader;
Ok(())
}
fn start_chunk(&mut self) -> Result<(), DecodeError> {
let offset = self.offset - riff::CHUNK_HEADER_BYTES;
let (Some(id), Some(declared)) = (
riff::four_cc_at(&self.pending, 0),
riff::u32_at(&self.pending, 4),
) else {
return Err(DecodeError::Truncated {
expected: riff::CHUNK_HEADER_BYTES,
available: self.pending.len() as u64,
});
};
self.pending.clear();
let size = riff::resolve_size(&self.overrides, id, declared);
if self.expect_ds64 && id != riff::DS64 {
return Err(DecodeError::Malformed {
expected: "a ds64 chunk immediately after the RF64 form type",
offset,
});
}
if id == riff::DS64 && self.expect_ds64 {
if size > riff::MAX_DS64_BYTES {
return Err(DecodeError::Malformed {
expected: "a ds64 chunk of at most 65536 bytes",
offset,
});
}
self.state = State::Body {
id,
size: size as usize,
offset,
};
return Ok(());
}
if id == riff::FMT && self.format.is_none() {
check_fmt_size(size, offset)?;
self.state = State::Body {
id,
size: size as usize,
offset,
};
return Ok(());
}
if id == riff::DATA {
let Some(format) = self.format else {
return Err(DecodeError::Malformed {
expected: "a fmt chunk before the data chunk",
offset,
});
};
check_whole_frames(size, format.frame_bytes())?;
self.payload = Some(Payload::from_parts(
format.codec.sample_format(),
format.codec.law(),
format.spec,
));
self.data_size = size;
self.data_left = size;
self.state = if size == 0 { State::Done } else { State::Data };
return Ok(());
}
self.state = if size == 0 {
State::ChunkHeader
} else {
State::Skip { size, left: size }
};
Ok(())
}
fn finish_body(&mut self, id: FourCc, size: usize, offset: u64) -> Result<(), DecodeError> {
if id == riff::FMT {
self.format = Some(parse_fmt(&self.pending, offset)?);
} else {
self.overrides = riff::parse_ds64(&self.pending, offset)?;
self.expect_ds64 = false;
}
self.pending.clear();
self.state = if riff::pad_len(size as u64) == 1 {
State::Pad
} else {
State::ChunkHeader
};
Ok(())
}
fn drain_payload(&mut self) -> Result<(), DecodeError> {
if let Some(payload) = self.payload.as_mut() {
payload.decode(&mut self.ready)?;
}
Ok(())
}
}
impl StreamSource for WavStreamDecoder {
fn push(&mut self, bytes: &[u8]) -> Result<usize, DecodeError> {
if self.finished {
return Ok(0);
}
let mut taken = 0;
let result = self.push_inner(bytes, &mut taken);
if result.is_err() {
self.finished = true;
}
result.map(|()| taken)
}
fn pull(&mut self, output: &mut Vec<f32>, max_frames: usize) -> Result<usize, DecodeError> {
let Some(format) = self.format else {
return Ok(0);
};
let channels = usize::from(format.spec.channels);
let available = self.ready.len() - self.ready_read;
let frames = (available / channels).min(max_frames);
let count = frames * channels;
output.extend_from_slice(&self.ready[self.ready_read..self.ready_read + count]);
self.ready_read += count;
if self.ready_read == self.ready.len() {
self.ready.clear();
self.ready_read = 0;
} else if self.ready_read >= self.ready.len() / 2 {
self.ready.drain(..self.ready_read);
self.ready_read = 0;
}
Ok(frames)
}
fn spec(&self) -> Option<AudioSpec> {
self.format.map(|format| format.spec)
}
fn buffered_bytes(&self) -> usize {
self.pending.len()
+ self
.payload
.as_ref()
.map_or(0, |payload| payload.buffered_bytes())
}
fn finish(&mut self, output: &mut Vec<f32>) -> Result<usize, DecodeError> {
if self.finished {
return Ok(0);
}
self.finished = true;
match self.state {
State::Done => {}
State::Riff => {
return Err(DecodeError::Truncated {
expected: riff::HEADER_BYTES,
available: self.pending.len() as u64,
})
}
State::Pad => {
return Err(DecodeError::Malformed {
expected: "a data chunk",
offset: self.offset,
})
}
State::ChunkHeader if self.pending.is_empty() => {
return Err(DecodeError::Malformed {
expected: "a data chunk",
offset: self.offset,
})
}
State::ChunkHeader => {
return Err(DecodeError::Truncated {
expected: riff::CHUNK_HEADER_BYTES,
available: self.pending.len() as u64,
})
}
State::Body { size, .. } => {
return Err(DecodeError::Truncated {
expected: size as u64,
available: self.pending.len() as u64,
})
}
State::Skip { size, left } => {
return Err(DecodeError::Truncated {
expected: size,
available: size - left,
})
}
State::Data => {
return Err(DecodeError::Truncated {
expected: self.data_size,
available: self.data_size - self.data_left,
})
}
}
if let Some(payload) = self.payload.as_mut() {
payload.flush(&mut self.ready)?;
}
let Some(format) = self.format else {
return Ok(0);
};
let channels = usize::from(format.spec.channels);
let frames = (self.ready.len() - self.ready_read) / channels;
output.extend_from_slice(&self.ready[self.ready_read..self.ready_read + frames * channels]);
self.ready.clear();
self.ready_read = 0;
Ok(frames)
}
fn reset(&mut self) {
*self = Self::new();
}
}
impl WavStreamDecoder {
fn push_inner(&mut self, bytes: &[u8], taken: &mut usize) -> Result<(), DecodeError> {
while *taken < bytes.len() {
let rest = &bytes[*taken..];
match self.state {
State::Riff => {
if !self.accumulate(rest, riff::HEADER_BYTES as usize, taken) {
break;
}
self.start_file()?;
}
State::ChunkHeader => {
if !self.accumulate(rest, riff::CHUNK_HEADER_BYTES as usize, taken) {
break;
}
self.start_chunk()?;
}
State::Body { id, size, offset } => {
if !self.accumulate(rest, size, taken) {
break;
}
self.finish_body(id, size, offset)?;
}
State::Skip { size, left } => {
let step = left.min(rest.len() as u64);
*taken += step as usize;
self.offset += step;
let left = left - step;
self.state = if left == 0 {
if riff::pad_len(size) == 1 {
State::Pad
} else {
State::ChunkHeader
}
} else {
State::Skip { size, left }
};
}
State::Pad => {
*taken += 1;
self.offset += 1;
self.state = State::ChunkHeader;
}
State::Data => {
if self.ready.len() - self.ready_read >= READY_LIMIT {
break;
}
let limit = self.data_left.min(rest.len() as u64) as usize;
let fed = match self.payload.as_mut() {
Some(payload) => payload.feed(&rest[..limit])?,
None => 0,
};
self.drain_payload()?;
*taken += fed;
self.offset += fed as u64;
self.data_left -= fed as u64;
if self.data_left == 0 {
self.state = State::Done;
} else if fed == 0 {
break;
}
}
State::Done => {
self.offset += (bytes.len() - *taken) as u64;
*taken = bytes.len();
}
}
}
Ok(())
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
#[non_exhaustive]
pub enum WavHeaderStyle {
#[default]
Plain,
Extensible,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
#[non_exhaustive]
pub enum RiffFlavour {
#[default]
Automatic,
Rf64,
}
fn needs_rf64(fmt_bytes: u64, data_bytes: u64) -> bool {
riff_size(fmt_bytes, data_bytes, false).is_none_or(|size| size > u64::from(u32::MAX))
}
fn riff_size(fmt_bytes: u64, data_bytes: u64, ds64: bool) -> Option<u64> {
let mut size: u64 = 4; if ds64 {
size = size.checked_add(riff::CHUNK_HEADER_BYTES + DS64_BODY_BYTES)?;
}
size = size
.checked_add(riff::CHUNK_HEADER_BYTES)?
.checked_add(fmt_bytes)?;
size = size
.checked_add(riff::CHUNK_HEADER_BYTES)?
.checked_add(data_bytes)?
.checked_add(data_bytes & 1)?;
Some(size)
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct WavWriter {
spec: AudioSpec,
codec: WavCodec,
header: WavHeaderStyle,
flavour: RiffFlavour,
}
impl WavWriter {
pub const fn new(spec: AudioSpec, codec: WavCodec) -> Self {
Self {
spec,
codec,
header: WavHeaderStyle::Plain,
flavour: RiffFlavour::Automatic,
}
}
pub const fn with_header_style(mut self, header: WavHeaderStyle) -> Self {
self.header = header;
self
}
pub const fn with_flavour(mut self, flavour: RiffFlavour) -> Self {
self.flavour = flavour;
self
}
pub const fn spec(&self) -> AudioSpec {
self.spec
}
pub const fn codec(&self) -> WavCodec {
self.codec
}
pub fn write(&self, samples: &[f32], output: &mut Vec<u8>) -> Result<usize, DecodeError> {
let channels = usize::from(self.spec.channels);
if channels == 0 {
return Err(DecodeError::UnsupportedChannelLayout {
channels: self.spec.channels,
});
}
let frame_bytes = channels * self.codec.bytes_per_sample();
let Ok(block_align) = u16::try_from(frame_bytes) else {
return Err(DecodeError::UnsupportedChannelLayout {
channels: self.spec.channels,
});
};
if self.spec.sample_rate == 0 {
return Err(DecodeError::Malformed {
expected: "a non-zero sample rate",
offset: riff::HEADER_BYTES + riff::CHUNK_HEADER_BYTES + 4,
});
}
let leftover = samples.len() % channels;
if leftover != 0 {
return Err(DecodeError::Truncated {
expected: frame_bytes as u64,
available: (leftover * self.codec.bytes_per_sample()) as u64,
});
}
let fmt_bytes = match self.header {
WavHeaderStyle::Plain => FMT_BYTES_PLAIN,
WavHeaderStyle::Extensible => FMT_BYTES_EXTENSIBLE,
};
let data_bytes = (samples.len() * self.codec.bytes_per_sample()) as u64;
let ds64 = match self.flavour {
RiffFlavour::Rf64 => true,
RiffFlavour::Automatic => needs_rf64(fmt_bytes, data_bytes),
};
let declared_riff = riff_size(fmt_bytes, data_bytes, ds64);
let start = output.len();
output.extend_from_slice(if ds64 {
riff::RF64.as_bytes()
} else {
riff::RIFF.as_bytes()
});
let riff_field = match (ds64, declared_riff) {
(true, _) => riff::SIZE_SENTINEL,
(false, Some(size)) => size as u32,
(false, None) => riff::SIZE_SENTINEL,
};
output.extend_from_slice(&riff_field.to_le_bytes());
output.extend_from_slice(riff::WAVE.as_bytes());
if ds64 {
output.extend_from_slice(riff::DS64.as_bytes());
output.extend_from_slice(&(DS64_BODY_BYTES as u32).to_le_bytes());
output.extend_from_slice(&declared_riff.unwrap_or(u64::MAX).to_le_bytes());
output.extend_from_slice(&data_bytes.to_le_bytes());
output.extend_from_slice(&((samples.len() / channels) as u64).to_le_bytes());
output.extend_from_slice(&0u32.to_le_bytes()); }
output.extend_from_slice(riff::FMT.as_bytes());
output.extend_from_slice(&(fmt_bytes as u32).to_le_bytes());
let tag = match self.header {
WavHeaderStyle::Extensible => TAG_EXTENSIBLE,
WavHeaderStyle::Plain => self.codec.format_tag(),
};
let bits = self.codec.bits_per_sample();
output.extend_from_slice(&tag.to_le_bytes());
output.extend_from_slice(&self.spec.channels.to_le_bytes());
output.extend_from_slice(&self.spec.sample_rate.to_le_bytes());
let byte_rate = u64::from(self.spec.sample_rate) * u64::from(block_align);
output.extend_from_slice(&(byte_rate.min(u64::from(u32::MAX)) as u32).to_le_bytes());
output.extend_from_slice(&block_align.to_le_bytes());
output.extend_from_slice(&bits.to_le_bytes());
if matches!(self.header, WavHeaderStyle::Extensible) {
output.extend_from_slice(&22u16.to_le_bytes()); output.extend_from_slice(&bits.to_le_bytes()); output.extend_from_slice(&0u32.to_le_bytes());
output.extend_from_slice(&self.codec.format_tag().to_le_bytes());
output.extend_from_slice(&SUBFORMAT_TAIL);
}
output.extend_from_slice(riff::DATA.as_bytes());
let data_field = if ds64 {
riff::SIZE_SENTINEL
} else {
data_bytes as u32
};
output.extend_from_slice(&data_field.to_le_bytes());
self.codec.encode(samples, output);
if riff::pad_len(data_bytes) == 1 {
output.push(0);
}
Ok(output.len() - start)
}
pub fn to_bytes(&self, samples: &[f32]) -> Result<Vec<u8>, DecodeError> {
let mut output = Vec::new();
self.write(samples, &mut output)?;
Ok(output)
}
}
#[cfg(test)]
mod tests {
use super::*;
pub(crate) const ALL: [WavCodec; 8] = [
WavCodec::PcmU8,
WavCodec::PcmI16,
WavCodec::PcmI24,
WavCodec::PcmI32,
WavCodec::Float32,
WavCodec::Float64,
WavCodec::ALaw,
WavCodec::MuLaw,
];
#[test]
fn all_lists_every_codec() {
for codec in ALL {
match codec {
WavCodec::PcmU8
| WavCodec::PcmI16
| WavCodec::PcmI24
| WavCodec::PcmI32
| WavCodec::Float32
| WavCodec::Float64
| WavCodec::ALaw
| WavCodec::MuLaw => {}
}
}
assert_eq!(ALL.len(), 8);
}
#[test]
fn dispatch_is_on_the_tag_and_the_width_together() {
let accepted: [(u16, u16, WavCodec); 8] = [
(1, 8, WavCodec::PcmU8),
(1, 16, WavCodec::PcmI16),
(1, 24, WavCodec::PcmI24),
(1, 32, WavCodec::PcmI32),
(3, 32, WavCodec::Float32),
(3, 64, WavCodec::Float64),
(6, 8, WavCodec::ALaw),
(7, 8, WavCodec::MuLaw),
];
for (tag, bits, codec) in accepted {
assert_eq!(WavCodec::resolve(tag, bits).expect("accepted"), codec);
assert_eq!(codec.format_tag(), tag);
assert_eq!(codec.bits_per_sample(), bits);
}
for (tag, bits) in [
(1u16, 4u16),
(1, 12),
(1, 20),
(1, 64),
(3, 16),
(6, 16),
(7, 4),
] {
let error = WavCodec::resolve(tag, bits).expect_err("must reject");
assert!(
matches!(
&error,
DecodeError::UnsupportedSampleFormat { format, bits_per_sample }
if *format == CodecId::WaveFormatTag(tag) && *bits_per_sample == bits
),
"({tag}, {bits}): unexpected error: {error}"
);
}
for tag in [0u16, 2, 0x11, 0x31, 0x50, 0x161, 0xFFFE] {
let error = WavCodec::resolve(tag, 16).expect_err("must reject");
assert!(
matches!(&error, DecodeError::UnsupportedCodec { codec }
if *codec == CodecId::WaveFormatTag(tag)),
"tag {tag:#x}: unexpected error: {error}"
);
}
}
#[test]
fn each_width_of_tag_one_has_its_own_stride() {
let widths: [(u16, usize); 4] = [(8, 1), (16, 2), (24, 3), (32, 4)];
for (bits, bytes) in widths {
let codec = WavCodec::resolve(1, bits).expect("accepted");
assert_eq!(codec.bytes_per_sample(), bytes, "{bits} bits");
let mut out = Vec::new();
assert_eq!(codec.decode(&[0u8; 24], &mut out), 24 / bytes);
}
}
#[test]
fn every_codec_is_linear_or_companded_and_never_both() {
for codec in ALL {
assert_ne!(
codec.sample_format().is_some(),
codec.law().is_some(),
"{codec:?} is on both sides or neither"
);
if let Some(format) = codec.sample_format() {
assert_eq!(format.bytes_per_sample(), codec.bytes_per_sample());
assert_eq!(format.bits_per_sample(), codec.bits_per_sample());
} else {
assert_eq!(codec.bytes_per_sample(), 1);
}
}
}
#[test]
fn a_guid_is_reported_in_the_form_it_is_documented_in() {
let mut pcm = [0u8; 16];
pcm[0] = 1;
pcm[2..].copy_from_slice(&SUBFORMAT_TAIL);
assert_eq!(format_guid(&pcm), "00000001-0000-0010-8000-00aa00389b71");
let ambisonic = [
0x01, 0x00, 0x00, 0x00, 0x21, 0x07, 0xd3, 0x11, 0x86, 0x44, 0xc8, 0xc1, 0xca, 0x00,
0x00, 0x00,
];
assert_eq!(
format_guid(&ambisonic),
"00000001-0721-11d3-8644-c8c1ca000000"
);
}
fn fmt_body(tag: u16, channels: u16, rate: u32, bits: u16, extension: &[u8]) -> Vec<u8> {
let block_align = channels * bits.div_ceil(8);
let mut body = Vec::new();
body.extend_from_slice(&tag.to_le_bytes());
body.extend_from_slice(&channels.to_le_bytes());
body.extend_from_slice(&rate.to_le_bytes());
body.extend_from_slice(&(rate * u32::from(block_align)).to_le_bytes());
body.extend_from_slice(&block_align.to_le_bytes());
body.extend_from_slice(&bits.to_le_bytes());
body.extend_from_slice(extension);
body
}
fn extension(tag: u16, cb_size: u16) -> Vec<u8> {
let mut bytes = Vec::new();
bytes.extend_from_slice(&cb_size.to_le_bytes());
bytes.extend_from_slice(&16u16.to_le_bytes()); bytes.extend_from_slice(&0u32.to_le_bytes()); bytes.extend_from_slice(&tag.to_le_bytes());
bytes.extend_from_slice(&SUBFORMAT_TAIL);
bytes
}
#[test]
fn an_extensible_header_resolves_through_its_subformat_guid() {
for (tag, bits, codec) in [
(1u16, 16u16, WavCodec::PcmI16),
(1, 24, WavCodec::PcmI24),
(3, 32, WavCodec::Float32),
(6, 8, WavCodec::ALaw),
(7, 8, WavCodec::MuLaw),
] {
let body = fmt_body(TAG_EXTENSIBLE, 2, 48_000, bits, &extension(tag, 22));
let format = parse_fmt(&body, 12).expect("extensible header");
assert_eq!(format.codec, codec);
assert_eq!(format.format_tag, TAG_EXTENSIBLE);
assert!(format.is_extensible());
}
}
#[test]
fn an_inconsistent_cb_size_is_malformed_rather_than_read_past() {
for cb_size in [0u16, 1, 21] {
let body = fmt_body(TAG_EXTENSIBLE, 1, 8_000, 16, &extension(1, cb_size));
let error = parse_fmt(&body, 12).expect_err("must reject");
assert!(
matches!(
error,
DecodeError::Malformed {
expected: "a 22-byte WAVE_FORMAT_EXTENSIBLE extension after cbSize",
..
}
),
"cbSize {cb_size}: unexpected error: {error}"
);
}
for truncate_to in [16usize, 18, 24, 39] {
let mut body = fmt_body(TAG_EXTENSIBLE, 1, 8_000, 16, &extension(1, 22));
body.truncate(truncate_to);
let error = parse_fmt(&body, 12).expect_err("must reject");
assert!(
matches!(error, DecodeError::Malformed { .. }),
"{truncate_to} bytes: unexpected error: {error}"
);
}
}
#[test]
fn an_unrecognised_subformat_guid_is_reported_as_the_guid_it_was() {
let mut ext = extension(1, 22);
ext[10] = 0xAB;
let body = fmt_body(TAG_EXTENSIBLE, 1, 8_000, 16, &ext);
let error = parse_fmt(&body, 12).expect_err("must reject");
match error {
DecodeError::UnsupportedCodec {
codec: CodecId::Name(name),
} => assert_eq!(name, "00ab0001-0000-0010-8000-00aa00389b71"),
other => panic!("unexpected error: {other}"),
}
}
#[test]
fn an_extensible_header_naming_an_unsupported_codec_reports_the_resolved_tag() {
let body = fmt_body(TAG_EXTENSIBLE, 1, 8_000, 4, &extension(0x0011, 22));
let error = parse_fmt(&body, 12).expect_err("must reject");
assert!(
matches!(&error, DecodeError::UnsupportedCodec { codec }
if *codec == CodecId::WaveFormatTag(0x0011)),
"unexpected error: {error}"
);
}
#[test]
fn a_zero_channel_count_is_an_unsupported_layout() {
let body = fmt_body(1, 0, 8_000, 16, &[]);
let error = parse_fmt(&body, 12).expect_err("must reject");
assert!(
matches!(error, DecodeError::UnsupportedChannelLayout { channels: 0 }),
"unexpected error: {error}"
);
}
#[test]
fn a_zero_sample_rate_is_malformed_and_names_where_it_was() {
let body = fmt_body(1, 1, 0, 16, &[]);
let error = parse_fmt(&body, 12).expect_err("must reject");
assert!(
matches!(
error,
DecodeError::Malformed {
expected: "a non-zero sample rate",
offset: 24
}
),
"unexpected error: {error}"
);
}
#[test]
fn a_fmt_chunk_size_outside_what_waveformatex_can_mean_is_malformed() {
for size in [0u64, 1, 15] {
assert!(check_fmt_size(size, 12).is_err(), "{size} bytes accepted");
}
for size in [16u64, 18, 40, MAX_FMT_BYTES] {
assert!(check_fmt_size(size, 12).is_ok(), "{size} bytes rejected");
}
assert_eq!(MAX_FMT_BYTES, 65_553);
assert!(check_fmt_size(MAX_FMT_BYTES + 1, 12).is_err());
}
#[test]
fn a_block_align_that_disagrees_with_the_format_does_not_stop_the_decode() {
let mut body = fmt_body(1, 2, 44_100, 16, &[]);
body[12..14].copy_from_slice(&999u16.to_le_bytes());
let format = parse_fmt(&body, 12).expect("advisory field");
assert_eq!(format.block_align, 999, "the declaration is kept");
assert_eq!(format.frame_bytes(), 4, "and the frame size is computed");
}
#[test]
fn a_data_length_that_is_not_whole_frames_is_truncated() {
assert!(check_whole_frames(8, 4).is_ok());
for (len, remainder) in [(9u64, 1u64), (10, 2), (11, 3), (1, 1)] {
let error = check_whole_frames(len, 4).expect_err("must reject");
assert!(
matches!(error, DecodeError::Truncated { expected: 4, available }
if available == remainder),
"{len} bytes: unexpected error: {error}"
);
}
assert!(check_whole_frames(0, 4).is_ok());
}
#[test]
fn the_rf64_upgrade_happens_exactly_at_the_riff_size_limit() {
const OVERHEAD: u64 =
4 + riff::CHUNK_HEADER_BYTES + FMT_BYTES_PLAIN + riff::CHUNK_HEADER_BYTES;
assert_eq!(OVERHEAD, 36);
let ceiling = u64::from(u32::MAX);
let largest = ceiling - OVERHEAD - 1;
assert_eq!(largest % 2, 0);
assert_eq!(
riff_size(FMT_BYTES_PLAIN, largest, false),
Some(ceiling - 1)
);
assert!(
!needs_rf64(FMT_BYTES_PLAIN, largest),
"the last fitting size"
);
assert!(needs_rf64(FMT_BYTES_PLAIN, largest + 1), "one byte past it");
assert!(needs_rf64(FMT_BYTES_PLAIN, largest + 2));
assert_eq!(
riff_size(FMT_BYTES_PLAIN, largest - 1, false),
Some(ceiling - 1)
);
assert!(!needs_rf64(FMT_BYTES_PLAIN, largest - 1));
assert!(needs_rf64(FMT_BYTES_EXTENSIBLE, largest));
assert!(!needs_rf64(FMT_BYTES_EXTENSIBLE, largest - 24));
assert!(needs_rf64(FMT_BYTES_EXTENSIBLE, largest - 23));
assert!(!needs_rf64(FMT_BYTES_PLAIN, 0));
assert!(!needs_rf64(FMT_BYTES_PLAIN, 1_000_000));
}
#[test]
fn the_riff_size_field_counts_everything_after_the_first_eight_bytes() {
assert_eq!(riff_size(FMT_BYTES_PLAIN, 4, false), Some(40));
assert_eq!(riff_size(FMT_BYTES_PLAIN, 5, false), Some(42));
assert_eq!(riff_size(FMT_BYTES_PLAIN, 4, true), Some(76));
}
#[test]
fn the_writer_rejects_a_partial_trailing_frame() {
let writer = WavWriter::new(AudioSpec::new(48_000, 3), WavCodec::PcmI16);
let error = writer.to_bytes(&[0.0; 7]).expect_err("must reject");
assert!(
matches!(
error,
DecodeError::Truncated {
expected: 6,
available: 2
}
),
"unexpected error: {error}"
);
assert!(writer.to_bytes(&[0.0; 6]).is_ok());
assert!(writer.to_bytes(&[0.0; 9]).is_ok());
}
#[test]
fn the_writer_rejects_what_the_header_cannot_express() {
let no_channels = WavWriter::new(AudioSpec::new(48_000, 0), WavCodec::PcmI16);
assert!(matches!(
no_channels.to_bytes(&[]),
Err(DecodeError::UnsupportedChannelLayout { channels: 0 })
));
let no_rate = WavWriter::new(AudioSpec::mono(0), WavCodec::PcmI16);
assert!(matches!(
no_rate.to_bytes(&[]),
Err(DecodeError::Malformed {
expected: "a non-zero sample rate",
..
})
));
let too_wide = WavWriter::new(AudioSpec::new(48_000, 8_192), WavCodec::Float64);
assert!(matches!(
too_wide.to_bytes(&[]),
Err(DecodeError::UnsupportedChannelLayout { channels: 8_192 })
));
let widest = WavWriter::new(AudioSpec::new(48_000, 8_191), WavCodec::Float64);
assert!(widest.to_bytes(&[]).is_ok());
}
#[test]
fn the_writer_appends_rather_than_clearing() {
let writer = WavWriter::new(AudioSpec::mono(8_000), WavCodec::PcmU8);
let mut output = vec![0xAA];
let written = writer.write(&[0.0, 0.0], &mut output).expect("write");
assert_eq!(output[0], 0xAA);
assert_eq!(output.len(), 1 + written);
assert_eq!(written, 12 + 8 + 16 + 8 + 2);
}
}