vpxenc.c 62.3 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 "./vpxenc.h"
12
#include "./vpx_config.h"
John Koleszar's avatar
John Koleszar committed
13

14
15
#include <assert.h>
#include <limits.h>
16
#include <math.h>
17
#include <stdarg.h>
John Koleszar's avatar
John Koleszar committed
18
19
20
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
21

22
#include "vpx/vpx_encoder.h"
23
#if CONFIG_DECODERS
John Koleszar's avatar
John Koleszar committed
24
#include "vpx/vpx_decoder.h"
25
#endif
John Koleszar's avatar
John Koleszar committed
26

27
#include "third_party/libyuv/include/libyuv/scale.h"
28
29
#include "./args.h"
#include "./ivfenc.h"
Tom Finegan's avatar
Tom Finegan committed
30
#include "./tools_common.h"
31

32
#if CONFIG_VP8_ENCODER || CONFIG_VP9_ENCODER
33
#include "vpx/vp8cx.h"
John Koleszar's avatar
John Koleszar committed
34
#endif
35
#if CONFIG_VP8_DECODER || CONFIG_VP9_DECODER
36
#include "vpx/vp8dx.h"
John Koleszar's avatar
John Koleszar committed
37
38
#endif

Tom Finegan's avatar
Tom Finegan committed
39
#include "vpx/vpx_integer.h"
John Koleszar's avatar
John Koleszar committed
40
41
#include "vpx_ports/mem_ops.h"
#include "vpx_ports/vpx_timer.h"
42
#include "./rate_hist.h"
43
#include "./vpxstats.h"
44
#include "./warnings.h"
45
46
#include "./webmenc.h"
#include "./y4minput.h"
47

John Koleszar's avatar
John Koleszar committed
48
49
/* Swallow warnings about unused results of fread/fwrite */
static size_t wrap_fread(void *ptr, size_t size, size_t nmemb,
John Koleszar's avatar
John Koleszar committed
50
51
                         FILE *stream) {
  return fread(ptr, size, nmemb, stream);
John Koleszar's avatar
John Koleszar committed
52
53
54
55
}
#define fread wrap_fread

static size_t wrap_fwrite(const void *ptr, size_t size, size_t nmemb,
John Koleszar's avatar
John Koleszar committed
56
57
                          FILE *stream) {
  return fwrite(ptr, size, nmemb, stream);
John Koleszar's avatar
John Koleszar committed
58
59
60
61
}
#define fwrite wrap_fwrite


John Koleszar's avatar
John Koleszar committed
62
63
static const char *exec_name;

Jim Bankoski's avatar
Jim Bankoski committed
64
static const struct codec_item {
John Koleszar's avatar
John Koleszar committed
65
  char const              *name;
66
67
  vpx_codec_iface_t *(*iface)(void);
  vpx_codec_iface_t *(*dx_iface)(void);
Jim Bankoski's avatar
Jim Bankoski committed
68
69
  unsigned int             fourcc;
} codecs[] = {
70
#if CONFIG_VP8_ENCODER && CONFIG_VP8_DECODER
John Koleszar's avatar
John Koleszar committed
71
  {"vp8", &vpx_codec_vp8_cx, &vpx_codec_vp8_dx, VP8_FOURCC},
72
#elif CONFIG_VP8_ENCODER && !CONFIG_VP8_DECODER
John Koleszar's avatar
John Koleszar committed
73
  {"vp8", &vpx_codec_vp8_cx, NULL, VP8_FOURCC},
74
#endif
John Koleszar's avatar
John Koleszar committed
75
#if CONFIG_VP9_ENCODER && CONFIG_VP9_DECODER
John Koleszar's avatar
John Koleszar committed
76
  {"vp9", &vpx_codec_vp9_cx, &vpx_codec_vp9_dx, VP9_FOURCC},
77
#elif CONFIG_VP9_ENCODER && !CONFIG_VP9_DECODER
John Koleszar's avatar
John Koleszar committed
78
  {"vp9", &vpx_codec_vp9_cx, NULL, VP9_FOURCC},
John Koleszar's avatar
John Koleszar committed
79
80
81
#endif
};

82
83
static void warn_or_exit_on_errorv(vpx_codec_ctx_t *ctx, int fatal,
                                   const char *s, va_list ap) {
John Koleszar's avatar
John Koleszar committed
84
85
  if (ctx->err) {
    const char *detail = vpx_codec_error_detail(ctx);
John Koleszar's avatar
John Koleszar committed
86

John Koleszar's avatar
John Koleszar committed
87
88
    vfprintf(stderr, s, ap);
    fprintf(stderr, ": %s\n", vpx_codec_error(ctx));
John Koleszar's avatar
John Koleszar committed
89

John Koleszar's avatar
John Koleszar committed
90
91
    if (detail)
      fprintf(stderr, "    %s\n", detail);
John Koleszar's avatar
John Koleszar committed
92

93
94
    if (fatal)
      exit(EXIT_FAILURE);
John Koleszar's avatar
John Koleszar committed
95
  }
John Koleszar's avatar
John Koleszar committed
96
97
}

98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
static void ctx_exit_on_error(vpx_codec_ctx_t *ctx, const char *s, ...) {
  va_list ap;

  va_start(ap, s);
  warn_or_exit_on_errorv(ctx, 1, s, ap);
  va_end(ap);
}

static void warn_or_exit_on_error(vpx_codec_ctx_t *ctx, int fatal,
                                  const char *s, ...) {
  va_list ap;

  va_start(ap, s);
  warn_or_exit_on_errorv(ctx, fatal, s, ap);
  va_end(ap);
}

115
116
117
int read_frame(struct VpxInputContext *input_ctx, vpx_image_t *img) {
  FILE *f = input_ctx->file;
  y4m_input *y4m = &input_ctx->y4m;
John Koleszar's avatar
John Koleszar committed
118
119
  int shortread = 0;

120
  if (input_ctx->file_type == FILE_TYPE_Y4M) {
John Koleszar's avatar
John Koleszar committed
121
122
123
    if (y4m_input_fetch_frame(y4m, f, img) < 1)
      return 0;
  } else {
124
    shortread = read_yuv_frame(input_ctx, img);
John Koleszar's avatar
John Koleszar committed
125
  }
John Koleszar's avatar
John Koleszar committed
126

John Koleszar's avatar
John Koleszar committed
127
  return !shortread;
John Koleszar's avatar
John Koleszar committed
128
129
}

130
int file_is_y4m(const char detect[4]) {
John Koleszar's avatar
John Koleszar committed
131
132
133
134
  if (memcmp(detect, "YUV4", 4) == 0) {
    return 1;
  }
  return 0;
135
136
}

137
138
139
140
141
142
int fourcc_is_ivf(const char detect[4]) {
  if (memcmp(detect, "DKIF", 4) == 0) {
    return 1;
  }
  return 0;
}
John Koleszar's avatar
John Koleszar committed
143

John Koleszar's avatar
John Koleszar committed
144
/* Murmur hash derived from public domain reference implementation at
John Koleszar's avatar
John Koleszar committed
145
 *   http:// sites.google.com/site/murmurhash/
John Koleszar's avatar
John Koleszar committed
146
 */
John Koleszar's avatar
John Koleszar committed
147
148
149
static unsigned int murmur(const void *key, int len, unsigned int seed) {
  const unsigned int m = 0x5bd1e995;
  const int r = 24;
John Koleszar's avatar
John Koleszar committed
150

John Koleszar's avatar
John Koleszar committed
151
  unsigned int h = seed ^ len;
John Koleszar's avatar
John Koleszar committed
152

John Koleszar's avatar
John Koleszar committed
153
  const unsigned char *data = (const unsigned char *)key;
John Koleszar's avatar
John Koleszar committed
154

John Koleszar's avatar
John Koleszar committed
155
156
  while (len >= 4) {
    unsigned int k;
John Koleszar's avatar
John Koleszar committed
157

Yaowu Xu's avatar
Yaowu Xu committed
158
159
160
161
    k  = (unsigned int)data[0];
    k |= (unsigned int)data[1] << 8;
    k |= (unsigned int)data[2] << 16;
    k |= (unsigned int)data[3] << 24;
John Koleszar's avatar
John Koleszar committed
162

John Koleszar's avatar
John Koleszar committed
163
164
165
    k *= m;
    k ^= k >> r;
    k *= m;
John Koleszar's avatar
John Koleszar committed
166
167

    h *= m;
John Koleszar's avatar
John Koleszar committed
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
    h ^= k;

    data += 4;
    len -= 4;
  }

  switch (len) {
    case 3:
      h ^= data[2] << 16;
    case 2:
      h ^= data[1] << 8;
    case 1:
      h ^= data[0];
      h *= m;
  };

  h ^= h >> 13;
  h *= m;
  h ^= h >> 15;

  return h;
John Koleszar's avatar
John Koleszar committed
189
190
191
}


192
static const arg_def_t debugmode = ARG_DEF("D", "debug", 0,
John Koleszar's avatar
John Koleszar committed
193
                                           "Debug mode (makes output deterministic)");
194
static const arg_def_t outputfile = ARG_DEF("o", "output", 1,
John Koleszar's avatar
John Koleszar committed
195
                                            "Output filename");
John Koleszar's avatar
John Koleszar committed
196
static const arg_def_t use_yv12 = ARG_DEF(NULL, "yv12", 0,
John Koleszar's avatar
John Koleszar committed
197
                                          "Input file is YV12 ");
John Koleszar's avatar
John Koleszar committed
198
static const arg_def_t use_i420 = ARG_DEF(NULL, "i420", 0,
John Koleszar's avatar
John Koleszar committed
199
                                          "Input file is I420 (default)");
John Koleszar's avatar
John Koleszar committed
200
static const arg_def_t codecarg = ARG_DEF(NULL, "codec", 1,
John Koleszar's avatar
John Koleszar committed
201
                                          "Codec to use");
John Koleszar's avatar
John Koleszar committed
202
static const arg_def_t passes           = ARG_DEF("p", "passes", 1,
John Koleszar's avatar
John Koleszar committed
203
                                                  "Number of passes (1/2)");
John Koleszar's avatar
John Koleszar committed
204
static const arg_def_t pass_arg         = ARG_DEF(NULL, "pass", 1,
John Koleszar's avatar
John Koleszar committed
205
                                                  "Pass to execute (1/2)");
John Koleszar's avatar
John Koleszar committed
206
static const arg_def_t fpf_name         = ARG_DEF(NULL, "fpf", 1,
John Koleszar's avatar
John Koleszar committed
207
                                                  "First pass statistics file name");
John Koleszar's avatar
John Koleszar committed
208
209
static const arg_def_t limit = ARG_DEF(NULL, "limit", 1,
                                       "Stop encoding after n input frames");
210
static const arg_def_t skip = ARG_DEF(NULL, "skip", 1,
John Koleszar's avatar
John Koleszar committed
211
                                      "Skip the first n input frames");
John Koleszar's avatar
John Koleszar committed
212
static const arg_def_t deadline         = ARG_DEF("d", "deadline", 1,
John Koleszar's avatar
John Koleszar committed
213
                                                  "Deadline per frame (usec)");
John Koleszar's avatar
John Koleszar committed
214
static const arg_def_t best_dl          = ARG_DEF(NULL, "best", 0,
John Koleszar's avatar
John Koleszar committed
215
                                                  "Use Best Quality Deadline");
John Koleszar's avatar
John Koleszar committed
216
static const arg_def_t good_dl          = ARG_DEF(NULL, "good", 0,
John Koleszar's avatar
John Koleszar committed
217
                                                  "Use Good Quality Deadline");
John Koleszar's avatar
John Koleszar committed
218
static const arg_def_t rt_dl            = ARG_DEF(NULL, "rt", 0,
John Koleszar's avatar
John Koleszar committed
219
                                                  "Use Realtime Quality Deadline");
James Zern's avatar
James Zern committed
220
static const arg_def_t quietarg         = ARG_DEF("q", "quiet", 0,
John Koleszar's avatar
John Koleszar committed
221
                                                  "Do not print encode progress");
John Koleszar's avatar
John Koleszar committed
222
static const arg_def_t verbosearg       = ARG_DEF("v", "verbose", 0,
John Koleszar's avatar
John Koleszar committed
223
                                                  "Show encoder parameters");
John Koleszar's avatar
John Koleszar committed
224
static const arg_def_t psnrarg          = ARG_DEF(NULL, "psnr", 0,
John Koleszar's avatar
John Koleszar committed
225
                                                  "Show PSNR in status line");
226

227
228
229
230
231
232
233
234
235
static const struct arg_enum_list test_decode_enum[] = {
  {"off",   TEST_DECODE_OFF},
  {"fatal", TEST_DECODE_FATAL},
  {"warn",  TEST_DECODE_WARN},
  {NULL, 0}
};
static const arg_def_t recontest = ARG_DEF_ENUM(NULL, "test-decode", 1,
                                                "Test encode/decode mismatch",
                                                test_decode_enum);
236
static const arg_def_t framerate        = ARG_DEF(NULL, "fps", 1,
John Koleszar's avatar
John Koleszar committed
237
                                                  "Stream frame rate (rate/scale)");
John Koleszar's avatar
John Koleszar committed
238
static const arg_def_t use_ivf          = ARG_DEF(NULL, "ivf", 0,
John Koleszar's avatar
John Koleszar committed
239
                                                  "Output IVF (default is WebM)");
240
static const arg_def_t out_part = ARG_DEF("P", "output-partitions", 0,
John Koleszar's avatar
John Koleszar committed
241
                                          "Makes encoder output partitions. Requires IVF output!");
242
static const arg_def_t q_hist_n         = ARG_DEF(NULL, "q-hist", 1,
John Koleszar's avatar
John Koleszar committed
243
                                                  "Show quantizer histogram (n-buckets)");
244
static const arg_def_t rate_hist_n         = ARG_DEF(NULL, "rate-hist", 1,
John Koleszar's avatar
John Koleszar committed
245
                                                     "Show rate histogram (n-buckets)");
246
247
248
static const arg_def_t disable_warnings =
    ARG_DEF(NULL, "disable-warnings", 0,
            "Disable warnings about potentially incorrect encode settings.");
249
250
251
static const arg_def_t disable_warning_prompt =
    ARG_DEF("y", "disable-warning-prompt", 0,
            "Display warnings, but do not prompt user to continue.");
252

John Koleszar's avatar
John Koleszar committed
253
254
255
static const arg_def_t *main_args[] = {
  &debugmode,
  &outputfile, &codecarg, &passes, &pass_arg, &fpf_name, &limit, &skip,
John Koleszar's avatar
John Koleszar committed
256
  &deadline, &best_dl, &good_dl, &rt_dl,
257
  &quietarg, &verbosearg, &psnrarg, &use_ivf, &out_part, &q_hist_n,
258
  &rate_hist_n, &disable_warnings, &disable_warning_prompt,
John Koleszar's avatar
John Koleszar committed
259
  NULL
John Koleszar's avatar
John Koleszar committed
260
261
262
};

static const arg_def_t usage            = ARG_DEF("u", "usage", 1,
John Koleszar's avatar
John Koleszar committed
263
                                                  "Usage profile number to use");
John Koleszar's avatar
John Koleszar committed
264
static const arg_def_t threads          = ARG_DEF("t", "threads", 1,
John Koleszar's avatar
John Koleszar committed
265
                                                  "Max number of threads to use");
John Koleszar's avatar
John Koleszar committed
266
static const arg_def_t profile          = ARG_DEF(NULL, "profile", 1,
John Koleszar's avatar
John Koleszar committed
267
                                                  "Bitstream profile number to use");
John Koleszar's avatar
John Koleszar committed
268
static const arg_def_t width            = ARG_DEF("w", "width", 1,
John Koleszar's avatar
John Koleszar committed
269
                                                  "Frame width");
John Koleszar's avatar
John Koleszar committed
270
static const arg_def_t height           = ARG_DEF("h", "height", 1,
John Koleszar's avatar
John Koleszar committed
271
                                                  "Frame height");
272
static const struct arg_enum_list stereo_mode_enum[] = {
John Koleszar's avatar
John Koleszar committed
273
274
275
276
277
278
  {"mono", STEREO_FORMAT_MONO},
  {"left-right", STEREO_FORMAT_LEFT_RIGHT},
  {"bottom-top", STEREO_FORMAT_BOTTOM_TOP},
  {"top-bottom", STEREO_FORMAT_TOP_BOTTOM},
  {"right-left", STEREO_FORMAT_RIGHT_LEFT},
  {NULL, 0}
279
280
};
static const arg_def_t stereo_mode      = ARG_DEF_ENUM(NULL, "stereo-mode", 1,
John Koleszar's avatar
John Koleszar committed
281
                                                       "Stereo 3D video format", stereo_mode_enum);
John Koleszar's avatar
John Koleszar committed
282
static const arg_def_t timebase         = ARG_DEF(NULL, "timebase", 1,
John Koleszar's avatar
John Koleszar committed
283
                                                  "Output timestamp precision (fractional seconds)");
John Koleszar's avatar
John Koleszar committed
284
static const arg_def_t error_resilient  = ARG_DEF(NULL, "error-resilient", 1,
John Koleszar's avatar
John Koleszar committed
285
                                                  "Enable error resiliency features");
John Koleszar's avatar
John Koleszar committed
286
static const arg_def_t lag_in_frames    = ARG_DEF(NULL, "lag-in-frames", 1,
John Koleszar's avatar
John Koleszar committed
287
                                                  "Max number of frames to lag");
John Koleszar's avatar
John Koleszar committed
288

John Koleszar's avatar
John Koleszar committed
289
290
static const arg_def_t *global_args[] = {
  &use_yv12, &use_i420, &usage, &threads, &profile,
291
292
  &width, &height, &stereo_mode, &timebase, &framerate,
  &error_resilient,
John Koleszar's avatar
John Koleszar committed
293
  &lag_in_frames, NULL
John Koleszar's avatar
John Koleszar committed
294
295
296
};

static const arg_def_t dropframe_thresh   = ARG_DEF(NULL, "drop-frame", 1,
John Koleszar's avatar
John Koleszar committed
297
                                                    "Temporal resampling threshold (buf %)");
John Koleszar's avatar
John Koleszar committed
298
static const arg_def_t resize_allowed     = ARG_DEF(NULL, "resize-allowed", 1,
John Koleszar's avatar
John Koleszar committed
299
                                                    "Spatial resampling enabled (bool)");
John Koleszar's avatar
John Koleszar committed
300
static const arg_def_t resize_up_thresh   = ARG_DEF(NULL, "resize-up", 1,
John Koleszar's avatar
John Koleszar committed
301
                                                    "Upscale threshold (buf %)");
John Koleszar's avatar
John Koleszar committed
302
static const arg_def_t resize_down_thresh = ARG_DEF(NULL, "resize-down", 1,
John Koleszar's avatar
John Koleszar committed
303
                                                    "Downscale threshold (buf %)");
304
static const struct arg_enum_list end_usage_enum[] = {
John Koleszar's avatar
John Koleszar committed
305
306
307
  {"vbr", VPX_VBR},
  {"cbr", VPX_CBR},
  {"cq",  VPX_CQ},
308
  {"q",   VPX_Q},
John Koleszar's avatar
John Koleszar committed
309
  {NULL, 0}
310
311
};
static const arg_def_t end_usage          = ARG_DEF_ENUM(NULL, "end-usage", 1,
John Koleszar's avatar
John Koleszar committed
312
                                                         "Rate control mode", end_usage_enum);
John Koleszar's avatar
John Koleszar committed
313
static const arg_def_t target_bitrate     = ARG_DEF(NULL, "target-bitrate", 1,
John Koleszar's avatar
John Koleszar committed
314
                                                    "Bitrate (kbps)");
John Koleszar's avatar
John Koleszar committed
315
static const arg_def_t min_quantizer      = ARG_DEF(NULL, "min-q", 1,
John Koleszar's avatar
John Koleszar committed
316
                                                    "Minimum (best) quantizer");
John Koleszar's avatar
John Koleszar committed
317
static const arg_def_t max_quantizer      = ARG_DEF(NULL, "max-q", 1,
John Koleszar's avatar
John Koleszar committed
318
                                                    "Maximum (worst) quantizer");
John Koleszar's avatar
John Koleszar committed
319
static const arg_def_t undershoot_pct     = ARG_DEF(NULL, "undershoot-pct", 1,
John Koleszar's avatar
John Koleszar committed
320
                                                    "Datarate undershoot (min) target (%)");
John Koleszar's avatar
John Koleszar committed
321
static const arg_def_t overshoot_pct      = ARG_DEF(NULL, "overshoot-pct", 1,
John Koleszar's avatar
John Koleszar committed
322
                                                    "Datarate overshoot (max) target (%)");
John Koleszar's avatar
John Koleszar committed
323
static const arg_def_t buf_sz             = ARG_DEF(NULL, "buf-sz", 1,
John Koleszar's avatar
John Koleszar committed
324
                                                    "Client buffer size (ms)");
John Koleszar's avatar
John Koleszar committed
325
static const arg_def_t buf_initial_sz     = ARG_DEF(NULL, "buf-initial-sz", 1,
John Koleszar's avatar
John Koleszar committed
326
                                                    "Client initial buffer size (ms)");
John Koleszar's avatar
John Koleszar committed
327
static const arg_def_t buf_optimal_sz     = ARG_DEF(NULL, "buf-optimal-sz", 1,
John Koleszar's avatar
John Koleszar committed
328
329
330
331
332
333
                                                    "Client optimal buffer size (ms)");
static const arg_def_t *rc_args[] = {
  &dropframe_thresh, &resize_allowed, &resize_up_thresh, &resize_down_thresh,
  &end_usage, &target_bitrate, &min_quantizer, &max_quantizer,
  &undershoot_pct, &overshoot_pct, &buf_sz, &buf_initial_sz, &buf_optimal_sz,
  NULL
John Koleszar's avatar
John Koleszar committed
334
335
336
337
};


static const arg_def_t bias_pct = ARG_DEF(NULL, "bias-pct", 1,
John Koleszar's avatar
John Koleszar committed
338
                                          "CBR/VBR bias (0=CBR, 100=VBR)");
John Koleszar's avatar
John Koleszar committed
339
static const arg_def_t minsection_pct = ARG_DEF(NULL, "minsection-pct", 1,
John Koleszar's avatar
John Koleszar committed
340
                                                "GOP min bitrate (% of target)");
John Koleszar's avatar
John Koleszar committed
341
static const arg_def_t maxsection_pct = ARG_DEF(NULL, "maxsection-pct", 1,
John Koleszar's avatar
John Koleszar committed
342
343
344
                                                "GOP max bitrate (% of target)");
static const arg_def_t *rc_twopass_args[] = {
  &bias_pct, &minsection_pct, &maxsection_pct, NULL
John Koleszar's avatar
John Koleszar committed
345
346
347
348
};


static const arg_def_t kf_min_dist = ARG_DEF(NULL, "kf-min-dist", 1,
John Koleszar's avatar
John Koleszar committed
349
                                             "Minimum keyframe interval (frames)");
John Koleszar's avatar
John Koleszar committed
350
static const arg_def_t kf_max_dist = ARG_DEF(NULL, "kf-max-dist", 1,
John Koleszar's avatar
John Koleszar committed
351
                                             "Maximum keyframe interval (frames)");
352
static const arg_def_t kf_disabled = ARG_DEF(NULL, "disable-kf", 0,
John Koleszar's avatar
John Koleszar committed
353
354
355
                                             "Disable keyframe placement");
static const arg_def_t *kf_args[] = {
  &kf_min_dist, &kf_max_dist, &kf_disabled, NULL
John Koleszar's avatar
John Koleszar committed
356
357
358
359
};


static const arg_def_t noise_sens = ARG_DEF(NULL, "noise-sensitivity", 1,
John Koleszar's avatar
John Koleszar committed
360
                                            "Noise sensitivity (frames to blur)");
John Koleszar's avatar
John Koleszar committed
361
static const arg_def_t sharpness = ARG_DEF(NULL, "sharpness", 1,
John Koleszar's avatar
John Koleszar committed
362
                                           "Filter sharpness (0-7)");
John Koleszar's avatar
John Koleszar committed
363
static const arg_def_t static_thresh = ARG_DEF(NULL, "static-thresh", 1,
John Koleszar's avatar
John Koleszar committed
364
                                               "Motion detection threshold");
John Koleszar's avatar
John Koleszar committed
365
static const arg_def_t cpu_used = ARG_DEF(NULL, "cpu-used", 1,
John Koleszar's avatar
John Koleszar committed
366
                                          "CPU Used (-16..16)");
John Koleszar's avatar
John Koleszar committed
367
static const arg_def_t auto_altref = ARG_DEF(NULL, "auto-alt-ref", 1,
John Koleszar's avatar
John Koleszar committed
368
                                             "Enable automatic alt reference frames");
John Koleszar's avatar
John Koleszar committed
369
static const arg_def_t arnr_maxframes = ARG_DEF(NULL, "arnr-maxframes", 1,
John Koleszar's avatar
John Koleszar committed
370
                                                "AltRef Max Frames");
John Koleszar's avatar
John Koleszar committed
371
static const arg_def_t arnr_strength = ARG_DEF(NULL, "arnr-strength", 1,
John Koleszar's avatar
John Koleszar committed
372
                                               "AltRef Strength");
John Koleszar's avatar
John Koleszar committed
373
static const arg_def_t arnr_type = ARG_DEF(NULL, "arnr-type", 1,
John Koleszar's avatar
John Koleszar committed
374
                                           "AltRef Type");
John Koleszar's avatar
John Koleszar committed
375
static const struct arg_enum_list tuning_enum[] = {
John Koleszar's avatar
John Koleszar committed
376
377
378
  {"psnr", VP8_TUNE_PSNR},
  {"ssim", VP8_TUNE_SSIM},
  {NULL, 0}
John Koleszar's avatar
John Koleszar committed
379
380
};
static const arg_def_t tune_ssim = ARG_DEF_ENUM(NULL, "tune", 1,
John Koleszar's avatar
John Koleszar committed
381
                                                "Material to favor", tuning_enum);
Paul Wilkins's avatar
CQ Mode    
Paul Wilkins committed
382
static const arg_def_t cq_level = ARG_DEF(NULL, "cq-level", 1,
383
                                          "Constant/Constrained Quality level");
384
static const arg_def_t max_intra_rate_pct = ARG_DEF(NULL, "max-intra-rate", 1,
John Koleszar's avatar
John Koleszar committed
385
                                                    "Max I-frame bitrate (pct)");
John Koleszar's avatar
John Koleszar committed
386

387
#if CONFIG_VP8_ENCODER
388
389
static const arg_def_t token_parts =
    ARG_DEF(NULL, "token-parts", 1, "Number of token partitions to use, log2");
John Koleszar's avatar
John Koleszar committed
390
391
392
static const arg_def_t *vp8_args[] = {
  &cpu_used, &auto_altref, &noise_sens, &sharpness, &static_thresh,
  &token_parts, &arnr_maxframes, &arnr_strength, &arnr_type,
John Koleszar's avatar
John Koleszar committed
393
  &tune_ssim, &cq_level, &max_intra_rate_pct,
394
  NULL
John Koleszar's avatar
John Koleszar committed
395
};
396
397
398
399
400
401
402
403
404
405
406
static const int vp8_arg_ctrl_map[] = {
  VP8E_SET_CPUUSED, VP8E_SET_ENABLEAUTOALTREF,
  VP8E_SET_NOISE_SENSITIVITY, VP8E_SET_SHARPNESS, VP8E_SET_STATIC_THRESHOLD,
  VP8E_SET_TOKEN_PARTITIONS,
  VP8E_SET_ARNR_MAXFRAMES, VP8E_SET_ARNR_STRENGTH, VP8E_SET_ARNR_TYPE,
  VP8E_SET_TUNING, VP8E_SET_CQ_LEVEL, VP8E_SET_MAX_INTRA_BITRATE_PCT,
  0
};
#endif

#if CONFIG_VP9_ENCODER
407
408
409
410
411
412
413
414
415
416
417
static const arg_def_t tile_cols =
    ARG_DEF(NULL, "tile-columns", 1, "Number of tile columns to use, log2");
static const arg_def_t tile_rows =
    ARG_DEF(NULL, "tile-rows", 1, "Number of tile rows to use, log2");
static const arg_def_t lossless = ARG_DEF(NULL, "lossless", 1, "Lossless mode");
static const arg_def_t frame_parallel_decoding = ARG_DEF(
    NULL, "frame-parallel", 1, "Enable frame parallel decodability features");
static const arg_def_t aq_mode = ARG_DEF(
    NULL, "aq-mode", 1,
    "Adaptive q mode (0: off (by default), 1: variance 2: complexity)");

418
419
static const arg_def_t *vp9_args[] = {
  &cpu_used, &auto_altref, &noise_sens, &sharpness, &static_thresh,
Ronald S. Bultje's avatar
Ronald S. Bultje committed
420
  &tile_cols, &tile_rows, &arnr_maxframes, &arnr_strength, &arnr_type,
Yaowu Xu's avatar
Yaowu Xu committed
421
  &tune_ssim, &cq_level, &max_intra_rate_pct, &lossless,
422
  &frame_parallel_decoding, &aq_mode,
John Koleszar's avatar
John Koleszar committed
423
  NULL
John Koleszar's avatar
John Koleszar committed
424
};
425
static const int vp9_arg_ctrl_map[] = {
John Koleszar's avatar
John Koleszar committed
426
427
  VP8E_SET_CPUUSED, VP8E_SET_ENABLEAUTOALTREF,
  VP8E_SET_NOISE_SENSITIVITY, VP8E_SET_SHARPNESS, VP8E_SET_STATIC_THRESHOLD,
Ronald S. Bultje's avatar
Ronald S. Bultje committed
428
  VP9E_SET_TILE_COLUMNS, VP9E_SET_TILE_ROWS,
John Koleszar's avatar
John Koleszar committed
429
  VP8E_SET_ARNR_MAXFRAMES, VP8E_SET_ARNR_STRENGTH, VP8E_SET_ARNR_TYPE,
John Koleszar's avatar
John Koleszar committed
430
  VP8E_SET_TUNING, VP8E_SET_CQ_LEVEL, VP8E_SET_MAX_INTRA_BITRATE_PCT,
431
  VP9E_SET_LOSSLESS, VP9E_SET_FRAME_PARALLEL_DECODING, VP9E_SET_AQ_MODE,
John Koleszar's avatar
John Koleszar committed
432
  0
John Koleszar's avatar
John Koleszar committed
433
434
435
436
437
};
#endif

static const arg_def_t *no_args[] = { NULL };

438
void usage_exit() {
John Koleszar's avatar
John Koleszar committed
439
440
441
442
443
444
  int i;

  fprintf(stderr, "Usage: %s <options> -o dst_filename src_filename \n",
          exec_name);

  fprintf(stderr, "\nOptions:\n");
John Koleszar's avatar
John Koleszar committed
445
  arg_show_usage(stderr, main_args);
John Koleszar's avatar
John Koleszar committed
446
  fprintf(stderr, "\nEncoder Global Options:\n");
John Koleszar's avatar
John Koleszar committed
447
  arg_show_usage(stderr, global_args);
John Koleszar's avatar
John Koleszar committed
448
  fprintf(stderr, "\nRate Control Options:\n");
John Koleszar's avatar
John Koleszar committed
449
  arg_show_usage(stderr, rc_args);
John Koleszar's avatar
John Koleszar committed
450
  fprintf(stderr, "\nTwopass Rate Control Options:\n");
John Koleszar's avatar
John Koleszar committed
451
  arg_show_usage(stderr, rc_twopass_args);
John Koleszar's avatar
John Koleszar committed
452
  fprintf(stderr, "\nKeyframe Placement Options:\n");
John Koleszar's avatar
John Koleszar committed
453
  arg_show_usage(stderr, kf_args);
John Koleszar's avatar
John Koleszar committed
454
#if CONFIG_VP8_ENCODER
John Koleszar's avatar
John Koleszar committed
455
  fprintf(stderr, "\nVP8 Specific Options:\n");
John Koleszar's avatar
John Koleszar committed
456
  arg_show_usage(stderr, vp8_args);
John Koleszar's avatar
John Koleszar committed
457
#endif
458
459
#if CONFIG_VP9_ENCODER
  fprintf(stderr, "\nVP9 Specific Options:\n");
John Koleszar's avatar
John Koleszar committed
460
  arg_show_usage(stderr, vp9_args);
John Koleszar's avatar
John Koleszar committed
461
#endif
John Koleszar's avatar
John Koleszar committed
462
463
464
465
466
467
468
469
470
471
  fprintf(stderr, "\nStream timebase (--timebase):\n"
          "  The desired precision of timestamps in the output, expressed\n"
          "  in fractional seconds. Default is 1/1000.\n");
  fprintf(stderr, "\n"
          "Included encoders:\n"
          "\n");

  for (i = 0; i < sizeof(codecs) / sizeof(codecs[0]); i++)
    fprintf(stderr, "    %-6s - %s\n",
            codecs[i].name,
Jim Bankoski's avatar
Jim Bankoski committed
472
            vpx_codec_iface_name(codecs[i].iface()));
John Koleszar's avatar
John Koleszar committed
473
474

  exit(EXIT_FAILURE);
John Koleszar's avatar
John Koleszar committed
475
476
}

477
#define mmin(a, b)  ((a) < (b) ? (a) : (b))
James Zern's avatar
James Zern committed
478
479
static void find_mismatch(const vpx_image_t *const img1,
                          const vpx_image_t *const img2,
480
                          int yloc[4], int uloc[4], int vloc[4]) {
481
482
483
484
485
486
487
488
489
  const uint32_t bsize = 64;
  const uint32_t bsizey = bsize >> img1->y_chroma_shift;
  const uint32_t bsizex = bsize >> img1->x_chroma_shift;
  const uint32_t c_w =
      (img1->d_w + img1->x_chroma_shift) >> img1->x_chroma_shift;
  const uint32_t c_h =
      (img1->d_h + img1->y_chroma_shift) >> img1->y_chroma_shift;
  int match = 1;
  uint32_t i, j;
490
  yloc[0] = yloc[1] = yloc[2] = yloc[3] = -1;
491
492
  for (i = 0, match = 1; match && i < img1->d_h; i += bsize) {
    for (j = 0; match && j < img1->d_w; j += bsize) {
493
      int k, l;
James Zern's avatar
James Zern committed
494
495
496
497
      const int si = mmin(i + bsize, img1->d_h) - i;
      const int sj = mmin(j + bsize, img1->d_w) - j;
      for (k = 0; match && k < si; ++k) {
        for (l = 0; match && l < sj; ++l) {
498
499
500
501
502
503
          if (*(img1->planes[VPX_PLANE_Y] +
                (i + k) * img1->stride[VPX_PLANE_Y] + j + l) !=
              *(img2->planes[VPX_PLANE_Y] +
                (i + k) * img2->stride[VPX_PLANE_Y] + j + l)) {
            yloc[0] = i + k;
            yloc[1] = j + l;
504
505
506
507
            yloc[2] = *(img1->planes[VPX_PLANE_Y] +
                        (i + k) * img1->stride[VPX_PLANE_Y] + j + l);
            yloc[3] = *(img2->planes[VPX_PLANE_Y] +
                        (i + k) * img2->stride[VPX_PLANE_Y] + j + l);
508
            match = 0;
509
            break;
510
511
          }
        }
James Zern's avatar
James Zern committed
512
      }
513
    }
514
  }
515

516
  uloc[0] = uloc[1] = uloc[2] = uloc[3] = -1;
517
  for (i = 0, match = 1; match && i < c_h; i += bsizey) {
John Koleszar's avatar
John Koleszar committed
518
    for (j = 0; match && j < c_w; j += bsizex) {
519
      int k, l;
James Zern's avatar
James Zern committed
520
521
522
523
      const int si = mmin(i + bsizey, c_h - i);
      const int sj = mmin(j + bsizex, c_w - j);
      for (k = 0; match && k < si; ++k) {
        for (l = 0; match && l < sj; ++l) {
524
525
526
527
528
529
          if (*(img1->planes[VPX_PLANE_U] +
                (i + k) * img1->stride[VPX_PLANE_U] + j + l) !=
              *(img2->planes[VPX_PLANE_U] +
                (i + k) * img2->stride[VPX_PLANE_U] + j + l)) {
            uloc[0] = i + k;
            uloc[1] = j + l;
530
531
532
            uloc[2] = *(img1->planes[VPX_PLANE_U] +
                        (i + k) * img1->stride[VPX_PLANE_U] + j + l);
            uloc[3] = *(img2->planes[VPX_PLANE_U] +
James Zern's avatar
James Zern committed
533
                        (i + k) * img2->stride[VPX_PLANE_U] + j + l);
534
535
536
537
            match = 0;
            break;
          }
        }
James Zern's avatar
James Zern committed
538
      }
539
540
    }
  }
541
  vloc[0] = vloc[1] = vloc[2] = vloc[3] = -1;
542
  for (i = 0, match = 1; match && i < c_h; i += bsizey) {
John Koleszar's avatar
John Koleszar committed
543
    for (j = 0; match && j < c_w; j += bsizex) {
544
      int k, l;
James Zern's avatar
James Zern committed
545
546
547
548
      const int si = mmin(i + bsizey, c_h - i);
      const int sj = mmin(j + bsizex, c_w - j);
      for (k = 0; match && k < si; ++k) {
        for (l = 0; match && l < sj; ++l) {
549
550
551
552
553
554
          if (*(img1->planes[VPX_PLANE_V] +
                (i + k) * img1->stride[VPX_PLANE_V] + j + l) !=
              *(img2->planes[VPX_PLANE_V] +
                (i + k) * img2->stride[VPX_PLANE_V] + j + l)) {
            vloc[0] = i + k;
            vloc[1] = j + l;
555
556
557
558
            vloc[2] = *(img1->planes[VPX_PLANE_V] +
                        (i + k) * img1->stride[VPX_PLANE_V] + j + l);
            vloc[3] = *(img2->planes[VPX_PLANE_V] +
                        (i + k) * img2->stride[VPX_PLANE_V] + j + l);
559
560
561
562
            match = 0;
            break;
          }
        }
James Zern's avatar
James Zern committed
563
      }
564
565
    }
  }
566
567
}

James Zern's avatar
James Zern committed
568
569
static int compare_img(const vpx_image_t *const img1,
                       const vpx_image_t *const img2) {
570
571
572
573
574
  const uint32_t c_w =
      (img1->d_w + img1->x_chroma_shift) >> img1->x_chroma_shift;
  const uint32_t c_h =
      (img1->d_h + img1->y_chroma_shift) >> img1->y_chroma_shift;
  uint32_t i;
John Koleszar's avatar
John Koleszar committed
575
  int match = 1;
576

John Koleszar's avatar
John Koleszar committed
577
  match &= (img1->fmt == img2->fmt);
578
579
  match &= (img1->d_w == img2->d_w);
  match &= (img1->d_h == img2->d_h);
580

James Zern's avatar
James Zern committed
581
582
583
  for (i = 0; i < img1->d_h; ++i)
    match &= (memcmp(img1->planes[VPX_PLANE_Y] + i * img1->stride[VPX_PLANE_Y],
                     img2->planes[VPX_PLANE_Y] + i * img2->stride[VPX_PLANE_Y],
John Koleszar's avatar
John Koleszar committed
584
                     img1->d_w) == 0);
585

James Zern's avatar
James Zern committed
586
587
588
  for (i = 0; i < c_h; ++i)
    match &= (memcmp(img1->planes[VPX_PLANE_U] + i * img1->stride[VPX_PLANE_U],
                     img2->planes[VPX_PLANE_U] + i * img2->stride[VPX_PLANE_U],
589
                     c_w) == 0);
590

James Zern's avatar
James Zern committed
591
592
593
  for (i = 0; i < c_h; ++i)
    match &= (memcmp(img1->planes[VPX_PLANE_V] + i * img1->stride[VPX_PLANE_V],
                     img2->planes[VPX_PLANE_V] + i * img2->stride[VPX_PLANE_V],
594
                     c_w) == 0);
595

John Koleszar's avatar
John Koleszar committed
596
  return match;
597
598
}

599

600
#define NELEMENTS(x) (sizeof(x)/sizeof(x[0]))
601
602
#define MAX(x,y) ((x)>(y)?(x):(y))
#if CONFIG_VP8_ENCODER && !CONFIG_VP9_ENCODER
603
#define ARG_CTRL_CNT_MAX NELEMENTS(vp8_arg_ctrl_map)
604
605
606
607
608
609
#elif !CONFIG_VP8_ENCODER && CONFIG_VP9_ENCODER
#define ARG_CTRL_CNT_MAX NELEMENTS(vp9_arg_ctrl_map)
#else
#define ARG_CTRL_CNT_MAX MAX(NELEMENTS(vp8_arg_ctrl_map), \
                             NELEMENTS(vp9_arg_ctrl_map))
#endif
John Koleszar's avatar
John Koleszar committed
610

611
/* Per-stream configuration */
John Koleszar's avatar
John Koleszar committed
612
613
614
615
616
617
618
619
620
struct stream_config {
  struct vpx_codec_enc_cfg  cfg;
  const char               *out_fn;
  const char               *stats_fn;
  stereo_format_t           stereo_fmt;
  int                       arg_ctrls[ARG_CTRL_CNT_MAX][2];
  int                       arg_ctrl_cnt;
  int                       write_webm;
  int                       have_kf_max_dist;
621
622
623
};


John Koleszar's avatar
John Koleszar committed
624
625
626
627
628
struct stream_state {
  int                       index;
  struct stream_state      *next;
  struct stream_config      config;
  FILE                     *file;
629
  struct rate_hist         *rate_hist;
630
  struct EbmlGlobal         ebml;
John Koleszar's avatar
John Koleszar committed
631
632
633
634
635
636
637
638
639
640
641
  uint32_t                  hash;
  uint64_t                  psnr_sse_total;
  uint64_t                  psnr_samples_total;
  double                    psnr_totals[4];
  int                       psnr_count;
  int                       counts[64];
  vpx_codec_ctx_t           encoder;
  unsigned int              frames_out;
  uint64_t                  cx_time;
  size_t                    nbytes;
  stats_io_t                stats;
642
  struct vpx_image         *img;
John Koleszar's avatar
John Koleszar committed
643
644
  vpx_codec_ctx_t           decoder;
  int                       mismatch_seen;
645
646
647
};


648
void validate_positive_rational(const char          *msg,
John Koleszar's avatar
John Koleszar committed
649
650
651
652
653
                                struct vpx_rational *rat) {
  if (rat->den < 0) {
    rat->num *= -1;
    rat->den *= -1;
  }
654

John Koleszar's avatar
John Koleszar committed
655
656
  if (rat->num < 0)
    die("Error: %s must be positive\n", msg);
657

John Koleszar's avatar
John Koleszar committed
658
659
  if (!rat->den)
    die("Error: %s has zero denominator\n", msg);
660
661
662
}


663
static void parse_global_config(struct VpxEncoderConfig *global, char **argv) {
John Koleszar's avatar
John Koleszar committed
664
665
666
667
668
669
  char       **argi, **argj;
  struct arg   arg;

  /* Initialize default parameters */
  memset(global, 0, sizeof(*global));
  global->codec = codecs;
670
  global->passes = 0;
John Koleszar's avatar
John Koleszar committed
671
  global->use_i420 = 1;
672
673
  /* Assign default deadline to good quality */
  global->deadline = VPX_DL_GOOD_QUALITY;
John Koleszar's avatar
John Koleszar committed
674
675
676
677
678
679
680
681
682
683
684
685

  for (argi = argj = argv; (*argj = *argi); argi += arg.argv_step) {
    arg.argv_step = 1;

    if (arg_match(&arg, &codecarg, argi)) {
      int j, k = -1;

      for (j = 0; j < sizeof(codecs) / sizeof(codecs[0]); j++)
        if (!strcmp(codecs[j].name, arg.val))
          k = j;

      if (k >= 0)
John Koleszar's avatar
John Koleszar committed
686
        global->codec = codecs + k;
John Koleszar's avatar
John Koleszar committed
687
688
689
690
691
      else
        die("Error: Unrecognized argument (%s) to --codec\n",
            arg.val);

    } else if (arg_match(&arg, &passes, argi)) {
John Koleszar's avatar
John Koleszar committed
692
      global->passes = arg_parse_uint(&arg);
John Koleszar's avatar
John Koleszar committed
693

John Koleszar's avatar
John Koleszar committed
694
695
      if (global->passes < 1 || global->passes > 2)
        die("Error: Invalid number of passes (%d)\n", global->passes);
John Koleszar's avatar
John Koleszar committed
696
    } else if (arg_match(&arg, &pass_arg, argi)) {
John Koleszar's avatar
John Koleszar committed
697
698
699
700
701
702
703
      global->pass = arg_parse_uint(&arg);

      if (global->pass < 1 || global->pass > 2)
        die("Error: Invalid pass selected (%d)\n",
            global->pass);
    } else if (arg_match(&arg, &usage, argi))
      global->usage = arg_parse_uint(&arg);
John Koleszar's avatar
John Koleszar committed
704
    else if (arg_match(&arg, &deadline, argi))
John Koleszar's avatar
John Koleszar committed
705
      global->deadline = arg_parse_uint(&arg);
John Koleszar's avatar
John Koleszar committed
706
    else if (arg_match(&arg, &best_dl, argi))
John Koleszar's avatar
John Koleszar committed
707
      global->deadline = VPX_DL_BEST_QUALITY;
John Koleszar's avatar
John Koleszar committed
708
    else if (arg_match(&arg, &good_dl, argi))
John Koleszar's avatar
John Koleszar committed
709
      global->deadline = VPX_DL_GOOD_QUALITY;
John Koleszar's avatar
John Koleszar committed
710
    else if (arg_match(&arg, &rt_dl, argi))
John Koleszar's avatar
John Koleszar committed
711
712
713
714
715
716
717
718
719
      global->deadline = VPX_DL_REALTIME;
    else if (arg_match(&arg, &use_yv12, argi))
      global->use_i420 = 0;
    else if (arg_match(&arg, &use_i420, argi))
      global->use_i420 = 1;
    else if (arg_match(&arg, &quietarg, argi))
      global->quiet = 1;
    else if (arg_match(&arg, &verbosearg, argi))
      global->verbose = 1;
John Koleszar's avatar
John Koleszar committed
720
    else if (arg_match(&arg, &limit, argi))
John Koleszar's avatar
John Koleszar committed
721
      global->limit = arg_parse_uint(&arg);
John Koleszar's avatar
John Koleszar committed
722
    else if (arg_match(&arg, &skip, argi))
John Koleszar's avatar
John Koleszar committed
723
      global->skip_frames = arg_parse_uint(&arg);
John Koleszar's avatar
John Koleszar committed
724
    else if (arg_match(&arg, &psnrarg, argi))
John Koleszar's avatar
John Koleszar committed
725
      global->show_psnr = 1;
John Koleszar's avatar
John Koleszar committed
726
    else if (arg_match(&arg, &recontest, argi))
727
      global->test_decode = arg_parse_enum_or_int(&arg);
John Koleszar's avatar
John Koleszar committed
728
    else if (arg_match(&arg, &framerate, argi)) {
John Koleszar's avatar
John Koleszar committed
729
730
731
732
733
      global->framerate = arg_parse_rational(&arg);
      validate_positive_rational(arg.name, &global->framerate);
      global->have_framerate = 1;
    } else if (arg_match(&arg, &out_part, argi))
      global->out_part = 1;
John Koleszar's avatar
John Koleszar committed
734
    else if (arg_match(&arg, &debugmode, argi))
John Koleszar's avatar
John Koleszar committed
735
      global->debug = 1;
John Koleszar's avatar
John Koleszar committed
736
    else if (arg_match(&arg, &q_hist_n, argi))
John Koleszar's avatar
John Koleszar committed
737
      global->show_q_hist_buckets = arg_parse_uint(&arg);
John Koleszar's avatar
John Koleszar committed
738
    else if (arg_match(&arg, &rate_hist_n, argi))
John Koleszar's avatar
John Koleszar committed
739
      global->show_rate_hist_buckets = arg_parse_uint(&arg);
740
741
742
743
    else if (arg_match(&arg, &disable_warnings, argi))
      global->disable_warnings = 1;
    else if (arg_match(&arg, &disable_warning_prompt, argi))
      global->disable_warning_prompt = 1;
John Koleszar's avatar
John Koleszar committed
744
745
746
    else
      argj++;
  }
John Koleszar's avatar
John Koleszar committed
747

John Koleszar's avatar
John Koleszar committed
748
  /* Validate global config */
749
  if (global->passes == 0) {
James Zern's avatar
James Zern committed
750
#if CONFIG_VP9_ENCODER
751
752
753
    // Make default VP9 passes = 2 until there is a better quality 1-pass
    // encoder
    global->passes = (global->codec->iface == vpx_codec_vp9_cx ? 2 : 1);
James Zern's avatar
James Zern committed
754
755
756
#else
    global->passes = 1;
#endif
757
  }
758

John Koleszar's avatar
John Koleszar committed
759
  if (global->pass) {
John Koleszar's avatar
John Koleszar committed
760
    /* DWIM: Assume the user meant passes=2 if pass=2 is specified */
John Koleszar's avatar
John Koleszar committed
761
762
763
764
    if (global->pass > global->passes) {
      warn("Assuming --pass=%d implies --passes=%d\n",
           global->pass, global->pass);
      global->passes = global->pass;
John Koleszar's avatar
John Koleszar committed
765
    }
John Koleszar's avatar
John Koleszar committed
766
  }
767
768
769
}


770
void open_input_file(struct VpxInputContext *input) {
John Koleszar's avatar
John Koleszar committed
771
  /* Parse certain options from the input file, if possible */
772
773
  input->file = strcmp(input->filename, "-")
      ? fopen(input->filename, "rb") : set_binary_mode(stdin);
John Koleszar's avatar
John Koleszar committed
774
775
776

  if (!input->file)
    fatal("Failed to open input file");
John Koleszar's avatar
John Koleszar committed
777

778
779
780
781
782
783
784
785
  if (!fseeko(input->file, 0, SEEK_END)) {
    /* Input file is seekable. Figure out how long it is, so we can get
     * progress info.
     */
    input->length = ftello(input->file);
    rewind(input->file);
  }

John Koleszar's avatar
John Koleszar committed
786
787
788
789
790
791
792
  /* For RAW input sources, these bytes will applied on the first frame
   *  in read_frame().
   */
  input->detect.buf_read = fread(input->detect.buf, 1, 4, input->file);
  input->detect.position = 0;

  if (input->detect.buf_read == 4
793
      && file_is_y4m(input->detect.buf)) {
794
795
    if (y4m_input_open(&input->y4m, input->file, input->detect.buf, 4,
                       input->only_i420) >= 0) {
John Koleszar's avatar
John Koleszar committed
796
      input->file_type = FILE_TYPE_Y4M;
797
798
799
800
      input->width = input->y4m.pic_w;
      input->height = input->y4m.pic_h;
      input->framerate.numerator = input->y4m.fps_n;
      input->framerate.denominator = input->y4m.fps_d;
John Koleszar's avatar
John Koleszar committed
801
802
803
      input->use_i420 = 0;
    } else
      fatal("Unsupported Y4M stream.");
804
  } else if (input->detect.buf_read == 4 && fourcc_is_ivf(input->detect.buf)) {
805
    fatal("IVF is not supported as input.");
John Koleszar's avatar
John Koleszar committed
806
807
  } else {
    input->file_type = FILE_TYPE_RAW;
John Koleszar's avatar
John Koleszar committed
808
  }
809
810
811
}


812
static void close_input_file(struct VpxInputContext *input) {
John Koleszar's avatar
John Koleszar committed
813
814
815
  fclose(input->file);
  if (input->file_type == FILE_TYPE_Y4M)
    y4m_input_close(&input->y4m);
816
817
}

818
static struct stream_state *new_stream(struct VpxEncoderConfig *global,
819
                                       struct stream_state *prev) {
John Koleszar's avatar
John Koleszar committed
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
  struct stream_state *stream;

  stream = calloc(1, sizeof(*stream));
  if (!stream)
    fatal("Failed to allocate new stream.");
  if (prev) {
    memcpy(stream, prev, sizeof(*stream));
    stream->index++;
    prev->next = stream;
  } else {
    vpx_codec_err_t  res;

    /* Populate encoder configuration */
    res = vpx_codec_enc_config_default(global->codec->iface(),
                                       &stream->config.cfg,
                                       global->usage);
    if (res)
      fatal("Failed to get config: %s\n", vpx_codec_err_to_string(res));
John Koleszar's avatar
John Koleszar committed
838

John Koleszar's avatar
John Koleszar committed
839
840
841
842
    /* Change the default timebase to a high enough value so that the
     * encoder will always create strictly increasing timestamps.
     */
    stream->config.cfg.g_timebase.den = 1000;
843

John Koleszar's avatar
John Koleszar committed
844
845
846
847
848
    /* Never use the library's default resolution, require it be parsed
     * from the file or set on the command line.
     */
    stream->config.cfg.g_w = 0;
    stream->config.cfg.g_h = 0;
John Koleszar's avatar
John Koleszar committed
849

John Koleszar's avatar
John Koleszar committed
850
851
852
853
    /* Initialize remaining stream parameters */
    stream->config.stereo_fmt = STEREO_FORMAT_MONO;
    stream->config.write_webm = 1;
    stream->ebml.last_pts_ms = -1;
John Koleszar's avatar
John Koleszar committed
854

John Koleszar's avatar
John Koleszar committed
855
856
    /* Allows removal of the application version from the EBML tags */
    stream->ebml.debug = global->debug;
John Koleszar's avatar
John Koleszar committed
857
  }
John Koleszar's avatar
John Koleszar committed
858

John Koleszar's avatar
John Koleszar committed
859
860
  /* Output files must be specified for each stream */
  stream->config.out_fn = NULL;
John Koleszar's avatar
John Koleszar committed
861

John Koleszar's avatar
John Koleszar committed
862
863
  stream->next = NULL;
  return stream;
864
}
John Koleszar's avatar
John Koleszar committed
865

866

867
static int parse_stream_params(struct VpxEncoderConfig *global,
868
                               struct stream_state  *stream,
John Koleszar's avatar
John Koleszar committed
869
870
871
872
873
874
875
876
877
                               char **argv) {
  char                   **argi, **argj;
  struct arg               arg;
  static const arg_def_t **ctrl_args = no_args;
  static const int        *ctrl_args_map = NULL;
  struct stream_config    *config = &stream->config;
  int                      eos_mark_found = 0;

  /* Handle codec specific options */
878
879
880
  if (0) {
#if CONFIG_VP8_ENCODER
  } else if (global->codec->iface == vpx_codec_vp8_cx) {
John Koleszar's avatar
John Koleszar committed
881
882
    ctrl_args = vp8_args;
    ctrl_args_map = vp8_arg_ctrl_map;
883
884
885
886
887
888
#endif
#if CONFIG_VP9_ENCODER
  } else if (global->codec->iface == vpx_codec_vp9_cx) {
    ctrl_args = vp9_args;
    ctrl_args_map = vp9_arg_ctrl_map;
#endif
John Koleszar's avatar
John Koleszar committed
889
  }
890

John Koleszar's avatar
John Koleszar committed
891
892
  for (argi = argj = argv; (*argj = *argi); argi += arg.argv_step) {
    arg.argv_step = 1;
John Koleszar's avatar
John Koleszar committed
893

John Koleszar's avatar
John Koleszar committed
894
895
896
897
898
899
900
901
902
903
    /* Once we've found an end-of-stream marker (--) we want to continue
     * shifting arguments but not consuming them.
     */
    if (eos_mark_found) {
      argj++;
      continue;
    } else if (!strcmp(*argj, "--")) {
      eos_mark_found = 1;
      continue;
    }
John Koleszar's avatar
John Koleszar committed
904

John Koleszar's avatar
John Koleszar committed
905
    if (0);
John Koleszar's avatar
John Koleszar committed
906
907
908
909
910
911
    else if (arg_match(&arg, &outputfile, argi))
      config->out_fn = arg.val;
    else if (arg_match(&arg, &fpf_name, argi))
      config->stats_fn = arg.val;
    else if (arg_match(&arg, &use_ivf, argi))
      config->write_webm = 0;