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 passes_arg =
70 ARG_DEF(
"p",
"passes", 1,
"Number of passes (1/2)");
71 static const arg_def_t pass_arg =
72 ARG_DEF(NULL,
"pass", 1,
"Pass to execute (1/2)");
73 static const arg_def_t fpf_name_arg =
74 ARG_DEF(NULL,
"fpf", 1,
"First pass statistics file name");
75 static const arg_def_t min_q_arg =
76 ARG_DEF(NULL,
"min-q", 1,
"Minimum quantizer");
77 static const arg_def_t max_q_arg =
78 ARG_DEF(NULL,
"max-q", 1,
"Maximum quantizer");
79 static const arg_def_t min_bitrate_arg =
80 ARG_DEF(NULL,
"min-bitrate", 1,
"Minimum bitrate");
81 static const arg_def_t max_bitrate_arg =
82 ARG_DEF(NULL,
"max-bitrate", 1,
"Maximum bitrate");
83 static const arg_def_t lag_in_frame_arg =
84 ARG_DEF(NULL,
"lag-in-frames", 1,
85 "Number of frame to input before " 86 "generating any outputs");
87 static const arg_def_t rc_end_usage_arg =
88 ARG_DEF(NULL,
"rc-end-usage", 1,
"0 - 3: VBR, CBR, CQ, Q");
89 static const arg_def_t speed_arg =
90 ARG_DEF(
"sp",
"speed", 1,
"speed configuration");
91 static const arg_def_t aqmode_arg =
92 ARG_DEF(
"aq",
"aqmode", 1,
"aq-mode off/on");
93 static const arg_def_t bitrates_arg =
94 ARG_DEF(
"bl",
"bitrates", 1,
"bitrates[sl * num_tl + tl]");
95 static const arg_def_t dropframe_thresh_arg =
96 ARG_DEF(NULL,
"drop-frame", 1,
"Temporal resampling threshold (buf %)");
97 static const struct arg_enum_list tune_content_enum[] = {
98 {
"default", VP9E_CONTENT_DEFAULT },
99 {
"screen", VP9E_CONTENT_SCREEN },
100 {
"film", VP9E_CONTENT_FILM },
104 static const arg_def_t tune_content_arg = ARG_DEF_ENUM(
105 NULL,
"tune-content", 1,
"Tune content type", tune_content_enum);
106 static const arg_def_t inter_layer_pred_arg = ARG_DEF(
107 NULL,
"inter-layer-pred", 1,
"0 - 3: On, Off, Key-frames, Constrained");
109 #if CONFIG_VP9_HIGHBITDEPTH 110 static const struct arg_enum_list bitdepth_enum[] = {
114 static const arg_def_t bitdepth_arg = ARG_DEF_ENUM(
115 "d",
"bit-depth", 1,
"Bit depth for codec 8, 10 or 12. ", bitdepth_enum);
116 #endif // CONFIG_VP9_HIGHBITDEPTH 118 static const arg_def_t *svc_args[] = { &frames_arg,
135 &temporal_layers_arg,
136 &temporal_layering_mode_arg,
141 &output_rc_stats_arg,
144 #if CONFIG_VP9_HIGHBITDEPTH 150 &dropframe_thresh_arg,
152 &inter_layer_pred_arg,
155 static const uint32_t default_frames_to_skip = 0;
156 static const uint32_t default_frames_to_code = 60 * 60;
157 static const uint32_t default_width = 1920;
158 static const uint32_t default_height = 1080;
159 static const uint32_t default_timebase_num = 1;
160 static const uint32_t default_timebase_den = 60;
161 static const uint32_t default_bitrate = 1000;
162 static const uint32_t default_spatial_layers = 5;
163 static const uint32_t default_temporal_layers = 1;
164 static const uint32_t default_kf_dist = 100;
165 static const uint32_t default_temporal_layering_mode = 0;
166 static const uint32_t default_output_rc_stats = 0;
167 static const int32_t default_speed = -1;
168 static const uint32_t default_threads = 0;
171 const char *output_filename;
172 uint32_t frames_to_code;
173 uint32_t frames_to_skip;
174 struct VpxInputContext input_ctx;
179 int inter_layer_pred;
182 static const char *exec_name;
184 void usage_exit(
void) {
185 fprintf(stderr,
"Usage: %s <options> input_filename -o output_filename\n",
187 fprintf(stderr,
"Options:\n");
188 arg_show_usage(stderr, svc_args);
192 static void parse_command_line(
int argc,
const char **argv_,
193 AppInput *app_input, SvcContext *svc_ctx,
202 const char *fpf_file_name = NULL;
203 unsigned int min_bitrate = 0;
204 unsigned int max_bitrate = 0;
205 char string_options[1024] = { 0 };
208 svc_ctx->log_level = SVC_LOG_DEBUG;
209 svc_ctx->spatial_layers = default_spatial_layers;
210 svc_ctx->temporal_layers = default_temporal_layers;
211 svc_ctx->temporal_layering_mode = default_temporal_layering_mode;
213 svc_ctx->output_rc_stat = default_output_rc_stats;
215 svc_ctx->speed = default_speed;
216 svc_ctx->threads = default_threads;
224 enc_cfg->
g_w = default_width;
225 enc_cfg->
g_h = default_height;
234 app_input->frames_to_code = default_frames_to_code;
235 app_input->frames_to_skip = default_frames_to_skip;
238 argv = argv_dup(argc - 1, argv_ + 1);
239 for (argi = argj = argv; (*argj = *argi); argi += arg.argv_step) {
242 if (arg_match(&arg, &frames_arg, argi)) {
243 app_input->frames_to_code = arg_parse_uint(&arg);
244 }
else if (arg_match(&arg, &outputfile, argi)) {
245 app_input->output_filename = arg.val;
246 }
else if (arg_match(&arg, &width_arg, argi)) {
247 enc_cfg->
g_w = arg_parse_uint(&arg);
248 }
else if (arg_match(&arg, &height_arg, argi)) {
249 enc_cfg->
g_h = arg_parse_uint(&arg);
250 }
else if (arg_match(&arg, &timebase_arg, argi)) {
251 enc_cfg->
g_timebase = arg_parse_rational(&arg);
252 }
else if (arg_match(&arg, &bitrate_arg, argi)) {
254 }
else if (arg_match(&arg, &skip_frames_arg, argi)) {
255 app_input->frames_to_skip = arg_parse_uint(&arg);
256 }
else if (arg_match(&arg, &spatial_layers_arg, argi)) {
257 svc_ctx->spatial_layers = arg_parse_uint(&arg);
258 }
else if (arg_match(&arg, &temporal_layers_arg, argi)) {
259 svc_ctx->temporal_layers = arg_parse_uint(&arg);
261 }
else if (arg_match(&arg, &output_rc_stats_arg, argi)) {
262 svc_ctx->output_rc_stat = arg_parse_uint(&arg);
264 }
else if (arg_match(&arg, &speed_arg, argi)) {
265 svc_ctx->speed = arg_parse_uint(&arg);
266 if (svc_ctx->speed > 9) {
267 warn(
"Mapping speed %d to speed 9.\n", svc_ctx->speed);
269 }
else if (arg_match(&arg, &aqmode_arg, argi)) {
270 svc_ctx->aqmode = arg_parse_uint(&arg);
271 }
else if (arg_match(&arg, &threads_arg, argi)) {
272 svc_ctx->threads = arg_parse_uint(&arg);
273 }
else if (arg_match(&arg, &temporal_layering_mode_arg, argi)) {
276 if (svc_ctx->temporal_layering_mode) {
279 }
else if (arg_match(&arg, &kf_dist_arg, argi)) {
282 }
else if (arg_match(&arg, &scale_factors_arg, argi)) {
283 strncat(string_options,
" scale-factors=",
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, &bitrates_arg, argi)) {
288 strncat(string_options,
" bitrates=",
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, &passes_arg, argi)) {
293 passes = arg_parse_uint(&arg);
294 if (passes < 1 || passes > 2) {
295 die(
"Error: Invalid number of passes (%d)\n", passes);
297 }
else if (arg_match(&arg, &pass_arg, argi)) {
298 pass = arg_parse_uint(&arg);
299 if (pass < 1 || pass > 2) {
300 die(
"Error: Invalid pass selected (%d)\n", pass);
302 }
else if (arg_match(&arg, &fpf_name_arg, argi)) {
303 fpf_file_name = arg.val;
304 }
else if (arg_match(&arg, &min_q_arg, argi)) {
305 strncat(string_options,
" min-quantizers=",
306 sizeof(string_options) - strlen(string_options) - 1);
307 strncat(string_options, arg.val,
308 sizeof(string_options) - strlen(string_options) - 1);
309 }
else if (arg_match(&arg, &max_q_arg, argi)) {
310 strncat(string_options,
" max-quantizers=",
311 sizeof(string_options) - strlen(string_options) - 1);
312 strncat(string_options, arg.val,
313 sizeof(string_options) - strlen(string_options) - 1);
314 }
else if (arg_match(&arg, &min_bitrate_arg, argi)) {
315 min_bitrate = arg_parse_uint(&arg);
316 }
else if (arg_match(&arg, &max_bitrate_arg, argi)) {
317 max_bitrate = arg_parse_uint(&arg);
318 }
else if (arg_match(&arg, &lag_in_frame_arg, argi)) {
320 }
else if (arg_match(&arg, &rc_end_usage_arg, argi)) {
322 #if CONFIG_VP9_HIGHBITDEPTH 323 }
else if (arg_match(&arg, &bitdepth_arg, argi)) {
324 enc_cfg->
g_bit_depth = arg_parse_enum_or_int(&arg);
339 die(
"Error: Invalid bit depth selected (%d)\n", enc_cfg->
g_bit_depth);
342 #endif // CONFIG_VP9_HIGHBITDEPTH 343 }
else if (arg_match(&arg, &dropframe_thresh_arg, argi)) {
345 }
else if (arg_match(&arg, &tune_content_arg, argi)) {
346 app_input->tune_content = arg_parse_uint(&arg);
347 }
else if (arg_match(&arg, &inter_layer_pred_arg, argi)) {
348 app_input->inter_layer_pred = arg_parse_uint(&arg);
355 if (strlen(string_options) > 0)
356 vpx_svc_set_options(svc_ctx, string_options + 1);
358 if (passes == 0 || passes == 1) {
360 fprintf(stderr,
"pass is ignored since there's only one pass\n");
365 die(
"pass must be specified when passes is 2\n");
368 if (fpf_file_name == NULL) {
369 die(
"fpf must be specified when passes is 2\n");
374 if (!stats_open_file(&app_input->rc_stats, fpf_file_name, 0)) {
375 fatal(
"Failed to open statistics store");
379 if (!stats_open_file(&app_input->rc_stats, fpf_file_name, 1)) {
380 fatal(
"Failed to open statistics store");
384 app_input->passes = passes;
385 app_input->pass = pass;
389 if (min_bitrate > 0) {
393 if (max_bitrate > 0) {
400 for (argi = argv; *argi; ++argi)
401 if (argi[0][0] ==
'-' && strlen(argi[0]) > 1)
402 die(
"Error: Unrecognized option %s\n", *argi);
404 if (argv[0] == NULL) {
407 app_input->input_ctx.filename = argv[0];
410 open_input_file(&app_input->input_ctx);
411 if (app_input->input_ctx.file_type == FILE_TYPE_Y4M) {
412 enc_cfg->
g_w = app_input->input_ctx.width;
413 enc_cfg->
g_h = app_input->input_ctx.height;
416 if (enc_cfg->
g_w < 16 || enc_cfg->
g_w % 2 || enc_cfg->
g_h < 16 ||
418 die(
"Invalid resolution: %d x %d\n", enc_cfg->
g_w, enc_cfg->
g_h);
421 "Codec %s\nframes: %d, skip: %d\n" 423 "width %d, height: %d,\n" 424 "num: %d, den: %d, bitrate: %d,\n" 427 app_input->frames_to_skip, svc_ctx->spatial_layers, enc_cfg->
g_w,
434 struct RateControlStats {
453 double avg_st_encoding_bitrate;
455 double variance_st_encoding_bitrate;
464 static void set_rate_control_stats(
struct RateControlStats *rc,
475 rc->layer_framerate[layer] = framerate;
479 rc->layer_pfb[layer] =
483 (rc->layer_framerate[layer] - rc->layer_framerate[layer - 1]);
486 rc->layer_framerate[layer];
488 rc->layer_input_frames[layer] = 0;
489 rc->layer_enc_frames[layer] = 0;
490 rc->layer_tot_enc_frames[layer] = 0;
491 rc->layer_encoding_bitrate[layer] = 0.0;
492 rc->layer_avg_frame_size[layer] = 0.0;
493 rc->layer_avg_rate_mismatch[layer] = 0.0;
496 rc->window_count = 0;
497 rc->window_size = 15;
498 rc->avg_st_encoding_bitrate = 0.0;
499 rc->variance_st_encoding_bitrate = 0.0;
502 static void printout_rate_control_summary(
struct RateControlStats *rc,
506 double perc_fluctuation = 0.0;
507 int tot_num_frames = 0;
508 printf(
"Total number of processed frames: %d\n\n", frame_cnt - 1);
509 printf(
"Rate control layer stats for sl%d tl%d layer(s):\n\n",
515 const int num_dropped =
517 ? (rc->layer_input_frames[layer] - rc->layer_enc_frames[layer])
518 : (rc->layer_input_frames[layer] - rc->layer_enc_frames[layer] -
520 tot_num_frames += rc->layer_input_frames[layer];
521 rc->layer_encoding_bitrate[layer] = 0.001 * rc->layer_framerate[layer] *
522 rc->layer_encoding_bitrate[layer] /
524 rc->layer_avg_frame_size[layer] =
525 rc->layer_avg_frame_size[layer] / rc->layer_enc_frames[layer];
526 rc->layer_avg_rate_mismatch[layer] = 100.0 *
527 rc->layer_avg_rate_mismatch[layer] /
528 rc->layer_enc_frames[layer];
529 printf(
"For layer#: sl%d tl%d \n", sl, tl);
530 printf(
"Bitrate (target vs actual): %d %f.0 kbps\n",
532 rc->layer_encoding_bitrate[layer]);
533 printf(
"Average frame size (target vs actual): %f %f bits\n",
534 rc->layer_pfb[layer], rc->layer_avg_frame_size[layer]);
535 printf(
"Average rate_mismatch: %f\n", rc->layer_avg_rate_mismatch[layer]);
537 "Number of input frames, encoded (non-key) frames, " 538 "and percent dropped frames: %d %d %f.0 \n",
539 rc->layer_input_frames[layer], rc->layer_enc_frames[layer],
540 100.0 * num_dropped / rc->layer_input_frames[layer]);
544 rc->avg_st_encoding_bitrate = rc->avg_st_encoding_bitrate / rc->window_count;
545 rc->variance_st_encoding_bitrate =
546 rc->variance_st_encoding_bitrate / rc->window_count -
547 (rc->avg_st_encoding_bitrate * rc->avg_st_encoding_bitrate);
548 perc_fluctuation = 100.0 * sqrt(rc->variance_st_encoding_bitrate) /
549 rc->avg_st_encoding_bitrate;
550 printf(
"Short-time stats, for window of %d frames: \n", rc->window_size);
551 printf(
"Average, rms-variance, and percent-fluct: %f %f %f \n",
552 rc->avg_st_encoding_bitrate, sqrt(rc->variance_st_encoding_bitrate),
554 printf(
"Num of input, num of encoded (super) frames: %d %d \n", frame_cnt,
559 size_t data_sz, uint64_t sizes[8],
569 marker = *(data + data_sz - 1);
572 if ((marker & 0xe0) == 0xc0) {
573 const uint32_t frames = (marker & 0x7) + 1;
574 const uint32_t mag = ((marker >> 3) & 0x3) + 1;
575 const size_t index_sz = 2 + mag * frames;
582 const uint8_t marker2 = *(data + data_sz - index_sz);
593 const uint8_t *x = &data[data_sz - index_sz + 1];
595 for (i = 0; i < frames; ++i) {
596 uint32_t this_sz = 0;
598 for (j = 0; j < mag; ++j) this_sz |= (*x++) << (j * 8);
612 static void set_frame_flags_bypass_mode_ex0(
613 int tl,
int num_spatial_layers,
int is_key_frame,
616 for (sl = 0; sl < num_spatial_layers; ++sl)
619 for (sl = 0; sl < num_spatial_layers; ++sl) {
634 }
else if (tl == 1) {
636 ref_frame_config->
gld_fb_idx[sl] = num_spatial_layers + sl - 1;
637 ref_frame_config->
alt_fb_idx[sl] = num_spatial_layers + sl;
664 }
else if (tl == 1) {
674 if (sl < num_spatial_layers - 1) {
680 }
else if (sl == num_spatial_layers - 1) {
694 static void set_frame_flags_bypass_mode_ex1(
695 int tl,
int num_spatial_layers,
int is_key_frame,
698 for (sl = 0; sl < num_spatial_layers; ++sl)
757 #if CONFIG_VP9_DECODER && !SIMULCAST_MODE 759 const int frames_out,
int *mismatch_seen) {
762 if (*mismatch_seen)
return;
767 enc_img = ref_enc.img;
769 dec_img = ref_dec.img;
770 #if CONFIG_VP9_HIGHBITDEPTH 775 enc_img.
d_w, enc_img.
d_h, 16);
776 vpx_img_truncate_16_to_8(&enc_img, &ref_enc.img);
780 dec_img.
d_w, dec_img.
d_h, 16);
781 vpx_img_truncate_16_to_8(&dec_img, &ref_dec.img);
786 if (!compare_img(&enc_img, &dec_img)) {
787 int y[4], u[4], v[4];
788 #if CONFIG_VP9_HIGHBITDEPTH 790 find_mismatch_high(&enc_img, &dec_img, y, u, v);
792 find_mismatch(&enc_img, &dec_img, y, u, v);
795 find_mismatch(&enc_img, &dec_img, y, u, v);
799 "Encode/decode mismatch on frame %d at" 800 " Y[%d, %d] {%d/%d}," 801 " U[%d, %d] {%d/%d}," 802 " V[%d, %d] {%d/%d}\n",
803 frames_out, y[0], y[1], y[2], y[3], u[0], u[1], u[2], u[3], v[0], v[1],
805 *mismatch_seen = frames_out;
814 static void svc_output_rc_stats(
817 struct RateControlStats *rc, VpxVideoWriter **outfile,
818 const uint32_t frame_cnt,
const double framerate) {
819 int num_layers_encoded = 0;
822 uint64_t sizes_parsed[8];
824 double sum_bitrate = 0.0;
825 double sum_bitrate2 = 0.0;
827 vp9_zero(sizes_parsed);
830 sizes_parsed, &count);
834 if (cx_pkt->
data.
frame.spatial_layer_encoded[sl]) {
835 sizes[sl] = sizes_parsed[num_layers_encoded];
836 num_layers_encoded++;
841 uint64_t tot_size = 0;
843 for (sl2 = 0; sl2 < sl; ++sl2) {
844 if (cx_pkt->
data.
frame.spatial_layer_encoded[sl2]) tot_size += sizes[sl2];
846 vpx_video_writer_write_frame(outfile[sl],
847 (uint8_t *)(cx_pkt->
data.
frame.buf) + tot_size,
848 (
size_t)(sizes[sl]), cx_pkt->
data.
frame.pts);
850 for (sl2 = 0; sl2 <= sl; ++sl2) {
851 if (cx_pkt->
data.
frame.spatial_layer_encoded[sl2]) tot_size += sizes[sl2];
854 vpx_video_writer_write_frame(outfile[sl], cx_pkt->
data.
frame.buf,
855 (
size_t)(tot_size), cx_pkt->
data.
frame.pts);
856 #endif // SIMULCAST_MODE 859 if (cx_pkt->
data.
frame.spatial_layer_encoded[sl]) {
863 ++rc->layer_tot_enc_frames[layer];
864 rc->layer_encoding_bitrate[layer] += 8.0 * sizes[sl];
869 rc->layer_avg_frame_size[layer] += 8.0 * sizes[sl];
870 rc->layer_avg_rate_mismatch[layer] +=
871 fabs(8.0 * sizes[sl] - rc->layer_pfb[layer]) /
872 rc->layer_pfb[layer];
873 ++rc->layer_enc_frames[layer];
882 if (frame_cnt > (
unsigned int)rc->window_size) {
884 if (cx_pkt->
data.
frame.spatial_layer_encoded[sl])
885 sum_bitrate += 0.001 * 8.0 * sizes[sl] * framerate;
887 if (frame_cnt % rc->window_size == 0) {
888 rc->window_count += 1;
889 rc->avg_st_encoding_bitrate += sum_bitrate / rc->window_size;
890 rc->variance_st_encoding_bitrate +=
891 (sum_bitrate / rc->window_size) * (sum_bitrate / rc->window_size);
896 if (frame_cnt > (
unsigned int)(rc->window_size + rc->window_size / 2)) {
898 sum_bitrate2 += 0.001 * 8.0 * sizes[sl] * framerate;
901 if (frame_cnt > (
unsigned int)(2 * rc->window_size) &&
902 frame_cnt % rc->window_size == 0) {
903 rc->window_count += 1;
904 rc->avg_st_encoding_bitrate += sum_bitrate2 / rc->window_size;
905 rc->variance_st_encoding_bitrate +=
906 (sum_bitrate2 / rc->window_size) * (sum_bitrate2 / rc->window_size);
912 int main(
int argc,
const char **argv) {
914 VpxVideoWriter *writer = NULL;
921 uint32_t frame_cnt = 0;
925 int frame_duration = 1;
926 int end_of_stream = 0;
927 int frames_received = 0;
930 struct RateControlStats rc;
934 double framerate = 30.0;
936 struct vpx_usec_timer timer;
938 #if CONFIG_INTERNAL_STATS 939 FILE *f = fopen(
"opsnr.stt",
"a");
941 #if CONFIG_VP9_DECODER && !SIMULCAST_MODE 942 int mismatch_seen = 0;
945 memset(&svc_ctx, 0,
sizeof(svc_ctx));
946 memset(&app_input, 0,
sizeof(AppInput));
947 memset(&info, 0,
sizeof(VpxVideoInfo));
949 memset(&rc, 0,
sizeof(
struct RateControlStats));
953 app_input.input_ctx.framerate.numerator = 30;
954 app_input.input_ctx.framerate.denominator = 1;
955 app_input.input_ctx.only_i420 = 1;
956 app_input.input_ctx.bit_depth = 0;
958 parse_command_line(argc, argv, &app_input, &svc_ctx, &enc_cfg);
961 if (app_input.input_ctx.file_type != FILE_TYPE_Y4M) {
963 #if CONFIG_VP9_HIGHBITDEPTH 966 : VPX_IMG_FMT_I42016,
967 enc_cfg.
g_w, enc_cfg.
g_h, 32)) {
968 die(
"Failed to allocate image %dx%d\n", enc_cfg.
g_w, enc_cfg.
g_h);
972 die(
"Failed to allocate image %dx%d\n", enc_cfg.
g_w, enc_cfg.
g_h);
974 #endif // CONFIG_VP9_HIGHBITDEPTH 978 if (vpx_svc_init(&svc_ctx, &encoder, vpx_codec_vp9_cx(), &enc_cfg) !=
980 die(
"Failed to initialize encoder\n");
981 #if CONFIG_VP9_DECODER && !SIMULCAST_MODE 983 &decoder, get_vpx_decoder_by_name(
"vp9")->codec_interface(), NULL, 0))
984 die(
"Failed to initialize decoder\n");
990 rc.avg_st_encoding_bitrate = 0.0;
991 rc.variance_st_encoding_bitrate = 0.0;
992 if (svc_ctx.output_rc_stat) {
993 set_rate_control_stats(&rc, &enc_cfg);
998 info.codec_fourcc = VP9_FOURCC;
999 info.frame_width = enc_cfg.
g_w;
1000 info.frame_height = enc_cfg.
g_h;
1004 if (!(app_input.passes == 2 && app_input.pass == 1)) {
1007 vpx_video_writer_open(app_input.output_filename, kContainerIVF, &info);
1009 die(
"Failed to open %s for writing\n", app_input.output_filename);
1014 if (svc_ctx.output_rc_stat) {
1016 char file_name[PATH_MAX];
1018 snprintf(file_name,
sizeof(file_name),
"%s_s%d.ivf",
1019 app_input.output_filename, sl);
1020 outfile[sl] = vpx_video_writer_open(file_name, kContainerIVF, &info);
1021 if (!outfile[sl]) die(
"Failed to open %s for writing", file_name);
1027 for (i = 0; i < app_input.frames_to_skip; ++i)
1028 read_frame(&app_input.input_ctx, &raw);
1030 if (svc_ctx.speed != -1)
1032 if (svc_ctx.threads) {
1034 get_msb(svc_ctx.threads));
1035 if (svc_ctx.threads > 1)
1040 if (svc_ctx.speed >= 5 && svc_ctx.aqmode == 1)
1042 if (svc_ctx.speed >= 5)
1047 app_input.inter_layer_pred);
1054 for (sl = 0; sl < (
unsigned int)svc_ctx.spatial_layers; ++sl)
1060 while (!end_of_stream) {
1068 int example_pattern = 0;
1069 if (frame_cnt >= app_input.frames_to_code ||
1070 !read_frame(&app_input.input_ctx, &raw)) {
1083 layer_id.spatial_layer_id = 0;
1085 if (frame_cnt % 2 == 0) {
1086 layer_id.temporal_layer_id = 0;
1088 layer_id.temporal_layer_id_per_spatial[i] = 0;
1090 layer_id.temporal_layer_id = 1;
1092 layer_id.temporal_layer_id_per_spatial[i] = 1;
1094 if (example_pattern == 1) {
1096 assert(svc_ctx.spatial_layers == 2);
1097 assert(svc_ctx.temporal_layers == 2);
1098 if (frame_cnt % 2 == 0) {
1100 layer_id.temporal_layer_id_per_spatial[0] = 0;
1101 layer_id.temporal_layer_id_per_spatial[1] = 0;
1102 layer_id.spatial_layer_id = 0;
1105 layer_id.temporal_layer_id_per_spatial[1] = 1;
1106 layer_id.spatial_layer_id = 1;
1112 if (example_pattern == 0) {
1113 set_frame_flags_bypass_mode_ex0(layer_id.temporal_layer_id,
1114 svc_ctx.spatial_layers, frame_cnt == 0,
1116 }
else if (example_pattern == 1) {
1117 set_frame_flags_bypass_mode_ex1(layer_id.temporal_layer_id,
1118 svc_ctx.spatial_layers, frame_cnt == 0,
1121 ref_frame_config.
duration[0] = frame_duration * 1;
1122 ref_frame_config.
duration[1] = frame_duration * 1;
1130 layer_id.temporal_layer_id];
1134 unsigned int tl = 0;
1136 tl = (frame_cnt % 2 != 0);
1138 if (frame_cnt % 2 != 0) tl = 2;
1139 if ((frame_cnt > 1) && ((frame_cnt - 2) % 4 == 0)) tl = 1;
1145 vpx_usec_timer_start(&timer);
1146 res = vpx_svc_encode(
1147 &svc_ctx, &encoder, (end_of_stream ? NULL : &raw), pts, frame_duration,
1149 vpx_usec_timer_mark(&timer);
1150 cx_time += vpx_usec_timer_elapsed(&timer);
1154 die_codec(&encoder,
"Failed to encode frame");
1158 switch (cx_pkt->
kind) {
1160 SvcInternal_t *
const si = (SvcInternal_t *)svc_ctx.internal;
1162 vpx_video_writer_write_frame(writer, cx_pkt->
data.
frame.buf,
1166 if (svc_ctx.output_rc_stat) {
1167 svc_output_rc_stats(&encoder, &enc_cfg, &layer_id, cx_pkt, &rc,
1168 outfile, frame_cnt, framerate);
1178 si->bytes_sum[0] += (int)cx_pkt->
data.
frame.sz;
1180 #
if CONFIG_VP9_DECODER && !SIMULCAST_MODE
1182 (
unsigned int)cx_pkt->
data.
frame.sz, NULL, 0))
1183 die_codec(&decoder,
"Failed to decode frame.");
1195 #if CONFIG_VP9_DECODER && !SIMULCAST_MODE 1200 !(layer_id.temporal_layer_id > 0 &&
1204 test_decode(&encoder, &decoder, frame_cnt, &mismatch_seen);
1209 if (!end_of_stream) {
1211 pts += frame_duration;
1215 printf(
"Processed %d frames\n", frame_cnt);
1217 close_input_file(&app_input.input_ctx);
1220 if (svc_ctx.output_rc_stat) {
1221 printout_rate_control_summary(&rc, &enc_cfg, frame_cnt);
1226 die_codec(&encoder,
"Failed to destroy codec");
1227 if (app_input.passes == 2) stats_close(&app_input.rc_stats, 1);
1229 vpx_video_writer_close(writer);
1232 if (svc_ctx.output_rc_stat) {
1234 vpx_video_writer_close(outfile[sl]);
1238 #if CONFIG_INTERNAL_STATS 1239 if (mismatch_seen) {
1240 fprintf(f,
"First mismatch occurred in frame %d\n", mismatch_seen);
1242 fprintf(f,
"No mismatch detected in recon buffers\n");
1246 printf(
"Frame cnt and encoding time/FPS stats for encoding: %d %f %f \n",
1247 frame_cnt, 1000 * (
float)cx_time / (
double)(frame_cnt * 1000000),
1248 1000000 * (
double)frame_cnt / (
double)cx_time);
1249 if (app_input.input_ctx.file_type != FILE_TYPE_Y4M) {
1253 vpx_svc_dump_statistics(&svc_ctx);
1254 vpx_svc_release(&svc_ctx);
1255 return EXIT_SUCCESS;
vpx_fixed_buf_t twopass_stats
Definition: vpx_encoder.h:182
unsigned int ts_number_layers
Number of temporal coding layers.
Definition: vpx_encoder.h:644
Codec control function to set encoder internal speed settings.
Definition: vp8cx.h:155
#define VPX_MAX_LAYERS
Definition: vpx_encoder.h:43
int reference_alt_ref[5]
Definition: vp8cx.h:828
Image Descriptor.
Definition: vpx_image.h:71
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:619
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:818
Codec control function to set content type.
Definition: vp8cx.h:463
struct vpx_rational g_timebase
Stream timebase units.
Definition: vpx_encoder.h:343
Codec control function to set noise sensitivity.
Definition: vp8cx.h:421
unsigned int layer_target_bitrate[12]
Target bitrate for each spatial/temporal layer.
Definition: vpx_encoder.h:684
SVC_LAYER_DROP_MODE framedrop_mode
Definition: vp8cx.h:856
unsigned int g_input_bit_depth
Bit-depth of the input frames.
Definition: vpx_encoder.h:329
int den
Definition: vpx_encoder.h:220
Definition: vpx_encoder.h:148
int framedrop_thresh[5]
Definition: vp8cx.h:854
unsigned int kf_max_dist
Keyframe maximum interval.
Definition: vpx_encoder.h:614
unsigned int g_lag_in_frames
Allow lagged encoding.
Definition: vpx_encoder.h:372
Encoder configuration structure.
Definition: vpx_encoder.h:268
int reference_golden[5]
Definition: vp8cx.h:827
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:570
Codec control function to set Max data rate for Intra frames.
Definition: vp8cx.h:257
Encoder output packet.
Definition: vpx_encoder.h:159
void * buf
Definition: vpx_encoder.h:97
unsigned int ts_rate_decimator[5]
Frame rate decimation factor for each temporal layer.
Definition: vpx_encoder.h:658
unsigned int kf_min_dist
Keyframe minimum interval.
Definition: vpx_encoder.h:605
Definition: vpx_encoder.h:226
vp9 svc frame dropping parameters.
Definition: vp8cx.h:853
unsigned int g_profile
Bitstream profile to use.
Definition: vpx_encoder.h:295
Definition: vpx_encoder.h:227
Codec control function to set number of tile columns.
Definition: vp8cx.h:351
#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:46
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:82
#define vpx_codec_dec_init(ctx, iface, cfg, flags)
Convenience macro for vpx_codec_dec_init_ver()
Definition: vpx_decoder.h:144
unsigned int g_w
Width of the frame.
Definition: vpx_encoder.h:304
int reference_last[5]
Definition: vp8cx.h:826
int update_buffer_slot[5]
Definition: vp8cx.h:821
Codec control function to set adaptive quantization mode.
Definition: vp8cx.h:398
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:471
unsigned int g_h
Height of the frame.
Definition: vpx_encoder.h:313
enum vpx_codec_cx_pkt_kind kind
Definition: vpx_encoder.h:160
unsigned int rc_dropframe_thresh
Temporal resampling configuration, if supported by the codec.
Definition: vpx_encoder.h:391
vp9 svc layer parameters
Definition: vp8cx.h:802
Operation completed without error.
Definition: vpx_codec.h:92
void vpx_img_free(vpx_image_t *img)
Close an image descriptor.
vpx_img_fmt_t fmt
Definition: vpx_image.h:72
unsigned int rc_target_bitrate
Target data rate.
Definition: vpx_encoder.h:460
#define VPX_DL_REALTIME
deadline parameter analogous to VPx REALTIME mode.
Definition: vpx_encoder.h:830
int num
Definition: vpx_encoder.h:219
Definition: vpx_codec.h:220
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:545
enum vpx_enc_pass g_pass
Multi-pass Encoding Mode.
Definition: vpx_encoder.h:358
Codec control function to set mode and thresholds for frame dropping in SVC. Drop frame thresholds ar...
Definition: vp8cx.h:628
#define VPX_DL_GOOD_QUALITY
deadline parameter analogous to VPx GOOD QUALITY mode.
Definition: vpx_encoder.h:832
unsigned int ss_number_layers
Number of spatial coding layers.
Definition: vpx_encoder.h:624
vpx_bit_depth_t g_bit_depth
Bit-depth of the codec.
Definition: vpx_encoder.h:321
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:708
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:693
vpx_fixed_buf_t rc_twopass_stats_in
Two-pass stats buffer.
Definition: vpx_encoder.h:447
VP9 specific reference frame data struct.
Definition: vp8.h:110
int temporal_layer_id
Definition: vp8cx.h:805
int max_consec_drop
Definition: vp8cx.h:857
Definition: vpx_encoder.h:234
int idx
Definition: vp8.h:111
#define vpx_codec_control(ctx, id, data)
vpx_codec_control wrapper macro
Definition: vpx_codec.h:404
vpx_codec_err_t vpx_codec_destroy(vpx_codec_ctx_t *ctx)
Destroy a codec instance.
unsigned int d_h
Definition: vpx_image.h:83
size_t sz
Definition: vpx_encoder.h:98
Definition: vpx_codec.h:218
vp9 svc frame flag parameters.
Definition: vp8cx.h:817
vpx_codec_err_t err
Definition: vpx_codec.h:200
Codec control function to set the threshold for MBs treated static.
Definition: vp8cx.h:188
int64_t duration[5]
Definition: vp8cx.h:829
#define VPX_FRAME_IS_KEY
Definition: vpx_encoder.h:116
Definition: vpx_codec.h:219
int alt_fb_idx[5]
Definition: vp8cx.h:820
const void * vpx_codec_iter_t
Iterator.
Definition: vpx_codec.h:187
Definition: vpx_encoder.h:147
unsigned int rc_2pass_vbr_maxsection_pct
Two-pass mode per-GOP maximum bitrate.
Definition: vpx_encoder.h:577
vpx_codec_er_flags_t g_error_resilient
Enable error resilient modes.
Definition: vpx_encoder.h:351
unsigned int rc_2pass_vbr_minsection_pct
Two-pass mode per-GOP minimum bitrate.
Definition: vpx_encoder.h:570
int gld_fb_idx[5]
Definition: vp8cx.h:819
Codec control function to set svc layer for spatial and temporal.
Definition: vp8cx.h:453
enum vpx_rc_mode rc_end_usage
Rate control algorithm to use.
Definition: vpx_encoder.h:440
Definition: vpx_encoder.h:225
Codec context structure.
Definition: vpx_codec.h:197