Skip to main content

av1_yuv_dump/
av1_yuv_dump.rs

1//! Decode an AV1 IVF (or Section 5 `.obu`) file with `codec::decode::av1`
2//! and write every shown frame as raw planes (8-bit: one byte per sample;
3//! 10/12-bit: little-endian u16), as `ffmpeg -f rawvideo` does.
4//!
5//!   av1_yuv_dump IN.ivf|IN.obu OUT.yuv
6use std::io::Write;
7
8use threers_codec::decode::av1::Av1Decoder;
9use threers_codec::mkv_demux::parse_ivf;
10
11fn main() {
12    let a: Vec<String> = std::env::args().collect();
13    if a.len() < 3 {
14        eprintln!("usage: av1_yuv_dump IN.ivf|IN.obu OUT.yuv");
15        std::process::exit(2);
16    }
17    let data = std::fs::read(&a[1]).expect("read");
18    // Section 5 streams start with a temporal delimiter OBU (0x12 0x00);
19    // anything else that is not IVF is taken as Annex B.
20    let annexb = !data.starts_with(b"DKIF") && !data.starts_with(&[0x12, 0x00]);
21    let packets: Vec<Vec<u8>> = if data.starts_with(b"DKIF") {
22        parse_ivf(&data)
23            .expect("ivf")
24            .4
25            .into_iter()
26            .map(|(_, d)| d)
27            .collect()
28    } else if annexb {
29        threers_codec::decode::av1::split_annexb(&data)
30            .expect("annexb")
31            .into_iter()
32            .map(|t| t.to_vec())
33            .collect()
34    } else {
35        vec![data]
36    };
37    let mut dec = Av1Decoder::new();
38    let mut out = std::io::BufWriter::new(std::fs::File::create(&a[2]).expect("create"));
39    let mut n = 0;
40    let mut desc = String::new();
41    let mut sizes = String::new();
42    for p in &packets {
43        let frames = match if annexb {
44            dec.decode_annexb(p)
45        } else {
46            dec.decode(p)
47        } {
48            Ok(f) => f,
49            Err(e) => {
50                println!("ERROR {e} (after {n} frames)");
51                std::process::exit(2);
52            }
53        };
54        for f in frames {
55            let pic = &f.pic;
56            let np = if pic.layout == threers_codec::decode::av1::obu::Layout::I400 {
57                1
58            } else {
59                3
60            };
61            for pl in 0..np {
62                let (ssh, ssv) = pic.ss(pl);
63                let w = ((pic.w + ssh) >> ssh) as usize;
64                let h = ((pic.h + ssv) >> ssv) as usize;
65                let s = pic.pstride(pl);
66                for y in 0..h {
67                    let row = &pic.planes[pl][y * s..y * s + w];
68                    if pic.bpc == 8 {
69                        out.write_all(&row.iter().map(|&v| v as u8).collect::<Vec<_>>())
70                            .unwrap();
71                    } else {
72                        out.write_all(
73                            &row.iter()
74                                .flat_map(|&v| v.to_le_bytes())
75                                .collect::<Vec<_>>(),
76                        )
77                        .unwrap();
78                    }
79                }
80            }
81            sizes.push_str(&format!("{} {}\n", pic.w, pic.h));
82            desc = format!("{}x{} {}-bit {:?}", pic.w, pic.h, pic.bpc, pic.layout);
83            n += 1;
84        }
85    }
86    std::fs::write(format!("{}.sizes", a[2]), sizes).unwrap();
87    println!("{n} frames, {desc}");
88}