use crate::audio::AudioSpec;
use crate::decoder::Decoder;
use crate::error::DecodeError;
use crate::sample::{f32_to_i16, i16_to_f32};
const READY_LIMIT: usize = 65_536;
const MU_BIAS: i32 = 33;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum G711Law {
MuLaw,
ALaw,
}
impl G711Law {
pub const fn code_to_linear(self, code: u8) -> i16 {
match self {
Self::MuLaw => mu_law_to_linear(code),
Self::ALaw => a_law_to_linear(code),
}
}
pub const fn linear_to_code(self, sample: i16) -> u8 {
match self {
Self::MuLaw => linear_to_mu_law(sample),
Self::ALaw => linear_to_a_law(sample),
}
}
pub fn decode(self, codes: &[u8], output: &mut Vec<f32>) -> usize {
output.reserve(codes.len());
for &code in codes {
output.push(i16_to_f32(self.code_to_linear(code)));
}
codes.len()
}
pub fn encode(self, samples: &[f32], output: &mut Vec<u8>) -> usize {
output.reserve(samples.len());
for &sample in samples {
output.push(self.linear_to_code(f32_to_i16(sample)));
}
samples.len()
}
}
const fn mu_law_to_linear(code: u8) -> i16 {
let value = !code;
let negative = value & 0x80 != 0;
let segment = ((value >> 4) & 0x07) as i32;
let interval = (value & 0x0F) as i32;
let start = 1_i32 << (segment + 5);
let step = 1_i32 << (segment + 1);
let magnitude = start + step * interval + step / 2 - MU_BIAS;
let linear = magnitude * 4;
if negative {
(-linear) as i16
} else {
linear as i16
}
}
const fn linear_to_mu_law(sample: i16) -> u8 {
let sample = sample as i32;
let negative = sample < 0;
let magnitude = if negative {
-(sample >> 2)
} else {
sample >> 2
};
let biased = magnitude + MU_BIAS;
let biased = if biased > 0x1FFF { 0x1FFF } else { biased };
let segment = biased.ilog2() as i32 - 5;
let start = 1_i32 << (segment + 5);
let step = 1_i32 << (segment + 1);
let interval = (biased - start) / step;
let word = if negative { 0x80_u8 } else { 0 } | ((segment as u8) << 4) | interval as u8;
!word
}
const fn a_law_to_linear(code: u8) -> i16 {
let value = code ^ 0x55;
let positive = value & 0x80 != 0;
let segment = ((value >> 4) & 0x07) as i32;
let interval = (value & 0x0F) as i32;
let start = if segment == 0 {
0
} else {
1_i32 << (segment + 4)
};
let step = if segment == 0 { 2 } else { 1_i32 << segment };
let magnitude = start + step * interval + step / 2;
let linear = magnitude * 8;
if positive {
linear as i16
} else {
(-linear) as i16
}
}
const fn linear_to_a_law(sample: i16) -> u8 {
let sample = sample as i32;
let positive = sample >= 0;
let magnitude = if positive {
sample >> 3
} else {
(-1 - sample) >> 3
};
let segment = if magnitude < 32 {
0
} else {
magnitude.ilog2() as i32 - 4
};
let start = if segment == 0 {
0
} else {
1_i32 << (segment + 4)
};
let step = if segment == 0 { 2 } else { 1_i32 << segment };
let interval = (magnitude - start) / step;
let word = if positive { 0x80_u8 } else { 0 } | ((segment as u8) << 4) | interval as u8;
word ^ 0x55
}
#[derive(Debug)]
pub struct G711Decoder {
law: G711Law,
spec: AudioSpec,
ready: Vec<f32>,
produced: u64,
finished: bool,
}
impl G711Decoder {
pub const fn new(law: G711Law, spec: AudioSpec) -> Self {
Self {
law,
spec,
ready: Vec::new(),
produced: 0,
finished: false,
}
}
pub const fn law(&self) -> G711Law {
self.law
}
pub fn buffered_bytes(&self) -> usize {
let channels = u64::from(self.spec.channels).max(1);
(self.produced % channels) as usize
}
fn frame_bytes(&self) -> usize {
usize::from(self.spec.channels).max(1)
}
}
impl Decoder for G711Decoder {
fn output_spec(&self) -> AudioSpec {
self.spec
}
fn feed(&mut self, input: &[u8]) -> Result<usize, DecodeError> {
if self.finished {
return Ok(0);
}
let room = READY_LIMIT.saturating_sub(self.ready.len());
let taken = input.len().min(room);
self.produced += self.law.decode(&input[..taken], &mut self.ready) as u64;
Ok(taken)
}
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;
let held = self.buffered_bytes();
if held > 0 {
return Err(DecodeError::Truncated {
expected: self.frame_bytes() as u64,
available: held as u64,
});
}
let produced = self.ready.len();
output.append(&mut self.ready);
Ok(produced)
}
fn reset(&mut self) {
self.ready.clear();
self.produced = 0;
self.finished = false;
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::audio::AudioBuffer;
const BOTH: [G711Law; 2] = [G711Law::MuLaw, G711Law::ALaw];
const A_LAW_SEGMENTS: [(i32, i32); 8] = [
(0, 2),
(32, 2),
(64, 4),
(128, 8),
(256, 16),
(512, 32),
(1024, 64),
(2048, 128),
];
const MU_LAW_SEGMENTS: [(i32, i32); 8] = [
(32, 2),
(64, 4),
(128, 8),
(256, 16),
(512, 32),
(1024, 64),
(2048, 128),
(4096, 256),
];
fn reference_decode(law: G711Law, code: u8) -> i16 {
let (segments, value) = match law {
G711Law::MuLaw => (MU_LAW_SEGMENTS, !code),
G711Law::ALaw => (A_LAW_SEGMENTS, code ^ 0x55),
};
let (start, step) = segments[usize::from((value >> 4) & 0x07)];
let interval = i32::from(value & 0x0F);
let midpoint = start + step * interval + step / 2;
let (magnitude, negative) = match law {
G711Law::MuLaw => ((midpoint - 33) * 4, value & 0x80 != 0),
G711Law::ALaw => (midpoint * 8, value & 0x80 == 0),
};
if negative {
-magnitude as i16
} else {
magnitude as i16
}
}
fn reference_input_range(law: G711Law, code: u8) -> Option<(i16, i16)> {
let (segments, value) = match law {
G711Law::MuLaw => (MU_LAW_SEGMENTS, !code),
G711Law::ALaw => (A_LAW_SEGMENTS, code ^ 0x55),
};
let segment = usize::from((value >> 4) & 0x07);
let interval = i32::from(value & 0x0F);
let (start, step) = segments[segment];
let positive = match law {
G711Law::MuLaw => value & 0x80 == 0,
G711Law::ALaw => value & 0x80 != 0,
};
let low = match law {
G711Law::MuLaw => start + step * interval - 33,
G711Law::ALaw => start + step * interval,
};
let high = low + step - 1;
let (mut lo, mut hi) = match (law, positive) {
(G711Law::MuLaw, true) => (low * 4, high * 4 + 3),
(G711Law::MuLaw, false) => (-(high * 4), -(low * 4) + 3),
(G711Law::ALaw, true) => (low * 8, high * 8 + 7),
(G711Law::ALaw, false) => (-(high * 8) - 8, -(low * 8) - 1),
};
if segment == 7 && interval == 15 {
if positive {
hi = i32::from(i16::MAX);
} else {
lo = i32::from(i16::MIN);
}
}
let (floor, ceiling) = if positive {
(0, i32::from(i16::MAX))
} else {
(i32::from(i16::MIN), -1)
};
let (lo, hi) = (lo.max(floor), hi.min(ceiling));
if lo > hi {
None
} else {
Some((lo as i16, hi as i16))
}
}
fn reference_encode_table(law: G711Law) -> Vec<u8> {
let mut table: Vec<Option<u8>> = vec![None; 65_536];
for code in 0..=u8::MAX {
let Some((lo, hi)) = reference_input_range(law, code) else {
continue;
};
for sample in lo..=hi {
let slot =
&mut table[usize::try_from(i32::from(sample) + 32_768).expect("in range")];
assert!(
slot.is_none(),
"{law:?}: {sample} is claimed by two codes, 0x{:02x} and 0x{code:02x}",
slot.unwrap_or_default()
);
*slot = Some(code);
}
}
table
.into_iter()
.enumerate()
.map(|(index, code)| {
code.unwrap_or_else(|| {
panic!("{law:?}: no code covers {}", index as i32 - 32_768);
})
})
.collect()
}
fn reference_encode(table: &[u8], sample: i16) -> u8 {
table[usize::try_from(i32::from(sample) + 32_768).expect("in range")]
}
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))
}
fn all_codes() -> Vec<u8> {
(0..=u8::MAX).collect()
}
#[test]
fn every_mu_law_code_decodes_to_the_itu_table() {
for code in 0..=u8::MAX {
assert_eq!(
G711Law::MuLaw.code_to_linear(code),
reference_decode(G711Law::MuLaw, code),
"mu-law 0x{code:02x}"
);
}
}
#[test]
fn every_a_law_code_decodes_to_the_itu_table() {
for code in 0..=u8::MAX {
assert_eq!(
G711Law::ALaw.code_to_linear(code),
reference_decode(G711Law::ALaw, code),
"A-law 0x{code:02x}"
);
}
}
#[test]
fn the_published_anchor_values_hold() {
assert_eq!(G711Law::MuLaw.code_to_linear(0xFF), 0);
assert_eq!(G711Law::ALaw.code_to_linear(0xD5), 8);
assert_eq!(G711Law::ALaw.code_to_linear(0x55), -8);
assert_eq!(G711Law::MuLaw.code_to_linear(0x80), 32_124);
assert_eq!(G711Law::MuLaw.code_to_linear(0x00), -32_124);
assert_eq!(G711Law::ALaw.code_to_linear(0xAA), 32_256);
assert_eq!(G711Law::ALaw.code_to_linear(0x2A), -32_256);
assert_eq!(G711Law::ALaw.code_to_linear(0xD4), 24);
assert_eq!(G711Law::MuLaw.code_to_linear(0xFE), 8);
assert_ne!(
G711Law::MuLaw.code_to_linear(0x00),
G711Law::ALaw.code_to_linear(0x00)
);
}
#[test]
fn the_reference_intervals_tile_the_whole_16_bit_domain() {
for law in BOTH {
let table = reference_encode_table(law);
assert_eq!(table.len(), 65_536);
}
let emitted = |law| {
(0..=u8::MAX)
.filter(|&code| reference_input_range(law, code).is_some())
.count()
};
assert_eq!(emitted(G711Law::ALaw), 256);
assert_eq!(emitted(G711Law::MuLaw), 255);
assert!(reference_input_range(G711Law::MuLaw, 0x7F).is_none());
}
#[test]
fn every_i16_encodes_to_the_itu_code_in_both_laws() {
for law in BOTH {
let table = reference_encode_table(law);
for sample in i16::MIN..=i16::MAX {
assert_eq!(
law.linear_to_code(sample),
reference_encode(&table, sample),
"{law:?} on {sample}"
);
}
}
}
#[test]
fn the_encoder_is_total_and_clamps_rather_than_wrapping() {
for law in BOTH {
assert_eq!(
law.code_to_linear(law.linear_to_code(i16::MAX)).signum(),
1,
"{law:?} sent i16::MAX negative"
);
assert_eq!(
law.code_to_linear(law.linear_to_code(i16::MIN)).signum(),
-1,
"{law:?} sent i16::MIN positive"
);
assert!(
law.code_to_linear(law.linear_to_code(0)).abs() <= 8,
"{law:?} did not put silence at the bottom of the table"
);
}
assert_eq!(G711Law::MuLaw.linear_to_code(0), 0xFF);
assert_eq!(G711Law::ALaw.linear_to_code(0), 0xD5);
assert_eq!(G711Law::MuLaw.linear_to_code(i16::MAX), 0x80);
assert_eq!(G711Law::MuLaw.linear_to_code(i16::MIN), 0x00);
assert_eq!(G711Law::ALaw.linear_to_code(i16::MAX), 0xAA);
assert_eq!(G711Law::ALaw.linear_to_code(i16::MIN), 0x2A);
}
#[test]
fn re_encoding_a_decoded_code_returns_it_except_for_mu_laws_second_zero() {
for law in BOTH {
for code in 0..=u8::MAX {
let linear = law.code_to_linear(code);
let again = law.linear_to_code(linear);
assert_eq!(
law.code_to_linear(again),
linear,
"{law:?} 0x{code:02x} lost information on a second pass"
);
if law == G711Law::MuLaw && code == 0x7F {
assert_eq!(again, 0xFF, "mu-law's second zero must fold onto 0xFF");
assert_eq!(linear, 0, "mu-law's second zero must be silence");
} else {
assert_eq!(
again, code,
"{law:?} 0x{code:02x} is not its own fixed point"
);
}
}
}
}
#[test]
fn a_second_encode_of_any_sample_returns_the_first_code() {
for law in BOTH {
for sample in i16::MIN..=i16::MAX {
let first = law.linear_to_code(sample);
let again = law.linear_to_code(law.code_to_linear(first));
assert_eq!(again, first, "{law:?} on {sample}");
}
}
}
#[test]
fn the_slice_decode_api_matches_the_scalar_path() {
let codes = all_codes();
for law in BOTH {
let expected: Vec<f32> = codes
.iter()
.map(|&code| i16_to_f32(law.code_to_linear(code)))
.collect();
let mut whole = Vec::new();
assert_eq!(law.decode(&codes, &mut whole), codes.len());
assert_eq!(whole, expected, "{law:?} in one call");
for chunk in [1, 2, 3, 5, 7, 17, 128, 255] {
let mut pieced = Vec::new();
for piece in codes.chunks(chunk) {
assert_eq!(law.decode(piece, &mut pieced), piece.len());
}
assert_eq!(pieced, expected, "{law:?} in {chunk}-byte pieces");
}
}
}
#[test]
fn the_slice_encode_api_matches_the_scalar_path() {
let samples: Vec<f32> = (-600..=600)
.map(|i| i as f32 / 512.0)
.chain([f32::NAN, f32::INFINITY, f32::NEG_INFINITY])
.collect();
for law in BOTH {
let expected: Vec<u8> = samples
.iter()
.map(|&sample| law.linear_to_code(f32_to_i16(sample)))
.collect();
let mut whole = Vec::new();
assert_eq!(law.encode(&samples, &mut whole), samples.len());
assert_eq!(whole, expected, "{law:?} in one call");
for chunk in [1, 3, 7, 64] {
let mut pieced = Vec::new();
for piece in samples.chunks(chunk) {
assert_eq!(law.encode(piece, &mut pieced), piece.len());
}
assert_eq!(pieced, expected, "{law:?} in {chunk}-sample pieces");
}
}
}
#[test]
fn the_decoder_byte_path_matches_the_scalar_path_at_every_chunk_size() {
let codes = all_codes();
for law in BOTH {
let expected: Vec<f32> = codes
.iter()
.map(|&code| i16_to_f32(law.code_to_linear(code)))
.collect();
for chunk in [1, 2, 3, 5, 7, 17, 128, 255, 256, 1024] {
let mut decoder = G711Decoder::new(law, AudioSpec::mono(16_000));
let decoded = drive(&mut decoder, &codes, chunk).expect("decode");
assert_eq!(
decoded.samples(),
expected.as_slice(),
"{law:?} changed with a {chunk}-byte feed size"
);
}
}
}
#[test]
fn the_decoder_preserves_byte_order_across_feeds() {
let mut decoder = G711Decoder::new(G711Law::ALaw, AudioSpec::mono(8_000));
let mut out = Vec::new();
for code in [0xD5_u8, 0x2A, 0xAA, 0x55] {
assert_eq!(decoder.feed(&[code]).expect("feed"), 1);
assert_eq!(decoder.decode(&mut out).expect("decode"), 1);
}
decoder.flush(&mut out).expect("flush");
assert_eq!(
out,
[
8.0 / 32768.0,
-32_256.0 / 32768.0,
32_256.0 / 32768.0,
-8.0 / 32768.0
]
);
}
#[test]
fn a_full_decoder_applies_back_pressure_instead_of_growing() {
let law = G711Law::MuLaw;
let mut decoder = G711Decoder::new(law, AudioSpec::mono(16_000));
let bytes: Vec<u8> = (0..READY_LIMIT * 3).map(|i| (i % 256) as u8).collect();
let first = decoder.feed(&bytes).expect("feed");
assert!(first < bytes.len(), "a full decoder must return short");
assert_eq!(first, READY_LIMIT);
assert_eq!(decoder.feed(&bytes[first..]).expect("feed"), 0);
let decoded = drive(&mut decoder, &bytes, bytes.len()).expect("decode");
assert_eq!(decoded.samples().len(), bytes.len() + first);
let expected: Vec<f32> = bytes
.iter()
.map(|&code| i16_to_f32(law.code_to_linear(code)))
.collect();
assert_eq!(&decoded.samples()[..first], &expected[..first]);
assert_eq!(&decoded.samples()[first..], expected.as_slice());
}
#[test]
fn a_whole_file_feed_loses_nothing_to_the_short_return() {
let bytes: Vec<u8> = (0..READY_LIMIT * 2 + 7).map(|i| (i % 251) as u8).collect();
for law in BOTH {
let expected: Vec<f32> = bytes
.iter()
.map(|&code| i16_to_f32(law.code_to_linear(code)))
.collect();
let mut decoder = G711Decoder::new(law, AudioSpec::mono(8_000));
let decoded = drive(&mut decoder, &bytes, bytes.len()).expect("decode");
assert_eq!(
decoded.samples(),
expected.as_slice(),
"{law:?} lost or reordered bytes on a whole-file feed"
);
}
}
#[test]
fn a_stereo_stream_ending_mid_frame_is_truncated() {
let mut decoder = G711Decoder::new(G711Law::MuLaw, AudioSpec::new(8_000, 2));
let mut out = Vec::new();
decoder.feed(&[0xFF]).expect("feed");
assert_eq!(decoder.decode(&mut out).expect("decode"), 1);
assert_eq!(
decoder.buffered_bytes(),
1,
"one sample into a 2-byte frame"
);
let error = decoder.flush(&mut out).expect_err("flush must reject");
assert!(
matches!(
error,
DecodeError::Truncated {
expected: 2,
available: 1
}
),
"unexpected error: {error}"
);
assert_eq!(decoder.flush(&mut out).expect("second flush"), 0);
let mut decoder = G711Decoder::new(G711Law::MuLaw, AudioSpec::new(8_000, 2));
let decoded = drive(&mut decoder, &[0xFF, 0x80], 1).expect("decode");
assert_eq!(decoded.frames(), 1);
assert_eq!(decoded.samples(), [0.0, 32_124.0 / 32768.0]);
}
#[test]
fn every_position_inside_a_frame_is_truncated_and_only_the_boundary_is_clean() {
for channels in [2_u16, 3, 6] {
for bytes in 1..=(channels * 2) {
let mut decoder = G711Decoder::new(G711Law::ALaw, AudioSpec::new(48_000, channels));
let input = vec![0xD5_u8; usize::from(bytes)];
let result = drive(&mut decoder, &input, 4);
if bytes % channels == 0 {
let decoded = result.expect("a whole number of frames must decode");
assert_eq!(decoded.frames(), usize::from(bytes / channels));
} else {
let error = result.expect_err("a partial frame must reject");
assert!(
matches!(
error,
DecodeError::Truncated { expected, available }
if expected == u64::from(channels)
&& available == u64::from(bytes % channels)
),
"{channels} channels, {bytes} bytes: unexpected error: {error}"
);
}
}
}
}
#[test]
fn a_headerless_g711_stream_decodes_at_the_spec_it_was_given() {
let mut decoder = G711Decoder::new(G711Law::ALaw, AudioSpec::mono(8_000));
assert_eq!(decoder.law(), G711Law::ALaw);
assert_eq!(decoder.output_spec(), AudioSpec::mono(8_000));
let decoded = drive(&mut decoder, &[0xD5, 0x55, 0xAA, 0x2A], 64).expect("decode");
assert_eq!(
decoded.samples(),
[
8.0 / 32768.0,
-8.0 / 32768.0,
32_256.0 / 32768.0,
-32_256.0 / 32768.0
]
);
assert_eq!(decoded.sample_rate(), 8_000);
assert_eq!(decoded.frames(), 4);
}
#[test]
fn the_rate_is_whatever_the_spec_says_and_never_assumed() {
for rate in [8_000, 16_000, 44_100, 48_000, 192_000, 1] {
let mut decoder = G711Decoder::new(G711Law::MuLaw, AudioSpec::mono(rate));
let decoded = drive(&mut decoder, &[0xFF, 0xFF], 1).expect("decode");
assert_eq!(decoded.sample_rate(), rate);
assert_eq!(decoded.samples(), [0.0, 0.0]);
}
}
#[test]
fn the_sample_count_is_exact_for_every_layout() {
for law in BOTH {
for channels in [1_u16, 2, 6] {
let frames = 50;
let spec = AudioSpec::new(48_000, channels);
let count = frames * usize::from(channels);
let input: Vec<u8> = (0..count).map(|i| (i % 256) as u8).collect();
let mut decoder = G711Decoder::new(law, spec);
let decoded = drive(&mut decoder, &input, 13).expect("decode");
assert_eq!(
decoded.samples().len(),
count,
"{law:?} at {channels} channels produced the wrong count"
);
assert_eq!(decoded.frames(), frames);
}
}
}
#[test]
fn a_starved_decoder_reports_zero_rather_than_end_of_stream() {
let mut decoder = G711Decoder::new(G711Law::ALaw, AudioSpec::mono(16_000));
let mut out = Vec::new();
assert_eq!(decoder.decode(&mut out).expect("decode"), 0);
assert!(out.is_empty());
assert_eq!(decoder.feed(&[]).expect("empty feed"), 0);
assert_eq!(decoder.decode(&mut out).expect("decode"), 0);
assert_eq!(decoder.feed(&[0xD5]).expect("feed"), 1);
assert_eq!(decoder.decode(&mut out).expect("decode"), 1);
}
#[test]
fn feeding_after_flush_is_quiet_until_reset() {
let mut decoder = G711Decoder::new(G711Law::MuLaw, AudioSpec::mono(8_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(&[0xFF]).expect("feed"), 0);
assert_eq!(decoder.decode(&mut out).expect("decode"), 0);
assert!(out.is_empty());
decoder.reset();
assert_eq!(decoder.feed(&[0x80]).expect("feed"), 1);
assert_eq!(decoder.decode(&mut out).expect("decode"), 1);
assert_eq!(out, [32_124.0 / 32768.0]);
}
#[test]
fn reset_drops_the_frame_position() {
let mut decoder = G711Decoder::new(G711Law::MuLaw, AudioSpec::new(16_000, 2));
decoder.feed(&[0xFF]).expect("feed");
assert_eq!(decoder.buffered_bytes(), 1);
decoder.reset();
assert_eq!(decoder.buffered_bytes(), 0);
let mut out = Vec::new();
assert_eq!(decoder.flush(&mut out).expect("flush after reset"), 0);
}
#[test]
fn the_decoder_is_object_safe_and_sendable() {
fn assert_send<T: Send>() {}
assert_send::<G711Decoder>();
let boxed: Box<dyn Decoder> =
Box::new(G711Decoder::new(G711Law::ALaw, AudioSpec::new(44_100, 2)));
assert_eq!(boxed.output_spec().channels, 2);
}
#[test]
fn a_zero_channel_spec_does_not_divide_by_zero() {
let mut decoder = G711Decoder::new(G711Law::MuLaw, AudioSpec::new(16_000, 0));
let mut out = Vec::new();
decoder.feed(&[0xFF]).expect("feed");
assert_eq!(decoder.decode(&mut out).expect("decode"), 1);
assert_eq!(decoder.buffered_bytes(), 0);
assert_eq!(decoder.flush(&mut out).expect("flush"), 0);
}
fn fnv1a(bytes: impl IntoIterator<Item = u8>) -> u64 {
let mut hash = 0xcbf2_9ce4_8422_2325_u64;
for byte in bytes {
hash ^= u64::from(byte);
hash = hash.wrapping_mul(0x0000_0100_0000_01b3);
}
hash
}
#[test]
fn g711_output_is_bit_identical_to_a_pinned_witness() {
let codes = all_codes();
let signal: Vec<f32> = (-2048..=2048)
.map(|i| i as f32 / 2048.0)
.chain([1.5, -3.0])
.collect();
let mut bytes: Vec<u8> = Vec::new();
for law in BOTH {
let mut decoder = G711Decoder::new(law, AudioSpec::mono(16_000));
let decoded = drive(&mut decoder, &codes, 7).expect("decode");
bytes.extend(
decoded
.samples()
.iter()
.flat_map(|s| s.to_bits().to_le_bytes()),
);
law.encode(&signal, &mut bytes);
}
assert_eq!(bytes.len(), 2 * (256 * 4 + signal.len()));
assert_eq!(fnv1a(bytes), 0x81b6_c667_9170_0ce0, "G.711 output changed");
}
}