54fa940591
Found because the port refused to apply my stream assignment and did the arithmetic instead: the running decoder's three ADV contexts sum to 3 584 000 B against a resolved region of 3 114 352 -- 15 % too small to hold them. Two spans, one wrong, and it was the disc side. The gap is 238 packets exactly (487 424 B), which is what a start offset looks like; ctx0 declares 632 packets and the resolver's leading chunk has 394. Verified against the decoder's own byte_sizes, which cannot be fitted to: at -238 packets to_xma_riffs yields [1294336, 1118208, 1171456], all three exactly. It is a real boundary and not the end of a sweep -- at -300 the previous asset's chunks appear while the three ADV sizes stay stable. Disc-wide: 24 of 24 single-chunk regions start at a boundary; 8 of 10 three-chunk regions start mid-stream. The defect is specific to the multichannel case. The audit's per-movie number is an UPPER BOUND, not the clip -- its stopping rule is the chunk count changing, and to_xma_riffs absorbs a few packets of the previous asset first (243 reported for ADV against a true 238). Only ADV has external ground truth. Consequence: in those 8 movies the leading chunk is a truncated first stream, not a spurious artefact, and anything measured on it was measured on a fragment -- including this corpus's own chunk-0 level, though the assignment survives because its ratio test was chosen to be immune to the clipping. The resolver is NOT patched. Why the predecessor cue's trailer lands 238 packets into the next asset is unanswered, and a fix guessed from one movie would be worse than a documented defect. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01Wuu56cE8vJGTBtn1ppsk8v
54 lines
2.4 KiB
Rust
54 lines
2.4 KiB
Rust
//! Does `resolve_movie_voice_region` start LATE, and by exactly how much?
|
|
//!
|
|
//! The port agent's arithmetic: the running decoder's three `ADV` XMA contexts sum
|
|
//! to **3 584 000** payload bytes, but the resolved voice region is **3 114 352** —
|
|
//! 15 % too small to hold them. One of the two spans is not what the other thinks
|
|
//! it is, and the disc side is this crate's.
|
|
//!
|
|
//! The gap is exact. `ctx0` declares **632** packets (1 294 336 B); the leading
|
|
//! chunk the resolver yields has **394** (806 912 B). The difference is **238
|
|
//! packets = 487 424 B**, a whole number of packets — which is what a start offset
|
|
//! looks like, not corruption.
|
|
//!
|
|
//! So: walk the region start backwards and report where `to_xma_riffs` first
|
|
//! reproduces the decoder's own three sizes. The probe's byte_sizes are the
|
|
//! control — this is not free to fit, it either lands on them or it does not.
|
|
//!
|
|
//! cargo run -p sylpheed-formats --example adv_region_extend
|
|
|
|
use sylpheed_formats::media::{self, DirectorySource, DiscSource};
|
|
use sylpheed_formats::slb::{self, VoiceLang};
|
|
|
|
/// What the running decoder reported (docs/re/structures/voice-three-streams-are-concurrent.md).
|
|
const WANT: [usize; 3] = [1_294_336, 1_118_208, 1_171_456];
|
|
|
|
fn main() {
|
|
let disc = std::env::var("SYLPHEED_DISC").expect("SYLPHEED_DISC");
|
|
let src = DirectorySource::new(std::path::PathBuf::from(&disc));
|
|
let (start, end) =
|
|
media::resolve_movie_voice_region(&src, "ADV", VoiceLang::English).expect("region");
|
|
println!("resolver says {start}..{end} ({} B)", end - start);
|
|
println!("decoder wants {:?} = {} B payload\n", WANT, WANT.iter().sum::<usize>());
|
|
|
|
for back_packets in [0usize, 100, 200, 237, 238, 239, 300, 400] {
|
|
let back = (back_packets * 2048) as u64;
|
|
if back > start {
|
|
continue;
|
|
}
|
|
let s = start - back;
|
|
let Ok(bytes) = src.read_segment_range("dat/sound", s, (end - s) as usize) else {
|
|
println!("-{back_packets:4} packets: unreadable");
|
|
continue;
|
|
};
|
|
let riffs = slb::to_xma_riffs(&bytes);
|
|
let sizes: Vec<usize> = riffs.iter().map(|r| r.len() - 60).collect();
|
|
let hit = sizes.len() == 3 && sizes.iter().zip(WANT.iter()).all(|(a, b)| a == b);
|
|
println!(
|
|
"-{back_packets:4} packets (start {s}): {} chunk(s) {:?}{}",
|
|
riffs.len(),
|
|
sizes,
|
|
if hit { " <== MATCHES THE DECODER" } else { "" }
|
|
);
|
|
}
|
|
}
|