| 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 |
} |