12#include "./vpx_config.h"
23#include "third_party/libyuv/include/libyuv/scale.h"
33#include "./tools_common.h"
35#if CONFIG_VP8_ENCODER || CONFIG_VP9_ENCODER
38#if CONFIG_VP8_DECODER || CONFIG_VP9_DECODER
42#include "vpx/vpx_integer.h"
43#include "vpx_ports/mem_ops.h"
44#include "vpx_ports/vpx_timer.h"
45#include "./rate_hist.h"
46#include "./vpxstats.h"
47#include "./warnings.h"
51#include "./y4minput.h"
53static size_t wrap_fwrite(
const void *ptr,
size_t size,
size_t nmemb,
55 return fwrite(ptr, size, nmemb, stream);
57#define fwrite wrap_fwrite
59static const char *exec_name;
61static VPX_TOOLS_FORMAT_PRINTF(3, 0) void warn_or_exit_on_errorv(
66 vfprintf(stderr, s, ap);
69 if (detail) fprintf(stderr,
" %s\n", detail);
71 if (fatal) exit(EXIT_FAILURE);
75static VPX_TOOLS_FORMAT_PRINTF(2,
81 warn_or_exit_on_errorv(ctx, 1, s, ap);
85static VPX_TOOLS_FORMAT_PRINTF(3, 4) void warn_or_exit_on_error(
90 warn_or_exit_on_errorv(ctx, fatal, s, ap);
94static const arg_def_t help =
95 ARG_DEF(NULL,
"help", 0,
"Show usage options and exit");
96static const arg_def_t debugmode =
97 ARG_DEF(
"D",
"debug", 0,
"Debug mode (makes output deterministic)");
98static const arg_def_t outputfile =
99 ARG_DEF(
"o",
"output", 1,
"Output filename");
100static const arg_def_t use_nv12 =
101 ARG_DEF(NULL,
"nv12", 0,
"Input file is NV12 ");
102static const arg_def_t use_yv12 =
103 ARG_DEF(NULL,
"yv12", 0,
"Input file is YV12 ");
104static const arg_def_t use_i420 =
105 ARG_DEF(NULL,
"i420", 0,
"Input file is I420 (default)");
106static const arg_def_t use_i422 =
107 ARG_DEF(NULL,
"i422", 0,
"Input file is I422");
108static const arg_def_t use_i444 =
109 ARG_DEF(NULL,
"i444", 0,
"Input file is I444");
110static const arg_def_t use_i440 =
111 ARG_DEF(NULL,
"i440", 0,
"Input file is I440");
112static const arg_def_t codecarg = ARG_DEF(NULL,
"codec", 1,
"Codec to use");
113static const arg_def_t passes =
114 ARG_DEF(
"p",
"passes", 1,
"Number of passes (1/2)");
115static const arg_def_t pass_arg =
116 ARG_DEF(NULL,
"pass", 1,
"Pass to execute (1/2)");
117static const arg_def_t fpf_name =
118 ARG_DEF(NULL,
"fpf", 1,
"First pass statistics file name");
119static const arg_def_t limit =
120 ARG_DEF(NULL,
"limit", 1,
"Stop encoding after n input frames");
121static const arg_def_t skip =
122 ARG_DEF(NULL,
"skip", 1,
"Skip the first n input frames");
123static const arg_def_t deadline =
124 ARG_DEF(
"d",
"deadline", 1,
"Deadline per frame (usec)");
125static const arg_def_t best_dl =
126 ARG_DEF(NULL,
"best", 0,
"Use Best Quality Deadline");
127static const arg_def_t good_dl =
128 ARG_DEF(NULL,
"good", 0,
"Use Good Quality Deadline");
129static const arg_def_t rt_dl =
130 ARG_DEF(NULL,
"rt", 0,
"Use Realtime Quality Deadline");
131static const arg_def_t quietarg =
132 ARG_DEF(
"q",
"quiet", 0,
"Do not print encode progress");
133static const arg_def_t verbosearg =
134 ARG_DEF(
"v",
"verbose", 0,
"Show encoder parameters");
135static const arg_def_t psnrarg =
136 ARG_DEF(NULL,
"psnr", 0,
"Show PSNR in status line");
138static const struct arg_enum_list test_decode_enum[] = {
139 {
"off", TEST_DECODE_OFF },
140 {
"fatal", TEST_DECODE_FATAL },
141 {
"warn", TEST_DECODE_WARN },
144static const arg_def_t recontest = ARG_DEF_ENUM(
145 NULL,
"test-decode", 1,
"Test encode/decode mismatch", test_decode_enum);
146static const arg_def_t framerate =
147 ARG_DEF(NULL,
"fps", 1,
"Stream frame rate (rate/scale)");
148static const arg_def_t use_webm =
149 ARG_DEF(NULL,
"webm", 0,
"Output WebM (default when WebM IO is enabled)");
150static const arg_def_t use_ivf = ARG_DEF(NULL,
"ivf", 0,
"Output IVF");
151static const arg_def_t out_part =
152 ARG_DEF(
"P",
"output-partitions", 0,
153 "Makes encoder output partitions. Requires IVF output!");
154static const arg_def_t q_hist_n =
155 ARG_DEF(NULL,
"q-hist", 1,
"Show quantizer histogram (n-buckets)");
156static const arg_def_t rate_hist_n =
157 ARG_DEF(NULL,
"rate-hist", 1,
"Show rate histogram (n-buckets)");
158static const arg_def_t disable_warnings =
159 ARG_DEF(NULL,
"disable-warnings", 0,
160 "Disable warnings about potentially incorrect encode settings.");
161static const arg_def_t disable_warning_prompt =
162 ARG_DEF(
"y",
"disable-warning-prompt", 0,
163 "Display warnings, but do not prompt user to continue.");
165#if CONFIG_VP9_HIGHBITDEPTH
166static const arg_def_t test16bitinternalarg = ARG_DEF(
167 NULL,
"test-16bit-internal", 0,
"Force use of 16 bit internal buffer");
170static const arg_def_t *main_args[] = { &help,
192 &disable_warning_prompt,
196static const arg_def_t usage =
197 ARG_DEF(
"u",
"usage", 1,
"Usage profile number to use");
198static const arg_def_t threads =
199 ARG_DEF(
"t",
"threads", 1,
"Max number of threads to use");
200static const arg_def_t profile =
201 ARG_DEF(NULL,
"profile", 1,
"Bitstream profile number to use");
202static const arg_def_t width = ARG_DEF(
"w",
"width", 1,
"Frame width");
203static const arg_def_t height = ARG_DEF(
"h",
"height", 1,
"Frame height");
205static const struct arg_enum_list stereo_mode_enum[] = {
206 {
"mono", STEREO_FORMAT_MONO },
207 {
"left-right", STEREO_FORMAT_LEFT_RIGHT },
208 {
"bottom-top", STEREO_FORMAT_BOTTOM_TOP },
209 {
"top-bottom", STEREO_FORMAT_TOP_BOTTOM },
210 {
"right-left", STEREO_FORMAT_RIGHT_LEFT },
213static const arg_def_t stereo_mode = ARG_DEF_ENUM(
214 NULL,
"stereo-mode", 1,
"Stereo 3D video format", stereo_mode_enum);
216static const arg_def_t timebase = ARG_DEF(
217 NULL,
"timebase", 1,
"Output timestamp precision (fractional seconds)");
218static const arg_def_t error_resilient =
219 ARG_DEF(NULL,
"error-resilient", 1,
"Enable error resiliency features");
220static const arg_def_t lag_in_frames =
221 ARG_DEF(NULL,
"lag-in-frames", 1,
"Max number of frames to lag");
223static const arg_def_t *global_args[] = { &use_nv12,
240#if CONFIG_VP9_HIGHBITDEPTH
241 &test16bitinternalarg,
246static const arg_def_t dropframe_thresh =
247 ARG_DEF(NULL,
"drop-frame", 1,
"Temporal resampling threshold (buf %)");
248static const arg_def_t resize_allowed =
249 ARG_DEF(NULL,
"resize-allowed", 1,
"Spatial resampling enabled (bool)");
250static const arg_def_t resize_width =
251 ARG_DEF(NULL,
"resize-width", 1,
"Width of encoded frame");
252static const arg_def_t resize_height =
253 ARG_DEF(NULL,
"resize-height", 1,
"Height of encoded frame");
254static const arg_def_t resize_up_thresh =
255 ARG_DEF(NULL,
"resize-up", 1,
"Upscale threshold (buf %)");
256static const arg_def_t resize_down_thresh =
257 ARG_DEF(NULL,
"resize-down", 1,
"Downscale threshold (buf %)");
258static const struct arg_enum_list end_usage_enum[] = { {
"vbr",
VPX_VBR },
263static const arg_def_t end_usage =
264 ARG_DEF_ENUM(NULL,
"end-usage", 1,
"Rate control mode", end_usage_enum);
265static const arg_def_t target_bitrate =
266 ARG_DEF(NULL,
"target-bitrate", 1,
"Bitrate (kbps)");
267static const arg_def_t min_quantizer =
268 ARG_DEF(NULL,
"min-q", 1,
"Minimum (best) quantizer");
269static const arg_def_t max_quantizer =
270 ARG_DEF(NULL,
"max-q", 1,
"Maximum (worst) quantizer");
271static const arg_def_t undershoot_pct =
272 ARG_DEF(NULL,
"undershoot-pct", 1,
"Datarate undershoot (min) target (%)");
273static const arg_def_t overshoot_pct =
274 ARG_DEF(NULL,
"overshoot-pct", 1,
"Datarate overshoot (max) target (%)");
275static const arg_def_t buf_sz =
276 ARG_DEF(NULL,
"buf-sz", 1,
"Client buffer size (ms)");
277static const arg_def_t buf_initial_sz =
278 ARG_DEF(NULL,
"buf-initial-sz", 1,
"Client initial buffer size (ms)");
279static const arg_def_t buf_optimal_sz =
280 ARG_DEF(NULL,
"buf-optimal-sz", 1,
"Client optimal buffer size (ms)");
281static const arg_def_t *rc_args[] = {
282 &dropframe_thresh, &resize_allowed, &resize_width, &resize_height,
283 &resize_up_thresh, &resize_down_thresh, &end_usage, &target_bitrate,
284 &min_quantizer, &max_quantizer, &undershoot_pct, &overshoot_pct,
285 &buf_sz, &buf_initial_sz, &buf_optimal_sz, NULL
288#if CONFIG_VP9_ENCODER
289static const arg_def_t use_vizier_rc_params =
290 ARG_DEF(NULL,
"use-vizier-rc-params", 1,
"Use vizier rc params");
291static const arg_def_t active_wq_factor =
292 ARG_DEF(NULL,
"active-wq-factor", 1,
"Active worst quality factor");
293static const arg_def_t err_per_mb_factor =
294 ARG_DEF(NULL,
"err-per-mb-factor", 1,
"Error per macroblock factor");
295static const arg_def_t sr_default_decay_limit = ARG_DEF(
296 NULL,
"sr-default-decay-limit", 1,
"Second reference default decay limit");
297static const arg_def_t sr_diff_factor =
298 ARG_DEF(NULL,
"sr-diff-factor", 1,
"Second reference diff factor");
299static const arg_def_t kf_err_per_mb_factor = ARG_DEF(
300 NULL,
"kf-err-per-mb-factor", 1,
"Keyframe error per macroblock factor");
301static const arg_def_t kf_frame_min_boost_factor =
302 ARG_DEF(NULL,
"kf-frame-min-boost-factor", 1,
"Keyframe min boost");
303static const arg_def_t kf_frame_max_boost_first_factor =
304 ARG_DEF(NULL,
"kf-frame-max-boost-first-factor", 1,
305 "Max keyframe boost adjustment factor for first frame");
306static const arg_def_t kf_frame_max_boost_subs_factor =
307 ARG_DEF(NULL,
"kf-frame-max-boost-subs-factor", 1,
308 "Max boost adjustment factor for subsequent KFs");
309static const arg_def_t kf_max_total_boost_factor = ARG_DEF(
310 NULL,
"kf-max-total-boost-factor", 1,
"Keyframe max total boost factor");
311static const arg_def_t gf_max_total_boost_factor =
312 ARG_DEF(NULL,
"gf-max-total-boost-factor", 1,
313 "Golden frame max total boost factor");
314static const arg_def_t gf_frame_max_boost_factor =
315 ARG_DEF(NULL,
"gf-frame-max-boost-factor", 1,
316 "Golden frame max per frame boost factor");
317static const arg_def_t zm_factor =
318 ARG_DEF(NULL,
"zm-factor", 1,
"Zero motion power factor");
319static const arg_def_t rd_mult_inter_qp_fac =
320 ARG_DEF(NULL,
"rd-mult-inter-qp-fac", 1,
321 "RD multiplier adjustment for inter frames");
322static const arg_def_t rd_mult_arf_qp_fac =
323 ARG_DEF(NULL,
"rd-mult-arf-qp-fac", 1,
324 "RD multiplier adjustment for alt-ref frames");
325static const arg_def_t rd_mult_key_qp_fac = ARG_DEF(
326 NULL,
"rd-mult-key-qp-fac", 1,
"RD multiplier adjustment for key frames");
327static const arg_def_t *vizier_rc_args[] = { &use_vizier_rc_params,
330 &sr_default_decay_limit,
332 &kf_err_per_mb_factor,
333 &kf_frame_min_boost_factor,
334 &kf_frame_max_boost_first_factor,
335 &kf_frame_max_boost_subs_factor,
336 &kf_max_total_boost_factor,
337 &gf_max_total_boost_factor,
338 &gf_frame_max_boost_factor,
340 &rd_mult_inter_qp_fac,
346static const arg_def_t bias_pct =
347 ARG_DEF(NULL,
"bias-pct", 1,
"CBR/VBR bias (0=CBR, 100=VBR)");
348static const arg_def_t minsection_pct =
349 ARG_DEF(NULL,
"minsection-pct", 1,
"GOP min bitrate (% of target)");
350static const arg_def_t maxsection_pct =
351 ARG_DEF(NULL,
"maxsection-pct", 1,
"GOP max bitrate (% of target)");
352static const arg_def_t corpus_complexity =
353 ARG_DEF(NULL,
"corpus-complexity", 1,
"corpus vbr complexity midpoint");
354static const arg_def_t *rc_twopass_args[] = { &bias_pct, &minsection_pct,
356 &corpus_complexity, NULL };
358static const arg_def_t kf_min_dist =
359 ARG_DEF(NULL,
"kf-min-dist", 1,
"Minimum keyframe interval (frames)");
360static const arg_def_t kf_max_dist =
361 ARG_DEF(NULL,
"kf-max-dist", 1,
"Maximum keyframe interval (frames)");
362static const arg_def_t kf_disabled =
363 ARG_DEF(NULL,
"disable-kf", 0,
"Disable keyframe placement");
364static const arg_def_t *kf_args[] = { &kf_min_dist, &kf_max_dist, &kf_disabled,
367static const arg_def_t noise_sens =
368 ARG_DEF(NULL,
"noise-sensitivity", 1,
"Noise sensitivity (frames to blur)");
369static const arg_def_t sharpness =
370 ARG_DEF(NULL,
"sharpness", 1,
371 "Increase sharpness at the expense of lower PSNR. (0..7)");
372static const arg_def_t static_thresh =
373 ARG_DEF(NULL,
"static-thresh", 1,
"Motion detection threshold");
374static const arg_def_t arnr_maxframes =
375 ARG_DEF(NULL,
"arnr-maxframes", 1,
"AltRef max frames (0..15)");
376static const arg_def_t arnr_strength =
377 ARG_DEF(NULL,
"arnr-strength", 1,
"AltRef filter strength (0..6)");
378static const arg_def_t arnr_type =
379 ARG_DEF(NULL,
"arnr-type", 1,
"AltRef filter type (1..3)");
380static const struct arg_enum_list tuning_enum[] = { {
"psnr", VP8_TUNE_PSNR },
381 {
"ssim", VP8_TUNE_SSIM },
383static const arg_def_t tune_ssim =
384 ARG_DEF_ENUM(NULL,
"tune", 1,
"Material to favor", tuning_enum);
385static const arg_def_t cq_level =
386 ARG_DEF(NULL,
"cq-level", 1,
"Constant/Constrained Quality level");
387static const arg_def_t max_intra_rate_pct =
388 ARG_DEF(NULL,
"max-intra-rate", 1,
"Max I-frame bitrate (pct)");
389static const arg_def_t gf_cbr_boost_pct = ARG_DEF(
390 NULL,
"gf-cbr-boost", 1,
"Boost for Golden Frame in CBR mode (pct)");
392#if CONFIG_VP8_ENCODER
393static const arg_def_t cpu_used_vp8 =
394 ARG_DEF(NULL,
"cpu-used", 1,
"CPU Used (-16..16)");
395static const arg_def_t auto_altref_vp8 = ARG_DEF(
396 NULL,
"auto-alt-ref", 1,
"Enable automatic alt reference frames. (0..1)");
397static const arg_def_t token_parts =
398 ARG_DEF(NULL,
"token-parts", 1,
"Number of token partitions to use, log2");
399static const arg_def_t screen_content_mode =
400 ARG_DEF(NULL,
"screen-content-mode", 1,
"Screen content mode");
401static const arg_def_t *vp8_args[] = { &cpu_used_vp8,
414 &screen_content_mode,
433#if CONFIG_VP9_ENCODER
434static const arg_def_t cpu_used_vp9 =
435 ARG_DEF(NULL,
"cpu-used", 1,
"CPU Used (-9..9)");
436static const arg_def_t auto_altref_vp9 = ARG_DEF(
437 NULL,
"auto-alt-ref", 1,
438 "Enable automatic alt reference frames, 2+ enables multi-layer. (0..6)");
439static const arg_def_t tile_cols =
440 ARG_DEF(NULL,
"tile-columns", 1,
"Number of tile columns to use, log2");
441static const arg_def_t tile_rows =
442 ARG_DEF(NULL,
"tile-rows", 1,
443 "Number of tile rows to use, log2 (set to 0 while threads > 1)");
445static const arg_def_t enable_tpl_model =
446 ARG_DEF(NULL,
"enable-tpl", 1,
"Enable temporal dependency model");
448static const arg_def_t lossless =
449 ARG_DEF(NULL,
"lossless", 1,
"Lossless mode (0: false (default), 1: true)");
450static const arg_def_t frame_parallel_decoding = ARG_DEF(
451 NULL,
"frame-parallel", 1,
"Enable frame parallel decodability features");
452static const arg_def_t aq_mode = ARG_DEF(
454 "Adaptive quantization mode (0: off (default), 1: variance 2: complexity, "
455 "3: cyclic refresh, 4: equator360)");
456static const arg_def_t alt_ref_aq = ARG_DEF(NULL,
"alt-ref-aq", 1,
457 "Special adaptive quantization for "
458 "the alternate reference frames.");
459static const arg_def_t frame_periodic_boost =
460 ARG_DEF(NULL,
"frame-boost", 1,
461 "Enable frame periodic boost (0: off (default), 1: on)");
462static const arg_def_t max_inter_rate_pct =
463 ARG_DEF(NULL,
"max-inter-rate", 1,
"Max P-frame bitrate (pct)");
464static const arg_def_t min_gf_interval = ARG_DEF(
465 NULL,
"min-gf-interval", 1,
466 "min gf/arf frame interval (default 0, indicating in-built behavior)");
467static const arg_def_t max_gf_interval = ARG_DEF(
468 NULL,
"max-gf-interval", 1,
469 "max gf/arf frame interval (default 0, indicating in-built behavior)");
471static const struct arg_enum_list color_space_enum[] = {
483static const arg_def_t input_color_space =
484 ARG_DEF_ENUM(NULL,
"color-space", 1,
485 "The color space of input content:", color_space_enum);
487#if CONFIG_VP9_HIGHBITDEPTH
488static const struct arg_enum_list bitdepth_enum[] = {
492static const arg_def_t bitdeptharg = ARG_DEF_ENUM(
494 "Bit depth for codec (8 for version <=1, 10 or 12 for version 2)",
496static const arg_def_t inbitdeptharg =
497 ARG_DEF(NULL,
"input-bit-depth", 1,
"Bit depth of input");
500static const struct arg_enum_list tune_content_enum[] = {
501 {
"default", VP9E_CONTENT_DEFAULT },
502 {
"screen", VP9E_CONTENT_SCREEN },
503 {
"film", VP9E_CONTENT_FILM },
507static const arg_def_t tune_content = ARG_DEF_ENUM(
508 NULL,
"tune-content", 1,
"Tune content type", tune_content_enum);
510static const arg_def_t target_level = ARG_DEF(
511 NULL,
"target-level", 1,
513 " 255: off (default)\n"
514 " 0: only keep level stats\n"
515 " 1: adaptively set alt-ref "
516 "distance and column tile limit based on picture size, and keep"
518 " 10: level 1.0 11: level 1.1 "
519 "... 62: level 6.2");
521static const arg_def_t row_mt =
522 ARG_DEF(NULL,
"row-mt", 1,
523 "Enable row based non-deterministic multi-threading in VP9");
525static const arg_def_t disable_loopfilter =
526 ARG_DEF(NULL,
"disable-loopfilter", 1,
527 "Control Loopfilter in VP9:\n"
529 "0: Loopfilter on for all frames (default)\n"
531 "1: Loopfilter off for non reference frames\n"
533 "2: Loopfilter off for all frames");
536#if CONFIG_VP9_ENCODER
537static const arg_def_t *vp9_args[] = { &cpu_used_vp9,
553 &frame_parallel_decoding,
556 &frame_periodic_boost,
568#if CONFIG_VP9_HIGHBITDEPTH
604static const arg_def_t *no_args[] = { NULL };
606static void show_help(FILE *fout,
int shorthelp) {
608 const int num_encoder = get_vpx_encoder_count();
610 fprintf(fout,
"Usage: %s <options> -o dst_filename src_filename \n",
614 fprintf(fout,
"Use --help to see the full list of options.\n");
618 fprintf(fout,
"\nOptions:\n");
619 arg_show_usage(fout, main_args);
620 fprintf(fout,
"\nEncoder Global Options:\n");
621 arg_show_usage(fout, global_args);
622 fprintf(fout,
"\nRate Control Options:\n");
623 arg_show_usage(fout, rc_args);
624 fprintf(fout,
"\nTwopass Rate Control Options:\n");
625 arg_show_usage(fout, rc_twopass_args);
626 fprintf(fout,
"\nKeyframe Placement Options:\n");
627 arg_show_usage(fout, kf_args);
628#if CONFIG_VP8_ENCODER
629 fprintf(fout,
"\nVP8 Specific Options:\n");
630 arg_show_usage(fout, vp8_args);
632#if CONFIG_VP9_ENCODER
633 fprintf(fout,
"\nVP9 Specific Options:\n");
634 arg_show_usage(fout, vp9_args);
635 fprintf(fout,
"\nVizier Rate Control Options:\n");
636 arg_show_usage(fout, vizier_rc_args);
639 "\nStream timebase (--timebase):\n"
640 " The desired precision of timestamps in the output, expressed\n"
641 " in fractional seconds. Default is 1/1000.\n");
642 fprintf(fout,
"\nIncluded encoders:\n\n");
644 for (i = 0; i < num_encoder; ++i) {
645 const VpxInterface *
const encoder = get_vpx_encoder_by_index(i);
646 const char *defstr = (i == (num_encoder - 1)) ?
"(default)" :
"";
647 fprintf(fout,
" %-6s - %s %s\n", encoder->name,
650 fprintf(fout,
"\n ");
651 fprintf(fout,
"Use --codec to switch to a non-default encoder.\n\n");
654void usage_exit(
void) {
655 show_help(stderr, 1);
659#define NELEMENTS(x) (sizeof(x) / sizeof(x[0]))
660#if CONFIG_VP9_ENCODER
661#define ARG_CTRL_CNT_MAX NELEMENTS(vp9_arg_ctrl_map)
663#define ARG_CTRL_CNT_MAX NELEMENTS(vp8_arg_ctrl_map)
667typedef int stereo_format_t;
668struct WebmOutputContext {
674struct stream_config {
677 const char *stats_fn;
678 stereo_format_t stereo_fmt;
679 int arg_ctrls[ARG_CTRL_CNT_MAX][2];
682#if CONFIG_VP9_HIGHBITDEPTH
684 int use_16bit_internal;
690 struct stream_state *next;
691 struct stream_config config;
693 struct rate_hist *rate_hist;
694 struct WebmOutputContext webm_ctx;
695 uint64_t psnr_sse_total;
696 uint64_t psnr_samples_total;
697 double psnr_totals[4];
701 unsigned int frames_out;
710static void validate_positive_rational(
const char *msg,
717 if (rat->
num < 0) die(
"Error: %s must be positive\n", msg);
719 if (!rat->
den) die(
"Error: %s has zero denominator\n", msg);
722static void parse_global_config(
struct VpxEncoderConfig *global,
char **argv) {
725 const int num_encoder = get_vpx_encoder_count();
727 if (num_encoder < 1) die(
"Error: no valid encoder available\n");
730 memset(global, 0,
sizeof(*global));
731 global->codec = get_vpx_encoder_by_index(num_encoder - 1);
733 global->color_type = I420;
737 for (argi = argj = argv; (*argj = *argi); argi += arg.argv_step) {
740 if (arg_match(&arg, &help, argi)) {
741 show_help(stdout, 0);
743 }
else if (arg_match(&arg, &codecarg, argi)) {
744 global->codec = get_vpx_encoder_by_name(arg.val);
746 die(
"Error: Unrecognized argument (%s) to --codec\n", arg.val);
747 }
else if (arg_match(&arg, &passes, argi)) {
748 global->passes = arg_parse_uint(&arg);
750 if (global->passes < 1 || global->passes > 2)
751 die(
"Error: Invalid number of passes (%d)\n", global->passes);
752 }
else if (arg_match(&arg, &pass_arg, argi)) {
753 global->pass = arg_parse_uint(&arg);
755 if (global->pass < 1 || global->pass > 2)
756 die(
"Error: Invalid pass selected (%d)\n", global->pass);
757 }
else if (arg_match(&arg, &usage, argi))
758 global->usage = arg_parse_uint(&arg);
759 else if (arg_match(&arg, &deadline, argi))
760 global->deadline = arg_parse_uint(&arg);
761 else if (arg_match(&arg, &best_dl, argi))
763 else if (arg_match(&arg, &good_dl, argi))
765 else if (arg_match(&arg, &rt_dl, argi))
767 else if (arg_match(&arg, &use_yv12, argi))
768 global->color_type = YV12;
769 else if (arg_match(&arg, &use_nv12, argi))
770 global->color_type = NV12;
771 else if (arg_match(&arg, &use_i420, argi))
772 global->color_type = I420;
773 else if (arg_match(&arg, &use_i422, argi))
774 global->color_type = I422;
775 else if (arg_match(&arg, &use_i444, argi))
776 global->color_type = I444;
777 else if (arg_match(&arg, &use_i440, argi))
778 global->color_type = I440;
779 else if (arg_match(&arg, &quietarg, argi))
781 else if (arg_match(&arg, &verbosearg, argi))
783 else if (arg_match(&arg, &limit, argi))
784 global->limit = arg_parse_uint(&arg);
785 else if (arg_match(&arg, &skip, argi))
786 global->skip_frames = arg_parse_uint(&arg);
787 else if (arg_match(&arg, &psnrarg, argi))
788 global->show_psnr = 1;
789 else if (arg_match(&arg, &recontest, argi))
790 global->test_decode = arg_parse_enum_or_int(&arg);
791 else if (arg_match(&arg, &framerate, argi)) {
792 global->framerate = arg_parse_rational(&arg);
793 validate_positive_rational(arg.name, &global->framerate);
794 global->have_framerate = 1;
795 }
else if (arg_match(&arg, &out_part, argi))
796 global->out_part = 1;
797 else if (arg_match(&arg, &debugmode, argi))
799 else if (arg_match(&arg, &q_hist_n, argi))
800 global->show_q_hist_buckets = arg_parse_uint(&arg);
801 else if (arg_match(&arg, &rate_hist_n, argi))
802 global->show_rate_hist_buckets = arg_parse_uint(&arg);
803 else if (arg_match(&arg, &disable_warnings, argi))
804 global->disable_warnings = 1;
805 else if (arg_match(&arg, &disable_warning_prompt, argi))
806 global->disable_warning_prompt = 1;
813 if (global->pass > global->passes) {
814 warn(
"Assuming --pass=%d implies --passes=%d\n", global->pass,
816 global->passes = global->pass;
820 if (global->passes == 0) {
821#if CONFIG_VP9_ENCODER
824 if (global->codec != NULL && global->codec->name != NULL)
825 global->passes = (strcmp(global->codec->name,
"vp9") == 0 &&
835 warn(
"Enforcing one-pass encoding in realtime mode\n");
840static struct stream_state *new_stream(
struct VpxEncoderConfig *global,
841 struct stream_state *prev) {
842 struct stream_state *stream;
844 stream = calloc(1,
sizeof(*stream));
845 if (stream == NULL) {
846 fatal(
"Failed to allocate new stream.");
850 memcpy(stream, prev,
sizeof(*stream));
858 &stream->config.cfg, global->usage);
864 stream->config.cfg.g_timebase.den = 1000;
869 stream->config.cfg.g_w = 0;
870 stream->config.cfg.g_h = 0;
873 stream->config.write_webm = 1;
875 stream->config.stereo_fmt = STEREO_FORMAT_MONO;
876 stream->webm_ctx.last_pts_ns = -1;
877 stream->webm_ctx.writer = NULL;
878 stream->webm_ctx.segment = NULL;
882 stream->webm_ctx.debug = global->debug;
886 stream->config.cfg.rc_end_usage == 1)
887 stream->config.cfg.g_lag_in_frames = 0;
891 stream->config.out_fn = NULL;
897static int parse_stream_params(
struct VpxEncoderConfig *global,
898 struct stream_state *stream,
char **argv) {
901 static const arg_def_t **ctrl_args = no_args;
902 static const int *ctrl_args_map = NULL;
903 struct stream_config *config = &stream->config;
904 int eos_mark_found = 0;
905#if CONFIG_VP9_HIGHBITDEPTH
906 int test_16bit_internal = 0;
911#if CONFIG_VP8_ENCODER
912 }
else if (strcmp(global->codec->name,
"vp8") == 0) {
913 ctrl_args = vp8_args;
914 ctrl_args_map = vp8_arg_ctrl_map;
916#if CONFIG_VP9_ENCODER
917 }
else if (strcmp(global->codec->name,
"vp9") == 0) {
918 ctrl_args = vp9_args;
919 ctrl_args_map = vp9_arg_ctrl_map;
923 for (argi = argj = argv; (*argj = *argi); argi += arg.argv_step) {
929 if (eos_mark_found) {
932 }
else if (!strcmp(*argj,
"--")) {
937 if (arg_match(&arg, &outputfile, argi)) {
938 config->out_fn = arg.val;
939 }
else if (arg_match(&arg, &fpf_name, argi)) {
940 config->stats_fn = arg.val;
941 }
else if (arg_match(&arg, &use_webm, argi)) {
943 config->write_webm = 1;
945 die(
"Error: --webm specified but webm is disabled.");
947 }
else if (arg_match(&arg, &use_ivf, argi)) {
948 config->write_webm = 0;
949 }
else if (arg_match(&arg, &threads, argi)) {
950 config->cfg.g_threads = arg_parse_uint(&arg);
951 }
else if (arg_match(&arg, &profile, argi)) {
952 config->cfg.g_profile = arg_parse_uint(&arg);
953 }
else if (arg_match(&arg, &width, argi)) {
954 config->cfg.g_w = arg_parse_uint(&arg);
955 }
else if (arg_match(&arg, &height, argi)) {
956 config->cfg.g_h = arg_parse_uint(&arg);
957#if CONFIG_VP9_HIGHBITDEPTH
958 }
else if (arg_match(&arg, &bitdeptharg, argi)) {
959 config->cfg.g_bit_depth = arg_parse_enum_or_int(&arg);
960 }
else if (arg_match(&arg, &inbitdeptharg, argi)) {
961 config->cfg.g_input_bit_depth = arg_parse_uint(&arg);
964 }
else if (arg_match(&arg, &stereo_mode, argi)) {
965 config->stereo_fmt = arg_parse_enum_or_int(&arg);
967 }
else if (arg_match(&arg, &timebase, argi)) {
968 config->cfg.g_timebase = arg_parse_rational(&arg);
969 validate_positive_rational(arg.name, &config->cfg.g_timebase);
970 }
else if (arg_match(&arg, &error_resilient, argi)) {
971 config->cfg.g_error_resilient = arg_parse_uint(&arg);
972 }
else if (arg_match(&arg, &end_usage, argi)) {
973 config->cfg.rc_end_usage = arg_parse_enum_or_int(&arg);
974 }
else if (arg_match(&arg, &lag_in_frames, argi)) {
975 config->cfg.g_lag_in_frames = arg_parse_uint(&arg);
977 config->cfg.rc_end_usage ==
VPX_CBR &&
978 config->cfg.g_lag_in_frames != 0) {
979 warn(
"non-zero %s option ignored in realtime CBR mode.\n", arg.name);
980 config->cfg.g_lag_in_frames = 0;
982 }
else if (arg_match(&arg, &dropframe_thresh, argi)) {
983 config->cfg.rc_dropframe_thresh = arg_parse_uint(&arg);
984 }
else if (arg_match(&arg, &resize_allowed, argi)) {
985 config->cfg.rc_resize_allowed = arg_parse_uint(&arg);
986 }
else if (arg_match(&arg, &resize_width, argi)) {
987 config->cfg.rc_scaled_width = arg_parse_uint(&arg);
988 }
else if (arg_match(&arg, &resize_height, argi)) {
989 config->cfg.rc_scaled_height = arg_parse_uint(&arg);
990 }
else if (arg_match(&arg, &resize_up_thresh, argi)) {
991 config->cfg.rc_resize_up_thresh = arg_parse_uint(&arg);
992 }
else if (arg_match(&arg, &resize_down_thresh, argi)) {
993 config->cfg.rc_resize_down_thresh = arg_parse_uint(&arg);
994 }
else if (arg_match(&arg, &end_usage, argi)) {
995 config->cfg.rc_end_usage = arg_parse_enum_or_int(&arg);
996 }
else if (arg_match(&arg, &target_bitrate, argi)) {
997 config->cfg.rc_target_bitrate = arg_parse_uint(&arg);
998 }
else if (arg_match(&arg, &min_quantizer, argi)) {
999 config->cfg.rc_min_quantizer = arg_parse_uint(&arg);
1000 }
else if (arg_match(&arg, &max_quantizer, argi)) {
1001 config->cfg.rc_max_quantizer = arg_parse_uint(&arg);
1002 }
else if (arg_match(&arg, &undershoot_pct, argi)) {
1003 config->cfg.rc_undershoot_pct = arg_parse_uint(&arg);
1004 }
else if (arg_match(&arg, &overshoot_pct, argi)) {
1005 config->cfg.rc_overshoot_pct = arg_parse_uint(&arg);
1006 }
else if (arg_match(&arg, &buf_sz, argi)) {
1007 config->cfg.rc_buf_sz = arg_parse_uint(&arg);
1008 }
else if (arg_match(&arg, &buf_initial_sz, argi)) {
1009 config->cfg.rc_buf_initial_sz = arg_parse_uint(&arg);
1010 }
else if (arg_match(&arg, &buf_optimal_sz, argi)) {
1011 config->cfg.rc_buf_optimal_sz = arg_parse_uint(&arg);
1012 }
else if (arg_match(&arg, &bias_pct, argi)) {
1013 config->cfg.rc_2pass_vbr_bias_pct = arg_parse_uint(&arg);
1014 if (global->passes < 2)
1015 warn(
"option %s ignored in one-pass mode.\n", arg.name);
1016 }
else if (arg_match(&arg, &minsection_pct, argi)) {
1017 config->cfg.rc_2pass_vbr_minsection_pct = arg_parse_uint(&arg);
1019 if (global->passes < 2)
1020 warn(
"option %s ignored in one-pass mode.\n", arg.name);
1021 }
else if (arg_match(&arg, &maxsection_pct, argi)) {
1022 config->cfg.rc_2pass_vbr_maxsection_pct = arg_parse_uint(&arg);
1024 if (global->passes < 2)
1025 warn(
"option %s ignored in one-pass mode.\n", arg.name);
1026 }
else if (arg_match(&arg, &corpus_complexity, argi)) {
1027 config->cfg.rc_2pass_vbr_corpus_complexity = arg_parse_uint(&arg);
1029 if (global->passes < 2)
1030 warn(
"option %s ignored in one-pass mode.\n", arg.name);
1031 }
else if (arg_match(&arg, &kf_min_dist, argi)) {
1032 config->cfg.kf_min_dist = arg_parse_uint(&arg);
1033 }
else if (arg_match(&arg, &kf_max_dist, argi)) {
1034 config->cfg.kf_max_dist = arg_parse_uint(&arg);
1035 }
else if (arg_match(&arg, &kf_disabled, argi)) {
1037#if CONFIG_VP9_ENCODER
1038 }
else if (arg_match(&arg, &use_vizier_rc_params, argi)) {
1039 config->cfg.use_vizier_rc_params = arg_parse_int(&arg);
1040 }
else if (arg_match(&arg, &active_wq_factor, argi)) {
1041 config->cfg.active_wq_factor = arg_parse_rational(&arg);
1042 }
else if (arg_match(&arg, &err_per_mb_factor, argi)) {
1043 config->cfg.err_per_mb_factor = arg_parse_rational(&arg);
1044 }
else if (arg_match(&arg, &sr_default_decay_limit, argi)) {
1045 config->cfg.sr_default_decay_limit = arg_parse_rational(&arg);
1046 }
else if (arg_match(&arg, &sr_diff_factor, argi)) {
1047 config->cfg.sr_diff_factor = arg_parse_rational(&arg);
1048 }
else if (arg_match(&arg, &kf_err_per_mb_factor, argi)) {
1049 config->cfg.kf_err_per_mb_factor = arg_parse_rational(&arg);
1050 }
else if (arg_match(&arg, &kf_frame_min_boost_factor, argi)) {
1051 config->cfg.kf_frame_min_boost_factor = arg_parse_rational(&arg);
1052 }
else if (arg_match(&arg, &kf_frame_max_boost_first_factor, argi)) {
1053 config->cfg.kf_frame_max_boost_first_factor = arg_parse_rational(&arg);
1054 }
else if (arg_match(&arg, &kf_frame_max_boost_subs_factor, argi)) {
1055 config->cfg.kf_frame_max_boost_subs_factor = arg_parse_rational(&arg);
1056 }
else if (arg_match(&arg, &kf_max_total_boost_factor, argi)) {
1057 config->cfg.kf_max_total_boost_factor = arg_parse_rational(&arg);
1058 }
else if (arg_match(&arg, &gf_max_total_boost_factor, argi)) {
1059 config->cfg.gf_max_total_boost_factor = arg_parse_rational(&arg);
1060 }
else if (arg_match(&arg, &gf_frame_max_boost_factor, argi)) {
1061 config->cfg.gf_frame_max_boost_factor = arg_parse_rational(&arg);
1062 }
else if (arg_match(&arg, &zm_factor, argi)) {
1063 config->cfg.zm_factor = arg_parse_rational(&arg);
1064 }
else if (arg_match(&arg, &rd_mult_inter_qp_fac, argi)) {
1065 config->cfg.rd_mult_inter_qp_fac = arg_parse_rational(&arg);
1066 }
else if (arg_match(&arg, &rd_mult_arf_qp_fac, argi)) {
1067 config->cfg.rd_mult_arf_qp_fac = arg_parse_rational(&arg);
1068 }
else if (arg_match(&arg, &rd_mult_key_qp_fac, argi)) {
1069 config->cfg.rd_mult_key_qp_fac = arg_parse_rational(&arg);
1071#if CONFIG_VP9_HIGHBITDEPTH
1072 }
else if (arg_match(&arg, &test16bitinternalarg, argi)) {
1073 if (strcmp(global->codec->name,
"vp9") == 0) {
1074 test_16bit_internal = 1;
1079 for (i = 0; ctrl_args[i]; i++) {
1080 if (arg_match(&arg, ctrl_args[i], argi)) {
1087 for (j = 0; j < config->arg_ctrl_cnt; j++)
1088 if (ctrl_args_map != NULL &&
1089 config->arg_ctrls[j][0] == ctrl_args_map[i])
1093 assert(j < (
int)ARG_CTRL_CNT_MAX);
1094 if (ctrl_args_map != NULL && j < (
int)ARG_CTRL_CNT_MAX) {
1095 config->arg_ctrls[j][0] = ctrl_args_map[i];
1096 config->arg_ctrls[j][1] = arg_parse_enum_or_int(&arg);
1097 if (j == config->arg_ctrl_cnt) config->arg_ctrl_cnt++;
1104#if CONFIG_VP9_HIGHBITDEPTH
1105 if (strcmp(global->codec->name,
"vp9") == 0) {
1106 config->use_16bit_internal =
1107 test_16bit_internal | (config->cfg.g_profile > 1);
1110 return eos_mark_found;
1113#define FOREACH_STREAM(func) \
1115 struct stream_state *stream; \
1116 for (stream = streams; stream; stream = stream->next) { \
1121static void validate_stream_config(
const struct stream_state *stream,
1122 const struct VpxEncoderConfig *global) {
1123 const struct stream_state *streami;
1126 if (!stream->config.cfg.g_w || !stream->config.cfg.g_h)
1128 "Stream %d: Specify stream dimensions with --width (-w) "
1129 " and --height (-h)",
1133 if (stream->config.cfg.g_input_bit_depth >
1134 (
unsigned int)stream->config.cfg.g_bit_depth) {
1135 fatal(
"Stream %d: codec bit depth (%d) less than input bit depth (%d)",
1136 stream->index, (
int)stream->config.cfg.g_bit_depth,
1137 stream->config.cfg.g_input_bit_depth);
1140 for (streami = stream; streami; streami = streami->next) {
1142 if (!streami->config.out_fn)
1143 fatal(
"Stream %d: Output file is required (specify with -o)",
1147 if (streami != stream) {
1148 const char *a = stream->config.out_fn;
1149 const char *b = streami->config.out_fn;
1150 if (!strcmp(a, b) && strcmp(a,
"/dev/null") && strcmp(a,
":nul"))
1151 fatal(
"Stream %d: duplicate output file (from stream %d)",
1152 streami->index, stream->index);
1156 if (streami != stream) {
1157 const char *a = stream->config.stats_fn;
1158 const char *b = streami->config.stats_fn;
1159 if (a && b && !strcmp(a, b))
1160 fatal(
"Stream %d: duplicate stats file (from stream %d)",
1161 streami->index, stream->index);
1166static void set_stream_dimensions(
struct stream_state *stream,
unsigned int w,
1168 if (!stream->config.cfg.g_w) {
1169 if (!stream->config.cfg.g_h)
1170 stream->config.cfg.g_w = w;
1172 stream->config.cfg.g_w = w * stream->config.cfg.g_h / h;
1174 if (!stream->config.cfg.g_h) {
1175 stream->config.cfg.g_h = h * stream->config.cfg.g_w / w;
1179static const char *file_type_to_string(
enum VideoFileType t) {
1181 case FILE_TYPE_RAW:
return "RAW";
1182 case FILE_TYPE_Y4M:
return "Y4M";
1183 default:
return "Other";
1198 default:
return "Other";
1202static void show_stream_config(
struct stream_state *stream,
1203 struct VpxEncoderConfig *global,
1204 struct VpxInputContext *input) {
1205#define SHOW(field) \
1206 fprintf(stderr, " %-28s = %d\n", #field, stream->config.cfg.field)
1208 if (stream->index == 0) {
1209 fprintf(stderr,
"Codec: %s\n",
1211 fprintf(stderr,
"Source file: %s File Type: %s Format: %s\n",
1212 input->filename, file_type_to_string(input->file_type),
1213 image_format_to_string(input->fmt));
1215 if (stream->next || stream->index)
1216 fprintf(stderr,
"\nStream Index: %d\n", stream->index);
1217 fprintf(stderr,
"Destination file: %s\n", stream->config.out_fn);
1218 fprintf(stderr,
"Encoder parameters:\n");
1226 SHOW(g_input_bit_depth);
1227 SHOW(g_timebase.num);
1228 SHOW(g_timebase.den);
1229 SHOW(g_error_resilient);
1231 SHOW(g_lag_in_frames);
1232 SHOW(rc_dropframe_thresh);
1233 SHOW(rc_resize_allowed);
1234 SHOW(rc_scaled_width);
1235 SHOW(rc_scaled_height);
1236 SHOW(rc_resize_up_thresh);
1237 SHOW(rc_resize_down_thresh);
1239 SHOW(rc_target_bitrate);
1240 SHOW(rc_min_quantizer);
1241 SHOW(rc_max_quantizer);
1242 SHOW(rc_undershoot_pct);
1243 SHOW(rc_overshoot_pct);
1245 SHOW(rc_buf_initial_sz);
1246 SHOW(rc_buf_optimal_sz);
1247 SHOW(rc_2pass_vbr_bias_pct);
1248 SHOW(rc_2pass_vbr_minsection_pct);
1249 SHOW(rc_2pass_vbr_maxsection_pct);
1250 SHOW(rc_2pass_vbr_corpus_complexity);
1255 SHOW(use_vizier_rc_params);
1256 SHOW(active_wq_factor.num);
1257 SHOW(active_wq_factor.den);
1260static void open_output_file(
struct stream_state *stream,
1261 struct VpxEncoderConfig *global,
1262 const struct VpxRational *pixel_aspect_ratio) {
1263 const char *fn = stream->config.out_fn;
1268 stream->file = strcmp(fn,
"-") ? fopen(fn,
"wb") : set_binary_mode(stdout);
1270 if (!stream->file) fatal(
"Failed to open output file");
1272 if (stream->config.write_webm && fseek(stream->file, 0, SEEK_CUR))
1273 fatal(
"WebM output to pipes not supported.");
1276 if (stream->config.write_webm) {
1277 stream->webm_ctx.stream = stream->file;
1278 write_webm_file_header(&stream->webm_ctx, cfg, stream->config.stereo_fmt,
1279 global->codec->fourcc, pixel_aspect_ratio);
1282 (void)pixel_aspect_ratio;
1285 if (!stream->config.write_webm) {
1286 ivf_write_file_header(stream->file, cfg, global->codec->fourcc, 0);
1290static void close_output_file(
struct stream_state *stream,
1291 unsigned int fourcc) {
1297 if (stream->config.write_webm) {
1298 write_webm_file_footer(&stream->webm_ctx);
1302 if (!stream->config.write_webm) {
1303 if (!fseek(stream->file, 0, SEEK_SET))
1304 ivf_write_file_header(stream->file, &stream->config.cfg, fourcc,
1305 stream->frames_out);
1308 fclose(stream->file);
1311static void setup_pass(
struct stream_state *stream,
1312 struct VpxEncoderConfig *global,
int pass) {
1313 if (stream->config.stats_fn) {
1314 if (!stats_open_file(&stream->stats, stream->config.stats_fn, pass))
1315 fatal(
"Failed to open statistics store");
1317 if (!stats_open_mem(&stream->stats, pass))
1318 fatal(
"Failed to open statistics store");
1321 stream->config.cfg.g_pass = global->passes == 2
1325 stream->config.cfg.rc_twopass_stats_in = stats_get(&stream->stats);
1328 stream->cx_time = 0;
1330 stream->frames_out = 0;
1333static void initialize_encoder(
struct stream_state *stream,
1334 struct VpxEncoderConfig *global) {
1340#if CONFIG_VP9_HIGHBITDEPTH
1346 &stream->config.cfg, flags);
1347 ctx_exit_on_error(&stream->encoder,
"Failed to initialize encoder");
1353 for (i = 0; i < stream->config.arg_ctrl_cnt; i++) {
1354 int ctrl = stream->config.arg_ctrls[i][0];
1355 int value = stream->config.arg_ctrls[i][1];
1357 fprintf(stderr,
"Error: Tried to set control %d = %d\n", ctrl, value);
1359 ctx_exit_on_error(&stream->encoder,
"Failed to control codec");
1363 if (global->test_decode != TEST_DECODE_OFF) {
1364 const VpxInterface *decoder = get_vpx_decoder_by_name(global->codec->name);
1370static void encode_frame(
struct stream_state *stream,
1371 struct VpxEncoderConfig *global,
struct vpx_image *img,
1372 unsigned int frames_in) {
1375 struct vpx_usec_timer timer;
1378 (cfg->
g_timebase.
den * (int64_t)(frames_in - 1) * global->framerate.den) /
1381 (cfg->
g_timebase.
den * (int64_t)(frames_in)*global->framerate.den) /
1385#if CONFIG_VP9_HIGHBITDEPTH
1390 fprintf(stderr,
"%s can only scale 4:2:0 inputs\n", exec_name);
1407 stream->img->stride[
VPX_PLANE_V] / 2, stream->img->d_w,
1408 stream->img->d_h, kFilterBox);
1411 stream->encoder.err = 1;
1412 ctx_exit_on_error(&stream->encoder,
1413 "Stream %d: Failed to encode frame.\n"
1414 "Scaling disabled in this configuration. \n"
1415 "To enable, configure with --enable-libyuv\n",
1421 if (img && (img->
d_w != cfg->
g_w || img->
d_h != cfg->
g_h)) {
1423 fprintf(stderr,
"%s can only scale 4:2:0 8bpp inputs\n", exec_name);
1437 stream->img->d_w, stream->img->d_h, kFilterBox);
1440 stream->encoder.err = 1;
1441 ctx_exit_on_error(&stream->encoder,
1442 "Stream %d: Failed to encode frame.\n"
1443 "Scaling disabled in this configuration. \n"
1444 "To enable, configure with --enable-libyuv\n",
1449 vpx_usec_timer_start(&timer);
1451 (
unsigned long)(next_frame_start - frame_start), 0,
1453 vpx_usec_timer_mark(&timer);
1454 stream->cx_time += vpx_usec_timer_elapsed(&timer);
1455 ctx_exit_on_error(&stream->encoder,
"Stream %d: Failed to encode frame",
1459static void update_quantizer_histogram(
struct stream_state *stream) {
1464 ctx_exit_on_error(&stream->encoder,
"Failed to read quantizer");
1465 stream->counts[q]++;
1469static void get_cx_data(
struct stream_state *stream,
1470 struct VpxEncoderConfig *global,
int *got_data) {
1477 static size_t fsize = 0;
1478 static FileOffset ivf_header_pos = 0;
1480 switch (pkt->
kind) {
1483 stream->frames_out++;
1486 fprintf(stderr,
" %6luF", (
unsigned long)pkt->
data.
frame.
sz);
1488 update_rate_histogram(stream->rate_hist, cfg, pkt);
1490 if (stream->config.write_webm) {
1491 write_webm_block(&stream->webm_ctx, cfg, pkt);
1494 if (!stream->config.write_webm) {
1496 ivf_header_pos = ftello(stream->file);
1499 ivf_write_frame_header(stream->file, pkt->
data.
frame.
pts, fsize);
1504 const FileOffset currpos = ftello(stream->file);
1505 fseeko(stream->file, ivf_header_pos, SEEK_SET);
1506 ivf_write_frame_size(stream->file, fsize);
1507 fseeko(stream->file, currpos, SEEK_SET);
1518 if (global->test_decode != TEST_DECODE_OFF && !stream->mismatch_seen) {
1521 if (stream->decoder.err) {
1522 warn_or_exit_on_error(&stream->decoder,
1523 global->test_decode == TEST_DECODE_FATAL,
1524 "Failed to decode frame %d in stream %d",
1525 stream->frames_out + 1, stream->index);
1526 stream->mismatch_seen = stream->frames_out + 1;
1532 stream->frames_out++;
1539 if (global->show_psnr) {
1542 stream->psnr_sse_total += pkt->
data.
psnr.sse[0];
1543 stream->psnr_samples_total += pkt->
data.
psnr.samples[0];
1544 for (i = 0; i < 4; i++) {
1546 fprintf(stderr,
"%.3f ", pkt->
data.
psnr.psnr[i]);
1547 stream->psnr_totals[i] += pkt->
data.
psnr.psnr[i];
1549 stream->psnr_count++;
1558static void show_psnr(
struct stream_state *stream,
double peak) {
1562 if (!stream->psnr_count)
return;
1564 fprintf(stderr,
"Stream %d PSNR (Overall/Avg/Y/U/V)", stream->index);
1565 ovpsnr = sse_to_psnr((
double)stream->psnr_samples_total, peak,
1566 (
double)stream->psnr_sse_total);
1567 fprintf(stderr,
" %.3f", ovpsnr);
1569 for (i = 0; i < 4; i++) {
1570 fprintf(stderr,
" %.3f", stream->psnr_totals[i] / stream->psnr_count);
1572 fprintf(stderr,
"\n");
1575static float usec_to_fps(uint64_t usec,
unsigned int frames) {
1576 return (
float)(usec > 0 ? frames * 1000000.0 / (float)usec : 0);
1579static void test_decode(
struct stream_state *stream,
1580 enum TestDecodeFatality fatal,
1581 const VpxInterface *codec) {
1584 if (stream->mismatch_seen)
return;
1587 if (strcmp(codec->name,
"vp8") == 0) {
1591 width = (stream->config.cfg.g_w + 15) & ~15;
1592 height = (stream->config.cfg.g_h + 15) & ~15;
1594 enc_img = ref_enc.img;
1596 dec_img = ref_dec.img;
1598 ref_enc.frame_type = VP8_LAST_FRAME;
1599 ref_dec.frame_type = VP8_LAST_FRAME;
1608 enc_img = ref_enc.img;
1610 dec_img = ref_dec.img;
1611#if CONFIG_VP9_HIGHBITDEPTH
1616 enc_img.
d_w, enc_img.
d_h, 16);
1617 vpx_img_truncate_16_to_8(&enc_img, &ref_enc.img);
1621 dec_img.
d_w, dec_img.
d_h, 16);
1622 vpx_img_truncate_16_to_8(&dec_img, &ref_dec.img);
1627 ctx_exit_on_error(&stream->encoder,
"Failed to get encoder reference frame");
1628 ctx_exit_on_error(&stream->decoder,
"Failed to get decoder reference frame");
1630 if (!compare_img(&enc_img, &dec_img)) {
1631 int y[4], u[4], v[4];
1632#if CONFIG_VP9_HIGHBITDEPTH
1634 find_mismatch_high(&enc_img, &dec_img, y, u, v);
1636 find_mismatch(&enc_img, &dec_img, y, u, v);
1639 find_mismatch(&enc_img, &dec_img, y, u, v);
1641 stream->decoder.err = 1;
1642 warn_or_exit_on_error(&stream->decoder, fatal == TEST_DECODE_FATAL,
1643 "Stream %d: Encode/decode mismatch on frame %d at"
1644 " Y[%d, %d] {%d/%d},"
1645 " U[%d, %d] {%d/%d},"
1646 " V[%d, %d] {%d/%d}",
1647 stream->index, stream->frames_out, y[0], y[1], y[2],
1648 y[3], u[0], u[1], u[2], u[3], v[0], v[1], v[2], v[3]);
1649 stream->mismatch_seen = stream->frames_out;
1656static void print_time(
const char *label, int64_t etl) {
1663 etl -= hours * 3600;
1668 fprintf(stderr,
"[%3s %2" PRId64
":%02" PRId64
":%02" PRId64
"] ", label,
1671 fprintf(stderr,
"[%3s unknown] ", label);
1675int main(
int argc,
const char **argv_) {
1678#if CONFIG_VP9_HIGHBITDEPTH
1680 int allocated_raw_shift = 0;
1681 int use_16bit_internal = 0;
1682 int input_shift = 0;
1684 int frame_avail, got_data;
1686 struct VpxInputContext input;
1687 struct VpxEncoderConfig global;
1688 struct stream_state *streams = NULL;
1689 char **argv, **argi;
1690 uint64_t cx_time = 0;
1694 memset(&input, 0,
sizeof(input));
1695 memset(&raw, 0,
sizeof(raw));
1696 exec_name = argv_[0];
1699 input.framerate.numerator = 30;
1700 input.framerate.denominator = 1;
1701 input.only_i420 = 1;
1702 input.bit_depth = 0;
1708 argv = argv_dup(argc - 1, argv_ + 1);
1710 fprintf(stderr,
"Error allocating argument list\n");
1711 return EXIT_FAILURE;
1713 parse_global_config(&global, argv);
1715 if (argc < 3) usage_exit();
1717 switch (global.color_type) {
1731 struct stream_state *stream = NULL;
1734 stream = new_stream(&global, stream);
1736 if (!streams) streams = stream;
1737 }
while (parse_stream_params(&global, stream, argv));
1741 for (argi = argv; *argi; argi++)
1742 if (argi[0][0] ==
'-' && argi[0][1])
1743 die(
"Error: Unrecognized option %s\n", *argi);
1745 FOREACH_STREAM(check_encoder_config(global.disable_warning_prompt, &global,
1746 &stream->config.cfg););
1749 input.filename = argv[0];
1751 if (!input.filename) {
1752 fprintf(stderr,
"No input file specified!\n");
1757 if (global.codec->fourcc == VP9_FOURCC) input.only_i420 = 0;
1759 for (pass = global.pass ? global.pass - 1 : 0; pass < global.passes; pass++) {
1760 int frames_in = 0, seen_frames = 0;
1761 int64_t estimated_time_left = -1;
1762 int64_t average_rate = -1;
1763 int64_t lagged_count = 0;
1765 open_input_file(&input);
1770 if (!input.width || !input.height) {
1772 if (stream->config.cfg.g_w && stream->config.cfg.g_h) {
1773 input.width = stream->config.cfg.g_w;
1774 input.height = stream->config.cfg.g_h;
1781 if (!input.width || !input.height)
1783 "Specify stream dimensions with --width (-w) "
1784 " and --height (-h)");
1791 if (!input.bit_depth) {
1793 if (stream->config.cfg.g_input_bit_depth)
1794 input.bit_depth = stream->config.cfg.g_input_bit_depth;
1796 input.bit_depth = stream->config.cfg.g_input_bit_depth =
1797 (
int)stream->config.cfg.g_bit_depth;
1802 { stream->config.cfg.g_input_bit_depth = input.bit_depth; });
1805 FOREACH_STREAM(set_stream_dimensions(stream, input.width, input.height));
1806 FOREACH_STREAM(validate_stream_config(stream, &global));
1811 if (global.pass && global.passes == 2)
1813 if (!stream->config.stats_fn)
1814 die(
"Stream %d: Must specify --fpf when --pass=%d"
1815 " and --passes=2\n",
1816 stream->index, global.pass);
1821 if (stream->config.write_webm) {
1822 stream->config.write_webm = 0;
1824 "vpxenc was compiled without WebM container support."
1825 "Producing IVF output");
1833 if (!global.have_framerate) {
1834 global.framerate.num = input.framerate.numerator;
1835 global.framerate.den = input.framerate.denominator;
1836 FOREACH_STREAM(stream->config.cfg.g_timebase.den = global.framerate.num;
1837 stream->config.cfg.g_timebase.num = global.framerate.den);
1841 if (global.verbose && pass == 0)
1842 FOREACH_STREAM(show_stream_config(stream, &global, &input));
1844 if (pass == (global.pass ? global.pass - 1 : 0)) {
1846 if (input.file_type != FILE_TYPE_Y4M) {
1847 vpx_img_alloc(&raw, input.fmt, input.width, input.height, 32);
1849 FOREACH_STREAM(stream->rate_hist = init_rate_histogram(
1850 &stream->config.cfg, &global.framerate));
1853 FOREACH_STREAM(setup_pass(stream, &global, pass));
1855 open_output_file(stream, &global, &input.pixel_aspect_ratio));
1856 FOREACH_STREAM(initialize_encoder(stream, &global));
1858#if CONFIG_VP9_HIGHBITDEPTH
1859 if (strcmp(global.codec->name,
"vp9") == 0) {
1864 if (stream->config.use_16bit_internal) {
1865 use_16bit_internal = 1;
1867 if (stream->config.cfg.g_profile == 0) {
1870 input_shift = (int)stream->config.cfg.g_bit_depth -
1871 stream->config.cfg.g_input_bit_depth;
1880 while (frame_avail || got_data) {
1881 struct vpx_usec_timer timer;
1883 if (!global.limit || frames_in < global.limit) {
1884 frame_avail = read_frame(&input, &raw);
1886 if (frame_avail) frames_in++;
1888 frames_in > global.skip_frames ? frames_in - global.skip_frames : 0;
1890 if (!global.quiet) {
1891 float fps = usec_to_fps(cx_time, seen_frames);
1892 fprintf(stderr,
"\rPass %d/%d ", pass + 1, global.passes);
1894 if (stream_cnt == 1)
1895 fprintf(stderr,
"frame %4d/%-4d %7" PRId64
"B ", frames_in,
1896 streams->frames_out, (int64_t)streams->nbytes);
1898 fprintf(stderr,
"frame %4d ", frames_in);
1900 fprintf(stderr,
"%7" PRId64
" %s %.2f %s ",
1901 cx_time > 9999999 ? cx_time / 1000 : cx_time,
1902 cx_time > 9999999 ?
"ms" :
"us", fps >= 1.0 ? fps : fps * 60,
1903 fps >= 1.0 ?
"fps" :
"fpm");
1904 print_time(
"ETA", estimated_time_left);
1910 if (frames_in > global.skip_frames) {
1911#if CONFIG_VP9_HIGHBITDEPTH
1913 if (input_shift || (use_16bit_internal && input.bit_depth == 8)) {
1914 assert(use_16bit_internal);
1917 if (!allocated_raw_shift) {
1919 input.width, input.height, 32);
1920 allocated_raw_shift = 1;
1922 vpx_img_upshift(&raw_shift, &raw, input_shift);
1923 frame_to_encode = &raw_shift;
1925 frame_to_encode = &raw;
1927 vpx_usec_timer_start(&timer);
1928 if (use_16bit_internal) {
1931 if (stream->config.use_16bit_internal)
1932 encode_frame(stream, &global,
1933 frame_avail ? frame_to_encode : NULL, frames_in);
1939 FOREACH_STREAM(encode_frame(stream, &global,
1940 frame_avail ? frame_to_encode : NULL,
1944 vpx_usec_timer_start(&timer);
1945 FOREACH_STREAM(encode_frame(stream, &global, frame_avail ? &raw : NULL,
1948 vpx_usec_timer_mark(&timer);
1949 cx_time += vpx_usec_timer_elapsed(&timer);
1951 FOREACH_STREAM(update_quantizer_histogram(stream));
1954 FOREACH_STREAM(get_cx_data(stream, &global, &got_data));
1956 if (!got_data && input.length && streams != NULL &&
1957 !streams->frames_out) {
1958 lagged_count = global.limit ? seen_frames : ftello(input.file);
1959 }
else if (input.length) {
1964 const int64_t frame_in_lagged = (seen_frames - lagged_count) * 1000;
1966 rate = cx_time ? frame_in_lagged * (int64_t)1000000 / cx_time : 0;
1967 remaining = 1000 * (global.limit - global.skip_frames -
1968 seen_frames + lagged_count);
1970 const int64_t input_pos = ftello(input.file);
1971 const int64_t input_pos_lagged = input_pos - lagged_count;
1972 const int64_t limit = input.length;
1974 rate = cx_time ? input_pos_lagged * (int64_t)1000000 / cx_time : 0;
1975 remaining = limit - input_pos + lagged_count;
1979 (average_rate <= 0) ? rate : (average_rate * 7 + rate) / 8;
1980 estimated_time_left = average_rate ? remaining / average_rate : -1;
1983 if (got_data && global.test_decode != TEST_DECODE_OFF)
1984 FOREACH_STREAM(test_decode(stream, global.test_decode, global.codec));
1988 if (!global.quiet) fprintf(stderr,
"\033[K");
1991 if (stream_cnt > 1) fprintf(stderr,
"\n");
1993 if (!global.quiet) {
1994 FOREACH_STREAM(fprintf(
1996 "\rPass %d/%d frame %4d/%-4d %7" PRId64
"B %7" PRId64
"b/f %7" PRId64
1997 "b/s %7" PRId64
" %s (%.2f fps)\033[K\n",
1998 pass + 1, global.passes, frames_in, stream->frames_out,
1999 (int64_t)stream->nbytes,
2000 seen_frames ? (int64_t)(stream->nbytes * 8 / seen_frames) : 0,
2002 ? (int64_t)stream->nbytes * 8 * (int64_t)global.framerate.num /
2003 global.framerate.den / seen_frames
2005 stream->cx_time > 9999999 ? stream->cx_time / 1000 : stream->cx_time,
2006 stream->cx_time > 9999999 ?
"ms" :
"us",
2007 usec_to_fps(stream->cx_time, seen_frames)));
2010 if (global.show_psnr) {
2011 if (global.codec->fourcc == VP9_FOURCC) {
2013 show_psnr(stream, (1 << stream->config.cfg.g_input_bit_depth) - 1));
2015 FOREACH_STREAM(show_psnr(stream, 255.0));
2021 if (global.test_decode != TEST_DECODE_OFF) {
2025 close_input_file(&input);
2027 if (global.test_decode == TEST_DECODE_FATAL) {
2028 FOREACH_STREAM(res |= stream->mismatch_seen);
2030 FOREACH_STREAM(close_output_file(stream, global.codec->fourcc));
2032 FOREACH_STREAM(stats_close(&stream->stats, global.passes - 1));
2034 if (global.pass)
break;
2037 if (global.show_q_hist_buckets)
2039 show_q_histogram(stream->counts, global.show_q_hist_buckets));
2041 if (global.show_rate_hist_buckets)
2042 FOREACH_STREAM(show_rate_histogram(stream->rate_hist, &stream->config.cfg,
2043 global.show_rate_hist_buckets));
2044 FOREACH_STREAM(destroy_rate_histogram(stream->rate_hist));
2046#if CONFIG_INTERNAL_STATS
2050 if (!(global.pass == 1 && global.passes == 2))
2052 FILE *f = fopen(
"opsnr.stt",
"a");
2053 if (stream->mismatch_seen) {
2054 fprintf(f,
"First mismatch occurred in frame %d\n",
2055 stream->mismatch_seen);
2057 fprintf(f,
"No mismatch detected in recon buffers\n");
2063#if CONFIG_VP9_HIGHBITDEPTH
2069 return res ? EXIT_FAILURE : EXIT_SUCCESS;
const char * vpx_codec_err_to_string(vpx_codec_err_t err)
Convert error number to printable string.
const char * vpx_codec_error_detail(vpx_codec_ctx_t *ctx)
Retrieve detailed error information for codec context.
vpx_codec_err_t vpx_codec_destroy(vpx_codec_ctx_t *ctx)
Destroy a codec instance.
const void * vpx_codec_iter_t
Iterator.
Definition: vpx_codec.h:190
const char * vpx_codec_iface_name(vpx_codec_iface_t *iface)
Return the name for a given interface.
#define vpx_codec_control(ctx, id, data)
vpx_codec_control wrapper macro
Definition: vpx_codec.h:407
vpx_codec_err_t
Algorithm return codes.
Definition: vpx_codec.h:93
const char * vpx_codec_error(vpx_codec_ctx_t *ctx)
Retrieve error synopsis for codec context.
vpx_codec_err_t vpx_codec_control_(vpx_codec_ctx_t *ctx, int ctrl_id,...)
Control algorithm.
@ VPX_BITS_8
Definition: vpx_codec.h:221
@ VPX_BITS_12
Definition: vpx_codec.h:223
@ VPX_BITS_10
Definition: vpx_codec.h:222
vpx_codec_err_t vpx_codec_decode(vpx_codec_ctx_t *ctx, const uint8_t *data, unsigned int data_sz, void *user_priv, long deadline)
Decode data.
#define vpx_codec_dec_init(ctx, iface, cfg, flags)
Convenience macro for vpx_codec_dec_init_ver()
Definition: vpx_decoder.h:143
#define VPX_DL_REALTIME
deadline parameter analogous to VPx REALTIME mode.
Definition: vpx_encoder.h:979
#define vpx_codec_enc_init(ctx, iface, cfg, flags)
Convenience macro for vpx_codec_enc_init_ver()
Definition: vpx_encoder.h:890
#define VPX_CODEC_USE_PSNR
Initialization-time Feature Enabling.
Definition: vpx_encoder.h:89
#define VPX_DL_GOOD_QUALITY
deadline parameter analogous to VPx GOOD QUALITY mode.
Definition: vpx_encoder.h:981
const vpx_codec_cx_pkt_t * vpx_codec_get_cx_data(vpx_codec_ctx_t *ctx, vpx_codec_iter_t *iter)
Encoded data iterator.
#define VPX_CODEC_USE_HIGHBITDEPTH
Definition: vpx_encoder.h:92
int64_t vpx_codec_pts_t
Time Stamp Type.
Definition: vpx_encoder.h:108
vpx_codec_err_t vpx_codec_enc_config_default(vpx_codec_iface_t *iface, vpx_codec_enc_cfg_t *cfg, unsigned int usage)
Get a default configuration.
#define VPX_DL_BEST_QUALITY
deadline parameter analogous to VPx BEST QUALITY mode.
Definition: vpx_encoder.h:983
#define VPX_CODEC_USE_OUTPUT_PARTITION
Make the encoder output one partition at a time.
Definition: vpx_encoder.h:91
vpx_codec_err_t vpx_codec_encode(vpx_codec_ctx_t *ctx, const vpx_image_t *img, vpx_codec_pts_t pts, unsigned long duration, vpx_enc_frame_flags_t flags, unsigned long deadline)
Encode a frame.
#define VPX_FRAME_IS_FRAGMENT
this is a fragment of the encoded frame
Definition: vpx_encoder.h:125
@ VPX_CODEC_PSNR_PKT
Definition: vpx_encoder.h:153
@ VPX_CODEC_CX_FRAME_PKT
Definition: vpx_encoder.h:150
@ VPX_CODEC_STATS_PKT
Definition: vpx_encoder.h:151
@ VPX_RC_LAST_PASS
Definition: vpx_encoder.h:230
@ VPX_RC_ONE_PASS
Definition: vpx_encoder.h:228
@ VPX_RC_FIRST_PASS
Definition: vpx_encoder.h:229
@ VPX_KF_DISABLED
Definition: vpx_encoder.h:252
@ VPX_Q
Definition: vpx_encoder.h:238
@ VPX_CQ
Definition: vpx_encoder.h:237
@ VPX_CBR
Definition: vpx_encoder.h:236
@ VPX_VBR
Definition: vpx_encoder.h:235
@ VP9E_SET_MIN_GF_INTERVAL
Codec control function to set minimum interval between GF/ARF frames.
Definition: vp8cx.h:519
@ VP9E_SET_MAX_INTER_BITRATE_PCT
Codec control function to set max data rate for Inter frames.
Definition: vp8cx.h:295
@ VP9E_SET_FRAME_PERIODIC_BOOST
Codec control function to enable/disable periodic Q boost.
Definition: vp8cx.h:430
@ VP8E_SET_MAX_INTRA_BITRATE_PCT
Codec control function to set Max data rate for Intra frames.
Definition: vp8cx.h:274
@ VP8E_SET_ARNR_STRENGTH
Codec control function to set the filter strength for the arf.
Definition: vp8cx.h:240
@ VP8E_SET_TUNING
Codec control function to set visual tuning.
Definition: vp8cx.h:249
@ VP8E_SET_ENABLEAUTOALTREF
Codec control function to enable automatic use of arf frames.
Definition: vp8cx.h:181
@ VP9E_SET_TARGET_LEVEL
Codec control function to set target level.
Definition: vp8cx.h:567
@ VP9E_SET_AQ_MODE
Codec control function to set adaptive quantization mode.
Definition: vp8cx.h:415
@ VP8E_SET_NOISE_SENSITIVITY
control function to set noise sensitivity
Definition: vp8cx.h:190
@ VP8E_SET_TOKEN_PARTITIONS
Codec control function to set the number of token partitions.
Definition: vp8cx.h:211
@ VP8E_SET_ARNR_TYPE
Definition: vp8cx.h:243
@ VP9E_SET_TILE_ROWS
Codec control function to set number of tile rows.
Definition: vp8cx.h:388
@ VP8E_SET_ARNR_MAXFRAMES
Codec control function to set the max no of frames to create arf.
Definition: vp8cx.h:234
@ VP9E_SET_LOSSLESS
Codec control function to set lossless encoding mode.
Definition: vp8cx.h:344
@ VP9E_SET_FRAME_PARALLEL_DECODING
Codec control function to enable frame parallel decoding feature.
Definition: vp8cx.h:402
@ VP8E_SET_SHARPNESS
Codec control function to set higher sharpness at the expense of a lower PSNR.
Definition: vp8cx.h:199
@ VP8E_SET_GF_CBR_BOOST_PCT
Boost percentage for Golden Frame in CBR mode.
Definition: vp8cx.h:606
@ VP9E_SET_TUNE_CONTENT
Codec control function to set content type.
Definition: vp8cx.h:480
@ VP9E_SET_TPL
Codec control function to enable temporal dependency model.
Definition: vp8cx.h:673
@ VP9E_SET_ROW_MT
Codec control function to set row level multi-threading.
Definition: vp8cx.h:575
@ VP8E_SET_CPUUSED
Codec control function to set encoder internal speed settings.
Definition: vp8cx.h:172
@ VP9E_SET_TILE_COLUMNS
Codec control function to set number of tile columns.
Definition: vp8cx.h:368
@ VP8E_SET_STATIC_THRESHOLD
Codec control function to set the threshold for MBs treated static.
Definition: vp8cx.h:205
@ VP9E_SET_COLOR_SPACE
Codec control function to set color space info.
Definition: vp8cx.h:511
@ VP8E_SET_SCREEN_CONTENT_MODE
Codec control function to set encoder screen content mode.
Definition: vp8cx.h:329
@ VP9E_SET_DISABLE_LOOPFILTER
Codec control function to disable loopfilter.
Definition: vp8cx.h:708
@ VP8E_SET_CQ_LEVEL
Codec control function to set constrained / constant quality level.
Definition: vp8cx.h:259
@ VP9E_SET_NOISE_SENSITIVITY
Codec control function to set noise sensitivity.
Definition: vp8cx.h:438
@ VP8E_GET_LAST_QUANTIZER_64
Codec control function to get last quantizer chosen by the encoder.
Definition: vp8cx.h:228
@ VP9E_SET_GF_CBR_BOOST_PCT
Boost percentage for Golden Frame in CBR mode.
Definition: vp8cx.h:310
@ VP9E_SET_MAX_GF_INTERVAL
Codec control function to set minimum interval between GF/ARF frames.
Definition: vp8cx.h:527
@ VP9E_SET_ALT_REF_AQ
Codec control function to enable/disable special mode for altref adaptive quantization....
Definition: vp8cx.h:591
@ VP8_COPY_REFERENCE
Definition: vp8.h:48
@ VP9_GET_REFERENCE
Definition: vp8.h:55
VP9 specific reference frame data struct.
Definition: vp8.h:110
int idx
Definition: vp8.h:111
Codec context structure.
Definition: vpx_codec.h:200
Encoder output packet.
Definition: vpx_encoder.h:162
vpx_codec_frame_flags_t flags
Definition: vpx_encoder.h:172
vpx_fixed_buf_t twopass_stats
Definition: vpx_encoder.h:185
enum vpx_codec_cx_pkt_kind kind
Definition: vpx_encoder.h:163
double psnr[4]
Definition: vpx_encoder.h:190
struct vpx_codec_cx_pkt::@1::@2 frame
size_t sz
Definition: vpx_encoder.h:167
void * buf
Definition: vpx_encoder.h:166
vpx_codec_pts_t pts
time stamp to show frame (in timebase units)
Definition: vpx_encoder.h:169
vpx_fixed_buf_t raw
Definition: vpx_encoder.h:192
int partition_id
the partition id defines the decoding order of the partitions. Only applicable when "output partition...
Definition: vpx_encoder.h:176
union vpx_codec_cx_pkt::@1 data
Encoder configuration structure.
Definition: vpx_encoder.h:271
unsigned int g_h
Height of the frame.
Definition: vpx_encoder.h:316
unsigned int g_w
Width of the frame.
Definition: vpx_encoder.h:307
struct vpx_rational g_timebase
Stream timebase units.
Definition: vpx_encoder.h:346
enum vpx_enc_pass g_pass
Multi-pass Encoding Mode.
Definition: vpx_encoder.h:361
size_t sz
Definition: vpx_encoder.h:100
void * buf
Definition: vpx_encoder.h:99
Image Descriptor.
Definition: vpx_image.h:72
vpx_img_fmt_t fmt
Definition: vpx_image.h:73
unsigned int d_h
Definition: vpx_image.h:84
unsigned int d_w
Definition: vpx_image.h:83
unsigned char * planes[4]
Definition: vpx_image.h:100
int stride[4]
Definition: vpx_image.h:101
Rational Number.
Definition: vpx_encoder.h:221
int den
Definition: vpx_encoder.h:223
int num
Definition: vpx_encoder.h:222
reference frame data struct
Definition: vp8.h:101
Provides definitions for using VP8 or VP9 encoder algorithm within the vpx Codec Interface.
Provides definitions for using VP8 or VP9 within the vpx Decoder interface.
Describes the decoder algorithm interface to applications.
Describes the encoder algorithm interface to applications.
@ VPX_CS_BT_709
Definition: vpx_image.h:57
@ VPX_CS_SRGB
Definition: vpx_image.h:62
@ VPX_CS_BT_601
Definition: vpx_image.h:56
@ VPX_CS_BT_2020
Definition: vpx_image.h:60
@ VPX_CS_SMPTE_170
Definition: vpx_image.h:58
@ VPX_CS_UNKNOWN
Definition: vpx_image.h:55
@ VPX_CS_SMPTE_240
Definition: vpx_image.h:59
@ VPX_CS_RESERVED
Definition: vpx_image.h:61
#define VPX_PLANE_Y
Definition: vpx_image.h:96
vpx_image_t * vpx_img_alloc(vpx_image_t *img, vpx_img_fmt_t fmt, unsigned int d_w, unsigned int d_h, unsigned int align)
Open a descriptor, allocating storage for the underlying image.
#define VPX_IMG_FMT_HIGHBITDEPTH
Definition: vpx_image.h:35
#define VPX_PLANE_U
Definition: vpx_image.h:97
@ VPX_IMG_FMT_I42216
Definition: vpx_image.h:48
@ VPX_IMG_FMT_I44016
Definition: vpx_image.h:50
@ VPX_IMG_FMT_NV12
Definition: vpx_image.h:46
@ VPX_IMG_FMT_YV12
Definition: vpx_image.h:40
@ VPX_IMG_FMT_I42016
Definition: vpx_image.h:47
@ VPX_IMG_FMT_I444
Definition: vpx_image.h:44
@ VPX_IMG_FMT_I440
Definition: vpx_image.h:45
@ VPX_IMG_FMT_I44416
Definition: vpx_image.h:49
@ VPX_IMG_FMT_I420
Definition: vpx_image.h:42
@ VPX_IMG_FMT_I422
Definition: vpx_image.h:43
#define VPX_PLANE_V
Definition: vpx_image.h:98
enum vpx_img_fmt vpx_img_fmt_t
List of supported image formats.
void vpx_img_free(vpx_image_t *img)
Close an image descriptor.