24 #include "../tools_common.h" 25 #include "../video_writer.h" 27 #include "../vpx_ports/vpx_timer.h" 28 #include "./svc_context.h" 31 #include "../vpxstats.h" 32 #include "vp9/encoder/vp9_encoder.h" 33 #include "./y4minput.h" 35 #define OUTPUT_RC_STATS 1 37 #define SIMULCAST_MODE 0 39 static const arg_def_t outputfile =
40 ARG_DEF(
"o",
"output", 1,
"Output filename");
41 static const arg_def_t skip_frames_arg =
42 ARG_DEF(
"s",
"skip-frames", 1,
"input frames to skip");
43 static const arg_def_t frames_arg =
44 ARG_DEF(
"f",
"frames", 1,
"number of frames to encode");
45 static const arg_def_t threads_arg =
46 ARG_DEF(
"th",
"threads", 1,
"number of threads to use");
48 static const arg_def_t output_rc_stats_arg =
49 ARG_DEF(
"rcstat",
"output_rc_stats", 1,
"output rc stats");
51 static const arg_def_t width_arg = ARG_DEF(
"w",
"width", 1,
"source width");
52 static const arg_def_t height_arg = ARG_DEF(
"h",
"height", 1,
"source height");
53 static const arg_def_t timebase_arg =
54 ARG_DEF(
"t",
"timebase", 1,
"timebase (num/den)");
55 static const arg_def_t bitrate_arg = ARG_DEF(
56 "b",
"target-bitrate", 1,
"encoding bitrate, in kilobits per second");
57 static const arg_def_t spatial_layers_arg =
58 ARG_DEF(
"sl",
"spatial-layers", 1,
"number of spatial SVC layers");
59 static const arg_def_t temporal_layers_arg =
60 ARG_DEF(
"tl",
"temporal-layers", 1,
"number of temporal SVC layers");
61 static const arg_def_t temporal_layering_mode_arg =
62 ARG_DEF(
"tlm",
"temporal-layering-mode", 1,
63 "temporal layering scheme." 64 "VP9E_TEMPORAL_LAYERING_MODE");
65 static const arg_def_t kf_dist_arg =
66 ARG_DEF(
"k",
"kf-dist", 1,
"number of frames between keyframes");
67 static const arg_def_t scale_factors_arg =
68 ARG_DEF(
"r",
"scale-factors", 1,
"scale factors (lowest to highest layer)");
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]");
89 static const arg_def_t dropframe_thresh_arg =
90 ARG_DEF(NULL,
"drop-frame", 1,
"Temporal resampling threshold (buf %)");
91 static const struct arg_enum_list tune_content_enum[] = {
92 {
"default", VP9E_CONTENT_DEFAULT },
93 {
"screen", VP9E_CONTENT_SCREEN },
94 {
"film", VP9E_CONTENT_FILM },
98 static const arg_def_t tune_content_arg = ARG_DEF_ENUM(
99 NULL,
"tune-content", 1,
"Tune content type", tune_content_enum);
100 static const arg_def_t inter_layer_pred_arg = ARG_DEF(
101 NULL,
"inter-layer-pred", 1,
"0 - 3: On, Off, Key-frames, Constrained");
103 #if CONFIG_VP9_HIGHBITDEPTH 104 static const struct arg_enum_list bitdepth_enum[] = {
108 static const arg_def_t bitdepth_arg = ARG_DEF_ENUM(
109 "d",
"bit-depth", 1,
"Bit depth for codec 8, 10 or 12. ", bitdepth_enum);
110 #endif // CONFIG_VP9_HIGHBITDEPTH 112 static const arg_def_t *svc_args[] = { &frames_arg,
126 &temporal_layers_arg,
127 &temporal_layering_mode_arg,
132 &output_rc_stats_arg,
135 #if CONFIG_VP9_HIGHBITDEPTH 141 &dropframe_thresh_arg,
143 &inter_layer_pred_arg,
146 static const uint32_t default_frames_to_skip = 0;
147 static const uint32_t default_frames_to_code = 60 * 60;
148 static const uint32_t default_width = 1920;
149 static const uint32_t default_height = 1080;
150 static const uint32_t default_timebase_num = 1;
151 static const uint32_t default_timebase_den = 60;
152 static const uint32_t default_bitrate = 1000;
153 static const uint32_t default_spatial_layers = 5;
154 static const uint32_t default_temporal_layers = 1;
155 static const uint32_t default_kf_dist = 100;
156 static const uint32_t default_temporal_layering_mode = 0;
157 static const uint32_t default_output_rc_stats = 0;
158 static const int32_t default_speed = -1;
159 static const uint32_t default_threads = 0;
162 const char *output_filename;
163 uint32_t frames_to_code;
164 uint32_t frames_to_skip;
165 struct VpxInputContext input_ctx;
168 int inter_layer_pred;
171 static const char *exec_name;
173 void usage_exit(
void) {
174 fprintf(stderr,
"Usage: %s <options> input_filename -o output_filename\n",
176 fprintf(stderr,
"Options:\n");
177 arg_show_usage(stderr, svc_args);
181 static void parse_command_line(
int argc,
const char **argv_,
182 AppInput *app_input, SvcContext *svc_ctx,
189 unsigned int min_bitrate = 0;
190 unsigned int max_bitrate = 0;
191 char string_options[1024] = { 0 };
194 svc_ctx->log_level = SVC_LOG_DEBUG;
195 svc_ctx->spatial_layers = default_spatial_layers;
196 svc_ctx->temporal_layers = default_temporal_layers;
197 svc_ctx->temporal_layering_mode = default_temporal_layering_mode;
199 svc_ctx->output_rc_stat = default_output_rc_stats;
201 svc_ctx->speed = default_speed;
202 svc_ctx->threads = default_threads;
210 enc_cfg->
g_w = default_width;
211 enc_cfg->
g_h = default_height;
220 app_input->frames_to_code = default_frames_to_code;
221 app_input->frames_to_skip = default_frames_to_skip;
224 argv = argv_dup(argc - 1, argv_ + 1);
226 fprintf(stderr,
"Error allocating argument list\n");
229 for (argi = argj = argv; (*argj = *argi); argi += arg.argv_step) {
232 if (arg_match(&arg, &frames_arg, argi)) {
233 app_input->frames_to_code = arg_parse_uint(&arg);
234 }
else if (arg_match(&arg, &outputfile, argi)) {
235 app_input->output_filename = arg.val;
236 }
else if (arg_match(&arg, &width_arg, argi)) {
237 enc_cfg->
g_w = arg_parse_uint(&arg);
238 }
else if (arg_match(&arg, &height_arg, argi)) {
239 enc_cfg->
g_h = arg_parse_uint(&arg);
240 }
else if (arg_match(&arg, &timebase_arg, argi)) {
241 enc_cfg->
g_timebase = arg_parse_rational(&arg);
242 }
else if (arg_match(&arg, &bitrate_arg, argi)) {
244 }
else if (arg_match(&arg, &skip_frames_arg, argi)) {
245 app_input->frames_to_skip = arg_parse_uint(&arg);
246 }
else if (arg_match(&arg, &spatial_layers_arg, argi)) {
247 svc_ctx->spatial_layers = arg_parse_uint(&arg);
248 }
else if (arg_match(&arg, &temporal_layers_arg, argi)) {
249 svc_ctx->temporal_layers = arg_parse_uint(&arg);
251 }
else if (arg_match(&arg, &output_rc_stats_arg, argi)) {
252 svc_ctx->output_rc_stat = arg_parse_uint(&arg);
254 }
else if (arg_match(&arg, &speed_arg, argi)) {
255 svc_ctx->speed = arg_parse_uint(&arg);
256 if (svc_ctx->speed > 9) {
257 warn(
"Mapping speed %d to speed 9.\n", svc_ctx->speed);
259 }
else if (arg_match(&arg, &aqmode_arg, argi)) {
260 svc_ctx->aqmode = arg_parse_uint(&arg);
261 }
else if (arg_match(&arg, &threads_arg, argi)) {
262 svc_ctx->threads = arg_parse_uint(&arg);
263 }
else if (arg_match(&arg, &temporal_layering_mode_arg, argi)) {
266 if (svc_ctx->temporal_layering_mode) {
269 }
else if (arg_match(&arg, &kf_dist_arg, argi)) {
272 }
else if (arg_match(&arg, &scale_factors_arg, argi)) {
273 strncat(string_options,
" scale-factors=",
274 sizeof(string_options) - strlen(string_options) - 1);
275 strncat(string_options, arg.val,
276 sizeof(string_options) - strlen(string_options) - 1);
277 }
else if (arg_match(&arg, &bitrates_arg, argi)) {
278 strncat(string_options,
" bitrates=",
279 sizeof(string_options) - strlen(string_options) - 1);
280 strncat(string_options, arg.val,
281 sizeof(string_options) - strlen(string_options) - 1);
282 }
else if (arg_match(&arg, &min_q_arg, argi)) {
283 strncat(string_options,
" min-quantizers=",
284 sizeof(string_options) - strlen(string_options) - 1);
285 strncat(string_options, arg.val,
286 sizeof(string_options) - strlen(string_options) - 1);
287 }
else if (arg_match(&arg, &max_q_arg, argi)) {
288 strncat(string_options,
" max-quantizers=",
289 sizeof(string_options) - strlen(string_options) - 1);
290 strncat(string_options, arg.val,
291 sizeof(string_options) - strlen(string_options) - 1);
292 }
else if (arg_match(&arg, &min_bitrate_arg, argi)) {
293 min_bitrate = arg_parse_uint(&arg);
294 }
else if (arg_match(&arg, &max_bitrate_arg, argi)) {
295 max_bitrate = arg_parse_uint(&arg);
296 }
else if (arg_match(&arg, &lag_in_frame_arg, argi)) {
298 }
else if (arg_match(&arg, &rc_end_usage_arg, argi)) {
300 #if CONFIG_VP9_HIGHBITDEPTH 301 }
else if (arg_match(&arg, &bitdepth_arg, argi)) {
302 enc_cfg->
g_bit_depth = arg_parse_enum_or_int(&arg);
317 die(
"Error: Invalid bit depth selected (%d)\n", enc_cfg->
g_bit_depth);
320 #endif // CONFIG_VP9_HIGHBITDEPTH 321 }
else if (arg_match(&arg, &dropframe_thresh_arg, argi)) {
323 }
else if (arg_match(&arg, &tune_content_arg, argi)) {
324 app_input->tune_content = arg_parse_uint(&arg);
325 }
else if (arg_match(&arg, &inter_layer_pred_arg, argi)) {
326 app_input->inter_layer_pred = arg_parse_uint(&arg);
333 if (strlen(string_options) > 0)
334 vpx_svc_set_options(svc_ctx, string_options + 1);
339 if (min_bitrate > 0) {
343 if (max_bitrate > 0) {
350 for (argi = argv; *argi; ++argi)
351 if (argi[0][0] ==
'-' && strlen(argi[0]) > 1)
352 die(
"Error: Unrecognized option %s\n", *argi);
354 if (argv[0] == NULL) {
357 app_input->input_ctx.filename = argv[0];
360 open_input_file(&app_input->input_ctx);
361 if (app_input->input_ctx.file_type == FILE_TYPE_Y4M) {
362 enc_cfg->
g_w = app_input->input_ctx.width;
363 enc_cfg->
g_h = app_input->input_ctx.height;
364 enc_cfg->
g_timebase.
den = app_input->input_ctx.framerate.numerator;
365 enc_cfg->
g_timebase.
num = app_input->input_ctx.framerate.denominator;
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,
511 size_t data_sz, uint64_t sizes[8],
521 marker = *(data + data_sz - 1);
524 if ((marker & 0xe0) == 0xc0) {
525 const uint32_t frames = (marker & 0x7) + 1;
526 const uint32_t mag = ((marker >> 3) & 0x3) + 1;
527 const size_t index_sz = 2 + mag * frames;
534 const uint8_t marker2 = *(data + data_sz - index_sz);
545 const uint8_t *x = &data[data_sz - index_sz + 1];
547 for (i = 0; i < frames; ++i) {
548 uint32_t this_sz = 0;
550 for (j = 0; j < mag; ++j) this_sz |= (*x++) << (j * 8);
564 static void set_frame_flags_bypass_mode_ex0(
565 int tl,
int num_spatial_layers,
int is_key_frame,
568 for (sl = 0; sl < num_spatial_layers; ++sl)
571 for (sl = 0; sl < num_spatial_layers; ++sl) {
586 }
else if (tl == 1) {
589 (sl == 0) ? 0 : num_spatial_layers + sl - 1;
590 ref_frame_config->
alt_fb_idx[sl] = num_spatial_layers + sl;
617 }
else if (tl == 1) {
627 if (sl < num_spatial_layers - 1) {
633 }
else if (sl == num_spatial_layers - 1) {
647 static void set_frame_flags_bypass_mode_ex1(
648 int tl,
int num_spatial_layers,
int is_key_frame,
651 for (sl = 0; sl < num_spatial_layers; ++sl)
710 #if CONFIG_VP9_DECODER && !SIMULCAST_MODE 712 const int frames_out,
int *mismatch_seen) {
715 if (*mismatch_seen)
return;
720 enc_img = ref_enc.img;
722 dec_img = ref_dec.img;
723 #if CONFIG_VP9_HIGHBITDEPTH 728 enc_img.
d_w, enc_img.
d_h, 16);
729 vpx_img_truncate_16_to_8(&enc_img, &ref_enc.img);
733 dec_img.
d_w, dec_img.
d_h, 16);
734 vpx_img_truncate_16_to_8(&dec_img, &ref_dec.img);
739 if (!compare_img(&enc_img, &dec_img)) {
740 int y[4], u[4], v[4];
741 #if CONFIG_VP9_HIGHBITDEPTH 743 find_mismatch_high(&enc_img, &dec_img, y, u, v);
745 find_mismatch(&enc_img, &dec_img, y, u, v);
748 find_mismatch(&enc_img, &dec_img, y, u, v);
752 "Encode/decode mismatch on frame %d at" 753 " Y[%d, %d] {%d/%d}," 754 " U[%d, %d] {%d/%d}," 755 " V[%d, %d] {%d/%d}\n",
756 frames_out, y[0], y[1], y[2], y[3], u[0], u[1], u[2], u[3], v[0], v[1],
758 *mismatch_seen = frames_out;
767 static void svc_output_rc_stats(
770 struct RateControlStats *rc, VpxVideoWriter **outfile,
771 const uint32_t frame_cnt,
const double framerate) {
772 int num_layers_encoded = 0;
775 uint64_t sizes_parsed[8];
777 double sum_bitrate = 0.0;
778 double sum_bitrate2 = 0.0;
780 vp9_zero(sizes_parsed);
783 sizes_parsed, &count);
789 if (cx_pkt->
data.
frame.spatial_layer_encoded[sl]) {
790 sizes[sl] = sizes_parsed[num_layers_encoded];
791 num_layers_encoded++;
797 uint64_t tot_size = 0;
799 for (sl2 = 0; sl2 < sl; ++sl2) {
800 if (cx_pkt->
data.
frame.spatial_layer_encoded[sl2]) tot_size += sizes[sl2];
802 vpx_video_writer_write_frame(outfile[sl],
803 (uint8_t *)(cx_pkt->
data.
frame.buf) + tot_size,
804 (
size_t)(sizes[sl]), cx_pkt->
data.
frame.pts);
806 for (sl2 = 0; sl2 <= sl; ++sl2) {
807 if (cx_pkt->
data.
frame.spatial_layer_encoded[sl2]) tot_size += sizes[sl2];
810 vpx_video_writer_write_frame(outfile[sl], cx_pkt->
data.
frame.buf,
811 (
size_t)(tot_size), cx_pkt->
data.
frame.pts);
812 #endif // SIMULCAST_MODE 815 if (cx_pkt->
data.
frame.spatial_layer_encoded[sl]) {
819 ++rc->layer_tot_enc_frames[layer];
820 rc->layer_encoding_bitrate[layer] += 8.0 * sizes[sl];
825 rc->layer_avg_frame_size[layer] += 8.0 * sizes[sl];
826 rc->layer_avg_rate_mismatch[layer] +=
827 fabs(8.0 * sizes[sl] - rc->layer_pfb[layer]) /
828 rc->layer_pfb[layer];
829 ++rc->layer_enc_frames[layer];
838 if (frame_cnt > (
unsigned int)rc->window_size) {
840 if (cx_pkt->
data.
frame.spatial_layer_encoded[sl])
841 sum_bitrate += 0.001 * 8.0 * sizes[sl] * framerate;
843 if (frame_cnt % rc->window_size == 0) {
844 rc->window_count += 1;
845 rc->avg_st_encoding_bitrate += sum_bitrate / rc->window_size;
846 rc->variance_st_encoding_bitrate +=
847 (sum_bitrate / rc->window_size) * (sum_bitrate / rc->window_size);
852 if (frame_cnt > (
unsigned int)(rc->window_size + rc->window_size / 2)) {
854 sum_bitrate2 += 0.001 * 8.0 * sizes[sl] * framerate;
857 if (frame_cnt > (
unsigned int)(2 * rc->window_size) &&
858 frame_cnt % rc->window_size == 0) {
859 rc->window_count += 1;
860 rc->avg_st_encoding_bitrate += sum_bitrate2 / rc->window_size;
861 rc->variance_st_encoding_bitrate +=
862 (sum_bitrate2 / rc->window_size) * (sum_bitrate2 / rc->window_size);
868 int main(
int argc,
const char **argv) {
870 VpxVideoWriter *writer = NULL;
877 uint32_t frame_cnt = 0;
881 int frame_duration = 1;
882 int end_of_stream = 0;
883 int frames_received = 0;
886 struct RateControlStats rc;
890 double framerate = 30.0;
892 struct vpx_usec_timer timer;
894 #if CONFIG_INTERNAL_STATS 895 FILE *f = fopen(
"opsnr.stt",
"a");
897 #if CONFIG_VP9_DECODER && !SIMULCAST_MODE 898 int mismatch_seen = 0;
901 memset(&svc_ctx, 0,
sizeof(svc_ctx));
902 memset(&app_input, 0,
sizeof(AppInput));
903 memset(&info, 0,
sizeof(VpxVideoInfo));
905 memset(&rc, 0,
sizeof(
struct RateControlStats));
909 app_input.input_ctx.framerate.numerator = 30;
910 app_input.input_ctx.framerate.denominator = 1;
911 app_input.input_ctx.only_i420 = 1;
912 app_input.input_ctx.bit_depth = 0;
914 parse_command_line(argc, argv, &app_input, &svc_ctx, &enc_cfg);
917 if (app_input.input_ctx.file_type != FILE_TYPE_Y4M) {
919 #if CONFIG_VP9_HIGHBITDEPTH 922 : VPX_IMG_FMT_I42016,
923 enc_cfg.
g_w, enc_cfg.
g_h, 32)) {
924 die(
"Failed to allocate image %dx%d\n", enc_cfg.
g_w, enc_cfg.
g_h);
928 die(
"Failed to allocate image %dx%d\n", enc_cfg.
g_w, enc_cfg.
g_h);
930 #endif // CONFIG_VP9_HIGHBITDEPTH 936 die(
"Failed to initialize encoder\n");
937 #if CONFIG_VP9_DECODER && !SIMULCAST_MODE 939 &decoder, get_vpx_decoder_by_name(
"vp9")->codec_interface(), NULL, 0))
940 die(
"Failed to initialize decoder\n");
946 rc.avg_st_encoding_bitrate = 0.0;
947 rc.variance_st_encoding_bitrate = 0.0;
948 if (svc_ctx.output_rc_stat) {
949 set_rate_control_stats(&rc, &enc_cfg);
954 info.codec_fourcc = VP9_FOURCC;
955 info.frame_width = enc_cfg.
g_w;
956 info.frame_height = enc_cfg.
g_h;
961 vpx_video_writer_open(app_input.output_filename, kContainerIVF, &info);
963 die(
"Failed to open %s for writing\n", app_input.output_filename);
968 if (svc_ctx.output_rc_stat) {
970 char file_name[PATH_MAX];
972 snprintf(file_name,
sizeof(file_name),
"%s_s%d.ivf",
973 app_input.output_filename, sl);
974 outfile[sl] = vpx_video_writer_open(file_name, kContainerIVF, &info);
975 if (!outfile[sl]) die(
"Failed to open %s for writing", file_name);
981 for (i = 0; i < app_input.frames_to_skip; ++i)
982 read_frame(&app_input.input_ctx, &raw);
984 if (svc_ctx.speed != -1)
986 if (svc_ctx.threads) {
988 get_msb(svc_ctx.threads));
989 if (svc_ctx.threads > 1)
994 if (svc_ctx.speed >= 5 && svc_ctx.aqmode == 1)
996 if (svc_ctx.speed >= 5)
1001 app_input.inter_layer_pred);
1011 for (sl = 0; sl < (
unsigned int)svc_ctx.spatial_layers; ++sl)
1017 while (!end_of_stream) {
1025 int example_pattern = 0;
1026 if (frame_cnt >= app_input.frames_to_code ||
1027 !read_frame(&app_input.input_ctx, &raw)) {
1040 layer_id.spatial_layer_id = 0;
1042 if (frame_cnt % 2 == 0) {
1043 layer_id.temporal_layer_id = 0;
1045 layer_id.temporal_layer_id_per_spatial[i] = 0;
1047 layer_id.temporal_layer_id = 1;
1049 layer_id.temporal_layer_id_per_spatial[i] = 1;
1051 if (example_pattern == 1) {
1053 assert(svc_ctx.spatial_layers == 2);
1054 assert(svc_ctx.temporal_layers == 2);
1055 if (frame_cnt % 2 == 0) {
1057 layer_id.temporal_layer_id_per_spatial[0] = 0;
1058 layer_id.temporal_layer_id_per_spatial[1] = 0;
1059 layer_id.spatial_layer_id = 0;
1062 layer_id.temporal_layer_id_per_spatial[1] = 1;
1063 layer_id.spatial_layer_id = 1;
1069 if (example_pattern == 0) {
1070 set_frame_flags_bypass_mode_ex0(layer_id.temporal_layer_id,
1071 svc_ctx.spatial_layers, frame_cnt == 0,
1073 }
else if (example_pattern == 1) {
1074 set_frame_flags_bypass_mode_ex1(layer_id.temporal_layer_id,
1075 svc_ctx.spatial_layers, frame_cnt == 0,
1078 ref_frame_config.
duration[0] = frame_duration * 1;
1079 ref_frame_config.
duration[1] = frame_duration * 1;
1087 layer_id.temporal_layer_id];
1091 unsigned int tl = 0;
1093 tl = (frame_cnt % 2 != 0);
1095 if (frame_cnt % 2 != 0) tl = 2;
1096 if ((frame_cnt > 1) && ((frame_cnt - 2) % 4 == 0)) tl = 1;
1102 vpx_usec_timer_start(&timer);
1103 res = vpx_svc_encode(
1104 &svc_ctx, &encoder, (end_of_stream ? NULL : &raw), pts, frame_duration,
1106 vpx_usec_timer_mark(&timer);
1107 cx_time += vpx_usec_timer_elapsed(&timer);
1111 die_codec(&encoder,
"Failed to encode frame");
1115 switch (cx_pkt->
kind) {
1117 SvcInternal_t *
const si = (SvcInternal_t *)svc_ctx.internal;
1119 vpx_video_writer_write_frame(writer, cx_pkt->
data.
frame.buf,
1123 if (svc_ctx.output_rc_stat) {
1124 svc_output_rc_stats(&encoder, &enc_cfg, &layer_id, cx_pkt, &rc,
1125 outfile, frame_cnt, framerate);
1135 si->bytes_sum[0] += (int)cx_pkt->
data.
frame.sz;
1137 #
if CONFIG_VP9_DECODER && !SIMULCAST_MODE
1139 (
unsigned int)cx_pkt->
data.
frame.sz, NULL, 0))
1140 die_codec(&decoder,
"Failed to decode frame.");
1152 #if CONFIG_VP9_DECODER && !SIMULCAST_MODE 1157 !(layer_id.temporal_layer_id > 0 &&
1161 test_decode(&encoder, &decoder, frame_cnt, &mismatch_seen);
1166 if (!end_of_stream) {
1168 pts += frame_duration;
1172 printf(
"Processed %d frames\n", frame_cnt);
1174 close_input_file(&app_input.input_ctx);
1177 if (svc_ctx.output_rc_stat) {
1178 printout_rate_control_summary(&rc, &enc_cfg, frame_cnt);
1183 die_codec(&encoder,
"Failed to destroy codec");
1185 vpx_video_writer_close(writer);
1188 if (svc_ctx.output_rc_stat) {
1190 vpx_video_writer_close(outfile[sl]);
1194 #if CONFIG_INTERNAL_STATS 1195 if (mismatch_seen) {
1196 fprintf(f,
"First mismatch occurred in frame %d\n", mismatch_seen);
1198 fprintf(f,
"No mismatch detected in recon buffers\n");
1202 printf(
"Frame cnt and encoding time/FPS stats for encoding: %d %f %f \n",
1203 frame_cnt, 1000 * (
float)cx_time / (
double)(frame_cnt * 1000000),
1204 1000000 * (
double)frame_cnt / (
double)cx_time);
1205 if (app_input.input_ctx.file_type != FILE_TYPE_Y4M) {
1209 vpx_svc_dump_statistics(&svc_ctx);
1210 vpx_svc_release(&svc_ctx);
1211 return EXIT_SUCCESS;
vpx_fixed_buf_t twopass_stats
Definition: vpx_encoder.h:184
unsigned int ts_number_layers
Number of temporal coding layers.
Definition: vpx_encoder.h:646
Codec control function to disable increase Q on overshoot in CBR.
Definition: vp8cx.h:699
Codec control function to set encoder internal speed settings.
Definition: vp8cx.h:172
#define VPX_MAX_LAYERS
Definition: vpx_encoder.h:44
int reference_alt_ref[5]
Definition: vp8cx.h:909
Image Descriptor.
Definition: vpx_image.h:72
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:624
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:899
Codec control function to set content type.
Definition: vp8cx.h:480
struct vpx_rational g_timebase
Stream timebase units.
Definition: vpx_encoder.h:345
Codec control function to set noise sensitivity.
Definition: vp8cx.h:438
unsigned int layer_target_bitrate[12]
Target bitrate for each spatial/temporal layer.
Definition: vpx_encoder.h:686
SVC_LAYER_DROP_MODE framedrop_mode
Definition: vp8cx.h:937
unsigned int g_input_bit_depth
Bit-depth of the input frames.
Definition: vpx_encoder.h:331
int den
Definition: vpx_encoder.h:222
Definition: vpx_encoder.h:150
int framedrop_thresh[5]
Definition: vp8cx.h:935
unsigned int kf_max_dist
Keyframe maximum interval.
Definition: vpx_encoder.h:616
unsigned int g_lag_in_frames
Allow lagged encoding.
Definition: vpx_encoder.h:374
Encoder configuration structure.
Definition: vpx_encoder.h:270
int reference_golden[5]
Definition: vp8cx.h:908
The coded data for this stream is corrupt or incomplete.
Definition: vpx_codec.h:133
Codec control function to set row level multi-threading.
Definition: vp8cx.h:575
Codec control function to disable loopfilter.
Definition: vp8cx.h:708
Codec control function to set Max data rate for Intra frames.
Definition: vp8cx.h:274
Encoder output packet.
Definition: vpx_encoder.h:161
void * buf
Definition: vpx_encoder.h:99
unsigned int ts_rate_decimator[5]
Frame rate decimation factor for each temporal layer.
Definition: vpx_encoder.h:660
unsigned int kf_min_dist
Keyframe minimum interval.
Definition: vpx_encoder.h:607
vp9 svc frame dropping parameters.
Definition: vp8cx.h:934
unsigned int g_profile
Bitstream profile to use.
Definition: vpx_encoder.h:297
Codec control function to set number of tile columns.
Definition: vp8cx.h:368
#define VPX_IMG_FMT_HIGHBITDEPTH
Definition: vpx_image.h:35
struct vpx_codec_cx_pkt::@1::@2 frame
#define VPX_SS_MAX_LAYERS
Definition: vpx_encoder.h:47
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:42
unsigned int d_w
Definition: vpx_image.h:83
#define vpx_codec_dec_init(ctx, iface, cfg, flags)
Convenience macro for vpx_codec_dec_init_ver()
Definition: vpx_decoder.h:143
unsigned int g_w
Width of the frame.
Definition: vpx_encoder.h:306
int reference_last[5]
Definition: vp8cx.h:907
int update_buffer_slot[5]
Definition: vp8cx.h:902
Codec control function to set adaptive quantization mode.
Definition: vp8cx.h:415
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.
Codec control function to get svc layer ID.
Definition: vp8cx.h:488
unsigned int g_h
Height of the frame.
Definition: vpx_encoder.h:315
enum vpx_codec_cx_pkt_kind kind
Definition: vpx_encoder.h:162
unsigned int rc_dropframe_thresh
Temporal resampling configuration, if supported by the codec.
Definition: vpx_encoder.h:393
vp9 svc layer parameters
Definition: vp8cx.h:883
Operation completed without error.
Definition: vpx_codec.h:95
void vpx_img_free(vpx_image_t *img)
Close an image descriptor.
vpx_img_fmt_t fmt
Definition: vpx_image.h:73
unsigned int rc_target_bitrate
Target data rate.
Definition: vpx_encoder.h:462
#define VPX_DL_REALTIME
deadline parameter analogous to VPx REALTIME mode.
Definition: vpx_encoder.h:978
int num
Definition: vpx_encoder.h:221
Definition: vpx_codec.h:223
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.
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:550
enum vpx_enc_pass g_pass
Multi-pass Encoding Mode.
Definition: vpx_encoder.h:360
Codec control function to set mode and thresholds for frame dropping in SVC. Drop frame thresholds ar...
Definition: vp8cx.h:633
#define VPX_DL_GOOD_QUALITY
deadline parameter analogous to VPx GOOD QUALITY mode.
Definition: vpx_encoder.h:980
unsigned int ss_number_layers
Number of spatial coding layers.
Definition: vpx_encoder.h:626
vpx_bit_depth_t g_bit_depth
Bit-depth of the codec.
Definition: vpx_encoder.h:323
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:789
vpx_codec_err_t
Algorithm return codes.
Definition: vpx_codec.h:93
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:695
VP9 specific reference frame data struct.
Definition: vp8.h:110
int temporal_layer_id
Definition: vp8cx.h:886
vpx_codec_iface_t * vpx_codec_vp9_cx(void)
The interface to the VP9 encoder.
int max_consec_drop
Definition: vp8cx.h:938
Definition: vpx_encoder.h:236
int idx
Definition: vp8.h:111
#define vpx_codec_control(ctx, id, data)
vpx_codec_control wrapper macro
Definition: vpx_codec.h:407
vpx_codec_err_t vpx_codec_destroy(vpx_codec_ctx_t *ctx)
Destroy a codec instance.
unsigned int d_h
Definition: vpx_image.h:84
size_t sz
Definition: vpx_encoder.h:100
Definition: vpx_codec.h:221
vp9 svc frame flag parameters.
Definition: vp8cx.h:898
vpx_codec_err_t err
Definition: vpx_codec.h:203
Codec control function to set the threshold for MBs treated static.
Definition: vp8cx.h:205
int64_t duration[5]
Definition: vp8cx.h:910
#define VPX_FRAME_IS_KEY
Definition: vpx_encoder.h:118
Definition: vpx_codec.h:222
int alt_fb_idx[5]
Definition: vp8cx.h:901
const void * vpx_codec_iter_t
Iterator.
Definition: vpx_codec.h:190
Definition: vpx_encoder.h:149
unsigned int rc_2pass_vbr_maxsection_pct
Two-pass mode per-GOP maximum bitrate.
Definition: vpx_encoder.h:579
vpx_codec_er_flags_t g_error_resilient
Enable error resilient modes.
Definition: vpx_encoder.h:353
unsigned int rc_2pass_vbr_minsection_pct
Two-pass mode per-GOP minimum bitrate.
Definition: vpx_encoder.h:572
int gld_fb_idx[5]
Definition: vp8cx.h:900
Codec control function to set svc layer for spatial and temporal.
Definition: vp8cx.h:470
enum vpx_rc_mode rc_end_usage
Rate control algorithm to use.
Definition: vpx_encoder.h:442
Definition: vpx_encoder.h:227
Codec context structure.
Definition: vpx_codec.h:200