Update dependencies

Cargo.toml

@@ -14,16 +14,15 @@ path = "src/main.rs"
 
 [dependencies]
 dolby_vision = { path = "dolby_vision", "features" = ["xml", "serde"] }
-bitvec_helpers = { version = "3.1.6", default-features = false, features = ["bitstream-io"] }
-hevc_parser = { version = "0.6.8", features = ["hevc_io"] }
+bitvec_helpers = { version = "4.0.0", default-features = false, features = ["bitstream-io"] }
+hevc_parser = { version = "0.6.9", features = ["hevc_io"] }
 madvr_parse = "1.0.2"
-hdr10plus = { version = "2.1.3", features = ["json"] }
+hdr10plus = { version = "2.1.4", features = ["json"] }
 
 anyhow = "1.0.98"
-clap = { version = "4.5.39", features = ["derive", "wrap_help", "deprecated"] }
+clap = { version = "4.5.41", features = ["derive", "wrap_help", "deprecated"] }
 clap_lex = "*"
-indicatif = "0.17.11"
-bitvec = "1.0.1"
+indicatif = "0.18.0"
 serde = { version = "1.0.219", features = ["derive"] }
 serde_json = { version = "1.0.140", features = ["preserve_order"] }
 itertools = "0.14.0"

dolby_vision/CHANGELOG.md

@@ -1,3 +1,7 @@
+## Unreleased
+
+- `ReservedExtMetadataBlock.data` was replaced by a regular `Vec`.
+
 ## 3.3.2
 - `rpu`: fix `write_rpu_data` allocated capacity. Now static and 512 bytes.
 - `RpuDataNlq`: fixed incorrect written data for `linear_deadzone_threshold_int`.

dolby_vision/Cargo.toml

@@ -9,7 +9,7 @@ description = "Dolby Vision metadata parsing and writing"
 repository = "https://github.com/quietvoid/dovi_tool/tree/main/dolby_vision"
 
 [dependencies]
-bitvec_helpers = { version = "3.1.6", default-features = false, features = ["bitstream-io"] }
+bitvec_helpers = { version = "4.0.0", default-features = false, features = ["bitstream-io"] }
 anyhow = "1.0.98"
 bitvec = "1.0.1"
 crc = "3.3.0"

dolby_vision/src/av1/emdf.rs

@@ -6,25 +6,25 @@ use bitvec_helpers::{
 /// Parse the expected EMDF container with fixed values according to spec
 /// Returns `emdf_payload_size`
 pub(crate) fn parse_emdf_container(reader: &mut BsIoSliceReader) -> Result<usize> {
-    let emdf_version = reader.get_n::<u8>(2)?;
+    let emdf_version = reader.read::<2, u8>()?;
     ensure!(emdf_version == 0);
 
-    let key_id = reader.get_n::<u8>(3)?;
+    let key_id = reader.read::<3, u8>()?;
     ensure!(key_id == 6);
 
-    let emdf_payload_id = reader.get_n::<u8>(5)?;
+    let emdf_payload_id = reader.read::<5, u8>()?;
     ensure!(emdf_payload_id == 31);
 
-    let emdf_payload_id_ext = parse_variable_bits(reader, 5)?;
+    let emdf_payload_id_ext = parse_variable_bits::<5>(reader)?;
     ensure!(emdf_payload_id_ext == 225);
 
-    ensure!(!reader.get()?); // smploffste = 0
-    ensure!(!reader.get()?); // duratione = 0
-    ensure!(!reader.get()?); // groupide = 0
-    ensure!(!reader.get()?); // codecdatae = 0
-    ensure!(reader.get()?); // discard_unknown_payload = 1
+    ensure!(!reader.read_bit()?); // smploffste = 0
+    ensure!(!reader.read_bit()?); // duratione = 0
+    ensure!(!reader.read_bit()?); // groupide = 0
+    ensure!(!reader.read_bit()?); // codecdatae = 0
+    ensure!(reader.read_bit()?); // discard_unknown_payload = 1
 
-    let emdf_payload_size = parse_variable_bits(reader, 8)? as usize;
+    let emdf_payload_size = parse_variable_bits::<8>(reader)? as usize;
     Ok(emdf_payload_size)
 }
 
@@ -36,79 +36,77 @@ pub(crate) fn write_emdf_container_with_dovi_rpu_payload(
     let emdf_payload_size = payload.len() as u32;
 
     write_dovi_rpu_emdf_header(writer)?;
-    write_variable_bits(writer, emdf_payload_size, 8)?;
+    write_variable_bits::<8>(writer, emdf_payload_size)?;
 
-    for b in payload {
-        writer.write_n(b, 8)?;
-    }
+    writer.write_bytes(payload)?;
 
     // emdf_payload_id and emdf_protection
-    writer.write_n(&0, 5)?;
-    writer.write_n(&1, 2)?;
-    writer.write_n(&0, 2)?;
-    writer.write_n(&0, 8)?;
+    writer.write_const::<5, 0>()?;
+    writer.write_const::<2, 1>()?;
+    writer.write_const::<2, 0>()?;
+    writer.write_const::<8, 0>()?;
 
     Ok(())
 }
 
 fn write_dovi_rpu_emdf_header(writer: &mut BitstreamIoWriter) -> Result<()> {
-    writer.write_n(&0, 2)?; // emdf_version
-    writer.write_n(&6, 3)?; // key_id
-    writer.write_n(&31, 5)?; // emdf_payload_id
-    write_variable_bits(writer, 225, 5)?; // emdf_payload_id_ext
+    writer.write_const::<2, 0>()?; // emdf_version
+    writer.write_const::<3, 6>()?; // key_id
+    writer.write_const::<5, 31>()?; // emdf_payload_id
+    write_variable_bits::<5>(writer, 225)?; // emdf_payload_id_ext
 
-    writer.write_n(&0, 4)?; // smploffste, duratione, groupide, codecdatae
-    writer.write(true)?; // discard_unknown_payload
+    writer.write_const::<4, 0>()?; // smploffste, duratione, groupide, codecdatae
+    writer.write_bit(true)?; // discard_unknown_payload
 
     Ok(())
 }
 
-fn parse_variable_bits(reader: &mut BsIoSliceReader, n: u32) -> Result<u32> {
+fn parse_variable_bits<const BITS: u32>(reader: &mut BsIoSliceReader) -> Result<u32> {
     let mut value: u32 = 0;
 
     loop {
-        let tmp: u32 = reader.get_n(n)?;
+        let tmp = reader.read::<BITS, u32>()?;
         value += tmp;
 
         // read_more flag
-        if !reader.get()? {
+        if !reader.read_bit()? {
             break;
         }
 
-        value <<= n;
-        value += 1 << n;
+        value <<= BITS;
+        value += 1 << BITS;
     }
 
     Ok(value)
 }
 
-fn write_variable_bits(writer: &mut BitstreamIoWriter, value: u32, n: u32) -> Result<()> {
-    let max = 1 << n;
+fn write_variable_bits<const BITS: u32>(writer: &mut BitstreamIoWriter, value: u32) -> Result<()> {
+    let max = 1 << BITS;
 
     if value > max {
         let mut remaining = value;
 
         loop {
-            let tmp = remaining >> n;
-            let clipped = tmp << n;
+            let tmp = remaining >> BITS;
+            let clipped = tmp << BITS;
             remaining -= clipped;
 
-            let byte = (clipped - max) >> n;
-            writer.write_n(&byte, n)?;
-            writer.write(true)?; // read_more
+            let byte = (clipped - max) >> BITS;
+            writer.write::<BITS, u32>(byte)?;
+            writer.write_bit(true)?; // read_more
 
             // Stop once the remaining can be written in N bits
             if remaining <= max {
                 break;
             }
         }
 
-        writer.write_n(&remaining, n)?;
+        writer.write::<BITS, u32>(remaining)?;
     } else {
-        writer.write_n(&value, n)?;
+        writer.write::<BITS, u32>(value)?;
     }
 
-    writer.write(false)?;
+    writer.write_bit(false)?;
 
     Ok(())
 }