23#include "config/aom_config.h"
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;
61static const arg_def_t outputfile =
62 ARG_DEF(
"o",
"output", 1,
"Output filename");
63static const arg_def_t frames_arg =
64 ARG_DEF(
"f",
"frames", 1,
"Number of frames to encode");
65static const arg_def_t threads_arg =
66 ARG_DEF(
"th",
"threads", 1,
"Number of threads to use");
67static const arg_def_t width_arg = ARG_DEF(
"w",
"width", 1,
"Source width");
68static const arg_def_t height_arg = ARG_DEF(
"h",
"height", 1,
"Source height");
69static const arg_def_t timebase_arg =
70 ARG_DEF(
"t",
"timebase", 1,
"Timebase (num/den)");
71static const arg_def_t bitrate_arg = ARG_DEF(
72 "b",
"target-bitrate", 1,
"Encoding bitrate, in kilobits per second");
73static const arg_def_t spatial_layers_arg =
74 ARG_DEF(
"sl",
"spatial-layers", 1,
"Number of spatial SVC layers");
75static const arg_def_t temporal_layers_arg =
76 ARG_DEF(
"tl",
"temporal-layers", 1,
"Number of temporal SVC layers");
77static const arg_def_t layering_mode_arg =
78 ARG_DEF(
"lm",
"layering-mode", 1,
"Temporal layering scheme.");
79static const arg_def_t kf_dist_arg =
80 ARG_DEF(
"k",
"kf-dist", 1,
"Number of frames between keyframes");
81static const arg_def_t scale_factors_arg =
82 ARG_DEF(
"r",
"scale-factors", 1,
"Scale factors (lowest to highest layer)");
83static const arg_def_t min_q_arg =
84 ARG_DEF(NULL,
"min-q", 1,
"Minimum quantizer");
85static const arg_def_t max_q_arg =
86 ARG_DEF(NULL,
"max-q", 1,
"Maximum quantizer");
87static const arg_def_t speed_arg =
88 ARG_DEF(
"sp",
"speed", 1,
"Speed configuration");
89static const arg_def_t aqmode_arg =
90 ARG_DEF(
"aq",
"aqmode", 1,
"AQ mode off/on");
91static const arg_def_t bitrates_arg =
92 ARG_DEF(
"bl",
"bitrates", 1,
93 "Bitrates[spatial_layer * num_temporal_layer + temporal_layer]");
94static const arg_def_t dropframe_thresh_arg =
95 ARG_DEF(NULL,
"drop-frame", 1,
"Temporal resampling threshold (buf %)");
96static const arg_def_t error_resilient_arg =
97 ARG_DEF(NULL,
"error-resilient", 1,
"Error resilient flag");
98static 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.");
101static 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.");
104static const arg_def_t psnr_arg =
105 ARG_DEF(NULL,
"psnr", -1,
"Show PSNR in status line.");
106static const arg_def_t ext_rc_arg =
107 ARG_DEF(NULL,
"use-ext-rc", 0,
"Use external rate control.");
108static const struct arg_enum_list tune_content_enum[] = {
109 {
"default", AOM_CONTENT_DEFAULT },
110 {
"screen", AOM_CONTENT_SCREEN },
111 {
"film", AOM_CONTENT_FILM },
114static 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
118static const struct arg_enum_list bitdepth_enum[] = { {
"8",
AOM_BITS_8 },
122static const arg_def_t bitdepth_arg = ARG_DEF_ENUM(
123 "d",
"bit-depth", 1,
"Bit depth for codec 8 or 10. ", bitdepth_enum);
126static 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))
142static const char *exec_name;
144void 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);
152static int file_is_y4m(
const char detect[4]) {
153 return memcmp(detect,
"YUV4", 4) == 0;
156static int fourcc_is_ivf(
const char detect[4]) {
157 if (memcmp(detect,
"DKIF", 4) == 0) {
163static const int option_max_values[ALL_OPTION_TYPES] = { 63, INT_MAX, INT_MAX,
166static const int option_min_values[ALL_OPTION_TYPES] = { 0, 0, 1, 0 };
168static 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;
216static 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);
274static 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"
440static int mode_to_num_temporal_layers[12] = {
441 1, 2, 3, 3, 2, 1, 1, 3, 3, 3, 3, 3,
443static int mode_to_num_spatial_layers[12] = {
444 1, 1, 1, 1, 1, 2, 3, 2, 3, 3, 3, 3,
448struct RateControlMetrics {
465 double avg_st_encoding_bitrate;
467 double variance_st_encoding_bitrate;
475static const int REF_FRAMES = 8;
477static const int INTER_REFS_PER_FRAME = 7;
490static 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);
504static void close_input_file(
struct AvxInputContext *input) {
506 if (input->file_type == FILE_TYPE_Y4M) y4m_input_close(&input->y4m);
515static 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;
558static 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");
609static 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];
1383static 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");
1400static 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;
1429static 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");
1474int 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]) /
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;
Describes the decoder algorithm interface to applications.
Describes the encoder algorithm interface to applications.
@ AOM_CSP_UNKNOWN
Definition aom_image.h:143
enum aom_chroma_sample_position aom_chroma_sample_position_t
List of chroma sample positions.
#define AOM_IMG_FMT_HIGHBITDEPTH
Definition aom_image.h:38
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.
@ 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:1662
#define AOM_MAX_TS_LAYERS
Definition aomcx.h:1664
aom_codec_iface_t * aom_codec_av1_cx(void)
The interface to the AV1 encoder.
@ AOM_FULL_SUPERFRAME_DROP
Definition aomcx.h:1711
@ 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
@ AOME_SET_ACTIVEMAP
Codec control function to pass an Active map to encoder, aom_active_map_t* parameter.
Definition aomcx.h:190
@ 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_FRAME_DROP_MODE
Codec control to set the frame drop mode for SVC, unsigned int parameter. The valid values are consta...
Definition aomcx.h:1540
@ 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
aom_codec_err_t aom_codec_destroy(aom_codec_ctx_t *ctx)
Destroy a codec instance.
const char * aom_codec_err_to_string(aom_codec_err_t err)
Convert error number to printable string.
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
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_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
@ 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
aom active region map
Definition aomcx.h:1596
unsigned int rows
Definition aomcx.h:1599
unsigned int cols
Definition aomcx.h:1600
unsigned char * active_map
specify an on (1) or off (0) each 16x16 region within a frame
Definition aomcx.h:1598
Codec context structure.
Definition aom_codec.h:298
Encoder output packet.
Definition aom_encoder.h:120
size_t sz
Definition aom_encoder.h:125
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
aom_codec_frame_flags_t flags
Definition aom_encoder.h:130
void * buf
Definition aom_encoder.h:124
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:182
aom_img_fmt_t fmt
Definition aom_image.h:183
unsigned int d_w
Definition aom_image.h:197
unsigned int d_h
Definition aom_image.h:198
int num
Definition aom_encoder.h:163
int den
Definition aom_encoder.h:164
aom image scaling mode
Definition aomcx.h:1608
int temporal_layer_id
Definition aomcx.h:1669
int spatial_layer_id
Definition aomcx.h:1668
int max_quantizers[32]
Definition aomcx.h:1681
int number_spatial_layers
Definition aomcx.h:1679
int layer_target_bitrate[32]
Definition aomcx.h:1686
int framerate_factor[8]
Definition aomcx.h:1688
int min_quantizers[32]
Definition aomcx.h:1682
int scaling_factor_den[4]
Definition aomcx.h:1684
int number_temporal_layers
Definition aomcx.h:1680
int scaling_factor_num[4]
Definition aomcx.h:1683
int use_comp_pred[3]
Definition aomcx.h:1705
int reference[7]
Definition aomcx.h:1695
int refresh[8]
Definition aomcx.h:1698
int ref_idx[7]
Definition aomcx.h:1697