Add support for extension metadata levels 15-18

dolby_vision/src/c_structs/extension_metadata.rs

@@ -106,6 +106,18 @@ impl DmData {
                     self.level11 =
                         Box::into_raw(Box::new(b.clone())) as *const ExtMetadataBlockLevel11
                 }
+                ExtMetadataBlock::Level15(_) => {
+                    // TODO
+                }
+                ExtMetadataBlock::Level16(_) => {
+                    // TODO
+                }
+                ExtMetadataBlock::Level17(_) => {
+                    // TODO
+                }
+                ExtMetadataBlock::Level18(_) => {
+                    // TODO
+                }
                 ExtMetadataBlock::Level254(b) => {
                     self.level254 =
                         Box::into_raw(Box::new(b.clone())) as *const ExtMetadataBlockLevel254

dolby_vision/src/rpu/extension_metadata/blocks/level15.rs

@@ -0,0 +1,92 @@
+use anyhow::{Result, ensure};
+use bitvec_helpers::{
+    bitstream_io_reader::BsIoSliceReader, bitstream_io_writer::BitstreamIoWriter,
+};
+
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+
+use super::{ExtMetadataBlock, ExtMetadataBlockInfo};
+
+/// Consumer look metadata, Precision Rendering/Detail
+#[repr(C)]
+#[derive(Debug, Default, Clone)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
+pub struct ExtMetadataBlockLevel15 {
+    pub confidence: u8,
+    pub precision_rendering_strength: u8,
+    pub d_local_contrast: u8,
+    pub d_brightness: u8,
+    pub d_saturation_plus_one: u8,
+    pub d_contrast_plus_one: u8,
+
+    pub confidence_no_pr: u8,
+    pub d_brightness_no_pr: u8,
+    pub d_saturation_plus_one_no_pr: u8,
+    pub d_contrast_plus_one_no_pr: u8,
+
+    /// 4 bits
+    pub revision: u8,
+    /// 4 bits
+    pub reserved: u8,
+}
+
+impl ExtMetadataBlockLevel15 {
+    pub(crate) fn parse(reader: &mut BsIoSliceReader) -> Result<ExtMetadataBlock> {
+        let block = Self {
+            confidence: reader.read::<8, u8>()?,
+            precision_rendering_strength: reader.read::<8, u8>()?,
+            d_local_contrast: reader.read::<8, u8>()?,
+            d_brightness: reader.read::<8, u8>()?,
+            d_saturation_plus_one: reader.read::<8, u8>()?,
+            d_contrast_plus_one: reader.read::<8, u8>()?,
+            confidence_no_pr: reader.read::<8, u8>()?,
+            d_brightness_no_pr: reader.read::<8, u8>()?,
+            d_saturation_plus_one_no_pr: reader.read::<8, u8>()?,
+            d_contrast_plus_one_no_pr: reader.read::<8, u8>()?,
+            revision: reader.read::<4, u8>()?,
+            reserved: reader.read::<4, u8>()?,
+        };
+
+        Ok(ExtMetadataBlock::Level15(block))
+    }
+
+    pub fn write(&self, writer: &mut BitstreamIoWriter) -> Result<()> {
+        self.validate()?;
+
+        writer.write::<8, u8>(self.confidence)?;
+        writer.write::<8, u8>(self.precision_rendering_strength)?;
+        writer.write::<8, u8>(self.d_local_contrast)?;
+        writer.write::<8, u8>(self.d_brightness)?;
+        writer.write::<8, u8>(self.d_saturation_plus_one)?;
+        writer.write::<8, u8>(self.d_contrast_plus_one)?;
+        writer.write::<8, u8>(self.confidence_no_pr)?;
+        writer.write::<8, u8>(self.d_brightness_no_pr)?;
+        writer.write::<8, u8>(self.d_saturation_plus_one_no_pr)?;
+        writer.write::<8, u8>(self.d_contrast_plus_one_no_pr)?;
+        writer.write::<4, u8>(self.revision)?;
+        writer.write::<4, u8>(self.reserved)?;
+
+        Ok(())
+    }
+
+    pub fn validate(&self) -> Result<()> {
+        ensure!(self.reserved == 0);
+
+        Ok(())
+    }
+}
+
+impl ExtMetadataBlockInfo for ExtMetadataBlockLevel15 {
+    fn level(&self) -> u8 {
+        15
+    }
+
+    fn bytes_size(&self) -> u64 {
+        11
+    }
+
+    fn required_bits(&self) -> u64 {
+        88
+    }
+}

dolby_vision/src/rpu/extension_metadata/blocks/level16.rs

@@ -0,0 +1,92 @@
+use anyhow::{Result, ensure};
+use bitvec_helpers::{
+    bitstream_io_reader::BsIoSliceReader, bitstream_io_writer::BitstreamIoWriter,
+};
+
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+
+use super::{ExtMetadataBlock, ExtMetadataBlockInfo};
+
+/// Local tone mapping metadata
+#[repr(C)]
+#[derive(Debug, Default, Clone)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
+pub struct ExtMetadataBlockLevel16 {
+    pub revision: u8,
+    pub count: usize,
+
+    pub params: Vec<Level16Params>,
+}
+
+#[repr(C)]
+#[derive(Debug, Default, Clone)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
+pub struct Level16Params {
+    pub contrast_target: u8,
+    pub precision_rendering_strength: u8,
+    pub d_local_contrast: u8,
+    pub max_d_brightness: u8,
+    pub max_d_saturation_plus_one: u8,
+}
+
+impl ExtMetadataBlockLevel16 {
+    pub(crate) fn parse(reader: &mut BsIoSliceReader) -> Result<ExtMetadataBlock> {
+        let mut block = Self {
+            revision: reader.read::<4, u8>()?,
+            count: reader.read::<4, u8>()? as usize,
+            ..Default::default()
+        };
+
+        block.params.reserve(block.count);
+
+        for _ in 0..block.count {
+            block.params.push(Level16Params {
+                contrast_target: reader.read::<8, u8>()?,
+                precision_rendering_strength: reader.read::<8, u8>()?,
+                d_local_contrast: reader.read::<8, u8>()?,
+                max_d_brightness: reader.read::<8, u8>()?,
+                max_d_saturation_plus_one: reader.read::<8, u8>()?,
+            });
+        }
+
+        Ok(ExtMetadataBlock::Level16(block))
+    }
+
+    pub fn write(&self, writer: &mut BitstreamIoWriter) -> Result<()> {
+        self.validate()?;
+
+        writer.write::<4, u8>(self.revision)?;
+        writer.write::<4, u8>(self.count as u8)?;
+
+        for params in &self.params {
+            writer.write::<8, u8>(params.contrast_target)?;
+            writer.write::<8, u8>(params.precision_rendering_strength)?;
+            writer.write::<8, u8>(params.d_local_contrast)?;
+            writer.write::<8, u8>(params.max_d_brightness)?;
+            writer.write::<8, u8>(params.max_d_saturation_plus_one)?;
+        }
+
+        Ok(())
+    }
+
+    pub fn validate(&self) -> Result<()> {
+        ensure!(self.count == self.params.len());
+
+        Ok(())
+    }
+}
+
+impl ExtMetadataBlockInfo for ExtMetadataBlockLevel16 {
+    fn level(&self) -> u8 {
+        16
+    }
+
+    fn bytes_size(&self) -> u64 {
+        1 + (self.count as u64 * 5)
+    }
+
+    fn required_bits(&self) -> u64 {
+        self.bytes_size() * 8
+    }
+}

dolby_vision/src/rpu/extension_metadata/blocks/level17.rs

@@ -0,0 +1,85 @@
+use anyhow::Result;
+use bitvec_helpers::{
+    bitstream_io_reader::BsIoSliceReader, bitstream_io_writer::BitstreamIoWriter,
+};
+
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+
+use super::{ExtMetadataBlock, ExtMetadataBlockInfo};
+
+/// Up mapping metadata
+#[repr(C)]
+#[derive(Debug, Default, Clone)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
+pub struct ExtMetadataBlockLevel17 {
+    pub mid_boost: u8,
+    pub highlight_stretch: u8,
+    pub shadow_drop: u8,
+    pub contrast_boost: u8,
+    pub saturation_boost: u8,
+    pub detail_boost: u8,
+    pub chroma_indicator: u8,
+
+    /// 12 bits
+    pub intensity_indicator_pq: u16,
+
+    /// 4 bits
+    pub revision: u8,
+
+    pub chroma_lift: u8,
+}
+
+impl ExtMetadataBlockLevel17 {
+    pub(crate) fn parse(reader: &mut BsIoSliceReader) -> Result<ExtMetadataBlock> {
+        let block = Self {
+            mid_boost: reader.read::<8, u8>()?,
+            highlight_stretch: reader.read::<8, u8>()?,
+            shadow_drop: reader.read::<8, u8>()?,
+            contrast_boost: reader.read::<8, u8>()?,
+            saturation_boost: reader.read::<8, u8>()?,
+            detail_boost: reader.read::<8, u8>()?,
+            chroma_indicator: reader.read::<8, u8>()?,
+            intensity_indicator_pq: reader.read::<12, u16>()?,
+            revision: reader.read::<4, u8>()?,
+            chroma_lift: reader.read::<8, u8>()?,
+        };
+
+        Ok(ExtMetadataBlock::Level17(block))
+    }
+
+    pub fn write(&self, writer: &mut BitstreamIoWriter) -> Result<()> {
+        self.validate()?;
+
+        writer.write::<8, u8>(self.mid_boost)?;
+        writer.write::<8, u8>(self.highlight_stretch)?;
+        writer.write::<8, u8>(self.shadow_drop)?;
+        writer.write::<8, u8>(self.contrast_boost)?;
+        writer.write::<8, u8>(self.saturation_boost)?;
+        writer.write::<8, u8>(self.detail_boost)?;
+        writer.write::<8, u8>(self.chroma_indicator)?;
+        writer.write::<12, u16>(self.intensity_indicator_pq)?;
+        writer.write::<4, u8>(self.revision)?;
+        writer.write::<8, u8>(self.chroma_lift)?;
+
+        Ok(())
+    }
+
+    pub fn validate(&self) -> Result<()> {
+        Ok(())
+    }
+}
+
+impl ExtMetadataBlockInfo for ExtMetadataBlockLevel17 {
+    fn level(&self) -> u8 {
+        17
+    }
+
+    fn bytes_size(&self) -> u64 {
+        10
+    }
+
+    fn required_bits(&self) -> u64 {
+        80
+    }
+}

dolby_vision/src/rpu/extension_metadata/blocks/level18.rs

@@ -0,0 +1,73 @@
+use anyhow::{Result, ensure};
+use bitvec_helpers::{
+    bitstream_io_reader::BsIoSliceReader, bitstream_io_writer::BitstreamIoWriter,
+};
+
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+
+use super::{ExtMetadataBlock, ExtMetadataBlockInfo};
+
+/// Creative environment metadata
+#[repr(C)]
+#[derive(Debug, Default, Clone)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
+pub struct ExtMetadataBlockLevel18 {
+    pub surround_luminance_pq: u16,
+    pub min_preserved_luminance_pq: u16,
+    pub adaptation_luminance_pq: u16,
+    pub max_preserved_luminance_pq: u16,
+
+    /// 4 bits
+    pub revision: u8,
+    /// 4 bits
+    pub reserved: u8,
+}
+
+impl ExtMetadataBlockLevel18 {
+    pub(crate) fn parse(reader: &mut BsIoSliceReader) -> Result<ExtMetadataBlock> {
+        let block = Self {
+            surround_luminance_pq: reader.read::<12, u16>()?,
+            min_preserved_luminance_pq: reader.read::<12, u16>()?,
+            adaptation_luminance_pq: reader.read::<12, u16>()?,
+            max_preserved_luminance_pq: reader.read::<12, u16>()?,
+            revision: reader.read::<4, u8>()?,
+            reserved: reader.read::<4, u8>()?,
+        };
+
+        Ok(ExtMetadataBlock::Level18(block))
+    }
+
+    pub fn write(&self, writer: &mut BitstreamIoWriter) -> Result<()> {
+        self.validate()?;
+
+        writer.write::<12, u16>(self.surround_luminance_pq)?;
+        writer.write::<12, u16>(self.min_preserved_luminance_pq)?;
+        writer.write::<12, u16>(self.adaptation_luminance_pq)?;
+        writer.write::<12, u16>(self.max_preserved_luminance_pq)?;
+        writer.write::<4, u8>(self.revision)?;
+        writer.write::<4, u8>(self.reserved)?;
+
+        Ok(())
+    }
+
+    pub fn validate(&self) -> Result<()> {
+        ensure!(self.reserved == 0);
+
+        Ok(())
+    }
+}
+
+impl ExtMetadataBlockInfo for ExtMetadataBlockLevel18 {
+    fn level(&self) -> u8 {
+        18
+    }
+
+    fn bytes_size(&self) -> u64 {
+        7
+    }
+
+    fn required_bits(&self) -> u64 {
+        56
+    }
+}