62d6732504
Two root causes, both found by building an oracle rather than guessing. 1. Amplitude ~75x low: the IMDCT applied a 2/n normalisation the encoder's forward transform had already carried. Because 2/n varies with block size it produced DIFFERENT errors on 256- vs 2048-sample blocks — exactly the reported symptom. Removing it gives fit scale 1.0000. 2. Leading trim, the real remaining defect. The first audio packet produces NO output (its window only primes the overlap-add) but we emitted from the first block's centre, injecting half a priming window of garbage and shifting everything early. And Vorbis carries encoder delay in the GRANULE POSITION, which varies per file — afinfo confirms 128 / 1103 / 960 frames on three samples — while our Ogg reader kept only last_granule and discarded per-page granules, making it unrecoverable. Added per-page granule tracking: the first page reporting a granule pins priming as centre - granule, and valid audio starts at priming + blocksize_0/2. That reproduces afinfo's numbers exactly on all three. A premise in the brief was also wrong and worth recording: our output length was already correct. afinfo reports valid frames matching OUR output — it is afconvert that trims a further 128. The reference WAV was short, not us. mono 47 files mean corr 1.00000 (min 1.00000) 47/47 exact stereo 107 files mean corr 0.826 68/107 exact Decode cost 5.13 ms/file average; 11.5 MB compressed expands to 143.3 MB of f32 PCM, which is why the sample bank's LRU cap matters. Honest remaining defect: ~39 stereo files decode wrongly and it is NOT alignment — a full lag sweep peaks at 0.40-0.89 with fit scales 0.40-1.87, so specific blocks have wrong amplitude. Mono being 47/47 rules out floor, residue 0/1, MDCT, windowing and priming; coupling matches the spec's square-polar mapping including reverse order; floor 0 is rejected rather than mis-decoded; and both channels are identical in the failing files, so it is not a swap. The failing set is transient-heavy impact/footstep sounds, so the lead is residue type 2 partition counting on short blocks. reference_decode.rs is no longer #[ignore]d: 3 real tests asserting mono correlation > 0.999 and length == granule, plus a 3000-mutation fuzz that must never panic, all skipping cleanly without fixtures. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
51 lines
1.9 KiB
Rust
51 lines
1.9 KiB
Rust
//! Per-channel comparison: tells swapped channels apart from a broken
|
|
//! coupling (one channel right, the other wrong).
|
|
//! Usage: vorbis_ch <file.ogg> <ref.wav>
|
|
use makepad_game_audio as audio;
|
|
|
|
fn corr(a: &[f32], b: &[f32]) -> f64 {
|
|
let n = a.len().min(b.len());
|
|
let (mut num, mut da, mut db) = (0f64, 0f64, 0f64);
|
|
for i in 0..n {
|
|
let (x, y) = (a[i] as f64, b[i] as f64);
|
|
num += x * y;
|
|
da += x * x;
|
|
db += y * y;
|
|
}
|
|
if da <= 0.0 || db <= 0.0 {
|
|
return 0.0;
|
|
}
|
|
num / (da.sqrt() * db.sqrt())
|
|
}
|
|
|
|
fn chan(p: &audio::Pcm, c: usize) -> Vec<f32> {
|
|
p.samples.iter().skip(c).step_by(p.channels).cloned().collect()
|
|
}
|
|
|
|
fn main() {
|
|
let a: Vec<String> = std::env::args().collect();
|
|
let got = audio::decode(&std::fs::read(&a[1]).expect("ogg")).expect("decode");
|
|
let want = audio::wav::decode(&std::fs::read(&a[2]).expect("ref")).expect("ref");
|
|
println!("ch={} got={} ref={}", got.channels, got.frames(), want.frames());
|
|
if got.channels < 2 {
|
|
println!("mono: corr {:.4}", corr(&got.samples, &want.samples));
|
|
return;
|
|
}
|
|
let (gl, gr) = (chan(&got, 0), chan(&got, 1));
|
|
let (wl, wr) = (chan(&want, 0), chan(&want, 1));
|
|
println!(" L->L {:.4} L->R {:.4}", corr(&gl, &wl), corr(&gl, &wr));
|
|
println!(" R->R {:.4} R->L {:.4}", corr(&gr, &wr), corr(&gr, &wl));
|
|
// Mid/side view: coupling errors usually leave the mid intact and wreck
|
|
// the side, which is invisible in a plain per-channel correlation.
|
|
let mid = |l: &[f32], r: &[f32]| -> Vec<f32> {
|
|
l.iter().zip(r).map(|(a, b)| (a + b) * 0.5).collect()
|
|
};
|
|
let side = |l: &[f32], r: &[f32]| -> Vec<f32> {
|
|
l.iter().zip(r).map(|(a, b)| (a - b) * 0.5).collect()
|
|
};
|
|
println!(
|
|
" mid {:.4} side {:.4}",
|
|
corr(&mid(&gl, &gr), &mid(&wl, &wr)),
|
|
corr(&side(&gl, &gr), &side(&wl, &wr))
|
|
);
|
|
}
|