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);
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);
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],
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;
Describes the decoder algorithm interface to applications.
Describes the encoder algorithm interface to applications.
@ AOM_CSP_UNKNOWN
Definition: aom_image.h:142
enum aom_chroma_sample_position aom_chroma_sample_position_t
List of chroma sample positions.
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.
#define AOM_IMG_FMT_HIGHBITDEPTH
Definition: aom_image.h:38
@ AOM_IMG_FMT_I420
Definition: aom_image.h:45
enum aom_img_fmt aom_img_fmt_t
List of supported image formats.
void aom_img_free(aom_image_t *img)
Close an image descriptor.
Provides definitions for using AOM or AV1 encoder algorithm within the aom Codec Interface.
#define AOM_MAX_LAYERS
Definition: aomcx.h:1656
aom_codec_iface_t * aom_codec_av1_cx(void)
The interface to the AV1 encoder.
#define AOM_MAX_TS_LAYERS
Definition: aomcx.h:1658
@ AV1E_SET_BITRATE_ONE_PASS_CBR
Codec control to set the target bitrate in kilobits per second, unsigned int parameter....
Definition: aomcx.h:1528
@ AV1E_SET_ENABLE_SMOOTH_INTRA
Codec control function to turn on / off smooth intra modes usage, int parameter.
Definition: aomcx.h:1070
@ AV1E_SET_ENABLE_TPL_MODEL
Codec control function to enable RDO modulated by frame temporal dependency, unsigned int parameter.
Definition: aomcx.h:408
@ AV1E_SET_AQ_MODE
Codec control function to set adaptive quantization mode, unsigned int parameter.
Definition: aomcx.h:468
@ AV1E_SET_SVC_LAYER_ID
Codec control function to set the layer id, aom_svc_layer_id_t* parameter.
Definition: aomcx.h:1276
@ AV1E_SET_SVC_REF_FRAME_CONFIG
Codec control function to set reference frame config: the ref_idx and the refresh flags for each buff...
Definition: aomcx.h:1287
@ AV1E_SET_TUNE_CONTENT
Codec control function to set content type, aom_tune_content parameter.
Definition: aomcx.h:497
@ AV1E_SET_CDF_UPDATE_MODE
Codec control function to set CDF update mode, unsigned int parameter.
Definition: aomcx.h:506
@ AV1E_SET_MAX_CONSEC_FRAME_DROP_CBR
Codec control to set the maximum number of consecutive frame drops allowed for the frame dropper in 1...
Definition: aomcx.h:1534
@ AV1E_SET_ENABLE_ANGLE_DELTA
Codec control function to turn on/off intra angle delta, int parameter.
Definition: aomcx.h:1117
@ AV1E_SET_MV_COST_UPD_FREQ
Control to set frequency of the cost updates for motion vectors, unsigned int parameter.
Definition: aomcx.h:1254
@ AV1E_SET_INTRA_DEFAULT_TX_ONLY
Control to use default tx type only for intra modes, int parameter.
Definition: aomcx.h:1203
@ AV1E_SET_SVC_REF_FRAME_COMP_PRED
Codec control function to set reference frame compound prediction. aom_svc_ref_frame_comp_pred_t* par...
Definition: aomcx.h:1392
@ AV1E_SET_ENABLE_INTRABC
Codec control function to turn on/off intra block copy mode, int parameter.
Definition: aomcx.h:1113
@ AV1E_SET_ENABLE_WARPED_MOTION
Codec control function to turn on / off warped motion usage at sequence level, int parameter.
Definition: aomcx.h:1038
@ AV1E_SET_RTC_EXTERNAL_RC
Codec control function to set flag for rate control used by external encoders.
Definition: aomcx.h:1427
@ AV1E_SET_COEFF_COST_UPD_FREQ
Control to set frequency of the cost updates for coefficients, unsigned int parameter.
Definition: aomcx.h:1234
@ AV1E_SET_ENABLE_CDEF
Codec control function to encode with CDEF, unsigned int parameter.
Definition: aomcx.h:670
@ AV1E_SET_DV_COST_UPD_FREQ
Control to set frequency of the cost updates for intrabc motion vectors, unsigned int parameter.
Definition: aomcx.h:1358
@ AV1E_SET_SVC_PARAMS
Codec control function to set SVC parameters, aom_svc_params_t* parameter.
Definition: aomcx.h:1281
@ AV1E_SET_ENABLE_FILTER_INTRA
Codec control function to turn on / off filter intra usage at sequence level, int parameter.
Definition: aomcx.h:1059
@ AV1E_SET_ENABLE_PALETTE
Codec control function to turn on/off palette mode, int parameter.
Definition: aomcx.h:1109
@ AV1E_SET_ENABLE_CFL_INTRA
Codec control function to turn on / off CFL uv intra mode usage, int parameter.
Definition: aomcx.h:1088
@ AOME_SET_MAX_INTRA_BITRATE_PCT
Codec control function to set max data rate for intra frames, unsigned int parameter.
Definition: aomcx.h:306
@ AV1E_SET_ERROR_RESILIENT_MODE
Codec control function to enable error_resilient_mode, int parameter.
Definition: aomcx.h:442
@ AV1E_SET_ENABLE_OBMC
Codec control function to predict with OBMC mode, unsigned int parameter.
Definition: aomcx.h:697
@ AV1E_SET_LOOPFILTER_CONTROL
Codec control to control loop filter.
Definition: aomcx.h:1407
@ AOME_SET_SCALEMODE
Codec control function to set encoder scaling mode for the next frame to be coded,...
Definition: aomcx.h:197
@ AV1E_SET_TILE_COLUMNS
Codec control function to set number of tile columns. unsigned int parameter.
Definition: aomcx.h:380
@ AV1E_SET_ENABLE_ORDER_HINT
Codec control function to turn on / off frame order hint (int parameter). Affects: joint compound mod...
Definition: aomcx.h:865
@ AV1E_SET_DELTAQ_MODE
Codec control function to set the delta q mode, unsigned int parameter.
Definition: aomcx.h:1131
@ AV1E_SET_ENABLE_GLOBAL_MOTION
Codec control function to turn on / off global motion usage for a sequence, int parameter.
Definition: aomcx.h:1028
@ AOME_SET_CPUUSED
Codec control function to set encoder internal speed settings, int parameter.
Definition: aomcx.h:220
@ AV1E_SET_GF_CBR_BOOST_PCT
Boost percentage for Golden Frame in CBR mode, unsigned int parameter.
Definition: aomcx.h:339
@ AV1E_SET_QUANTIZER_ONE_PASS
Codec control to set quantizer for the next frame, int parameter.
Definition: aomcx.h:1490
@ AV1E_SET_MODE_COST_UPD_FREQ
Control to set frequency of the cost updates for mode, unsigned int parameter.
Definition: aomcx.h:1244
@ AV1_GET_NEW_FRAME_IMAGE
Codec control function to get a pointer to the new frame.
Definition: aom.h:70
const char * aom_codec_iface_name(aom_codec_iface_t *iface)
Return the name for a given interface.
enum aom_bit_depth aom_bit_depth_t
Bit depth for codecThis enumeration determines the bit depth of the codec.
aom_codec_err_t aom_codec_control(aom_codec_ctx_t *ctx, int ctrl_id,...)
Algorithm Control.
long aom_codec_flags_t
Initialization-time Feature Enabling.
Definition: aom_codec.h:228
const struct aom_codec_iface aom_codec_iface_t
Codec interface structure.
Definition: aom_codec.h:254
const char * aom_codec_err_to_string(aom_codec_err_t err)
Convert error number to printable string.
aom_codec_err_t aom_codec_destroy(aom_codec_ctx_t *ctx)
Destroy a codec instance.
aom_codec_err_t
Algorithm return codes.
Definition: aom_codec.h:155
#define AOM_CODEC_CONTROL_TYPECHECKED(ctx, id, data)
aom_codec_control wrapper macro (adds type-checking, less flexible)
Definition: aom_codec.h:525
const void * aom_codec_iter_t
Iterator.
Definition: aom_codec.h:288
#define AOM_FRAME_IS_KEY
Definition: aom_codec.h:271
@ AOM_BITS_8
Definition: aom_codec.h:319
@ AOM_BITS_10
Definition: aom_codec.h:320
@ AOM_CODEC_INVALID_PARAM
An application-supplied parameter is not valid.
Definition: aom_codec.h:200
@ AOM_CODEC_MEM_ERROR
Memory operation failed.
Definition: aom_codec.h:163
@ AOM_CODEC_OK
Operation completed without error.
Definition: aom_codec.h:157
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.
#define aom_codec_dec_init(ctx, iface, cfg, flags)
Convenience macro for aom_codec_dec_init_ver()
Definition: aom_decoder.h:129
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_codec_enc_init(ctx, iface, cfg, flags)
Convenience macro for aom_codec_enc_init_ver()
Definition: aom_encoder.h:938
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.
#define AOM_USAGE_REALTIME
usage parameter analogous to AV1 REALTIME mode.
Definition: aom_encoder.h:1011
#define AOM_CODEC_USE_HIGHBITDEPTH
Definition: aom_encoder.h:80
#define AOM_CODEC_USE_PSNR
Initialization-time Feature Enabling.
Definition: aom_encoder.h:79
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_CBR
Definition: aom_encoder.h:185
@ AOM_KF_AUTO
Definition: aom_encoder.h:200
@ AOM_CODEC_PSNR_PKT
Definition: aom_encoder.h:111
@ AOM_CODEC_CX_FRAME_PKT
Definition: aom_encoder.h:108
Codec context structure.
Definition: aom_codec.h:298
Encoder output packet.
Definition: aom_encoder.h:120
enum aom_codec_cx_pkt_kind kind
Definition: aom_encoder.h:121
double psnr[4]
Definition: aom_encoder.h:143
union aom_codec_cx_pkt::@1 data
struct aom_codec_cx_pkt::@1::@2 frame
Encoder configuration structure.
Definition: aom_encoder.h:385
unsigned int g_input_bit_depth
Bit-depth of the input frames.
Definition: aom_encoder.h:473
unsigned int rc_dropframe_thresh
Temporal resampling configuration, if supported by the codec.
Definition: aom_encoder.h:538
struct aom_rational g_timebase
Stream timebase units.
Definition: aom_encoder.h:487
unsigned int g_usage
Algorithm specific "usage" value.
Definition: aom_encoder.h:397
unsigned int rc_buf_sz
Decoder Buffer Size.
Definition: aom_encoder.h:702
unsigned int g_h
Height of the frame.
Definition: aom_encoder.h:433
enum aom_kf_mode kf_mode
Keyframe placement mode.
Definition: aom_encoder.h:765
enum aom_rc_mode rc_end_usage
Rate control algorithm to use.
Definition: aom_encoder.h:621
unsigned int g_threads
Maximum number of threads to use.
Definition: aom_encoder.h:405
unsigned int kf_min_dist
Keyframe minimum interval.
Definition: aom_encoder.h:774
unsigned int g_lag_in_frames
Allow lagged encoding.
Definition: aom_encoder.h:516
unsigned int rc_buf_initial_sz
Decoder Buffer Initial Size.
Definition: aom_encoder.h:711
unsigned int g_profile
Bitstream profile to use.
Definition: aom_encoder.h:415
aom_bit_depth_t g_bit_depth
Bit-depth of the codec.
Definition: aom_encoder.h:465
unsigned int g_w
Width of the frame.
Definition: aom_encoder.h:424
unsigned int rc_undershoot_pct
Rate control adaptation undershoot control.
Definition: aom_encoder.h:678
unsigned int kf_max_dist
Keyframe maximum interval.
Definition: aom_encoder.h:783
aom_codec_er_flags_t g_error_resilient
Enable error resilient modes.
Definition: aom_encoder.h:495
unsigned int rc_max_quantizer
Maximum (Worst Quality) Quantizer.
Definition: aom_encoder.h:665
unsigned int rc_buf_optimal_sz
Decoder Buffer Optimal Size.
Definition: aom_encoder.h:720
unsigned int rc_min_quantizer
Minimum (Best Quality) Quantizer.
Definition: aom_encoder.h:655
unsigned int rc_target_bitrate
Target data rate.
Definition: aom_encoder.h:641
unsigned int rc_resize_mode
Mode for spatial resampling, if supported by the codec.
Definition: aom_encoder.h:547
unsigned int rc_overshoot_pct
Rate control adaptation overshoot control.
Definition: aom_encoder.h:687
Image Descriptor.
Definition: aom_image.h:180
aom_img_fmt_t fmt
Definition: aom_image.h:181
unsigned int d_w
Definition: aom_image.h:195
unsigned int d_h
Definition: aom_image.h:196
int num
Definition: aom_encoder.h:163
int den
Definition: aom_encoder.h:164
aom image scaling mode
Definition: aomcx.h:1602
int temporal_layer_id
Definition: aomcx.h:1663
int spatial_layer_id
Definition: aomcx.h:1662
int max_quantizers[32]
Definition: aomcx.h:1675
int number_spatial_layers
Definition: aomcx.h:1673
int layer_target_bitrate[32]
Definition: aomcx.h:1680
int framerate_factor[8]
Definition: aomcx.h:1682
int min_quantizers[32]
Definition: aomcx.h:1676
int scaling_factor_den[4]
Definition: aomcx.h:1678
int number_temporal_layers
Definition: aomcx.h:1674
int scaling_factor_num[4]
Definition: aomcx.h:1677
int use_comp_pred[3]
Definition: aomcx.h:1699
int reference[7]
Definition: aomcx.h:1689
int refresh[8]
Definition: aomcx.h:1692
int ref_idx[7]
Definition: aomcx.h:1691