diff --git a/Cargo.lock b/Cargo.lock
index 487469a7..9f719168 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -65,7 +65,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "05b07e8e73d720a1f2e4b6014766e6039fd2e96a4fa44e2a78d0e1fa2ff49826"
dependencies = [
"android_log-sys",
- "env_filter",
+ "env_filter 0.1.4",
"log",
]
@@ -446,7 +446,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "993776b509cfb49c750f11b8f07a46fa23e0a1386ffc01fb1e7d343efc387895"
dependencies = [
"annotate-snippets",
- "bitflags",
+ "bitflags 2.13.0",
"cexpr",
"clang-sys",
"itertools 0.13.0",
@@ -475,6 +475,12 @@ version = "0.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7"
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
[[package]]
name = "bitflags"
version = "2.13.0"
@@ -556,7 +562,7 @@ version = "0.22.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5cc8d9aa793480744cd9a0524fef1a2e197d9eaa0f739cde19d16aba530dcb95"
dependencies = [
- "bitflags",
+ "bitflags 2.13.0",
"cairo-sys-rs",
"glib",
"libc",
@@ -885,6 +891,15 @@ dependencies = [
"itertools 0.10.5",
]
+[[package]]
+name = "cros-codecs"
+version = "0.0.5"
+dependencies = [
+ "env_logger",
+ "log",
+ "serde_json",
+]
+
[[package]]
name = "crossbeam-deque"
version = "0.8.6"
@@ -991,6 +1006,37 @@ version = "2.11.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a4ae5f15dda3c708c0ade84bfee31ccab44a3da4f88015ed22f63732abe300c8"
+[[package]]
+name = "defmt"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2953bfe4f93bbd20cc71198842756f77d161884c99ebbabc41d80231ded88d1"
+dependencies = [
+ "bitflags 1.3.2",
+ "defmt-macros",
+]
+
+[[package]]
+name = "defmt-macros"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bad9c72e7ca2137e0dc3813245a0d282fd6daad32fd800af018306a9169b5fe8"
+dependencies = [
+ "defmt-parser",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "defmt-parser"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "10d60334b3b2e7c9d91ef8150abfb6fa4c1c39ebbcf4a81c2e346aad939fee3e"
+dependencies = [
+ "thiserror 2.0.18",
+]
+
[[package]]
name = "der"
version = "0.7.10"
@@ -1101,6 +1147,29 @@ dependencies = [
"regex",
]
+[[package]]
+name = "env_filter"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "900d271a03799a1ee8d1ca9b19893b48ca674a9284fefcfb85f05e74ed314217"
+dependencies = [
+ "log",
+ "regex",
+]
+
+[[package]]
+name = "env_logger"
+version = "0.11.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "de671bd27a75a797dc9ae289ba1e77276e75e2026408aab65185384e2d5cd3f6"
+dependencies = [
+ "anstream",
+ "anstyle",
+ "env_filter 2.0.0",
+ "jiff",
+ "log",
+]
+
[[package]]
name = "equivalent"
version = "1.0.2"
@@ -1193,7 +1262,7 @@ version = "8.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f7c4bd5ab1ac61f29c634df1175d350ded29cf74c3c6d4f7030431a5ae3c7d5d"
dependencies = [
- "bitflags",
+ "bitflags 2.13.0",
"ffmpeg-sys-next",
"libc",
]
@@ -1584,7 +1653,7 @@ version = "0.22.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c207e04e51605dcf7b2924c41591b3a10e1438eaac5bcf448fb91f325381104a"
dependencies = [
- "bitflags",
+ "bitflags 2.13.0",
"futures-channel",
"futures-core",
"futures-executor",
@@ -2127,6 +2196,42 @@ version = "1.0.18"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
+[[package]]
+name = "jiff"
+version = "0.2.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "668b7183bd07af9a4885f5c35b0cc5c83c4607a913c16b7e17291832910d2dcc"
+dependencies = [
+ "defmt",
+ "jiff-core",
+ "jiff-static",
+ "log",
+ "portable-atomic",
+ "portable-atomic-util",
+ "serde_core",
+]
+
+[[package]]
+name = "jiff-core"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7feca88439efe53da3754500c1851dedf3cb36c524dd5cf8225cc0794de95d09"
+dependencies = [
+ "defmt",
+]
+
+[[package]]
+name = "jiff-static"
+version = "0.2.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a69dcb3a21cfb32ce1cd056169337ca284af0766dd766e7878819b251a49204"
+dependencies = [
+ "jiff-core",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
[[package]]
name = "jni"
version = "0.21.1"
@@ -2291,7 +2396,7 @@ version = "0.9.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b6b8cfa2a7656627b4c92c6b9ef929433acd673d5ab3708cda1b18478ac00df4"
dependencies = [
- "bitflags",
+ "bitflags 2.13.0",
"cc",
"convert_case",
"cookie-factory",
@@ -2493,7 +2598,7 @@ dependencies = [
name = "ndk"
version = "0.9.0"
dependencies = [
- "bitflags",
+ "bitflags 2.13.0",
"jni-sys 0.3.1",
"log",
"ndk-sys",
@@ -2517,7 +2622,7 @@ version = "0.29.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "71e2746dc3a24dd78b3cfcb7be93368c6de9963d30f43a6a73998a9cf4b17b46"
dependencies = [
- "bitflags",
+ "bitflags 2.13.0",
"cfg-if",
"cfg_aliases",
"libc",
@@ -2530,7 +2635,7 @@ version = "0.30.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "74523f3a35e05aba87a1d978330aef40f67b0304ac79c1c00b294c9830543db6"
dependencies = [
- "bitflags",
+ "bitflags 2.13.0",
"cfg-if",
"cfg_aliases",
"libc",
@@ -2848,6 +2953,14 @@ version = "2.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
+[[package]]
+name = "pf-bitstream"
+version = "0.24.0"
+dependencies = [
+ "cros-codecs",
+ "tracing",
+]
+
[[package]]
name = "pf-capture"
version = "0.24.0"
@@ -3075,7 +3188,7 @@ version = "0.24.0"
dependencies = [
"anyhow",
"ashpd",
- "bitflags",
+ "bitflags 2.13.0",
"bytemuck",
"futures-util",
"hex",
@@ -3153,7 +3266,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9688b89abf11d756499f7c6190711d6dbe5a3acdb30c8fbf001d6596d06a8d44"
dependencies = [
"anyhow",
- "bitflags",
+ "bitflags 2.13.0",
"libc",
"libspa",
"libspa-sys",
@@ -3207,7 +3320,7 @@ version = "0.18.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "60769b8b31b2a9f263dae2776c37b1b28ae246943cf719eb6946a1db05128a61"
dependencies = [
- "bitflags",
+ "bitflags 2.13.0",
"crc32fast",
"fdeflate",
"flate2",
@@ -3251,6 +3364,21 @@ dependencies = [
"universal-hash",
]
+[[package]]
+name = "portable-atomic"
+version = "1.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d20d5497ef88037a52ff98267d066e7f11fcc5e99bbfbd58a42336193aacec3"
+
+[[package]]
+name = "portable-atomic-util"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2a106d1259c23fac8e543272398ae0e3c0b8d33c88ed73d0cc71b0f1d902618"
+dependencies = [
+ "portable-atomic",
+]
+
[[package]]
name = "potential_utf"
version = "0.1.5"
@@ -3311,7 +3439,7 @@ checksum = "4b45fcc2344c680f5025fe57779faef368840d0bd1f42f216291f0dc4ace4744"
dependencies = [
"bit-set",
"bit-vec",
- "bitflags",
+ "bitflags 2.13.0",
"num-traits",
"rand 0.9.4",
"rand_chacha 0.9.0",
@@ -3777,7 +3905,7 @@ version = "0.5.18"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d"
dependencies = [
- "bitflags",
+ "bitflags 2.13.0",
]
[[package]]
@@ -3934,7 +4062,7 @@ version = "0.40.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "11438310b19e3109b6446c33d1ed5e889428cf2e278407bc7896bc4aaea43323"
dependencies = [
- "bitflags",
+ "bitflags 2.13.0",
"fallible-iterator",
"fallible-streaming-iterator",
"hashlink",
@@ -3973,7 +4101,7 @@ version = "1.1.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190"
dependencies = [
- "bitflags",
+ "bitflags 2.13.0",
"errno",
"libc",
"linux-raw-sys",
@@ -4127,7 +4255,7 @@ version = "0.18.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "25bd22eb1bbc9137e914022b4994ed35591eea0884e9e3e98e6d9895cad6e1d2"
dependencies = [
- "bitflags",
+ "bitflags 2.13.0",
"libc",
"sdl3-image-sys",
"sdl3-mixer-sys",
@@ -4222,7 +4350,7 @@ version = "3.7.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b7f4bc775c73d9a02cde8bf7b2ec4c9d12743edf609006c7facc23998404cd1d"
dependencies = [
- "bitflags",
+ "bitflags 2.13.0",
"core-foundation",
"core-foundation-sys",
"libc",
@@ -4428,7 +4556,7 @@ version = "0.87.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0f7d94f3e7537c71ad4cf132eb26e3be8c8a886ed3649c4525c089041fc312b2"
dependencies = [
- "bitflags",
+ "bitflags 2.13.0",
"lazy_static",
"skia-bindings",
]
@@ -5301,7 +5429,7 @@ version = "0.31.14"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "645c7c96bb74690c3189b5c9cb4ca1627062bb23693a4fad9d8c3de958260144"
dependencies = [
- "bitflags",
+ "bitflags 2.13.0",
"rustix",
"wayland-backend",
"wayland-scanner",
@@ -5313,7 +5441,7 @@ version = "0.32.13"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "23d0c813de3daa2ed6520af85a3bd49b0e722a3078506899aa9686fea58dc4b6"
dependencies = [
- "bitflags",
+ "bitflags 2.13.0",
"wayland-backend",
"wayland-client",
"wayland-scanner",
@@ -5325,7 +5453,7 @@ version = "0.3.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6e9567599ef23e09b8dad6e429e5738d4509dfc46b3b21f32841a304d16b29c8"
dependencies = [
- "bitflags",
+ "bitflags 2.13.0",
"wayland-backend",
"wayland-client",
"wayland-protocols",
@@ -5338,7 +5466,7 @@ version = "0.3.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "eb04e52f7836d7c7976c78ca0250d61e33873c34156a2a1fc9474828ec268234"
dependencies = [
- "bitflags",
+ "bitflags 2.13.0",
"wayland-backend",
"wayland-client",
"wayland-protocols",
@@ -5690,7 +5818,7 @@ version = "0.7.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d24d6bcc7f734a4091ecf8d7a64c5f7d7066f45585c1861eba06449909609c8a"
dependencies = [
- "bitflags",
+ "bitflags 2.13.0",
"widestring",
"windows-sys 0.52.0",
]
diff --git a/Cargo.toml b/Cargo.toml
index 8ee7bd85..003b9b97 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -5,6 +5,8 @@ members = [
"crates/punktfunk-host",
"crates/punktfunk-host/vendor/usbip-sim",
"crates/punktfunk-tray",
+ "crates/pf-bitstream",
+ "crates/pf-bitstream/vendor/cros-codecs",
"crates/pf-client-core",
"crates/pf-clipboard",
"crates/pf-presenter",
diff --git a/crates/pf-bitstream/Cargo.toml b/crates/pf-bitstream/Cargo.toml
new file mode 100644
index 00000000..fd565e38
--- /dev/null
+++ b/crates/pf-bitstream/Cargo.toml
@@ -0,0 +1,16 @@
+[package]
+name = "pf-bitstream"
+description = "Client-side bitstream layer for native decode: AU parsing, POC/DPB/reference derivation and per-AU DecodePlans (H.264/HEVC/AV1) on the vendored cros-codecs parsers — the layer libavcodec used to be (design/client-native-decode.md §3.1)"
+version.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+license.workspace = true
+authors.workspace = true
+repository.workspace = true
+
+[dependencies]
+cros-codecs = { path = "vendor/cros-codecs" }
+tracing = "0.1"
+
+[lints]
+workspace = true
diff --git a/crates/pf-bitstream/src/lib.rs b/crates/pf-bitstream/src/lib.rs
new file mode 100644
index 00000000..ed7fa7b6
--- /dev/null
+++ b/crates/pf-bitstream/src/lib.rs
@@ -0,0 +1,149 @@
+//! The client's bitstream layer for native decode (design/client-native-decode.md §3.1):
+//! everything a stateless hardware decoder needs to know about an AU before submission —
+//! parsed headers, POC, DPB state, reference lists (including MMCO/LTR, which the hosts'
+//! RFI recovery actively uses), recovery-point SEI — derived once here and consumed by
+//! every backend (Vulkan `StdVideo*`, DXVA picparams, libva buffers).
+//!
+//! Parsing primitives come from the vendored cros-codecs parser layer
+//! (`vendor/cros-codecs`, see its PROVENANCE.md); this crate owns what upstream keeps in
+//! its Linux-only `decoder::stateless` half — the per-AU orchestration — plus the pieces
+//! upstream lacks (SEI payload parsing: their parsers classify SEI NALUs but never read
+//! them).
+//!
+//! Scope discipline: punktfunk clients decode punktfunk hosts — zero-reorder, no
+//! B-frames, progressive, parameter sets from encoders we control. Implement to spec
+//! where cheap; reject-with-log outside that envelope rather than half-decode.
+//!
+//! Nothing in this crate may touch a GPU API, an OS handle, or the network: CPU-only by
+//! construction, so its tests run on every CI leg including macOS.
+
+// The vendor-pinning smoke tests below assert against byte counts and golden values from
+// the vendored snapshot's own test vectors; a cros-codecs re-sync that shifts parser
+// behavior must trip HERE, in our tree, not in a decode session.
+#[cfg(test)]
+mod vendor_smoke {
+ use std::io::Cursor;
+
+ use cros_codecs::bitstream_utils::IvfIterator;
+ use cros_codecs::codec::av1::parser::ObuAction;
+ use cros_codecs::codec::av1::parser::ParsedObu;
+ use cros_codecs::codec::h264::parser::Nalu as H264Nalu;
+ use cros_codecs::codec::h264::parser::Parser as H264Parser;
+ use cros_codecs::codec::h265::parser::Nalu as H265Nalu;
+ use cros_codecs::codec::h265::parser::Parser as H265Parser;
+
+ const H264_25FPS: &[u8] =
+ include_bytes!("../vendor/cros-codecs/src/codec/h264/test_data/test-25fps.h264");
+ const H265_25FPS: &[u8] =
+ include_bytes!("../vendor/cros-codecs/src/codec/h265/test_data/test-25fps.h265");
+ const AV1_25FPS: &[u8] =
+ include_bytes!("../vendor/cros-codecs/src/codec/av1/test_data/test-25fps.ivf.av1");
+ const VP9_25FPS: &[u8] =
+ include_bytes!("../vendor/cros-codecs/src/codec/vp9/test_data/test-25fps.vp9");
+
+ #[test]
+ fn h264_parses_the_vendored_vector_to_its_goldens() {
+ let mut cursor = Cursor::new(H264_25FPS);
+ let mut parser = H264Parser::default();
+ let (mut nalus, mut sps, mut slices) = (0u32, 0u32, 0u32);
+ let mut coded = (0u32, 0u32);
+ while let Ok(nalu) = H264Nalu::next(&mut cursor) {
+ nalus += 1;
+ if let Ok(s) = parser.parse_sps(&nalu) {
+ sps += 1;
+ coded = (
+ (s.pic_width_in_mbs_minus1 as u32 + 1) * 16,
+ (s.pic_height_in_map_units_minus1 as u32 + 1) * 16,
+ );
+ continue;
+ }
+ if parser.parse_pps(&nalu).is_ok() {
+ continue;
+ }
+ if parser.parse_slice_header(nalu).is_ok() {
+ slices += 1;
+ }
+ }
+ // 759 is upstream's own golden for this stream (chromium h264_parser_unittest lineage).
+ assert_eq!(nalus, 759);
+ assert_eq!(sps, 4);
+ assert_eq!(slices, 500);
+ assert_eq!(coded, (320, 240));
+ }
+
+ #[test]
+ fn h265_parses_the_vendored_vector() {
+ let mut cursor = Cursor::new(H265_25FPS);
+ let mut parser = H265Parser::default();
+ let (mut nalus, mut sps, mut slices) = (0u32, 0u32, 0u32);
+ while let Ok(nalu) = H265Nalu::next(&mut cursor) {
+ nalus += 1;
+ if parser.parse_sps(&nalu).is_ok() {
+ sps += 1;
+ continue;
+ }
+ if parser.parse_pps(&nalu).is_ok() {
+ continue;
+ }
+ if parser.parse_slice_header(nalu).is_ok() {
+ slices += 1;
+ }
+ }
+ assert_eq!(nalus, 254);
+ assert_eq!(sps, 1);
+ assert_eq!(slices, 250);
+ }
+
+ #[test]
+ fn av1_walks_obus_and_maintains_ref_slots_across_the_stream() {
+ let mut parser = cros_codecs::codec::av1::parser::Parser::default();
+ let (mut obus, mut frames) = (0u32, 0u32);
+ for packet in IvfIterator::new(AV1_25FPS) {
+ let mut consumed = 0;
+ while let Ok(action) = parser.read_obu(&packet[consumed..]) {
+ let obu = match action {
+ ObuAction::Process(obu) => obu,
+ ObuAction::Drop(n) => {
+ consumed += n as usize;
+ continue;
+ }
+ };
+ consumed += obu.bytes_used;
+ obus += 1;
+ // `ref_frame_update` is the parser's ref-slot bookkeeping; without it,
+ // inter frames fail with "Reference is invalid" — the parser validates
+ // reference integrity rather than trusting the stream.
+ match parser.parse_obu(obu).expect("parse_obu") {
+ ParsedObu::FrameHeader(fh) => {
+ frames += 1;
+ parser.ref_frame_update(&fh).expect("ref slot update");
+ }
+ ParsedObu::Frame(f) => {
+ frames += 1;
+ parser.ref_frame_update(&f.header).expect("ref slot update");
+ }
+ _ => {}
+ }
+ }
+ }
+ // 525 is upstream's own golden (cross-checked against GStreamer's OBU walk).
+ assert_eq!(obus, 525);
+ assert_eq!(frames, 274);
+ }
+
+ #[test]
+ fn vp9_splits_superframes_and_parses_headers() {
+ let mut parser = cros_codecs::codec::vp9::parser::Parser::default();
+ let (mut chunks, mut frames) = (0u32, 0u32);
+ for packet in IvfIterator::new(VP9_25FPS) {
+ chunks += 1;
+ frames += parser
+ .parse_chunk(packet.as_ref())
+ .expect("vp9 chunk")
+ .len() as u32;
+ }
+ assert_eq!(chunks, 250);
+ // > chunks proves superframe splitting engaged.
+ assert_eq!(frames, 269);
+ }
+}
diff --git a/crates/pf-bitstream/vendor/cros-codecs/Cargo.toml b/crates/pf-bitstream/vendor/cros-codecs/Cargo.toml
new file mode 100644
index 00000000..898bfe87
--- /dev/null
+++ b/crates/pf-bitstream/vendor/cros-codecs/Cargo.toml
@@ -0,0 +1,17 @@
+# Vendored snapshot — see PROVENANCE.md. Deliberately NOT opted into workspace lints
+# or workspace package inheritance: upstream code stays as close to pristine as the
+# trim allows, so re-syncing against the AOSP tree stays a diff, not an archaeology dig.
+[package]
+name = "cros-codecs"
+version = "0.0.5"
+license = "BSD-3-Clause"
+description = "Vendored cros-codecs parser layer (codec module only) for pf-bitstream"
+edition = "2021"
+
+[dependencies]
+log = "0.4"
+
+# Upstream's in-tree unit tests (kept — they are the conformance goldens) want these.
+[dev-dependencies]
+env_logger = "0.11"
+serde_json = "1"
diff --git a/crates/pf-bitstream/vendor/cros-codecs/LICENSE b/crates/pf-bitstream/vendor/cros-codecs/LICENSE
new file mode 100644
index 00000000..9c1f8394
--- /dev/null
+++ b/crates/pf-bitstream/vendor/cros-codecs/LICENSE
@@ -0,0 +1,26 @@
+Copyright 2022 The ChromiumOS Authors
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors
+ may be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/crates/pf-bitstream/vendor/cros-codecs/PROVENANCE.md b/crates/pf-bitstream/vendor/cros-codecs/PROVENANCE.md
new file mode 100644
index 00000000..659b495f
--- /dev/null
+++ b/crates/pf-bitstream/vendor/cros-codecs/PROVENANCE.md
@@ -0,0 +1,45 @@
+# Vendored: cros-codecs (parser layer only)
+
+- **Upstream:** (the
+ authoritative AOSP tree). Snapshot taken from the read-only GitHub mirror
+ , branch `main`,
+ commit **`5ff6d693ffae0b36935b8fc13092c733b4c2646f`**, fetched 2026-08-05.
+- **License:** BSD-3-Clause (`LICENSE`, copied verbatim). Attribution headers retained
+ in every source file.
+- **Why vendored, not a crates.io dependency:** the GitHub repo is a read-only mirror
+ and the crates.io release lags it; a pinned, reviewed snapshot is the supply-chain
+ posture punktfunk already uses elsewhere (`clients/android/native/vendor/ndk`,
+ `punktfunk-host/vendor/usbip-sim`). Decision of record:
+ punktfunk-planning `design/client-native-decode.md` §8.1.
+
+## What was taken
+
+`src/codec/{h264,h265,av1,vp9}` (parsers, DPBs, picture types, NALU/OBU machinery,
+their `test_data` vectors — they double as punktfunk's conformance corpus),
+`src/bitstream_utils.rs`, `LICENSE`. Upstream designed the `codec` module for exactly
+this extraction — its module doc: "There shall be no dependencies from other modules of
+this crate to this module, so that it can be turned into a crate of its own if needed
+in the future."
+
+## What was left behind
+
+- `decoder/`, `encoder/`, `backend/`, `c2_wrapper/`, `video_frame`, `image_processing`,
+ `utils` — the Linux-only halves (libva/v4l2/gbm/nix). punktfunk's `pf-bitstream` +
+ `pf-vkdecode` occupy that layer.
+- `codec/vp8` — VP9 has no dependency on it (verified) and no punktfunk host will ever
+ emit VP8.
+
+## Deviations from pristine upstream
+
+1. `src/lib.rs` — rewritten: keeps only the module decls and `Resolution` /
+ `ResolutionRoundMode` (the sole root items `codec` references), both copied verbatim;
+ adds crate-level `#![allow(clippy::all, mismatched_lifetime_syntaxes)]` — vendored
+ code is not held to the workspace lint bar (CI's `-D warnings` legs would fail on
+ upstream style otherwise).
+2. `src/codec.rs` — one line removed (`pub mod vp8;`).
+3. `Cargo.toml` — rewritten: `log` is the only dependency the vendored subset needs,
+ plus `env_logger`/`serde_json` dev-dependencies for upstream's in-tree tests.
+4. `cargo fmt` normalization under the workspace's rustfmt config (mechanical only).
+
+Re-sync procedure: fetch the AOSP tree, re-apply this trim, diff `codec/` +
+`bitstream_utils.rs` (expect near-zero conflicts), update the commit pin above.
diff --git a/crates/pf-bitstream/vendor/cros-codecs/src/bitstream_utils.rs b/crates/pf-bitstream/vendor/cros-codecs/src/bitstream_utils.rs
new file mode 100644
index 00000000..07d59dfe
--- /dev/null
+++ b/crates/pf-bitstream/vendor/cros-codecs/src/bitstream_utils.rs
@@ -0,0 +1,788 @@
+// Copyright 2024 The ChromiumOS Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+use std::borrow::Cow;
+use std::fmt;
+use std::io::Cursor;
+use std::io::Read;
+use std::io::Seek;
+use std::io::SeekFrom;
+use std::io::Write;
+use std::marker::PhantomData;
+
+use crate::codec::h264::parser::Nalu as H264Nalu;
+use crate::codec::h265::parser::Nalu as H265Nalu;
+
+/// A bit reader for codec bitstreams. It properly handles emulation-prevention
+/// bytes and stop bits for H264.
+#[derive(Clone)]
+pub(crate) struct BitReader<'a> {
+ /// A reference into the next unread byte in the stream.
+ data: Cursor<&'a [u8]>,
+ /// Contents of the current byte. First unread bit starting at position 8 -
+ /// num_remaining_bits_in_curr_bytes.
+ curr_byte: u8,
+ /// Number of bits remaining in `curr_byte`
+ num_remaining_bits_in_curr_byte: usize,
+ /// Used in emulation prevention byte detection.
+ prev_two_bytes: u16,
+ /// Number of emulation prevention bytes (i.e. 0x000003) we found.
+ num_epb: usize,
+ /// Whether or not we need emulation prevention logic.
+ needs_epb: bool,
+ /// How many bits have been read so far.
+ position: u64,
+}
+
+#[derive(Debug)]
+pub(crate) enum GetByteError {
+ OutOfBits,
+}
+
+impl fmt::Display for GetByteError {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ write!(f, "reader ran out of bits")
+ }
+}
+
+#[derive(Debug)]
+pub(crate) enum ReadBitsError {
+ TooManyBitsRequested(usize),
+ GetByte(GetByteError),
+ ConversionFailed,
+}
+
+impl fmt::Display for ReadBitsError {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match self {
+ ReadBitsError::TooManyBitsRequested(bits) => {
+ write!(f, "more than 31 ({}) bits were requested", bits)
+ }
+ ReadBitsError::GetByte(_) => write!(f, "failed to advance the current byte"),
+ ReadBitsError::ConversionFailed => {
+ write!(f, "failed to convert read input to target type")
+ }
+ }
+ }
+}
+
+impl From for ReadBitsError {
+ fn from(err: GetByteError) -> Self {
+ ReadBitsError::GetByte(err)
+ }
+}
+
+impl<'a> BitReader<'a> {
+ pub fn new(data: &'a [u8], needs_epb: bool) -> Self {
+ Self {
+ data: Cursor::new(data),
+ curr_byte: Default::default(),
+ num_remaining_bits_in_curr_byte: Default::default(),
+ prev_two_bytes: 0xffff,
+ num_epb: Default::default(),
+ needs_epb: needs_epb,
+ position: 0,
+ }
+ }
+
+ /// Read a single bit from the stream.
+ pub fn read_bit(&mut self) -> Result {
+ let bit = self.read_bits::(1)?;
+ match bit {
+ 1 => Ok(true),
+ 0 => Ok(false),
+ _ => panic!("Unexpected value {}", bit),
+ }
+ }
+
+ /// Read up to 31 bits from the stream. Note that we don't want to read 32
+ /// bits even though we're returning a u32 because that would break the
+ /// read_bits_signed() function. 31 bits should be overkill for compressed
+ /// header parsing anyway.
+ pub fn read_bits>(&mut self, num_bits: usize) -> Result {
+ if num_bits > 31 {
+ return Err(ReadBitsError::TooManyBitsRequested(num_bits).to_string());
+ }
+
+ let mut bits_left = num_bits;
+ let mut out = 0u32;
+
+ while self.num_remaining_bits_in_curr_byte < bits_left {
+ out |= (self.curr_byte as u32) << (bits_left - self.num_remaining_bits_in_curr_byte);
+ bits_left -= self.num_remaining_bits_in_curr_byte;
+ self.move_to_next_byte().map_err(|err| err.to_string())?;
+ }
+
+ out |= (self.curr_byte >> (self.num_remaining_bits_in_curr_byte - bits_left)) as u32;
+ out &= (1 << num_bits) - 1;
+ self.num_remaining_bits_in_curr_byte -= bits_left;
+ self.position += num_bits as u64;
+
+ U::try_from(out).map_err(|_| ReadBitsError::ConversionFailed.to_string())
+ }
+
+ /// Reads a two's complement signed integer of length |num_bits|.
+ pub fn read_bits_signed>(&mut self, num_bits: usize) -> Result {
+ let mut out: i32 = self
+ .read_bits::(num_bits)?
+ .try_into()
+ .map_err(|_| ReadBitsError::ConversionFailed.to_string())?;
+ if out >> (num_bits - 1) != 0 {
+ out |= -1i32 ^ ((1 << num_bits) - 1);
+ }
+
+ U::try_from(out).map_err(|_| ReadBitsError::ConversionFailed.to_string())
+ }
+
+ /// Reads an unsigned integer from the stream and checks if the stream is byte aligned.
+ pub fn read_bits_aligned>(&mut self, num_bits: usize) -> Result {
+ if self.num_remaining_bits_in_curr_byte % 8 != 0 {
+ return Err("Attempted unaligned read_le()".into());
+ }
+
+ Ok(self.read_bits(num_bits).map_err(|err| err.to_string())?)
+ }
+
+ /// Skip `num_bits` bits from the stream.
+ pub fn skip_bits(&mut self, mut num_bits: usize) -> Result<(), String> {
+ while num_bits > 0 {
+ let n = std::cmp::min(num_bits, 31);
+ self.read_bits::(n)?;
+ num_bits -= n;
+ }
+
+ Ok(())
+ }
+
+ /// Returns the amount of bits left in the stream
+ pub fn num_bits_left(&mut self) -> usize {
+ let cur_pos = self.data.position();
+ // This should always be safe to unwrap.
+ let end_pos = self.data.seek(SeekFrom::End(0)).unwrap();
+ let _ = self.data.seek(SeekFrom::Start(cur_pos));
+ ((end_pos - cur_pos) as usize) * 8 + self.num_remaining_bits_in_curr_byte
+ }
+
+ /// Returns the number of emulation-prevention bytes read so far.
+ pub fn num_epb(&self) -> usize {
+ self.num_epb
+ }
+
+ /// Whether the stream still has RBSP data. Implements more_rbsp_data(). See
+ /// the spec for more details.
+ pub fn has_more_rsbp_data(&mut self) -> bool {
+ if self.num_remaining_bits_in_curr_byte == 0 && self.move_to_next_byte().is_err() {
+ // no more data at all in the rbsp
+ return false;
+ }
+
+ // If the next bit is the stop bit, then we should only see unset bits
+ // until the end of the data.
+ if (self.curr_byte & ((1 << (self.num_remaining_bits_in_curr_byte - 1)) - 1)) != 0 {
+ return true;
+ }
+
+ let mut buf = [0u8; 1];
+ let orig_pos = self.data.position();
+ while let Ok(_) = self.data.read_exact(&mut buf) {
+ if buf[0] != 0 {
+ self.data.set_position(orig_pos);
+ return true;
+ }
+ }
+ false
+ }
+
+ /// Reads an Unsigned Exponential golomb coding number from the next bytes in the
+ /// bitstream. This may advance the state of position within the bitstream even if the
+ /// read operation is unsuccessful. See H264 Annex B specification 9.1 for details.
+ pub fn read_ue>(&mut self) -> Result {
+ let mut num_bits = 0;
+
+ while self.read_bits::(1)? == 0 {
+ num_bits += 1;
+ if num_bits > 31 {
+ return Err("invalid stream".into());
+ }
+ }
+
+ let value = ((1u32 << num_bits) - 1)
+ .checked_add(self.read_bits::(num_bits)?)
+ .ok_or::("read number cannot fit in 32 bits".into())?;
+
+ U::try_from(value).map_err(|_| "conversion error".into())
+ }
+
+ pub fn read_ue_bounded>(&mut self, min: u32, max: u32) -> Result {
+ let ue = self.read_ue()?;
+ if ue > max || ue < min {
+ Err(format!(
+ "Value out of bounds: expected {} - {}, got {}",
+ min, max, ue
+ ))
+ } else {
+ Ok(U::try_from(ue).map_err(|_| String::from("Conversion error"))?)
+ }
+ }
+
+ pub fn read_ue_max>(&mut self, max: u32) -> Result {
+ self.read_ue_bounded(0, max)
+ }
+
+ /// Reads a signed exponential golomb coding number. Instead of using two's
+ /// complement, this scheme maps even integers to positive numbers and odd
+ /// integers to negative numbers. The least significant bit indicates the
+ /// sign. See H264 Annex B specification 9.1.1 for details.
+ pub fn read_se>(&mut self) -> Result {
+ let ue = self.read_ue::()? as i32;
+
+ if ue % 2 == 0 {
+ Ok(U::try_from(-(ue / 2)).map_err(|_| String::from("Conversion error"))?)
+ } else {
+ Ok(U::try_from(ue / 2 + 1).map_err(|_| String::from("Conversion error"))?)
+ }
+ }
+
+ pub fn read_se_bounded>(&mut self, min: i32, max: i32) -> Result {
+ let se = self.read_se()?;
+ if se < min || se > max {
+ Err(format!(
+ "Value out of bounds, expected between {}-{}, got {}",
+ min, max, se
+ ))
+ } else {
+ Ok(U::try_from(se).map_err(|_| String::from("Conversion error"))?)
+ }
+ }
+
+ /// Read little endian multi-byte integer.
+ pub fn read_le>(&mut self, num_bits: u8) -> Result {
+ let mut t = 0;
+
+ for i in 0..num_bits {
+ let byte = self.read_bits_aligned::(8)?;
+ t += byte << (i * 8)
+ }
+
+ Ok(U::try_from(t).map_err(|_| String::from("Conversion error"))?)
+ }
+
+ /// Return the position of this bitstream in bits.
+ pub fn position(&self) -> u64 {
+ self.position
+ }
+
+ fn get_byte(&mut self) -> Result {
+ let mut buf = [0u8; 1];
+ self.data
+ .read_exact(&mut buf)
+ .map_err(|_| GetByteError::OutOfBits)?;
+ Ok(buf[0])
+ }
+
+ fn move_to_next_byte(&mut self) -> Result<(), GetByteError> {
+ let mut byte = self.get_byte()?;
+
+ if self.needs_epb {
+ if self.prev_two_bytes == 0 && byte == 0x03 {
+ // We found an epb
+ self.num_epb += 1;
+ // Read another byte
+ byte = self.get_byte()?;
+ // We need another 3 bytes before another epb can happen.
+ self.prev_two_bytes = 0xffff;
+ }
+ self.prev_two_bytes = (self.prev_two_bytes << 8) | u16::from(byte);
+ }
+
+ self.num_remaining_bits_in_curr_byte = 8;
+ self.curr_byte = byte;
+ Ok(())
+ }
+}
+
+/// Iterator over IVF packets.
+pub struct IvfIterator<'a> {
+ cursor: Cursor<&'a [u8]>,
+}
+
+impl<'a> IvfIterator<'a> {
+ pub fn new(data: &'a [u8]) -> Self {
+ let mut cursor = Cursor::new(data);
+
+ // Skip the IVH header entirely.
+ cursor.seek(std::io::SeekFrom::Start(32)).unwrap();
+
+ Self { cursor }
+ }
+}
+
+impl<'a> Iterator for IvfIterator<'a> {
+ type Item = &'a [u8];
+
+ fn next(&mut self) -> Option {
+ // Make sure we have a header.
+ let mut len_buf = [0u8; 4];
+ self.cursor.read_exact(&mut len_buf).ok()?;
+ let len = ((len_buf[3] as usize) << 24)
+ | ((len_buf[2] as usize) << 16)
+ | ((len_buf[1] as usize) << 8)
+ | (len_buf[0] as usize);
+
+ // Skip PTS.
+ self.cursor.seek(std::io::SeekFrom::Current(8)).ok()?;
+
+ let start = self.cursor.position() as usize;
+ let _ = self
+ .cursor
+ .seek(std::io::SeekFrom::Current(len as i64))
+ .ok()?;
+ let end = self.cursor.position() as usize;
+
+ Some(&self.cursor.get_ref()[start..end])
+ }
+}
+
+/// Helper struct for synthesizing IVF file header
+pub struct IvfFileHeader {
+ pub magic: [u8; 4],
+ pub version: u16,
+ pub header_size: u16,
+ pub codec: [u8; 4],
+ pub width: u16,
+ pub height: u16,
+ pub framerate: u32,
+ pub timescale: u32,
+ pub frame_count: u32,
+ pub unused: u32,
+}
+
+impl Default for IvfFileHeader {
+ fn default() -> Self {
+ Self {
+ magic: Self::MAGIC,
+ version: 0,
+ header_size: 32,
+ codec: Self::CODEC_VP9,
+ width: 320,
+ height: 240,
+ framerate: 1,
+ timescale: 1000,
+ frame_count: 1,
+ unused: Default::default(),
+ }
+ }
+}
+
+impl IvfFileHeader {
+ pub const MAGIC: [u8; 4] = *b"DKIF";
+ pub const CODEC_VP8: [u8; 4] = *b"VP80";
+ pub const CODEC_VP9: [u8; 4] = *b"VP90";
+ pub const CODEC_AV1: [u8; 4] = *b"AV01";
+
+ pub fn new(codec: [u8; 4], width: u16, height: u16, framerate: u32, frame_count: u32) -> Self {
+ let default = Self::default();
+
+ Self {
+ codec,
+ width,
+ height,
+ framerate: framerate * default.timescale,
+ frame_count,
+ ..default
+ }
+ }
+}
+
+impl IvfFileHeader {
+ /// Writes header into writer
+ pub fn writo_into(&self, writer: &mut impl std::io::Write) -> std::io::Result<()> {
+ writer.write_all(&self.magic)?;
+ writer.write_all(&self.version.to_le_bytes())?;
+ writer.write_all(&self.header_size.to_le_bytes())?;
+ writer.write_all(&self.codec)?;
+ writer.write_all(&self.width.to_le_bytes())?;
+ writer.write_all(&self.height.to_le_bytes())?;
+ writer.write_all(&self.framerate.to_le_bytes())?;
+ writer.write_all(&self.timescale.to_le_bytes())?;
+ writer.write_all(&self.frame_count.to_le_bytes())?;
+ writer.write_all(&self.unused.to_le_bytes())?;
+
+ Ok(())
+ }
+}
+
+/// Helper struct for synthesizing IVF frame header
+pub struct IvfFrameHeader {
+ pub frame_size: u32,
+ pub timestamp: u64,
+}
+
+impl IvfFrameHeader {
+ /// Writes header into writer
+ pub fn writo_into(&self, writer: &mut impl std::io::Write) -> std::io::Result<()> {
+ writer.write_all(&self.frame_size.to_le_bytes())?;
+ writer.write_all(&self.timestamp.to_le_bytes())?;
+ Ok(())
+ }
+}
+
+/// Iterator NALUs in a bitstream.
+pub struct NalIterator<'a, Nalu>(Cursor<&'a [u8]>, PhantomData);
+
+impl<'a, Nalu> NalIterator<'a, Nalu> {
+ pub fn new(stream: &'a [u8]) -> Self {
+ Self(Cursor::new(stream), PhantomData)
+ }
+}
+
+impl<'a> Iterator for NalIterator<'a, H264Nalu<'a>> {
+ type Item = Cow<'a, [u8]>;
+
+ fn next(&mut self) -> Option {
+ H264Nalu::next(&mut self.0).map(|n| n.data).ok()
+ }
+}
+
+impl<'a> Iterator for NalIterator<'a, H265Nalu<'a>> {
+ type Item = Cow<'a, [u8]>;
+
+ fn next(&mut self) -> Option {
+ H265Nalu::next(&mut self.0).map(|n| n.data).ok()
+ }
+}
+
+#[derive(Debug)]
+pub enum BitWriterError {
+ InvalidBitCount,
+ Io(std::io::Error),
+}
+
+impl fmt::Display for BitWriterError {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match self {
+ BitWriterError::InvalidBitCount => write!(f, "invalid bit count"),
+ BitWriterError::Io(x) => write!(f, "{}", x.to_string()),
+ }
+ }
+}
+
+impl From for BitWriterError {
+ fn from(err: std::io::Error) -> Self {
+ BitWriterError::Io(err)
+ }
+}
+
+pub type BitWriterResult = std::result::Result;
+
+pub struct BitWriter {
+ out: W,
+ nth_bit: u8,
+ curr_byte: u8,
+}
+
+impl BitWriter {
+ pub fn new(writer: W) -> Self {
+ Self {
+ out: writer,
+ curr_byte: 0,
+ nth_bit: 0,
+ }
+ }
+
+ /// Writes fixed bit size integer (up to 32 bit)
+ pub fn write_f>(&mut self, bits: usize, value: T) -> BitWriterResult {
+ let value = value.into();
+
+ if bits > 32 {
+ return Err(BitWriterError::InvalidBitCount);
+ }
+
+ let mut written = 0;
+ for bit in (0..bits).rev() {
+ let bit = (1 << bit) as u32;
+
+ self.write_bit((value & bit) == bit)?;
+ written += 1;
+ }
+
+ Ok(written)
+ }
+
+ /// Takes a single bit that will be outputed to [`std::io::Write`]
+ pub fn write_bit(&mut self, bit: bool) -> BitWriterResult<()> {
+ self.curr_byte |= (bit as u8) << (7u8 - self.nth_bit);
+ self.nth_bit += 1;
+
+ if self.nth_bit == 8 {
+ self.out.write_all(&[self.curr_byte])?;
+ self.nth_bit = 0;
+ self.curr_byte = 0;
+ }
+
+ Ok(())
+ }
+
+ /// Immediately outputs any cached bits to [`std::io::Write`]
+ pub fn flush(&mut self) -> BitWriterResult<()> {
+ if self.nth_bit != 0 {
+ self.out.write_all(&[self.curr_byte])?;
+ self.nth_bit = 0;
+ self.curr_byte = 0;
+ }
+
+ self.out.flush()?;
+ Ok(())
+ }
+
+ /// Returns `true` if ['Self`] hold data that wasn't written to [`std::io::Write`]
+ pub fn has_data_pending(&self) -> bool {
+ self.nth_bit != 0
+ }
+
+ pub(crate) fn inner(&self) -> &W {
+ &self.out
+ }
+
+ pub(crate) fn inner_mut(&mut self) -> &mut W {
+ &mut self.out
+ }
+}
+
+impl Drop for BitWriter {
+ fn drop(&mut self) {
+ if let Err(e) = self.flush() {
+ log::error!("Unable to flush bits {e:?}");
+ }
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn test_ivf_file_header() {
+ let mut hdr = IvfFileHeader {
+ version: 0,
+ codec: IvfFileHeader::CODEC_VP9,
+ width: 256,
+ height: 256,
+ framerate: 30_000,
+ timescale: 1_000,
+ frame_count: 1,
+
+ ..Default::default()
+ };
+
+ let mut buf = Vec::new();
+ hdr.writo_into(&mut buf).unwrap();
+
+ const EXPECTED: [u8; 32] = [
+ 0x44, 0x4b, 0x49, 0x46, 0x00, 0x00, 0x20, 0x00, 0x56, 0x50, 0x39, 0x30, 0x00, 0x01,
+ 0x00, 0x01, 0x30, 0x75, 0x00, 0x00, 0xe8, 0x03, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ ];
+
+ assert_eq!(&buf, &EXPECTED);
+
+ hdr.width = 1920;
+ hdr.height = 800;
+ hdr.framerate = 24;
+ hdr.timescale = 1;
+ hdr.frame_count = 100;
+
+ buf.clear();
+ hdr.writo_into(&mut buf).unwrap();
+
+ const EXPECTED2: [u8; 32] = [
+ 0x44, 0x4b, 0x49, 0x46, 0x00, 0x00, 0x20, 0x00, 0x56, 0x50, 0x39, 0x30, 0x80, 0x07,
+ 0x20, 0x03, 0x18, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ ];
+
+ assert_eq!(&buf, &EXPECTED2);
+ }
+
+ #[test]
+ fn test_ivf_frame_header() {
+ let mut hdr = IvfFrameHeader {
+ frame_size: 199249,
+ timestamp: 0,
+ };
+
+ let mut buf = Vec::new();
+ hdr.writo_into(&mut buf).unwrap();
+
+ const EXPECTED: [u8; 12] = [
+ 0x51, 0x0a, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ ];
+
+ assert_eq!(&buf, &EXPECTED);
+
+ hdr.timestamp = 1;
+ hdr.frame_size = 52;
+
+ buf.clear();
+ hdr.writo_into(&mut buf).unwrap();
+
+ const EXPECTED2: [u8; 12] = [
+ 0x34, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ ];
+
+ assert_eq!(&buf, &EXPECTED2);
+ }
+
+ #[test]
+ fn test_bitwriter_f1() {
+ let mut buf = Vec::::new();
+ {
+ let mut writer = BitWriter::new(&mut buf);
+ writer.write_f(1, true).unwrap();
+ writer.write_f(1, false).unwrap();
+ writer.write_f(1, false).unwrap();
+ writer.write_f(1, false).unwrap();
+ writer.write_f(1, true).unwrap();
+ writer.write_f(1, true).unwrap();
+ writer.write_f(1, true).unwrap();
+ writer.write_f(1, true).unwrap();
+ }
+ assert_eq!(buf, vec![0b10001111u8]);
+ }
+
+ #[test]
+ fn test_bitwriter_f3() {
+ let mut buf = Vec::::new();
+ {
+ let mut writer = BitWriter::new(&mut buf);
+ writer.write_f(3, 0b100u8).unwrap();
+ writer.write_f(3, 0b101u8).unwrap();
+ writer.write_f(3, 0b011u8).unwrap();
+ }
+ assert_eq!(buf, vec![0b10010101u8, 0b10000000u8]);
+ }
+
+ #[test]
+ fn test_bitwriter_f4() {
+ let mut buf = Vec::::new();
+ {
+ let mut writer = BitWriter::new(&mut buf);
+ writer.write_f(4, 0b1000u8).unwrap();
+ writer.write_f(4, 0b1011u8).unwrap();
+ }
+ assert_eq!(buf, vec![0b10001011u8]);
+ }
+
+ // These tests are adapted from the chromium tests at media/video/h264_bit_reader_unitttest.cc
+
+ #[test]
+ fn read_stream_without_escape_and_trailing_zero_bytes() {
+ const RBSP: [u8; 6] = [0x01, 0x23, 0x45, 0x67, 0x89, 0xa0];
+
+ let mut reader = BitReader::new(&RBSP, true);
+ assert_eq!(reader.read_bits::(1).unwrap(), 0);
+ assert_eq!(reader.num_bits_left(), 47);
+ assert!(reader.has_more_rsbp_data());
+
+ assert_eq!(reader.read_bits::(8).unwrap(), 0x02);
+ assert_eq!(reader.num_bits_left(), 39);
+ assert!(reader.has_more_rsbp_data());
+
+ assert_eq!(reader.read_bits::(31).unwrap(), 0x23456789);
+ assert_eq!(reader.num_bits_left(), 8);
+ assert!(reader.has_more_rsbp_data());
+
+ assert_eq!(reader.read_bits::(1).unwrap(), 1);
+ assert_eq!(reader.num_bits_left(), 7);
+ assert!(reader.has_more_rsbp_data());
+
+ assert_eq!(reader.read_bits::(1).unwrap(), 0);
+ assert_eq!(reader.num_bits_left(), 6);
+ assert!(!reader.has_more_rsbp_data());
+ }
+
+ #[test]
+ fn single_byte_stream() {
+ const RBSP: [u8; 1] = [0x18];
+
+ let mut reader = BitReader::new(&RBSP, true);
+ assert_eq!(reader.num_bits_left(), 8);
+ assert!(reader.has_more_rsbp_data());
+ assert_eq!(reader.read_bits::(4).unwrap(), 1);
+ assert!(!reader.has_more_rsbp_data());
+ }
+
+ #[test]
+ fn stop_bit_occupy_full_byte() {
+ const RBSP: [u8; 2] = [0xab, 0x80];
+
+ let mut reader = BitReader::new(&RBSP, true);
+ assert_eq!(reader.num_bits_left(), 16);
+ assert!(reader.has_more_rsbp_data());
+
+ assert_eq!(reader.read_bits::(8).unwrap(), 0xab);
+ assert_eq!(reader.num_bits_left(), 8);
+
+ assert!(!reader.has_more_rsbp_data());
+ }
+
+ // Check that read_ue behaves properly with input at the limits.
+ #[test]
+ fn read_ue() {
+ // Regular value.
+ let mut reader = BitReader::new(&[0b0001_1010], true);
+ assert_eq!(reader.read_ue::().unwrap(), 12);
+ assert_eq!(reader.data.position(), 1);
+ assert_eq!(reader.num_remaining_bits_in_curr_byte, 1);
+
+ // 0 value.
+ let mut reader = BitReader::new(&[0b1000_0000], true);
+ assert_eq!(reader.read_ue::().unwrap(), 0);
+ assert_eq!(reader.data.position(), 1);
+ assert_eq!(reader.num_remaining_bits_in_curr_byte, 7);
+
+ // No prefix stop bit.
+ let mut reader = BitReader::new(&[0b0000_0000], true);
+ reader.read_ue::().unwrap_err();
+
+ // u32 max value: 31 0-bits, 1 bit marker, 31 bits 1-bits.
+ let mut reader = BitReader::new(
+ &[
+ 0b0000_0000,
+ 0b0000_0000,
+ 0b0000_0000,
+ 0b0000_0001,
+ 0b1111_1111,
+ 0b1111_1111,
+ 0b1111_1111,
+ 0b1111_1110,
+ ],
+ true,
+ );
+ assert_eq!(reader.read_ue::().unwrap(), 0xffff_fffe);
+ assert_eq!(reader.data.position(), 8);
+ assert_eq!(reader.num_remaining_bits_in_curr_byte, 1);
+ }
+
+ // Check that emulation prevention is being handled correctly.
+ #[test]
+ fn skip_epb_when_enabled() {
+ let mut reader = BitReader::new(&[0x00, 0x00, 0x03, 0x01], false);
+ assert_eq!(reader.read_bits::(8).unwrap(), 0x00);
+ assert_eq!(reader.read_bits::(8).unwrap(), 0x00);
+ assert_eq!(reader.read_bits::(8).unwrap(), 0x03);
+ assert_eq!(reader.read_bits::(8).unwrap(), 0x01);
+
+ let mut reader = BitReader::new(&[0x00, 0x00, 0x03, 0x01], true);
+ assert_eq!(reader.read_bits::(8).unwrap(), 0x00);
+ assert_eq!(reader.read_bits::(8).unwrap(), 0x00);
+ assert_eq!(reader.read_bits::(8).unwrap(), 0x01);
+ }
+
+ #[test]
+ fn read_signed_bits() {
+ let mut reader = BitReader::new(&[0b1111_0000], false);
+ assert_eq!(reader.read_bits_signed::(4).unwrap(), -1);
+ }
+}
diff --git a/crates/pf-bitstream/vendor/cros-codecs/src/codec.rs b/crates/pf-bitstream/vendor/cros-codecs/src/codec.rs
new file mode 100644
index 00000000..23876f40
--- /dev/null
+++ b/crates/pf-bitstream/vendor/cros-codecs/src/codec.rs
@@ -0,0 +1,17 @@
+// Copyright 2023 The ChromiumOS Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+//! Parsers for various kinds of encoded streams.
+//!
+//! This module does not provide any actual decoding tools - that's the job of the
+//! [crate::decoder] module. However the parsers of this module are heavily used in order to
+//! implement stateless decoding.
+//!
+//! There shall be no dependencies from other modules of this crate to this module, so that it
+//! can be turned into a crate of its own if needed in the future.
+
+pub mod av1;
+pub mod h264;
+pub mod h265;
+pub mod vp9;
diff --git a/crates/pf-bitstream/vendor/cros-codecs/src/codec/av1.rs b/crates/pf-bitstream/vendor/cros-codecs/src/codec/av1.rs
new file mode 100644
index 00000000..477cd906
--- /dev/null
+++ b/crates/pf-bitstream/vendor/cros-codecs/src/codec/av1.rs
@@ -0,0 +1,9 @@
+// Copyright 2023 The ChromiumOS Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+mod helpers;
+pub mod parser;
+pub mod reader;
+pub mod synthesizer;
+pub mod writer;
diff --git a/crates/pf-bitstream/vendor/cros-codecs/src/codec/av1/helpers.rs b/crates/pf-bitstream/vendor/cros-codecs/src/codec/av1/helpers.rs
new file mode 100644
index 00000000..f8df7cd8
--- /dev/null
+++ b/crates/pf-bitstream/vendor/cros-codecs/src/codec/av1/helpers.rs
@@ -0,0 +1,186 @@
+// Copyright 2023 The ChromiumOS Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+use crate::codec::av1::parser::NUM_REF_FRAMES;
+
+const DIV_LUT: [i32; 257] = [
+ 16384, 16320, 16257, 16194, 16132, 16070, 16009, 15948, 15888, 15828, 15768, 15709, 15650,
+ 15592, 15534, 15477, 15420, 15364, 15308, 15252, 15197, 15142, 15087, 15033, 14980, 14926,
+ 14873, 14821, 14769, 14717, 14665, 14614, 14564, 14513, 14463, 14413, 14364, 14315, 14266,
+ 14218, 14170, 14122, 14075, 14028, 13981, 13935, 13888, 13843, 13797, 13752, 13707, 13662,
+ 13618, 13574, 13530, 13487, 13443, 13400, 13358, 13315, 13273, 13231, 13190, 13148, 13107,
+ 13066, 13026, 12985, 12945, 12906, 12866, 12827, 12788, 12749, 12710, 12672, 12633, 12596,
+ 12558, 12520, 12483, 12446, 12409, 12373, 12336, 12300, 12264, 12228, 12193, 12157, 12122,
+ 12087, 12053, 12018, 11984, 11950, 11916, 11882, 11848, 11815, 11782, 11749, 11716, 11683,
+ 11651, 11619, 11586, 11555, 11523, 11491, 11460, 11429, 11398, 11367, 11336, 11305, 11275,
+ 11245, 11215, 11185, 11155, 11125, 11096, 11067, 11038, 11009, 10980, 10951, 10923, 10894,
+ 10866, 10838, 10810, 10782, 10755, 10727, 10700, 10673, 10645, 10618, 10592, 10565, 10538,
+ 10512, 10486, 10460, 10434, 10408, 10382, 10356, 10331, 10305, 10280, 10255, 10230, 10205,
+ 10180, 10156, 10131, 10107, 10082, 10058, 10034, 10010, 9986, 9963, 9939, 9916, 9892, 9869,
+ 9846, 9823, 9800, 9777, 9754, 9732, 9709, 9687, 9664, 9642, 9620, 9598, 9576, 9554, 9533, 9511,
+ 9489, 9468, 9447, 9425, 9404, 9383, 9362, 9341, 9321, 9300, 9279, 9259, 9239, 9218, 9198, 9178,
+ 9158, 9138, 9118, 9098, 9079, 9059, 9039, 9020, 9001, 8981, 8962, 8943, 8924, 8905, 8886, 8867,
+ 8849, 8830, 8812, 8793, 8775, 8756, 8738, 8720, 8702, 8684, 8666, 8648, 8630, 8613, 8595, 8577,
+ 8560, 8542, 8525, 8508, 8490, 8473, 8456, 8439, 8422, 8405, 8389, 8372, 8355, 8339, 8322, 8306,
+ 8289, 8273, 8257, 8240, 8224, 8208, 8192,
+];
+
+const DIV_LUT_BITS: u32 = 8;
+const DIV_LUT_PREC_BITS: u32 = 14;
+
+/// Implements FloorLog2(x), which is defined to be the floor of the base 2
+/// logarithm of the input x.
+///
+/// The input x will always be an integer, and will always be greater than or equal to 1.
+/// This function extracts the location of the most significant bit in x.
+pub fn floor_log2(mut x: u32) -> u32 {
+ assert!(x > 0);
+ let mut s = 0;
+
+ while x != 0 {
+ x >>= 1;
+ s += 1;
+ }
+
+ s - 1
+}
+
+/// Implements 5.9.3. Get relative distance function
+pub fn get_relative_dist(enable_order_hint: bool, order_hint_bits: i32, a: i32, b: i32) -> i32 {
+ if !enable_order_hint {
+ 0
+ } else {
+ let diff = a - b;
+ let m = 1 << (order_hint_bits - 1);
+ (diff & (m - 1)) - (diff & m)
+ }
+}
+
+/// Implements find_latest_backward from section 7.8.
+pub fn find_latest_backward(
+ shifted_order_hints: &[i32; NUM_REF_FRAMES],
+ used_frame: &[bool; NUM_REF_FRAMES],
+ cur_frame_hint: i32,
+ latest_order_hint: &mut i32,
+) -> i32 {
+ let mut _ref = -1;
+
+ for i in 0..NUM_REF_FRAMES {
+ let hint = shifted_order_hints[i];
+ if !used_frame[i] && hint >= cur_frame_hint && (_ref < 0 || hint >= *latest_order_hint) {
+ _ref = i as i32;
+ *latest_order_hint = hint;
+ }
+ }
+
+ _ref
+}
+
+/// Implements find_earliest_backward from section 7.8.
+pub fn find_earliest_backward(
+ shifted_order_hints: &[i32; NUM_REF_FRAMES],
+ used_frame: &[bool; NUM_REF_FRAMES],
+ cur_frame_hint: i32,
+ earliest_order_hint: &mut i32,
+) -> i32 {
+ let mut _ref = -1;
+
+ for i in 0..NUM_REF_FRAMES {
+ let hint = shifted_order_hints[i];
+ if !used_frame[i] && hint >= cur_frame_hint && (_ref < 0 || hint < *earliest_order_hint) {
+ _ref = i as i32;
+ *earliest_order_hint = hint;
+ }
+ }
+
+ _ref
+}
+
+/// Implements find_latest_forward from section 7.8.
+pub fn find_latest_forward(
+ shifted_order_hints: &[i32; NUM_REF_FRAMES],
+ used_frame: &[bool; NUM_REF_FRAMES],
+ cur_frame_hint: i32,
+ latest_order_hint: &mut i32,
+) -> i32 {
+ let mut _ref = -1;
+ for i in 0..NUM_REF_FRAMES {
+ let hint = shifted_order_hints[i];
+ if !used_frame[i] && hint < cur_frame_hint && (_ref < 0 || hint >= *latest_order_hint) {
+ _ref = i as i32;
+ *latest_order_hint = hint;
+ }
+ }
+
+ _ref
+}
+
+pub fn tile_log2(blk_size: u32, target: u32) -> u32 {
+ let mut k = 0;
+
+ while (blk_size << k) < target {
+ k += 1;
+ }
+
+ k
+}
+
+pub fn clip3(x: i32, y: i32, z: i32) -> i32 {
+ if z < x {
+ x
+ } else if z > y {
+ y
+ } else {
+ z
+ }
+}
+
+/// 5.9.29
+pub fn inverse_recenter(r: i32, v: i32) -> i32 {
+ if v > 2 * r {
+ v
+ } else if v & 1 != 0 {
+ r - ((v + 1) >> 1)
+ } else {
+ r + (v >> 1)
+ }
+}
+
+/// Implements Round2. See 4.7: mathematical functions.
+pub fn round2(x: u32, n: u32) -> u32 {
+ (x + 2u32.pow(n - 1)) / 2u32.pow(n)
+}
+
+/// Implements Round2Signed. See 4.7: mathematical functions.
+pub fn round2signed(x: i32, n: u32) -> Result {
+ if x >= 0 {
+ i32::try_from(round2(x as u32, n)).map_err(|e| e.to_string())
+ } else {
+ let x = x as i64;
+ let val = i32::try_from(round2(-x as u32, n)).map_err(|e| e.to_string())?;
+ Ok(-val)
+ }
+}
+
+/// Implements 7.11.3.7. Resolve divisor process
+pub fn resolve_divisor(d: i32) -> Result<(u32, i32), String> {
+ let abs_d = u32::try_from(d.abs()).unwrap(); // abs cannot return a negative
+ let n = floor_log2(abs_d);
+ let e = abs_d - (1 << n);
+
+ let f = if n > DIV_LUT_BITS {
+ round2(e, n - DIV_LUT_BITS)
+ } else {
+ e << (DIV_LUT_BITS - n)
+ };
+
+ let div_shift = n + DIV_LUT_PREC_BITS;
+ let div_factor = if d < 0 {
+ -DIV_LUT[f as usize]
+ } else {
+ DIV_LUT[f as usize]
+ };
+
+ Ok((div_shift, div_factor))
+}
diff --git a/crates/pf-bitstream/vendor/cros-codecs/src/codec/av1/parser.rs b/crates/pf-bitstream/vendor/cros-codecs/src/codec/av1/parser.rs
new file mode 100644
index 00000000..ecb40a9f
--- /dev/null
+++ b/crates/pf-bitstream/vendor/cros-codecs/src/codec/av1/parser.rs
@@ -0,0 +1,4294 @@
+// Copyright 2023 The ChromiumOS Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+use std::borrow::Cow;
+use std::rc::Rc;
+
+use crate::codec::av1::helpers;
+use crate::codec::av1::reader::Reader;
+
+pub const TOTAL_REFS_PER_FRAME: usize = 8;
+pub const NUM_REF_FRAMES: usize = 8;
+pub const REFS_PER_FRAME: usize = 7;
+pub const MAX_SEGMENTS: usize = 8;
+pub const SEG_LVL_ALT_Q: usize = 0;
+pub const SEG_LVL_ALT_LF_Y_V: usize = 1;
+pub const SEG_LVL_REF_FRAME: usize = 5;
+pub const SEG_LVL_SKIP: usize = 6;
+pub const SEG_LVL_GLOBAL_MV: usize = 7;
+pub const SEG_LVL_MAX: usize = 8;
+pub const MAX_TILE_COLS: usize = 64;
+pub const MAX_TILE_ROWS: usize = 64;
+pub const CDEF_MAX: usize = 1 << 3;
+pub const MAX_NUM_PLANES: usize = 3;
+pub const MAX_NUM_Y_POINTS: usize = 16;
+pub const MAX_NUM_CB_POINTS: usize = 16;
+pub const MAX_NUM_CR_POINTS: usize = 16;
+pub const MAX_NUM_POS_LUMA: usize = 25;
+pub const MAX_NUM_SPATIAL_LAYERS: usize = 4;
+pub const MAX_NUM_TEMPORAL_LAYERS: usize = 8;
+pub const MAX_NUM_OPERATING_POINTS: usize = MAX_NUM_SPATIAL_LAYERS * MAX_NUM_TEMPORAL_LAYERS;
+pub const SELECT_SCREEN_CONTENT_TOOLS: usize = 2;
+pub const SELECT_INTEGER_MV: usize = 2;
+pub const PRIMARY_REF_NONE: u32 = 7;
+pub const SUPERRES_DENOM_BITS: usize = 3;
+pub const SUPERRES_DENOM_MIN: usize = 9;
+pub const SUPERRES_NUM: usize = 8;
+pub const MAX_TILE_WIDTH: u32 = 4096;
+pub const MAX_TILE_HEIGHT: u32 = 2304;
+pub const MAX_TILE_AREA: u32 = MAX_TILE_WIDTH * MAX_TILE_HEIGHT;
+pub const RESTORATION_TILESIZE_MAX: u16 = 256;
+pub const WARPEDMODEL_PREC_BITS: u32 = 16;
+pub const WARP_PARAM_REDUCE_BITS: u32 = 6;
+pub const GM_ABS_ALPHA_BITS: u32 = 12;
+pub const GM_ALPHA_PREC_BITS: u32 = 15;
+pub const GM_ABS_TRANS_ONLY_BITS: u32 = 9;
+pub const GM_TRANS_ONLY_PREC_BITS: u32 = 3;
+pub const GM_ABS_TRANS_BITS: u32 = 12;
+pub const GM_TRANS_PREC_BITS: u32 = 6;
+
+// Same as Segmentation_Feature_Bits in the specification. See 5.9.14
+pub const FEATURE_BITS: [u8; SEG_LVL_MAX] = [8, 6, 6, 6, 6, 3, 0, 0];
+// Same as Segmentation_Feature_Signed in the specification. See 5.9.14
+pub const FEATURE_SIGNED: [bool; SEG_LVL_MAX] = [true, true, true, true, true, false, false, false];
+// Same as Segmentation_Feature_Max in the specification. See 5.9.14
+pub const FEATURE_MAX: [i32; SEG_LVL_MAX] = [255, 63, 63, 63, 63, 7, 0, 0];
+
+/// Tells what should be done with the OBU after [`Parser::read_obu`] is called.
+pub enum ObuAction<'a> {
+ /// We should process the OBU normally.
+ Process(Obu<'a>),
+ /// We should drop this OBU and advance to the next one. The u32 is how much
+ /// we should advance.
+ Drop(u32),
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord)]
+pub enum ObuType {
+ #[default]
+ Reserved = 0,
+ SequenceHeader = 1,
+ TemporalDelimiter = 2,
+ FrameHeader = 3,
+ TileGroup = 4,
+ Metadata = 5,
+ Frame = 6,
+ RedundantFrameHeader = 7,
+ TileList = 8,
+ Reserved2 = 9,
+ Reserved3 = 10,
+ Reserved4 = 11,
+ Reserved5 = 12,
+ Reserved6 = 13,
+ Reserved7 = 14,
+ Padding = 15,
+}
+
+impl TryFrom for ObuType {
+ type Error = String;
+
+ fn try_from(value: u32) -> Result {
+ match value {
+ 0 => Ok(ObuType::Reserved),
+ 1 => Ok(ObuType::SequenceHeader),
+ 2 => Ok(ObuType::TemporalDelimiter),
+ 3 => Ok(ObuType::FrameHeader),
+ 4 => Ok(ObuType::TileGroup),
+ 5 => Ok(ObuType::Metadata),
+ 6 => Ok(ObuType::Frame),
+ 7 => Ok(ObuType::RedundantFrameHeader),
+ 8 => Ok(ObuType::TileList),
+ 9 => Ok(ObuType::Reserved2),
+ 10 => Ok(ObuType::Reserved3),
+ 11 => Ok(ObuType::Reserved4),
+ 12 => Ok(ObuType::Reserved5),
+ 13 => Ok(ObuType::Reserved6),
+ 14 => Ok(ObuType::Reserved7),
+ 15 => Ok(ObuType::Padding),
+ _ => Err(format!("Invalid ObuType {}", value)),
+ }
+ }
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord)]
+pub enum Profile {
+ #[default]
+ Profile0 = 0,
+ Profile1 = 1,
+ Profile2 = 2,
+}
+
+impl TryFrom for Profile {
+ type Error = String;
+
+ fn try_from(value: u32) -> Result {
+ match value {
+ 0 => Ok(Profile::Profile0),
+ 1 => Ok(Profile::Profile1),
+ 2 => Ok(Profile::Profile2),
+ _ => Err(format!("Invalid Profile {}", value)),
+ }
+ }
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct ObuHeader {
+ pub obu_type: ObuType,
+ pub extension_flag: bool,
+ pub has_size_field: bool,
+ pub temporal_id: u32,
+ pub spatial_id: u32,
+}
+
+impl ObuHeader {
+ /// Length in bytes
+ #[allow(clippy::len_without_is_empty)]
+ pub fn len(&self) -> usize {
+ if self.extension_flag {
+ 2
+ } else {
+ 1
+ }
+ }
+}
+
+/// Contains the OBU header and a reference to its data. The OBU itself hasn't been parsed yet.
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct Obu<'a> {
+ /// The OBU header.
+ pub header: ObuHeader,
+ /// Amount of bytes from the input consumed to parse this OBU.
+ pub bytes_used: usize,
+ /// The slice backing the OBU.
+ data: Cow<'a, [u8]>,
+}
+
+impl<'a> AsRef<[u8]> for Obu<'a> {
+ fn as_ref(&self) -> &[u8] {
+ self.data.as_ref()
+ }
+}
+
+/// A fully parsed OBU, with additional data when relevant.
+pub enum ParsedObu<'a> {
+ Reserved,
+ SequenceHeader(Rc),
+ TemporalDelimiter,
+ FrameHeader(FrameHeaderObu),
+ TileGroup(TileGroupObu<'a>),
+ Metadata,
+ Frame(FrameObu<'a>),
+ RedundantFrameHeader,
+ TileList,
+ Reserved2,
+ Reserved3,
+ Reserved4,
+ Reserved5,
+ Reserved6,
+ Reserved7,
+ Padding,
+}
+
+impl<'a> ParsedObu<'a> {
+ pub fn obu_type(&self) -> ObuType {
+ match self {
+ ParsedObu::Reserved => ObuType::Reserved,
+ ParsedObu::SequenceHeader(_) => ObuType::SequenceHeader,
+ ParsedObu::TemporalDelimiter => ObuType::TemporalDelimiter,
+ ParsedObu::FrameHeader(_) => ObuType::FrameHeader,
+ ParsedObu::TileGroup(_) => ObuType::TileGroup,
+ ParsedObu::Metadata => ObuType::Metadata,
+ ParsedObu::Frame(_) => ObuType::Frame,
+ ParsedObu::RedundantFrameHeader => ObuType::RedundantFrameHeader,
+ ParsedObu::TileList => ObuType::TileList,
+ ParsedObu::Reserved2 => ObuType::Reserved2,
+ ParsedObu::Reserved3 => ObuType::Reserved3,
+ ParsedObu::Reserved4 => ObuType::Reserved4,
+ ParsedObu::Reserved5 => ObuType::Reserved5,
+ ParsedObu::Reserved6 => ObuType::Reserved6,
+ ParsedObu::Reserved7 => ObuType::Reserved7,
+ ParsedObu::Padding => ObuType::Padding,
+ }
+ }
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct Tile {
+ /// Same as TileOffset in the specification.
+ pub tile_offset: u32,
+ /// Same as TileSize in the specification.
+ pub tile_size: u32,
+ /// Same as TileRow in the specification.
+ pub tile_row: u32,
+ /// Same as TileCol in the specification.
+ pub tile_col: u32,
+ // Same as MiRowStart in the specification.
+ pub mi_row_start: u32,
+ // Same as MiRowEnd in the specification.
+ pub mi_row_end: u32,
+ // Same as MiColStart in the specification.
+ pub mi_col_start: u32,
+ // Same as MiColEnd in the specification.
+ pub mi_col_end: u32,
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct TileGroupObu<'a> {
+ /// The OBU backing this tile group.
+ pub obu: Obu<'a>,
+ /// Specifies whether tg_start and tg_end are present. If tg_start and
+ /// tg_end are not present, this tile group covers the entire frame.
+ pub tile_start_and_end_present_flag: bool,
+ /// Specifies the zero-based index of the first tile in the current tile
+ /// group.
+ pub tg_start: u32,
+ /// Specifies the zero-based index of the last tile in the current tile
+ /// group.
+ pub tg_end: u32,
+ /// Contains the tiles in this tile group. Use `tile_offset`to index into
+ /// the OBU data.
+ ///
+ /// The tiles in the Vec span from tg_start to tg_end.
+ pub tiles: Vec,
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct OperatingPoint {
+ /// Specifies the level that the coded video sequence conforms to when
+ /// operating point i is selected.
+ pub seq_level_idx: u8,
+ /// Specifies the tier that the coded video sequence conforms to when
+ /// operating point i is selected.
+ pub seq_tier: u8,
+ /// Specifies the value of operating_point_idc for the selected operating
+ /// point.
+ pub idc: u16,
+ /// If set, indicates that there is a decoder model associated with
+ /// operating point i. If not set, indicates that there is not a decoder
+ /// model associated with operating point i.
+ pub decoder_model_present_for_this_op: bool,
+ /// Specifies the time interval between the arrival of the first bit in the
+ /// smoothing buffer and the subsequent removal of the data that belongs to
+ /// the first coded frame for operating point op, measured in units of
+ /// 1/90000 seconds. The length of decoder_buffer_delay is specified by
+ /// buffer_delay_length_minus_1 + 1, in bits.
+ pub decoder_buffer_delay: u32,
+ /// Specifies, in combination with decoder_buffer_delay\[ op \] syntax
+ /// element, the first bit arrival time of frames to be decoded to the
+ /// smoothing buffer. encoder_buffer_delay is measured in units of 1/90000
+ /// seconds.
+ pub encoder_buffer_delay: u32,
+ /// If set, indicates that the smoothing buffer operates in low-delay mode
+ /// for operating point op. In low-delay mode late decode times and buffer
+ /// underflow are both permitted. If not set, indicates that the smoothing
+ /// buffer operates in strict mode, where buffer underflow is not allowed.
+ pub low_delay_mode_flag: bool,
+ /// If set, indicates that initial_display_delay_minus_1 is specified for
+ /// operating point i. If not set, indicates that
+ /// initial_display_delay_minus_1 is not specified for operating point i.
+ pub initial_display_delay_present_for_this_op: bool,
+ /// Plus 1 specifies, for operating point i, the number of decoded frames
+ /// that should be present in the buffer pool before the first presentable
+ /// frame is displayed. This will ensure that all presentable frames in the
+ /// sequence can be decoded at or before the time that they are scheduled
+ /// for display. If not signaled then initial_display_delay_minus_1\[ i \] =
+ /// BUFFER_POOL_MAX_SIZE - 1.
+ pub initial_display_delay_minus_1: u32,
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct TimingInfo {
+ /// The number of time units of a clock operating at the frequency
+ /// time_scale Hz that corresponds to one increment of a clock tick counter.
+ /// A display clock tick, in seconds, is equal to num_units_in_display_tick
+ /// divided by time_scale:
+ pub num_units_in_display_tick: u32,
+ /// The number of time units that pass in one second.
+ pub time_scale: u32,
+ /// If set, indicates that pictures should be displayed according to their
+ /// output order with the number of ticks between two consecutive pictures
+ /// (without dropping frames) specified by num_ticks_per_picture_minus_1 +
+ /// 1. If not set, indicates that the interval between two consecutive
+ /// pictures is not specified.
+ pub equal_picture_interval: bool,
+ /// Plus 1 specifies the number of clock ticks corresponding to output time
+ /// between two consecutive pictures in the output order.
+ pub num_ticks_per_picture_minus_1: u32,
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct DecoderModelInfo {
+ /// Plus 1 specifies the length of the decoder_buffer_delay and the
+ /// encoder_buffer_delay syntax elements, in bits.
+ pub buffer_delay_length_minus_1: u8,
+ /// The number of time units of a decoding clock operating at the frequency
+ /// time_scale Hz that corresponds to one increment of a clock tick counter:
+ pub num_units_in_decoding_tick: u32,
+ /// Plus 1 specifies the length of the buffer_removal_time syntax element,
+ /// in bits.
+ pub buffer_removal_time_length_minus_1: u8,
+ /// Plus 1 specifies the length of the frame_presentation_time syntax
+ /// element, in bits.
+ pub frame_presentation_time_length_minus_1: u32,
+}
+
+/// Defined by the “Color primaries” section of ISO/IEC 23091-4/ITU-T H.273
+/// See 6.4.2
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord)]
+pub enum ColorPrimaries {
+ Bt709 = 1,
+ #[default]
+ Unspecified = 2,
+ Bt470M = 4,
+ Bt470bg = 5,
+ Bt601 = 6,
+ Smpte240 = 7,
+ GenericFilm = 8,
+ Bt2020 = 9,
+ Xyz = 10,
+ Smpte431 = 11,
+ Smpte432 = 12,
+ Ebu3213 = 22,
+}
+
+impl TryFrom for ColorPrimaries {
+ type Error = String;
+
+ fn try_from(value: u32) -> Result {
+ match value {
+ 1 => Ok(ColorPrimaries::Bt709),
+ 2 => Ok(ColorPrimaries::Unspecified),
+ 4 => Ok(ColorPrimaries::Bt470M),
+ 5 => Ok(ColorPrimaries::Bt470bg),
+ 6 => Ok(ColorPrimaries::Bt601),
+ 7 => Ok(ColorPrimaries::Smpte240),
+ 8 => Ok(ColorPrimaries::GenericFilm),
+ 9 => Ok(ColorPrimaries::Bt2020),
+ 10 => Ok(ColorPrimaries::Xyz),
+ 11 => Ok(ColorPrimaries::Smpte431),
+ 12 => Ok(ColorPrimaries::Smpte432),
+ 22 => Ok(ColorPrimaries::Ebu3213),
+ _ => Err(format!("Invalid ColorPrimaries {}", value)),
+ }
+ }
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord)]
+pub enum TransferCharacteristics {
+ Reserved0 = 0,
+ Bt709 = 1,
+ #[default]
+ Unspecified = 2,
+ Reserved3 = 3,
+ Bt470m = 4,
+ Bt470bg = 5,
+ Bt601 = 6,
+ Smpte240 = 7,
+ Linear = 8,
+ Log100 = 9,
+ Log100Sqrt10 = 10,
+ Iec61966 = 11,
+ Bt1361 = 12,
+ Srgb = 13,
+ Bt202010Bit = 14,
+ Bt202012Bit = 15,
+ Smpte2084 = 16,
+ Smpte428 = 17,
+ Hlg = 18,
+}
+
+impl TryFrom for TransferCharacteristics {
+ type Error = String;
+
+ fn try_from(value: u32) -> Result {
+ match value {
+ 0 => Ok(TransferCharacteristics::Reserved0),
+ 1 => Ok(TransferCharacteristics::Bt709),
+ 2 => Ok(TransferCharacteristics::Unspecified),
+ 3 => Ok(TransferCharacteristics::Reserved3),
+ 4 => Ok(TransferCharacteristics::Bt470m),
+ 5 => Ok(TransferCharacteristics::Bt470bg),
+ 6 => Ok(TransferCharacteristics::Bt601),
+ 7 => Ok(TransferCharacteristics::Smpte240),
+ 8 => Ok(TransferCharacteristics::Linear),
+ 9 => Ok(TransferCharacteristics::Log100),
+ 10 => Ok(TransferCharacteristics::Log100Sqrt10),
+ 11 => Ok(TransferCharacteristics::Iec61966),
+ 12 => Ok(TransferCharacteristics::Bt1361),
+ 13 => Ok(TransferCharacteristics::Srgb),
+ 14 => Ok(TransferCharacteristics::Bt202010Bit),
+ 15 => Ok(TransferCharacteristics::Bt202012Bit),
+ 16 => Ok(TransferCharacteristics::Smpte2084),
+ 17 => Ok(TransferCharacteristics::Smpte428),
+ 18 => Ok(TransferCharacteristics::Hlg),
+ _ => Err(format!("Invalid TransferCharacteristics {}", value)),
+ }
+ }
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord)]
+pub enum BitDepth {
+ #[default]
+ Depth8 = 0,
+ Depth10 = 1,
+ Depth12 = 2,
+}
+
+impl TryFrom for BitDepth {
+ type Error = String;
+
+ fn try_from(value: u32) -> Result {
+ match value {
+ 0 => Ok(BitDepth::Depth8),
+ 1 => Ok(BitDepth::Depth10),
+ 2 => Ok(BitDepth::Depth12),
+ _ => Err(format!("Invalid BitDepth {}", value)),
+ }
+ }
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord)]
+pub enum MatrixCoefficients {
+ Identity = 0,
+ Bt709 = 1,
+ #[default]
+ Unspecified = 2,
+ Reserved3 = 3,
+ Fcc = 4,
+ Bt470bg = 5,
+ Bt601 = 6,
+ Smpte240 = 7,
+ Ycgco = 8,
+ Bt2020Ncl = 9,
+ Bt2020Cl = 10,
+ Smpte2085 = 11,
+ ChromaDerivedNcl = 12,
+ ChromaDerivedCl = 13,
+ Ictcp = 14,
+}
+
+impl TryFrom for MatrixCoefficients {
+ type Error = String;
+
+ fn try_from(value: u32) -> Result {
+ match value {
+ 0 => Ok(MatrixCoefficients::Identity),
+ 1 => Ok(MatrixCoefficients::Bt709),
+ 2 => Ok(MatrixCoefficients::Unspecified),
+ 3 => Ok(MatrixCoefficients::Reserved3),
+ 4 => Ok(MatrixCoefficients::Fcc),
+ 5 => Ok(MatrixCoefficients::Bt470bg),
+ 6 => Ok(MatrixCoefficients::Bt601),
+ 7 => Ok(MatrixCoefficients::Smpte240),
+ 8 => Ok(MatrixCoefficients::Ycgco),
+ 9 => Ok(MatrixCoefficients::Bt2020Ncl),
+ 10 => Ok(MatrixCoefficients::Bt2020Cl),
+ 11 => Ok(MatrixCoefficients::Smpte2085),
+ 12 => Ok(MatrixCoefficients::ChromaDerivedNcl),
+ 13 => Ok(MatrixCoefficients::ChromaDerivedCl),
+ 14 => Ok(MatrixCoefficients::Ictcp),
+ _ => Err(format!("Invalid MatrixCoefficients {}", value)),
+ }
+ }
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord)]
+pub enum ChromaSamplePosition {
+ #[default]
+ Unknown = 0,
+ Vertical = 1,
+ Colocated = 2,
+ Reserved = 3,
+}
+
+impl TryFrom for ChromaSamplePosition {
+ type Error = String;
+
+ fn try_from(value: u32) -> Result {
+ match value {
+ 0 => Ok(ChromaSamplePosition::Unknown),
+ 1 => Ok(ChromaSamplePosition::Vertical),
+ 2 => Ok(ChromaSamplePosition::Colocated),
+ 3 => Ok(ChromaSamplePosition::Reserved),
+ _ => Err(format!("Invalid ChromaSamplePosition {}", value)),
+ }
+ }
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct ColorConfig {
+ /// Syntax elements which, together with seq_profile, determine the bit
+ /// depth.
+ pub high_bitdepth: bool,
+ /// Syntax elements which, together with seq_profile, determine the bit
+ /// depth.
+ pub twelve_bit: bool,
+ /// If set, indicates that the video does not contain U and V color planes.
+ /// If not set, indicates that the video contains Y, U, and V color planes.
+ pub mono_chrome: bool,
+ /// If set, specifies that color_primaries, transfer_characteristics, and
+ /// matrix_coefficients are present. If not set, specifies that
+ /// color_primaries, transfer_characteristics and matrix_coefficients are
+ /// not present.
+ pub color_description_present_flag: bool,
+ /// Defined by the “Color primaries” section of ISO/IEC 23091-4/ITU-T H.273.
+ pub color_primaries: ColorPrimaries,
+ /// Defined by the “Transfer characteristics” section of ISO/IEC
+ /// 23091-4/ITU-T H.273.
+ pub transfer_characteristics: TransferCharacteristics,
+ /// Defined by the “Matrix coefficients” section of ISO/IEC 23091-4/ITU-T
+ /// H.273.
+ pub matrix_coefficients: MatrixCoefficients,
+ /// Binary value that is associated with the VideoFullRangeFlag variable
+ /// specified in ISO/IEC 23091-4/ITU- T H.273. color range equal to 0 shall
+ /// be referred to as the studio swing representation and color range equal
+ /// to 1 shall be referred to as the full swing representation for all
+ /// intents relating to this specification.
+ pub color_range: bool,
+ /// Specify the chroma subsampling format
+ pub subsampling_x: bool,
+ /// Specify the chroma subsampling format
+ pub subsampling_y: bool,
+ /// Specifies the sample position for subsampled streams
+ pub chroma_sample_position: ChromaSamplePosition,
+ /// If set, indicates that the U and V planes may have separate delta
+ /// quantizer values. If not set, indicates that the U and V planes will
+ /// share the same delta quantizer value.
+ pub separate_uv_delta_q: bool,
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct SequenceHeaderObu {
+ /// The OBU header from the OBU that generated this sequence.
+ pub obu_header: ObuHeader,
+ /// Specifies the features that can be used in the coded video sequence.
+ pub seq_profile: Profile,
+ /// If set, specifies that the coded video sequence contains only one coded
+ /// frame. If not set, specifies that the coded video sequence contains one
+ /// or more coded frames.
+ pub still_picture: bool,
+ /// Specifies that the syntax elements not needed by a still picture are
+ /// omitted.
+ pub reduced_still_picture_header: bool,
+ /// Specifies the number of bits minus 1 used for transmitting the frame
+ /// width syntax elements.
+ pub frame_width_bits_minus_1: u8,
+ /// Specifies the number of bits minus 1 used for transmitting the frame
+ /// height syntax elements.
+ pub frame_height_bits_minus_1: u8,
+ /// Specifies the maximum frame width minus 1 for the frames represented by
+ /// this sequence header.
+ pub max_frame_width_minus_1: u16,
+ /// Specifies the maximum frame height minus 1 for the frames represented by
+ /// this sequence header.
+ pub max_frame_height_minus_1: u16,
+ /// Specifies whether frame id numbers are present in the coded video
+ /// sequence.
+ pub frame_id_numbers_present_flag: bool,
+ /// Specifies the number of bits minus 2 used to encode delta_frame_id
+ /// syntax elements.
+ pub delta_frame_id_length_minus_2: u32,
+ /// Used to calculate the number of bits used to encode the frame_id syntax
+ /// element.
+ pub additional_frame_id_length_minus_1: u32,
+ /// When set, indicates that superblocks contain 128x128 luma samples. When
+ /// not set, it indicates that superblocks contain 64x64 luma samples. (The
+ /// number of contained chroma samples depends on subsampling_x and
+ /// subsampling_y.)
+ pub use_128x128_superblock: bool,
+ /// When set, specifies that the use_filter_intra syntax element may be
+ /// present. When not set, specifies that the use_filter_intra syntax
+ /// element will not be present.
+ pub enable_filter_intra: bool,
+ /// Specifies whether the intra edge filtering process should be enabled.
+ pub enable_intra_edge_filter: bool,
+ /// When set, specifies that the mode info for inter blocks may contain the
+ /// syntax element interintra. If not set, specifies that the syntax element
+ /// interintra will not be present.
+ pub enable_interintra_compound: bool,
+ /// When set, specifies that the mode info for inter blocks may contain the
+ /// syntax element compound_type. When not set, specifies that the syntax
+ /// element compound_type will not be present.
+ pub enable_masked_compound: bool,
+ /// When set, indicates that the allow_warped_motion syntax element may be
+ /// present. When not set, indicates that the allow_warped_motion syntax
+ /// element will not be present.
+ pub enable_warped_motion: bool,
+ /// When set, indicates that tools based on the values of order hints may be
+ /// used. When not set, indicates that tools based on order hints are
+ /// disabled.
+ pub enable_order_hint: bool,
+ /// When set, indicates that the inter prediction filter type may be
+ /// specified independently in the horizontal and vertical directions. If
+ /// the flag is not set, only one filter type may be specified, which is
+ /// then used in both directions.
+ pub enable_dual_filter: bool,
+ /// If set, indicates that the distance weights process may be used for
+ /// inter prediction.
+ pub enable_jnt_comp: bool,
+ /// If set, indicates that the use_ref_frame_mvs syntax element may be
+ /// present. If not set, indicates that the use_ref_frame_mvs syntax element
+ /// will not be present.
+ pub enable_ref_frame_mvs: bool,
+ /// If not set, indicates that the seq_force_screen_content_tools syntax
+ /// element will be present. If set, indicates that
+ /// seq_force_screen_content_tools should be set equal to
+ /// SELECT_SCREEN_CONTENT_TOOLS.
+ pub seq_choose_screen_content_tools: bool,
+ /// Equal to SELECT_SCREEN_CONTENT_TOOLS indicates that the
+ /// allow_screen_content_tools syntax element will be present in the frame
+ /// header. Otherwise, seq_force_screen_content_tools contains the value for
+ /// allow_screen_content_tools.
+ pub seq_force_screen_content_tools: u32,
+ /// If not set, indicates that the seq_force_integer_mv syntax element will
+ /// be present. If set, indicates that seq_force_integer_mv should be set
+ /// equal to SELECT_INTEGER_MV.
+ pub seq_choose_integer_mv: bool,
+ /// Equal to SELECT_INTEGER_MV indicates that the force_integer_mv syntax
+ /// element will be present in the frame header (providing
+ /// allow_screen_content_tools is equal to 1). Otherwise,
+ /// seq_force_integer_mv contains the value for force_integer_mv.
+ pub seq_force_integer_mv: u32,
+ /// Used to compute OrderHintBits.
+ pub order_hint_bits_minus_1: i32,
+ /// Specifies the number of bits used for the order_hint syntax element.
+ pub order_hint_bits: i32,
+ /// If set, specifies that the use_superres syntax element will be present
+ /// in the uncompressed header. If not set, specifies that the use_superres
+ /// syntax element will not be present (instead use_superres will be set to
+ /// 0 in the uncompressed header without being read).
+ pub enable_superres: bool,
+ /// If set, specifies that cdef filtering may be enabled. If not set,
+ /// specifies that cdef filtering is disabled.
+ pub enable_cdef: bool,
+ /// If set, specifies that loop restoration filtering may be enabled. If
+ /// not set, specifies that loop restoration filtering is disabled.
+ pub enable_restoration: bool,
+ /// Specifies whether film grain parameters are present in the coded video
+ /// sequence.
+ pub film_grain_params_present: bool,
+ /// Indicates the number of operating points minus 1 present in the coded
+ /// video sequence. An operating point specifies which spatial and temporal
+ /// layers should be decoded.
+ pub operating_points_cnt_minus_1: u32,
+ /// The set of operating points.
+ pub operating_points: [OperatingPoint; MAX_NUM_OPERATING_POINTS],
+ /// Specifies whether decoder model information is present in the coded
+ /// video sequence.
+ pub decoder_model_info_present_flag: bool,
+ /// The decoder model info.
+ pub decoder_model_info: DecoderModelInfo,
+ /// Specifies whether initial display delay information is present in the
+ /// coded video sequence.
+ pub initial_display_delay_present_flag: bool,
+ /// Specifies whether timing info is present in the coded video sequence.
+ pub timing_info_present_flag: bool,
+ /// The timing info.
+ pub timing_info: TimingInfo,
+ /// The color config.
+ pub color_config: ColorConfig,
+
+ /* CamelCase variables in the specification */
+ pub bit_depth: BitDepth,
+ pub num_planes: u32,
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct StreamInfo {
+ pub seq_header: Rc,
+ pub render_width: u32,
+ pub render_height: u32,
+}
+
+/// A TemporalDelimiterOBU
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct TemporalDelimiterObu {
+ pub obu_header: ObuHeader,
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord)]
+pub enum InterpolationFilter {
+ #[default]
+ EightTap = 0,
+ EightTapSmooth = 1,
+ EightTapSharp = 2,
+ Bilinear = 3,
+ Switchable = 4,
+}
+
+impl TryFrom for InterpolationFilter {
+ type Error = String;
+
+ fn try_from(value: u32) -> Result {
+ match value {
+ 0 => Ok(InterpolationFilter::EightTap),
+ 1 => Ok(InterpolationFilter::EightTapSmooth),
+ 2 => Ok(InterpolationFilter::EightTapSharp),
+ 3 => Ok(InterpolationFilter::Bilinear),
+ 4 => Ok(InterpolationFilter::Switchable),
+ _ => Err(format!("Invalid InterpolationFilter {}", value)),
+ }
+ }
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord)]
+pub enum TxModes {
+ #[default]
+ Only4x4 = 0,
+ Largest = 1,
+ Select = 2,
+}
+
+impl TryFrom for TxModes {
+ type Error = String;
+
+ fn try_from(value: u32) -> Result {
+ match value {
+ 0 => Ok(TxModes::Only4x4),
+ 1 => Ok(TxModes::Largest),
+ 2 => Ok(TxModes::Select),
+ _ => Err(format!("Invalid TxModes {}", value)),
+ }
+ }
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord)]
+pub enum FrameRestorationType {
+ #[default]
+ None = 0,
+ Wiener = 1,
+ Sgrproj = 2,
+ Switchable = 3,
+}
+
+impl TryFrom for FrameRestorationType {
+ type Error = String;
+
+ fn try_from(value: u32) -> Result {
+ match value {
+ 0 => Ok(FrameRestorationType::None),
+ 1 => Ok(FrameRestorationType::Wiener),
+ 2 => Ok(FrameRestorationType::Sgrproj),
+ 3 => Ok(FrameRestorationType::Switchable),
+ _ => Err(format!("Invalid FrameRestorationType {}", value)),
+ }
+ }
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord)]
+pub enum ReferenceFrameType {
+ #[default]
+ Intra = 0,
+ Last = 1,
+ Last2 = 2,
+ Last3 = 3,
+ Golden = 4,
+ BwdRef = 5,
+ AltRef2 = 6,
+ AltRef = 7,
+}
+
+impl TryFrom for ReferenceFrameType {
+ type Error = String;
+
+ fn try_from(value: u32) -> Result {
+ match value {
+ 0 => Ok(ReferenceFrameType::Intra),
+ 1 => Ok(ReferenceFrameType::Last),
+ 2 => Ok(ReferenceFrameType::Last2),
+ 3 => Ok(ReferenceFrameType::Last3),
+ 4 => Ok(ReferenceFrameType::Golden),
+ 5 => Ok(ReferenceFrameType::BwdRef),
+ 6 => Ok(ReferenceFrameType::AltRef2),
+ 7 => Ok(ReferenceFrameType::AltRef),
+ _ => Err(format!("Invalid ReferenceFrameType {}", value)),
+ }
+ }
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord)]
+pub enum WarpModelType {
+ #[default]
+ Identity = 0,
+ Translation = 1,
+ RotZoom = 2,
+ Affine = 3,
+}
+
+impl TryFrom for WarpModelType {
+ type Error = String;
+
+ fn try_from(value: u32) -> Result {
+ match value {
+ 0 => Ok(WarpModelType::Identity),
+ 1 => Ok(WarpModelType::Translation),
+ 2 => Ok(WarpModelType::RotZoom),
+ 3 => Ok(WarpModelType::Affine),
+ _ => Err(format!("Invalid WarpModelType {}", value)),
+ }
+ }
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord)]
+pub enum FrameType {
+ #[default]
+ KeyFrame = 0,
+ InterFrame = 1,
+ IntraOnlyFrame = 2,
+ SwitchFrame = 3,
+}
+
+impl TryFrom for FrameType {
+ type Error = String;
+
+ fn try_from(value: u32) -> Result {
+ match value {
+ 0 => Ok(FrameType::KeyFrame),
+ 1 => Ok(FrameType::InterFrame),
+ 2 => Ok(FrameType::IntraOnlyFrame),
+ 3 => Ok(FrameType::SwitchFrame),
+ _ => Err(format!("Invalid FrameType {}", value)),
+ }
+ }
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord)]
+pub enum TxMode {
+ #[default]
+ Only4x4 = 0,
+ Largest = 1,
+ Select = 2,
+}
+
+impl TryFrom for TxMode {
+ type Error = String;
+
+ fn try_from(value: u32) -> Result {
+ match value {
+ 0 => Ok(TxMode::Only4x4),
+ 1 => Ok(TxMode::Largest),
+ 2 => Ok(TxMode::Select),
+ _ => Err(format!("Invalid TxMode {}", value)),
+ }
+ }
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct FrameObu<'a> {
+ pub header: FrameHeaderObu,
+ pub tile_group: TileGroupObu<'a>,
+}
+
+/// A FrameHeaderOBU
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct FrameHeaderObu {
+ /// The original OBU header. This may be from a FrameOBU or a FrameHeaderOBU
+ /// directly.
+ pub obu_header: ObuHeader,
+ /// If set, indicates the frame indexed by frame_to_show_map_idx is to be
+ /// output; If not set, indicates that further processing is required.
+ pub show_existing_frame: bool,
+ /// Specifies the frame to be output. It is only available if
+ /// show_existing_frame is set.
+ pub frame_to_show_map_idx: u8,
+ /// Specifies the length of the frame_presentation_time syntax element, in
+ /// bits.
+ pub frame_presentation_time: u32,
+ /// Provides the frame id number for the frame to output.
+ pub display_frame_id: u32,
+ /// Specifies the type of the frame
+ pub frame_type: FrameType,
+ /// If set, specifies that this frame should be immediately output once
+ /// decoded. If not set specifies that this frame should not be
+ /// immediately output. (It may be output later if a later uncompressed
+ /// header uses show_existing_frame is set).
+ pub show_frame: bool,
+ /// When set, specifies that the frame may be output using the
+ /// show_existing_frame mechanism. When not set, specifies that this frame
+ /// will not be output using the show_existing_frame mechanism.
+ pub showable_frame: bool,
+ /// If set, indicates that error resilient mode is enabled;
+ /// error_resilient_mode equal to 0 indicates that error resilient mode is
+ /// disabled.
+ pub error_resilient_mode: bool,
+ /// Specifies whether the CDF update in the symbol decoding process should
+ /// be disabled.
+ pub disable_cdf_update: bool,
+ /// When set, indicates that intra blocks may use palette encoding; When not
+ /// set, indicates that palette encoding is never used.
+ pub allow_screen_content_tools: u32,
+ /// If set, specifies that motion vectors will always be integers. If not
+ /// set, specifies that motion vectors can contain fractional bits.
+ pub force_integer_mv: u32,
+ /// Specifies the frame id number for the current frame. Frame id numbers
+ /// are additional information that do not affect the decoding process, but
+ /// provide decoders with a way of detecting missing reference frames so
+ /// that appropriate action can be taken.
+ pub current_frame_id: u32,
+ /// If not set, specifies that the frame size is equal to the size in the
+ /// sequence header. If set, specifies that the frame size will either be
+ /// specified as the size of one of the reference frames, or computed from
+ /// the frame_width_minus_1 and frame_height_minus_1 syntax elements.
+ pub frame_size_override_flag: bool,
+ /// Specifies OrderHintBits least significant bits of the expected output
+ /// order for this frame.
+ pub order_hint: u32,
+ /// Specifies which reference frame contains the CDF values and other state
+ /// that should be loaded at the start of the frame.
+ pub primary_ref_frame: u32,
+ /// If set, specifies that buffer_removal_time is present. If not set,
+ /// specifies that buffer_removal_time is not present.
+ pub buffer_removal_time_present_flag: bool,
+ /// Specifies the frame removal time in units of DecCT clock ticks counted
+ /// from the removal time of the last random access point for operating
+ /// point opNum. buffer_removal_time is signaled as a fixed length unsigned
+ /// integer with a length in bits given by
+ /// buffer_removal_time_length_minus_1 + 1.
+ pub buffer_removal_time: Vec,
+ /// Contains a bitmask that specifies which reference frame slots will be
+ /// updated with the current frame after it is decoded.
+ pub refresh_frame_flags: u32,
+ /// Specifies the expected output order hint for each reference frame.
+ pub ref_order_hint: [u32; NUM_REF_FRAMES],
+ /// If set, indicates that intra block copy may be used in this frame. If
+ /// not set indicates that intra block copy is not allowed in this frame.
+ pub allow_intrabc: bool,
+ /// If set, indicates that only two reference frames are explicitly
+ /// signaled. If not set, indicates that all reference frames are explicitly
+ /// signaled.
+ pub frame_refs_short_signaling: bool,
+ /// Specifies the reference frame to use for LAST_FRAME.
+ pub last_frame_idx: u8,
+ /// Specifies the reference frame to use for GOLDEN_FRAME.
+ pub gold_frame_idx: u8,
+ /// Specifies which reference frames are used by inter frames
+ pub ref_frame_idx: [u8; REFS_PER_FRAME],
+ /// If not set, specifies that motion vectors are specified to quarter pel
+ /// precision; If set, specifies that motion vectors are specified to eighth
+ /// pel precision.
+ pub allow_high_precision_mv: bool,
+ /// If not set, specifies that only the SIMPLE motion mode will be used.
+ pub is_motion_mode_switchable: bool,
+ /// If set, specifies that motion vector information from a previous frame
+ /// can be used when decoding the current frame. If not set, specifies that
+ /// this information will not be used.
+ pub use_ref_frame_mvs: bool,
+ /// If set, indicates that the end of frame CDF update is disabled; If not
+ /// set, indicates that the end of frame CDF update is enabled.
+ pub disable_frame_end_update_cdf: bool,
+ /// If set, indicates that the syntax element motion_mode may be present.
+ /// If not set, indicates that the syntax element motion_mode will not be
+ /// present
+ pub allow_warped_motion: bool,
+ /// If set, specifies that the frame is restricted to a reduced subset of
+ /// the full set of transform types.
+ pub reduced_tx_set: bool,
+ /// If not set, means that the render width and height are inferred from the
+ /// frame width and height. If set, means that the render width and height
+ /// are explicitly coded.
+ pub render_and_frame_size_different: bool,
+ /// If not set, indicates that no upscaling is needed. If set, indicates
+ /// that upscaling is needed.
+ pub use_superres: bool,
+ /// If set indicates that the filter selection is signaled at the block
+ /// level; If not set, indicates that the filter selection is signaled at
+ /// the frame level.
+ pub is_filter_switchable: bool,
+ /// The interpolation filter parameters.
+ pub interpolation_filter: InterpolationFilter,
+ /// The loop filter parameters.
+ pub loop_filter_params: LoopFilterParams,
+ /// The quantization parameters.
+ pub quantization_params: QuantizationParams,
+ /// The segmentation parameters.
+ pub segmentation_params: SegmentationParams,
+ /// The tile info.
+ pub tile_info: TileInfo,
+ /// The CDEF parameters.
+ pub cdef_params: CdefParams,
+ /// The loop restoration parameters.
+ pub loop_restoration_params: LoopRestorationParams,
+ /// Used to compute TxMode.
+ pub tx_mode_select: u32,
+ /// If set specifies that the syntax element skip_mode will be present. If
+ /// not set, specifies that skip_mode will not be used for this frame.
+ pub skip_mode_present: bool,
+ /// If set, specifies that the mode info for inter blocks contains the
+ /// syntax element comp_mode that indicates whether to use single or
+ /// compound reference prediction. If not set, specifies that all inter
+ /// blocks will use single prediction.
+ pub reference_select: bool,
+ /// The global motion parameters.
+ pub global_motion_params: GlobalMotionParams,
+ /// The film grain parameters.
+ pub film_grain_params: FilmGrainParams,
+
+ /* CamelCase variables */
+ pub superres_denom: u32,
+ pub frame_is_intra: bool,
+ pub order_hints: [u32; NUM_REF_FRAMES],
+ pub ref_frame_sign_bias: [bool; NUM_REF_FRAMES],
+ pub coded_lossless: bool,
+ pub all_lossless: bool,
+ pub lossless_array: [bool; MAX_SEGMENTS],
+ pub seg_qm_level: [[u32; MAX_SEGMENTS]; 3],
+ pub upscaled_width: u32,
+ pub frame_width: u32,
+ pub frame_height: u32,
+ pub render_width: u32,
+ pub render_height: u32,
+ pub tx_mode: TxMode,
+ pub skip_mode_frame: [u32; 2],
+ pub mi_cols: u32,
+ pub mi_rows: u32,
+ pub header_bytes: usize,
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct LoopFilterParams {
+ /// An array containing loop filter strength values. Different loop filter
+ /// strength values from the array are used depending on the image plane
+ /// being filtered, and the edge direction (vertical or horizontal) being
+ /// filtered.
+ pub loop_filter_level: [u8; 4],
+ /// Indicates the sharpness level. The loop_filter_level and
+ /// loop_filter_sharpness together determine when a block edge is filtered,
+ /// and by how much the filtering can change the sample values.
+ pub loop_filter_sharpness: u8,
+ /// If set, means that the filter level depends on the mode and reference
+ /// frame used to predict a block. If not set, means that the filter level
+ /// does not depend on the mode and reference frame.
+ pub loop_filter_delta_enabled: bool,
+ /// If set, means that additional syntax elements are present that specify
+ /// which mode and reference frame deltas are to be updated.
+ /// loop_filter_delta_update equal to 0 means that these syntax elements are
+ /// not present.
+ pub loop_filter_delta_update: bool,
+ /// Contains the adjustment needed for the filter level based on the chosen
+ /// reference frame. If this syntax element is not present, it maintains
+ /// its previous value.
+ pub loop_filter_ref_deltas: [i8; TOTAL_REFS_PER_FRAME],
+ /// Contains the adjustment needed for the filter level based on the chosen
+ /// mode. If this syntax element is not present in the, it maintains its
+ /// previous value.
+ pub loop_filter_mode_deltas: [i8; 2],
+ /// Specifies whether loop filter delta values are present.
+ pub delta_lf_present: bool,
+ /// Specifies the left shift which should be applied to decoded loop filter
+ /// delta values.
+ pub delta_lf_res: u8,
+ /// If set, specifies that separate loop filter deltas are sent for
+ /// horizontal luma edges, vertical luma edges, the U edges, and the V
+ /// edges. If not set, specifies that the same loop filter delta is used for
+ /// all edges.
+ pub delta_lf_multi: bool,
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct QuantizationParams {
+ /// Indicates the base frame qindex. This is used for Y AC coefficients and
+ /// as the base value for the other quantizers.
+ pub base_q_idx: u32,
+ /// Indicates the base frame qindex. This is used for Y AC coefficients and
+ /// as the base value for the other quantizers.
+ pub diff_uv_delta: bool,
+ /// Specifies that the quantizer matrix will be used to compute quantizers.
+ pub using_qmatrix: bool,
+ /// Specifies the level in the quantizer matrix that should be used for luma
+ /// plane decoding.
+ pub qm_y: u32,
+ /// Specifies the level in the quantizer matrix that should be used for
+ /// chroma U plane decoding.
+ pub qm_u: u32,
+ /// Specifies the level in the quantizer matrix that should be used for
+ /// chroma V plane decoding.
+ pub qm_v: u32,
+ /// Specifies whether quantizer index delta values are present.
+ pub delta_q_present: bool,
+ /// Specifies the left shift which should be applied to decoded quantizer
+ /// index delta values.
+ pub delta_q_res: u32,
+ /// Same as DeltaQYDc
+ pub delta_q_y_dc: i32,
+ /// Same as DeltaQUDc
+ pub delta_q_u_dc: i32,
+ /// Same as DeltaQUAc
+ pub delta_q_u_ac: i32,
+ /// Same as DeltaQVDc
+ pub delta_q_v_dc: i32,
+ /// Same as DeltaQVAc
+ pub delta_q_v_ac: i32,
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct SegmentationParams {
+ /// If set, indicates that this frame makes use of the segmentation tool; If
+ /// not set, indicates that the frame does not use segmentation.
+ pub segmentation_enabled: bool,
+ /// If set, indicates that the segmentation map are updated during the
+ /// decoding of this frame. If not set, means that the segmentation map from
+ /// the previous frame is used.
+ pub segmentation_update_map: bool,
+ /// If set, indicates that the updates to the segmentation map are coded
+ /// relative to the existing segmentation map. If not set, indicates that
+ /// the new segmentation map is coded without reference to the existing
+ /// segmentation map.
+ pub segmentation_temporal_update: bool,
+ /// If set, indicates that new parameters are about to be specified for each
+ /// segment. If not set, indicates that the segmentation parameters should
+ /// keep their existing values.
+ pub segmentation_update_data: bool,
+ /// If not set, indicates that the corresponding feature is unused and has
+ /// value equal to 0. If set, indicates that the feature value is coded.
+ pub feature_enabled: [[bool; SEG_LVL_MAX]; MAX_SEGMENTS],
+ /// Specifies the feature data for a segment feature.
+ pub feature_data: [[i16; SEG_LVL_MAX]; MAX_SEGMENTS],
+ /// Same as SegIdPreSkip
+ pub seg_id_pre_skip: bool,
+ /// Same as LastActiveSegId
+ pub last_active_seg_id: u8,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct TileInfo {
+ /// If set, means that the tiles are uniformly spaced across the frame. (In
+ /// other words, all tiles are the same size except for the ones at the
+ /// right and bottom edge which can be smaller.) If not set, means that the
+ /// tile sizes are coded.
+ pub uniform_tile_spacing_flag: bool,
+ /// Used to compute TileColsLog2.
+ pub increment_tile_rows_log2: u32,
+ /// Specifies the width of a tile minus 1 in units of superblocks.
+ pub width_in_sbs_minus_1: [u32; MAX_TILE_COLS],
+ /// Specifies the height of a tile minus 1 in units of superblocks.
+ pub height_in_sbs_minus_1: [u32; MAX_TILE_ROWS],
+ /// Specifies which tile to use for the CDF update
+ pub context_update_tile_id: u32,
+ /// An array specifying the start column (in units of 4x4 luma samples) for
+ /// each tile across the image.
+ pub mi_col_starts: [u32; MAX_TILE_COLS + 1],
+ /// An array specifying the start row (in units of 4x4 luma samples) for
+ /// each tile down the image.
+ pub mi_row_starts: [u32; MAX_TILE_ROWS + 1],
+ /// Specifies the base 2 logarithm of the desired number of tiles down the
+ /// frame.
+ pub tile_cols_log2: u32,
+ /// Specifies the number of tiles across the frame.
+ pub tile_cols: u32,
+ /// Specifies the base 2 logarithm of the desired number of tiles down the
+ /// frame.
+ pub tile_rows_log2: u32,
+ /// Secifies the number of tiles down the frame
+ pub tile_rows: u32,
+ /// Specifies the number of bytes needed to code each tile size.
+ pub tile_size_bytes: u32,
+}
+
+impl Default for TileInfo {
+ fn default() -> Self {
+ Self {
+ uniform_tile_spacing_flag: Default::default(),
+ increment_tile_rows_log2: Default::default(),
+ width_in_sbs_minus_1: [0; MAX_TILE_COLS],
+ height_in_sbs_minus_1: [0; MAX_TILE_ROWS],
+ context_update_tile_id: Default::default(),
+ mi_col_starts: [0; MAX_TILE_COLS + 1],
+ mi_row_starts: [0; MAX_TILE_ROWS + 1],
+ tile_cols_log2: Default::default(),
+ tile_cols: Default::default(),
+ tile_rows_log2: Default::default(),
+ tile_rows: Default::default(),
+ tile_size_bytes: Default::default(),
+ }
+ }
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct CdefParams {
+ /// Controls the amount of damping in the deringing filter.
+ pub cdef_damping: u32,
+ /// Specifies the number of bits needed to specify which CDEF filter to
+ /// apply.
+ pub cdef_bits: u32,
+ /// Specify the strength of the primary filter.
+ pub cdef_y_pri_strength: [u32; CDEF_MAX],
+ /// Specify the strength of the secondary filter.
+ pub cdef_y_sec_strength: [u32; CDEF_MAX],
+ /// Specify the strength of the primary filter.
+ pub cdef_uv_pri_strength: [u32; CDEF_MAX],
+ /// Specify the strength of the secondary filter.
+ pub cdef_uv_sec_strength: [u32; CDEF_MAX],
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct LoopRestorationParams {
+ /// Specifies if the luma restoration size should be halved.
+ pub lr_unit_shift: u8,
+ /// Only present for 4:2:0 formats and specifies if the chroma size should
+ /// be half the luma size.
+ pub lr_uv_shift: u8,
+ /// Same as FrameRestorationType in the specification.
+ pub frame_restoration_type: [FrameRestorationType; MAX_NUM_PLANES],
+ /// Same as LoopRestorationSize in the specification.
+ pub loop_restoration_size: [u16; MAX_NUM_PLANES],
+ /// Same as UsesLr in the specification.
+ pub uses_lr: bool,
+ /// Same as UsesChromaLr in the specification.
+ pub uses_chroma_lr: bool,
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct GlobalMotionParams {
+ /// Specifies whether global motion parameters are present for a particular
+ /// reference frame.
+ pub is_global: [bool; NUM_REF_FRAMES],
+ /// Specifies whether a particular reference frame uses rotation and zoom
+ /// global motion.
+ pub is_rot_zoom: [bool; NUM_REF_FRAMES],
+ /// Specifies whether a particular reference frame uses translation global
+ /// motion.
+ pub is_translation: [bool; NUM_REF_FRAMES],
+ /// gm_params\[ ref \]\[ j \] is set equal to SavedGmParams\[
+ /// frame_to_show_map_idx \]\[ ref \]\[ j \] for ref = LAST_FRAME..ALTREF_FRAME,
+ /// for j = 0..5.
+ pub gm_params: [[i32; 6]; NUM_REF_FRAMES],
+ /// Whether the parameters are valid (see warpValid and section 7.11.3.6)
+ pub warp_valid: [bool; NUM_REF_FRAMES],
+ /// Same as GmType.
+ pub gm_type: [WarpModelType; NUM_REF_FRAMES],
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct FilmGrainParams {
+ /// If set, specifies that film grain should be added to this frame. If not
+ /// set, specifies that film grain should not be added.
+ pub apply_grain: bool,
+ /// Specifies the starting value for the pseudo-random numbers used during
+ /// film grain synthesis.
+ pub grain_seed: u16,
+ /// If set means that a new set of parameters should be sent. If not set,
+ /// means that the previous set of parameters should be used.
+ pub update_grain: bool,
+ /// Indicates which reference frame contains the film grain parameters to be
+ /// used for this frame.
+ pub film_grain_params_ref_idx: u8,
+ /// Specifies the number of points for the piece-wise linear scaling
+ /// function of the luma component.
+ pub num_y_points: u8,
+ /// Represents the x (luma value) coordinate for the i-th point of the
+ /// piecewise linear scaling function for luma component. The values are
+ /// signaled on the scale of 0..255. (In case of 10 bit video, these values
+ /// correspond to luma values divided by 4. In case of 12 bit video, these
+ /// values correspond to luma values divided by 16.)
+ pub point_y_value: [u8; MAX_NUM_Y_POINTS],
+ /// Pepresents the scaling (output) value for the i-th point of the
+ /// piecewise linear scaling function for luma component.
+ pub point_y_scaling: [u8; MAX_NUM_Y_POINTS],
+ /// Specifies that the chroma scaling is inferred from the luma scaling.
+ pub chroma_scaling_from_luma: bool,
+ /// Specifies the number of points for the piece-wise linear scaling
+ /// function of the cb component.
+ pub num_cb_points: u8,
+ /// Represents the x coordinate for the i-th point of the piece-wise linear
+ /// scaling function for cb component. The values are signaled on the scale
+ /// of 0..255.
+ pub point_cb_value: [u8; MAX_NUM_CB_POINTS],
+ /// Represents the scaling (output) value for the i-th point of the
+ /// piecewise linear scaling function for cb component.
+ pub point_cb_scaling: [u8; MAX_NUM_CB_POINTS],
+ /// Specifies represents the number of points for the piece-wise linear
+ /// scaling function of the cr component.
+ pub num_cr_points: u8,
+ /// Represents the x coordinate for the i-th point of the piece-wise linear
+ /// scaling function for cr component. The values are signaled on the scale
+ /// of 0..255.
+ pub point_cr_value: [u8; MAX_NUM_CR_POINTS],
+ /// Represents the scaling (output) value for the i-th point of the
+ /// piecewise linear scaling function for cr component.
+ pub point_cr_scaling: [u8; MAX_NUM_CR_POINTS],
+ /// Represents the shift – 8 applied to the values of the chroma component.
+ /// The grain_scaling_minus_8 can take values of 0..3 and determines the
+ /// range and quantization step of the standard deviation of film grain.
+ pub grain_scaling_minus_8: u8,
+ /// Specifies the number of auto-regressive coefficients for luma and chroma.
+ pub ar_coeff_lag: u32,
+ /// Specifies auto-regressive coefficients used for the Y plane.
+ pub ar_coeffs_y_plus_128: [u8; MAX_NUM_POS_LUMA],
+ /// Specifies auto-regressive coefficients used for the U plane.
+ pub ar_coeffs_cb_plus_128: [u8; MAX_NUM_POS_LUMA],
+ /// Specifies auto-regressive coefficients used for the V plane.
+ pub ar_coeffs_cr_plus_128: [u8; MAX_NUM_POS_LUMA],
+ /// Specifies the range of the auto-regressive coefficients. Values of 0, 1,
+ /// 2, and 3 correspond to the ranges for auto-regressive coefficients of
+ /// [-2, 2), [-1, 1), [-0.5, 0.5) and [-0.25, 0.25) respectively.
+ pub ar_coeff_shift_minus_6: u8,
+ /// Specifies how much the Gaussian random numbers should be scaled down
+ /// during the grain synthesis process.
+ pub grain_scale_shift: u8,
+ /// Represents a multiplier for the cb component used in derivation of the
+ /// input index to the cb component scaling function.
+ pub cb_mult: u8,
+ /// Represents a multiplier for the average luma component used in
+ /// derivation of the input index to the cb component scaling function.
+ pub cb_luma_mult: u8,
+ /// Represents an offset used in derivation of the input index to the cb
+ /// component scaling function.
+ pub cb_offset: u16,
+ /// Represents a multiplier for the cr component used in derivation of the
+ /// input index to the cr component scaling function.
+ pub cr_mult: u8,
+ /// Represents a multiplier for the average luma component used in
+ /// derivation of the input index to the cr component scaling function.
+ pub cr_luma_mult: u8,
+ /// Represents an offset used in derivation of the input index to the cr
+ /// component scaling function.
+ pub cr_offset: u16,
+ /// If set, indicates that the overlap between film grain blocks shall be
+ /// applied. If not set, indicates that the overlap between film grain
+ /// blocks shall not be applied.
+ pub overlap_flag: bool,
+ /// If set, indicates that clipping to the restricted (studio) range shall
+ /// be applied to the sample values after adding the film grain (see the
+ /// semantics for color_range for an explanation of studio swing). If not
+ /// set, indicates that clipping to the full range shall be applied to the
+ /// sample values after adding the film grain.
+ pub clip_to_restricted_range: bool,
+}
+
+/// Keeps track of the state of the reference frames in the parser. All
+/// variables are CamelCase.
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+struct ReferenceFrameInfo {
+ /// An array which is indexed by a reference picture slot number. A value of
+ /// true in the array signifies that the corresponding reference picture
+ /// slot is valid for use as a reference picture, while a value of false
+ /// signifies that the corresponding reference picture slot is not valid for
+ /// use as a reference picture.
+ ref_valid: bool,
+ /// Specifies the frame id for each reference frame.
+ ref_frame_id: u32,
+ /// See 7.20 Reference Frame Update Process.
+ ref_upscaled_width: u32,
+ /// See 7.20 Reference Frame Update Process.
+ ref_frame_width: u32,
+ /// See 7.20 Reference Frame Update Process.
+ ref_frame_height: u32,
+ /// See 7.20 Reference Frame Update Process.
+ ref_render_width: u32,
+ /// See 7.20 Reference Frame Update Process.
+ ref_render_height: u32,
+ /// See 7.20 Reference Frame Update Process.
+ ref_mi_cols: u32,
+ /// See 7.20 Reference Frame Update Process.
+ ref_mi_rows: u32,
+ /// See 7.20 Reference Frame Update Process.
+ ref_frame_type: FrameType,
+ /// See 7.20 Reference Frame Update Process.
+ ref_subsampling_x: bool,
+ /// See 7.20 Reference Frame Update Process.
+ ref_subsampling_y: bool,
+ /// See 7.20 Reference Frame Update Process.
+ ref_bit_depth: BitDepth,
+ /// See 7.20 Reference Frame Update Process.
+ ref_order_hint: u32,
+ /// The saved segmentation parameters.
+ segmentation_params: SegmentationParams,
+ /// The saved global motion parameters.
+ global_motion_params: GlobalMotionParams,
+ /// The saved loop filter parameters.
+ loop_filter_params: LoopFilterParams,
+ /// The saved film grain parameters.
+ film_grain_params: FilmGrainParams,
+ /// The saved tile info parameters.
+ tile_info: TileInfo,
+ display_frame_id: u32,
+ showable_frame: bool,
+}
+
+#[derive(Clone, Debug, Default)]
+pub struct AnnexBState {
+ pub temporal_unit_size: u32,
+ pub frame_unit_size: u32,
+ pub temporal_unit_consumed: u32,
+ pub frame_unit_consumed: u32,
+}
+
+#[derive(Clone, Debug)]
+enum StreamFormat {
+ LowOverhead,
+ AnnexB(AnnexBState),
+}
+
+#[derive(Debug)]
+pub struct Parser {
+ stream_format: StreamFormat,
+ operating_point: u32,
+ /// Same as SeenFrameHeader in the specification
+ seen_frame_header: bool,
+ operating_point_idc: u16,
+ should_probe_for_annexb: bool,
+ is_first_frame: bool,
+ ref_info: [ReferenceFrameInfo; NUM_REF_FRAMES],
+
+ /* CamelCase variables */
+ mi_cols: u32,
+ mi_rows: u32,
+ prev_frame_id: u32,
+ current_frame_id: u32,
+ mi_col_starts: [u32; MAX_TILE_COLS + 1],
+ mi_row_starts: [u32; MAX_TILE_ROWS + 1],
+ tile_cols_log2: u32,
+ tile_cols: u32,
+ tile_rows_log2: u32,
+ tile_rows: u32,
+ tile_size_bytes: u32,
+
+ /// We keep this to implement frame_header_copy() in the specification, and to fill in
+ /// StreamInfo render_width and render_height.
+ pub last_frame_header: Option,
+ /// The last SequenceHeaderObu parsed.
+ pub sequence_header: Option>,
+}
+
+impl Parser {
+ /// Probes the input data for the Annex B format. Anything other than
+ /// Ok(true) refers to data in "low-overhead" format instead, as we are trying to parse
+ fn annexb_probe(data: &[u8]) -> Result {
+ let mut r = Reader::new(data);
+ let mut seen_sequence = false;
+ let mut seen_frame = false;
+
+ // Try reading the first TU and frame unit size
+ let temporal_unit_size = r.read_leb128()?;
+ if temporal_unit_size == 0 {
+ return Ok(false);
+ }
+
+ let frame_unit_size = r.read_leb128()?;
+ if frame_unit_size == 0 || frame_unit_size > temporal_unit_size {
+ return Ok(false);
+ }
+
+ let obu_length = r.read_leb128()?;
+ if obu_length == 0 || obu_length > frame_unit_size {
+ return Ok(false);
+ }
+
+ // The first OBU in the first frame_unit of each temporal_unit must
+ // be a temporal delimiter OBU (and this is the only place temporal
+ // delimiter OBUs can appear)
+ let header = Self::parse_obu_header(&mut r.clone())?;
+ if !matches!(header.obu_type, ObuType::TemporalDelimiter) {
+ return Ok(false);
+ }
+
+ // Try identifying a sequence and a frame.
+ r.0.skip_bits(obu_length as usize * 8)?;
+ let mut num_bytes_read = 0;
+
+ loop {
+ let obu_length = r.read_leb128()?;
+ let mut obu_reader = r.clone();
+
+ r.0.skip_bits(obu_length as usize * 8)?;
+ num_bytes_read += obu_length;
+
+ if !seen_sequence {
+ let header = Self::parse_obu_header(&mut obu_reader)?;
+ seen_sequence = matches!(header.obu_type, ObuType::SequenceHeader);
+ }
+
+ if !seen_frame {
+ let header = Self::parse_obu_header(&mut obu_reader)?;
+ seen_frame = matches!(header.obu_type, ObuType::Frame | ObuType::FrameHeader);
+ }
+
+ if seen_sequence && seen_frame {
+ // OK, enough evidence of Annex B format.
+ return Ok(true);
+ }
+
+ if num_bytes_read >= frame_unit_size {
+ // We read what we've identified as the first frame and yet no
+ // sequence and no actual frames were found.
+ return Ok(false);
+ }
+ }
+ }
+
+ fn compute_image_size(&mut self, fh: &mut FrameHeaderObu) {
+ fh.mi_cols = 2 * ((fh.frame_width + 7) >> 3);
+ fh.mi_rows = 2 * ((fh.frame_height + 7) >> 3);
+ self.mi_cols = fh.mi_cols;
+ self.mi_rows = fh.mi_rows;
+ }
+
+ // 5.9.8
+ fn parse_superres_params(
+ fh: &mut FrameHeaderObu,
+ r: &mut Reader,
+ seq: &SequenceHeaderObu,
+ ) -> Result<(), String> {
+ if seq.enable_superres {
+ fh.use_superres = r.0.read_bit()?;
+ } else {
+ fh.use_superres = false;
+ }
+
+ if fh.use_superres {
+ fh.superres_denom =
+ r.0.read_bits::(SUPERRES_DENOM_BITS)? + SUPERRES_DENOM_MIN as u32;
+ } else {
+ fh.superres_denom = SUPERRES_NUM as u32;
+ }
+
+ fh.upscaled_width = fh.frame_width;
+ fh.frame_width =
+ (fh.upscaled_width * SUPERRES_NUM as u32 + (fh.superres_denom / 2)) / fh.superres_denom;
+
+ Ok(())
+ }
+
+ // 7.8 verbatim.
+ fn set_frame_refs(
+ &self,
+ fh: &mut FrameHeaderObu,
+ ref_order_hint: &[u32; NUM_REF_FRAMES],
+ ) -> Result<(), String> {
+ let seq = self.sequence()?;
+ let mut ref_frame_idx = [-1i32; REFS_PER_FRAME];
+
+ ref_frame_idx[0] = fh.last_frame_idx.into();
+ ref_frame_idx[ReferenceFrameType::Golden as usize - ReferenceFrameType::Last as usize] =
+ fh.gold_frame_idx.into();
+
+ let mut used_frame = [false; NUM_REF_FRAMES];
+ used_frame[fh.last_frame_idx as usize] = true;
+ used_frame[fh.gold_frame_idx as usize] = true;
+
+ let cur_frame_hint = 1 << (seq.order_hint_bits - 1);
+ let mut shifted_order_hints = [0; NUM_REF_FRAMES];
+ for i in 0..NUM_REF_FRAMES {
+ shifted_order_hints[i] = cur_frame_hint
+ + helpers::get_relative_dist(
+ seq.enable_order_hint,
+ seq.order_hint_bits,
+ ref_order_hint[i].try_into().unwrap(),
+ fh.order_hint.try_into().unwrap(),
+ );
+ }
+
+ let mut latest_order_hint = shifted_order_hints[fh.last_frame_idx as usize];
+ if latest_order_hint >= cur_frame_hint {
+ return Err("It is a requirement of bitstream conformance that last_order_hint < cur_frame_hint".into());
+ }
+
+ let mut earliest_order_hint = shifted_order_hints[fh.gold_frame_idx as usize];
+ if earliest_order_hint >= cur_frame_hint {
+ return Err("It is a requirement of bitstream conformance that gold_order_hint < cur_frame_hint".into());
+ }
+
+ let ref_ = helpers::find_latest_backward(
+ &shifted_order_hints,
+ &used_frame,
+ cur_frame_hint,
+ &mut latest_order_hint,
+ );
+
+ if ref_ >= 0 {
+ ref_frame_idx
+ [ReferenceFrameType::AltRef as usize - ReferenceFrameType::Last as usize] = ref_;
+ used_frame[ref_ as usize] = true;
+ }
+
+ let ref_ = helpers::find_earliest_backward(
+ &shifted_order_hints,
+ &used_frame,
+ cur_frame_hint,
+ &mut earliest_order_hint,
+ );
+
+ if ref_ >= 0 {
+ ref_frame_idx
+ [ReferenceFrameType::BwdRef as usize - ReferenceFrameType::Last as usize] = ref_;
+ used_frame[ref_ as usize] = true;
+ }
+
+ let ref_ = helpers::find_earliest_backward(
+ &shifted_order_hints,
+ &used_frame,
+ cur_frame_hint,
+ &mut earliest_order_hint,
+ );
+
+ if ref_ >= 0 {
+ ref_frame_idx
+ [ReferenceFrameType::AltRef2 as usize - ReferenceFrameType::Last as usize] = ref_;
+ used_frame[ref_ as usize] = true;
+ }
+
+ const REF_FRAME_LIST: [usize; 5] = [
+ ReferenceFrameType::Last2 as usize - ReferenceFrameType::Last as usize,
+ ReferenceFrameType::Last3 as usize - ReferenceFrameType::Last as usize,
+ ReferenceFrameType::BwdRef as usize - ReferenceFrameType::Last as usize,
+ ReferenceFrameType::AltRef2 as usize - ReferenceFrameType::Last as usize,
+ ReferenceFrameType::AltRef as usize - ReferenceFrameType::Last as usize,
+ ];
+
+ #[allow(clippy::needless_range_loop)]
+ for i in 0..REFS_PER_FRAME - 2 {
+ let ref_frame = REF_FRAME_LIST[i];
+
+ if ref_frame_idx[ref_frame] < 0 {
+ let ref_ = helpers::find_latest_forward(
+ &shifted_order_hints,
+ &used_frame,
+ cur_frame_hint,
+ &mut latest_order_hint,
+ );
+
+ if ref_ >= 0 {
+ ref_frame_idx[ref_frame] = ref_;
+ used_frame[ref_ as usize] = true;
+ }
+ }
+ }
+
+ let mut ref_ = 0;
+ earliest_order_hint = shifted_order_hints[0];
+ #[allow(clippy::needless_range_loop)]
+ for i in 1..NUM_REF_FRAMES {
+ let hint = shifted_order_hints[i];
+ if hint < earliest_order_hint {
+ ref_ = i as u8;
+ earliest_order_hint = hint;
+ }
+ }
+
+ fh.ref_frame_idx
+ .iter_mut()
+ .zip(ref_frame_idx.iter().copied())
+ .for_each(|(dest, src)| *dest = if src < 0 { ref_ } else { src as u8 });
+
+ Ok(())
+ }
+
+ // 5.9.5.
+ fn parse_frame_size(&mut self, fh: &mut FrameHeaderObu, r: &mut Reader) -> Result<(), String> {
+ let seq = self.sequence()?;
+ if fh.frame_size_override_flag {
+ let n = seq.frame_width_bits_minus_1 + 1;
+ fh.frame_width = r.0.read_bits::(n as usize)? + 1;
+
+ let n = seq.frame_height_bits_minus_1 + 1;
+ fh.frame_height = r.0.read_bits::(n as usize)? + 1;
+ } else {
+ fh.frame_width = seq.max_frame_width_minus_1 as u32 + 1;
+ fh.frame_height = seq.max_frame_height_minus_1 as u32 + 1;
+ }
+
+ Self::parse_superres_params(fh, r, seq)?;
+ self.compute_image_size(fh);
+
+ Ok(())
+ }
+
+ fn parse_render_size(fh: &mut FrameHeaderObu, r: &mut Reader) -> Result<(), String> {
+ fh.render_and_frame_size_different = r.0.read_bit()?;
+ if fh.render_and_frame_size_different {
+ fh.render_width = r.0.read_bits::(16)? + 1;
+ fh.render_height = r.0.read_bits::(16)? + 1;
+ } else {
+ fh.render_width = fh.upscaled_width;
+ fh.render_height = fh.frame_height;
+ }
+ Ok(())
+ }
+
+ fn frame_size_with_refs(
+ &mut self,
+ fh: &mut FrameHeaderObu,
+ r: &mut Reader,
+ ) -> Result<(), String> {
+ let mut found_ref = false;
+ let seq = self.sequence()?;
+
+ for i in 0..REFS_PER_FRAME {
+ found_ref = r.0.read_bit()?;
+
+ if found_ref {
+ let rf = &self.ref_info[fh.ref_frame_idx[i] as usize];
+ fh.upscaled_width = rf.ref_upscaled_width;
+ fh.frame_width = fh.upscaled_width;
+ fh.frame_height = rf.ref_frame_height;
+ fh.render_width = rf.ref_render_width;
+ fh.render_height = rf.ref_render_height;
+ break;
+ }
+ }
+
+ if !found_ref {
+ self.parse_frame_size(fh, r)?;
+ Self::parse_render_size(fh, r)?;
+ } else {
+ Self::parse_superres_params(fh, r, seq)?;
+ self.compute_image_size(fh);
+ }
+
+ Ok(())
+ }
+
+ /// Skip the padding bits, ensuring that they actually make sense.
+ fn skip_and_check_trailing_bits(r: &mut Reader, obu: &Obu) -> Result<(), String> {
+ // We can't have that in parse_obu as per the spec, because the reader
+ // is not initialized on our design at that point, so move the check to
+ // inside this function.
+ if obu.data.len() == 0
+ || matches!(
+ obu.header.obu_type,
+ ObuType::TileList | ObuType::TileGroup | ObuType::Frame
+ )
+ {
+ return Ok(());
+ }
+ let num_trailing = obu.as_ref().len() as u64 * 8 - r.0.position();
+ r.read_trailing_bits(num_trailing)?;
+ Ok(())
+ }
+
+ fn parse_obu_header(r: &mut Reader) -> Result {
+ let _obu_forbidden_bit = r.0.read_bit()?;
+
+ let mut header = ObuHeader {
+ obu_type: ObuType::try_from(r.0.read_bits::(4)?)?,
+ extension_flag: r.0.read_bit()?,
+ has_size_field: r.0.read_bit()?,
+ temporal_id: Default::default(),
+ spatial_id: Default::default(),
+ };
+
+ let obu_reserved_1bit = r.0.read_bit()?;
+ assert!(!obu_reserved_1bit); // Must be set to zero as per spec.
+
+ if header.extension_flag {
+ header.temporal_id = r.0.read_bits::(3)?;
+ header.spatial_id = r.0.read_bits::(2)?;
+ let _ = r.0.read_bits::(3)?;
+ }
+
+ Ok(header)
+ }
+
+ /// Parses one OBU from `data`, which can be in Annex B or low-overhead
+ /// format.
+ ///
+ /// `None` may eventually be returned if the OBU is to be dropped.
+ pub fn read_obu<'a>(&mut self, data: &'a [u8]) -> Result, String> {
+ if data.is_empty() {
+ return Err("Empty data".into());
+ }
+
+ let mut reader = Reader::new(data);
+
+ if self.should_probe_for_annexb {
+ // Try probing for Annex B data.
+ self.stream_format = if matches!(Self::annexb_probe(data), Ok(true)) {
+ log::debug!("Parsing an Annex B stream");
+ StreamFormat::AnnexB(AnnexBState::default())
+ } else {
+ log::debug!("Parsing a low-overhead stream");
+ StreamFormat::LowOverhead
+ };
+
+ self.should_probe_for_annexb = false;
+ }
+
+ let obu_length: usize = if let StreamFormat::AnnexB(annexb_state) = &mut self.stream_format
+ {
+ // Read the length to skip to the start of the open_bitstream_unit()
+ // syntax element.
+ let obu_length = reader.current_annexb_obu_length(annexb_state)?;
+ match obu_length {
+ Some(length) => length,
+ None => return Ok(ObuAction::Drop(reader.consumed(0))),
+ }
+ } else {
+ 0
+ };
+
+ let start_pos = reader.consumed(0);
+
+ // Both "low-overhead" and Annex B are now at the same point, i.e.: a
+ // open_bitstream_unit() follows.
+ let header = Self::parse_obu_header(&mut reader)?;
+ if matches!(self.stream_format, StreamFormat::LowOverhead) {
+ assert!(header.has_size_field);
+ }
+
+ let obu_size: usize = if header.has_size_field {
+ reader.read_leb128()? as usize
+ } else {
+ /* trap any bugs when computing the final length */
+ obu_length
+ .checked_sub(1)
+ .ok_or::("obu_length must be greater than 0".into())?
+ .checked_sub(usize::from(header.extension_flag))
+ .ok_or::("obu_length too short".into())?
+ };
+
+ let consumed = reader.consumed(start_pos);
+
+ if let StreamFormat::AnnexB(annexb_state) = &mut self.stream_format {
+ annexb_state.temporal_unit_consumed += consumed;
+ annexb_state.frame_unit_consumed += consumed;
+
+ annexb_state.temporal_unit_consumed += u32::try_from(obu_size).unwrap();
+ annexb_state.frame_unit_consumed += u32::try_from(obu_size).unwrap();
+ }
+
+ assert!(reader.0.position() % 8 == 0);
+ let start_offset: usize = (reader.0.position() / 8).try_into().unwrap();
+
+ log::debug!(
+ "Identified OBU type {:?}, data size: {}, obu_size: {}",
+ header.obu_type,
+ start_offset + obu_size,
+ obu_size
+ );
+
+ if header.obu_type != ObuType::SequenceHeader
+ && header.obu_type != ObuType::TemporalDelimiter
+ && self.operating_point_idc != 0
+ && header.extension_flag
+ {
+ let in_temporal_layer = ((self.operating_point_idc >> header.temporal_id) & 1) != 0;
+ let in_spatial_layer = ((self.operating_point_idc >> (header.spatial_id + 8)) & 1) != 0;
+ if !in_temporal_layer || !in_spatial_layer {
+ log::debug!("Dropping obu as per drop_obu() in the specification",);
+ return Ok(ObuAction::Drop(reader.consumed(0)));
+ }
+ }
+
+ Ok(ObuAction::Process(Obu {
+ header,
+ data: Cow::from(&data[start_offset..start_offset + obu_size]),
+ bytes_used: start_offset + obu_size,
+ }))
+ }
+
+ fn parse_color_config(s: &mut SequenceHeaderObu, r: &mut Reader) -> Result<(), String> {
+ let cc = &mut s.color_config;
+
+ cc.high_bitdepth = r.0.read_bit()?;
+ if s.seq_profile as u32 == 2 && cc.high_bitdepth {
+ cc.twelve_bit = r.0.read_bit()?;
+ if cc.twelve_bit {
+ s.bit_depth = BitDepth::Depth12;
+ } else {
+ s.bit_depth = BitDepth::Depth10;
+ }
+ } else if s.seq_profile as u32 <= 2 {
+ s.bit_depth = if cc.high_bitdepth {
+ BitDepth::Depth10
+ } else {
+ BitDepth::Depth8
+ };
+ }
+
+ if s.seq_profile as u32 == 1 {
+ cc.mono_chrome = false;
+ } else {
+ cc.mono_chrome = r.0.read_bit()?;
+ }
+
+ if cc.mono_chrome {
+ s.num_planes = 1;
+ } else {
+ s.num_planes = 3;
+ }
+
+ cc.color_description_present_flag = r.0.read_bit()?;
+ if cc.color_description_present_flag {
+ cc.color_primaries = ColorPrimaries::try_from(r.0.read_bits::(8)?)?;
+ cc.transfer_characteristics =
+ TransferCharacteristics::try_from(r.0.read_bits::(8)?)?;
+ cc.matrix_coefficients = MatrixCoefficients::try_from(r.0.read_bits::(8)?)?;
+ } else {
+ cc.color_primaries = ColorPrimaries::Unspecified;
+ cc.transfer_characteristics = TransferCharacteristics::Unspecified;
+ cc.matrix_coefficients = MatrixCoefficients::Unspecified;
+ }
+
+ if cc.mono_chrome {
+ cc.color_range = r.0.read_bit()?;
+ cc.subsampling_x = true;
+ cc.subsampling_y = true;
+ cc.chroma_sample_position = ChromaSamplePosition::Unknown;
+ cc.separate_uv_delta_q = false;
+ return Ok(());
+ } else if matches!(cc.color_primaries, ColorPrimaries::Bt709)
+ && matches!(cc.transfer_characteristics, TransferCharacteristics::Srgb)
+ && matches!(cc.matrix_coefficients, MatrixCoefficients::Identity)
+ {
+ cc.color_range = true;
+ cc.subsampling_x = false;
+ cc.subsampling_y = false;
+ } else {
+ cc.color_range = r.0.read_bit()?;
+ if s.seq_profile as u32 == 0 {
+ cc.subsampling_x = true;
+ cc.subsampling_y = true;
+ } else if s.seq_profile as u32 == 1 {
+ cc.subsampling_x = false;
+ cc.subsampling_y = false;
+ } else if matches!(s.bit_depth, BitDepth::Depth12) {
+ cc.subsampling_x = r.0.read_bit()?;
+ if cc.subsampling_x {
+ cc.subsampling_y = r.0.read_bit()?;
+ } else {
+ cc.subsampling_y = false;
+ }
+ } else {
+ cc.subsampling_x = true;
+ cc.subsampling_y = false;
+ }
+
+ if cc.subsampling_x && cc.subsampling_y {
+ cc.chroma_sample_position =
+ ChromaSamplePosition::try_from(r.0.read_bits::(2)?)?;
+ }
+ }
+
+ cc.separate_uv_delta_q = r.0.read_bit()?;
+
+ Ok(())
+ }
+
+ fn parse_operating_parameters_info(
+ opi: &mut OperatingPoint,
+ r: &mut Reader,
+ buffer_delay_length_minus_1: u8,
+ ) -> Result<(), String> {
+ let n = buffer_delay_length_minus_1 + 1;
+ opi.decoder_buffer_delay = r.0.read_bits::(n as usize)?;
+ opi.encoder_buffer_delay = r.0.read_bits::(n as usize)?;
+ opi.low_delay_mode_flag = r.0.read_bit()?;
+ Ok(())
+ }
+
+ fn parse_decoder_model_info(dmi: &mut DecoderModelInfo, r: &mut Reader) -> Result<(), String> {
+ dmi.buffer_delay_length_minus_1 = r.0.read_bits::(5)? as u8;
+ dmi.num_units_in_decoding_tick = r.0.read_bits::(32)?;
+ dmi.buffer_removal_time_length_minus_1 = r.0.read_bits::(5)? as u8;
+ dmi.frame_presentation_time_length_minus_1 = r.0.read_bits::(5)?;
+ Ok(())
+ }
+
+ fn parse_timing_info(ti: &mut TimingInfo, r: &mut Reader) -> Result<(), String> {
+ ti.num_units_in_display_tick = r.0.read_bits::(32)?;
+ ti.time_scale = r.0.read_bits::(32)?;
+ ti.equal_picture_interval = r.0.read_bit()?;
+ if ti.equal_picture_interval {
+ ti.num_ticks_per_picture_minus_1 = r.read_uvlc()?;
+ }
+ Ok(())
+ }
+
+ /// Selects an operating point. Only call this after the Sequence OBU for
+ /// which the operating point should apply has been parsed.
+ pub fn choose_operating_point(&mut self, operating_point: u32) -> Result<(), String> {
+ if operating_point > self.sequence()?.operating_points_cnt_minus_1 {
+ return Err(format!(
+ "Invalid operating point {} (max {})",
+ operating_point,
+ self.sequence()?.operating_points_cnt_minus_1
+ ));
+ }
+ self.operating_point = operating_point;
+ self.operating_point_idc = self.sequence()?.operating_points[operating_point as usize].idc;
+ Ok(())
+ }
+
+ fn parse_temporal_delimiter_obu(&mut self) -> Result<(), String> {
+ self.seen_frame_header = false;
+ Ok(())
+ }
+
+ fn parse_sequence_header_obu(&mut self, obu: &Obu) -> Result, String> {
+ let mut s = SequenceHeaderObu {
+ obu_header: obu.header.clone(),
+ ..Default::default()
+ };
+
+ let mut r = Reader::new(obu.as_ref());
+ let profile = r.0.read_bits::(3)?;
+
+ s.seq_profile = Profile::try_from(profile)?;
+ s.still_picture = r.0.read_bit()?;
+ s.reduced_still_picture_header = r.0.read_bit()?;
+
+ if s.reduced_still_picture_header {
+ /* Default::default() already ensures a lot of this, but lets go verbatim */
+ s.timing_info_present_flag = false;
+ s.decoder_model_info_present_flag = false;
+ s.initial_display_delay_present_flag = false;
+ s.operating_points_cnt_minus_1 = 0;
+ s.operating_points[0].idc = 0;
+ s.operating_points[0].seq_level_idx = r.0.read_bits::(5)? as u8;
+ s.operating_points[0].seq_tier = 0;
+ s.operating_points[0].decoder_model_present_for_this_op = false;
+ s.operating_points[0].initial_display_delay_present_for_this_op = false;
+ } else {
+ s.timing_info_present_flag = r.0.read_bit()?;
+ if s.timing_info_present_flag {
+ Self::parse_timing_info(&mut s.timing_info, &mut r)?;
+ s.decoder_model_info_present_flag = r.0.read_bit()?;
+ if s.decoder_model_info_present_flag {
+ Self::parse_decoder_model_info(&mut s.decoder_model_info, &mut r)?;
+ }
+ } else {
+ s.decoder_model_info_present_flag = false;
+ }
+
+ s.initial_display_delay_present_flag = r.0.read_bit()?;
+ s.operating_points_cnt_minus_1 = r.0.read_bits::(5)?;
+ if s.operating_points_cnt_minus_1 > MAX_NUM_OPERATING_POINTS as u32 {
+ return Err(format!(
+ "Invalid operating_points_cnt_minus_1 {}",
+ s.operating_points_cnt_minus_1
+ ));
+ }
+
+ for i in 0..=s.operating_points_cnt_minus_1 as usize {
+ s.operating_points[i].idc = r.0.read_bits::(12)? as u16;
+ s.operating_points[i].seq_level_idx = r.0.read_bits::(5)? as u8;
+ if s.operating_points[i].seq_level_idx > 7 {
+ s.operating_points[i].seq_tier = r.0.read_bit()? as u8;
+ } else {
+ s.operating_points[i].seq_tier = 0;
+ }
+ if s.decoder_model_info_present_flag {
+ s.operating_points[i].decoder_model_present_for_this_op = r.0.read_bit()?;
+ if s.operating_points[i].decoder_model_present_for_this_op {
+ let buffer_delay_length_minus_1 =
+ s.decoder_model_info.buffer_delay_length_minus_1;
+ Self::parse_operating_parameters_info(
+ &mut s.operating_points[i],
+ &mut r,
+ buffer_delay_length_minus_1,
+ )?;
+ }
+ } else {
+ s.operating_points[i].decoder_model_present_for_this_op = false;
+ }
+
+ if s.initial_display_delay_present_flag {
+ s.operating_points[i].initial_display_delay_present_for_this_op =
+ r.0.read_bit()?;
+ if s.operating_points[i].initial_display_delay_present_for_this_op {
+ s.operating_points[i].initial_display_delay_minus_1 =
+ r.0.read_bits::(4)?;
+ }
+ }
+ }
+ }
+
+ s.frame_width_bits_minus_1 = r.0.read_bits::(4)? as u8;
+ s.frame_height_bits_minus_1 = r.0.read_bits::(4)? as u8;
+ // frame_width_bits_minus_1 has been read from 4 bits, meaning we can read 16 bits at most.
+ s.max_frame_width_minus_1 =
+ r.0.read_bits::(s.frame_width_bits_minus_1 as usize + 1)? as u16;
+ // frame_height_bits_minus_1 has been read from 4 bits, meaning we can read 16 bits at most.
+ s.max_frame_height_minus_1 =
+ r.0.read_bits::(s.frame_height_bits_minus_1 as usize + 1)? as u16;
+ if s.reduced_still_picture_header {
+ s.frame_id_numbers_present_flag = false;
+ } else {
+ s.frame_id_numbers_present_flag = r.0.read_bit()?;
+ }
+ if s.frame_id_numbers_present_flag {
+ s.delta_frame_id_length_minus_2 = r.0.read_bits::(4)?;
+ s.additional_frame_id_length_minus_1 = r.0.read_bits::(3)?;
+ let frame_id_length =
+ s.additional_frame_id_length_minus_1 + s.delta_frame_id_length_minus_2 + 3;
+ if frame_id_length > 16 {
+ return Err(format!("Invalid frame_id_length {}", frame_id_length));
+ }
+ }
+
+ s.use_128x128_superblock = r.0.read_bit()?;
+ s.enable_filter_intra = r.0.read_bit()?;
+ s.enable_intra_edge_filter = r.0.read_bit()?;
+ if s.reduced_still_picture_header {
+ s.enable_interintra_compound = false;
+ s.enable_masked_compound = false;
+ s.enable_warped_motion = false;
+ s.enable_dual_filter = false;
+ s.enable_order_hint = false;
+ s.enable_jnt_comp = false;
+ s.enable_ref_frame_mvs = false;
+ s.seq_force_screen_content_tools = SELECT_SCREEN_CONTENT_TOOLS as _;
+ s.seq_force_integer_mv = SELECT_INTEGER_MV as _;
+ s.order_hint_bits = 0;
+ s.order_hint_bits_minus_1 = -1;
+ } else {
+ s.enable_interintra_compound = r.0.read_bit()?;
+ s.enable_masked_compound = r.0.read_bit()?;
+ s.enable_warped_motion = r.0.read_bit()?;
+ s.enable_dual_filter = r.0.read_bit()?;
+ s.enable_order_hint = r.0.read_bit()?;
+ if s.enable_order_hint {
+ s.enable_jnt_comp = r.0.read_bit()?;
+ s.enable_ref_frame_mvs = r.0.read_bit()?;
+ } else {
+ s.enable_jnt_comp = false;
+ s.enable_ref_frame_mvs = false;
+ }
+ s.seq_choose_screen_content_tools = r.0.read_bit()?;
+ if s.seq_choose_screen_content_tools {
+ s.seq_force_screen_content_tools = SELECT_SCREEN_CONTENT_TOOLS as _;
+ } else {
+ s.seq_force_screen_content_tools = r.0.read_bit()? as _;
+ }
+ if s.seq_force_screen_content_tools > 0 {
+ s.seq_choose_integer_mv = r.0.read_bit()?;
+ if s.seq_choose_integer_mv {
+ s.seq_force_integer_mv = SELECT_INTEGER_MV as _;
+ } else {
+ s.seq_force_integer_mv = r.0.read_bit()? as _;
+ }
+ } else {
+ s.seq_force_integer_mv = SELECT_INTEGER_MV as _;
+ }
+
+ if s.enable_order_hint {
+ s.order_hint_bits_minus_1 = r.0.read_bits::(3)?.try_into().unwrap();
+ s.order_hint_bits = s.order_hint_bits_minus_1 + 1;
+ } else {
+ s.order_hint_bits_minus_1 = -1;
+ s.order_hint_bits = 0;
+ }
+ }
+
+ s.enable_superres = r.0.read_bit()?;
+ s.enable_cdef = r.0.read_bit()?;
+ s.enable_restoration = r.0.read_bit()?;
+
+ Self::parse_color_config(&mut s, &mut r)?;
+
+ s.film_grain_params_present = r.0.read_bit()?;
+
+ Self::skip_and_check_trailing_bits(&mut r, obu)?;
+ let rc = Rc::new(s);
+ self.sequence_header = Some(rc.clone());
+
+ /* Client is supposed to set the operating point through external means,
+ * here we just set 0 as default. */
+ self.choose_operating_point(0)?;
+
+ Ok(rc)
+ }
+
+ /// Implements 7.21. Note that 7.20 will use the information from the
+ /// header, so we must save them now, as they will not be parsed from the
+ /// bitstream. We also save some internal parser state which will be useful
+ /// later.
+ fn load_reference_frame(&self, fh: &mut FrameHeaderObu) -> Result<(), String> {
+ let rf = &self.ref_info[fh.frame_to_show_map_idx as usize];
+
+ // Section 6.8.1: It is a requirement of bitstream conformance that a
+ // sequence header OBU has been received before a frame header OBU.
+ let seq = self.sequence()?;
+
+ /* at least save the sizes and for both kf and non-kf */
+ fh.frame_type = rf.ref_frame_type;
+ fh.upscaled_width = rf.ref_upscaled_width;
+ fh.frame_width = rf.ref_frame_width;
+ fh.frame_height = rf.ref_frame_height;
+ fh.render_width = rf.ref_render_width;
+ fh.render_height = rf.ref_render_height;
+
+ /* Save into the frame header */
+ if fh.frame_type == FrameType::KeyFrame {
+ fh.current_frame_id = rf.ref_frame_id;
+ /* We don't keep track of sequence information at the frame level */
+ fh.mi_cols = rf.ref_mi_cols;
+ fh.mi_rows = rf.ref_mi_rows;
+ /* The accelerator is keeping track of CDF values, so that is skipped too */
+ fh.global_motion_params = rf.global_motion_params.clone();
+
+ if seq.film_grain_params_present {
+ fh.film_grain_params = rf.film_grain_params.clone();
+ }
+ fh.loop_filter_params = rf.loop_filter_params.clone();
+ fh.segmentation_params = rf.segmentation_params.clone();
+ }
+
+ Ok(())
+ }
+
+ fn setup_past_independence(fh: &mut FrameHeaderObu) {
+ fh.segmentation_params.feature_enabled = Default::default();
+ fh.segmentation_params.feature_data = Default::default();
+
+ for i in ReferenceFrameType::Last as usize..ReferenceFrameType::AltRef as usize {
+ fh.global_motion_params.gm_type[i] = WarpModelType::Identity;
+ }
+
+ fh.loop_filter_params.loop_filter_delta_enabled = true;
+ fh.loop_filter_params.loop_filter_ref_deltas = [1, 0, 0, 0, -1, 0, -1, -1];
+ fh.loop_filter_params.loop_filter_mode_deltas = Default::default();
+ }
+
+ fn parse_tile_info(&mut self, r: &mut Reader, ti: &mut TileInfo) -> Result<(), String> {
+ let seq = self.sequence()?;
+
+ let sb_cols = if seq.use_128x128_superblock {
+ (self.mi_cols + 31) >> 5
+ } else {
+ (self.mi_cols + 15) >> 4
+ };
+
+ let sb_rows = if seq.use_128x128_superblock {
+ (self.mi_rows + 31) >> 5
+ } else {
+ (self.mi_rows + 15) >> 4
+ };
+
+ let sb_shift = if seq.use_128x128_superblock { 5 } else { 4 };
+ let sb_size = sb_shift + 2;
+
+ let max_tile_width_sb = MAX_TILE_WIDTH >> sb_size;
+ let mut max_tile_area_sb = MAX_TILE_AREA >> (2 * sb_size);
+
+ let min_log2_tile_cols = helpers::tile_log2(max_tile_width_sb, sb_cols);
+
+ let max_log2_tile_cols =
+ helpers::tile_log2(1, std::cmp::min(sb_cols, MAX_TILE_COLS as u32));
+
+ let max_log2_tile_rows =
+ helpers::tile_log2(1, std::cmp::min(sb_rows, MAX_TILE_ROWS as u32));
+
+ let min_log2_tiles = std::cmp::max(
+ min_log2_tile_cols,
+ helpers::tile_log2(max_tile_area_sb, sb_rows * sb_cols),
+ );
+
+ ti.uniform_tile_spacing_flag = r.0.read_bit()?;
+
+ if ti.uniform_tile_spacing_flag {
+ self.tile_cols_log2 = min_log2_tile_cols;
+ while self.tile_cols_log2 < max_log2_tile_cols {
+ let increment_tile_cols_log_2 = r.0.read_bit()?;
+ if increment_tile_cols_log_2 {
+ self.tile_cols_log2 += 1;
+ } else {
+ break;
+ }
+ }
+
+ let tile_width_sb = (sb_cols + (1 << self.tile_cols_log2) - 1) >> self.tile_cols_log2;
+
+ let mut i = 0;
+ let mut start_sb = 0;
+
+ while start_sb < sb_cols {
+ self.mi_col_starts[i] = start_sb << sb_shift;
+ i += 1;
+ start_sb += tile_width_sb;
+ }
+
+ self.mi_col_starts[i] = self.mi_cols;
+ self.tile_cols = i as _;
+
+ if self.tile_cols > MAX_TILE_COLS as u32 {
+ return Err(format!("Invalid tile_cols {}", self.tile_cols));
+ }
+
+ /* compute this anyways */
+ while i >= 1 {
+ ti.width_in_sbs_minus_1[i - 1] =
+ ((self.mi_col_starts[i] - self.mi_col_starts[i - 1] + ((1 << sb_shift) - 1))
+ >> sb_shift)
+ - 1;
+ i -= 1;
+ }
+
+ let min_log2_tile_rows =
+ std::cmp::max(min_log2_tiles.saturating_sub(self.tile_cols_log2), 0);
+ self.tile_rows_log2 = min_log2_tile_rows;
+
+ while self.tile_rows_log2 < max_log2_tile_rows {
+ let increment_tile_rows_log_2 = r.0.read_bit()?;
+
+ if increment_tile_rows_log_2 {
+ self.tile_rows_log2 += 1;
+ } else {
+ break;
+ }
+ }
+
+ let tile_height_sb = (sb_rows + (1 << self.tile_rows_log2) - 1) >> self.tile_rows_log2;
+
+ let mut i = 0;
+ let mut start_sb = 0;
+
+ while start_sb < sb_rows {
+ self.mi_row_starts[i] = start_sb << sb_shift;
+ i += 1;
+ start_sb += tile_height_sb;
+ }
+
+ self.mi_row_starts[i] = self.mi_rows;
+ self.tile_rows = i as _;
+
+ if self.tile_rows > MAX_TILE_ROWS as u32 {
+ return Err(format!("Invalid tile_rows {}", self.tile_cols));
+ }
+
+ /* compute this anyways */
+ while i >= 1 {
+ ti.height_in_sbs_minus_1[i - 1] =
+ ((self.mi_row_starts[i] - self.mi_row_starts[i - 1] + ((1 << sb_shift) - 1))
+ >> sb_shift)
+ - 1;
+ i -= 1;
+ }
+ } else {
+ let mut widest_tile_sb = 0;
+ let mut start_sb = 0;
+ let mut i = 0;
+
+ while start_sb < sb_cols {
+ self.mi_col_starts[i] = start_sb << sb_shift;
+
+ let max_width = std::cmp::min(sb_cols - start_sb, max_tile_width_sb);
+ ti.width_in_sbs_minus_1[i] = r.read_ns(max_width.try_into().unwrap())?;
+
+ let size_sb = ti.width_in_sbs_minus_1[i] + 1;
+ widest_tile_sb = std::cmp::max(size_sb, widest_tile_sb);
+
+ start_sb += size_sb;
+ i += 1;
+ }
+
+ self.mi_col_starts[i] = self.mi_cols;
+ self.tile_cols = i as _;
+ self.tile_cols_log2 = helpers::tile_log2(1, self.tile_cols);
+
+ if min_log2_tiles > 0 {
+ max_tile_area_sb = (sb_rows * sb_cols) >> (min_log2_tiles + 1);
+ } else {
+ max_tile_area_sb = sb_rows * sb_cols;
+ }
+
+ let max_tile_height_sb = std::cmp::max(max_tile_area_sb / widest_tile_sb, 1);
+ let mut start_sb = 0;
+ let mut i = 0;
+ while start_sb < sb_rows {
+ self.mi_row_starts[i] = start_sb << sb_shift;
+ let max_height = std::cmp::min(sb_rows - start_sb, max_tile_height_sb);
+ ti.height_in_sbs_minus_1[i] = r.read_ns(max_height.try_into().unwrap())?;
+
+ let size_sb = ti.height_in_sbs_minus_1[i] + 1;
+ start_sb += size_sb;
+ i += 1;
+ }
+
+ self.mi_row_starts[i] = self.mi_rows;
+ self.tile_rows = i as _;
+ self.tile_rows_log2 = helpers::tile_log2(1, self.tile_rows);
+ }
+
+ if self.tile_cols_log2 > 0 || self.tile_rows_log2 > 0 {
+ let num_bits: usize = (self.tile_rows_log2 + self.tile_cols_log2)
+ .try_into()
+ .unwrap();
+ ti.context_update_tile_id = r.0.read_bits::(num_bits)?;
+
+ if ti.context_update_tile_id >= self.tile_rows * self.tile_cols {
+ return Err(format!(
+ "Invalid context_update_tile_id {}",
+ ti.context_update_tile_id
+ ));
+ }
+ self.tile_size_bytes = r.0.read_bits::(2)? + 1;
+ } else {
+ ti.context_update_tile_id = 0;
+ }
+
+ ti.mi_col_starts = self.mi_col_starts;
+ ti.mi_row_starts = self.mi_row_starts;
+ ti.tile_cols_log2 = self.tile_cols_log2;
+ ti.tile_cols = self.tile_cols;
+ ti.tile_rows_log2 = self.tile_rows_log2;
+ ti.tile_rows = self.tile_rows;
+ ti.tile_size_bytes = self.tile_size_bytes;
+
+ Ok(())
+ }
+
+ fn parse_quantization_params(
+ r: &mut Reader,
+ q: &mut QuantizationParams,
+ num_planes: u32,
+ separate_uv_delta_q: bool,
+ ) -> Result<(), String> {
+ q.base_q_idx = r.0.read_bits::(8)?;
+ q.delta_q_y_dc = r.read_delta_q()?;
+ if num_planes > 1 {
+ if separate_uv_delta_q {
+ q.diff_uv_delta = r.0.read_bit()?;
+ } else {
+ q.diff_uv_delta = false;
+ }
+
+ q.delta_q_u_dc = r.read_delta_q()?;
+ q.delta_q_u_ac = r.read_delta_q()?;
+ if q.diff_uv_delta {
+ q.delta_q_v_dc = r.read_delta_q()?;
+ q.delta_q_v_ac = r.read_delta_q()?;
+ } else {
+ q.delta_q_v_dc = q.delta_q_u_dc;
+ q.delta_q_v_ac = q.delta_q_u_ac;
+ }
+ } else {
+ q.delta_q_u_dc = 0;
+ q.delta_q_u_ac = 0;
+ q.delta_q_v_dc = 0;
+ q.delta_q_v_ac = 0;
+ }
+
+ q.using_qmatrix = r.0.read_bit()?;
+ if q.using_qmatrix {
+ q.qm_y = r.0.read_bits::(4)?;
+ q.qm_u = r.0.read_bits::(4)?;
+ if !separate_uv_delta_q {
+ q.qm_v = q.qm_u;
+ } else {
+ q.qm_v = r.0.read_bits::(4)?;
+ }
+ }
+ Ok(())
+ }
+
+ fn parse_delta_q_params(r: &mut Reader, q: &mut QuantizationParams) -> Result<(), String> {
+ q.delta_q_res = 0;
+ q.delta_q_present = false;
+ if q.base_q_idx > 0 {
+ q.delta_q_present = r.0.read_bit()?;
+ }
+ if q.delta_q_present {
+ q.delta_q_res = r.0.read_bits::(2)?;
+ }
+
+ Ok(())
+ }
+
+ fn parse_delta_lf_params(
+ r: &mut Reader,
+ lf: &mut LoopFilterParams,
+ delta_q_present: bool,
+ allow_intrabc: bool,
+ ) -> Result<(), String> {
+ lf.delta_lf_present = false;
+ lf.delta_lf_res = 0;
+ lf.delta_lf_multi = false;
+ if delta_q_present {
+ if !allow_intrabc {
+ lf.delta_lf_present = r.0.read_bit()?;
+ }
+ if lf.delta_lf_present {
+ lf.delta_lf_res = r.0.read_bits::(2)? as u8;
+ lf.delta_lf_multi = r.0.read_bit()?;
+ }
+ }
+ Ok(())
+ }
+
+ fn parse_segmentation_params(
+ &self,
+ r: &mut Reader,
+ fh: &mut FrameHeaderObu,
+ ) -> Result<(), String> {
+ let s = &mut fh.segmentation_params;
+ s.segmentation_enabled = r.0.read_bit()?;
+ if s.segmentation_enabled {
+ if fh.primary_ref_frame == PRIMARY_REF_NONE {
+ s.segmentation_update_map = true;
+ s.segmentation_temporal_update = false;
+ s.segmentation_update_data = true;
+ } else {
+ s.segmentation_update_map = r.0.read_bit()?;
+ if s.segmentation_update_map {
+ s.segmentation_temporal_update = r.0.read_bit()?;
+ }
+ s.segmentation_update_data = r.0.read_bit()?;
+ }
+ if s.segmentation_update_data {
+ for i in 0..MAX_SEGMENTS {
+ for j in 0..SEG_LVL_MAX {
+ let feature_enabled = r.0.read_bit()?;
+ s.feature_enabled[i][j] = feature_enabled;
+ if feature_enabled {
+ let bits_to_read = FEATURE_BITS[j];
+ let limit = FEATURE_MAX[j];
+ let signed = FEATURE_SIGNED[j];
+
+ if signed {
+ let feature_value = r.read_su(1 + bits_to_read as usize)?;
+ let clipped_value = helpers::clip3(-limit, limit, feature_value);
+ s.feature_data[i][j] = clipped_value as _;
+ } else {
+ let feature_value = r.0.read_bits::(bits_to_read as usize)?;
+ let clipped_value = helpers::clip3(
+ 0,
+ limit,
+ feature_value
+ .try_into()
+ .map_err(|_| "Invalid feature_value")?,
+ );
+ s.feature_data[i][j] = clipped_value as _;
+ }
+ }
+ }
+ }
+ } else {
+ /* copy from prev_frame */
+ let prev_frame =
+ &self.ref_info[fh.ref_frame_idx[fh.primary_ref_frame as usize] as usize];
+
+ if !prev_frame.ref_valid {
+ return Err("Reference is invalid".into());
+ }
+
+ s.feature_enabled = prev_frame.segmentation_params.feature_enabled;
+ s.feature_data = prev_frame.segmentation_params.feature_data;
+ }
+ } else {
+ for i in 0..MAX_SEGMENTS {
+ for j in 0..SEG_LVL_MAX {
+ s.feature_enabled[i][j] = false;
+ s.feature_data[i][j] = 0;
+ }
+ }
+ }
+
+ s.seg_id_pre_skip = false;
+ s.last_active_seg_id = 0;
+ for i in 0..MAX_SEGMENTS {
+ for j in 0..SEG_LVL_MAX {
+ if s.feature_enabled[i][j] {
+ s.last_active_seg_id = i as u8;
+ if j >= SEG_LVL_REF_FRAME {
+ s.seg_id_pre_skip = true;
+ }
+ }
+ }
+ }
+
+ Ok(())
+ }
+
+ fn parse_loop_filter_parameters(
+ r: &mut Reader,
+ fh: &mut FrameHeaderObu,
+ num_planes: u32,
+ ) -> Result<(), String> {
+ let lf = &mut fh.loop_filter_params;
+ if fh.coded_lossless || fh.allow_intrabc {
+ lf.loop_filter_level[0] = 0;
+ lf.loop_filter_level[1] = 0;
+ lf.loop_filter_ref_deltas = [1, 0, 0, 0, -1, 0, -1, -1];
+
+ lf.loop_filter_mode_deltas = Default::default();
+
+ return Ok(());
+ }
+
+ lf.loop_filter_level[0] = r.0.read_bits::(6)? as u8;
+ lf.loop_filter_level[1] = r.0.read_bits::(6)? as u8;
+ if num_planes > 1 && (lf.loop_filter_level[0] > 0 || lf.loop_filter_level[1] > 0) {
+ lf.loop_filter_level[2] = r.0.read_bits::(6)? as u8;
+ lf.loop_filter_level[3] = r.0.read_bits::(6)? as u8;
+ }
+
+ lf.loop_filter_sharpness = r.0.read_bits::(3)? as u8;
+ lf.loop_filter_delta_enabled = r.0.read_bit()?;
+ if lf.loop_filter_delta_enabled {
+ lf.loop_filter_delta_update = r.0.read_bit()?;
+ if lf.loop_filter_delta_update {
+ for i in 0..TOTAL_REFS_PER_FRAME {
+ let update_ref_delta = r.0.read_bit()?;
+ if update_ref_delta {
+ lf.loop_filter_ref_deltas[i] = r.read_su(7)? as i8;
+ }
+ }
+
+ for i in 0..2 {
+ let update_mode_delta = r.0.read_bit()?;
+ if update_mode_delta {
+ lf.loop_filter_mode_deltas[i] = r.read_su(7)? as i8;
+ }
+ }
+ }
+ }
+
+ Ok(())
+ }
+
+ fn parse_cdef_params(
+ r: &mut Reader,
+ fh: &mut FrameHeaderObu,
+ enable_cdef: bool,
+ num_planes: u32,
+ ) -> Result<(), String> {
+ let cdef = &mut fh.cdef_params;
+
+ if fh.coded_lossless || fh.allow_intrabc || !enable_cdef {
+ cdef.cdef_bits = 0;
+ cdef.cdef_y_pri_strength[0] = 0;
+ cdef.cdef_y_sec_strength[0] = 0;
+ cdef.cdef_uv_pri_strength[0] = 0;
+ cdef.cdef_uv_sec_strength[0] = 0;
+ cdef.cdef_damping = 3;
+ return Ok(());
+ }
+
+ cdef.cdef_damping = r.0.read_bits::(2)? + 3;
+ cdef.cdef_bits = r.0.read_bits::(2)?;
+ for i in 0..(1 << cdef.cdef_bits) as usize {
+ cdef.cdef_y_pri_strength[i] = r.0.read_bits::(4)?;
+ cdef.cdef_y_sec_strength[i] = r.0.read_bits::(2)?;
+ if cdef.cdef_y_sec_strength[i] == 3 {
+ cdef.cdef_y_sec_strength[i] += 1;
+ }
+ if num_planes > 1 {
+ cdef.cdef_uv_pri_strength[i] = r.0.read_bits::(4)?;
+ cdef.cdef_uv_sec_strength[i] = r.0.read_bits::(2)?;
+ if cdef.cdef_uv_sec_strength[i] == 3 {
+ cdef.cdef_uv_sec_strength[i] += 1;
+ }
+ }
+ }
+
+ Ok(())
+ }
+
+ fn parse_loop_restoration_params(
+ r: &mut Reader,
+ fh: &mut FrameHeaderObu,
+ enable_restoration: bool,
+ num_planes: u32,
+ use_128x128_superblock: bool,
+ subsampling_x: bool,
+ subsampling_y: bool,
+ ) -> Result<(), String> {
+ let lr = &mut fh.loop_restoration_params;
+
+ if fh.all_lossless || fh.allow_intrabc || !enable_restoration {
+ lr.frame_restoration_type[0] = FrameRestorationType::None;
+ lr.frame_restoration_type[1] = FrameRestorationType::None;
+ lr.frame_restoration_type[2] = FrameRestorationType::None;
+ lr.uses_lr = false;
+ return Ok(());
+ }
+
+ lr.uses_lr = false;
+ lr.uses_chroma_lr = false;
+
+ const REMAP_LR_TYPE: [FrameRestorationType; 4] = [
+ FrameRestorationType::None,
+ FrameRestorationType::Switchable,
+ FrameRestorationType::Wiener,
+ FrameRestorationType::Sgrproj,
+ ];
+
+ for i in 0..num_planes as usize {
+ let lr_type = r.0.read_bits::(2)?;
+ lr.frame_restoration_type[i] = REMAP_LR_TYPE[lr_type as usize];
+ if lr.frame_restoration_type[i] != FrameRestorationType::None {
+ lr.uses_lr = true;
+ if i > 0 {
+ lr.uses_chroma_lr = true;
+ }
+ }
+ }
+
+ if lr.uses_lr {
+ if use_128x128_superblock {
+ lr.lr_unit_shift = r.0.read_bits::(1)? as u8 + 1;
+ } else {
+ lr.lr_unit_shift = r.0.read_bits::(1)? as u8;
+ if lr.lr_unit_shift > 0 {
+ lr.lr_unit_shift += r.0.read_bits::(1)? as u8;
+ }
+ }
+
+ lr.loop_restoration_size[0] = RESTORATION_TILESIZE_MAX >> (2 - lr.lr_unit_shift);
+ if subsampling_x && subsampling_y && lr.uses_chroma_lr {
+ lr.lr_uv_shift = r.0.read_bits::(1)? as u8;
+ } else {
+ lr.lr_uv_shift = 0;
+ }
+
+ lr.loop_restoration_size[1] = lr.loop_restoration_size[0] >> lr.lr_uv_shift;
+ lr.loop_restoration_size[2] = lr.loop_restoration_size[0] >> lr.lr_uv_shift;
+ }
+
+ Ok(())
+ }
+
+ fn read_tx_mode(r: &mut Reader, fh: &mut FrameHeaderObu) -> Result<(), String> {
+ if fh.coded_lossless {
+ fh.tx_mode = TxMode::Only4x4;
+ } else {
+ let tx_mode_select = r.0.read_bit()?;
+
+ if tx_mode_select {
+ fh.tx_mode = TxMode::Select;
+ } else {
+ fh.tx_mode = TxMode::Largest;
+ }
+ }
+
+ Ok(())
+ }
+
+ fn parse_skip_mode_params(
+ &self,
+ r: &mut Reader,
+ fh: &mut FrameHeaderObu,
+ enable_order_hint: bool,
+ order_hint_bits: i32,
+ ) -> Result<(), String> {
+ let skip_mode_allowed;
+
+ if fh.frame_is_intra || !fh.reference_select || !enable_order_hint {
+ skip_mode_allowed = false;
+ } else {
+ let mut forward_idx = -1;
+ let mut backward_idx = -1;
+ let mut forward_hint = 0;
+ let mut backward_hint = 0;
+ for i in 0..REFS_PER_FRAME {
+ let ref_hint = self.ref_info[fh.ref_frame_idx[i] as usize].ref_order_hint;
+ if helpers::get_relative_dist(
+ enable_order_hint,
+ order_hint_bits,
+ ref_hint.try_into().unwrap(),
+ fh.order_hint.try_into().unwrap(),
+ ) < 0
+ && (forward_idx < 0
+ || helpers::get_relative_dist(
+ enable_order_hint,
+ order_hint_bits,
+ ref_hint.try_into().unwrap(),
+ forward_hint,
+ ) > 0)
+ {
+ forward_idx = i32::try_from(i).unwrap();
+ forward_hint = ref_hint.try_into().unwrap();
+ } else if helpers::get_relative_dist(
+ enable_order_hint,
+ order_hint_bits,
+ ref_hint.try_into().unwrap(),
+ fh.order_hint.try_into().unwrap(),
+ ) > 0
+ && (backward_idx < 0 || {
+ helpers::get_relative_dist(
+ enable_order_hint,
+ order_hint_bits,
+ ref_hint.try_into().unwrap(),
+ backward_hint,
+ ) < 0
+ })
+ {
+ backward_idx = i32::try_from(i).unwrap();
+ backward_hint = ref_hint.try_into().unwrap();
+ }
+ }
+
+ if forward_idx < 0 {
+ skip_mode_allowed = false;
+ } else if backward_idx >= 0 {
+ skip_mode_allowed = true;
+ fh.skip_mode_frame[0] = ReferenceFrameType::Last as u32
+ + u32::try_from(std::cmp::min(forward_idx, backward_idx)).unwrap();
+ fh.skip_mode_frame[1] = ReferenceFrameType::Last as u32
+ + u32::try_from(std::cmp::max(forward_idx, backward_idx)).unwrap();
+ } else {
+ let mut second_forward_idx = -1;
+ let mut second_forward_hint = 0;
+ for i in 0..REFS_PER_FRAME {
+ let ref_hint = self.ref_info[fh.ref_frame_idx[i] as usize].ref_order_hint;
+ if helpers::get_relative_dist(
+ enable_order_hint,
+ order_hint_bits,
+ ref_hint.try_into().unwrap(),
+ forward_hint,
+ ) < 0
+ && (second_forward_idx < 0
+ || helpers::get_relative_dist(
+ enable_order_hint,
+ order_hint_bits,
+ ref_hint.try_into().unwrap(),
+ second_forward_hint,
+ ) > 0)
+ {
+ second_forward_idx = i32::try_from(i).unwrap();
+ second_forward_hint = ref_hint.try_into().unwrap();
+ }
+ }
+
+ if second_forward_idx < 0 {
+ skip_mode_allowed = false;
+ } else {
+ skip_mode_allowed = true;
+ fh.skip_mode_frame[0] = ReferenceFrameType::Last as u32
+ + u32::try_from(std::cmp::min(forward_idx, second_forward_idx)).unwrap();
+ fh.skip_mode_frame[1] = ReferenceFrameType::Last as u32
+ + u32::try_from(std::cmp::max(forward_idx, second_forward_idx)).unwrap();
+ }
+ }
+ }
+
+ if skip_mode_allowed {
+ fh.skip_mode_present = r.0.read_bit()?;
+ } else {
+ fh.skip_mode_present = false;
+ }
+
+ Ok(())
+ }
+
+ fn parse_frame_reference_mode(r: &mut Reader, fh: &mut FrameHeaderObu) -> Result<(), String> {
+ if fh.frame_is_intra {
+ fh.reference_select = false;
+ } else {
+ fh.reference_select = r.0.read_bit()?;
+ }
+ Ok(())
+ }
+
+ fn seg_feature_active_idx(seg: &SegmentationParams, idx: u32, feature: u32) -> bool {
+ seg.segmentation_enabled && seg.feature_enabled[idx as usize][feature as usize]
+ }
+
+ fn get_qindex(fh: &FrameHeaderObu, ignore_deltaq: bool, segment_id: u32) -> i32 {
+ let base_q_idx = i32::try_from(fh.quantization_params.base_q_idx).unwrap();
+ if Self::seg_feature_active_idx(&fh.segmentation_params, segment_id, SEG_LVL_ALT_Q as u32) {
+ let data = fh.segmentation_params.feature_data[segment_id as usize][SEG_LVL_ALT_Q];
+ let mut qindex = base_q_idx + i32::from(data);
+ if !ignore_deltaq && fh.quantization_params.delta_q_present {
+ qindex += i32::try_from(fh.quantization_params.delta_q_res).unwrap();
+ }
+ helpers::clip3(0, 255, qindex)
+ } else {
+ base_q_idx
+ }
+ }
+
+ fn setup_shear(warp_params: &[i32; 6]) -> Result {
+ let mut default = true;
+ for (i, param) in warp_params.iter().enumerate() {
+ let default_value = if i % 3 == 2 {
+ 1 << WARPEDMODEL_PREC_BITS
+ } else {
+ 0
+ };
+ if *param != default_value {
+ default = false;
+ break;
+ }
+ }
+
+ /* assume the default params to be valid */
+ if default {
+ return Ok(true);
+ }
+
+ let alpha0 = helpers::clip3(-32768, 32767, warp_params[2] - (1 << WARPEDMODEL_PREC_BITS));
+ let beta0 = helpers::clip3(-32768, 32767, warp_params[3]);
+
+ let (div_shift, div_factor) = helpers::resolve_divisor(warp_params[2])?;
+
+ let v = i64::from(warp_params[4] << WARPEDMODEL_PREC_BITS);
+ let v = (v * i64::from(div_factor)) as i32;
+ let gamma0 = helpers::clip3(-32678, 32767, helpers::round2signed(v, div_shift)?);
+
+ let w = warp_params[3] * warp_params[4];
+
+ let delta0 = helpers::clip3(
+ -32768,
+ 32767,
+ warp_params[5]
+ - helpers::round2signed(w * div_factor, div_shift)?
+ - (1 << WARPEDMODEL_PREC_BITS),
+ );
+
+ let alpha =
+ helpers::round2signed(alpha0, WARP_PARAM_REDUCE_BITS)? << WARP_PARAM_REDUCE_BITS;
+ let beta = helpers::round2signed(beta0, WARP_PARAM_REDUCE_BITS)? << WARP_PARAM_REDUCE_BITS;
+ let gamma =
+ helpers::round2signed(gamma0, WARP_PARAM_REDUCE_BITS)? << WARP_PARAM_REDUCE_BITS;
+ let delta =
+ helpers::round2signed(delta0, WARP_PARAM_REDUCE_BITS)? << WARP_PARAM_REDUCE_BITS;
+
+ #[allow(clippy::needless_bool)]
+ let warp_valid = if 4 * alpha.abs() + 7 * beta.abs() >= (1 << WARPEDMODEL_PREC_BITS)
+ || 4 * gamma.abs() + 4 * delta.abs() >= (1 << WARPEDMODEL_PREC_BITS)
+ {
+ false
+ } else {
+ true
+ };
+
+ Ok(warp_valid)
+ }
+
+ fn read_global_param(
+ reader: &mut Reader,
+ type_: WarpModelType,
+ ref_frame: usize,
+ idx: usize,
+ allow_high_precision_mv: bool,
+ prev_gm_params: &[[i32; 6]; NUM_REF_FRAMES],
+ gm_params: &mut [[i32; 6]; NUM_REF_FRAMES],
+ ) -> Result<(), String> {
+ let mut abs_bits = GM_ABS_ALPHA_BITS;
+ let mut prec_bits = GM_ALPHA_PREC_BITS;
+ if idx < 2 {
+ if type_ == WarpModelType::Translation {
+ abs_bits = GM_ABS_TRANS_ONLY_BITS - !allow_high_precision_mv as u32;
+ prec_bits = GM_TRANS_ONLY_PREC_BITS - !allow_high_precision_mv as u32;
+ } else {
+ abs_bits = GM_ABS_TRANS_BITS;
+ prec_bits = GM_TRANS_PREC_BITS;
+ }
+ }
+
+ let prec_diff = WARPEDMODEL_PREC_BITS - prec_bits;
+
+ let (round, sub) = if (idx % 3) == 2 {
+ (1 << WARPEDMODEL_PREC_BITS, 1 << prec_bits)
+ } else {
+ (0, 0)
+ };
+
+ let mx = 1 << abs_bits;
+ let r = (prev_gm_params[ref_frame][idx] >> prec_diff) - sub;
+ gm_params[ref_frame][idx] =
+ (reader.decode_signed_subexp_with_ref(-mx, mx + 1, r)? << prec_diff) + round;
+
+ Ok(())
+ }
+
+ fn parse_global_motion_params(
+ &mut self,
+ r: &mut Reader,
+ fh: &mut FrameHeaderObu,
+ ) -> Result<(), String> {
+ let gm = &mut fh.global_motion_params;
+ let mut type_;
+ let mut prev_gm_params: [[i32; 6]; NUM_REF_FRAMES] = Default::default();
+
+ for ref_frame in ReferenceFrameType::Last as usize..=ReferenceFrameType::AltRef as usize {
+ gm.gm_type[ref_frame] = WarpModelType::Identity;
+ for i in 0..6 {
+ gm.gm_params[ref_frame][i] = if i % 3 == 2 {
+ 1 << WARPEDMODEL_PREC_BITS
+ } else {
+ 0
+ }
+ }
+ gm.warp_valid[ref_frame] = true;
+ }
+
+ if fh.frame_is_intra {
+ return Ok(());
+ }
+
+ // Following libgav1: implement part of setup_past_independence() and
+ // load_previous(), i.e.: the parts that refer to the global motion
+ // parameters.
+ if fh.primary_ref_frame == PRIMARY_REF_NONE {
+ // setup_past_independence()
+ #[allow(clippy::needless_range_loop)]
+ for ref_frame in ReferenceFrameType::Last as usize..ReferenceFrameType::AltRef as usize
+ {
+ for i in 0..5 {
+ prev_gm_params[ref_frame][i] = if i % 3 == 2 {
+ 1 << WARPEDMODEL_PREC_BITS
+ } else {
+ 0
+ }
+ }
+ }
+ } else {
+ // load_previous():
+ // 1. The variable prevFrame is set equal to ref_frame_idx[ primary_ref_frame ].
+ // 2. PrevGmParams is set equal to SavedGmParams[ prevFrame ].
+ let prev_frame = fh.ref_frame_idx[fh.primary_ref_frame as usize];
+ prev_gm_params = self.ref_info[prev_frame as usize]
+ .global_motion_params
+ .gm_params;
+ }
+
+ for ref_frame in ReferenceFrameType::Last as usize..=ReferenceFrameType::AltRef as usize {
+ gm.is_global[ref_frame] = r.0.read_bit()?;
+ if gm.is_global[ref_frame] {
+ gm.is_rot_zoom[ref_frame] = r.0.read_bit()?;
+ if gm.is_rot_zoom[ref_frame] {
+ type_ = WarpModelType::RotZoom;
+ } else {
+ gm.is_translation[ref_frame] = r.0.read_bit()?;
+ if gm.is_translation[ref_frame] {
+ type_ = WarpModelType::Translation;
+ } else {
+ type_ = WarpModelType::Affine;
+ }
+ }
+ } else {
+ type_ = WarpModelType::Identity;
+ }
+
+ gm.gm_type[ref_frame] = type_;
+ if gm.gm_type[ref_frame] as u32 >= WarpModelType::RotZoom as u32 {
+ Self::read_global_param(
+ r,
+ type_,
+ ref_frame,
+ 2,
+ fh.allow_high_precision_mv,
+ &prev_gm_params,
+ &mut gm.gm_params,
+ )?;
+
+ Self::read_global_param(
+ r,
+ type_,
+ ref_frame,
+ 3,
+ fh.allow_high_precision_mv,
+ &prev_gm_params,
+ &mut gm.gm_params,
+ )?;
+
+ if type_ == WarpModelType::Affine {
+ Self::read_global_param(
+ r,
+ type_,
+ ref_frame,
+ 4,
+ fh.allow_high_precision_mv,
+ &prev_gm_params,
+ &mut gm.gm_params,
+ )?;
+
+ Self::read_global_param(
+ r,
+ type_,
+ ref_frame,
+ 5,
+ fh.allow_high_precision_mv,
+ &prev_gm_params,
+ &mut gm.gm_params,
+ )?;
+ } else {
+ gm.gm_params[ref_frame][4] = -gm.gm_params[ref_frame][3];
+ gm.gm_params[ref_frame][5] = gm.gm_params[ref_frame][2];
+ }
+ }
+
+ if gm.gm_type[ref_frame] as u32 >= WarpModelType::Translation as u32 {
+ Self::read_global_param(
+ r,
+ type_,
+ ref_frame,
+ 0,
+ fh.allow_high_precision_mv,
+ &prev_gm_params,
+ &mut gm.gm_params,
+ )?;
+
+ Self::read_global_param(
+ r,
+ type_,
+ ref_frame,
+ 1,
+ fh.allow_high_precision_mv,
+ &prev_gm_params,
+ &mut gm.gm_params,
+ )?;
+ }
+
+ gm.warp_valid[ref_frame] = Self::setup_shear(&gm.gm_params[ref_frame])?;
+ }
+
+ Ok(())
+ }
+
+ fn parse_film_grain_parameters(
+ &self,
+ r: &mut Reader,
+ fh: &mut FrameHeaderObu,
+ film_grain_params_present: bool,
+ mono_chrome: bool,
+ subsampling_x: bool,
+ subsampling_y: bool,
+ ) -> Result<(), String> {
+ let fg = &mut fh.film_grain_params;
+
+ if !film_grain_params_present || (!fh.show_frame && !fh.showable_frame) {
+ *fg = Default::default();
+ return Ok(());
+ }
+
+ fg.apply_grain = r.0.read_bit()?;
+ if !fg.apply_grain {
+ *fg = Default::default();
+ return Ok(());
+ }
+
+ fg.grain_seed = r.0.read_bits::(16)? as u16;
+ if fh.frame_type == FrameType::InterFrame {
+ fg.update_grain = r.0.read_bit()?;
+ } else {
+ fg.update_grain = true;
+ }
+
+ if !fg.update_grain {
+ fg.film_grain_params_ref_idx = r.0.read_bits::(3)? as u8;
+ let temp_grain_seed = fg.grain_seed;
+
+ if !fh
+ .ref_frame_idx
+ .iter()
+ .any(|&ref_frame_idx| ref_frame_idx == fg.film_grain_params_ref_idx)
+ {
+ return Err("Invalid film_grain_params_ref_idx".into());
+ }
+
+ // load_grain_params()
+ *fg = self.ref_info[fg.film_grain_params_ref_idx as usize]
+ .film_grain_params
+ .clone();
+
+ fg.grain_seed = temp_grain_seed;
+
+ return Ok(());
+ }
+
+ fg.num_y_points = r.0.read_bits::(4)? as u8;
+ fg.point_y_value
+ .iter_mut()
+ .zip(fg.point_y_scaling.iter_mut())
+ .take(fg.num_y_points as usize)
+ .try_for_each(|(point_y_value, point_y_scaling)| {
+ *point_y_value = r.0.read_bits::(8)? as u8;
+ *point_y_scaling = r.0.read_bits::(8)? as u8;
+ Ok::<_, String>(())
+ })?;
+
+ if mono_chrome {
+ fg.chroma_scaling_from_luma = false;
+ } else {
+ fg.chroma_scaling_from_luma = r.0.read_bit()?;
+ }
+
+ if mono_chrome
+ || fg.chroma_scaling_from_luma
+ || (subsampling_x && subsampling_y && fg.num_y_points == 0)
+ {
+ fg.num_cb_points = 0;
+ fg.num_cr_points = 0;
+ } else {
+ fg.num_cb_points = r.0.read_bits::(4)? as u8;
+ if fg.num_cb_points > 10 {
+ return Err(format!("Invalid num_cb_points {}", fg.num_cb_points));
+ }
+
+ for i in 0..fg.num_cb_points as usize {
+ fg.point_cb_value[i] = r.0.read_bits::(8)? as u8;
+ if i > 0 && fg.point_cb_value[i - 1] >= fg.point_cb_value[i] {
+ return Err(format!(
+ "Invalid point_cb_value[{}] {}",
+ i, fg.point_cb_value[i]
+ ));
+ }
+ fg.point_cb_scaling[i] = r.0.read_bits::(8)? as u8;
+ }
+
+ fg.num_cr_points = r.0.read_bits::(4)? as u8;
+ for i in 0..fg.num_cr_points as usize {
+ fg.point_cr_value[i] = r.0.read_bits::(8)? as u8;
+ if i > 0 && fg.point_cr_value[i - 1] >= fg.point_cr_value[i] {
+ return Err(format!(
+ "Invalid point_cr_value[{}] {}",
+ i, fg.point_cr_value[i]
+ ));
+ }
+ fg.point_cr_scaling[i] = r.0.read_bits::(8)? as u8;
+ }
+ }
+
+ fg.grain_scaling_minus_8 = r.0.read_bits::(2)? as u8;
+ fg.ar_coeff_lag = r.0.read_bits::(2)?;
+
+ let num_pos_luma = 2 * fg.ar_coeff_lag * (fg.ar_coeff_lag + 1);
+ let num_pos_chroma = if fg.num_y_points > 0 {
+ for i in 0..num_pos_luma as usize {
+ fg.ar_coeffs_y_plus_128[i] = r.0.read_bits::(8)? as u8;
+ }
+ num_pos_luma + 1
+ } else {
+ num_pos_luma
+ };
+
+ if fg.chroma_scaling_from_luma || fg.num_cb_points > 0 {
+ for i in 0..num_pos_chroma as usize {
+ fg.ar_coeffs_cb_plus_128[i] = r.0.read_bits::(8)? as u8;
+ }
+ }
+
+ if fg.chroma_scaling_from_luma || fg.num_cr_points > 0 {
+ for i in 0..num_pos_chroma as usize {
+ fg.ar_coeffs_cr_plus_128[i] = r.0.read_bits::(8)? as u8;
+ }
+ }
+
+ fg.ar_coeff_shift_minus_6 = r.0.read_bits::(2)? as u8;
+ fg.grain_scale_shift = r.0.read_bits::(2)? as u8;
+
+ if fg.num_cb_points > 0 {
+ fg.cb_mult = r.0.read_bits::(8)? as u8;
+ fg.cb_luma_mult = r.0.read_bits::(8)? as u8;
+ fg.cb_offset = r.0.read_bits::(9)? as u16;
+ }
+
+ if fg.num_cr_points > 0 {
+ fg.cr_mult = r.0.read_bits::(8)? as u8;
+ fg.cr_luma_mult = r.0.read_bits::(8)? as u8;
+ fg.cr_offset = r.0.read_bits::(9)? as u16;
+ }
+
+ fg.overlap_flag = r.0.read_bit()?;
+ fg.clip_to_restricted_range = r.0.read_bit()?;
+
+ Ok(())
+ }
+
+ fn sequence(&self) -> Result<&SequenceHeaderObu, String> {
+ let Some(seq) = self.sequence_header.as_ref() else {
+ return Err("No sequence header parsed yet".into());
+ };
+
+ Ok(seq)
+ }
+
+ fn parse_uncompressed_frame_header(&mut self, obu: &Obu) -> Result {
+ let mut r = Reader::new(obu.as_ref());
+
+ let mut fh = FrameHeaderObu {
+ obu_header: obu.header.clone(),
+ ..Default::default()
+ };
+
+ // Section 6.8.1: It is a requirement of bitstream conformance that a
+ // sequence header OBU has been received before a frame header OBU.
+ let &SequenceHeaderObu {
+ operating_points_cnt_minus_1,
+ seq_force_integer_mv,
+ additional_frame_id_length_minus_1,
+ delta_frame_id_length_minus_2,
+ decoder_model_info_present_flag,
+ reduced_still_picture_header,
+ frame_id_numbers_present_flag,
+ use_128x128_superblock,
+ enable_order_hint,
+ seq_force_screen_content_tools,
+ order_hint_bits,
+ enable_cdef,
+ enable_restoration,
+ enable_warped_motion,
+ color_config:
+ ColorConfig {
+ subsampling_x,
+ subsampling_y,
+ separate_uv_delta_q,
+ mono_chrome,
+ ..
+ },
+ timing_info:
+ TimingInfo {
+ equal_picture_interval,
+ ..
+ },
+ decoder_model_info:
+ DecoderModelInfo {
+ frame_presentation_time_length_minus_1,
+ buffer_removal_time_length_minus_1,
+ ..
+ },
+ num_planes,
+ film_grain_params_present,
+ ..
+ } = self.sequence()?;
+
+ let mut id_len = 0;
+
+ if frame_id_numbers_present_flag {
+ id_len = additional_frame_id_length_minus_1 + delta_frame_id_length_minus_2 + 3;
+ }
+
+ const ALL_FRAMES: u32 = (1 << NUM_REF_FRAMES) - 1;
+
+ if reduced_still_picture_header {
+ fh.show_existing_frame = false;
+ fh.frame_type = FrameType::KeyFrame;
+ fh.frame_is_intra = true;
+ fh.show_frame = true;
+ fh.showable_frame = false;
+ } else {
+ fh.show_existing_frame = r.0.read_bit()?;
+ if matches!(obu.header.obu_type, ObuType::Frame) && fh.show_existing_frame {
+ return Err("If obu_type is equal to OBU_FRAME, it is a requirement of bitstream conformance that show_existing_frame is equal to 0.".into());
+ }
+ if fh.show_existing_frame {
+ fh.frame_to_show_map_idx = r.0.read_bits::(3)? as u8;
+
+ if decoder_model_info_present_flag && !equal_picture_interval {
+ fh.frame_presentation_time =
+ r.0.read_bits::(frame_presentation_time_length_minus_1 as usize + 1)?;
+ }
+
+ let ref_frame = &self.ref_info[fh.frame_to_show_map_idx as usize];
+
+ fh.refresh_frame_flags = 0;
+ if frame_id_numbers_present_flag {
+ if id_len == 0 {
+ return Err(format!("Invalid id_len {}", id_len));
+ }
+ fh.display_frame_id = r.0.read_bits::(id_len.try_into().unwrap())?;
+ if ref_frame.display_frame_id != fh.display_frame_id || !ref_frame.ref_valid {
+ return Err("Invalid display_frame_id".into());
+ }
+ }
+
+ if !ref_frame.showable_frame {
+ return Err("Invalid bitstream: can't show this past frame".into());
+ }
+
+ // In decode_frame_wrapup():
+ //
+ // Otherwise (show_existing_frame is equal to 1), if frame_type
+ // is equal to KEY_FRAME, the reference frame loading process as
+ // specified in section 7.21 is invoked (this process loads
+ // frame state from the reference frames into the current frame
+ // state variables)
+ //
+ // The following ordered steps now apply:
+ //
+ // 1. The reference frame update process as specified in section
+ // 7.20 is invoked (this process saves the current frame state
+ // into the reference frames).
+ //
+ // 2. If show_frame is equal to 1 or show_existing_frame is
+ // equal to 1, the output process as specified in section 7.18
+ // is invoked (this will output the current frame or a saved
+ // frame).
+ //
+ // We implement 1. here while 2. is left to the actual decoder
+ self.load_reference_frame(&mut fh)?;
+ if fh.frame_type == FrameType::KeyFrame {
+ fh.refresh_frame_flags = ALL_FRAMES;
+ }
+
+ if film_grain_params_present {
+ // load_grain_params()
+ fh.film_grain_params = self.ref_info[fh.frame_to_show_map_idx as usize]
+ .film_grain_params
+ .clone();
+ }
+
+ // See 5.10.
+ if matches!(obu.header.obu_type, ObuType::Frame) {
+ r.byte_alignment()?;
+ }
+
+ fh.header_bytes = usize::try_from(r.0.position() / 8).unwrap();
+ return Ok(fh);
+ }
+
+ fh.frame_type = FrameType::try_from(r.0.read_bits::(2)?)?;
+ fh.frame_is_intra = matches!(
+ fh.frame_type,
+ FrameType::IntraOnlyFrame | FrameType::KeyFrame
+ );
+
+ fh.show_frame = r.0.read_bit()?;
+
+ if fh.show_frame && decoder_model_info_present_flag && equal_picture_interval {
+ fh.frame_presentation_time =
+ r.0.read_bits::(frame_presentation_time_length_minus_1 as usize + 1)?;
+ }
+
+ if fh.show_frame {
+ fh.showable_frame = !matches!(fh.frame_type, FrameType::KeyFrame);
+ } else {
+ fh.showable_frame = r.0.read_bit()?;
+ }
+
+ if fh.frame_type == FrameType::SwitchFrame
+ || (fh.frame_type == FrameType::KeyFrame && fh.show_frame)
+ {
+ fh.error_resilient_mode = true;
+ } else {
+ fh.error_resilient_mode = r.0.read_bit()?;
+ }
+ }
+
+ if fh.frame_type == FrameType::KeyFrame && fh.show_frame {
+ for i in 0..NUM_REF_FRAMES {
+ self.ref_info[i].ref_valid = false;
+ self.ref_info[i].ref_order_hint = 0;
+ }
+ for i in 0..REFS_PER_FRAME {
+ fh.order_hints[ReferenceFrameType::Last as usize + i] = 0;
+ }
+ }
+
+ fh.disable_cdf_update = r.0.read_bit()?;
+ if seq_force_screen_content_tools == SELECT_SCREEN_CONTENT_TOOLS as u32 {
+ fh.allow_screen_content_tools = r.0.read_bit()? as u32;
+ } else {
+ fh.allow_screen_content_tools = seq_force_screen_content_tools;
+ }
+
+ if fh.allow_screen_content_tools > 0 {
+ if seq_force_integer_mv == SELECT_INTEGER_MV as u32 {
+ fh.force_integer_mv = r.0.read_bit()? as u32;
+ } else {
+ fh.force_integer_mv = seq_force_integer_mv;
+ }
+ } else {
+ fh.force_integer_mv = 0;
+ }
+
+ if fh.frame_is_intra {
+ fh.force_integer_mv = 1;
+ }
+
+ if frame_id_numbers_present_flag {
+ self.prev_frame_id = self.current_frame_id;
+ self.current_frame_id = r.0.read_bits::(id_len.try_into().unwrap())?;
+ fh.current_frame_id = self.current_frame_id;
+
+ /* conformance checking, as per aom */
+ let have_prev_frame_id =
+ !(self.is_first_frame || fh.frame_type == FrameType::KeyFrame && fh.show_frame);
+
+ if have_prev_frame_id {
+ let frame_id_length =
+ additional_frame_id_length_minus_1 + delta_frame_id_length_minus_2 + 3;
+
+ let diff_frame_id = if self.current_frame_id > self.prev_frame_id {
+ self.current_frame_id - self.prev_frame_id
+ } else {
+ if frame_id_length > 16 {
+ return Err(format!("Invalid frame_id_length {}", frame_id_length));
+ }
+ (1 << frame_id_length) + self.current_frame_id - self.prev_frame_id
+ };
+
+ if self.prev_frame_id == self.current_frame_id
+ || diff_frame_id >= (1 << (frame_id_length - 1))
+ {
+ return Err(format!(
+ "Invalid frame_id: prev_frame_id = {}, current_frame_id = {}",
+ self.prev_frame_id, self.current_frame_id
+ ));
+ }
+ }
+
+ /* mark_ref_frames (idLen) */
+ let diff_len = delta_frame_id_length_minus_2 + 2;
+ let shifted_diff_len = 1 << diff_len;
+ let shifted_id_len = 1 << id_len;
+
+ for i in 0..NUM_REF_FRAMES {
+ if self.current_frame_id > shifted_diff_len {
+ if self.ref_info[i].ref_frame_id > self.current_frame_id
+ || self.ref_info[i].ref_frame_id
+ < (self.current_frame_id - shifted_diff_len)
+ {
+ self.ref_info[i].ref_valid = false;
+ }
+ } else if self.ref_info[i].ref_frame_id > self.current_frame_id
+ && self.ref_info[i].ref_frame_id
+ < shifted_id_len + self.current_frame_id - shifted_diff_len
+ {
+ self.ref_info[i].ref_valid = false;
+ }
+ }
+ } else {
+ self.current_frame_id = 0;
+ self.prev_frame_id = self.current_frame_id;
+ fh.current_frame_id = self.current_frame_id;
+ }
+
+ if fh.frame_type == FrameType::SwitchFrame {
+ fh.frame_size_override_flag = true;
+ } else if reduced_still_picture_header {
+ fh.frame_size_override_flag = false;
+ } else {
+ fh.frame_size_override_flag = r.0.read_bit()?;
+ }
+
+ fh.order_hint = r.0.read_bits::(order_hint_bits.try_into().unwrap())?;
+
+ if fh.frame_is_intra || fh.error_resilient_mode {
+ fh.primary_ref_frame = PRIMARY_REF_NONE;
+ } else {
+ fh.primary_ref_frame = r.0.read_bits::(3)?;
+ }
+
+ let operating_points = &self.sequence()?.operating_points;
+ if decoder_model_info_present_flag {
+ fh.buffer_removal_time_present_flag = r.0.read_bit()?;
+ if fh.buffer_removal_time_present_flag {
+ #[allow(clippy::needless_range_loop)]
+ for op_num in 0..=operating_points_cnt_minus_1 as usize {
+ if operating_points[op_num].decoder_model_present_for_this_op {
+ let op_pt_idc = operating_points[op_num].idc;
+ let in_temporal_layer = (op_pt_idc >> fh.obu_header.temporal_id) & 1 != 0;
+ let in_spatial_layer =
+ (op_pt_idc >> (fh.obu_header.spatial_id + 8)) & 1 != 0;
+
+ if op_pt_idc == 0 || (in_temporal_layer && in_spatial_layer) {
+ let n = buffer_removal_time_length_minus_1 + 1;
+ fh.buffer_removal_time[op_num] = r.0.read_bits::(n as usize)?;
+ }
+ }
+ }
+ }
+ }
+
+ fh.allow_high_precision_mv = false;
+ fh.use_ref_frame_mvs = false;
+ fh.allow_intrabc = false;
+ if fh.frame_type == FrameType::SwitchFrame
+ || (fh.frame_type == FrameType::KeyFrame && fh.show_frame)
+ {
+ fh.refresh_frame_flags = ALL_FRAMES;
+ } else {
+ fh.refresh_frame_flags = r.0.read_bits::(8)?;
+ }
+
+ /* equivalent boolean expression */
+ if (!fh.frame_is_intra || fh.refresh_frame_flags != ALL_FRAMES)
+ && fh.error_resilient_mode
+ && enable_order_hint
+ {
+ for i in 0..NUM_REF_FRAMES {
+ fh.ref_order_hint[i] = r.0.read_bits::(order_hint_bits.try_into().unwrap())?;
+ if fh.ref_order_hint[i] != self.ref_info[i].ref_order_hint {
+ self.ref_info[i].ref_valid = false;
+ }
+ }
+ }
+
+ if fh.frame_is_intra {
+ self.parse_frame_size(&mut fh, &mut r)?;
+ Self::parse_render_size(&mut fh, &mut r)?;
+ if fh.allow_screen_content_tools > 0 && fh.upscaled_width == fh.frame_width {
+ fh.allow_intrabc = r.0.read_bit()?;
+ }
+ } else {
+ if !enable_order_hint {
+ fh.frame_refs_short_signaling = false;
+ } else {
+ fh.frame_refs_short_signaling = r.0.read_bit()?;
+ if fh.frame_refs_short_signaling {
+ fh.last_frame_idx = r.0.read_bits::(3)? as u8;
+ fh.gold_frame_idx = r.0.read_bits::(3)? as u8;
+ let ref_order_hints = self
+ .ref_info
+ .iter()
+ .map(|i| i.ref_order_hint)
+ .collect::>()
+ .try_into()
+ .unwrap();
+ self.set_frame_refs(&mut fh, &ref_order_hints)?;
+ }
+ }
+
+ let mut expected_frame_id = [0; REFS_PER_FRAME];
+ #[allow(clippy::needless_range_loop)]
+ for i in 0..REFS_PER_FRAME {
+ if !fh.frame_refs_short_signaling {
+ fh.ref_frame_idx[i] = r.0.read_bits::(3)?.try_into().unwrap();
+ }
+
+ if frame_id_numbers_present_flag {
+ /* DeltaFrameId */
+ let delta_frame_id =
+ r.0.read_bits::(delta_frame_id_length_minus_2 as usize + 2)? + 1;
+
+ if id_len == 0 {
+ return Err(format!("Invalid id_len {}", id_len));
+ }
+
+ let shifted_id_len = 1 << id_len;
+
+ expected_frame_id[i] =
+ (self.current_frame_id + shifted_id_len - delta_frame_id) % shifted_id_len;
+
+ let actual_frame_id = self.ref_info[fh.ref_frame_idx[i] as usize].ref_frame_id;
+
+ if expected_frame_id[i] != actual_frame_id {
+ return Err(format!(
+ "Invalid frame id, expected {} got {}",
+ expected_frame_id[i], actual_frame_id
+ ));
+ }
+ }
+ }
+
+ if fh.frame_size_override_flag && !fh.error_resilient_mode {
+ self.frame_size_with_refs(&mut fh, &mut r)?;
+ } else {
+ self.parse_frame_size(&mut fh, &mut r)?;
+ Self::parse_render_size(&mut fh, &mut r)?;
+ }
+
+ if fh.force_integer_mv > 0 {
+ fh.allow_high_precision_mv = false;
+ } else {
+ fh.allow_high_precision_mv = r.0.read_bit()?;
+ }
+
+ /* read_interpolation_filter */
+ fh.is_filter_switchable = r.0.read_bit()?;
+ if fh.is_filter_switchable {
+ fh.interpolation_filter = InterpolationFilter::Switchable;
+ } else {
+ fh.interpolation_filter = InterpolationFilter::try_from(r.0.read_bits::(2)?)?;
+ }
+
+ fh.is_motion_mode_switchable = r.0.read_bit()?;
+
+ if fh.error_resilient_mode || !self.sequence()?.enable_ref_frame_mvs {
+ fh.use_ref_frame_mvs = false;
+ } else {
+ fh.use_ref_frame_mvs = r.0.read_bit()?;
+ }
+
+ for i in 0..REFS_PER_FRAME {
+ let ref_frame = ReferenceFrameType::Last as usize + i;
+ let hint = self.ref_info[fh.ref_frame_idx[i] as usize].ref_order_hint;
+ fh.order_hints[ref_frame] = hint;
+
+ if !enable_order_hint {
+ fh.ref_frame_sign_bias[i] = false;
+ } else {
+ fh.ref_frame_sign_bias[i] = helpers::get_relative_dist(
+ enable_order_hint,
+ order_hint_bits,
+ hint.try_into().unwrap(),
+ fh.order_hint.try_into().unwrap(),
+ ) > 0;
+ }
+ }
+ }
+
+ if reduced_still_picture_header || fh.disable_cdf_update {
+ fh.disable_frame_end_update_cdf = true;
+ } else {
+ fh.disable_frame_end_update_cdf = r.0.read_bit()?;
+ }
+
+ if fh.primary_ref_frame == PRIMARY_REF_NONE {
+ Self::setup_past_independence(&mut fh);
+ } else {
+ /* load from the past reference */
+ let prev_frame =
+ &self.ref_info[fh.ref_frame_idx[fh.primary_ref_frame as usize] as usize];
+
+ if !prev_frame.ref_valid {
+ return Err("Reference is invalid".into());
+ }
+
+ /* load_loop_filter_params: load ref_deltas and mode_deltas */
+ fh.loop_filter_params.loop_filter_ref_deltas =
+ prev_frame.loop_filter_params.loop_filter_ref_deltas;
+ fh.loop_filter_params.loop_filter_mode_deltas =
+ prev_frame.loop_filter_params.loop_filter_mode_deltas;
+
+ /* load_segmentation_params: load feature_enabled and feature_data */
+ fh.segmentation_params.feature_enabled = prev_frame.segmentation_params.feature_enabled;
+ fh.segmentation_params.feature_data = prev_frame.segmentation_params.feature_data;
+ }
+
+ // TODO: we can live without this for now.
+ // if fh.use_ref_frame_mvs {
+ // // motion_field_estimators()
+ // }
+
+ self.parse_tile_info(&mut r, &mut fh.tile_info)?;
+ Self::parse_quantization_params(
+ &mut r,
+ &mut fh.quantization_params,
+ num_planes,
+ separate_uv_delta_q,
+ )?;
+ self.parse_segmentation_params(&mut r, &mut fh)?;
+ Self::parse_delta_q_params(&mut r, &mut fh.quantization_params)?;
+ Self::parse_delta_lf_params(
+ &mut r,
+ &mut fh.loop_filter_params,
+ fh.quantization_params.delta_q_present,
+ fh.allow_intrabc,
+ )?;
+
+ fh.coded_lossless = true;
+ for segment_id in 0..MAX_SEGMENTS {
+ let q_index = Self::get_qindex(&fh, true, segment_id as _);
+ let q = &fh.quantization_params;
+ fh.lossless_array[segment_id] = q_index == 0
+ && q.delta_q_y_dc == 0
+ && q.delta_q_u_ac == 0
+ && q.delta_q_u_dc == 0
+ && q.delta_q_v_ac == 0
+ && q.delta_q_v_dc == 0;
+ if !fh.lossless_array[segment_id] {
+ fh.coded_lossless = false;
+ }
+ if q.using_qmatrix {
+ if fh.lossless_array[segment_id] {
+ fh.seg_qm_level[0][segment_id] = 15;
+ fh.seg_qm_level[1][segment_id] = 15;
+ fh.seg_qm_level[2][segment_id] = 15;
+ } else {
+ fh.seg_qm_level[0][segment_id] = q.qm_y;
+ fh.seg_qm_level[1][segment_id] = q.qm_u;
+ fh.seg_qm_level[2][segment_id] = q.qm_v;
+ }
+ }
+ }
+
+ fh.all_lossless = fh.coded_lossless && fh.frame_width == fh.upscaled_width;
+ Self::parse_loop_filter_parameters(&mut r, &mut fh, num_planes)?;
+ Self::parse_cdef_params(&mut r, &mut fh, enable_cdef, num_planes)?;
+ Self::parse_loop_restoration_params(
+ &mut r,
+ &mut fh,
+ enable_restoration,
+ num_planes,
+ use_128x128_superblock,
+ subsampling_x,
+ subsampling_y,
+ )?;
+ Self::read_tx_mode(&mut r, &mut fh)?;
+ Self::parse_frame_reference_mode(&mut r, &mut fh)?;
+ self.parse_skip_mode_params(&mut r, &mut fh, enable_order_hint, order_hint_bits)?;
+
+ if fh.frame_is_intra || fh.error_resilient_mode || !enable_warped_motion {
+ fh.allow_warped_motion = false;
+ } else {
+ fh.allow_warped_motion = r.0.read_bit()?;
+ }
+
+ fh.reduced_tx_set = r.0.read_bit()?;
+ self.parse_global_motion_params(&mut r, &mut fh)?;
+ self.parse_film_grain_parameters(
+ &mut r,
+ &mut fh,
+ film_grain_params_present,
+ mono_chrome,
+ subsampling_x,
+ subsampling_y,
+ )?;
+
+ Self::skip_and_check_trailing_bits(&mut r, obu)?;
+
+ // See 5.10
+ if matches!(obu.header.obu_type, ObuType::Frame) {
+ r.byte_alignment()?;
+ }
+
+ fh.header_bytes = usize::try_from(r.0.position() / 8).unwrap();
+ Ok(fh)
+ }
+
+ fn parse_tile_group_obu<'a>(&mut self, obu: Obu<'a>) -> Result, String> {
+ let mut tg = TileGroupObu {
+ obu,
+ ..Default::default()
+ };
+
+ let mut r = Reader::new(tg.obu.as_ref());
+
+ if r.0.num_bits_left() % 8 != 0 {
+ return Err("Bitstream is not byte aligned".into());
+ }
+
+ let mut sz: u64 = r.0.num_bits_left() as u64 / 8;
+
+ let num_tiles = self.tile_rows * self.tile_cols;
+ let start_bit_pos = r.0.position();
+
+ if num_tiles > 1 {
+ tg.tile_start_and_end_present_flag = r.0.read_bit()?;
+ }
+
+ if num_tiles == 1 || !tg.tile_start_and_end_present_flag {
+ tg.tg_start = 0;
+ tg.tg_end = num_tiles - 1;
+ } else {
+ let tile_bits = (self.tile_cols_log2 + self.tile_rows_log2) as usize;
+ tg.tg_start = r.0.read_bits::(tile_bits)?;
+ tg.tg_end = r.0.read_bits::(tile_bits)?;
+ }
+
+ r.byte_alignment()?;
+
+ let end_bit_pos = r.0.position();
+ let header_bytes = (end_bit_pos - start_bit_pos) / 8;
+ sz -= header_bytes;
+
+ let mut tile_num = tg.tg_start;
+ while tile_num <= tg.tg_end {
+ let tile_row = tile_num / self.tile_cols;
+ let tile_col = tile_num % self.tile_cols;
+ let last_tile = tile_num == tg.tg_end;
+ let tile_size;
+
+ if last_tile {
+ tile_size = u32::try_from(sz).unwrap();
+ } else {
+ tile_size =
+ r.0.read_le::(self.tile_size_bytes.try_into().unwrap())? + 1;
+ sz -= u64::from(tile_size + self.tile_size_bytes);
+ }
+
+ let tile = Tile {
+ tile_offset: u32::try_from(r.0.position()).unwrap() / 8,
+ tile_size,
+ tile_row,
+ tile_col,
+ mi_row_start: self.mi_row_starts[tile_row as usize],
+ mi_row_end: self.mi_row_starts[tile_row as usize + 1],
+ mi_col_start: self.mi_row_starts[tile_col as usize],
+ mi_col_end: self.mi_row_starts[tile_col as usize + 1],
+ };
+
+ tg.tiles.push(tile);
+
+ // init_symbol, decode_tile() and exit_symbol() left to the accelerator.
+
+ // Skip the actual tile data
+ if tile_num < tg.tg_end {
+ r.0.skip_bits(tile_size as usize * 8)?;
+ }
+
+ tile_num += 1;
+ }
+
+ if tg.tg_end == num_tiles - 1 {
+ // left to the accelerator:
+ // if ( !disable_frame_end_update_cdf ) {
+ // frame_end_update_cdf( )
+ // }
+ // decode_frame_wrapup( )
+ self.seen_frame_header = false;
+ }
+
+ Ok(tg)
+ }
+
+ fn parse_frame_obu<'a>(&mut self, obu: Obu<'a>) -> Result, String> {
+ if !matches!(obu.header.obu_type, ObuType::Frame) {
+ return Err(format!(
+ "Expected a FrameOBU, got {:?}",
+ obu.header.obu_type
+ ));
+ }
+
+ let frame_header_obu = self.parse_frame_header_obu(&obu)?;
+ let obu = Obu {
+ header: obu.header,
+ data: match obu.data {
+ Cow::Borrowed(d) => Cow::Borrowed(&d[frame_header_obu.header_bytes..]),
+ Cow::Owned(d) => Cow::Owned(d[frame_header_obu.header_bytes..].to_owned()),
+ },
+ bytes_used: obu.bytes_used,
+ };
+ let tile_group_obu = self.parse_tile_group_obu(obu)?;
+
+ Ok(FrameObu {
+ header: frame_header_obu,
+ tile_group: tile_group_obu,
+ })
+ }
+
+ pub fn parse_frame_header_obu(&mut self, obu: &Obu) -> Result {
+ if !matches!(obu.header.obu_type, ObuType::FrameHeader | ObuType::Frame) {
+ return Err(format!(
+ "Expected a FrameHeaderOBU, got {:?}",
+ obu.header.obu_type
+ ));
+ }
+
+ if self.seen_frame_header {
+ Ok(self
+ .last_frame_header
+ .clone()
+ .take()
+ .ok_or::("Broken stream: no previous frame header to copy".into())?)
+ } else {
+ self.seen_frame_header = true;
+ let header = self.parse_uncompressed_frame_header(obu)?;
+ if header.show_existing_frame {
+ self.last_frame_header = None;
+ self.seen_frame_header = false;
+ } else {
+ /* TileNum = 0 */
+ self.seen_frame_header = true;
+ self.last_frame_header = Some(header.clone());
+ }
+
+ Ok(header)
+ }
+ }
+
+ /// Implements 7.20. This function should be called right after decoding a
+ /// frame.
+ pub fn ref_frame_update(&mut self, fh: &FrameHeaderObu) -> Result<(), String> {
+ // This was found as a bug otherwise by Nicolas Dufresne in GStreamer's
+ // av1parse.
+ if fh.show_existing_frame && !matches!(fh.frame_type, FrameType::KeyFrame) {
+ return Ok(());
+ }
+
+ if matches!(fh.frame_type, FrameType::IntraOnlyFrame) && fh.refresh_frame_flags == 0xff {
+ return Err("Intra-only frames cannot refresh all of the DPB as per the spec.".into());
+ }
+
+ let &SequenceHeaderObu {
+ color_config:
+ ColorConfig {
+ subsampling_x,
+ subsampling_y,
+ ..
+ },
+ film_grain_params_present,
+ bit_depth,
+ ..
+ } = self.sequence()?;
+
+ for (i, ref_info) in self.ref_info.iter_mut().enumerate() {
+ if ((fh.refresh_frame_flags >> i) & 1) != 0 {
+ ref_info.ref_valid = true;
+
+ ref_info.ref_frame_id = fh.current_frame_id;
+ ref_info.ref_frame_type = fh.frame_type;
+ ref_info.ref_upscaled_width = fh.upscaled_width;
+ ref_info.ref_frame_width = fh.frame_width;
+ ref_info.ref_frame_height = fh.frame_height;
+ ref_info.ref_render_width = fh.render_width;
+ ref_info.ref_render_height = fh.render_height;
+ ref_info.ref_order_hint = fh.order_hint;
+ ref_info.ref_mi_cols = self.mi_cols;
+ ref_info.ref_mi_rows = self.mi_rows;
+ ref_info.ref_subsampling_x = subsampling_x;
+ ref_info.ref_subsampling_y = subsampling_y;
+ ref_info.ref_bit_depth = bit_depth;
+ ref_info.segmentation_params = fh.segmentation_params.clone();
+ ref_info.global_motion_params = fh.global_motion_params.clone();
+ ref_info.loop_filter_params = fh.loop_filter_params.clone();
+ ref_info.tile_info = fh.tile_info.clone();
+ ref_info.display_frame_id = fh.display_frame_id;
+ ref_info.showable_frame = fh.showable_frame;
+
+ if film_grain_params_present {
+ ref_info.film_grain_params = fh.film_grain_params.clone();
+ }
+ }
+ }
+
+ Ok(())
+ }
+
+ pub fn highest_operating_point(&self) -> Option {
+ if self.operating_point_idc == 0 {
+ /* No scalability information, all OBUs must be decoded */
+ None
+ } else {
+ Some(helpers::floor_log2((self.operating_point_idc >> 8) as u32))
+ }
+ }
+
+ /// Fully parse an OBU.
+ pub fn parse_obu<'a>(&mut self, obu: Obu<'a>) -> Result, String> {
+ match obu.header.obu_type {
+ ObuType::Reserved => Ok(ParsedObu::Reserved),
+ ObuType::SequenceHeader => self
+ .parse_sequence_header_obu(&obu)
+ .map(ParsedObu::SequenceHeader),
+ ObuType::TemporalDelimiter => self
+ .parse_temporal_delimiter_obu()
+ .map(|_| ParsedObu::TemporalDelimiter),
+ ObuType::FrameHeader => self
+ .parse_frame_header_obu(&obu)
+ .map(ParsedObu::FrameHeader),
+ ObuType::TileGroup => self.parse_tile_group_obu(obu).map(ParsedObu::TileGroup),
+ ObuType::Metadata => Ok(ParsedObu::Metadata),
+ ObuType::Frame => self.parse_frame_obu(obu).map(ParsedObu::Frame),
+ ObuType::RedundantFrameHeader => Ok(ParsedObu::RedundantFrameHeader),
+ ObuType::TileList => Ok(ParsedObu::TileList),
+ ObuType::Reserved2 => Ok(ParsedObu::Reserved2),
+ ObuType::Reserved3 => Ok(ParsedObu::Reserved3),
+ ObuType::Reserved4 => Ok(ParsedObu::Reserved4),
+ ObuType::Reserved5 => Ok(ParsedObu::Reserved5),
+ ObuType::Reserved6 => Ok(ParsedObu::Reserved6),
+ ObuType::Reserved7 => Ok(ParsedObu::Reserved7),
+ ObuType::Padding => Ok(ParsedObu::Padding),
+ }
+ }
+}
+
+impl Default for Parser {
+ fn default() -> Self {
+ Self {
+ stream_format: StreamFormat::LowOverhead,
+ operating_point: Default::default(),
+ seen_frame_header: Default::default(),
+ last_frame_header: Default::default(),
+ operating_point_idc: Default::default(),
+ should_probe_for_annexb: true,
+ is_first_frame: Default::default(),
+ mi_cols: Default::default(),
+ mi_rows: Default::default(),
+ prev_frame_id: Default::default(),
+ current_frame_id: Default::default(),
+ ref_info: Default::default(),
+ mi_col_starts: [0; MAX_TILE_COLS + 1],
+ mi_row_starts: [0; MAX_TILE_ROWS + 1],
+ tile_cols_log2: Default::default(),
+ tile_cols: Default::default(),
+ tile_rows_log2: Default::default(),
+ tile_rows: Default::default(),
+ tile_size_bytes: Default::default(),
+ sequence_header: Default::default(),
+ }
+ }
+}
+
+impl Clone for Parser {
+ fn clone(&self) -> Self {
+ let sequence_header = self
+ .sequence_header
+ .as_ref()
+ .map(|s| Rc::new((**s).clone()));
+
+ Self {
+ stream_format: self.stream_format.clone(),
+ operating_point: self.operating_point,
+ seen_frame_header: self.seen_frame_header,
+ last_frame_header: self.last_frame_header.clone(),
+ operating_point_idc: self.operating_point_idc,
+ should_probe_for_annexb: self.should_probe_for_annexb,
+ is_first_frame: self.is_first_frame,
+ ref_info: self.ref_info.clone(),
+ mi_cols: self.mi_cols,
+ mi_rows: self.mi_rows,
+ prev_frame_id: self.prev_frame_id,
+ current_frame_id: self.current_frame_id,
+ mi_col_starts: self.mi_col_starts,
+ mi_row_starts: self.mi_row_starts,
+ tile_cols_log2: self.tile_cols_log2,
+ tile_cols: self.tile_cols,
+ tile_rows_log2: self.tile_rows_log2,
+ tile_rows: self.tile_rows,
+ tile_size_bytes: self.tile_size_bytes,
+ sequence_header,
+ }
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use crate::bitstream_utils::IvfIterator;
+ use crate::codec::av1::parser::{ObuAction, Parser, StreamFormat};
+
+ use super::ObuType;
+
+ /// Same as test-25fps.av1.ivf from Chromium
+ const STREAM_TEST_25_FPS: &[u8] = include_bytes!("test_data/test-25fps.ivf.av1");
+
+ /// Encoded with
+ ///
+ /// gst-launch-1.0 videotestsrc num-buffers=1 !
+ /// video/x-raw,format=I420,width=64,height=64 ! filesink
+ /// location=aom_input.yuv
+ ///
+ /// And:
+ ///
+ /// aomenc -p 1 --ivf -w 64 -h 64 -o av1-annexb.ivf.av1 aom_input.yuv --annexb=1
+ const STREAM_ANNEXB: &[u8] = include_bytes!("test_data/av1-annexb.ivf.av1");
+
+ #[test]
+ fn parse_test25fps() {
+ let mut parser = Parser::default();
+ let ivf_iter = IvfIterator::new(STREAM_TEST_25_FPS);
+ let mut num_obus = 0;
+
+ for packet in ivf_iter {
+ let mut consumed = 0;
+
+ while let Ok(obu) = parser.read_obu(&packet[consumed..]) {
+ let obu = match obu {
+ ObuAction::Process(obu) => obu,
+ // This OBU should be dropped.
+ ObuAction::Drop(length) => {
+ consumed += usize::try_from(length).unwrap();
+ continue;
+ }
+ };
+ consumed += obu.bytes_used;
+ num_obus += 1;
+ }
+ }
+
+ // Manually checked with GStreamer under GDB by using a hitcount on
+ // "gst_av1_parse_identify_one_obu" *after* the stream format has been
+ // detected.
+ assert_eq!(num_obus, 525);
+ }
+
+ #[test]
+ /// Test that we can correctly identify streams in both "low-overhead" and
+ /// Annex B formats.
+ fn parse_annexb() {
+ let mut parser = Parser::default();
+ let mut ivf_iter = IvfIterator::new(STREAM_TEST_25_FPS);
+ let packet = ivf_iter.next().unwrap();
+
+ parser.read_obu(packet).unwrap();
+ assert!(matches!(parser.stream_format, StreamFormat::LowOverhead));
+
+ let mut parser = Parser::default();
+ let mut ivf_iter = IvfIterator::new(STREAM_ANNEXB);
+ let packet = ivf_iter.next().unwrap();
+
+ parser.read_obu(packet).unwrap();
+ assert!(matches!(parser.stream_format, StreamFormat::AnnexB { .. }));
+ }
+
+ #[test]
+ /// Test that we can correctly identify streams in both "low-overhead" and
+ /// Annex B formats and identify all the OBUs in the stream until the end.
+ fn parse_annexb_full() {
+ let mut parser = Parser::default();
+ let ivf_iter = IvfIterator::new(STREAM_TEST_25_FPS);
+
+ for packet in ivf_iter {
+ let mut consumed = 0;
+
+ while let Ok(obu) = parser.read_obu(&packet[consumed..]) {
+ let obu = match obu {
+ ObuAction::Process(obu) => obu,
+ // This OBU should be dropped.
+ ObuAction::Drop(length) => {
+ consumed += usize::try_from(length).unwrap();
+ continue;
+ }
+ };
+ assert!(matches!(parser.stream_format, StreamFormat::LowOverhead));
+ consumed += obu.bytes_used;
+ }
+ }
+
+ let mut parser = Parser::default();
+ let ivf_iter = IvfIterator::new(STREAM_ANNEXB);
+ let mut num_obus = 0;
+
+ for packet in ivf_iter {
+ let mut consumed = 0;
+
+ while let Ok(obu) = parser.read_obu(&packet[consumed..]) {
+ let obu = match obu {
+ ObuAction::Process(obu) => obu,
+ // This OBU should be dropped.
+ ObuAction::Drop(length) => {
+ consumed += usize::try_from(length).unwrap();
+ continue;
+ }
+ };
+ assert!(matches!(parser.stream_format, StreamFormat::AnnexB { .. }));
+ consumed += obu.bytes_used;
+ num_obus += 1;
+ }
+ }
+
+ assert_eq!(num_obus, 3);
+ let annexb_state = match parser.stream_format {
+ StreamFormat::AnnexB(annexb_state) => annexb_state,
+ _ => panic!("Wrong StreamFormat, expected AnnexB"),
+ };
+ assert_eq!(
+ annexb_state.temporal_unit_consumed,
+ annexb_state.temporal_unit_size
+ );
+ assert_eq!(
+ annexb_state.frame_unit_consumed,
+ annexb_state.frame_unit_size
+ );
+ }
+
+ #[test]
+ fn parse_test25fps_obus() {
+ let mut parser = Parser::default();
+ let ivf_iter = IvfIterator::new(STREAM_TEST_25_FPS);
+
+ for packet in ivf_iter {
+ let mut consumed = 0;
+
+ while let Ok(obu) = parser.read_obu(&packet[consumed..]) {
+ let obu = match obu {
+ ObuAction::Process(obu) => obu,
+ // This OBU should be dropped.
+ ObuAction::Drop(length) => {
+ consumed += usize::try_from(length).unwrap();
+ continue;
+ }
+ };
+
+ let data_len = obu.bytes_used;
+
+ match obu.header.obu_type {
+ ObuType::SequenceHeader => {
+ parser.parse_sequence_header_obu(&obu).unwrap();
+ }
+ ObuType::FrameHeader | ObuType::RedundantFrameHeader => {
+ let fh = parser.parse_frame_header_obu(&obu).unwrap();
+ parser.ref_frame_update(&fh).unwrap();
+ }
+ ObuType::TileGroup => {
+ parser.parse_tile_group_obu(obu).unwrap();
+ }
+ ObuType::Frame => {
+ let frame = parser.parse_frame_obu(obu).unwrap();
+ parser.ref_frame_update(&frame.header).unwrap();
+ }
+ _ => {}
+ };
+
+ consumed += data_len;
+ }
+ }
+ }
+}
diff --git a/crates/pf-bitstream/vendor/cros-codecs/src/codec/av1/reader.rs b/crates/pf-bitstream/vendor/cros-codecs/src/codec/av1/reader.rs
new file mode 100644
index 00000000..7daccfab
--- /dev/null
+++ b/crates/pf-bitstream/vendor/cros-codecs/src/codec/av1/reader.rs
@@ -0,0 +1,251 @@
+// Copyright 2023 The ChromiumOS Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+use crate::bitstream_utils::BitReader;
+
+use crate::codec::av1::helpers;
+
+use super::parser::AnnexBState;
+
+pub(crate) struct Reader<'a>(pub BitReader<'a>);
+
+impl<'a> Reader<'a> {
+ pub fn new(data: &'a [u8]) -> Self {
+ Self(BitReader::new(data, false))
+ }
+
+ /// Implements uvlc(): Variable length unsigned n-bit number appearing
+ /// directly in the bitstream. See 4.10.3
+ pub fn read_uvlc(&mut self) -> Result {
+ let mut leading_zeroes = 0;
+ loop {
+ let done = self.0.read_bit()?;
+
+ if done {
+ break;
+ }
+
+ leading_zeroes += 1;
+ }
+
+ if leading_zeroes >= 32 {
+ return Ok(u32::MAX);
+ }
+
+ let value = self.0.read_bits::(leading_zeroes)?;
+ Ok(value + (1 << leading_zeroes) - 1)
+ }
+
+ /// Implements leb128(): Unsigned integer represented by a variable number
+ /// of little-endian bytes. See 4.10.5
+ pub fn read_leb128(&mut self) -> Result {
+ let mut value = 0u64;
+
+ for i in 0..8 {
+ let byte = u64::from(self.0.read_bits_aligned::(8)?);
+ value |= (byte & 0x7f) << (i * 7);
+
+ if byte & 0x80 == 0 {
+ break;
+ }
+ }
+
+ Ok(value as u32)
+ }
+
+ /// Implements su(n): Signed integer converted from an n bits unsigned
+ /// integer in the bitstream. (The unsigned integer corresponds to the
+ /// bottom n bits of the signed integer.). See 4.10.6
+ pub fn read_su(&mut self, num_bits: usize) -> Result {
+ let mut value: i32 = self
+ .0
+ .read_bits::(num_bits)?
+ .try_into()
+ .map_err(|_| String::from("Read more than 31 signed bits!"))?;
+ let sign_mask = 1 << (num_bits - 1);
+
+ if (value & sign_mask) != 0 {
+ value -= 2 * sign_mask;
+ }
+
+ Ok(value)
+ }
+
+ /// Implements ns(n): Unsigned encoded integer with maximum number of values
+ /// n (i.e. output in range 0..n-1). See 4.10.7
+ pub fn read_ns(&mut self, num_bits: usize) -> Result {
+ let w = helpers::floor_log2(num_bits as u32) + 1;
+ let m = (1 << w) - num_bits as u32;
+ let v = self.0.read_bits::(
+ usize::try_from(w).map_err(|_| String::from("Invalid num_bits"))? - 1,
+ )?;
+
+ if v < m.into() {
+ return Ok(v);
+ }
+
+ let extra_bit = self.0.read_bit()?;
+ Ok((v << 1) - u32::from(m) + u32::from(extra_bit))
+ }
+
+ /// Implements 5.9.13: Delta quantizer syntax.
+ pub fn read_delta_q(&mut self) -> Result {
+ let delta_coded = self.0.read_bit()?;
+
+ if delta_coded {
+ self.read_su(7)
+ } else {
+ Ok(0)
+ }
+ }
+
+ pub fn more_data_in_bitstream(&mut self) -> bool {
+ self.0.num_bits_left() > 0
+ }
+
+ pub(crate) fn consumed(&self, start_pos: u32) -> u32 {
+ (self.0.position() / 8) as u32 - start_pos
+ }
+
+ /// Get the length of the current OBU in AnnexB format.
+ pub fn current_annexb_obu_length(
+ &mut self,
+ annexb_state: &mut AnnexBState,
+ ) -> Result, String> {
+ if !self.more_data_in_bitstream() {
+ return Ok(None);
+ }
+
+ #[allow(clippy::comparison_chain)]
+ if annexb_state.temporal_unit_consumed == annexb_state.temporal_unit_size {
+ annexb_state.temporal_unit_size = 0;
+ } else if annexb_state.temporal_unit_consumed > annexb_state.temporal_unit_size {
+ return Err(format!(
+ "temporal_unit_size is {} but we consumed {} bytes",
+ annexb_state.temporal_unit_size, annexb_state.temporal_unit_consumed,
+ ));
+ }
+
+ if annexb_state.temporal_unit_size == 0 {
+ annexb_state.temporal_unit_size = self.read_leb128()?;
+ if annexb_state.temporal_unit_size == 0 {
+ return Ok(None);
+ }
+ }
+
+ let start_pos = self.consumed(0);
+
+ #[allow(clippy::comparison_chain)]
+ if annexb_state.frame_unit_consumed == annexb_state.frame_unit_size {
+ annexb_state.frame_unit_size = 0;
+ } else if annexb_state.frame_unit_consumed > annexb_state.frame_unit_size {
+ return Err(format!(
+ "frame_unit_size is {} but we consumed {} bytes",
+ annexb_state.frame_unit_size, annexb_state.frame_unit_consumed,
+ ));
+ }
+
+ if annexb_state.frame_unit_size == 0 {
+ annexb_state.frame_unit_size = self.read_leb128()?;
+ if annexb_state.frame_unit_size == 0 {
+ return Ok(None);
+ }
+ annexb_state.temporal_unit_consumed += self.consumed(start_pos);
+ }
+
+ let start_pos = self.consumed(0);
+ let obu_length = self.read_leb128()?;
+ let consumed = self.consumed(start_pos);
+
+ annexb_state.temporal_unit_consumed += consumed;
+ annexb_state.frame_unit_consumed += consumed;
+
+ Ok(Some(obu_length.try_into().unwrap()))
+ }
+
+ /// Implements 5.3.4.
+ pub fn read_trailing_bits(&mut self, mut num_bits: u64) -> Result<(), String> {
+ let trailing_one_bit = self.0.read_bit()?;
+ num_bits -= 1;
+
+ if !trailing_one_bit {
+ return Err("bad padding: trailing_one_bit is not set".into());
+ }
+
+ while num_bits > 0 {
+ let trailing_zero_bit = self.0.read_bit()?;
+ if trailing_zero_bit {
+ return Err("bad padding: trailing_zero_bit is set".into());
+ }
+ num_bits -= 1;
+ }
+
+ Ok(())
+ }
+
+ fn decode_subexp(&mut self, num_syms: i32) -> Result {
+ let mut i = 0;
+ let mut mk = 0;
+ let k = 3;
+
+ loop {
+ let b2 = if i != 0 { k + i - 1 } else { k };
+ let a = 1 << b2;
+ if num_syms <= mk + 3 * a {
+ let num_bits = num_syms - mk;
+ let subexp_final_bits = self.read_ns(num_bits as usize)?;
+ return Ok(subexp_final_bits);
+ } else {
+ let subexp_more_bits = self.0.read_bit()?;
+ if subexp_more_bits {
+ i += 1;
+ mk += a;
+ } else {
+ let num_bits = b2 as usize;
+ let subexp_bits = self.0.read_bits::(num_bits)?;
+ return Ok(subexp_bits + mk as u32);
+ }
+ }
+ }
+ }
+
+ /// Implements 5.9.27.
+ pub fn decode_unsigned_subexp_with_ref(&mut self, mx: i32, r: i32) -> Result {
+ let v = self.decode_subexp(mx)?;
+ if (r << 1) <= mx {
+ Ok(helpers::inverse_recenter(r, v.try_into().unwrap())
+ .try_into()
+ .unwrap())
+ } else {
+ let res = mx - 1 - helpers::inverse_recenter(mx - 1 - r, v.try_into().unwrap());
+ Ok(res.try_into().unwrap())
+ }
+ }
+
+ /// Implements 5.9.26.
+ pub fn decode_signed_subexp_with_ref(
+ &mut self,
+ low: i32,
+ high: i32,
+ r: i32,
+ ) -> Result {
+ let x = self.decode_unsigned_subexp_with_ref(high - low, r - low)?;
+ Ok(i32::try_from(x).unwrap() + low)
+ }
+
+ /// Implements 5.3.5 Byte alignment syntax
+ pub fn byte_alignment(&mut self) -> Result<(), String> {
+ while (self.0.position() & 7) != 0 {
+ self.0.read_bit()?;
+ }
+
+ Ok(())
+ }
+}
+
+impl<'a> Clone for Reader<'a> {
+ fn clone(&self) -> Self {
+ Self(self.0.clone())
+ }
+}
diff --git a/crates/pf-bitstream/vendor/cros-codecs/src/codec/av1/synthesizer.rs b/crates/pf-bitstream/vendor/cros-codecs/src/codec/av1/synthesizer.rs
new file mode 100644
index 00000000..4faf7346
--- /dev/null
+++ b/crates/pf-bitstream/vendor/cros-codecs/src/codec/av1/synthesizer.rs
@@ -0,0 +1,1825 @@
+// Copyright 2024 The ChromiumOS Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+use std::fmt;
+use std::io::Write;
+use std::num::TryFromIntError;
+
+use crate::codec::av1::helpers::clip3;
+use crate::codec::av1::parser::BitDepth;
+use crate::codec::av1::parser::ChromaSamplePosition;
+use crate::codec::av1::parser::ColorPrimaries;
+use crate::codec::av1::parser::FrameHeaderObu;
+use crate::codec::av1::parser::FrameRestorationType;
+use crate::codec::av1::parser::FrameType;
+use crate::codec::av1::parser::InterpolationFilter;
+use crate::codec::av1::parser::MatrixCoefficients;
+use crate::codec::av1::parser::ObuHeader;
+use crate::codec::av1::parser::ObuType;
+use crate::codec::av1::parser::Profile;
+use crate::codec::av1::parser::ReferenceFrameType;
+use crate::codec::av1::parser::SequenceHeaderObu;
+use crate::codec::av1::parser::TemporalDelimiterObu;
+use crate::codec::av1::parser::TransferCharacteristics;
+use crate::codec::av1::parser::TxMode;
+use crate::codec::av1::parser::WarpModelType;
+use crate::codec::av1::parser::FEATURE_BITS;
+use crate::codec::av1::parser::FEATURE_MAX;
+use crate::codec::av1::parser::FEATURE_SIGNED;
+use crate::codec::av1::parser::MAX_NUM_OPERATING_POINTS;
+use crate::codec::av1::parser::MAX_NUM_PLANES;
+use crate::codec::av1::parser::MAX_SEGMENTS;
+use crate::codec::av1::parser::NUM_REF_FRAMES;
+use crate::codec::av1::parser::PRIMARY_REF_NONE;
+use crate::codec::av1::parser::REFS_PER_FRAME;
+use crate::codec::av1::parser::SEG_LVL_MAX;
+use crate::codec::av1::parser::SELECT_INTEGER_MV;
+use crate::codec::av1::parser::SELECT_SCREEN_CONTENT_TOOLS;
+use crate::codec::av1::parser::SUPERRES_DENOM_BITS;
+use crate::codec::av1::parser::SUPERRES_DENOM_MIN;
+use crate::codec::av1::parser::SUPERRES_NUM;
+use crate::codec::av1::parser::TOTAL_REFS_PER_FRAME;
+use crate::codec::av1::writer::ObuWriter;
+use crate::codec::av1::writer::ObuWriterError;
+
+mod private {
+ pub trait ObuStruct {}
+}
+
+impl private::ObuStruct for SequenceHeaderObu {}
+
+impl private::ObuStruct for TemporalDelimiterObu {}
+
+impl private::ObuStruct for FrameHeaderObu {}
+
+#[derive(Debug)]
+pub enum SynthesizerError {
+ Unsupported,
+ InvalidSyntaxElementValue(&'static str),
+ ConversionError(TryFromIntError),
+ ObuWriter(ObuWriterError),
+ Io(std::io::Error),
+}
+
+impl fmt::Display for SynthesizerError {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match self {
+ SynthesizerError::Unsupported => write!(f, "tried to synthesize unsupported settings"),
+ SynthesizerError::InvalidSyntaxElementValue(x) => {
+ write!(f, "invalid syntax element for value {}", x)
+ }
+ SynthesizerError::ConversionError(x) => write!(f, "{}", x.to_string()),
+ SynthesizerError::ObuWriter(x) => write!(f, "{}", x.to_string()),
+ SynthesizerError::Io(x) => write!(f, "{}", x.to_string()),
+ }
+ }
+}
+
+impl From for SynthesizerError {
+ fn from(err: TryFromIntError) -> Self {
+ SynthesizerError::ConversionError(err)
+ }
+}
+
+impl From for SynthesizerError {
+ fn from(err: ObuWriterError) -> Self {
+ SynthesizerError::ObuWriter(err)
+ }
+}
+
+impl From for SynthesizerError {
+ fn from(err: std::io::Error) -> Self {
+ SynthesizerError::Io(err)
+ }
+}
+
+pub type SynthesizerResult = Result;
+
+pub struct Synthesizer<'o, O: private::ObuStruct, W: Write> {
+ writer: ObuWriter,
+ obu: &'o O,
+}
+
+impl<'o, O, W> Synthesizer<'o, O, W>
+where
+ O: private::ObuStruct,
+ W: Write,
+{
+ fn new(writer: W, obu: &'o O) -> Self {
+ Self {
+ writer: ObuWriter::new(writer),
+ obu,
+ }
+ }
+
+ fn f>(&mut self, bits: usize, value: T) -> SynthesizerResult<()> {
+ let value: u32 = value.into();
+ self.writer.write_f(bits, value)?;
+ Ok(())
+ }
+
+ fn leb128>(&mut self, value: T) -> SynthesizerResult<()> {
+ let value: u32 = value.into();
+ self.writer.write_leb128(value, 0)?;
+ Ok(())
+ }
+
+ fn uvlc>(&mut self, value: T) -> SynthesizerResult<()> {
+ self.writer.write_uvlc(value)?;
+ Ok(())
+ }
+
+ fn su>(&mut self, bits: usize, value: T) -> SynthesizerResult<()> {
+ self.writer.write_su(bits, value)?;
+ Ok(())
+ }
+
+ #[cfg(any(test, debug_assertions))]
+ fn invalid_element_value(&mut self, element: &'static str) -> SynthesizerResult<()> {
+ Err(SynthesizerError::InvalidSyntaxElementValue(element))
+ }
+
+ #[cfg(not(any(test, debug_assertions)))]
+ fn invalid_element_value(&mut self, element: &'static str) -> SynthesizerResult<()> {
+ log::error!("Invalid syntax element value: '{element}', expect corrupted bitstream");
+ Ok(())
+ }
+
+ /// Writes 5.3.2. OBU header syntax
+ fn obu_header(&mut self, obu: &ObuHeader) -> SynthesizerResult<()> {
+ self.f(1, /* obu_forbidden_bit */ 0u32)?;
+ self.f(4, obu.obu_type as u32)?;
+ self.f(1, obu.extension_flag)?;
+ self.f(1, obu.has_size_field)?;
+ self.f(1, /* obu_reserved_1bit */ 0u32)?;
+
+ if obu.extension_flag {
+ self.obu_extension_header(obu)?;
+ }
+
+ Ok(())
+ }
+
+ /// Writes AV1 5.3.3. OBU extension header syntax
+ fn obu_extension_header(&mut self, obu: &ObuHeader) -> SynthesizerResult<()> {
+ // AV1 5.3.3
+ self.f(3, obu.temporal_id)?;
+ self.f(2, obu.spatial_id)?;
+ self.f(3, /* extension_header_reserved_3bits */ 0u32)?;
+
+ Ok(())
+ }
+
+ fn obu_size(&mut self, size: u32) -> SynthesizerResult<()> {
+ self.leb128(size)
+ }
+
+ /// Writes AV1 5.3.4. Trailing bits syntax
+ fn trailing_bits(&mut self) -> SynthesizerResult<()> {
+ self.f(1, /* trailing_one_bit */ 1u32)?;
+ while !self.writer.aligned() {
+ self.f(1, /* trailing_zero_bit */ 0u32)?;
+ }
+
+ Ok(())
+ }
+}
+
+impl<'o, W> Synthesizer<'o, TemporalDelimiterObu, W>
+where
+ W: Write,
+{
+ pub fn synthesize(obu: &'o TemporalDelimiterObu, writer: W) -> SynthesizerResult<()> {
+ let mut s = Self::new(writer, obu);
+
+ if obu.obu_header.obu_type != ObuType::TemporalDelimiter {
+ s.invalid_element_value("obu_type")?;
+ }
+
+ s.obu_header(&obu.obu_header)?;
+
+ if obu.obu_header.has_size_field {
+ s.obu_size(0u32)?;
+ }
+
+ Ok(())
+ }
+}
+
+impl<'o, W> Synthesizer<'o, SequenceHeaderObu, W>
+where
+ W: Write,
+{
+ pub fn synthesize(obu: &'o SequenceHeaderObu, mut writer: W) -> SynthesizerResult<()> {
+ let mut s = Synthesizer::new(&mut writer, obu);
+
+ if obu.obu_header.obu_type != ObuType::SequenceHeader {
+ s.invalid_element_value("obu_type")?;
+ }
+
+ s.obu_header(&obu.obu_header)?;
+
+ if !obu.obu_header.has_size_field {
+ s.sequence_header_obu()?;
+ s.trailing_bits()?;
+ return Ok(());
+ }
+
+ let mut buf = Vec::::new();
+ let mut buffered = Synthesizer::new(&mut buf, obu);
+ buffered.sequence_header_obu()?;
+ buffered.trailing_bits()?;
+ drop(buffered);
+
+ s.obu_size(buf.len() as u32)?;
+ drop(s);
+
+ writer.write_all(&buf)?;
+
+ Ok(())
+ }
+
+ /// Writes AV1 5.5.1. General sequence header OBU syntax
+ fn sequence_header_obu(&mut self) -> SynthesizerResult<()> {
+ self.f(3, self.obu.seq_profile as u32)?;
+ self.f(1, self.obu.still_picture)?;
+ self.f(1, self.obu.reduced_still_picture_header)?;
+
+ if self.obu.reduced_still_picture_header {
+ if self.obu.timing_info_present_flag {
+ self.invalid_element_value("reduced_still_picture_header")?
+ }
+ if self.obu.timing_info_present_flag {
+ self.invalid_element_value("timing_info_present_flag")?
+ }
+ if self.obu.initial_display_delay_present_flag {
+ self.invalid_element_value("initial_display_delay_present_flag")?
+ }
+ if self.obu.operating_points_cnt_minus_1 != 0 {
+ self.invalid_element_value("operating_points_cnt_minus_1")?
+ }
+ if self.obu.operating_points[0].idc != 0 {
+ self.invalid_element_value("operating_point_idc")?
+ }
+
+ self.f(5, self.obu.operating_points[0].seq_level_idx)?;
+
+ if self.obu.operating_points[0].decoder_model_present_for_this_op {
+ self.invalid_element_value("decoder_model_present_for_this_op")?
+ }
+ if self.obu.operating_points[0].initial_display_delay_present_for_this_op {
+ self.invalid_element_value("initial_display_delay_present_for_this_op")?
+ }
+ } else {
+ self.f(1, self.obu.timing_info_present_flag)?;
+ if self.obu.timing_info_present_flag {
+ self.timing_info()?;
+ self.f(1, self.obu.decoder_model_info_present_flag)?;
+ if self.obu.decoder_model_info_present_flag {
+ self.decoder_model_info()?;
+ }
+ } else if self.obu.decoder_model_info_present_flag {
+ self.invalid_element_value("decoder_model_info_present_flag")?;
+ }
+
+ self.f(1, self.obu.initial_display_delay_present_flag)?;
+
+ if self.obu.operating_points_cnt_minus_1 > MAX_NUM_OPERATING_POINTS as u32 {
+ self.invalid_element_value("operating_points_cnt_minus_1")?;
+ }
+ self.f(5, self.obu.operating_points_cnt_minus_1)?;
+ for i in 0..=self.obu.operating_points_cnt_minus_1 {
+ let op = &self.obu.operating_points[i as usize];
+
+ self.f(12, op.idc)?;
+ self.f(5, op.seq_level_idx)?;
+ if op.seq_level_idx > 7 {
+ self.f(1, op.seq_tier)?;
+ } else if op.seq_tier != 0 {
+ self.invalid_element_value("seq_tier")?;
+ }
+
+ if self.obu.decoder_model_info_present_flag {
+ self.f(1, op.decoder_model_present_for_this_op)?;
+ if op.decoder_model_present_for_this_op {
+ self.operating_parameters_info(i as usize)?;
+ }
+ } else if op.decoder_model_present_for_this_op {
+ self.invalid_element_value("decoder_model_present_for_this_op")?;
+ }
+
+ if self.obu.initial_display_delay_present_flag {
+ self.f(1, op.initial_display_delay_present_for_this_op)?;
+ if op.initial_display_delay_present_for_this_op {
+ self.f(4, op.initial_display_delay_minus_1)?;
+ }
+ }
+ }
+ }
+
+ let bits = u16::BITS - self.obu.max_frame_width_minus_1.leading_zeros();
+ if self.obu.frame_width_bits_minus_1 as u32 + 1 < bits {
+ self.invalid_element_value("frame_width_bits_minus_1")?;
+ }
+
+ let bits = u16::BITS - self.obu.max_frame_height_minus_1.leading_zeros();
+ if self.obu.frame_height_bits_minus_1 as u32 + 1 < bits {
+ self.invalid_element_value("frame_height_bits_minus_1")?;
+ }
+
+ self.f(4, self.obu.frame_width_bits_minus_1)?;
+ self.f(4, self.obu.frame_height_bits_minus_1)?;
+
+ let n = self.obu.frame_width_bits_minus_1 as usize + 1;
+ if (n as u32) < u16::BITS - self.obu.max_frame_width_minus_1.leading_zeros() {
+ self.invalid_element_value("max_frame_width_minus_1")?;
+ }
+ self.f(n, self.obu.max_frame_width_minus_1)?;
+
+ let n = self.obu.frame_height_bits_minus_1 as usize + 1;
+ if (n as u32) < u16::BITS - self.obu.max_frame_height_minus_1.leading_zeros() {
+ self.invalid_element_value("max_frame_height_minus_1")?;
+ }
+ self.f(n, self.obu.max_frame_height_minus_1)?;
+
+ if self.obu.reduced_still_picture_header {
+ if self.obu.frame_id_numbers_present_flag {
+ self.invalid_element_value("frame_id_numbers_present_flag")?;
+ }
+ } else {
+ self.f(1, self.obu.frame_id_numbers_present_flag)?;
+ }
+
+ if self.obu.frame_id_numbers_present_flag {
+ self.f(4, self.obu.delta_frame_id_length_minus_2)?;
+ self.f(3, self.obu.additional_frame_id_length_minus_1)?;
+ }
+
+ self.f(1, self.obu.use_128x128_superblock)?;
+ self.f(1, self.obu.enable_filter_intra)?;
+ self.f(1, self.obu.enable_intra_edge_filter)?;
+
+ if self.obu.reduced_still_picture_header {
+ if self.obu.enable_interintra_compound {
+ self.invalid_element_value("enable_interintra_compound")?;
+ }
+ if self.obu.enable_masked_compound {
+ self.invalid_element_value("enable_masked_compound")?;
+ }
+ if self.obu.enable_warped_motion {
+ self.invalid_element_value("enable_warped_motion")?;
+ }
+ if self.obu.enable_dual_filter {
+ self.invalid_element_value("enable_dual_filter")?;
+ }
+ if self.obu.enable_order_hint {
+ self.invalid_element_value("enable_order_hint")?;
+ }
+ if self.obu.enable_jnt_comp {
+ self.invalid_element_value("enable_jnt_comp")?;
+ }
+ if self.obu.enable_ref_frame_mvs {
+ self.invalid_element_value("enable_ref_frame_mvs")?;
+ }
+ if self.obu.seq_force_screen_content_tools != SELECT_SCREEN_CONTENT_TOOLS as u32 {
+ self.invalid_element_value("seq_force_screen_content_tools")?;
+ }
+ if self.obu.seq_force_integer_mv != SELECT_INTEGER_MV as u32 {
+ self.invalid_element_value("seq_force_integer_mv")?;
+ }
+ if self.obu.order_hint_bits != 0 {
+ self.invalid_element_value("OrderHintBits")?;
+ }
+ } else {
+ self.f(1, self.obu.enable_interintra_compound)?;
+ self.f(1, self.obu.enable_masked_compound)?;
+ self.f(1, self.obu.enable_warped_motion)?;
+ self.f(1, self.obu.enable_dual_filter)?;
+ self.f(1, self.obu.enable_order_hint)?;
+
+ if self.obu.enable_order_hint {
+ self.f(1, self.obu.enable_jnt_comp)?;
+ self.f(1, self.obu.enable_ref_frame_mvs)?;
+ } else {
+ if self.obu.enable_jnt_comp {
+ self.invalid_element_value("enable_jnt_comp")?;
+ }
+ if self.obu.enable_ref_frame_mvs {
+ self.invalid_element_value("enable_ref_frame_mvs")?;
+ }
+ }
+
+ self.f(1, self.obu.seq_choose_screen_content_tools)?;
+ if self.obu.seq_choose_screen_content_tools {
+ if self.obu.seq_force_screen_content_tools != SELECT_SCREEN_CONTENT_TOOLS as u32 {
+ self.invalid_element_value("seq_force_screen_content_tools")?;
+ }
+ } else {
+ self.f(1, self.obu.seq_force_screen_content_tools)?;
+ }
+
+ if self.obu.seq_force_screen_content_tools > 0 {
+ self.f(1, self.obu.seq_choose_integer_mv)?;
+ if self.obu.seq_choose_integer_mv {
+ if self.obu.seq_force_integer_mv != SELECT_INTEGER_MV as u32 {
+ self.invalid_element_value("seq_force_integer_mv")?;
+ }
+ } else {
+ self.f(1, self.obu.seq_force_integer_mv)?;
+ }
+ } else if self.obu.seq_force_integer_mv != SELECT_INTEGER_MV as u32 {
+ self.invalid_element_value("seq_force_integer_mv")?;
+ }
+
+ if self.obu.enable_order_hint {
+ self.f(3, self.obu.order_hint_bits_minus_1 as u32)?;
+ if self.obu.order_hint_bits != self.obu.order_hint_bits_minus_1 + 1 {
+ self.invalid_element_value("OrderHintBits")?;
+ }
+ } else if self.obu.order_hint_bits != 0 {
+ self.invalid_element_value("OrderHintBits")?;
+ }
+ }
+
+ self.f(1, self.obu.enable_superres)?;
+ self.f(1, self.obu.enable_cdef)?;
+ self.f(1, self.obu.enable_restoration)?;
+ self.color_config()?;
+ self.f(1, self.obu.film_grain_params_present)?;
+
+ Ok(())
+ }
+
+ /// Writes AV1 5.5.2. Color config syntax
+ fn color_config(&mut self) -> SynthesizerResult<()> {
+ let cc = &self.obu.color_config;
+
+ self.f(1, cc.high_bitdepth)?;
+ if matches!(self.obu.seq_profile, Profile::Profile2) && cc.high_bitdepth {
+ self.f(1, cc.twelve_bit)?;
+
+ if (cc.twelve_bit && self.obu.bit_depth != BitDepth::Depth12)
+ || (!cc.twelve_bit && self.obu.bit_depth != BitDepth::Depth10)
+ {
+ self.invalid_element_value("BitDepth")?;
+ }
+ } else if self.obu.seq_profile <= Profile::Profile2
+ && ((cc.high_bitdepth && self.obu.bit_depth != BitDepth::Depth10)
+ || (!cc.high_bitdepth && self.obu.bit_depth != BitDepth::Depth8))
+ {
+ self.invalid_element_value("BitDepth")?;
+ }
+
+ if matches!(self.obu.seq_profile, Profile::Profile1) {
+ if cc.mono_chrome {
+ self.invalid_element_value("mono_chrome")?;
+ }
+ } else {
+ self.f(1, cc.mono_chrome)?;
+ }
+
+ if (cc.mono_chrome && self.obu.num_planes != 1)
+ || (!cc.mono_chrome && self.obu.num_planes != 3)
+ {
+ self.invalid_element_value("NumPlanes")?;
+ }
+
+ self.f(1, cc.color_description_present_flag)?;
+ if cc.color_description_present_flag {
+ self.f(8, cc.color_primaries as u32)?;
+ self.f(8, cc.transfer_characteristics as u32)?;
+ self.f(8, cc.matrix_coefficients as u32)?;
+ } else {
+ if !matches!(cc.color_primaries, ColorPrimaries::Unspecified) {
+ self.invalid_element_value("color_primaries")?;
+ }
+ if !matches!(
+ cc.transfer_characteristics,
+ TransferCharacteristics::Unspecified
+ ) {
+ self.invalid_element_value("transfer_characteristics")?;
+ }
+ if !matches!(cc.matrix_coefficients, MatrixCoefficients::Unspecified) {
+ self.invalid_element_value("matrix_coefficients")?;
+ }
+ }
+
+ if cc.mono_chrome {
+ self.f(1, cc.color_range)?;
+
+ if !cc.subsampling_x {
+ self.invalid_element_value("subsampling_x")?;
+ }
+ if !cc.subsampling_y {
+ self.invalid_element_value("subsampling_y")?;
+ }
+ if !matches!(cc.chroma_sample_position, ChromaSamplePosition::Unknown) {
+ self.invalid_element_value("chroma_sample_position")?;
+ }
+ if !matches!(cc.chroma_sample_position, ChromaSamplePosition::Unknown) {
+ self.invalid_element_value("chroma_sample_position")?;
+ }
+ if cc.separate_uv_delta_q {
+ self.invalid_element_value("separate_uv_delta_q")?;
+ }
+
+ return Ok(());
+ } else if matches!(cc.color_primaries, ColorPrimaries::Bt709)
+ && matches!(cc.transfer_characteristics, TransferCharacteristics::Srgb)
+ && matches!(cc.matrix_coefficients, MatrixCoefficients::Identity)
+ {
+ if !cc.color_range {
+ self.invalid_element_value("color_range")?;
+ }
+ if cc.subsampling_x {
+ self.invalid_element_value("subsampling_x")?;
+ }
+ if cc.subsampling_y {
+ self.invalid_element_value("subsampling_y")?;
+ }
+ } else {
+ self.f(1, cc.color_range)?;
+
+ match self.obu.seq_profile {
+ Profile::Profile0 => {
+ if !cc.subsampling_x {
+ self.invalid_element_value("subsampling_x")?;
+ }
+ if !cc.subsampling_y {
+ self.invalid_element_value("subsampling_y")?;
+ }
+ }
+ Profile::Profile1 => {
+ if cc.subsampling_x {
+ self.invalid_element_value("subsampling_x")?;
+ }
+ if cc.subsampling_y {
+ self.invalid_element_value("subsampling_y")?;
+ }
+ }
+ _ => {
+ if matches!(self.obu.bit_depth, BitDepth::Depth12) {
+ self.f(1, cc.subsampling_x)?;
+ if cc.subsampling_x {
+ self.f(1, cc.subsampling_y)?;
+ } else if cc.subsampling_y {
+ self.invalid_element_value("subsampling_y")?;
+ }
+ } else {
+ if !cc.subsampling_x {
+ self.invalid_element_value("subsampling_x")?;
+ }
+ if cc.subsampling_y {
+ self.invalid_element_value("subsampling_y")?;
+ }
+ }
+ }
+ }
+
+ if cc.subsampling_x && cc.subsampling_y {
+ self.f(2, cc.chroma_sample_position as u32)?;
+ }
+ }
+
+ self.f(1, cc.separate_uv_delta_q)?;
+
+ Ok(())
+ }
+
+ /// Writes AV1 5.5.3. Timing info syntax
+ fn timing_info(&mut self) -> SynthesizerResult<()> {
+ // AV1 5.5.3
+ let ti = &self.obu.timing_info;
+
+ self.f(32, ti.num_units_in_display_tick)?;
+ self.f(32, ti.time_scale)?;
+ self.f(1, ti.equal_picture_interval)?;
+ if ti.equal_picture_interval {
+ self.uvlc(ti.num_ticks_per_picture_minus_1)?;
+ }
+
+ Ok(())
+ }
+
+ /// Writes AV1 5.5.4. Decoder model info syntax
+ fn decoder_model_info(&mut self) -> SynthesizerResult<()> {
+ let dm = &self.obu.decoder_model_info;
+
+ self.f(5, dm.buffer_delay_length_minus_1)?;
+ self.f(32, dm.num_units_in_decoding_tick)?;
+ self.f(5, dm.buffer_removal_time_length_minus_1)?;
+ self.f(5, dm.frame_presentation_time_length_minus_1)?;
+
+ Ok(())
+ }
+
+ /// Writes AV1 5.5.5. Operating parameters info syntax
+ fn operating_parameters_info(&mut self, i: usize) -> SynthesizerResult<()> {
+ let op = &self.obu.operating_points[i];
+
+ let n = usize::from(self.obu.decoder_model_info.buffer_delay_length_minus_1) + 1;
+ self.f(n, op.decoder_buffer_delay)?;
+ self.f(n, op.encoder_buffer_delay)?;
+ self.f(1, op.low_delay_mode_flag)?;
+
+ Ok(())
+ }
+}
+
+impl<'o, W> Synthesizer<'o, FrameHeaderObu, W>
+where
+ W: Write,
+{
+ pub fn synthesize(
+ obu: &'o FrameHeaderObu,
+ sequence: &'o SequenceHeaderObu,
+ mut writer: W,
+ ) -> SynthesizerResult<()> {
+ let mut s = Synthesizer::new(&mut writer, obu);
+
+ if obu.obu_header.obu_type != ObuType::FrameHeader {
+ s.invalid_element_value("obu_type")?;
+ }
+
+ s.obu_header(&obu.obu_header)?;
+
+ if !obu.obu_header.has_size_field {
+ s.frame_header_obu(sequence)?;
+ s.trailing_bits()?;
+ return Ok(());
+ }
+
+ let mut buf = Vec::::new();
+ let mut buffered = Synthesizer::new(&mut buf, obu);
+ buffered.frame_header_obu(sequence)?;
+ buffered.trailing_bits()?;
+ drop(buffered);
+
+ s.obu_size(buf.len() as u32)?;
+ drop(s);
+
+ writer.write_all(&buf)?;
+
+ Ok(())
+ }
+
+ /// Writes AV1 5.9.1. General frame header OBU syntax
+ fn frame_header_obu(&mut self, sequence: &'o SequenceHeaderObu) -> SynthesizerResult<()> {
+ self.uncompressed_header(sequence)
+ }
+
+ /// Writes AV1 5.9.2. Uncompressed header syntax
+ fn uncompressed_header(&mut self, sequence: &'o SequenceHeaderObu) -> SynthesizerResult<()> {
+ const ALL_FRAMES: u32 = (1 << NUM_REF_FRAMES) - 1;
+
+ // idLen
+ let id_len = usize::try_from(
+ sequence.additional_frame_id_length_minus_1
+ + sequence.delta_frame_id_length_minus_2
+ + 3,
+ )?;
+
+ if sequence.reduced_still_picture_header {
+ if !self.obu.show_existing_frame {
+ self.invalid_element_value("show_existing_frame")?;
+ }
+ if !matches!(self.obu.frame_type, FrameType::KeyFrame) {
+ self.invalid_element_value("frame_type")?;
+ }
+ if !self.obu.show_frame {
+ self.invalid_element_value("show_frame")?;
+ }
+ if !self.obu.showable_frame {
+ self.invalid_element_value("showable_frame")?;
+ }
+ if !self.obu.frame_is_intra {
+ self.invalid_element_value("FrameIsIntra")?;
+ }
+ } else {
+ self.f(1, self.obu.show_existing_frame)?;
+ if self.obu.show_existing_frame {
+ self.f(3, self.obu.frame_to_show_map_idx)?;
+
+ if sequence.decoder_model_info_present_flag
+ && !sequence.timing_info.equal_picture_interval
+ {
+ self.temporal_point_info(sequence)?;
+ }
+
+ if sequence.frame_id_numbers_present_flag {
+ self.f(id_len, self.obu.display_frame_id)?;
+ }
+ return Ok(());
+ }
+
+ self.f(2, self.obu.frame_type as u32)?;
+ if self.obu.frame_is_intra
+ ^ matches!(
+ self.obu.frame_type,
+ FrameType::IntraOnlyFrame | FrameType::KeyFrame
+ )
+ {
+ self.invalid_element_value("FrameIsIntra")?;
+ }
+
+ self.f(1, self.obu.show_frame)?;
+ if self.obu.show_frame
+ && sequence.decoder_model_info_present_flag
+ && !sequence.timing_info.equal_picture_interval
+ {
+ self.temporal_point_info(sequence)?;
+ }
+
+ if self.obu.show_frame {
+ if self.obu.showable_frame ^ !matches!(self.obu.frame_type, FrameType::KeyFrame) {
+ self.invalid_element_value("showable_frame")?;
+ }
+ } else {
+ self.f(1, self.obu.showable_frame)?;
+ }
+
+ if matches!(self.obu.frame_type, FrameType::SwitchFrame)
+ || (matches!(self.obu.frame_type, FrameType::KeyFrame) && self.obu.show_frame)
+ {
+ if !self.obu.error_resilient_mode {
+ self.invalid_element_value("error_resilient_mode")?;
+ }
+ } else {
+ self.f(1, self.obu.error_resilient_mode)?;
+ }
+ }
+
+ self.f(1, self.obu.disable_cdf_update)?;
+ if sequence.seq_force_screen_content_tools == SELECT_SCREEN_CONTENT_TOOLS as u32 {
+ self.f(1, self.obu.allow_screen_content_tools)?;
+ } else if self.obu.allow_screen_content_tools != sequence.seq_force_screen_content_tools {
+ self.invalid_element_value("allow_screen_content_tools")?;
+ }
+
+ if self.obu.allow_screen_content_tools != 0 {
+ if sequence.seq_force_integer_mv == SELECT_INTEGER_MV as u32 {
+ self.f(1, self.obu.force_integer_mv)?;
+ } else if self.obu.force_integer_mv != sequence.seq_force_integer_mv {
+ self.invalid_element_value("force_integer_mv")?;
+ }
+ } else if self.obu.force_integer_mv != 0
+ && !(self.obu.frame_is_intra && self.obu.force_integer_mv != 1)
+ {
+ self.invalid_element_value("force_integer_mv")?;
+ }
+
+ if sequence.frame_id_numbers_present_flag {
+ self.f(id_len, self.obu.current_frame_id)?;
+ } else if self.obu.current_frame_id != 0 {
+ self.invalid_element_value("current_frame_id")?;
+ }
+
+ if matches!(self.obu.frame_type, FrameType::SwitchFrame) {
+ if !self.obu.frame_size_override_flag {
+ self.invalid_element_value("frame_size_override_flag")?;
+ }
+ } else if sequence.reduced_still_picture_header {
+ if self.obu.frame_size_override_flag {
+ self.invalid_element_value("frame_size_override_flag")?;
+ }
+ } else {
+ self.f(1, self.obu.frame_size_override_flag)?;
+ }
+
+ if sequence.order_hint_bits != 0 {
+ if sequence.order_hint_bits != sequence.order_hint_bits_minus_1 + 1 {
+ self.invalid_element_value("order_hint_bits_minus_1")?;
+ }
+
+ self.f(sequence.order_hint_bits as usize, self.obu.order_hint)?;
+ }
+
+ if self.obu.frame_is_intra || self.obu.error_resilient_mode {
+ if self.obu.primary_ref_frame != PRIMARY_REF_NONE {
+ self.invalid_element_value("primary_ref_frame")?;
+ }
+ } else {
+ self.f(3, self.obu.primary_ref_frame)?;
+ }
+
+ if sequence.decoder_model_info_present_flag {
+ self.f(1, self.obu.buffer_removal_time_present_flag)?;
+
+ for op_num in 0..=sequence.operating_points_cnt_minus_1 {
+ let op = &sequence.operating_points[op_num as usize];
+ if op.decoder_model_present_for_this_op {
+ let in_temporal_layer = (op.idc >> self.obu.obu_header.temporal_id) & 1 != 0;
+ let in_spatial_layer =
+ (op.idc >> (self.obu.obu_header.spatial_id + 8)) & 1 != 0;
+
+ if op.idc == 0 || (in_temporal_layer && in_spatial_layer) {
+ let n = usize::from(
+ sequence
+ .decoder_model_info
+ .buffer_removal_time_length_minus_1
+ + 1,
+ );
+
+ self.f(n, op.decoder_buffer_delay)?;
+ }
+ }
+ }
+ }
+
+ if matches!(self.obu.frame_type, FrameType::SwitchFrame)
+ || (matches!(self.obu.frame_type, FrameType::KeyFrame) && self.obu.show_frame)
+ {
+ if self.obu.refresh_frame_flags != ALL_FRAMES {
+ self.invalid_element_value("refresh_frame_flags")?;
+ }
+ } else {
+ self.f(8, self.obu.refresh_frame_flags)?;
+ }
+
+ if (!self.obu.frame_is_intra || self.obu.refresh_frame_flags != ALL_FRAMES)
+ && self.obu.error_resilient_mode
+ && sequence.enable_order_hint
+ {
+ for i in 0..NUM_REF_FRAMES {
+ self.f(
+ sequence.order_hint_bits as usize,
+ self.obu.ref_order_hint[i],
+ )?;
+ }
+ }
+
+ if self.obu.frame_is_intra {
+ self.frame_size(sequence)?;
+ self.render_size()?;
+
+ if self.obu.allow_screen_content_tools != 0
+ && self.obu.upscaled_width == self.obu.frame_width
+ {
+ self.f(1, self.obu.allow_intrabc)?;
+ }
+ } else {
+ if !sequence.enable_order_hint {
+ if self.obu.frame_refs_short_signaling {
+ self.invalid_element_value("frame_refs_short_signaling")?;
+ }
+ } else {
+ self.f(1, self.obu.frame_refs_short_signaling)?;
+ if self.obu.frame_refs_short_signaling {
+ self.f(3, self.obu.last_frame_idx)?;
+ self.f(3, self.obu.gold_frame_idx)?;
+ }
+ }
+
+ for i in 0..REFS_PER_FRAME {
+ let ref_frame_idx = self.obu.ref_frame_idx[i] as u32;
+ if !self.obu.frame_refs_short_signaling {
+ self.f(3, ref_frame_idx)?;
+ }
+
+ if sequence.frame_id_numbers_present_flag {
+ let n = usize::try_from(sequence.delta_frame_id_length_minus_2 + 2)?;
+
+ let delta_frame_id_minus_1 = ((self.obu.current_frame_id - ref_frame_idx
+ + (1 << id_len))
+ % (1 << id_len))
+ - 1;
+
+ self.f(n, delta_frame_id_minus_1)?;
+ }
+ }
+
+ if self.obu.frame_size_override_flag && !self.obu.error_resilient_mode {
+ self.frame_size_with_refs()?;
+ } else {
+ self.frame_size(sequence)?;
+ self.render_size()?;
+ }
+
+ if self.obu.force_integer_mv != 0 {
+ if !self.obu.allow_high_precision_mv {
+ self.invalid_element_value("allow_high_precision_mv")?;
+ }
+ } else {
+ self.f(1, self.obu.allow_high_precision_mv)?;
+ }
+
+ self.read_interpolation_filter()?;
+ self.f(1, self.obu.is_motion_mode_switchable)?;
+
+ if self.obu.error_resilient_mode || !sequence.enable_ref_frame_mvs {
+ if self.obu.use_ref_frame_mvs {
+ self.invalid_element_value("use_ref_frame_mvs")?;
+ }
+ } else {
+ self.f(1, self.obu.use_ref_frame_mvs)?;
+ }
+ }
+
+ if sequence.reduced_still_picture_header || self.obu.disable_cdf_update {
+ if !self.obu.disable_frame_end_update_cdf {
+ self.invalid_element_value("disable_frame_end_update_cdf")?
+ }
+ } else {
+ self.f(1, self.obu.disable_frame_end_update_cdf)?;
+ }
+
+ self.tile_info()?;
+ self.quantization_params(sequence)?;
+ self.segmentation_params()?;
+
+ self.delta_q_params()?;
+ self.delta_lf_params()?;
+
+ if self.obu.coded_lossless && self.obu.lossless_array != [true; MAX_SEGMENTS] {
+ self.invalid_element_value("CodedLossless")?;
+ }
+
+ if self.obu.all_lossless
+ ^ (self.obu.coded_lossless && self.obu.frame_width == self.obu.upscaled_width)
+ {
+ self.invalid_element_value("AllLossless")?;
+ }
+
+ self.loop_filter_params(sequence)?;
+ self.cdef_params(sequence)?;
+ self.lr_params(sequence)?;
+ self.read_tx_mode()?;
+ self.frame_reference_mode()?;
+ self.skip_mode_params()?;
+
+ if self.obu.frame_is_intra
+ || self.obu.error_resilient_mode
+ || !sequence.enable_warped_motion
+ {
+ if self.obu.allow_warped_motion {
+ self.invalid_element_value("allow_warped_motion")?;
+ }
+ } else {
+ self.f(1, self.obu.allow_warped_motion)?;
+ }
+
+ self.f(1, self.obu.reduced_tx_set)?;
+
+ self.global_motion_params()?;
+ self.film_grain_params(sequence)?;
+
+ Ok(())
+ }
+
+ /// Writes AV1 5.9.31. Temporal point info syntax
+ fn temporal_point_info(&mut self, sequence: &'o SequenceHeaderObu) -> SynthesizerResult<()> {
+ let n = usize::try_from(
+ sequence
+ .decoder_model_info
+ .frame_presentation_time_length_minus_1
+ + 1,
+ )?;
+
+ self.f(n, self.obu.frame_presentation_time)?;
+
+ Ok(())
+ }
+
+ /// Writes AV1 5.9.5. Frame size syntax
+ fn frame_size(&mut self, sequence: &'o SequenceHeaderObu) -> SynthesizerResult<()> {
+ if self.obu.frame_size_override_flag {
+ let n = sequence.frame_width_bits_minus_1 as usize + 1;
+ self.f(n, self.obu.frame_width - 1)?;
+ let n = sequence.frame_height_bits_minus_1 as usize + 1;
+ self.f(n, self.obu.frame_height - 1)?;
+ } else {
+ if self.obu.frame_width != sequence.max_frame_width_minus_1 as u32 + 1 {
+ self.invalid_element_value("FrameWidth")?;
+ }
+ if self.obu.frame_height != sequence.max_frame_height_minus_1 as u32 + 1 {
+ self.invalid_element_value("FrameHeight")?;
+ }
+
+ self.superres_params(sequence)?;
+ }
+
+ Ok(())
+ }
+
+ /// Writes AV1 5.9.6. Render size syntax
+ fn render_size(&mut self) -> SynthesizerResult<()> {
+ self.f(1, self.obu.render_and_frame_size_different)?;
+
+ if self.obu.render_and_frame_size_different {
+ self.f(16, self.obu.render_width - 1)?;
+ self.f(16, self.obu.render_height - 1)?;
+ } else {
+ if self.obu.render_width != self.obu.upscaled_width {
+ self.invalid_element_value("RenderWidth")?;
+ }
+ if self.obu.render_height != self.obu.frame_height {
+ self.invalid_element_value("RenderHeight")?;
+ }
+ }
+
+ Ok(())
+ }
+
+ /// Writes AV1 5.9.7. Frame size with refs syntax
+ fn frame_size_with_refs(&mut self) -> SynthesizerResult<()> {
+ log::error!("Syntax element frame_size_with_refs is unsupported");
+ Err(SynthesizerError::Unsupported)
+ }
+
+ /// Writes AV1 5.9.8. Superres params syntax
+ fn superres_params(&mut self, sequence: &'o SequenceHeaderObu) -> SynthesizerResult<()> {
+ if sequence.enable_superres {
+ self.f(1, self.obu.use_superres)?;
+ } else if self.obu.use_superres {
+ self.invalid_element_value("use_superres")?;
+ }
+
+ if self.obu.use_superres {
+ let coded_denom = self.obu.superres_denom - SUPERRES_DENOM_MIN as u32;
+
+ self.f(SUPERRES_DENOM_BITS, coded_denom)?;
+ } else if self.obu.superres_denom != SUPERRES_NUM as u32 {
+ self.invalid_element_value("superres_denom")?;
+ }
+
+ Ok(())
+ }
+
+ /// Writes AV1 5.9.10. Interpolation filter syntax
+ fn read_interpolation_filter(&mut self) -> SynthesizerResult<()> {
+ self.f(1, self.obu.is_filter_switchable)?;
+ if self.obu.is_filter_switchable {
+ if !matches!(
+ self.obu.interpolation_filter,
+ InterpolationFilter::Switchable
+ ) {
+ self.invalid_element_value("interpolation_filter")?;
+ }
+ } else {
+ self.f(2, self.obu.interpolation_filter as u32)?;
+ }
+
+ Ok(())
+ }
+
+ /// Writes AV1 5.9.11. Loop filter params syntax
+ fn loop_filter_params(&mut self, sequence: &'o SequenceHeaderObu) -> SynthesizerResult<()> {
+ if self.obu.coded_lossless || self.obu.allow_intrabc {
+ if !matches!(self.obu.loop_filter_params.loop_filter_level, [0, 0, _, _]) {
+ self.invalid_element_value("loop_filter_level")?;
+ }
+ if self.obu.loop_filter_params.loop_filter_ref_deltas != [1, 0, 0, 0, 0, -1, -1, -1] {
+ self.invalid_element_value("loop_filter_ref_deltas")?;
+ }
+ if self.obu.loop_filter_params.loop_filter_mode_deltas != [0, 0] {
+ self.invalid_element_value("loop_filter_mode_deltas")?;
+ }
+ return Ok(());
+ }
+
+ self.f(6, self.obu.loop_filter_params.loop_filter_level[0])?;
+ self.f(6, self.obu.loop_filter_params.loop_filter_level[1])?;
+ if sequence.num_planes > 1
+ && self.obu.loop_filter_params.loop_filter_level[0] != 0
+ && self.obu.loop_filter_params.loop_filter_level[1] != 0
+ {
+ self.f(6, self.obu.loop_filter_params.loop_filter_level[2])?;
+ self.f(6, self.obu.loop_filter_params.loop_filter_level[3])?;
+ }
+
+ self.f(3, self.obu.loop_filter_params.loop_filter_sharpness)?;
+ self.f(1, self.obu.loop_filter_params.loop_filter_delta_enabled)?;
+ if self.obu.loop_filter_params.loop_filter_delta_enabled {
+ self.f(1, self.obu.loop_filter_params.loop_filter_delta_update)?;
+ if self.obu.loop_filter_params.loop_filter_delta_update {
+ for i in 0..TOTAL_REFS_PER_FRAME {
+ // NOTE: Currently we have no way of checking if the value changed between
+ // frames, always update the value to make sure the decoder will recreate
+ // the same state.
+ const UPDATE_REF_DELTA: bool = true;
+ if UPDATE_REF_DELTA {
+ self.su(1 + 6, self.obu.loop_filter_params.loop_filter_ref_deltas[i])?;
+ }
+ }
+
+ for i in 0..2 {
+ // NOTE: Same as above
+ const UPDATE_MODE_DELTA: bool = true;
+ if UPDATE_MODE_DELTA {
+ self.su(
+ 1 + 6,
+ self.obu.loop_filter_params.loop_filter_mode_deltas[i],
+ )?;
+ }
+ }
+ }
+ }
+
+ Ok(())
+ }
+
+ /// Writes AV1 5.9.12. Quantization params syntax
+ fn quantization_params(&mut self, sequence: &'o SequenceHeaderObu) -> SynthesizerResult<()> {
+ self.f(8, self.obu.quantization_params.base_q_idx)?;
+ self.read_delta_q(self.obu.quantization_params.delta_q_y_dc)?;
+ if sequence.num_planes > 1 {
+ if sequence.color_config.separate_uv_delta_q {
+ self.f(1, self.obu.quantization_params.diff_uv_delta)?;
+ } else if self.obu.quantization_params.diff_uv_delta {
+ self.invalid_element_value("diff_uv_delta")?;
+ };
+
+ self.read_delta_q(self.obu.quantization_params.delta_q_u_dc)?;
+ self.read_delta_q(self.obu.quantization_params.delta_q_u_ac)?;
+
+ if self.obu.quantization_params.diff_uv_delta {
+ self.read_delta_q(self.obu.quantization_params.delta_q_v_dc)?;
+ self.read_delta_q(self.obu.quantization_params.delta_q_v_ac)?;
+ } else {
+ if self.obu.quantization_params.delta_q_v_dc != 0 {
+ self.invalid_element_value("delta_q_v_dc")?;
+ }
+ if self.obu.quantization_params.delta_q_v_ac != 0 {
+ self.invalid_element_value("delta_q_v_ac")?;
+ }
+ }
+ } else {
+ if self.obu.quantization_params.delta_q_u_dc != 0 {
+ self.invalid_element_value("delta_q_u_dc")?;
+ }
+ if self.obu.quantization_params.delta_q_u_ac != 0 {
+ self.invalid_element_value("delta_q_u_ac")?;
+ }
+ if self.obu.quantization_params.delta_q_v_dc != 0 {
+ self.invalid_element_value("delta_q_v_dc")?;
+ }
+ if self.obu.quantization_params.delta_q_v_ac != 0 {
+ self.invalid_element_value("delta_q_v_ac")?;
+ }
+ }
+
+ self.f(1, self.obu.quantization_params.using_qmatrix)?;
+ if self.obu.quantization_params.using_qmatrix {
+ self.f(4, self.obu.quantization_params.qm_y)?;
+ self.f(4, self.obu.quantization_params.qm_u)?;
+
+ if !sequence.color_config.separate_uv_delta_q {
+ if self.obu.quantization_params.qm_v != self.obu.quantization_params.qm_u {
+ self.invalid_element_value("qm_v")?;
+ }
+ } else {
+ self.f(4, self.obu.quantization_params.qm_v)?;
+ }
+ }
+
+ Ok(())
+ }
+
+ /// Writes AV1 5.9.13. Delta quantizer syntax
+ fn read_delta_q(&mut self, delta_q: i32) -> SynthesizerResult<()> {
+ self.f(1, delta_q != 0)?;
+ if delta_q != 0 {
+ self.su(1 + 6, delta_q)?;
+ }
+ Ok(())
+ }
+
+ /// Writes AV1 5.9.14. Segmentation params syntax
+ fn segmentation_params(&mut self) -> SynthesizerResult<()> {
+ self.f(1, self.obu.segmentation_params.segmentation_enabled)?;
+ if self.obu.segmentation_params.segmentation_enabled {
+ if self.obu.primary_ref_frame == PRIMARY_REF_NONE {
+ if !self.obu.segmentation_params.segmentation_update_map {
+ self.invalid_element_value("segmentation_update_map")?;
+ }
+
+ if self.obu.segmentation_params.segmentation_temporal_update {
+ self.invalid_element_value("segmentation_temporal_update")?;
+ }
+
+ if !self.obu.segmentation_params.segmentation_update_data {
+ self.invalid_element_value("segmentation_update_data")?;
+ }
+ } else {
+ self.f(1, self.obu.segmentation_params.segmentation_update_map)?;
+ if self.obu.segmentation_params.segmentation_update_map {
+ self.f(1, self.obu.segmentation_params.segmentation_temporal_update)?;
+ }
+ self.f(1, self.obu.segmentation_params.segmentation_temporal_update)?;
+ }
+
+ if self.obu.segmentation_params.segmentation_update_data {
+ for i in 0..MAX_SEGMENTS {
+ for j in 0..SEG_LVL_MAX {
+ let feature_enabled = self.obu.segmentation_params.feature_enabled[i][j];
+ self.f(1, feature_enabled)?;
+
+ if feature_enabled {
+ let bits_to_read = FEATURE_BITS[j] as usize;
+ let limit = FEATURE_MAX[j];
+ let signed = FEATURE_SIGNED[j];
+
+ let value = i32::from(self.obu.segmentation_params.feature_data[i][j]);
+ if signed {
+ let clipped_value = clip3(-limit, limit, value);
+ self.su(bits_to_read + 1, clipped_value)?;
+ } else {
+ let clipped_value = clip3(0, limit, value);
+ self.f(bits_to_read, u32::try_from(clipped_value)?)?;
+ }
+ }
+ }
+ }
+ } else {
+ if self.obu.segmentation_params.feature_enabled
+ != [[false; SEG_LVL_MAX]; MAX_SEGMENTS]
+ {
+ self.invalid_element_value("feature_enabled")?;
+ }
+ if self.obu.segmentation_params.feature_data != [[0; SEG_LVL_MAX]; MAX_SEGMENTS] {
+ self.invalid_element_value("feature_data")?;
+ }
+ }
+ }
+
+ Ok(())
+ }
+
+ /// Writes AV1 5.9.15. Tile info syntax
+ fn tile_info(&mut self) -> SynthesizerResult<()> {
+ // From AV1 5.9.9. Compute image size function
+ self.f(1, self.obu.tile_info.uniform_tile_spacing_flag)?;
+ if self.obu.tile_info.uniform_tile_spacing_flag {
+ if self.obu.tile_info.tile_cols != 1
+ && self.obu.tile_info.tile_cols_log2 != 0
+ && self.obu.tile_info.tile_rows != 1
+ && self.obu.tile_info.tile_rows_log2 != 0
+ {
+ // TODO: Allow more then single tile
+ log::error!("Only 1x1 tiles frame is currently supported");
+ return Err(SynthesizerError::Unsupported);
+ }
+
+ const INCREMENT_TILE_COLS_LOG2: u32 = 0;
+ const INCREMENT_TILE_ROWS_LOG2: u32 = 0;
+
+ self.f(1, INCREMENT_TILE_COLS_LOG2)?;
+ self.f(1, INCREMENT_TILE_ROWS_LOG2)?;
+ } else {
+ // TODO
+ log::error!("Only uniformly sized tiles are currently supported");
+ return Err(SynthesizerError::Unsupported);
+ }
+
+ Ok(())
+ }
+
+ /// Writes AV1 5.9.17. Quantizer index delta parameters syntax
+ fn delta_q_params(&mut self) -> SynthesizerResult<()> {
+ if self.obu.quantization_params.base_q_idx > 0 {
+ self.f(1, self.obu.quantization_params.delta_q_present)?;
+
+ if self.obu.quantization_params.delta_q_present {
+ self.f(2, self.obu.quantization_params.delta_q_res)?;
+ }
+ } else if self.obu.quantization_params.delta_q_present {
+ self.invalid_element_value("delta_q_present")?;
+ }
+
+ Ok(())
+ }
+
+ /// Writes AV1 5.9.18. Loop filter delta parameters syntax
+ fn delta_lf_params(&mut self) -> SynthesizerResult<()> {
+ if self.obu.quantization_params.delta_q_present {
+ if self.obu.allow_intrabc {
+ self.f(1, self.obu.loop_filter_params.delta_lf_present)?;
+
+ if self.obu.loop_filter_params.delta_lf_present {
+ self.f(2, self.obu.loop_filter_params.delta_lf_res)?;
+ self.f(1, self.obu.loop_filter_params.delta_lf_multi)?;
+ }
+ } else if self.obu.loop_filter_params.delta_lf_present {
+ self.invalid_element_value("delta_lf_present")?;
+ }
+ }
+
+ Ok(())
+ }
+
+ /// Writes AV1 5.9.19. CDEF params syntax
+ fn cdef_params(&mut self, sequence: &'o SequenceHeaderObu) -> SynthesizerResult<()> {
+ if self.obu.coded_lossless || self.obu.allow_intrabc || !sequence.enable_cdef {
+ if self.obu.cdef_params.cdef_bits != 0 {
+ self.invalid_element_value("cdef_bits")?;
+ }
+
+ if self.obu.cdef_params.cdef_y_pri_strength[0] != 0 {
+ self.invalid_element_value("cdef_y_pri_strength")?;
+ }
+
+ if self.obu.cdef_params.cdef_y_sec_strength[0] != 0 {
+ self.invalid_element_value("cdef_y_sec_strength")?;
+ }
+
+ if self.obu.cdef_params.cdef_uv_pri_strength[0] != 0 {
+ self.invalid_element_value("cdef_uv_pri_strength")?;
+ }
+
+ if self.obu.cdef_params.cdef_uv_sec_strength[0] != 0 {
+ self.invalid_element_value("cdef_uv_sec_strength")?;
+ }
+
+ if self.obu.cdef_params.cdef_damping != 3 {
+ self.invalid_element_value("cdef_damping")?;
+ }
+
+ return Ok(());
+ }
+
+ self.f(2, self.obu.cdef_params.cdef_damping - 3)?;
+ self.f(2, self.obu.cdef_params.cdef_bits)?;
+
+ for i in 0..(1 << self.obu.cdef_params.cdef_bits) {
+ self.f(4, self.obu.cdef_params.cdef_y_pri_strength[i])?;
+
+ let mut cdef_y_sec_strength = self.obu.cdef_params.cdef_y_sec_strength[i];
+ if cdef_y_sec_strength == 4 {
+ cdef_y_sec_strength -= 1;
+ }
+
+ self.f(2, cdef_y_sec_strength)?;
+
+ if sequence.num_planes > 1 {
+ self.f(4, self.obu.cdef_params.cdef_uv_pri_strength[i])?;
+
+ let mut cdef_uv_sec_strength = self.obu.cdef_params.cdef_uv_sec_strength[i];
+ if cdef_uv_sec_strength == 4 {
+ cdef_uv_sec_strength -= 1;
+ }
+
+ self.f(2, cdef_uv_sec_strength)?;
+ }
+ }
+
+ Ok(())
+ }
+
+ /// Writes AV1 5.9.20. Loop restoration params syntax
+ fn lr_params(&mut self, sequence: &'o SequenceHeaderObu) -> SynthesizerResult<()> {
+ if self.obu.all_lossless || self.obu.allow_intrabc || !sequence.enable_restoration {
+ if self.obu.loop_restoration_params.frame_restoration_type
+ != [FrameRestorationType::None; MAX_NUM_PLANES]
+ {
+ self.invalid_element_value("frame_restoration_type")?;
+ }
+
+ if self.obu.loop_restoration_params.uses_lr {
+ self.invalid_element_value("uses_lr")?;
+ }
+
+ return Ok(());
+ }
+
+ let mut uses_lr = false;
+ let mut uses_chroma_lr = false;
+ for i in 0..MAX_NUM_PLANES {
+ let lr_type = self.obu.loop_restoration_params.frame_restoration_type[i];
+ self.f(2, lr_type as u32)?;
+
+ if lr_type != FrameRestorationType::None {
+ uses_lr = true;
+
+ if i > 0 {
+ uses_chroma_lr = true;
+ }
+ }
+ }
+
+ if uses_lr ^ self.obu.loop_restoration_params.uses_lr {
+ self.invalid_element_value("uses_lr")?;
+ }
+ if uses_chroma_lr ^ self.obu.loop_restoration_params.uses_chroma_lr {
+ self.invalid_element_value("uses_chroma_lr")?;
+ }
+
+ if uses_lr {
+ if sequence.use_128x128_superblock {
+ if self.obu.loop_restoration_params.lr_unit_shift == 0 {
+ self.invalid_element_value("lr_unit_shift")?;
+ }
+
+ self.f(1, self.obu.loop_restoration_params.lr_unit_shift - 1)?;
+ } else {
+ self.f(1, self.obu.loop_restoration_params.lr_unit_shift)?;
+ if self.obu.loop_restoration_params.lr_unit_shift != 0 {
+ self.f(1, self.obu.loop_restoration_params.lr_unit_shift > 1)?;
+ }
+ }
+
+ if sequence.color_config.subsampling_x
+ && sequence.color_config.subsampling_y
+ && uses_chroma_lr
+ {
+ self.f(1, self.obu.loop_restoration_params.lr_uv_shift)?;
+ } else if self.obu.loop_restoration_params.lr_uv_shift != 0 {
+ self.invalid_element_value("lr_uv_shift")?;
+ }
+ }
+
+ Ok(())
+ }
+
+ /// Writes AV1 5.9.21. TX mode syntax
+ fn read_tx_mode(&mut self) -> SynthesizerResult<()> {
+ if self.obu.coded_lossless {
+ if self.obu.tx_mode != TxMode::Only4x4 {
+ self.invalid_element_value("TxMode")?;
+ }
+ } else {
+ self.f(1, self.obu.tx_mode_select)?;
+
+ if (self.obu.tx_mode_select != 0 && self.obu.tx_mode != TxMode::Select)
+ || (self.obu.tx_mode_select == 0 && self.obu.tx_mode != TxMode::Largest)
+ {
+ self.invalid_element_value("TxMode")?;
+ }
+ }
+
+ Ok(())
+ }
+
+ /// Writes AV1 5.9.22. Skip mode params syntax
+ fn skip_mode_params(&mut self) -> SynthesizerResult<()> {
+ // TODO: Implement if needed
+ Ok(())
+ }
+
+ /// Writes AV1 5.9.23. Frame reference mode syntax
+ fn frame_reference_mode(&mut self) -> SynthesizerResult<()> {
+ if self.obu.frame_is_intra {
+ if self.obu.reference_select {
+ self.invalid_element_value("reference_select")?;
+ }
+ } else {
+ self.f(1, self.obu.reference_select)?;
+ }
+
+ Ok(())
+ }
+
+ /// Writes AV1 5.9.23. Frame reference mode syntax
+ fn global_motion_params(&mut self) -> SynthesizerResult<()> {
+ if self.obu.frame_is_intra {
+ return Ok(());
+ }
+
+ for ref_ in ReferenceFrameType::Last as usize..=ReferenceFrameType::AltRef as usize {
+ let is_global = self.obu.global_motion_params.is_global[ref_];
+ let is_rot_zoom = self.obu.global_motion_params.is_rot_zoom[ref_];
+ let is_translation = self.obu.global_motion_params.is_translation[ref_];
+ let gm_type = self.obu.global_motion_params.gm_type[ref_];
+
+ let expected_type = match (is_global, is_rot_zoom, is_translation) {
+ (false, _, _) => WarpModelType::Identity,
+ (true, true, _) => WarpModelType::RotZoom,
+ (true, false, true) => WarpModelType::Translation,
+ (true, false, false) => WarpModelType::Affine,
+ };
+
+ if expected_type != gm_type {
+ self.invalid_element_value("GmType")?;
+ }
+
+ self.f(1, is_global)?;
+ if is_global {
+ self.f(1, is_rot_zoom)?;
+ if is_rot_zoom {
+ } else {
+ self.f(1, is_translation)?;
+ }
+ }
+
+ if gm_type >= WarpModelType::RotZoom {
+ self.read_global_param(gm_type, ref_, 2)?;
+ self.read_global_param(gm_type, ref_, 3)?;
+ if gm_type == WarpModelType::Affine {
+ self.read_global_param(gm_type, ref_, 4)?;
+ self.read_global_param(gm_type, ref_, 5)?;
+ }
+ }
+
+ if gm_type >= WarpModelType::Translation {
+ self.read_global_param(gm_type, ref_, 0)?;
+ self.read_global_param(gm_type, ref_, 1)?;
+ }
+ }
+
+ Ok(())
+ }
+
+ /// Writes AV1 5.9.25. Global param syntax
+ fn read_global_param(
+ &mut self,
+ _gm_type: WarpModelType,
+ _ref_: usize,
+ _idx: u32,
+ ) -> SynthesizerResult<()> {
+ // TODO
+ log::warn!(
+ "Syntax element read_global_param() is not currently supported. Use GmType=IDENTITY"
+ );
+ Err(SynthesizerError::Unsupported)
+ }
+
+ /// Writes AV1 5.9.30. Film grain params syntax
+ fn film_grain_params(&mut self, sequence: &'o SequenceHeaderObu) -> SynthesizerResult<()> {
+ if !sequence.film_grain_params_present || (!self.obu.show_frame && !self.obu.showable_frame)
+ {
+ return Ok(());
+ }
+
+ self.f(1, self.obu.film_grain_params.apply_grain)?;
+ if !self.obu.film_grain_params.apply_grain {
+ return Ok(());
+ }
+
+ Err(SynthesizerError::Unsupported)
+ }
+}
+
+#[cfg(test)]
+mod tests {
+
+ use super::*;
+ use crate::codec::av1::parser::CdefParams;
+ use crate::codec::av1::parser::ChromaSamplePosition;
+ use crate::codec::av1::parser::ColorConfig;
+ use crate::codec::av1::parser::TileInfo;
+ use crate::codec::av1::parser::MAX_TILE_COLS;
+ use crate::codec::av1::parser::MAX_TILE_ROWS;
+
+ #[test]
+ fn sequence_header_obu_test25fps() {
+ // Extraced from ./src/codec/av1/test_data/test-25fps.ivf.av1
+ const SEQ_HDR_RAW: [u8; 13] = [
+ 0x0a, 0x0b, 0x00, 0x00, 0x00, 0x04, 0x3c, 0xff, 0xbd, 0xff, 0xf9, 0x80, 0x40,
+ ];
+
+ let seq_hdr = SequenceHeaderObu {
+ obu_header: ObuHeader {
+ obu_type: ObuType::SequenceHeader,
+ extension_flag: false,
+ has_size_field: true,
+ temporal_id: 0,
+ spatial_id: 0,
+ },
+
+ seq_profile: Profile::Profile0,
+ num_planes: 3,
+ still_picture: false,
+ reduced_still_picture_header: false,
+ timing_info_present_flag: false,
+ initial_display_delay_present_flag: false,
+ operating_points_cnt_minus_1: 0,
+ frame_width_bits_minus_1: 8,
+ frame_height_bits_minus_1: 7,
+ max_frame_width_minus_1: 319,
+ max_frame_height_minus_1: 239,
+ frame_id_numbers_present_flag: false,
+ use_128x128_superblock: true,
+ enable_filter_intra: true,
+ enable_intra_edge_filter: true,
+ enable_interintra_compound: true,
+ enable_masked_compound: true,
+ enable_warped_motion: true,
+ enable_dual_filter: true,
+ enable_order_hint: true,
+ enable_jnt_comp: true,
+ enable_ref_frame_mvs: true,
+ seq_choose_screen_content_tools: true,
+ seq_force_screen_content_tools: SELECT_SCREEN_CONTENT_TOOLS as u32,
+ seq_choose_integer_mv: true,
+ seq_force_integer_mv: SELECT_INTEGER_MV as u32,
+ order_hint_bits_minus_1: 6,
+ order_hint_bits: 7,
+ enable_superres: false,
+ enable_cdef: true,
+ enable_restoration: true,
+ color_config: ColorConfig {
+ high_bitdepth: false,
+ mono_chrome: false,
+ color_description_present_flag: false,
+ color_range: false,
+ subsampling_x: true,
+ subsampling_y: true,
+ chroma_sample_position: ChromaSamplePosition::Unknown,
+ separate_uv_delta_q: false,
+ ..Default::default()
+ },
+ film_grain_params_present: false,
+
+ ..Default::default()
+ };
+
+ let mut buf = Vec::::new();
+ Synthesizer::<'_, SequenceHeaderObu, _>::synthesize(&seq_hdr, &mut buf).unwrap();
+ assert_eq!(buf, SEQ_HDR_RAW);
+ }
+
+ #[test]
+ fn sequence_header_obu_av1_annexb() {
+ // Extraced from: ./src/codec/av1/test_data/av1-annexb.ivf.av1
+ const SEQ_HDR_RAW: [u8; 12] = [
+ 0x0a, 0x0a, 0x00, 0x00, 0x00, 0x02, 0xaf, 0xff, 0xbf, 0xff, 0x30, 0x08,
+ ];
+
+ let seq_hdr = SequenceHeaderObu {
+ obu_header: ObuHeader {
+ obu_type: ObuType::SequenceHeader,
+ extension_flag: false,
+ has_size_field: true,
+ temporal_id: 0,
+ spatial_id: 0,
+ },
+
+ seq_profile: Profile::Profile0,
+ num_planes: 3,
+ still_picture: false,
+ reduced_still_picture_header: false,
+ timing_info_present_flag: false,
+ initial_display_delay_present_flag: false,
+ operating_points_cnt_minus_1: 0,
+ frame_width_bits_minus_1: 5,
+ frame_height_bits_minus_1: 5,
+ max_frame_width_minus_1: 63,
+ max_frame_height_minus_1: 63,
+ frame_id_numbers_present_flag: false,
+ use_128x128_superblock: true,
+ enable_filter_intra: true,
+ enable_intra_edge_filter: true,
+ enable_interintra_compound: true,
+ enable_masked_compound: true,
+ enable_warped_motion: true,
+ enable_dual_filter: true,
+ enable_order_hint: true,
+ enable_jnt_comp: true,
+ enable_ref_frame_mvs: true,
+ seq_choose_screen_content_tools: true,
+ seq_force_screen_content_tools: SELECT_SCREEN_CONTENT_TOOLS as u32,
+ seq_choose_integer_mv: true,
+ seq_force_integer_mv: SELECT_INTEGER_MV as u32,
+ order_hint_bits_minus_1: 6,
+ order_hint_bits: 7,
+ enable_superres: false,
+ enable_cdef: true,
+ enable_restoration: true,
+ color_config: ColorConfig {
+ high_bitdepth: false,
+ mono_chrome: false,
+ color_description_present_flag: false,
+ color_range: false,
+ subsampling_x: true,
+ subsampling_y: true,
+ chroma_sample_position: ChromaSamplePosition::Unknown,
+ separate_uv_delta_q: false,
+ ..Default::default()
+ },
+ film_grain_params_present: false,
+
+ ..Default::default()
+ };
+
+ let mut buf = Vec::::new();
+ Synthesizer::<'_, SequenceHeaderObu, _>::synthesize(&seq_hdr, &mut buf).unwrap();
+ assert_eq!(buf, SEQ_HDR_RAW);
+ }
+
+ #[test]
+ fn temporal_delim_obu() {
+ const TD_RAW: [u8; 2] = [0x12, 0x00];
+
+ let td = TemporalDelimiterObu {
+ obu_header: ObuHeader {
+ obu_type: ObuType::TemporalDelimiter,
+ extension_flag: false,
+ has_size_field: true,
+ temporal_id: 0,
+ spatial_id: 0,
+ },
+ };
+
+ let mut buf = Vec::::new();
+ Synthesizer::<'_, TemporalDelimiterObu, _>::synthesize(&td, &mut buf).unwrap();
+
+ assert_eq!(buf, TD_RAW);
+ }
+
+ #[test]
+ fn frame_header_obu() {
+ let _ = env_logger::try_init();
+
+ const WIDTH: u32 = 512;
+ const HEIGHT: u32 = 512;
+
+ let seq = SequenceHeaderObu {
+ obu_header: ObuHeader {
+ obu_type: ObuType::SequenceHeader,
+ extension_flag: false,
+ has_size_field: true,
+ temporal_id: 0,
+ spatial_id: 0,
+ },
+
+ seq_profile: Profile::Profile0,
+
+ frame_width_bits_minus_1: 16 - 1,
+ frame_height_bits_minus_1: 16 - 1,
+ max_frame_width_minus_1: (WIDTH - 1) as u16,
+ max_frame_height_minus_1: (HEIGHT - 1) as u16,
+
+ seq_force_integer_mv: SELECT_INTEGER_MV as u32,
+
+ enable_order_hint: true,
+ order_hint_bits: 8,
+ order_hint_bits_minus_1: 7,
+ num_planes: 3,
+
+ color_config: ColorConfig {
+ subsampling_x: true,
+ subsampling_y: true,
+ ..Default::default()
+ },
+
+ ..Default::default()
+ };
+
+ let frame = FrameHeaderObu {
+ obu_header: ObuHeader {
+ obu_type: ObuType::FrameHeader,
+ extension_flag: false,
+ has_size_field: true,
+ temporal_id: 0,
+ spatial_id: 0,
+ },
+
+ frame_type: FrameType::KeyFrame,
+ frame_is_intra: true,
+ primary_ref_frame: PRIMARY_REF_NONE,
+ refresh_frame_flags: 0xff,
+ error_resilient_mode: true,
+
+ reduced_tx_set: true,
+ tx_mode_select: 1,
+ tx_mode: TxMode::Select,
+
+ tile_info: TileInfo {
+ uniform_tile_spacing_flag: true,
+ tile_cols: 1,
+ tile_rows: 1,
+ tile_cols_log2: 0,
+ tile_rows_log2: 0,
+ width_in_sbs_minus_1: {
+ let mut value = [0u32; MAX_TILE_COLS];
+ value[0] = WIDTH / 64 - 1;
+ value
+ },
+ height_in_sbs_minus_1: {
+ let mut value = [0u32; MAX_TILE_ROWS];
+ value[0] = HEIGHT / 64 - 1;
+ value
+ },
+ ..Default::default()
+ },
+
+ cdef_params: CdefParams {
+ cdef_damping: 3,
+ ..Default::default()
+ },
+
+ superres_denom: SUPERRES_NUM as u32,
+ upscaled_width: WIDTH,
+ frame_width: WIDTH,
+ frame_height: HEIGHT,
+ render_width: WIDTH,
+ render_height: HEIGHT,
+
+ ..Default::default()
+ };
+
+ let mut buf = Vec::::new();
+ Synthesizer::<'_, SequenceHeaderObu, _>::synthesize(&seq, &mut buf).unwrap();
+
+ Synthesizer::<'_, FrameHeaderObu, _>::synthesize(&frame, &seq, &mut buf).unwrap();
+
+ // TODO actual test
+
+ let write_to_file = std::option_env!("CROS_CODECS_TEST_WRITE_TO_FILE") == Some("true");
+ if write_to_file {
+ let mut out = std::fs::File::create("frame_header_obu.av1").unwrap();
+ out.write_all(&buf).unwrap();
+ out.flush().unwrap();
+ }
+ }
+}
diff --git a/crates/pf-bitstream/vendor/cros-codecs/src/codec/av1/test_data/av1-annexb.ivf.av1 b/crates/pf-bitstream/vendor/cros-codecs/src/codec/av1/test_data/av1-annexb.ivf.av1
new file mode 100644
index 00000000..1bdc6b4c
Binary files /dev/null and b/crates/pf-bitstream/vendor/cros-codecs/src/codec/av1/test_data/av1-annexb.ivf.av1 differ
diff --git a/crates/pf-bitstream/vendor/cros-codecs/src/codec/av1/test_data/av1-annexb.ivf.av1.crc b/crates/pf-bitstream/vendor/cros-codecs/src/codec/av1/test_data/av1-annexb.ivf.av1.crc
new file mode 100644
index 00000000..e69de29b
diff --git a/crates/pf-bitstream/vendor/cros-codecs/src/codec/av1/test_data/gen_crcs.sh b/crates/pf-bitstream/vendor/cros-codecs/src/codec/av1/test_data/gen_crcs.sh
new file mode 100755
index 00000000..007b63e6
--- /dev/null
+++ b/crates/pf-bitstream/vendor/cros-codecs/src/codec/av1/test_data/gen_crcs.sh
@@ -0,0 +1,8 @@
+#!/bin/bash
+
+# Generates the CRCs for all .av1 files in the current directory using ffmpeg.
+
+for f in `ls *.av1`; do
+ ffmpeg -i $f -pix_fmt nv12 -f framehash -hash crc32 - |grep -v '^#' |awk '{print $6}' >$f.crc
+ ffmpeg -i $f -pix_fmt nv12 -f framehash -hash md5 - |grep -v '^#' |awk '{print $6}' >$f.md5
+done
diff --git a/crates/pf-bitstream/vendor/cros-codecs/src/codec/av1/test_data/test-25fps.av1.ivf b/crates/pf-bitstream/vendor/cros-codecs/src/codec/av1/test_data/test-25fps.av1.ivf
new file mode 100644
index 00000000..83b53b27
Binary files /dev/null and b/crates/pf-bitstream/vendor/cros-codecs/src/codec/av1/test_data/test-25fps.av1.ivf differ
diff --git a/crates/pf-bitstream/vendor/cros-codecs/src/codec/av1/test_data/test-25fps.av1.ivf.json b/crates/pf-bitstream/vendor/cros-codecs/src/codec/av1/test_data/test-25fps.av1.ivf.json
new file mode 100644
index 00000000..195ed7c8
--- /dev/null
+++ b/crates/pf-bitstream/vendor/cros-codecs/src/codec/av1/test_data/test-25fps.av1.ivf.json
@@ -0,0 +1,260 @@
+{
+ "profile": "AV1PROFILE_PROFILE_MAIN",
+ "width": 320,
+ "height": 240,
+ "frame_rate": 25,
+ "num_frames": 250,
+ "num_fragments": 250,
+ "md5_checksums": [
+ "83dab175e49c33a6e3ece5c3758d1bf6",
+ "cedb4e25453dba430cb6ee830c1643f3",
+ "ef14d142df162819eee800f3930a9e95",
+ "11849ccb72cfdabc8f70e33271cd916f",
+ "7c9856ed61566f399a1eda2243e199ca",
+ "9394ed10354e986ecdfa2b753b921d2b",
+ "573005df5ba8f982980c1f427dfb472e",
+ "a96d9a913b1712f37f73b6c47b577cdf",
+ "91fc52b076badd1e6cbddb9bca5c5cc3",
+ "6253dde984bc5282f01005d7ebb55fe9",
+ "ad88146fe374423e7c597a922049c76c",
+ "ca7d1ddea7269e476b43a805bd5dd50b",
+ "e3d1eeec3cbfa363a2222d274890be84",
+ "fd7902a1b7352e04dc3940a010482a67",
+ "cada3ee9e33c11c99f89c3f439e2723e",
+ "1723ee290ae8be930f2904cb5aaf9de4",
+ "bf48d536e70a6a0a6549e221a833ebe4",
+ "f13b2e454420b1e0e5ab0adbbf2ce72f",
+ "31c799b4bb0971b798970e23b906cd25",
+ "3d925424bf645a225caf64757944a6e5",
+ "ac55ba724f54dd068350fd2818064dd5",
+ "a7125b8b0dc1e464e76ee64956897d22",
+ "f2a00db38d83cc778fa9fbdb3f4515e3",
+ "c804823f3401558a0283c4e77888af20",
+ "662d71a06319faef70a0981b664481d2",
+ "ad3a221a5f1f9d1a615733155a194385",
+ "8b071335d6cee4b227782415b1cb8a13",
+ "f3d98bfac8e5083233b88386b539b790",
+ "739c73e71590e64db0629911039962b4",
+ "0944990b0ada4012cc686b06833264ef",
+ "77e306874ec1b0c91668f8df0953831b",
+ "ca376820c5248cccb221ec8cb4b0eb9e",
+ "86a72cec3aaf50e393880ac8d4139921",
+ "b892ef1ff0c169b683b35cbaa9462ee3",
+ "b5feafe6c294d29adb1b05138803be36",
+ "3c3b150801f2dc48d300380c9a932890",
+ "16b06dfb6e426a1b6d88e17de83f5e2c",
+ "b1633b1c661a645bd1b04317b30fdbfa",
+ "56d08d66ad8042ba295c3f86025d44cf",
+ "78f6697fbb3af79dbd614f495c372031",
+ "afb700399aacde4c8c895def06fd8594",
+ "e7ae993d18af5c58047196d8369eee3e",
+ "65d5d77181388229606972ea99f5191a",
+ "bd336774b22d502d8fdca07d881d737e",
+ "5cabd4479d94c040f86892fa41860ca9",
+ "9ab949d5ede2f25889a9612b39f6f158",
+ "bb54bb8d7782c4b2d63f201a8d338e7d",
+ "9bf73fc10b4bb19021fd07586a0401d1",
+ "a37621cda632ac5f58e03272d226e53b",
+ "5c3ca20aa646d72b69f6e56592fd2f0b",
+ "b8ff47ec622ce73e70cfc913a3f8116e",
+ "1d020f74b9d3adf17b3f3da6992fcb52",
+ "0236c4d4a9aa68ba59eeaeb6b010db26",
+ "78a8e16aebbe5fc3d1e6051153031a51",
+ "78a54c1182b8ce007a2c10d17915272d",
+ "c7ac4f87168bbddd01155f54c79bc132",
+ "e074be8ece629e08d6d93029b8d34ce2",
+ "edfba91c624f4cdc558c693b33165542",
+ "f3d005151909922bfed7a905693de7c0",
+ "80118fa45af8b3e486928aae49d85b94",
+ "e7663b97fc9b26348876d5fa64a54d5d",
+ "69200a2a34bd4beccf4d473b4a4976f3",
+ "82f6c63a1d87037c08fba3bf16ef9bf8",
+ "6e3033f25eb56670a3c45c12822f340c",
+ "6085ac2c582fd3048c240d3dc46e3455",
+ "b4bbf1a7ae3f57b1d8f0ed65070e010b",
+ "e7f0aad67af5c7719eb89e457cefe6b4",
+ "6d5fdc1d68e136ce9095696be59b617b",
+ "bf15759321de7b21ec3c1bd2cb98ca69",
+ "fc4d67815a94c2e18e7d8b0b7d866641",
+ "0d96425a800252d500fd25da7dccb94d",
+ "5438c9e83cc90f030ee9b1876ec28bdc",
+ "a88915fd11ad765299cef49c8e65e8ab",
+ "4995a3442fa74849f3c45888037f9b42",
+ "82693761e531127d2a98cdc5615cdb92",
+ "07b9601bebc32dc33fd806f90cee586f",
+ "d68df0d6b1dae0e4428a17717723dbe0",
+ "2851422da5bcceebf57ae37a02a1fb57",
+ "ae9ff5d20ea6ba6105fb5ed3e0109834",
+ "a0f956663545e54acbaecf684d0841ff",
+ "23589649e474e155583e6742fa79098c",
+ "9031fbd94bd7a0508b48f8081018d447",
+ "b72920bce007e8f0584d615529dda39f",
+ "0638d4c62dbf43087b4831f2e39314fe",
+ "7d34a23c9b78a61da7a60c520784e204",
+ "0a3cf1af9095a7cb2787cf79ed257c59",
+ "1c05ab5abe793c14ee53ea80e170d6cc",
+ "02d0b03fe10b1b6675b86390fe317778",
+ "7639df2f62c4f958a90337b19a591530",
+ "6080ee3519bd5dd88fbb4050459c126b",
+ "75ce7282839cda34f7ca6111d6353cdb",
+ "2214093ad2bb512a223808ed78fe3369",
+ "eb9bfad6ef08a5f28b531203db3fcb43",
+ "cf4fd68dd57df907f35cc55fe5930fb8",
+ "0aaf799fc8509acd1168cd667f789c9c",
+ "e36ebe2332eb5a9a0ddd03469493d3cb",
+ "49ec5c818b0fcc02fbe3f5636417a2da",
+ "8430b81f1a90c325d116cec424d3c32c",
+ "c67e1e1f7fec9f9ab688f1d54cf2f4d4",
+ "fd98fabb3db5dc2d841dc50af7395130",
+ "8af0c8f486057cbae86939fa248c8238",
+ "e1888b1f32d2991682261f28f860cb27",
+ "9c0455744df622675a6d5232d790f5b1",
+ "acc73e6665f54bdaa98acead49be5f65",
+ "5c6e6167e6c05411a22c348a2c807fc5",
+ "89d09cb95dc2e212efed266b4b687b35",
+ "9d35702693b699ac0ccb4bffc559e2e8",
+ "afbeb04e4e00a1b0a4407b4a34815a63",
+ "6f3515d4331d83abfd1dbdfb2de78189",
+ "be6cb0da9149ad5d68269d0ed657cd38",
+ "9e9f498bc71df3097caa266089a77fba",
+ "40d9198beea17a254ee6b74544317a7a",
+ "e2f04358338ae115635e621cf229df56",
+ "5da22d2d7c5c304fc6198f809206de1d",
+ "4951c1ad5ea945a098c6a4d7fad163fa",
+ "5a25300d1ef28b60f9e137b47b2e4364",
+ "5954dd49f459ea4c0984dba30076db89",
+ "820a838b57e43271a55f2f17c3e0676f",
+ "b486477fe004ed8ee213afe8ecdb35c6",
+ "0715a96ada76fe2d713cdfc2b9abf11d",
+ "c30544fc39df1c7876043115ceed355f",
+ "1f7ce18debf0e339db20c68c1f0bf8b8",
+ "e10229f1f8a95d2e59a086e5d6ac4faa",
+ "8ad6c73b38d32fd1712a1fd67750d364",
+ "30fdf5b06ae3fd2c0df9e631ea1e1048",
+ "0026b1e7db5e25651ecaaf19685b2dc2",
+ "0b53f3f2ca17d00138b4678580d63ab6",
+ "cb08de2030a42826ef573082188d3614",
+ "e14242c776b3a32da936d1f6484e29ba",
+ "41a43d3ee9021bcda09efa1b218cc65a",
+ "9b884d243e8b330edb8f569e416960f1",
+ "5737c4f611cdc9871df094ba51a6a6d5",
+ "9d47768c1a15c0b20d28545ad5e6ca53",
+ "8c981af4e6c3432a330b6d8e330bc03a",
+ "195910783821f51cb3dad54f651c1a75",
+ "659833dc03dc5f929eb140e188f2b1f6",
+ "f2f30eaa72c5a093d67cebfda15fac73",
+ "3c521e3025340933cf826027a994114b",
+ "469b72a8db2ac77c70a792c8035b0288",
+ "e2cf1d7930d44341c5c363b0ceaa6c84",
+ "469d4283cca04e78ac2cb9407531db67",
+ "02416a6c77174796ecbd61adab5177b9",
+ "f89077b3dfb54119157e04dff24b79bd",
+ "2d1a8fc14b649e343288b5972abe1fdf",
+ "3d059186dab49cd8d13584dc365862db",
+ "765ef42f457dee16234df6992ec74cd2",
+ "957589c357d82631477177e6250c713c",
+ "2473af8395d08e9396216c082f854d6f",
+ "6a117d16f8e8ffe87aebec05844d6a0a",
+ "8e467cfcbd66ed80fca648248af56b3f",
+ "71e39c4304e09688750aa85e9d040f4a",
+ "3071ee85d87ef8029619d4777c799c2b",
+ "cc86f09e3f228001e806fd3afe5e1271",
+ "3828673cf67828240005f7bf9fe37412",
+ "12700b04cc22fba7688ae1709e48b886",
+ "a1045aa13b0007d23f22ad8e83c4bdb0",
+ "a12e6c2d2805336c407417b7503670fe",
+ "11dd1907c6785eccbedeba6a5708c516",
+ "3fb8be1276b83db1ccd8206cc69ec736",
+ "980ce03ae4e6f2eceb314f37290e0dd2",
+ "c39395d9b6108f1bd4ab1f004c44a5f0",
+ "a7244c89efd3b00611c92ebaf98793e8",
+ "fbede5a2957c023216e79cc31ab32946",
+ "bb40544a3adfe992e07a8eb3e5bf6966",
+ "0f71f57100699e95fff51dabde86cb42",
+ "6ba085efefacf385728423ca99bd4629",
+ "4df2d956234cb2129ebefdd90f28185a",
+ "d0a0d4263ef4f32d59b004752a5b94af",
+ "a9deed8bf550f4ee370730e1d993d4dc",
+ "eca65ba94930bf78854ce991c05e3d9c",
+ "4eef9fa5bca7ee74e97a0ac6e12e5f53",
+ "84e97d688ba1922f9ed71d72cea67259",
+ "407dc974664f93be14c53a2b291cc422",
+ "31eb9e589470cfbe4e72e1c441d56e3f",
+ "ea4f696ad2ae150a1f0e622874f67fca",
+ "7552fea18e053b4771c0490015488291",
+ "6863cd478581244fff72f6a0021a9fb8",
+ "9118deacdd49db27c317eeec868cd870",
+ "50290c87c5ee1c558bd304fc0f4a15ea",
+ "5aef6d78538151648450fd391c9deaec",
+ "a7e3feb23e01e0b4556446e01b2d81eb",
+ "6918645d2b0bd511247c6ed372bf213e",
+ "2f9661df4d114ab9f3a98a255a8177f2",
+ "baaea6f9f05a7a2bc10721f1afe6f57b",
+ "366ab99c236a8e84e658bad69d82a1ba",
+ "f950a6508c051ef32e4c04be56fcc719",
+ "9e586c73c3b9daebc608600efbee33b0",
+ "e9fb7690077e8cbac15d5564130a8d7c",
+ "ef3c8d2b5376753c26a795bf403cdcc1",
+ "be46eec37b67dfc8077705ce89588a7c",
+ "dba1b08cfeddbcf4e8d79621ee343bd4",
+ "a4a612bcb6c33c7799433c998c5f12d1",
+ "5f45fa214bc860825510d034f1ff26de",
+ "1766dd6fe6080c408a4baca135609f1c",
+ "34dc16d50d7afeb93a874563f1f5e4fd",
+ "0a5314f217972a9271c4792921f61153",
+ "7c228f1f5ccc6f7307526531f79a307d",
+ "188544479f5a44b6a90b6be62e33611a",
+ "9cb9be5574c6a2c06862a3ed605c68b5",
+ "845b033cc82472d8e647f2a3bb3eb653",
+ "2c6b66c68107fd13395a1ed5f0639355",
+ "0436424e24e562c52ab7e7063b04c129",
+ "21248608746bb252faa347028f5343d7",
+ "81607476ae05bbf7386dea9d8eac352b",
+ "fadc83171e49e779ebe5d81769049cef",
+ "e768c96238a8cf14caf8d03420981265",
+ "c57aa4d8e2f7c9101868246de4de1c13",
+ "b405a01f8eb1d4ffade0e49f593e5a8f",
+ "76f02bab5b932bf4bcf4ce06bdf0e42c",
+ "51b09ce7117e15cf654ad76e13263f0c",
+ "45f650b845e31b87b522574cc7afde80",
+ "858605e70124ef7130742b713b079ad9",
+ "5d955329a007742ecab7153d2e69b262",
+ "c4139450cb6ffcac62b764d62083bc31",
+ "8b13de43cffa8d12dd17b8e749a375b2",
+ "b000fbdb48be876302bc336aeb6deba1",
+ "88e2b7abbc33f70231889113582f8f8c",
+ "d9f31d4cfeee31da719b3567d5d11a19",
+ "7c2a6cc9be9ce8cb96b5a1616909941b",
+ "954c2be78496f0235ab137a98a5ae11a",
+ "9efd13fe15e8900f67a6c76103c9ce78",
+ "b04aedbee4993ff955ebba1dcb8a04e1",
+ "83b045a2a43445f97d82c1faaf33b332",
+ "1cf416bf7bf4a2124932d4b1bb0aca94",
+ "ac17d329b587b065512269fa3def8279",
+ "fcf2b7ab8b7d53741c737f75c3587a6f",
+ "0aaaaca0aa165a6786e2161043aa1e72",
+ "8d19a0848fad7b32a15522cc0b24b4d1",
+ "be0a1be3f90ff47b80be31be021c28f1",
+ "c9e423c59186d93100c56ad8f14c0fb4",
+ "052dbb80693750c716acce06f3ad7266",
+ "6a2c8002df49d3832b7e1abd70af542f",
+ "92bec3aa91edfd2cc5dee7d1f66ac189",
+ "579d29110e7a7a71152aedb9a462c79f",
+ "b0bb435df9dd211dd5da3c547c8887b8",
+ "fb7a3cf05afd06668287f5dcc9c20a55",
+ "bbd27b9b555f361478f9516e839077a5",
+ "a74dc95fe982709b25434bcc53a91973",
+ "27f82418568440caea8df7bcdf56eae7",
+ "d5ff54f75c8fa6d60428816945ee5e89",
+ "4b6677c4cc9866f477ecda5618411c8d",
+ "d56046f25113a82b090bf9a91291587c",
+ "cb56aa0f4343c7da821c04e55e8af21a",
+ "c633ea8a4c20ea4d70c8c241d0293e9b",
+ "dd2b157ce8a010a61908170ecb3e31b0",
+ "3c3509c92b03a702ac1f4a28b5abd3d5",
+ "d1400e54b8b61241cabad5291d6e3a43",
+ "c29470cd6afb0aee4ae4a8d0622a468d",
+ "e35764f7bd48746d37478b2d6f3f2755",
+ "3dcf1fd38fbcc1d45f98574b17ac5710"
+ ]
+}
diff --git a/crates/pf-bitstream/vendor/cros-codecs/src/codec/av1/test_data/test-25fps.ivf.av1 b/crates/pf-bitstream/vendor/cros-codecs/src/codec/av1/test_data/test-25fps.ivf.av1
new file mode 100644
index 00000000..83b53b27
Binary files /dev/null and b/crates/pf-bitstream/vendor/cros-codecs/src/codec/av1/test_data/test-25fps.ivf.av1 differ
diff --git a/crates/pf-bitstream/vendor/cros-codecs/src/codec/av1/test_data/test-25fps.ivf.av1.crc b/crates/pf-bitstream/vendor/cros-codecs/src/codec/av1/test_data/test-25fps.ivf.av1.crc
new file mode 100644
index 00000000..43013f62
--- /dev/null
+++ b/crates/pf-bitstream/vendor/cros-codecs/src/codec/av1/test_data/test-25fps.ivf.av1.crc
@@ -0,0 +1,250 @@
+6aea6152
+cb4a90b3
+fd83e35f
+074bd081
+216fcc04
+c73ca1e4
+fbfb2a30
+cd587935
+e8bc2912
+051517b7
+f3e9831d
+812e7bba
+3e2054e6
+7446385e
+8b75d043
+f930d9a7
+7bf6b591
+253c5389
+11a25f1f
+c5101d08
+ee1c0aae
+ce055a9f
+0ed4a046
+aa0a72c3
+87f7a598
+aa3a422e
+0ee0e533
+5ce3d683
+cc7e88e5
+3e1c7774
+bd6708d3
+0ba6a0ee
+ac00d2da
+f1222e65
+3c6aadc8
+a28e7327
+fd2d0d8c
+e0a791bf
+90a33d7e
+63ae28ce
+26230e31
+215e9021
+6ca1295b
+01604116
+15f8d3c9
+6f28a1d4
+8d54633d
+08cccd41
+0b082923
+0aaae5a1
+98310e98
+33f12578
+9fd072e0
+36a1220e
+a278c894
+828dcf3f
+3573505c
+861874b7
+dd78b1fd
+310ca9a0
+74d670f3
+93c48c50
+814991b1
+fca836a7
+9299e121
+a8d3b267
+661a1c05
+50038462
+bc866fe1
+46e2d826
+7035f78c
+00c2ed17
+6b64a0c6
+315f4761
+df4c3ef7
+7ad4996a
+3185972f
+19af5f17
+01c4e3a3
+3728bd7e
+16adc384
+5798878c
+d0ac34ee
+56f76f8a
+2b6f3f47
+4a5ec1a9
+75f0027c
+7a1dd1f6
+50c0f14f
+978d00e7
+a1c430b8
+7c67432a
+4615b4cb
+c53c7308
+876d9f98
+b0015dd1
+73288a1e
+d843f40a
+4127f309
+3adbe013
+9e84104c
+9f98680d
+380a36e2
+2202f414
+ca931e02
+182b20e1
+815a6be2
+59cc5d53
+0a05d420
+d53b5f2d
+98c613aa
+e4de4fc1
+2b8f6d29
+48ce9586
+d6e822dd
+c8674577
+75dfa0e9
+7ad6ed39
+f7725767
+a44e0f11
+bcd743cd
+1ccf1835
+8ceb6153
+0a43af09
+79bab263
+855dd65a
+a37d34fe
+be063b4d
+aec5df0c
+7b12399b
+c5ad7294
+2f609050
+8bb2dcba
+c19aa763
+700eb99b
+11bf5174
+e74d5eda
+f54e54ef
+0173e328
+162372d6
+3c8f18a3
+ce8579c7
+91bdbf86
+745edb27
+df783664
+e7462cfd
+30d8d761
+f15474e6
+4c5bb874
+27c36dd2
+c40981c0
+1cc4b7c0
+ebd96a40
+a5f4d31e
+cd1a957a
+0b0d8e1d
+c5d30b99
+d7d6b75e
+0ea512b8
+dd12fced
+29eab68d
+e4bb47d1
+e3060770
+0483e6ca
+296b084f
+d11abff6
+c7589394
+b187d62e
+2e217b3c
+b516603b
+287c8b71
+2f24a994
+7ea617d0
+7ba0024e
+7067ae3e
+95650cbd
+7b2e7deb
+d1b6da6d
+76f22a5a
+9ce6fac7
+1e5cf6c7
+bbe20b47
+2f2cc450
+3f0297f3
+a2084503
+06487daa
+5d06ae48
+02cbba1b
+b386b4f4
+47623370
+1acb6e9d
+5b55fd00
+70d43ae3
+8a0703c0
+4d62a79b
+e358a27d
+b89fcec0
+59508160
+f2c9f57d
+2b57ec09
+9427c163
+91169e76
+eda7cda1
+289c7bc0
+821dc9d5
+b003d6ce
+3d8dbc53
+d6c3324a
+76a7b9c9
+a4d4b21b
+51ce1f2c
+49cc8861
+b4fc2309
+c435862e
+3bceba0f
+7ee0c219
+cb04facd
+b2fad23b
+2b8cf4f1
+fcdcbad2
+f3c038c6
+71e639e9
+282325bf
+52c64dc8
+9ebe8705
+f8679dc3
+906116a2
+9f740960
+3cad2af8
+c7765bb4
+c8f38650
+1e5d7d36
+3374dc4c
+e83476e5
+6a9c0d00
+08b8cb58
+bd74ea9e
+399bce4c
+1577335d
+cdbbea48
+d1373c35
+cc62212a
+8a5e59e2
+75f5f297
+8c5f3776
+fce09105
+92b2d17e
+416e8530
+968d1450
+d20688a8
diff --git a/crates/pf-bitstream/vendor/cros-codecs/src/codec/av1/test_data/test-25fps.ivf.av1.md5 b/crates/pf-bitstream/vendor/cros-codecs/src/codec/av1/test_data/test-25fps.ivf.av1.md5
new file mode 100644
index 00000000..ad04cf61
--- /dev/null
+++ b/crates/pf-bitstream/vendor/cros-codecs/src/codec/av1/test_data/test-25fps.ivf.av1.md5
@@ -0,0 +1,250 @@
+ce5386b1beaa89f73a668d3720717fb4
+8f5d21bf3d78d9c242609bdd8df6cfd6
+7d75a95c82171c8cf4b09d694d4cbef9
+20d4bebdc51702ee7f40e187747696c7
+9c55dc575db2a189c5576537afca2c54
+68a15a8cdbc0aeaf10dff65db4d1a810
+dfd03584b10852eb16901d52578d8f8e
+a9a0cffed57bba344c9366ce91408e26
+9fdf7ac0fc07f2391da56462faf3e2e0
+b83d2da8f82e1a06d26bbb514b471f4b
+17c92a58fb68d0b3b02cb5b9105dbb37
+1e5bd3c05fb67f2aefc01611ed43d117
+eb287667a027f3e5325bfb27652021a6
+67e388816af98b99e4b9134516205c52
+35cba13cd8a6f23d6dfd95803af0886b
+45966e4a1b83dce6a2b0c259fea10cae
+416a95236e46a7bb0f11cf1147631979
+f23ab59d3c4efbb8eb2d80d67a2e5136
+ab7bce374a3468c03483418ccffb52de
+bdaaf22c6c4e58d393d7c051d4d0ae8a
+6f7de2de3e8d79c726f0f2c2fe52ee58
+d2fc7067797bbffe3765a238ff803b85
+769dbc781b43759287da0b2888e8338b
+2abd608af57978290e24c4cd62e4904f
+4fb54d7b0a71a4d3ca95b56d7b3d9a81
+262ba91321a0edac67c01e6ddcc2e4f7
+4c9c2d967fb853ecdc6042f223a7d138
+f21ccd6a4eb5f561b0a0eff9cb1956ec
+3c206ed277864249e7eaade75e71c815
+7167fed00621472662b19a0215dd00c8
+76e6f142e710ff5d7f6797d3fc1b8dfd
+4d814bb1fec0a2bca9d92140d5734ae0
+65b576bf469b182c8954591fd15dd21c
+abb7e8f11617aa0c9bf6870e537b008d
+02b86ea6b2f8699097d6899ab1f073c4
+610786c84b9fc118679afb09404c15ae
+7feb8fae65767f848ebbefa730f15d68
+12677768a4266571e85b750b51ef9fc8
+5b6541b178f6a885d0439b381e501967
+352cc90ecc1f3e26c19970f106c475fa
+9c5215a9fce00f0ec30615649171f8e4
+27e593a4b30c0b64939c62e5e0488e5a
+d8a5fd54958527ecefc642f6730e4164
+754dfeb4337108e534ba70bab429777a
+821ad11c37ffda3ad5438b57a9523e9f
+add12a889a5e08a5358e2e0e086fe522
+fa100278f49cbb7f9c9d7dc5e12fc0e1
+ef46a151df454084d0f0bc644adeb47d
+c02f8023a4be8a3249bcf6e1b223dffa
+41a11da85806e85fa86a9de41e1cd93f
+e792d89b5df357d1b03b1812a762832c
+90f72aead8124bc6ce51495b4b99da75
+af25c00b1990b778b50f529ae81efa30
+900f66f0e222a8d253153711a23a5ee9
+0850cad30d59e1b5e5e2943e6b916d0a
+03ca961e9876ee96b14711c44a9f2a69
+fa6bf9c30dd8618fdab499e9dd217582
+4e09e08e1f99bf210d4757281ab4c836
+dbf2bc5355a6846a028a7b3140fdef34
+b38e1973cabab58f8137cf66fc7fa3aa
+0ee4998cda155ca2823f5c9336a62cc2
+4f9918b4782a59a0361619389bd22d54
+c5c82a59505a9888b95e012a068b3254
+5eabc71dca6f57407ba306db416c5031
+41b8b1155bf6144aeb822acbff051e1a
+12e7d40ccd4298400cf3b5577370bff8
+2f22b7979183c9c3b26838c7e84a49a8
+68af2e17a487001d9374f6b38ed950af
+3a55bc482844ecc366e10544c38cc890
+6a08d19bbecb554837c9922b9818455a
+b2f95f48c1214a5dfb8f4528afcbf901
+c3c4fc391a1a040c71cb65a8c654a5b1
+86786c55d138bb9a4a4165522cd15253
+b329ece66a9dab6bebab9e3687629e7c
+7d6d818e7fe9a9b335c72ee6aedf9980
+317956c14cb119eda584de03dbf089cc
+d095660e8dd16899be9e916e0ff7946c
+12571880bd56bed1bbbd034094fabbaa
+7f702375e8c43036e36ddc07b543afb2
+e254d4c9854b28db694fb5477144551e
+24a4b250bc0461ad4894334838fbb645
+16b3dca0bfcad463498a62bf8a3f06a8
+77dbe27a373d87a6fc1012caa166a0a5
+1b304ea04baf90e1bf11d6296f64f933
+42c94efb8ab8ceb6ff98497ef0981c66
+1074398b6c210e833b4135c7d2caeb91
+3bce8712a7ba7b037a2cc85e4f72aea4
+42c1bc84350e82cbead374b41732d8d5
+76f8fc8e26d1b64e8afb8f263ec3f795
+ef9f8b042eb888f5408ccb500c9a157f
+d46505a331887bf49e157f8de4c17a98
+0be7df49394337bb277b63a6b9147520
+deb977415048b0b7fa1fd02878c1b10e
+a0395e32b4cc279f8545b791cee5d394
+c7dcd8741840799886a1f3b5208c0b36
+02b1297f58b9e699f232b9ed7e8bbcd0
+48852b209e405d7aaab50c5810448579
+d8a5598b2e7183d72cd3a81e54f301ce
+dfe2e4af7518f0d1f04fd825069d575b
+e1a70679c95173e6a1504b7c52dd0d3c
+16ae515dfb1268052bfe330a1cbbbffa
+f17c090f2140cfd3060558ceefe4d1bd
+58b1ba1fbbd76670c9218a846a8f6baf
+f543d8380c2d095f9b62d4ffaaee7467
+1b16d3e1d688a5a905ff22680ad803cb
+12e16d58422d5a5899379f11c6ca5b9a
+f1986c3e4a4545356656f76c27db0ae7
+324a3d45f631aed6c758888254ae07ad
+49532c06798f685e2a41dc683b081f79
+95934c5a6e2cc8de08c8b8342936cf38
+67d89790392f18908c24cc36bbe50362
+c4f963cd490f9241f4959cca6a6d35ce
+b21db693ba10898ec3205cb0cb343a02
+72e63227e74f2473a44da365fa9bc02f
+220d247b6c0f9512256dfcdf95582148
+86c290279ffa61ca615f1f8f8877e807
+6651d56c548fd4c5e8b2c86354c28ca3
+d863321ec53cd582d34a8ee5e88a5576
+f262bda775cf67026d8d226620c9d4aa
+15816d939647890021ac31aa1c3b2f75
+229b295a4bc44d8522580dd4383812d0
+833afe87641e34e60f2d127f44a7cbeb
+62cc76ec3a853878ebfff04ebbc8addc
+40fca93e2d6a976de641cdbfb56257b5
+65d654e9145527f8fcd24608d64f68f1
+1b2b0c68b6d9305f46642109b92a234b
+85aa859b29f2caeb60343cf53718e451
+3aa590c6c8a4dee128f1e7fcb2b82a2a
+699cb26687934746b722e2dfbc1d2c82
+9cc9b7f51cbdbaf15bc8eec9c1a1cf7c
+b1be900fe6a6eb21a563754420c5f38e
+47976686aff65b42661ae0fb2685f462
+6b3f96a1be97c4c2a371d5935672096a
+ac9b60c754c95ccbaf56f68544712dd6
+7dab91b68788d2ed61cd40d3073091a8
+35b367c591e71f11ddcd9dcc75be79e7
+d3321d793265630e81e6d52b20e58f44
+9d97047182efd2ba0594a569f6f2ce04
+14c772a342a28bd6785bb722e67fc767
+288802e107c373c9d28eeb3f8726214e
+1c9d8ff04c346a59ea4f3a349dc4b891
+2c857a65df4619d06f424ddcccbd2221
+10a0b3e4e7825d21fc22bcff34a3b26c
+78c8a5ee6e6880a3af222bfc27de62a1
+9e16c4346a69ff9127bb6c9287d98859
+1f1d95fa30c9c3a58f41d9657aa0e6ec
+5e8c6b3b4690da7f4175abe288d0c509
+0bf315da2ec1e135963cc4c9cf73ea1a
+2992fdf295438ec9f8dc7979b6d4e5ff
+a3d43afab0119aa3b6e38a81d244c388
+889d049dc64457637ad089e18e718a23
+46016c611b9323fe8f4206bd393a6741
+f555b79be75ba2a1a741f467192b693e
+242d4b4c323c7c1e9648de52ec8d7c2c
+383d2ee4d28919f193f28448ba28ddc6
+2c7cd221bd1025547fc654ca6717553d
+e16de72e05b548758832102ffb39d242
+5cecf3fc2823225f0f1748a1fedadf35
+4e709cb904317a43ffd94739281d32bc
+b6dfd4657668ed2c1ebaff9fa92702ab
+3c618cd95706cc25a0565fc0ed00e352
+dca8dbc91708a94525f16c064454a2ce
+fe3fbff45e30dcc3fa4f57ae78114f7f
+0f7bc1eab5cf9faeaa127c0243675253
+19b6fca6e3f0d039074753265436d2c5
+fce950fc2ec2526c0b29b6869ff58dee
+4c9c0b19668dc20a9fac84e13c590deb
+8fe06eb38ee870ffd7cb9f065476ac78
+515ce9eaa9a6970f809475e416325123
+6d58868e827dd9dca698c5b24380fea7
+072951a0e1d06aa829d716a86ae498fe
+07f23add152c44f754eac930093e6b59
+e98798eb29c162ddfff7ec72aa7b65dc
+62f4e1ca0294a3944224fb4a4280ed56
+28fc910d3b7a926f63e7bfaf18878cc1
+40065fe5c0e32a16622988bc1485a038
+b2623ec75309e28c6c0a4b179e4acd6d
+3ea6b991014bde2185be7a6c92745c28
+5fde25c7fe79a9c0e2b86eb1878de02c
+5bf42dc3006f4c601d01ee4820e44d38
+44500b37f18b2eb499894bc1ff1efdcc
+f5bfe3352c4281083083e51ef1fe0a72
+abf9c6ba639f68d9b8f8c0d9d97a19d3
+75f6dc9ccbc6a1381785bf9440a95744
+4db0fd27cac20f59718fe00c5dc13202
+9e0d611017698f2d1716f8d9d81a8bf7
+13c7015f10b37b3dbe1618cde5edc2ee
+70e2a0182471290a46961a0d62611053
+47ba942fc3396104b3731ea40eb97339
+bf10238458969233c0062b09a68f22a7
+115b7375a9aa156b8203dd88acdc5672
+1b39aa22702c993aa1e7606e9afad9c5
+c85e67c08e02538f151c6276662ba69b
+89dcf41c5adb944bcd46ca3f67666a75
+90fd81f9b572ede873313f4faa58da4b
+00badd56e7d5b2dddb10ef7de05be515
+a13c3404ac033c9fce8a6435f2a4a416
+af83e8f7af9785c96ff61c354417aab4
+5176b27945cc7686520b1425144dc4d3
+e5f248be2c0e83ad0a6bfd2eff759f6e
+cd693cce87898dafa5c68dbaeeb151fa
+2a47245fc3da1229e3dc288f216c4e20
+c6f8e88fbf5566000f8f86b0d4bf9020
+3e88c5f7b571a292c998cac33b41215b
+2a2e8271ecba2cec040ef343317e2ae9
+8e693282602bde3452061affde3ce514
+992acab07cf4d6aa5b95b4c4cc33cf0c
+6db1ad3494be9c3c9758b00d956bd2cb
+824d130a16d7bc2c6d6b26c31c2a0e05
+d286bd8f5cdfd65b695815ff68bb191f
+4c5bbeecda37bf4fb6dd79f266aac3d6
+c4f64e991e13dfc3913246f730c31e87
+459d8fd53975479aa977c61dc3ef1b9e
+ece59558539b52684433b54bf2c7e214
+4362122d7ed40dd5ad0886cdf901539e
+66ffe4fb31a5e4fa9462a3aa57224476
+86586a04e75ebde21903f407e6037e50
+93b2e3af91cb24ffafa6418c76cc1ce7
+41ca4598aac764fa944d8f578b2ab5ab
+6ef7ce05836d63520925817c220a5274
+c4e902503f3d5602ba2454907d7809f7
+8f3cb447682bebd3a230740e11d35dff
+4340ec4c3e62118b2749264393fc78ee
+8178fbeab83126f2111ab74c23d241c9
+db298bcb2a999b7ac2037991ef078d32
+f586895d6dca606e2d62dfdc92cc2021
+b5aaf4b91dd7b6cda3a2635c603c4500
+0f024b59afa957b59f5ebb9b63ff1b1a
+41acc378b08b5d9b7da2f644b79aebdf
+cd173062829e6e86eb094b8d40d16579
+ef55ddf0fa94dcb4f275033bb55e8466
+48a3efa1f9d8291d99ce434fc5474fb6
+731a649c764fa964d6e2ce640b34c25a
+5f9ac7b1dca56c8dab9ce1f92341094b
+e9b0ee7355299aaf55cce1e240050125
+8a285fc7c728cdfa1f4b651c64eab7e5
+05823b86e463ad514a4cd7eacd9c01bb
+0ce34318119eb0e8921b5e798789bea0
+e46f4c793b42136b1eefbece7b867052
+1331c7fcae627f290299b978299a9b48
+285c5783029a7b23374e91cce19df0de
+670fba4fad181308c15778f38e619646
+46a3350a39c21f45bafed75d339ed101
+b1d6f3230e58d2647d1aa4a5446061ed
+f6eb5936ec9bb3212b14716da8329839
+1ecb00343900a550ad33ba10777df23d
+4b9f70244adda8e0a42f4da7341b8d84
+6caafeb26793a011ebef352ef1d1aa34
+723ab0797281e7ee36109b53140a324d
+7a5e9be8c7c8307aa22c8b48708424a2
diff --git a/crates/pf-bitstream/vendor/cros-codecs/src/codec/av1/writer.rs b/crates/pf-bitstream/vendor/cros-codecs/src/codec/av1/writer.rs
new file mode 100644
index 00000000..fcc8fa4d
--- /dev/null
+++ b/crates/pf-bitstream/vendor/cros-codecs/src/codec/av1/writer.rs
@@ -0,0 +1,203 @@
+// Copyright 2024 The ChromiumOS Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+use std::fmt;
+use std::io::Write;
+
+use crate::bitstream_utils::BitWriter;
+use crate::bitstream_utils::BitWriterError;
+
+#[derive(Debug)]
+pub enum ObuWriterError {
+ BitWriterError(BitWriterError),
+ UnalignedLeb128,
+}
+
+impl fmt::Display for ObuWriterError {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match self {
+ ObuWriterError::BitWriterError(x) => write!(f, "{}", x.to_string()),
+ ObuWriterError::UnalignedLeb128 => {
+ write!(f, "attempted to write leb128 on unaligned position")
+ }
+ }
+ }
+}
+
+impl From for ObuWriterError {
+ fn from(err: BitWriterError) -> Self {
+ ObuWriterError::BitWriterError(err)
+ }
+}
+
+pub type ObuWriterResult = std::result::Result;
+
+pub struct ObuWriter(BitWriter);
+
+impl