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 || CONFIG_VP10_ENCODER
20 #include "vpx/vp8cx.h"
21 #endif
22 
23 #if CONFIG_VP8_DECODER || CONFIG_VP9_DECODER || CONFIG_VP10_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) do {\
39   const char *l = label;\
40   va_list ap;\
41   va_start(ap, fmt);\
42   if (l)\
43     fprintf(stderr, "%s: ", l);\
44   vfprintf(stderr, fmt, ap);\
45   fprintf(stderr, "\n");\
46   va_end(ap);\
47 } while (0)
48 
49 
set_binary_mode(FILE * stream)50 FILE *set_binary_mode(FILE *stream) {
51   (void)stream;
52 #if defined(_WIN32) || defined(__OS2__)
53   _setmode(_fileno(stream), _O_BINARY);
54 #endif
55   return stream;
56 }
57 
die(const char * fmt,...)58 void die(const char *fmt, ...) {
59   LOG_ERROR(NULL);
60   usage_exit();
61 }
62 
fatal(const char * fmt,...)63 void fatal(const char *fmt, ...) {
64   LOG_ERROR("Fatal");
65   exit(EXIT_FAILURE);
66 }
67 
warn(const char * fmt,...)68 void warn(const char *fmt, ...) {
69   LOG_ERROR("Warning");
70 }
71 
die_codec(vpx_codec_ctx_t * ctx,const char * s)72 void die_codec(vpx_codec_ctx_t *ctx, const char *s) {
73   const char *detail = vpx_codec_error_detail(ctx);
74 
75   printf("%s: %s\n", s, vpx_codec_error(ctx));
76   if (detail)
77     printf("    %s\n", detail);
78   exit(EXIT_FAILURE);
79 }
80 
read_yuv_frame(struct VpxInputContext * input_ctx,vpx_image_t * yuv_frame)81 int read_yuv_frame(struct VpxInputContext *input_ctx, vpx_image_t *yuv_frame) {
82   FILE *f = input_ctx->file;
83   struct FileTypeDetectionBuffer *detect = &input_ctx->detect;
84   int plane = 0;
85   int shortread = 0;
86   const int bytespp = (yuv_frame->fmt & VPX_IMG_FMT_HIGHBITDEPTH) ? 2 : 1;
87 
88   for (plane = 0; plane < 3; ++plane) {
89     uint8_t *ptr;
90     const int w = vpx_img_plane_width(yuv_frame, plane);
91     const int h = vpx_img_plane_height(yuv_frame, plane);
92     int r;
93 
94     /* Determine the correct plane based on the image format. The for-loop
95      * always counts in Y,U,V order, but this may not match the order of
96      * the data on disk.
97      */
98     switch (plane) {
99       case 1:
100         ptr = yuv_frame->planes[
101             yuv_frame->fmt == VPX_IMG_FMT_YV12 ? VPX_PLANE_V : VPX_PLANE_U];
102         break;
103       case 2:
104         ptr = yuv_frame->planes[
105             yuv_frame->fmt == VPX_IMG_FMT_YV12 ? VPX_PLANE_U : VPX_PLANE_V];
106         break;
107       default:
108         ptr = yuv_frame->planes[plane];
109     }
110 
111     for (r = 0; r < h; ++r) {
112       size_t needed = w * bytespp;
113       size_t buf_position = 0;
114       const size_t left = detect->buf_read - detect->position;
115       if (left > 0) {
116         const size_t more = (left < needed) ? left : needed;
117         memcpy(ptr, detect->buf + detect->position, more);
118         buf_position = more;
119         needed -= more;
120         detect->position += more;
121       }
122       if (needed > 0) {
123         shortread |= (fread(ptr + buf_position, 1, needed, f) < needed);
124       }
125 
126       ptr += yuv_frame->stride[plane];
127     }
128   }
129 
130   return shortread;
131 }
132 
133 #if CONFIG_ENCODERS
134 
135 static const VpxInterface vpx_encoders[] = {
136 #if CONFIG_VP10_ENCODER
137   {"vp10", VP10_FOURCC, &vpx_codec_vp10_cx},
138 #endif
139 
140 #if CONFIG_VP8_ENCODER
141   {"vp8", VP8_FOURCC, &vpx_codec_vp8_cx},
142 #endif
143 
144 #if CONFIG_VP9_ENCODER
145   {"vp9", VP9_FOURCC, &vpx_codec_vp9_cx},
146 #endif
147 };
148 
get_vpx_encoder_count(void)149 int get_vpx_encoder_count(void) {
150   return sizeof(vpx_encoders) / sizeof(vpx_encoders[0]);
151 }
152 
get_vpx_encoder_by_index(int i)153 const VpxInterface *get_vpx_encoder_by_index(int i) {
154   return &vpx_encoders[i];
155 }
156 
get_vpx_encoder_by_name(const char * name)157 const VpxInterface *get_vpx_encoder_by_name(const char *name) {
158   int i;
159 
160   for (i = 0; i < get_vpx_encoder_count(); ++i) {
161     const VpxInterface *encoder = get_vpx_encoder_by_index(i);
162     if (strcmp(encoder->name, name) == 0)
163       return encoder;
164   }
165 
166   return NULL;
167 }
168 
169 #endif  // CONFIG_ENCODERS
170 
171 #if CONFIG_DECODERS
172 
173 static const VpxInterface vpx_decoders[] = {
174 #if CONFIG_VP8_DECODER
175   {"vp8", VP8_FOURCC, &vpx_codec_vp8_dx},
176 #endif
177 
178 #if CONFIG_VP9_DECODER
179   {"vp9", VP9_FOURCC, &vpx_codec_vp9_dx},
180 #endif
181 
182 #if CONFIG_VP10_DECODER
183   {"vp10", VP10_FOURCC, &vpx_codec_vp10_dx},
184 #endif
185 };
186 
get_vpx_decoder_count(void)187 int get_vpx_decoder_count(void) {
188   return sizeof(vpx_decoders) / sizeof(vpx_decoders[0]);
189 }
190 
get_vpx_decoder_by_index(int i)191 const VpxInterface *get_vpx_decoder_by_index(int i) {
192   return &vpx_decoders[i];
193 }
194 
get_vpx_decoder_by_name(const char * name)195 const VpxInterface *get_vpx_decoder_by_name(const char *name) {
196   int i;
197 
198   for (i = 0; i < get_vpx_decoder_count(); ++i) {
199      const VpxInterface *const decoder = get_vpx_decoder_by_index(i);
200      if (strcmp(decoder->name, name) == 0)
201        return decoder;
202   }
203 
204   return NULL;
205 }
206 
get_vpx_decoder_by_fourcc(uint32_t fourcc)207 const VpxInterface *get_vpx_decoder_by_fourcc(uint32_t fourcc) {
208   int i;
209 
210   for (i = 0; i < get_vpx_decoder_count(); ++i) {
211     const VpxInterface *const decoder = get_vpx_decoder_by_index(i);
212     if (decoder->fourcc == fourcc)
213       return decoder;
214   }
215 
216   return NULL;
217 }
218 
219 #endif  // CONFIG_DECODERS
220 
221 // TODO(dkovalev): move this function to vpx_image.{c, h}, so it will be part
222 // of vpx_image_t support
vpx_img_plane_width(const vpx_image_t * img,int plane)223 int vpx_img_plane_width(const vpx_image_t *img, int plane) {
224   if (plane > 0 && img->x_chroma_shift > 0)
225     return (img->d_w + 1) >> img->x_chroma_shift;
226   else
227     return img->d_w;
228 }
229 
vpx_img_plane_height(const vpx_image_t * img,int plane)230 int vpx_img_plane_height(const vpx_image_t *img, int plane) {
231   if (plane > 0 &&  img->y_chroma_shift > 0)
232     return (img->d_h + 1) >> img->y_chroma_shift;
233   else
234     return img->d_h;
235 }
236 
vpx_img_write(const vpx_image_t * img,FILE * file)237 void vpx_img_write(const vpx_image_t *img, FILE *file) {
238   int plane;
239 
240   for (plane = 0; plane < 3; ++plane) {
241     const unsigned char *buf = img->planes[plane];
242     const int stride = img->stride[plane];
243     const int w = vpx_img_plane_width(img, plane) *
244         ((img->fmt & VPX_IMG_FMT_HIGHBITDEPTH) ? 2 : 1);
245     const int h = vpx_img_plane_height(img, plane);
246     int y;
247 
248     for (y = 0; y < h; ++y) {
249       fwrite(buf, 1, w, file);
250       buf += stride;
251     }
252   }
253 }
254 
vpx_img_read(vpx_image_t * img,FILE * file)255 int vpx_img_read(vpx_image_t *img, FILE *file) {
256   int plane;
257 
258   for (plane = 0; plane < 3; ++plane) {
259     unsigned char *buf = img->planes[plane];
260     const int stride = img->stride[plane];
261     const int w = vpx_img_plane_width(img, plane) *
262         ((img->fmt & VPX_IMG_FMT_HIGHBITDEPTH) ? 2 : 1);
263     const int h = vpx_img_plane_height(img, plane);
264     int y;
265 
266     for (y = 0; y < h; ++y) {
267       if (fread(buf, 1, w, file) != (size_t)w)
268         return 0;
269       buf += stride;
270     }
271   }
272 
273   return 1;
274 }
275 
276 // TODO(dkovalev) change sse_to_psnr signature: double -> int64_t
sse_to_psnr(double samples,double peak,double sse)277 double sse_to_psnr(double samples, double peak, double sse) {
278   static const double kMaxPSNR = 100.0;
279 
280   if (sse > 0.0) {
281     const double psnr = 10.0 * log10(samples * peak * peak / sse);
282     return psnr > kMaxPSNR ? kMaxPSNR : psnr;
283   } else {
284     return kMaxPSNR;
285   }
286 }
287 
288 // TODO(debargha): Consolidate the functions below into a separate file.
289 #if CONFIG_VP9_HIGHBITDEPTH
highbd_img_upshift(vpx_image_t * dst,vpx_image_t * src,int input_shift)290 static void highbd_img_upshift(vpx_image_t *dst, vpx_image_t *src,
291                                int input_shift) {
292   // Note the offset is 1 less than half.
293   const int offset = input_shift > 0 ? (1 << (input_shift - 1)) - 1 : 0;
294   int plane;
295   if (dst->d_w != src->d_w || dst->d_h != src->d_h ||
296       dst->x_chroma_shift != src->x_chroma_shift ||
297       dst->y_chroma_shift != src->y_chroma_shift ||
298       dst->fmt != src->fmt || input_shift < 0) {
299     fatal("Unsupported image conversion");
300   }
301   switch (src->fmt) {
302     case VPX_IMG_FMT_I42016:
303     case VPX_IMG_FMT_I42216:
304     case VPX_IMG_FMT_I44416:
305     case VPX_IMG_FMT_I44016:
306       break;
307     default:
308       fatal("Unsupported image conversion");
309       break;
310   }
311   for (plane = 0; plane < 3; plane++) {
312     int w = src->d_w;
313     int h = src->d_h;
314     int x, y;
315     if (plane) {
316       w = (w + src->x_chroma_shift) >> src->x_chroma_shift;
317       h = (h + src->y_chroma_shift) >> src->y_chroma_shift;
318     }
319     for (y = 0; y < h; y++) {
320       uint16_t *p_src =
321           (uint16_t *)(src->planes[plane] + y * src->stride[plane]);
322       uint16_t *p_dst =
323           (uint16_t *)(dst->planes[plane] + y * dst->stride[plane]);
324       for (x = 0; x < w; x++)
325         *p_dst++ = (*p_src++ << input_shift) + offset;
326     }
327   }
328 }
329 
lowbd_img_upshift(vpx_image_t * dst,vpx_image_t * src,int input_shift)330 static void lowbd_img_upshift(vpx_image_t *dst, vpx_image_t *src,
331                               int input_shift) {
332   // Note the offset is 1 less than half.
333   const int offset = input_shift > 0 ? (1 << (input_shift - 1)) - 1 : 0;
334   int plane;
335   if (dst->d_w != src->d_w || dst->d_h != src->d_h ||
336       dst->x_chroma_shift != src->x_chroma_shift ||
337       dst->y_chroma_shift != src->y_chroma_shift ||
338       dst->fmt != src->fmt + VPX_IMG_FMT_HIGHBITDEPTH ||
339       input_shift < 0) {
340     fatal("Unsupported image conversion");
341   }
342   switch (src->fmt) {
343     case VPX_IMG_FMT_I420:
344     case VPX_IMG_FMT_I422:
345     case VPX_IMG_FMT_I444:
346     case VPX_IMG_FMT_I440:
347       break;
348     default:
349       fatal("Unsupported image conversion");
350       break;
351   }
352   for (plane = 0; plane < 3; plane++) {
353     int w = src->d_w;
354     int h = src->d_h;
355     int x, y;
356     if (plane) {
357       w = (w + src->x_chroma_shift) >> src->x_chroma_shift;
358       h = (h + src->y_chroma_shift) >> src->y_chroma_shift;
359     }
360     for (y = 0; y < h; y++) {
361       uint8_t *p_src = src->planes[plane] + y * src->stride[plane];
362       uint16_t *p_dst =
363           (uint16_t *)(dst->planes[plane] + y * dst->stride[plane]);
364       for (x = 0; x < w; x++) {
365         *p_dst++ = (*p_src++ << input_shift) + offset;
366       }
367     }
368   }
369 }
370 
vpx_img_upshift(vpx_image_t * dst,vpx_image_t * src,int input_shift)371 void vpx_img_upshift(vpx_image_t *dst, vpx_image_t *src,
372                      int input_shift) {
373   if (src->fmt & VPX_IMG_FMT_HIGHBITDEPTH) {
374     highbd_img_upshift(dst, src, input_shift);
375   } else {
376     lowbd_img_upshift(dst, src, input_shift);
377   }
378 }
379 
vpx_img_truncate_16_to_8(vpx_image_t * dst,vpx_image_t * src)380 void vpx_img_truncate_16_to_8(vpx_image_t *dst, vpx_image_t *src) {
381   int plane;
382   if (dst->fmt + VPX_IMG_FMT_HIGHBITDEPTH != src->fmt ||
383       dst->d_w != src->d_w || dst->d_h != src->d_h ||
384       dst->x_chroma_shift != src->x_chroma_shift ||
385       dst->y_chroma_shift != src->y_chroma_shift) {
386     fatal("Unsupported image conversion");
387   }
388   switch (dst->fmt) {
389     case VPX_IMG_FMT_I420:
390     case VPX_IMG_FMT_I422:
391     case VPX_IMG_FMT_I444:
392     case VPX_IMG_FMT_I440:
393       break;
394     default:
395       fatal("Unsupported image conversion");
396       break;
397   }
398   for (plane = 0; plane < 3; plane++) {
399     int w = src->d_w;
400     int h = src->d_h;
401     int x, y;
402     if (plane) {
403       w = (w + src->x_chroma_shift) >> src->x_chroma_shift;
404       h = (h + src->y_chroma_shift) >> src->y_chroma_shift;
405     }
406     for (y = 0; y < h; y++) {
407       uint16_t *p_src =
408           (uint16_t *)(src->planes[plane] + y * src->stride[plane]);
409       uint8_t *p_dst = dst->planes[plane] + y * dst->stride[plane];
410       for (x = 0; x < w; x++) {
411         *p_dst++ = (uint8_t)(*p_src++);
412       }
413     }
414   }
415 }
416 
highbd_img_downshift(vpx_image_t * dst,vpx_image_t * src,int down_shift)417 static void highbd_img_downshift(vpx_image_t *dst, vpx_image_t *src,
418                                  int down_shift) {
419   int plane;
420   if (dst->d_w != src->d_w || dst->d_h != src->d_h ||
421       dst->x_chroma_shift != src->x_chroma_shift ||
422       dst->y_chroma_shift != src->y_chroma_shift ||
423       dst->fmt != src->fmt || down_shift < 0) {
424     fatal("Unsupported image conversion");
425   }
426   switch (src->fmt) {
427     case VPX_IMG_FMT_I42016:
428     case VPX_IMG_FMT_I42216:
429     case VPX_IMG_FMT_I44416:
430     case VPX_IMG_FMT_I44016:
431       break;
432     default:
433       fatal("Unsupported image conversion");
434       break;
435   }
436   for (plane = 0; plane < 3; plane++) {
437     int w = src->d_w;
438     int h = src->d_h;
439     int x, y;
440     if (plane) {
441       w = (w + src->x_chroma_shift) >> src->x_chroma_shift;
442       h = (h + src->y_chroma_shift) >> src->y_chroma_shift;
443     }
444     for (y = 0; y < h; y++) {
445       uint16_t *p_src =
446           (uint16_t *)(src->planes[plane] + y * src->stride[plane]);
447       uint16_t *p_dst =
448           (uint16_t *)(dst->planes[plane] + y * dst->stride[plane]);
449       for (x = 0; x < w; x++)
450         *p_dst++ = *p_src++ >> down_shift;
451     }
452   }
453 }
454 
lowbd_img_downshift(vpx_image_t * dst,vpx_image_t * src,int down_shift)455 static void lowbd_img_downshift(vpx_image_t *dst, vpx_image_t *src,
456                                 int down_shift) {
457   int plane;
458   if (dst->d_w != src->d_w || dst->d_h != src->d_h ||
459       dst->x_chroma_shift != src->x_chroma_shift ||
460       dst->y_chroma_shift != src->y_chroma_shift ||
461       src->fmt != dst->fmt + VPX_IMG_FMT_HIGHBITDEPTH ||
462       down_shift < 0) {
463     fatal("Unsupported image conversion");
464   }
465   switch (dst->fmt) {
466     case VPX_IMG_FMT_I420:
467     case VPX_IMG_FMT_I422:
468     case VPX_IMG_FMT_I444:
469     case VPX_IMG_FMT_I440:
470       break;
471     default:
472       fatal("Unsupported image conversion");
473       break;
474   }
475   for (plane = 0; plane < 3; plane++) {
476     int w = src->d_w;
477     int h = src->d_h;
478     int x, y;
479     if (plane) {
480       w = (w + src->x_chroma_shift) >> src->x_chroma_shift;
481       h = (h + src->y_chroma_shift) >> src->y_chroma_shift;
482     }
483     for (y = 0; y < h; y++) {
484       uint16_t *p_src =
485           (uint16_t *)(src->planes[plane] + y * src->stride[plane]);
486       uint8_t *p_dst = dst->planes[plane] + y * dst->stride[plane];
487       for (x = 0; x < w; x++) {
488         *p_dst++ = *p_src++ >> down_shift;
489       }
490     }
491   }
492 }
493 
vpx_img_downshift(vpx_image_t * dst,vpx_image_t * src,int down_shift)494 void vpx_img_downshift(vpx_image_t *dst, vpx_image_t *src,
495                        int down_shift) {
496   if (dst->fmt & VPX_IMG_FMT_HIGHBITDEPTH) {
497     highbd_img_downshift(dst, src, down_shift);
498   } else {
499     lowbd_img_downshift(dst, src, down_shift);
500   }
501 }
502 #endif  // CONFIG_VP9_HIGHBITDEPTH
503