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;
1449 map.
rows = (cfg->
g_h + 15) / 16;
1450 map.
cols = (cfg->
g_w + 15) / 16;
1453 if (!map.
active_map) die(
"Failed to allocate active map");
1456 for (
unsigned int i = 0; i < map.
rows; ++i) {
1457 for (
unsigned int j = 0; j < map.
cols; ++j) {
1458 int index = map.
cols * i + j;
1460 if (frame_cnt < 300) {
1462 }
else if (frame_cnt >= 300) {
1463 if (i < map.rows / 2 && j >= map.
cols / 2) map.
active_map[index] = 0;
1469 die_codec(codec,
"Failed to set active map");
1474 int main(
int argc,
const char **argv) {
1478 AvxVideoWriter *total_layer_file = NULL;
1479 FILE *total_layer_obu_file = NULL;
1488 int frame_duration = 1;
1494 #if CONFIG_INTERNAL_STATS
1495 FILE *stats_file = fopen(
"opsnr.stt",
"a");
1496 if (stats_file == NULL) {
1497 die(
"Cannot open opsnr.stt\n");
1500 #if CONFIG_AV1_DECODER
1504 struct RateControlMetrics rc;
1505 int64_t cx_time = 0;
1508 double sum_bitrate = 0.0;
1509 double sum_bitrate2 = 0.0;
1510 double framerate = 30.0;
1511 int use_svc_control = 1;
1512 int set_err_resil_frame = 0;
1513 int test_changing_bitrate = 0;
1514 zero(rc.layer_target_bitrate);
1516 memset(&app_input, 0,
sizeof(AppInput));
1517 memset(&svc_params, 0,
sizeof(svc_params));
1521 const int test_dynamic_scaling_single_layer = 0;
1524 const int test_speed_per_layer = 0;
1527 const int test_active_maps = 0;
1530 app_input.input_ctx.framerate.numerator = 30;
1531 app_input.input_ctx.framerate.denominator = 1;
1532 app_input.input_ctx.only_i420 = 0;
1534 app_input.speed = 7;
1535 exec_name = argv[0];
1559 parse_command_line(argc, argv, &app_input, &svc_params, &cfg);
1564 unsigned int width = cfg.
g_w;
1565 unsigned int height = cfg.
g_h;
1567 if (app_input.layering_mode >= 0) {
1568 if (ts_number_layers !=
1569 mode_to_num_temporal_layers[app_input.layering_mode] ||
1571 mode_to_num_spatial_layers[app_input.layering_mode]) {
1572 die(
"Number of layers doesn't match layering mode.");
1577 if (app_input.input_ctx.file_type != FILE_TYPE_Y4M) {
1579 die(
"Failed to allocate image (%dx%d)", width, height);
1588 unsigned int total_rate = 0;
1589 for (i = 0; i < ss_number_layers; i++) {
1595 die(
"Incorrect total target bitrate");
1599 if (ts_number_layers == 2) {
1602 }
else if (ts_number_layers == 3) {
1608 if (app_input.input_ctx.file_type == FILE_TYPE_Y4M) {
1610 cfg.
g_w = app_input.input_ctx.width;
1611 cfg.
g_h = app_input.input_ctx.height;
1613 cfg.
g_timebase.
num = app_input.input_ctx.framerate.denominator;
1614 cfg.
g_timebase.
den = app_input.input_ctx.framerate.numerator;
1617 set_rate_control_metrics(&rc, framerate, ss_number_layers, ts_number_layers);
1620 info.codec_fourcc = get_fourcc_by_aom_encoder(encoder);
1621 info.frame_width = cfg.
g_w;
1622 info.frame_height = cfg.
g_h;
1626 for (
int sl = 0; sl < ss_number_layers; ++sl) {
1627 for (
int tl = 0; tl < ts_number_layers; ++tl) {
1628 i = sl * ts_number_layers + tl;
1629 char file_name[PATH_MAX];
1630 snprintf(file_name,
sizeof(file_name),
"%s_%d.av1",
1631 app_input.output_filename, i);
1632 if (app_input.output_obu) {
1633 obu_files[i] = fopen(file_name,
"wb");
1634 if (!obu_files[i]) die(
"Failed to open %s for writing", file_name);
1636 outfile[i] = aom_video_writer_open(file_name, kContainerIVF, &info);
1637 if (!outfile[i]) die(
"Failed to open %s for writing", file_name);
1641 if (app_input.output_obu) {
1642 total_layer_obu_file = fopen(app_input.output_filename,
"wb");
1643 if (!total_layer_obu_file)
1644 die(
"Failed to open %s for writing", app_input.output_filename);
1647 aom_video_writer_open(app_input.output_filename, kContainerIVF, &info);
1648 if (!total_layer_file)
1649 die(
"Failed to open %s for writing", app_input.output_filename);
1658 die_codec(&codec,
"Failed to initialize encoder");
1660 #if CONFIG_AV1_DECODER
1661 if (app_input.decode) {
1663 die_codec(&decoder,
"Failed to initialize decoder");
1697 if (app_input.tune_content == AOM_CONTENT_SCREEN) {
1704 if (app_input.use_external_rc) {
1715 for (i = 0; i < ss_number_layers * ts_number_layers; ++i) {
1719 for (i = 0; i < ss_number_layers; ++i) {
1723 if (ss_number_layers == 2) {
1726 }
else if (ss_number_layers == 3) {
1739 const int max_intra_size_pct = 300;
1741 max_intra_size_pct);
1744 for (
int lx = 0; lx < ts_number_layers * ss_number_layers; lx++) {
1745 cx_time_layer[lx] = 0;
1746 frame_cnt_layer[lx] = 0;
1749 std::unique_ptr<aom::AV1RateControlRTC> rc_api;
1750 if (app_input.use_external_rc) {
1751 const aom::AV1RateControlRtcConfig rc_cfg =
1752 create_rtc_rc_config(cfg, app_input);
1753 rc_api = aom::AV1RateControlRTC::Create(rc_cfg);
1757 struct psnr_stats psnr_stream;
1758 memset(&psnr_stream, 0,
sizeof(psnr_stream));
1759 while (frame_avail || got_data) {
1760 struct aom_usec_timer timer;
1761 frame_avail = read_frame(&(app_input.input_ctx), &raw);
1763 for (
int slx = 0; slx < ss_number_layers; slx++) {
1768 int is_key_frame = (frame_cnt % cfg.
kf_max_dist) == 0;
1770 if (app_input.layering_mode >= 0) {
1773 set_layer_pattern(app_input.layering_mode, frame_cnt, &layer_id,
1774 &ref_frame_config, &ref_frame_comp_pred,
1775 &use_svc_control, slx, is_key_frame,
1776 (app_input.layering_mode == 10), app_input.speed);
1778 if (use_svc_control) {
1782 &ref_frame_comp_pred);
1785 if (test_speed_per_layer) {
1786 int speed_per_layer = 10;
1808 if (ts_number_layers == 2) {
1810 }
else if (ts_number_layers == 3) {
1811 if (frame_cnt % 2 != 0)
1813 else if ((frame_cnt > 1) && ((frame_cnt - 2) % 4 == 0))
1827 const int err_resil_mode =
1834 if (frame_avail && slx == 0) ++rc.layer_input_frames[layer];
1836 if (test_dynamic_scaling_single_layer) {
1839 int frame_2x2 = 200;
1840 int frame_4x4 = 400;
1841 int frame_2x2up = 600;
1842 int frame_orig = 800;
1843 if (frame_cnt >= frame_2x2 && frame_cnt < frame_4x4) {
1847 }
else if (frame_cnt >= frame_4x4 && frame_cnt < frame_2x2up) {
1851 }
else if (frame_cnt >= frame_2x2up && frame_cnt < frame_orig) {
1855 }
else if (frame_cnt >= frame_orig) {
1860 if (frame_cnt == frame_2x2 || frame_cnt == frame_4x4 ||
1861 frame_cnt == frame_2x2up || frame_cnt == frame_orig) {
1867 for (i = 0; i < REF_FRAMES; i++) ref_frame_config.
refresh[i] = 1;
1868 if (use_svc_control) {
1872 &ref_frame_comp_pred);
1878 if (test_changing_bitrate && frame_cnt % 2 == 0) {
1879 if (frame_cnt < 500)
1891 die_codec(&codec,
"Failed to SET_BITRATE_ONE_PASS_CBR");
1895 aom::AV1FrameParamsRTC frame_params;
1897 frame_params.spatial_layer_id = 0;
1898 frame_params.temporal_layer_id = 0;
1899 frame_params.frame_type =
1900 is_key_frame ? aom::kKeyFrame : aom::kInterFrame;
1901 rc_api->ComputeQP(frame_params);
1902 const int current_qp = rc_api->GetQP();
1904 qindex_to_quantizer(current_qp))) {
1905 die_codec(&codec,
"Failed to SET_QUANTIZER_ONE_PASS");
1909 if (test_active_maps) set_active_map(&cfg, &codec, frame_cnt);
1912 aom_usec_timer_start(&timer);
1914 die_codec(&codec,
"Failed to encode frame");
1915 aom_usec_timer_mark(&timer);
1916 cx_time += aom_usec_timer_elapsed(&timer);
1917 cx_time_layer[layer] += aom_usec_timer_elapsed(&timer);
1918 frame_cnt_layer[layer] += 1;
1922 int ss_layers_write = (app_input.layering_mode == 11)
1926 switch (pkt->
kind) {
1932 int j = sl * ts_number_layers + tl;
1933 if (app_input.output_obu) {
1937 aom_video_writer_write_frame(
1939 reinterpret_cast<const uint8_t *>(pkt->
data.
frame.buf),
1943 rc.layer_encoding_bitrate[j] += 8.0 * pkt->
data.
frame.sz;
1948 if (app_input.output_obu) {
1950 total_layer_obu_file);
1952 aom_video_writer_write_frame(
1954 reinterpret_cast<const uint8_t *>(pkt->
data.
frame.buf),
1962 rc.layer_avg_frame_size[j] += 8.0 * pkt->
data.
frame.sz;
1963 rc.layer_avg_rate_mismatch[j] +=
1964 fabs(8.0 * pkt->
data.
frame.sz - rc.layer_pfb[j]) /
1970 rc_api->PostEncodeUpdate(pkt->
data.
frame.sz);
1976 if (frame_cnt > rc.window_size && slx == ss_number_layers - 1) {
1977 sum_bitrate += 0.001 * 8.0 * pkt->
data.
frame.sz * framerate;
1978 rc.window_size = (rc.window_size <= 0) ? 1 : rc.window_size;
1979 if (frame_cnt % rc.window_size == 0) {
1980 rc.window_count += 1;
1981 rc.avg_st_encoding_bitrate += sum_bitrate / rc.window_size;
1982 rc.variance_st_encoding_bitrate +=
1983 (sum_bitrate / rc.window_size) *
1984 (sum_bitrate / rc.window_size);
1989 if (frame_cnt > rc.window_size + rc.window_size / 2 &&
1990 slx == ss_number_layers - 1) {
1991 sum_bitrate2 += 0.001 * 8.0 * pkt->
data.
frame.sz * framerate;
1992 if (frame_cnt > 2 * rc.window_size &&
1993 frame_cnt % rc.window_size == 0) {
1994 rc.window_count += 1;
1995 rc.avg_st_encoding_bitrate += sum_bitrate2 / rc.window_size;
1996 rc.variance_st_encoding_bitrate +=
1997 (sum_bitrate2 / rc.window_size) *
1998 (sum_bitrate2 / rc.window_size);
2003 #if CONFIG_AV1_DECODER
2004 if (app_input.decode) {
2007 reinterpret_cast<const uint8_t *>(pkt->
data.
frame.buf),
2009 die_codec(&decoder,
"Failed to decode frame");
2015 if (app_input.show_psnr) {
2016 psnr_stream.psnr_sse_total[0] += pkt->
data.
psnr.sse[0];
2017 psnr_stream.psnr_samples_total[0] += pkt->
data.
psnr.samples[0];
2018 for (
int plane = 0; plane < 4; plane++) {
2019 psnr_stream.psnr_totals[0][plane] += pkt->
data.
psnr.psnr[plane];
2021 psnr_stream.psnr_count[0]++;
2027 #if CONFIG_AV1_DECODER
2028 if (got_data && app_input.decode) {
2031 if ((ss_number_layers > 1 || ts_number_layers > 1) &&
2034 if (test_decode(&codec, &decoder, frame_cnt)) {
2035 #if CONFIG_INTERNAL_STATS
2036 fprintf(stats_file,
"First mismatch occurred in frame %d\n",
2040 fatal(
"Mismatch seen");
2047 pts += frame_duration;
2050 close_input_file(&(app_input.input_ctx));
2051 printout_rate_control_summary(&rc, frame_cnt, ss_number_layers,
2055 for (
int slx = 0; slx < ss_number_layers; slx++)
2056 for (
int tlx = 0; tlx < ts_number_layers; tlx++) {
2057 int lx = slx * ts_number_layers + tlx;
2058 printf(
"Per layer encoding time/FPS stats for encoder: %d %d %d %f %f \n",
2059 slx, tlx, frame_cnt_layer[lx],
2060 (
float)cx_time_layer[lx] / (
double)(frame_cnt_layer[lx] * 1000),
2061 1000000 * (
double)frame_cnt_layer[lx] / (
double)cx_time_layer[lx]);
2065 printf(
"Frame cnt and encoding time/FPS stats for encoding: %d %f %f\n",
2066 frame_cnt, 1000 * (
float)cx_time / (
double)(frame_cnt * 1000000),
2067 1000000 * (
double)frame_cnt / (
double)cx_time);
2069 if (app_input.show_psnr) {
2070 show_psnr(&psnr_stream, 255.0);
2075 #if CONFIG_AV1_DECODER
2076 if (app_input.decode) {
2078 die_codec(&decoder,
"Failed to destroy decoder");
2082 #if CONFIG_INTERNAL_STATS
2083 fprintf(stats_file,
"No mismatch detected in recon buffers\n");
2088 for (i = 0; i < ss_number_layers * ts_number_layers; ++i)
2089 aom_video_writer_close(outfile[i]);
2090 aom_video_writer_close(total_layer_file);
2092 if (app_input.input_ctx.file_type != FILE_TYPE_Y4M) {
2095 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:1679
unsigned int d_h
Definition: aom_image.h:198
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 frame drop mode for SVC, unsigned int parameter. The valid values are consta...
Definition: aomcx.h:1540
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
int layer_target_bitrate[32]
Definition: aomcx.h:1686
unsigned int rc_target_bitrate
Target data rate.
Definition: aom_encoder.h:641
unsigned char * active_map
specify an on (1) or off (0) each 16x16 region within a frame
Definition: aomcx.h:1598
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:1668
Definition: aom_image.h:143
#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
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
int min_quantizers[32]
Definition: aomcx.h:1682
Describes the decoder algorithm interface to applications.
int refresh[8]
Definition: aomcx.h:1698
Image Descriptor.
Definition: aom_image.h:182
int reference[7]
Definition: aomcx.h:1695
double psnr[4]
Definition: aom_encoder.h:143
#define AOM_MAX_TS_LAYERS
Definition: aomcx.h:1664
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:1669
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.
int scaling_factor_num[4]
Definition: aomcx.h:1683
const char * aom_codec_err_to_string(aom_codec_err_t err)
Convert error number to printable string.
unsigned int cols
Definition: aomcx.h:1600
Codec control function to turn on / off CFL uv intra mode usage, int parameter.
Definition: aomcx.h:1088
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
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
aom active region map
Definition: aomcx.h:1596
int use_comp_pred[3]
Definition: aomcx.h:1705
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:1662
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
int max_quantizers[32]
Definition: aomcx.h:1681
#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:1680
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.
Codec control function to pass an Active map to encoder, aom_active_map_t* parameter.
Definition: aomcx.h:190
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
unsigned int rows
Definition: aomcx.h:1599
#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:1608
Codec control to set quantizer for the next frame, int parameter.
Definition: aomcx.h:1490
int scaling_factor_den[4]
Definition: aomcx.h:1684
int den
Definition: aom_encoder.h:164
Codec control function to set content type, aom_tune_content parameter.
Definition: aomcx.h:497
int framerate_factor[8]
Definition: aomcx.h:1688
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:197
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:183
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:1697