Merge "Two pass rc changes."
[platform/upstream/libvpx.git] / tools_common.c
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) 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
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
58 void die(const char *fmt, ...) {
59   LOG_ERROR(NULL);
60   usage_exit();
61 }
62
63 void fatal(const char *fmt, ...) {
64   LOG_ERROR("Fatal");
65   exit(EXIT_FAILURE);
66 }
67
68 void warn(const char *fmt, ...) {
69   LOG_ERROR("Warning");
70 }
71
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
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 static const VpxInterface vpx_encoders[] = {
134 #if CONFIG_VP8_ENCODER
135   {"vp8", VP8_FOURCC, &vpx_codec_vp8_cx},
136 #endif
137
138 #if CONFIG_VP9_ENCODER
139   {"vp9", VP9_FOURCC, &vpx_codec_vp9_cx},
140 #endif
141 };
142
143 int get_vpx_encoder_count() {
144   return sizeof(vpx_encoders) / sizeof(vpx_encoders[0]);
145 }
146
147 const VpxInterface *get_vpx_encoder_by_index(int i) {
148   return &vpx_encoders[i];
149 }
150
151 const VpxInterface *get_vpx_encoder_by_name(const char *name) {
152   int i;
153
154   for (i = 0; i < get_vpx_encoder_count(); ++i) {
155     const VpxInterface *encoder = get_vpx_encoder_by_index(i);
156     if (strcmp(encoder->name, name) == 0)
157       return encoder;
158   }
159
160   return NULL;
161 }
162
163 static const VpxInterface vpx_decoders[] = {
164 #if CONFIG_VP8_DECODER
165   {"vp8", VP8_FOURCC, &vpx_codec_vp8_dx},
166 #endif
167
168 #if CONFIG_VP9_DECODER
169   {"vp9", VP9_FOURCC, &vpx_codec_vp9_dx},
170 #endif
171 };
172
173 int get_vpx_decoder_count() {
174   return sizeof(vpx_decoders) / sizeof(vpx_decoders[0]);
175 }
176
177 const VpxInterface *get_vpx_decoder_by_index(int i) {
178   return &vpx_decoders[i];
179 }
180
181 const VpxInterface *get_vpx_decoder_by_name(const char *name) {
182   int i;
183
184   for (i = 0; i < get_vpx_decoder_count(); ++i) {
185      const VpxInterface *const decoder = get_vpx_decoder_by_index(i);
186      if (strcmp(decoder->name, name) == 0)
187        return decoder;
188   }
189
190   return NULL;
191 }
192
193 const VpxInterface *get_vpx_decoder_by_fourcc(uint32_t fourcc) {
194   int i;
195
196   for (i = 0; i < get_vpx_decoder_count(); ++i) {
197     const VpxInterface *const decoder = get_vpx_decoder_by_index(i);
198     if (decoder->fourcc == fourcc)
199       return decoder;
200   }
201
202   return NULL;
203 }
204
205 // TODO(dkovalev): move this function to vpx_image.{c, h}, so it will be part
206 // of vpx_image_t support
207 int vpx_img_plane_width(const vpx_image_t *img, int plane) {
208   if (plane > 0 && img->x_chroma_shift > 0)
209     return (img->d_w + 1) >> img->x_chroma_shift;
210   else
211     return img->d_w;
212 }
213
214 int vpx_img_plane_height(const vpx_image_t *img, int plane) {
215   if (plane > 0 &&  img->y_chroma_shift > 0)
216     return (img->d_h + 1) >> img->y_chroma_shift;
217   else
218     return img->d_h;
219 }
220
221 void vpx_img_write(const vpx_image_t *img, FILE *file) {
222   int plane;
223
224   for (plane = 0; plane < 3; ++plane) {
225     const unsigned char *buf = img->planes[plane];
226     const int stride = img->stride[plane];
227     const int w = vpx_img_plane_width(img, plane) *
228         ((img->fmt & VPX_IMG_FMT_HIGHBITDEPTH) ? 2 : 1);
229     const int h = vpx_img_plane_height(img, plane);
230     int y;
231
232     for (y = 0; y < h; ++y) {
233       fwrite(buf, 1, w, file);
234       buf += stride;
235     }
236   }
237 }
238
239 int vpx_img_read(vpx_image_t *img, FILE *file) {
240   int plane;
241
242   for (plane = 0; plane < 3; ++plane) {
243     unsigned char *buf = img->planes[plane];
244     const int stride = img->stride[plane];
245     const int w = vpx_img_plane_width(img, plane) *
246         ((img->fmt & VPX_IMG_FMT_HIGHBITDEPTH) ? 2 : 1);
247     const int h = vpx_img_plane_height(img, plane);
248     int y;
249
250     for (y = 0; y < h; ++y) {
251       if (fread(buf, 1, w, file) != (size_t)w)
252         return 0;
253       buf += stride;
254     }
255   }
256
257   return 1;
258 }
259
260 // TODO(dkovalev) change sse_to_psnr signature: double -> int64_t
261 double sse_to_psnr(double samples, double peak, double sse) {
262   static const double kMaxPSNR = 100.0;
263
264   if (sse > 0.0) {
265     const double psnr = 10.0 * log10(samples * peak * peak / sse);
266     return psnr > kMaxPSNR ? kMaxPSNR : psnr;
267   } else {
268     return kMaxPSNR;
269   }
270 }