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
ExtractResolutionFromFilename(const char * name,int * width_ptr,int * height_ptr)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] == '_') && name[i + 1] >= '0' &&
75 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
ScaleY(uint8 y)110 uint8 ScaleY(uint8 y) {
111 int ny = (y - 16) * 256 / 224;
112 if (ny < 0)
113 ny = 0;
114 if (ny > 255)
115 ny = 255;
116 return static_cast<uint8>(ny);
117 }
118
119 // MSE = Mean Square Error
GetMSE(double sse,double size)120 double GetMSE(double sse, double size) {
121 return sse / size;
122 }
123
PrintHelp(const char * program)124 void PrintHelp(const char* program) {
125 printf("%s [-options] org_seq rec_seq [rec_seq2.. etc]\n", program);
126 #ifdef HAVE_JPEG
127 printf("jpeg or raw YUV 420 supported.\n");
128 #endif
129 printf("options:\n");
130 printf(
131 " -s <width> <height> .... specify YUV size, mandatory if none of the "
132 "sequences have the\n");
133 printf(
134 " resolution embedded in their filename (ie. "
135 "name.1920x800_24Hz_P420.yuv)\n");
136 printf(" -psnr .................. compute PSNR (default)\n");
137 printf(" -ssim .................. compute SSIM\n");
138 printf(" -mse ................... compute MSE\n");
139 printf(" -swap .................. Swap U and V plane\n");
140 printf(" -skip <org> <rec> ...... Number of frame to skip of org and rec\n");
141 printf(" -frames <num> .......... Number of frames to compare\n");
142 #ifdef _OPENMP
143 printf(" -t <num> ............... Number of threads\n");
144 #endif
145 printf(" -n ..................... Show file name\n");
146 printf(" -v ..................... verbose++\n");
147 printf(" -q ..................... quiet\n");
148 printf(" -h ..................... this help\n");
149 exit(0);
150 }
151
ParseOptions(int argc,const char * argv[])152 void ParseOptions(int argc, const char* argv[]) {
153 if (argc <= 1)
154 PrintHelp(argv[0]);
155 for (int c = 1; c < argc; ++c) {
156 if (!strcmp(argv[c], "-v")) {
157 verbose = true;
158 } else if (!strcmp(argv[c], "-q")) {
159 quiet = true;
160 } else if (!strcmp(argv[c], "-n")) {
161 show_name = true;
162 } else if (!strcmp(argv[c], "-psnr")) {
163 do_psnr = true;
164 } else if (!strcmp(argv[c], "-mse")) {
165 do_mse = true;
166 } else if (!strcmp(argv[c], "-ssim")) {
167 do_ssim = true;
168 } else if (!strcmp(argv[c], "-lssim")) {
169 do_ssim = true;
170 do_lssim = true;
171 } else if (!strcmp(argv[c], "-swap")) {
172 do_swap_uv = true;
173 } else if (!strcmp(argv[c], "-h") || !strcmp(argv[c], "-help")) {
174 PrintHelp(argv[0]);
175 } else if (!strcmp(argv[c], "-s") && c + 2 < argc) {
176 image_width = atoi(argv[++c]); // NOLINT
177 image_height = atoi(argv[++c]); // NOLINT
178 } else if (!strcmp(argv[c], "-skip") && c + 2 < argc) {
179 num_skip_org = atoi(argv[++c]); // NOLINT
180 num_skip_rec = atoi(argv[++c]); // NOLINT
181 } else if (!strcmp(argv[c], "-frames") && c + 1 < argc) {
182 num_frames = atoi(argv[++c]); // NOLINT
183 #ifdef _OPENMP
184 } else if (!strcmp(argv[c], "-t") && c + 1 < argc) {
185 num_threads = atoi(argv[++c]); // NOLINT
186 #endif
187 } else if (argv[c][0] == '-') {
188 fprintf(stderr, "Unknown option. %s\n", argv[c]);
189 } else if (fileindex_org == 0) {
190 fileindex_org = c;
191 } else if (fileindex_rec == 0) {
192 fileindex_rec = c;
193 num_rec = 1;
194 } else {
195 ++num_rec;
196 }
197 }
198 if (fileindex_org == 0 || fileindex_rec == 0) {
199 fprintf(stderr, "Missing filenames\n");
200 PrintHelp(argv[0]);
201 }
202 if (num_skip_org < 0 || num_skip_rec < 0) {
203 fprintf(stderr, "Skipped frames incorrect\n");
204 PrintHelp(argv[0]);
205 }
206 if (num_frames < 0) {
207 fprintf(stderr, "Number of frames incorrect\n");
208 PrintHelp(argv[0]);
209 }
210 if (image_width == 0 || image_height == 0) {
211 int org_width, org_height;
212 int rec_width, rec_height;
213 bool org_res_avail = ExtractResolutionFromFilename(argv[fileindex_org],
214 &org_width, &org_height);
215 bool rec_res_avail = ExtractResolutionFromFilename(argv[fileindex_rec],
216 &rec_width, &rec_height);
217 if (org_res_avail) {
218 if (rec_res_avail) {
219 if ((org_width == rec_width) && (org_height == rec_height)) {
220 image_width = org_width;
221 image_height = org_height;
222 } else {
223 fprintf(stderr, "Sequences have different resolutions.\n");
224 PrintHelp(argv[0]);
225 }
226 } else {
227 image_width = org_width;
228 image_height = org_height;
229 }
230 } else if (rec_res_avail) {
231 image_width = rec_width;
232 image_height = rec_height;
233 } else {
234 fprintf(stderr, "Missing dimensions.\n");
235 PrintHelp(argv[0]);
236 }
237 }
238 }
239
UpdateMetrics(uint8 * ch_org,uint8 * ch_rec,const int y_size,const int uv_size,const size_t total_size,int number_of_frames,metric * cur_distortion_psnr,metric * distorted_frame,bool do_psnr)240 bool UpdateMetrics(uint8* ch_org,
241 uint8* ch_rec,
242 const int y_size,
243 const int uv_size,
244 const size_t total_size,
245 int number_of_frames,
246 metric* cur_distortion_psnr,
247 metric* distorted_frame,
248 bool do_psnr) {
249 const int uv_offset = (do_swap_uv ? uv_size : 0);
250 const uint8* const u_org = ch_org + y_size + uv_offset;
251 const uint8* const u_rec = ch_rec + y_size;
252 const uint8* const v_org = ch_org + y_size + (uv_size - uv_offset);
253 const uint8* const v_rec = ch_rec + y_size + uv_size;
254 if (do_psnr) {
255 #ifdef HAVE_JPEG
256 double y_err = static_cast<double>(
257 libyuv::ComputeSumSquareError(ch_org, ch_rec, y_size));
258 double u_err = static_cast<double>(
259 libyuv::ComputeSumSquareError(u_org, u_rec, uv_size));
260 double v_err = static_cast<double>(
261 libyuv::ComputeSumSquareError(v_org, v_rec, uv_size));
262 #else
263 double y_err = ComputeSumSquareError(ch_org, ch_rec, y_size);
264 double u_err = ComputeSumSquareError(u_org, u_rec, uv_size);
265 double v_err = ComputeSumSquareError(v_org, v_rec, uv_size);
266 #endif
267 const double total_err = y_err + u_err + v_err;
268 cur_distortion_psnr->global_y += y_err;
269 cur_distortion_psnr->global_u += u_err;
270 cur_distortion_psnr->global_v += v_err;
271 cur_distortion_psnr->global_all += total_err;
272 distorted_frame->y = ComputePSNR(y_err, static_cast<double>(y_size));
273 distorted_frame->u = ComputePSNR(u_err, static_cast<double>(uv_size));
274 distorted_frame->v = ComputePSNR(v_err, static_cast<double>(uv_size));
275 distorted_frame->all =
276 ComputePSNR(total_err, static_cast<double>(total_size));
277 } else {
278 distorted_frame->y = CalcSSIM(ch_org, ch_rec, image_width, image_height);
279 distorted_frame->u =
280 CalcSSIM(u_org, u_rec, (image_width + 1) / 2, (image_height + 1) / 2);
281 distorted_frame->v =
282 CalcSSIM(v_org, v_rec, (image_width + 1) / 2, (image_height + 1) / 2);
283 distorted_frame->all =
284 (distorted_frame->y + distorted_frame->u + distorted_frame->v) /
285 total_size;
286 distorted_frame->y /= y_size;
287 distorted_frame->u /= uv_size;
288 distorted_frame->v /= uv_size;
289
290 if (do_lssim) {
291 distorted_frame->all = CalcLSSIM(distorted_frame->all);
292 distorted_frame->y = CalcLSSIM(distorted_frame->y);
293 distorted_frame->u = CalcLSSIM(distorted_frame->u);
294 distorted_frame->v = CalcLSSIM(distorted_frame->v);
295 }
296 }
297
298 cur_distortion_psnr->y += distorted_frame->y;
299 cur_distortion_psnr->u += distorted_frame->u;
300 cur_distortion_psnr->v += distorted_frame->v;
301 cur_distortion_psnr->all += distorted_frame->all;
302
303 bool ismin = false;
304 if (distorted_frame->y < cur_distortion_psnr->min_y)
305 cur_distortion_psnr->min_y = distorted_frame->y;
306 if (distorted_frame->u < cur_distortion_psnr->min_u)
307 cur_distortion_psnr->min_u = distorted_frame->u;
308 if (distorted_frame->v < cur_distortion_psnr->min_v)
309 cur_distortion_psnr->min_v = distorted_frame->v;
310 if (distorted_frame->all < cur_distortion_psnr->min_all) {
311 cur_distortion_psnr->min_all = distorted_frame->all;
312 cur_distortion_psnr->min_frame = number_of_frames;
313 ismin = true;
314 }
315 return ismin;
316 }
317
main(int argc,const char * argv[])318 int main(int argc, const char* argv[]) {
319 ParseOptions(argc, argv);
320 if (!do_psnr && !do_ssim) {
321 do_psnr = true;
322 }
323
324 #ifdef _OPENMP
325 if (num_threads) {
326 omp_set_num_threads(num_threads);
327 }
328 if (verbose) {
329 printf("OpenMP %d procs\n", omp_get_num_procs());
330 }
331 #endif
332 // Open original file (first file argument)
333 FILE* const file_org = fopen(argv[fileindex_org], "rb");
334 if (file_org == NULL) {
335 fprintf(stderr, "Cannot open %s\n", argv[fileindex_org]);
336 exit(1);
337 }
338
339 // Open all files to compare to
340 FILE** file_rec = new FILE*[num_rec];
341 memset(file_rec, 0, num_rec * sizeof(FILE*)); // NOLINT
342 for (int cur_rec = 0; cur_rec < num_rec; ++cur_rec) {
343 file_rec[cur_rec] = fopen(argv[fileindex_rec + cur_rec], "rb");
344 if (file_rec[cur_rec] == NULL) {
345 fprintf(stderr, "Cannot open %s\n", argv[fileindex_rec + cur_rec]);
346 fclose(file_org);
347 for (int i = 0; i < cur_rec; ++i) {
348 fclose(file_rec[i]);
349 }
350 delete[] file_rec;
351 exit(1);
352 }
353 }
354
355 const int y_size = image_width * image_height;
356 const int uv_size = ((image_width + 1) / 2) * ((image_height + 1) / 2);
357 const size_t total_size = y_size + 2 * uv_size; // NOLINT
358 #if defined(_MSC_VER)
359 _fseeki64(
360 file_org,
361 static_cast<__int64>(num_skip_org) * static_cast<__int64>(total_size),
362 SEEK_SET);
363 #else
364 fseek(file_org, num_skip_org * total_size, SEEK_SET);
365 #endif
366 for (int cur_rec = 0; cur_rec < num_rec; ++cur_rec) {
367 #if defined(_MSC_VER)
368 _fseeki64(
369 file_rec[cur_rec],
370 static_cast<__int64>(num_skip_rec) * static_cast<__int64>(total_size),
371 SEEK_SET);
372 #else
373 fseek(file_rec[cur_rec], num_skip_rec * total_size, SEEK_SET);
374 #endif
375 }
376
377 uint8* const ch_org = new uint8[total_size];
378 uint8* const ch_rec = new uint8[total_size];
379 if (ch_org == NULL || ch_rec == NULL) {
380 fprintf(stderr, "No memory available\n");
381 fclose(file_org);
382 for (int i = 0; i < num_rec; ++i) {
383 fclose(file_rec[i]);
384 }
385 delete[] ch_org;
386 delete[] ch_rec;
387 delete[] file_rec;
388 exit(1);
389 }
390
391 metric* const distortion_psnr = new metric[num_rec];
392 metric* const distortion_ssim = new metric[num_rec];
393 for (int cur_rec = 0; cur_rec < num_rec; ++cur_rec) {
394 metric* cur_distortion_psnr = &distortion_psnr[cur_rec];
395 cur_distortion_psnr->y = 0.0;
396 cur_distortion_psnr->u = 0.0;
397 cur_distortion_psnr->v = 0.0;
398 cur_distortion_psnr->all = 0.0;
399 cur_distortion_psnr->min_y = kMaxPSNR;
400 cur_distortion_psnr->min_u = kMaxPSNR;
401 cur_distortion_psnr->min_v = kMaxPSNR;
402 cur_distortion_psnr->min_all = kMaxPSNR;
403 cur_distortion_psnr->min_frame = 0;
404 cur_distortion_psnr->global_y = 0.0;
405 cur_distortion_psnr->global_u = 0.0;
406 cur_distortion_psnr->global_v = 0.0;
407 cur_distortion_psnr->global_all = 0.0;
408 distortion_ssim[cur_rec] = cur_distortion_psnr[cur_rec];
409 }
410
411 if (verbose) {
412 printf("Size: %dx%d\n", image_width, image_height);
413 }
414
415 if (!quiet) {
416 printf("Frame");
417 if (do_psnr) {
418 printf("\t PSNR-Y \t PSNR-U \t PSNR-V \t PSNR-All \t Frame");
419 }
420 if (do_ssim) {
421 printf("\t SSIM-Y\t SSIM-U\t SSIM-V\t SSIM-All\t Frame");
422 }
423 if (show_name) {
424 printf("\tName\n");
425 } else {
426 printf("\n");
427 }
428 }
429
430 int number_of_frames;
431 for (number_of_frames = 0;; ++number_of_frames) {
432 if (num_frames && number_of_frames >= num_frames)
433 break;
434
435 size_t bytes_org = fread(ch_org, sizeof(uint8), total_size, file_org);
436 if (bytes_org < total_size) {
437 #ifdef HAVE_JPEG
438 // Try parsing file as a jpeg.
439 uint8* const ch_jpeg = new uint8[bytes_org];
440 memcpy(ch_jpeg, ch_org, bytes_org);
441 memset(ch_org, 0, total_size);
442
443 if (0 != libyuv::MJPGToI420(ch_jpeg, bytes_org, ch_org, image_width,
444 ch_org + y_size, (image_width + 1) / 2,
445 ch_org + y_size + uv_size,
446 (image_width + 1) / 2, image_width,
447 image_height, image_width, image_height)) {
448 delete[] ch_jpeg;
449 break;
450 }
451 delete[] ch_jpeg;
452 #else
453 break;
454 #endif // HAVE_JPEG
455 }
456
457 for (int cur_rec = 0; cur_rec < num_rec; ++cur_rec) {
458 size_t bytes_rec =
459 fread(ch_rec, sizeof(uint8), total_size, file_rec[cur_rec]);
460 if (bytes_rec < total_size) {
461 #ifdef HAVE_JPEG
462 // Try parsing file as a jpeg.
463 uint8* const ch_jpeg = new uint8[bytes_rec];
464 memcpy(ch_jpeg, ch_rec, bytes_rec);
465 memset(ch_rec, 0, total_size);
466
467 if (0 != libyuv::MJPGToI420(ch_jpeg, bytes_rec, ch_rec, image_width,
468 ch_rec + y_size, (image_width + 1) / 2,
469 ch_rec + y_size + uv_size,
470 (image_width + 1) / 2, image_width,
471 image_height, image_width, image_height)) {
472 delete[] ch_jpeg;
473 break;
474 }
475 delete[] ch_jpeg;
476 #else
477 break;
478 #endif // HAVE_JPEG
479 }
480
481 if (verbose) {
482 printf("%5d", number_of_frames);
483 }
484 if (do_psnr) {
485 metric distorted_frame;
486 metric* cur_distortion_psnr = &distortion_psnr[cur_rec];
487 bool ismin = UpdateMetrics(ch_org, ch_rec, y_size, uv_size, total_size,
488 number_of_frames, cur_distortion_psnr,
489 &distorted_frame, true);
490 if (verbose) {
491 printf("\t%10.6f", distorted_frame.y);
492 printf("\t%10.6f", distorted_frame.u);
493 printf("\t%10.6f", distorted_frame.v);
494 printf("\t%10.6f", distorted_frame.all);
495 printf("\t%5s", ismin ? "min" : "");
496 }
497 }
498 if (do_ssim) {
499 metric distorted_frame;
500 metric* cur_distortion_ssim = &distortion_ssim[cur_rec];
501 bool ismin = UpdateMetrics(ch_org, ch_rec, y_size, uv_size, total_size,
502 number_of_frames, cur_distortion_ssim,
503 &distorted_frame, false);
504 if (verbose) {
505 printf("\t%10.6f", distorted_frame.y);
506 printf("\t%10.6f", distorted_frame.u);
507 printf("\t%10.6f", distorted_frame.v);
508 printf("\t%10.6f", distorted_frame.all);
509 printf("\t%5s", ismin ? "min" : "");
510 }
511 }
512 if (verbose) {
513 if (show_name) {
514 printf("\t%s", argv[fileindex_rec + cur_rec]);
515 }
516 printf("\n");
517 }
518 }
519 }
520
521 // Final PSNR computation.
522 for (int cur_rec = 0; cur_rec < num_rec; ++cur_rec) {
523 metric* cur_distortion_psnr = &distortion_psnr[cur_rec];
524 metric* cur_distortion_ssim = &distortion_ssim[cur_rec];
525 if (number_of_frames > 0) {
526 const double norm = 1. / static_cast<double>(number_of_frames);
527 cur_distortion_psnr->y *= norm;
528 cur_distortion_psnr->u *= norm;
529 cur_distortion_psnr->v *= norm;
530 cur_distortion_psnr->all *= norm;
531 cur_distortion_ssim->y *= norm;
532 cur_distortion_ssim->u *= norm;
533 cur_distortion_ssim->v *= norm;
534 cur_distortion_ssim->all *= norm;
535 }
536
537 if (do_psnr) {
538 const double global_psnr_y =
539 ComputePSNR(cur_distortion_psnr->global_y,
540 static_cast<double>(y_size) * number_of_frames);
541 const double global_psnr_u =
542 ComputePSNR(cur_distortion_psnr->global_u,
543 static_cast<double>(uv_size) * number_of_frames);
544 const double global_psnr_v =
545 ComputePSNR(cur_distortion_psnr->global_v,
546 static_cast<double>(uv_size) * number_of_frames);
547 const double global_psnr_all =
548 ComputePSNR(cur_distortion_psnr->global_all,
549 static_cast<double>(total_size) * number_of_frames);
550 printf("Global:\t%10.6f\t%10.6f\t%10.6f\t%10.6f\t%5d", global_psnr_y,
551 global_psnr_u, global_psnr_v, global_psnr_all, number_of_frames);
552 if (show_name) {
553 printf("\t%s", argv[fileindex_rec + cur_rec]);
554 }
555 printf("\n");
556 }
557
558 if (!quiet) {
559 printf("Avg:");
560 if (do_psnr) {
561 printf("\t%10.6f\t%10.6f\t%10.6f\t%10.6f\t%5d", cur_distortion_psnr->y,
562 cur_distortion_psnr->u, cur_distortion_psnr->v,
563 cur_distortion_psnr->all, number_of_frames);
564 }
565 if (do_ssim) {
566 printf("\t%10.6f\t%10.6f\t%10.6f\t%10.6f\t%5d", cur_distortion_ssim->y,
567 cur_distortion_ssim->u, cur_distortion_ssim->v,
568 cur_distortion_ssim->all, number_of_frames);
569 }
570 if (show_name) {
571 printf("\t%s", argv[fileindex_rec + cur_rec]);
572 }
573 printf("\n");
574 }
575 if (!quiet) {
576 printf("Min:");
577 if (do_psnr) {
578 printf("\t%10.6f\t%10.6f\t%10.6f\t%10.6f\t%5d",
579 cur_distortion_psnr->min_y, cur_distortion_psnr->min_u,
580 cur_distortion_psnr->min_v, cur_distortion_psnr->min_all,
581 cur_distortion_psnr->min_frame);
582 }
583 if (do_ssim) {
584 printf("\t%10.6f\t%10.6f\t%10.6f\t%10.6f\t%5d",
585 cur_distortion_ssim->min_y, cur_distortion_ssim->min_u,
586 cur_distortion_ssim->min_v, cur_distortion_ssim->min_all,
587 cur_distortion_ssim->min_frame);
588 }
589 if (show_name) {
590 printf("\t%s", argv[fileindex_rec + cur_rec]);
591 }
592 printf("\n");
593 }
594
595 if (do_mse) {
596 double global_mse_y =
597 GetMSE(cur_distortion_psnr->global_y,
598 static_cast<double>(y_size) * number_of_frames);
599 double global_mse_u =
600 GetMSE(cur_distortion_psnr->global_u,
601 static_cast<double>(uv_size) * number_of_frames);
602 double global_mse_v =
603 GetMSE(cur_distortion_psnr->global_v,
604 static_cast<double>(uv_size) * number_of_frames);
605 double global_mse_all =
606 GetMSE(cur_distortion_psnr->global_all,
607 static_cast<double>(total_size) * number_of_frames);
608 printf("MSE:\t%10.6f\t%10.6f\t%10.6f\t%10.6f\t%5d", global_mse_y,
609 global_mse_u, global_mse_v, global_mse_all, number_of_frames);
610 if (show_name) {
611 printf("\t%s", argv[fileindex_rec + cur_rec]);
612 }
613 printf("\n");
614 }
615 }
616 fclose(file_org);
617 for (int cur_rec = 0; cur_rec < num_rec; ++cur_rec) {
618 fclose(file_rec[cur_rec]);
619 }
620 delete[] distortion_psnr;
621 delete[] distortion_ssim;
622 delete[] ch_org;
623 delete[] ch_rec;
624 delete[] file_rec;
625 return 0;
626 }
627