#![allow(dead_code)]
#[cfg(feature = "decode")]
pub mod h264;
pub mod synth;
pub fn write_stats(root: &std::path::Path) {
let info: serde_json::Value =
serde_json::from_slice(&std::fs::read(root.join("meta/info.json")).unwrap()).unwrap();
let stats: serde_json::Map<String, serde_json::Value> = info["features"]
.as_object()
.unwrap()
.iter()
.filter(|(_, f)| f["dtype"] != "string")
.map(|(k, _)| (k.clone(), serde_json::json!({})))
.collect();
let (name, body) = if info["codebase_version"]
.as_str()
.unwrap()
.starts_with("v2.1")
{
let line = serde_json::json!({"episode_index": 0, "stats": stats});
("episodes_stats.jsonl", format!("{line}\n"))
} else {
("stats.json", serde_json::Value::Object(stats).to_string())
};
std::fs::write(root.join("meta").join(name), body).unwrap();
}
fn bx(kind: &[u8; 4], payload: &[u8]) -> Vec<u8> {
let mut v = ((payload.len() + 8) as u32).to_be_bytes().to_vec();
v.extend(kind);
v.extend(payload);
v
}
fn be(x: u32) -> [u8; 4] {
x.to_be_bytes()
}
fn stsd(width: u16, height: u16) -> Vec<u8> {
let mut e = vec![0u8; 6]; e.extend([0, 1]); e.extend([0u8; 16]); e.extend(width.to_be_bytes());
e.extend(height.to_be_bytes());
e.extend(vec![0u8; 50]); let mut v = vec![0u8; 4];
v.extend(be(1)); v.extend(bx(b"av01", &e));
v
}
fn trak(
handler: &[u8; 4],
timescale: u32,
stts: &[(u32, u32)],
samples: u32,
size: Option<(u16, u16)>,
) -> Vec<u8> {
let mut mdhd = vec![0u8; 4]; mdhd.extend([0u8; 8]); mdhd.extend(be(timescale));
mdhd.extend(be(stts.iter().map(|(c, d)| c * d).sum()));
mdhd.extend([0u8; 4]);
let mut hdlr = vec![0u8; 8]; hdlr.extend(handler);
hdlr.extend([0u8; 12]);
hdlr.push(0);
let mut st = vec![0u8; 4];
st.extend(be(stts.len() as u32));
for (c, d) in stts {
st.extend(be(*c));
st.extend(be(*d));
}
let mut sz = vec![0u8; 4];
sz.extend(be(0));
sz.extend(be(samples));
for _ in 0..samples {
sz.extend(be(100));
}
let mut tables = vec![bx(b"stts", &st), bx(b"stsz", &sz)];
if let Some((w, h)) = size {
tables.insert(0, bx(b"stsd", &stsd(w, h)));
}
let stbl = bx(b"stbl", &tables.concat());
let minf = bx(b"minf", &stbl);
let mdia = bx(
b"mdia",
&[bx(b"mdhd", &mdhd), bx(b"hdlr", &hdlr), minf].concat(),
);
bx(b"trak", &mdia)
}
pub struct Mp4 {
pub timescale: u32,
pub stts: Vec<(u32, u32)>,
pub moov_first: bool,
pub audio_track_first: bool,
pub video_track: bool,
pub size: Option<(u16, u16)>,
pub large_mdat: bool,
pub mdat_len: usize,
}
impl Mp4 {
pub fn constant_fps(frames: u32, fps: u32) -> Self {
Mp4 {
timescale: fps * 1024,
stts: vec![(frames, 1024)],
moov_first: false,
audio_track_first: false,
video_track: true,
size: None,
large_mdat: false,
mdat_len: 64,
}
}
pub fn bytes(&self) -> Vec<u8> {
let frames: u32 = self.stts.iter().map(|(c, _)| c).sum();
let mut tracks = Vec::new();
if self.audio_track_first {
tracks.push(trak(b"soun", 48000, &[(50, 1024)], 50, None));
}
if self.video_track {
tracks.push(trak(b"vide", self.timescale, &self.stts, frames, self.size));
}
let moov = bx(b"moov", &tracks.concat());
let ftyp = bx(b"ftyp", b"isom\0\0\0\0isom");
let mdat = if self.large_mdat {
let payload = vec![0u8; 64];
let mut v = be(1).to_vec();
v.extend(b"mdat");
v.extend((payload.len() as u64 + 16).to_be_bytes());
v.extend(payload);
v
} else {
bx(b"mdat", &vec![0u8; self.mdat_len])
};
if self.moov_first {
[ftyp, moov, mdat].concat()
} else {
[ftyp, mdat, moov].concat()
}
}
}