1
2
3
4
5
6
7
8
9
10
11
12
13
14#include <assert.h>
15#include <limits.h>
16#include <math.h>
17#include <stdio.h>
18#include <stdlib.h>
19#include <string.h>
20
21#include "config/aom_config.h"
22
23#if CONFIG_AV1_DECODER
25#endif
28#include "common/args.h"
29#include "common/tools_common.h"
30#include "common/video_writer.h"
31#include "examples/encoder_util.h"
32#include "aom_ports/aom_timer.h"
33
34#define OPTION_BUFFER_SIZE 1024
35
36typedef struct {
37 const char *output_filename;
38 char options[OPTION_BUFFER_SIZE];
39 struct AvxInputContext input_ctx;
40 int speed;
41 int aq_mode;
42 int layering_mode;
43 int output_obu;
44 int decode;
45 int tune_content;
46 int show_psnr;
47} AppInput;
48
49typedef enum {
50 QUANTIZER = 0,
51 BITRATE,
52 SCALE_FACTOR,
53 AUTO_ALT_REF,
54 ALL_OPTION_TYPES
55} LAYER_OPTION_TYPE;
56
57static const arg_def_t outputfile =
58 ARG_DEF("o", "output", 1, "Output filename");
59static const arg_def_t frames_arg =
60 ARG_DEF("f", "frames", 1, "Number of frames to encode");
61static const arg_def_t threads_arg =
62 ARG_DEF("th", "threads", 1, "Number of threads to use");
63static const arg_def_t width_arg = ARG_DEF("w", "width", 1, "Source width");
64static const arg_def_t height_arg = ARG_DEF("h", "height", 1, "Source height");
65static const arg_def_t timebase_arg =
66 ARG_DEF("t", "timebase", 1, "Timebase (num/den)");
67static const arg_def_t bitrate_arg = ARG_DEF(
68 "b", "target-bitrate", 1, "Encoding bitrate, in kilobits per second");
69static const arg_def_t spatial_layers_arg =
70 ARG_DEF("sl", "spatial-layers", 1, "Number of spatial SVC layers");
71static const arg_def_t temporal_layers_arg =
72 ARG_DEF("tl", "temporal-layers", 1, "Number of temporal SVC layers");
73static const arg_def_t layering_mode_arg =
74 ARG_DEF("lm", "layering-mode", 1, "Temporal layering scheme.");
75static const arg_def_t kf_dist_arg =
76 ARG_DEF("k", "kf-dist", 1, "Number of frames between keyframes");
77static const arg_def_t scale_factors_arg =
78 ARG_DEF("r", "scale-factors", 1, "Scale factors (lowest to highest layer)");
79static const arg_def_t min_q_arg =
80 ARG_DEF(NULL, "min-q", 1, "Minimum quantizer");
81static const arg_def_t max_q_arg =
82 ARG_DEF(NULL, "max-q", 1, "Maximum quantizer");
83static const arg_def_t speed_arg =
84 ARG_DEF("sp", "speed", 1, "Speed configuration");
85static const arg_def_t aqmode_arg =
86 ARG_DEF("aq", "aqmode", 1, "AQ mode off/on");
87static const arg_def_t bitrates_arg =
88 ARG_DEF("bl", "bitrates", 1,
89 "Bitrates[spatial_layer * num_temporal_layer + temporal_layer]");
90static const arg_def_t dropframe_thresh_arg =
91 ARG_DEF(NULL, "drop-frame", 1, "Temporal resampling threshold (buf %)");
92static const arg_def_t error_resilient_arg =
93 ARG_DEF(NULL, "error-resilient", 1, "Error resilient flag");
94static const arg_def_t output_obu_arg =
95 ARG_DEF(NULL, "output-obu", 1,
96 "Write OBUs when set to 1. Otherwise write IVF files.");
97static const arg_def_t test_decode_arg =
98 ARG_DEF(NULL, "test-decode", 1,
99 "Attempt to test decoding the output when set to 1. Default is 1.");
100static const arg_def_t psnr_arg =
101 ARG_DEF(NULL, "psnr", -1, "Show PSNR in status line.");
102static const struct arg_enum_list tune_content_enum[] = {
103 { "default", AOM_CONTENT_DEFAULT },
104 { "screen", AOM_CONTENT_SCREEN },
105 { "film", AOM_CONTENT_FILM },
106 { NULL, 0 }
107};
108static const arg_def_t tune_content_arg = ARG_DEF_ENUM(
109 NULL, "tune-content", 1, "Tune content type", tune_content_enum);
110
111#if CONFIG_AV1_HIGHBITDEPTH
112static const struct arg_enum_list bitdepth_enum[] = { {
"8",
AOM_BITS_8 },
114 { NULL, 0 } };
115
116static const arg_def_t bitdepth_arg = ARG_DEF_ENUM(
117 "d", "bit-depth", 1, "Bit depth for codec 8 or 10. ", bitdepth_enum);
118#endif
119
120static const arg_def_t *svc_args[] = {
121 &frames_arg, &outputfile, &width_arg,
122 &height_arg, &timebase_arg, &bitrate_arg,
123 &spatial_layers_arg, &kf_dist_arg, &scale_factors_arg,
124 &min_q_arg, &max_q_arg, &temporal_layers_arg,
125 &layering_mode_arg, &threads_arg, &aqmode_arg,
126#if CONFIG_AV1_HIGHBITDEPTH
127 &bitdepth_arg,
128#endif
129 &speed_arg, &bitrates_arg, &dropframe_thresh_arg,
130 &error_resilient_arg, &output_obu_arg, &test_decode_arg,
131 &tune_content_arg, &psnr_arg, NULL,
132};
133
134#define zero(Dest) memset(&(Dest), 0, sizeof(Dest))
135
136static const char *exec_name;
137
138void usage_exit(void) {
139 fprintf(stderr, "Usage: %s <options> input_filename -o output_filename\n",
140 exec_name);
141 fprintf(stderr, "Options:\n");
142 arg_show_usage(stderr, svc_args);
143 exit(EXIT_FAILURE);
144}
145
146static int file_is_y4m(const char detect[4]) {
147 return memcmp(detect, "YUV4", 4) == 0;
148}
149
150static int fourcc_is_ivf(const char detect[4]) {
151 if (memcmp(detect, "DKIF", 4) == 0) {
152 return 1;
153 }
154 return 0;
155}
156
157static const int option_max_values[ALL_OPTION_TYPES] = { 63, INT_MAX, INT_MAX,
158 1 };
159
160static const int option_min_values[ALL_OPTION_TYPES] = { 0, 0, 1, 0 };
161
162static void open_input_file(struct AvxInputContext *input,
164
165 input->file = strcmp(input->filename, "-") ? fopen(input->filename, "rb")
166 : set_binary_mode(stdin);
167
168 if (!input->file) fatal("Failed to open input file");
169
170 if (!fseeko(input->file, 0, SEEK_END)) {
171
172
173
174 input->length = ftello(input->file);
175 rewind(input->file);
176 }
177
178
179 input->pixel_aspect_ratio.numerator = 1;
180 input->pixel_aspect_ratio.denominator = 1;
181
182
183
184
185 input->detect.buf_read = fread(input->detect.buf, 1, 4, input->file);
186 input->detect.position = 0;
187
188 if (input->detect.buf_read == 4 && file_is_y4m(input->detect.buf)) {
189 if (y4m_input_open(&input->y4m, input->file, input->detect.buf, 4, csp,
190 input->only_i420) >= 0) {
191 input->file_type = FILE_TYPE_Y4M;
192 input->width = input->y4m.pic_w;
193 input->height = input->y4m.pic_h;
194 input->pixel_aspect_ratio.numerator = input->y4m.par_n;
195 input->pixel_aspect_ratio.denominator = input->y4m.par_d;
196 input->framerate.numerator = input->y4m.fps_n;
197 input->framerate.denominator = input->y4m.fps_d;
198 input->fmt = input->y4m.aom_fmt;
199 input->bit_depth = static_cast<aom_bit_depth_t>(input->y4m.bit_depth);
200 } else {
201 fatal("Unsupported Y4M stream.");
202 }
203 } else if (input->detect.buf_read == 4 && fourcc_is_ivf(input->detect.buf)) {
204 fatal("IVF is not supported as input.");
205 } else {
206 input->file_type = FILE_TYPE_RAW;
207 }
208}
209
210static aom_codec_err_t extract_option(LAYER_OPTION_TYPE type,
char *input,
211 int *value0, int *value1) {
212 if (type == SCALE_FACTOR) {
213 *value0 = (int)strtol(input, &input, 10);
215 *value1 = (int)strtol(input, &input, 10);
216
217 if (*value0 < option_min_values[SCALE_FACTOR] ||
218 *value1 < option_min_values[SCALE_FACTOR] ||
219 *value0 > option_max_values[SCALE_FACTOR] ||
220 *value1 > option_max_values[SCALE_FACTOR] ||
221 *value0 > *value1)
223 } else {
224 *value0 = atoi(input);
225 if (*value0 < option_min_values[type] || *value0 > option_max_values[type])
227 }
229}
230
233 int *option0, int *option1) {
235 char *input_string;
236 char *token;
237 const char *delim = ",";
239 int i = 0;
240
241 if (type == BITRATE)
242 num_layers =
244
245 if (input == NULL || option0 == NULL ||
246 (option1 == NULL && type == SCALE_FACTOR))
248
249 const size_t input_length = strlen(input);
250 input_string = reinterpret_cast<char *>(malloc(input_length + 1));
252 memcpy(input_string, input, input_length + 1);
253 token = strtok(input_string, delim);
254 for (i = 0; i < num_layers; ++i) {
255 if (token != NULL) {
256 res = extract_option(type, token, option0 + i, option1 + i);
258 token = strtok(NULL, delim);
259 } else {
261 break;
262 }
263 }
264 free(input_string);
265 return res;
266}
267
268static void parse_command_line(int argc, const char **argv_,
269 AppInput *app_input,
272 struct arg arg;
273 char **argv = NULL;
274 char **argi = NULL;
275 char **argj = NULL;
276 char string_options[1024] = { 0 };
277
278
281 app_input->layering_mode = 0;
282 app_input->output_obu = 0;
283 app_input->decode = 1;
286
287
288 argv = argv_dup(argc - 1, argv_ + 1);
289 if (!argv) {
290 fprintf(stderr, "Error allocating argument list\n");
291 exit(EXIT_FAILURE);
292 }
293 for (argi = argj = argv; (*argj = *argi); argi += arg.argv_step) {
294 arg.argv_step = 1;
295
296 if (arg_match(&arg, &outputfile, argi)) {
297 app_input->output_filename = arg.val;
298 } else if (arg_match(&arg, &width_arg, argi)) {
299 enc_cfg->
g_w = arg_parse_uint(&arg);
300 } else if (arg_match(&arg, &height_arg, argi)) {
301 enc_cfg->
g_h = arg_parse_uint(&arg);
302 } else if (arg_match(&arg, &timebase_arg, argi)) {
303 enc_cfg->
g_timebase = arg_parse_rational(&arg);
304 } else if (arg_match(&arg, &bitrate_arg, argi)) {
306 } else if (arg_match(&arg, &spatial_layers_arg, argi)) {
308 } else if (arg_match(&arg, &temporal_layers_arg, argi)) {
310 } else if (arg_match(&arg, &speed_arg, argi)) {
311 app_input->speed = arg_parse_uint(&arg);
312 if (app_input->speed > 11) {
313 aom_tools_warn("Mapping speed %d to speed 11.\n", app_input->speed);
314 }
315 } else if (arg_match(&arg, &aqmode_arg, argi)) {
316 app_input->aq_mode = arg_parse_uint(&arg);
317 } else if (arg_match(&arg, &threads_arg, argi)) {
318 enc_cfg->
g_threads = arg_parse_uint(&arg);
319 } else if (arg_match(&arg, &layering_mode_arg, argi)) {
320 app_input->layering_mode = arg_parse_int(&arg);
321 } else if (arg_match(&arg, &kf_dist_arg, argi)) {
324 } else if (arg_match(&arg, &scale_factors_arg, argi)) {
329 die("Failed to parse scale factors: %s\n",
331 }
332 } else if (arg_match(&arg, &min_q_arg, argi)) {
334 } else if (arg_match(&arg, &max_q_arg, argi)) {
336#if CONFIG_AV1_HIGHBITDEPTH
337 } else if (arg_match(&arg, &bitdepth_arg, argi)) {
344 break;
348 break;
349 default:
350 die(
"Error: Invalid bit depth selected (%d)\n", enc_cfg->
g_bit_depth);
351 }
352#endif
353 } else if (arg_match(&arg, &dropframe_thresh_arg, argi)) {
355 } else if (arg_match(&arg, &error_resilient_arg, argi)) {
358 die("Invalid value for error resilient (0, 1): %d.",
360 } else if (arg_match(&arg, &output_obu_arg, argi)) {
361 app_input->output_obu = arg_parse_uint(&arg);
362 if (app_input->output_obu != 0 && app_input->output_obu != 1)
363 die("Invalid value for obu output flag (0, 1): %d.",
364 app_input->output_obu);
365 } else if (arg_match(&arg, &test_decode_arg, argi)) {
366 app_input->decode = arg_parse_uint(&arg);
367 if (app_input->decode != 0 && app_input->decode != 1)
368 die("Invalid value for test decode flag (0, 1): %d.",
369 app_input->decode);
370 } else if (arg_match(&arg, &tune_content_arg, argi)) {
371 app_input->tune_content = arg_parse_enum_or_int(&arg);
372 printf("tune content %d\n", app_input->tune_content);
373 } else if (arg_match(&arg, &psnr_arg, argi)) {
374 app_input->show_psnr = 1;
375 } else {
376 ++argj;
377 }
378 }
379
380
381 for (argi = argj = argv; (*argj = *argi); argi += arg.argv_step) {
382 arg.argv_step = 1;
383 if (arg_match(&arg, &bitrates_arg, argi)) {
388 }
389 } else {
390 ++argj;
391 }
392 }
393
394
395 if (strlen(string_options) > 0)
396 strncpy(app_input->options, string_options, OPTION_BUFFER_SIZE);
397
398
399 for (argi = argv; *argi; ++argi)
400 if (argi[0][0] == '-' && strlen(argi[0]) > 1)
401 die("Error: Unrecognized option %s\n", *argi);
402
403 if (argv[0] == NULL) {
404 usage_exit();
405 }
406
407 app_input->input_ctx.filename = argv[0];
408 free(argv);
409
411 if (app_input->input_ctx.file_type == FILE_TYPE_Y4M) {
412 enc_cfg->
g_w = app_input->input_ctx.width;
413 enc_cfg->
g_h = app_input->input_ctx.height;
414 }
415
416 if (enc_cfg->
g_w < 16 || enc_cfg->
g_w % 2 || enc_cfg->
g_h < 16 ||
418 die(
"Invalid resolution: %d x %d\n", enc_cfg->
g_w, enc_cfg->
g_h);
419
420 printf(
421 "Codec %s\n"
422 "layers: %d\n"
423 "width %u, height: %u\n"
424 "num: %d, den: %d, bitrate: %u\n"
425 "gop size: %u\n",
430}
431
432static int mode_to_num_temporal_layers[11] = {
433 1, 2, 3, 3, 2, 1, 1, 3, 3, 3, 3
434};
435static int mode_to_num_spatial_layers[11] = { 1, 1, 1, 1, 1, 2, 3, 2, 3, 3, 3 };
436
437
438struct RateControlMetrics {
439
441
443
445
447
449
451
453
454
455 double avg_st_encoding_bitrate;
456
457 double variance_st_encoding_bitrate;
458
459 int window_size;
460
461 int window_count;
463};
464
465static const int REF_FRAMES = 8;
466
467static const int INTER_REFS_PER_FRAME = 7;
468
469
470enum {
471 SVC_LAST_FRAME = 0,
472 SVC_LAST2_FRAME,
473 SVC_LAST3_FRAME,
474 SVC_GOLDEN_FRAME,
475 SVC_BWDREF_FRAME,
476 SVC_ALTREF2_FRAME,
477 SVC_ALTREF_FRAME
478};
479
480static int read_frame(
struct AvxInputContext *input_ctx,
aom_image_t *img) {
481 FILE *f = input_ctx->file;
482 y4m_input *y4m = &input_ctx->y4m;
483 int shortread = 0;
484
485 if (input_ctx->file_type == FILE_TYPE_Y4M) {
486 if (y4m_input_fetch_frame(y4m, f, img) < 1) return 0;
487 } else {
488 shortread = read_yuv_frame(input_ctx, img);
489 }
490
491 return !shortread;
492}
493
494static void close_input_file(struct AvxInputContext *input) {
495 fclose(input->file);
496 if (input->file_type == FILE_TYPE_Y4M) y4m_input_close(&input->y4m);
497}
498
499
500
501
502
503
504
505static void set_rate_control_metrics(struct RateControlMetrics *rc,
506 double framerate, int ss_number_layers,
507 int ts_number_layers) {
509 ts_rate_decimator[0] = 1;
510 if (ts_number_layers == 2) {
511 ts_rate_decimator[0] = 2;
512 ts_rate_decimator[1] = 1;
513 }
514 if (ts_number_layers == 3) {
515 ts_rate_decimator[0] = 4;
516 ts_rate_decimator[1] = 2;
517 ts_rate_decimator[2] = 1;
518 }
519
520
521 for (int sl = 0; sl < ss_number_layers; ++sl) {
522 int i = sl * ts_number_layers;
523 rc->layer_framerate[0] = framerate / ts_rate_decimator[0];
524 rc->layer_pfb[i] =
525 1000.0 * rc->layer_target_bitrate[i] / rc->layer_framerate[0];
526 for (int tl = 0; tl < ts_number_layers; ++tl) {
527 i = sl * ts_number_layers + tl;
528 if (tl > 0) {
529 rc->layer_framerate[tl] = framerate / ts_rate_decimator[tl];
530 rc->layer_pfb[i] =
531 1000.0 *
532 (rc->layer_target_bitrate[i] - rc->layer_target_bitrate[i - 1]) /
533 (rc->layer_framerate[tl] - rc->layer_framerate[tl - 1]);
534 }
535 rc->layer_input_frames[tl] = 0;
536 rc->layer_enc_frames[tl] = 0;
537 rc->layer_encoding_bitrate[i] = 0.0;
538 rc->layer_avg_frame_size[i] = 0.0;
539 rc->layer_avg_rate_mismatch[i] = 0.0;
540 }
541 }
542 rc->window_count = 0;
543 rc->window_size = 15;
544 rc->avg_st_encoding_bitrate = 0.0;
545 rc->variance_st_encoding_bitrate = 0.0;
546}
547
548static void printout_rate_control_summary(struct RateControlMetrics *rc,
549 int frame_cnt, int ss_number_layers,
550 int ts_number_layers) {
551 int tot_num_frames = 0;
552 double perc_fluctuation = 0.0;
553 printf("Total number of processed frames: %d\n\n", frame_cnt - 1);
554 printf("Rate control layer stats for %d layer(s):\n\n", ts_number_layers);
555 for (int sl = 0; sl < ss_number_layers; ++sl) {
556 tot_num_frames = 0;
557 for (int tl = 0; tl < ts_number_layers; ++tl) {
558 int i = sl * ts_number_layers + tl;
559 const int num_dropped =
560 tl > 0 ? rc->layer_input_frames[tl] - rc->layer_enc_frames[tl]
561 : rc->layer_input_frames[tl] - rc->layer_enc_frames[tl] - 1;
562 tot_num_frames += rc->layer_input_frames[tl];
563 rc->layer_encoding_bitrate[i] = 0.001 * rc->layer_framerate[tl] *
564 rc->layer_encoding_bitrate[i] /
565 tot_num_frames;
566 rc->layer_avg_frame_size[i] =
567 rc->layer_avg_frame_size[i] / rc->layer_enc_frames[tl];
568 rc->layer_avg_rate_mismatch[i] =
569 100.0 * rc->layer_avg_rate_mismatch[i] / rc->layer_enc_frames[tl];
570 printf("For layer#: %d %d \n", sl, tl);
571 printf("Bitrate (target vs actual): %d %f\n", rc->layer_target_bitrate[i],
572 rc->layer_encoding_bitrate[i]);
573 printf("Average frame size (target vs actual): %f %f\n", rc->layer_pfb[i],
574 rc->layer_avg_frame_size[i]);
575 printf("Average rate_mismatch: %f\n", rc->layer_avg_rate_mismatch[i]);
576 printf(
577 "Number of input frames, encoded (non-key) frames, "
578 "and perc dropped frames: %d %d %f\n",
579 rc->layer_input_frames[tl], rc->layer_enc_frames[tl],
580 100.0 * num_dropped / rc->layer_input_frames[tl]);
581 printf("\n");
582 }
583 }
584 rc->avg_st_encoding_bitrate = rc->avg_st_encoding_bitrate / rc->window_count;
585 rc->variance_st_encoding_bitrate =
586 rc->variance_st_encoding_bitrate / rc->window_count -
587 (rc->avg_st_encoding_bitrate * rc->avg_st_encoding_bitrate);
588 perc_fluctuation = 100.0 * sqrt(rc->variance_st_encoding_bitrate) /
589 rc->avg_st_encoding_bitrate;
590 printf("Short-time stats, for window of %d frames:\n", rc->window_size);
591 printf("Average, rms-variance, and percent-fluct: %f %f %f\n",
592 rc->avg_st_encoding_bitrate, sqrt(rc->variance_st_encoding_bitrate),
593 perc_fluctuation);
594 if (frame_cnt - 1 != tot_num_frames)
595 die("Error: Number of input frames not equal to output!\n");
596}
597
598
599static void set_layer_pattern(
603 int spatial_layer_id, int is_key_frame, int ksvc_mode, int speed) {
604
605
606 int use_rps_example = 0;
607 int i;
608 int enable_longterm_temporal_ref = 1;
609 int shift = (layering_mode == 8) ? 2 : 0;
610 *use_svc_control = 1;
612 int lag_index = 0;
613 int base_count = superframe_cnt >> 2;
617
618
619
620 for (i = 0; i < INTER_REFS_PER_FRAME; i++) ref_frame_config->
ref_idx[i] = i;
621 for (i = 0; i < INTER_REFS_PER_FRAME; i++) ref_frame_config->
reference[i] = 0;
622 for (i = 0; i < REF_FRAMES; i++) ref_frame_config->
refresh[i] = 0;
623
624 if (ksvc_mode) {
625
626
627 layering_mode = 9;
628 }
629 switch (layering_mode) {
630 case 0:
631 if (use_rps_example == 0) {
632
635 ref_frame_config->
refresh[0] = 1;
636 ref_frame_config->
reference[SVC_LAST_FRAME] = 1;
637 } else {
638
639
640
641
642
643 int last_idx = 0;
644 int last_idx_refresh = 0;
645 int gld_idx = 0;
646 int alt_ref_idx = 0;
647 int lag_alt = 4;
648 int lag_gld = 8;
651 int sh = 8;
652
653 if (superframe_cnt > 1) last_idx = (superframe_cnt - 1) % sh;
654
655 last_idx_refresh = superframe_cnt % sh;
656
657 if (superframe_cnt > lag_gld) gld_idx = (superframe_cnt - lag_gld) % sh;
658
659 if (superframe_cnt > lag_alt)
660 alt_ref_idx = (superframe_cnt - lag_alt) % sh;
661
662
663 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
664 ref_frame_config->
ref_idx[i] = last_idx;
665
666 ref_frame_config->
ref_idx[SVC_LAST_FRAME] = last_idx;
667 ref_frame_config->
ref_idx[SVC_LAST2_FRAME] = last_idx_refresh;
668 ref_frame_config->
ref_idx[SVC_GOLDEN_FRAME] = gld_idx;
669 ref_frame_config->
ref_idx[SVC_ALTREF_FRAME] = alt_ref_idx;
670
671 ref_frame_config->
refresh[last_idx_refresh] = 1;
672
673 ref_frame_config->
reference[SVC_LAST_FRAME] = 1;
674 ref_frame_config->
reference[SVC_ALTREF_FRAME] = 1;
675 ref_frame_config->
reference[SVC_GOLDEN_FRAME] = 1;
676
677 if (superframe_cnt % 200 == 0 && superframe_cnt > 0) {
678 ref_frame_config->
reference[SVC_LAST_FRAME] = 0;
679 ref_frame_config->
reference[SVC_ALTREF_FRAME] = 0;
680 ref_frame_config->
reference[SVC_GOLDEN_FRAME] = 1;
681
682
683
684 if (superframe_cnt % 400 == 0 && superframe_cnt > 0) {
685 ref_frame_config->
ref_idx[SVC_LAST_FRAME] = gld_idx;
686 ref_frame_config->
reference[SVC_LAST_FRAME] = 1;
687 ref_frame_config->
reference[SVC_ALTREF_FRAME] = 0;
688 ref_frame_config->
reference[SVC_GOLDEN_FRAME] = 0;
689 }
690 }
691 }
692 break;
693 case 1:
694
695
696
697
698 base_count = superframe_cnt >> 1;
699 ref_frame_config->
ref_idx[SVC_GOLDEN_FRAME] = 3;
700
701 lag_index = 5;
702 if (base_count > 0) {
703 lag_index = 5 + (base_count % 3);
704 if (superframe_cnt % 2 != 0) lag_index = 5 + ((base_count + 1) % 3);
705 }
706
707 ref_frame_config->
ref_idx[SVC_ALTREF_FRAME] = lag_index;
708 if (superframe_cnt % 2 == 0) {
710
711 ref_frame_config->
refresh[0] = 1;
712 ref_frame_config->
reference[SVC_LAST_FRAME] = 1;
713
714 ref_frame_config->
refresh[lag_index] = 1;
715
716 if (base_count % 32 == 0) ref_frame_config->
refresh[3] = 1;
717 } else {
719
720 ref_frame_config->
reference[SVC_LAST_FRAME] = 1;
721 }
722
724 ref_frame_config->
reference[SVC_GOLDEN_FRAME] = 1;
725 ref_frame_config->
reference[SVC_ALTREF_FRAME] = 1;
726 }
727 break;
728 case 2:
729
730
731
732
733 if (superframe_cnt % 4 == 0) {
734
736
737 ref_frame_config->
refresh[0] = 1;
738 ref_frame_config->
reference[SVC_LAST_FRAME] = 1;
739 } else if ((superframe_cnt - 1) % 4 == 0) {
741
742 ref_frame_config->
reference[SVC_LAST_FRAME] = 1;
743 } else if ((superframe_cnt - 2) % 4 == 0) {
745
746 ref_frame_config->
refresh[1] = 1;
747 ref_frame_config->
reference[SVC_LAST_FRAME] = 1;
748 } else if ((superframe_cnt - 3) % 4 == 0) {
750
751
752
753 ref_frame_config->
ref_idx[SVC_LAST_FRAME] = 1;
754 ref_frame_config->
ref_idx[SVC_LAST2_FRAME] = 0;
755 ref_frame_config->
reference[SVC_LAST_FRAME] = 1;
756 }
757 break;
758 case 3:
759
760
761
762
763
764
765
766 ref_frame_config->
ref_idx[SVC_GOLDEN_FRAME] = 3;
767
768 lag_index = 5;
769 if (base_count > 0) {
770 lag_index = 5 + (base_count % 3);
771 if (superframe_cnt % 4 != 0) lag_index = 5 + ((base_count + 1) % 3);
772 }
773
774 ref_frame_config->
ref_idx[SVC_ALTREF_FRAME] = lag_index;
775 if (superframe_cnt % 4 == 0) {
776
778
779 ref_frame_config->
refresh[0] = 1;
780 ref_frame_config->
reference[SVC_LAST_FRAME] = 1;
781
782 if (base_count % 10 == 0) ref_frame_config->
refresh[3] = 1;
783
784 ref_frame_config->
refresh[lag_index] = 1;
785 } else if ((superframe_cnt - 1) % 4 == 0) {
787
788 ref_frame_config->
reference[SVC_LAST_FRAME] = 1;
789 } else if ((superframe_cnt - 2) % 4 == 0) {
791
792 ref_frame_config->
refresh[1] = 1;
793 ref_frame_config->
reference[SVC_LAST_FRAME] = 1;
794 } else if ((superframe_cnt - 3) % 4 == 0) {
796
797
798
799 ref_frame_config->
ref_idx[SVC_LAST_FRAME] = 1;
800 ref_frame_config->
ref_idx[SVC_LAST2_FRAME] = 0;
801 ref_frame_config->
reference[SVC_LAST_FRAME] = 1;
802 }
803
804 ref_frame_config->
reference[SVC_GOLDEN_FRAME] = 1;
805 ref_frame_config->
reference[SVC_ALTREF_FRAME] = 1;
806
807 if (speed >= 7) {
810 }
811 break;
812 case 4:
813
814
815
816
817
818 if (superframe_cnt % 4 == 0) {
819
821
822 ref_frame_config->
refresh[0] = 1;
823 ref_frame_config->
reference[SVC_LAST_FRAME] = 1;
824 } else if ((superframe_cnt - 1) % 4 == 0) {
826
827 ref_frame_config->
reference[SVC_LAST_FRAME] = 1;
828 } else if ((superframe_cnt - 2) % 4 == 0) {
830
831 ref_frame_config->
refresh[3] = 1;
832 ref_frame_config->
reference[SVC_LAST_FRAME] = 1;
833 } else if ((superframe_cnt - 3) % 4 == 0) {
835
836 ref_frame_config->
reference[SVC_GOLDEN_FRAME] = 1;
837 }
838 break;
839 case 5:
840
843
844 ref_frame_config->
refresh[0] = 1;
845 ref_frame_config->
reference[SVC_LAST_FRAME] = 1;
847
848
849 ref_frame_config->
ref_idx[SVC_LAST_FRAME] = 1;
850 ref_frame_config->
ref_idx[SVC_GOLDEN_FRAME] = 0;
851 ref_frame_config->
refresh[1] = 1;
852 ref_frame_config->
reference[SVC_LAST_FRAME] = 1;
853 ref_frame_config->
reference[SVC_GOLDEN_FRAME] = 1;
854 }
855 break;
856 case 6:
857
858
859
860
861
864
865 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
866 ref_frame_config->
ref_idx[i] = 0;
867 ref_frame_config->
refresh[0] = 1;
868 ref_frame_config->
reference[SVC_LAST_FRAME] = 1;
870
871
872
873 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
874 ref_frame_config->
ref_idx[i] = 0;
875 ref_frame_config->
ref_idx[SVC_LAST_FRAME] = 1;
876 ref_frame_config->
refresh[1] = 1;
877 ref_frame_config->
reference[SVC_LAST_FRAME] = 1;
878 ref_frame_config->
reference[SVC_GOLDEN_FRAME] = 1;
880
881
882
883 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
884 ref_frame_config->
ref_idx[i] = 1;
885 ref_frame_config->
ref_idx[SVC_LAST_FRAME] = 2;
886 ref_frame_config->
refresh[2] = 1;
887 ref_frame_config->
reference[SVC_LAST_FRAME] = 1;
888 ref_frame_config->
reference[SVC_GOLDEN_FRAME] = 1;
889
890
891 if (enable_longterm_temporal_ref) {
892 ref_frame_config->
ref_idx[SVC_ALTREF_FRAME] = REF_FRAMES - 1;
893 ref_frame_config->
reference[SVC_ALTREF_FRAME] = 1;
894 if (base_count % 10 == 0)
895 ref_frame_config->
refresh[REF_FRAMES - 1] = 1;
896 }
897 }
898 break;
899 case 7:
900
901 ref_frame_config->
reference[SVC_LAST_FRAME] = 1;
902 if (superframe_cnt % 4 == 0) {
903
906
907
908 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
909 ref_frame_config->
ref_idx[i] = 0;
910 ref_frame_config->
refresh[0] = 1;
912
913 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
914 ref_frame_config->
ref_idx[i] = 0;
915 ref_frame_config->
ref_idx[SVC_LAST_FRAME] = 1;
916 ref_frame_config->
refresh[1] = 1;
917 }
918 } else if ((superframe_cnt - 1) % 4 == 0) {
919
922 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
923 ref_frame_config->
ref_idx[i] = 0;
924 ref_frame_config->
ref_idx[SVC_GOLDEN_FRAME] = 3;
925 ref_frame_config->
refresh[3] = 1;
927
928
929
930 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
931 ref_frame_config->
ref_idx[i] = 3;
932 ref_frame_config->
ref_idx[SVC_LAST_FRAME] = 1;
933 }
934 } else if ((superframe_cnt - 2) % 4 == 0) {
935
938
939
940
941 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
942 ref_frame_config->
ref_idx[i] = 0;
943 ref_frame_config->
ref_idx[SVC_GOLDEN_FRAME] = 5 - shift;
944 ref_frame_config->
refresh[5 - shift] = 1;
946
947
948
949 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
950 ref_frame_config->
ref_idx[i] = 5 - shift;
951 ref_frame_config->
ref_idx[SVC_LAST_FRAME] = 1;
952 ref_frame_config->
ref_idx[SVC_LAST3_FRAME] = 6 - shift;
953 ref_frame_config->
refresh[6 - shift] = 1;
954 }
955 } else if ((superframe_cnt - 3) % 4 == 0) {
956
959
960
961
962 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
963 ref_frame_config->
ref_idx[i] = 0;
964 ref_frame_config->
ref_idx[SVC_LAST_FRAME] = 5 - shift;
965 ref_frame_config->
ref_idx[SVC_GOLDEN_FRAME] = 3;
966 ref_frame_config->
refresh[3] = 1;
968
969
970 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
971 ref_frame_config->
ref_idx[i] = 0;
972 ref_frame_config->
ref_idx[SVC_LAST_FRAME] = 6 - shift;
973 ref_frame_config->
ref_idx[SVC_GOLDEN_FRAME] = 3;
974 }
975 }
976 break;
977 case 8:
978
979
980
981
982
983
984 case 9:
985
986
987
988
989
990 ref_frame_config->
reference[SVC_LAST_FRAME] = 1;
991 if (superframe_cnt % 4 == 0) {
992
995
996
997 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
998 ref_frame_config->
ref_idx[i] = 0;
999 ref_frame_config->
refresh[0] = 1;
1001
1002
1003
1004 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
1005 ref_frame_config->
ref_idx[i] = 0;
1006 ref_frame_config->
ref_idx[SVC_LAST_FRAME] = 1;
1007 ref_frame_config->
refresh[1] = 1;
1009
1010
1011
1012 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
1013 ref_frame_config->
ref_idx[i] = 1;
1014 ref_frame_config->
ref_idx[SVC_LAST_FRAME] = 2;
1015 ref_frame_config->
refresh[2] = 1;
1016 }
1017 } else if ((superframe_cnt - 1) % 4 == 0) {
1018
1021
1022
1023
1024 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
1025 ref_frame_config->
ref_idx[i] = 0;
1026 ref_frame_config->
ref_idx[SVC_GOLDEN_FRAME] = 3;
1027 ref_frame_config->
refresh[3] = 1;
1029
1030
1031
1032 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
1033 ref_frame_config->
ref_idx[i] = 3;
1034 ref_frame_config->
ref_idx[SVC_LAST_FRAME] = 1;
1035 ref_frame_config->
ref_idx[SVC_LAST2_FRAME] = 4;
1036 ref_frame_config->
refresh[4] = 1;
1038
1039
1040
1041 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
1042 ref_frame_config->
ref_idx[i] = 4;
1043 ref_frame_config->
ref_idx[SVC_LAST_FRAME] = 2;
1044 }
1045 } else if ((superframe_cnt - 2) % 4 == 0) {
1046
1049
1050
1051
1052 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
1053 ref_frame_config->
ref_idx[i] = 0;
1054 ref_frame_config->
ref_idx[SVC_GOLDEN_FRAME] = 5 - shift;
1055 ref_frame_config->
refresh[5 - shift] = 1;
1057
1058
1059
1060 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
1061 ref_frame_config->
ref_idx[i] = 5 - shift;
1062 ref_frame_config->
ref_idx[SVC_LAST_FRAME] = 1;
1063 ref_frame_config->
ref_idx[SVC_LAST3_FRAME] = 6 - shift;
1064 ref_frame_config->
refresh[6 - shift] = 1;
1066
1067
1068
1069 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
1070 ref_frame_config->
ref_idx[i] = 6 - shift;
1071 ref_frame_config->
ref_idx[SVC_LAST_FRAME] = 2;
1072 ref_frame_config->
ref_idx[SVC_LAST3_FRAME] = 7 - shift;
1073 ref_frame_config->
refresh[7 - shift] = 1;
1074 }
1075 } else if ((superframe_cnt - 3) % 4 == 0) {
1076
1079
1080
1081
1082 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
1083 ref_frame_config->
ref_idx[i] = 0;
1084 ref_frame_config->
ref_idx[SVC_LAST_FRAME] = 5 - shift;
1085 ref_frame_config->
ref_idx[SVC_GOLDEN_FRAME] = 3;
1086 ref_frame_config->
refresh[3] = 1;
1088
1089
1090 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
1091 ref_frame_config->
ref_idx[i] = 0;
1092 ref_frame_config->
ref_idx[SVC_LAST_FRAME] = 6 - shift;
1093 ref_frame_config->
ref_idx[SVC_GOLDEN_FRAME] = 3;
1094 ref_frame_config->
ref_idx[SVC_LAST2_FRAME] = 4;
1095 ref_frame_config->
refresh[4] = 1;
1097
1098
1099 for (i = 0; i < INTER_REFS_PER_FRAME; i++)
1100 ref_frame_config->
ref_idx[i] = 0;
1101 ref_frame_config->
ref_idx[SVC_LAST_FRAME] = 7 - shift;
1102 ref_frame_config->
ref_idx[SVC_GOLDEN_FRAME] = 4;
1103 }
1104 }
1106
1107 ref_frame_config->
reference[SVC_GOLDEN_FRAME] = 1;
1108 if (ksvc_mode) {
1109
1110
1111 if (!is_key_frame) ref_frame_config->
reference[SVC_GOLDEN_FRAME] = 0;
1112 }
1114
1115
1116 ref_frame_config->
reference[SVC_LAST_FRAME] = 0;
1117 }
1118 }
1119
1120
1121
1122
1124 layering_mode == 8) {
1125 ref_frame_config->
ref_idx[SVC_ALTREF_FRAME] = REF_FRAMES - 1;
1126 if (!is_key_frame) ref_frame_config->
reference[SVC_ALTREF_FRAME] = 1;
1128 ref_frame_config->
refresh[REF_FRAMES - 1] = 1;
1129 }
1130 break;
1131 default: assert(0); die("Error: Unsupported temporal layering mode!\n");
1132 }
1133}
1134
1135#if CONFIG_AV1_DECODER
1136
1137
1139 const int frames_out) {
1141 int mismatch = 0;
1142
1143
1146
1147#if CONFIG_AV1_HIGHBITDEPTH
1153 &enc_hbd_img,
1155 enc_img.
d_w, enc_img.
d_h, 16);
1156 aom_img_truncate_16_to_8(&enc_hbd_img, &enc_img);
1157 enc_img = enc_hbd_img;
1158 }
1162 &dec_hbd_img,
1164 dec_img.
d_w, dec_img.
d_h, 16);
1165 aom_img_truncate_16_to_8(&dec_hbd_img, &dec_img);
1166 dec_img = dec_hbd_img;
1167 }
1168 }
1169#endif
1170
1171 if (!aom_compare_img(&enc_img, &dec_img)) {
1172 int y[4], u[4], v[4];
1173#if CONFIG_AV1_HIGHBITDEPTH
1175 aom_find_mismatch_high(&enc_img, &dec_img, y, u, v);
1176 } else {
1177 aom_find_mismatch(&enc_img, &dec_img, y, u, v);
1178 }
1179#else
1180 aom_find_mismatch(&enc_img, &dec_img, y, u, v);
1181#endif
1182 fprintf(stderr,
1183 "Encode/decode mismatch on frame %d at"
1184 " Y[%d, %d] {%d/%d},"
1185 " U[%d, %d] {%d/%d},"
1186 " V[%d, %d] {%d/%d}\n",
1187 frames_out, y[0], y[1], y[2], y[3], u[0], u[1], u[2], u[3], v[0],
1188 v[1], v[2], v[3]);
1189 mismatch = 1;
1190 }
1191
1194 return mismatch;
1195}
1196#endif
1197
1198struct psnr_stats {
1199
1200 uint64_t psnr_sse_total[2];
1201 uint64_t psnr_samples_total[2];
1202 double psnr_totals[2][4];
1203 int psnr_count[2];
1204};
1205
1206static void show_psnr(struct psnr_stats *psnr_stream, double peak) {
1207 double ovpsnr;
1208
1209 if (!psnr_stream->psnr_count[0]) return;
1210
1211 fprintf(stderr, "\nPSNR (Overall/Avg/Y/U/V)");
1212 ovpsnr = sse_to_psnr((double)psnr_stream->psnr_samples_total[0], peak,
1213 (double)psnr_stream->psnr_sse_total[0]);
1214 fprintf(stderr, " %.3f", ovpsnr);
1215
1216 for (int i = 0; i < 4; i++) {
1217 fprintf(stderr, " %.3f",
1218 psnr_stream->psnr_totals[0][i] / psnr_stream->psnr_count[0]);
1219 }
1220 fprintf(stderr, "\n");
1221}
1222
1223int main(int argc, const char **argv) {
1224 AppInput app_input;
1227 AvxVideoWriter *total_layer_file = NULL;
1228 FILE *total_layer_obu_file = NULL;
1230 int frame_cnt = 0;
1232 int frame_avail;
1233 int got_data = 0;
1234 int flags = 0;
1235 int i;
1236 int pts = 0;
1237 int frame_duration = 1;
1242
1243#if CONFIG_INTERNAL_STATS
1244 FILE *stats_file = fopen("opsnr.stt", "a");
1245 if (stats_file == NULL) {
1246 die("Cannot open opsnr.stt\n");
1247 }
1248#endif
1249#if CONFIG_AV1_DECODER
1251#endif
1252
1253 struct RateControlMetrics rc;
1254 int64_t cx_time = 0;
1257 double sum_bitrate = 0.0;
1258 double sum_bitrate2 = 0.0;
1259 double framerate = 30.0;
1260 int use_svc_control = 1;
1261 int set_err_resil_frame = 0;
1262 int test_changing_bitrate = 0;
1263 zero(rc.layer_target_bitrate);
1265 memset(&app_input, 0, sizeof(AppInput));
1266 memset(&svc_params, 0, sizeof(svc_params));
1267
1268
1269
1270 const int test_dynamic_scaling_single_layer = 0;
1271
1272
1273 const int test_speed_per_layer = 0;
1274
1275
1276 app_input.input_ctx.framerate.numerator = 30;
1277 app_input.input_ctx.framerate.denominator = 1;
1278 app_input.input_ctx.only_i420 = 0;
1280 app_input.speed = 7;
1281 exec_name = argv[0];
1282
1283
1288 }
1289
1290
1292
1304
1305 parse_command_line(argc, argv, &app_input, &svc_params, &cfg);
1306
1309
1310 unsigned int width = cfg.
g_w;
1311 unsigned int height = cfg.
g_h;
1312
1313 if (app_input.layering_mode >= 0) {
1314 if (ts_number_layers !=
1315 mode_to_num_temporal_layers[app_input.layering_mode] ||
1316 ss_number_layers !=
1317 mode_to_num_spatial_layers[app_input.layering_mode]) {
1318 die("Number of layers doesn't match layering mode.");
1319 }
1320 }
1321
1322
1323 if (app_input.input_ctx.file_type != FILE_TYPE_Y4M) {
1325 die("Failed to allocate image (%dx%d)", width, height);
1326 }
1327 }
1328
1330
1333
1334 unsigned int total_rate = 0;
1335 for (i = 0; i < ss_number_layers; i++) {
1336 total_rate +=
1337 svc_params
1339 }
1341 die("Incorrect total target bitrate");
1342 }
1343
1345 if (ts_number_layers == 2) {
1348 } else if (ts_number_layers == 3) {
1352 }
1353
1354 if (app_input.input_ctx.file_type == FILE_TYPE_Y4M) {
1355
1356 cfg.
g_w = app_input.input_ctx.width;
1357 cfg.
g_h = app_input.input_ctx.height;
1358
1359 cfg.
g_timebase.
num = app_input.input_ctx.framerate.denominator;
1360 cfg.
g_timebase.
den = app_input.input_ctx.framerate.numerator;
1361 }
1363 set_rate_control_metrics(&rc, framerate, ss_number_layers, ts_number_layers);
1364
1365 AvxVideoInfo info;
1366 info.codec_fourcc = get_fourcc_by_aom_encoder(encoder);
1367 info.frame_width = cfg.
g_w;
1368 info.frame_height = cfg.
g_h;
1371
1372 for (int sl = 0; sl < ss_number_layers; ++sl) {
1373 for (int tl = 0; tl < ts_number_layers; ++tl) {
1374 i = sl * ts_number_layers + tl;
1375 char file_name[PATH_MAX];
1376 snprintf(file_name, sizeof(file_name), "%s_%d.av1",
1377 app_input.output_filename, i);
1378 if (app_input.output_obu) {
1379 obu_files[i] = fopen(file_name, "wb");
1380 if (!obu_files[i]) die("Failed to open %s for writing", file_name);
1381 } else {
1382 outfile[i] = aom_video_writer_open(file_name, kContainerIVF, &info);
1383 if (!outfile[i]) die("Failed to open %s for writing", file_name);
1384 }
1385 }
1386 }
1387 if (app_input.output_obu) {
1388 total_layer_obu_file = fopen(app_input.output_filename, "wb");
1389 if (!total_layer_obu_file)
1390 die("Failed to open %s for writing", app_input.output_filename);
1391 } else {
1392 total_layer_file =
1393 aom_video_writer_open(app_input.output_filename, kContainerIVF, &info);
1394 if (!total_layer_file)
1395 die("Failed to open %s for writing", app_input.output_filename);
1396 }
1397
1398
1404 die_codec(&codec, "Failed to initialize encoder");
1405
1406#if CONFIG_AV1_DECODER
1407 if (app_input.decode) {
1409 die_codec(&decoder, "Failed to initialize decoder");
1410 }
1411#endif
1412
1429
1430
1436
1440 }
1441
1443 if (app_input.tune_content == AOM_CONTENT_SCREEN) {
1446
1448 }
1449
1452 for (i = 0; i < ss_number_layers * ts_number_layers; ++i) {
1455 }
1456 for (i = 0; i < ss_number_layers; ++i) {
1459 }
1460 if (ss_number_layers == 2) {
1463 } else if (ss_number_layers == 3) {
1468 }
1470
1471
1472
1473
1474
1475 {
1476 const int max_intra_size_pct = 300;
1478 max_intra_size_pct);
1479 }
1480
1481 for (int lx = 0; lx < ts_number_layers * ss_number_layers; lx++) {
1482 cx_time_layer[lx] = 0;
1483 frame_cnt_layer[lx] = 0;
1484 }
1485
1486 frame_avail = 1;
1487 struct psnr_stats psnr_stream;
1488 memset(&psnr_stream, 0, sizeof(psnr_stream));
1489 while (frame_avail || got_data) {
1490 struct aom_usec_timer timer;
1491 frame_avail = read_frame(&(app_input.input_ctx), &raw);
1492
1493 for (int slx = 0; slx < ss_number_layers; slx++) {
1496 int layer = 0;
1497
1498 int is_key_frame = (frame_cnt % cfg.
kf_max_dist) == 0;
1499
1500 if (app_input.layering_mode >= 0) {
1501
1502
1503 set_layer_pattern(app_input.layering_mode, frame_cnt, &layer_id,
1504 &ref_frame_config, &ref_frame_comp_pred,
1505 &use_svc_control, slx, is_key_frame,
1506 (app_input.layering_mode == 10), app_input.speed);
1508 if (use_svc_control) {
1510 &ref_frame_config);
1512 &ref_frame_comp_pred);
1513 }
1514
1515 if (test_speed_per_layer) {
1516 int speed_per_layer = 10;
1529 }
1531 }
1532 } else {
1533
1534
1535
1538 if (ts_number_layers == 2) {
1540 } else if (ts_number_layers == 3) {
1541 if (frame_cnt % 2 != 0)
1543 else if ((frame_cnt > 1) && ((frame_cnt - 2) % 4 == 0))
1545 }
1547 }
1548
1550
1551
1552
1553
1554
1555
1556
1557 const int err_resil_mode =
1560 err_resil_mode);
1561 }
1562
1564 if (frame_avail && slx == 0) ++rc.layer_input_frames[layer];
1565
1566 if (test_dynamic_scaling_single_layer) {
1567
1568
1569 int frame_2x2 = 200;
1570 int frame_4x4 = 400;
1571 int frame_2x2up = 600;
1572 int frame_orig = 800;
1573 if (frame_cnt >= frame_2x2 && frame_cnt < frame_4x4) {
1574
1577 } else if (frame_cnt >= frame_4x4 && frame_cnt < frame_2x2up) {
1578
1581 } else if (frame_cnt >= frame_2x2up && frame_cnt < frame_orig) {
1582
1585 } else if (frame_cnt >= frame_orig) {
1586
1589 }
1590 if (frame_cnt == frame_2x2 || frame_cnt == frame_4x4 ||
1591 frame_cnt == frame_2x2up || frame_cnt == frame_orig) {
1592
1593
1594
1595
1596
1597 for (i = 0; i < REF_FRAMES; i++) ref_frame_config.
refresh[i] = 1;
1598 if (use_svc_control) {
1600 &ref_frame_config);
1602 &ref_frame_comp_pred);
1603 }
1604 }
1605 }
1606
1607
1608 if (test_changing_bitrate && frame_cnt % 2 == 0) {
1609 if (frame_cnt < 500)
1611 else
1613
1617
1618
1621 die_codec(&codec, "Failed to SET_BITRATE_ONE_PASS_CBR");
1622 }
1623
1624
1625 aom_usec_timer_start(&timer);
1627 die_codec(&codec, "Failed to encode frame");
1628 aom_usec_timer_mark(&timer);
1629 cx_time += aom_usec_timer_elapsed(&timer);
1630 cx_time_layer[layer] += aom_usec_timer_elapsed(&timer);
1631 frame_cnt_layer[layer] += 1;
1632
1633 got_data = 0;
1635 switch (pkt->
kind) {
1638 ++sl) {
1640 ++tl) {
1641 int j = sl * ts_number_layers + tl;
1642 if (app_input.output_obu) {
1644 obu_files[j]);
1645 } else {
1646 aom_video_writer_write_frame(
1647 outfile[j],
1648 reinterpret_cast<const uint8_t *
>(pkt->
data.
frame.
buf),
1650 }
1652 rc.layer_encoding_bitrate[j] += 8.0 * pkt->
data.
frame.
sz;
1653 }
1654 }
1655 got_data = 1;
1656
1657 if (app_input.output_obu) {
1659 total_layer_obu_file);
1660 } else {
1661 aom_video_writer_write_frame(
1662 total_layer_file,
1663 reinterpret_cast<const uint8_t *
>(pkt->
data.
frame.
buf),
1665 }
1666
1670 assert(j >= 0);
1671 rc.layer_avg_frame_size[j] += 8.0 * pkt->
data.
frame.
sz;
1672 rc.layer_avg_rate_mismatch[j] +=
1673 fabs(8.0 * pkt->
data.
frame.
sz - rc.layer_pfb[j]) /
1674 rc.layer_pfb[j];
1676 }
1677
1678
1679
1680
1681
1682 if (frame_cnt > rc.window_size && slx == ss_number_layers - 1) {
1683 sum_bitrate += 0.001 * 8.0 * pkt->
data.
frame.
sz * framerate;
1684 rc.window_size = (rc.window_size <= 0) ? 1 : rc.window_size;
1685 if (frame_cnt % rc.window_size == 0) {
1686 rc.window_count += 1;
1687 rc.avg_st_encoding_bitrate += sum_bitrate / rc.window_size;
1688 rc.variance_st_encoding_bitrate +=
1689 (sum_bitrate / rc.window_size) *
1690 (sum_bitrate / rc.window_size);
1691 sum_bitrate = 0.0;
1692 }
1693 }
1694
1695 if (frame_cnt > rc.window_size + rc.window_size / 2 &&
1696 slx == ss_number_layers - 1) {
1697 sum_bitrate2 += 0.001 * 8.0 * pkt->
data.
frame.
sz * framerate;
1698 if (frame_cnt > 2 * rc.window_size &&
1699 frame_cnt % rc.window_size == 0) {
1700 rc.window_count += 1;
1701 rc.avg_st_encoding_bitrate += sum_bitrate2 / rc.window_size;
1702 rc.variance_st_encoding_bitrate +=
1703 (sum_bitrate2 / rc.window_size) *
1704 (sum_bitrate2 / rc.window_size);
1705 sum_bitrate2 = 0.0;
1706 }
1707 }
1708
1709#if CONFIG_AV1_DECODER
1710 if (app_input.decode) {
1712 &decoder,
1713 reinterpret_cast<const uint8_t *
>(pkt->
data.
frame.
buf),
1715 die_codec(&decoder, "Failed to decode frame");
1716 }
1717#endif
1718
1719 break;
1721 if (app_input.show_psnr) {
1722 psnr_stream.psnr_sse_total[0] += pkt->
data.
psnr.sse[0];
1723 psnr_stream.psnr_samples_total[0] += pkt->
data.
psnr.samples[0];
1724 for (int plane = 0; plane < 4; plane++) {
1725 psnr_stream.psnr_totals[0][plane] += pkt->
data.
psnr.psnr[plane];
1726 }
1727 psnr_stream.psnr_count[0]++;
1728 }
1729 break;
1730 default: break;
1731 }
1732 }
1733#if CONFIG_AV1_DECODER
1734 if (got_data && app_input.decode) {
1735
1736
1737 if ((ss_number_layers > 1 || ts_number_layers > 1) &&
1740 if (test_decode(&codec, &decoder, frame_cnt)) {
1741#if CONFIG_INTERNAL_STATS
1742 fprintf(stats_file, "First mismatch occurred in frame %d\n",
1743 frame_cnt);
1744 fclose(stats_file);
1745#endif
1746 fatal("Mismatch seen");
1747 }
1748 }
1749 }
1750#endif
1751 }
1752 ++frame_cnt;
1753 pts += frame_duration;
1754 }
1755
1756 close_input_file(&(app_input.input_ctx));
1757 printout_rate_control_summary(&rc, frame_cnt, ss_number_layers,
1758 ts_number_layers);
1759
1760 printf("\n");
1761 for (int slx = 0; slx < ss_number_layers; slx++)
1762 for (int tlx = 0; tlx < ts_number_layers; tlx++) {
1763 int lx = slx * ts_number_layers + tlx;
1764 printf("Per layer encoding time/FPS stats for encoder: %d %d %d %f %f \n",
1765 slx, tlx, frame_cnt_layer[lx],
1766 (float)cx_time_layer[lx] / (double)(frame_cnt_layer[lx] * 1000),
1767 1000000 * (double)frame_cnt_layer[lx] / (double)cx_time_layer[lx]);
1768 }
1769
1770 printf("\n");
1771 printf("Frame cnt and encoding time/FPS stats for encoding: %d %f %f\n",
1772 frame_cnt, 1000 * (float)cx_time / (double)(frame_cnt * 1000000),
1773 1000000 * (double)frame_cnt / (double)cx_time);
1774
1775 if (app_input.show_psnr) {
1776 show_psnr(&psnr_stream, 255.0);
1777 }
1778
1780
1781#if CONFIG_AV1_DECODER
1782 if (app_input.decode) {
1784 die_codec(&decoder, "Failed to destroy decoder");
1785 }
1786#endif
1787
1788#if CONFIG_INTERNAL_STATS
1789 fprintf(stats_file, "No mismatch detected in recon buffers\n");
1790 fclose(stats_file);
1791#endif
1792
1793
1794 for (i = 0; i < ss_number_layers * ts_number_layers; ++i)
1795 aom_video_writer_close(outfile[i]);
1796 aom_video_writer_close(total_layer_file);
1797
1798 if (app_input.input_ctx.file_type != FILE_TYPE_Y4M) {
1800 }
1801 return EXIT_SUCCESS;
1802}
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.
#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.
struct aom_image aom_image_t
Image Descriptor.
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:1650
struct aom_svc_params aom_svc_params_t
#define AOM_MAX_TS_LAYERS
Definition aomcx.h:1652
aom_codec_iface_t * aom_codec_av1_cx(void)
The interface to the AV1 encoder.
struct aom_svc_layer_id aom_svc_layer_id_t
struct aom_svc_ref_frame_comp_pred aom_svc_ref_frame_comp_pred_t
struct aom_svc_ref_frame_config aom_svc_ref_frame_config_t
@ 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_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_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_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
struct aom_codec_ctx aom_codec_ctx_t
Codec context structure.
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.
struct aom_codec_cx_pkt aom_codec_cx_pkt_t
Encoder output packet.
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.
struct aom_codec_enc_cfg aom_codec_enc_cfg_t
Encoder configuration structure.
#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
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::@202210014045072156205127107315337341215221351166 data
aom_codec_frame_flags_t flags
Definition aom_encoder.h:130
struct aom_codec_cx_pkt::@202210014045072156205127107315337341215221351166::@052232317104146204273007241322037340334334344046 frame
void * buf
Definition aom_encoder.h:124
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
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:1596
int temporal_layer_id
Definition aomcx.h:1657
int spatial_layer_id
Definition aomcx.h:1656
int max_quantizers[32]
Definition aomcx.h:1669
int number_spatial_layers
Definition aomcx.h:1667
int layer_target_bitrate[32]
Definition aomcx.h:1674
int framerate_factor[8]
Definition aomcx.h:1676
int min_quantizers[32]
Definition aomcx.h:1670
int scaling_factor_den[4]
Definition aomcx.h:1672
int number_temporal_layers
Definition aomcx.h:1668
int scaling_factor_num[4]
Definition aomcx.h:1671
int use_comp_pred[3]
Definition aomcx.h:1693
int reference[7]
Definition aomcx.h:1683
int refresh[8]
Definition aomcx.h:1686
int ref_idx[7]
Definition aomcx.h:1685