2010-05-18 19:58:33 +04:00
|
|
|
/*
|
2010-09-09 16:16:39 +04:00
|
|
|
* Copyright (c) 2010 The WebM project authors. All Rights Reserved.
|
2010-05-18 19:58:33 +04:00
|
|
|
*
|
2010-06-11 01:10:12 +04:00
|
|
|
* Use of this source code is governed by a BSD-style license
|
2010-06-05 00:19:40 +04:00
|
|
|
* that can be found in the LICENSE file in the root of the source
|
|
|
|
* tree. An additional intellectual property rights grant can be found
|
2010-06-11 01:10:12 +04:00
|
|
|
* in the file PATENTS. All contributing project authors may
|
2010-06-05 00:19:40 +04:00
|
|
|
* be found in the AUTHORS file in the root of the source tree.
|
2010-05-18 19:58:33 +04:00
|
|
|
*/
|
|
|
|
|
2013-11-22 04:46:40 +04:00
|
|
|
#include "./vpxenc.h"
|
2013-11-08 09:28:45 +04:00
|
|
|
#include "./vpx_config.h"
|
2010-05-18 19:58:33 +04:00
|
|
|
|
2013-11-15 00:37:42 +04:00
|
|
|
#include <assert.h>
|
|
|
|
#include <limits.h>
|
2013-11-08 09:28:45 +04:00
|
|
|
#include <math.h>
|
2013-11-15 00:37:42 +04:00
|
|
|
#include <stdarg.h>
|
2010-05-18 19:58:33 +04:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
2013-11-15 00:37:42 +04:00
|
|
|
|
2010-05-24 19:39:59 +04:00
|
|
|
#include "vpx/vpx_encoder.h"
|
2012-12-23 19:20:10 +04:00
|
|
|
#if CONFIG_DECODERS
|
2012-11-07 00:02:42 +04:00
|
|
|
#include "vpx/vpx_decoder.h"
|
2012-12-23 19:20:10 +04:00
|
|
|
#endif
|
2012-11-07 00:02:42 +04:00
|
|
|
|
2013-11-05 22:02:18 +04:00
|
|
|
#include "third_party/libyuv/include/libyuv/scale.h"
|
2013-11-15 00:37:42 +04:00
|
|
|
#include "./args.h"
|
|
|
|
#include "./ivfenc.h"
|
2013-11-05 22:02:18 +04:00
|
|
|
|
2012-11-07 04:59:01 +04:00
|
|
|
#if CONFIG_VP8_ENCODER || CONFIG_VP9_ENCODER
|
2010-05-24 19:39:59 +04:00
|
|
|
#include "vpx/vp8cx.h"
|
2012-11-07 00:02:42 +04:00
|
|
|
#endif
|
2012-11-07 04:59:01 +04:00
|
|
|
#if CONFIG_VP8_DECODER || CONFIG_VP9_DECODER
|
2012-03-08 00:25:50 +04:00
|
|
|
#include "vpx/vp8dx.h"
|
2012-11-07 00:02:42 +04:00
|
|
|
#endif
|
|
|
|
|
2013-11-08 09:28:45 +04:00
|
|
|
#include "./tools_common.h"
|
2010-05-18 19:58:33 +04:00
|
|
|
#include "vpx_ports/mem_ops.h"
|
|
|
|
#include "vpx_ports/vpx_timer.h"
|
2014-01-30 00:28:29 +04:00
|
|
|
#include "./rate_hist.h"
|
2013-11-08 09:28:45 +04:00
|
|
|
#include "./vpxstats.h"
|
2013-11-26 00:05:19 +04:00
|
|
|
#include "./warnings.h"
|
2013-11-08 09:28:45 +04:00
|
|
|
#include "./webmenc.h"
|
|
|
|
#include "./y4minput.h"
|
2013-11-05 22:02:18 +04:00
|
|
|
|
2012-06-20 08:05:36 +04:00
|
|
|
/* Swallow warnings about unused results of fread/fwrite */
|
|
|
|
static size_t wrap_fread(void *ptr, size_t size, size_t nmemb,
|
2012-11-07 00:02:42 +04:00
|
|
|
FILE *stream) {
|
|
|
|
return fread(ptr, size, nmemb, stream);
|
2012-06-20 08:05:36 +04:00
|
|
|
}
|
|
|
|
#define fread wrap_fread
|
|
|
|
|
|
|
|
static size_t wrap_fwrite(const void *ptr, size_t size, size_t nmemb,
|
2012-11-07 00:02:42 +04:00
|
|
|
FILE *stream) {
|
|
|
|
return fwrite(ptr, size, nmemb, stream);
|
2012-06-20 08:05:36 +04:00
|
|
|
}
|
|
|
|
#define fwrite wrap_fwrite
|
|
|
|
|
|
|
|
|
2010-05-18 19:58:33 +04:00
|
|
|
static const char *exec_name;
|
|
|
|
|
2012-07-23 23:32:59 +04:00
|
|
|
static const struct codec_item {
|
2012-11-07 00:02:42 +04:00
|
|
|
char const *name;
|
2014-02-01 04:32:42 +04:00
|
|
|
vpx_codec_iface_t *(*iface)(void);
|
|
|
|
vpx_codec_iface_t *(*dx_iface)(void);
|
2012-07-23 23:32:59 +04:00
|
|
|
unsigned int fourcc;
|
|
|
|
} codecs[] = {
|
2012-11-07 04:59:01 +04:00
|
|
|
#if CONFIG_VP8_ENCODER && CONFIG_VP8_DECODER
|
2012-11-14 00:14:28 +04:00
|
|
|
{"vp8", &vpx_codec_vp8_cx, &vpx_codec_vp8_dx, VP8_FOURCC},
|
2012-11-09 05:09:30 +04:00
|
|
|
#elif CONFIG_VP8_ENCODER && !CONFIG_VP8_DECODER
|
2012-11-14 00:14:28 +04:00
|
|
|
{"vp8", &vpx_codec_vp8_cx, NULL, VP8_FOURCC},
|
2012-11-07 04:59:01 +04:00
|
|
|
#endif
|
2012-11-07 00:02:42 +04:00
|
|
|
#if CONFIG_VP9_ENCODER && CONFIG_VP9_DECODER
|
2012-11-14 00:14:28 +04:00
|
|
|
{"vp9", &vpx_codec_vp9_cx, &vpx_codec_vp9_dx, VP9_FOURCC},
|
2012-11-07 04:59:01 +04:00
|
|
|
#elif CONFIG_VP9_ENCODER && !CONFIG_VP9_DECODER
|
2012-11-14 00:14:28 +04:00
|
|
|
{"vp9", &vpx_codec_vp9_cx, NULL, VP9_FOURCC},
|
2010-05-18 19:58:33 +04:00
|
|
|
#endif
|
|
|
|
};
|
|
|
|
|
2013-02-16 04:31:02 +04:00
|
|
|
static void warn_or_exit_on_errorv(vpx_codec_ctx_t *ctx, int fatal,
|
|
|
|
const char *s, va_list ap) {
|
2012-07-14 02:21:29 +04:00
|
|
|
if (ctx->err) {
|
|
|
|
const char *detail = vpx_codec_error_detail(ctx);
|
2010-05-18 19:58:33 +04:00
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
vfprintf(stderr, s, ap);
|
|
|
|
fprintf(stderr, ": %s\n", vpx_codec_error(ctx));
|
2010-05-18 19:58:33 +04:00
|
|
|
|
2012-07-14 02:21:29 +04:00
|
|
|
if (detail)
|
|
|
|
fprintf(stderr, " %s\n", detail);
|
2010-05-18 19:58:33 +04:00
|
|
|
|
2013-02-16 04:31:02 +04:00
|
|
|
if (fatal)
|
|
|
|
exit(EXIT_FAILURE);
|
2012-07-14 02:21:29 +04:00
|
|
|
}
|
2010-05-18 19:58:33 +04:00
|
|
|
}
|
|
|
|
|
2013-02-16 04:31:02 +04:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2013-11-15 00:37:42 +04:00
|
|
|
int read_frame(struct VpxInputContext *input_ctx, vpx_image_t *img) {
|
|
|
|
FILE *f = input_ctx->file;
|
|
|
|
y4m_input *y4m = &input_ctx->y4m;
|
2012-07-14 02:21:29 +04:00
|
|
|
int shortread = 0;
|
|
|
|
|
2013-11-15 00:37:42 +04:00
|
|
|
if (input_ctx->file_type == FILE_TYPE_Y4M) {
|
2012-07-14 02:21:29 +04:00
|
|
|
if (y4m_input_fetch_frame(y4m, f, img) < 1)
|
|
|
|
return 0;
|
|
|
|
} else {
|
2013-11-15 00:37:42 +04:00
|
|
|
shortread = read_yuv_frame(input_ctx, img);
|
2012-07-14 02:21:29 +04:00
|
|
|
}
|
2010-05-18 19:58:33 +04:00
|
|
|
|
2012-07-14 02:21:29 +04:00
|
|
|
return !shortread;
|
2010-05-18 19:58:33 +04:00
|
|
|
}
|
|
|
|
|
2014-01-07 04:29:09 +04:00
|
|
|
int file_is_y4m(const char detect[4]) {
|
2012-07-14 02:21:29 +04:00
|
|
|
if (memcmp(detect, "YUV4", 4) == 0) {
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
2010-05-27 02:27:51 +04:00
|
|
|
}
|
|
|
|
|
2014-01-07 04:29:09 +04:00
|
|
|
int fourcc_is_ivf(const char detect[4]) {
|
|
|
|
if (memcmp(detect, "DKIF", 4) == 0) {
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2010-10-20 20:05:48 +04:00
|
|
|
|
2010-10-27 18:05:55 +04:00
|
|
|
/* Murmur hash derived from public domain reference implementation at
|
2012-07-14 02:21:29 +04:00
|
|
|
* http:// sites.google.com/site/murmurhash/
|
2010-10-27 18:05:55 +04:00
|
|
|
*/
|
2012-07-14 02:21:29 +04:00
|
|
|
static unsigned int murmur(const void *key, int len, unsigned int seed) {
|
|
|
|
const unsigned int m = 0x5bd1e995;
|
|
|
|
const int r = 24;
|
2010-10-27 18:05:55 +04:00
|
|
|
|
2012-07-14 02:21:29 +04:00
|
|
|
unsigned int h = seed ^ len;
|
2010-10-27 18:05:55 +04:00
|
|
|
|
2012-07-14 02:21:29 +04:00
|
|
|
const unsigned char *data = (const unsigned char *)key;
|
2010-10-27 18:05:55 +04:00
|
|
|
|
2012-07-14 02:21:29 +04:00
|
|
|
while (len >= 4) {
|
|
|
|
unsigned int k;
|
2010-10-27 18:05:55 +04:00
|
|
|
|
2013-09-18 03:31:46 +04:00
|
|
|
k = (unsigned int)data[0];
|
|
|
|
k |= (unsigned int)data[1] << 8;
|
|
|
|
k |= (unsigned int)data[2] << 16;
|
|
|
|
k |= (unsigned int)data[3] << 24;
|
2010-10-27 18:05:55 +04:00
|
|
|
|
2012-07-14 02:21:29 +04:00
|
|
|
k *= m;
|
|
|
|
k ^= k >> r;
|
|
|
|
k *= m;
|
2010-10-27 18:05:55 +04:00
|
|
|
|
|
|
|
h *= m;
|
2012-07-14 02:21:29 +04:00
|
|
|
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;
|
2010-10-27 18:05:55 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-10-27 00:22:22 +04:00
|
|
|
static const arg_def_t debugmode = ARG_DEF("D", "debug", 0,
|
2012-07-14 02:21:29 +04:00
|
|
|
"Debug mode (makes output deterministic)");
|
2010-10-22 22:48:21 +04:00
|
|
|
static const arg_def_t outputfile = ARG_DEF("o", "output", 1,
|
2012-07-14 02:21:29 +04:00
|
|
|
"Output filename");
|
2010-05-18 19:58:33 +04:00
|
|
|
static const arg_def_t use_yv12 = ARG_DEF(NULL, "yv12", 0,
|
2012-07-14 02:21:29 +04:00
|
|
|
"Input file is YV12 ");
|
2010-05-18 19:58:33 +04:00
|
|
|
static const arg_def_t use_i420 = ARG_DEF(NULL, "i420", 0,
|
2012-07-14 02:21:29 +04:00
|
|
|
"Input file is I420 (default)");
|
2010-05-18 19:58:33 +04:00
|
|
|
static const arg_def_t codecarg = ARG_DEF(NULL, "codec", 1,
|
2012-07-14 02:21:29 +04:00
|
|
|
"Codec to use");
|
2010-05-18 19:58:33 +04:00
|
|
|
static const arg_def_t passes = ARG_DEF("p", "passes", 1,
|
2012-07-14 02:21:29 +04:00
|
|
|
"Number of passes (1/2)");
|
2010-05-18 19:58:33 +04:00
|
|
|
static const arg_def_t pass_arg = ARG_DEF(NULL, "pass", 1,
|
2012-07-14 02:21:29 +04:00
|
|
|
"Pass to execute (1/2)");
|
2010-05-18 19:58:33 +04:00
|
|
|
static const arg_def_t fpf_name = ARG_DEF(NULL, "fpf", 1,
|
2012-07-14 02:21:29 +04:00
|
|
|
"First pass statistics file name");
|
2010-05-18 19:58:33 +04:00
|
|
|
static const arg_def_t limit = ARG_DEF(NULL, "limit", 1,
|
|
|
|
"Stop encoding after n input frames");
|
2012-03-14 18:37:10 +04:00
|
|
|
static const arg_def_t skip = ARG_DEF(NULL, "skip", 1,
|
2012-07-14 02:21:29 +04:00
|
|
|
"Skip the first n input frames");
|
2010-05-18 19:58:33 +04:00
|
|
|
static const arg_def_t deadline = ARG_DEF("d", "deadline", 1,
|
2012-07-14 02:21:29 +04:00
|
|
|
"Deadline per frame (usec)");
|
2010-05-18 19:58:33 +04:00
|
|
|
static const arg_def_t best_dl = ARG_DEF(NULL, "best", 0,
|
2012-07-14 02:21:29 +04:00
|
|
|
"Use Best Quality Deadline");
|
2010-05-18 19:58:33 +04:00
|
|
|
static const arg_def_t good_dl = ARG_DEF(NULL, "good", 0,
|
2012-07-14 02:21:29 +04:00
|
|
|
"Use Good Quality Deadline");
|
2010-05-18 19:58:33 +04:00
|
|
|
static const arg_def_t rt_dl = ARG_DEF(NULL, "rt", 0,
|
2012-07-14 02:21:29 +04:00
|
|
|
"Use Realtime Quality Deadline");
|
2012-10-26 05:31:35 +04:00
|
|
|
static const arg_def_t quietarg = ARG_DEF("q", "quiet", 0,
|
2012-11-07 00:02:42 +04:00
|
|
|
"Do not print encode progress");
|
2010-05-18 19:58:33 +04:00
|
|
|
static const arg_def_t verbosearg = ARG_DEF("v", "verbose", 0,
|
2012-07-14 02:21:29 +04:00
|
|
|
"Show encoder parameters");
|
2010-05-18 19:58:33 +04:00
|
|
|
static const arg_def_t psnrarg = ARG_DEF(NULL, "psnr", 0,
|
2012-07-14 02:21:29 +04:00
|
|
|
"Show PSNR in status line");
|
2013-11-22 04:46:40 +04:00
|
|
|
|
2013-02-16 04:31:02 +04:00
|
|
|
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);
|
2010-10-22 00:52:14 +04:00
|
|
|
static const arg_def_t framerate = ARG_DEF(NULL, "fps", 1,
|
2012-07-14 02:21:29 +04:00
|
|
|
"Stream frame rate (rate/scale)");
|
2010-10-22 00:23:20 +04:00
|
|
|
static const arg_def_t use_ivf = ARG_DEF(NULL, "ivf", 0,
|
2012-07-14 02:21:29 +04:00
|
|
|
"Output IVF (default is WebM)");
|
2012-02-09 14:37:03 +04:00
|
|
|
static const arg_def_t out_part = ARG_DEF("P", "output-partitions", 0,
|
2012-11-07 00:02:42 +04:00
|
|
|
"Makes encoder output partitions. Requires IVF output!");
|
2011-06-21 01:09:29 +04:00
|
|
|
static const arg_def_t q_hist_n = ARG_DEF(NULL, "q-hist", 1,
|
2012-07-14 02:21:29 +04:00
|
|
|
"Show quantizer histogram (n-buckets)");
|
2011-06-22 00:42:33 +04:00
|
|
|
static const arg_def_t rate_hist_n = ARG_DEF(NULL, "rate-hist", 1,
|
2012-07-14 02:21:29 +04:00
|
|
|
"Show rate histogram (n-buckets)");
|
2013-11-21 05:18:28 +04:00
|
|
|
static const arg_def_t disable_warnings =
|
|
|
|
ARG_DEF(NULL, "disable-warnings", 0,
|
|
|
|
"Disable warnings about potentially incorrect encode settings.");
|
2013-11-26 00:05:19 +04:00
|
|
|
static const arg_def_t disable_warning_prompt =
|
|
|
|
ARG_DEF("y", "disable-warning-prompt", 0,
|
|
|
|
"Display warnings, but do not prompt user to continue.");
|
2013-11-21 05:18:28 +04:00
|
|
|
|
2012-07-14 02:21:29 +04:00
|
|
|
static const arg_def_t *main_args[] = {
|
|
|
|
&debugmode,
|
|
|
|
&outputfile, &codecarg, &passes, &pass_arg, &fpf_name, &limit, &skip,
|
2012-11-07 00:02:42 +04:00
|
|
|
&deadline, &best_dl, &good_dl, &rt_dl,
|
2013-11-21 05:18:28 +04:00
|
|
|
&quietarg, &verbosearg, &psnrarg, &use_ivf, &out_part, &q_hist_n,
|
2013-11-26 00:05:19 +04:00
|
|
|
&rate_hist_n, &disable_warnings, &disable_warning_prompt,
|
2012-07-14 02:21:29 +04:00
|
|
|
NULL
|
2010-05-18 19:58:33 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
static const arg_def_t usage = ARG_DEF("u", "usage", 1,
|
2012-07-14 02:21:29 +04:00
|
|
|
"Usage profile number to use");
|
2010-05-18 19:58:33 +04:00
|
|
|
static const arg_def_t threads = ARG_DEF("t", "threads", 1,
|
2012-07-14 02:21:29 +04:00
|
|
|
"Max number of threads to use");
|
2010-05-18 19:58:33 +04:00
|
|
|
static const arg_def_t profile = ARG_DEF(NULL, "profile", 1,
|
2012-07-14 02:21:29 +04:00
|
|
|
"Bitstream profile number to use");
|
2010-05-18 19:58:33 +04:00
|
|
|
static const arg_def_t width = ARG_DEF("w", "width", 1,
|
2012-07-14 02:21:29 +04:00
|
|
|
"Frame width");
|
2010-05-18 19:58:33 +04:00
|
|
|
static const arg_def_t height = ARG_DEF("h", "height", 1,
|
2012-07-14 02:21:29 +04:00
|
|
|
"Frame height");
|
2011-04-21 11:50:07 +04:00
|
|
|
static const struct arg_enum_list stereo_mode_enum[] = {
|
2012-07-14 02:21:29 +04:00
|
|
|
{"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}
|
2011-04-21 11:50:07 +04:00
|
|
|
};
|
|
|
|
static const arg_def_t stereo_mode = ARG_DEF_ENUM(NULL, "stereo-mode", 1,
|
2012-07-14 02:21:29 +04:00
|
|
|
"Stereo 3D video format", stereo_mode_enum);
|
2010-05-18 19:58:33 +04:00
|
|
|
static const arg_def_t timebase = ARG_DEF(NULL, "timebase", 1,
|
2012-07-14 02:21:29 +04:00
|
|
|
"Output timestamp precision (fractional seconds)");
|
2010-05-18 19:58:33 +04:00
|
|
|
static const arg_def_t error_resilient = ARG_DEF(NULL, "error-resilient", 1,
|
2012-07-14 02:21:29 +04:00
|
|
|
"Enable error resiliency features");
|
2010-05-18 19:58:33 +04:00
|
|
|
static const arg_def_t lag_in_frames = ARG_DEF(NULL, "lag-in-frames", 1,
|
2012-07-14 02:21:29 +04:00
|
|
|
"Max number of frames to lag");
|
2010-05-18 19:58:33 +04:00
|
|
|
|
2012-07-14 02:21:29 +04:00
|
|
|
static const arg_def_t *global_args[] = {
|
|
|
|
&use_yv12, &use_i420, &usage, &threads, &profile,
|
2013-01-25 23:30:28 +04:00
|
|
|
&width, &height, &stereo_mode, &timebase, &framerate,
|
|
|
|
&error_resilient,
|
2012-07-14 02:21:29 +04:00
|
|
|
&lag_in_frames, NULL
|
2010-05-18 19:58:33 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
static const arg_def_t dropframe_thresh = ARG_DEF(NULL, "drop-frame", 1,
|
2012-07-14 02:21:29 +04:00
|
|
|
"Temporal resampling threshold (buf %)");
|
2010-05-18 19:58:33 +04:00
|
|
|
static const arg_def_t resize_allowed = ARG_DEF(NULL, "resize-allowed", 1,
|
2012-07-14 02:21:29 +04:00
|
|
|
"Spatial resampling enabled (bool)");
|
2010-05-18 19:58:33 +04:00
|
|
|
static const arg_def_t resize_up_thresh = ARG_DEF(NULL, "resize-up", 1,
|
2012-07-14 02:21:29 +04:00
|
|
|
"Upscale threshold (buf %)");
|
2010-05-18 19:58:33 +04:00
|
|
|
static const arg_def_t resize_down_thresh = ARG_DEF(NULL, "resize-down", 1,
|
2012-07-14 02:21:29 +04:00
|
|
|
"Downscale threshold (buf %)");
|
2011-03-21 14:50:42 +03:00
|
|
|
static const struct arg_enum_list end_usage_enum[] = {
|
2012-07-14 02:21:29 +04:00
|
|
|
{"vbr", VPX_VBR},
|
|
|
|
{"cbr", VPX_CBR},
|
|
|
|
{"cq", VPX_CQ},
|
2013-08-30 03:21:44 +04:00
|
|
|
{"q", VPX_Q},
|
2012-07-14 02:21:29 +04:00
|
|
|
{NULL, 0}
|
2011-03-21 14:50:42 +03:00
|
|
|
};
|
|
|
|
static const arg_def_t end_usage = ARG_DEF_ENUM(NULL, "end-usage", 1,
|
2012-07-14 02:21:29 +04:00
|
|
|
"Rate control mode", end_usage_enum);
|
2010-05-18 19:58:33 +04:00
|
|
|
static const arg_def_t target_bitrate = ARG_DEF(NULL, "target-bitrate", 1,
|
2012-07-14 02:21:29 +04:00
|
|
|
"Bitrate (kbps)");
|
2010-05-18 19:58:33 +04:00
|
|
|
static const arg_def_t min_quantizer = ARG_DEF(NULL, "min-q", 1,
|
2012-07-14 02:21:29 +04:00
|
|
|
"Minimum (best) quantizer");
|
2010-05-18 19:58:33 +04:00
|
|
|
static const arg_def_t max_quantizer = ARG_DEF(NULL, "max-q", 1,
|
2012-07-14 02:21:29 +04:00
|
|
|
"Maximum (worst) quantizer");
|
2010-05-18 19:58:33 +04:00
|
|
|
static const arg_def_t undershoot_pct = ARG_DEF(NULL, "undershoot-pct", 1,
|
2012-07-14 02:21:29 +04:00
|
|
|
"Datarate undershoot (min) target (%)");
|
2010-05-18 19:58:33 +04:00
|
|
|
static const arg_def_t overshoot_pct = ARG_DEF(NULL, "overshoot-pct", 1,
|
2012-07-14 02:21:29 +04:00
|
|
|
"Datarate overshoot (max) target (%)");
|
2010-05-18 19:58:33 +04:00
|
|
|
static const arg_def_t buf_sz = ARG_DEF(NULL, "buf-sz", 1,
|
2012-07-14 02:21:29 +04:00
|
|
|
"Client buffer size (ms)");
|
2010-05-18 19:58:33 +04:00
|
|
|
static const arg_def_t buf_initial_sz = ARG_DEF(NULL, "buf-initial-sz", 1,
|
2012-07-14 02:21:29 +04:00
|
|
|
"Client initial buffer size (ms)");
|
2010-05-18 19:58:33 +04:00
|
|
|
static const arg_def_t buf_optimal_sz = ARG_DEF(NULL, "buf-optimal-sz", 1,
|
2012-07-14 02:21:29 +04:00
|
|
|
"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
|
2010-05-18 19:58:33 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
static const arg_def_t bias_pct = ARG_DEF(NULL, "bias-pct", 1,
|
2012-07-14 02:21:29 +04:00
|
|
|
"CBR/VBR bias (0=CBR, 100=VBR)");
|
2010-05-18 19:58:33 +04:00
|
|
|
static const arg_def_t minsection_pct = ARG_DEF(NULL, "minsection-pct", 1,
|
2012-07-14 02:21:29 +04:00
|
|
|
"GOP min bitrate (% of target)");
|
2010-05-18 19:58:33 +04:00
|
|
|
static const arg_def_t maxsection_pct = ARG_DEF(NULL, "maxsection-pct", 1,
|
2012-07-14 02:21:29 +04:00
|
|
|
"GOP max bitrate (% of target)");
|
|
|
|
static const arg_def_t *rc_twopass_args[] = {
|
|
|
|
&bias_pct, &minsection_pct, &maxsection_pct, NULL
|
2010-05-18 19:58:33 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
static const arg_def_t kf_min_dist = ARG_DEF(NULL, "kf-min-dist", 1,
|
2012-07-14 02:21:29 +04:00
|
|
|
"Minimum keyframe interval (frames)");
|
2010-05-18 19:58:33 +04:00
|
|
|
static const arg_def_t kf_max_dist = ARG_DEF(NULL, "kf-max-dist", 1,
|
2012-07-14 02:21:29 +04:00
|
|
|
"Maximum keyframe interval (frames)");
|
2010-06-24 16:41:51 +04:00
|
|
|
static const arg_def_t kf_disabled = ARG_DEF(NULL, "disable-kf", 0,
|
2012-07-14 02:21:29 +04:00
|
|
|
"Disable keyframe placement");
|
|
|
|
static const arg_def_t *kf_args[] = {
|
|
|
|
&kf_min_dist, &kf_max_dist, &kf_disabled, NULL
|
2010-05-18 19:58:33 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
static const arg_def_t noise_sens = ARG_DEF(NULL, "noise-sensitivity", 1,
|
2012-07-14 02:21:29 +04:00
|
|
|
"Noise sensitivity (frames to blur)");
|
2010-05-18 19:58:33 +04:00
|
|
|
static const arg_def_t sharpness = ARG_DEF(NULL, "sharpness", 1,
|
2012-07-14 02:21:29 +04:00
|
|
|
"Filter sharpness (0-7)");
|
2010-05-18 19:58:33 +04:00
|
|
|
static const arg_def_t static_thresh = ARG_DEF(NULL, "static-thresh", 1,
|
2012-07-14 02:21:29 +04:00
|
|
|
"Motion detection threshold");
|
2010-05-18 19:58:33 +04:00
|
|
|
static const arg_def_t cpu_used = ARG_DEF(NULL, "cpu-used", 1,
|
2012-07-14 02:21:29 +04:00
|
|
|
"CPU Used (-16..16)");
|
2010-05-18 19:58:33 +04:00
|
|
|
static const arg_def_t auto_altref = ARG_DEF(NULL, "auto-alt-ref", 1,
|
2012-07-14 02:21:29 +04:00
|
|
|
"Enable automatic alt reference frames");
|
2010-05-18 19:58:33 +04:00
|
|
|
static const arg_def_t arnr_maxframes = ARG_DEF(NULL, "arnr-maxframes", 1,
|
2012-07-14 02:21:29 +04:00
|
|
|
"AltRef Max Frames");
|
2010-05-18 19:58:33 +04:00
|
|
|
static const arg_def_t arnr_strength = ARG_DEF(NULL, "arnr-strength", 1,
|
2012-07-14 02:21:29 +04:00
|
|
|
"AltRef Strength");
|
2010-05-18 19:58:33 +04:00
|
|
|
static const arg_def_t arnr_type = ARG_DEF(NULL, "arnr-type", 1,
|
2012-07-14 02:21:29 +04:00
|
|
|
"AltRef Type");
|
2010-12-17 17:43:39 +03:00
|
|
|
static const struct arg_enum_list tuning_enum[] = {
|
2012-07-14 02:21:29 +04:00
|
|
|
{"psnr", VP8_TUNE_PSNR},
|
|
|
|
{"ssim", VP8_TUNE_SSIM},
|
|
|
|
{NULL, 0}
|
2010-12-17 17:43:39 +03:00
|
|
|
};
|
|
|
|
static const arg_def_t tune_ssim = ARG_DEF_ENUM(NULL, "tune", 1,
|
2012-07-14 02:21:29 +04:00
|
|
|
"Material to favor", tuning_enum);
|
2011-01-07 21:29:37 +03:00
|
|
|
static const arg_def_t cq_level = ARG_DEF(NULL, "cq-level", 1,
|
2013-08-30 03:21:44 +04:00
|
|
|
"Constant/Constrained Quality level");
|
2011-07-28 17:17:32 +04:00
|
|
|
static const arg_def_t max_intra_rate_pct = ARG_DEF(NULL, "max-intra-rate", 1,
|
2012-07-14 02:21:29 +04:00
|
|
|
"Max I-frame bitrate (pct)");
|
2010-05-18 19:58:33 +04:00
|
|
|
|
2012-11-09 05:09:30 +04:00
|
|
|
#if CONFIG_VP8_ENCODER
|
2014-01-15 05:56:45 +04:00
|
|
|
static const arg_def_t token_parts =
|
|
|
|
ARG_DEF(NULL, "token-parts", 1, "Number of token partitions to use, log2");
|
2012-07-14 02:21:29 +04:00
|
|
|
static const arg_def_t *vp8_args[] = {
|
|
|
|
&cpu_used, &auto_altref, &noise_sens, &sharpness, &static_thresh,
|
|
|
|
&token_parts, &arnr_maxframes, &arnr_strength, &arnr_type,
|
2012-11-06 00:37:14 +04:00
|
|
|
&tune_ssim, &cq_level, &max_intra_rate_pct,
|
2012-11-09 05:09:30 +04:00
|
|
|
NULL
|
2010-05-18 19:58:33 +04:00
|
|
|
};
|
2012-11-09 05:09:30 +04:00
|
|
|
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
|
2014-01-15 05:56:45 +04:00
|
|
|
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)");
|
|
|
|
|
2012-11-09 05:09:30 +04:00
|
|
|
static const arg_def_t *vp9_args[] = {
|
|
|
|
&cpu_used, &auto_altref, &noise_sens, &sharpness, &static_thresh,
|
2013-02-08 23:33:11 +04:00
|
|
|
&tile_cols, &tile_rows, &arnr_maxframes, &arnr_strength, &arnr_type,
|
2013-02-20 19:27:35 +04:00
|
|
|
&tune_ssim, &cq_level, &max_intra_rate_pct, &lossless,
|
2013-11-14 22:23:57 +04:00
|
|
|
&frame_parallel_decoding, &aq_mode,
|
2012-11-06 00:37:14 +04:00
|
|
|
NULL
|
2010-05-18 19:58:33 +04:00
|
|
|
};
|
2012-11-09 05:09:30 +04:00
|
|
|
static const int vp9_arg_ctrl_map[] = {
|
2012-07-14 02:21:29 +04:00
|
|
|
VP8E_SET_CPUUSED, VP8E_SET_ENABLEAUTOALTREF,
|
|
|
|
VP8E_SET_NOISE_SENSITIVITY, VP8E_SET_SHARPNESS, VP8E_SET_STATIC_THRESHOLD,
|
2013-02-08 23:33:11 +04:00
|
|
|
VP9E_SET_TILE_COLUMNS, VP9E_SET_TILE_ROWS,
|
2012-07-14 02:21:29 +04:00
|
|
|
VP8E_SET_ARNR_MAXFRAMES, VP8E_SET_ARNR_STRENGTH, VP8E_SET_ARNR_TYPE,
|
2012-11-06 00:37:14 +04:00
|
|
|
VP8E_SET_TUNING, VP8E_SET_CQ_LEVEL, VP8E_SET_MAX_INTRA_BITRATE_PCT,
|
2013-11-14 22:23:57 +04:00
|
|
|
VP9E_SET_LOSSLESS, VP9E_SET_FRAME_PARALLEL_DECODING, VP9E_SET_AQ_MODE,
|
2012-11-06 00:37:14 +04:00
|
|
|
0
|
2010-05-18 19:58:33 +04:00
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static const arg_def_t *no_args[] = { NULL };
|
|
|
|
|
2013-11-05 22:02:18 +04:00
|
|
|
void usage_exit() {
|
2012-07-14 02:21:29 +04:00
|
|
|
int i;
|
|
|
|
|
|
|
|
fprintf(stderr, "Usage: %s <options> -o dst_filename src_filename \n",
|
|
|
|
exec_name);
|
|
|
|
|
|
|
|
fprintf(stderr, "\nOptions:\n");
|
2013-06-25 20:15:07 +04:00
|
|
|
arg_show_usage(stderr, main_args);
|
2012-07-14 02:21:29 +04:00
|
|
|
fprintf(stderr, "\nEncoder Global Options:\n");
|
2013-06-25 20:15:07 +04:00
|
|
|
arg_show_usage(stderr, global_args);
|
2012-07-14 02:21:29 +04:00
|
|
|
fprintf(stderr, "\nRate Control Options:\n");
|
2013-06-25 20:15:07 +04:00
|
|
|
arg_show_usage(stderr, rc_args);
|
2012-07-14 02:21:29 +04:00
|
|
|
fprintf(stderr, "\nTwopass Rate Control Options:\n");
|
2013-06-25 20:15:07 +04:00
|
|
|
arg_show_usage(stderr, rc_twopass_args);
|
2012-07-14 02:21:29 +04:00
|
|
|
fprintf(stderr, "\nKeyframe Placement Options:\n");
|
2013-06-25 20:15:07 +04:00
|
|
|
arg_show_usage(stderr, kf_args);
|
2010-05-18 19:58:33 +04:00
|
|
|
#if CONFIG_VP8_ENCODER
|
2012-07-14 02:21:29 +04:00
|
|
|
fprintf(stderr, "\nVP8 Specific Options:\n");
|
2013-06-25 20:15:07 +04:00
|
|
|
arg_show_usage(stderr, vp8_args);
|
2010-05-18 19:58:33 +04:00
|
|
|
#endif
|
2012-11-09 05:09:30 +04:00
|
|
|
#if CONFIG_VP9_ENCODER
|
|
|
|
fprintf(stderr, "\nVP9 Specific Options:\n");
|
2013-06-25 20:15:07 +04:00
|
|
|
arg_show_usage(stderr, vp9_args);
|
2010-05-18 19:58:33 +04:00
|
|
|
#endif
|
2012-07-14 02:21:29 +04:00
|
|
|
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,
|
2012-07-23 23:32:59 +04:00
|
|
|
vpx_codec_iface_name(codecs[i].iface()));
|
2012-07-14 02:21:29 +04:00
|
|
|
|
|
|
|
exit(EXIT_FAILURE);
|
2010-05-18 19:58:33 +04:00
|
|
|
}
|
|
|
|
|
2012-11-16 03:14:38 +04:00
|
|
|
#define mmin(a, b) ((a) < (b) ? (a) : (b))
|
2014-02-01 03:49:17 +04:00
|
|
|
static void find_mismatch(const vpx_image_t *const img1,
|
|
|
|
const vpx_image_t *const img2,
|
2013-04-06 21:00:53 +04:00
|
|
|
int yloc[4], int uloc[4], int vloc[4]) {
|
2014-02-01 04:10:43 +04:00
|
|
|
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;
|
Implicit weighted prediction experiment
Adds an experiment to use a weighted prediction of two INTER
predictors, where the weight is one of (1/4, 3/4), (3/8, 5/8),
(1/2, 1/2), (5/8, 3/8) or (3/4, 1/4), and is chosen implicitly
based on consistency of the predictors to the already
reconstructed pixels to the top and left of the current macroblock
or superblock.
Currently the weighting is not applied to SPLITMV modes, which
default to the usual (1/2, 1/2) weighting. However the code is in
place controlled by a macro. The same weighting is used for Y and
UV components, where the weight is derived from analyzing the Y
component only.
Results (over compound inter-intra experiment)
derf: +0.18%
yt: +0.34%
hd: +0.49%
stdhd: +0.23%
The experiment suggests bigger benefit for explicitly signaled weights.
Change-Id: I5438539ff4485c5752874cd1eb078ff14bf5235a
2013-03-13 01:21:08 +04:00
|
|
|
yloc[0] = yloc[1] = yloc[2] = yloc[3] = -1;
|
2013-01-15 18:43:35 +04:00
|
|
|
for (i = 0, match = 1; match && i < img1->d_h; i += bsize) {
|
|
|
|
for (j = 0; match && j < img1->d_w; j += bsize) {
|
2012-11-16 03:14:38 +04:00
|
|
|
int k, l;
|
2014-02-01 03:49:17 +04:00
|
|
|
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) {
|
2012-11-16 03:14:38 +04:00
|
|
|
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;
|
Implicit weighted prediction experiment
Adds an experiment to use a weighted prediction of two INTER
predictors, where the weight is one of (1/4, 3/4), (3/8, 5/8),
(1/2, 1/2), (5/8, 3/8) or (3/4, 1/4), and is chosen implicitly
based on consistency of the predictors to the already
reconstructed pixels to the top and left of the current macroblock
or superblock.
Currently the weighting is not applied to SPLITMV modes, which
default to the usual (1/2, 1/2) weighting. However the code is in
place controlled by a macro. The same weighting is used for Y and
UV components, where the weight is derived from analyzing the Y
component only.
Results (over compound inter-intra experiment)
derf: +0.18%
yt: +0.34%
hd: +0.49%
stdhd: +0.23%
The experiment suggests bigger benefit for explicitly signaled weights.
Change-Id: I5438539ff4485c5752874cd1eb078ff14bf5235a
2013-03-13 01:21:08 +04:00
|
|
|
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);
|
2012-11-16 03:14:38 +04:00
|
|
|
match = 0;
|
2011-06-22 00:42:33 +04:00
|
|
|
break;
|
2012-11-16 03:14:38 +04:00
|
|
|
}
|
|
|
|
}
|
2014-02-01 03:49:17 +04:00
|
|
|
}
|
2011-06-22 00:42:33 +04:00
|
|
|
}
|
2012-11-16 03:14:38 +04:00
|
|
|
}
|
2013-04-06 21:00:53 +04:00
|
|
|
|
Implicit weighted prediction experiment
Adds an experiment to use a weighted prediction of two INTER
predictors, where the weight is one of (1/4, 3/4), (3/8, 5/8),
(1/2, 1/2), (5/8, 3/8) or (3/4, 1/4), and is chosen implicitly
based on consistency of the predictors to the already
reconstructed pixels to the top and left of the current macroblock
or superblock.
Currently the weighting is not applied to SPLITMV modes, which
default to the usual (1/2, 1/2) weighting. However the code is in
place controlled by a macro. The same weighting is used for Y and
UV components, where the weight is derived from analyzing the Y
component only.
Results (over compound inter-intra experiment)
derf: +0.18%
yt: +0.34%
hd: +0.49%
stdhd: +0.23%
The experiment suggests bigger benefit for explicitly signaled weights.
Change-Id: I5438539ff4485c5752874cd1eb078ff14bf5235a
2013-03-13 01:21:08 +04:00
|
|
|
uloc[0] = uloc[1] = uloc[2] = uloc[3] = -1;
|
2013-05-09 03:07:38 +04:00
|
|
|
for (i = 0, match = 1; match && i < c_h; i += bsizey) {
|
2013-06-11 22:28:08 +04:00
|
|
|
for (j = 0; match && j < c_w; j += bsizex) {
|
2012-11-16 03:14:38 +04:00
|
|
|
int k, l;
|
2014-02-01 03:49:17 +04:00
|
|
|
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) {
|
2012-11-16 03:14:38 +04:00
|
|
|
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;
|
Implicit weighted prediction experiment
Adds an experiment to use a weighted prediction of two INTER
predictors, where the weight is one of (1/4, 3/4), (3/8, 5/8),
(1/2, 1/2), (5/8, 3/8) or (3/4, 1/4), and is chosen implicitly
based on consistency of the predictors to the already
reconstructed pixels to the top and left of the current macroblock
or superblock.
Currently the weighting is not applied to SPLITMV modes, which
default to the usual (1/2, 1/2) weighting. However the code is in
place controlled by a macro. The same weighting is used for Y and
UV components, where the weight is derived from analyzing the Y
component only.
Results (over compound inter-intra experiment)
derf: +0.18%
yt: +0.34%
hd: +0.49%
stdhd: +0.23%
The experiment suggests bigger benefit for explicitly signaled weights.
Change-Id: I5438539ff4485c5752874cd1eb078ff14bf5235a
2013-03-13 01:21:08 +04:00
|
|
|
uloc[2] = *(img1->planes[VPX_PLANE_U] +
|
|
|
|
(i + k) * img1->stride[VPX_PLANE_U] + j + l);
|
|
|
|
uloc[3] = *(img2->planes[VPX_PLANE_U] +
|
2014-02-01 03:49:17 +04:00
|
|
|
(i + k) * img2->stride[VPX_PLANE_U] + j + l);
|
2012-11-16 03:14:38 +04:00
|
|
|
match = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2014-02-01 03:49:17 +04:00
|
|
|
}
|
2012-11-16 03:14:38 +04:00
|
|
|
}
|
|
|
|
}
|
Implicit weighted prediction experiment
Adds an experiment to use a weighted prediction of two INTER
predictors, where the weight is one of (1/4, 3/4), (3/8, 5/8),
(1/2, 1/2), (5/8, 3/8) or (3/4, 1/4), and is chosen implicitly
based on consistency of the predictors to the already
reconstructed pixels to the top and left of the current macroblock
or superblock.
Currently the weighting is not applied to SPLITMV modes, which
default to the usual (1/2, 1/2) weighting. However the code is in
place controlled by a macro. The same weighting is used for Y and
UV components, where the weight is derived from analyzing the Y
component only.
Results (over compound inter-intra experiment)
derf: +0.18%
yt: +0.34%
hd: +0.49%
stdhd: +0.23%
The experiment suggests bigger benefit for explicitly signaled weights.
Change-Id: I5438539ff4485c5752874cd1eb078ff14bf5235a
2013-03-13 01:21:08 +04:00
|
|
|
vloc[0] = vloc[1] = vloc[2] = vloc[3] = -1;
|
2013-05-09 03:07:38 +04:00
|
|
|
for (i = 0, match = 1; match && i < c_h; i += bsizey) {
|
2013-06-11 22:28:08 +04:00
|
|
|
for (j = 0; match && j < c_w; j += bsizex) {
|
2012-11-16 03:14:38 +04:00
|
|
|
int k, l;
|
2014-02-01 03:49:17 +04:00
|
|
|
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) {
|
2012-11-16 03:14:38 +04:00
|
|
|
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;
|
Implicit weighted prediction experiment
Adds an experiment to use a weighted prediction of two INTER
predictors, where the weight is one of (1/4, 3/4), (3/8, 5/8),
(1/2, 1/2), (5/8, 3/8) or (3/4, 1/4), and is chosen implicitly
based on consistency of the predictors to the already
reconstructed pixels to the top and left of the current macroblock
or superblock.
Currently the weighting is not applied to SPLITMV modes, which
default to the usual (1/2, 1/2) weighting. However the code is in
place controlled by a macro. The same weighting is used for Y and
UV components, where the weight is derived from analyzing the Y
component only.
Results (over compound inter-intra experiment)
derf: +0.18%
yt: +0.34%
hd: +0.49%
stdhd: +0.23%
The experiment suggests bigger benefit for explicitly signaled weights.
Change-Id: I5438539ff4485c5752874cd1eb078ff14bf5235a
2013-03-13 01:21:08 +04:00
|
|
|
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);
|
2012-11-16 03:14:38 +04:00
|
|
|
match = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2014-02-01 03:49:17 +04:00
|
|
|
}
|
2012-11-16 03:14:38 +04:00
|
|
|
}
|
|
|
|
}
|
2011-06-22 00:42:33 +04:00
|
|
|
}
|
|
|
|
|
2014-02-01 03:49:17 +04:00
|
|
|
static int compare_img(const vpx_image_t *const img1,
|
|
|
|
const vpx_image_t *const img2) {
|
2014-02-01 04:10:43 +04:00
|
|
|
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;
|
2012-07-14 02:21:29 +04:00
|
|
|
int match = 1;
|
2011-06-22 00:42:33 +04:00
|
|
|
|
2012-07-14 02:21:29 +04:00
|
|
|
match &= (img1->fmt == img2->fmt);
|
2014-01-23 02:58:59 +04:00
|
|
|
match &= (img1->d_w == img2->d_w);
|
|
|
|
match &= (img1->d_h == img2->d_h);
|
2012-03-08 00:25:50 +04:00
|
|
|
|
2014-02-01 03:49:17 +04:00
|
|
|
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],
|
2012-07-14 02:21:29 +04:00
|
|
|
img1->d_w) == 0);
|
2011-06-22 00:42:33 +04:00
|
|
|
|
2014-02-01 03:49:17 +04:00
|
|
|
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],
|
2013-05-09 03:07:38 +04:00
|
|
|
c_w) == 0);
|
2012-03-08 00:25:50 +04:00
|
|
|
|
2014-02-01 03:49:17 +04:00
|
|
|
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],
|
2013-05-09 03:07:38 +04:00
|
|
|
c_w) == 0);
|
2012-03-08 00:25:50 +04:00
|
|
|
|
2012-07-14 02:21:29 +04:00
|
|
|
return match;
|
2011-06-22 00:42:33 +04:00
|
|
|
}
|
|
|
|
|
2012-03-08 00:25:50 +04:00
|
|
|
|
2011-11-28 23:09:35 +04:00
|
|
|
#define NELEMENTS(x) (sizeof(x)/sizeof(x[0]))
|
2012-11-09 05:09:30 +04:00
|
|
|
#define MAX(x,y) ((x)>(y)?(x):(y))
|
|
|
|
#if CONFIG_VP8_ENCODER && !CONFIG_VP9_ENCODER
|
2011-11-28 23:09:35 +04:00
|
|
|
#define ARG_CTRL_CNT_MAX NELEMENTS(vp8_arg_ctrl_map)
|
2012-11-09 05:09:30 +04:00
|
|
|
#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
|
2010-05-18 19:58:33 +04:00
|
|
|
|
2012-02-16 00:39:38 +04:00
|
|
|
/* Per-stream configuration */
|
2012-11-07 00:02:42 +04:00
|
|
|
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;
|
2012-02-16 00:39:38 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
struct stream_state {
|
|
|
|
int index;
|
|
|
|
struct stream_state *next;
|
|
|
|
struct stream_config config;
|
|
|
|
FILE *file;
|
2014-01-30 00:28:29 +04:00
|
|
|
struct rate_hist *rate_hist;
|
2013-11-05 22:02:18 +04:00
|
|
|
struct EbmlGlobal ebml;
|
2012-11-07 00:02:42 +04:00
|
|
|
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;
|
2012-03-02 00:50:40 +04:00
|
|
|
struct vpx_image *img;
|
2012-11-07 00:02:42 +04:00
|
|
|
vpx_codec_ctx_t decoder;
|
|
|
|
int mismatch_seen;
|
2012-02-16 00:39:38 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2012-04-26 04:08:56 +04:00
|
|
|
void validate_positive_rational(const char *msg,
|
2012-11-07 00:02:42 +04:00
|
|
|
struct vpx_rational *rat) {
|
|
|
|
if (rat->den < 0) {
|
|
|
|
rat->num *= -1;
|
|
|
|
rat->den *= -1;
|
|
|
|
}
|
2012-04-26 04:08:56 +04:00
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
if (rat->num < 0)
|
|
|
|
die("Error: %s must be positive\n", msg);
|
2012-04-26 04:08:56 +04:00
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
if (!rat->den)
|
|
|
|
die("Error: %s has zero denominator\n", msg);
|
2012-04-26 04:08:56 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-11-22 04:46:40 +04:00
|
|
|
static void parse_global_config(struct VpxEncoderConfig *global, char **argv) {
|
2012-11-07 00:02:42 +04:00
|
|
|
char **argi, **argj;
|
|
|
|
struct arg arg;
|
|
|
|
|
|
|
|
/* Initialize default parameters */
|
|
|
|
memset(global, 0, sizeof(*global));
|
|
|
|
global->codec = codecs;
|
2013-08-20 01:16:26 +04:00
|
|
|
global->passes = 0;
|
2012-11-07 00:02:42 +04:00
|
|
|
global->use_i420 = 1;
|
2013-08-20 01:16:26 +04:00
|
|
|
/* Assign default deadline to good quality */
|
|
|
|
global->deadline = VPX_DL_GOOD_QUALITY;
|
2012-07-14 02:21:29 +04:00
|
|
|
|
|
|
|
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)
|
2012-11-07 00:02:42 +04:00
|
|
|
global->codec = codecs + k;
|
2012-07-14 02:21:29 +04:00
|
|
|
else
|
|
|
|
die("Error: Unrecognized argument (%s) to --codec\n",
|
|
|
|
arg.val);
|
|
|
|
|
|
|
|
} else if (arg_match(&arg, &passes, argi)) {
|
2012-11-07 00:02:42 +04:00
|
|
|
global->passes = arg_parse_uint(&arg);
|
2012-07-14 02:21:29 +04:00
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
if (global->passes < 1 || global->passes > 2)
|
|
|
|
die("Error: Invalid number of passes (%d)\n", global->passes);
|
2012-07-14 02:21:29 +04:00
|
|
|
} else if (arg_match(&arg, &pass_arg, argi)) {
|
2012-11-07 00:02:42 +04:00
|
|
|
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);
|
2012-07-14 02:21:29 +04:00
|
|
|
else if (arg_match(&arg, &deadline, argi))
|
2012-11-07 00:02:42 +04:00
|
|
|
global->deadline = arg_parse_uint(&arg);
|
2012-07-14 02:21:29 +04:00
|
|
|
else if (arg_match(&arg, &best_dl, argi))
|
2012-11-07 00:02:42 +04:00
|
|
|
global->deadline = VPX_DL_BEST_QUALITY;
|
2012-07-14 02:21:29 +04:00
|
|
|
else if (arg_match(&arg, &good_dl, argi))
|
2012-11-07 00:02:42 +04:00
|
|
|
global->deadline = VPX_DL_GOOD_QUALITY;
|
2012-07-14 02:21:29 +04:00
|
|
|
else if (arg_match(&arg, &rt_dl, argi))
|
2012-11-07 00:02:42 +04:00
|
|
|
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;
|
2012-07-14 02:21:29 +04:00
|
|
|
else if (arg_match(&arg, &limit, argi))
|
2012-11-07 00:02:42 +04:00
|
|
|
global->limit = arg_parse_uint(&arg);
|
2012-07-14 02:21:29 +04:00
|
|
|
else if (arg_match(&arg, &skip, argi))
|
2012-11-07 00:02:42 +04:00
|
|
|
global->skip_frames = arg_parse_uint(&arg);
|
2012-07-14 02:21:29 +04:00
|
|
|
else if (arg_match(&arg, &psnrarg, argi))
|
2012-11-07 00:02:42 +04:00
|
|
|
global->show_psnr = 1;
|
2012-07-14 02:21:29 +04:00
|
|
|
else if (arg_match(&arg, &recontest, argi))
|
2013-02-16 04:31:02 +04:00
|
|
|
global->test_decode = arg_parse_enum_or_int(&arg);
|
2012-07-14 02:21:29 +04:00
|
|
|
else if (arg_match(&arg, &framerate, argi)) {
|
2012-11-07 00:02:42 +04:00
|
|
|
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;
|
2012-07-14 02:21:29 +04:00
|
|
|
else if (arg_match(&arg, &debugmode, argi))
|
2012-11-07 00:02:42 +04:00
|
|
|
global->debug = 1;
|
2012-07-14 02:21:29 +04:00
|
|
|
else if (arg_match(&arg, &q_hist_n, argi))
|
2012-11-07 00:02:42 +04:00
|
|
|
global->show_q_hist_buckets = arg_parse_uint(&arg);
|
2012-07-14 02:21:29 +04:00
|
|
|
else if (arg_match(&arg, &rate_hist_n, argi))
|
2012-11-07 00:02:42 +04:00
|
|
|
global->show_rate_hist_buckets = arg_parse_uint(&arg);
|
2013-11-26 00:05:19 +04:00
|
|
|
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;
|
2012-07-14 02:21:29 +04:00
|
|
|
else
|
|
|
|
argj++;
|
|
|
|
}
|
2010-05-18 19:58:33 +04:00
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
/* Validate global config */
|
2013-08-20 01:16:26 +04:00
|
|
|
if (global->passes == 0) {
|
2013-09-18 05:47:25 +04:00
|
|
|
#if CONFIG_VP9_ENCODER
|
2013-08-20 01:16:26 +04:00
|
|
|
// 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);
|
2013-09-18 05:47:25 +04:00
|
|
|
#else
|
|
|
|
global->passes = 1;
|
|
|
|
#endif
|
2013-08-20 01:16:26 +04:00
|
|
|
}
|
2012-02-14 04:52:18 +04:00
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
if (global->pass) {
|
2012-07-14 02:21:29 +04:00
|
|
|
/* DWIM: Assume the user meant passes=2 if pass=2 is specified */
|
2012-11-07 00:02:42 +04:00
|
|
|
if (global->pass > global->passes) {
|
|
|
|
warn("Assuming --pass=%d implies --passes=%d\n",
|
|
|
|
global->pass, global->pass);
|
|
|
|
global->passes = global->pass;
|
2010-05-18 19:58:33 +04:00
|
|
|
}
|
2012-11-07 00:02:42 +04:00
|
|
|
}
|
2012-02-14 04:52:18 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-11-15 00:37:42 +04:00
|
|
|
void open_input_file(struct VpxInputContext *input) {
|
2012-11-07 00:02:42 +04:00
|
|
|
/* Parse certain options from the input file, if possible */
|
2013-11-15 00:37:42 +04:00
|
|
|
input->file = strcmp(input->filename, "-")
|
|
|
|
? fopen(input->filename, "rb") : set_binary_mode(stdin);
|
2012-11-07 00:02:42 +04:00
|
|
|
|
|
|
|
if (!input->file)
|
|
|
|
fatal("Failed to open input file");
|
2010-05-18 19:58:33 +04:00
|
|
|
|
2013-02-13 09:17:56 +04:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
/* 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
|
2014-01-07 04:29:09 +04:00
|
|
|
&& file_is_y4m(input->detect.buf)) {
|
2013-05-06 22:01:35 +04:00
|
|
|
if (y4m_input_open(&input->y4m, input->file, input->detect.buf, 4,
|
|
|
|
input->only_i420) >= 0) {
|
2012-11-07 00:02:42 +04:00
|
|
|
input->file_type = FILE_TYPE_Y4M;
|
2013-11-15 00:37:42 +04:00
|
|
|
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;
|
2012-11-07 00:02:42 +04:00
|
|
|
input->use_i420 = 0;
|
|
|
|
} else
|
|
|
|
fatal("Unsupported Y4M stream.");
|
2014-01-07 04:29:09 +04:00
|
|
|
} else if (input->detect.buf_read == 4 && fourcc_is_ivf(input->detect.buf)) {
|
2013-11-08 23:32:23 +04:00
|
|
|
fatal("IVF is not supported as input.");
|
2012-11-07 00:02:42 +04:00
|
|
|
} else {
|
|
|
|
input->file_type = FILE_TYPE_RAW;
|
2012-07-14 02:21:29 +04:00
|
|
|
}
|
2012-02-15 00:30:17 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-11-15 00:37:42 +04:00
|
|
|
static void close_input_file(struct VpxInputContext *input) {
|
2012-11-07 00:02:42 +04:00
|
|
|
fclose(input->file);
|
|
|
|
if (input->file_type == FILE_TYPE_Y4M)
|
|
|
|
y4m_input_close(&input->y4m);
|
2012-02-15 00:30:17 +04:00
|
|
|
}
|
|
|
|
|
2013-11-22 04:46:40 +04:00
|
|
|
static struct stream_state *new_stream(struct VpxEncoderConfig *global,
|
2013-11-08 23:32:23 +04:00
|
|
|
struct stream_state *prev) {
|
2012-11-07 00:02:42 +04:00
|
|
|
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));
|
2010-05-18 19:58:33 +04:00
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
/* 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;
|
2012-02-14 04:52:18 +04:00
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
/* 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;
|
2010-05-18 19:58:33 +04:00
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
/* Initialize remaining stream parameters */
|
|
|
|
stream->config.stereo_fmt = STEREO_FORMAT_MONO;
|
|
|
|
stream->config.write_webm = 1;
|
|
|
|
stream->ebml.last_pts_ms = -1;
|
2010-05-18 19:58:33 +04:00
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
/* Allows removal of the application version from the EBML tags */
|
|
|
|
stream->ebml.debug = global->debug;
|
2012-07-14 02:21:29 +04:00
|
|
|
}
|
2010-05-18 19:58:33 +04:00
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
/* Output files must be specified for each stream */
|
|
|
|
stream->config.out_fn = NULL;
|
2010-05-18 19:58:33 +04:00
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
stream->next = NULL;
|
|
|
|
return stream;
|
2012-02-16 00:39:38 +04:00
|
|
|
}
|
2010-05-18 19:58:33 +04:00
|
|
|
|
2010-10-06 20:51:00 +04:00
|
|
|
|
2013-11-22 04:46:40 +04:00
|
|
|
static int parse_stream_params(struct VpxEncoderConfig *global,
|
2012-02-16 00:39:38 +04:00
|
|
|
struct stream_state *stream,
|
2012-11-07 00:02:42 +04:00
|
|
|
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 */
|
2012-11-09 05:09:30 +04:00
|
|
|
if (0) {
|
|
|
|
#if CONFIG_VP8_ENCODER
|
|
|
|
} else if (global->codec->iface == vpx_codec_vp8_cx) {
|
2012-11-07 00:02:42 +04:00
|
|
|
ctrl_args = vp8_args;
|
|
|
|
ctrl_args_map = vp8_arg_ctrl_map;
|
2012-11-09 05:09:30 +04:00
|
|
|
#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
|
2012-11-07 00:02:42 +04:00
|
|
|
}
|
2012-02-16 00:39:38 +04:00
|
|
|
|
2012-07-14 02:21:29 +04:00
|
|
|
for (argi = argj = argv; (*argj = *argi); argi += arg.argv_step) {
|
|
|
|
arg.argv_step = 1;
|
2010-05-18 19:58:33 +04:00
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
/* 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;
|
|
|
|
}
|
2010-05-18 19:58:33 +04:00
|
|
|
|
2012-07-14 02:21:29 +04:00
|
|
|
if (0);
|
2012-11-07 00:02:42 +04:00
|
|
|
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;
|
2012-07-14 02:21:29 +04:00
|
|
|
else if (arg_match(&arg, &threads, argi))
|
2012-11-07 00:02:42 +04:00
|
|
|
config->cfg.g_threads = arg_parse_uint(&arg);
|
2012-07-14 02:21:29 +04:00
|
|
|
else if (arg_match(&arg, &profile, argi))
|
2012-11-07 00:02:42 +04:00
|
|
|
config->cfg.g_profile = arg_parse_uint(&arg);
|
2012-07-14 02:21:29 +04:00
|
|
|
else if (arg_match(&arg, &width, argi))
|
2012-11-07 00:02:42 +04:00
|
|
|
config->cfg.g_w = arg_parse_uint(&arg);
|
2012-07-14 02:21:29 +04:00
|
|
|
else if (arg_match(&arg, &height, argi))
|
2012-11-07 00:02:42 +04:00
|
|
|
config->cfg.g_h = arg_parse_uint(&arg);
|
2012-07-14 02:21:29 +04:00
|
|
|
else if (arg_match(&arg, &stereo_mode, argi))
|
2012-11-07 00:02:42 +04:00
|
|
|
config->stereo_fmt = arg_parse_enum_or_int(&arg);
|
|
|
|
else if (arg_match(&arg, &timebase, argi)) {
|
|
|
|
config->cfg.g_timebase = arg_parse_rational(&arg);
|
|
|
|
validate_positive_rational(arg.name, &config->cfg.g_timebase);
|
|
|
|
} else if (arg_match(&arg, &error_resilient, argi))
|
|
|
|
config->cfg.g_error_resilient = arg_parse_uint(&arg);
|
2012-07-14 02:21:29 +04:00
|
|
|
else if (arg_match(&arg, &lag_in_frames, argi))
|
2012-11-07 00:02:42 +04:00
|
|
|
config->cfg.g_lag_in_frames = arg_parse_uint(&arg);
|
2012-07-14 02:21:29 +04:00
|
|
|
else if (arg_match(&arg, &dropframe_thresh, argi))
|
2012-11-07 00:02:42 +04:00
|
|
|
config->cfg.rc_dropframe_thresh = arg_parse_uint(&arg);
|
2012-07-14 02:21:29 +04:00
|
|
|
else if (arg_match(&arg, &resize_allowed, argi))
|
2012-11-07 00:02:42 +04:00
|
|
|
config->cfg.rc_resize_allowed = arg_parse_uint(&arg);
|
2012-07-14 02:21:29 +04:00
|
|
|
else if (arg_match(&arg, &resize_up_thresh, argi))
|
2012-11-07 00:02:42 +04:00
|
|
|
config->cfg.rc_resize_up_thresh = arg_parse_uint(&arg);
|
2012-07-14 02:21:29 +04:00
|
|
|
else if (arg_match(&arg, &resize_down_thresh, argi))
|
2012-11-07 00:02:42 +04:00
|
|
|
config->cfg.rc_resize_down_thresh = arg_parse_uint(&arg);
|
2012-07-14 02:21:29 +04:00
|
|
|
else if (arg_match(&arg, &end_usage, argi))
|
2012-11-07 00:02:42 +04:00
|
|
|
config->cfg.rc_end_usage = arg_parse_enum_or_int(&arg);
|
2012-07-14 02:21:29 +04:00
|
|
|
else if (arg_match(&arg, &target_bitrate, argi))
|
2012-11-07 00:02:42 +04:00
|
|
|
config->cfg.rc_target_bitrate = arg_parse_uint(&arg);
|
2012-07-14 02:21:29 +04:00
|
|
|
else if (arg_match(&arg, &min_quantizer, argi))
|
2012-11-07 00:02:42 +04:00
|
|
|
config->cfg.rc_min_quantizer = arg_parse_uint(&arg);
|
2012-07-14 02:21:29 +04:00
|
|
|
else if (arg_match(&arg, &max_quantizer, argi))
|
2012-11-07 00:02:42 +04:00
|
|
|
config->cfg.rc_max_quantizer = arg_parse_uint(&arg);
|
2012-07-14 02:21:29 +04:00
|
|
|
else if (arg_match(&arg, &undershoot_pct, argi))
|
2012-11-07 00:02:42 +04:00
|
|
|
config->cfg.rc_undershoot_pct = arg_parse_uint(&arg);
|
2012-07-14 02:21:29 +04:00
|
|
|
else if (arg_match(&arg, &overshoot_pct, argi))
|
2012-11-07 00:02:42 +04:00
|
|
|
config->cfg.rc_overshoot_pct = arg_parse_uint(&arg);
|
2012-07-14 02:21:29 +04:00
|
|
|
else if (arg_match(&arg, &buf_sz, argi))
|
2012-11-07 00:02:42 +04:00
|
|
|
config->cfg.rc_buf_sz = arg_parse_uint(&arg);
|
2012-07-14 02:21:29 +04:00
|
|
|
else if (arg_match(&arg, &buf_initial_sz, argi))
|
2012-11-07 00:02:42 +04:00
|
|
|
config->cfg.rc_buf_initial_sz = arg_parse_uint(&arg);
|
2012-07-14 02:21:29 +04:00
|
|
|
else if (arg_match(&arg, &buf_optimal_sz, argi))
|
2012-11-07 00:02:42 +04:00
|
|
|
config->cfg.rc_buf_optimal_sz = arg_parse_uint(&arg);
|
2012-07-14 02:21:29 +04:00
|
|
|
else if (arg_match(&arg, &bias_pct, argi)) {
|
2012-11-07 00:02:42 +04:00
|
|
|
config->cfg.rc_2pass_vbr_bias_pct = arg_parse_uint(&arg);
|
2012-07-14 02:21:29 +04:00
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
if (global->passes < 2)
|
|
|
|
warn("option %s ignored in one-pass mode.\n", arg.name);
|
2012-07-14 02:21:29 +04:00
|
|
|
} else if (arg_match(&arg, &minsection_pct, argi)) {
|
2012-11-07 00:02:42 +04:00
|
|
|
config->cfg.rc_2pass_vbr_minsection_pct = arg_parse_uint(&arg);
|
2010-05-18 19:58:33 +04:00
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
if (global->passes < 2)
|
|
|
|
warn("option %s ignored in one-pass mode.\n", arg.name);
|
2012-07-14 02:21:29 +04:00
|
|
|
} else if (arg_match(&arg, &maxsection_pct, argi)) {
|
2012-11-07 00:02:42 +04:00
|
|
|
config->cfg.rc_2pass_vbr_maxsection_pct = arg_parse_uint(&arg);
|
2010-05-18 19:58:33 +04:00
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
if (global->passes < 2)
|
|
|
|
warn("option %s ignored in one-pass mode.\n", arg.name);
|
2012-07-14 02:21:29 +04:00
|
|
|
} else if (arg_match(&arg, &kf_min_dist, argi))
|
2012-11-07 00:02:42 +04:00
|
|
|
config->cfg.kf_min_dist = arg_parse_uint(&arg);
|
|
|
|
else if (arg_match(&arg, &kf_max_dist, argi)) {
|
|
|
|
config->cfg.kf_max_dist = arg_parse_uint(&arg);
|
|
|
|
config->have_kf_max_dist = 1;
|
|
|
|
} else if (arg_match(&arg, &kf_disabled, argi))
|
|
|
|
config->cfg.kf_mode = VPX_KF_DISABLED;
|
|
|
|
else {
|
|
|
|
int i, match = 0;
|
|
|
|
|
|
|
|
for (i = 0; ctrl_args[i]; i++) {
|
|
|
|
if (arg_match(&arg, ctrl_args[i], argi)) {
|
|
|
|
int j;
|
|
|
|
match = 1;
|
|
|
|
|
|
|
|
/* Point either to the next free element or the first
|
|
|
|
* instance of this control.
|
|
|
|
*/
|
|
|
|
for (j = 0; j < config->arg_ctrl_cnt; j++)
|
|
|
|
if (config->arg_ctrls[j][0] == ctrl_args_map[i])
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* Update/insert */
|
|
|
|
assert(j < ARG_CTRL_CNT_MAX);
|
|
|
|
if (j < ARG_CTRL_CNT_MAX) {
|
|
|
|
config->arg_ctrls[j][0] = ctrl_args_map[i];
|
|
|
|
config->arg_ctrls[j][1] = arg_parse_enum_or_int(&arg);
|
|
|
|
if (j == config->arg_ctrl_cnt)
|
|
|
|
config->arg_ctrl_cnt++;
|
|
|
|
}
|
2010-05-18 19:58:33 +04:00
|
|
|
|
|
|
|
}
|
2012-11-07 00:02:42 +04:00
|
|
|
}
|
2012-02-16 00:39:38 +04:00
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
if (!match)
|
|
|
|
argj++;
|
2010-05-18 19:58:33 +04:00
|
|
|
}
|
2012-07-14 02:21:29 +04:00
|
|
|
}
|
2010-05-18 19:58:33 +04:00
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
return eos_mark_found;
|
2012-02-16 00:39:38 +04:00
|
|
|
}
|
2010-05-18 19:58:33 +04:00
|
|
|
|
2012-02-16 00:39:38 +04:00
|
|
|
|
2013-11-21 05:18:28 +04:00
|
|
|
#define FOREACH_STREAM(func) \
|
|
|
|
do { \
|
|
|
|
struct stream_state *stream; \
|
2013-11-26 00:05:19 +04:00
|
|
|
for (stream = streams; stream; stream = stream->next) { \
|
2013-11-21 05:18:28 +04:00
|
|
|
func; \
|
|
|
|
} \
|
|
|
|
} while (0)
|
2012-11-07 00:02:42 +04:00
|
|
|
|
|
|
|
|
|
|
|
static void validate_stream_config(struct stream_state *stream) {
|
|
|
|
struct stream_state *streami;
|
|
|
|
|
|
|
|
if (!stream->config.cfg.g_w || !stream->config.cfg.g_h)
|
|
|
|
fatal("Stream %d: Specify stream dimensions with --width (-w) "
|
|
|
|
" and --height (-h)", stream->index);
|
|
|
|
|
|
|
|
for (streami = stream; streami; streami = streami->next) {
|
|
|
|
/* All streams require output files */
|
|
|
|
if (!streami->config.out_fn)
|
|
|
|
fatal("Stream %d: Output file is required (specify with -o)",
|
|
|
|
streami->index);
|
|
|
|
|
|
|
|
/* Check for two streams outputting to the same file */
|
|
|
|
if (streami != stream) {
|
|
|
|
const char *a = stream->config.out_fn;
|
|
|
|
const char *b = streami->config.out_fn;
|
|
|
|
if (!strcmp(a, b) && strcmp(a, "/dev/null") && strcmp(a, ":nul"))
|
|
|
|
fatal("Stream %d: duplicate output file (from stream %d)",
|
|
|
|
streami->index, stream->index);
|
|
|
|
}
|
2012-02-16 00:39:38 +04:00
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
/* Check for two streams sharing a stats file. */
|
|
|
|
if (streami != stream) {
|
|
|
|
const char *a = stream->config.stats_fn;
|
|
|
|
const char *b = streami->config.stats_fn;
|
|
|
|
if (a && b && !strcmp(a, b))
|
|
|
|
fatal("Stream %d: duplicate stats file (from stream %d)",
|
|
|
|
streami->index, stream->index);
|
2010-05-18 19:58:33 +04:00
|
|
|
}
|
2012-07-14 02:21:29 +04:00
|
|
|
}
|
2012-02-16 00:39:38 +04:00
|
|
|
}
|
2010-05-18 19:58:33 +04:00
|
|
|
|
|
|
|
|
2012-02-16 00:39:38 +04:00
|
|
|
static void set_stream_dimensions(struct stream_state *stream,
|
|
|
|
unsigned int w,
|
2012-11-07 00:02:42 +04:00
|
|
|
unsigned int h) {
|
2012-03-02 00:50:40 +04:00
|
|
|
if (!stream->config.cfg.g_w) {
|
|
|
|
if (!stream->config.cfg.g_h)
|
|
|
|
stream->config.cfg.g_w = w;
|
|
|
|
else
|
|
|
|
stream->config.cfg.g_w = w * stream->config.cfg.g_h / h;
|
|
|
|
}
|
|
|
|
if (!stream->config.cfg.g_h) {
|
|
|
|
stream->config.cfg.g_h = h * stream->config.cfg.g_w / w;
|
|
|
|
}
|
2012-02-16 00:39:38 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-11-22 04:46:40 +04:00
|
|
|
static void set_default_kf_interval(struct stream_state *stream,
|
|
|
|
struct VpxEncoderConfig *global) {
|
2012-11-07 00:02:42 +04:00
|
|
|
/* Use a max keyframe interval of 5 seconds, if none was
|
|
|
|
* specified on the command line.
|
|
|
|
*/
|
|
|
|
if (!stream->config.have_kf_max_dist) {
|
|
|
|
double framerate = (double)global->framerate.num / global->framerate.den;
|
|
|
|
if (framerate > 0.0)
|
|
|
|
stream->config.cfg.kf_max_dist = (unsigned int)(5.0 * framerate);
|
|
|
|
}
|
2012-01-06 01:05:05 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-11-22 04:46:40 +04:00
|
|
|
static void show_stream_config(struct stream_state *stream,
|
|
|
|
struct VpxEncoderConfig *global,
|
2013-11-15 00:37:42 +04:00
|
|
|
struct VpxInputContext *input) {
|
2012-02-16 00:39:38 +04:00
|
|
|
|
|
|
|
#define SHOW(field) \
|
2012-11-07 00:02:42 +04:00
|
|
|
fprintf(stderr, " %-28s = %d\n", #field, stream->config.cfg.field)
|
|
|
|
|
|
|
|
if (stream->index == 0) {
|
|
|
|
fprintf(stderr, "Codec: %s\n",
|
|
|
|
vpx_codec_iface_name(global->codec->iface()));
|
2013-11-15 00:37:42 +04:00
|
|
|
fprintf(stderr, "Source file: %s Format: %s\n", input->filename,
|
2012-11-07 00:02:42 +04:00
|
|
|
input->use_i420 ? "I420" : "YV12");
|
2012-07-14 02:21:29 +04:00
|
|
|
}
|
2012-11-07 00:02:42 +04:00
|
|
|
if (stream->next || stream->index)
|
|
|
|
fprintf(stderr, "\nStream Index: %d\n", stream->index);
|
|
|
|
fprintf(stderr, "Destination file: %s\n", stream->config.out_fn);
|
|
|
|
fprintf(stderr, "Encoder parameters:\n");
|
|
|
|
|
|
|
|
SHOW(g_usage);
|
|
|
|
SHOW(g_threads);
|
|
|
|
SHOW(g_profile);
|
|
|
|
SHOW(g_w);
|
|
|
|
SHOW(g_h);
|
|
|
|
SHOW(g_timebase.num);
|
|
|
|
SHOW(g_timebase.den);
|
|
|
|
SHOW(g_error_resilient);
|
|
|
|
SHOW(g_pass);
|
|
|
|
SHOW(g_lag_in_frames);
|
|
|
|
SHOW(rc_dropframe_thresh);
|
|
|
|
SHOW(rc_resize_allowed);
|
|
|
|
SHOW(rc_resize_up_thresh);
|
|
|
|
SHOW(rc_resize_down_thresh);
|
|
|
|
SHOW(rc_end_usage);
|
|
|
|
SHOW(rc_target_bitrate);
|
|
|
|
SHOW(rc_min_quantizer);
|
|
|
|
SHOW(rc_max_quantizer);
|
|
|
|
SHOW(rc_undershoot_pct);
|
|
|
|
SHOW(rc_overshoot_pct);
|
|
|
|
SHOW(rc_buf_sz);
|
|
|
|
SHOW(rc_buf_initial_sz);
|
|
|
|
SHOW(rc_buf_optimal_sz);
|
|
|
|
SHOW(rc_2pass_vbr_bias_pct);
|
|
|
|
SHOW(rc_2pass_vbr_minsection_pct);
|
|
|
|
SHOW(rc_2pass_vbr_maxsection_pct);
|
|
|
|
SHOW(kf_mode);
|
|
|
|
SHOW(kf_min_dist);
|
|
|
|
SHOW(kf_max_dist);
|
2012-02-16 00:39:38 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void open_output_file(struct stream_state *stream,
|
2013-11-22 04:46:40 +04:00
|
|
|
struct VpxEncoderConfig *global) {
|
2012-11-07 00:02:42 +04:00
|
|
|
const char *fn = stream->config.out_fn;
|
2014-01-14 03:21:48 +04:00
|
|
|
const struct vpx_codec_enc_cfg *const cfg = &stream->config.cfg;
|
|
|
|
|
|
|
|
if (cfg->g_pass == VPX_RC_FIRST_PASS)
|
|
|
|
return;
|
2010-05-18 19:58:33 +04:00
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
stream->file = strcmp(fn, "-") ? fopen(fn, "wb") : set_binary_mode(stdout);
|
2010-10-22 22:48:21 +04:00
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
if (!stream->file)
|
|
|
|
fatal("Failed to open output file");
|
2010-05-18 19:58:33 +04:00
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
if (stream->config.write_webm && fseek(stream->file, 0, SEEK_CUR))
|
|
|
|
fatal("WebM output to pipes not supported.");
|
2010-05-18 19:58:33 +04:00
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
if (stream->config.write_webm) {
|
|
|
|
stream->ebml.stream = stream->file;
|
2014-01-14 03:21:48 +04:00
|
|
|
write_webm_file_header(&stream->ebml, cfg,
|
2012-11-07 00:02:42 +04:00
|
|
|
&global->framerate,
|
2012-11-14 00:14:28 +04:00
|
|
|
stream->config.stereo_fmt,
|
|
|
|
global->codec->fourcc);
|
2014-01-14 03:21:48 +04:00
|
|
|
} else {
|
|
|
|
ivf_write_file_header(stream->file, cfg, global->codec->fourcc, 0);
|
|
|
|
}
|
2012-02-16 00:39:38 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void close_output_file(struct stream_state *stream,
|
2014-01-14 03:21:48 +04:00
|
|
|
unsigned int fourcc) {
|
|
|
|
const struct vpx_codec_enc_cfg *const cfg = &stream->config.cfg;
|
|
|
|
|
|
|
|
if (cfg->g_pass == VPX_RC_FIRST_PASS)
|
|
|
|
return;
|
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
if (stream->config.write_webm) {
|
|
|
|
write_webm_file_footer(&stream->ebml, stream->hash);
|
|
|
|
free(stream->ebml.cue_list);
|
|
|
|
stream->ebml.cue_list = NULL;
|
|
|
|
} else {
|
|
|
|
if (!fseek(stream->file, 0, SEEK_SET))
|
2013-11-15 00:37:42 +04:00
|
|
|
ivf_write_file_header(stream->file, &stream->config.cfg,
|
2012-11-07 00:02:42 +04:00
|
|
|
fourcc,
|
|
|
|
stream->frames_out);
|
|
|
|
}
|
2010-06-11 01:10:12 +04:00
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
fclose(stream->file);
|
2012-02-16 00:39:38 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-11-22 04:46:40 +04:00
|
|
|
static void setup_pass(struct stream_state *stream,
|
|
|
|
struct VpxEncoderConfig *global,
|
|
|
|
int pass) {
|
2012-11-07 00:02:42 +04:00
|
|
|
if (stream->config.stats_fn) {
|
|
|
|
if (!stats_open_file(&stream->stats, stream->config.stats_fn,
|
|
|
|
pass))
|
|
|
|
fatal("Failed to open statistics store");
|
|
|
|
} else {
|
|
|
|
if (!stats_open_mem(&stream->stats, pass))
|
|
|
|
fatal("Failed to open statistics store");
|
|
|
|
}
|
|
|
|
|
|
|
|
stream->config.cfg.g_pass = global->passes == 2
|
|
|
|
? pass ? VPX_RC_LAST_PASS : VPX_RC_FIRST_PASS
|
|
|
|
: VPX_RC_ONE_PASS;
|
|
|
|
if (pass)
|
|
|
|
stream->config.cfg.rc_twopass_stats_in = stats_get(&stream->stats);
|
|
|
|
|
|
|
|
stream->cx_time = 0;
|
|
|
|
stream->nbytes = 0;
|
|
|
|
stream->frames_out = 0;
|
2012-02-16 00:39:38 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-11-22 04:46:40 +04:00
|
|
|
static void initialize_encoder(struct stream_state *stream,
|
|
|
|
struct VpxEncoderConfig *global) {
|
2012-11-07 00:02:42 +04:00
|
|
|
int i;
|
|
|
|
int flags = 0;
|
|
|
|
|
|
|
|
flags |= global->show_psnr ? VPX_CODEC_USE_PSNR : 0;
|
|
|
|
flags |= global->out_part ? VPX_CODEC_USE_OUTPUT_PARTITION : 0;
|
|
|
|
|
|
|
|
/* Construct Encoder Context */
|
|
|
|
vpx_codec_enc_init(&stream->encoder, global->codec->iface(),
|
|
|
|
&stream->config.cfg, flags);
|
|
|
|
ctx_exit_on_error(&stream->encoder, "Failed to initialize encoder");
|
|
|
|
|
|
|
|
/* Note that we bypass the vpx_codec_control wrapper macro because
|
|
|
|
* we're being clever to store the control IDs in an array. Real
|
|
|
|
* applications will want to make use of the enumerations directly
|
|
|
|
*/
|
|
|
|
for (i = 0; i < stream->config.arg_ctrl_cnt; i++) {
|
|
|
|
int ctrl = stream->config.arg_ctrls[i][0];
|
|
|
|
int value = stream->config.arg_ctrls[i][1];
|
|
|
|
if (vpx_codec_control_(&stream->encoder, ctrl, value))
|
|
|
|
fprintf(stderr, "Error: Tried to set control %d = %d\n",
|
|
|
|
ctrl, value);
|
|
|
|
|
|
|
|
ctx_exit_on_error(&stream->encoder, "Failed to control codec");
|
|
|
|
}
|
|
|
|
|
2012-12-23 19:20:10 +04:00
|
|
|
#if CONFIG_DECODERS
|
2013-02-16 04:31:02 +04:00
|
|
|
if (global->test_decode != TEST_DECODE_OFF) {
|
2012-11-07 00:02:42 +04:00
|
|
|
vpx_codec_dec_init(&stream->decoder, global->codec->dx_iface(), NULL, 0);
|
|
|
|
}
|
2012-12-23 19:20:10 +04:00
|
|
|
#endif
|
2012-02-16 00:39:38 +04:00
|
|
|
}
|
2010-05-18 19:58:33 +04:00
|
|
|
|
|
|
|
|
2013-11-22 04:46:40 +04:00
|
|
|
static void encode_frame(struct stream_state *stream,
|
|
|
|
struct VpxEncoderConfig *global,
|
|
|
|
struct vpx_image *img,
|
|
|
|
unsigned int frames_in) {
|
2012-11-07 00:02:42 +04:00
|
|
|
vpx_codec_pts_t frame_start, next_frame_start;
|
|
|
|
struct vpx_codec_enc_cfg *cfg = &stream->config.cfg;
|
|
|
|
struct vpx_usec_timer timer;
|
|
|
|
|
|
|
|
frame_start = (cfg->g_timebase.den * (int64_t)(frames_in - 1)
|
|
|
|
* global->framerate.den)
|
|
|
|
/ cfg->g_timebase.num / global->framerate.num;
|
|
|
|
next_frame_start = (cfg->g_timebase.den * (int64_t)(frames_in)
|
|
|
|
* global->framerate.den)
|
|
|
|
/ cfg->g_timebase.num / global->framerate.num;
|
2012-03-02 00:50:40 +04:00
|
|
|
|
|
|
|
/* Scale if necessary */
|
|
|
|
if (img && (img->d_w != cfg->g_w || img->d_h != cfg->g_h)) {
|
|
|
|
if (!stream->img)
|
|
|
|
stream->img = vpx_img_alloc(NULL, VPX_IMG_FMT_I420,
|
|
|
|
cfg->g_w, cfg->g_h, 16);
|
|
|
|
I420Scale(img->planes[VPX_PLANE_Y], img->stride[VPX_PLANE_Y],
|
|
|
|
img->planes[VPX_PLANE_U], img->stride[VPX_PLANE_U],
|
|
|
|
img->planes[VPX_PLANE_V], img->stride[VPX_PLANE_V],
|
|
|
|
img->d_w, img->d_h,
|
|
|
|
stream->img->planes[VPX_PLANE_Y],
|
|
|
|
stream->img->stride[VPX_PLANE_Y],
|
|
|
|
stream->img->planes[VPX_PLANE_U],
|
|
|
|
stream->img->stride[VPX_PLANE_U],
|
|
|
|
stream->img->planes[VPX_PLANE_V],
|
|
|
|
stream->img->stride[VPX_PLANE_V],
|
|
|
|
stream->img->d_w, stream->img->d_h,
|
|
|
|
kFilterBox);
|
|
|
|
|
|
|
|
img = stream->img;
|
|
|
|
}
|
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
vpx_usec_timer_start(&timer);
|
|
|
|
vpx_codec_encode(&stream->encoder, img, frame_start,
|
|
|
|
(unsigned long)(next_frame_start - frame_start),
|
|
|
|
0, global->deadline);
|
|
|
|
vpx_usec_timer_mark(&timer);
|
|
|
|
stream->cx_time += vpx_usec_timer_elapsed(&timer);
|
|
|
|
ctx_exit_on_error(&stream->encoder, "Stream %d: Failed to encode frame",
|
|
|
|
stream->index);
|
2012-02-16 00:39:38 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
static void update_quantizer_histogram(struct stream_state *stream) {
|
|
|
|
if (stream->config.cfg.g_pass != VPX_RC_FIRST_PASS) {
|
|
|
|
int q;
|
2012-02-16 00:39:38 +04:00
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
vpx_codec_control(&stream->encoder, VP8E_GET_LAST_QUANTIZER_64, &q);
|
|
|
|
ctx_exit_on_error(&stream->encoder, "Failed to read quantizer");
|
|
|
|
stream->counts[q]++;
|
|
|
|
}
|
2012-02-16 00:39:38 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-11-22 04:46:40 +04:00
|
|
|
static void get_cx_data(struct stream_state *stream,
|
|
|
|
struct VpxEncoderConfig *global,
|
|
|
|
int *got_data) {
|
2012-11-07 00:02:42 +04:00
|
|
|
const vpx_codec_cx_pkt_t *pkt;
|
|
|
|
const struct vpx_codec_enc_cfg *cfg = &stream->config.cfg;
|
|
|
|
vpx_codec_iter_t iter = NULL;
|
|
|
|
|
2012-11-09 21:07:50 +04:00
|
|
|
*got_data = 0;
|
2012-11-07 00:02:42 +04:00
|
|
|
while ((pkt = vpx_codec_get_cx_data(&stream->encoder, &iter))) {
|
|
|
|
static size_t fsize = 0;
|
|
|
|
static off_t ivf_header_pos = 0;
|
|
|
|
|
|
|
|
switch (pkt->kind) {
|
|
|
|
case VPX_CODEC_CX_FRAME_PKT:
|
|
|
|
if (!(pkt->data.frame.flags & VPX_FRAME_IS_FRAGMENT)) {
|
|
|
|
stream->frames_out++;
|
2010-11-03 20:58:40 +03:00
|
|
|
}
|
2013-02-13 21:03:21 +04:00
|
|
|
if (!global->quiet)
|
|
|
|
fprintf(stderr, " %6luF", (unsigned long)pkt->data.frame.sz);
|
2012-11-07 00:02:42 +04:00
|
|
|
|
2014-01-30 00:28:29 +04:00
|
|
|
update_rate_histogram(stream->rate_hist, cfg, pkt);
|
2012-11-07 00:02:42 +04:00
|
|
|
if (stream->config.write_webm) {
|
|
|
|
/* Update the hash */
|
|
|
|
if (!stream->ebml.debug)
|
|
|
|
stream->hash = murmur(pkt->data.frame.buf,
|
|
|
|
(int)pkt->data.frame.sz,
|
|
|
|
stream->hash);
|
|
|
|
|
|
|
|
write_webm_block(&stream->ebml, cfg, pkt);
|
|
|
|
} else {
|
|
|
|
if (pkt->data.frame.partition_id <= 0) {
|
|
|
|
ivf_header_pos = ftello(stream->file);
|
|
|
|
fsize = pkt->data.frame.sz;
|
|
|
|
|
2014-01-30 05:57:21 +04:00
|
|
|
ivf_write_frame_header(stream->file, pkt->data.frame.pts, fsize);
|
2012-11-07 00:02:42 +04:00
|
|
|
} else {
|
|
|
|
fsize += pkt->data.frame.sz;
|
|
|
|
|
|
|
|
if (!(pkt->data.frame.flags & VPX_FRAME_IS_FRAGMENT)) {
|
|
|
|
off_t currpos = ftello(stream->file);
|
|
|
|
fseeko(stream->file, ivf_header_pos, SEEK_SET);
|
2013-11-15 00:37:42 +04:00
|
|
|
ivf_write_frame_size(stream->file, fsize);
|
2012-11-07 00:02:42 +04:00
|
|
|
fseeko(stream->file, currpos, SEEK_SET);
|
|
|
|
}
|
|
|
|
}
|
2012-02-16 00:39:38 +04:00
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
(void) fwrite(pkt->data.frame.buf, 1, pkt->data.frame.sz,
|
|
|
|
stream->file);
|
|
|
|
}
|
|
|
|
stream->nbytes += pkt->data.raw.sz;
|
2012-02-09 14:37:03 +04:00
|
|
|
|
2012-02-16 00:39:38 +04:00
|
|
|
*got_data = 1;
|
2012-12-23 19:20:10 +04:00
|
|
|
#if CONFIG_DECODERS
|
2013-02-16 04:31:02 +04:00
|
|
|
if (global->test_decode != TEST_DECODE_OFF && !stream->mismatch_seen) {
|
2012-11-07 00:02:42 +04:00
|
|
|
vpx_codec_decode(&stream->decoder, pkt->data.frame.buf,
|
|
|
|
pkt->data.frame.sz, NULL, 0);
|
2013-02-16 04:31:02 +04:00
|
|
|
if (stream->decoder.err) {
|
|
|
|
warn_or_exit_on_error(&stream->decoder,
|
|
|
|
global->test_decode == TEST_DECODE_FATAL,
|
|
|
|
"Failed to decode frame %d in stream %d",
|
|
|
|
stream->frames_out + 1, stream->index);
|
|
|
|
stream->mismatch_seen = stream->frames_out + 1;
|
|
|
|
}
|
2012-11-07 00:02:42 +04:00
|
|
|
}
|
2012-12-23 19:20:10 +04:00
|
|
|
#endif
|
2012-11-07 00:02:42 +04:00
|
|
|
break;
|
|
|
|
case VPX_CODEC_STATS_PKT:
|
|
|
|
stream->frames_out++;
|
|
|
|
stats_write(&stream->stats,
|
|
|
|
pkt->data.twopass_stats.buf,
|
|
|
|
pkt->data.twopass_stats.sz);
|
|
|
|
stream->nbytes += pkt->data.raw.sz;
|
|
|
|
break;
|
|
|
|
case VPX_CODEC_PSNR_PKT:
|
|
|
|
|
|
|
|
if (global->show_psnr) {
|
|
|
|
int i;
|
|
|
|
|
|
|
|
stream->psnr_sse_total += pkt->data.psnr.sse[0];
|
|
|
|
stream->psnr_samples_total += pkt->data.psnr.samples[0];
|
|
|
|
for (i = 0; i < 4; i++) {
|
2013-02-13 21:03:21 +04:00
|
|
|
if (!global->quiet)
|
|
|
|
fprintf(stderr, "%.3f ", pkt->data.psnr.psnr[i]);
|
2012-11-07 00:02:42 +04:00
|
|
|
stream->psnr_totals[i] += pkt->data.psnr.psnr[i];
|
|
|
|
}
|
|
|
|
stream->psnr_count++;
|
2010-05-18 19:58:33 +04:00
|
|
|
}
|
2012-07-14 02:21:29 +04:00
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
2012-02-16 00:39:38 +04:00
|
|
|
}
|
2012-11-07 00:02:42 +04:00
|
|
|
}
|
2012-02-16 00:39:38 +04:00
|
|
|
}
|
2010-05-18 19:58:33 +04:00
|
|
|
|
2012-02-16 00:39:38 +04:00
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
static void show_psnr(struct stream_state *stream) {
|
|
|
|
int i;
|
|
|
|
double ovpsnr;
|
2012-02-16 00:39:38 +04:00
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
if (!stream->psnr_count)
|
|
|
|
return;
|
2012-02-16 00:39:38 +04:00
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
fprintf(stderr, "Stream %d PSNR (Overall/Avg/Y/U/V)", stream->index);
|
|
|
|
ovpsnr = vp8_mse2psnr((double)stream->psnr_samples_total, 255.0,
|
|
|
|
(double)stream->psnr_sse_total);
|
|
|
|
fprintf(stderr, " %.3f", ovpsnr);
|
2012-02-16 00:39:38 +04:00
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
for (i = 0; i < 4; i++) {
|
|
|
|
fprintf(stderr, " %.3f", stream->psnr_totals[i] / stream->psnr_count);
|
|
|
|
}
|
|
|
|
fprintf(stderr, "\n");
|
2012-02-16 00:39:38 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-02-13 09:17:56 +04:00
|
|
|
static float usec_to_fps(uint64_t usec, unsigned int frames) {
|
2012-11-07 00:02:42 +04:00
|
|
|
return (float)(usec > 0 ? frames * 1000000.0 / (float)usec : 0);
|
2012-02-16 00:39:38 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-02-16 04:31:02 +04:00
|
|
|
static void test_decode(struct stream_state *stream,
|
2013-03-13 23:15:43 +04:00
|
|
|
enum TestDecodeFatality fatal,
|
|
|
|
const struct codec_item *codec) {
|
|
|
|
vpx_image_t enc_img, dec_img;
|
|
|
|
|
2013-02-16 04:31:02 +04:00
|
|
|
if (stream->mismatch_seen)
|
|
|
|
return;
|
|
|
|
|
2013-03-13 23:15:43 +04:00
|
|
|
/* Get the internal reference frame */
|
|
|
|
if (codec->fourcc == VP8_FOURCC) {
|
|
|
|
struct vpx_ref_frame ref_enc, ref_dec;
|
|
|
|
int width, height;
|
|
|
|
|
|
|
|
width = (stream->config.cfg.g_w + 15) & ~15;
|
|
|
|
height = (stream->config.cfg.g_h + 15) & ~15;
|
|
|
|
vpx_img_alloc(&ref_enc.img, VPX_IMG_FMT_I420, width, height, 1);
|
|
|
|
enc_img = ref_enc.img;
|
|
|
|
vpx_img_alloc(&ref_dec.img, VPX_IMG_FMT_I420, width, height, 1);
|
|
|
|
dec_img = ref_dec.img;
|
|
|
|
|
|
|
|
ref_enc.frame_type = VP8_LAST_FRAME;
|
|
|
|
ref_dec.frame_type = VP8_LAST_FRAME;
|
|
|
|
vpx_codec_control(&stream->encoder, VP8_COPY_REFERENCE, &ref_enc);
|
|
|
|
vpx_codec_control(&stream->decoder, VP8_COPY_REFERENCE, &ref_dec);
|
|
|
|
} else {
|
|
|
|
struct vp9_ref_frame ref;
|
|
|
|
|
|
|
|
ref.idx = 0;
|
|
|
|
vpx_codec_control(&stream->encoder, VP9_GET_REFERENCE, &ref);
|
|
|
|
enc_img = ref.img;
|
|
|
|
vpx_codec_control(&stream->decoder, VP9_GET_REFERENCE, &ref);
|
|
|
|
dec_img = ref.img;
|
|
|
|
}
|
2012-11-07 00:02:42 +04:00
|
|
|
ctx_exit_on_error(&stream->encoder, "Failed to get encoder reference frame");
|
|
|
|
ctx_exit_on_error(&stream->decoder, "Failed to get decoder reference frame");
|
2012-07-14 02:21:29 +04:00
|
|
|
|
2013-03-13 23:15:43 +04:00
|
|
|
if (!compare_img(&enc_img, &dec_img)) {
|
Implicit weighted prediction experiment
Adds an experiment to use a weighted prediction of two INTER
predictors, where the weight is one of (1/4, 3/4), (3/8, 5/8),
(1/2, 1/2), (5/8, 3/8) or (3/4, 1/4), and is chosen implicitly
based on consistency of the predictors to the already
reconstructed pixels to the top and left of the current macroblock
or superblock.
Currently the weighting is not applied to SPLITMV modes, which
default to the usual (1/2, 1/2) weighting. However the code is in
place controlled by a macro. The same weighting is used for Y and
UV components, where the weight is derived from analyzing the Y
component only.
Results (over compound inter-intra experiment)
derf: +0.18%
yt: +0.34%
hd: +0.49%
stdhd: +0.23%
The experiment suggests bigger benefit for explicitly signaled weights.
Change-Id: I5438539ff4485c5752874cd1eb078ff14bf5235a
2013-03-13 01:21:08 +04:00
|
|
|
int y[4], u[4], v[4];
|
2013-03-13 23:15:43 +04:00
|
|
|
find_mismatch(&enc_img, &dec_img, y, u, v);
|
2013-03-05 02:12:49 +04:00
|
|
|
stream->decoder.err = 1;
|
2013-02-16 04:31:02 +04:00
|
|
|
warn_or_exit_on_error(&stream->decoder, fatal == TEST_DECODE_FATAL,
|
Implicit weighted prediction experiment
Adds an experiment to use a weighted prediction of two INTER
predictors, where the weight is one of (1/4, 3/4), (3/8, 5/8),
(1/2, 1/2), (5/8, 3/8) or (3/4, 1/4), and is chosen implicitly
based on consistency of the predictors to the already
reconstructed pixels to the top and left of the current macroblock
or superblock.
Currently the weighting is not applied to SPLITMV modes, which
default to the usual (1/2, 1/2) weighting. However the code is in
place controlled by a macro. The same weighting is used for Y and
UV components, where the weight is derived from analyzing the Y
component only.
Results (over compound inter-intra experiment)
derf: +0.18%
yt: +0.34%
hd: +0.49%
stdhd: +0.23%
The experiment suggests bigger benefit for explicitly signaled weights.
Change-Id: I5438539ff4485c5752874cd1eb078ff14bf5235a
2013-03-13 01:21:08 +04:00
|
|
|
"Stream %d: Encode/decode mismatch on frame %d at"
|
|
|
|
" Y[%d, %d] {%d/%d},"
|
|
|
|
" U[%d, %d] {%d/%d},"
|
|
|
|
" V[%d, %d] {%d/%d}",
|
2013-02-16 04:31:02 +04:00
|
|
|
stream->index, stream->frames_out,
|
Implicit weighted prediction experiment
Adds an experiment to use a weighted prediction of two INTER
predictors, where the weight is one of (1/4, 3/4), (3/8, 5/8),
(1/2, 1/2), (5/8, 3/8) or (3/4, 1/4), and is chosen implicitly
based on consistency of the predictors to the already
reconstructed pixels to the top and left of the current macroblock
or superblock.
Currently the weighting is not applied to SPLITMV modes, which
default to the usual (1/2, 1/2) weighting. However the code is in
place controlled by a macro. The same weighting is used for Y and
UV components, where the weight is derived from analyzing the Y
component only.
Results (over compound inter-intra experiment)
derf: +0.18%
yt: +0.34%
hd: +0.49%
stdhd: +0.23%
The experiment suggests bigger benefit for explicitly signaled weights.
Change-Id: I5438539ff4485c5752874cd1eb078ff14bf5235a
2013-03-13 01:21:08 +04:00
|
|
|
y[0], y[1], y[2], y[3],
|
|
|
|
u[0], u[1], u[2], u[3],
|
|
|
|
v[0], v[1], v[2], v[3]);
|
2012-11-11 04:22:49 +04:00
|
|
|
stream->mismatch_seen = stream->frames_out;
|
2012-11-07 00:02:42 +04:00
|
|
|
}
|
2013-03-13 23:15:43 +04:00
|
|
|
|
|
|
|
vpx_img_free(&enc_img);
|
|
|
|
vpx_img_free(&dec_img);
|
2012-11-07 00:02:42 +04:00
|
|
|
}
|
2012-02-16 00:39:38 +04:00
|
|
|
|
2013-02-13 09:17:56 +04:00
|
|
|
|
|
|
|
static void print_time(const char *label, int64_t etl) {
|
|
|
|
int hours, mins, secs;
|
|
|
|
|
|
|
|
if (etl >= 0) {
|
|
|
|
hours = etl / 3600;
|
|
|
|
etl -= hours * 3600;
|
|
|
|
mins = etl / 60;
|
|
|
|
etl -= mins * 60;
|
|
|
|
secs = etl;
|
|
|
|
|
|
|
|
fprintf(stderr, "[%3s %2d:%02d:%02d] ",
|
|
|
|
label, hours, mins, secs);
|
|
|
|
} else {
|
|
|
|
fprintf(stderr, "[%3s unknown] ", label);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-11-21 05:18:28 +04:00
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
int main(int argc, const char **argv_) {
|
2013-11-21 05:18:28 +04:00
|
|
|
int pass;
|
|
|
|
vpx_image_t raw;
|
|
|
|
int frame_avail, got_data;
|
|
|
|
|
|
|
|
struct VpxInputContext input = {0};
|
2013-11-22 04:46:40 +04:00
|
|
|
struct VpxEncoderConfig global;
|
2013-11-21 05:18:28 +04:00
|
|
|
struct stream_state *streams = NULL;
|
|
|
|
char **argv, **argi;
|
|
|
|
uint64_t cx_time = 0;
|
|
|
|
int stream_cnt = 0;
|
|
|
|
int res = 0;
|
2010-05-18 19:58:33 +04:00
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
exec_name = argv_[0];
|
2010-05-18 19:58:33 +04:00
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
if (argc < 3)
|
|
|
|
usage_exit();
|
2010-05-18 19:58:33 +04:00
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
/* Setup default input stream settings */
|
2013-11-15 00:37:42 +04:00
|
|
|
input.framerate.numerator = 30;
|
|
|
|
input.framerate.denominator = 1;
|
2012-11-07 00:02:42 +04:00
|
|
|
input.use_i420 = 1;
|
2013-05-06 22:01:35 +04:00
|
|
|
input.only_i420 = 1;
|
2010-05-18 19:58:33 +04:00
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
/* First parse the global configuration values, because we want to apply
|
|
|
|
* other parameters on top of the default configuration provided by the
|
|
|
|
* codec.
|
|
|
|
*/
|
|
|
|
argv = argv_dup(argc - 1, argv_ + 1);
|
|
|
|
parse_global_config(&global, argv);
|
|
|
|
|
2013-11-21 05:18:28 +04:00
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
{
|
|
|
|
/* Now parse each stream's parameters. Using a local scope here
|
|
|
|
* due to the use of 'stream' as loop variable in FOREACH_STREAM
|
|
|
|
* loops
|
2012-07-14 02:21:29 +04:00
|
|
|
*/
|
2012-11-07 00:02:42 +04:00
|
|
|
struct stream_state *stream = NULL;
|
2010-05-18 19:58:33 +04:00
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
do {
|
|
|
|
stream = new_stream(&global, stream);
|
|
|
|
stream_cnt++;
|
|
|
|
if (!streams)
|
|
|
|
streams = stream;
|
|
|
|
} while (parse_stream_params(&global, stream, argv));
|
|
|
|
}
|
2010-05-18 19:58:33 +04:00
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
/* Check for unrecognized options */
|
|
|
|
for (argi = argv; *argi; argi++)
|
|
|
|
if (argi[0][0] == '-' && argi[0][1])
|
|
|
|
die("Error: Unrecognized option %s\n", *argi);
|
2010-05-18 19:58:33 +04:00
|
|
|
|
2013-11-26 00:05:19 +04:00
|
|
|
FOREACH_STREAM(check_encoder_config(global.disable_warning_prompt,
|
|
|
|
&global, &stream->config.cfg););
|
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
/* Handle non-option arguments */
|
2013-11-15 00:37:42 +04:00
|
|
|
input.filename = argv[0];
|
2012-02-16 00:39:38 +04:00
|
|
|
|
2013-11-15 00:37:42 +04:00
|
|
|
if (!input.filename)
|
2012-11-07 00:02:42 +04:00
|
|
|
usage_exit();
|
2010-05-18 19:58:33 +04:00
|
|
|
|
2013-05-06 22:01:35 +04:00
|
|
|
#if CONFIG_NON420
|
|
|
|
/* Decide if other chroma subsamplings than 4:2:0 are supported */
|
|
|
|
if (global.codec->fourcc == VP9_FOURCC)
|
|
|
|
input.only_i420 = 0;
|
|
|
|
#endif
|
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
for (pass = global.pass ? global.pass - 1 : 0; pass < global.passes; pass++) {
|
2013-03-12 02:03:00 +04:00
|
|
|
int frames_in = 0, seen_frames = 0;
|
2013-02-13 09:17:56 +04:00
|
|
|
int64_t estimated_time_left = -1;
|
|
|
|
int64_t average_rate = -1;
|
|
|
|
off_t lagged_count = 0;
|
2011-06-21 01:09:29 +04:00
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
open_input_file(&input);
|
2011-06-21 01:09:29 +04:00
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
/* If the input file doesn't specify its w/h (raw files), try to get
|
|
|
|
* the data from the first stream's configuration.
|
|
|
|
*/
|
2013-11-15 00:37:42 +04:00
|
|
|
if (!input.width || !input.height)
|
2012-11-07 00:02:42 +04:00
|
|
|
FOREACH_STREAM( {
|
|
|
|
if (stream->config.cfg.g_w && stream->config.cfg.g_h) {
|
2013-11-15 00:37:42 +04:00
|
|
|
input.width = stream->config.cfg.g_w;
|
|
|
|
input.height = stream->config.cfg.g_h;
|
2012-07-14 02:21:29 +04:00
|
|
|
break;
|
2012-11-07 00:02:42 +04:00
|
|
|
}
|
|
|
|
});
|
|
|
|
|
|
|
|
/* Update stream configurations from the input file's parameters */
|
2013-11-15 00:37:42 +04:00
|
|
|
if (!input.width || !input.height)
|
2012-03-02 00:50:40 +04:00
|
|
|
fatal("Specify stream dimensions with --width (-w) "
|
|
|
|
" and --height (-h)");
|
2013-11-15 00:37:42 +04:00
|
|
|
FOREACH_STREAM(set_stream_dimensions(stream, input.width, input.height));
|
2012-11-07 00:02:42 +04:00
|
|
|
FOREACH_STREAM(validate_stream_config(stream));
|
|
|
|
|
|
|
|
/* Ensure that --passes and --pass are consistent. If --pass is set and
|
|
|
|
* --passes=2, ensure --fpf was set.
|
|
|
|
*/
|
|
|
|
if (global.pass && global.passes == 2)
|
|
|
|
FOREACH_STREAM( {
|
|
|
|
if (!stream->config.stats_fn)
|
|
|
|
die("Stream %d: Must specify --fpf when --pass=%d"
|
|
|
|
" and --passes=2\n", stream->index, global.pass);
|
|
|
|
});
|
2010-05-18 19:58:33 +04:00
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
/* Use the frame rate from the file only if none was specified
|
|
|
|
* on the command-line.
|
|
|
|
*/
|
2013-11-15 00:37:42 +04:00
|
|
|
if (!global.have_framerate) {
|
|
|
|
global.framerate.num = input.framerate.numerator;
|
|
|
|
global.framerate.den = input.framerate.denominator;
|
|
|
|
}
|
2012-11-07 00:02:42 +04:00
|
|
|
|
|
|
|
FOREACH_STREAM(set_default_kf_interval(stream, &global));
|
|
|
|
|
|
|
|
/* Show configuration */
|
|
|
|
if (global.verbose && pass == 0)
|
|
|
|
FOREACH_STREAM(show_stream_config(stream, &global, &input));
|
|
|
|
|
|
|
|
if (pass == (global.pass ? global.pass - 1 : 0)) {
|
|
|
|
if (input.file_type == FILE_TYPE_Y4M)
|
|
|
|
/*The Y4M reader does its own allocation.
|
|
|
|
Just initialize this here to avoid problems if we never read any
|
|
|
|
frames.*/
|
|
|
|
memset(&raw, 0, sizeof(raw));
|
|
|
|
else
|
|
|
|
vpx_img_alloc(&raw,
|
|
|
|
input.use_i420 ? VPX_IMG_FMT_I420
|
|
|
|
: VPX_IMG_FMT_YV12,
|
2013-11-15 00:37:42 +04:00
|
|
|
input.width, input.height, 32);
|
2012-11-07 00:02:42 +04:00
|
|
|
|
2014-01-30 00:28:29 +04:00
|
|
|
FOREACH_STREAM(stream->rate_hist =
|
|
|
|
init_rate_histogram(&stream->config.cfg,
|
|
|
|
&global.framerate));
|
2012-07-14 02:21:29 +04:00
|
|
|
}
|
2012-02-16 00:39:38 +04:00
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
FOREACH_STREAM(setup_pass(stream, &global, pass));
|
2013-08-15 05:28:42 +04:00
|
|
|
FOREACH_STREAM(open_output_file(stream, &global));
|
2012-11-07 00:02:42 +04:00
|
|
|
FOREACH_STREAM(initialize_encoder(stream, &global));
|
|
|
|
|
|
|
|
frame_avail = 1;
|
|
|
|
got_data = 0;
|
|
|
|
|
2012-07-14 02:21:29 +04:00
|
|
|
while (frame_avail || got_data) {
|
|
|
|
struct vpx_usec_timer timer;
|
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
if (!global.limit || frames_in < global.limit) {
|
|
|
|
frame_avail = read_frame(&input, &raw);
|
|
|
|
|
2012-07-14 02:21:29 +04:00
|
|
|
if (frame_avail)
|
|
|
|
frames_in++;
|
2013-03-12 02:03:00 +04:00
|
|
|
seen_frames = frames_in > global.skip_frames ?
|
|
|
|
frames_in - global.skip_frames : 0;
|
2012-11-07 00:02:42 +04:00
|
|
|
|
|
|
|
if (!global.quiet) {
|
2013-03-12 02:03:00 +04:00
|
|
|
float fps = usec_to_fps(cx_time, seen_frames);
|
2013-02-13 09:17:56 +04:00
|
|
|
fprintf(stderr, "\rPass %d/%d ", pass + 1, global.passes);
|
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
if (stream_cnt == 1)
|
|
|
|
fprintf(stderr,
|
2013-02-13 09:17:56 +04:00
|
|
|
"frame %4d/%-4d %7"PRId64"B ",
|
|
|
|
frames_in, streams->frames_out, (int64_t)streams->nbytes);
|
2012-11-07 00:02:42 +04:00
|
|
|
else
|
2013-02-13 09:17:56 +04:00
|
|
|
fprintf(stderr, "frame %4d ", frames_in);
|
|
|
|
|
2013-02-27 23:14:23 +04:00
|
|
|
fprintf(stderr, "%7"PRId64" %s %.2f %s ",
|
2013-02-13 09:17:56 +04:00
|
|
|
cx_time > 9999999 ? cx_time / 1000 : cx_time,
|
|
|
|
cx_time > 9999999 ? "ms" : "us",
|
2013-09-18 03:31:46 +04:00
|
|
|
fps >= 1.0 ? fps : fps * 60,
|
|
|
|
fps >= 1.0 ? "fps" : "fpm");
|
2013-02-13 09:17:56 +04:00
|
|
|
print_time("ETA", estimated_time_left);
|
|
|
|
fprintf(stderr, "\033[K");
|
2012-11-07 00:02:42 +04:00
|
|
|
}
|
2012-02-16 00:39:38 +04:00
|
|
|
|
2012-07-14 02:21:29 +04:00
|
|
|
} else
|
|
|
|
frame_avail = 0;
|
2012-02-16 00:39:38 +04:00
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
if (frames_in > global.skip_frames) {
|
|
|
|
vpx_usec_timer_start(&timer);
|
|
|
|
FOREACH_STREAM(encode_frame(stream, &global,
|
|
|
|
frame_avail ? &raw : NULL,
|
|
|
|
frames_in));
|
|
|
|
vpx_usec_timer_mark(&timer);
|
2013-02-27 23:14:23 +04:00
|
|
|
cx_time += vpx_usec_timer_elapsed(&timer);
|
2010-05-18 19:58:33 +04:00
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
FOREACH_STREAM(update_quantizer_histogram(stream));
|
2010-05-18 19:58:33 +04:00
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
got_data = 0;
|
|
|
|
FOREACH_STREAM(get_cx_data(stream, &global, &got_data));
|
2010-05-18 19:58:33 +04:00
|
|
|
|
2013-02-13 09:17:56 +04:00
|
|
|
if (!got_data && input.length && !streams->frames_out) {
|
2013-03-12 02:03:00 +04:00
|
|
|
lagged_count = global.limit ? seen_frames : ftello(input.file);
|
2013-02-27 23:14:23 +04:00
|
|
|
} else if (input.length) {
|
2013-02-13 09:17:56 +04:00
|
|
|
int64_t remaining;
|
|
|
|
int64_t rate;
|
|
|
|
|
|
|
|
if (global.limit) {
|
2013-03-12 02:03:00 +04:00
|
|
|
int frame_in_lagged = (seen_frames - lagged_count) * 1000;
|
2013-02-13 09:17:56 +04:00
|
|
|
|
|
|
|
rate = cx_time ? frame_in_lagged * (int64_t)1000000 / cx_time : 0;
|
2013-03-12 02:03:00 +04:00
|
|
|
remaining = 1000 * (global.limit - global.skip_frames
|
|
|
|
- seen_frames + lagged_count);
|
2013-02-13 09:17:56 +04:00
|
|
|
} else {
|
|
|
|
off_t input_pos = ftello(input.file);
|
|
|
|
off_t input_pos_lagged = input_pos - lagged_count;
|
|
|
|
int64_t limit = input.length;
|
|
|
|
|
|
|
|
rate = cx_time ? input_pos_lagged * (int64_t)1000000 / cx_time : 0;
|
|
|
|
remaining = limit - input_pos + lagged_count;
|
|
|
|
}
|
|
|
|
|
|
|
|
average_rate = (average_rate <= 0)
|
|
|
|
? rate
|
|
|
|
: (average_rate * 7 + rate) / 8;
|
|
|
|
estimated_time_left = average_rate ? remaining / average_rate : -1;
|
|
|
|
}
|
|
|
|
|
2013-02-16 04:31:02 +04:00
|
|
|
if (got_data && global.test_decode != TEST_DECODE_OFF)
|
2013-03-13 23:15:43 +04:00
|
|
|
FOREACH_STREAM(test_decode(stream, global.test_decode, global.codec));
|
2012-07-14 02:21:29 +04:00
|
|
|
}
|
2010-05-18 19:58:33 +04:00
|
|
|
|
2012-07-14 02:21:29 +04:00
|
|
|
fflush(stdout);
|
2010-05-18 19:58:33 +04:00
|
|
|
}
|
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
if (stream_cnt > 1)
|
|
|
|
fprintf(stderr, "\n");
|
|
|
|
|
|
|
|
if (!global.quiet)
|
|
|
|
FOREACH_STREAM(fprintf(
|
|
|
|
stderr,
|
|
|
|
"\rPass %d/%d frame %4d/%-4d %7"PRId64"B %7lub/f %7"PRId64"b/s"
|
|
|
|
" %7"PRId64" %s (%.2f fps)\033[K\n", pass + 1,
|
|
|
|
global.passes, frames_in, stream->frames_out, (int64_t)stream->nbytes,
|
2013-03-12 02:03:00 +04:00
|
|
|
seen_frames ? (unsigned long)(stream->nbytes * 8 / seen_frames) : 0,
|
|
|
|
seen_frames ? (int64_t)stream->nbytes * 8
|
2012-11-07 00:02:42 +04:00
|
|
|
* (int64_t)global.framerate.num / global.framerate.den
|
2013-03-12 02:03:00 +04:00
|
|
|
/ seen_frames
|
2012-11-07 00:02:42 +04:00
|
|
|
: 0,
|
|
|
|
stream->cx_time > 9999999 ? stream->cx_time / 1000 : stream->cx_time,
|
|
|
|
stream->cx_time > 9999999 ? "ms" : "us",
|
2013-03-12 02:03:00 +04:00
|
|
|
usec_to_fps(stream->cx_time, seen_frames));
|
2012-11-07 00:02:42 +04:00
|
|
|
);
|
|
|
|
|
|
|
|
if (global.show_psnr)
|
|
|
|
FOREACH_STREAM(show_psnr(stream));
|
|
|
|
|
|
|
|
FOREACH_STREAM(vpx_codec_destroy(&stream->encoder));
|
|
|
|
|
2013-02-16 04:31:02 +04:00
|
|
|
if (global.test_decode != TEST_DECODE_OFF) {
|
2012-11-07 00:02:42 +04:00
|
|
|
FOREACH_STREAM(vpx_codec_destroy(&stream->decoder));
|
2012-07-14 02:21:29 +04:00
|
|
|
}
|
2011-06-21 01:09:29 +04:00
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
close_input_file(&input);
|
2010-05-18 19:58:33 +04:00
|
|
|
|
2013-02-16 04:31:02 +04:00
|
|
|
if (global.test_decode == TEST_DECODE_FATAL) {
|
|
|
|
FOREACH_STREAM(res |= stream->mismatch_seen);
|
|
|
|
}
|
2012-11-07 00:02:42 +04:00
|
|
|
FOREACH_STREAM(close_output_file(stream, global.codec->fourcc));
|
2010-05-18 19:58:33 +04:00
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
FOREACH_STREAM(stats_close(&stream->stats, global.passes - 1));
|
2012-07-14 02:21:29 +04:00
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
if (global.pass)
|
2012-07-14 02:21:29 +04:00
|
|
|
break;
|
|
|
|
}
|
2011-06-22 00:42:33 +04:00
|
|
|
|
2012-11-07 00:02:42 +04:00
|
|
|
if (global.show_q_hist_buckets)
|
|
|
|
FOREACH_STREAM(show_q_histogram(stream->counts,
|
|
|
|
global.show_q_hist_buckets));
|
|
|
|
|
|
|
|
if (global.show_rate_hist_buckets)
|
2014-01-30 00:28:29 +04:00
|
|
|
FOREACH_STREAM(show_rate_histogram(stream->rate_hist,
|
2012-11-07 00:02:42 +04:00
|
|
|
&stream->config.cfg,
|
|
|
|
global.show_rate_hist_buckets));
|
2014-01-30 00:28:29 +04:00
|
|
|
FOREACH_STREAM(destroy_rate_histogram(stream->rate_hist));
|
2012-11-07 00:02:42 +04:00
|
|
|
|
2012-10-11 21:13:48 +04:00
|
|
|
#if CONFIG_INTERNAL_STATS
|
2012-11-07 00:02:42 +04:00
|
|
|
/* TODO(jkoleszar): This doesn't belong in this executable. Do it for now,
|
|
|
|
* to match some existing utilities.
|
|
|
|
*/
|
2013-10-17 03:29:28 +04:00
|
|
|
if (!(global.pass == 1 && global.passes == 2))
|
|
|
|
FOREACH_STREAM({
|
|
|
|
FILE *f = fopen("opsnr.stt", "a");
|
|
|
|
if (stream->mismatch_seen) {
|
|
|
|
fprintf(f, "First mismatch occurred in frame %d\n",
|
|
|
|
stream->mismatch_seen);
|
|
|
|
} else {
|
|
|
|
fprintf(f, "No mismatch detected in recon buffers\n");
|
|
|
|
}
|
|
|
|
fclose(f);
|
|
|
|
});
|
2012-10-11 21:13:48 +04:00
|
|
|
#endif
|
2011-06-22 00:42:33 +04:00
|
|
|
|
2012-07-14 02:21:29 +04:00
|
|
|
vpx_img_free(&raw);
|
|
|
|
free(argv);
|
2012-11-07 00:02:42 +04:00
|
|
|
free(streams);
|
2013-02-16 04:31:02 +04:00
|
|
|
return res ? EXIT_FAILURE : EXIT_SUCCESS;
|
2010-05-18 19:58:33 +04:00
|
|
|
}
|