add --l2 option to plot command

Author: bbeny123

src/commands/plot.rs

@@ -39,4 +39,7 @@ pub struct PlotArgs {
 
     #[arg(long, short = 'e', help = "Set frame range end (inclusive)")]
     pub end: Option<usize>,
+
+    #[arg(long, help = "Plot L2 trims metadata instead of L1 dynamic brightness")]
+    pub l2: bool,
 }

src/dovi/plotter.rs

@@ -10,15 +10,15 @@ use plotters::coord::ranged1d::{KeyPointHint, NoDefaultFormatting, Ranged, Value
 use plotters::coord::types::RangedCoordusize;
 use plotters::prelude::{
     AreaSeries, BitMapBackend, Cartesian2d, ChartBuilder, ChartContext, IntoDrawingArea,
-    PathElement, SeriesLabelPosition, WHITE,
+    LineSeries, PathElement, SeriesLabelPosition, WHITE,
 };
 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::RpusListSummary;
+use super::rpu_info::{L2Data, RpusListSummary};
 use crate::commands::PlotArgs;
 
 #[cfg(not(feature = "system-font"))]
@@ -56,10 +56,13 @@ impl Plotter {
             title,
             start: start_arg,
             end: end_arg,
+            l2,
         } = args;
 
-        let output = output.unwrap_or(PathBuf::from("L1_plot.png"));
-        let title = title.unwrap_or(String::from("Dolby Vision L1 plot"));
+        let (level, y_desc) = if l2 { (2, "") } else { (1, "nits (cd/m²)") };
+
+        let output = output.unwrap_or(PathBuf::from(format!("L{level}_plot.png")));
+        let title = title.unwrap_or(format!("Dolby Vision L{level} plot"));
 
         let input = input_from_either("info", input, input_pos)?;
         let plotter = Plotter { input };
@@ -81,13 +84,17 @@ impl Plotter {
             .titled(&title, ("sans-serif", 40))?;
 
         println!("Plotting...");
-        let summary = RpusListSummary::new(rpus)?;
+        let summary = if l2 {
+            RpusListSummary::with_l2_data(rpus)?
+        } else {
+            RpusListSummary::new(rpus)?
+        };
 
         let mut chart = ChartBuilder::on(&root)
             .x_label_area_size(60)
             .y_label_area_size(60)
             .margin_top(90)
-            .build_cartesian_2d(x_spec, PqCoord {})?;
+            .build_cartesian_2d(x_spec, PqCoord::for_level(level))?;
 
         chart
             .configure_mesh()
@@ -98,10 +105,15 @@ impl Plotter {
             .x_desc("frames")
             .x_max_light_lines(1)
             .x_labels(24)
-            .y_desc("nits (cd/m²)")
+            .y_desc(y_desc)
             .draw()?;
 
-        Self::draw_l1_series(&mut chart, &summary)?;
+        if l2 {
+            Self::draw_l2_series(&mut chart, &summary)?;
+        } else {
+            Self::draw_l1_series(&mut chart, &summary)?;
+        }
+
         chart
             .configure_series_labels()
             .border_style(BLACK)
@@ -239,49 +251,155 @@ impl Plotter {
 
         Ok(())
     }
+
+    fn draw_l2_series(
+        chart: &mut ChartContext<BitMapBackend, Cartesian2d<RangedCoordusize, PqCoord>>,
+        summary: &RpusListSummary,
+    ) -> Result<()> {
+        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);
+        let series: [Series; 6] = [
+            (
+                "slope (gain)",
+                |e| e.0 as f64,
+                l2_stats.slope,
+                RGBColor(96, 158, 232), // blue
+            ),
+            (
+                "offset (lift)",
+                |e| e.1 as f64,
+                l2_stats.offset,
+                RGBColor(230, 110, 132), // pink
+            ),
+            (
+                "power (gamma)",
+                |e| e.2 as f64,
+                l2_stats.power,
+                RGBColor(236, 162, 75), // orange
+            ),
+            (
+                "chroma (weight)",
+                |e| e.3 as f64,
+                l2_stats.chroma,
+                RGBColor(115, 187, 190), // cyan
+            ),
+            (
+                "saturation (gain)",
+                |e| e.4 as f64,
+                l2_stats.saturation,
+                RGBColor(144, 106, 252), // purple
+            ),
+            (
+                "ms (weight)",
+                |e| e.5 as f64,
+                l2_stats.ms_weight,
+                RGBColor(243, 205, 95), // yellow
+            ),
+        ];
+
+        for (name, field_extractor, stats, color) in series.iter() {
+            let label = format!(
+                "{name} (min: {:.0}, max: {:.0}, avg: {:.0})",
+                stats.0, stats.1, stats.2
+            );
+            let series = LineSeries::new(
+                (0..).zip(data.iter()).map(|(x, y)| (x, field_extractor(y))),
+                color,
+            );
+            let shape_style = ShapeStyle {
+                color: color.to_rgba(),
+                filled: false,
+                stroke_width: 2,
+            };
+
+            chart
+                .draw_series(series)?
+                .label(label)
+                .legend(move |(x, y)| PathElement::new(vec![(x, y), (x + 20, y)], shape_style));
+        }
+
+        Ok(())
+    }
+}
+
+pub struct PqCoord {
+    key_points: Vec<f64>,
+    range: Range<f64>,
+    mapper: fn(&f64, (i32, i32)) -> i32,
+    formatter: fn(&f64) -> String,
 }
 
-pub struct PqCoord {}
+impl PqCoord {
+    pub fn for_level(level: u8) -> PqCoord {
+        if level == 2 {
+            PqCoord {
+                key_points: vec![
+                    0.0, 512.0, 1024.0, 1536.0, 2048.0, 2560.0, 3072.0, 3584.0, 4096.0,
+                ],
+                range: 0_f64..4096.0_f64,
+                mapper: |value, limit| {
+                    let norm = value / 4096.0;
+                    let size = limit.1 - limit.0;
+                    (norm * size as f64).round() as i32 + limit.0
+                },
+                formatter: |value| format!("{value}"),
+            }
+        } else {
+            PqCoord {
+                key_points: vec![
+                    nits_to_pq(0.01),
+                    nits_to_pq(0.1),
+                    nits_to_pq(0.5),
+                    nits_to_pq(1.0),
+                    nits_to_pq(2.5),
+                    nits_to_pq(5.0),
+                    nits_to_pq(10.0),
+                    nits_to_pq(25.0),
+                    nits_to_pq(50.0),
+                    nits_to_pq(100.0),
+                    nits_to_pq(200.0),
+                    nits_to_pq(400.0),
+                    nits_to_pq(600.0),
+                    nits_to_pq(1000.0),
+                    nits_to_pq(2000.0),
+                    nits_to_pq(4000.0),
+                    nits_to_pq(10000.0),
+                ],
+                range: 0_f64..1.0_f64,
+                mapper: |value, limit| {
+                    let size = limit.1 - limit.0;
+                    (*value * size as f64) as i32 + limit.0
+                },
+                formatter: |value| {
+                    let nits = (pq_to_nits(*value) * 1000.0).round() / 1000.0;
+                    format!("{nits}")
+                },
+            }
+        }
+    }
+}
 
 impl Ranged for PqCoord {
     type FormatOption = NoDefaultFormatting;
     type ValueType = f64;
 
     fn map(&self, value: &f64, limit: (i32, i32)) -> i32 {
-        let size = limit.1 - limit.0;
-        (*value * size as f64) as i32 + limit.0
+        (self.mapper)(value, limit)
     }
 
     fn key_points<Hint: KeyPointHint>(&self, _hint: Hint) -> Vec<f64> {
-        vec![
-            nits_to_pq(0.01),
-            nits_to_pq(0.1),
-            nits_to_pq(0.5),
-            nits_to_pq(1.0),
-            nits_to_pq(2.5),
-            nits_to_pq(5.0),
-            nits_to_pq(10.0),
-            nits_to_pq(25.0),
-            nits_to_pq(50.0),
-            nits_to_pq(100.0),
-            nits_to_pq(200.0),
-            nits_to_pq(400.0),
-            nits_to_pq(600.0),
-            nits_to_pq(1000.0),
-            nits_to_pq(2000.0),
-            nits_to_pq(4000.0),
-            nits_to_pq(10000.0),
-        ]
+        self.key_points.clone()
     }
 
     fn range(&self) -> Range<f64> {
-        0_f64..1.0_f64
+        self.range.clone()
     }
 }
 
 impl ValueFormatter<f64> for PqCoord {
     fn format_ext(&self, value: &f64) -> String {
-        let nits = (pq_to_nits(*value) * 1000.0).round() / 1000.0;
-        format!("{nits}")
+        (self.formatter)(value)
     }
 }

src/dovi/rpu_info.rs

@@ -7,14 +7,16 @@ use itertools::Itertools;
 
 use dolby_vision::rpu::dovi_rpu::DoviRpu;
 use dolby_vision::rpu::extension_metadata::blocks::{
-    ExtMetadataBlock, ExtMetadataBlockLevel1, ExtMetadataBlockLevel6,
+    ExtMetadataBlock, ExtMetadataBlockLevel1, ExtMetadataBlockLevel2, ExtMetadataBlockLevel6,
 };
 use dolby_vision::rpu::utils::parse_rpu_file;
 use dolby_vision::utils::pq_to_nits;
 
 use super::input_from_either;
 use crate::commands::InfoArgs;
 
+pub type L2Data = (u16, u16, u16, u16, u16, i16);
+
 pub struct RpuInfo {
     input: PathBuf,
 }
@@ -31,6 +33,8 @@ 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_stats: Option<SummaryL2Stats>,
 }
 
 pub struct SummaryL1Stats {
@@ -43,6 +47,15 @@ pub struct SummaryL1Stats {
     pub max_min_nits: f64,
 }
 
+pub struct SummaryL2Stats {
+    pub slope: (f64, f64, f64),
+    pub offset: (f64, f64, f64),
+    pub power: (f64, f64, f64),
+    pub chroma: (f64, f64, f64),
+    pub saturation: (f64, f64, f64),
+    pub ms_weight: (f64, f64, f64),
+}
+
 impl RpuInfo {
     pub fn info(args: InfoArgs) -> Result<()> {
         let InfoArgs {
@@ -344,6 +357,71 @@ impl RpusListSummary {
             l1_data,
             l1_stats,
             l2_trims,
+            l2_data: None,
+            l2_stats: None,
         })
     }
+
+    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,
+                    )
+                } else {
+                    unreachable!();
+                }
+            })
+            .collect();
+
+        fn min_max_avg<F>(data: &[L2Data], field_extractor: F) -> (f64, f64, f64)
+        where
+            F: Fn(&L2Data) -> f64,
+        {
+            let mut iter = data.iter().map(field_extractor);
+            let first = iter.next().unwrap();
+            let (mut min, mut max, mut sum) = (first, first, first);
+
+            for v in iter {
+                if v < min {
+                    min = v;
+                }
+                if v > max {
+                    max = v;
+                }
+                sum += v;
+            }
+
+            (min, max, sum / data.len() as f64)
+        }
+
+        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),
+        });
+        summary.l2_data = Some(l2_data);
+
+        Ok(summary)
+    }
 }