EffectCraft: An open-source motion graphics and compositing tool written by scratch in pure Rust
Media: downmix AAC in the order its channel configuration decodes in (#1701)
tylerjenningsw8bb5dbb81e86
diff --git a/Cargo.lock b/Cargo.lockindex d7b774557..627da7cf4 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -1632,6 +1632,7 @@ dependencies = ["effectcraft-svg","effectcraft-time","exr",+ "filmcraft-aac","filmcraft-codecs","filmcraft-color","filmcraft-frame",diff --git a/crates/media/Cargo.toml b/crates/media/Cargo.tomlindex 923a28afa..d3f815bba 100644--- a/crates/media/Cargo.toml+++ b/crates/media/Cargo.toml@@ -21,6 +21,7 @@ effectcraft-pdf = { workspace = true }effectcraft-model = { workspace = true }filmcraft-codecs = { workspace = true }filmcraft-media = { workspace = true }+filmcraft-aac = { workspace = true }filmcraft-isobmff = { workspace = true }filmcraft-frame = { workspace = true }filmcraft-color = { workspace = true }diff --git a/crates/media/src/downmix.rs b/crates/media/src/downmix.rsindex 1ad9721ba..745f28065 100644--- a/crates/media/src/downmix.rs+++ b/crates/media/src/downmix.rs@@ -12,9 +12,10 @@//!//! Channel order follows the WAVE / SMPTE convention by channel count (what FilmCraft's AC-3, PCM,//! FLAC and Opus readers deliver): 3 = L R C, 4 = quad L R Ls Rs, 5 = L R C Ls Rs,-//! 6 = L R C LFE Ls Rs, 7 = L R C LFE Cs Ls Rs, 8 = L R C LFE Lb Rb Ls Rs. FilmCraft's AAC-LC-//! decoder instead delivers AAC's own order (C L R first, LFE last), so AAC gets its own tables.-//! More than 8 channels carry no known layout: only the first two (front L/R) are used.+//! 6 = L R C LFE Ls Rs, 7 = L R C LFE Cs Ls Rs, 8 = L R C LFE Lb Rb Ls Rs. AAC arrives in either+//! that order or AAC's own (C L R first, LFE last) depending on its channel configuration+//! ([`aac_order`]). More than 8 channels carry no known layout: only the first two (front L/R)+//! are used.use std::f32::consts::FRAC_1_SQRT_2;@@ -64,28 +65,59 @@ pub fn stereo_gains(count: usize, aac: bool) -> Vec<Pair> {out}-/// The gains for AAC as FilmCraft's decoder hands it over: channel configurations 3 to 6 (3 to 6-/// channels) and 12 (7.1, 8 channels) are already in WAV/SMPTE order (L R C [Cs] / [LFE] Ls Rs,-/// L R C LFE Lb Rb Ls Rs), everything else (mono, stereo, program-config layouts such as the 6.1-/// ffmpeg writes) in AAC's element order. Configuration 11 (6.1) and 7 (7.1 with front wides)-/// can't be told from those by the channel count and are read in the order of the commoner one.-pub fn decoded_aac_gains(count: usize) -> Vec<Pair> {- match count {+/// The order a source's decoded channels arrive in.+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]+pub enum Order {+ /// WAVE / SMPTE by channel count: PCM, FLAC, AC-3, Opus and the rest.+ #[default]+ Wav,+ /// AAC that FilmCraft reorders to WAVE / SMPTE (configurations 3 to 6, 11 and 12; 4 becomes+ /// L R C Cs) or that ffmpeg wrote in it (a program config element listing the front pair+ /// first: ffmpeg fills a PCE's elements in its own channel order and reads them back so).+ AacWav,+ /// AAC in its element order (C L R … LFE), which FilmCraft keeps: configuration 7 and a PCE+ /// listing the centre first.+ AacElements,+ /// AAC whose configuration the container doesn't show us (only MP4 / MOV headers are read):+ /// as [`Order::AacWav`] up to 7 channels (configurations 3 to 6, 11 and ffmpeg's 6.1 PCE),+ /// as [`Order::AacElements`] above (configuration 7, ffmpeg's 7.1).+ Aac,+}++/// How FilmCraft's decoder hands over the AAC described by the AudioSpecificConfig `asc`.+pub fn aac_order(asc: &[u8]) -> Order {+ let Ok(asc) = filmcraft_aac::AudioSpecificConfig::parse(asc) else { return Order::Aac };+ match (asc.channel_config, asc.pce) {+ (3..=6 | 11 | 12, _) => Order::AacWav,+ (0, Some(pce)) if pce.front.first().is_some_and(|&(cpe, _)| cpe) => Order::AacWav,+ (0, None) => Order::Aac,+ _ => Order::AacElements,+ }+}++/// The gains for `count` channels arriving in `order`.+pub fn decoded_gains(count: usize, order: Order) -> Vec<Pair> {+ let order = match order {+ Order::Aac if (3..=7).contains(&count) => Order::AacWav,+ Order::Aac => Order::AacElements,+ o => o,+ };+ match (order, count) {// C L R Cs, reordered to L R C Cs: the same gains, permuted.- 4 => {+ (Order::AacWav, 4) => {let g = stereo_gains(4, true);[1, 2, 0, 3].iter().filter_map(|&i| g.get(i).copied()).collect()}- 3 | 5 | 6 | 8 => stereo_gains(count, false),- _ => stereo_gains(count, true),+ (Order::AacElements, _) => stereo_gains(count, true),+ _ => stereo_gains(count, false),}}-/// Downmix planar `channels` to interleaved stereo in `out` (`out.len() / 2` frames); frames a-/// channel is too short for count as silence, extra frames in `out` stay as they are.-pub fn downmix_into(channels: &[Vec<f32>], aac: bool, out: &mut [f32]) {- let gains = if aac { decoded_aac_gains(channels.len()) } else { stereo_gains(channels.len(), false) };- mix(channels, &gains, out);+/// Downmix planar `channels` arriving in `order` to interleaved stereo in `out` (`out.len() / 2`+/// frames); frames a channel is too short for count as silence, extra frames in `out` stay as+/// they are.+pub fn downmix_into(channels: &[Vec<f32>], order: Order, out: &mut [f32]) {+ mix(channels, &decoded_gains(channels.len(), order), out);}fn mix(channels: &[Vec<f32>], gains: &[Pair], out: &mut [f32]) {@@ -119,19 +151,46 @@ mod tests {}}+ /// AudioSpecificConfigs as ffmpeg 8.1 and FilmCraft's encoder write them (48 kHz AAC-LC).+ const PCE_FFMPEG_61: &str = "118004c848002000c4400d4c61766336322e32382e31303256e500";+ const PCE_FILMCRAFT_61: &str = "118004c845000108840000";++ fn asc(hex: &str) -> Vec<u8> {+ (0..hex.len() / 2).filter_map(|i| hex.get(2 * i..2 * i + 2).and_then(|b| u8::from_str_radix(b, 16).ok())).collect()+ }+#[test]- fn decoded_aac_is_in_wav_order_for_three_to_six_and_eight_channels() {- // FilmCraft hands AAC 3.0 to 5.1 and 7.1 over in the order of the plain layouts.- for n in [3, 5, 6, 8] {- assert_eq!(decoded_aac_gains(n), stereo_gains(n, false), "{n} channels");+ fn aac_order_follows_the_channel_configuration() {+ // AAC-LC at 48 kHz with channel configuration n+ let config = |n: u8| aac_order(&[0x11, 0x80 | n << 3]);+ for n in [3, 4, 5, 6, 11, 12] {+ assert_eq!(config(n), Order::AacWav, "configuration {n}");+ }+ for n in [1, 2, 7] {+ assert_eq!(config(n), Order::AacElements, "configuration {n}");}- let g = decoded_aac_gains(4);+ assert_eq!(aac_order(&asc(PCE_FFMPEG_61)), Order::AacWav, "ffmpeg's 6.1 PCE lists L R first");+ assert_eq!(aac_order(&asc(PCE_FILMCRAFT_61)), Order::AacElements, "a PCE listing the centre first");+ assert_eq!(aac_order(&[]), Order::Aac);+ }++ #[test]+ fn decoded_aac_gains_follow_the_order() {+ for n in [3, 5, 6, 7, 8] {+ assert_eq!(decoded_gains(n, Order::AacWav), stereo_gains(n, false), "{n} channels");+ assert_eq!(decoded_gains(n, Order::AacElements), stereo_gains(n, true), "{n} channels");+ }+ let g = decoded_gains(4, Order::AacWav);assert_eq!(g.len(), 4);assert!(g[0][0] > 0.0 && g[0][1] == 0.0 && g[1][1] > 0.0 && g[1][0] == 0.0, "L R first");assert!(g[2][0] > 0.0 && g[2][0] == g[2][1], "the centre is third and feeds both sides");assert!(g[3][0] > 0.0 && g[3][0] < g[2][0], "the rear centre is last, below the centre");- for n in [1, 2, 7, 9] {- assert_eq!(decoded_aac_gains(n), stereo_gains(n, true), "{n} channels");+ assert_eq!(decoded_gains(4, Order::Wav), stereo_gains(4, false), "PCM 4 channels are quad");+ for n in [3, 4, 5, 6, 7] {+ assert_eq!(decoded_gains(n, Order::Aac), decoded_gains(n, Order::AacWav), "{n} channels");+ }+ for n in [1, 2, 8, 9] {+ assert_eq!(decoded_gains(n, Order::Aac), stereo_gains(n, true), "{n} channels");}}@@ -161,10 +220,10 @@ mod tests {#[test]fn ragged_and_empty_input_never_panics() {let mut out = vec![0.0; 8];- downmix_into(&[], false, &mut out);- downmix_into(&[vec![1.0; 100], vec![1.0; 2], vec![], vec![1.0; 3], vec![1.0; 1], vec![1.0]], true, &mut out);+ downmix_into(&[], Order::Wav, &mut out);+ downmix_into(&[vec![1.0; 100], vec![1.0; 2], vec![], vec![1.0; 3], vec![1.0; 1], vec![1.0]], Order::Aac, &mut out);assert!(out.iter().all(|v| v.is_finite()));let mut none: [f32; 0] = [];- downmix_into(&vec![vec![1.0; 3]; 7], false, &mut none);+ downmix_into(&vec![vec![1.0; 3]; 7], Order::Wav, &mut none);}}diff --git a/crates/media/src/pool.rs b/crates/media/src/pool.rsindex ed89bf7e8..193804447 100644--- a/crates/media/src/pool.rs+++ b/crates/media/src/pool.rs@@ -12,6 +12,7 @@ use filmcraft_media::{FrameRequest, SharedSource};use image::metadata::Orientation;use crate::convert::{AlphaOp, dynamic_to_image, frame_to_image_in, frame_to_image_scaled, turned};+use crate::downmix::Order;use crate::gif_anim::{self, Anim};use crate::{MediaError, Result};@@ -178,10 +179,37 @@ struct CacheState {last: HashMap<Arc<str>, i64>,}-/// A movie/audio source by path and the turn its picture is shown with-/// ([`crate::probe::video_turn`]), opened by the first caller while the others wait for it-/// (`None`: failed to open; not retried until `forget`).-type SourceSlot = Arc<OnceLock<Option<(SharedSource, Orientation)>>>;+/// A movie/audio source by path ([`Opened`]), opened by the first caller while the others wait+/// for it (`None`: failed to open; not retried until `forget`).+type SourceSlot = Arc<OnceLock<Option<Opened>>>;++/// An opened movie/audio source, the turn its picture is shown with and the order its decoded+/// audio channels arrive in.+#[derive(Clone)]+struct Opened {+ src: SharedSource,+ turn: Orientation,+ order: Order,+}++impl Opened {+ /// `src` with what its MP4/MOV `header` (ftyp and moov) says, if it has one.+ fn new(src: SharedSource, header: Option<&[u8]>) -> Opened {+ let turn = header.map_or(Orientation::NoTransforms, crate::probe::video_turn);+ let order = channel_order(&src, header.and_then(crate::probe::aac_config).as_deref());+ Opened { src, turn, order }+ }+}++/// The order `src`'s audio channels decode in, AAC's decided by its AudioSpecificConfig `asc`+/// when the container's header was read.+fn channel_order(src: &SharedSource, asc: Option<&[u8]>) -> Order {+ match (src.info().audio().is_some_and(|a| a.codec.starts_with("AAC")), asc) {+ (false, _) => Order::Wav,+ (true, Some(asc)) => crate::downmix::aac_order(asc),+ (true, None) => Order::Aac,+ }+}/// An animated GIF by path, as [`SourceSlot`] (the error message when it failed to load).type GifSlot = Arc<OnceLock<std::result::Result<Arc<Anim>, String>>>;@@ -514,7 +542,7 @@ impl MediaPool {/// [`MediaPool::decode_audio`], failing when the source can't be opened or read.fn try_decode_audio(&self, footage: &Footage, start: Tick, frames: usize, rate: u32) -> std::result::Result<Vec<f32>, String> {let path: Arc<str> = footage.path.as_str().into();- let src = self.inner.source(&path).ok_or("the file can't be opened")?;+ let Opened { src, order, .. } = self.inner.opened(&path).ok_or("the file can't be opened")?;let s0 = start.to_units_floor(rate as i64);let native = src.info().audio().map_or(rate, |a| a.sample_rate);// The header's rate scales the samples read: 0xFFFFFFFF Hz made one conform chunk about@@ -523,14 +551,14 @@ impl MediaPool {return Err(format!("a sample rate of {native} Hz is outside {MIN_SAMPLE_RATE}–{MAX_SAMPLE_RATE} Hz"));}if native == 0 || rate == 0 || native == rate {- return read_stereo(&src, s0, frames, rate);+ return read_stereo(&src, order, s0, frames, rate);}// Output sample `n` sits at source position n × native / rate.let (native_i, rate_i) = (i128::from(native), i128::from(rate));let first = (i128::from(s0) * native_i).div_euclid(rate_i);let last = ((i128::from(s0) + frames as i128) * native_i).div_euclid(rate_i) + 1;let (Ok(first64), Ok(count)) = (i64::try_from(first), usize::try_from(last - first + 1)) else { return Ok(vec![0.0; frames * 2]) };- let buf = read_stereo(&src, first64, count, native)?;+ let buf = read_stereo(&src, order, first64, count, native)?;let mut out = Vec::with_capacity(frames * 2);for k in 0..frames as i128 {let pos = (i128::from(s0) + k) * native_i;@@ -593,17 +621,12 @@ impl Inner {crate::read_regular_file(std::path::Path::new(path)).map(Into::into).map_err(|e| MediaError::Io(format!("{path}: {e}")))}- /// The opened movie/audio source for `path`. The first caller opens it, outside the map's- /// lock (reading and parsing a large file takes a moment; FLAC, MP3, Ogg and AIFF files are- /// decoded whole); callers asking for the same file meanwhile wait for that instead of opening- /// it again: a preview's frame workers, audio feeder, conform and waveform threads each- /// decoded a long FLAC in full at once (#408).- fn source(&self, path: &Arc<str>) -> Option<SharedSource> {- self.opened(path).map(|(src, _)| src)- }-- /// [`Self::source`] and the turn the movie's picture is shown with.- fn opened(&self, path: &Arc<str>) -> Option<(SharedSource, Orientation)> {+ /// The opened movie/audio source for `path` ([`Opened`]). The first caller opens it, outside+ /// the map's lock (reading and parsing a large file takes a moment; FLAC, MP3, Ogg and AIFF+ /// files are decoded whole); callers asking for the same file meanwhile wait for that instead+ /// of opening it again: a preview's frame workers, audio feeder, conform and waveform threads+ /// each decoded a long FLAC in full at once (#408).+ fn opened(&self, path: &Arc<str>) -> Option<Opened> {let slot = lock(&self.sources).entry(path.clone()).or_default().clone();slot.get_or_init(|| {self.opened.fetch_add(1, Ordering::Relaxed);@@ -613,14 +636,15 @@ impl Inner {let file = std::path::Path::new(&**path);let in_place = if in_memory { None } else { crate::stream::open_source(file) };let in_place = in_place.map(|src| {- let turn = crate::stream::movie_header(file).map_or(Orientation::NoTransforms, |h| crate::probe::video_turn(&h));- src.map(|src| (src, turn))+ let header = crate::stream::movie_header(file);+ src.map(|src| Opened::new(src, header.as_deref()))});let opened = in_place.unwrap_or_else(|| {self.read(path).and_then(|bytes| {let name = std::path::Path::new(&**path).file_name().map(|n| n.to_string_lossy().to_string()).unwrap_or_default();- let turn = crate::probe::video_turn(&bytes);- filmcraft_codecs::open_bytes(&name, bytes).map(|src| (src, turn)).map_err(MediaError::from)+ let (turn, asc) = (crate::probe::video_turn(&bytes), crate::probe::aac_config(&bytes));+ let src = filmcraft_codecs::open_bytes(&name, bytes).map_err(MediaError::from)?;+ Ok(Opened { order: channel_order(&src, asc.as_deref()), src, turn })})});match opened {@@ -854,7 +878,7 @@ impl Inner {Ok(dynamic_to_image(frame, op))}Some(mt) => {- let (src, turn) = self.opened(path).ok_or_else(|| MediaError::Io(format!("{path}: cannot open")))?;+ let Opened { src, turn, .. } = self.opened(path).ok_or_else(|| MediaError::Io(format!("{path}: cannot open")))?;let vf = src.video_frame(FrameRequest::full(filmcraft_time::Tick(mt.0))).map_err(MediaError::from)@@ -953,8 +977,8 @@ impl FootageSource for MediaPool {/// `frames` stereo sample frames (interleaved) of `src` from sample `s0` at `rate` Hz, which/// FilmCraft serves as decoded when it is the source's own rate. Mono is duplicated to both-/// channels, multichannel sources are downmixed ([`crate::downmix`]); silence before the start. An error where decoding fails.-fn read_stereo(src: &SharedSource, s0: i64, frames: usize, rate: u32) -> std::result::Result<Vec<f32>, String> {+/// channels, multichannel sources (channels in `order`) are downmixed ([`crate::downmix`]); silence before the start. An error where decoding fails.+fn read_stereo(src: &SharedSource, order: Order, s0: i64, frames: usize, rate: u32) -> std::result::Result<Vec<f32>, String> {let mut out = vec![0.0; frames * 2];let skip = usize::try_from(s0.saturating_neg()).unwrap_or(0);if skip >= frames {@@ -962,8 +986,7 @@ fn read_stereo(src: &SharedSource, s0: i64, frames: usize, rate: u32) -> std::re}let buf = src.audio(s0.max(0), frames - skip, rate).map_err(|e| e.to_string())?;let Some(dst) = skip.checked_mul(2).and_then(|i| out.get_mut(i..)) else { return Ok(out) };- let aac = src.info().audio().is_some_and(|a| a.codec.starts_with("AAC"));- crate::downmix::downmix_into(&buf.channels, aac, dst);+ crate::downmix::downmix_into(&buf.channels, order, dst);Ok(out)}diff --git a/crates/media/src/probe.rs b/crates/media/src/probe.rsindex 9a7ebfa1d..435f9ce57 100644--- a/crates/media/src/probe.rs+++ b/crates/media/src/probe.rs@@ -259,6 +259,17 @@ pub(crate) fn load_oriented(bytes: &[u8], fmt: Option<image::ImageFormat>) -> imOk(img)}+/// The AudioSpecificConfig of an MP4/MOV movie's first audio track (the one FilmCraft plays), if+/// that is AAC.+pub(crate) fn aac_config(bytes: &[u8]) -> Option<Vec<u8>> {+ let file = filmcraft_isobmff::open(bytes).ok()?;+ let track = file.tracks.iter().find(|t| t.kind == filmcraft_isobmff::TrackKind::Audio)?;+ match &track.entries.first()?.codec {+ filmcraft_isobmff::CodecConfig::Aac(a) => Some(a.asc.clone()),+ _ => None,+ }+}+/// The rotation an MP4/MOV movie is shown with (a phone held upright records sideways frames and/// says so in its video track's header): the quarter turn nearest the track's rotation. Only the/// rotation counts; any mirroring, scaling or offset in the header is ignored, and otherdiff --git a/crates/media/tests/it/downmix.rs b/crates/media/tests/it/downmix.rsindex e2c95c251..c139676d6 100644--- a/crates/media/tests/it/downmix.rs+++ b/crates/media/tests/it/downmix.rs@@ -164,22 +164,64 @@ fn each_channel_reaches_stereo_at_its_bs775_gain() {for c in cases() {let freqs: Vec<u32> = FREQS.iter().copied().take(c.names.len()).collect();let Some(p) = fixture(c.file, c.layout, c.names, &freqs, c.codec) else { continue };- let s = ours(&p);- let sine = 0.125 * 1.0; // peak of ffmpeg's sine source (0.125 = 2^-3)- for (i, (name, g)) in c.names.iter().zip(&c.gains).enumerate() {- for (side, gain) in g.iter().enumerate() {- let got = amp(&s, side, freqs[i]);- let want = sine * gain;- assert!((got - want).abs() <= sine * c.tol.max(0.02), "{}: {name} -> {} is {got:.4}, expected {want:.4}", c.file, ["L", "R"][side]);- }+ check(&c, &p);+ }+}++/// AAC 7.1 in channel configuration 12 (back surrounds), which FilmCraft reorders where it+/// leaves ffmpeg's configuration 7 as coded: ffmpeg's 7.1 with its configuration rewritten (both+/// code the same elements).+#[test]+fn seven_one_aac_in_configuration_12() {+ let c = cases().into_iter().find(|c| c.file == "dm71.m4a").expect("the 7.1 AAC case");+ let freqs: Vec<u32> = FREQS.iter().copied().take(c.names.len()).collect();+ let Some(p) = fixture(c.file, c.layout, c.names, &freqs, c.codec) else { return };+ let mut bytes = std::fs::read(&p).expect("read");+ let (asc, _) = aac_entry(&bytes).expect("an AAC track");+ assert_eq!(asc.get(..2), Some(&[0x11, 0xB8][..]), "AAC-LC 48 kHz, configuration 7");+ let at = bytes.windows(asc.len()).position(|w| w == asc).expect("the configuration in the file");+ bytes[at + 1] = 0xE0;+ let p12 = fixtures().join("dm71c12.m4a");+ std::fs::write(&p12, bytes).expect("write");+ check(&Case { file: "dm71c12.m4a", ..c }, &p12);+}++/// The AudioSpecificConfig and sample entry channel count of an MP4's first AAC track.+fn aac_entry(bytes: &[u8]) -> Option<(Vec<u8>, u32)> {+ let file = filmcraft_isobmff::open(bytes).ok()?;+ file.tracks.iter().flat_map(|t| &t.entries).find_map(|e| match &e.codec {+ filmcraft_isobmff::CodecConfig::Aac(a) => Some((a.asc.clone(), e.audio.as_ref()?.channels)),+ _ => None,+ })+}++fn check(c: &Case, p: &Path) {+ let pce_as_stereo = aac_entry(&std::fs::read(p).expect("read")).is_some_and(|(asc, entry)| {+ let config = filmcraft_aac::AudioSpecificConfig::parse(&asc).map(|a| a.channel_config);+ config.ok() == Some(0) && entry == 2+ });+ if pce_as_stereo && c.names.len() > 2 {+ // ffmpeg 4.2 writes 2 in the sample entry of an AAC PCE layout (8.1 the real count), and+ // that is all FilmCraft decodes.+ eprintln!("{}: FilmCraft reads 2 of its {} channels: skipping", c.file, c.names.len());+ return;+ }+ let s = ours(p);+ let freqs: Vec<u32> = FREQS.iter().copied().take(c.names.len()).collect();+ let sine = 0.125 * 1.0; // peak of ffmpeg's sine source (0.125 = 2^-3)+ for (i, (name, g)) in c.names.iter().zip(&c.gains).enumerate() {+ for (side, gain) in g.iter().enumerate() {+ let got = amp(&s, side, freqs[i]);+ let want = sine * gain;+ assert!((got - want).abs() <= sine * c.tol.max(0.02), "{}: {name} -> {} is {got:.4}, expected {want:.4}", c.file, ["L", "R"][side]);}- let theirs = ffmpeg_ac2(&p);- let (a, b) = (rms(&s), rms(&theirs));- let db = 20.0 * (a / b).log10();- assert!(db.abs() < 1.0, "{}: level {db:.2} dB off ffmpeg -ac 2 (rms {a:.4} vs {b:.4})", c.file);- let pdb = 20.0 * (peak(&s) / peak(&theirs)).log10();- assert!(pdb.abs() < 1.5, "{}: peak {pdb:.2} dB off ffmpeg -ac 2", c.file);}+ let theirs = ffmpeg_ac2(p);+ let (a, b) = (rms(&s), rms(&theirs));+ let db = 20.0 * (a / b).log10();+ assert!(db.abs() < 1.0, "{}: level {db:.2} dB off ffmpeg -ac 2 (rms {a:.4} vs {b:.4})", c.file);+ let pdb = 20.0 * (peak(&s) / peak(&theirs)).log10();+ assert!(pdb.abs() < 1.5, "{}: peak {pdb:.2} dB off ffmpeg -ac 2", c.file);}/// Full-scale in every channel must not clip.