24 #include "../tools_common.h" 25 #include "../video_writer.h" 27 #include "../vpx_ports/vpx_timer.h" 28 #include "vpx/svc_context.h" 31 #include "../vpxstats.h" 32 #include "vp9/encoder/vp9_encoder.h" 33 #define OUTPUT_RC_STATS 1 35 static const arg_def_t skip_frames_arg =
36 ARG_DEF(
"s",
"skip-frames", 1,
"input frames to skip");
37 static const arg_def_t frames_arg =
38 ARG_DEF(
"f",
"frames", 1,
"number of frames to encode");
39 static const arg_def_t threads_arg =
40 ARG_DEF(
"th",
"threads", 1,
"number of threads to use");
42 static const arg_def_t output_rc_stats_arg =
43 ARG_DEF(
"rcstat",
"output_rc_stats", 1,
"output rc stats");
45 static const arg_def_t width_arg = ARG_DEF(
"w",
"width", 1,
"source width");
46 static const arg_def_t height_arg = ARG_DEF(
"h",
"height", 1,
"source height");
47 static const arg_def_t timebase_arg =
48 ARG_DEF(
"t",
"timebase", 1,
"timebase (num/den)");
49 static const arg_def_t bitrate_arg = ARG_DEF(
50 "b",
"target-bitrate", 1,
"encoding bitrate, in kilobits per second");
51 static const arg_def_t spatial_layers_arg =
52 ARG_DEF(
"sl",
"spatial-layers", 1,
"number of spatial SVC layers");
53 static const arg_def_t temporal_layers_arg =
54 ARG_DEF(
"tl",
"temporal-layers", 1,
"number of temporal SVC layers");
55 static const arg_def_t temporal_layering_mode_arg =
56 ARG_DEF(
"tlm",
"temporal-layering-mode", 1,
57 "temporal layering scheme." 58 "VP9E_TEMPORAL_LAYERING_MODE");
59 static const arg_def_t kf_dist_arg =
60 ARG_DEF(
"k",
"kf-dist", 1,
"number of frames between keyframes");
61 static const arg_def_t scale_factors_arg =
62 ARG_DEF(
"r",
"scale-factors", 1,
"scale factors (lowest to highest layer)");
63 static const arg_def_t passes_arg =
64 ARG_DEF(
"p",
"passes", 1,
"Number of passes (1/2)");
65 static const arg_def_t pass_arg =
66 ARG_DEF(NULL,
"pass", 1,
"Pass to execute (1/2)");
67 static const arg_def_t fpf_name_arg =
68 ARG_DEF(NULL,
"fpf", 1,
"First pass statistics file name");
69 static const arg_def_t min_q_arg =
70 ARG_DEF(NULL,
"min-q", 1,
"Minimum quantizer");
71 static const arg_def_t max_q_arg =
72 ARG_DEF(NULL,
"max-q", 1,
"Maximum quantizer");
73 static const arg_def_t min_bitrate_arg =
74 ARG_DEF(NULL,
"min-bitrate", 1,
"Minimum bitrate");
75 static const arg_def_t max_bitrate_arg =
76 ARG_DEF(NULL,
"max-bitrate", 1,
"Maximum bitrate");
77 static const arg_def_t lag_in_frame_arg =
78 ARG_DEF(NULL,
"lag-in-frames", 1,
79 "Number of frame to input before " 80 "generating any outputs");
81 static const arg_def_t rc_end_usage_arg =
82 ARG_DEF(NULL,
"rc-end-usage", 1,
"0 - 3: VBR, CBR, CQ, Q");
83 static const arg_def_t speed_arg =
84 ARG_DEF(
"sp",
"speed", 1,
"speed configuration");
85 static const arg_def_t aqmode_arg =
86 ARG_DEF(
"aq",
"aqmode", 1,
"aq-mode off/on");
87 static const arg_def_t bitrates_arg =
88 ARG_DEF(
"bl",
"bitrates", 1,
"bitrates[sl * num_tl + tl]");
90 #if CONFIG_VP9_HIGHBITDEPTH 91 static const struct arg_enum_list bitdepth_enum[] = {
95 static const arg_def_t bitdepth_arg = ARG_DEF_ENUM(
96 "d",
"bit-depth", 1,
"Bit depth for codec 8, 10 or 12. ", bitdepth_enum);
97 #endif // CONFIG_VP9_HIGHBITDEPTH 99 static const arg_def_t *svc_args[] = { &frames_arg,
115 &temporal_layers_arg,
116 &temporal_layering_mode_arg,
121 &output_rc_stats_arg,
124 #if CONFIG_VP9_HIGHBITDEPTH 132 static const uint32_t default_frames_to_skip = 0;
133 static const uint32_t default_frames_to_code = 60 * 60;
134 static const uint32_t default_width = 1920;
135 static const uint32_t default_height = 1080;
136 static const uint32_t default_timebase_num = 1;
137 static const uint32_t default_timebase_den = 60;
138 static const uint32_t default_bitrate = 1000;
139 static const uint32_t default_spatial_layers = 5;
140 static const uint32_t default_temporal_layers = 1;
141 static const uint32_t default_kf_dist = 100;
142 static const uint32_t default_temporal_layering_mode = 0;
143 static const uint32_t default_output_rc_stats = 0;
144 static const int32_t default_speed = -1;
145 static const uint32_t default_threads = 0;
148 const char *input_filename;
149 const char *output_filename;
150 uint32_t frames_to_code;
151 uint32_t frames_to_skip;
152 struct VpxInputContext input_ctx;
158 static const char *exec_name;
160 void usage_exit(
void) {
161 fprintf(stderr,
"Usage: %s <options> input_filename output_filename\n",
163 fprintf(stderr,
"Options:\n");
164 arg_show_usage(stderr, svc_args);
168 static void parse_command_line(
int argc,
const char **argv_,
169 AppInput *app_input, SvcContext *svc_ctx,
178 const char *fpf_file_name = NULL;
179 unsigned int min_bitrate = 0;
180 unsigned int max_bitrate = 0;
181 char string_options[1024] = { 0 };
184 svc_ctx->log_level = SVC_LOG_DEBUG;
185 svc_ctx->spatial_layers = default_spatial_layers;
186 svc_ctx->temporal_layers = default_temporal_layers;
187 svc_ctx->temporal_layering_mode = default_temporal_layering_mode;
189 svc_ctx->output_rc_stat = default_output_rc_stats;
191 svc_ctx->speed = default_speed;
192 svc_ctx->threads = default_threads;
200 enc_cfg->
g_w = default_width;
201 enc_cfg->
g_h = default_height;
210 app_input->frames_to_code = default_frames_to_code;
211 app_input->frames_to_skip = default_frames_to_skip;
214 argv = argv_dup(argc - 1, argv_ + 1);
215 for (argi = argj = argv; (*argj = *argi); argi += arg.argv_step) {
218 if (arg_match(&arg, &frames_arg, argi)) {
219 app_input->frames_to_code = arg_parse_uint(&arg);
220 }
else if (arg_match(&arg, &width_arg, argi)) {
221 enc_cfg->
g_w = arg_parse_uint(&arg);
222 }
else if (arg_match(&arg, &height_arg, argi)) {
223 enc_cfg->
g_h = arg_parse_uint(&arg);
224 }
else if (arg_match(&arg, &timebase_arg, argi)) {
225 enc_cfg->
g_timebase = arg_parse_rational(&arg);
226 }
else if (arg_match(&arg, &bitrate_arg, argi)) {
228 }
else if (arg_match(&arg, &skip_frames_arg, argi)) {
229 app_input->frames_to_skip = arg_parse_uint(&arg);
230 }
else if (arg_match(&arg, &spatial_layers_arg, argi)) {
231 svc_ctx->spatial_layers = arg_parse_uint(&arg);
232 }
else if (arg_match(&arg, &temporal_layers_arg, argi)) {
233 svc_ctx->temporal_layers = arg_parse_uint(&arg);
235 }
else if (arg_match(&arg, &output_rc_stats_arg, argi)) {
236 svc_ctx->output_rc_stat = arg_parse_uint(&arg);
238 }
else if (arg_match(&arg, &speed_arg, argi)) {
239 svc_ctx->speed = arg_parse_uint(&arg);
240 }
else if (arg_match(&arg, &aqmode_arg, argi)) {
241 svc_ctx->aqmode = arg_parse_uint(&arg);
242 }
else if (arg_match(&arg, &threads_arg, argi)) {
243 svc_ctx->threads = arg_parse_uint(&arg);
244 }
else if (arg_match(&arg, &temporal_layering_mode_arg, argi)) {
247 if (svc_ctx->temporal_layering_mode) {
250 }
else if (arg_match(&arg, &kf_dist_arg, argi)) {
253 }
else if (arg_match(&arg, &scale_factors_arg, argi)) {
254 snprintf(string_options,
sizeof(string_options),
"%s scale-factors=%s",
255 string_options, arg.val);
256 }
else if (arg_match(&arg, &bitrates_arg, argi)) {
257 snprintf(string_options,
sizeof(string_options),
"%s bitrates=%s",
258 string_options, arg.val);
259 }
else if (arg_match(&arg, &passes_arg, argi)) {
260 passes = arg_parse_uint(&arg);
261 if (passes < 1 || passes > 2) {
262 die(
"Error: Invalid number of passes (%d)\n", passes);
264 }
else if (arg_match(&arg, &pass_arg, argi)) {
265 pass = arg_parse_uint(&arg);
266 if (pass < 1 || pass > 2) {
267 die(
"Error: Invalid pass selected (%d)\n", pass);
269 }
else if (arg_match(&arg, &fpf_name_arg, argi)) {
270 fpf_file_name = arg.val;
271 }
else if (arg_match(&arg, &min_q_arg, argi)) {
272 snprintf(string_options,
sizeof(string_options),
"%s min-quantizers=%s",
273 string_options, arg.val);
274 }
else if (arg_match(&arg, &max_q_arg, argi)) {
275 snprintf(string_options,
sizeof(string_options),
"%s max-quantizers=%s",
276 string_options, arg.val);
277 }
else if (arg_match(&arg, &min_bitrate_arg, argi)) {
278 min_bitrate = arg_parse_uint(&arg);
279 }
else if (arg_match(&arg, &max_bitrate_arg, argi)) {
280 max_bitrate = arg_parse_uint(&arg);
281 }
else if (arg_match(&arg, &lag_in_frame_arg, argi)) {
283 }
else if (arg_match(&arg, &rc_end_usage_arg, argi)) {
285 #if CONFIG_VP9_HIGHBITDEPTH 286 }
else if (arg_match(&arg, &bitdepth_arg, argi)) {
287 enc_cfg->
g_bit_depth = arg_parse_enum_or_int(&arg);
302 die(
"Error: Invalid bit depth selected (%d)\n", enc_cfg->
g_bit_depth);
305 #endif // CONFIG_VP9_HIGHBITDEPTH 312 if (strlen(string_options) > 0)
313 vpx_svc_set_options(svc_ctx, string_options + 1);
315 if (passes == 0 || passes == 1) {
317 fprintf(stderr,
"pass is ignored since there's only one pass\n");
322 die(
"pass must be specified when passes is 2\n");
325 if (fpf_file_name == NULL) {
326 die(
"fpf must be specified when passes is 2\n");
331 if (!stats_open_file(&app_input->rc_stats, fpf_file_name, 0)) {
332 fatal(
"Failed to open statistics store");
336 if (!stats_open_file(&app_input->rc_stats, fpf_file_name, 1)) {
337 fatal(
"Failed to open statistics store");
341 app_input->passes = passes;
342 app_input->pass = pass;
346 if (min_bitrate > 0) {
350 if (max_bitrate > 0) {
357 for (argi = argv; *argi; ++argi)
358 if (argi[0][0] ==
'-' && strlen(argi[0]) > 1)
359 die(
"Error: Unrecognized option %s\n", *argi);
361 if (argv[0] == NULL || argv[1] == 0) {
364 app_input->input_filename = argv[0];
365 app_input->output_filename = argv[1];
368 if (enc_cfg->
g_w < 16 || enc_cfg->
g_w % 2 || enc_cfg->
g_h < 16 ||
370 die(
"Invalid resolution: %d x %d\n", enc_cfg->
g_w, enc_cfg->
g_h);
373 "Codec %s\nframes: %d, skip: %d\n" 375 "width %d, height: %d,\n" 376 "num: %d, den: %d, bitrate: %d,\n" 379 app_input->frames_to_skip, svc_ctx->spatial_layers, enc_cfg->
g_w,
386 struct RateControlStats {
405 double avg_st_encoding_bitrate;
407 double variance_st_encoding_bitrate;
416 static void set_rate_control_stats(
struct RateControlStats *rc,
427 rc->layer_framerate[layer] = framerate;
431 rc->layer_pfb[layer] =
435 (rc->layer_framerate[layer] - rc->layer_framerate[layer - 1]);
438 rc->layer_framerate[layer];
440 rc->layer_input_frames[layer] = 0;
441 rc->layer_enc_frames[layer] = 0;
442 rc->layer_tot_enc_frames[layer] = 0;
443 rc->layer_encoding_bitrate[layer] = 0.0;
444 rc->layer_avg_frame_size[layer] = 0.0;
445 rc->layer_avg_rate_mismatch[layer] = 0.0;
448 rc->window_count = 0;
449 rc->window_size = 15;
450 rc->avg_st_encoding_bitrate = 0.0;
451 rc->variance_st_encoding_bitrate = 0.0;
454 static void printout_rate_control_summary(
struct RateControlStats *rc,
458 double perc_fluctuation = 0.0;
459 int tot_num_frames = 0;
460 printf(
"Total number of processed frames: %d\n\n", frame_cnt - 1);
461 printf(
"Rate control layer stats for sl%d tl%d layer(s):\n\n",
467 const int num_dropped =
469 ? (rc->layer_input_frames[layer] - rc->layer_enc_frames[layer])
470 : (rc->layer_input_frames[layer] - rc->layer_enc_frames[layer] -
472 tot_num_frames += rc->layer_input_frames[layer];
473 rc->layer_encoding_bitrate[layer] = 0.001 * rc->layer_framerate[layer] *
474 rc->layer_encoding_bitrate[layer] /
476 rc->layer_avg_frame_size[layer] =
477 rc->layer_avg_frame_size[layer] / rc->layer_enc_frames[layer];
478 rc->layer_avg_rate_mismatch[layer] = 100.0 *
479 rc->layer_avg_rate_mismatch[layer] /
480 rc->layer_enc_frames[layer];
481 printf(
"For layer#: sl%d tl%d \n", sl, tl);
482 printf(
"Bitrate (target vs actual): %d %f.0 kbps\n",
484 rc->layer_encoding_bitrate[layer]);
485 printf(
"Average frame size (target vs actual): %f %f bits\n",
486 rc->layer_pfb[layer], rc->layer_avg_frame_size[layer]);
487 printf(
"Average rate_mismatch: %f\n", rc->layer_avg_rate_mismatch[layer]);
489 "Number of input frames, encoded (non-key) frames, " 490 "and percent dropped frames: %d %d %f.0 \n",
491 rc->layer_input_frames[layer], rc->layer_enc_frames[layer],
492 100.0 * num_dropped / rc->layer_input_frames[layer]);
496 rc->avg_st_encoding_bitrate = rc->avg_st_encoding_bitrate / rc->window_count;
497 rc->variance_st_encoding_bitrate =
498 rc->variance_st_encoding_bitrate / rc->window_count -
499 (rc->avg_st_encoding_bitrate * rc->avg_st_encoding_bitrate);
500 perc_fluctuation = 100.0 * sqrt(rc->variance_st_encoding_bitrate) /
501 rc->avg_st_encoding_bitrate;
502 printf(
"Short-time stats, for window of %d frames: \n", rc->window_size);
503 printf(
"Average, rms-variance, and percent-fluct: %f %f %f \n",
504 rc->avg_st_encoding_bitrate, sqrt(rc->variance_st_encoding_bitrate),
506 printf(
"Num of input, num of encoded (super) frames: %d %d \n", frame_cnt,
510 vpx_codec_err_t parse_superframe_index(
const uint8_t *data,
size_t data_sz,
511 uint64_t sizes[8],
int *count) {
520 marker = *(data + data_sz - 1);
523 if ((marker & 0xe0) == 0xc0) {
524 const uint32_t frames = (marker & 0x7) + 1;
525 const uint32_t mag = ((marker >> 3) & 0x3) + 1;
526 const size_t index_sz = 2 + mag * frames;
533 const uint8_t marker2 = *(data + data_sz - index_sz);
544 const uint8_t *x = &data[data_sz - index_sz + 1];
546 for (i = 0; i < frames; ++i) {
547 uint32_t this_sz = 0;
549 for (j = 0; j < mag; ++j) this_sz |= (*x++) << (j * 8);
563 void set_frame_flags_bypass_mode(
int tl,
int num_spatial_layers,
567 for (sl = 0; sl < num_spatial_layers; ++sl) {
583 }
else if (tl == 1) {
591 if (sl == num_spatial_layers - 1)
610 }
else if (tl == 1) {
612 ref_frame_config->
gld_fb_idx[sl] = num_spatial_layers + sl - 1;
613 ref_frame_config->
alt_fb_idx[sl] = num_spatial_layers + sl;
618 int main(
int argc,
const char **argv) {
620 VpxVideoWriter *writer = NULL;
626 uint32_t frame_cnt = 0;
630 int frame_duration = 1;
632 int end_of_stream = 0;
633 int frames_received = 0;
636 struct RateControlStats rc;
640 double sum_bitrate = 0.0;
641 double sum_bitrate2 = 0.0;
642 double framerate = 30.0;
644 struct vpx_usec_timer timer;
646 memset(&svc_ctx, 0,
sizeof(svc_ctx));
648 parse_command_line(argc, argv, &app_input, &svc_ctx, &enc_cfg);
651 #if CONFIG_VP9_HIGHBITDEPTH 655 enc_cfg.
g_w, enc_cfg.
g_h, 32)) {
656 die(
"Failed to allocate image %dx%d\n", enc_cfg.
g_w, enc_cfg.
g_h);
660 die(
"Failed to allocate image %dx%d\n", enc_cfg.
g_w, enc_cfg.
g_h);
662 #endif // CONFIG_VP9_HIGHBITDEPTH 664 if (!(infile = fopen(app_input.input_filename,
"rb")))
665 die(
"Failed to open %s for reading\n", app_input.input_filename);
668 if (vpx_svc_init(&svc_ctx, &codec, vpx_codec_vp9_cx(), &enc_cfg) !=
670 die(
"Failed to initialize encoder\n");
675 rc.avg_st_encoding_bitrate = 0.0;
676 rc.variance_st_encoding_bitrate = 0.0;
677 if (svc_ctx.output_rc_stat) {
678 set_rate_control_stats(&rc, &enc_cfg);
683 info.codec_fourcc = VP9_FOURCC;
687 if (!(app_input.passes == 2 && app_input.pass == 1)) {
690 vpx_video_writer_open(app_input.output_filename, kContainerIVF, &info);
692 die(
"Failed to open %s for writing\n", app_input.output_filename);
697 if (svc_ctx.output_rc_stat) {
699 char file_name[PATH_MAX];
701 snprintf(file_name,
sizeof(file_name),
"%s_t%d.ivf",
702 app_input.output_filename, tl);
703 outfile[tl] = vpx_video_writer_open(file_name, kContainerIVF, &info);
704 if (!outfile[tl]) die(
"Failed to open %s for writing", file_name);
710 for (i = 0; i < app_input.frames_to_skip; ++i) vpx_img_read(&raw, infile);
712 if (svc_ctx.speed != -1)
714 if (svc_ctx.threads) {
716 if (svc_ctx.threads > 1)
721 if (svc_ctx.speed >= 5 && svc_ctx.aqmode == 1)
723 if (svc_ctx.speed >= 5)
730 while (!end_of_stream) {
733 if (frame_cnt >= app_input.frames_to_code || !vpx_img_read(&raw, infile)) {
746 layer_id.spatial_layer_id = 0;
748 if (frame_cnt % 2 == 0)
749 layer_id.temporal_layer_id = 0;
751 layer_id.temporal_layer_id = 1;
758 set_frame_flags_bypass_mode(layer_id.temporal_layer_id,
759 svc_ctx.spatial_layers, frame_cnt == 0,
767 layer_id.temporal_layer_id];
773 tl = (frame_cnt % 2 != 0);
775 if (frame_cnt % 2 != 0) tl = 2;
776 if ((frame_cnt > 1) && ((frame_cnt - 2) % 4 == 0)) tl = 1;
782 vpx_usec_timer_start(&timer);
783 res = vpx_svc_encode(
784 &svc_ctx, &codec, (end_of_stream ? NULL : &raw), pts, frame_duration,
786 vpx_usec_timer_mark(&timer);
787 cx_time += vpx_usec_timer_elapsed(&timer);
791 die_codec(&codec,
"Failed to encode frame");
795 switch (cx_pkt->
kind) {
797 SvcInternal_t *
const si = (SvcInternal_t *)svc_ctx.internal;
801 uint64_t sizes_parsed[8];
804 vp9_zero(sizes_parsed);
806 vpx_video_writer_write_frame(writer, cx_pkt->
data.
frame.buf,
811 if (svc_ctx.output_rc_stat) {
813 parse_superframe_index(cx_pkt->
data.
frame.buf,
818 if (svc_ctx.temporal_layering_mode !=
820 int num_layers_encoded = 0;
823 if (cx_pkt->
data.
frame.spatial_layer_encoded[sl]) {
824 sizes[sl] = sizes_parsed[num_layers_encoded];
825 num_layers_encoded++;
829 for (tl = layer_id.temporal_layer_id;
831 vpx_video_writer_write_frame(
837 if (cx_pkt->
data.
frame.spatial_layer_encoded[sl]) {
838 for (tl = layer_id.temporal_layer_id;
841 ++rc.layer_tot_enc_frames[layer];
842 rc.layer_encoding_bitrate[layer] += 8.0 * sizes[sl];
845 if (tl == (
unsigned int)layer_id.temporal_layer_id &&
847 rc.layer_avg_frame_size[layer] += 8.0 * sizes[sl];
848 rc.layer_avg_rate_mismatch[layer] +=
849 fabs(8.0 * sizes[sl] - rc.layer_pfb[layer]) /
851 ++rc.layer_enc_frames[layer];
860 if (frame_cnt > (
unsigned int)rc.window_size) {
862 if (cx_pkt->
data.
frame.spatial_layer_encoded[sl])
863 sum_bitrate += 0.001 * 8.0 * sizes[sl] * framerate;
865 if (frame_cnt % rc.window_size == 0) {
866 rc.window_count += 1;
867 rc.avg_st_encoding_bitrate += sum_bitrate / rc.window_size;
868 rc.variance_st_encoding_bitrate +=
869 (sum_bitrate / rc.window_size) *
870 (sum_bitrate / rc.window_size);
877 (
unsigned int)(rc.window_size + rc.window_size / 2)) {
879 sum_bitrate2 += 0.001 * 8.0 * sizes[sl] * framerate;
882 if (frame_cnt > (
unsigned int)(2 * rc.window_size) &&
883 frame_cnt % rc.window_size == 0) {
884 rc.window_count += 1;
885 rc.avg_st_encoding_bitrate += sum_bitrate2 / rc.window_size;
886 rc.variance_st_encoding_bitrate +=
887 (sum_bitrate2 / rc.window_size) *
888 (sum_bitrate2 / rc.window_size);
901 si->bytes_sum[0] += (int)cx_pkt->
data.
frame.sz;
914 if (!end_of_stream) {
916 pts += frame_duration;
925 --rc.layer_input_frames[layer];
929 printf(
"Processed %d frames\n", frame_cnt);
932 if (svc_ctx.output_rc_stat) {
933 printout_rate_control_summary(&rc, &enc_cfg, frame_cnt);
938 if (app_input.passes == 2) stats_close(&app_input.rc_stats, 1);
940 vpx_video_writer_close(writer);
943 if (svc_ctx.output_rc_stat) {
945 vpx_video_writer_close(outfile[tl]);
949 printf(
"Frame cnt and encoding time/FPS stats for encoding: %d %f %f \n",
950 frame_cnt, 1000 * (
float)cx_time / (
double)(frame_cnt * 1000000),
951 1000000 * (
double)frame_cnt / (
double)cx_time);
954 vpx_svc_dump_statistics(&svc_ctx);
955 vpx_svc_release(&svc_ctx);
vpx_fixed_buf_t twopass_stats
Definition: vpx_encoder.h:188
unsigned int ts_number_layers
Number of temporal coding layers.
Definition: vpx_encoder.h:660
Codec control function to set encoder internal speed settings.
Definition: vp8cx.h:155
#define VPX_MAX_LAYERS
Definition: vpx_encoder.h:46
#define VP8_EFLAG_NO_UPD_GF
Don't update the golden frame.
Definition: vp8cx.h:88
Image Descriptor.
Definition: vpx_image.h:88
Describes the encoder algorithm interface to applications.
const char * vpx_codec_iface_name(vpx_codec_iface_t *iface)
Return the name for a given interface.
Codec control function to constrain the inter-layer prediction (prediction of lower spatial resolutio...
Definition: vp8cx.h:613
const char * vpx_codec_err_to_string(vpx_codec_err_t err)
Convert error number to printable string.
int lst_fb_idx[5]
Definition: vp8cx.h:761
#define VPX_TS_MAX_LAYERS
Definition: vpx_encoder.h:40
struct vpx_rational g_timebase
Stream timebase units.
Definition: vpx_encoder.h:354
unsigned int layer_target_bitrate[12]
Target bitrate for each spatial/temporal layer.
Definition: vpx_encoder.h:700
#define VP8_EFLAG_NO_REF_GF
Don't reference the golden frame.
Definition: vp8cx.h:66
unsigned int g_input_bit_depth
Bit-depth of the input frames.
Definition: vpx_encoder.h:340
int den
Definition: vpx_encoder.h:228
Definition: vpx_encoder.h:154
unsigned int kf_max_dist
Keyframe maximum interval.
Definition: vpx_encoder.h:630
unsigned int g_lag_in_frames
Allow lagged encoding.
Definition: vpx_encoder.h:383
Encoder configuration structure.
Definition: vpx_encoder.h:276
The coded data for this stream is corrupt or incomplete.
Definition: vpx_codec.h:130
Codec control function to set row level multi-threading.
Definition: vp8cx.h:564
Codec control function to set Max data rate for Intra frames.
Definition: vp8cx.h:251
Encoder output packet.
Definition: vpx_encoder.h:165
void * buf
Definition: vpx_encoder.h:103
unsigned int ts_rate_decimator[5]
Frame rate decimation factor for each temporal layer.
Definition: vpx_encoder.h:674
unsigned int kf_min_dist
Keyframe minimum interval.
Definition: vpx_encoder.h:621
Definition: vpx_encoder.h:234
unsigned int g_profile
Bitstream profile to use.
Definition: vpx_encoder.h:306
Definition: vpx_encoder.h:235
Codec control function to set number of tile columns.
Definition: vp8cx.h:345
struct vpx_codec_cx_pkt::@1::@2 frame
int frame_flags[5]
Definition: vp8cx.h:760
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.
Definition: vpx_image.h:55
unsigned int g_w
Width of the frame.
Definition: vpx_encoder.h:315
Codec control function to set adaptive quantization mode.
Definition: vp8cx.h:392
Codec control function to get svc layer ID.
Definition: vp8cx.h:465
unsigned int g_h
Height of the frame.
Definition: vpx_encoder.h:324
enum vpx_codec_cx_pkt_kind kind
Definition: vpx_encoder.h:166
vp9 svc layer parameters
Definition: vp8cx.h:746
Operation completed without error.
Definition: vpx_codec.h:92
#define VP8_EFLAG_NO_UPD_LAST
Don't update the last frame.
Definition: vp8cx.h:81
void vpx_img_free(vpx_image_t *img)
Close an image descriptor.
unsigned int rc_target_bitrate
Target data rate.
Definition: vpx_encoder.h:474
#define VPX_DL_REALTIME
deadline parameter analogous to VPx REALTIME mode.
Definition: vpx_encoder.h:846
int num
Definition: vpx_encoder.h:227
Definition: vpx_codec.h:220
Codec control function to set the frame flags and buffer indices for spatial layers. The frame flags and buffer indices are set using the struct vpx_svc_ref_frame_config defined below.
Definition: vp8cx.h:539
enum vpx_enc_pass g_pass
Multi-pass Encoding Mode.
Definition: vpx_encoder.h:369
#define VPX_DL_GOOD_QUALITY
deadline parameter analogous to VPx GOOD QUALITY mode.
Definition: vpx_encoder.h:848
unsigned int ss_number_layers
Number of spatial coding layers.
Definition: vpx_encoder.h:640
vpx_bit_depth_t g_bit_depth
Bit-depth of the codec.
Definition: vpx_encoder.h:332
Provides definitions for using VP8 or VP9 encoder algorithm within the vpx Codec Interface.
Bypass mode. Used when application needs to control temporal layering. This will only work when the n...
Definition: vp8cx.h:652
vpx_codec_err_t
Algorithm return codes.
Definition: vpx_codec.h:90
const vpx_codec_cx_pkt_t * vpx_codec_get_cx_data(vpx_codec_ctx_t *ctx, vpx_codec_iter_t *iter)
Encoded data iterator.
union vpx_codec_cx_pkt::@1 data
int temporal_layering_mode
Temporal layering mode indicating which temporal layering scheme to use.
Definition: vpx_encoder.h:709
vpx_fixed_buf_t rc_twopass_stats_in
Two-pass stats buffer.
Definition: vpx_encoder.h:461
Definition: vpx_image.h:63
vpx_codec_err_t vpx_codec_enc_config_default(vpx_codec_iface_t *iface, vpx_codec_enc_cfg_t *cfg, unsigned int reserved)
Get a default configuration.
Definition: vpx_encoder.h:242
#define vpx_codec_control(ctx, id, data)
vpx_codec_control wrapper macro
Definition: vpx_codec.h:404
#define VP8_EFLAG_NO_REF_ARF
Don't reference the alternate reference frame.
Definition: vp8cx.h:74
vpx_codec_err_t vpx_codec_destroy(vpx_codec_ctx_t *ctx)
Destroy a codec instance.
size_t sz
Definition: vpx_encoder.h:104
Definition: vpx_codec.h:218
vp9 svc frame flag parameters.
Definition: vp8cx.h:759
Codec control function to set the threshold for MBs treated static.
Definition: vp8cx.h:182
#define VPX_FRAME_IS_KEY
Definition: vpx_encoder.h:122
Definition: vpx_codec.h:219
int alt_fb_idx[5]
Definition: vp8cx.h:763
const void * vpx_codec_iter_t
Iterator.
Definition: vpx_codec.h:187
Definition: vpx_encoder.h:153
unsigned int rc_2pass_vbr_maxsection_pct
Two-pass mode per-GOP maximum bitrate.
Definition: vpx_encoder.h:593
vpx_codec_er_flags_t g_error_resilient
Enable error resilient modes.
Definition: vpx_encoder.h:362
#define VP8_EFLAG_NO_UPD_ARF
Don't update the alternate reference frame.
Definition: vp8cx.h:95
unsigned int rc_2pass_vbr_minsection_pct
Two-pass mode per-GOP minimum bitrate.
Definition: vpx_encoder.h:586
int gld_fb_idx[5]
Definition: vp8cx.h:762
Codec control function to set svc layer for spatial and temporal.
Definition: vp8cx.h:447
enum vpx_rc_mode rc_end_usage
Rate control algorithm to use.
Definition: vpx_encoder.h:454
Definition: vpx_encoder.h:233
Codec context structure.
Definition: vpx_codec.h:197