vpxdec.c 28.9 KB
Newer Older
John Koleszar's avatar
John Koleszar committed
1
/*
2
 *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
John Koleszar's avatar
John Koleszar committed
3
 *
4
 *  Use of this source code is governed by a BSD-style license
5
6
 *  that can be found in the LICENSE file in the root of the source
 *  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.
John Koleszar's avatar
John Koleszar committed
9
10
 */

11
#include <assert.h>
John Koleszar's avatar
John Koleszar committed
12
13
14
15
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
16
#include <limits.h>
17

18
19
20
#include "third_party/libyuv/include/libyuv/scale.h"

#include "./args.h"
21
22
#include "./ivfdec.h"

John Koleszar's avatar
John Koleszar committed
23
#define VPX_CODEC_DISABLE_COMPAT 1
24
#include "./vpx_config.h"
25
#include "vpx/vpx_decoder.h"
John Koleszar's avatar
John Koleszar committed
26
#include "vpx_ports/vpx_timer.h"
27

28
#if CONFIG_VP8_DECODER || CONFIG_VP9_DECODER
29
#include "vpx/vp8dx.h"
John Koleszar's avatar
John Koleszar committed
30
#endif
31

32
#include "./md5_utils.h"
33
34

#include "./tools_common.h"
35
#include "./webmdec.h"
36
#include "./y4menc.h"
John Koleszar's avatar
John Koleszar committed
37
38
39

static const char *exec_name;

40
41
42
43
44
struct VpxDecInputContext {
  struct VpxInputContext *vpx_input_ctx;
  struct WebmInputContext *webm_ctx;
};

John Koleszar's avatar
John Koleszar committed
45
46
static const arg_def_t looparg = ARG_DEF(NULL, "loops", 1,
                                          "Number of times to decode the file");
John Koleszar's avatar
John Koleszar committed
47
static const arg_def_t codecarg = ARG_DEF(NULL, "codec", 1,
John Koleszar's avatar
John Koleszar committed
48
                                          "Codec to use");
John Koleszar's avatar
John Koleszar committed
49
static const arg_def_t use_yv12 = ARG_DEF(NULL, "yv12", 0,
John Koleszar's avatar
John Koleszar committed
50
                                          "Output raw YV12 frames");
John Koleszar's avatar
John Koleszar committed
51
static const arg_def_t use_i420 = ARG_DEF(NULL, "i420", 0,
John Koleszar's avatar
John Koleszar committed
52
                                          "Output raw I420 frames");
John Koleszar's avatar
John Koleszar committed
53
static const arg_def_t flipuvarg = ARG_DEF(NULL, "flipuv", 0,
John Koleszar's avatar
John Koleszar committed
54
                                           "Flip the chroma planes in the output");
John Koleszar's avatar
John Koleszar committed
55
static const arg_def_t noblitarg = ARG_DEF(NULL, "noblit", 0,
John Koleszar's avatar
John Koleszar committed
56
                                           "Don't process the decoded frames");
John Koleszar's avatar
John Koleszar committed
57
static const arg_def_t progressarg = ARG_DEF(NULL, "progress", 0,
John Koleszar's avatar
John Koleszar committed
58
                                             "Show progress after each frame decodes");
John Koleszar's avatar
John Koleszar committed
59
static const arg_def_t limitarg = ARG_DEF(NULL, "limit", 1,
John Koleszar's avatar
John Koleszar committed
60
                                          "Stop decoding after n frames");
61
62
static const arg_def_t skiparg = ARG_DEF(NULL, "skip", 1,
                                         "Skip the first n input frames");
John Koleszar's avatar
John Koleszar committed
63
static const arg_def_t postprocarg = ARG_DEF(NULL, "postproc", 0,
John Koleszar's avatar
John Koleszar committed
64
                                             "Postprocess decoded frames");
John Koleszar's avatar
John Koleszar committed
65
static const arg_def_t summaryarg = ARG_DEF(NULL, "summary", 0,
John Koleszar's avatar
John Koleszar committed
66
                                            "Show timing summary");
67
static const arg_def_t outputfile = ARG_DEF("o", "output", 1,
John Koleszar's avatar
John Koleszar committed
68
                                            "Output file name pattern (see below)");
John Koleszar's avatar
John Koleszar committed
69
static const arg_def_t threadsarg = ARG_DEF("t", "threads", 1,
John Koleszar's avatar
John Koleszar committed
70
                                            "Max threads to use");
71
static const arg_def_t verbosearg = ARG_DEF("v", "verbose", 0,
John Koleszar's avatar
John Koleszar committed
72
                                            "Show version string");
John Koleszar's avatar
John Koleszar committed
73
74
static const arg_def_t error_concealment = ARG_DEF(NULL, "error-concealment", 0,
                                                   "Enable decoder error-concealment");
John Koleszar's avatar
John Koleszar committed
75
76
static const arg_def_t scalearg = ARG_DEF("S", "scale", 0,
                                            "Scale output frames uniformly");
John Koleszar's avatar
John Koleszar committed
77

John Koleszar's avatar
John Koleszar committed
78
79
80

static const arg_def_t md5arg = ARG_DEF(NULL, "md5", 0,
                                        "Compute the MD5 sum of the decoded frame");
Dmitry Kovalev's avatar
Dmitry Kovalev committed
81

John Koleszar's avatar
John Koleszar committed
82
83
static const arg_def_t *all_args[] = {
  &codecarg, &use_yv12, &use_i420, &flipuvarg, &noblitarg,
84
  &progressarg, &limitarg, &skiparg, &postprocarg, &summaryarg, &outputfile,
85
  &threadsarg, &verbosearg, &scalearg,
John Koleszar's avatar
John Koleszar committed
86
  &md5arg,
John Koleszar's avatar
John Koleszar committed
87
  &error_concealment,
John Koleszar's avatar
John Koleszar committed
88
  NULL
John Koleszar's avatar
John Koleszar committed
89
90
};

91
#if CONFIG_VP8_DECODER
John Koleszar's avatar
John Koleszar committed
92
static const arg_def_t addnoise_level = ARG_DEF(NULL, "noise-level", 1,
John Koleszar's avatar
John Koleszar committed
93
                                                "Enable VP8 postproc add noise");
John Koleszar's avatar
John Koleszar committed
94
static const arg_def_t deblock = ARG_DEF(NULL, "deblock", 0,
John Koleszar's avatar
John Koleszar committed
95
                                         "Enable VP8 deblocking");
John Koleszar's avatar
John Koleszar committed
96
static const arg_def_t demacroblock_level = ARG_DEF(NULL, "demacroblock-level", 1,
John Koleszar's avatar
John Koleszar committed
97
                                                    "Enable VP8 demacroblocking, w/ level");
John Koleszar's avatar
John Koleszar committed
98
static const arg_def_t pp_debug_info = ARG_DEF(NULL, "pp-debug-info", 1,
John Koleszar's avatar
John Koleszar committed
99
                                               "Enable VP8 visible debug info");
100
static const arg_def_t pp_disp_ref_frame = ARG_DEF(NULL, "pp-dbg-ref-frame", 1,
John Koleszar's avatar
John Koleszar committed
101
                                                   "Display only selected reference frame per macro block");
102
static const arg_def_t pp_disp_mb_modes = ARG_DEF(NULL, "pp-dbg-mb-modes", 1,
John Koleszar's avatar
John Koleszar committed
103
                                                  "Display only selected macro block modes");
104
static const arg_def_t pp_disp_b_modes = ARG_DEF(NULL, "pp-dbg-b-modes", 1,
John Koleszar's avatar
John Koleszar committed
105
                                                 "Display only selected block modes");
106
static const arg_def_t pp_disp_mvs = ARG_DEF(NULL, "pp-dbg-mvs", 1,
John Koleszar's avatar
John Koleszar committed
107
                                             "Draw only selected motion vectors");
John Koleszar's avatar
John Koleszar committed
108
109
static const arg_def_t mfqe = ARG_DEF(NULL, "mfqe", 0,
                                      "Enable multiframe quality enhancement");
John Koleszar's avatar
John Koleszar committed
110

John Koleszar's avatar
John Koleszar committed
111
112
static const arg_def_t *vp8_pp_args[] = {
  &addnoise_level, &deblock, &demacroblock_level, &pp_debug_info,
John Koleszar's avatar
John Koleszar committed
113
  &pp_disp_ref_frame, &pp_disp_mb_modes, &pp_disp_b_modes, &pp_disp_mvs, &mfqe,
John Koleszar's avatar
John Koleszar committed
114
  NULL
John Koleszar's avatar
John Koleszar committed
115
116
117
};
#endif

118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
static int vpx_image_scale(vpx_image_t *src, vpx_image_t *dst,
                           FilterMode mode) {
  assert(src->fmt == VPX_IMG_FMT_I420);
  assert(dst->fmt == VPX_IMG_FMT_I420);
  return I420Scale(src->planes[VPX_PLANE_Y], src->stride[VPX_PLANE_Y],
                   src->planes[VPX_PLANE_U], src->stride[VPX_PLANE_U],
                   src->planes[VPX_PLANE_V], src->stride[VPX_PLANE_V],
                   src->d_w, src->d_h,
                   dst->planes[VPX_PLANE_Y], dst->stride[VPX_PLANE_Y],
                   dst->planes[VPX_PLANE_U], dst->stride[VPX_PLANE_U],
                   dst->planes[VPX_PLANE_V], dst->stride[VPX_PLANE_V],
                   dst->d_w, dst->d_h,
                   mode);
}

133
void usage_exit() {
John Koleszar's avatar
John Koleszar committed
134
  int i;
John Koleszar's avatar
John Koleszar committed
135

John Koleszar's avatar
John Koleszar committed
136
137
138
  fprintf(stderr, "Usage: %s <options> filename\n\n"
          "Options:\n", exec_name);
  arg_show_usage(stderr, all_args);
139
#if CONFIG_VP8_DECODER
John Koleszar's avatar
John Koleszar committed
140
141
  fprintf(stderr, "\nVP8 Postprocessing Options:\n");
  arg_show_usage(stderr, vp8_pp_args);
John Koleszar's avatar
John Koleszar committed
142
#endif
John Koleszar's avatar
John Koleszar committed
143
144
145
146
147
148
  fprintf(stderr,
          "\nOutput File Patterns:\n\n"
          "  The -o argument specifies the name of the file(s) to "
          "write to. If the\n  argument does not include any escape "
          "characters, the output will be\n  written to a single file. "
          "Otherwise, the filename will be calculated by\n  expanding "
John Koleszar's avatar
John Koleszar committed
149
150
          "the following escape characters:\n");
  fprintf(stderr,
John Koleszar's avatar
John Koleszar committed
151
152
153
154
155
156
157
158
159
          "\n\t%%w   - Frame width"
          "\n\t%%h   - Frame height"
          "\n\t%%<n> - Frame number, zero padded to <n> places (1..9)"
          "\n\n  Pattern arguments are only supported in conjunction "
          "with the --yv12 and\n  --i420 options. If the -o option is "
          "not specified, the output will be\n  directed to stdout.\n"
         );
  fprintf(stderr, "\nIncluded decoders:\n\n");

160
161
  for (i = 0; i < get_vpx_decoder_count(); ++i) {
    const VpxInterface *const decoder = get_vpx_decoder_by_index(i);
John Koleszar's avatar
John Koleszar committed
162
    fprintf(stderr, "    %-6s - %s\n",
163
164
            decoder->name, vpx_codec_iface_name(decoder->interface()));
  }
John Koleszar's avatar
John Koleszar committed
165
166

  exit(EXIT_FAILURE);
John Koleszar's avatar
John Koleszar committed
167
168
}

169
static int raw_read_frame(FILE *infile, uint8_t **buffer,
170
                          size_t *bytes_read, size_t *buffer_size) {
171
  char raw_hdr[RAW_FRAME_HDR_SZ];
172
  size_t frame_size = 0;
John Koleszar's avatar
John Koleszar committed
173

174
175
176
177
  if (fread(raw_hdr, RAW_FRAME_HDR_SZ, 1, infile) != 1) {
    if (!feof(infile))
      warn("Failed to read RAW frame size\n");
  } else {
178
179
    const size_t kCorruptFrameThreshold = 256 * 1024 * 1024;
    const size_t kFrameTooSmallThreshold = 256 * 1024;
180
    frame_size = mem_get_le32(raw_hdr);
John Koleszar's avatar
John Koleszar committed
181

182
183
184
185
    if (frame_size > kCorruptFrameThreshold) {
      warn("Read invalid frame size (%u)\n", (unsigned int)frame_size);
      frame_size = 0;
    }
John Koleszar's avatar
John Koleszar committed
186

187
188
189
    if (frame_size < kFrameTooSmallThreshold) {
      warn("Warning: Read invalid frame size (%u) - not a raw file?\n",
           (unsigned int)frame_size);
John Koleszar's avatar
John Koleszar committed
190
    }
John Koleszar's avatar
John Koleszar committed
191

192
193
194
195
196
197
198
199
    if (frame_size > *buffer_size) {
      uint8_t *new_buf = realloc(*buffer, 2 * frame_size);
      if (new_buf) {
        *buffer = new_buf;
        *buffer_size = 2 * frame_size;
      } else {
        warn("Failed to allocate compressed data buffer\n");
        frame_size = 0;
200
      }
John Koleszar's avatar
John Koleszar committed
201
    }
202
  }
John Koleszar's avatar
John Koleszar committed
203

204
205
206
207
208
209
  if (!feof(infile)) {
    if (fread(*buffer, 1, frame_size, infile) != frame_size) {
      warn("Failed to read full frame\n");
      return 1;
    }
    *bytes_read = frame_size;
John Koleszar's avatar
John Koleszar committed
210
211
  }

212
213
214
215
216
217
218
219
220
221
  return 0;
}

static int read_frame(struct VpxDecInputContext *input, uint8_t **buf,
                      size_t *bytes_in_buffer, size_t *buffer_size) {
  switch (input->vpx_input_ctx->file_type) {
    case FILE_TYPE_WEBM:
      return webm_read_frame(input->webm_ctx,
                             buf, bytes_in_buffer, buffer_size);
    case FILE_TYPE_RAW:
222
      return raw_read_frame(input->vpx_input_ctx->file,
223
224
                            buf, bytes_in_buffer, buffer_size);
    case FILE_TYPE_IVF:
225
      return ivf_read_frame(input->vpx_input_ctx->file,
226
227
228
229
                            buf, bytes_in_buffer, buffer_size);
    default:
      return 1;
  }
John Koleszar's avatar
John Koleszar committed
230
231
}

232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
static int get_image_plane_width(int plane, const vpx_image_t *img) {
  return (plane > 0 && img->x_chroma_shift > 0) ?
             (img->d_w + 1) >> img->x_chroma_shift :
             img->d_w;
}

static int get_image_plane_height(int plane, const vpx_image_t *img) {
  return (plane > 0 &&  img->y_chroma_shift > 0) ?
             (img->d_h + 1) >> img->y_chroma_shift :
             img->d_h;
}

static void update_image_md5(const vpx_image_t *img, const int planes[3],
                             MD5Context *md5) {
  int i, y;

  for (i = 0; i < 3; ++i) {
    const int plane = planes[i];
    const unsigned char *buf = img->planes[plane];
    const int stride = img->stride[plane];
    const int w = get_image_plane_width(plane, img);
    const int h = get_image_plane_height(plane, img);

    for (y = 0; y < h; ++y) {
      MD5Update(md5, buf, w);
      buf += stride;
    }
  }
}

static void write_image_file(const vpx_image_t *img, const int planes[3],
                             FILE *file) {
  int i, y;

  for (i = 0; i < 3; ++i) {
    const int plane = planes[i];
    const unsigned char *buf = img->planes[plane];
    const int stride = img->stride[plane];
    const int w = get_image_plane_width(plane, img);
    const int h = get_image_plane_height(plane, img);

    for (y = 0; y < h; ++y) {
      fwrite(buf, 1, w, file);
      buf += stride;
    }
John Koleszar's avatar
John Koleszar committed
277
  }
John Koleszar's avatar
John Koleszar committed
278
279
}

280
281
int file_is_raw(struct VpxInputContext *input) {
  uint8_t buf[32];
John Koleszar's avatar
John Koleszar committed
282
283
  int is_raw = 0;
  vpx_codec_stream_info_t si;
284

John Koleszar's avatar
John Koleszar committed
285
286
  si.sz = sizeof(si);

287
  if (fread(buf, 1, 32, input->file) == 32) {
John Koleszar's avatar
John Koleszar committed
288
289
    int i;

290
    if (mem_get_le32(buf) < 256 * 1024 * 1024) {
291
292
293
      for (i = 0; i < get_vpx_decoder_count(); ++i) {
        const VpxInterface *const decoder = get_vpx_decoder_by_index(i);
        if (!vpx_codec_peek_stream_info(decoder->interface(),
John Koleszar's avatar
John Koleszar committed
294
295
                                        buf + 4, 32 - 4, &si)) {
          is_raw = 1;
296
          input->fourcc = decoder->fourcc;
297
298
299
300
          input->width = si.w;
          input->height = si.h;
          input->framerate.numerator = 30;
          input->framerate.denominator = 1;
John Koleszar's avatar
John Koleszar committed
301
302
          break;
        }
303
304
      }
    }
John Koleszar's avatar
John Koleszar committed
305
306
  }

307
  rewind(input->file);
John Koleszar's avatar
John Koleszar committed
308
  return is_raw;
309
310
}

John Koleszar's avatar
John Koleszar committed
311
312
313
314
void show_progress(int frame_in, int frame_out, unsigned long dx_time) {
  fprintf(stderr, "%d decoded frames/%d showed frames in %lu us (%.2f fps)\r",
          frame_in, frame_out, dx_time,
          (float)frame_out * 1000000.0 / (float)dx_time);
315
316
}

317
318
void generate_filename(const char *pattern, char *out, size_t q_len,
                       unsigned int d_w, unsigned int d_h,
John Koleszar's avatar
John Koleszar committed
319
320
321
322
323
324
325
326
327
328
                       unsigned int frame_in) {
  const char *p = pattern;
  char *q = out;

  do {
    char *next_pat = strchr(p, '%');

    if (p == next_pat) {
      size_t pat_len;

John Koleszar's avatar
John Koleszar committed
329
      /* parse the pattern */
John Koleszar's avatar
John Koleszar committed
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
      q[q_len - 1] = '\0';
      switch (p[1]) {
        case 'w':
          snprintf(q, q_len - 1, "%d", d_w);
          break;
        case 'h':
          snprintf(q, q_len - 1, "%d", d_h);
          break;
        case '1':
          snprintf(q, q_len - 1, "%d", frame_in);
          break;
        case '2':
          snprintf(q, q_len - 1, "%02d", frame_in);
          break;
        case '3':
          snprintf(q, q_len - 1, "%03d", frame_in);
          break;
        case '4':
          snprintf(q, q_len - 1, "%04d", frame_in);
          break;
        case '5':
          snprintf(q, q_len - 1, "%05d", frame_in);
          break;
        case '6':
          snprintf(q, q_len - 1, "%06d", frame_in);
          break;
        case '7':
          snprintf(q, q_len - 1, "%07d", frame_in);
          break;
        case '8':
          snprintf(q, q_len - 1, "%08d", frame_in);
          break;
        case '9':
          snprintf(q, q_len - 1, "%09d", frame_in);
          break;
        default:
          die("Unrecognized pattern %%%c\n", p[1]);
      }

      pat_len = strlen(q);
      if (pat_len >= q_len - 1)
        die("Output filename too long.\n");
      q += pat_len;
      p += 2;
      q_len -= pat_len;
    } else {
      size_t copy_len;

John Koleszar's avatar
John Koleszar committed
378
      /* copy the next segment */
John Koleszar's avatar
John Koleszar committed
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
      if (!next_pat)
        copy_len = strlen(p);
      else
        copy_len = next_pat - p;

      if (copy_len >= q_len - 1)
        die("Output filename too long.\n");

      memcpy(q, p, copy_len);
      q[copy_len] = '\0';
      q += copy_len;
      p += copy_len;
      q_len -= copy_len;
    }
  } while (*p);
394
395
}

396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
static int is_single_file(const char *outfile_pattern) {
  const char *p = outfile_pattern;

  do {
    p = strchr(p, '%');
    if (p && p[1] >= '1' && p[1] <= '9')
      return 0;  // pattern contains sequence number, so it's not unique
    if (p)
      p++;
  } while (p);

  return 1;
}

static void print_md5(unsigned char digest[16], const char *filename) {
  int i;

  for (i = 0; i < 16; ++i)
    printf("%02x", digest[i]);
  printf("  %s\n", filename);
}

static FILE *open_outfile(const char *name) {
  if (strcmp("-", name) == 0) {
    set_binary_mode(stdout);
    return stdout;
  } else {
    FILE *file = fopen(name, "wb");
    if (!file)
      fatal("Failed to output file %s", name);
    return file;
  }
}

John Koleszar's avatar
John Koleszar committed
430
int main_loop(int argc, const char **argv_) {
431
  vpx_codec_ctx_t       decoder;
John Koleszar's avatar
John Koleszar committed
432
433
  char                  *fn = NULL;
  uint8_t               *buf = NULL;
434
  size_t                 bytes_in_buffer = 0, buffer_size = 0;
John Koleszar's avatar
John Koleszar committed
435
  FILE                  *infile;
436
437
  int                    frame_in = 0, frame_out = 0, flipuv = 0, noblit = 0;
  int                    do_md5 = 0, progress = 0;
John Koleszar's avatar
John Koleszar committed
438
  int                    stop_after = 0, postproc = 0, summary = 0, quiet = 1;
439
  int                    arg_skip = 0;
John Koleszar's avatar
John Koleszar committed
440
  int                    ec_enabled = 0;
441
442
  const VpxInterface *interface = NULL;
  const VpxInterface *fourcc_interface = NULL;
John Koleszar's avatar
John Koleszar committed
443
444
445
  unsigned long          dx_time = 0;
  struct arg               arg;
  char                   **argv, **argi, **argj;
446

John Koleszar's avatar
John Koleszar committed
447
448
449
  int                     single_file;
  int                     use_y4m = 1;
  vpx_codec_dec_cfg_t     cfg = {0};
450
#if CONFIG_VP8_DECODER
John Koleszar's avatar
John Koleszar committed
451
452
453
454
455
  vp8_postproc_cfg_t      vp8_pp_cfg = {0};
  int                     vp8_dbg_color_ref_frame = 0;
  int                     vp8_dbg_color_mb_modes = 0;
  int                     vp8_dbg_color_b_modes = 0;
  int                     vp8_dbg_display_mv = 0;
John Koleszar's avatar
John Koleszar committed
456
#endif
John Koleszar's avatar
John Koleszar committed
457
458
  int                     frames_corrupted = 0;
  int                     dec_flags = 0;
459
  int                     do_scale = 0;
John Koleszar's avatar
John Koleszar committed
460
  vpx_image_t             *scaled_img = NULL;
Scott LaVarnway's avatar
Scott LaVarnway committed
461
  int                     frame_avail, got_data;
John Koleszar's avatar
John Koleszar committed
462

463
464
465
466
467
468
469
  const char *outfile_pattern = NULL;
  char outfile_name[PATH_MAX] = {0};
  FILE *outfile = NULL;

  MD5Context md5_ctx;
  unsigned char md5_digest[16];

470
471
  struct VpxDecInputContext input = {0};
  struct VpxInputContext vpx_input_ctx = {0};
472
  struct WebmInputContext webm_ctx = {0};
473
  input.vpx_input_ctx = &vpx_input_ctx;
474
  input.webm_ctx = &webm_ctx;
475

John Koleszar's avatar
John Koleszar committed
476
477
478
479
480
481
482
483
484
  /* Parse command line */
  exec_name = argv_[0];
  argv = argv_dup(argc - 1, argv_ + 1);

  for (argi = argj = argv; (*argj = *argi); argi += arg.argv_step) {
    memset(&arg, 0, sizeof(arg));
    arg.argv_step = 1;

    if (arg_match(&arg, &codecarg, argi)) {
485
486
487
      interface = get_vpx_decoder_by_name(arg.val);
      if (!interface)
        die("Error: Unrecognized argument (%s) to --codec\n", arg.val);
John Koleszar's avatar
John Koleszar committed
488
489
    } else if (arg_match(&arg, &looparg, argi)) {
      // no-op
John Koleszar's avatar
John Koleszar committed
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
    } else if (arg_match(&arg, &outputfile, argi))
      outfile_pattern = arg.val;
    else if (arg_match(&arg, &use_yv12, argi)) {
      use_y4m = 0;
      flipuv = 1;
    } else if (arg_match(&arg, &use_i420, argi)) {
      use_y4m = 0;
      flipuv = 0;
    } else if (arg_match(&arg, &flipuvarg, argi))
      flipuv = 1;
    else if (arg_match(&arg, &noblitarg, argi))
      noblit = 1;
    else if (arg_match(&arg, &progressarg, argi))
      progress = 1;
    else if (arg_match(&arg, &limitarg, argi))
      stop_after = arg_parse_uint(&arg);
506
507
    else if (arg_match(&arg, &skiparg, argi))
      arg_skip = arg_parse_uint(&arg);
John Koleszar's avatar
John Koleszar committed
508
509
510
511
512
513
514
515
516
517
    else if (arg_match(&arg, &postprocarg, argi))
      postproc = 1;
    else if (arg_match(&arg, &md5arg, argi))
      do_md5 = 1;
    else if (arg_match(&arg, &summaryarg, argi))
      summary = 1;
    else if (arg_match(&arg, &threadsarg, argi))
      cfg.threads = arg_parse_uint(&arg);
    else if (arg_match(&arg, &verbosearg, argi))
      quiet = 0;
John Koleszar's avatar
John Koleszar committed
518
519
    else if (arg_match(&arg, &scalearg, argi))
      do_scale = 1;
John Koleszar's avatar
John Koleszar committed
520

521
#if CONFIG_VP8_DECODER
John Koleszar's avatar
John Koleszar committed
522
523
524
525
526
527
528
529
530
531
532
    else if (arg_match(&arg, &addnoise_level, argi)) {
      postproc = 1;
      vp8_pp_cfg.post_proc_flag |= VP8_ADDNOISE;
      vp8_pp_cfg.noise_level = arg_parse_uint(&arg);
    } else if (arg_match(&arg, &demacroblock_level, argi)) {
      postproc = 1;
      vp8_pp_cfg.post_proc_flag |= VP8_DEMACROBLOCK;
      vp8_pp_cfg.deblocking_level = arg_parse_uint(&arg);
    } else if (arg_match(&arg, &deblock, argi)) {
      postproc = 1;
      vp8_pp_cfg.post_proc_flag |= VP8_DEBLOCK;
John Koleszar's avatar
John Koleszar committed
533
534
535
    } else if (arg_match(&arg, &mfqe, argi)) {
      postproc = 1;
      vp8_pp_cfg.post_proc_flag |= VP8_MFQE;
John Koleszar's avatar
John Koleszar committed
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
    } else if (arg_match(&arg, &pp_debug_info, argi)) {
      unsigned int level = arg_parse_uint(&arg);

      postproc = 1;
      vp8_pp_cfg.post_proc_flag &= ~0x7;

      if (level)
        vp8_pp_cfg.post_proc_flag |= level;
    } else if (arg_match(&arg, &pp_disp_ref_frame, argi)) {
      unsigned int flags = arg_parse_int(&arg);
      if (flags) {
        postproc = 1;
        vp8_dbg_color_ref_frame = flags;
      }
    } else if (arg_match(&arg, &pp_disp_mb_modes, argi)) {
      unsigned int flags = arg_parse_int(&arg);
      if (flags) {
        postproc = 1;
        vp8_dbg_color_mb_modes = flags;
      }
    } else if (arg_match(&arg, &pp_disp_b_modes, argi)) {
      unsigned int flags = arg_parse_int(&arg);
      if (flags) {
        postproc = 1;
        vp8_dbg_color_b_modes = flags;
      }
    } else if (arg_match(&arg, &pp_disp_mvs, argi)) {
      unsigned int flags = arg_parse_int(&arg);
      if (flags) {
        postproc = 1;
        vp8_dbg_display_mv = flags;
      }
John Koleszar's avatar
John Koleszar committed
568
569
    } else if (arg_match(&arg, &error_concealment, argi)) {
      ec_enabled = 1;
John Koleszar's avatar
John Koleszar committed
570
    }
John Koleszar's avatar
John Koleszar committed
571
572

#endif
John Koleszar's avatar
John Koleszar committed
573
574
575
    else
      argj++;
  }
John Koleszar's avatar
John Koleszar committed
576

John Koleszar's avatar
John Koleszar committed
577
578
579
580
  /* Check for unrecognized options */
  for (argi = argv; *argi; argi++)
    if (argi[0][0] == '-' && strlen(argi[0]) > 1)
      die("Error: Unrecognized option %s\n", *argi);
John Koleszar's avatar
John Koleszar committed
581

John Koleszar's avatar
John Koleszar committed
582
583
  /* Handle non-option arguments */
  fn = argv[0];
John Koleszar's avatar
John Koleszar committed
584

John Koleszar's avatar
John Koleszar committed
585
586
  if (!fn)
    usage_exit();
John Koleszar's avatar
John Koleszar committed
587

John Koleszar's avatar
John Koleszar committed
588
589
  /* Open file */
  infile = strcmp(fn, "-") ? fopen(fn, "rb") : set_binary_mode(stdin);
John Koleszar's avatar
John Koleszar committed
590

John Koleszar's avatar
John Koleszar committed
591
  if (!infile) {
592
    fprintf(stderr, "Failed to open file '%s'", strcmp(fn, "-") ? fn : "stdin");
John Koleszar's avatar
John Koleszar committed
593
594
    return EXIT_FAILURE;
  }
595
#if CONFIG_OS_SUPPORT
John Koleszar's avatar
John Koleszar committed
596
597
598
599
600
601
602
  /* Make sure we don't dump to the terminal, unless forced to with -o - */
  if (!outfile_pattern && isatty(fileno(stdout)) && !do_md5 && !noblit) {
    fprintf(stderr,
            "Not dumping raw video to your terminal. Use '-o -' to "
            "override.\n");
    return EXIT_FAILURE;
  }
603
#endif
604
605
606
  input.vpx_input_ctx->file = infile;
  if (file_is_ivf(input.vpx_input_ctx))
    input.vpx_input_ctx->file_type = FILE_TYPE_IVF;
607
  else if (file_is_webm(input.webm_ctx, input.vpx_input_ctx))
608
609
610
    input.vpx_input_ctx->file_type = FILE_TYPE_WEBM;
  else if (file_is_raw(input.vpx_input_ctx))
    input.vpx_input_ctx->file_type = FILE_TYPE_RAW;
John Koleszar's avatar
John Koleszar committed
611
612
613
614
615
616
  else {
    fprintf(stderr, "Unrecognized input file type.\n");
    return EXIT_FAILURE;
  }

  outfile_pattern = outfile_pattern ? outfile_pattern : "-";
617
  single_file = is_single_file(outfile_pattern);
John Koleszar's avatar
John Koleszar committed
618

619
620
  if (!noblit && single_file) {
    generate_filename(outfile_pattern, outfile_name, PATH_MAX,
621
                      vpx_input_ctx.width, vpx_input_ctx.height, 0);
622
623
624
625
    if (do_md5)
      MD5Init(&md5_ctx);
    else
      outfile = open_outfile(outfile_name);
John Koleszar's avatar
John Koleszar committed
626
627
628
629
630
631
632
  }

  if (use_y4m && !noblit) {
    if (!single_file) {
      fprintf(stderr, "YUV4MPEG2 not supported with output patterns,"
              " try --i420 or --yv12.\n");
      return EXIT_FAILURE;
633
    }
John Koleszar's avatar
John Koleszar committed
634

635
    if (vpx_input_ctx.file_type == FILE_TYPE_WEBM) {
636
      if (webm_guess_framerate(input.webm_ctx, input.vpx_input_ctx)) {
John Koleszar's avatar
John Koleszar committed
637
638
639
640
        fprintf(stderr, "Failed to guess framerate -- error parsing "
                "webm file?\n");
        return EXIT_FAILURE;
      }
641
    }
John Koleszar's avatar
John Koleszar committed
642
643
  }

644
645
646
647
648
  fourcc_interface = get_vpx_decoder_by_fourcc(vpx_input_ctx.fourcc);
  if (interface && fourcc_interface && interface != fourcc_interface)
    warn("Header indicates codec: %s\n", fourcc_interface->name);
  else
    interface = fourcc_interface;
John Koleszar's avatar
John Koleszar committed
649

650
651
  if (!interface)
    interface = get_vpx_decoder_by_index(0);
652

John Koleszar's avatar
John Koleszar committed
653
654
  dec_flags = (postproc ? VPX_CODEC_USE_POSTPROC : 0) |
              (ec_enabled ? VPX_CODEC_USE_ERROR_CONCEALMENT : 0);
655
656
657
  if (vpx_codec_dec_init(&decoder, interface->interface(), &cfg, dec_flags)) {
    fprintf(stderr, "Failed to initialize decoder: %s\n",
            vpx_codec_error(&decoder));
John Koleszar's avatar
John Koleszar committed
658
659
    return EXIT_FAILURE;
  }
John Koleszar's avatar
John Koleszar committed
660

John Koleszar's avatar
John Koleszar committed
661
662
  if (!quiet)
    fprintf(stderr, "%s\n", decoder.name);
John Koleszar's avatar
John Koleszar committed
663

664
#if CONFIG_VP8_DECODER
John Koleszar's avatar
John Koleszar committed
665

John Koleszar's avatar
John Koleszar committed
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
  if (vp8_pp_cfg.post_proc_flag
      && vpx_codec_control(&decoder, VP8_SET_POSTPROC, &vp8_pp_cfg)) {
    fprintf(stderr, "Failed to configure postproc: %s\n", vpx_codec_error(&decoder));
    return EXIT_FAILURE;
  }

  if (vp8_dbg_color_ref_frame
      && vpx_codec_control(&decoder, VP8_SET_DBG_COLOR_REF_FRAME, vp8_dbg_color_ref_frame)) {
    fprintf(stderr, "Failed to configure reference block visualizer: %s\n", vpx_codec_error(&decoder));
    return EXIT_FAILURE;
  }

  if (vp8_dbg_color_mb_modes
      && vpx_codec_control(&decoder, VP8_SET_DBG_COLOR_MB_MODES, vp8_dbg_color_mb_modes)) {
    fprintf(stderr, "Failed to configure macro block visualizer: %s\n", vpx_codec_error(&decoder));
    return EXIT_FAILURE;
  }

  if (vp8_dbg_color_b_modes
      && vpx_codec_control(&decoder, VP8_SET_DBG_COLOR_B_MODES, vp8_dbg_color_b_modes)) {
    fprintf(stderr, "Failed to configure block visualizer: %s\n", vpx_codec_error(&decoder));
    return EXIT_FAILURE;
  }

  if (vp8_dbg_display_mv
      && vpx_codec_control(&decoder, VP8_SET_DBG_DISPLAY_MV, vp8_dbg_display_mv)) {
    fprintf(stderr, "Failed to configure motion vector visualizer: %s\n", vpx_codec_error(&decoder));
    return EXIT_FAILURE;
  }
#endif
John Koleszar's avatar
John Koleszar committed
696

697

698
  if (arg_skip)
699
    fprintf(stderr, "Skipping first %d frames.\n", arg_skip);
700
  while (arg_skip) {
701
    if (read_frame(&input, &buf, &bytes_in_buffer, &buffer_size))
702
703
704
705
      break;
    arg_skip--;
  }

Scott LaVarnway's avatar
Scott LaVarnway committed
706
707
708
  frame_avail = 1;
  got_data = 0;

John Koleszar's avatar
John Koleszar committed
709
  /* Decode file */
Scott LaVarnway's avatar
Scott LaVarnway committed
710
  while (frame_avail || got_data) {
John Koleszar's avatar
John Koleszar committed
711
712
713
714
    vpx_codec_iter_t  iter = NULL;
    vpx_image_t    *img;
    struct vpx_usec_timer timer;
    int                   corrupted;
John Koleszar's avatar
John Koleszar committed
715

Scott LaVarnway's avatar
Scott LaVarnway committed
716
717
    frame_avail = 0;
    if (!stop_after || frame_in < stop_after) {
718
      if (!read_frame(&input, &buf, &bytes_in_buffer, &buffer_size)) {
Scott LaVarnway's avatar
Scott LaVarnway committed
719
720
        frame_avail = 1;
        frame_in++;
John Koleszar's avatar
John Koleszar committed
721

Scott LaVarnway's avatar
Scott LaVarnway committed
722
        vpx_usec_timer_start(&timer);
John Koleszar's avatar
John Koleszar committed
723

724
        if (vpx_codec_decode(&decoder, buf, bytes_in_buffer, NULL, 0)) {
Scott LaVarnway's avatar
Scott LaVarnway committed
725
          const char *detail = vpx_codec_error_detail(&decoder);
726
727
          warn("Failed to decode frame %d: %s",
               frame_in, vpx_codec_error(&decoder));
728

Scott LaVarnway's avatar
Scott LaVarnway committed
729
          if (detail)
730
            warn("Additional information: %s", detail);
Scott LaVarnway's avatar
Scott LaVarnway committed
731
732
733
734
735
736
737
738
739
740
741
742
743
744
          goto fail;
        }

        vpx_usec_timer_mark(&timer);
        dx_time += (unsigned int)vpx_usec_timer_elapsed(&timer);
      }
    }

    vpx_usec_timer_start(&timer);

    got_data = 0;
    if ((img = vpx_codec_get_frame(&decoder, &iter))) {
      ++frame_out;
      got_data = 1;
745
746
    }

John Koleszar's avatar
John Koleszar committed
747
    vpx_usec_timer_mark(&timer);
John Koleszar's avatar
John Koleszar committed
748
    dx_time += (unsigned int)vpx_usec_timer_elapsed(&timer);
749

John Koleszar's avatar
John Koleszar committed
750
    if (vpx_codec_control(&decoder, VP8D_GET_FRAME_CORRUPTED, &corrupted)) {
751
      warn("Failed VP8_GET_FRAME_CORRUPTED: %s", vpx_codec_error(&decoder));
John Koleszar's avatar
John Koleszar committed
752
      goto fail;
753
    }
John Koleszar's avatar
John Koleszar committed
754
    frames_corrupted += corrupted;
John Koleszar's avatar
John Koleszar committed
755

John Koleszar's avatar
John Koleszar committed
756
757
    if (progress)
      show_progress(frame_in, frame_out, dx_time);
John Koleszar's avatar
John Koleszar committed
758

759
760
761
762
    if (!noblit && img) {
      const int PLANES_YUV[] = {VPX_PLANE_Y, VPX_PLANE_U, VPX_PLANE_V};
      const int PLANES_YVU[] = {VPX_PLANE_Y, VPX_PLANE_V, VPX_PLANE_U};
      const int *planes = flipuv ? PLANES_YVU : PLANES_YUV;
763

764
      if (do_scale) {
765
766
767
768
        if (frame_out == 1) {
          // If the output frames are to be scaled to a fixed display size then
          // use the width and height specified in the container. If either of
          // these is set to 0, use the display size set in the first frame
769
770
          // header. If that is unavailable, use the raw decoded size of the
          // first decoded frame.
771
772
          int display_width = vpx_input_ctx.width;
          int display_height = vpx_input_ctx.height;
773
774
775
776
777
778
779
780
781
782
783
          if (!display_width || !display_height) {
            int display_size[2];
            if (vpx_codec_control(&decoder, VP9D_GET_DISPLAY_SIZE,
                                  display_size)) {
              // As last resort use size of first frame as display size.
              display_width = img->d_w;
              display_height = img->d_h;
            } else {
              display_width = display_size[0];
              display_height = display_size[1];
            }
784
          }
785
786
          scaled_img = vpx_img_alloc(NULL, VPX_IMG_FMT_I420, display_width,
                                     display_height, 16);
John Koleszar's avatar
John Koleszar committed
787
        }
788

789
790
        if (img->d_w != scaled_img->d_w || img->d_h != scaled_img->d_h) {
          vpx_image_scale(img, scaled_img, kFilterBox);
John Koleszar's avatar
John Koleszar committed
791
792
793
          img = scaled_img;
        }
      }
794

795
      if (single_file) {
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
        if (use_y4m) {
          char buf[Y4M_BUFFER_SIZE] = {0};
          size_t len = 0;
          if (frame_out == 1) {
            // Y4M file header
            len = y4m_write_file_header(buf, sizeof(buf),
                                        vpx_input_ctx.width,
                                        vpx_input_ctx.height,
                                        &vpx_input_ctx.framerate, img->fmt);
            if (do_md5) {
              MD5Update(&md5_ctx, (md5byte *)buf, len);
            } else {
              fputs(buf, outfile);
            }
          }

          // Y4M frame header
          len = y4m_write_frame_header(buf, sizeof(buf));
          if (do_md5) {
            MD5Update(&md5_ctx, (md5byte *)buf, len);
          } else {
            fputs(buf, outfile);
          }
        }

821
822
        if (do_md5) {
          update_image_md5(img, planes, &md5_ctx);
823
        } else {
824
825
826
827
828
829
830
831
832
833
834
835
836
837
          write_image_file(img, planes, outfile);
        }
      } else {
        generate_filename(outfile_pattern, outfile_name, PATH_MAX,
                          img->d_w, img->d_h, frame_in);
        if (do_md5) {
          MD5Init(&md5_ctx);
          update_image_md5(img, planes, &md5_ctx);
          MD5Final(md5_digest, &md5_ctx);
          print_md5(md5_digest, outfile_name);
        } else {
          outfile = open_outfile(outfile_name);
          write_image_file(img, planes, outfile);
          fclose(outfile);
838
        }
John Koleszar's avatar
John Koleszar committed
839
      }
John Koleszar's avatar
John Koleszar committed
840
841
    }

John Koleszar's avatar
John Koleszar committed
842
843
844
    if (stop_after && frame_in >= stop_after)
      break;
  }
John Koleszar's avatar
John Koleszar committed
845

John Koleszar's avatar
John Koleszar committed
846
847
848
849
850
851
852
  if (summary || progress) {
    show_progress(frame_in, frame_out, dx_time);
    fprintf(stderr, "\n");
  }

  if (frames_corrupted)
    fprintf(stderr, "WARNING: %d frames corrupted.\n", frames_corrupted);
853

John Koleszar's avatar
John Koleszar committed
854
855
fail:

John Koleszar's avatar
John Koleszar committed
856
  if (vpx_codec_destroy(&decoder)) {
857
858
    fprintf(stderr, "Failed to destroy decoder: %s\n",
            vpx_codec_error(&decoder));
John Koleszar's avatar
John Koleszar committed
859
860
    return EXIT_FAILURE;
  }
John Koleszar's avatar
John Koleszar committed
861

862
863
864
865
866
867
868
869
  if (!noblit && single_file) {
    if (do_md5) {
      MD5Final(md5_digest, &md5_ctx);
      print_md5(md5_digest, outfile_name);
    } else {
      fclose(outfile);
    }
  }
John Koleszar's avatar
John Koleszar committed
870

871
872
873
  if (input.vpx_input_ctx->file_type == FILE_TYPE_WEBM)
    webm_free(input.webm_ctx);
  else
John Koleszar's avatar
John Koleszar committed
874
    free(buf);
875

876
877
  if (scaled_img) vpx_img_free(scaled_img);

John Koleszar's avatar
John Koleszar committed
878
879
  fclose(infile);
  free(argv);
John Koleszar's avatar
John Koleszar committed
880

John Koleszar's avatar
John Koleszar committed
881
  return frames_corrupted ? EXIT_FAILURE : EXIT_SUCCESS;
John Koleszar's avatar
John Koleszar committed
882
}
John Koleszar's avatar
John Koleszar committed
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904

int main(int argc, const char **argv_) {
  unsigned int loops = 1, i;
  char **argv, **argi, **argj;
  struct arg arg;
  int error = 0;

  argv = argv_dup(argc - 1, argv_ + 1);
  for (argi = argj = argv; (*argj = *argi); argi += arg.argv_step) {
    memset(&arg, 0, sizeof(arg));
    arg.argv_step = 1;

    if (arg_match(&arg, &looparg, argi)) {
      loops = arg_parse_uint(&arg);
      break;
    }
  }
  free(argv);
  for (i = 0; !error && i < loops; i++)
    error = main_loop(argc, argv_);
  return error;
}