rpu_info - use ExtMetadataBlockLevel2 instead of L2Data & extend MasteringDisplayPrimaries

(cherry picked from commit 86c28b1)

Author: bbeny123

dolby_vision/src/rpu/extension_metadata/primaries.rs

@@ -50,23 +50,40 @@ pub enum MasteringDisplayPrimaries {
     SGamut3Cine,
 }
 
-impl MasteringDisplayPrimaries {
-    pub fn u8_to_alias(value: u8) -> Option<&'static str> {
+impl From<u8> for MasteringDisplayPrimaries {
+    fn from(value: u8) -> Self {
         match value {
-            0 => Some("DCI-P3 D65"),
-            1 => Some("BT.709"),
-            2 => Some("BT.2020"),
-            3 => Some("SMPTE-C"),
-            4 => Some("BT.601"),
-            5 => Some("DCI-P3"),
-            6 => Some("ACES"),
-            7 => Some("S-Gamut"),
-            8 => Some("S-Gamut-3.Cine"),
-            _ => None,
+            0 => Self::DCIP3D65,
+            1 => Self::BT709,
+            2 => Self::BT2020,
+            3 => Self::SMPTEC,
+            4 => Self::BT601,
+            5 => Self::DCIP3,
+            6 => Self::ACES,
+            7 => Self::SGamut,
+            8 => Self::SGamut3Cine,
+            _ => Self::DCIP3D65,
         }
     }
 }
 
+impl std::fmt::Display for MasteringDisplayPrimaries {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let alias = match self {
+            Self::DCIP3D65 => "DCI-P3 D65",
+            Self::BT709 => "BT.709",
+            Self::BT2020 => "BT.2020",
+            Self::SMPTEC => "SMPTE-C",
+            Self::BT601 => "BT.601",
+            Self::DCIP3 => "DCI-P3",
+            Self::ACES => "ACES",
+            Self::SGamut => "S-Gamut",
+            Self::SGamut3Cine => "S-Gamut-3.Cine",
+        };
+        write!(f, "{}", alias)
+    }
+}
+
 impl ColorPrimaries {
     pub fn from_array_int(primaries: &[u16; 8]) -> ColorPrimaries {
         Self {

src/dovi/plotter.rs

@@ -6,6 +6,9 @@ use std::path::PathBuf;
 use anyhow::bail;
 
 use anyhow::Result;
+use dolby_vision::rpu::extension_metadata::blocks::ExtMetadataBlockLevel2;
+use dolby_vision::rpu::utils::parse_rpu_file;
+use dolby_vision::utils::{nits_to_pq, pq_to_nits};
 use plotters::coord::ranged1d::{KeyPointHint, NoDefaultFormatting, Ranged, ValueFormatter};
 use plotters::coord::types::RangedCoordusize;
 use plotters::prelude::{
@@ -14,11 +17,8 @@ use plotters::prelude::{
 };
 use plotters::style::{BLACK, Color, IntoTextStyle, RGBColor, ShapeStyle};
 
-use dolby_vision::rpu::utils::parse_rpu_file;
-use dolby_vision::utils::{nits_to_pq, pq_to_nits};
-
 use super::input_from_either;
-use super::rpu_info::{L2Data, RpusListSummary};
+use super::rpu_info::RpusListSummary;
 use crate::commands::PlotArgs;
 
 #[cfg(not(feature = "system-font"))]
@@ -270,41 +270,46 @@ impl Plotter {
         let data = summary.l2_data.as_ref().unwrap();
         let l2_stats = summary.l2_stats.as_ref().unwrap();
 
-        type Series = (&'static str, fn(&L2Data) -> f64, (f64, f64, f64), RGBColor);
+        type Series = (
+            &'static str,
+            fn(&ExtMetadataBlockLevel2) -> f64,
+            (f64, f64, f64),
+            RGBColor,
+        );
         let series: [Series; 6] = [
             (
                 "slope (gain)",
-                |e| e.0 as f64,
+                |e| e.trim_slope as f64,
                 l2_stats.slope,
                 RGBColor(96, 158, 232), // blue
             ),
             (
                 "offset (lift)",
-                |e| e.1 as f64,
+                |e| e.trim_offset as f64,
                 l2_stats.offset,
                 RGBColor(230, 110, 132), // pink
             ),
             (
                 "power (gamma)",
-                |e| e.2 as f64,
+                |e| e.trim_power as f64,
                 l2_stats.power,
                 RGBColor(236, 162, 75), // orange
             ),
             (
                 "chroma (weight)",
-                |e| e.3 as f64,
+                |e| e.trim_chroma_weight as f64,
                 l2_stats.chroma,
                 RGBColor(115, 187, 190), // cyan
             ),
             (
                 "saturation (gain)",
-                |e| e.4 as f64,
+                |e| e.trim_saturation_gain as f64,
                 l2_stats.saturation,
                 RGBColor(144, 106, 252), // purple
             ),
             (
                 "ms (weight)",
-                |e| e.5 as f64,
+                |e| e.ms_weight as f64,
                 l2_stats.ms_weight,
                 RGBColor(243, 205, 95), // yellow
             ),

src/dovi/rpu_info.rs

@@ -17,8 +17,6 @@ use itertools::Itertools;
 use super::input_from_either;
 use crate::commands::InfoArgs;
 
-pub type L2Data = (u16, u16, u16, u16, u16, i16);
-
 pub struct RpuInfo {
     input: PathBuf,
 }
@@ -38,7 +36,7 @@ pub struct RpusListSummary {
     pub l1_data: Vec<(f64, f64, f64)>,
     pub l1_stats: SummaryL1Stats,
     pub l2_trims: Vec<String>,
-    pub l2_data: Option<Vec<L2Data>>,
+    pub l2_data: Option<Vec<ExtMetadataBlockLevel2>>,
     pub l2_stats: Option<SummaryL2Stats>,
 }
 
@@ -443,14 +441,13 @@ impl RpusListSummary {
                 })
                 .into_iter()
                 .sorted_by_key(|e| e.0)
-                .filter_map(|(idx, frames)| {
-                    MasteringDisplayPrimaries::u8_to_alias(idx).map(|alias| {
-                        if frames < dmv2_count {
-                            format!("{alias} ({frames})")
-                        } else {
-                            alias.to_string()
-                        }
-                    })
+                .map(|(idx, frames)| {
+                    let alias = MasteringDisplayPrimaries::from(idx).to_string();
+                    if frames < dmv2_count {
+                        format!("{alias} ({frames})")
+                    } else {
+                        alias
+                    }
                 })
                 .collect();
 
@@ -481,35 +478,22 @@ impl RpusListSummary {
     pub fn with_l2_data(rpus: &[DoviRpu]) -> Result<Self> {
         let mut summary = Self::new(rpus)?;
 
-        let default_l2_for_missing = ExtMetadataBlock::Level2(ExtMetadataBlockLevel2::default());
-
         let l2_data: Vec<_> = rpus
             .iter()
             .map(|rpu| {
-                let block = rpu
-                    .vdr_dm_data
-                    .as_ref()
-                    .and_then(|dm| dm.get_block(2))
-                    .unwrap_or(&default_l2_for_missing);
-
-                if let ExtMetadataBlock::Level2(l2) = block {
-                    (
-                        l2.trim_slope,
-                        l2.trim_offset,
-                        l2.trim_power,
-                        l2.trim_chroma_weight,
-                        l2.trim_saturation_gain,
-                        l2.ms_weight,
-                    )
+                if let Some(ExtMetadataBlock::Level2(l2)) =
+                    rpu.vdr_dm_data.as_ref().and_then(|dm| dm.get_block(2))
+                {
+                    l2.clone()
                 } else {
-                    unreachable!();
+                    ExtMetadataBlockLevel2::default()
                 }
             })
             .collect();
 
-        fn min_max_avg<F>(data: &[L2Data], field_extractor: F) -> (f64, f64, f64)
+        fn min_max_avg<F>(data: &[ExtMetadataBlockLevel2], field_extractor: F) -> (f64, f64, f64)
         where
-            F: Fn(&L2Data) -> f64,
+            F: Fn(&ExtMetadataBlockLevel2) -> f64,
         {
             let mut iter = data.iter().map(field_extractor);
             let first = iter.next().unwrap();
@@ -529,12 +513,12 @@ impl RpusListSummary {
         }
 
         summary.l2_stats = Some(SummaryL2Stats {
-            slope: min_max_avg(&l2_data, |e| e.0 as f64),
-            offset: min_max_avg(&l2_data, |e| e.1 as f64),
-            power: min_max_avg(&l2_data, |e| e.2 as f64),
-            chroma: min_max_avg(&l2_data, |e| e.3 as f64),
-            saturation: min_max_avg(&l2_data, |e| e.4 as f64),
-            ms_weight: min_max_avg(&l2_data, |e| e.5 as f64),
+            slope: min_max_avg(&l2_data, |e| e.trim_slope as f64),
+            offset: min_max_avg(&l2_data, |e| e.trim_offset as f64),
+            power: min_max_avg(&l2_data, |e| e.trim_power as f64),
+            chroma: min_max_avg(&l2_data, |e| e.trim_chroma_weight as f64),
+            saturation: min_max_avg(&l2_data, |e| e.trim_saturation_gain as f64),
+            ms_weight: min_max_avg(&l2_data, |e| e.ms_weight as f64),
         });
         summary.l2_data = Some(l2_data);