Implement RPU parsing (#1)

Implement RPU parsing according to patent No. US 2019/0373290 A1
Allow processing the RPU when demuxing and extracting

Author: quietvoid

Cargo.toml

@@ -10,3 +10,5 @@ structopt = "0.3.20"
 indicatif = "0.15.0"
 regex = "1.4.2"
 ansi_term = "0.12.1"
+bitvec = "0.19.4"
+crc = "2.0.0-rc.1"

README.md

@@ -1,12 +1,21 @@
-## Rust port of yusesope's python tool.
-## Credits goes to them.
+### Options
+`--mode`, `-m` Sets the mode for RPU processing. `--help` for more info
 
-## Commands
+### Commands
 
-### Demux
+#### demux
+Rust port of yusesope's python tool. Credits goes to them.  
 Demuxes single track dual layer Dolby Vision into Base layer and Enhancement layer files.
 
 * `dovi_tool demux file.hevc`
 * `ffmpeg -i input.mkv -c:v copy -vbsf hevc_mp4toannexb -f hevc - | dovi_tool demux -`
 
+#### extract-rpu
+Extracts Dolby Vision RPU from an HEVC encoded file.
+Supports profiles 5, 7, and 8.  
+Input can be piped.
+
+* `dovi_tool extract-rpu video.hevc`
+* FEL to MEL example: `dovi_tool -m 1 extract-rpu video.hevc`
+
 More features may or may not be added in the future.

assets/data_before_crc32.bin

@@ -0,0 +1,11 @@
+Differentiating between Dolby Vision profiles. 
+##### Profile 5  
+`vdr_rpu_profile = 0`  
+`bl_video_full_range_flag = 0`
+##### Profile 7  
+`vdr_rpu_profile = 1`  
+`el_spatial_resampling_filter_flag = 1`  
+`disable_residual_flag = 0`
+##### Profile 8  
+`vdr_rpu_profile = 1`  
+`el_spatial_resampling_filter_flag = 0`

assets/fel_orig.bin

@@ -0,0 +1,105 @@
+use bitvec::prelude::*;
+use std::fmt;
+
+#[derive(Default)]
+pub struct BitVecReader {
+    bs: BitVec<Msb0, u8>,
+    offset: usize,
+}
+
+impl BitVecReader {
+    pub fn new(data: Vec<u8>) -> Self {
+        Self {
+            bs: BitVec::from_vec(data),
+            offset: 0,
+        }
+    }
+
+    #[inline(always)]
+    pub fn get(&mut self) -> bool {
+        let val = self.bs.get(self.offset).unwrap();
+        self.offset += 1;
+
+        *val
+    }
+
+    #[inline(always)]
+    pub fn get_n<T: BitMemory>(&mut self, n: usize) -> T {
+        let val = self.bs[self.offset..self.offset + n].load_be::<T>();
+        self.offset += n;
+
+        val
+    }
+
+    // bitstring.py implementation: https://github.com/scott-griffiths/bitstring/blob/master/bitstring.py#L1706
+    #[inline(always)]
+    pub fn get_ue(&mut self) -> u64 {
+        let oldpos = self.offset;
+        let mut pos = self.offset;
+
+        loop {
+            match self.bs.get(pos) {
+                Some(val) => {
+                    if !val {
+                        pos += 1;
+                    } else {
+                        break;
+                    }
+                }
+                None => panic!("Out of bounds index: {}", pos),
+            }
+        }
+
+        let leading_zeroes = pos - oldpos;
+        let mut code_num = (1 << leading_zeroes) - 1;
+
+        if leading_zeroes > 0 {
+            if pos + leading_zeroes + 1 > self.bs.len() {
+                panic!("Out of bounds attempt");
+            }
+
+            code_num += self.bs[pos + 1..pos + leading_zeroes + 1].load_be::<u64>();
+            pos += leading_zeroes + 1;
+        } else {
+            assert_eq!(code_num, 0);
+            pos += 1;
+        }
+
+        self.offset = pos;
+
+        code_num
+    }
+
+    // bitstring.py implementation: https://github.com/scott-griffiths/bitstring/blob/master/bitstring.py#L1767
+    #[inline(always)]
+    pub fn get_se(&mut self) -> i64 {
+        let code_num = self.get_ue();
+
+        let m = ((code_num + 1) as f64 / 2.0).floor() as u64;
+
+        if code_num % 2 == 0 {
+            -(m as i64)
+        } else {
+            m as i64
+        }
+    }
+
+    pub fn is_aligned(&self) -> bool {
+        self.offset % 8 == 0
+    }
+
+    pub fn available(&self) -> usize {
+        self.bs.len() - self.offset
+    }
+}
+
+impl fmt::Debug for BitVecReader {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "BitVecReader: {{offset: {}, len: {}}}",
+            self.offset,
+            self.bs.len()
+        )
+    }
+}

assets/fel_rpu.bin

@@ -0,0 +1,75 @@
+use super::signed_to_unsigned;
+use bitvec::prelude::*;
+
+#[derive(Debug)]
+pub struct BitVecWriter {
+    bs: BitVec<Msb0, u8>,
+    offset: usize,
+}
+
+impl BitVecWriter {
+    pub fn new() -> Self {
+        Self {
+            bs: BitVec::new(),
+            offset: 0,
+        }
+    }
+
+    #[inline(always)]
+    pub fn write(&mut self, v: bool) {
+        self.bs.push(v);
+        self.offset += 1;
+    }
+
+    #[inline(always)]
+    pub fn write_n(&mut self, v: &[u8], n: usize) {
+        let slice = v.view_bits();
+
+        self.bs.extend_from_bitslice(&slice[slice.len() - n..]);
+
+        self.offset += n;
+    }
+
+    #[inline(always)]
+    pub fn write_ue(&mut self, v: u64) {
+        if v == 0 {
+            self.bs.push(true);
+            self.offset += 1;
+        } else {
+            let mut vec: BitVec<Msb0, u8> = BitVec::new();
+            let mut tmp = v + 1;
+            let mut leading_zeroes: i64 = -1;
+
+            while tmp > 0 {
+                tmp >>= 1;
+                leading_zeroes += 1;
+            }
+
+            let remaining = (v + 1 - (1 << leading_zeroes)).to_be_bytes();
+
+            for _ in 0..leading_zeroes {
+                vec.push(false);
+            }
+
+            vec.push(true);
+
+            self.bs.extend_from_bitslice(&vec);
+            self.offset += vec.len();
+
+            self.write_n(&remaining, leading_zeroes as usize);
+        }
+    }
+
+    #[inline(always)]
+    pub fn write_se(&mut self, v: i64) {
+        self.write_ue(signed_to_unsigned(v));
+    }
+
+    pub fn is_aligned(&self) -> bool {
+        self.offset % 8 == 0
+    }
+
+    pub fn as_slice(&self) -> &[u8] {
+        self.bs.as_slice()
+    }
+}

assets/fel_to_81.bin

@@ -0,0 +1,8 @@
+pub mod bitvec_reader;
+pub mod bitvec_writer;
+
+pub(crate) fn signed_to_unsigned(v: i64) -> u64 {
+    let u = if v.is_positive() { v } else { -2 * v };
+
+    u as u64
+}