25 #include "../tools_common.h" 26 #include "../video_writer.h" 28 #include "../vpx_ports/vpx_timer.h" 29 #include "vpx/svc_context.h" 32 #include "../vpxstats.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,
"temporal layering scheme." 57 "VP9E_TEMPORAL_LAYERING_MODE");
58 static const arg_def_t kf_dist_arg =
59 ARG_DEF(
"k",
"kf-dist", 1,
"number of frames between keyframes");
60 static const arg_def_t scale_factors_arg =
61 ARG_DEF(
"r",
"scale-factors", 1,
"scale factors (lowest to highest layer)");
62 static const arg_def_t passes_arg =
63 ARG_DEF(
"p",
"passes", 1,
"Number of passes (1/2)");
64 static const arg_def_t pass_arg =
65 ARG_DEF(NULL,
"pass", 1,
"Pass to execute (1/2)");
66 static const arg_def_t fpf_name_arg =
67 ARG_DEF(NULL,
"fpf", 1,
"First pass statistics file name");
68 static const arg_def_t min_q_arg =
69 ARG_DEF(NULL,
"min-q", 1,
"Minimum quantizer");
70 static const arg_def_t max_q_arg =
71 ARG_DEF(NULL,
"max-q", 1,
"Maximum quantizer");
72 static const arg_def_t min_bitrate_arg =
73 ARG_DEF(NULL,
"min-bitrate", 1,
"Minimum bitrate");
74 static const arg_def_t max_bitrate_arg =
75 ARG_DEF(NULL,
"max-bitrate", 1,
"Maximum bitrate");
76 static const arg_def_t lag_in_frame_arg =
77 ARG_DEF(NULL,
"lag-in-frames", 1,
"Number of frame to input before " 78 "generating any outputs");
79 static const arg_def_t rc_end_usage_arg =
80 ARG_DEF(NULL,
"rc-end-usage", 1,
"0 - 3: VBR, CBR, CQ, Q");
81 static const arg_def_t speed_arg =
82 ARG_DEF(
"sp",
"speed", 1,
"speed configuration");
83 static const arg_def_t aqmode_arg =
84 ARG_DEF(
"aq",
"aqmode", 1,
"aq-mode off/on");
86 #if CONFIG_VP9_HIGHBITDEPTH 87 static const struct arg_enum_list bitdepth_enum[] = {
94 static const arg_def_t bitdepth_arg =
95 ARG_DEF_ENUM(
"d",
"bit-depth", 1,
"Bit depth for codec 8, 10 or 12. ",
97 #endif // CONFIG_VP9_HIGHBITDEPTH 100 static const arg_def_t *svc_args[] = {
101 &frames_arg, &width_arg, &height_arg,
102 &timebase_arg, &bitrate_arg, &skip_frames_arg, &spatial_layers_arg,
103 &kf_dist_arg, &scale_factors_arg, &passes_arg, &pass_arg,
104 &fpf_name_arg, &min_q_arg, &max_q_arg, &min_bitrate_arg,
105 &max_bitrate_arg, &temporal_layers_arg, &temporal_layering_mode_arg,
106 &lag_in_frame_arg, &threads_arg, &aqmode_arg,
108 &output_rc_stats_arg,
111 #if CONFIG_VP9_HIGHBITDEPTH 115 &rc_end_usage_arg, NULL
118 static const uint32_t default_frames_to_skip = 0;
119 static const uint32_t default_frames_to_code = 60 * 60;
120 static const uint32_t default_width = 1920;
121 static const uint32_t default_height = 1080;
122 static const uint32_t default_timebase_num = 1;
123 static const uint32_t default_timebase_den = 60;
124 static const uint32_t default_bitrate = 1000;
125 static const uint32_t default_spatial_layers = 5;
126 static const uint32_t default_temporal_layers = 1;
127 static const uint32_t default_kf_dist = 100;
128 static const uint32_t default_temporal_layering_mode = 0;
129 static const uint32_t default_output_rc_stats = 0;
130 static const int32_t default_speed = -1;
131 static const uint32_t default_threads = 0;
134 const char *input_filename;
135 const char *output_filename;
136 uint32_t frames_to_code;
137 uint32_t frames_to_skip;
138 struct VpxInputContext input_ctx;
144 static const char *exec_name;
146 void usage_exit(
void) {
147 fprintf(stderr,
"Usage: %s <options> input_filename output_filename\n",
149 fprintf(stderr,
"Options:\n");
150 arg_show_usage(stderr, svc_args);
154 static void parse_command_line(
int argc,
const char **argv_,
155 AppInput *app_input, SvcContext *svc_ctx,
157 struct arg arg = {0};
164 const char *fpf_file_name = NULL;
165 unsigned int min_bitrate = 0;
166 unsigned int max_bitrate = 0;
167 char string_options[1024] = {0};
170 svc_ctx->log_level = SVC_LOG_DEBUG;
171 svc_ctx->spatial_layers = default_spatial_layers;
172 svc_ctx->temporal_layers = default_temporal_layers;
173 svc_ctx->temporal_layering_mode = default_temporal_layering_mode;
175 svc_ctx->output_rc_stat = default_output_rc_stats;
177 svc_ctx->speed = default_speed;
178 svc_ctx->threads = default_threads;
186 enc_cfg->
g_w = default_width;
187 enc_cfg->
g_h = default_height;
196 app_input->frames_to_code = default_frames_to_code;
197 app_input->frames_to_skip = default_frames_to_skip;
200 argv = argv_dup(argc - 1, argv_ + 1);
201 for (argi = argj = argv; (*argj = *argi); argi += arg.argv_step) {
204 if (arg_match(&arg, &frames_arg, argi)) {
205 app_input->frames_to_code = arg_parse_uint(&arg);
206 }
else if (arg_match(&arg, &width_arg, argi)) {
207 enc_cfg->
g_w = arg_parse_uint(&arg);
208 }
else if (arg_match(&arg, &height_arg, argi)) {
209 enc_cfg->
g_h = arg_parse_uint(&arg);
210 }
else if (arg_match(&arg, &timebase_arg, argi)) {
211 enc_cfg->
g_timebase = arg_parse_rational(&arg);
212 }
else if (arg_match(&arg, &bitrate_arg, argi)) {
214 }
else if (arg_match(&arg, &skip_frames_arg, argi)) {
215 app_input->frames_to_skip = arg_parse_uint(&arg);
216 }
else if (arg_match(&arg, &spatial_layers_arg, argi)) {
217 svc_ctx->spatial_layers = arg_parse_uint(&arg);
218 }
else if (arg_match(&arg, &temporal_layers_arg, argi)) {
219 svc_ctx->temporal_layers = arg_parse_uint(&arg);
221 }
else if (arg_match(&arg, &output_rc_stats_arg, argi)) {
222 svc_ctx->output_rc_stat = arg_parse_uint(&arg);
224 }
else if (arg_match(&arg, &speed_arg, argi)) {
225 svc_ctx->speed = arg_parse_uint(&arg);
226 }
else if (arg_match(&arg, &aqmode_arg, argi)) {
227 svc_ctx->aqmode = arg_parse_uint(&arg);
228 }
else if (arg_match(&arg, &threads_arg, argi)) {
229 svc_ctx->threads = arg_parse_uint(&arg);
230 }
else if (arg_match(&arg, &temporal_layering_mode_arg, argi)) {
231 svc_ctx->temporal_layering_mode =
233 if (svc_ctx->temporal_layering_mode) {
236 }
else if (arg_match(&arg, &kf_dist_arg, argi)) {
239 }
else if (arg_match(&arg, &scale_factors_arg, argi)) {
240 snprintf(string_options,
sizeof(string_options),
"%s scale-factors=%s",
241 string_options, arg.val);
242 }
else if (arg_match(&arg, &passes_arg, argi)) {
243 passes = arg_parse_uint(&arg);
244 if (passes < 1 || passes > 2) {
245 die(
"Error: Invalid number of passes (%d)\n", passes);
247 }
else if (arg_match(&arg, &pass_arg, argi)) {
248 pass = arg_parse_uint(&arg);
249 if (pass < 1 || pass > 2) {
250 die(
"Error: Invalid pass selected (%d)\n", pass);
252 }
else if (arg_match(&arg, &fpf_name_arg, argi)) {
253 fpf_file_name = arg.val;
254 }
else if (arg_match(&arg, &min_q_arg, argi)) {
255 snprintf(string_options,
sizeof(string_options),
"%s min-quantizers=%s",
256 string_options, arg.val);
257 }
else if (arg_match(&arg, &max_q_arg, argi)) {
258 snprintf(string_options,
sizeof(string_options),
"%s max-quantizers=%s",
259 string_options, arg.val);
260 }
else if (arg_match(&arg, &min_bitrate_arg, argi)) {
261 min_bitrate = arg_parse_uint(&arg);
262 }
else if (arg_match(&arg, &max_bitrate_arg, argi)) {
263 max_bitrate = arg_parse_uint(&arg);
264 }
else if (arg_match(&arg, &lag_in_frame_arg, argi)) {
266 }
else if (arg_match(&arg, &rc_end_usage_arg, argi)) {
268 #if CONFIG_VP9_HIGHBITDEPTH 269 }
else if (arg_match(&arg, &bitdepth_arg, argi)) {
270 enc_cfg->
g_bit_depth = arg_parse_enum_or_int(&arg);
285 die(
"Error: Invalid bit depth selected (%d)\n", enc_cfg->
g_bit_depth);
288 #endif // CONFIG_VP9_HIGHBITDEPTH 295 if (strlen(string_options) > 0)
296 vpx_svc_set_options(svc_ctx, string_options + 1);
298 if (passes == 0 || passes == 1) {
300 fprintf(stderr,
"pass is ignored since there's only one pass\n");
305 die(
"pass must be specified when passes is 2\n");
308 if (fpf_file_name == NULL) {
309 die(
"fpf must be specified when passes is 2\n");
314 if (!stats_open_file(&app_input->rc_stats, fpf_file_name, 0)) {
315 fatal(
"Failed to open statistics store");
319 if (!stats_open_file(&app_input->rc_stats, fpf_file_name, 1)) {
320 fatal(
"Failed to open statistics store");
324 app_input->passes = passes;
325 app_input->pass = pass;
329 if (min_bitrate > 0) {
333 if (max_bitrate > 0) {
340 for (argi = argv; *argi; ++argi)
341 if (argi[0][0] ==
'-' && strlen(argi[0]) > 1)
342 die(
"Error: Unrecognized option %s\n", *argi);
344 if (argv[0] == NULL || argv[1] == 0) {
347 app_input->input_filename = argv[0];
348 app_input->output_filename = argv[1];
351 if (enc_cfg->
g_w < 16 || enc_cfg->
g_w % 2 || enc_cfg->
g_h < 16 ||
353 die(
"Invalid resolution: %d x %d\n", enc_cfg->
g_w, enc_cfg->
g_h);
356 "Codec %s\nframes: %d, skip: %d\n" 358 "width %d, height: %d,\n" 359 "num: %d, den: %d, bitrate: %d,\n" 362 app_input->frames_to_skip,
363 svc_ctx->spatial_layers, enc_cfg->
g_w, enc_cfg->
g_h,
370 struct RateControlStats {
389 double avg_st_encoding_bitrate;
391 double variance_st_encoding_bitrate;
400 static void set_rate_control_stats(
struct RateControlStats *rc,
411 rc->layer_framerate[layer] =
414 rc->layer_pfb[layer] = 1000.0 *
417 (rc->layer_framerate[layer] -
418 rc->layer_framerate[layer - 1]);
420 rc->layer_pfb[tlayer0] = 1000.0 *
422 rc->layer_framerate[tlayer0];
424 rc->layer_input_frames[layer] = 0;
425 rc->layer_enc_frames[layer] = 0;
426 rc->layer_tot_enc_frames[layer] = 0;
427 rc->layer_encoding_bitrate[layer] = 0.0;
428 rc->layer_avg_frame_size[layer] = 0.0;
429 rc->layer_avg_rate_mismatch[layer] = 0.0;
432 rc->window_count = 0;
433 rc->window_size = 15;
434 rc->avg_st_encoding_bitrate = 0.0;
435 rc->variance_st_encoding_bitrate = 0.0;
438 static void printout_rate_control_summary(
struct RateControlStats *rc,
442 int tot_num_frames = 0;
443 double perc_fluctuation = 0.0;
444 printf(
"Total number of processed frames: %d\n\n", frame_cnt - 1);
445 printf(
"Rate control layer stats for sl%d tl%d layer(s):\n\n",
450 const int num_dropped = (tl > 0) ?
451 (rc->layer_input_frames[layer] - rc->layer_enc_frames[layer]) :
452 (rc->layer_input_frames[layer] - rc->layer_enc_frames[layer] - 1);
454 tot_num_frames += rc->layer_input_frames[layer];
455 rc->layer_encoding_bitrate[layer] = 0.001 * rc->layer_framerate[layer] *
456 rc->layer_encoding_bitrate[layer] / tot_num_frames;
457 rc->layer_avg_frame_size[layer] = rc->layer_avg_frame_size[layer] /
458 rc->layer_enc_frames[layer];
459 rc->layer_avg_rate_mismatch[layer] =
460 100.0 * rc->layer_avg_rate_mismatch[layer] /
461 rc->layer_enc_frames[layer];
462 printf(
"For layer#: sl%d tl%d \n", sl, tl);
463 printf(
"Bitrate (target vs actual): %d %f.0 kbps\n",
465 rc->layer_encoding_bitrate[layer]);
466 printf(
"Average frame size (target vs actual): %f %f bits\n",
467 rc->layer_pfb[layer], rc->layer_avg_frame_size[layer]);
468 printf(
"Average rate_mismatch: %f\n",
469 rc->layer_avg_rate_mismatch[layer]);
470 printf(
"Number of input frames, encoded (non-key) frames, " 471 "and percent dropped frames: %d %d %f.0 \n",
472 rc->layer_input_frames[layer], rc->layer_enc_frames[layer],
473 100.0 * num_dropped / rc->layer_input_frames[layer]);
477 rc->avg_st_encoding_bitrate = rc->avg_st_encoding_bitrate / rc->window_count;
478 rc->variance_st_encoding_bitrate =
479 rc->variance_st_encoding_bitrate / rc->window_count -
480 (rc->avg_st_encoding_bitrate * rc->avg_st_encoding_bitrate);
481 perc_fluctuation = 100.0 * sqrt(rc->variance_st_encoding_bitrate) /
482 rc->avg_st_encoding_bitrate;
483 printf(
"Short-time stats, for window of %d frames: \n", rc->window_size);
484 printf(
"Average, rms-variance, and percent-fluct: %f %f %f \n",
485 rc->avg_st_encoding_bitrate,
486 sqrt(rc->variance_st_encoding_bitrate),
488 if (frame_cnt != tot_num_frames)
489 die(
"Error: Number of input frames not equal to output encoded frames != " 490 "%d tot_num_frames = %d\n", frame_cnt, tot_num_frames);
495 uint32_t sizes[8],
int *count) {
504 marker = *(data + data_sz - 1);
508 if ((marker & 0xe0) == 0xc0) {
509 const uint32_t frames = (marker & 0x7) + 1;
510 const uint32_t mag = ((marker >> 3) & 0x3) + 1;
511 const size_t index_sz = 2 + mag * frames;
515 if (data_sz < index_sz)
519 const uint8_t marker2 = *(data + data_sz - index_sz);
524 if (marker != marker2)
531 const uint8_t *x = &data[data_sz - index_sz + 1];
533 for (i = 0; i < frames; ++i) {
534 uint32_t this_sz = 0;
536 for (j = 0; j < mag; ++j)
537 this_sz |= (*x++) << (j * 8);
551 void set_frame_flags_bypass_mode(
int sl,
int tl,
int num_spatial_layers,
554 for (sl = 0; sl < num_spatial_layers; ++sl) {
573 }
else if (tl == 1) {
592 }
else if (tl == 1) {
594 ref_frame_config->
gld_fb_idx[sl] = num_spatial_layers + sl - 1;
595 ref_frame_config->
alt_fb_idx[sl] = num_spatial_layers + sl;
600 int main(
int argc,
const char **argv) {
601 AppInput app_input = {0};
602 VpxVideoWriter *writer = NULL;
603 VpxVideoInfo info = {0};
608 uint32_t frame_cnt = 0;
612 int frame_duration = 1;
614 int end_of_stream = 0;
615 int frames_received = 0;
618 struct RateControlStats rc;
622 double sum_bitrate = 0.0;
623 double sum_bitrate2 = 0.0;
624 double framerate = 30.0;
626 struct vpx_usec_timer timer;
628 memset(&svc_ctx, 0,
sizeof(svc_ctx));
629 svc_ctx.log_print = 1;
631 parse_command_line(argc, argv, &app_input, &svc_ctx, &enc_cfg);
634 #if CONFIG_VP9_HIGHBITDEPTH 637 enc_cfg.
g_w, enc_cfg.
g_h, 32)) {
638 die(
"Failed to allocate image %dx%d\n", enc_cfg.
g_w, enc_cfg.
g_h);
642 die(
"Failed to allocate image %dx%d\n", enc_cfg.
g_w, enc_cfg.
g_h);
644 #endif // CONFIG_VP9_HIGHBITDEPTH 646 if (!(infile = fopen(app_input.input_filename,
"rb")))
647 die(
"Failed to open %s for reading\n", app_input.input_filename);
650 if (vpx_svc_init(&svc_ctx, &codec, vpx_codec_vp9_cx(), &enc_cfg) !=
652 die(
"Failed to initialize encoder\n");
655 if (svc_ctx.output_rc_stat) {
656 set_rate_control_stats(&rc, &enc_cfg);
661 info.codec_fourcc = VP9_FOURCC;
665 if (!(app_input.passes == 2 && app_input.pass == 1)) {
667 writer = vpx_video_writer_open(app_input.output_filename, kContainerIVF,
670 die(
"Failed to open %s for writing\n", app_input.output_filename);
675 if (svc_ctx.output_rc_stat) {
677 char file_name[PATH_MAX];
679 snprintf(file_name,
sizeof(file_name),
"%s_t%d.ivf",
680 app_input.output_filename, tl);
681 outfile[tl] = vpx_video_writer_open(file_name, kContainerIVF, &info);
683 die(
"Failed to open %s for writing", file_name);
689 for (i = 0; i < app_input.frames_to_skip; ++i)
690 vpx_img_read(&raw, infile);
692 if (svc_ctx.speed != -1)
696 if (svc_ctx.speed >= 5 && svc_ctx.aqmode == 1)
701 while (!end_of_stream) {
704 if (frame_cnt >= app_input.frames_to_code || !vpx_img_read(&raw, infile)) {
718 if (frame_cnt % 2 == 0)
719 layer_id.temporal_layer_id = 0;
721 layer_id.temporal_layer_id = 1;
726 set_frame_flags_bypass_mode(sl, layer_id.temporal_layer_id,
727 svc_ctx.spatial_layers,
734 vpx_usec_timer_start(&timer);
735 res = vpx_svc_encode(&svc_ctx, &codec, (end_of_stream ? NULL : &raw),
736 pts, frame_duration, svc_ctx.speed >= 5 ?
738 vpx_usec_timer_mark(&timer);
739 cx_time += vpx_usec_timer_elapsed(&timer);
741 printf(
"%s", vpx_svc_get_message(&svc_ctx));
743 die_codec(&codec,
"Failed to encode frame");
747 switch (cx_pkt->
kind) {
754 vpx_video_writer_write_frame(writer,
760 if (svc_ctx.output_rc_stat) {
762 parse_superframe_index(cx_pkt->
data.
frame.buf,
766 layer_id.temporal_layer_id];
768 for (tl = layer_id.temporal_layer_id;
770 vpx_video_writer_write_frame(outfile[tl],
777 for (tl = layer_id.temporal_layer_id;
780 ++rc.layer_tot_enc_frames[layer];
781 rc.layer_encoding_bitrate[layer] += 8.0 * sizes[sl];
784 if (tl == layer_id.temporal_layer_id &&
786 rc.layer_avg_frame_size[layer] += 8.0 * sizes[sl];
787 rc.layer_avg_rate_mismatch[layer] +=
788 fabs(8.0 * sizes[sl] - rc.layer_pfb[layer]) /
790 ++rc.layer_enc_frames[layer];
798 if (frame_cnt > rc.window_size) {
799 tl = layer_id.temporal_layer_id;
801 sum_bitrate += 0.001 * 8.0 * sizes[sl] * framerate;
803 if (frame_cnt % rc.window_size == 0) {
804 rc.window_count += 1;
805 rc.avg_st_encoding_bitrate += sum_bitrate / rc.window_size;
806 rc.variance_st_encoding_bitrate +=
807 (sum_bitrate / rc.window_size) *
808 (sum_bitrate / rc.window_size);
814 if (frame_cnt > rc.window_size + rc.window_size / 2) {
815 tl = layer_id.temporal_layer_id;
817 sum_bitrate2 += 0.001 * 8.0 * sizes[sl] * framerate;
820 if (frame_cnt > 2 * rc.window_size &&
821 frame_cnt % rc.window_size == 0) {
822 rc.window_count += 1;
823 rc.avg_st_encoding_bitrate += sum_bitrate2 / rc.window_size;
824 rc.variance_st_encoding_bitrate +=
825 (sum_bitrate2 / rc.window_size) *
826 (sum_bitrate2 / rc.window_size);
834 printf(
"SVC frame: %d, kf: %d, size: %d, pts: %d\n", frames_received,
841 stats_write(&app_input.rc_stats,
852 if (!end_of_stream) {
854 pts += frame_duration;
857 printf(
"Processed %d frames\n", frame_cnt);
860 if (svc_ctx.output_rc_stat) {
861 printout_rate_control_summary(&rc, &enc_cfg, frame_cnt);
866 if (app_input.passes == 2)
867 stats_close(&app_input.rc_stats, 1);
869 vpx_video_writer_close(writer);
872 if (svc_ctx.output_rc_stat) {
874 vpx_video_writer_close(outfile[tl]);
878 printf(
"Frame cnt and encoding time/FPS stats for encoding: %d %f %f \n",
880 1000 * (
float)cx_time / (
double)(frame_cnt * 1000000),
881 1000000 * (
double)frame_cnt / (
double)cx_time);
884 printf(
"%s", vpx_svc_dump_statistics(&svc_ctx));
885 vpx_svc_release(&svc_ctx);
vpx_fixed_buf_t twopass_stats
Definition: vpx_encoder.h:214
unsigned int ts_number_layers
Number of temporal coding layers.
Definition: vpx_encoder.h:715
Codec control function to set encoder internal speed settings.
Definition: vp8cx.h:173
#define VPX_MAX_LAYERS
Definition: vpx_encoder.h:46
#define VP8_EFLAG_NO_REF_LAST
Don't reference the last frame.
Definition: vp8cx.h:67
#define VP8_EFLAG_NO_UPD_GF
Don't update the golden frame.
Definition: vp8cx.h:101
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.
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:693
#define VPX_TS_MAX_LAYERS
Definition: vpx_encoder.h:40
struct vpx_rational g_timebase
Stream timebase units.
Definition: vpx_encoder.h:397
unsigned int layer_target_bitrate[12]
Target bitrate for each spatial/temporal layer.
Definition: vpx_encoder.h:755
#define VP8_EFLAG_NO_REF_GF
Don't reference the golden frame.
Definition: vp8cx.h:76
unsigned int g_input_bit_depth
Bit-depth of the input frames.
Definition: vpx_encoder.h:383
int den
Definition: vpx_encoder.h:261
Definition: vpx_encoder.h:177
unsigned int kf_max_dist
Keyframe maximum interval.
Definition: vpx_encoder.h:685
unsigned int g_lag_in_frames
Allow lagged encoding.
Definition: vpx_encoder.h:429
Encoder configuration structure.
Definition: vpx_encoder.h:314
The coded data for this stream is corrupt or incomplete.
Definition: vpx_codec.h:129
Encoder output packet.
Definition: vpx_encoder.h:195
void * buf
Definition: vpx_encoder.h:109
unsigned int ts_rate_decimator[5]
Frame rate decimation factor for each temporal layer.
Definition: vpx_encoder.h:729
unsigned int kf_min_dist
Keyframe minimum interval.
Definition: vpx_encoder.h:675
Definition: vpx_encoder.h:268
unsigned int g_profile
Bitstream profile to use.
Definition: vpx_encoder.h:346
Definition: vpx_encoder.h:269
Codec control function to set number of tile columns.
Definition: vp8cx.h:362
struct vpx_codec_cx_pkt::@1::@2 frame
int frame_flags[5]
Definition: vp8cx.h:692
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:56
unsigned int g_w
Width of the frame.
Definition: vpx_encoder.h:357
Codec control function to set adaptive quantization mode.
Definition: vp8cx.h:409
Codec control function to get svc layer ID.
Definition: vp8cx.h:475
unsigned int g_h
Height of the frame.
Definition: vpx_encoder.h:367
enum vpx_codec_cx_pkt_kind kind
Definition: vpx_encoder.h:196
vp9 svc layer parameters
Definition: vp8cx.h:678
Operation completed without error.
Definition: vpx_codec.h:91
#define VP8_EFLAG_NO_UPD_LAST
Don't update the last frame.
Definition: vp8cx.h:93
void vpx_img_free(vpx_image_t *img)
Close an image descriptor.
unsigned int rc_target_bitrate
Target data rate.
Definition: vpx_encoder.h:525
#define VPX_DL_REALTIME
Definition: vpx_encoder.h:911
int num
Definition: vpx_encoder.h:260
Definition: vpx_codec.h:222
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:548
enum vpx_enc_pass g_pass
Multi-pass Encoding Mode.
Definition: vpx_encoder.h:414
#define VPX_DL_GOOD_QUALITY
Definition: vpx_encoder.h:914
unsigned int ss_number_layers
Number of spatial coding layers.
Definition: vpx_encoder.h:695
vpx_bit_depth_t g_bit_depth
Bit-depth of the codec.
Definition: vpx_encoder.h:375
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:586
vpx_codec_err_t
Algorithm return codes.
Definition: vpx_codec.h:89
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:763
vpx_fixed_buf_t rc_twopass_stats_in
Two-pass stats buffer.
Definition: vpx_encoder.h:512
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:277
#define vpx_codec_control(ctx, id, data)
vpx_codec_control wrapper macro
Definition: vpx_codec.h:407
#define VP8_EFLAG_NO_REF_ARF
Don't reference the alternate reference frame.
Definition: vp8cx.h:85
vpx_codec_err_t vpx_codec_destroy(vpx_codec_ctx_t *ctx)
Destroy a codec instance.
size_t sz
Definition: vpx_encoder.h:110
Definition: vpx_codec.h:220
vp9 svc frame flag parameters.
Definition: vp8cx.h:691
#define VPX_FRAME_IS_KEY
Definition: vpx_encoder.h:130
Definition: vpx_codec.h:221
int alt_fb_idx[5]
Definition: vp8cx.h:695
const void * vpx_codec_iter_t
Iterator.
Definition: vpx_codec.h:188
Definition: vpx_encoder.h:176
unsigned int rc_2pass_vbr_maxsection_pct
Two-pass mode per-GOP maximum bitrate.
Definition: vpx_encoder.h:652
vpx_codec_er_flags_t g_error_resilient
Enable error resilient modes.
Definition: vpx_encoder.h:406
#define VP8_EFLAG_NO_UPD_ARF
Don't update the alternate reference frame.
Definition: vp8cx.h:109
unsigned int rc_2pass_vbr_minsection_pct
Two-pass mode per-GOP minimum bitrate.
Definition: vpx_encoder.h:644
int gld_fb_idx[5]
Definition: vp8cx.h:694
Codec control function to set svc layer for spatial and temporal.
Definition: vp8cx.h:458
enum vpx_rc_mode rc_end_usage
Rate control algorithm to use.
Definition: vpx_encoder.h:504
Definition: vpx_encoder.h:267
Codec context structure.
Definition: vpx_codec.h:199