Debian Codegraph @

.cargo/vendor/rav1e/src/bin/stats.rs

raw
1 // Copyright (c) 2018-2022, The rav1e contributors. All rights reserved
2 //
3 // This source code is subject to the terms of the BSD 2 Clause License and
4 // the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
5 // was not distributed with this source code in the LICENSE file, you can
6 // obtain it at www.aomedia.org/license/software. If the Alliance for Open
7 // Media Patent License 1.0 was not distributed with this source code in the
8 // PATENTS file, you can obtain it at www.aomedia.org/license/patent.
9
10 use av_metrics::video::*;
11 use rav1e::data::EncoderStats;
12 use rav1e::prelude::*;
13 use std::fmt;
14 use std::time::Instant;
15
16 #[derive(Debug, Clone)]
17 pub struct FrameSummary {
18 /// Frame size in bytes
19 pub size: usize,
20 pub input_frameno: u64,
21 pub frame_type: FrameType,
22 /// Contains metrics such as PSNR, SSIM, etc.
23 pub metrics: QualityMetrics,
24 /// QP selected for the frame.
25 pub qp: u8,
26 /// Block-level encoding stats for the frame
27 pub enc_stats: EncoderStats,
28 }
29
30 #[profiling::function]
31 pub fn build_frame_summary<T: Pixel>(
32 packets: Packet<T>, bit_depth: usize, chroma_sampling: ChromaSampling,
33 metrics_cli: MetricsEnabled,
34 ) -> FrameSummary {
35 let metrics_input_frame: &Frame<T> = packets.source.as_ref().unwrap();
36 let metrics_output_frame: &Frame<T> = packets.rec.as_ref().unwrap();
37 let encode_metrics: QualityMetrics = calculate_frame_metrics(
38 metrics_input_frame,
39 metrics_output_frame,
40 bit_depth,
41 chroma_sampling,
42 metrics_cli,
43 );
44 FrameSummary {
45 size: packets.data.len(),
46 input_frameno: packets.input_frameno,
47 frame_type: packets.frame_type,
48 metrics: encode_metrics,
49 qp: packets.qp,
50 enc_stats: packets.enc_stats,
51 }
52 }
53
54 impl fmt::Display for FrameSummary {
55 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
56 write!(
57 f,
58 "Input Frame {} - {} - {} bytes{}",
59 self.input_frameno,
60 self.frame_type,
61 self.size,
62 if let Some(psnr) = self.metrics.psnr {
63 format!(
64 " - PSNR: Y: {:.4} Cb: {:.4} Cr: {:.4}",
65 psnr.y, psnr.u, psnr.v
66 )
67 } else {
68 String::new()
69 }
70 )
71 }
72 }
73
74 #[derive(Debug, Clone)]
75 pub struct ProgressInfo {
76 // Frame rate of the video
77 frame_rate: Rational,
78 // The length of the whole video, in frames, if known
79 total_frames: Option<usize>,
80 // The time the encode was started
81 time_started: Instant,
82 // List of frames encoded so far
83 frame_info: Vec<FrameSummary>,
84 // Video size so far in bytes.
85 //
86 // This value will be updated in the CLI very frequently, so we cache the previous value
87 // to reduce the overall complexity.
88 encoded_size: usize,
89 // Which Metrics to display during and at end of encode
90 metrics_enabled: MetricsEnabled,
91 }
92
93 impl ProgressInfo {
94 pub fn new(
95 frame_rate: Rational, total_frames: Option<usize>,
96 metrics_enabled: MetricsEnabled,
97 ) -> Self {
98 Self {
99 frame_rate,
100 total_frames,
101 time_started: Instant::now(),
102 frame_info: Vec::with_capacity(total_frames.unwrap_or_default()),
103 encoded_size: 0,
104 metrics_enabled,
105 }
106 }
107
108 pub fn add_frame(&mut self, frame: FrameSummary) {
109 self.encoded_size += frame.size;
110 self.frame_info.push(frame);
111 }
112
113 pub fn frames_encoded(&self) -> usize {
114 self.frame_info.len()
115 }
116
117 pub fn encoding_fps(&self) -> f64 {
118 let duration = Instant::now().duration_since(self.time_started);
119 self.frame_info.len() as f64
120 / (duration.as_secs() as f64 + duration.subsec_millis() as f64 / 1000f64)
121 }
122
123 pub fn video_fps(&self) -> f64 {
124 self.frame_rate.num as f64 / self.frame_rate.den as f64
125 }
126
127 // Returns the bitrate of the frames so far, in bits/second
128 pub fn bitrate(&self) -> usize {
129 let bits = self.encoded_size * 8;
130 let seconds = self.frame_info.len() as f64 / self.video_fps();
131 (bits as f64 / seconds) as usize
132 }
133
134 // Estimates the final filesize in bytes, if the number of frames is known
135 pub fn estimated_size(&self) -> usize {
136 self
137 .total_frames
138 .map(|frames| self.encoded_size * frames / self.frames_encoded())
139 .unwrap_or_default()
140 }
141
142 // Estimates the remaining encoding time in seconds, if the number of frames is known
143 pub fn estimated_time(&self) -> u64 {
144 self
145 .total_frames
146 .map(|frames| {
147 (frames - self.frames_encoded()) as f64 / self.encoding_fps()
148 })
149 .unwrap_or_default() as u64
150 }
151
152 // Elapsed time in seconds
153 pub fn elapsed_time(&self) -> u64 {
154 Instant::now().duration_since(self.time_started).as_secs()
155 }
156
157 // Number of frames of given type which appear in the video
158 fn get_frame_type_count(&self, frame_type: FrameType) -> usize {
159 self
160 .frame_info
161 .iter()
162 .filter(|frame| frame.frame_type == frame_type)
163 .count()
164 }
165
166 fn get_frame_type_avg_size(&self, frame_type: FrameType) -> usize {
167 let count = self.get_frame_type_count(frame_type);
168 if count == 0 {
169 return 0;
170 }
171 self
172 .frame_info
173 .iter()
174 .filter(|frame| frame.frame_type == frame_type)
175 .map(|frame| frame.size)
176 .sum::<usize>()
177 / count
178 }
179
180 fn get_frame_type_avg_qp(&self, frame_type: FrameType) -> f32 {
181 let count = self.get_frame_type_count(frame_type);
182 if count == 0 {
183 return 0.;
184 }
185 self
186 .frame_info
187 .iter()
188 .filter(|frame| frame.frame_type == frame_type)
189 .map(|frame| frame.qp as f32)
190 .sum::<f32>()
191 / count as f32
192 }
193
194 fn get_block_count_by_frame_type(&self, frame_type: FrameType) -> usize {
195 self
196 .frame_info
197 .iter()
198 .filter(|frame| frame.frame_type == frame_type)
199 .map(|frame| frame.enc_stats.block_size_counts.iter().sum::<usize>())
200 .sum()
201 }
202
203 fn get_tx_count_by_frame_type(&self, frame_type: FrameType) -> usize {
204 self
205 .frame_info
206 .iter()
207 .filter(|frame| frame.frame_type == frame_type)
208 .map(|frame| frame.enc_stats.tx_type_counts.iter().sum::<usize>())
209 .sum()
210 }
211
212 fn get_bsize_pct_by_frame_type(
213 &self, bsize: BlockSize, frame_type: FrameType,
214 ) -> f32 {
215 let count = self.get_block_count_by_frame_type(frame_type);
216 if count == 0 {
217 return 0.;
218 }
219 self
220 .frame_info
221 .iter()
222 .filter(|frame| frame.frame_type == frame_type)
223 .map(|frame| frame.enc_stats.block_size_counts[bsize as usize])
224 .sum::<usize>() as f32
225 / count as f32
226 * 100.
227 }
228
229 fn get_skip_pct_by_frame_type(&self, frame_type: FrameType) -> f32 {
230 let count = self.get_block_count_by_frame_type(frame_type);
231 if count == 0 {
232 return 0.;
233 }
234 self
235 .frame_info
236 .iter()
237 .filter(|frame| frame.frame_type == frame_type)
238 .map(|frame| frame.enc_stats.skip_block_count)
239 .sum::<usize>() as f32
240 / count as f32
241 * 100.
242 }
243
244 fn get_txtype_pct_by_frame_type(
245 &self, txtype: TxType, frame_type: FrameType,
246 ) -> f32 {
247 let count = self.get_tx_count_by_frame_type(frame_type);
248 if count == 0 {
249 return 0.;
250 }
251 self
252 .frame_info
253 .iter()
254 .filter(|frame| frame.frame_type == frame_type)
255 .map(|frame| frame.enc_stats.tx_type_counts[txtype as usize])
256 .sum::<usize>() as f32
257 / count as f32
258 * 100.
259 }
260
261 fn get_luma_pred_count_by_frame_type(&self, frame_type: FrameType) -> usize {
262 self
263 .frame_info
264 .iter()
265 .filter(|frame| frame.frame_type == frame_type)
266 .map(|frame| frame.enc_stats.luma_pred_mode_counts.iter().sum::<usize>())
267 .sum()
268 }
269
270 fn get_chroma_pred_count_by_frame_type(
271 &self, frame_type: FrameType,
272 ) -> usize {
273 self
274 .frame_info
275 .iter()
276 .filter(|frame| frame.frame_type == frame_type)
277 .map(|frame| {
278 frame.enc_stats.chroma_pred_mode_counts.iter().sum::<usize>()
279 })
280 .sum()
281 }
282
283 fn get_luma_pred_mode_pct_by_frame_type(
284 &self, pred_mode: PredictionMode, frame_type: FrameType,
285 ) -> f32 {
286 let count = self.get_luma_pred_count_by_frame_type(frame_type);
287 if count == 0 {
288 return 0.;
289 }
290 self
291 .frame_info
292 .iter()
293 .filter(|frame| frame.frame_type == frame_type)
294 .map(|frame| frame.enc_stats.luma_pred_mode_counts[pred_mode as usize])
295 .sum::<usize>() as f32
296 / count as f32
297 * 100.
298 }
299
300 fn get_chroma_pred_mode_pct_by_frame_type(
301 &self, pred_mode: PredictionMode, frame_type: FrameType,
302 ) -> f32 {
303 let count = self.get_chroma_pred_count_by_frame_type(frame_type);
304 if count == 0 {
305 return 0.;
306 }
307 self
308 .frame_info
309 .iter()
310 .filter(|frame| frame.frame_type == frame_type)
311 .map(|frame| frame.enc_stats.chroma_pred_mode_counts[pred_mode as usize])
312 .sum::<usize>() as f32
313 / count as f32
314 * 100.
315 }
316
317 pub fn print_summary(&self, verbose: bool) {
318 eprint!("\r");
319 info!("{}", self);
320 info!("----------");
321 self.print_frame_type_summary(FrameType::KEY);
322 self.print_frame_type_summary(FrameType::INTER);
323 self.print_frame_type_summary(FrameType::INTRA_ONLY);
324 self.print_frame_type_summary(FrameType::SWITCH);
325 if verbose {
326 self.print_block_type_summary();
327 self.print_transform_type_summary();
328 self.print_prediction_modes_summary();
329 }
330 match self.metrics_enabled {
331 MetricsEnabled::None => info!("----"),
332 MetricsEnabled::Psnr => self.print_video_psnr(),
333 MetricsEnabled::All => {
334 self.print_video_psnr();
335 self.print_video_all();
336 }
337 }
338 }
339
340 fn print_frame_type_summary(&self, frame_type: FrameType) {
341 let count = self.get_frame_type_count(frame_type);
342 let size = self.get_frame_type_avg_size(frame_type);
343 let avg_qp = self.get_frame_type_avg_qp(frame_type);
344 info!(
345 "{:17} {:>6} | avg QP: {:6.2} | avg size: {:>7} B",
346 format!("{frame_type}:"),
347 count,
348 avg_qp,
349 size
350 );
351 }
352
353 fn print_video_psnr(&self) {
354 info!("----------");
355 let psnr_y = sum_metric(&self.frame_info, |fi| fi.metrics.psnr.unwrap().y);
356 let psnr_u = sum_metric(&self.frame_info, |fi| fi.metrics.psnr.unwrap().u);
357 let psnr_v = sum_metric(&self.frame_info, |fi| fi.metrics.psnr.unwrap().v);
358 let psnr_avg =
359 sum_metric(&self.frame_info, |fi| fi.metrics.psnr.unwrap().avg);
360 info!(
361 "Mean PSNR: Avg: {:.4} Y: {:.4} Cb: {:.4} Cr: {:.4}",
362 psnr_avg, psnr_y, psnr_u, psnr_v
363 );
364 }
365 fn print_video_all(&self) {
366 info!("----------");
367 let psnr_hvs =
368 sum_metric(&self.frame_info, |fi| fi.metrics.psnr_hvs.unwrap().avg);
369 let ssim = sum_metric(&self.frame_info, |fi| fi.metrics.ssim.unwrap().avg);
370 let ms_ssim =
371 sum_metric(&self.frame_info, |fi| fi.metrics.ms_ssim.unwrap().avg);
372 let ciede = sum_metric(&self.frame_info, |fi| fi.metrics.ciede.unwrap());
373 info!("PSNR HVS: {:.4}", psnr_hvs);
374 info!("SSIM: {:.4} MS SSIM: {:.4}", ssim, ms_ssim);
375 info!("CIEDE2000: {:.4}", ciede);
376 info!("----------");
377 }
378
379 fn print_block_type_summary(&self) {
380 self.print_block_type_summary_for_frame_type(FrameType::KEY, 'I');
381 self.print_block_type_summary_for_frame_type(FrameType::INTER, 'P');
382 }
383
384 fn print_block_type_summary_for_frame_type(
385 &self, frame_type: FrameType, type_label: char,
386 ) {
387 info!("----------");
388 info!(
389 "bsize {}: {:>6} {:>6} {:>6} {:>6} {:>6} {:>6}",
390 type_label, "x128", "x64", "x32", "x16", "x8", "x4"
391 );
392 info!(
393 " 128x: {:>5.1}% {:>5.1}% {}",
394 self.get_bsize_pct_by_frame_type(BlockSize::BLOCK_128X128, frame_type),
395 self.get_bsize_pct_by_frame_type(BlockSize::BLOCK_128X64, frame_type),
396 if frame_type == FrameType::INTER {
397 format!("skip: {:>5.1}%", self.get_skip_pct_by_frame_type(frame_type))
398 } else {
399 String::new()
400 }
401 );
402 info!(
403 " 64x: {:>5.1}% {:>5.1}% {:>5.1}% {:>5.1}%",
404 self.get_bsize_pct_by_frame_type(BlockSize::BLOCK_64X128, frame_type),
405 self.get_bsize_pct_by_frame_type(BlockSize::BLOCK_64X64, frame_type),
406 self.get_bsize_pct_by_frame_type(BlockSize::BLOCK_64X32, frame_type),
407 self.get_bsize_pct_by_frame_type(BlockSize::BLOCK_64X16, frame_type),
408 );
409 info!(
410 " 32x: {:>5.1}% {:>5.1}% {:>5.1}% {:>5.1}%",
411 self.get_bsize_pct_by_frame_type(BlockSize::BLOCK_32X64, frame_type),
412 self.get_bsize_pct_by_frame_type(BlockSize::BLOCK_32X32, frame_type),
413 self.get_bsize_pct_by_frame_type(BlockSize::BLOCK_32X16, frame_type),
414 self.get_bsize_pct_by_frame_type(BlockSize::BLOCK_32X8, frame_type),
415 );
416 info!(
417 " 16x: {:>5.1}% {:>5.1}% {:>5.1}% {:>5.1}% {:>5.1}%",
418 self.get_bsize_pct_by_frame_type(BlockSize::BLOCK_16X64, frame_type),
419 self.get_bsize_pct_by_frame_type(BlockSize::BLOCK_16X32, frame_type),
420 self.get_bsize_pct_by_frame_type(BlockSize::BLOCK_16X16, frame_type),
421 self.get_bsize_pct_by_frame_type(BlockSize::BLOCK_16X8, frame_type),
422 self.get_bsize_pct_by_frame_type(BlockSize::BLOCK_16X4, frame_type),
423 );
424 info!(
425 " 8x: {:>5.1}% {:>5.1}% {:>5.1}% {:>5.1}%",
426 self.get_bsize_pct_by_frame_type(BlockSize::BLOCK_8X32, frame_type),
427 self.get_bsize_pct_by_frame_type(BlockSize::BLOCK_8X16, frame_type),
428 self.get_bsize_pct_by_frame_type(BlockSize::BLOCK_8X8, frame_type),
429 self.get_bsize_pct_by_frame_type(BlockSize::BLOCK_8X4, frame_type),
430 );
431 info!(
432 " 4x: {:>5.1}% {:>5.1}% {:>5.1}%",
433 self.get_bsize_pct_by_frame_type(BlockSize::BLOCK_4X16, frame_type),
434 self.get_bsize_pct_by_frame_type(BlockSize::BLOCK_4X8, frame_type),
435 self.get_bsize_pct_by_frame_type(BlockSize::BLOCK_4X4, frame_type),
436 );
437 }
438
439 fn print_transform_type_summary(&self) {
440 info!("----------");
441 self.print_transform_type_summary_by_frame_type(FrameType::KEY, 'I');
442 self.print_transform_type_summary_by_frame_type(FrameType::INTER, 'P');
443 }
444
445 fn print_transform_type_summary_by_frame_type(
446 &self, frame_type: FrameType, type_label: char,
447 ) {
448 info!(
449 "txtypes {}: DCT_DCT: {:.1}% | ADST_DCT: {:.1}% | DCT_ADST: {:.1}% | ADST_ADST: {:.1}%",
450 type_label,
451 self.get_txtype_pct_by_frame_type(TxType::DCT_DCT, frame_type),
452 self.get_txtype_pct_by_frame_type(TxType::ADST_DCT, frame_type),
453 self.get_txtype_pct_by_frame_type(TxType::DCT_ADST, frame_type),
454 self.get_txtype_pct_by_frame_type(TxType::ADST_ADST, frame_type)
455 );
456 info!(
457 " IDTX: {:.1}% | V_DCT: {:.1}% | H_DCT: {:.1}%",
458 self.get_txtype_pct_by_frame_type(TxType::IDTX, frame_type),
459 self.get_txtype_pct_by_frame_type(TxType::V_DCT, frame_type),
460 self.get_txtype_pct_by_frame_type(TxType::H_DCT, frame_type),
461 )
462 }
463
464 fn print_prediction_modes_summary(&self) {
465 info!("----------");
466 self.print_luma_prediction_mode_summary_by_frame_type(FrameType::KEY, 'I');
467 self
468 .print_chroma_prediction_mode_summary_by_frame_type(FrameType::KEY, 'I');
469 info!("----------");
470 self
471 .print_luma_prediction_mode_summary_by_frame_type(FrameType::INTER, 'P');
472 self.print_chroma_prediction_mode_summary_by_frame_type(
473 FrameType::INTER,
474 'P',
475 );
476 }
477
478 fn print_luma_prediction_mode_summary_by_frame_type(
479 &self, frame_type: FrameType, type_label: char,
480 ) {
481 if frame_type == FrameType::KEY {
482 info!(
483 "y modes {}: DC: {:.1}% | V: {:.1}% | H: {:.1}% | Paeth: {:.1}%",
484 type_label,
485 self.get_luma_pred_mode_pct_by_frame_type(
486 PredictionMode::DC_PRED,
487 frame_type
488 ),
489 self.get_luma_pred_mode_pct_by_frame_type(
490 PredictionMode::V_PRED,
491 frame_type
492 ),
493 self.get_luma_pred_mode_pct_by_frame_type(
494 PredictionMode::H_PRED,
495 frame_type
496 ),
497 self.get_luma_pred_mode_pct_by_frame_type(
498 PredictionMode::PAETH_PRED,
499 frame_type
500 ),
501 );
502 info!(
503 " Smooth: {:.1}% | Smooth V: {:.1}% | Smooth H: {:.1}%",
504 self.get_luma_pred_mode_pct_by_frame_type(
505 PredictionMode::SMOOTH_PRED,
506 frame_type
507 ),
508 self.get_luma_pred_mode_pct_by_frame_type(
509 PredictionMode::SMOOTH_V_PRED,
510 frame_type
511 ),
512 self.get_luma_pred_mode_pct_by_frame_type(
513 PredictionMode::SMOOTH_H_PRED,
514 frame_type
515 ),
516 );
517 // Keep angular order for presentation here, rather than enum order.
518 info!(
519 " D: 45: {:.1}% | 67: {:.1}% | 113: {:.1}% | 135: {:.1}% | 157: {:.1}% | 203: {:.1}%",
520 self.get_luma_pred_mode_pct_by_frame_type(PredictionMode::D45_PRED, frame_type),
521 self.get_luma_pred_mode_pct_by_frame_type(PredictionMode::D67_PRED, frame_type),
522 self.get_luma_pred_mode_pct_by_frame_type(PredictionMode::D113_PRED, frame_type),
523 self.get_luma_pred_mode_pct_by_frame_type(PredictionMode::D135_PRED, frame_type),
524 self.get_luma_pred_mode_pct_by_frame_type(PredictionMode::D157_PRED, frame_type),
525 self.get_luma_pred_mode_pct_by_frame_type(PredictionMode::D203_PRED, frame_type),
526 );
527 } else if frame_type == FrameType::INTER {
528 info!(
529 "y modes {}: Nearest: {:.1}% | Near0: {:.1}% | Near1: {:.1}% | NearNear0: {:.1}% | NearNear1: {:.1}% | NearNear2: {:.1}%",
530 type_label,
531 self.get_luma_pred_mode_pct_by_frame_type(PredictionMode::NEARESTMV, frame_type),
532 self.get_luma_pred_mode_pct_by_frame_type(PredictionMode::NEAR0MV, frame_type),
533 self.get_luma_pred_mode_pct_by_frame_type(PredictionMode::NEAR1MV, frame_type),
534 self.get_luma_pred_mode_pct_by_frame_type(PredictionMode::NEAR_NEAR0MV, frame_type),
535 self.get_luma_pred_mode_pct_by_frame_type(PredictionMode::NEAR_NEAR1MV, frame_type),
536 self.get_luma_pred_mode_pct_by_frame_type(PredictionMode::NEAR_NEAR2MV, frame_type),
537 );
538 info!(
539 "y modes {}: NearNew0: {:.1}% | NearNew1: {:.1}% | NearNew2: {:.1}%",
540 type_label,
541 self.get_luma_pred_mode_pct_by_frame_type(
542 PredictionMode::NEAR_NEW0MV,
543 frame_type
544 ),
545 self.get_luma_pred_mode_pct_by_frame_type(
546 PredictionMode::NEAR_NEW1MV,
547 frame_type
548 ),
549 self.get_luma_pred_mode_pct_by_frame_type(
550 PredictionMode::NEAR_NEW2MV,
551 frame_type
552 ),
553 );
554 info!(
555 "y modes {}: NewNear0: {:.1}% | NewNear1: {:.1}% | NewNear2: {:.1}%",
556 type_label,
557 self.get_luma_pred_mode_pct_by_frame_type(
558 PredictionMode::NEW_NEAR0MV,
559 frame_type
560 ),
561 self.get_luma_pred_mode_pct_by_frame_type(
562 PredictionMode::NEW_NEAR1MV,
563 frame_type
564 ),
565 self.get_luma_pred_mode_pct_by_frame_type(
566 PredictionMode::NEW_NEAR2MV,
567 frame_type
568 ),
569 );
570 }
571 }
572
573 fn print_chroma_prediction_mode_summary_by_frame_type(
574 &self, frame_type: FrameType, type_label: char,
575 ) {
576 if frame_type == FrameType::KEY {
577 info!(
578 "uv modes {}: DC: {:.1}% | V: {:.1}% | H: {:.1}% | Paeth: {:.1}%",
579 type_label,
580 self.get_chroma_pred_mode_pct_by_frame_type(
581 PredictionMode::DC_PRED,
582 frame_type
583 ),
584 self.get_chroma_pred_mode_pct_by_frame_type(
585 PredictionMode::V_PRED,
586 frame_type
587 ),
588 self.get_chroma_pred_mode_pct_by_frame_type(
589 PredictionMode::H_PRED,
590 frame_type
591 ),
592 self.get_chroma_pred_mode_pct_by_frame_type(
593 PredictionMode::PAETH_PRED,
594 frame_type
595 ),
596 );
597 info!(
598 " Smooth: {:.1}% | Smooth V: {:.1}% | Smooth H: {:.1}% | UV CFL: {:.1}%",
599 self.get_chroma_pred_mode_pct_by_frame_type(PredictionMode::SMOOTH_PRED, frame_type),
600 self.get_chroma_pred_mode_pct_by_frame_type(PredictionMode::SMOOTH_V_PRED, frame_type),
601 self.get_chroma_pred_mode_pct_by_frame_type(PredictionMode::SMOOTH_H_PRED, frame_type),
602 self.get_chroma_pred_mode_pct_by_frame_type(PredictionMode::UV_CFL_PRED, frame_type),
603 );
604 // Keep angular order for presentation here, rather than enum order.
605 info!(
606 " D: 45: {:.1}% | 67: {:.1}% | 113: {:.1}% | 135: {:.1}% | 157: {:.1}% | 203: {:.1}%",
607 self.get_chroma_pred_mode_pct_by_frame_type(PredictionMode::D45_PRED, frame_type),
608 self.get_chroma_pred_mode_pct_by_frame_type(PredictionMode::D67_PRED, frame_type),
609 self.get_chroma_pred_mode_pct_by_frame_type(PredictionMode::D113_PRED, frame_type),
610 self.get_chroma_pred_mode_pct_by_frame_type(PredictionMode::D135_PRED, frame_type),
611 self.get_chroma_pred_mode_pct_by_frame_type(PredictionMode::D157_PRED, frame_type),
612 self.get_chroma_pred_mode_pct_by_frame_type(PredictionMode::D203_PRED, frame_type),
613 );
614 } else if frame_type == FrameType::INTER {
615 info!(
616 "uv modes {}: Nearest: {:.1}% | Near0: {:.1}% | Near1: {:.1}% | NearNear0: {:.1}% | NearNear1: {:.1}% | NearNear2: {:.1}%",
617 type_label,
618 self.get_chroma_pred_mode_pct_by_frame_type(PredictionMode::NEARESTMV, frame_type),
619 self.get_chroma_pred_mode_pct_by_frame_type(PredictionMode::NEAR0MV, frame_type),
620 self.get_chroma_pred_mode_pct_by_frame_type(PredictionMode::NEAR1MV, frame_type),
621 self.get_chroma_pred_mode_pct_by_frame_type(PredictionMode::NEAR_NEAR0MV, frame_type),
622 self.get_chroma_pred_mode_pct_by_frame_type(PredictionMode::NEAR_NEAR1MV, frame_type),
623 self.get_chroma_pred_mode_pct_by_frame_type(PredictionMode::NEAR_NEAR2MV, frame_type),
624 );
625 info!(
626 "uv modes {}: NearNew0: {:.1}% | NearNew1: {:.1}% | NearNew2: {:.1}%",
627 type_label,
628 self.get_chroma_pred_mode_pct_by_frame_type(
629 PredictionMode::NEAR_NEW0MV,
630 frame_type
631 ),
632 self.get_chroma_pred_mode_pct_by_frame_type(
633 PredictionMode::NEAR_NEW1MV,
634 frame_type
635 ),
636 self.get_chroma_pred_mode_pct_by_frame_type(
637 PredictionMode::NEAR_NEW2MV,
638 frame_type
639 ),
640 );
641 info!(
642 "uv modes {}: NewNear0: {:.1}% | NewNear1: {:.1}% | NewNear2: {:.1}%",
643 type_label,
644 self.get_chroma_pred_mode_pct_by_frame_type(
645 PredictionMode::NEW_NEAR0MV,
646 frame_type
647 ),
648 self.get_chroma_pred_mode_pct_by_frame_type(
649 PredictionMode::NEW_NEAR1MV,
650 frame_type
651 ),
652 self.get_chroma_pred_mode_pct_by_frame_type(
653 PredictionMode::NEW_NEAR2MV,
654 frame_type
655 ),
656 );
657 info!(" New: {:.1}% | NewNew: {:.1}% | NearestNearest: {:.1}% | GlobalGlobal: {:.1}%",
658 self.get_chroma_pred_mode_pct_by_frame_type(PredictionMode::NEWMV, frame_type),
659 self.get_chroma_pred_mode_pct_by_frame_type(PredictionMode::NEW_NEWMV, frame_type),
660 self.get_chroma_pred_mode_pct_by_frame_type(PredictionMode::NEAREST_NEARESTMV, frame_type),
661 self.get_chroma_pred_mode_pct_by_frame_type(PredictionMode::GLOBAL_GLOBALMV, frame_type),);
662 }
663 }
664 }
665
666 fn sum_metric<F: FnMut(&FrameSummary) -> f64>(
667 frame_info: &[FrameSummary], map_fn: F,
668 ) -> f64 {
669 frame_info.iter().map(map_fn).sum::<f64>() / frame_info.len() as f64
670 }
671
672 impl fmt::Display for ProgressInfo {
673 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
674 if let Some(total_frames) = self.total_frames {
675 write!(
676 f,
677 "encoded {}/{} frames, {:.3} fps, {:.2} Kb/s, est: {}, {:.2} MB, elapsed: {}",
678 self.frames_encoded(),
679 total_frames,
680 self.encoding_fps(),
681 self.bitrate() as f64 / 1000f64,
682 secs_to_human_time(self.estimated_time()),
683 self.estimated_size() as f64 / (1024 * 1024) as f64,
684 secs_to_human_time(self.elapsed_time())
685 )
686 } else {
687 write!(
688 f,
689 "encoded {} frames, {:.3} fps, {:.2} Kb/s, elapsed: {}",
690 self.frames_encoded(),
691 self.encoding_fps(),
692 self.bitrate() as f64 / 1000f64,
693 secs_to_human_time(self.elapsed_time())
694 )
695 }
696 }
697 }
698
699 fn secs_to_human_time(mut secs: u64) -> String {
700 let mut mins = secs / 60;
701 secs %= 60;
702 let hours = mins / 60;
703 mins %= 60;
704 if hours > 0 {
705 format!("{hours}h {mins}m {secs}s")
706 } else if mins > 0 {
707 format!("{mins}m {secs}s")
708 } else {
709 format!("{secs}s")
710 }
711 }
712
713 #[derive(Debug, Clone, Copy, Default, PartialEq)]
714 pub struct QualityMetrics {
715 /// Peak Signal-to-Noise Ratio for Y, U, and V planes
716 pub psnr: Option<PlanarMetrics>,
717 /// Peak Signal-to-Noise Ratio as perceived by the Human Visual System--
718 /// taking into account Contrast Sensitivity Function (CSF)
719 pub psnr_hvs: Option<PlanarMetrics>,
720 /// Structural Similarity
721 pub ssim: Option<PlanarMetrics>,
722 /// Multi-Scale Structural Similarity
723 pub ms_ssim: Option<PlanarMetrics>,
724 /// CIEDE 2000 [color difference algorithm](https://en.wikipedia.org/wiki/Color_difference#CIEDE2000)
725 pub ciede: Option<f64>,
726 /// Aligned Peak Signal-to-Noise Ratio for Y, U, and V planes
727 pub apsnr: Option<PlanarMetrics>,
728 /// Netflix's Video Multimethod Assessment Fusion
729 pub vmaf: Option<f64>,
730 }
731
732 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
733 pub enum MetricsEnabled {
734 /// Don't calculate any metrics.
735 None,
736 /// Calculate the PSNR of each plane, but no other metrics.
737 Psnr,
738 /// Calculate all implemented metrics. Currently implemented metrics match what is available via AWCY.
739 All,
740 }
741
742 pub fn calculate_frame_metrics<T: Pixel>(
743 frame1: &Frame<T>, frame2: &Frame<T>, bit_depth: usize, cs: ChromaSampling,
744 metrics: MetricsEnabled,
745 ) -> QualityMetrics {
746 match metrics {
747 MetricsEnabled::None => QualityMetrics::default(),
748 MetricsEnabled::Psnr => QualityMetrics {
749 psnr: Some(
750 psnr::calculate_frame_psnr(frame1, frame2, bit_depth, cs).unwrap(),
751 ),
752 ..Default::default()
753 },
754 MetricsEnabled::All => {
755 let mut metrics = QualityMetrics {
756 psnr: Some(
757 psnr::calculate_frame_psnr(frame1, frame2, bit_depth, cs).unwrap(),
758 ),
759 psnr_hvs: Some(
760 psnr_hvs::calculate_frame_psnr_hvs(frame1, frame2, bit_depth, cs)
761 .unwrap(),
762 ),
763 ..Default::default()
764 };
765 let ssim = ssim::calculate_frame_ssim(frame1, frame2, bit_depth, cs);
766 metrics.ssim = Some(ssim.unwrap());
767 let ms_ssim =
768 ssim::calculate_frame_msssim(frame1, frame2, bit_depth, cs);
769 metrics.ms_ssim = Some(ms_ssim.unwrap());
770 let ciede = ciede::calculate_frame_ciede(frame1, frame2, bit_depth, cs);
771 metrics.ciede = Some(ciede.unwrap());
772 // TODO APSNR
773 // TODO VMAF
774 metrics
775 }
776 }
777 }