mirror of
https://github.com/storytold/craft-libs.git
synced 2026-11-18 00:05:08 +00:00
Merge pull request #1762 from el-j/feat/audio-adpcm
craft-audio: IMA WAV, Microsoft, Yamaha and Flash ADPCM (adpcm)
This commit is contained in:
9 files changed
+1355
-1
No files matched your search
@@ -41,6 +41,8 @@ aac-decode = ["craft-media/bitstream"]
|
||||
# The AAC encoder (`aac::Encoder`), and AAC in M4A through `encode` and `FileEncoder`.
|
||||
aac-encode = ["craft-media/bitstream", "craft-media/isobmff"]
|
||||
opus-decode = []
|
||||
# ADPCM (`adpcm`): IMA WAV, Microsoft, Yamaha and Flash (SWF) decoders and encoders.
|
||||
adpcm = ["craft-media/bitstream"]
|
||||
# QOA (Quite OK Audio) files: decoder and encoder in the `qoa` module, each on its own.
|
||||
qoa = ["qoa-decode", "qoa-encode"]
|
||||
qoa-decode = []
|
||||
@@ -111,6 +113,10 @@ required-features = ["decode", "encode"]
|
||||
name = "mp2_encoder_oracle"
|
||||
required-features = ["mpa-encode"]
|
||||
|
||||
[[test]]
|
||||
name = "adpcm_oracle"
|
||||
required-features = ["adpcm"]
|
||||
|
||||
[[test]]
|
||||
name = "flac_decode"
|
||||
required-features = ["flac-decode", "flac-encode"]
|
||||
|
||||
@@ -45,6 +45,7 @@ No default features. The shared types (`AudioBuffer`, `AudioInfo`, `ChannelLayou
|
||||
| `mp3-decode` | `mp3::Decoder`, `mp3::InfoTag` | `mpa-decode` |
|
||||
| `mp3-encode` | `mp3::Encoder`; `encode`, `FileEncoder` for MP3 | craft-media `bitstream` |
|
||||
| `mpa-encode` | `mpa::encoder::Encoder` (Layer II / MP2 frames) | `mpa-decode`, `mp3-encode` |
|
||||
| `adpcm` | `adpcm::{ima, ms, yamaha, swf}`: decoders and encoders for IMA WAV, Microsoft, Yamaha and Flash ADPCM | craft-media `bitstream` |
|
||||
| `gsm-decode`, `gsm-encode` (`gsm`) | `gsm::Decoder`, `gsm::Encoder`, `gsm::decode`, `gsm::encode`: GSM 06.10 full-rate speech, bit-exact, raw `.gsm` and WAV (GSM 6.10) packings | none |
|
||||
| `vmd-decode` | `vmd::Decoder`: Sierra VMD sound (8-bit PCM and 16-bit DPCM), frame by frame from `craft_media::vmd` | none |
|
||||
| `peaks` | `peaks::Peaks` | none |
|
||||
|
||||
@@ -0,0 +1,247 @@
|
||||
//! IMA ADPCM in WAV blocks (format tag 0x0011).
|
||||
//!
|
||||
//! A block is, per channel, a 4-byte header (the first sample as `i16` and the step index as `u8`,
|
||||
//! then a zero byte), then groups of 4 bytes per channel in channel order, each holding eight
|
||||
//! 4-bit codes, low nibble first. A block of `block_align` bytes holds
|
||||
//! `(block_align - 4 * channels) * 2 / channels + 1` samples per channel. A code is a sign bit and
|
||||
//! three magnitude bits: the decoder adds `step/8` plus `step`, `step/2` and `step/4` for each set
|
||||
//! magnitude bit from the top, then moves the step index by `[-1, -1, -1, -1, 2, 4, 6, 8]`.
|
||||
|
||||
use super::{Error, Result, clip16, step_at};
|
||||
|
||||
const INDEX_ADJUST: [i32; 8] = [-1, -1, -1, -1, 2, 4, 6, 8];
|
||||
|
||||
/// The state of one channel's decoder.
|
||||
#[derive(Clone, Copy)]
|
||||
struct State {
|
||||
predictor: i32,
|
||||
index: i32,
|
||||
}
|
||||
|
||||
impl State {
|
||||
/// The sample after code `nibble`.
|
||||
fn step(&mut self, nibble: u8) -> i16 {
|
||||
let step = step_at(self.index);
|
||||
let mut diff = step >> 3;
|
||||
if nibble & 1 != 0 {
|
||||
diff += step >> 2;
|
||||
}
|
||||
if nibble & 2 != 0 {
|
||||
diff += step >> 1;
|
||||
}
|
||||
if nibble & 4 != 0 {
|
||||
diff += step;
|
||||
}
|
||||
if nibble & 8 != 0 {
|
||||
diff = -diff;
|
||||
}
|
||||
self.predictor = clip16(self.predictor + diff);
|
||||
self.index = (self.index + INDEX_ADJUST.get(usize::from(nibble & 7)).copied().unwrap_or(0)).clamp(0, 88);
|
||||
self.predictor as i16
|
||||
}
|
||||
|
||||
/// The code that brings the predictor closest to `sample`, applied to the state.
|
||||
fn encode(&mut self, sample: i16) -> u8 {
|
||||
let step = step_at(self.index);
|
||||
let mut diff = i32::from(sample) - self.predictor;
|
||||
let mut code = 0u8;
|
||||
if diff < 0 {
|
||||
code = 8;
|
||||
diff = -diff;
|
||||
}
|
||||
let mut s = step;
|
||||
for bit in [4u8, 2, 1] {
|
||||
if diff >= s {
|
||||
code |= bit;
|
||||
diff -= s;
|
||||
}
|
||||
s >>= 1;
|
||||
}
|
||||
self.step(code);
|
||||
code
|
||||
}
|
||||
}
|
||||
|
||||
/// Samples per channel in a block of `block_align` bytes; `None` when the layout is impossible
|
||||
/// (a block must hold the headers and whole groups of eight samples, and there are 1 to 8
|
||||
/// channels).
|
||||
pub fn samples_per_block(block_align: usize, channels: usize) -> Option<usize> {
|
||||
if !(1..=8).contains(&channels) {
|
||||
return None;
|
||||
}
|
||||
let header = 4 * channels;
|
||||
let body = block_align.checked_sub(header)?;
|
||||
if body == 0 || !body.is_multiple_of(4 * channels) {
|
||||
return None;
|
||||
}
|
||||
let per = (body / channels).checked_mul(2)?.checked_add(1)?;
|
||||
// Callers size interleaved buffers from this value; the full count must fit too.
|
||||
per.checked_mul(channels)?;
|
||||
Some(per)
|
||||
}
|
||||
|
||||
/// Decode one block, appending its samples interleaved by channel to `out`.
|
||||
pub fn decode_block(block: &[u8], channels: usize, out: &mut Vec<i16>) -> Result<()> {
|
||||
let per = samples_per_block(block.len(), channels).ok_or(Error::Malformed("block size does not fit the channel count"))?;
|
||||
let mut states = Vec::with_capacity(channels);
|
||||
for ch in 0..channels {
|
||||
let h = block.get(4 * ch..4 * ch + 4).ok_or(Error::Malformed("truncated block header"))?;
|
||||
let index = i32::from(h[2]);
|
||||
if index > 88 {
|
||||
return Err(Error::Malformed("step index above 88"));
|
||||
}
|
||||
states.push(State { predictor: i32::from(i16::from_le_bytes([h[0], h[1]])), index });
|
||||
}
|
||||
let start = out.len();
|
||||
out.resize(start + per * channels, 0);
|
||||
let samples = out.get_mut(start..).ok_or(Error::Malformed("output"))?;
|
||||
for (ch, s) in states.iter().enumerate() {
|
||||
if let Some(o) = samples.get_mut(ch) {
|
||||
*o = s.predictor as i16;
|
||||
}
|
||||
}
|
||||
let body = block.get(4 * channels..).ok_or(Error::Malformed("truncated block"))?;
|
||||
for (g, group) in body.chunks_exact(4 * channels).enumerate() {
|
||||
for (ch, bytes) in group.as_chunks::<4>().0.iter().enumerate() {
|
||||
let Some(state) = states.get_mut(ch) else { continue };
|
||||
for (k, b) in bytes.iter().enumerate() {
|
||||
for (half, nibble) in [b & 0xF, b >> 4].into_iter().enumerate() {
|
||||
let t = 1 + g * 8 + k * 2 + half;
|
||||
if let Some(o) = samples.get_mut(t * channels + ch) {
|
||||
*o = state.step(nibble);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Decode a stream of blocks of `block_align` bytes. A final partial block is decoded as far as it
|
||||
/// holds whole groups.
|
||||
pub fn decode(data: &[u8], channels: usize, block_align: usize) -> Result<Vec<i16>> {
|
||||
samples_per_block(block_align, channels).ok_or(Error::Malformed("block size does not fit the channel count"))?;
|
||||
let mut out = Vec::new();
|
||||
for block in data.chunks(block_align) {
|
||||
if block.len() == block_align {
|
||||
decode_block(block, channels, &mut out)?;
|
||||
} else {
|
||||
let (header, group) = (4 * channels, 4 * channels);
|
||||
let whole = block.len().saturating_sub(header) / group * group;
|
||||
if whole > 0 {
|
||||
decode_block(block.get(..header + whole).unwrap_or(block), channels, &mut out)?;
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
/// The starting step index for a channel whose first samples are `x`: the index whose first
|
||||
/// codes follow `x` most closely.
|
||||
fn start_index(first: i16, x: &[i16]) -> i32 {
|
||||
let mut best = (i64::MAX, 0);
|
||||
for index in 0..=88 {
|
||||
let mut st = State { predictor: i32::from(first), index };
|
||||
let mut err = 0i64;
|
||||
for &s in x.iter().take(16) {
|
||||
let code = st.encode(s);
|
||||
let _ = code;
|
||||
err += (i64::from(s) - i64::from(st.predictor)).pow(2);
|
||||
}
|
||||
if err < best.0 {
|
||||
best = (err, index);
|
||||
}
|
||||
}
|
||||
best.1
|
||||
}
|
||||
|
||||
/// Encode one block from exactly `samples_per_block * channels` interleaved samples.
|
||||
pub fn encode_block(samples: &[i16], channels: usize, block_align: usize) -> Result<Vec<u8>> {
|
||||
let per = samples_per_block(block_align, channels).ok_or(Error::InvalidInput("block size does not fit the channel count"))?;
|
||||
if samples.len() != per * channels {
|
||||
return Err(Error::InvalidInput("a block needs exactly samples_per_block samples per channel"));
|
||||
}
|
||||
let mut block = vec![0u8; block_align];
|
||||
let mut states = Vec::with_capacity(channels);
|
||||
for ch in 0..channels {
|
||||
let col: Vec<i16> = samples.iter().skip(ch).step_by(channels).copied().collect();
|
||||
let first = col.first().copied().unwrap_or(0);
|
||||
let st = State { predictor: i32::from(first), index: start_index(first, col.get(1..).unwrap_or(&[])) };
|
||||
if let Some(h) = block.get_mut(4 * ch..4 * ch + 4) {
|
||||
h[..2].copy_from_slice(&first.to_le_bytes());
|
||||
h[2] = st.index as u8;
|
||||
}
|
||||
states.push(st);
|
||||
}
|
||||
let groups = (block_align - 4 * channels) / (4 * channels);
|
||||
for g in 0..groups {
|
||||
for ch in 0..channels {
|
||||
let Some(state) = states.get_mut(ch) else { continue };
|
||||
for k in 0..4 {
|
||||
let mut byte = 0u8;
|
||||
for half in 0..2 {
|
||||
let t = 1 + g * 8 + k * 2 + half;
|
||||
let nibble = state.encode(samples.get(t * channels + ch).copied().unwrap_or(0));
|
||||
byte |= nibble << (4 * half);
|
||||
}
|
||||
if let Some(b) = block.get_mut(4 * channels + g * 4 * channels + ch * 4 + k) {
|
||||
*b = byte;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(block)
|
||||
}
|
||||
|
||||
/// Encode interleaved samples as blocks of `block_align` bytes. The last block is padded with
|
||||
/// copies of the last sample, so a decoder returns up to one block more than was given.
|
||||
pub fn encode(samples: &[i16], channels: usize, block_align: usize) -> Result<Vec<u8>> {
|
||||
let per = samples_per_block(block_align, channels).ok_or(Error::InvalidInput("block size does not fit the channel count"))?;
|
||||
if !samples.len().is_multiple_of(channels) {
|
||||
return Err(Error::InvalidInput("the sample count is not a multiple of the channel count"));
|
||||
}
|
||||
let mut out = Vec::new();
|
||||
for chunk in samples.chunks(per * channels) {
|
||||
if chunk.len() == per * channels {
|
||||
out.extend(encode_block(chunk, channels, block_align)?);
|
||||
} else {
|
||||
let mut padded = chunk.to_vec();
|
||||
let last: Vec<i16> = chunk.get(chunk.len().saturating_sub(channels)..).unwrap_or(&[]).to_vec();
|
||||
while padded.len() < per * channels {
|
||||
padded.extend(last.iter().copied().chain(std::iter::repeat(0)).take(channels));
|
||||
}
|
||||
out.extend(encode_block(&padded, channels, block_align)?);
|
||||
}
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn layout() {
|
||||
assert_eq!(samples_per_block(256, 1), Some(505));
|
||||
assert_eq!(samples_per_block(512, 2), Some(505));
|
||||
assert_eq!(samples_per_block(4, 1), None);
|
||||
assert_eq!(samples_per_block(100, 0), None);
|
||||
assert_eq!(samples_per_block(258, 2), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unrepresentable_interleaved_layout_is_rejected() {
|
||||
let align = usize::MAX - 7;
|
||||
assert_eq!(samples_per_block(align, 2), None);
|
||||
assert!(encode(&[], 2, align).is_err());
|
||||
assert!(encode_block(&[], 2, align).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn silence_stays_silent() {
|
||||
let block = encode_block(&vec![0; 505], 1, 256).unwrap();
|
||||
let mut out = Vec::new();
|
||||
decode_block(&block, 1, &mut out).unwrap();
|
||||
assert!(out.iter().all(|&s| s == 0));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,56 @@
|
||||
//! ADPCM: a decoder and an encoder for four families, each on whole blocks or streams of `i16`
|
||||
//! samples interleaved by channel (feature `adpcm`).
|
||||
//!
|
||||
//! - [`ima`]: IMA / DVI ADPCM in WAV blocks (format tag 0x0011): 4 bits per sample, a 4-byte header
|
||||
//! per channel and groups of eight samples per channel.
|
||||
//! - [`ms`]: Microsoft ADPCM in WAV blocks (format tag 0x0002): 4 bits per sample, adaptive
|
||||
//! two-tap prediction with the seven standard coefficient pairs.
|
||||
//! - [`yamaha`]: Yamaha ADPCM (the YM2608 / AICA family): a raw stream of 4-bit codes.
|
||||
//! - [`swf`]: the ADPCM of Flash (SWF) audio: 2 to 5 bits per sample, in blocks of 4096 samples.
|
||||
//!
|
||||
//! Written from the public descriptions of the algorithms: the IMA Digital Audio Focus and
|
||||
//! Technical Working Groups' *Recommended Practices for Enhancing Digital Audio Compatibility*
|
||||
//! (IMA ADPCM), Microsoft's *Multimedia Standards Update* (the WAVE format tags and the block
|
||||
//! layout of Microsoft ADPCM), the SWF file format specification (the ADPCM section) and the
|
||||
//! Yamaha ADPCM-B description. ffmpeg is only run as a black-box oracle in the tests.
|
||||
//!
|
||||
//! Decoders return errors, never panic, on damaged blocks. Encoders are greedy: they choose each
|
||||
//! code to bring the decoder's output closest to the sample.
|
||||
|
||||
pub mod ima;
|
||||
pub mod ms;
|
||||
pub mod swf;
|
||||
pub mod yamaha;
|
||||
|
||||
/// What went wrong decoding or encoding ADPCM.
|
||||
#[non_exhaustive]
|
||||
#[derive(Debug, thiserror::Error, PartialEq, Eq)]
|
||||
pub enum Error {
|
||||
/// The data is damaged, truncated or does not fit the stated block layout.
|
||||
#[error("malformed ADPCM: {0}")]
|
||||
Malformed(&'static str),
|
||||
/// The settings or samples given to an encoder cannot be written.
|
||||
#[error("ADPCM cannot encode: {0}")]
|
||||
InvalidInput(&'static str),
|
||||
}
|
||||
|
||||
/// Result with this module's [`Error`].
|
||||
pub type Result<T> = std::result::Result<T, Error>;
|
||||
|
||||
/// IMA ADPCM step sizes (the 89-entry table of the IMA recommended practices).
|
||||
pub(crate) const STEP_TABLE: [i32; 89] = [
|
||||
7, 8, 9, 10, 11, 12, 13, 14, 16, 17, 19, 21, 23, 25, 28, 31, 34, 37, 41, 45, 50, 55, 60, 66, 73, 80, 88, 97, 107, 118, 130, 143, 157, 173, 190,
|
||||
209, 230, 253, 279, 307, 337, 371, 408, 449, 494, 544, 598, 658, 724, 796, 876, 963, 1060, 1166, 1282, 1411, 1552, 1707, 1878, 2066, 2272, 2499,
|
||||
2749, 3024, 3327, 3660, 4026, 4428, 4871, 5358, 5894, 6484, 7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899, 15289, 16818, 18500, 20350,
|
||||
22385, 24623, 27086, 29794, 32767,
|
||||
];
|
||||
|
||||
/// Clamp to the 16-bit sample range.
|
||||
pub(crate) fn clip16(v: i32) -> i32 {
|
||||
v.clamp(i32::from(i16::MIN), i32::from(i16::MAX))
|
||||
}
|
||||
|
||||
/// The step size at `index` (clamped to the table).
|
||||
pub(crate) fn step_at(index: i32) -> i32 {
|
||||
STEP_TABLE.get(index.clamp(0, 88) as usize).copied().unwrap_or(7)
|
||||
}
|
||||
@@ -0,0 +1,244 @@
|
||||
//! Microsoft ADPCM in WAV blocks (format tag 0x0002).
|
||||
//!
|
||||
//! A block starts, for all channels in turn, with one predictor index (a byte, 0 to 6), then one
|
||||
//! initial step (`delta`, `i16`), then each channel's second-last sample (`sample1`, `i16`) and
|
||||
//! last sample (`sample2`, `i16`) before the block; the block's first two samples per channel are
|
||||
//! `sample2` then `sample1`. The rest is 4-bit two's-complement codes, the first channel in the
|
||||
//! high nibble. A block of `block_align` bytes holds `(block_align - 7 * channels) * 2 / channels
|
||||
//! + 2` samples per channel. Each sample is predicted as `(sample1 * c1 + sample2 * c2) / 256` (rounding toward zero)
|
||||
//! from the block's coefficient pair, plus `code * delta`; then `delta` becomes
|
||||
//! `max(16, delta * a / 256)`, where `a` is the table entry for the code (`ADAPT`).
|
||||
|
||||
use super::{Error, Result, clip16};
|
||||
|
||||
/// The seven coefficient pairs `(c1, c2)` every Microsoft ADPCM stream uses.
|
||||
pub const COEFFICIENTS: [(i32, i32); 7] = [(256, 0), (512, -256), (0, 0), (192, 64), (240, 0), (460, -208), (392, -232)];
|
||||
/// How the step moves with the code's unsigned value (the index is the 4-bit pattern).
|
||||
/// The largest step. The reference keeps it in 16 bits and no real stream gets near this bound; it
|
||||
/// keeps every product in range however long a damaged block runs.
|
||||
const MAX_DELTA: i32 = 1 << 24;
|
||||
const ADAPT: [i32; 16] = [230, 230, 230, 230, 307, 409, 512, 614, 768, 614, 512, 409, 307, 230, 230, 230];
|
||||
|
||||
#[derive(Clone, Copy)]
|
||||
struct State {
|
||||
c1: i32,
|
||||
c2: i32,
|
||||
delta: i32,
|
||||
s1: i32,
|
||||
s2: i32,
|
||||
}
|
||||
|
||||
impl State {
|
||||
fn step(&mut self, nibble: u8) -> i16 {
|
||||
let signed = i32::from(nibble) - if nibble & 8 != 0 { 16 } else { 0 };
|
||||
let predicted = (self.s1 * self.c1 + self.s2 * self.c2) / 256;
|
||||
let sample = clip16(predicted + signed * self.delta);
|
||||
self.s2 = self.s1;
|
||||
self.s1 = sample;
|
||||
let adapt = i64::from(ADAPT.get(usize::from(nibble)).copied().unwrap_or(256));
|
||||
let new_delta = (adapt * i64::from(self.delta)) >> 8;
|
||||
self.delta = (new_delta.min(i64::from(MAX_DELTA)) as i32).max(16);
|
||||
sample as i16
|
||||
}
|
||||
|
||||
/// The code that brings the output closest to `sample`, applied to the state.
|
||||
fn encode(&mut self, sample: i16) -> u8 {
|
||||
let predicted = (self.s1 * self.c1 + self.s2 * self.c2) / 256;
|
||||
let err = i32::from(sample) - predicted;
|
||||
// round to the nearest multiple of delta
|
||||
let q = if err >= 0 { (err + self.delta / 2) / self.delta } else { -((-err + self.delta / 2) / self.delta) };
|
||||
let code = (q.clamp(-8, 7) & 0xF) as u8;
|
||||
self.step(code);
|
||||
code
|
||||
}
|
||||
}
|
||||
|
||||
/// Samples per channel in a block of `block_align` bytes; `None` for an impossible layout (1 or 2
|
||||
/// channels, and room for the header and at least one code byte).
|
||||
pub fn samples_per_block(block_align: usize, channels: usize) -> Option<usize> {
|
||||
if !(1..=2).contains(&channels) {
|
||||
return None;
|
||||
}
|
||||
let body = block_align.checked_sub(7 * channels).filter(|&b| b > 0)?;
|
||||
// codes pair up across channels
|
||||
let per = (body.checked_mul(2)? / channels).checked_add(2)?;
|
||||
// Include the header samples and all channels before callers size their buffers.
|
||||
per.checked_mul(channels)?;
|
||||
Some(per)
|
||||
}
|
||||
|
||||
/// Decode one block, appending its samples interleaved by channel to `out`.
|
||||
pub fn decode_block(block: &[u8], channels: usize, out: &mut Vec<i16>) -> Result<()> {
|
||||
let per = samples_per_block(block.len(), channels).ok_or(Error::Malformed("block size does not fit the channel count"))?;
|
||||
let header = block.get(..7 * channels).ok_or(Error::Malformed("truncated block header"))?;
|
||||
let mut states = Vec::with_capacity(channels);
|
||||
let word = |i: usize| i32::from(i16::from_le_bytes([header.get(i).copied().unwrap_or(0), header.get(i + 1).copied().unwrap_or(0)]));
|
||||
for ch in 0..channels {
|
||||
let pred = usize::from(header.get(ch).copied().unwrap_or(0));
|
||||
let &(c1, c2) = COEFFICIENTS.get(pred).ok_or(Error::Malformed("predictor index above 6"))?;
|
||||
states.push(State { c1, c2, delta: word(channels + 2 * ch), s1: word(3 * channels + 2 * ch), s2: word(5 * channels + 2 * ch) });
|
||||
}
|
||||
let start = out.len();
|
||||
out.resize(start + per * channels, 0);
|
||||
let samples = out.get_mut(start..).ok_or(Error::Malformed("output"))?;
|
||||
for (ch, s) in states.iter().enumerate() {
|
||||
if let Some(a) = samples.get_mut(ch) {
|
||||
*a = s.s2 as i16;
|
||||
}
|
||||
if let Some(b) = samples.get_mut(channels + ch) {
|
||||
*b = s.s1 as i16;
|
||||
}
|
||||
}
|
||||
let codes = block.get(7 * channels..).ok_or(Error::Malformed("truncated block"))?;
|
||||
let mut t = 2 * channels;
|
||||
for byte in codes {
|
||||
for nibble in [byte >> 4, byte & 0xF] {
|
||||
let ch = t % channels;
|
||||
if let (Some(o), Some(state)) = (samples.get_mut(t), states.get_mut(ch)) {
|
||||
*o = state.step(nibble);
|
||||
}
|
||||
t += 1;
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Decode a stream of blocks of `block_align` bytes. A final partial block is decoded in full if
|
||||
/// it holds a header and a code byte.
|
||||
pub fn decode(data: &[u8], channels: usize, block_align: usize) -> Result<Vec<i16>> {
|
||||
samples_per_block(block_align, channels).ok_or(Error::Malformed("block size does not fit the channel count"))?;
|
||||
let mut out = Vec::new();
|
||||
for block in data.chunks(block_align) {
|
||||
if block.len() == block_align || samples_per_block(block.len(), channels).is_some() {
|
||||
decode_block(block, channels, &mut out)?;
|
||||
}
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
/// The squared error of encoding `col` (one channel) from state `st`.
|
||||
fn trial(mut st: State, col: &[i16]) -> i64 {
|
||||
let mut err = 0i64;
|
||||
for &s in col {
|
||||
st.encode(s);
|
||||
err += (i64::from(s) - i64::from(st.s1)).pow(2);
|
||||
}
|
||||
err
|
||||
}
|
||||
|
||||
/// Encode one block from exactly `samples_per_block * channels` interleaved samples. Each channel
|
||||
/// gets the coefficient pair and initial step that code it with the least error.
|
||||
pub fn encode_block(samples: &[i16], channels: usize, block_align: usize) -> Result<Vec<u8>> {
|
||||
let per = samples_per_block(block_align, channels).ok_or(Error::InvalidInput("block size does not fit the channel count"))?;
|
||||
if samples.len() != per * channels {
|
||||
return Err(Error::InvalidInput("a block needs exactly samples_per_block samples per channel"));
|
||||
}
|
||||
let mut block = vec![0u8; block_align];
|
||||
let mut states = Vec::with_capacity(channels);
|
||||
for ch in 0..channels {
|
||||
let col: Vec<i16> = samples.iter().skip(ch).step_by(channels).copied().collect();
|
||||
let (x0, x1) = (col.first().copied().unwrap_or(0), col.get(1).copied().unwrap_or(0));
|
||||
let rest = col.get(2..).unwrap_or(&[]);
|
||||
let mut best: Option<(i64, usize, i32)> = None;
|
||||
for (p, &(c1, c2)) in COEFFICIENTS.iter().enumerate() {
|
||||
for delta in [16, 64, 256, 1024] {
|
||||
let st = State { c1, c2, delta, s1: i32::from(x1), s2: i32::from(x0) };
|
||||
let e = trial(st, rest);
|
||||
if best.is_none_or(|(b, _, _)| e < b) {
|
||||
best = Some((e, p, delta));
|
||||
}
|
||||
}
|
||||
}
|
||||
let (_, p, delta) = best.unwrap_or((0, 0, 16));
|
||||
let &(c1, c2) = COEFFICIENTS.get(p).unwrap_or(&(256, 0));
|
||||
states.push(State { c1, c2, delta, s1: i32::from(x1), s2: i32::from(x0) });
|
||||
let (d, a, b) = (delta as i16, x1, x0);
|
||||
let put = |block: &mut Vec<u8>, at: usize, v: i16| {
|
||||
if let Some(w) = block.get_mut(at..at + 2) {
|
||||
w.copy_from_slice(&v.to_le_bytes());
|
||||
}
|
||||
};
|
||||
if let Some(h) = block.get_mut(ch) {
|
||||
*h = p as u8;
|
||||
}
|
||||
put(&mut block, channels + 2 * ch, d);
|
||||
put(&mut block, 3 * channels + 2 * ch, a);
|
||||
put(&mut block, 5 * channels + 2 * ch, b);
|
||||
}
|
||||
let mut t = 2 * channels;
|
||||
for byte in block.iter_mut().skip(7 * channels) {
|
||||
let mut b = 0u8;
|
||||
for half in 0..2 {
|
||||
let ch = t % channels;
|
||||
let nibble = match states.get_mut(ch) {
|
||||
Some(st) => st.encode(samples.get(t).copied().unwrap_or(0)),
|
||||
None => 0,
|
||||
};
|
||||
b |= nibble << (4 * (1 - half));
|
||||
t += 1;
|
||||
}
|
||||
*byte = b;
|
||||
}
|
||||
Ok(block)
|
||||
}
|
||||
|
||||
/// Encode interleaved samples as blocks of `block_align` bytes. The last block is padded with
|
||||
/// copies of the last frame, so a decoder returns up to one block more than was given.
|
||||
pub fn encode(samples: &[i16], channels: usize, block_align: usize) -> Result<Vec<u8>> {
|
||||
let per = samples_per_block(block_align, channels).ok_or(Error::InvalidInput("block size does not fit the channel count"))?;
|
||||
if !samples.len().is_multiple_of(channels) {
|
||||
return Err(Error::InvalidInput("the sample count is not a multiple of the channel count"));
|
||||
}
|
||||
let mut out = Vec::new();
|
||||
for chunk in samples.chunks(per * channels) {
|
||||
let mut padded = chunk.to_vec();
|
||||
let last: Vec<i16> = chunk.get(chunk.len().saturating_sub(channels)..).unwrap_or(&[]).to_vec();
|
||||
while padded.len() < per * channels {
|
||||
padded.extend(last.iter().copied().chain(std::iter::repeat(0)).take(channels));
|
||||
}
|
||||
out.extend(encode_block(&padded, channels, block_align)?);
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn layout() {
|
||||
assert_eq!(samples_per_block(256, 1), Some(500));
|
||||
assert_eq!(samples_per_block(512, 2), Some(500));
|
||||
assert_eq!(samples_per_block(7, 1), None);
|
||||
assert_eq!(samples_per_block(100, 3), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unrepresentable_layouts_are_rejected() {
|
||||
for (align, channels) in [(usize::MAX / 2 + 7, 1), (usize::MAX / 2 + 14, 2)] {
|
||||
assert_eq!(samples_per_block(align, channels), None);
|
||||
assert!(encode(&[], channels, align).is_err());
|
||||
assert!(encode_block(&[], channels, align).is_err());
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_long_run_of_large_codes_cannot_overflow() {
|
||||
// a step that starts at its largest 16-bit value and grows with every large code
|
||||
let mut block = vec![0x77u8; 7 + 2000];
|
||||
block[..7].copy_from_slice(&[0, 255, 127, 0, 0, 0, 0]);
|
||||
for b in block.iter_mut().skip(7) {
|
||||
*b = 0x88;
|
||||
}
|
||||
let mut out = Vec::new();
|
||||
decode_block(&block, 1, &mut out).unwrap();
|
||||
assert_eq!(out.len(), 2000 * 2 + 2);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bad_predictor_index_is_an_error() {
|
||||
let mut block = vec![0u8; 64];
|
||||
block[0] = 7;
|
||||
assert!(decode_block(&block, 1, &mut Vec::new()).is_err());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,168 @@
|
||||
//! The ADPCM of Flash (SWF) audio, 2 to 5 bits per sample.
|
||||
//!
|
||||
//! The stream starts with two bits, the code size minus 2. It continues in blocks of 4096 samples
|
||||
//! per channel: each block starts, for every channel, with the first sample (16 bits, signed) and
|
||||
//! the step index (6 bits, 0 to 88), then 4095 codes per channel, interleaved by sample. All fields
|
||||
//! are packed most significant bit first. A code is a sign bit and `bits - 1` magnitude bits; the
|
||||
//! decoder adds `step >> (bits - 1)` plus `step >> k` for each magnitude bit set `k` places below
|
||||
//! the top one, negated when the sign is set, and moves the step index by the adjustment table of
|
||||
//! the code size (negative for small magnitudes, positive for large ones). The last block may
|
||||
//! be shorter.
|
||||
|
||||
use super::{Error, Result, clip16, step_at};
|
||||
use craft_media::bitstream::{BitReader, BitWriter};
|
||||
|
||||
/// Samples per channel in a full block.
|
||||
pub const BLOCK_SAMPLES: usize = 4096;
|
||||
|
||||
/// The index adjustment for each magnitude, per code size.
|
||||
fn adjust(bits: u32) -> &'static [i32] {
|
||||
match bits {
|
||||
2 => &[-1, 2],
|
||||
3 => &[-1, -1, 2, 4],
|
||||
4 => &[-1, -1, -1, -1, 2, 4, 6, 8],
|
||||
_ => &[-1, -1, -1, -1, -1, -1, -1, -1, 1, 2, 4, 6, 8, 10, 13, 16],
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy)]
|
||||
struct State {
|
||||
predictor: i32,
|
||||
index: i32,
|
||||
}
|
||||
|
||||
impl State {
|
||||
fn apply(&mut self, code: u32, bits: u32) -> i16 {
|
||||
let step = step_at(self.index);
|
||||
let mag = code & ((1 << (bits - 1)) - 1);
|
||||
let mut diff = step >> (bits - 1);
|
||||
for k in 0..bits - 1 {
|
||||
if mag & (1 << (bits - 2 - k)) != 0 {
|
||||
diff += step >> k;
|
||||
}
|
||||
}
|
||||
if code & (1 << (bits - 1)) != 0 {
|
||||
diff = -diff;
|
||||
}
|
||||
self.predictor = clip16(self.predictor + diff);
|
||||
self.index = (self.index + adjust(bits).get(mag as usize).copied().unwrap_or(0)).clamp(0, 88);
|
||||
self.predictor as i16
|
||||
}
|
||||
|
||||
fn encode(&mut self, sample: i16, bits: u32) -> u32 {
|
||||
let step = step_at(self.index);
|
||||
let mut diff = i32::from(sample) - self.predictor;
|
||||
let mut code = 0u32;
|
||||
if diff < 0 {
|
||||
code = 1 << (bits - 1);
|
||||
diff = -diff;
|
||||
}
|
||||
let mut s = step;
|
||||
for k in 0..bits - 1 {
|
||||
if diff >= s {
|
||||
code |= 1 << (bits - 2 - k);
|
||||
diff -= s;
|
||||
}
|
||||
s >>= 1;
|
||||
}
|
||||
self.apply(code, bits);
|
||||
code
|
||||
}
|
||||
}
|
||||
|
||||
/// Decode a stream. `channels` is 1 or 2; the code size comes from the stream's first two bits.
|
||||
/// The result holds every sample up to the end of the data (a last block cut short decodes as
|
||||
/// far as it goes).
|
||||
pub fn decode(data: &[u8], channels: usize) -> Result<Vec<i16>> {
|
||||
if !(1..=2).contains(&channels) {
|
||||
return Err(Error::Malformed("Flash ADPCM has one or two channels"));
|
||||
}
|
||||
let mut r = BitReader::new(data);
|
||||
let bits = r.read_bits(2).map_err(|_| Error::Malformed("empty stream"))? + 2;
|
||||
let mut out = Vec::new();
|
||||
let header_bits = channels * 22;
|
||||
while r.bits_left() >= header_bits {
|
||||
let mut states = Vec::with_capacity(channels);
|
||||
for _ in 0..channels {
|
||||
let sample = r.read_bits(16).map_err(|_| Error::Malformed("truncated block"))? as u16 as i16;
|
||||
let index = r.read_bits(6).map_err(|_| Error::Malformed("truncated block"))? as i32;
|
||||
if index > 88 {
|
||||
return Err(Error::Malformed("step index above 88"));
|
||||
}
|
||||
out.push(sample);
|
||||
states.push(State { predictor: i32::from(sample), index });
|
||||
}
|
||||
'block: for _ in 1..BLOCK_SAMPLES {
|
||||
if r.bits_left() < channels * (bits as usize) {
|
||||
break 'block;
|
||||
}
|
||||
for st in states.iter_mut() {
|
||||
match r.read_bits(bits) {
|
||||
Ok(code) => out.push(st.apply(code, bits)),
|
||||
Err(_) => break 'block,
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
/// Encode interleaved samples with `bits` (2 to 5) bits per sample. Blocks hold 4096 samples per
|
||||
/// channel; the stream ends at a byte boundary.
|
||||
pub fn encode(samples: &[i16], channels: usize, bits: u32) -> Result<Vec<u8>> {
|
||||
if !(1..=2).contains(&channels) {
|
||||
return Err(Error::InvalidInput("Flash ADPCM has one or two channels"));
|
||||
}
|
||||
if !(2..=5).contains(&bits) {
|
||||
return Err(Error::InvalidInput("Flash ADPCM codes have 2 to 5 bits"));
|
||||
}
|
||||
if !samples.len().is_multiple_of(channels) {
|
||||
return Err(Error::InvalidInput("the sample count is not a multiple of the channel count"));
|
||||
}
|
||||
let mut w = BitWriter::new();
|
||||
w.write_bits(bits - 2, 2);
|
||||
for block in samples.chunks(BLOCK_SAMPLES * channels) {
|
||||
let mut states = Vec::with_capacity(channels);
|
||||
for ch in 0..channels {
|
||||
let col: Vec<i16> = block.iter().skip(ch).step_by(channels).copied().collect();
|
||||
let first = col.first().copied().unwrap_or(0);
|
||||
// the index whose first codes follow the signal most closely
|
||||
let mut best = (i64::MAX, 0);
|
||||
for index in 0..=63 {
|
||||
let mut st = State { predictor: i32::from(first), index };
|
||||
let mut err = 0i64;
|
||||
for &s in col.iter().skip(1).take(16) {
|
||||
st.encode(s, bits);
|
||||
err += (i64::from(s) - i64::from(st.predictor)).pow(2);
|
||||
}
|
||||
if err < best.0 {
|
||||
best = (err, index);
|
||||
}
|
||||
}
|
||||
w.write_bits(u32::from(first as u16), 16);
|
||||
w.write_bits(best.1 as u32, 6);
|
||||
states.push(State { predictor: i32::from(first), index: best.1 });
|
||||
}
|
||||
for frame in block.chunks(channels).skip(1) {
|
||||
for (st, &s) in states.iter_mut().zip(frame) {
|
||||
w.write_bits(st.encode(s, bits), bits);
|
||||
}
|
||||
}
|
||||
}
|
||||
w.align_zero();
|
||||
Ok(w.finish())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn settings_are_checked() {
|
||||
assert!(encode(&[0], 3, 4).is_err());
|
||||
assert!(encode(&[0], 1, 1).is_err());
|
||||
assert!(encode(&[0], 1, 6).is_err());
|
||||
assert!(decode(&[], 1).is_err());
|
||||
assert!(decode(&[0], 0).is_err());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,113 @@
|
||||
//! Yamaha ADPCM (the ADPCM-B of the YM2608 and the AICA): a raw stream of 4-bit codes, no header.
|
||||
//!
|
||||
//! Each channel starts at predictor 0 and step 127. A code is a sign bit and three magnitude bits;
|
||||
//! the sample moves by `step * [1, 3, 5, 7, 9, 11, 13, 15][magnitude] / 8` (negative when the sign
|
||||
//! is set) and the step is multiplied by `[230, 230, 230, 230, 307, 409, 512, 614][magnitude] / 256`,
|
||||
//! kept within 127 and 24576. One channel: the low nibble of a byte is the first sample. Two
|
||||
//! channels: the low nibble is the left channel and the high nibble the right one of the same
|
||||
//! frame.
|
||||
|
||||
use super::{Error, Result, clip16};
|
||||
|
||||
const SCALE: [i32; 8] = [230, 230, 230, 230, 307, 409, 512, 614];
|
||||
|
||||
#[derive(Clone, Copy)]
|
||||
struct State {
|
||||
predictor: i32,
|
||||
step: i32,
|
||||
}
|
||||
|
||||
impl State {
|
||||
fn new() -> State {
|
||||
State { predictor: 0, step: 127 }
|
||||
}
|
||||
|
||||
fn apply(&mut self, nibble: u8) -> i16 {
|
||||
let m = usize::from(nibble & 7);
|
||||
let diff = self.step * (2 * m as i32 + 1) / 8;
|
||||
self.predictor = clip16(self.predictor + if nibble & 8 != 0 { -diff } else { diff });
|
||||
self.step = ((self.step * SCALE.get(m).copied().unwrap_or(256)) >> 8).clamp(127, 24_576);
|
||||
self.predictor as i16
|
||||
}
|
||||
|
||||
fn encode(&mut self, sample: i16) -> u8 {
|
||||
let err = i32::from(sample) - self.predictor;
|
||||
let m = (err.abs() * 8 / self.step / 2).clamp(0, 7);
|
||||
// the magnitude whose reconstruction (2m + 1) * step / 8 is nearest
|
||||
let mut best = (i32::MAX, 0u8);
|
||||
for cand in [m - 1, m, m + 1] {
|
||||
let c = cand.clamp(0, 7);
|
||||
let recon = self.step * (2 * c + 1) / 8;
|
||||
let e = (err.abs() - recon).abs();
|
||||
if e < best.0 {
|
||||
best = (e, c as u8);
|
||||
}
|
||||
}
|
||||
let nibble = best.1 | if err < 0 { 8 } else { 0 };
|
||||
self.apply(nibble);
|
||||
nibble
|
||||
}
|
||||
}
|
||||
|
||||
/// Decode a stream of `channels` (1 or 2) interleaved channels.
|
||||
pub fn decode(data: &[u8], channels: usize) -> Result<Vec<i16>> {
|
||||
if !(1..=2).contains(&channels) {
|
||||
return Err(Error::Malformed("Yamaha ADPCM has one or two channels"));
|
||||
}
|
||||
let mut states = vec![State::new(); channels];
|
||||
let mut out = Vec::with_capacity(data.len() * 2);
|
||||
let mut t = 0usize;
|
||||
for byte in data {
|
||||
for nibble in [byte & 0xF, byte >> 4] {
|
||||
if let Some(st) = states.get_mut(t % channels) {
|
||||
out.push(st.apply(nibble));
|
||||
}
|
||||
t += 1;
|
||||
}
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
/// Encode interleaved samples. With two channels the frame count must be whole bytes, which it
|
||||
/// always is; with one channel an odd count is padded with a copy of the last sample.
|
||||
pub fn encode(samples: &[i16], channels: usize) -> Result<Vec<u8>> {
|
||||
if !(1..=2).contains(&channels) {
|
||||
return Err(Error::InvalidInput("Yamaha ADPCM has one or two channels"));
|
||||
}
|
||||
if !samples.len().is_multiple_of(channels) {
|
||||
return Err(Error::InvalidInput("the sample count is not a multiple of the channel count"));
|
||||
}
|
||||
let mut states = vec![State::new(); channels];
|
||||
let mut out = Vec::with_capacity(samples.len().div_ceil(2));
|
||||
let mut t = 0usize;
|
||||
let mut padded = samples.to_vec();
|
||||
if padded.len() % 2 == 1 {
|
||||
padded.push(padded.last().copied().unwrap_or(0));
|
||||
}
|
||||
for pair in padded.chunks(2) {
|
||||
let mut byte = 0u8;
|
||||
for (half, &s) in pair.iter().enumerate() {
|
||||
let code = match states.get_mut(t % channels) {
|
||||
Some(st) => st.encode(s),
|
||||
None => 0,
|
||||
};
|
||||
byte |= code << (4 * half);
|
||||
t += 1;
|
||||
}
|
||||
out.push(byte);
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn channel_count_is_checked() {
|
||||
assert!(decode(&[0], 0).is_err());
|
||||
assert!(decode(&[0], 3).is_err());
|
||||
assert!(encode(&[0], 3).is_err());
|
||||
assert!(encode(&[0, 0, 0], 2).is_err());
|
||||
}
|
||||
}
|
||||
@@ -30,7 +30,8 @@
|
||||
//! `aac-encode`), [`alac`] (`alac-decode`, `alac-encode`), [`opus`] (`opus-decode`, and
|
||||
//! [`opus::encoder`] with `opus-encode`), [`ac3`] (`ac3-decode`), [`mpa`] (`mpa-decode`; `mpa-encode`: the Layer II encoder), [`mp3`]
|
||||
//! (`mp3-decode`, `mp3-encode`), [`flac`] (`flac-decode`: the frame and file decoder;
|
||||
//! `flac-encode`: the packet encoder), [`qoa`] (`qoa-decode`, `qoa-encode`: whole QOA files),
|
||||
//! `flac-encode`: the packet encoder), [`qoa`] (`qoa-decode`, `qoa-encode`: whole QOA files), [`adpcm`]
|
||||
//! (`adpcm`: IMA WAV, Microsoft, Yamaha and Flash ADPCM),
|
||||
//! [`gsm`] (`gsm-decode`, `gsm-encode`: GSM 06.10 full-rate speech), [`vmd`] (`vmd-decode`:
|
||||
//! Sierra VMD sound).
|
||||
//!
|
||||
@@ -40,6 +41,8 @@
|
||||
pub mod aac;
|
||||
#[cfg(any(feature = "ac3-decode", feature = "ac3-encode", feature = "eac3-encode"))]
|
||||
pub mod ac3;
|
||||
#[cfg(feature = "adpcm")]
|
||||
pub mod adpcm;
|
||||
#[cfg(any(feature = "alac-decode", feature = "alac-encode"))]
|
||||
pub mod alac;
|
||||
mod buffer;
|
||||
|
||||
@@ -0,0 +1,516 @@
|
||||
//! ADPCM (feature `adpcm`): every family decodes what ffmpeg's encoder writes to ffmpeg's own
|
||||
//! samples, and ffmpeg decodes what our encoder writes to our own decoder's samples (oracle;
|
||||
//! skipped when ffmpeg is absent, a failure with `CRAFT_MEDIA_REQUIRE_ORACLES=1`); plus the
|
||||
//! round trip through our own encoder and decoder, and damaged input.
|
||||
|
||||
use craft_audio::adpcm::{ima, ms, swf, yamaha};
|
||||
use std::path::Path;
|
||||
use std::process::Command;
|
||||
|
||||
const RATE: u32 = 22_050;
|
||||
|
||||
/// Interleaved test audio: tones, a sweep, noise bursts, silence and a full-scale square.
|
||||
fn signal(channels: usize, frames: usize) -> Vec<i16> {
|
||||
let mut seed = 0x2545_F491u32;
|
||||
let mut out = Vec::with_capacity(frames * channels);
|
||||
for i in 0..frames {
|
||||
for c in 0..channels {
|
||||
seed ^= seed << 13;
|
||||
seed ^= seed >> 17;
|
||||
seed ^= seed << 5;
|
||||
let t = i as f64;
|
||||
let v = match (i / 1500) % 5 {
|
||||
0 => (t * (0.03 + 0.011 * c as f64)).sin() * 9000.0,
|
||||
1 => (t * 0.002 * (1.0 + t / 3000.0)).sin() * 14000.0,
|
||||
2 => f64::from(seed % 12000) - 6000.0,
|
||||
3 => 0.0,
|
||||
_ => {
|
||||
if (i / 40) % 2 == 0 {
|
||||
20000.0
|
||||
} else {
|
||||
-20000.0
|
||||
}
|
||||
}
|
||||
};
|
||||
out.push(v as i16);
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
fn snr(a: &[i16], b: &[i16]) -> f64 {
|
||||
let (mut s, mut n) = (0f64, 0f64);
|
||||
for (x, y) in a.iter().zip(b) {
|
||||
s += f64::from(*x).powi(2);
|
||||
n += (f64::from(*x) - f64::from(*y)).powi(2);
|
||||
}
|
||||
10.0 * (s / n.max(1.0)).log10()
|
||||
}
|
||||
|
||||
fn max_diff(a: &[i16], b: &[i16]) -> i32 {
|
||||
a.iter().zip(b).map(|(x, y)| (i32::from(*x) - i32::from(*y)).abs()).max().unwrap_or(0)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn encode_then_decode_is_close_to_the_input() {
|
||||
for channels in [1usize, 2] {
|
||||
let x = signal(channels, 20_000);
|
||||
// (name, decoded, minimum SNR dB, a few dB under what each reaches): the signal has noise bursts
|
||||
// and full-scale square waves, which codes this small follow loosely
|
||||
let cases: Vec<(&str, Vec<i16>, f64)> = vec![
|
||||
("ima", ima::decode(&ima::encode(&x, channels, 512).unwrap(), channels, 512).unwrap(), 5.0),
|
||||
("ms", ms::decode(&ms::encode(&x, channels, 512).unwrap(), channels, 512).unwrap(), 18.0),
|
||||
("yamaha", yamaha::decode(&yamaha::encode(&x, channels).unwrap(), channels).unwrap(), 5.0),
|
||||
("swf2", swf::decode(&swf::encode(&x, channels, 2).unwrap(), channels).unwrap(), 1.0),
|
||||
("swf3", swf::decode(&swf::encode(&x, channels, 3).unwrap(), channels).unwrap(), 3.0),
|
||||
("swf4", swf::decode(&swf::encode(&x, channels, 4).unwrap(), channels).unwrap(), 5.0),
|
||||
("swf5", swf::decode(&swf::encode(&x, channels, 5).unwrap(), channels).unwrap(), 7.0),
|
||||
];
|
||||
for (name, y, min) in cases {
|
||||
assert!(y.len() >= x.len(), "{name}: {} samples for {}", y.len(), x.len());
|
||||
let s = snr(&x, &y[..x.len()]);
|
||||
println!("{name} {channels}ch: SNR {s:.1} dB");
|
||||
assert!(s >= min, "{name} {channels}ch: SNR {s:.1} dB under {min}");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn damaged_input_is_an_error_or_decodes_never_panics() {
|
||||
let x = signal(2, 4000);
|
||||
let streams: Vec<(&str, Vec<u8>)> = vec![
|
||||
("ima", ima::encode(&x, 2, 256).unwrap()),
|
||||
("ms", ms::encode(&x, 2, 256).unwrap()),
|
||||
("yamaha", yamaha::encode(&x, 2).unwrap()),
|
||||
("swf", swf::encode(&x, 2, 4).unwrap()),
|
||||
];
|
||||
let mut seed = 99u32;
|
||||
for (name, s) in &streams {
|
||||
for cut in (0..s.len()).step_by(7) {
|
||||
let part = &s[..cut];
|
||||
let _ = match *name {
|
||||
"ima" => ima::decode(part, 2, 256).map(drop),
|
||||
"ms" => ms::decode(part, 2, 256).map(drop),
|
||||
"yamaha" => yamaha::decode(part, 2).map(drop),
|
||||
_ => swf::decode(part, 2).map(drop),
|
||||
};
|
||||
}
|
||||
for _ in 0..300 {
|
||||
let mut d = s.clone();
|
||||
seed ^= seed << 13;
|
||||
seed ^= seed >> 17;
|
||||
seed ^= seed << 5;
|
||||
let at = seed as usize % d.len();
|
||||
d[at] ^= (seed >> 8) as u8 | 1;
|
||||
let _ = match *name {
|
||||
"ima" => ima::decode(&d, 2, 256).map(drop),
|
||||
"ms" => ms::decode(&d, 2, 256).map(drop),
|
||||
"yamaha" => yamaha::decode(&d, 2).map(drop),
|
||||
_ => swf::decode(&d, 2).map(drop),
|
||||
};
|
||||
}
|
||||
}
|
||||
// the impossible layouts
|
||||
assert!(ima::decode(&[0; 10], 2, 10).is_err());
|
||||
assert!(ima::decode(&[0; 8], 9, 8).is_err());
|
||||
assert!(ms::decode(&[0; 8], 3, 8).is_err());
|
||||
assert!(ima::encode(&[0; 3], 2, 256).is_err());
|
||||
assert!(ima::encode_block(&[0; 3], 1, 256).is_err());
|
||||
assert!(ms::encode_block(&[0; 3], 1, 256).is_err());
|
||||
// a block whose step index or predictor is out of range
|
||||
let mut bad = ima::encode_block(&vec![0; 505], 1, 256).unwrap();
|
||||
bad[2] = 200;
|
||||
assert!(ima::decode_block(&bad, 1, &mut Vec::new()).is_err());
|
||||
let mut bad = swf::encode(&[0; 10], 1, 4).unwrap();
|
||||
bad[2] = 0xFF;
|
||||
let _ = swf::decode(&bad, 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn huge_layouts_and_big_jumps_are_handled() {
|
||||
// block sizes whose sample counts do not fit in a usize
|
||||
assert_eq!(ima::samples_per_block(usize::MAX - 3, 1), None);
|
||||
assert_eq!(ms::samples_per_block(usize::MAX, 1), None);
|
||||
assert!(ima::encode(&[], 1, usize::MAX - 3).is_err());
|
||||
assert!(ms::encode(&[], 1, usize::MAX).is_err());
|
||||
// a Flash stream's header holds the step index in six bits: a jump from silence to full scale
|
||||
// still decodes to what the encoder's own state says
|
||||
for bits in [2u32, 3, 4, 5] {
|
||||
let x = [0i16, 32767, -32768, 0, 0];
|
||||
let y = swf::decode(&swf::encode(&x, 1, bits).unwrap(), 1).unwrap();
|
||||
// the stream has no length: up to seven padding bits can read as one more code
|
||||
assert!((x.len()..=x.len() + 3).contains(&y.len()), "{bits} bits: {} samples", y.len());
|
||||
assert!(y[1] > 0 && y[2] < y[1], "{bits} bits: {y:?}");
|
||||
}
|
||||
// padding bits at the end of a stream are not a code: no incomplete stereo frame
|
||||
for bits in [2u32, 3, 4, 5] {
|
||||
let y = swf::decode(&swf::encode(&[0, 0, 5, -5, 9, 9], 2, bits).unwrap(), 2).unwrap();
|
||||
assert_eq!(y.len() % 2, 0, "{bits} bits: {y:?}");
|
||||
assert!((6..=8).contains(&y.len()), "{bits} bits: {} samples", y.len());
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn partial_final_blocks_are_handled() {
|
||||
let x = signal(1, 1000);
|
||||
// IMA: 256-byte blocks hold 505 samples; 1000 samples is two blocks, the second padded
|
||||
let enc = ima::encode(&x, 1, 256).unwrap();
|
||||
assert_eq!(enc.len(), 2 * 256);
|
||||
assert_eq!(ima::decode(&enc, 1, 256).unwrap().len(), 1010);
|
||||
// a stream cut inside the last block decodes as far as it goes
|
||||
let cut = ima::decode(&enc[..256 + 4 + 40], 1, 256).unwrap();
|
||||
assert_eq!(cut.len(), 505 + 1 + 80);
|
||||
let enc = ms::encode(&x, 1, 256).unwrap();
|
||||
assert_eq!(ms::decode(&enc, 1, 256).unwrap().len(), 1000);
|
||||
assert!(ima::encode(&[], 1, 256).unwrap().is_empty());
|
||||
assert!(ms::encode(&[], 1, 256).unwrap().is_empty());
|
||||
assert!(yamaha::encode(&[], 1).unwrap().is_empty());
|
||||
assert_eq!(yamaha::decode(&yamaha::encode(&[5, 6, 7], 1).unwrap(), 1).unwrap().len(), 4);
|
||||
}
|
||||
|
||||
// ---- the other rounding some ffmpeg versions use for IMA and Flash ADPCM
|
||||
//
|
||||
// The IMA recommended practices build the step difference from `step >> 3` and the shifted steps
|
||||
// of the magnitude bits that are set; some decoders (including older ffmpeg releases) compute
|
||||
// `((2 * magnitude + 1) * step) >> (bits - 1)` instead, which rounds differently by a few units
|
||||
// and so drifts apart through the predictor. A stream decodes to ours or to this one.
|
||||
|
||||
fn alt_diff(mag: i32, step: i32, bits: u32) -> i32 {
|
||||
((2 * mag + 1) * step) >> (bits - 1)
|
||||
}
|
||||
|
||||
const INDEX_4: [i32; 8] = [-1, -1, -1, -1, 2, 4, 6, 8];
|
||||
const INDEX_5: [i32; 16] = [-1, -1, -1, -1, -1, -1, -1, -1, 1, 2, 4, 6, 8, 10, 13, 16];
|
||||
const STEPS: [i32; 89] = [
|
||||
7, 8, 9, 10, 11, 12, 13, 14, 16, 17, 19, 21, 23, 25, 28, 31, 34, 37, 41, 45, 50, 55, 60, 66, 73, 80, 88, 97, 107, 118, 130, 143, 157, 173, 190,
|
||||
209, 230, 253, 279, 307, 337, 371, 408, 449, 494, 544, 598, 658, 724, 796, 876, 963, 1060, 1166, 1282, 1411, 1552, 1707, 1878, 2066, 2272, 2499,
|
||||
2749, 3024, 3327, 3660, 4026, 4428, 4871, 5358, 5894, 6484, 7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899, 15289, 16818, 18500, 20350,
|
||||
22385, 24623, 27086, 29794, 32767,
|
||||
];
|
||||
|
||||
fn index_table(bits: u32) -> &'static [i32] {
|
||||
match bits {
|
||||
2 => &[-1, 2],
|
||||
3 => &[-1, -1, 2, 4],
|
||||
4 => &INDEX_4,
|
||||
_ => &INDEX_5,
|
||||
}
|
||||
}
|
||||
|
||||
/// `ima::decode` with the other rounding.
|
||||
fn alt_ima_decode(data: &[u8], channels: usize, block_align: usize) -> Vec<i16> {
|
||||
let per = ima::samples_per_block(block_align, channels).expect("layout");
|
||||
let mut out = Vec::new();
|
||||
for block in data.chunks_exact(block_align) {
|
||||
let mut pred = vec![0i32; channels];
|
||||
let mut idx = vec![0i32; channels];
|
||||
let base = out.len();
|
||||
out.resize(base + per * channels, 0);
|
||||
for ch in 0..channels {
|
||||
pred[ch] = i32::from(i16::from_le_bytes([block[4 * ch], block[4 * ch + 1]]));
|
||||
idx[ch] = i32::from(block[4 * ch + 2]);
|
||||
out[base + ch] = pred[ch] as i16;
|
||||
}
|
||||
for (g, group) in block[4 * channels..].chunks_exact(4 * channels).enumerate() {
|
||||
for (ch, bytes) in group.as_chunks::<4>().0.iter().enumerate() {
|
||||
for (k, b) in bytes.iter().enumerate() {
|
||||
for (half, nib) in [b & 0xF, b >> 4].into_iter().enumerate() {
|
||||
let step = STEPS[idx[ch] as usize];
|
||||
let d = alt_diff(i32::from(nib & 7), step, 4);
|
||||
pred[ch] = (pred[ch] + if nib & 8 != 0 { -d } else { d }).clamp(-32768, 32767);
|
||||
idx[ch] = (idx[ch] + INDEX_4[usize::from(nib & 7)]).clamp(0, 88);
|
||||
out[base + (1 + g * 8 + k * 2 + half) * channels + ch] = pred[ch] as i16;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// `swf::decode` with the other rounding (one stream).
|
||||
fn alt_swf_decode(data: &[u8], channels: usize) -> Vec<i16> {
|
||||
let mut bitpos = 0usize;
|
||||
let mut get = |n: usize| -> Option<u32> {
|
||||
let mut v = 0u32;
|
||||
for _ in 0..n {
|
||||
let byte = *data.get(bitpos / 8)?;
|
||||
v = (v << 1) | u32::from((byte >> (7 - bitpos % 8)) & 1);
|
||||
bitpos += 1;
|
||||
}
|
||||
Some(v)
|
||||
};
|
||||
let bits = get(2).expect("header") + 2;
|
||||
let mut out = Vec::new();
|
||||
loop {
|
||||
let mut pred = Vec::new();
|
||||
let mut idx = Vec::new();
|
||||
for _ in 0..channels {
|
||||
let (Some(p), Some(i)) = (get(16), get(6)) else { return out };
|
||||
out.push(p as u16 as i16);
|
||||
pred.push(i32::from(p as u16 as i16));
|
||||
idx.push(i as i32);
|
||||
}
|
||||
for _ in 1..4096 {
|
||||
for ch in 0..channels {
|
||||
let Some(code) = get(bits as usize) else { return out };
|
||||
let mag = (code & ((1 << (bits - 1)) - 1)) as i32;
|
||||
let d = alt_diff(mag, STEPS[idx[ch] as usize], bits);
|
||||
pred[ch] = (pred[ch] + if code >> (bits - 1) != 0 { -d } else { d }).clamp(-32768, 32767);
|
||||
idx[ch] = (idx[ch] + index_table(bits)[mag as usize]).clamp(0, 88);
|
||||
out.push(pred[ch] as i16);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Assert `theirs` is `ours` or `alt` over their common length (and say which).
|
||||
fn same_as_either(what: &str, ours: &[i16], alt: &[i16], theirs: &[i16]) {
|
||||
let n = ours.len().min(theirs.len());
|
||||
let (a, b) = (max_diff(&ours[..n], &theirs[..n]), max_diff(&alt[..n.min(alt.len())], &theirs[..n.min(alt.len())]));
|
||||
println!("{what}: largest difference from ours {a}, from the other rounding {b}");
|
||||
assert!(a == 0 || b == 0, "{what}: ffmpeg's decode is neither ours ({a}) nor the other rounding ({b})");
|
||||
}
|
||||
|
||||
/// A name, the WAV file around our stream, our decode of it and the other rounding's.
|
||||
type Stream = (&'static str, Vec<u8>, Vec<i16>, Vec<i16>);
|
||||
|
||||
// ---- ffmpeg as the reference
|
||||
|
||||
fn ffmpeg(ff: &Path, args: &[&str]) {
|
||||
let out = Command::new(ff).args(["-v", "error", "-nostdin", "-y"]).args(args).output().expect("run ffmpeg");
|
||||
assert!(out.status.success(), "ffmpeg {args:?}: {}", String::from_utf8_lossy(&out.stderr));
|
||||
}
|
||||
|
||||
fn s(p: &Path) -> String {
|
||||
p.to_str().expect("path").to_string()
|
||||
}
|
||||
|
||||
fn write_pcm(path: &Path, x: &[i16]) {
|
||||
std::fs::write(path, x.iter().flat_map(|v| v.to_le_bytes()).collect::<Vec<u8>>()).expect("write");
|
||||
}
|
||||
|
||||
fn read_pcm(path: &Path) -> Vec<i16> {
|
||||
std::fs::read(path).expect("read").as_chunks::<2>().0.iter().map(|b| i16::from_le_bytes(*b)).collect()
|
||||
}
|
||||
|
||||
/// The `fmt ` chunk's fields and the `data` chunk of a WAV file.
|
||||
fn wav_parts(bytes: &[u8]) -> (u16, usize, usize, Vec<u8>) {
|
||||
let mut at = 12;
|
||||
let (mut tag, mut channels, mut align) = (0, 0, 0);
|
||||
while at + 8 <= bytes.len() {
|
||||
let id = &bytes[at..at + 4];
|
||||
let len = u32::from_le_bytes([bytes[at + 4], bytes[at + 5], bytes[at + 6], bytes[at + 7]]) as usize;
|
||||
let body = &bytes[at + 8..(at + 8 + len).min(bytes.len())];
|
||||
if id == b"fmt " {
|
||||
tag = u16::from_le_bytes([body[0], body[1]]);
|
||||
channels = usize::from(u16::from_le_bytes([body[2], body[3]]));
|
||||
align = usize::from(u16::from_le_bytes([body[12], body[13]]));
|
||||
} else if id == b"data" {
|
||||
return (tag, channels, align, body.to_vec());
|
||||
}
|
||||
at += 8 + len + (len & 1);
|
||||
}
|
||||
panic!("no data chunk");
|
||||
}
|
||||
|
||||
/// A WAV file around `data`.
|
||||
fn wav(tag: u16, channels: usize, align: usize, bits: u16, extra: &[u8], data: &[u8]) -> Vec<u8> {
|
||||
let mut fmt = Vec::new();
|
||||
fmt.extend(tag.to_le_bytes());
|
||||
fmt.extend((channels as u16).to_le_bytes());
|
||||
fmt.extend(RATE.to_le_bytes());
|
||||
fmt.extend((RATE * align as u32 / 500).to_le_bytes());
|
||||
fmt.extend((align as u16).to_le_bytes());
|
||||
fmt.extend(bits.to_le_bytes());
|
||||
if !extra.is_empty() || tag == 0x11 || tag == 2 {
|
||||
fmt.extend((extra.len() as u16).to_le_bytes());
|
||||
fmt.extend(extra);
|
||||
}
|
||||
let mut out = b"RIFF".to_vec();
|
||||
out.extend((4 + 8 + fmt.len() as u32 + 8 + data.len() as u32).to_le_bytes());
|
||||
out.extend(b"WAVEfmt ");
|
||||
out.extend((fmt.len() as u32).to_le_bytes());
|
||||
out.extend(fmt);
|
||||
out.extend(b"data");
|
||||
out.extend((data.len() as u32).to_le_bytes());
|
||||
out.extend(data);
|
||||
out
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn we_decode_what_ffmpeg_encodes_to_the_samples_ffmpeg_decodes() {
|
||||
let Some(ff) = craft_media_testkit::ffmpeg() else { return };
|
||||
let dir = craft_media_testkit::fixture_subdir("adpcm");
|
||||
for channels in [1usize, 2] {
|
||||
let x = signal(channels, 30_000);
|
||||
let pcm = dir.join(format!("in{channels}.pcm"));
|
||||
write_pcm(&pcm, &x);
|
||||
let input = ["-f", "s16le", "-ar", "22050", "-ac", if channels == 1 { "1" } else { "2" }, "-i"];
|
||||
for (name, codec, align) in [("ima", "adpcm_ima_wav", 512usize), ("ms", "adpcm_ms", 512), ("yamaha", "adpcm_yamaha", 0)] {
|
||||
let file = dir.join(format!("{name}{channels}.wav"));
|
||||
let mut args: Vec<String> = input.iter().map(|a| a.to_string()).collect();
|
||||
args.extend([s(&pcm), "-c:a".into(), codec.into()]);
|
||||
if align > 0 {
|
||||
args.extend(["-block_size".into(), align.to_string()]);
|
||||
}
|
||||
args.push(s(&file));
|
||||
ffmpeg(&ff, &args.iter().map(String::as_str).collect::<Vec<_>>());
|
||||
let back = dir.join(format!("{name}{channels}.out.pcm"));
|
||||
ffmpeg(&ff, &["-i", &s(&file), "-f", "s16le", "-acodec", "pcm_s16le", &s(&back)]);
|
||||
let theirs = read_pcm(&back);
|
||||
let (tag, ch, block, data) = wav_parts(&std::fs::read(&file).expect("read"));
|
||||
assert_eq!(ch, channels);
|
||||
let ours = match name {
|
||||
"ima" => {
|
||||
assert_eq!(tag, 0x11);
|
||||
ima::decode(&data, ch, block).expect("decode")
|
||||
}
|
||||
"ms" => {
|
||||
assert_eq!(tag, 2);
|
||||
ms::decode(&data, ch, block).expect("decode")
|
||||
}
|
||||
_ => yamaha::decode(&data, ch).expect("decode"),
|
||||
};
|
||||
let n = ours.len().min(theirs.len());
|
||||
assert!(n >= 29_000 * channels, "{name} {channels}ch: {} ours, {} theirs", ours.len(), theirs.len());
|
||||
if name == "ima" {
|
||||
same_as_either(&format!("{name} {channels}ch"), &ours, &alt_ima_decode(&data, ch, block), &theirs);
|
||||
} else {
|
||||
let d = max_diff(&ours[..n], &theirs[..n]);
|
||||
println!("{name} {channels}ch: {n} samples, largest difference from ffmpeg's decode {d}");
|
||||
assert_eq!(d, 0, "{name} {channels}ch");
|
||||
}
|
||||
// our encoder is as good as ffmpeg's on the same audio, to within 3 dB
|
||||
let mine = match name {
|
||||
"ima" => ima::decode(&ima::encode(&x, ch, block).expect("encode"), ch, block).expect("decode"),
|
||||
"ms" => ms::decode(&ms::encode(&x, ch, block).expect("encode"), ch, block).expect("decode"),
|
||||
_ => yamaha::decode(&yamaha::encode(&x, ch).expect("encode"), ch).expect("decode"),
|
||||
};
|
||||
let m = x.len().min(mine.len()).min(theirs.len());
|
||||
let (a, b) = (snr(&x[..m], &mine[..m]), snr(&x[..m], &theirs[..m]));
|
||||
println!("{name} {channels}ch: SNR {a:.1} dB ours, {b:.1} dB ffmpeg's");
|
||||
assert!(a + 3.0 >= b, "{name} {channels}ch: our encoder {a:.1} dB against ffmpeg's {b:.1} dB");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ffmpeg_decodes_what_we_encode_to_the_samples_we_decode() {
|
||||
let Some(ff) = craft_media_testkit::ffmpeg() else { return };
|
||||
let dir = craft_media_testkit::fixture_subdir("adpcm");
|
||||
for channels in [1usize, 2] {
|
||||
let x = signal(channels, 12_000);
|
||||
let coefs: Vec<u8> = ms::COEFFICIENTS.iter().flat_map(|&(a, b)| [a as i16, b as i16].into_iter().flat_map(i16::to_le_bytes)).collect();
|
||||
let streams: Vec<Stream> = {
|
||||
let e = ima::encode(&x, channels, 512).unwrap();
|
||||
let per = ima::samples_per_block(512, channels).unwrap() as u16;
|
||||
let d = ima::decode(&e, channels, 512).unwrap();
|
||||
let d_alt = alt_ima_decode(&e, channels, 512);
|
||||
let ima_wav = wav(0x11, channels, 512, 4, &per.to_le_bytes(), &e);
|
||||
let e = ms::encode(&x, channels, 512).unwrap();
|
||||
let per = ms::samples_per_block(512, channels).unwrap() as u16;
|
||||
let d2 = ms::decode(&e, channels, 512).unwrap();
|
||||
let mut extra = per.to_le_bytes().to_vec();
|
||||
extra.extend(7u16.to_le_bytes());
|
||||
extra.extend(&coefs);
|
||||
let ms_wav = wav(2, channels, 512, 4, &extra, &e);
|
||||
let e = yamaha::encode(&x, channels).unwrap();
|
||||
let d3 = yamaha::decode(&e, channels).unwrap();
|
||||
let y_wav = wav(0x20, channels, 512 * channels, 4, &[], &e);
|
||||
vec![("ima", ima_wav, d, d_alt), ("ms", ms_wav, d2.clone(), d2), ("yamaha", y_wav, d3.clone(), d3)]
|
||||
};
|
||||
for (name, bytes, ours, alt) in streams {
|
||||
let file = dir.join(format!("our_{name}{channels}.wav"));
|
||||
std::fs::write(&file, bytes).expect("write");
|
||||
let back = dir.join(format!("our_{name}{channels}.pcm"));
|
||||
ffmpeg(&ff, &["-i", &s(&file), "-f", "s16le", "-acodec", "pcm_s16le", &s(&back)]);
|
||||
let theirs = read_pcm(&back);
|
||||
let n = ours.len().min(theirs.len());
|
||||
assert!(n + 2048 >= ours.len(), "{name} {channels}ch: ffmpeg decoded {} of {}", theirs.len(), ours.len());
|
||||
same_as_either(&format!("{name} {channels}ch, our stream"), &ours, &alt, &theirs);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// The audio tags of an FLV file: each tag's body without its flags byte.
|
||||
fn flv_audio(bytes: &[u8]) -> Vec<Vec<u8>> {
|
||||
let mut at = 13;
|
||||
let mut out = Vec::new();
|
||||
while at + 11 <= bytes.len() {
|
||||
let kind = bytes[at];
|
||||
let len = (usize::from(bytes[at + 1]) << 16) | (usize::from(bytes[at + 2]) << 8) | usize::from(bytes[at + 3]);
|
||||
let body = &bytes[at + 11..(at + 11 + len).min(bytes.len())];
|
||||
if kind == 8 && body.len() > 1 {
|
||||
assert_eq!(body[0] >> 4, 1, "SWF ADPCM tag");
|
||||
out.push(body[1..].to_vec());
|
||||
}
|
||||
at += 11 + len + 4;
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// An FLV file of 44.1 kHz audio tags with these ADPCM bodies.
|
||||
fn flv(stereo: bool, tags: &[Vec<u8>]) -> Vec<u8> {
|
||||
let mut out = b"FLV\x01\x04\0\0\0\x09\0\0\0\0".to_vec();
|
||||
let flags = (1u8 << 4) | (3 << 2) | (1 << 1) | u8::from(stereo);
|
||||
for (i, t) in tags.iter().enumerate() {
|
||||
let len = t.len() + 1;
|
||||
let ts = (i * 4096 * 1000 / 44_100) as u32;
|
||||
out.extend([
|
||||
8,
|
||||
(len >> 16) as u8,
|
||||
(len >> 8) as u8,
|
||||
len as u8,
|
||||
(ts >> 16) as u8,
|
||||
(ts >> 8) as u8,
|
||||
ts as u8,
|
||||
(ts >> 24) as u8,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
flags,
|
||||
]);
|
||||
out.extend(t);
|
||||
out.extend((len as u32 + 11).to_be_bytes());
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn flash_adpcm_matches_ffmpeg_in_both_directions() {
|
||||
let Some(ff) = craft_media_testkit::ffmpeg() else { return };
|
||||
let dir = craft_media_testkit::fixture_subdir("adpcm");
|
||||
for channels in [1usize, 2] {
|
||||
let x = signal(channels, 4096 * 3);
|
||||
let pcm = dir.join(format!("swf_in{channels}.pcm"));
|
||||
write_pcm(&pcm, &x);
|
||||
// ffmpeg encodes (it needs 44.1 kHz for FLV)
|
||||
let file = dir.join(format!("swf{channels}.flv"));
|
||||
ffmpeg(&ff, &["-f", "s16le", "-ar", "44100", "-ac", &channels.to_string(), "-i", &s(&pcm), "-c:a", "adpcm_swf", "-f", "flv", &s(&file)]);
|
||||
let tags = flv_audio(&std::fs::read(&file).expect("read"));
|
||||
assert!(tags.len() >= 3, "{} tags", tags.len());
|
||||
let back = dir.join(format!("swf{channels}.out.pcm"));
|
||||
ffmpeg(&ff, &["-i", &s(&file), "-f", "s16le", "-acodec", "pcm_s16le", &s(&back)]);
|
||||
let theirs = read_pcm(&back);
|
||||
let ours: Vec<i16> = tags.iter().flat_map(|t| swf::decode(t, channels).expect("decode")).collect();
|
||||
assert_eq!(ours.len(), 4096 * 3 * channels);
|
||||
assert_eq!(theirs.len(), 4096 * 3 * channels);
|
||||
let alt: Vec<i16> = tags.iter().flat_map(|t| alt_swf_decode(t, channels)).collect();
|
||||
same_as_either(&format!("swf {channels}ch"), &ours, &alt, &theirs);
|
||||
// ffmpeg decodes ours, one 4096-sample stream per tag
|
||||
for bits in [2u32, 3, 4, 5] {
|
||||
let tags: Vec<Vec<u8>> = x.chunks(4096 * channels).map(|c| swf::encode(c, channels, bits).expect("encode")).collect();
|
||||
let ours: Vec<i16> = tags.iter().flat_map(|t| swf::decode(t, channels).expect("decode")).collect();
|
||||
let file = dir.join(format!("our_swf{channels}_{bits}.flv"));
|
||||
std::fs::write(&file, flv(channels == 2, &tags)).expect("write");
|
||||
let back = dir.join(format!("our_swf{channels}_{bits}.pcm"));
|
||||
ffmpeg(&ff, &["-i", &s(&file), "-f", "s16le", "-acodec", "pcm_s16le", &s(&back)]);
|
||||
let theirs = read_pcm(&back);
|
||||
assert_eq!(ours.len(), 4096 * 3 * channels);
|
||||
assert_eq!(theirs.len(), 4096 * 3 * channels);
|
||||
let alt: Vec<i16> = tags.iter().flat_map(|t| alt_swf_decode(t, channels)).collect();
|
||||
same_as_either(&format!("swf {channels}ch {bits} bits, our stream"), &ours, &alt, &theirs);
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user