src/third_party/libyuv/util/psnr_main.cc

   1 /*
   2  *  Copyright 2013 The LibYuv Project Authors. All rights reserved.
   3  *
   4  *  Use of this source code is governed by a BSD-style license
   5  *  that can be found in the LICENSE file in the root of the source
   6  *  tree. An additional intellectual property rights grant can be found
   7  *  in the file PATENTS. All contributing project authors may
   8  *  be found in the AUTHORS file in the root of the source tree.
   9  */
  10
  11 // Get PSNR or SSIM for video sequence. Assuming RAW 4:2:0 Y:Cb:Cr format
  12 // To build: g++ -O3 -o psnr psnr.cc ssim.cc psnr_main.cc
  13 // or VisualC: cl /Ox psnr.cc ssim.cc psnr_main.cc
  14 //
  15 // To enable OpenMP and SSE2
  16 // gcc: g++ -msse2 -O3 -fopenmp -o psnr psnr.cc ssim.cc psnr_main.cc
  17 // vc:  cl /arch:SSE2 /Ox /openmp psnr.cc ssim.cc psnr_main.cc
  18 //
  19 // Usage: psnr org_seq rec_seq -s width height [-skip skip_org skip_rec]
  20
  21 #ifndef _CRT_SECURE_NO_WARNINGS
  22 #define _CRT_SECURE_NO_WARNINGS
  23 #endif
  24
  25 #include <stddef.h>
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #ifdef _OPENMP
  30 #include <omp.h>
  31 #endif
  32
  33 #include "./psnr.h"
  34 #include "./ssim.h"
  35 #ifdef HAVE_JPEG
  36 #include "libyuv/compare.h"
  37 #include "libyuv/convert.h"
  38 #endif
  39
  40 struct metric {
  41   double y, u, v, all;
  42   double min_y, min_u, min_v, min_all;
  43   double global_y, global_u, global_v, global_all;
  44   int min_frame;
  45 };
  46
  47 // options
  48 bool verbose = false;
  49 bool quiet = false;
  50 bool show_name = false;
  51 bool do_swap_uv = false;
  52 bool do_psnr = false;
  53 bool do_ssim = false;
  54 bool do_mse = false;
  55 bool do_lssim = false;
  56 int image_width = 0, image_height = 0;
  57 int fileindex_org = 0;  // argv argument contains the source file name.
  58 int fileindex_rec = 0;  // argv argument contains the destination file name.
  59 int num_rec = 0;
  60 int num_skip_org = 0;
  61 int num_skip_rec = 0;
  62 int num_frames = 0;
  63 #ifdef _OPENMP
  64 int num_threads = 0;
  65 #endif
  66
  67 // Parse PYUV format. ie name.1920x800_24Hz_P420.yuv
  68 bool ExtractResolutionFromFilename(const char* name,
  69                                    int* width_ptr,
  70                                    int* height_ptr) {
  71   // Isolate the .width_height. section of the filename by searching for a
  72   // dot or underscore followed by a digit.
  73   for (int i = 0; name[i]; ++i) {
  74     if ((name[i] == '.' || name[i] == '_') &&
  75         name[i + 1] >= '0' && name[i + 1] <= '9') {
  76       int n = sscanf(name + i + 1, "%dx%d", width_ptr, height_ptr);  // NOLINT
  77       if (2 == n) {
  78         return true;
  79       }
  80     }
  81   }
  82
  83 #ifdef HAVE_JPEG
  84   // Try parsing file as a jpeg.
  85   FILE* const file_org = fopen(name, "rb");
  86   if (file_org == NULL) {
  87     fprintf(stderr, "Cannot open %s\n", name);
  88     return false;
  89   }
  90   fseek(file_org, 0, SEEK_END);
  91   size_t total_size  = ftell(file_org);
  92   fseek(file_org, 0, SEEK_SET);
  93   uint8* const ch_org = new uint8[total_size];
  94   memset(ch_org, 0, total_size);
  95   size_t bytes_org = fread(ch_org, sizeof(uint8), total_size, file_org);
  96   fclose(file_org);
  97   if (bytes_org == total_size) {
  98     if (0 == libyuv::MJPGSize(ch_org, total_size, width_ptr, height_ptr)) {
  99       delete[] ch_org;
 100       return true;
 101     }
 102   }
 103   delete[] ch_org;
 104 #endif  // HAVE_JPEG
 105   return false;
 106 }
 107
 108 // Scale Y channel from 16..240 to 0..255.
 109 // This can be useful when comparing codecs that are inconsistant about Y
 110 uint8 ScaleY(uint8 y) {
 111   int ny = (y - 16) * 256 / 224;
 112   if (ny < 0) ny = 0;
 113   if (ny > 255) ny = 255;
 114   return static_cast<uint8>(ny);
 115 }
 116
 117 // MSE = Mean Square Error
 118 double GetMSE(double sse, double size) {
 119   return sse / size;
 120 }
 121
 122 void PrintHelp(const char * program) {
 123   printf("%s [-options] org_seq rec_seq [rec_seq2.. etc]\n", program);
 124 #ifdef HAVE_JPEG
 125   printf("jpeg or raw YUV 420 supported.\n");
 126 #endif
 127   printf("options:\n");
 128   printf(" -s <width> <height> .... specify YUV size, mandatory if none of the "
 129          "sequences have the\n");
 130   printf("                          resolution embedded in their filename (ie. "
 131          "name.1920x800_24Hz_P420.yuv)\n");
 132   printf(" -psnr .................. compute PSNR (default)\n");
 133   printf(" -ssim .................. compute SSIM\n");
 134   printf(" -mse ................... compute MSE\n");
 135   printf(" -swap .................. Swap U and V plane\n");
 136   printf(" -skip <org> <rec> ...... Number of frame to skip of org and rec\n");
 137   printf(" -frames <num> .......... Number of frames to compare\n");
 138 #ifdef _OPENMP
 139   printf(" -t <num> ............... Number of threads\n");
 140 #endif
 141   printf(" -n ..................... Show file name\n");
 142   printf(" -v ..................... verbose++\n");
 143   printf(" -q ..................... quiet\n");
 144   printf(" -h ..................... this help\n");
 145   exit(0);
 146 }
 147
 148 void ParseOptions(int argc, const char* argv[]) {
 149   if (argc <= 1) PrintHelp(argv[0]);
 150   for (int c = 1; c < argc; ++c) {
 151     if (!strcmp(argv[c], "-v")) {
 152       verbose = true;
 153     } else if (!strcmp(argv[c], "-q")) {
 154       quiet = true;
 155     } else if (!strcmp(argv[c], "-n")) {
 156       show_name = true;
 157     } else if (!strcmp(argv[c], "-psnr")) {
 158       do_psnr = true;
 159     } else if (!strcmp(argv[c], "-mse")) {
 160       do_mse = true;
 161     } else if (!strcmp(argv[c], "-ssim")) {
 162       do_ssim = true;
 163     } else if (!strcmp(argv[c], "-lssim")) {
 164       do_ssim = true;
 165       do_lssim = true;
 166     } else if (!strcmp(argv[c], "-swap")) {
 167       do_swap_uv = true;
 168     } else if (!strcmp(argv[c], "-h") || !strcmp(argv[c], "-help")) {
 169       PrintHelp(argv[0]);
 170     } else if (!strcmp(argv[c], "-s") && c + 2 < argc) {
 171       image_width = atoi(argv[++c]);    // NOLINT
 172       image_height = atoi(argv[++c]);   // NOLINT
 173     } else if (!strcmp(argv[c], "-skip") && c + 2 < argc) {
 174       num_skip_org = atoi(argv[++c]);   // NOLINT
 175       num_skip_rec = atoi(argv[++c]);   // NOLINT
 176     } else if (!strcmp(argv[c], "-frames") && c + 1 < argc) {
 177       num_frames = atoi(argv[++c]);     // NOLINT
 178 #ifdef _OPENMP
 179     } else if (!strcmp(argv[c], "-t") && c + 1 < argc) {
 180       num_threads = atoi(argv[++c]);    // NOLINT
 181 #endif
 182     } else if (argv[c][0] == '-') {
 183       fprintf(stderr, "Unknown option. %s\n", argv[c]);
 184     } else if (fileindex_org == 0) {
 185       fileindex_org = c;
 186     } else if (fileindex_rec == 0) {
 187       fileindex_rec = c;
 188       num_rec = 1;
 189     } else {
 190       ++num_rec;
 191     }
 192   }
 193   if (fileindex_org == 0 || fileindex_rec == 0) {
 194     fprintf(stderr, "Missing filenames\n");
 195     PrintHelp(argv[0]);
 196   }
 197   if (num_skip_org < 0 || num_skip_rec < 0) {
 198     fprintf(stderr, "Skipped frames incorrect\n");
 199     PrintHelp(argv[0]);
 200   }
 201   if (num_frames < 0) {
 202     fprintf(stderr, "Number of frames incorrect\n");
 203     PrintHelp(argv[0]);
 204   }
 205   if (image_width == 0 || image_height == 0) {
 206     int org_width, org_height;
 207     int rec_width, rec_height;
 208     bool org_res_avail = ExtractResolutionFromFilename(argv[fileindex_org],
 209                                                        &org_width,
 210                                                        &org_height);
 211     bool rec_res_avail = ExtractResolutionFromFilename(argv[fileindex_rec],
 212                                                        &rec_width,
 213                                                        &rec_height);
 214     if (org_res_avail) {
 215       if (rec_res_avail) {
 216         if ((org_width == rec_width) && (org_height == rec_height)) {
 217           image_width = org_width;
 218           image_height = org_height;
 219         } else {
 220           fprintf(stderr, "Sequences have different resolutions.\n");
 221           PrintHelp(argv[0]);
 222         }
 223       } else {
 224         image_width = org_width;
 225         image_height = org_height;
 226       }
 227     } else if (rec_res_avail) {
 228       image_width = rec_width;
 229       image_height = rec_height;
 230     } else {
 231       fprintf(stderr, "Missing dimensions.\n");
 232       PrintHelp(argv[0]);
 233     }
 234   }
 235 }
 236
 237 bool UpdateMetrics(uint8* ch_org, uint8* ch_rec,
 238                    const int y_size, const int uv_size, const size_t total_size,
 239                    int number_of_frames,
 240                    metric* cur_distortion_psnr,
 241                    metric* distorted_frame, bool do_psnr) {
 242   const int uv_offset = (do_swap_uv ? uv_size : 0);
 243   const uint8* const u_org = ch_org + y_size + uv_offset;
 244   const uint8* const u_rec = ch_rec + y_size;
 245   const uint8* const v_org = ch_org + y_size + (uv_size - uv_offset);
 246   const uint8* const v_rec = ch_rec + y_size + uv_size;
 247   if (do_psnr) {
 248 #ifdef HAVE_JPEG
 249     double y_err = static_cast<double>(
 250       libyuv::ComputeSumSquareError(ch_org, ch_rec, y_size));
 251     double u_err = static_cast<double>(
 252       libyuv::ComputeSumSquareError(u_org, u_rec, uv_size));
 253     double v_err = static_cast<double>(
 254       libyuv::ComputeSumSquareError(v_org, v_rec, uv_size));
 255 #else
 256     double y_err = ComputeSumSquareError(ch_org, ch_rec, y_size);
 257     double u_err = ComputeSumSquareError(u_org, u_rec, uv_size);
 258     double v_err = ComputeSumSquareError(v_org, v_rec, uv_size);
 259 #endif
 260     const double total_err = y_err + u_err + v_err;
 261     cur_distortion_psnr->global_y += y_err;
 262     cur_distortion_psnr->global_u += u_err;
 263     cur_distortion_psnr->global_v += v_err;
 264     cur_distortion_psnr->global_all += total_err;
 265     distorted_frame->y = ComputePSNR(y_err, static_cast<double>(y_size));
 266     distorted_frame->u = ComputePSNR(u_err, static_cast<double>(uv_size));
 267     distorted_frame->v = ComputePSNR(v_err, static_cast<double>(uv_size));
 268     distorted_frame->all = ComputePSNR(total_err,
 269                                        static_cast<double>(total_size));
 270   } else {
 271     distorted_frame->y = CalcSSIM(ch_org, ch_rec, image_width, image_height);
 272     distorted_frame->u = CalcSSIM(u_org, u_rec, (image_width + 1) / 2,
 273                                  (image_height + 1) / 2);
 274     distorted_frame->v = CalcSSIM(v_org, v_rec, (image_width + 1) / 2,
 275                                  (image_height + 1) / 2);
 276     distorted_frame->all =
 277       (distorted_frame->y + distorted_frame->u + distorted_frame->v)
 278         / total_size;
 279     distorted_frame->y /= y_size;
 280     distorted_frame->u /= uv_size;
 281     distorted_frame->v /= uv_size;
 282
 283     if (do_lssim) {
 284       distorted_frame->all = CalcLSSIM(distorted_frame->all);
 285       distorted_frame->y = CalcLSSIM(distorted_frame->y);
 286       distorted_frame->u = CalcLSSIM(distorted_frame->u);
 287       distorted_frame->v = CalcLSSIM(distorted_frame->v);
 288     }
 289   }
 290
 291   cur_distortion_psnr->y += distorted_frame->y;
 292   cur_distortion_psnr->u += distorted_frame->u;
 293   cur_distortion_psnr->v += distorted_frame->v;
 294   cur_distortion_psnr->all += distorted_frame->all;
 295
 296   bool ismin = false;
 297   if (distorted_frame->y < cur_distortion_psnr->min_y)
 298     cur_distortion_psnr->min_y = distorted_frame->y;
 299   if (distorted_frame->u < cur_distortion_psnr->min_u)
 300     cur_distortion_psnr->min_u = distorted_frame->u;
 301   if (distorted_frame->v < cur_distortion_psnr->min_v)
 302     cur_distortion_psnr->min_v = distorted_frame->v;
 303   if (distorted_frame->all < cur_distortion_psnr->min_all) {
 304     cur_distortion_psnr->min_all = distorted_frame->all;
 305     cur_distortion_psnr->min_frame = number_of_frames;
 306     ismin = true;
 307   }
 308   return ismin;
 309 }
 310
 311 int main(int argc, const char* argv[]) {
 312   ParseOptions(argc, argv);
 313   if (!do_psnr && !do_ssim) {
 314     do_psnr = true;
 315   }
 316
 317 #ifdef _OPENMP
 318   if (num_threads) {
 319     omp_set_num_threads(num_threads);
 320   }
 321   if (verbose) {
 322     printf("OpenMP %d procs\n", omp_get_num_procs());
 323   }
 324 #endif
 325   // Open original file (first file argument)
 326   FILE* const file_org = fopen(argv[fileindex_org], "rb");
 327   if (file_org == NULL) {
 328     fprintf(stderr, "Cannot open %s\n", argv[fileindex_org]);
 329     exit(1);
 330   }
 331
 332   // Open all files to compare to
 333   FILE** file_rec = new FILE* [num_rec];
 334   memset(file_rec, 0, num_rec * sizeof(FILE*)); // NOLINT
 335   for (int cur_rec = 0; cur_rec < num_rec; ++cur_rec) {
 336     file_rec[cur_rec] = fopen(argv[fileindex_rec + cur_rec], "rb");
 337     if (file_rec[cur_rec] == NULL) {
 338       fprintf(stderr, "Cannot open %s\n", argv[fileindex_rec + cur_rec]);
 339       fclose(file_org);
 340       for (int i = 0; i < cur_rec; ++i) {
 341         fclose(file_rec[i]);
 342       }
 343       delete[] file_rec;
 344       exit(1);
 345     }
 346   }
 347
 348   const int y_size = image_width * image_height;
 349   const int uv_size = ((image_width + 1) / 2) * ((image_height + 1) / 2);
 350   const size_t total_size = y_size + 2 * uv_size;    // NOLINT
 351 #if defined(_MSC_VER)
 352   _fseeki64(file_org,
 353             static_cast<__int64>(num_skip_org) *
 354             static_cast<__int64>(total_size), SEEK_SET);
 355 #else
 356   fseek(file_org, num_skip_org * total_size, SEEK_SET);
 357 #endif
 358   for (int cur_rec = 0; cur_rec < num_rec; ++cur_rec) {
 359 #if defined(_MSC_VER)
 360     _fseeki64(file_rec[cur_rec],
 361               static_cast<__int64>(num_skip_rec) *
 362               static_cast<__int64>(total_size),
 363               SEEK_SET);
 364 #else
 365     fseek(file_rec[cur_rec], num_skip_rec * total_size, SEEK_SET);
 366 #endif
 367   }
 368
 369   uint8* const ch_org = new uint8[total_size];
 370   uint8* const ch_rec = new uint8[total_size];
 371   if (ch_org == NULL || ch_rec == NULL) {
 372     fprintf(stderr, "No memory available\n");
 373     fclose(file_org);
 374     for (int i = 0; i < num_rec; ++i) {
 375       fclose(file_rec[i]);
 376     }
 377     delete[] ch_org;
 378     delete[] ch_rec;
 379     delete[] file_rec;
 380     exit(1);
 381   }
 382
 383   metric* const distortion_psnr = new metric[num_rec];
 384   metric* const distortion_ssim = new metric[num_rec];
 385   for (int cur_rec = 0; cur_rec < num_rec; ++cur_rec) {
 386     metric* cur_distortion_psnr = &distortion_psnr[cur_rec];
 387     cur_distortion_psnr->y = 0.0;
 388     cur_distortion_psnr->u = 0.0;
 389     cur_distortion_psnr->v = 0.0;
 390     cur_distortion_psnr->all = 0.0;
 391     cur_distortion_psnr->min_y = kMaxPSNR;
 392     cur_distortion_psnr->min_u = kMaxPSNR;
 393     cur_distortion_psnr->min_v = kMaxPSNR;
 394     cur_distortion_psnr->min_all = kMaxPSNR;
 395     cur_distortion_psnr->min_frame = 0;
 396     cur_distortion_psnr->global_y = 0.0;
 397     cur_distortion_psnr->global_u = 0.0;
 398     cur_distortion_psnr->global_v = 0.0;
 399     cur_distortion_psnr->global_all = 0.0;
 400     distortion_ssim[cur_rec] = cur_distortion_psnr[cur_rec];
 401   }
 402
 403   if (verbose) {
 404     printf("Size: %dx%d\n", image_width, image_height);
 405   }
 406
 407   if (!quiet) {
 408     printf("Frame");
 409     if (do_psnr) {
 410       printf("\t PSNR-Y \t PSNR-U \t PSNR-V \t PSNR-All \t Frame");
 411     }
 412     if (do_ssim) {
 413       printf("\t  SSIM-Y\t  SSIM-U\t  SSIM-V\t  SSIM-All\t Frame");
 414     }
 415     if (show_name) {
 416       printf("\tName\n");
 417     } else {
 418       printf("\n");
 419     }
 420   }
 421
 422   int number_of_frames;
 423   for (number_of_frames = 0; ; ++number_of_frames) {
 424     if (num_frames && number_of_frames >= num_frames)
 425       break;
 426
 427     size_t bytes_org = fread(ch_org, sizeof(uint8), total_size, file_org);
 428     if (bytes_org < total_size) {
 429 #ifdef HAVE_JPEG
 430       // Try parsing file as a jpeg.
 431       uint8* const ch_jpeg = new uint8[bytes_org];
 432       memcpy(ch_jpeg, ch_org, bytes_org);
 433       memset(ch_org, 0, total_size);
 434
 435       if (0 != libyuv::MJPGToI420(ch_jpeg, bytes_org,
 436                                   ch_org,
 437                                   image_width,
 438                                   ch_org + y_size,
 439                                   (image_width + 1) / 2,
 440                                   ch_org + y_size + uv_size,
 441                                   (image_width + 1) / 2,
 442                                   image_width,
 443                                   image_height,
 444                                   image_width,
 445                                   image_height)) {
 446         delete[] ch_jpeg;
 447         break;
 448       }
 449       delete[] ch_jpeg;
 450 #else
 451       break;
 452 #endif  // HAVE_JPEG
 453     }
 454
 455     for (int cur_rec = 0; cur_rec < num_rec; ++cur_rec) {
 456       size_t bytes_rec = fread(ch_rec, sizeof(uint8),
 457                                total_size, file_rec[cur_rec]);
 458       if (bytes_rec < total_size) {
 459 #ifdef HAVE_JPEG
 460         // Try parsing file as a jpeg.
 461         uint8* const ch_jpeg = new uint8[bytes_rec];
 462         memcpy(ch_jpeg, ch_rec, bytes_rec);
 463         memset(ch_rec, 0, total_size);
 464
 465         if (0 != libyuv::MJPGToI420(ch_jpeg, bytes_rec,
 466                                     ch_rec,
 467                                     image_width,
 468                                     ch_rec + y_size,
 469                                     (image_width + 1) / 2,
 470                                     ch_rec + y_size + uv_size,
 471                                     (image_width + 1) / 2,
 472                                     image_width,
 473                                     image_height,
 474                                     image_width,
 475                                     image_height)) {
 476           delete[] ch_jpeg;
 477           break;
 478         }
 479         delete[] ch_jpeg;
 480 #else
 481         break;
 482 #endif  // HAVE_JPEG
 483       }
 484
 485       if (verbose) {
 486         printf("%5d", number_of_frames);
 487       }
 488       if (do_psnr) {
 489         metric distorted_frame;
 490         metric* cur_distortion_psnr = &distortion_psnr[cur_rec];
 491         bool ismin = UpdateMetrics(ch_org, ch_rec,
 492                                    y_size, uv_size, total_size,
 493                                    number_of_frames,
 494                                    cur_distortion_psnr,
 495                                    &distorted_frame, true);
 496         if (verbose) {
 497           printf("\t%10.6f", distorted_frame.y);
 498           printf("\t%10.6f", distorted_frame.u);
 499           printf("\t%10.6f", distorted_frame.v);
 500           printf("\t%10.6f", distorted_frame.all);
 501           printf("\t%5s", ismin ? "min" : "");
 502         }
 503       }
 504       if (do_ssim) {
 505         metric distorted_frame;
 506         metric* cur_distortion_ssim = &distortion_ssim[cur_rec];
 507         bool ismin = UpdateMetrics(ch_org, ch_rec,
 508                                    y_size, uv_size, total_size,
 509                                    number_of_frames,
 510                                    cur_distortion_ssim,
 511                                    &distorted_frame, false);
 512         if (verbose) {
 513           printf("\t%10.6f", distorted_frame.y);
 514           printf("\t%10.6f", distorted_frame.u);
 515           printf("\t%10.6f", distorted_frame.v);
 516           printf("\t%10.6f", distorted_frame.all);
 517           printf("\t%5s", ismin ? "min" : "");
 518         }
 519       }
 520       if (verbose) {
 521         if (show_name) {
 522           printf("\t%s", argv[fileindex_rec + cur_rec]);
 523         }
 524         printf("\n");
 525       }
 526     }
 527   }
 528
 529   // Final PSNR computation.
 530   for (int cur_rec = 0; cur_rec < num_rec; ++cur_rec) {
 531     metric* cur_distortion_psnr = &distortion_psnr[cur_rec];
 532     metric* cur_distortion_ssim = &distortion_ssim[cur_rec];
 533     if (number_of_frames > 0) {
 534       const double norm = 1. / static_cast<double>(number_of_frames);
 535       cur_distortion_psnr->y *= norm;
 536       cur_distortion_psnr->u *= norm;
 537       cur_distortion_psnr->v *= norm;
 538       cur_distortion_psnr->all *= norm;
 539       cur_distortion_ssim->y *= norm;
 540       cur_distortion_ssim->u *= norm;
 541       cur_distortion_ssim->v *= norm;
 542       cur_distortion_ssim->all *= norm;
 543     }
 544
 545     if (do_psnr) {
 546       const double global_psnr_y = ComputePSNR(
 547           cur_distortion_psnr->global_y,
 548           static_cast<double>(y_size) * number_of_frames);
 549       const double global_psnr_u = ComputePSNR(
 550           cur_distortion_psnr->global_u,
 551           static_cast<double>(uv_size) * number_of_frames);
 552       const double global_psnr_v = ComputePSNR(
 553           cur_distortion_psnr->global_v,
 554           static_cast<double>(uv_size) * number_of_frames);
 555       const double global_psnr_all = ComputePSNR(
 556           cur_distortion_psnr->global_all,
 557           static_cast<double>(total_size) * number_of_frames);
 558       printf("Global:\t%10.6f\t%10.6f\t%10.6f\t%10.6f\t%5d",
 559           global_psnr_y,
 560           global_psnr_u,
 561           global_psnr_v,
 562           global_psnr_all,
 563           number_of_frames);
 564       if (show_name) {
 565         printf("\t%s", argv[fileindex_rec + cur_rec]);
 566       }
 567       printf("\n");
 568     }
 569
 570     if (!quiet) {
 571       printf("Avg:");
 572       if (do_psnr) {
 573         printf("\t%10.6f\t%10.6f\t%10.6f\t%10.6f\t%5d",
 574              cur_distortion_psnr->y,
 575              cur_distortion_psnr->u,
 576              cur_distortion_psnr->v,
 577              cur_distortion_psnr->all,
 578              number_of_frames);
 579       }
 580       if (do_ssim) {
 581         printf("\t%10.6f\t%10.6f\t%10.6f\t%10.6f\t%5d",
 582              cur_distortion_ssim->y,
 583              cur_distortion_ssim->u,
 584              cur_distortion_ssim->v,
 585              cur_distortion_ssim->all,
 586              number_of_frames);
 587       }
 588       if (show_name) {
 589         printf("\t%s", argv[fileindex_rec + cur_rec]);
 590       }
 591       printf("\n");
 592     }
 593     if (!quiet) {
 594       printf("Min:");
 595       if (do_psnr) {
 596         printf("\t%10.6f\t%10.6f\t%10.6f\t%10.6f\t%5d",
 597             cur_distortion_psnr->min_y,
 598             cur_distortion_psnr->min_u,
 599             cur_distortion_psnr->min_v,
 600             cur_distortion_psnr->min_all,
 601             cur_distortion_psnr->min_frame);
 602       }
 603       if (do_ssim) {
 604         printf("\t%10.6f\t%10.6f\t%10.6f\t%10.6f\t%5d",
 605             cur_distortion_ssim->min_y,
 606             cur_distortion_ssim->min_u,
 607             cur_distortion_ssim->min_v,
 608             cur_distortion_ssim->min_all,
 609             cur_distortion_ssim->min_frame);
 610       }
 611       if (show_name) {
 612         printf("\t%s", argv[fileindex_rec + cur_rec]);
 613       }
 614       printf("\n");
 615     }
 616
 617     if (do_mse) {
 618       double global_mse_y = GetMSE(cur_distortion_psnr->global_y,
 619         static_cast<double>(y_size) * number_of_frames);
 620       double global_mse_u = GetMSE(cur_distortion_psnr->global_u,
 621         static_cast<double>(uv_size) * number_of_frames);
 622       double global_mse_v = GetMSE(cur_distortion_psnr->global_v,
 623         static_cast<double>(uv_size) * number_of_frames);
 624       double global_mse_all = GetMSE(cur_distortion_psnr->global_all,
 625         static_cast<double>(total_size) * number_of_frames);
 626       printf("MSE:\t%10.6f\t%10.6f\t%10.6f\t%10.6f\t%5d",
 627           global_mse_y,
 628           global_mse_u,
 629           global_mse_v,
 630           global_mse_all,
 631           number_of_frames);
 632       if (show_name) {
 633         printf("\t%s", argv[fileindex_rec + cur_rec]);
 634       }
 635       printf("\n");
 636     }
 637   }
 638   fclose(file_org);
 639   for (int cur_rec = 0; cur_rec < num_rec; ++cur_rec) {
 640     fclose(file_rec[cur_rec]);
 641   }
 642   delete[] distortion_psnr;
 643   delete[] distortion_ssim;
 644   delete[] ch_org;
 645   delete[] ch_rec;
 646   delete[] file_rec;
 647   return 0;
 648 }