1 /*
2 * Copyright (c) 2010 The WebM 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 #include <math.h>
12 #include <stdarg.h>
13 #include <stdio.h>
14 #include <stdlib.h>
15 #include <string.h>
16
17 #include "./tools_common.h"
18
19 #if CONFIG_VP8_ENCODER || CONFIG_VP9_ENCODER
20 #include "vpx/vp8cx.h"
21 #endif
22
23 #if CONFIG_VP8_DECODER || CONFIG_VP9_DECODER
24 #include "vpx/vp8dx.h"
25 #endif
26
27 #if defined(_WIN32) || defined(__OS2__)
28 #include <io.h>
29 #include <fcntl.h>
30
31 #ifdef __OS2__
32 #define _setmode setmode
33 #define _fileno fileno
34 #define _O_BINARY O_BINARY
35 #endif
36 #endif
37
38 #define LOG_ERROR(label) \
39 do { \
40 const char *l = label; \
41 va_list ap; \
42 va_start(ap, fmt); \
43 if (l) fprintf(stderr, "%s: ", l); \
44 vfprintf(stderr, fmt, ap); \
45 fprintf(stderr, "\n"); \
46 va_end(ap); \
47 } while (0)
48
49 #if CONFIG_ENCODERS
50 /* Swallow warnings about unused results of fread/fwrite */
wrap_fread(void * ptr,size_t size,size_t nmemb,FILE * stream)51 static size_t wrap_fread(void *ptr, size_t size, size_t nmemb, FILE *stream) {
52 return fread(ptr, size, nmemb, stream);
53 }
54 #define fread wrap_fread
55 #endif
56
set_binary_mode(FILE * stream)57 FILE *set_binary_mode(FILE *stream) {
58 (void)stream;
59 #if defined(_WIN32) || defined(__OS2__)
60 _setmode(_fileno(stream), _O_BINARY);
61 #endif
62 return stream;
63 }
64
die(const char * fmt,...)65 void die(const char *fmt, ...) {
66 LOG_ERROR(NULL);
67 usage_exit();
68 }
69
fatal(const char * fmt,...)70 void fatal(const char *fmt, ...) {
71 LOG_ERROR("Fatal");
72 exit(EXIT_FAILURE);
73 }
74
warn(const char * fmt,...)75 void warn(const char *fmt, ...) { LOG_ERROR("Warning"); }
76
die_codec(vpx_codec_ctx_t * ctx,const char * s)77 void die_codec(vpx_codec_ctx_t *ctx, const char *s) {
78 const char *detail = vpx_codec_error_detail(ctx);
79
80 printf("%s: %s\n", s, vpx_codec_error(ctx));
81 if (detail) printf(" %s\n", detail);
82 exit(EXIT_FAILURE);
83 }
84
read_yuv_frame(struct VpxInputContext * input_ctx,vpx_image_t * yuv_frame)85 int read_yuv_frame(struct VpxInputContext *input_ctx, vpx_image_t *yuv_frame) {
86 FILE *f = input_ctx->file;
87 struct FileTypeDetectionBuffer *detect = &input_ctx->detect;
88 int plane = 0;
89 int shortread = 0;
90 const int bytespp = (yuv_frame->fmt & VPX_IMG_FMT_HIGHBITDEPTH) ? 2 : 1;
91
92 for (plane = 0; plane < 3; ++plane) {
93 uint8_t *ptr;
94 int w = vpx_img_plane_width(yuv_frame, plane);
95 const int h = vpx_img_plane_height(yuv_frame, plane);
96 int r;
97 // Assuming that for nv12 we read all chroma data at one time
98 if (yuv_frame->fmt == VPX_IMG_FMT_NV12 && plane > 1) break;
99 // Fixing NV12 chroma width it is odd
100 if (yuv_frame->fmt == VPX_IMG_FMT_NV12 && plane == 1) w = (w + 1) & ~1;
101 /* Determine the correct plane based on the image format. The for-loop
102 * always counts in Y,U,V order, but this may not match the order of
103 * the data on disk.
104 */
105 switch (plane) {
106 case 1:
107 ptr =
108 yuv_frame->planes[yuv_frame->fmt == VPX_IMG_FMT_YV12 ? VPX_PLANE_V
109 : VPX_PLANE_U];
110 break;
111 case 2:
112 ptr =
113 yuv_frame->planes[yuv_frame->fmt == VPX_IMG_FMT_YV12 ? VPX_PLANE_U
114 : VPX_PLANE_V];
115 break;
116 default: ptr = yuv_frame->planes[plane];
117 }
118
119 for (r = 0; r < h; ++r) {
120 size_t needed = w * bytespp;
121 size_t buf_position = 0;
122 const size_t left = detect->buf_read - detect->position;
123 if (left > 0) {
124 const size_t more = (left < needed) ? left : needed;
125 memcpy(ptr, detect->buf + detect->position, more);
126 buf_position = more;
127 needed -= more;
128 detect->position += more;
129 }
130 if (needed > 0) {
131 shortread |= (fread(ptr + buf_position, 1, needed, f) < needed);
132 }
133
134 ptr += yuv_frame->stride[plane];
135 }
136 }
137
138 return shortread;
139 }
140
141 #if CONFIG_ENCODERS
142
143 static const VpxInterface vpx_encoders[] = {
144 #if CONFIG_VP8_ENCODER
145 { "vp8", VP8_FOURCC, &vpx_codec_vp8_cx },
146 #endif
147
148 #if CONFIG_VP9_ENCODER
149 { "vp9", VP9_FOURCC, &vpx_codec_vp9_cx },
150 #endif
151 };
152
get_vpx_encoder_count(void)153 int get_vpx_encoder_count(void) {
154 return sizeof(vpx_encoders) / sizeof(vpx_encoders[0]);
155 }
156
get_vpx_encoder_by_index(int i)157 const VpxInterface *get_vpx_encoder_by_index(int i) { return &vpx_encoders[i]; }
158
get_vpx_encoder_by_name(const char * name)159 const VpxInterface *get_vpx_encoder_by_name(const char *name) {
160 int i;
161
162 for (i = 0; i < get_vpx_encoder_count(); ++i) {
163 const VpxInterface *encoder = get_vpx_encoder_by_index(i);
164 if (strcmp(encoder->name, name) == 0) return encoder;
165 }
166
167 return NULL;
168 }
169
170 #endif // CONFIG_ENCODERS
171
172 #if CONFIG_DECODERS
173
174 static const VpxInterface vpx_decoders[] = {
175 #if CONFIG_VP8_DECODER
176 { "vp8", VP8_FOURCC, &vpx_codec_vp8_dx },
177 #endif
178
179 #if CONFIG_VP9_DECODER
180 { "vp9", VP9_FOURCC, &vpx_codec_vp9_dx },
181 #endif
182 };
183
get_vpx_decoder_count(void)184 int get_vpx_decoder_count(void) {
185 return sizeof(vpx_decoders) / sizeof(vpx_decoders[0]);
186 }
187
get_vpx_decoder_by_index(int i)188 const VpxInterface *get_vpx_decoder_by_index(int i) { return &vpx_decoders[i]; }
189
get_vpx_decoder_by_name(const char * name)190 const VpxInterface *get_vpx_decoder_by_name(const char *name) {
191 int i;
192
193 for (i = 0; i < get_vpx_decoder_count(); ++i) {
194 const VpxInterface *const decoder = get_vpx_decoder_by_index(i);
195 if (strcmp(decoder->name, name) == 0) return decoder;
196 }
197
198 return NULL;
199 }
200
get_vpx_decoder_by_fourcc(uint32_t fourcc)201 const VpxInterface *get_vpx_decoder_by_fourcc(uint32_t fourcc) {
202 int i;
203
204 for (i = 0; i < get_vpx_decoder_count(); ++i) {
205 const VpxInterface *const decoder = get_vpx_decoder_by_index(i);
206 if (decoder->fourcc == fourcc) return decoder;
207 }
208
209 return NULL;
210 }
211
212 #endif // CONFIG_DECODERS
213
vpx_img_plane_width(const vpx_image_t * img,int plane)214 int vpx_img_plane_width(const vpx_image_t *img, int plane) {
215 if (plane > 0 && img->x_chroma_shift > 0)
216 return (img->d_w + 1) >> img->x_chroma_shift;
217 else
218 return img->d_w;
219 }
220
vpx_img_plane_height(const vpx_image_t * img,int plane)221 int vpx_img_plane_height(const vpx_image_t *img, int plane) {
222 if (plane > 0 && img->y_chroma_shift > 0)
223 return (img->d_h + 1) >> img->y_chroma_shift;
224 else
225 return img->d_h;
226 }
227
vpx_img_write(const vpx_image_t * img,FILE * file)228 void vpx_img_write(const vpx_image_t *img, FILE *file) {
229 int plane;
230
231 for (plane = 0; plane < 3; ++plane) {
232 const unsigned char *buf = img->planes[plane];
233 const int stride = img->stride[plane];
234 const int w = vpx_img_plane_width(img, plane) *
235 ((img->fmt & VPX_IMG_FMT_HIGHBITDEPTH) ? 2 : 1);
236 const int h = vpx_img_plane_height(img, plane);
237 int y;
238
239 for (y = 0; y < h; ++y) {
240 fwrite(buf, 1, w, file);
241 buf += stride;
242 }
243 }
244 }
245
vpx_img_read(vpx_image_t * img,FILE * file)246 int vpx_img_read(vpx_image_t *img, FILE *file) {
247 int plane;
248
249 for (plane = 0; plane < 3; ++plane) {
250 unsigned char *buf = img->planes[plane];
251 const int stride = img->stride[plane];
252 const int w = vpx_img_plane_width(img, plane) *
253 ((img->fmt & VPX_IMG_FMT_HIGHBITDEPTH) ? 2 : 1);
254 const int h = vpx_img_plane_height(img, plane);
255 int y;
256
257 for (y = 0; y < h; ++y) {
258 if (fread(buf, 1, w, file) != (size_t)w) return 0;
259 buf += stride;
260 }
261 }
262
263 return 1;
264 }
265
266 // TODO(dkovalev) change sse_to_psnr signature: double -> int64_t
sse_to_psnr(double samples,double peak,double sse)267 double sse_to_psnr(double samples, double peak, double sse) {
268 static const double kMaxPSNR = 100.0;
269
270 if (sse > 0.0) {
271 const double psnr = 10.0 * log10(samples * peak * peak / sse);
272 return psnr > kMaxPSNR ? kMaxPSNR : psnr;
273 } else {
274 return kMaxPSNR;
275 }
276 }
277
278 #if CONFIG_ENCODERS
read_frame(struct VpxInputContext * input_ctx,vpx_image_t * img)279 int read_frame(struct VpxInputContext *input_ctx, vpx_image_t *img) {
280 FILE *f = input_ctx->file;
281 y4m_input *y4m = &input_ctx->y4m;
282 int shortread = 0;
283
284 if (input_ctx->file_type == FILE_TYPE_Y4M) {
285 if (y4m_input_fetch_frame(y4m, f, img) < 1) return 0;
286 } else {
287 shortread = read_yuv_frame(input_ctx, img);
288 }
289
290 return !shortread;
291 }
292
file_is_y4m(const char detect[4])293 int file_is_y4m(const char detect[4]) {
294 if (memcmp(detect, "YUV4", 4) == 0) {
295 return 1;
296 }
297 return 0;
298 }
299
fourcc_is_ivf(const char detect[4])300 int fourcc_is_ivf(const char detect[4]) {
301 if (memcmp(detect, "DKIF", 4) == 0) {
302 return 1;
303 }
304 return 0;
305 }
306
open_input_file(struct VpxInputContext * input)307 void open_input_file(struct VpxInputContext *input) {
308 /* Parse certain options from the input file, if possible */
309 input->file = strcmp(input->filename, "-") ? fopen(input->filename, "rb")
310 : set_binary_mode(stdin);
311
312 if (!input->file) fatal("Failed to open input file");
313
314 if (!fseeko(input->file, 0, SEEK_END)) {
315 /* Input file is seekable. Figure out how long it is, so we can get
316 * progress info.
317 */
318 input->length = ftello(input->file);
319 rewind(input->file);
320 }
321
322 /* Default to 1:1 pixel aspect ratio. */
323 input->pixel_aspect_ratio.numerator = 1;
324 input->pixel_aspect_ratio.denominator = 1;
325
326 /* For RAW input sources, these bytes will applied on the first frame
327 * in read_frame().
328 */
329 input->detect.buf_read = fread(input->detect.buf, 1, 4, input->file);
330 input->detect.position = 0;
331
332 if (input->detect.buf_read == 4 && file_is_y4m(input->detect.buf)) {
333 if (y4m_input_open(&input->y4m, input->file, input->detect.buf, 4,
334 input->only_i420) >= 0) {
335 input->file_type = FILE_TYPE_Y4M;
336 input->width = input->y4m.pic_w;
337 input->height = input->y4m.pic_h;
338 input->pixel_aspect_ratio.numerator = input->y4m.par_n;
339 input->pixel_aspect_ratio.denominator = input->y4m.par_d;
340 input->framerate.numerator = input->y4m.fps_n;
341 input->framerate.denominator = input->y4m.fps_d;
342 input->fmt = input->y4m.vpx_fmt;
343 input->bit_depth = input->y4m.bit_depth;
344 } else {
345 fatal("Unsupported Y4M stream.");
346 }
347 } else if (input->detect.buf_read == 4 && fourcc_is_ivf(input->detect.buf)) {
348 fatal("IVF is not supported as input.");
349 } else {
350 input->file_type = FILE_TYPE_RAW;
351 }
352 }
353
close_input_file(struct VpxInputContext * input)354 void close_input_file(struct VpxInputContext *input) {
355 fclose(input->file);
356 if (input->file_type == FILE_TYPE_Y4M) y4m_input_close(&input->y4m);
357 }
358 #endif
359
360 // TODO(debargha): Consolidate the functions below into a separate file.
361 #if CONFIG_VP9_HIGHBITDEPTH
highbd_img_upshift(vpx_image_t * dst,vpx_image_t * src,int input_shift)362 static void highbd_img_upshift(vpx_image_t *dst, vpx_image_t *src,
363 int input_shift) {
364 // Note the offset is 1 less than half.
365 const int offset = input_shift > 0 ? (1 << (input_shift - 1)) - 1 : 0;
366 int plane;
367 if (dst->d_w != src->d_w || dst->d_h != src->d_h ||
368 dst->x_chroma_shift != src->x_chroma_shift ||
369 dst->y_chroma_shift != src->y_chroma_shift || dst->fmt != src->fmt ||
370 input_shift < 0) {
371 fatal("Unsupported image conversion");
372 }
373 switch (src->fmt) {
374 case VPX_IMG_FMT_I42016:
375 case VPX_IMG_FMT_I42216:
376 case VPX_IMG_FMT_I44416:
377 case VPX_IMG_FMT_I44016: break;
378 default: fatal("Unsupported image conversion"); break;
379 }
380 for (plane = 0; plane < 3; plane++) {
381 int w = src->d_w;
382 int h = src->d_h;
383 int x, y;
384 if (plane) {
385 w = (w + src->x_chroma_shift) >> src->x_chroma_shift;
386 h = (h + src->y_chroma_shift) >> src->y_chroma_shift;
387 }
388 for (y = 0; y < h; y++) {
389 uint16_t *p_src =
390 (uint16_t *)(src->planes[plane] + y * src->stride[plane]);
391 uint16_t *p_dst =
392 (uint16_t *)(dst->planes[plane] + y * dst->stride[plane]);
393 for (x = 0; x < w; x++) *p_dst++ = (*p_src++ << input_shift) + offset;
394 }
395 }
396 }
397
lowbd_img_upshift(vpx_image_t * dst,vpx_image_t * src,int input_shift)398 static void lowbd_img_upshift(vpx_image_t *dst, vpx_image_t *src,
399 int input_shift) {
400 // Note the offset is 1 less than half.
401 const int offset = input_shift > 0 ? (1 << (input_shift - 1)) - 1 : 0;
402 int plane;
403 if (dst->d_w != src->d_w || dst->d_h != src->d_h ||
404 dst->x_chroma_shift != src->x_chroma_shift ||
405 dst->y_chroma_shift != src->y_chroma_shift ||
406 dst->fmt != src->fmt + VPX_IMG_FMT_HIGHBITDEPTH || input_shift < 0) {
407 fatal("Unsupported image conversion");
408 }
409 switch (src->fmt) {
410 case VPX_IMG_FMT_I420:
411 case VPX_IMG_FMT_I422:
412 case VPX_IMG_FMT_I444:
413 case VPX_IMG_FMT_I440: break;
414 default: fatal("Unsupported image conversion"); break;
415 }
416 for (plane = 0; plane < 3; plane++) {
417 int w = src->d_w;
418 int h = src->d_h;
419 int x, y;
420 if (plane) {
421 w = (w + src->x_chroma_shift) >> src->x_chroma_shift;
422 h = (h + src->y_chroma_shift) >> src->y_chroma_shift;
423 }
424 for (y = 0; y < h; y++) {
425 uint8_t *p_src = src->planes[plane] + y * src->stride[plane];
426 uint16_t *p_dst =
427 (uint16_t *)(dst->planes[plane] + y * dst->stride[plane]);
428 for (x = 0; x < w; x++) {
429 *p_dst++ = (*p_src++ << input_shift) + offset;
430 }
431 }
432 }
433 }
434
vpx_img_upshift(vpx_image_t * dst,vpx_image_t * src,int input_shift)435 void vpx_img_upshift(vpx_image_t *dst, vpx_image_t *src, int input_shift) {
436 if (src->fmt & VPX_IMG_FMT_HIGHBITDEPTH) {
437 highbd_img_upshift(dst, src, input_shift);
438 } else {
439 lowbd_img_upshift(dst, src, input_shift);
440 }
441 }
442
vpx_img_truncate_16_to_8(vpx_image_t * dst,vpx_image_t * src)443 void vpx_img_truncate_16_to_8(vpx_image_t *dst, vpx_image_t *src) {
444 int plane;
445 if (dst->fmt + VPX_IMG_FMT_HIGHBITDEPTH != src->fmt || dst->d_w != src->d_w ||
446 dst->d_h != src->d_h || dst->x_chroma_shift != src->x_chroma_shift ||
447 dst->y_chroma_shift != src->y_chroma_shift) {
448 fatal("Unsupported image conversion");
449 }
450 switch (dst->fmt) {
451 case VPX_IMG_FMT_I420:
452 case VPX_IMG_FMT_I422:
453 case VPX_IMG_FMT_I444:
454 case VPX_IMG_FMT_I440: break;
455 default: fatal("Unsupported image conversion"); break;
456 }
457 for (plane = 0; plane < 3; plane++) {
458 int w = src->d_w;
459 int h = src->d_h;
460 int x, y;
461 if (plane) {
462 w = (w + src->x_chroma_shift) >> src->x_chroma_shift;
463 h = (h + src->y_chroma_shift) >> src->y_chroma_shift;
464 }
465 for (y = 0; y < h; y++) {
466 uint16_t *p_src =
467 (uint16_t *)(src->planes[plane] + y * src->stride[plane]);
468 uint8_t *p_dst = dst->planes[plane] + y * dst->stride[plane];
469 for (x = 0; x < w; x++) {
470 *p_dst++ = (uint8_t)(*p_src++);
471 }
472 }
473 }
474 }
475
highbd_img_downshift(vpx_image_t * dst,vpx_image_t * src,int down_shift)476 static void highbd_img_downshift(vpx_image_t *dst, vpx_image_t *src,
477 int down_shift) {
478 int plane;
479 if (dst->d_w != src->d_w || dst->d_h != src->d_h ||
480 dst->x_chroma_shift != src->x_chroma_shift ||
481 dst->y_chroma_shift != src->y_chroma_shift || dst->fmt != src->fmt ||
482 down_shift < 0) {
483 fatal("Unsupported image conversion");
484 }
485 switch (src->fmt) {
486 case VPX_IMG_FMT_I42016:
487 case VPX_IMG_FMT_I42216:
488 case VPX_IMG_FMT_I44416:
489 case VPX_IMG_FMT_I44016: break;
490 default: fatal("Unsupported image conversion"); break;
491 }
492 for (plane = 0; plane < 3; plane++) {
493 int w = src->d_w;
494 int h = src->d_h;
495 int x, y;
496 if (plane) {
497 w = (w + src->x_chroma_shift) >> src->x_chroma_shift;
498 h = (h + src->y_chroma_shift) >> src->y_chroma_shift;
499 }
500 for (y = 0; y < h; y++) {
501 uint16_t *p_src =
502 (uint16_t *)(src->planes[plane] + y * src->stride[plane]);
503 uint16_t *p_dst =
504 (uint16_t *)(dst->planes[plane] + y * dst->stride[plane]);
505 for (x = 0; x < w; x++) *p_dst++ = *p_src++ >> down_shift;
506 }
507 }
508 }
509
lowbd_img_downshift(vpx_image_t * dst,vpx_image_t * src,int down_shift)510 static void lowbd_img_downshift(vpx_image_t *dst, vpx_image_t *src,
511 int down_shift) {
512 int plane;
513 if (dst->d_w != src->d_w || dst->d_h != src->d_h ||
514 dst->x_chroma_shift != src->x_chroma_shift ||
515 dst->y_chroma_shift != src->y_chroma_shift ||
516 src->fmt != dst->fmt + VPX_IMG_FMT_HIGHBITDEPTH || down_shift < 0) {
517 fatal("Unsupported image conversion");
518 }
519 switch (dst->fmt) {
520 case VPX_IMG_FMT_I420:
521 case VPX_IMG_FMT_I422:
522 case VPX_IMG_FMT_I444:
523 case VPX_IMG_FMT_I440: break;
524 default: fatal("Unsupported image conversion"); break;
525 }
526 for (plane = 0; plane < 3; plane++) {
527 int w = src->d_w;
528 int h = src->d_h;
529 int x, y;
530 if (plane) {
531 w = (w + src->x_chroma_shift) >> src->x_chroma_shift;
532 h = (h + src->y_chroma_shift) >> src->y_chroma_shift;
533 }
534 for (y = 0; y < h; y++) {
535 uint16_t *p_src =
536 (uint16_t *)(src->planes[plane] + y * src->stride[plane]);
537 uint8_t *p_dst = dst->planes[plane] + y * dst->stride[plane];
538 for (x = 0; x < w; x++) {
539 *p_dst++ = *p_src++ >> down_shift;
540 }
541 }
542 }
543 }
544
vpx_img_downshift(vpx_image_t * dst,vpx_image_t * src,int down_shift)545 void vpx_img_downshift(vpx_image_t *dst, vpx_image_t *src, int down_shift) {
546 if (dst->fmt & VPX_IMG_FMT_HIGHBITDEPTH) {
547 highbd_img_downshift(dst, src, down_shift);
548 } else {
549 lowbd_img_downshift(dst, src, down_shift);
550 }
551 }
552 #endif // CONFIG_VP9_HIGHBITDEPTH
553
compare_img(const vpx_image_t * const img1,const vpx_image_t * const img2)554 int compare_img(const vpx_image_t *const img1, const vpx_image_t *const img2) {
555 uint32_t l_w = img1->d_w;
556 uint32_t c_w = (img1->d_w + img1->x_chroma_shift) >> img1->x_chroma_shift;
557 const uint32_t c_h =
558 (img1->d_h + img1->y_chroma_shift) >> img1->y_chroma_shift;
559 uint32_t i;
560 int match = 1;
561
562 match &= (img1->fmt == img2->fmt);
563 match &= (img1->d_w == img2->d_w);
564 match &= (img1->d_h == img2->d_h);
565 #if CONFIG_VP9_HIGHBITDEPTH
566 if (img1->fmt & VPX_IMG_FMT_HIGHBITDEPTH) {
567 l_w *= 2;
568 c_w *= 2;
569 }
570 #endif
571
572 for (i = 0; i < img1->d_h; ++i)
573 match &= (memcmp(img1->planes[VPX_PLANE_Y] + i * img1->stride[VPX_PLANE_Y],
574 img2->planes[VPX_PLANE_Y] + i * img2->stride[VPX_PLANE_Y],
575 l_w) == 0);
576
577 for (i = 0; i < c_h; ++i)
578 match &= (memcmp(img1->planes[VPX_PLANE_U] + i * img1->stride[VPX_PLANE_U],
579 img2->planes[VPX_PLANE_U] + i * img2->stride[VPX_PLANE_U],
580 c_w) == 0);
581
582 for (i = 0; i < c_h; ++i)
583 match &= (memcmp(img1->planes[VPX_PLANE_V] + i * img1->stride[VPX_PLANE_V],
584 img2->planes[VPX_PLANE_V] + i * img2->stride[VPX_PLANE_V],
585 c_w) == 0);
586
587 return match;
588 }
589
590 #define mmin(a, b) ((a) < (b) ? (a) : (b))
591
592 #if CONFIG_VP9_HIGHBITDEPTH
find_mismatch_high(const vpx_image_t * const img1,const vpx_image_t * const img2,int yloc[4],int uloc[4],int vloc[4])593 void find_mismatch_high(const vpx_image_t *const img1,
594 const vpx_image_t *const img2, int yloc[4], int uloc[4],
595 int vloc[4]) {
596 uint16_t *plane1, *plane2;
597 uint32_t stride1, stride2;
598 const uint32_t bsize = 64;
599 const uint32_t bsizey = bsize >> img1->y_chroma_shift;
600 const uint32_t bsizex = bsize >> img1->x_chroma_shift;
601 const uint32_t c_w =
602 (img1->d_w + img1->x_chroma_shift) >> img1->x_chroma_shift;
603 const uint32_t c_h =
604 (img1->d_h + img1->y_chroma_shift) >> img1->y_chroma_shift;
605 int match = 1;
606 uint32_t i, j;
607 yloc[0] = yloc[1] = yloc[2] = yloc[3] = -1;
608 plane1 = (uint16_t *)img1->planes[VPX_PLANE_Y];
609 plane2 = (uint16_t *)img2->planes[VPX_PLANE_Y];
610 stride1 = img1->stride[VPX_PLANE_Y] / 2;
611 stride2 = img2->stride[VPX_PLANE_Y] / 2;
612 for (i = 0, match = 1; match && i < img1->d_h; i += bsize) {
613 for (j = 0; match && j < img1->d_w; j += bsize) {
614 int k, l;
615 const int si = mmin(i + bsize, img1->d_h) - i;
616 const int sj = mmin(j + bsize, img1->d_w) - j;
617 for (k = 0; match && k < si; ++k) {
618 for (l = 0; match && l < sj; ++l) {
619 if (*(plane1 + (i + k) * stride1 + j + l) !=
620 *(plane2 + (i + k) * stride2 + j + l)) {
621 yloc[0] = i + k;
622 yloc[1] = j + l;
623 yloc[2] = *(plane1 + (i + k) * stride1 + j + l);
624 yloc[3] = *(plane2 + (i + k) * stride2 + j + l);
625 match = 0;
626 break;
627 }
628 }
629 }
630 }
631 }
632
633 uloc[0] = uloc[1] = uloc[2] = uloc[3] = -1;
634 plane1 = (uint16_t *)img1->planes[VPX_PLANE_U];
635 plane2 = (uint16_t *)img2->planes[VPX_PLANE_U];
636 stride1 = img1->stride[VPX_PLANE_U] / 2;
637 stride2 = img2->stride[VPX_PLANE_U] / 2;
638 for (i = 0, match = 1; match && i < c_h; i += bsizey) {
639 for (j = 0; match && j < c_w; j += bsizex) {
640 int k, l;
641 const int si = mmin(i + bsizey, c_h - i);
642 const int sj = mmin(j + bsizex, c_w - j);
643 for (k = 0; match && k < si; ++k) {
644 for (l = 0; match && l < sj; ++l) {
645 if (*(plane1 + (i + k) * stride1 + j + l) !=
646 *(plane2 + (i + k) * stride2 + j + l)) {
647 uloc[0] = i + k;
648 uloc[1] = j + l;
649 uloc[2] = *(plane1 + (i + k) * stride1 + j + l);
650 uloc[3] = *(plane2 + (i + k) * stride2 + j + l);
651 match = 0;
652 break;
653 }
654 }
655 }
656 }
657 }
658
659 vloc[0] = vloc[1] = vloc[2] = vloc[3] = -1;
660 plane1 = (uint16_t *)img1->planes[VPX_PLANE_V];
661 plane2 = (uint16_t *)img2->planes[VPX_PLANE_V];
662 stride1 = img1->stride[VPX_PLANE_V] / 2;
663 stride2 = img2->stride[VPX_PLANE_V] / 2;
664 for (i = 0, match = 1; match && i < c_h; i += bsizey) {
665 for (j = 0; match && j < c_w; j += bsizex) {
666 int k, l;
667 const int si = mmin(i + bsizey, c_h - i);
668 const int sj = mmin(j + bsizex, c_w - j);
669 for (k = 0; match && k < si; ++k) {
670 for (l = 0; match && l < sj; ++l) {
671 if (*(plane1 + (i + k) * stride1 + j + l) !=
672 *(plane2 + (i + k) * stride2 + j + l)) {
673 vloc[0] = i + k;
674 vloc[1] = j + l;
675 vloc[2] = *(plane1 + (i + k) * stride1 + j + l);
676 vloc[3] = *(plane2 + (i + k) * stride2 + j + l);
677 match = 0;
678 break;
679 }
680 }
681 }
682 }
683 }
684 }
685 #endif // CONFIG_VP9_HIGHBITDEPTH
686
find_mismatch(const vpx_image_t * const img1,const vpx_image_t * const img2,int yloc[4],int uloc[4],int vloc[4])687 void find_mismatch(const vpx_image_t *const img1, const vpx_image_t *const img2,
688 int yloc[4], int uloc[4], int vloc[4]) {
689 const uint32_t bsize = 64;
690 const uint32_t bsizey = bsize >> img1->y_chroma_shift;
691 const uint32_t bsizex = bsize >> img1->x_chroma_shift;
692 const uint32_t c_w =
693 (img1->d_w + img1->x_chroma_shift) >> img1->x_chroma_shift;
694 const uint32_t c_h =
695 (img1->d_h + img1->y_chroma_shift) >> img1->y_chroma_shift;
696 int match = 1;
697 uint32_t i, j;
698 yloc[0] = yloc[1] = yloc[2] = yloc[3] = -1;
699 for (i = 0, match = 1; match && i < img1->d_h; i += bsize) {
700 for (j = 0; match && j < img1->d_w; j += bsize) {
701 int k, l;
702 const int si = mmin(i + bsize, img1->d_h) - i;
703 const int sj = mmin(j + bsize, img1->d_w) - j;
704 for (k = 0; match && k < si; ++k) {
705 for (l = 0; match && l < sj; ++l) {
706 if (*(img1->planes[VPX_PLANE_Y] +
707 (i + k) * img1->stride[VPX_PLANE_Y] + j + l) !=
708 *(img2->planes[VPX_PLANE_Y] +
709 (i + k) * img2->stride[VPX_PLANE_Y] + j + l)) {
710 yloc[0] = i + k;
711 yloc[1] = j + l;
712 yloc[2] = *(img1->planes[VPX_PLANE_Y] +
713 (i + k) * img1->stride[VPX_PLANE_Y] + j + l);
714 yloc[3] = *(img2->planes[VPX_PLANE_Y] +
715 (i + k) * img2->stride[VPX_PLANE_Y] + j + l);
716 match = 0;
717 break;
718 }
719 }
720 }
721 }
722 }
723
724 uloc[0] = uloc[1] = uloc[2] = uloc[3] = -1;
725 for (i = 0, match = 1; match && i < c_h; i += bsizey) {
726 for (j = 0; match && j < c_w; j += bsizex) {
727 int k, l;
728 const int si = mmin(i + bsizey, c_h - i);
729 const int sj = mmin(j + bsizex, c_w - j);
730 for (k = 0; match && k < si; ++k) {
731 for (l = 0; match && l < sj; ++l) {
732 if (*(img1->planes[VPX_PLANE_U] +
733 (i + k) * img1->stride[VPX_PLANE_U] + j + l) !=
734 *(img2->planes[VPX_PLANE_U] +
735 (i + k) * img2->stride[VPX_PLANE_U] + j + l)) {
736 uloc[0] = i + k;
737 uloc[1] = j + l;
738 uloc[2] = *(img1->planes[VPX_PLANE_U] +
739 (i + k) * img1->stride[VPX_PLANE_U] + j + l);
740 uloc[3] = *(img2->planes[VPX_PLANE_U] +
741 (i + k) * img2->stride[VPX_PLANE_U] + j + l);
742 match = 0;
743 break;
744 }
745 }
746 }
747 }
748 }
749 vloc[0] = vloc[1] = vloc[2] = vloc[3] = -1;
750 for (i = 0, match = 1; match && i < c_h; i += bsizey) {
751 for (j = 0; match && j < c_w; j += bsizex) {
752 int k, l;
753 const int si = mmin(i + bsizey, c_h - i);
754 const int sj = mmin(j + bsizex, c_w - j);
755 for (k = 0; match && k < si; ++k) {
756 for (l = 0; match && l < sj; ++l) {
757 if (*(img1->planes[VPX_PLANE_V] +
758 (i + k) * img1->stride[VPX_PLANE_V] + j + l) !=
759 *(img2->planes[VPX_PLANE_V] +
760 (i + k) * img2->stride[VPX_PLANE_V] + j + l)) {
761 vloc[0] = i + k;
762 vloc[1] = j + l;
763 vloc[2] = *(img1->planes[VPX_PLANE_V] +
764 (i + k) * img1->stride[VPX_PLANE_V] + j + l);
765 vloc[3] = *(img2->planes[VPX_PLANE_V] +
766 (i + k) * img2->stride[VPX_PLANE_V] + j + l);
767 match = 0;
768 break;
769 }
770 }
771 }
772 }
773 }
774 }
775