23 #include "config/aom_config.h" 25 #if CONFIG_AV1_DECODER 30 #include "common/args.h" 31 #include "common/tools_common.h" 32 #include "common/video_writer.h" 33 #include "examples/encoder_util.h" 34 #include "aom_ports/aom_timer.h" 35 #include "av1/ratectrl_rtc.h" 37 #define OPTION_BUFFER_SIZE 1024 40 const char *output_filename;
41 char options[OPTION_BUFFER_SIZE];
42 struct AvxInputContext input_ctx;
61 static const arg_def_t outputfile =
62 ARG_DEF(
"o",
"output", 1,
"Output filename");
63 static const arg_def_t frames_arg =
64 ARG_DEF(
"f",
"frames", 1,
"Number of frames to encode");
65 static const arg_def_t threads_arg =
66 ARG_DEF(
"th",
"threads", 1,
"Number of threads to use");
67 static const arg_def_t width_arg = ARG_DEF(
"w",
"width", 1,
"Source width");
68 static const arg_def_t height_arg = ARG_DEF(
"h",
"height", 1,
"Source height");
69 static const arg_def_t timebase_arg =
70 ARG_DEF(
"t",
"timebase", 1,
"Timebase (num/den)");
71 static const arg_def_t bitrate_arg = ARG_DEF(
72 "b",
"target-bitrate", 1,
"Encoding bitrate, in kilobits per second");
73 static const arg_def_t spatial_layers_arg =
74 ARG_DEF(
"sl",
"spatial-layers", 1,
"Number of spatial SVC layers");
75 static const arg_def_t temporal_layers_arg =
76 ARG_DEF(
"tl",
"temporal-layers", 1,
"Number of temporal SVC layers");
77 static const arg_def_t layering_mode_arg =
78 ARG_DEF(
"lm",
"layering-mode", 1,
"Temporal layering scheme.");
79 static const arg_def_t kf_dist_arg =
80 ARG_DEF(
"k",
"kf-dist", 1,
"Number of frames between keyframes");
81 static const arg_def_t scale_factors_arg =
82 ARG_DEF(
"r",
"scale-factors", 1,
"Scale factors (lowest to highest layer)");
83 static const arg_def_t min_q_arg =
84 ARG_DEF(NULL,
"min-q", 1,
"Minimum quantizer");
85 static const arg_def_t max_q_arg =
86 ARG_DEF(NULL,
"max-q", 1,
"Maximum quantizer");
87 static const arg_def_t speed_arg =
88 ARG_DEF(
"sp",
"speed", 1,
"Speed configuration");
89 static const arg_def_t aqmode_arg =
90 ARG_DEF(
"aq",
"aqmode", 1,
"AQ mode off/on");
91 static const arg_def_t bitrates_arg =
92 ARG_DEF(
"bl",
"bitrates", 1,
93 "Bitrates[spatial_layer * num_temporal_layer + temporal_layer]");
94 static const arg_def_t dropframe_thresh_arg =
95 ARG_DEF(NULL,
"drop-frame", 1,
"Temporal resampling threshold (buf %)");
96 static const arg_def_t error_resilient_arg =
97 ARG_DEF(NULL,
"error-resilient", 1,
"Error resilient flag");
98 static const arg_def_t output_obu_arg =
99 ARG_DEF(NULL,
"output-obu", 1,
100 "Write OBUs when set to 1. Otherwise write IVF files.");
101 static const arg_def_t test_decode_arg =
102 ARG_DEF(NULL,
"test-decode", 1,
103 "Attempt to test decoding the output when set to 1. Default is 1.");
104 static const arg_def_t psnr_arg =
105 ARG_DEF(NULL,
"psnr", -1,
"Show PSNR in status line.");
106 static const arg_def_t ext_rc_arg =
107 ARG_DEF(NULL,
"use-ext-rc", 0,
"Use external rate control.");
108 static const struct arg_enum_list tune_content_enum[] = {
109 {
"default", AOM_CONTENT_DEFAULT },
110 {
"screen", AOM_CONTENT_SCREEN },
111 {
"film", AOM_CONTENT_FILM },
114 static const arg_def_t tune_content_arg = ARG_DEF_ENUM(
115 NULL,
"tune-content", 1,
"Tune content type", tune_content_enum);
117 #if CONFIG_AV1_HIGHBITDEPTH 118 static const struct arg_enum_list bitdepth_enum[] = { {
"8",
AOM_BITS_8 },
122 static const arg_def_t bitdepth_arg = ARG_DEF_ENUM(
123 "d",
"bit-depth", 1,
"Bit depth for codec 8 or 10. ", bitdepth_enum);
124 #endif // CONFIG_AV1_HIGHBITDEPTH 126 static const arg_def_t *svc_args[] = {
127 &frames_arg, &outputfile, &width_arg,
128 &height_arg, &timebase_arg, &bitrate_arg,
129 &spatial_layers_arg, &kf_dist_arg, &scale_factors_arg,
130 &min_q_arg, &max_q_arg, &temporal_layers_arg,
131 &layering_mode_arg, &threads_arg, &aqmode_arg,
132 #if CONFIG_AV1_HIGHBITDEPTH 135 &speed_arg, &bitrates_arg, &dropframe_thresh_arg,
136 &error_resilient_arg, &output_obu_arg, &test_decode_arg,
137 &tune_content_arg, &psnr_arg, NULL,
140 #define zero(Dest) memset(&(Dest), 0, sizeof(Dest)) 142 static const char *exec_name;
144 void usage_exit(
void) {
145 fprintf(stderr,
"Usage: %s <options> input_filename -o output_filename\n",
147 fprintf(stderr,
"Options:\n");
148 arg_show_usage(stderr, svc_args);
152 static int file_is_y4m(
const char detect[4]) {
153 return memcmp(detect,
"YUV4", 4) == 0;
156 static int fourcc_is_ivf(
const char detect[4]) {
157 if (memcmp(detect,
"DKIF", 4) == 0) {
163 static const int option_max_values[ALL_OPTION_TYPES] = { 63, INT_MAX, INT_MAX,
166 static const int option_min_values[ALL_OPTION_TYPES] = { 0, 0, 1, 0 };
168 static void open_input_file(
struct AvxInputContext *input,
171 input->file = strcmp(input->filename,
"-") ? fopen(input->filename,
"rb")
172 : set_binary_mode(stdin);
174 if (!input->file) fatal(
"Failed to open input file");
176 if (!fseeko(input->file, 0, SEEK_END)) {
180 input->length = ftello(input->file);
185 input->pixel_aspect_ratio.numerator = 1;
186 input->pixel_aspect_ratio.denominator = 1;
191 input->detect.buf_read = fread(input->detect.buf, 1, 4, input->file);
192 input->detect.position = 0;
194 if (input->detect.buf_read == 4 && file_is_y4m(input->detect.buf)) {
195 if (y4m_input_open(&input->y4m, input->file, input->detect.buf, 4, csp,
196 input->only_i420) >= 0) {
197 input->file_type = FILE_TYPE_Y4M;
198 input->width = input->y4m.pic_w;
199 input->height = input->y4m.pic_h;
200 input->pixel_aspect_ratio.numerator = input->y4m.par_n;
201 input->pixel_aspect_ratio.denominator = input->y4m.par_d;
202 input->framerate.numerator = input->y4m.fps_n;
203 input->framerate.denominator = input->y4m.fps_d;
204 input->fmt = input->y4m.aom_fmt;
207 fatal(
"Unsupported Y4M stream.");
209 }
else if (input->detect.buf_read == 4 && fourcc_is_ivf(input->detect.buf)) {
210 fatal(
"IVF is not supported as input.");
212 input->file_type = FILE_TYPE_RAW;
216 static aom_codec_err_t extract_option(LAYER_OPTION_TYPE type,
char *input,
217 int *value0,
int *value1) {
218 if (type == SCALE_FACTOR) {
219 *value0 = (int)strtol(input, &input, 10);
221 *value1 = (int)strtol(input, &input, 10);
223 if (*value0 < option_min_values[SCALE_FACTOR] ||
224 *value1 < option_min_values[SCALE_FACTOR] ||
225 *value0 > option_max_values[SCALE_FACTOR] ||
226 *value1 > option_max_values[SCALE_FACTOR] ||
230 *value0 = atoi(input);
231 if (*value0 < option_min_values[type] || *value0 > option_max_values[type])
239 int *option0,
int *option1) {
243 const char *delim =
",";
251 if (input == NULL || option0 == NULL ||
252 (option1 == NULL && type == SCALE_FACTOR))
255 const size_t input_length = strlen(input);
256 input_string =
reinterpret_cast<char *
>(malloc(input_length + 1));
258 memcpy(input_string, input, input_length + 1);
259 token = strtok(input_string, delim);
260 for (i = 0; i < num_layers; ++i) {
262 res = extract_option(type, token, option0 + i, option1 + i);
264 token = strtok(NULL, delim);
274 static void parse_command_line(
int argc,
const char **argv_,
282 char string_options[1024] = { 0 };
287 app_input->layering_mode = 0;
288 app_input->output_obu = 0;
289 app_input->decode = 1;
294 argv = argv_dup(argc - 1, argv_ + 1);
296 fprintf(stderr,
"Error allocating argument list\n");
299 for (argi = argj = argv; (*argj = *argi); argi += arg.argv_step) {
302 if (arg_match(&arg, &outputfile, argi)) {
303 app_input->output_filename = arg.val;
304 }
else if (arg_match(&arg, &width_arg, argi)) {
305 enc_cfg->
g_w = arg_parse_uint(&arg);
306 }
else if (arg_match(&arg, &height_arg, argi)) {
307 enc_cfg->
g_h = arg_parse_uint(&arg);
308 }
else if (arg_match(&arg, &timebase_arg, argi)) {
309 enc_cfg->
g_timebase = arg_parse_rational(&arg);
310 }
else if (arg_match(&arg, &bitrate_arg, argi)) {
312 }
else if (arg_match(&arg, &spatial_layers_arg, argi)) {
314 }
else if (arg_match(&arg, &temporal_layers_arg, argi)) {
316 }
else if (arg_match(&arg, &speed_arg, argi)) {
317 app_input->speed = arg_parse_uint(&arg);
318 if (app_input->speed > 11) {
319 aom_tools_warn(
"Mapping speed %d to speed 11.\n", app_input->speed);
321 }
else if (arg_match(&arg, &aqmode_arg, argi)) {
322 app_input->aq_mode = arg_parse_uint(&arg);
323 }
else if (arg_match(&arg, &threads_arg, argi)) {
324 enc_cfg->
g_threads = arg_parse_uint(&arg);
325 }
else if (arg_match(&arg, &layering_mode_arg, argi)) {
326 app_input->layering_mode = arg_parse_int(&arg);
327 }
else if (arg_match(&arg, &kf_dist_arg, argi)) {
330 }
else if (arg_match(&arg, &scale_factors_arg, argi)) {
335 die(
"Failed to parse scale factors: %s\n",
338 }
else if (arg_match(&arg, &min_q_arg, argi)) {
340 }
else if (arg_match(&arg, &max_q_arg, argi)) {
342 #if CONFIG_AV1_HIGHBITDEPTH 343 }
else if (arg_match(&arg, &bitdepth_arg, argi)) {
356 die(
"Error: Invalid bit depth selected (%d)\n", enc_cfg->
g_bit_depth);
358 #endif // CONFIG_VP9_HIGHBITDEPTH 359 }
else if (arg_match(&arg, &dropframe_thresh_arg, argi)) {
361 }
else if (arg_match(&arg, &error_resilient_arg, argi)) {
364 die(
"Invalid value for error resilient (0, 1): %d.",
366 }
else if (arg_match(&arg, &output_obu_arg, argi)) {
367 app_input->output_obu = arg_parse_uint(&arg);
368 if (app_input->output_obu != 0 && app_input->output_obu != 1)
369 die(
"Invalid value for obu output flag (0, 1): %d.",
370 app_input->output_obu);
371 }
else if (arg_match(&arg, &test_decode_arg, argi)) {
372 app_input->decode = arg_parse_uint(&arg);
373 if (app_input->decode != 0 && app_input->decode != 1)
374 die(
"Invalid value for test decode flag (0, 1): %d.",
376 }
else if (arg_match(&arg, &tune_content_arg, argi)) {
377 app_input->tune_content = arg_parse_enum_or_int(&arg);
378 printf(
"tune content %d\n", app_input->tune_content);
379 }
else if (arg_match(&arg, &psnr_arg, argi)) {
380 app_input->show_psnr = 1;
381 }
else if (arg_match(&arg, &ext_rc_arg, argi)) {
382 app_input->use_external_rc =
true;
389 for (argi = argj = argv; (*argj = *argi); argi += arg.argv_step) {
391 if (arg_match(&arg, &bitrates_arg, argi)) {
403 if (strlen(string_options) > 0)
404 strncpy(app_input->options, string_options, OPTION_BUFFER_SIZE);
407 for (argi = argv; *argi; ++argi)
408 if (argi[0][0] ==
'-' && strlen(argi[0]) > 1)
409 die(
"Error: Unrecognized option %s\n", *argi);
411 if (argv[0] == NULL) {
415 app_input->input_ctx.filename = argv[0];
419 if (app_input->input_ctx.file_type == FILE_TYPE_Y4M) {
420 enc_cfg->
g_w = app_input->input_ctx.width;
421 enc_cfg->
g_h = app_input->input_ctx.height;
424 if (enc_cfg->
g_w < 16 || enc_cfg->
g_w % 2 || enc_cfg->
g_h < 16 ||
426 die(
"Invalid resolution: %d x %d\n", enc_cfg->
g_w, enc_cfg->
g_h);
431 "width %u, height: %u\n" 432 "num: %d, den: %d, bitrate: %u\n" 440 static int mode_to_num_temporal_layers[12] = {
441 1, 2, 3, 3, 2, 1, 1, 3, 3, 3, 3, 3,
443 static int mode_to_num_spatial_layers[12] = {
444 1, 1, 1, 1, 1, 2, 3, 2, 3, 3, 3, 3,
448 struct RateControlMetrics {
465 double avg_st_encoding_bitrate;
467 double variance_st_encoding_bitrate;
475 static const int REF_FRAMES = 8;
477 static const int INTER_REFS_PER_FRAME = 7;
490 static int read_frame(
struct AvxInputContext *input_ctx,
aom_image_t *img) {
491 FILE *f = input_ctx->file;
492 y4m_input *y4m = &input_ctx->y4m;
495 if (input_ctx->file_type == FILE_TYPE_Y4M) {
496 if (y4m_input_fetch_frame(y4m, f, img) < 1)
return 0;
498 shortread = read_yuv_frame(input_ctx, img);
504 static void close_input_file(
struct AvxInputContext *input) {
506 if (input->file_type == FILE_TYPE_Y4M) y4m_input_close(&input->y4m);
515 static void set_rate_control_metrics(
struct RateControlMetrics *rc,
516 double framerate,
int ss_number_layers,
517 int ts_number_layers) {
519 ts_rate_decimator[0] = 1;
520 if (ts_number_layers == 2) {
521 ts_rate_decimator[0] = 2;
522 ts_rate_decimator[1] = 1;
524 if (ts_number_layers == 3) {
525 ts_rate_decimator[0] = 4;
526 ts_rate_decimator[1] = 2;
527 ts_rate_decimator[2] = 1;
531 for (
int sl = 0; sl < ss_number_layers; ++sl) {
532 int i = sl * ts_number_layers;
533 rc->layer_framerate[0] = framerate / ts_rate_decimator[0];
535 1000.0 * rc->layer_target_bitrate[i] / rc->layer_framerate[0];
536 for (
int tl = 0; tl < ts_number_layers; ++tl) {
537 i = sl * ts_number_layers + tl;
539 rc->layer_framerate[tl] = framerate / ts_rate_decimator[tl];
542 (rc->layer_target_bitrate[i] - rc->layer_target_bitrate[i - 1]) /
543 (rc->layer_framerate[tl] - rc->layer_framerate[tl - 1]);
545 rc->layer_input_frames[tl] = 0;
546 rc->layer_enc_frames[tl] = 0;
547 rc->layer_encoding_bitrate[i] = 0.0;
548 rc->layer_avg_frame_size[i] = 0.0;
549 rc->layer_avg_rate_mismatch[i] = 0.0;
552 rc->window_count = 0;
553 rc->window_size = 15;
554 rc->avg_st_encoding_bitrate = 0.0;
555 rc->variance_st_encoding_bitrate = 0.0;
558 static void printout_rate_control_summary(
struct RateControlMetrics *rc,
559 int frame_cnt,
int ss_number_layers,
560 int ts_number_layers) {
561 int tot_num_frames = 0;
562 double perc_fluctuation = 0.0;
563 printf(
"Total number of processed frames: %d\n\n", frame_cnt - 1);
564 printf(
"Rate control layer stats for %d layer(s):\n\n", ts_number_layers);
565 for (
int sl = 0; sl < ss_number_layers; ++sl) {
567 for (
int tl = 0; tl < ts_number_layers; ++tl) {
568 int i = sl * ts_number_layers + tl;
569 const int num_dropped =
570 tl > 0 ? rc->layer_input_frames[tl] - rc->layer_enc_frames[tl]
571 : rc->layer_input_frames[tl] - rc->layer_enc_frames[tl] - 1;
572 tot_num_frames += rc->layer_input_frames[tl];
573 rc->layer_encoding_bitrate[i] = 0.001 * rc->layer_framerate[tl] *
574 rc->layer_encoding_bitrate[i] /
576 rc->layer_avg_frame_size[i] =
577 rc->layer_avg_frame_size[i] / rc->layer_enc_frames[tl];
578 rc->layer_avg_rate_mismatch[i] =
579 100.0 * rc->layer_avg_rate_mismatch[i] / rc->layer_enc_frames[tl];
580 printf(
"For layer#: %d %d \n", sl, tl);
581 printf(
"Bitrate (target vs actual): %d %f\n", rc->layer_target_bitrate[i],
582 rc->layer_encoding_bitrate[i]);
583 printf(
"Average frame size (target vs actual): %f %f\n", rc->layer_pfb[i],
584 rc->layer_avg_frame_size[i]);
585 printf(
"Average rate_mismatch: %f\n", rc->layer_avg_rate_mismatch[i]);
587 "Number of input frames, encoded (non-key) frames, " 588 "and perc dropped frames: %d %d %f\n",
589 rc->layer_input_frames[tl], rc->layer_enc_frames[tl],
590 100.0 * num_dropped / rc->layer_input_frames[tl]);
594 rc->avg_st_encoding_bitrate = rc->avg_st_encoding_bitrate / rc->window_count;
595 rc->variance_st_encoding_bitrate =
596 rc->variance_st_encoding_bitrate / rc->window_count -
597 (rc->avg_st_encoding_bitrate * rc->avg_st_encoding_bitrate);
598 perc_fluctuation = 100.0 * sqrt(rc->variance_st_encoding_bitrate) /
599 rc->avg_st_encoding_bitrate;
600 printf(
"Short-time stats, for window of %d frames:\n", rc->window_size);
601 printf(
"Average, rms-variance, and percent-fluct: %f %f %f\n",
602 rc->avg_st_encoding_bitrate, sqrt(rc->variance_st_encoding_bitrate),
604 if (frame_cnt - 1 != tot_num_frames)
605 die(
"Error: Number of input frames not equal to output!\n");
609 static void set_layer_pattern(
613 int spatial_layer_id,
int is_key_frame,
int ksvc_mode,
int speed) {
616 int use_rps_example = 0;
618 int enable_longterm_temporal_ref = 1;
619 int shift = (layering_mode == 8) ? 2 : 0;
620 int simulcast_mode = (layering_mode == 11);
621 *use_svc_control = 1;
624 int base_count = superframe_cnt >> 2;
631 for (i = 0; i < INTER_REFS_PER_FRAME; i++) ref_frame_config->
ref_idx[i] = i;
632 for (i = 0; i < INTER_REFS_PER_FRAME; i++) ref_frame_config->
reference[i] = 0;
633 for (i = 0; i < REF_FRAMES; i++) ref_frame_config->
refresh[i] = 0;
640 switch (layering_mode) {
642 if (use_rps_example == 0) {
646 ref_frame_config->
refresh[0] = 1;
647 ref_frame_config->
reference[SVC_LAST_FRAME] = 1;
655 int last_idx_refresh = 0;
664 if (superframe_cnt > 1) last_idx = (superframe_cnt - 1) % sh;
666 last_idx_refresh = superframe_cnt % sh;
668 if (superframe_cnt > lag_gld) gld_idx = (superframe_cnt - lag_gld) % sh;
670 if (superframe_cnt > lag_alt)
671 alt_ref_idx = (superframe_cnt - lag_alt) % sh;
674 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
675 ref_frame_config->
ref_idx[i] = last_idx;
677 ref_frame_config->
ref_idx[SVC_LAST_FRAME] = last_idx;
678 ref_frame_config->
ref_idx[SVC_LAST2_FRAME] = last_idx_refresh;
679 ref_frame_config->
ref_idx[SVC_GOLDEN_FRAME] = gld_idx;
680 ref_frame_config->
ref_idx[SVC_ALTREF_FRAME] = alt_ref_idx;
682 ref_frame_config->
refresh[last_idx_refresh] = 1;
684 ref_frame_config->
reference[SVC_LAST_FRAME] = 1;
685 ref_frame_config->
reference[SVC_ALTREF_FRAME] = 1;
686 ref_frame_config->
reference[SVC_GOLDEN_FRAME] = 1;
688 if (superframe_cnt % 200 == 0 && superframe_cnt > 0) {
689 ref_frame_config->
reference[SVC_LAST_FRAME] = 0;
690 ref_frame_config->
reference[SVC_ALTREF_FRAME] = 0;
691 ref_frame_config->
reference[SVC_GOLDEN_FRAME] = 1;
695 if (superframe_cnt % 400 == 0 && superframe_cnt > 0) {
696 ref_frame_config->
ref_idx[SVC_LAST_FRAME] = gld_idx;
697 ref_frame_config->
reference[SVC_LAST_FRAME] = 1;
698 ref_frame_config->
reference[SVC_ALTREF_FRAME] = 0;
699 ref_frame_config->
reference[SVC_GOLDEN_FRAME] = 0;
709 base_count = superframe_cnt >> 1;
710 ref_frame_config->
ref_idx[SVC_GOLDEN_FRAME] = 3;
713 if (base_count > 0) {
714 lag_index = 5 + (base_count % 3);
715 if (superframe_cnt % 2 != 0) lag_index = 5 + ((base_count + 1) % 3);
718 ref_frame_config->
ref_idx[SVC_ALTREF_FRAME] = lag_index;
719 if (superframe_cnt % 2 == 0) {
722 ref_frame_config->
refresh[0] = 1;
723 ref_frame_config->
reference[SVC_LAST_FRAME] = 1;
725 ref_frame_config->
refresh[lag_index] = 1;
727 if (base_count % 32 == 0) ref_frame_config->
refresh[3] = 1;
731 ref_frame_config->
reference[SVC_LAST_FRAME] = 1;
735 ref_frame_config->
reference[SVC_GOLDEN_FRAME] = 1;
736 ref_frame_config->
reference[SVC_ALTREF_FRAME] = 1;
744 if (superframe_cnt % 4 == 0) {
748 ref_frame_config->
refresh[0] = 1;
749 ref_frame_config->
reference[SVC_LAST_FRAME] = 1;
750 }
else if ((superframe_cnt - 1) % 4 == 0) {
753 ref_frame_config->
reference[SVC_LAST_FRAME] = 1;
754 }
else if ((superframe_cnt - 2) % 4 == 0) {
757 ref_frame_config->
refresh[1] = 1;
758 ref_frame_config->
reference[SVC_LAST_FRAME] = 1;
759 }
else if ((superframe_cnt - 3) % 4 == 0) {
764 ref_frame_config->
ref_idx[SVC_LAST_FRAME] = 1;
765 ref_frame_config->
ref_idx[SVC_LAST2_FRAME] = 0;
766 ref_frame_config->
reference[SVC_LAST_FRAME] = 1;
777 ref_frame_config->
ref_idx[SVC_GOLDEN_FRAME] = 3;
780 if (base_count > 0) {
781 lag_index = 5 + (base_count % 3);
782 if (superframe_cnt % 4 != 0) lag_index = 5 + ((base_count + 1) % 3);
785 ref_frame_config->
ref_idx[SVC_ALTREF_FRAME] = lag_index;
786 if (superframe_cnt % 4 == 0) {
790 ref_frame_config->
refresh[0] = 1;
791 ref_frame_config->
reference[SVC_LAST_FRAME] = 1;
793 if (base_count % 10 == 0) ref_frame_config->
refresh[3] = 1;
795 ref_frame_config->
refresh[lag_index] = 1;
796 }
else if ((superframe_cnt - 1) % 4 == 0) {
799 ref_frame_config->
reference[SVC_LAST_FRAME] = 1;
800 }
else if ((superframe_cnt - 2) % 4 == 0) {
803 ref_frame_config->
refresh[1] = 1;
804 ref_frame_config->
reference[SVC_LAST_FRAME] = 1;
805 }
else if ((superframe_cnt - 3) % 4 == 0) {
810 ref_frame_config->
ref_idx[SVC_LAST_FRAME] = 1;
811 ref_frame_config->
ref_idx[SVC_LAST2_FRAME] = 0;
812 ref_frame_config->
reference[SVC_LAST_FRAME] = 1;
815 ref_frame_config->
reference[SVC_GOLDEN_FRAME] = 1;
816 ref_frame_config->
reference[SVC_ALTREF_FRAME] = 1;
829 if (superframe_cnt % 4 == 0) {
833 ref_frame_config->
refresh[0] = 1;
834 ref_frame_config->
reference[SVC_LAST_FRAME] = 1;
835 }
else if ((superframe_cnt - 1) % 4 == 0) {
838 ref_frame_config->
reference[SVC_LAST_FRAME] = 1;
839 }
else if ((superframe_cnt - 2) % 4 == 0) {
842 ref_frame_config->
refresh[3] = 1;
843 ref_frame_config->
reference[SVC_LAST_FRAME] = 1;
844 }
else if ((superframe_cnt - 3) % 4 == 0) {
847 ref_frame_config->
reference[SVC_GOLDEN_FRAME] = 1;
855 ref_frame_config->
refresh[0] = 1;
856 ref_frame_config->
reference[SVC_LAST_FRAME] = 1;
860 ref_frame_config->
ref_idx[SVC_LAST_FRAME] = 1;
861 ref_frame_config->
ref_idx[SVC_GOLDEN_FRAME] = 0;
862 ref_frame_config->
refresh[1] = 1;
863 ref_frame_config->
reference[SVC_LAST_FRAME] = 1;
864 ref_frame_config->
reference[SVC_GOLDEN_FRAME] = 1;
876 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
877 ref_frame_config->
ref_idx[i] = 0;
878 ref_frame_config->
refresh[0] = 1;
879 ref_frame_config->
reference[SVC_LAST_FRAME] = 1;
884 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
885 ref_frame_config->
ref_idx[i] = 0;
886 ref_frame_config->
ref_idx[SVC_LAST_FRAME] = 1;
887 ref_frame_config->
refresh[1] = 1;
888 ref_frame_config->
reference[SVC_LAST_FRAME] = 1;
889 ref_frame_config->
reference[SVC_GOLDEN_FRAME] = 1;
894 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
895 ref_frame_config->
ref_idx[i] = 1;
896 ref_frame_config->
ref_idx[SVC_LAST_FRAME] = 2;
897 ref_frame_config->
refresh[2] = 1;
898 ref_frame_config->
reference[SVC_LAST_FRAME] = 1;
899 ref_frame_config->
reference[SVC_GOLDEN_FRAME] = 1;
902 if (enable_longterm_temporal_ref) {
903 ref_frame_config->
ref_idx[SVC_ALTREF_FRAME] = REF_FRAMES - 1;
904 ref_frame_config->
reference[SVC_ALTREF_FRAME] = 1;
905 if (base_count % 10 == 0)
906 ref_frame_config->
refresh[REF_FRAMES - 1] = 1;
912 ref_frame_config->
reference[SVC_LAST_FRAME] = 1;
913 if (superframe_cnt % 4 == 0) {
919 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
920 ref_frame_config->
ref_idx[i] = 0;
921 ref_frame_config->
refresh[0] = 1;
924 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
925 ref_frame_config->
ref_idx[i] = 0;
926 ref_frame_config->
ref_idx[SVC_LAST_FRAME] = 1;
927 ref_frame_config->
refresh[1] = 1;
929 }
else if ((superframe_cnt - 1) % 4 == 0) {
933 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
934 ref_frame_config->
ref_idx[i] = 0;
935 ref_frame_config->
ref_idx[SVC_GOLDEN_FRAME] = 3;
936 ref_frame_config->
refresh[3] = 1;
941 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
942 ref_frame_config->
ref_idx[i] = 3;
943 ref_frame_config->
ref_idx[SVC_LAST_FRAME] = 1;
945 }
else if ((superframe_cnt - 2) % 4 == 0) {
952 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
953 ref_frame_config->
ref_idx[i] = 0;
954 ref_frame_config->
ref_idx[SVC_GOLDEN_FRAME] = 5 - shift;
955 ref_frame_config->
refresh[5 - shift] = 1;
960 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
961 ref_frame_config->
ref_idx[i] = 5 - shift;
962 ref_frame_config->
ref_idx[SVC_LAST_FRAME] = 1;
963 ref_frame_config->
ref_idx[SVC_LAST3_FRAME] = 6 - shift;
964 ref_frame_config->
refresh[6 - shift] = 1;
966 }
else if ((superframe_cnt - 3) % 4 == 0) {
973 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
974 ref_frame_config->
ref_idx[i] = 0;
975 ref_frame_config->
ref_idx[SVC_LAST_FRAME] = 5 - shift;
976 ref_frame_config->
ref_idx[SVC_GOLDEN_FRAME] = 3;
977 ref_frame_config->
refresh[3] = 1;
981 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
982 ref_frame_config->
ref_idx[i] = 0;
983 ref_frame_config->
ref_idx[SVC_LAST_FRAME] = 6 - shift;
984 ref_frame_config->
ref_idx[SVC_GOLDEN_FRAME] = 3;
1001 ref_frame_config->
reference[SVC_LAST_FRAME] = 1;
1002 if (superframe_cnt % 4 == 0) {
1008 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
1009 ref_frame_config->
ref_idx[i] = 0;
1010 ref_frame_config->
refresh[0] = 1;
1015 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
1016 ref_frame_config->
ref_idx[i] = 0;
1017 ref_frame_config->
ref_idx[SVC_LAST_FRAME] = 1;
1018 ref_frame_config->
refresh[1] = 1;
1023 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
1024 ref_frame_config->
ref_idx[i] = 1;
1025 ref_frame_config->
ref_idx[SVC_LAST_FRAME] = 2;
1026 ref_frame_config->
refresh[2] = 1;
1028 }
else if ((superframe_cnt - 1) % 4 == 0) {
1035 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
1036 ref_frame_config->
ref_idx[i] = 0;
1037 ref_frame_config->
ref_idx[SVC_GOLDEN_FRAME] = 3;
1038 ref_frame_config->
refresh[3] = 1;
1043 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
1044 ref_frame_config->
ref_idx[i] = 3;
1045 ref_frame_config->
ref_idx[SVC_LAST_FRAME] = 1;
1046 ref_frame_config->
ref_idx[SVC_LAST2_FRAME] = 4;
1047 ref_frame_config->
refresh[4] = 1;
1052 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
1053 ref_frame_config->
ref_idx[i] = 4;
1054 ref_frame_config->
ref_idx[SVC_LAST_FRAME] = 2;
1056 }
else if ((superframe_cnt - 2) % 4 == 0) {
1063 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
1064 ref_frame_config->
ref_idx[i] = 0;
1065 ref_frame_config->
ref_idx[SVC_GOLDEN_FRAME] = 5 - shift;
1066 ref_frame_config->
refresh[5 - shift] = 1;
1071 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
1072 ref_frame_config->
ref_idx[i] = 5 - shift;
1073 ref_frame_config->
ref_idx[SVC_LAST_FRAME] = 1;
1074 ref_frame_config->
ref_idx[SVC_LAST3_FRAME] = 6 - shift;
1075 ref_frame_config->
refresh[6 - shift] = 1;
1080 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
1081 ref_frame_config->
ref_idx[i] = 6 - shift;
1082 ref_frame_config->
ref_idx[SVC_LAST_FRAME] = 2;
1083 ref_frame_config->
ref_idx[SVC_LAST3_FRAME] = 7 - shift;
1084 ref_frame_config->
refresh[7 - shift] = 1;
1086 }
else if ((superframe_cnt - 3) % 4 == 0) {
1093 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
1094 ref_frame_config->
ref_idx[i] = 0;
1095 ref_frame_config->
ref_idx[SVC_LAST_FRAME] = 5 - shift;
1096 ref_frame_config->
ref_idx[SVC_GOLDEN_FRAME] = 3;
1097 ref_frame_config->
refresh[3] = 1;
1101 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
1102 ref_frame_config->
ref_idx[i] = 0;
1103 ref_frame_config->
ref_idx[SVC_LAST_FRAME] = 6 - shift;
1104 ref_frame_config->
ref_idx[SVC_GOLDEN_FRAME] = 3;
1105 ref_frame_config->
ref_idx[SVC_LAST2_FRAME] = 4;
1106 ref_frame_config->
refresh[4] = 1;
1110 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
1111 ref_frame_config->
ref_idx[i] = 0;
1112 ref_frame_config->
ref_idx[SVC_LAST_FRAME] = 7 - shift;
1113 ref_frame_config->
ref_idx[SVC_GOLDEN_FRAME] = 4;
1136 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
1139 for (i = 0; i < REF_FRAMES; i++) ref_frame_config->
refresh[i] = 0;
1140 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
1141 ref_frame_config->
ref_idx[i] = 0;
1148 ref_frame_config->
ref_idx[SVC_LAST_FRAME] = 0;
1149 ref_frame_config->
ref_idx[SVC_GOLDEN_FRAME] = 1;
1150 ref_frame_config->
refresh[0] = 1;
1151 ref_frame_config->
refresh[1] = 1;
1156 ref_frame_config->
ref_idx[SVC_LAST_FRAME] = 2;
1157 ref_frame_config->
ref_idx[SVC_GOLDEN_FRAME] = 3;
1158 ref_frame_config->
refresh[2] = 1;
1159 ref_frame_config->
refresh[3] = 1;
1164 ref_frame_config->
ref_idx[SVC_LAST_FRAME] = 4;
1165 ref_frame_config->
ref_idx[SVC_GOLDEN_FRAME] = 5;
1166 ref_frame_config->
refresh[4] = 1;
1167 ref_frame_config->
refresh[5] = 1;
1169 }
else if (superframe_cnt % 4 == 0) {
1176 ref_frame_config->
reference[SVC_LAST_FRAME] = 1;
1177 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
1178 ref_frame_config->
ref_idx[i] = 1;
1179 ref_frame_config->
ref_idx[SVC_LAST_FRAME] = 0;
1180 ref_frame_config->
refresh[0] = 1;
1185 ref_frame_config->
reference[SVC_LAST_FRAME] = 1;
1186 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
1187 ref_frame_config->
ref_idx[i] = 3;
1188 ref_frame_config->
ref_idx[SVC_LAST_FRAME] = 2;
1189 ref_frame_config->
refresh[2] = 1;
1194 ref_frame_config->
reference[SVC_LAST_FRAME] = 1;
1195 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
1196 ref_frame_config->
ref_idx[i] = 5;
1197 ref_frame_config->
ref_idx[SVC_LAST_FRAME] = 4;
1198 ref_frame_config->
refresh[4] = 1;
1200 }
else if ((superframe_cnt - 1) % 4 == 0) {
1206 ref_frame_config->
reference[SVC_LAST_FRAME] = 1;
1207 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
1208 ref_frame_config->
ref_idx[i] = 1;
1209 ref_frame_config->
ref_idx[SVC_LAST_FRAME] = 0;
1213 ref_frame_config->
reference[SVC_LAST_FRAME] = 1;
1214 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
1215 ref_frame_config->
ref_idx[i] = 3;
1216 ref_frame_config->
ref_idx[SVC_LAST_FRAME] = 2;
1220 ref_frame_config->
reference[SVC_LAST_FRAME] = 1;
1221 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
1222 ref_frame_config->
ref_idx[i] = 5;
1223 ref_frame_config->
ref_idx[SVC_LAST_FRAME] = 4;
1225 }
else if ((superframe_cnt - 2) % 4 == 0) {
1232 ref_frame_config->
reference[SVC_LAST_FRAME] = 1;
1233 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
1234 ref_frame_config->
ref_idx[i] = 1;
1235 ref_frame_config->
ref_idx[SVC_LAST_FRAME] = 0;
1236 ref_frame_config->
refresh[1] = 1;
1241 ref_frame_config->
reference[SVC_LAST_FRAME] = 1;
1242 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
1243 ref_frame_config->
ref_idx[i] = 3;
1244 ref_frame_config->
ref_idx[SVC_LAST_FRAME] = 2;
1245 ref_frame_config->
refresh[3] = 1;
1250 ref_frame_config->
reference[SVC_LAST_FRAME] = 1;
1251 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
1252 ref_frame_config->
ref_idx[i] = 5;
1253 ref_frame_config->
ref_idx[SVC_LAST_FRAME] = 4;
1254 ref_frame_config->
refresh[5] = 1;
1256 }
else if ((superframe_cnt - 3) % 4 == 0) {
1262 ref_frame_config->
reference[SVC_LAST_FRAME] = 1;
1263 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
1264 ref_frame_config->
ref_idx[i] = 0;
1265 ref_frame_config->
ref_idx[SVC_LAST_FRAME] = 1;
1269 ref_frame_config->
reference[SVC_LAST_FRAME] = 1;
1270 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
1271 ref_frame_config->
ref_idx[i] = 2;
1272 ref_frame_config->
ref_idx[SVC_LAST_FRAME] = 3;
1276 ref_frame_config->
reference[SVC_LAST_FRAME] = 1;
1277 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
1278 ref_frame_config->
ref_idx[i] = 4;
1279 ref_frame_config->
ref_idx[SVC_LAST_FRAME] = 5;
1284 ref_frame_config->
reference[SVC_GOLDEN_FRAME] = 1;
1288 if (!is_key_frame) ref_frame_config->
reference[SVC_GOLDEN_FRAME] = 0;
1293 ref_frame_config->
reference[SVC_LAST_FRAME] = 0;
1300 if (!simulcast_mode && enable_longterm_temporal_ref &&
1302 ref_frame_config->
ref_idx[SVC_ALTREF_FRAME] = REF_FRAMES - 1;
1303 if (!is_key_frame) ref_frame_config->
reference[SVC_ALTREF_FRAME] = 1;
1305 ref_frame_config->
refresh[REF_FRAMES - 1] = 1;
1308 default: assert(0); die(
"Error: Unsupported temporal layering mode!\n");
1312 #if CONFIG_AV1_DECODER 1316 const int frames_out) {
1324 #if CONFIG_AV1_HIGHBITDEPTH 1332 enc_img.
d_w, enc_img.
d_h, 16);
1333 aom_img_truncate_16_to_8(&enc_hbd_img, &enc_img);
1334 enc_img = enc_hbd_img;
1341 dec_img.
d_w, dec_img.
d_h, 16);
1342 aom_img_truncate_16_to_8(&dec_hbd_img, &dec_img);
1343 dec_img = dec_hbd_img;
1348 if (!aom_compare_img(&enc_img, &dec_img)) {
1349 int y[4], u[4], v[4];
1350 #if CONFIG_AV1_HIGHBITDEPTH 1352 aom_find_mismatch_high(&enc_img, &dec_img, y, u, v);
1354 aom_find_mismatch(&enc_img, &dec_img, y, u, v);
1357 aom_find_mismatch(&enc_img, &dec_img, y, u, v);
1360 "Encode/decode mismatch on frame %d at" 1361 " Y[%d, %d] {%d/%d}," 1362 " U[%d, %d] {%d/%d}," 1363 " V[%d, %d] {%d/%d}\n",
1364 frames_out, y[0], y[1], y[2], y[3], u[0], u[1], u[2], u[3], v[0],
1373 #endif // CONFIG_AV1_DECODER 1377 uint64_t psnr_sse_total[2];
1378 uint64_t psnr_samples_total[2];
1379 double psnr_totals[2][4];
1383 static void show_psnr(
struct psnr_stats *psnr_stream,
double peak) {
1386 if (!psnr_stream->psnr_count[0])
return;
1388 fprintf(stderr,
"\nPSNR (Overall/Avg/Y/U/V)");
1389 ovpsnr = sse_to_psnr((
double)psnr_stream->psnr_samples_total[0], peak,
1390 (
double)psnr_stream->psnr_sse_total[0]);
1391 fprintf(stderr,
" %.3f", ovpsnr);
1393 for (
int i = 0; i < 4; i++) {
1394 fprintf(stderr,
" %.3f",
1395 psnr_stream->psnr_totals[0][i] / psnr_stream->psnr_count[0]);
1397 fprintf(stderr,
"\n");
1400 static aom::AV1RateControlRtcConfig create_rtc_rc_config(
1402 aom::AV1RateControlRtcConfig rc_cfg;
1403 rc_cfg.width = cfg.
g_w;
1404 rc_cfg.height = cfg.
g_h;
1414 rc_cfg.max_intra_bitrate_pct = 300;
1417 rc_cfg.ss_number_layers = 1;
1418 rc_cfg.ts_number_layers = 1;
1419 rc_cfg.scaling_factor_num[0] = 1;
1420 rc_cfg.scaling_factor_den[0] = 1;
1421 rc_cfg.layer_target_bitrate[0] =
static_cast<int>(rc_cfg.target_bandwidth);
1422 rc_cfg.max_quantizers[0] = rc_cfg.max_quantizer;
1423 rc_cfg.min_quantizers[0] = rc_cfg.min_quantizer;
1424 rc_cfg.aq_mode = app_input.aq_mode;
1429 static int qindex_to_quantizer(
int qindex) {
1432 static const int quantizer_to_qindex[] = {
1433 0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48,
1434 52, 56, 60, 64, 68, 72, 76, 80, 84, 88, 92, 96, 100,
1435 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 144, 148, 152,
1436 156, 160, 164, 168, 172, 176, 180, 184, 188, 192, 196, 200, 204,
1437 208, 212, 216, 220, 224, 228, 232, 236, 240, 244, 249, 255,
1439 for (
int quantizer = 0; quantizer < 64; ++quantizer)
1440 if (quantizer_to_qindex[quantizer] >= qindex)
return quantizer;
1445 int main(
int argc,
const char **argv) {
1449 AvxVideoWriter *total_layer_file = NULL;
1450 FILE *total_layer_obu_file = NULL;
1459 int frame_duration = 1;
1465 #if CONFIG_INTERNAL_STATS 1466 FILE *stats_file = fopen(
"opsnr.stt",
"a");
1467 if (stats_file == NULL) {
1468 die(
"Cannot open opsnr.stt\n");
1471 #if CONFIG_AV1_DECODER 1475 struct RateControlMetrics rc;
1476 int64_t cx_time = 0;
1479 double sum_bitrate = 0.0;
1480 double sum_bitrate2 = 0.0;
1481 double framerate = 30.0;
1482 int use_svc_control = 1;
1483 int set_err_resil_frame = 0;
1484 int test_changing_bitrate = 0;
1485 zero(rc.layer_target_bitrate);
1487 memset(&app_input, 0,
sizeof(AppInput));
1488 memset(&svc_params, 0,
sizeof(svc_params));
1492 const int test_dynamic_scaling_single_layer = 0;
1495 const int test_speed_per_layer = 0;
1498 app_input.input_ctx.framerate.numerator = 30;
1499 app_input.input_ctx.framerate.denominator = 1;
1500 app_input.input_ctx.only_i420 = 0;
1502 app_input.speed = 7;
1503 exec_name = argv[0];
1527 parse_command_line(argc, argv, &app_input, &svc_params, &cfg);
1532 unsigned int width = cfg.
g_w;
1533 unsigned int height = cfg.
g_h;
1535 if (app_input.layering_mode >= 0) {
1536 if (ts_number_layers !=
1537 mode_to_num_temporal_layers[app_input.layering_mode] ||
1539 mode_to_num_spatial_layers[app_input.layering_mode]) {
1540 die(
"Number of layers doesn't match layering mode.");
1545 if (app_input.input_ctx.file_type != FILE_TYPE_Y4M) {
1547 die(
"Failed to allocate image (%dx%d)", width, height);
1556 unsigned int total_rate = 0;
1557 for (i = 0; i < ss_number_layers; i++) {
1563 die(
"Incorrect total target bitrate");
1567 if (ts_number_layers == 2) {
1570 }
else if (ts_number_layers == 3) {
1576 if (app_input.input_ctx.file_type == FILE_TYPE_Y4M) {
1578 cfg.
g_w = app_input.input_ctx.width;
1579 cfg.
g_h = app_input.input_ctx.height;
1581 cfg.
g_timebase.
num = app_input.input_ctx.framerate.denominator;
1582 cfg.
g_timebase.
den = app_input.input_ctx.framerate.numerator;
1585 set_rate_control_metrics(&rc, framerate, ss_number_layers, ts_number_layers);
1588 info.codec_fourcc = get_fourcc_by_aom_encoder(encoder);
1589 info.frame_width = cfg.
g_w;
1590 info.frame_height = cfg.
g_h;
1594 for (
int sl = 0; sl < ss_number_layers; ++sl) {
1595 for (
int tl = 0; tl < ts_number_layers; ++tl) {
1596 i = sl * ts_number_layers + tl;
1597 char file_name[PATH_MAX];
1598 snprintf(file_name,
sizeof(file_name),
"%s_%d.av1",
1599 app_input.output_filename, i);
1600 if (app_input.output_obu) {
1601 obu_files[i] = fopen(file_name,
"wb");
1602 if (!obu_files[i]) die(
"Failed to open %s for writing", file_name);
1604 outfile[i] = aom_video_writer_open(file_name, kContainerIVF, &info);
1605 if (!outfile[i]) die(
"Failed to open %s for writing", file_name);
1609 if (app_input.output_obu) {
1610 total_layer_obu_file = fopen(app_input.output_filename,
"wb");
1611 if (!total_layer_obu_file)
1612 die(
"Failed to open %s for writing", app_input.output_filename);
1615 aom_video_writer_open(app_input.output_filename, kContainerIVF, &info);
1616 if (!total_layer_file)
1617 die(
"Failed to open %s for writing", app_input.output_filename);
1626 die_codec(&codec,
"Failed to initialize encoder");
1628 #if CONFIG_AV1_DECODER 1629 if (app_input.decode) {
1631 die_codec(&decoder,
"Failed to initialize decoder");
1665 if (app_input.tune_content == AOM_CONTENT_SCREEN) {
1672 if (app_input.use_external_rc) {
1680 for (i = 0; i < ss_number_layers * ts_number_layers; ++i) {
1684 for (i = 0; i < ss_number_layers; ++i) {
1688 if (ss_number_layers == 2) {
1691 }
else if (ss_number_layers == 3) {
1704 const int max_intra_size_pct = 300;
1706 max_intra_size_pct);
1709 for (
int lx = 0; lx < ts_number_layers * ss_number_layers; lx++) {
1710 cx_time_layer[lx] = 0;
1711 frame_cnt_layer[lx] = 0;
1714 std::unique_ptr<aom::AV1RateControlRTC> rc_api;
1715 if (app_input.use_external_rc) {
1716 const aom::AV1RateControlRtcConfig rc_cfg =
1717 create_rtc_rc_config(cfg, app_input);
1718 rc_api = aom::AV1RateControlRTC::Create(rc_cfg);
1722 struct psnr_stats psnr_stream;
1723 memset(&psnr_stream, 0,
sizeof(psnr_stream));
1724 while (frame_avail || got_data) {
1725 struct aom_usec_timer timer;
1726 frame_avail = read_frame(&(app_input.input_ctx), &raw);
1728 for (
int slx = 0; slx < ss_number_layers; slx++) {
1733 int is_key_frame = (frame_cnt % cfg.
kf_max_dist) == 0;
1735 if (app_input.layering_mode >= 0) {
1738 set_layer_pattern(app_input.layering_mode, frame_cnt, &layer_id,
1739 &ref_frame_config, &ref_frame_comp_pred,
1740 &use_svc_control, slx, is_key_frame,
1741 (app_input.layering_mode == 10), app_input.speed);
1743 if (use_svc_control) {
1747 &ref_frame_comp_pred);
1750 if (test_speed_per_layer) {
1751 int speed_per_layer = 10;
1773 if (ts_number_layers == 2) {
1775 }
else if (ts_number_layers == 3) {
1776 if (frame_cnt % 2 != 0)
1778 else if ((frame_cnt > 1) && ((frame_cnt - 2) % 4 == 0))
1792 const int err_resil_mode =
1799 if (frame_avail && slx == 0) ++rc.layer_input_frames[layer];
1801 if (test_dynamic_scaling_single_layer) {
1804 int frame_2x2 = 200;
1805 int frame_4x4 = 400;
1806 int frame_2x2up = 600;
1807 int frame_orig = 800;
1808 if (frame_cnt >= frame_2x2 && frame_cnt < frame_4x4) {
1812 }
else if (frame_cnt >= frame_4x4 && frame_cnt < frame_2x2up) {
1816 }
else if (frame_cnt >= frame_2x2up && frame_cnt < frame_orig) {
1820 }
else if (frame_cnt >= frame_orig) {
1825 if (frame_cnt == frame_2x2 || frame_cnt == frame_4x4 ||
1826 frame_cnt == frame_2x2up || frame_cnt == frame_orig) {
1832 for (i = 0; i < REF_FRAMES; i++) ref_frame_config.
refresh[i] = 1;
1833 if (use_svc_control) {
1837 &ref_frame_comp_pred);
1843 if (test_changing_bitrate && frame_cnt % 2 == 0) {
1844 if (frame_cnt < 500)
1856 die_codec(&codec,
"Failed to SET_BITRATE_ONE_PASS_CBR");
1860 aom::AV1FrameParamsRTC frame_params;
1862 frame_params.spatial_layer_id = 0;
1863 frame_params.temporal_layer_id = 0;
1864 frame_params.frame_type =
1865 is_key_frame ? aom::kKeyFrame : aom::kInterFrame;
1866 rc_api->ComputeQP(frame_params);
1867 const int current_qp = rc_api->GetQP();
1869 qindex_to_quantizer(current_qp))) {
1870 die_codec(&codec,
"Failed to SET_QUANTIZER_ONE_PASS");
1875 aom_usec_timer_start(&timer);
1877 die_codec(&codec,
"Failed to encode frame");
1878 aom_usec_timer_mark(&timer);
1879 cx_time += aom_usec_timer_elapsed(&timer);
1880 cx_time_layer[layer] += aom_usec_timer_elapsed(&timer);
1881 frame_cnt_layer[layer] += 1;
1885 int ss_layers_write = (app_input.layering_mode == 11)
1889 switch (pkt->
kind) {
1895 int j = sl * ts_number_layers + tl;
1896 if (app_input.output_obu) {
1900 aom_video_writer_write_frame(
1902 reinterpret_cast<const uint8_t *>(pkt->
data.
frame.buf),
1906 rc.layer_encoding_bitrate[j] += 8.0 * pkt->
data.
frame.sz;
1911 if (app_input.output_obu) {
1913 total_layer_obu_file);
1915 aom_video_writer_write_frame(
1917 reinterpret_cast<const uint8_t *>(pkt->
data.
frame.buf),
1925 rc.layer_avg_frame_size[j] += 8.0 * pkt->
data.
frame.sz;
1926 rc.layer_avg_rate_mismatch[j] +=
1927 fabs(8.0 * pkt->
data.
frame.sz - rc.layer_pfb[j]) /
1933 rc_api->PostEncodeUpdate(pkt->
data.
frame.sz);
1939 if (frame_cnt > rc.window_size && slx == ss_number_layers - 1) {
1940 sum_bitrate += 0.001 * 8.0 * pkt->
data.
frame.sz * framerate;
1941 rc.window_size = (rc.window_size <= 0) ? 1 : rc.window_size;
1942 if (frame_cnt % rc.window_size == 0) {
1943 rc.window_count += 1;
1944 rc.avg_st_encoding_bitrate += sum_bitrate / rc.window_size;
1945 rc.variance_st_encoding_bitrate +=
1946 (sum_bitrate / rc.window_size) *
1947 (sum_bitrate / rc.window_size);
1952 if (frame_cnt > rc.window_size + rc.window_size / 2 &&
1953 slx == ss_number_layers - 1) {
1954 sum_bitrate2 += 0.001 * 8.0 * pkt->
data.
frame.sz * framerate;
1955 if (frame_cnt > 2 * rc.window_size &&
1956 frame_cnt % rc.window_size == 0) {
1957 rc.window_count += 1;
1958 rc.avg_st_encoding_bitrate += sum_bitrate2 / rc.window_size;
1959 rc.variance_st_encoding_bitrate +=
1960 (sum_bitrate2 / rc.window_size) *
1961 (sum_bitrate2 / rc.window_size);
1966 #if CONFIG_AV1_DECODER 1967 if (app_input.decode) {
1970 reinterpret_cast<const uint8_t *>(pkt->
data.
frame.buf),
1972 die_codec(&decoder,
"Failed to decode frame");
1978 if (app_input.show_psnr) {
1979 psnr_stream.psnr_sse_total[0] += pkt->
data.
psnr.sse[0];
1980 psnr_stream.psnr_samples_total[0] += pkt->
data.
psnr.samples[0];
1981 for (
int plane = 0; plane < 4; plane++) {
1982 psnr_stream.psnr_totals[0][plane] += pkt->
data.
psnr.psnr[plane];
1984 psnr_stream.psnr_count[0]++;
1990 #if CONFIG_AV1_DECODER 1991 if (got_data && app_input.decode) {
1994 if ((ss_number_layers > 1 || ts_number_layers > 1) &&
1997 if (test_decode(&codec, &decoder, frame_cnt)) {
1998 #if CONFIG_INTERNAL_STATS 1999 fprintf(stats_file,
"First mismatch occurred in frame %d\n",
2003 fatal(
"Mismatch seen");
2010 pts += frame_duration;
2013 close_input_file(&(app_input.input_ctx));
2014 printout_rate_control_summary(&rc, frame_cnt, ss_number_layers,
2018 for (
int slx = 0; slx < ss_number_layers; slx++)
2019 for (
int tlx = 0; tlx < ts_number_layers; tlx++) {
2020 int lx = slx * ts_number_layers + tlx;
2021 printf(
"Per layer encoding time/FPS stats for encoder: %d %d %d %f %f \n",
2022 slx, tlx, frame_cnt_layer[lx],
2023 (
float)cx_time_layer[lx] / (
double)(frame_cnt_layer[lx] * 1000),
2024 1000000 * (
double)frame_cnt_layer[lx] / (
double)cx_time_layer[lx]);
2028 printf(
"Frame cnt and encoding time/FPS stats for encoding: %d %f %f\n",
2029 frame_cnt, 1000 * (
float)cx_time / (
double)(frame_cnt * 1000000),
2030 1000000 * (
double)frame_cnt / (
double)cx_time);
2032 if (app_input.show_psnr) {
2033 show_psnr(&psnr_stream, 255.0);
2038 #if CONFIG_AV1_DECODER 2039 if (app_input.decode) {
2041 die_codec(&decoder,
"Failed to destroy decoder");
2045 #if CONFIG_INTERNAL_STATS 2046 fprintf(stats_file,
"No mismatch detected in recon buffers\n");
2051 for (i = 0; i < ss_number_layers * ts_number_layers; ++i)
2052 aom_video_writer_close(outfile[i]);
2053 aom_video_writer_close(total_layer_file);
2055 if (app_input.input_ctx.file_type != FILE_TYPE_Y4M) {
2058 return EXIT_SUCCESS;
Definition: aom_encoder.h:200
Codec control function to set max data rate for intra frames, unsigned int parameter.
Definition: aomcx.h:306
Operation completed without error.
Definition: aom_codec.h:157
int number_spatial_layers
Definition: aomcx.h:1673
unsigned int d_h
Definition: aom_image.h:196
unsigned int kf_max_dist
Keyframe maximum interval.
Definition: aom_encoder.h:783
Codec control function to encode with CDEF, unsigned int parameter.
Definition: aomcx.h:670
unsigned int g_w
Width of the frame.
Definition: aom_encoder.h:424
Codec control to set the target bitrate in kilobits per second, unsigned int parameter. For 1 pass CBR mode, single layer encoding. This controls replaces the call aom_codec_enc_config_set(&codec, &cfg) when only target bitrate is changed, and so is much cheaper as it bypasses a lot of unneeded code checks.
Definition: aomcx.h:1528
#define AOM_CODEC_CONTROL_TYPECHECKED(ctx, id, data)
aom_codec_control wrapper macro (adds type-checking, less flexible)
Definition: aom_codec.h:525
unsigned int rc_target_bitrate
Target data rate.
Definition: aom_encoder.h:641
Codec control function to turn on / off frame order hint (int parameter). Affects: joint compound mod...
Definition: aomcx.h:865
Describes the encoder algorithm interface to applications.
int spatial_layer_id
Definition: aomcx.h:1662
Definition: aom_image.h:142
#define aom_codec_enc_init(ctx, iface, cfg, flags)
Convenience macro for aom_codec_enc_init_ver()
Definition: aom_encoder.h:938
unsigned int rc_buf_optimal_sz
Decoder Buffer Optimal Size.
Definition: aom_encoder.h:720
int framerate_factor[8]
Definition: aomcx.h:1682
Encoder configuration structure.
Definition: aom_encoder.h:385
enum aom_kf_mode kf_mode
Keyframe placement mode.
Definition: aom_encoder.h:765
Control to use default tx type only for intra modes, int parameter.
Definition: aomcx.h:1203
#define AOM_CODEC_USE_PSNR
Initialization-time Feature Enabling.
Definition: aom_encoder.h:79
aom_codec_err_t aom_codec_enc_config_default(aom_codec_iface_t *iface, aom_codec_enc_cfg_t *cfg, unsigned int usage)
Get the default configuration for a usage.
Definition: aom_encoder.h:185
Codec control function to set encoder scaling mode for the next frame to be coded, aom_scaling_mode_t* parameter.
Definition: aomcx.h:197
aom_codec_er_flags_t g_error_resilient
Enable error resilient modes.
Definition: aom_encoder.h:495
Provides definitions for using AOM or AV1 encoder algorithm within the aom Codec Interface.
Codec context structure.
Definition: aom_codec.h:298
Codec control function to turn on/off intra block copy mode, int parameter.
Definition: aomcx.h:1113
Codec control function to turn on / off warped motion usage at sequence level, int parameter...
Definition: aomcx.h:1038
#define AOM_IMG_FMT_HIGHBITDEPTH
Definition: aom_image.h:38
Describes the decoder algorithm interface to applications.
int refresh[8]
Definition: aomcx.h:1692
Image Descriptor.
Definition: aom_image.h:180
int reference[7]
Definition: aomcx.h:1689
double psnr[4]
Definition: aom_encoder.h:143
#define AOM_MAX_TS_LAYERS
Definition: aomcx.h:1658
Codec control function to set number of tile columns. unsigned int parameter.
Definition: aomcx.h:380
unsigned int rc_undershoot_pct
Rate control adaptation undershoot control.
Definition: aom_encoder.h:678
Codec control function to set reference frame config: the ref_idx and the refresh flags for each buff...
Definition: aomcx.h:1287
aom_image_t * aom_img_alloc(aom_image_t *img, aom_img_fmt_t fmt, unsigned int d_w, unsigned int d_h, unsigned int align)
Open a descriptor, allocating storage for the underlying image.
enum aom_rc_mode rc_end_usage
Rate control algorithm to use.
Definition: aom_encoder.h:621
aom_codec_err_t aom_codec_decode(aom_codec_ctx_t *ctx, const uint8_t *data, size_t data_sz, void *user_priv)
Decode data.
unsigned int g_profile
Bitstream profile to use.
Definition: aom_encoder.h:415
const aom_codec_cx_pkt_t * aom_codec_get_cx_data(aom_codec_ctx_t *ctx, aom_codec_iter_t *iter)
Encoded data iterator.
aom_codec_err_t aom_codec_encode(aom_codec_ctx_t *ctx, const aom_image_t *img, aom_codec_pts_t pts, unsigned long duration, aom_enc_frame_flags_t flags)
Encode a frame.
#define AOM_USAGE_REALTIME
usage parameter analogous to AV1 REALTIME mode.
Definition: aom_encoder.h:1011
Definition: aom_codec.h:319
const struct aom_codec_iface aom_codec_iface_t
Codec interface structure.
Definition: aom_codec.h:254
unsigned int rc_buf_initial_sz
Decoder Buffer Initial Size.
Definition: aom_encoder.h:711
#define aom_codec_dec_init(ctx, iface, cfg, flags)
Convenience macro for aom_codec_dec_init_ver()
Definition: aom_decoder.h:129
int temporal_layer_id
Definition: aomcx.h:1663
const char * aom_codec_iface_name(aom_codec_iface_t *iface)
Return the name for a given interface.
struct aom_rational g_timebase
Stream timebase units.
Definition: aom_encoder.h:487
Definition: aom_encoder.h:111
aom_codec_err_t aom_codec_destroy(aom_codec_ctx_t *ctx)
Destroy a codec instance.
const char * aom_codec_err_to_string(aom_codec_err_t err)
Convert error number to printable string.
Codec control function to turn on / off CFL uv intra mode usage, int parameter.
Definition: aomcx.h:1088
int layer_target_bitrate[32]
Definition: aomcx.h:1680
Memory operation failed.
Definition: aom_codec.h:163
enum aom_codec_cx_pkt_kind kind
Definition: aom_encoder.h:121
Codec control function to enable error_resilient_mode, int parameter.
Definition: aomcx.h:442
void aom_img_free(aom_image_t *img)
Close an image descriptor.
Codec control function to turn on / off global motion usage for a sequence, int parameter.
Definition: aomcx.h:1028
int scaling_factor_num[4]
Definition: aomcx.h:1677
int max_quantizers[32]
Definition: aomcx.h:1675
Codec control function to set SVC parameters, aom_svc_params_t* parameter.
Definition: aomcx.h:1281
Codec control function to turn on / off filter intra usage at sequence level, int parameter...
Definition: aomcx.h:1059
struct aom_codec_cx_pkt::@1::@2 frame
Definition: aom_encoder.h:108
int min_quantizers[32]
Definition: aomcx.h:1676
int use_comp_pred[3]
Definition: aomcx.h:1699
unsigned int rc_resize_mode
Mode for spatial resampling, if supported by the codec.
Definition: aom_encoder.h:547
#define AOM_MAX_LAYERS
Definition: aomcx.h:1656
unsigned int rc_max_quantizer
Maximum (Worst Quality) Quantizer.
Definition: aom_encoder.h:665
Control to set frequency of the cost updates for intrabc motion vectors, unsigned int parameter...
Definition: aomcx.h:1358
#define AOM_CODEC_USE_HIGHBITDEPTH
Definition: aom_encoder.h:80
unsigned int rc_buf_sz
Decoder Buffer Size.
Definition: aom_encoder.h:702
Control to set frequency of the cost updates for motion vectors, unsigned int parameter.
Definition: aomcx.h:1254
int number_temporal_layers
Definition: aomcx.h:1674
unsigned int rc_overshoot_pct
Rate control adaptation overshoot control.
Definition: aom_encoder.h:687
Codec control function to turn on/off palette mode, int parameter.
Definition: aomcx.h:1109
Control to set frequency of the cost updates for mode, unsigned int parameter.
Definition: aomcx.h:1244
Codec control to control loop filter.
Definition: aomcx.h:1407
Codec control function to get a pointer to the new frame.
Definition: aom.h:70
Codec control function to set encoder internal speed settings, int parameter.
Definition: aomcx.h:220
Codec control function to enable RDO modulated by frame temporal dependency, unsigned int parameter...
Definition: aomcx.h:408
Codec control function to set the delta q mode, unsigned int parameter.
Definition: aomcx.h:1131
aom_codec_iface_t * aom_codec_av1_cx(void)
The interface to the AV1 encoder.
unsigned int kf_min_dist
Keyframe minimum interval.
Definition: aom_encoder.h:774
const void * aom_codec_iter_t
Iterator.
Definition: aom_codec.h:288
Codec control function to set flag for rate control used by external encoders.
Definition: aomcx.h:1427
#define AOM_FRAME_IS_KEY
Definition: aom_codec.h:271
long aom_codec_flags_t
Initialization-time Feature Enabling.
Definition: aom_codec.h:228
Codec control function to turn on / off smooth intra modes usage, int parameter.
Definition: aomcx.h:1070
enum aom_bit_depth aom_bit_depth_t
Bit depth for codecThis enumeration determines the bit depth of the codec.
Codec control function to set reference frame compound prediction. aom_svc_ref_frame_comp_pred_t* par...
Definition: aomcx.h:1392
unsigned int g_usage
Algorithm specific "usage" value.
Definition: aom_encoder.h:397
unsigned int g_input_bit_depth
Bit-depth of the input frames.
Definition: aom_encoder.h:473
aom_codec_err_t
Algorithm return codes.
Definition: aom_codec.h:155
Control to set frequency of the cost updates for coefficients, unsigned int parameter.
Definition: aomcx.h:1234
enum aom_chroma_sample_position aom_chroma_sample_position_t
List of chroma sample positions.
aom image scaling mode
Definition: aomcx.h:1602
Codec control to set quantizer for the next frame, int parameter.
Definition: aomcx.h:1490
int den
Definition: aom_encoder.h:164
Codec control function to set content type, aom_tune_content parameter.
Definition: aomcx.h:497
int scaling_factor_den[4]
Definition: aomcx.h:1678
Codec control function to set adaptive quantization mode, unsigned int parameter. ...
Definition: aomcx.h:468
Encoder output packet.
Definition: aom_encoder.h:120
unsigned int rc_min_quantizer
Minimum (Best Quality) Quantizer.
Definition: aom_encoder.h:655
Codec control to set the maximum number of consecutive frame drops allowed for the frame dropper in 1...
Definition: aomcx.h:1534
Codec control function to predict with OBMC mode, unsigned int parameter.
Definition: aomcx.h:697
int num
Definition: aom_encoder.h:163
Boost percentage for Golden Frame in CBR mode, unsigned int parameter.
Definition: aomcx.h:339
Definition: aom_image.h:45
Definition: aom_codec.h:320
unsigned int g_lag_in_frames
Allow lagged encoding.
Definition: aom_encoder.h:516
Codec control function to set CDF update mode, unsigned int parameter.
Definition: aomcx.h:506
An application-supplied parameter is not valid.
Definition: aom_codec.h:200
Codec control function to turn on/off intra angle delta, int parameter.
Definition: aomcx.h:1117
unsigned int g_threads
Maximum number of threads to use.
Definition: aom_encoder.h:405
union aom_codec_cx_pkt::@1 data
aom_bit_depth_t g_bit_depth
Bit-depth of the codec.
Definition: aom_encoder.h:465
unsigned int d_w
Definition: aom_image.h:195
aom_codec_err_t aom_codec_control(aom_codec_ctx_t *ctx, int ctrl_id,...)
Algorithm Control.
unsigned int g_h
Height of the frame.
Definition: aom_encoder.h:433
aom_img_fmt_t fmt
Definition: aom_image.h:181
Codec control function to set the layer id, aom_svc_layer_id_t* parameter.
Definition: aomcx.h:1276
unsigned int rc_dropframe_thresh
Temporal resampling configuration, if supported by the codec.
Definition: aom_encoder.h:538
int ref_idx[7]
Definition: aomcx.h:1691