Sylpheed/crates/sylpheed-export/examples/record_population.rs

//! Why do two "every pak, every timed record" scans disagree by 86 %?
//!
//! This port counts 1 781 timed nested records and reports `+0x08 == max t` at
//! 92.3 %. The Decoder counts 3 311 and reports 49.6 %. Both scans are described
//! the same way, so at least one of them is narrower than its own description --
//! and the exactness figure this port has quoted repeatedly is a property of
//! whichever subset it actually walks.
//!
//! Counts the survivors at each filter, so the gap is located rather than
//! guessed at.
use sylpheed_formats::{pak, ratc, ui_layout};

fn main() {
    let root =
        std::env::var("SYLPHEED_DISC").expect("set SYLPHEED_DISC to the extracted disc root");
    let mut paks: Vec<_> = std::fs::read_dir(format!("{root}/dat"))
        .expect("dat/")
        .flatten()
        .map(|e| e.path())
        .filter(|p| p.extension().and_then(|s| s.to_str()) == Some("pak"))
        .collect();
    paks.sort();
    let (mut records, mut in_bounds, mut magic, mut parsed, mut timed) = (0, 0, 0, 0, 0);
    let (mut untimed, mut all_at_zero) = (0usize, 0usize);
    for p in &paks {
        let Ok(ar) = pak::PakArchive::open(p) else {
            continue;
        };
        for e in ar.entries() {
            let Ok(by) = ar.read(e) else { continue };
            if !ratc::is_ratc(&by) {
                continue;
            }
            let Some(b) = ui_layout::parse_build(&by) else {
                continue;
            };
            for &(o, s) in b.records.values() {
                records += 1;
                if o + 12 > by.len() || o + s > by.len() {
                    continue;
                }
                in_bounds += 1;
                if &by[o..o + 4] != b"RATC" {
                    continue;
                }
                magic += 1;
                let Some(lb) = ui_layout::parse_build(&by[o..o + s]) else {
                    continue;
                };
                parsed += 1;
                let maxt = lb
                    .elements
                    .iter()
                    .flat_map(|el| el.keyframes.iter().filter_map(|k| k.time))
                    .max()
                    .unwrap_or(0);
                // 🔴 `maxt == 0` merges two different populations, and the
                // Decoder's cause -- `.max()` returning `Some(0)` -- is only one
                // of them. A record with NO timed keyframe has no largest
                // keyframe time; a record whose keyframes all sit at t=0 has
                // one, and it is 0. Only the first is a question without
                // content. Both of us called all 1 530 "the question has no
                // meaning"; that is true of one group and an assumption about
                // the other.
                let any_timed = lb
                    .elements
                    .iter()
                    .any(|el| el.keyframes.iter().any(|k| k.time.is_some()));
                if maxt == 0 {
                    if any_timed {
                        all_at_zero += 1
                    } else {
                        untimed += 1
                    }
                    continue;
                }
                timed += 1;
            }
        }
    }
    println!("  records declared by parse_build : {records}");
    println!("  within the entry's bounds       : {in_bounds}");
    println!(
        "  carrying the RATC magic         : {magic}   <- {} dropped here",
        in_bounds - magic
    );
    println!("  parsing as a nested build       : {parsed}");
    println!("  with a largest keyframe time > 0: {timed}");
    println!("    of the {} excluded:", untimed + all_at_zero);
    println!("      NO timed keyframe at all      : {untimed}  <- the question has no content");
    println!("      timed, but every pose at t=0  : {all_at_zero}  <- a largest time EXISTS, and it is 0");
}