av_metrics/video/
mod.rs

1//! Contains metrics related to video/image quality.
2
3pub mod ciede;
4pub mod decode;
5mod pixel;
6pub mod psnr;
7pub mod psnr_hvs;
8pub mod ssim;
9
10use crate::MetricsError;
11use decode::*;
12use std::error::Error;
13
14pub use pixel::*;
15pub use v_frame::frame::Frame;
16pub use v_frame::plane::Plane;
17
18trait FrameCompare {
19    fn can_compare(&self, other: &Self) -> Result<(), MetricsError>;
20}
21
22impl<T: Pixel> FrameCompare for Frame<T> {
23    fn can_compare(&self, other: &Self) -> Result<(), MetricsError> {
24        self.planes[0].can_compare(&other.planes[0])?;
25        self.planes[1].can_compare(&other.planes[1])?;
26        self.planes[2].can_compare(&other.planes[2])?;
27
28        Ok(())
29    }
30}
31
32pub(crate) trait PlaneCompare {
33    fn can_compare(&self, other: &Self) -> Result<(), MetricsError>;
34}
35
36impl<T: Pixel> PlaneCompare for Plane<T> {
37    fn can_compare(&self, other: &Self) -> Result<(), MetricsError> {
38        if self.cfg != other.cfg {
39            return Err(MetricsError::InputMismatch {
40                reason: "Video resolution does not match",
41            });
42        }
43        Ok(())
44    }
45}
46
47pub use v_frame::pixel::ChromaSampling;
48
49pub(crate) trait ChromaWeight {
50    fn get_chroma_weight(self) -> f64;
51}
52
53impl ChromaWeight for ChromaSampling {
54    /// The relative impact of chroma planes compared to luma
55    fn get_chroma_weight(self) -> f64 {
56        match self {
57            ChromaSampling::Cs420 => 0.25,
58            ChromaSampling::Cs422 => 0.5,
59            ChromaSampling::Cs444 => 1.0,
60            ChromaSampling::Cs400 => 0.0,
61        }
62    }
63}
64
65/// Sample position for subsampled chroma
66#[derive(Copy, Clone, Debug, PartialEq, Eq, Default)]
67pub enum ChromaSamplePosition {
68    /// The source video transfer function is not signaled. This crate will assume
69    /// no transformation needs to be done on this data, but there is a risk of metric
70    /// calculations being inaccurate.
71    #[default]
72    Unknown,
73    /// Horizontally co-located with (0, 0) luma sample, vertically positioned
74    /// in the middle between two luma samples.
75    Vertical,
76    /// Co-located with (0, 0) luma sample.
77    Colocated,
78    /// Bilaterally located chroma plane in the diagonal space between luma samples.
79    Bilateral,
80    /// Interlaced content with interpolated chroma samples.
81    Interpolated,
82}
83
84/// Certain metrics return a value per plane. This struct contains the output
85/// for those metrics per plane, as well as a weighted average of the planes.
86#[derive(Debug, Default, Clone, Copy, PartialEq)]
87#[cfg_attr(feature = "serde", derive(serde::Serialize))]
88pub struct PlanarMetrics {
89    /// Metric value for the Y plane.
90    pub y: f64,
91    /// Metric value for the U/Cb plane.
92    pub u: f64,
93    /// Metric value for the V/Cb plane.
94    pub v: f64,
95    /// Weighted average of the three planes.
96    pub avg: f64,
97}
98
99trait VideoMetric: Send + Sync {
100    type FrameResult: Send + Sync;
101    type VideoResult: Send + Sync;
102
103    /// Generic method for internal use that processes multiple frames from a video
104    /// into an aggregate metric.
105    ///
106    /// `frame_fn` is the function to calculate metrics on one frame of the video.
107    /// `acc_fn` is the accumulator function to calculate the aggregate metric.
108    fn process_video<D: Decoder, F: Fn(usize) + Send>(
109        &mut self,
110        decoder1: &mut D,
111        decoder2: &mut D,
112        frame_limit: Option<usize>,
113        progress_callback: F,
114    ) -> Result<Self::VideoResult, Box<dyn Error>> {
115        if decoder1.get_bit_depth() != decoder2.get_bit_depth() {
116            return Err(Box::new(MetricsError::InputMismatch {
117                reason: "Bit depths do not match",
118            }));
119        }
120        if decoder1.get_video_details().chroma_sampling
121            != decoder2.get_video_details().chroma_sampling
122        {
123            return Err(Box::new(MetricsError::InputMismatch {
124                reason: "Chroma samplings do not match",
125            }));
126        }
127
128        if decoder1.get_bit_depth() > 8 {
129            self.process_video_mt::<D, u16, F>(decoder1, decoder2, frame_limit, progress_callback)
130        } else {
131            self.process_video_mt::<D, u8, F>(decoder1, decoder2, frame_limit, progress_callback)
132        }
133    }
134
135    fn process_frame<T: Pixel>(
136        &self,
137        frame1: &Frame<T>,
138        frame2: &Frame<T>,
139        bit_depth: usize,
140        chroma_sampling: ChromaSampling,
141    ) -> Result<Self::FrameResult, Box<dyn Error>>;
142
143    fn aggregate_frame_results(
144        &self,
145        metrics: &[Self::FrameResult],
146    ) -> Result<Self::VideoResult, Box<dyn Error>>;
147
148    fn process_video_mt<D: Decoder, P: Pixel, F: Fn(usize) + Send>(
149        &mut self,
150        decoder1: &mut D,
151        decoder2: &mut D,
152        frame_limit: Option<usize>,
153        progress_callback: F,
154    ) -> Result<Self::VideoResult, Box<dyn Error>> {
155        let num_threads = (rayon::current_num_threads() - 1).max(1);
156
157        let mut out = Vec::new();
158
159        let (send, recv) = crossbeam::channel::bounded(num_threads);
160        let vid_info = decoder1.get_video_details();
161
162        match crossbeam::scope(|s| {
163            let send_result = s.spawn(move |_| {
164                let mut decoded = 0;
165                while frame_limit.map(|limit| limit > decoded).unwrap_or(true) {
166                    decoded += 1;
167                    let frame1 = decoder1.read_video_frame::<P>();
168                    let frame2 = decoder2.read_video_frame::<P>();
169                    if let (Some(frame1), Some(frame2)) = (frame1, frame2) {
170                        progress_callback(decoded);
171                        if let Err(e) = send.send((frame1, frame2)) {
172                            let (frame1, frame2) = e.into_inner();
173                            return Err(format!(
174                                "Error sending\n\nframe1: {frame1:?}\n\nframe2: {frame2:?}"
175                            ));
176                        }
177                    } else {
178                        break;
179                    }
180                }
181                // Mark the end of the decoding process
182                progress_callback(usize::MAX);
183                Ok(())
184            });
185
186            use rayon::prelude::*;
187            let mut metrics = Vec::with_capacity(frame_limit.unwrap_or(0));
188            let mut process_error = Ok(());
189            loop {
190                let working_set: Vec<_> = (0..num_threads)
191                    .into_par_iter()
192                    .filter_map(|_w| {
193                        recv.recv()
194                            .map(|(f1, f2)| {
195                                self.process_frame(
196                                    &f1,
197                                    &f2,
198                                    vid_info.bit_depth,
199                                    vid_info.chroma_sampling,
200                                )
201                                .map_err(|e| {
202                                    format!("\n\n{e} on\n\nframe1: {f1:?}\n\nand\n\nframe2: {f2:?}")
203                                })
204                            })
205                            .ok()
206                    })
207                    .collect();
208                let work_set: Vec<_> = working_set
209                    .into_iter()
210                    .filter_map(|v| v.map_err(|e| process_error = Err(e)).ok())
211                    .collect();
212                if work_set.is_empty() || process_error.is_err() {
213                    break;
214                } else {
215                    metrics.extend(work_set);
216                }
217            }
218
219            out = metrics;
220
221            (
222                send_result
223                    .join()
224                    .unwrap_or_else(|_| Err("Failed joining the sender thread".to_owned())),
225                process_error,
226            )
227        }) {
228            Ok((send_error, process_error)) => {
229                if let Err(error) = send_error {
230                    return Err(MetricsError::SendError { reason: error }.into());
231                }
232
233                if let Err(error) = process_error {
234                    return Err(MetricsError::ProcessError { reason: error }.into());
235                }
236
237                if out.is_empty() {
238                    return Err(MetricsError::UnsupportedInput {
239                        reason: "No readable frames found in one or more input files",
240                    }
241                    .into());
242                }
243
244                self.aggregate_frame_results(&out)
245            }
246            Err(e) => Err(MetricsError::VideoError {
247                reason: format!("\n\nError {e:?} processing the two videos"),
248            }
249            .into()),
250        }
251    }
252}
av_metrics/video/mod.rs

av_metrics/video/
mod.rs
