tools_common.c 13.2 KB
Newer Older
1 2 3 4 5 6 7 8 9
/*
 *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
 *
 *  Use of this source code is governed by a BSD-style license
 *  that can be found in the LICENSE file in the root of the source
 *  tree. An additional intellectual property rights grant can be found
 *  in the file PATENTS.  All contributing project authors may
 *  be found in the AUTHORS file in the root of the source tree.
 */
10

11
#include <math.h>
12
#include <stdarg.h>
13
#include <stdio.h>
14
#include <stdlib.h>
15
#include <string.h>
16

17 18
#include "./tools_common.h"

James Zern's avatar
James Zern committed
19
#if CONFIG_VP8_ENCODER || CONFIG_VP9_ENCODER
20 21 22
#include "vpx/vp8cx.h"
#endif

James Zern's avatar
James Zern committed
23
#if CONFIG_VP8_DECODER || CONFIG_VP9_DECODER
24 25 26
#include "vpx/vp8dx.h"
#endif

27
#if defined(_WIN32) || defined(__OS2__)
28 29
#include <io.h>
#include <fcntl.h>
30 31

#ifdef __OS2__
32 33 34
#define _setmode setmode
#define _fileno fileno
#define _O_BINARY O_BINARY
35
#endif
36 37
#endif

38 39 40 41 42 43 44 45 46 47
#define LOG_ERROR(label)               \
  do {                                 \
    const char *l = label;             \
    va_list ap;                        \
    va_start(ap, fmt);                 \
    if (l) fprintf(stderr, "%s: ", l); \
    vfprintf(stderr, fmt, ap);         \
    fprintf(stderr, "\n");             \
    va_end(ap);                        \
  } while (0)
48

John Koleszar's avatar
John Koleszar committed
49 50
FILE *set_binary_mode(FILE *stream) {
  (void)stream;
51
#if defined(_WIN32) || defined(__OS2__)
John Koleszar's avatar
John Koleszar committed
52
  _setmode(_fileno(stream), _O_BINARY);
53
#endif
John Koleszar's avatar
John Koleszar committed
54
  return stream;
55
}
56 57 58 59 60 61 62 63 64 65 66

void die(const char *fmt, ...) {
  LOG_ERROR(NULL);
  usage_exit();
}

void fatal(const char *fmt, ...) {
  LOG_ERROR("Fatal");
  exit(EXIT_FAILURE);
}

67
void warn(const char *fmt, ...) { LOG_ERROR("Warning"); }
68

69 70 71 72
void die_codec(vpx_codec_ctx_t *ctx, const char *s) {
  const char *detail = vpx_codec_error_detail(ctx);

  printf("%s: %s\n", s, vpx_codec_error(ctx));
73
  if (detail) printf("    %s\n", detail);
74 75 76
  exit(EXIT_FAILURE);
}

77 78 79 80 81
int read_yuv_frame(struct VpxInputContext *input_ctx, vpx_image_t *yuv_frame) {
  FILE *f = input_ctx->file;
  struct FileTypeDetectionBuffer *detect = &input_ctx->detect;
  int plane = 0;
  int shortread = 0;
82
  const int bytespp = (yuv_frame->fmt & VPX_IMG_FMT_HIGHBITDEPTH) ? 2 : 1;
83 84 85

  for (plane = 0; plane < 3; ++plane) {
    uint8_t *ptr;
86 87
    const int w = vpx_img_plane_width(yuv_frame, plane);
    const int h = vpx_img_plane_height(yuv_frame, plane);
88 89 90 91 92 93 94 95
    int r;

    /* Determine the correct plane based on the image format. The for-loop
     * always counts in Y,U,V order, but this may not match the order of
     * the data on disk.
     */
    switch (plane) {
      case 1:
96 97 98
        ptr =
            yuv_frame->planes[yuv_frame->fmt == VPX_IMG_FMT_YV12 ? VPX_PLANE_V
                                                                 : VPX_PLANE_U];
99 100
        break;
      case 2:
101 102 103
        ptr =
            yuv_frame->planes[yuv_frame->fmt == VPX_IMG_FMT_YV12 ? VPX_PLANE_U
                                                                 : VPX_PLANE_V];
104
        break;
105
      default: ptr = yuv_frame->planes[plane];
106 107 108
    }

    for (r = 0; r < h; ++r) {
109
      size_t needed = w * bytespp;
110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128
      size_t buf_position = 0;
      const size_t left = detect->buf_read - detect->position;
      if (left > 0) {
        const size_t more = (left < needed) ? left : needed;
        memcpy(ptr, detect->buf + detect->position, more);
        buf_position = more;
        needed -= more;
        detect->position += more;
      }
      if (needed > 0) {
        shortread |= (fread(ptr + buf_position, 1, needed, f) < needed);
      }

      ptr += yuv_frame->stride[plane];
    }
  }

  return shortread;
}
129

130 131
#if CONFIG_ENCODERS

132 133
static const VpxInterface vpx_encoders[] = {
#if CONFIG_VP8_ENCODER
134
  { "vp8", VP8_FOURCC, &vpx_codec_vp8_cx },
135 136 137
#endif

#if CONFIG_VP9_ENCODER
138
  { "vp9", VP9_FOURCC, &vpx_codec_vp9_cx },
139 140 141
#endif
};

142
int get_vpx_encoder_count(void) {
143 144 145
  return sizeof(vpx_encoders) / sizeof(vpx_encoders[0]);
}

146
const VpxInterface *get_vpx_encoder_by_index(int i) { return &vpx_encoders[i]; }
147 148 149 150 151 152

const VpxInterface *get_vpx_encoder_by_name(const char *name) {
  int i;

  for (i = 0; i < get_vpx_encoder_count(); ++i) {
    const VpxInterface *encoder = get_vpx_encoder_by_index(i);
153
    if (strcmp(encoder->name, name) == 0) return encoder;
154 155 156 157 158
  }

  return NULL;
}

159 160 161 162
#endif  // CONFIG_ENCODERS

#if CONFIG_DECODERS

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(void) {
174 175 176
  return sizeof(vpx_decoders) / sizeof(vpx_decoders[0]);
}

177
const VpxInterface *get_vpx_decoder_by_index(int i) { return &vpx_decoders[i]; }
178 179 180 181 182

const VpxInterface *get_vpx_decoder_by_name(const char *name) {
  int i;

  for (i = 0; i < get_vpx_decoder_count(); ++i) {
183 184
    const VpxInterface *const decoder = get_vpx_decoder_by_index(i);
    if (strcmp(decoder->name, name) == 0) return decoder;
185
  }
186 187 188 189 190 191 192 193 194

  return NULL;
}

const VpxInterface *get_vpx_decoder_by_fourcc(uint32_t fourcc) {
  int i;

  for (i = 0; i < get_vpx_decoder_count(); ++i) {
    const VpxInterface *const decoder = get_vpx_decoder_by_index(i);
195
    if (decoder->fourcc == fourcc) return decoder;
196 197
  }

198 199 200
  return NULL;
}

201 202
#endif  // CONFIG_DECODERS

203 204 205 206 207 208 209 210 211 212
// TODO(dkovalev): move this function to vpx_image.{c, h}, so it will be part
// of vpx_image_t support
int vpx_img_plane_width(const vpx_image_t *img, int plane) {
  if (plane > 0 && img->x_chroma_shift > 0)
    return (img->d_w + 1) >> img->x_chroma_shift;
  else
    return img->d_w;
}

int vpx_img_plane_height(const vpx_image_t *img, int plane) {
213
  if (plane > 0 && img->y_chroma_shift > 0)
214 215 216 217 218
    return (img->d_h + 1) >> img->y_chroma_shift;
  else
    return img->d_h;
}

219
void vpx_img_write(const vpx_image_t *img, FILE *file) {
220
  int plane;
221 222 223 224

  for (plane = 0; plane < 3; ++plane) {
    const unsigned char *buf = img->planes[plane];
    const int stride = img->stride[plane];
225
    const int w = vpx_img_plane_width(img, plane) *
226
                  ((img->fmt & VPX_IMG_FMT_HIGHBITDEPTH) ? 2 : 1);
227 228
    const int h = vpx_img_plane_height(img, plane);
    int y;
229

230 231 232 233 234 235
    for (y = 0; y < h; ++y) {
      fwrite(buf, 1, w, file);
      buf += stride;
    }
  }
}
236 237 238 239 240 241 242

int vpx_img_read(vpx_image_t *img, FILE *file) {
  int plane;

  for (plane = 0; plane < 3; ++plane) {
    unsigned char *buf = img->planes[plane];
    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 247 248
    int y;

    for (y = 0; y < h; ++y) {
249
      if (fread(buf, 1, w, file) != (size_t)w) return 0;
250 251 252 253 254 255 256
      buf += stride;
    }
  }

  return 1;
}

257 258 259 260 261 262 263 264 265 266 267
// TODO(dkovalev) change sse_to_psnr signature: double -> int64_t
double sse_to_psnr(double samples, double peak, double sse) {
  static const double kMaxPSNR = 100.0;

  if (sse > 0.0) {
    const double psnr = 10.0 * log10(samples * peak * peak / sse);
    return psnr > kMaxPSNR ? kMaxPSNR : psnr;
  } else {
    return kMaxPSNR;
  }
}
268 269

// TODO(debargha): Consolidate the functions below into a separate file.
270
#if CONFIG_VP9_HIGHBITDEPTH
271 272 273 274 275
static void highbd_img_upshift(vpx_image_t *dst, vpx_image_t *src,
                               int input_shift) {
  // Note the offset is 1 less than half.
  const int offset = input_shift > 0 ? (1 << (input_shift - 1)) - 1 : 0;
  int plane;
276
  if (dst->d_w != src->d_w || dst->d_h != src->d_h ||
277
      dst->x_chroma_shift != src->x_chroma_shift ||
278 279
      dst->y_chroma_shift != src->y_chroma_shift || dst->fmt != src->fmt ||
      input_shift < 0) {
280 281 282 283 284 285
    fatal("Unsupported image conversion");
  }
  switch (src->fmt) {
    case VPX_IMG_FMT_I42016:
    case VPX_IMG_FMT_I42216:
    case VPX_IMG_FMT_I44416:
286 287
    case VPX_IMG_FMT_I44016: break;
    default: fatal("Unsupported image conversion"); break;
288 289
  }
  for (plane = 0; plane < 3; plane++) {
290 291
    int w = src->d_w;
    int h = src->d_h;
292 293
    int x, y;
    if (plane) {
294 295
      w = (w + src->x_chroma_shift) >> src->x_chroma_shift;
      h = (h + src->y_chroma_shift) >> src->y_chroma_shift;
296 297 298 299 300 301
    }
    for (y = 0; y < h; y++) {
      uint16_t *p_src =
          (uint16_t *)(src->planes[plane] + y * src->stride[plane]);
      uint16_t *p_dst =
          (uint16_t *)(dst->planes[plane] + y * dst->stride[plane]);
302
      for (x = 0; x < w; x++) *p_dst++ = (*p_src++ << input_shift) + offset;
303 304 305 306 307 308 309 310 311
    }
  }
}

static void lowbd_img_upshift(vpx_image_t *dst, vpx_image_t *src,
                              int input_shift) {
  // Note the offset is 1 less than half.
  const int offset = input_shift > 0 ? (1 << (input_shift - 1)) - 1 : 0;
  int plane;
312
  if (dst->d_w != src->d_w || dst->d_h != src->d_h ||
313 314
      dst->x_chroma_shift != src->x_chroma_shift ||
      dst->y_chroma_shift != src->y_chroma_shift ||
315
      dst->fmt != src->fmt + VPX_IMG_FMT_HIGHBITDEPTH || input_shift < 0) {
316 317 318 319 320 321
    fatal("Unsupported image conversion");
  }
  switch (src->fmt) {
    case VPX_IMG_FMT_I420:
    case VPX_IMG_FMT_I422:
    case VPX_IMG_FMT_I444:
322 323
    case VPX_IMG_FMT_I440: break;
    default: fatal("Unsupported image conversion"); break;
324 325
  }
  for (plane = 0; plane < 3; plane++) {
326 327
    int w = src->d_w;
    int h = src->d_h;
328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343
    int x, y;
    if (plane) {
      w = (w + src->x_chroma_shift) >> src->x_chroma_shift;
      h = (h + src->y_chroma_shift) >> src->y_chroma_shift;
    }
    for (y = 0; y < h; y++) {
      uint8_t *p_src = src->planes[plane] + y * src->stride[plane];
      uint16_t *p_dst =
          (uint16_t *)(dst->planes[plane] + y * dst->stride[plane]);
      for (x = 0; x < w; x++) {
        *p_dst++ = (*p_src++ << input_shift) + offset;
      }
    }
  }
}

344
void vpx_img_upshift(vpx_image_t *dst, vpx_image_t *src, int input_shift) {
345 346 347 348 349 350 351 352 353
  if (src->fmt & VPX_IMG_FMT_HIGHBITDEPTH) {
    highbd_img_upshift(dst, src, input_shift);
  } else {
    lowbd_img_upshift(dst, src, input_shift);
  }
}

void vpx_img_truncate_16_to_8(vpx_image_t *dst, vpx_image_t *src) {
  int plane;
354 355
  if (dst->fmt + VPX_IMG_FMT_HIGHBITDEPTH != src->fmt || dst->d_w != src->d_w ||
      dst->d_h != src->d_h || dst->x_chroma_shift != src->x_chroma_shift ||
356 357 358 359 360 361 362
      dst->y_chroma_shift != src->y_chroma_shift) {
    fatal("Unsupported image conversion");
  }
  switch (dst->fmt) {
    case VPX_IMG_FMT_I420:
    case VPX_IMG_FMT_I422:
    case VPX_IMG_FMT_I444:
363 364
    case VPX_IMG_FMT_I440: break;
    default: fatal("Unsupported image conversion"); break;
365 366 367 368 369 370
  }
  for (plane = 0; plane < 3; plane++) {
    int w = src->d_w;
    int h = src->d_h;
    int x, y;
    if (plane) {
371 372
      w = (w + src->x_chroma_shift) >> src->x_chroma_shift;
      h = (h + src->y_chroma_shift) >> src->y_chroma_shift;
373 374 375 376 377 378
    }
    for (y = 0; y < h; y++) {
      uint16_t *p_src =
          (uint16_t *)(src->planes[plane] + y * src->stride[plane]);
      uint8_t *p_dst = dst->planes[plane] + y * dst->stride[plane];
      for (x = 0; x < w; x++) {
Yaowu Xu's avatar
Yaowu Xu committed
379
        *p_dst++ = (uint8_t)(*p_src++);
380 381 382 383 384 385 386 387 388 389
      }
    }
  }
}

static void highbd_img_downshift(vpx_image_t *dst, vpx_image_t *src,
                                 int down_shift) {
  int plane;
  if (dst->d_w != src->d_w || dst->d_h != src->d_h ||
      dst->x_chroma_shift != src->x_chroma_shift ||
390 391
      dst->y_chroma_shift != src->y_chroma_shift || dst->fmt != src->fmt ||
      down_shift < 0) {
392 393 394 395 396 397
    fatal("Unsupported image conversion");
  }
  switch (src->fmt) {
    case VPX_IMG_FMT_I42016:
    case VPX_IMG_FMT_I42216:
    case VPX_IMG_FMT_I44416:
398 399
    case VPX_IMG_FMT_I44016: break;
    default: fatal("Unsupported image conversion"); break;
400 401 402 403 404 405 406 407 408 409 410 411 412 413
  }
  for (plane = 0; plane < 3; plane++) {
    int w = src->d_w;
    int h = src->d_h;
    int x, y;
    if (plane) {
      w = (w + src->x_chroma_shift) >> src->x_chroma_shift;
      h = (h + src->y_chroma_shift) >> src->y_chroma_shift;
    }
    for (y = 0; y < h; y++) {
      uint16_t *p_src =
          (uint16_t *)(src->planes[plane] + y * src->stride[plane]);
      uint16_t *p_dst =
          (uint16_t *)(dst->planes[plane] + y * dst->stride[plane]);
414
      for (x = 0; x < w; x++) *p_dst++ = *p_src++ >> down_shift;
415 416 417 418 419 420 421 422 423 424
    }
  }
}

static void lowbd_img_downshift(vpx_image_t *dst, vpx_image_t *src,
                                int down_shift) {
  int plane;
  if (dst->d_w != src->d_w || dst->d_h != src->d_h ||
      dst->x_chroma_shift != src->x_chroma_shift ||
      dst->y_chroma_shift != src->y_chroma_shift ||
425
      src->fmt != dst->fmt + VPX_IMG_FMT_HIGHBITDEPTH || down_shift < 0) {
426 427 428 429 430 431
    fatal("Unsupported image conversion");
  }
  switch (dst->fmt) {
    case VPX_IMG_FMT_I420:
    case VPX_IMG_FMT_I422:
    case VPX_IMG_FMT_I444:
432 433
    case VPX_IMG_FMT_I440: break;
    default: fatal("Unsupported image conversion"); break;
434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453
  }
  for (plane = 0; plane < 3; plane++) {
    int w = src->d_w;
    int h = src->d_h;
    int x, y;
    if (plane) {
      w = (w + src->x_chroma_shift) >> src->x_chroma_shift;
      h = (h + src->y_chroma_shift) >> src->y_chroma_shift;
    }
    for (y = 0; y < h; y++) {
      uint16_t *p_src =
          (uint16_t *)(src->planes[plane] + y * src->stride[plane]);
      uint8_t *p_dst = dst->planes[plane] + y * dst->stride[plane];
      for (x = 0; x < w; x++) {
        *p_dst++ = *p_src++ >> down_shift;
      }
    }
  }
}

454
void vpx_img_downshift(vpx_image_t *dst, vpx_image_t *src, int down_shift) {
455 456 457 458 459 460
  if (dst->fmt & VPX_IMG_FMT_HIGHBITDEPTH) {
    highbd_img_downshift(dst, src, down_shift);
  } else {
    lowbd_img_downshift(dst, src, down_shift);
  }
}
461
#endif  // CONFIG_VP9_HIGHBITDEPTH