1 /*
2 * Copyright (c) 2016, Alliance for Open Media. All rights reserved
3 *
4 * This source code is subject to the terms of the BSD 2 Clause License and
5 * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
6 * was not distributed with this source code in the LICENSE file, you can
7 * obtain it at www.aomedia.org/license/software. If the Alliance for Open
8 * Media Patent License 1.0 was not distributed with this source code in the
9 * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
10 */
11
12 /*!\file
13 * \brief Declares top-level encoder structures and functions.
14 */
15 #ifndef AOM_AV1_ENCODER_ENCODER_H_
16 #define AOM_AV1_ENCODER_ENCODER_H_
17
18 #include <stdbool.h>
19 #include <stdio.h>
20
21 #include "config/aom_config.h"
22
23 #include "aom/aomcx.h"
24
25 #include "av1/common/alloccommon.h"
26 #include "av1/common/av1_common_int.h"
27 #include "av1/common/blockd.h"
28 #include "av1/common/entropymode.h"
29 #include "av1/common/enums.h"
30 #include "av1/common/resize.h"
31 #include "av1/common/thread_common.h"
32 #include "av1/common/timing.h"
33 #include "av1/encoder/aq_cyclicrefresh.h"
34 #include "av1/encoder/av1_quantize.h"
35 #include "av1/encoder/block.h"
36 #include "av1/encoder/context_tree.h"
37 #include "av1/encoder/encodemb.h"
38 #include "av1/encoder/firstpass.h"
39 #include "av1/encoder/global_motion.h"
40 #include "av1/encoder/level.h"
41 #include "av1/encoder/lookahead.h"
42 #include "av1/encoder/mcomp.h"
43 #include "av1/encoder/pickcdef.h"
44 #include "av1/encoder/ratectrl.h"
45 #include "av1/encoder/rd.h"
46 #include "av1/encoder/speed_features.h"
47 #include "av1/encoder/svc_layercontext.h"
48 #include "av1/encoder/temporal_filter.h"
49 #include "av1/encoder/tokenize.h"
50 #include "av1/encoder/tpl_model.h"
51 #include "av1/encoder/av1_noise_estimate.h"
52
53 #if CONFIG_INTERNAL_STATS
54 #include "aom_dsp/ssim.h"
55 #endif
56 #include "aom_dsp/variance.h"
57 #if CONFIG_DENOISE
58 #include "aom_dsp/noise_model.h"
59 #endif
60 #if CONFIG_TUNE_VMAF
61 #include "av1/encoder/tune_vmaf.h"
62 #endif
63 #if CONFIG_AV1_TEMPORAL_DENOISING
64 #include "av1/encoder/av1_temporal_denoiser.h"
65 #endif
66
67 #include "aom/internal/aom_codec_internal.h"
68 #include "aom_util/aom_thread.h"
69
70 #ifdef __cplusplus
71 extern "C" {
72 #endif
73
74 // TODO(yunqing, any): Added suppression tag to quiet Doxygen warnings. Need to
75 // adjust it while we work on documentation.
76 /*!\cond */
77 // Number of frames required to test for scene cut detection
78 #define SCENE_CUT_KEY_TEST_INTERVAL 16
79
80 // Rational number with an int64 numerator
81 // This structure holds a fractional value
82 typedef struct aom_rational64 {
83 int64_t num; // fraction numerator
84 int den; // fraction denominator
85 } aom_rational64_t; // alias for struct aom_rational
86
87 enum {
88 NORMAL = 0,
89 FOURFIVE = 1,
90 THREEFIVE = 2,
91 THREEFOUR = 3,
92 ONEFOUR = 4,
93 ONEEIGHT = 5,
94 ONETWO = 6
95 } UENUM1BYTE(AOM_SCALING);
96
97 enum {
98 // Good Quality Fast Encoding. The encoder balances quality with the amount of
99 // time it takes to encode the output. Speed setting controls how fast.
100 GOOD,
101 // Realtime Fast Encoding. Will force some restrictions on bitrate
102 // constraints.
103 REALTIME
104 } UENUM1BYTE(MODE);
105
106 enum {
107 FRAMEFLAGS_KEY = 1 << 0,
108 FRAMEFLAGS_GOLDEN = 1 << 1,
109 FRAMEFLAGS_BWDREF = 1 << 2,
110 // TODO(zoeliu): To determine whether a frame flag is needed for ALTREF2_FRAME
111 FRAMEFLAGS_ALTREF = 1 << 3,
112 FRAMEFLAGS_INTRAONLY = 1 << 4,
113 FRAMEFLAGS_SWITCH = 1 << 5,
114 FRAMEFLAGS_ERROR_RESILIENT = 1 << 6,
115 } UENUM1BYTE(FRAMETYPE_FLAGS);
116
117 enum {
118 NO_AQ = 0,
119 VARIANCE_AQ = 1,
120 COMPLEXITY_AQ = 2,
121 CYCLIC_REFRESH_AQ = 3,
122 AQ_MODE_COUNT // This should always be the last member of the enum
123 } UENUM1BYTE(AQ_MODE);
124 enum {
125 NO_DELTA_Q = 0,
126 DELTA_Q_OBJECTIVE = 1, // Modulation to improve objective quality
127 DELTA_Q_PERCEPTUAL = 2, // Modulation to improve perceptual quality
128 DELTA_Q_MODE_COUNT // This should always be the last member of the enum
129 } UENUM1BYTE(DELTAQ_MODE);
130
131 enum {
132 RESIZE_NONE = 0, // No frame resizing allowed.
133 RESIZE_FIXED = 1, // All frames are coded at the specified scale.
134 RESIZE_RANDOM = 2, // All frames are coded at a random scale.
135 RESIZE_DYNAMIC = 3, // Frames coded at lower scale based on rate control.
136 RESIZE_MODES
137 } UENUM1BYTE(RESIZE_MODE);
138
139 enum {
140 SS_CFG_SRC = 0,
141 SS_CFG_LOOKAHEAD = 1,
142 SS_CFG_FPF = 2,
143 SS_CFG_TOTAL = 3
144 } UENUM1BYTE(SS_CFG_OFFSET);
145
146 enum {
147 DISABLE_SCENECUT, // For LAP, lag_in_frames < 19
148 ENABLE_SCENECUT_MODE_1, // For LAP, lag_in_frames >=19 and < 33
149 ENABLE_SCENECUT_MODE_2 // For twopass and LAP - lag_in_frames >=33
150 } UENUM1BYTE(SCENECUT_MODE);
151
152 #define MAX_VBR_CORPUS_COMPLEXITY 10000
153
154 /*!\cond */
155
156 typedef enum {
157 COST_UPD_SB,
158 COST_UPD_SBROW,
159 COST_UPD_TILE,
160 COST_UPD_OFF,
161 } COST_UPDATE_TYPE;
162
163 typedef enum {
164 MOD_FP, // First pass
165 MOD_TF, // Temporal filtering
166 MOD_TPL, // TPL
167 MOD_GME, // Global motion estimation
168 MOD_ENC, // Encode stage
169 MOD_LPF, // Deblocking loop filter
170 MOD_CDEF_SEARCH, // CDEF search
171 MOD_LR, // Loop restoration filtering
172 NUM_MT_MODULES
173 } MULTI_THREADED_MODULES;
174
175 /*!\endcond */
176
177 /*!
178 * \brief Encoder config related to resize.
179 */
180 typedef struct {
181 /*!
182 * Indicates the frame resize mode to be used by the encoder.
183 */
184 RESIZE_MODE resize_mode;
185 /*!
186 * Indicates the denominator for resize of inter frames, assuming 8 as the
187 * numerator. Its value ranges between 8-16.
188 */
189 uint8_t resize_scale_denominator;
190 /*!
191 * Indicates the denominator for resize of key frames, assuming 8 as the
192 * numerator. Its value ranges between 8-16.
193 */
194 uint8_t resize_kf_scale_denominator;
195 } ResizeCfg;
196
197 /*!
198 * \brief Encoder config for coding block partitioning.
199 */
200 typedef struct {
201 /*!
202 * Flag to indicate if rectanguar partitions should be enabled.
203 */
204 bool enable_rect_partitions;
205 /*!
206 * Flag to indicate if AB partitions should be enabled.
207 */
208 bool enable_ab_partitions;
209 /*!
210 * Flag to indicate if 1:4 / 4:1 partitions should be enabled.
211 */
212 bool enable_1to4_partitions;
213 /*!
214 * Indicates the minimum partition size that should be allowed. Both width and
215 * height of a partition cannot be smaller than the min_partition_size.
216 */
217 BLOCK_SIZE min_partition_size;
218 /*!
219 * Indicates the maximum partition size that should be allowed. Both width and
220 * height of a partition cannot be larger than the max_partition_size.
221 */
222 BLOCK_SIZE max_partition_size;
223 } PartitionCfg;
224
225 /*!
226 * \brief Encoder flags for intra prediction.
227 */
228 typedef struct {
229 /*!
230 * Flag to indicate if intra edge filtering process should be enabled.
231 */
232 bool enable_intra_edge_filter;
233 /*!
234 * Flag to indicate if recursive filtering based intra prediction should be
235 * enabled.
236 */
237 bool enable_filter_intra;
238 /*!
239 * Flag to indicate if smooth intra prediction modes should be enabled.
240 */
241 bool enable_smooth_intra;
242 /*!
243 * Flag to indicate if PAETH intra prediction mode should be enabled.
244 */
245 bool enable_paeth_intra;
246 /*!
247 * Flag to indicate if CFL uv intra mode should be enabled.
248 */
249 bool enable_cfl_intra;
250 /*!
251 * Flag to indicate if delta angles for directional intra prediction should be
252 * enabled.
253 */
254 bool enable_angle_delta;
255 } IntraModeCfg;
256
257 /*!
258 * \brief Encoder flags for transform sizes and types.
259 */
260 typedef struct {
261 /*!
262 * Flag to indicate if 64-pt transform should be enabled.
263 */
264 bool enable_tx64;
265 /*!
266 * Flag to indicate if flip and identity transform types should be enabled.
267 */
268 bool enable_flip_idtx;
269 /*!
270 * Flag to indicate if rectangular transform should be enabled.
271 */
272 bool enable_rect_tx;
273 /*!
274 * Flag to indicate whether or not to use a default reduced set for ext-tx
275 * rather than the potential full set of 16 transforms.
276 */
277 bool reduced_tx_type_set;
278 /*!
279 * Flag to indicate if transform type for intra blocks should be limited to
280 * DCT_DCT.
281 */
282 bool use_intra_dct_only;
283 /*!
284 * Flag to indicate if transform type for inter blocks should be limited to
285 * DCT_DCT.
286 */
287 bool use_inter_dct_only;
288 /*!
289 * Flag to indicate if intra blocks should use default transform type
290 * (mode-dependent) only.
291 */
292 bool use_intra_default_tx_only;
293 } TxfmSizeTypeCfg;
294
295 /*!
296 * \brief Encoder flags for compound prediction modes.
297 */
298 typedef struct {
299 /*!
300 * Flag to indicate if distance-weighted compound type should be enabled.
301 */
302 bool enable_dist_wtd_comp;
303 /*!
304 * Flag to indicate if masked (wedge/diff-wtd) compound type should be
305 * enabled.
306 */
307 bool enable_masked_comp;
308 /*!
309 * Flag to indicate if smooth interintra mode should be enabled.
310 */
311 bool enable_smooth_interintra;
312 /*!
313 * Flag to indicate if difference-weighted compound type should be enabled.
314 */
315 bool enable_diff_wtd_comp;
316 /*!
317 * Flag to indicate if inter-inter wedge compound type should be enabled.
318 */
319 bool enable_interinter_wedge;
320 /*!
321 * Flag to indicate if inter-intra wedge compound type should be enabled.
322 */
323 bool enable_interintra_wedge;
324 } CompoundTypeCfg;
325
326 /*!
327 * \brief Encoder config related to frame super-resolution.
328 */
329 typedef struct {
330 /*!
331 * Indicates the qindex based threshold to be used when AOM_SUPERRES_QTHRESH
332 * mode is used for inter frames.
333 */
334 int superres_qthresh;
335 /*!
336 * Indicates the qindex based threshold to be used when AOM_SUPERRES_QTHRESH
337 * mode is used for key frames.
338 */
339 int superres_kf_qthresh;
340 /*!
341 * Indicates the denominator of the fraction that specifies the ratio between
342 * the superblock width before and after upscaling for inter frames. The
343 * numerator of this fraction is equal to the constant SCALE_NUMERATOR.
344 */
345 uint8_t superres_scale_denominator;
346 /*!
347 * Indicates the denominator of the fraction that specifies the ratio between
348 * the superblock width before and after upscaling for key frames. The
349 * numerator of this fraction is equal to the constant SCALE_NUMERATOR.
350 */
351 uint8_t superres_kf_scale_denominator;
352 /*!
353 * Indicates the Super-resolution mode to be used by the encoder.
354 */
355 aom_superres_mode superres_mode;
356 /*!
357 * Flag to indicate if super-resolution should be enabled for the sequence.
358 */
359 bool enable_superres;
360 } SuperResCfg;
361
362 /*!
363 * \brief Encoder config related to the coding of key frames.
364 */
365 typedef struct {
366 /*!
367 * Indicates the minimum distance to a key frame.
368 */
369 int key_freq_min;
370
371 /*!
372 * Indicates the maximum distance to a key frame.
373 */
374 int key_freq_max;
375
376 /*!
377 * Indicates if temporal filtering should be applied on keyframe.
378 */
379 int enable_keyframe_filtering;
380
381 /*!
382 * Indicates the number of frames after which a frame may be coded as an
383 * S-Frame.
384 */
385 int sframe_dist;
386
387 /*!
388 * Indicates how an S-Frame should be inserted.
389 * 1: the considered frame will be made into an S-Frame only if it is an
390 * altref frame. 2: the next altref frame will be made into an S-Frame.
391 */
392 int sframe_mode;
393
394 /*!
395 * Indicates if encoder should autodetect cut scenes and set the keyframes.
396 */
397 bool auto_key;
398
399 /*!
400 * Indicates if forward keyframe reference should be enabled.
401 */
402 bool fwd_kf_enabled;
403
404 /*!
405 * Indicates if S-Frames should be enabled for the sequence.
406 */
407 bool enable_sframe;
408
409 /*!
410 * Indicates if intra block copy prediction mode should be enabled or not.
411 */
412 bool enable_intrabc;
413 } KeyFrameCfg;
414
415 /*!
416 * \brief Encoder rate control configuration parameters
417 */
418 typedef struct {
419 /*!\cond */
420 // BUFFERING PARAMETERS
421 /*!\endcond */
422 /*!
423 * Indicates the amount of data that will be buffered by the decoding
424 * application prior to beginning playback, and is expressed in units of
425 * time(milliseconds).
426 */
427 int64_t starting_buffer_level_ms;
428 /*!
429 * Indicates the amount of data that the encoder should try to maintain in the
430 * decoder's buffer, and is expressed in units of time(milliseconds).
431 */
432 int64_t optimal_buffer_level_ms;
433 /*!
434 * Indicates the maximum amount of data that may be buffered by the decoding
435 * application, and is expressed in units of time(milliseconds).
436 */
437 int64_t maximum_buffer_size_ms;
438
439 /*!
440 * Indicates the bandwidth to be used in bits per second.
441 */
442 int64_t target_bandwidth;
443
444 /*!
445 * Indicates average complexity of the corpus in single pass vbr based on
446 * LAP. 0 indicates that corpus complexity vbr mode is disabled.
447 */
448 unsigned int vbr_corpus_complexity_lap;
449 /*!
450 * Indicates the maximum allowed bitrate for any intra frame as % of bitrate
451 * target.
452 */
453 unsigned int max_intra_bitrate_pct;
454 /*!
455 * Indicates the maximum allowed bitrate for any inter frame as % of bitrate
456 * target.
457 */
458 unsigned int max_inter_bitrate_pct;
459 /*!
460 * Indicates the percentage of rate boost for golden frame in CBR mode.
461 */
462 unsigned int gf_cbr_boost_pct;
463 /*!
464 * min_cr / 100 indicates the target minimum compression ratio for each
465 * frame.
466 */
467 unsigned int min_cr;
468 /*!
469 * Indicates the frame drop threshold.
470 */
471 int drop_frames_water_mark;
472 /*!
473 * under_shoot_pct indicates the tolerance of the VBR algorithm to
474 * undershoot and is used as a trigger threshold for more agressive
475 * adaptation of Q. It's value can range from 0-100.
476 */
477 int under_shoot_pct;
478 /*!
479 * over_shoot_pct indicates the tolerance of the VBR algorithm to overshoot
480 * and is used as a trigger threshold for more agressive adaptation of Q.
481 * It's value can range from 0-1000.
482 */
483 int over_shoot_pct;
484 /*!
485 * Indicates the maximum qindex that can be used by the quantizer i.e. the
486 * worst quality qindex.
487 */
488 int worst_allowed_q;
489 /*!
490 * Indicates the minimum qindex that can be used by the quantizer i.e. the
491 * best quality qindex.
492 */
493 int best_allowed_q;
494 /*!
495 * Indicates the Constant/Constrained Quality level.
496 */
497 int cq_level;
498 /*!
499 * Indicates if the encoding mode is vbr, cbr, constrained quality or
500 * constant quality.
501 */
502 enum aom_rc_mode mode;
503 /*!
504 * Indicates the bias (expressed on a scale of 0 to 100) for determining
505 * target size for the current frame. The value 0 indicates the optimal CBR
506 * mode value should be used, and 100 indicates the optimal VBR mode value
507 * should be used.
508 */
509 int vbrbias;
510 /*!
511 * Indicates the minimum bitrate to be used for a single frame as a percentage
512 * of the target bitrate.
513 */
514 int vbrmin_section;
515 /*!
516 * Indicates the maximum bitrate to be used for a single frame as a percentage
517 * of the target bitrate.
518 */
519 int vbrmax_section;
520 } RateControlCfg;
521
522 /*!\cond */
523 typedef struct {
524 // Indicates the number of frames lag before encoding is started.
525 int lag_in_frames;
526 // Indicates the minimum gf/arf interval to be used.
527 int min_gf_interval;
528 // Indicates the maximum gf/arf interval to be used.
529 int max_gf_interval;
530 // Indicates the minimum height for GF group pyramid structure to be used.
531 int gf_min_pyr_height;
532 // Indicates the maximum height for GF group pyramid structure to be used.
533 int gf_max_pyr_height;
534 // Indicates if automatic set and use of altref frames should be enabled.
535 bool enable_auto_arf;
536 // Indicates if automatic set and use of (b)ackward (r)ef (f)rames should be
537 // enabled.
538 bool enable_auto_brf;
539 } GFConfig;
540
541 typedef struct {
542 // Indicates the number of tile groups.
543 unsigned int num_tile_groups;
544 // Indicates the MTU size for a tile group. If mtu is non-zero,
545 // num_tile_groups is set to DEFAULT_MAX_NUM_TG.
546 unsigned int mtu;
547 // Indicates the number of tile columns in log2.
548 int tile_columns;
549 // Indicates the number of tile rows in log2.
550 int tile_rows;
551 // Indicates the number of widths in the tile_widths[] array.
552 int tile_width_count;
553 // Indicates the number of heights in the tile_heights[] array.
554 int tile_height_count;
555 // Indicates the tile widths, and may be empty.
556 int tile_widths[MAX_TILE_COLS];
557 // Indicates the tile heights, and may be empty.
558 int tile_heights[MAX_TILE_ROWS];
559 // Indicates if large scale tile coding should be used.
560 bool enable_large_scale_tile;
561 // Indicates if single tile decoding mode should be enabled.
562 bool enable_single_tile_decoding;
563 // Indicates if EXT_TILE_DEBUG should be enabled.
564 bool enable_ext_tile_debug;
565 } TileConfig;
566
567 typedef struct {
568 // Indicates the width of the input frame.
569 int width;
570 // Indicates the height of the input frame.
571 int height;
572 // If forced_max_frame_width is non-zero then it is used to force the maximum
573 // frame width written in write_sequence_header().
574 int forced_max_frame_width;
575 // If forced_max_frame_width is non-zero then it is used to force the maximum
576 // frame height written in write_sequence_header().
577 int forced_max_frame_height;
578 // Indicates the frame width after applying both super-resolution and resize
579 // to the coded frame.
580 int render_width;
581 // Indicates the frame height after applying both super-resolution and resize
582 // to the coded frame.
583 int render_height;
584 } FrameDimensionCfg;
585
586 typedef struct {
587 // Indicates if warped motion should be enabled.
588 bool enable_warped_motion;
589 // Indicates if warped motion should be evaluated or not.
590 bool allow_warped_motion;
591 // Indicates if OBMC motion should be enabled.
592 bool enable_obmc;
593 } MotionModeCfg;
594
595 typedef struct {
596 // Timing info for each frame.
597 aom_timing_info_t timing_info;
598 // Indicates the number of time units of a decoding clock.
599 uint32_t num_units_in_decoding_tick;
600 // Indicates if decoder model information is present in the coded sequence
601 // header.
602 bool decoder_model_info_present_flag;
603 // Indicates if display model information is present in the coded sequence
604 // header.
605 bool display_model_info_present_flag;
606 // Indicates if timing info for each frame is present.
607 bool timing_info_present;
608 } DecoderModelCfg;
609
610 typedef struct {
611 // Indicates the update frequency for coeff costs.
612 COST_UPDATE_TYPE coeff;
613 // Indicates the update frequency for mode costs.
614 COST_UPDATE_TYPE mode;
615 // Indicates the update frequency for mv costs.
616 COST_UPDATE_TYPE mv;
617 } CostUpdateFreq;
618
619 typedef struct {
620 // Indicates the maximum number of reference frames allowed per frame.
621 unsigned int max_reference_frames;
622 // Indicates if the reduced set of references should be enabled.
623 bool enable_reduced_reference_set;
624 // Indicates if one-sided compound should be enabled.
625 bool enable_onesided_comp;
626 } RefFrameCfg;
627
628 typedef struct {
629 // Indicates the color space that should be used.
630 aom_color_primaries_t color_primaries;
631 // Indicates the characteristics of transfer function to be used.
632 aom_transfer_characteristics_t transfer_characteristics;
633 // Indicates the matrix coefficients to be used for the transfer function.
634 aom_matrix_coefficients_t matrix_coefficients;
635 // Indicates the chroma 4:2:0 sample position info.
636 aom_chroma_sample_position_t chroma_sample_position;
637 // Indicates if a limited color range or full color range should be used.
638 aom_color_range_t color_range;
639 } ColorCfg;
640
641 typedef struct {
642 // Indicates if extreme motion vector unit test should be enabled or not.
643 unsigned int motion_vector_unit_test;
644 // Indicates if superblock multipass unit test should be enabled or not.
645 unsigned int sb_multipass_unit_test;
646 } UnitTestCfg;
647
648 typedef struct {
649 // Indicates the file path to the VMAF model.
650 const char *vmaf_model_path;
651 // Indicates the path to the film grain parameters.
652 const char *film_grain_table_filename;
653 // Indicates the visual tuning metric.
654 aom_tune_metric tuning;
655 // Indicates if the current content is screen or default type.
656 aom_tune_content content;
657 // Indicates the film grain parameters.
658 int film_grain_test_vector;
659 } TuneCfg;
660
661 typedef struct {
662 // Indicates the framerate of the input video.
663 double init_framerate;
664 // Indicates the bit-depth of the input video.
665 unsigned int input_bit_depth;
666 // Indicates the maximum number of frames to be encoded.
667 unsigned int limit;
668 // Indicates the chrome subsampling x value.
669 unsigned int chroma_subsampling_x;
670 // Indicates the chrome subsampling y value.
671 unsigned int chroma_subsampling_y;
672 } InputCfg;
673
674 typedef struct {
675 // List of QP offsets for: keyframe, ALTREF, and 3 levels of internal ARFs.
676 // If any of these values are negative, fixed offsets are disabled.
677 // Uses internal q range.
678 double fixed_qp_offsets[FIXED_QP_OFFSET_COUNT];
679 // If true, encoder will use fixed QP offsets, that are either:
680 // - Given by the user, and stored in 'fixed_qp_offsets' array, OR
681 // - Picked automatically from cq_level.
682 int use_fixed_qp_offsets;
683 // Indicates the minimum flatness of the quantization matrix.
684 int qm_minlevel;
685 // Indicates the maximum flatness of the quantization matrix.
686 int qm_maxlevel;
687 // Indicates if adaptive quantize_b should be enabled.
688 int quant_b_adapt;
689 // Indicates the Adaptive Quantization mode to be used.
690 AQ_MODE aq_mode;
691 // Indicates the delta q mode to be used.
692 DELTAQ_MODE deltaq_mode;
693 // Indicates if delta quantization should be enabled in chroma planes.
694 bool enable_chroma_deltaq;
695 // Indicates if encoding with quantization matrices should be enabled.
696 bool using_qm;
697 } QuantizationCfg;
698
699 /*!\endcond */
700 /*!
701 * \brief Algorithm configuration parameters.
702 */
703 typedef struct {
704 /*!
705 * Indicates the loop filter sharpness.
706 */
707 int sharpness;
708
709 /*!
710 * Indicates the trellis optimization mode of quantized coefficients.
711 * 0: disabled
712 * 1: enabled
713 * 2: enabled for rd search
714 * 3: true for estimate yrd search
715 */
716 int disable_trellis_quant;
717
718 /*!
719 * The maximum number of frames used to create an arf.
720 */
721 int arnr_max_frames;
722
723 /*!
724 * The temporal filter strength for arf used when creating ARFs.
725 */
726 int arnr_strength;
727
728 /*!
729 * Indicates the CDF update mode
730 * 0: no update
731 * 1: update on every frame(default)
732 * 2: selectively update
733 */
734 uint8_t cdf_update_mode;
735
736 /*!
737 * Indicates if RDO based on frame temporal dependency should be enabled.
738 */
739 bool enable_tpl_model;
740
741 /*!
742 * Indicates if coding of overlay frames for filtered ALTREF frames is
743 * enabled.
744 */
745 bool enable_overlay;
746 } AlgoCfg;
747 /*!\cond */
748
749 typedef struct {
750 // Indicates the codec bit-depth.
751 aom_bit_depth_t bit_depth;
752 // Indicates the superblock size that should be used by the encoder.
753 aom_superblock_size_t superblock_size;
754 // Indicates if loopfilter modulation should be enabled.
755 bool enable_deltalf_mode;
756 // Indicates if CDEF should be enabled.
757 bool enable_cdef;
758 // Indicates if loop restoration filter should be enabled.
759 bool enable_restoration;
760 // When enabled, video mode should be used even for single frame input.
761 bool force_video_mode;
762 // Indicates if the error resiliency features should be enabled.
763 bool error_resilient_mode;
764 // Indicates if frame parallel decoding feature should be enabled.
765 bool frame_parallel_decoding_mode;
766 // Indicates if the input should be encoded as monochrome.
767 bool enable_monochrome;
768 // When enabled, the encoder will use a full header even for still pictures.
769 // When disabled, a reduced header is used for still pictures.
770 bool full_still_picture_hdr;
771 // Indicates if dual interpolation filters should be enabled.
772 bool enable_dual_filter;
773 // Indicates if frame order hint should be enabled or not.
774 bool enable_order_hint;
775 // Indicates if ref_frame_mvs should be enabled at the sequence level.
776 bool ref_frame_mvs_present;
777 // Indicates if ref_frame_mvs should be enabled at the frame level.
778 bool enable_ref_frame_mvs;
779 // Indicates if interintra compound mode is enabled.
780 bool enable_interintra_comp;
781 // Indicates if global motion should be enabled.
782 bool enable_global_motion;
783 // Indicates if palette should be enabled.
784 bool enable_palette;
785 } ToolCfg;
786
787 /*!\endcond */
788 /*!
789 * \brief Main encoder configuration data structure.
790 */
791 typedef struct AV1EncoderConfig {
792 /*!\cond */
793 // Configuration related to the input video.
794 InputCfg input_cfg;
795
796 // Configuration related to frame-dimensions.
797 FrameDimensionCfg frm_dim_cfg;
798
799 /*!\endcond */
800 /*!
801 * Encoder algorithm configuration.
802 */
803 AlgoCfg algo_cfg;
804
805 /*!
806 * Configuration related to key-frames.
807 */
808 KeyFrameCfg kf_cfg;
809
810 /*!
811 * Rate control configuration
812 */
813 RateControlCfg rc_cfg;
814 /*!\cond */
815
816 // Configuration related to Quantization.
817 QuantizationCfg q_cfg;
818
819 // Internal frame size scaling.
820 ResizeCfg resize_cfg;
821
822 // Frame Super-Resolution size scaling.
823 SuperResCfg superres_cfg;
824
825 /*!\endcond */
826 /*!
827 * stats_in buffer contains all of the stats packets produced in the first
828 * pass, concatenated.
829 */
830 aom_fixed_buf_t twopass_stats_in;
831 /*!\cond */
832
833 // Configuration related to encoder toolsets.
834 ToolCfg tool_cfg;
835
836 // Configuration related to Group of frames.
837 GFConfig gf_cfg;
838
839 // Tile related configuration parameters.
840 TileConfig tile_cfg;
841
842 // Configuration related to Tune.
843 TuneCfg tune_cfg;
844
845 // Configuration related to color.
846 ColorCfg color_cfg;
847
848 // Configuration related to decoder model.
849 DecoderModelCfg dec_model_cfg;
850
851 // Configuration related to reference frames.
852 RefFrameCfg ref_frm_cfg;
853
854 // Configuration related to unit tests.
855 UnitTestCfg unit_test_cfg;
856
857 // Flags related to motion mode.
858 MotionModeCfg motion_mode_cfg;
859
860 // Flags related to intra mode search.
861 IntraModeCfg intra_mode_cfg;
862
863 // Flags related to transform size/type.
864 TxfmSizeTypeCfg txfm_cfg;
865
866 // Flags related to compound type.
867 CompoundTypeCfg comp_type_cfg;
868
869 // Partition related information.
870 PartitionCfg part_cfg;
871
872 // Configuration related to frequency of cost update.
873 CostUpdateFreq cost_upd_freq;
874
875 #if CONFIG_DENOISE
876 // Indicates the noise level.
877 float noise_level;
878 // Indicates the the denoisers block size.
879 int noise_block_size;
880 // Indicates whether to apply denoising to the frame to be encoded
881 int enable_dnl_denoising;
882 #endif
883
884 #if CONFIG_AV1_TEMPORAL_DENOISING
885 // Noise sensitivity.
886 int noise_sensitivity;
887 #endif
888 // Bit mask to specify which tier each of the 32 possible operating points
889 // conforms to.
890 unsigned int tier_mask;
891
892 // Indicates the number of pixels off the edge of a reference frame we're
893 // allowed to go when forming an inter prediction.
894 int border_in_pixels;
895
896 // Indicates the maximum number of threads that may be used by the encoder.
897 int max_threads;
898
899 // Indicates the speed preset to be used.
900 int speed;
901
902 // Indicates the target sequence level index for each operating point(OP).
903 AV1_LEVEL target_seq_level_idx[MAX_NUM_OPERATING_POINTS];
904
905 // Indicates the bitstream profile to be used.
906 BITSTREAM_PROFILE profile;
907
908 /*!\endcond */
909 /*!
910 * Indicates the current encoder pass :
911 * 0 = 1 Pass encode,
912 * 1 = First pass of two pass,
913 * 2 = Second pass of two pass.
914 *
915 */
916 enum aom_enc_pass pass;
917 /*!\cond */
918
919 // Indicates if the encoding is GOOD or REALTIME.
920 MODE mode;
921
922 // Indicates if row-based multi-threading should be enabled or not.
923 bool row_mt;
924
925 // Indicates if 16bit frame buffers are to be used i.e., the content is >
926 // 8-bit.
927 bool use_highbitdepth;
928
929 // Indicates the bitstream syntax mode. 0 indicates bitstream is saved as
930 // Section 5 bitstream, while 1 indicates the bitstream is saved in Annex - B
931 // format.
932 bool save_as_annexb;
933
934 /*!\endcond */
935 } AV1EncoderConfig;
936
937 /*!\cond */
is_lossless_requested(const RateControlCfg * const rc_cfg)938 static INLINE int is_lossless_requested(const RateControlCfg *const rc_cfg) {
939 return rc_cfg->best_allowed_q == 0 && rc_cfg->worst_allowed_q == 0;
940 }
941 /*!\endcond */
942
943 /*!
944 * \brief Encoder-side probabilities for pruning of various AV1 tools
945 */
946 typedef struct {
947 /*!
948 * obmc_probs[i][j] is the probability of OBMC being the best motion mode for
949 * jth block size and ith frame update type, averaged over past frames. If
950 * obmc_probs[i][j] < thresh, then OBMC search is pruned.
951 */
952 int obmc_probs[FRAME_UPDATE_TYPES][BLOCK_SIZES_ALL];
953
954 /*!
955 * warped_probs[i] is the probability of warped motion being the best motion
956 * mode for ith frame update type, averaged over past frames. If
957 * warped_probs[i] < thresh, then warped motion search is pruned.
958 */
959 int warped_probs[FRAME_UPDATE_TYPES];
960
961 /*!
962 * tx_type_probs[i][j][k] is the probability of kth tx_type being the best
963 * for jth transform size and ith frame update type, averaged over past
964 * frames. If tx_type_probs[i][j][k] < thresh, then transform search for that
965 * type is pruned.
966 */
967 int tx_type_probs[FRAME_UPDATE_TYPES][TX_SIZES_ALL][TX_TYPES];
968
969 /*!
970 * switchable_interp_probs[i][j][k] is the probability of kth interpolation
971 * filter being the best for jth filter context and ith frame update type,
972 * averaged over past frames. If switchable_interp_probs[i][j][k] < thresh,
973 * then interpolation filter search is pruned for that case.
974 */
975 int switchable_interp_probs[FRAME_UPDATE_TYPES][SWITCHABLE_FILTER_CONTEXTS]
976 [SWITCHABLE_FILTERS];
977 } FrameProbInfo;
978
979 /*!\cond */
980
981 typedef struct FRAME_COUNTS {
982 // Note: This structure should only contain 'unsigned int' fields, or
983 // aggregates built solely from 'unsigned int' fields/elements
984 #if CONFIG_ENTROPY_STATS
985 unsigned int kf_y_mode[KF_MODE_CONTEXTS][KF_MODE_CONTEXTS][INTRA_MODES];
986 unsigned int angle_delta[DIRECTIONAL_MODES][2 * MAX_ANGLE_DELTA + 1];
987 unsigned int y_mode[BLOCK_SIZE_GROUPS][INTRA_MODES];
988 unsigned int uv_mode[CFL_ALLOWED_TYPES][INTRA_MODES][UV_INTRA_MODES];
989 unsigned int cfl_sign[CFL_JOINT_SIGNS];
990 unsigned int cfl_alpha[CFL_ALPHA_CONTEXTS][CFL_ALPHABET_SIZE];
991 unsigned int palette_y_mode[PALATTE_BSIZE_CTXS][PALETTE_Y_MODE_CONTEXTS][2];
992 unsigned int palette_uv_mode[PALETTE_UV_MODE_CONTEXTS][2];
993 unsigned int palette_y_size[PALATTE_BSIZE_CTXS][PALETTE_SIZES];
994 unsigned int palette_uv_size[PALATTE_BSIZE_CTXS][PALETTE_SIZES];
995 unsigned int palette_y_color_index[PALETTE_SIZES]
996 [PALETTE_COLOR_INDEX_CONTEXTS]
997 [PALETTE_COLORS];
998 unsigned int palette_uv_color_index[PALETTE_SIZES]
999 [PALETTE_COLOR_INDEX_CONTEXTS]
1000 [PALETTE_COLORS];
1001 unsigned int partition[PARTITION_CONTEXTS][EXT_PARTITION_TYPES];
1002 unsigned int txb_skip[TOKEN_CDF_Q_CTXS][TX_SIZES][TXB_SKIP_CONTEXTS][2];
1003 unsigned int eob_extra[TOKEN_CDF_Q_CTXS][TX_SIZES][PLANE_TYPES]
1004 [EOB_COEF_CONTEXTS][2];
1005 unsigned int dc_sign[PLANE_TYPES][DC_SIGN_CONTEXTS][2];
1006 unsigned int coeff_lps[TX_SIZES][PLANE_TYPES][BR_CDF_SIZE - 1][LEVEL_CONTEXTS]
1007 [2];
1008 unsigned int eob_flag[TX_SIZES][PLANE_TYPES][EOB_COEF_CONTEXTS][2];
1009 unsigned int eob_multi16[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][5];
1010 unsigned int eob_multi32[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][6];
1011 unsigned int eob_multi64[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][7];
1012 unsigned int eob_multi128[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][8];
1013 unsigned int eob_multi256[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][9];
1014 unsigned int eob_multi512[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][10];
1015 unsigned int eob_multi1024[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][11];
1016 unsigned int coeff_lps_multi[TOKEN_CDF_Q_CTXS][TX_SIZES][PLANE_TYPES]
1017 [LEVEL_CONTEXTS][BR_CDF_SIZE];
1018 unsigned int coeff_base_multi[TOKEN_CDF_Q_CTXS][TX_SIZES][PLANE_TYPES]
1019 [SIG_COEF_CONTEXTS][NUM_BASE_LEVELS + 2];
1020 unsigned int coeff_base_eob_multi[TOKEN_CDF_Q_CTXS][TX_SIZES][PLANE_TYPES]
1021 [SIG_COEF_CONTEXTS_EOB][NUM_BASE_LEVELS + 1];
1022 unsigned int newmv_mode[NEWMV_MODE_CONTEXTS][2];
1023 unsigned int zeromv_mode[GLOBALMV_MODE_CONTEXTS][2];
1024 unsigned int refmv_mode[REFMV_MODE_CONTEXTS][2];
1025 unsigned int drl_mode[DRL_MODE_CONTEXTS][2];
1026 unsigned int inter_compound_mode[INTER_MODE_CONTEXTS][INTER_COMPOUND_MODES];
1027 unsigned int wedge_idx[BLOCK_SIZES_ALL][16];
1028 unsigned int interintra[BLOCK_SIZE_GROUPS][2];
1029 unsigned int interintra_mode[BLOCK_SIZE_GROUPS][INTERINTRA_MODES];
1030 unsigned int wedge_interintra[BLOCK_SIZES_ALL][2];
1031 unsigned int compound_type[BLOCK_SIZES_ALL][MASKED_COMPOUND_TYPES];
1032 unsigned int motion_mode[BLOCK_SIZES_ALL][MOTION_MODES];
1033 unsigned int obmc[BLOCK_SIZES_ALL][2];
1034 unsigned int intra_inter[INTRA_INTER_CONTEXTS][2];
1035 unsigned int comp_inter[COMP_INTER_CONTEXTS][2];
1036 unsigned int comp_ref_type[COMP_REF_TYPE_CONTEXTS][2];
1037 unsigned int uni_comp_ref[UNI_COMP_REF_CONTEXTS][UNIDIR_COMP_REFS - 1][2];
1038 unsigned int single_ref[REF_CONTEXTS][SINGLE_REFS - 1][2];
1039 unsigned int comp_ref[REF_CONTEXTS][FWD_REFS - 1][2];
1040 unsigned int comp_bwdref[REF_CONTEXTS][BWD_REFS - 1][2];
1041 unsigned int intrabc[2];
1042
1043 unsigned int txfm_partition[TXFM_PARTITION_CONTEXTS][2];
1044 unsigned int intra_tx_size[MAX_TX_CATS][TX_SIZE_CONTEXTS][MAX_TX_DEPTH + 1];
1045 unsigned int skip_mode[SKIP_MODE_CONTEXTS][2];
1046 unsigned int skip_txfm[SKIP_CONTEXTS][2];
1047 unsigned int compound_index[COMP_INDEX_CONTEXTS][2];
1048 unsigned int comp_group_idx[COMP_GROUP_IDX_CONTEXTS][2];
1049 unsigned int delta_q[DELTA_Q_PROBS][2];
1050 unsigned int delta_lf_multi[FRAME_LF_COUNT][DELTA_LF_PROBS][2];
1051 unsigned int delta_lf[DELTA_LF_PROBS][2];
1052
1053 unsigned int inter_ext_tx[EXT_TX_SETS_INTER][EXT_TX_SIZES][TX_TYPES];
1054 unsigned int intra_ext_tx[EXT_TX_SETS_INTRA][EXT_TX_SIZES][INTRA_MODES]
1055 [TX_TYPES];
1056 unsigned int filter_intra_mode[FILTER_INTRA_MODES];
1057 unsigned int filter_intra[BLOCK_SIZES_ALL][2];
1058 unsigned int switchable_restore[RESTORE_SWITCHABLE_TYPES];
1059 unsigned int wiener_restore[2];
1060 unsigned int sgrproj_restore[2];
1061 #endif // CONFIG_ENTROPY_STATS
1062
1063 unsigned int switchable_interp[SWITCHABLE_FILTER_CONTEXTS]
1064 [SWITCHABLE_FILTERS];
1065 } FRAME_COUNTS;
1066
1067 #define INTER_MODE_RD_DATA_OVERALL_SIZE 6400
1068
1069 typedef struct {
1070 int ready;
1071 double a;
1072 double b;
1073 double dist_mean;
1074 double ld_mean;
1075 double sse_mean;
1076 double sse_sse_mean;
1077 double sse_ld_mean;
1078 int num;
1079 double dist_sum;
1080 double ld_sum;
1081 double sse_sum;
1082 double sse_sse_sum;
1083 double sse_ld_sum;
1084 } InterModeRdModel;
1085
1086 typedef struct {
1087 int idx;
1088 int64_t rd;
1089 } RdIdxPair;
1090 // TODO(angiebird): This is an estimated size. We still need to figure what is
1091 // the maximum number of modes.
1092 #define MAX_INTER_MODES 1024
1093 // TODO(any): rename this struct to something else. There is already another
1094 // struct called inter_mode_info, which makes this terribly confusing.
1095 /*!\endcond */
1096 /*!
1097 * \brief Struct used to hold inter mode data for fast tx search.
1098 *
1099 * This struct is used to perform a full transform search only on winning
1100 * candidates searched with an estimate for transform coding RD.
1101 */
1102 typedef struct inter_modes_info {
1103 /*!
1104 * The number of inter modes for which data was stored in each of the
1105 * following arrays.
1106 */
1107 int num;
1108 /*!
1109 * Mode info struct for each of the candidate modes.
1110 */
1111 MB_MODE_INFO mbmi_arr[MAX_INTER_MODES];
1112 /*!
1113 * The rate for each of the candidate modes.
1114 */
1115 int mode_rate_arr[MAX_INTER_MODES];
1116 /*!
1117 * The sse of the predictor for each of the candidate modes.
1118 */
1119 int64_t sse_arr[MAX_INTER_MODES];
1120 /*!
1121 * The estimated rd of the predictor for each of the candidate modes.
1122 */
1123 int64_t est_rd_arr[MAX_INTER_MODES];
1124 /*!
1125 * The rate and mode index for each of the candidate modes.
1126 */
1127 RdIdxPair rd_idx_pair_arr[MAX_INTER_MODES];
1128 /*!
1129 * The full rd stats for each of the candidate modes.
1130 */
1131 RD_STATS rd_cost_arr[MAX_INTER_MODES];
1132 /*!
1133 * The full rd stats of luma only for each of the candidate modes.
1134 */
1135 RD_STATS rd_cost_y_arr[MAX_INTER_MODES];
1136 /*!
1137 * The full rd stats of chroma only for each of the candidate modes.
1138 */
1139 RD_STATS rd_cost_uv_arr[MAX_INTER_MODES];
1140 } InterModesInfo;
1141
1142 /*!\cond */
1143 typedef struct {
1144 // TODO(kyslov): consider changing to 64bit
1145
1146 // This struct is used for computing variance in choose_partitioning(), where
1147 // the max number of samples within a superblock is 32x32 (with 4x4 avg).
1148 // With 8bit bitdepth, uint32_t is enough for sum_square_error (2^8 * 2^8 * 32
1149 // * 32 = 2^26). For high bitdepth we need to consider changing this to 64 bit
1150 uint32_t sum_square_error;
1151 int32_t sum_error;
1152 int log2_count;
1153 int variance;
1154 } VPartVar;
1155
1156 typedef struct {
1157 VPartVar none;
1158 VPartVar horz[2];
1159 VPartVar vert[2];
1160 } VPVariance;
1161
1162 typedef struct {
1163 VPVariance part_variances;
1164 VPartVar split[4];
1165 } VP4x4;
1166
1167 typedef struct {
1168 VPVariance part_variances;
1169 VP4x4 split[4];
1170 } VP8x8;
1171
1172 typedef struct {
1173 VPVariance part_variances;
1174 VP8x8 split[4];
1175 } VP16x16;
1176
1177 typedef struct {
1178 VPVariance part_variances;
1179 VP16x16 split[4];
1180 } VP32x32;
1181
1182 typedef struct {
1183 VPVariance part_variances;
1184 VP32x32 split[4];
1185 } VP64x64;
1186
1187 typedef struct {
1188 VPVariance part_variances;
1189 VP64x64 *split;
1190 } VP128x128;
1191
1192 /*!\endcond */
1193
1194 /*!
1195 * \brief Thresholds for variance based partitioning.
1196 */
1197 typedef struct {
1198 /*!
1199 * If block variance > threshold, then that block is forced to split.
1200 * thresholds[0] - threshold for 128x128;
1201 * thresholds[1] - threshold for 64x64;
1202 * thresholds[2] - threshold for 32x32;
1203 * thresholds[3] - threshold for 16x16;
1204 * thresholds[4] - threshold for 8x8;
1205 */
1206 int64_t thresholds[5];
1207
1208 /*!
1209 * MinMax variance threshold for 8x8 sub blocks of a 16x16 block. If actual
1210 * minmax > threshold_minmax, the 16x16 is forced to split.
1211 */
1212 int64_t threshold_minmax;
1213 } VarBasedPartitionInfo;
1214
1215 /*!
1216 * \brief Encoder parameters for synchronization of row based multi-threading
1217 */
1218 typedef struct {
1219 #if CONFIG_MULTITHREAD
1220 /**
1221 * \name Synchronization objects for top-right dependency.
1222 */
1223 /**@{*/
1224 pthread_mutex_t *mutex_; /*!< Mutex lock object */
1225 pthread_cond_t *cond_; /*!< Condition variable */
1226 /**@}*/
1227 #endif // CONFIG_MULTITHREAD
1228 /*!
1229 * Buffer to store the superblock whose encoding is complete.
1230 * cur_col[i] stores the number of superblocks which finished encoding in the
1231 * ith superblock row.
1232 */
1233 int *num_finished_cols;
1234 /*!
1235 * Number of extra superblocks of the top row to be complete for encoding
1236 * of the current superblock to start. A value of 1 indicates top-right
1237 * dependency.
1238 */
1239 int sync_range;
1240 /*!
1241 * Number of superblock rows.
1242 */
1243 int rows;
1244 /*!
1245 * The superblock row (in units of MI blocks) to be processed next.
1246 */
1247 int next_mi_row;
1248 /*!
1249 * Number of threads processing the current tile.
1250 */
1251 int num_threads_working;
1252 } AV1EncRowMultiThreadSync;
1253
1254 /*!\cond */
1255
1256 // TODO(jingning) All spatially adaptive variables should go to TileDataEnc.
1257 typedef struct TileDataEnc {
1258 TileInfo tile_info;
1259 DECLARE_ALIGNED(16, FRAME_CONTEXT, tctx);
1260 FRAME_CONTEXT *row_ctx;
1261 uint8_t allow_update_cdf;
1262 InterModeRdModel inter_mode_rd_models[BLOCK_SIZES_ALL];
1263 AV1EncRowMultiThreadSync row_mt_sync;
1264 MV firstpass_top_mv;
1265 } TileDataEnc;
1266
1267 typedef struct RD_COUNTS {
1268 int64_t comp_pred_diff[REFERENCE_MODES];
1269 int compound_ref_used_flag;
1270 int skip_mode_used_flag;
1271 int tx_type_used[TX_SIZES_ALL][TX_TYPES];
1272 int obmc_used[BLOCK_SIZES_ALL][2];
1273 int warped_used[2];
1274 } RD_COUNTS;
1275
1276 typedef struct ThreadData {
1277 MACROBLOCK mb;
1278 RD_COUNTS rd_counts;
1279 FRAME_COUNTS *counts;
1280 PC_TREE_SHARED_BUFFERS shared_coeff_buf;
1281 SIMPLE_MOTION_DATA_TREE *sms_tree;
1282 SIMPLE_MOTION_DATA_TREE *sms_root;
1283 InterModesInfo *inter_modes_info;
1284 uint32_t *hash_value_buffer[2][2];
1285 OBMCBuffer obmc_buffer;
1286 PALETTE_BUFFER *palette_buffer;
1287 CompoundTypeRdBuffers comp_rd_buffer;
1288 CONV_BUF_TYPE *tmp_conv_dst;
1289 uint8_t *tmp_pred_bufs[2];
1290 int intrabc_used;
1291 int deltaq_used;
1292 FRAME_CONTEXT *tctx;
1293 VP64x64 *vt64x64;
1294 int32_t num_64x64_blocks;
1295 PICK_MODE_CONTEXT *firstpass_ctx;
1296 TemporalFilterData tf_data;
1297 } ThreadData;
1298
1299 struct EncWorkerData;
1300
1301 /*!\endcond */
1302
1303 /*!
1304 * \brief Encoder data related to row-based multi-threading
1305 */
1306 typedef struct {
1307 /*!
1308 * Number of tile rows for which row synchronization memory is allocated.
1309 */
1310 int allocated_tile_rows;
1311 /*!
1312 * Number of tile cols for which row synchronization memory is allocated.
1313 */
1314 int allocated_tile_cols;
1315 /*!
1316 * Number of rows for which row synchronization memory is allocated
1317 * per tile. During first-pass/look-ahead stage this equals the
1318 * maximum number of macroblock rows in a tile. During encode stage,
1319 * this equals the maximum number of superblock rows in a tile.
1320 */
1321 int allocated_rows;
1322 /*!
1323 * Number of columns for which entropy context memory is allocated
1324 * per tile. During encode stage, this equals the maximum number of
1325 * superblock columns in a tile minus 1. The entropy context memory
1326 * is not allocated during first-pass/look-ahead stage.
1327 */
1328 int allocated_cols;
1329
1330 /*!
1331 * thread_id_to_tile_id[i] indicates the tile id assigned to the ith thread.
1332 */
1333 int thread_id_to_tile_id[MAX_NUM_THREADS];
1334
1335 #if CONFIG_MULTITHREAD
1336 /*!
1337 * Mutex lock used while dispatching jobs.
1338 */
1339 pthread_mutex_t *mutex_;
1340 #endif
1341
1342 /**
1343 * \name Row synchronization related function pointers.
1344 */
1345 /**@{*/
1346 /*!
1347 * Reader.
1348 */
1349 void (*sync_read_ptr)(AV1EncRowMultiThreadSync *const, int, int);
1350 /*!
1351 * Writer.
1352 */
1353 void (*sync_write_ptr)(AV1EncRowMultiThreadSync *const, int, int, int);
1354 /**@}*/
1355 } AV1EncRowMultiThreadInfo;
1356
1357 /*!
1358 * \brief Encoder parameters related to multi-threading.
1359 */
1360 typedef struct MultiThreadInfo {
1361 /*!
1362 * Number of workers created for multi-threading.
1363 */
1364 int num_workers;
1365
1366 /*!
1367 * Number of workers used for different MT modules.
1368 */
1369 int num_mod_workers[NUM_MT_MODULES];
1370
1371 /*!
1372 * Flag to indicate whether thread specific buffers need to be allocated for
1373 * tile/row based multi-threading of first pass stage.
1374 */
1375 int fp_mt_buf_init_done;
1376
1377 /*!
1378 * Flag to indicate whether thread specific buffers need to be allocated for
1379 * tile/row based multi-threading of encode stage.
1380 */
1381 int enc_mt_buf_init_done;
1382
1383 /*!
1384 * Synchronization object used to launch job in the worker thread.
1385 */
1386 AVxWorker *workers;
1387
1388 /*!
1389 * Data specific to each worker in encoder multi-threading.
1390 * tile_thr_data[i] stores the worker data of the ith thread.
1391 */
1392 struct EncWorkerData *tile_thr_data;
1393
1394 /*!
1395 * When set, indicates that row based multi-threading of the encoder is
1396 * enabled.
1397 */
1398 bool row_mt_enabled;
1399
1400 /*!
1401 * Encoder row multi-threading data.
1402 */
1403 AV1EncRowMultiThreadInfo enc_row_mt;
1404
1405 /*!
1406 * Tpl row multi-threading data.
1407 */
1408 AV1TplRowMultiThreadInfo tpl_row_mt;
1409
1410 /*!
1411 * Loop Filter multi-threading object.
1412 */
1413 AV1LfSync lf_row_sync;
1414
1415 /*!
1416 * Loop Restoration multi-threading object.
1417 */
1418 AV1LrSync lr_row_sync;
1419
1420 /*!
1421 * Global Motion multi-threading object.
1422 */
1423 AV1GlobalMotionSync gm_sync;
1424
1425 /*!
1426 * Temporal Filter multi-threading object.
1427 */
1428 AV1TemporalFilterSync tf_sync;
1429
1430 /*!
1431 * CDEF search multi-threading object.
1432 */
1433 AV1CdefSync cdef_sync;
1434 } MultiThreadInfo;
1435
1436 /*!\cond */
1437
1438 typedef struct ActiveMap {
1439 int enabled;
1440 int update;
1441 unsigned char *map;
1442 } ActiveMap;
1443
1444 /*!\endcond */
1445
1446 /*!
1447 * \brief Encoder info used for decision on forcing integer motion vectors.
1448 */
1449 typedef struct {
1450 /*!
1451 * cs_rate_array[i] is the fraction of blocks in a frame which either match
1452 * with the collocated block or are smooth, where i is the rate_index.
1453 */
1454 double cs_rate_array[32];
1455 /*!
1456 * rate_index is used to index cs_rate_array.
1457 */
1458 int rate_index;
1459 /*!
1460 * rate_size is the total number of entries populated in cs_rate_array.
1461 */
1462 int rate_size;
1463 } ForceIntegerMVInfo;
1464
1465 /*!\cond */
1466
1467 #if CONFIG_INTERNAL_STATS
1468 // types of stats
1469 enum {
1470 STAT_Y,
1471 STAT_U,
1472 STAT_V,
1473 STAT_ALL,
1474 NUM_STAT_TYPES // This should always be the last member of the enum
1475 } UENUM1BYTE(StatType);
1476
1477 typedef struct IMAGE_STAT {
1478 double stat[NUM_STAT_TYPES];
1479 double worst;
1480 } ImageStat;
1481 #endif // CONFIG_INTERNAL_STATS
1482
1483 typedef struct {
1484 int ref_count;
1485 YV12_BUFFER_CONFIG buf;
1486 } EncRefCntBuffer;
1487
1488 /*!\endcond */
1489
1490 /*!
1491 * \brief Buffer to store mode information at mi_alloc_bsize (4x4 or 8x8) level
1492 *
1493 * This is used for bitstream preparation.
1494 */
1495 typedef struct {
1496 /*!
1497 * frame_base[mi_row * stride + mi_col] stores the mode information of
1498 * block (mi_row,mi_col).
1499 */
1500 MB_MODE_INFO_EXT_FRAME *frame_base;
1501 /*!
1502 * Size of frame_base buffer.
1503 */
1504 int alloc_size;
1505 /*!
1506 * Stride of frame_base buffer.
1507 */
1508 int stride;
1509 } MBMIExtFrameBufferInfo;
1510
1511 /*!\cond */
1512
1513 #if CONFIG_COLLECT_PARTITION_STATS
1514 typedef struct FramePartitionTimingStats {
1515 int partition_decisions[6][EXT_PARTITION_TYPES];
1516 int partition_attempts[6][EXT_PARTITION_TYPES];
1517 int64_t partition_times[6][EXT_PARTITION_TYPES];
1518
1519 int partition_redo;
1520 } FramePartitionTimingStats;
1521 #endif // CONFIG_COLLECT_PARTITION_STATS
1522
1523 #if CONFIG_COLLECT_COMPONENT_TIMING
1524 #include "aom_ports/aom_timer.h"
1525 // Adjust the following to add new components.
1526 enum {
1527 av1_encode_strategy_time,
1528 av1_get_second_pass_params_time,
1529 denoise_and_encode_time,
1530 apply_filtering_time,
1531 av1_tpl_setup_stats_time,
1532 encode_frame_to_data_rate_time,
1533 encode_with_recode_loop_time,
1534 loop_filter_time,
1535 cdef_time,
1536 loop_restoration_time,
1537 av1_pack_bitstream_final_time,
1538 av1_encode_frame_time,
1539 av1_compute_global_motion_time,
1540 av1_setup_motion_field_time,
1541 encode_sb_row_time,
1542
1543 rd_pick_partition_time,
1544 av1_prune_partitions_time,
1545 none_partition_search_time,
1546 split_partition_search_time,
1547 rectangular_partition_search_time,
1548 ab_partitions_search_time,
1549 rd_pick_4partition_time,
1550 encode_sb_time,
1551
1552 rd_pick_sb_modes_time,
1553 av1_rd_pick_intra_mode_sb_time,
1554 av1_rd_pick_inter_mode_sb_time,
1555 handle_inter_mode_time,
1556 evaluate_motion_mode_for_winner_candidates_time,
1557 handle_intra_mode_time,
1558 do_tx_search_time,
1559 av1_search_palette_mode_time,
1560 handle_newmv_time,
1561 compound_type_rd_time,
1562 interpolation_filter_search_time,
1563 motion_mode_rd_time,
1564 kTimingComponents,
1565 } UENUM1BYTE(TIMING_COMPONENT);
1566
get_component_name(int index)1567 static INLINE char const *get_component_name(int index) {
1568 switch (index) {
1569 case av1_encode_strategy_time: return "av1_encode_strategy_time";
1570 case av1_get_second_pass_params_time:
1571 return "av1_get_second_pass_params_time";
1572 case denoise_and_encode_time: return "denoise_and_encode_time";
1573 case apply_filtering_time: return "apply_filtering_time";
1574 case av1_tpl_setup_stats_time: return "av1_tpl_setup_stats_time";
1575 case encode_frame_to_data_rate_time:
1576 return "encode_frame_to_data_rate_time";
1577 case encode_with_recode_loop_time: return "encode_with_recode_loop_time";
1578 case loop_filter_time: return "loop_filter_time";
1579 case cdef_time: return "cdef_time";
1580 case loop_restoration_time: return "loop_restoration_time";
1581 case av1_pack_bitstream_final_time: return "av1_pack_bitstream_final_time";
1582 case av1_encode_frame_time: return "av1_encode_frame_time";
1583 case av1_compute_global_motion_time:
1584 return "av1_compute_global_motion_time";
1585 case av1_setup_motion_field_time: return "av1_setup_motion_field_time";
1586 case encode_sb_row_time: return "encode_sb_row_time";
1587
1588 case rd_pick_partition_time: return "rd_pick_partition_time";
1589 case av1_prune_partitions_time: return "av1_prune_partitions_time";
1590 case none_partition_search_time: return "none_partition_search_time";
1591 case split_partition_search_time: return "split_partition_search_time";
1592 case rectangular_partition_search_time:
1593 return "rectangular_partition_search_time";
1594 case ab_partitions_search_time: return "ab_partitions_search_time";
1595 case rd_pick_4partition_time: return "rd_pick_4partition_time";
1596 case encode_sb_time: return "encode_sb_time";
1597
1598 case rd_pick_sb_modes_time: return "rd_pick_sb_modes_time";
1599 case av1_rd_pick_intra_mode_sb_time:
1600 return "av1_rd_pick_intra_mode_sb_time";
1601 case av1_rd_pick_inter_mode_sb_time:
1602 return "av1_rd_pick_inter_mode_sb_time";
1603 case handle_inter_mode_time: return "handle_inter_mode_time";
1604 case evaluate_motion_mode_for_winner_candidates_time:
1605 return "evaluate_motion_mode_for_winner_candidates_time";
1606 case handle_intra_mode_time: return "handle_intra_mode_time";
1607 case do_tx_search_time: return "do_tx_search_time";
1608 case av1_search_palette_mode_time: return "av1_search_palette_mode_time";
1609 case handle_newmv_time: return "handle_newmv_time";
1610 case compound_type_rd_time: return "compound_type_rd_time";
1611 case interpolation_filter_search_time:
1612 return "interpolation_filter_search_time";
1613 case motion_mode_rd_time: return "motion_mode_rd_time";
1614 default: assert(0);
1615 }
1616 return "error";
1617 }
1618 #endif
1619
1620 // The maximum number of internal ARFs except ALTREF_FRAME
1621 #define MAX_INTERNAL_ARFS (REF_FRAMES - BWDREF_FRAME - 1)
1622
1623 /*!\endcond */
1624
1625 /*!
1626 * \brief Parameters related to global motion search
1627 */
1628 typedef struct {
1629 /*!
1630 * Flag to indicate if global motion search needs to be rerun.
1631 */
1632 bool search_done;
1633
1634 /*!
1635 * Array of pointers to the frame buffers holding the reference frames.
1636 * ref_buf[i] stores the pointer to the reference frame of the ith
1637 * reference frame type.
1638 */
1639 YV12_BUFFER_CONFIG *ref_buf[REF_FRAMES];
1640
1641 /*!
1642 * Pointer to the source frame buffer.
1643 */
1644 unsigned char *src_buffer;
1645
1646 /*!
1647 * Holds the number of valid reference frames in past and future directions
1648 * w.r.t. the current frame. num_ref_frames[i] stores the total number of
1649 * valid reference frames in 'i' direction.
1650 */
1651 int num_ref_frames[MAX_DIRECTIONS];
1652
1653 /*!
1654 * Array of structure which stores the valid reference frames in past and
1655 * future directions and their corresponding distance from the source frame.
1656 * reference_frames[i][j] holds the jth valid reference frame type in the
1657 * direction 'i' and its temporal distance from the source frame .
1658 */
1659 FrameDistPair reference_frames[MAX_DIRECTIONS][REF_FRAMES - 1];
1660
1661 /**
1662 * \name Dimensions for which segment map is allocated.
1663 */
1664 /**@{*/
1665 int segment_map_w; /*!< segment map width */
1666 int segment_map_h; /*!< segment map height */
1667 /**@}*/
1668
1669 /*!
1670 * Holds the total number of corner points detected in the source frame.
1671 */
1672 int num_src_corners;
1673
1674 /*!
1675 * Holds the x and y co-ordinates of the corner points detected in the source
1676 * frame. src_corners[i] holds the x co-ordinate and src_corners[i+1] holds
1677 * the y co-ordinate of the ith corner point detected.
1678 */
1679 int src_corners[2 * MAX_CORNERS];
1680 } GlobalMotionInfo;
1681
1682 /*!
1683 * \brief Initial frame dimensions
1684 *
1685 * Tracks the frame dimensions using which:
1686 * - Frame buffers (like altref and util frame buffers) were allocated
1687 * - Motion estimation related initializations were done
1688 * This structure is helpful to reallocate / reinitialize the above when there
1689 * is a change in frame dimensions.
1690 */
1691 typedef struct {
1692 int width; /*!< initial width */
1693 int height; /*!< initial height */
1694 } InitialDimensions;
1695
1696 /*!
1697 * \brief Flags related to interpolation filter search
1698 */
1699 typedef struct {
1700 /*!
1701 * Stores the default value of skip flag depending on chroma format
1702 * Set as 1 for monochrome and 3 for other color formats
1703 */
1704 int default_interp_skip_flags;
1705 /*!
1706 * Filter mask to allow certain interp_filter type.
1707 */
1708 uint16_t interp_filter_search_mask;
1709 } InterpSearchFlags;
1710
1711 /*!
1712 * \brief Parameters for motion vector search process
1713 */
1714 typedef struct {
1715 /*!
1716 * Largest MV component used in a frame.
1717 * The value from the previous frame is used to set the full pixel search
1718 * range for the current frame.
1719 */
1720 int max_mv_magnitude;
1721 /*!
1722 * Parameter indicating initial search window to be used in full-pixel search.
1723 * Range [0, MAX_MVSEARCH_STEPS-2]. Lower value indicates larger window.
1724 */
1725 int mv_step_param;
1726 /*!
1727 * Pointer to sub-pixel search function.
1728 * In encoder: av1_find_best_sub_pixel_tree
1729 * av1_find_best_sub_pixel_tree_pruned
1730 * av1_find_best_sub_pixel_tree_pruned_more
1731 * In MV unit test: av1_return_max_sub_pixel_mv
1732 * av1_return_min_sub_pixel_mv
1733 */
1734 fractional_mv_step_fp *find_fractional_mv_step;
1735 /*!
1736 * Search site configuration for full-pel MV search.
1737 * search_site_cfg[SS_CFG_SRC]: Used in tpl, rd/non-rd inter mode loop, simple
1738 * motion search. search_site_cfg[SS_CFG_LOOKAHEAD]: Used in intraBC, temporal
1739 * filter search_site_cfg[SS_CFG_FPF]: Used during first pass and lookahead
1740 */
1741 search_site_config search_site_cfg[SS_CFG_TOTAL][NUM_DISTINCT_SEARCH_METHODS];
1742 } MotionVectorSearchParams;
1743
1744 /*!
1745 * \brief Refresh frame flags for different type of frames.
1746 *
1747 * If the refresh flag is true for a particular reference frame, after the
1748 * current frame is encoded, the reference frame gets refreshed (updated) to
1749 * be the current frame. Note: Usually at most one flag will be set to true at
1750 * a time. But, for key-frames, all flags are set to true at once.
1751 */
1752 typedef struct {
1753 bool golden_frame; /*!< Refresh flag for golden frame */
1754 bool bwd_ref_frame; /*!< Refresh flag for bwd-ref frame */
1755 bool alt_ref_frame; /*!< Refresh flag for alt-ref frame */
1756 } RefreshFrameFlagsInfo;
1757
1758 /*!
1759 * \brief Desired dimensions for an externally triggered resize.
1760 *
1761 * When resize is triggered externally, the desired dimensions are stored in
1762 * this struct until used in the next frame to be coded. These values are
1763 * effective only for one frame and are reset after they are used.
1764 */
1765 typedef struct {
1766 int width; /*!< Desired resized width */
1767 int height; /*!< Desired resized height */
1768 } ResizePendingParams;
1769
1770 /*!
1771 * \brief Refrence frame distance related variables.
1772 */
1773 typedef struct {
1774 /*!
1775 * True relative distance of reference frames w.r.t. the current frame.
1776 */
1777 int ref_relative_dist[INTER_REFS_PER_FRAME];
1778 /*!
1779 * The nearest reference w.r.t. current frame in the past.
1780 */
1781 int8_t nearest_past_ref;
1782 /*!
1783 * The nearest reference w.r.t. current frame in the future.
1784 */
1785 int8_t nearest_future_ref;
1786 } RefFrameDistanceInfo;
1787
1788 /*!
1789 * \brief Parameters used for winner mode processing.
1790 *
1791 * This is a basic two pass approach: in the first pass, we reduce the number of
1792 * transform searches based on some thresholds during the rdopt process to find
1793 * the "winner mode". In the second pass, we perform a more through tx search
1794 * on the winner mode.
1795 * There are some arrays in the struct, and their indices are used in the
1796 * following manner:
1797 * Index 0: Default mode evaluation, Winner mode processing is not applicable
1798 * (Eg : IntraBc).
1799 * Index 1: Mode evaluation.
1800 * Index 2: Winner mode evaluation
1801 * Index 1 and 2 are only used when the respective speed feature is on.
1802 */
1803 typedef struct {
1804 /*!
1805 * Threshold to determine if trellis optimization is to be enabled
1806 * based on :
1807 * 0 : dist threshold
1808 * 1 : satd threshold
1809 * Corresponds to enable_winner_mode_for_coeff_opt speed feature.
1810 */
1811 unsigned int coeff_opt_thresholds[MODE_EVAL_TYPES][2];
1812
1813 /*!
1814 * Determines the tx size search method during rdopt.
1815 * Corresponds to enable_winner_mode_for_tx_size_srch speed feature.
1816 */
1817 TX_SIZE_SEARCH_METHOD tx_size_search_methods[MODE_EVAL_TYPES];
1818
1819 /*!
1820 * Controls how often we should approximate prediction error with tx
1821 * coefficients. If it's 0, then never. If 1, then it's during the tx_type
1822 * search only. If 2, then always.
1823 * Corresponds to tx_domain_dist_level speed feature.
1824 */
1825 unsigned int use_transform_domain_distortion[MODE_EVAL_TYPES];
1826
1827 /*!
1828 * Threshold to approximate pixel domain distortion with transform domain
1829 * distortion. This is only used if use_txform_domain_distortion is on.
1830 * Corresponds to enable_winner_mode_for_use_tx_domain_dist speed feature.
1831 */
1832 unsigned int tx_domain_dist_threshold[MODE_EVAL_TYPES];
1833
1834 /*!
1835 * Controls how often we should try to skip the transform process based on
1836 * result from dct.
1837 * Corresponds to use_skip_flag_prediction speed feature.
1838 */
1839 unsigned int skip_txfm_level[MODE_EVAL_TYPES];
1840
1841 /*!
1842 * Predict DC only txfm blocks for default, mode and winner mode evaluation.
1843 * Index 0: Default mode evaluation, Winner mode processing is not applicable.
1844 * Index 1: Mode evaluation, Index 2: Winner mode evaluation
1845 */
1846 unsigned int predict_dc_level[MODE_EVAL_TYPES];
1847 } WinnerModeParams;
1848
1849 /*!
1850 * \brief Frame refresh flags set by the external interface.
1851 *
1852 * Flags set by external interface to determine which reference buffers are
1853 * refreshed by this frame. When set, the encoder will update the particular
1854 * reference frame buffer with the contents of the current frame.
1855 */
1856 typedef struct {
1857 bool last_frame; /*!< Refresh flag for last frame */
1858 bool golden_frame; /*!< Refresh flag for golden frame */
1859 bool bwd_ref_frame; /*!< Refresh flag for bwd-ref frame */
1860 bool alt2_ref_frame; /*!< Refresh flag for alt2-ref frame */
1861 bool alt_ref_frame; /*!< Refresh flag for alt-ref frame */
1862 /*!
1863 * Flag indicating if the update of refresh frame flags is pending.
1864 */
1865 bool update_pending;
1866 } ExtRefreshFrameFlagsInfo;
1867
1868 /*!
1869 * \brief Flags signalled by the external interface at frame level.
1870 */
1871 typedef struct {
1872 /*!
1873 * Bit mask to disable certain reference frame types.
1874 */
1875 int ref_frame_flags;
1876
1877 /*!
1878 * Frame refresh flags set by the external interface.
1879 */
1880 ExtRefreshFrameFlagsInfo refresh_frame;
1881
1882 /*!
1883 * Flag to enable the update of frame contexts at the end of a frame decode.
1884 */
1885 bool refresh_frame_context;
1886
1887 /*!
1888 * Flag to indicate that update of refresh_frame_context from external
1889 * interface is pending.
1890 */
1891 bool refresh_frame_context_pending;
1892
1893 /*!
1894 * Flag to enable temporal MV prediction.
1895 */
1896 bool use_ref_frame_mvs;
1897
1898 /*!
1899 * Indicates whether the current frame is to be coded as error resilient.
1900 */
1901 bool use_error_resilient;
1902
1903 /*!
1904 * Indicates whether the current frame is to be coded as s-frame.
1905 */
1906 bool use_s_frame;
1907
1908 /*!
1909 * Indicates whether the current frame's primary_ref_frame is set to
1910 * PRIMARY_REF_NONE.
1911 */
1912 bool use_primary_ref_none;
1913 } ExternalFlags;
1914
1915 /*!\cond */
1916
1917 typedef struct {
1918 int arf_stack[FRAME_BUFFERS];
1919 int arf_stack_size;
1920 int lst_stack[FRAME_BUFFERS];
1921 int lst_stack_size;
1922 int gld_stack[FRAME_BUFFERS];
1923 int gld_stack_size;
1924 } RefBufferStack;
1925
1926 typedef struct {
1927 // Some misc info
1928 int high_prec;
1929 int q;
1930 int order;
1931
1932 // MV counters
1933 int inter_count;
1934 int intra_count;
1935 int default_mvs;
1936 int mv_joint_count[4];
1937 int last_bit_zero;
1938 int last_bit_nonzero;
1939
1940 // Keep track of the rates
1941 int total_mv_rate;
1942 int hp_total_mv_rate;
1943 int lp_total_mv_rate;
1944
1945 // Texture info
1946 int horz_text;
1947 int vert_text;
1948 int diag_text;
1949
1950 // Whether the current struct contains valid data
1951 int valid;
1952 } MV_STATS;
1953
1954 typedef struct {
1955 struct loopfilter lf;
1956 CdefInfo cdef_info;
1957 YV12_BUFFER_CONFIG copy_buffer;
1958 RATE_CONTROL rc;
1959 MV_STATS mv_stats;
1960 } CODING_CONTEXT;
1961
1962 typedef struct {
1963 int frame_width;
1964 int frame_height;
1965 int mi_rows;
1966 int mi_cols;
1967 int mb_rows;
1968 int mb_cols;
1969 int num_mbs;
1970 aom_bit_depth_t bit_depth;
1971 int subsampling_x;
1972 int subsampling_y;
1973 } FRAME_INFO;
1974
1975 /*!
1976 * \brief This structure stores different types of frame indices.
1977 */
1978 typedef struct {
1979 int show_frame_count;
1980 } FRAME_INDEX_SET;
1981
1982 /*!\endcond */
1983
1984 /*!
1985 * \brief Segmentation related information for the current frame.
1986 */
1987 typedef struct {
1988 /*!
1989 * 3-bit number containing the segment affiliation for each 4x4 block in the
1990 * frame. map[y * stride + x] contains the segment id of the 4x4 block at
1991 * (x,y) position.
1992 */
1993 uint8_t *map;
1994 /*!
1995 * Flag to indicate if current frame has lossless segments or not.
1996 * 1: frame has at least one lossless segment.
1997 * 0: frame has no lossless segments.
1998 */
1999 bool has_lossless_segment;
2000 } EncSegmentationInfo;
2001
2002 /*!
2003 * \brief Frame time stamps.
2004 */
2005 typedef struct {
2006 /*!
2007 * Start time stamp of the previous frame
2008 */
2009 int64_t prev_ts_start;
2010 /*!
2011 * End time stamp of the previous frame
2012 */
2013 int64_t prev_ts_end;
2014 /*!
2015 * Start time stamp of the first frame
2016 */
2017 int64_t first_ts_start;
2018 } TimeStamps;
2019
2020 /*!
2021 * Pointers to the memory allocated for frame level transform coeff related
2022 * info.
2023 */
2024 typedef struct {
2025 /*!
2026 * Pointer to the transformed coefficients buffer.
2027 */
2028 tran_low_t *tcoeff;
2029 /*!
2030 * Pointer to the eobs buffer.
2031 */
2032 uint16_t *eobs;
2033 /*!
2034 * Pointer to the entropy_ctx buffer.
2035 */
2036 uint8_t *entropy_ctx;
2037 } CoeffBufferPool;
2038
2039 /*!
2040 * \brief Top level encoder structure.
2041 */
2042 typedef struct AV1_COMP {
2043 /*!
2044 * Quantization and dequantization parameters for internal quantizer setup
2045 * in the encoder.
2046 */
2047 EncQuantDequantParams enc_quant_dequant_params;
2048
2049 /*!
2050 * Structure holding thread specific variables.
2051 */
2052 ThreadData td;
2053
2054 /*!
2055 * Statistics collected at frame level.
2056 */
2057 FRAME_COUNTS counts;
2058
2059 /*!
2060 * Holds buffer storing mode information at 4x4/8x8 level.
2061 */
2062 MBMIExtFrameBufferInfo mbmi_ext_info;
2063
2064 /*!
2065 * Buffer holding the transform block related information.
2066 * coeff_buffer_base[i] stores the transform block related information of the
2067 * ith superblock in raster scan order.
2068 */
2069 CB_COEFF_BUFFER *coeff_buffer_base;
2070
2071 /*!
2072 * Structure holding pointers to frame level memory allocated for transform
2073 * block related information.
2074 */
2075 CoeffBufferPool coeff_buffer_pool;
2076
2077 /*!
2078 * Structure holding variables common to encoder and decoder.
2079 */
2080 AV1_COMMON common;
2081
2082 /*!
2083 * Encoder configuration related parameters.
2084 */
2085 AV1EncoderConfig oxcf;
2086
2087 /*!
2088 * Look-ahead context.
2089 */
2090 struct lookahead_ctx *lookahead;
2091
2092 /*!
2093 * When set, this flag indicates that the current frame is a forward keyframe.
2094 */
2095 int no_show_fwd_kf;
2096
2097 /*!
2098 * Stores the trellis optimization type at segment level.
2099 * optimize_seg_arr[i] stores the trellis opt type for ith segment.
2100 */
2101 TRELLIS_OPT_TYPE optimize_seg_arr[MAX_SEGMENTS];
2102
2103 /*!
2104 * Pointer to the frame buffer holding the source frame to be used during the
2105 * current stage of encoding. It can be the raw input, temporally filtered
2106 * input or scaled input.
2107 */
2108 YV12_BUFFER_CONFIG *source;
2109
2110 /*!
2111 * Pointer to the frame buffer holding the last raw source frame.
2112 * NULL for first frame and alt_ref frames.
2113 */
2114 YV12_BUFFER_CONFIG *last_source;
2115
2116 /*!
2117 * Pointer to the frame buffer holding the unscaled source frame.
2118 * It can be either the raw input or temporally filtered input.
2119 */
2120 YV12_BUFFER_CONFIG *unscaled_source;
2121
2122 /*!
2123 * Frame buffer holding the resized source frame (cropping / superres).
2124 */
2125 YV12_BUFFER_CONFIG scaled_source;
2126
2127 /*!
2128 * Pointer to the frame buffer holding the unscaled last source frame.
2129 */
2130 YV12_BUFFER_CONFIG *unscaled_last_source;
2131
2132 /*!
2133 * Frame buffer holding the resized last source frame.
2134 */
2135 YV12_BUFFER_CONFIG scaled_last_source;
2136
2137 /*!
2138 * Pointer to the original source frame. This is used to determine if the
2139 * content is screen.
2140 */
2141 YV12_BUFFER_CONFIG *unfiltered_source;
2142
2143 /*!
2144 * Parameters related to tpl.
2145 */
2146 TplParams tpl_data;
2147
2148 /*!
2149 * Temporal filter context.
2150 */
2151 TemporalFilterCtx tf_ctx;
2152
2153 /*!
2154 * For a still frame, this flag is set to 1 to skip partition search.
2155 */
2156 int partition_search_skippable_frame;
2157
2158 /*!
2159 * Variables related to forcing integer mv decisions for the current frame.
2160 */
2161 ForceIntegerMVInfo force_intpel_info;
2162
2163 /*!
2164 * Pointer to the buffer holding the scaled reference frames.
2165 * scaled_ref_buf[i] holds the scaled reference frame of type i.
2166 */
2167 RefCntBuffer *scaled_ref_buf[INTER_REFS_PER_FRAME];
2168
2169 /*!
2170 * Pointer to the buffer holding the last show frame.
2171 */
2172 RefCntBuffer *last_show_frame_buf;
2173
2174 /*!
2175 * Refresh frame flags for golden, bwd-ref and alt-ref frames.
2176 */
2177 RefreshFrameFlagsInfo refresh_frame;
2178
2179 /*!
2180 * For each type of reference frame, this contains the index of a reference
2181 * frame buffer for a reference frame of the same type. We use this to
2182 * choose our primary reference frame (which is the most recent reference
2183 * frame of the same type as the current frame).
2184 */
2185 int fb_of_context_type[REF_FRAMES];
2186
2187 /*!
2188 * Flags signalled by the external interface at frame level.
2189 */
2190 ExternalFlags ext_flags;
2191
2192 /*!
2193 * Temporary frame buffer used to store the non-loop filtered reconstructed
2194 * frame during the search of loop filter level.
2195 */
2196 YV12_BUFFER_CONFIG last_frame_uf;
2197
2198 /*!
2199 * Temporary frame buffer used to store the loop restored frame during loop
2200 * restoration search.
2201 */
2202 YV12_BUFFER_CONFIG trial_frame_rst;
2203
2204 /*!
2205 * Ambient reconstruction err target for force key frames.
2206 */
2207 int64_t ambient_err;
2208
2209 /*!
2210 * Parameters related to rate distortion optimization.
2211 */
2212 RD_OPT rd;
2213
2214 /*!
2215 * Temporary coding context used to save and restore when encoding with and
2216 * without super-resolution.
2217 */
2218 CODING_CONTEXT coding_context;
2219
2220 /*!
2221 * Parameters related to global motion search.
2222 */
2223 GlobalMotionInfo gm_info;
2224
2225 /*!
2226 * Parameters related to winner mode processing.
2227 */
2228 WinnerModeParams winner_mode_params;
2229
2230 /*!
2231 * Frame time stamps.
2232 */
2233 TimeStamps time_stamps;
2234
2235 /*!
2236 * Rate control related parameters.
2237 */
2238 RATE_CONTROL rc;
2239
2240 /*!
2241 * Frame rate of the video.
2242 */
2243 double framerate;
2244
2245 /*!
2246 * Pointer to internal utility functions that manipulate aom_codec_* data
2247 * structures.
2248 */
2249 struct aom_codec_pkt_list *output_pkt_list;
2250
2251 /*!
2252 * Bitmask indicating which reference buffers may be referenced by this frame.
2253 */
2254 int ref_frame_flags;
2255
2256 /*!
2257 * speed is passed as a per-frame parameter into the encoder.
2258 */
2259 int speed;
2260
2261 /*!
2262 * sf contains fine-grained config set internally based on speed.
2263 */
2264 SPEED_FEATURES sf;
2265
2266 /*!
2267 * Parameters for motion vector search process.
2268 */
2269 MotionVectorSearchParams mv_search_params;
2270
2271 /*!
2272 * When set, indicates that all reference frames are forward references,
2273 * i.e., all the reference frames are output before the current frame.
2274 */
2275 int all_one_sided_refs;
2276
2277 /*!
2278 * Segmentation related information for current frame.
2279 */
2280 EncSegmentationInfo enc_seg;
2281
2282 /*!
2283 * Parameters related to cyclic refresh aq-mode.
2284 */
2285 CYCLIC_REFRESH *cyclic_refresh;
2286 /*!
2287 * Parameters related to active map. Active maps indicate
2288 * if there is any activity on a 4x4 block basis.
2289 */
2290 ActiveMap active_map;
2291
2292 /*!
2293 * Function pointers to variants of sse/sad/variance computation functions.
2294 * fn_ptr[i] indicates the list of function pointers corresponding to block
2295 * size i.
2296 */
2297 aom_variance_fn_ptr_t fn_ptr[BLOCK_SIZES_ALL];
2298
2299 /*!
2300 * Information related to two pass encoding.
2301 */
2302 TWO_PASS twopass;
2303
2304 /*!
2305 * Information related to a gf group.
2306 */
2307 GF_GROUP gf_group;
2308
2309 /*!
2310 * Track prior gf group state.
2311 */
2312 GF_STATE gf_state;
2313
2314 /*!
2315 * To control the reference frame buffer and selection.
2316 */
2317 RefBufferStack ref_buffer_stack;
2318
2319 /*!
2320 * Frame buffer holding the temporally filtered source frame. It can be KEY
2321 * frame or ARF frame.
2322 */
2323 YV12_BUFFER_CONFIG alt_ref_buffer;
2324
2325 /*!
2326 * Tell if OVERLAY frame shows existing alt_ref frame.
2327 */
2328 int show_existing_alt_ref;
2329
2330 #if CONFIG_INTERNAL_STATS
2331 /*!\cond */
2332 uint64_t time_receive_data;
2333 uint64_t time_compress_data;
2334
2335 unsigned int mode_chosen_counts[MAX_MODES];
2336
2337 int count[2];
2338 uint64_t total_sq_error[2];
2339 uint64_t total_samples[2];
2340 ImageStat psnr[2];
2341
2342 double total_blockiness;
2343 double worst_blockiness;
2344
2345 int bytes;
2346 double summed_quality;
2347 double summed_weights;
2348 double summed_quality_hbd;
2349 double summed_weights_hbd;
2350 unsigned int tot_recode_hits;
2351 double worst_ssim;
2352 double worst_ssim_hbd;
2353
2354 ImageStat fastssim;
2355 ImageStat psnrhvs;
2356
2357 int b_calculate_blockiness;
2358 int b_calculate_consistency;
2359
2360 double total_inconsistency;
2361 double worst_consistency;
2362 Ssimv *ssim_vars;
2363 Metrics metrics;
2364 /*!\endcond */
2365 #endif
2366
2367 /*!
2368 * Calculates PSNR on each frame when set to 1.
2369 */
2370 int b_calculate_psnr;
2371
2372 #if CONFIG_SPEED_STATS
2373 /*!
2374 * For debugging: number of transform searches we have performed.
2375 */
2376 unsigned int tx_search_count;
2377 #endif // CONFIG_SPEED_STATS
2378
2379 /*!
2380 * When set, indicates that the frame is droppable, i.e., this frame
2381 * does not update any reference buffers.
2382 */
2383 int droppable;
2384
2385 /*!
2386 * Stores the frame parameters during encoder initialization.
2387 */
2388 FRAME_INFO frame_info;
2389
2390 /*!
2391 * Stores different types of frame indices.
2392 */
2393 FRAME_INDEX_SET frame_index_set;
2394
2395 /*!
2396 * Structure to store the dimensions of current frame.
2397 */
2398 InitialDimensions initial_dimensions;
2399
2400 /*!
2401 * Number of MBs in the full-size frame; to be used to
2402 * normalize the firstpass stats. This will differ from the
2403 * number of MBs in the current frame when the frame is
2404 * scaled.
2405 */
2406 int initial_mbs;
2407
2408 /*!
2409 * Resize related parameters.
2410 */
2411 ResizePendingParams resize_pending_params;
2412
2413 /*!
2414 * Pointer to struct holding adaptive data/contexts/models for the tile during
2415 * encoding.
2416 */
2417 TileDataEnc *tile_data;
2418 /*!
2419 * Number of tiles for which memory has been allocated for tile_data.
2420 */
2421 int allocated_tiles;
2422
2423 /*!
2424 * Structure to store the palette token related information.
2425 */
2426 TokenInfo token_info;
2427
2428 /*!
2429 * Sequence parameters have been transmitted already and locked
2430 * or not. Once locked av1_change_config cannot change the seq
2431 * parameters.
2432 */
2433 int seq_params_locked;
2434
2435 /*!
2436 * VARIANCE_AQ segment map refresh.
2437 */
2438 int vaq_refresh;
2439
2440 /*!
2441 * Thresholds for variance based partitioning.
2442 */
2443 VarBasedPartitionInfo vbp_info;
2444
2445 /*!
2446 * Probabilities for pruning of various AV1 tools.
2447 */
2448 FrameProbInfo frame_probs;
2449
2450 /*!
2451 * Multi-threading parameters.
2452 */
2453 MultiThreadInfo mt_info;
2454
2455 /*!
2456 * Specifies the frame to be output. It is valid only if show_existing_frame
2457 * is 1. When show_existing_frame is 0, existing_fb_idx_to_show is set to
2458 * INVALID_IDX.
2459 */
2460 int existing_fb_idx_to_show;
2461
2462 /*!
2463 * When set, indicates that internal ARFs are enabled.
2464 */
2465 int internal_altref_allowed;
2466
2467 /*!
2468 * A flag to indicate if intrabc is ever used in current frame.
2469 */
2470 int intrabc_used;
2471
2472 /*!
2473 * Tables to calculate IntraBC MV cost.
2474 */
2475 IntraBCMVCosts dv_costs;
2476
2477 /*!
2478 * Mark which ref frames can be skipped for encoding current frame during RDO.
2479 */
2480 int prune_ref_frame_mask;
2481
2482 /*!
2483 * Loop Restoration context.
2484 */
2485 AV1LrStruct lr_ctxt;
2486
2487 /*!
2488 * Pointer to list of tables with film grain parameters.
2489 */
2490 aom_film_grain_table_t *film_grain_table;
2491
2492 #if CONFIG_DENOISE
2493 /*!
2494 * Pointer to structure holding the denoised image buffers and the helper
2495 * noise models.
2496 */
2497 struct aom_denoise_and_model_t *denoise_and_model;
2498 #endif
2499
2500 /*!
2501 * Flags related to interpolation filter search.
2502 */
2503 InterpSearchFlags interp_search_flags;
2504
2505 /*!
2506 * Turn on screen content tools flag.
2507 * Note that some videos are not screen content videos, but
2508 * screen content tools could also improve coding efficiency.
2509 * For example, videos with large flat regions, gaming videos that look
2510 * like natural videos.
2511 */
2512 int use_screen_content_tools;
2513
2514 /*!
2515 * A flag to indicate "real" screen content videos.
2516 * For example, screen shares, screen editing.
2517 * This type is true indicates |use_screen_content_tools| must be true.
2518 * In addition, rate control strategy is adjusted when this flag is true.
2519 */
2520 int is_screen_content_type;
2521
2522 #if CONFIG_COLLECT_PARTITION_STATS
2523 /*!
2524 * Accumulates the partition timing stat over the whole frame.
2525 */
2526 FramePartitionTimingStats partition_stats;
2527 #endif // CONFIG_COLLECT_PARTITION_STATS
2528
2529 #if CONFIG_COLLECT_COMPONENT_TIMING
2530 /*!
2531 * component_time[] are initialized to zero while encoder starts.
2532 */
2533 uint64_t component_time[kTimingComponents];
2534 struct aom_usec_timer component_timer[kTimingComponents];
2535 /*!
2536 * frame_component_time[] are initialized to zero at beginning of each frame.
2537 */
2538 uint64_t frame_component_time[kTimingComponents];
2539 #endif
2540
2541 /*!
2542 * Parameters for AV1 bitstream levels.
2543 */
2544 AV1LevelParams level_params;
2545
2546 /*!
2547 * Whether any no-zero delta_q was actually used.
2548 */
2549 int deltaq_used;
2550
2551 /*!
2552 * Refrence frame distance related variables.
2553 */
2554 RefFrameDistanceInfo ref_frame_dist_info;
2555
2556 /*!
2557 * Scaling factors used in the RD multiplier modulation.
2558 * TODO(sdeng): consider merge the following arrays.
2559 * tpl_rdmult_scaling_factors is a temporary buffer used to store the
2560 * intermediate scaling factors which are used in the calculation of
2561 * tpl_sb_rdmult_scaling_factors. tpl_rdmult_scaling_factors[i] stores the
2562 * intermediate scaling factor of the ith 16 x 16 block in raster scan order.
2563 */
2564 double *tpl_rdmult_scaling_factors;
2565 /*!
2566 * tpl_sb_rdmult_scaling_factors[i] stores the RD multiplier scaling factor of
2567 * the ith 16 x 16 block in raster scan order.
2568 */
2569 double *tpl_sb_rdmult_scaling_factors;
2570 /*!
2571 * ssim_rdmult_scaling_factors[i] stores the RD multiplier scaling factor of
2572 * the ith 16 x 16 block in raster scan order. This scaling factor is used for
2573 * RD multiplier modulation when SSIM tuning is enabled.
2574 */
2575 double *ssim_rdmult_scaling_factors;
2576
2577 #if CONFIG_TUNE_VMAF
2578 /*!
2579 * Parameters for VMAF tuning.
2580 */
2581 TuneVMAFInfo vmaf_info;
2582 #endif
2583
2584 /*!
2585 * Indicates whether to use SVC.
2586 */
2587 int use_svc;
2588 /*!
2589 * Parameters for scalable video coding.
2590 */
2591 SVC svc;
2592
2593 /*!
2594 * Flag indicating whether look ahead processing (LAP) is enabled.
2595 */
2596 int lap_enabled;
2597 /*!
2598 * Indicates whether current processing stage is encode stage or LAP stage.
2599 */
2600 COMPRESSOR_STAGE compressor_stage;
2601
2602 /*!
2603 * Some motion vector stats from the last encoded frame to help us decide what
2604 * precision to use to encode the current frame.
2605 */
2606 MV_STATS mv_stats;
2607
2608 /*!
2609 * Frame type of the last frame. May be used in some heuristics for speeding
2610 * up the encoding.
2611 */
2612 FRAME_TYPE last_frame_type;
2613
2614 /*!
2615 * Number of tile-groups.
2616 */
2617 int num_tg;
2618
2619 /*!
2620 * Super-resolution mode currently being used by the encoder.
2621 * This may / may not be same as user-supplied mode in oxcf->superres_mode
2622 * (when we are recoding to try multiple options for example).
2623 */
2624 aom_superres_mode superres_mode;
2625
2626 /*!
2627 * First pass related data.
2628 */
2629 FirstPassData firstpass_data;
2630
2631 /*!
2632 * Temporal Noise Estimate
2633 */
2634 NOISE_ESTIMATE noise_estimate;
2635
2636 #if CONFIG_AV1_TEMPORAL_DENOISING
2637 /*!
2638 * Temporal Denoiser
2639 */
2640 AV1_DENOISER denoiser;
2641 #endif
2642
2643 /*!
2644 * Count on how many consecutive times a block uses small/zeromv for encoding
2645 * in a scale of 8x8 block.
2646 */
2647 uint8_t *consec_zero_mv;
2648
2649 /*!
2650 * Number of frames left to be encoded, is 0 if limit is not set.
2651 */
2652 int frames_left;
2653
2654 /*!
2655 * Block size of first pass encoding
2656 */
2657 BLOCK_SIZE fp_block_size;
2658 } AV1_COMP;
2659
2660 /*!
2661 * \brief Input frames and last input frame
2662 */
2663 typedef struct EncodeFrameInput {
2664 /*!\cond */
2665 YV12_BUFFER_CONFIG *source;
2666 YV12_BUFFER_CONFIG *last_source;
2667 int64_t ts_duration;
2668 /*!\endcond */
2669 } EncodeFrameInput;
2670
2671 /*!
2672 * \brief contains per-frame encoding parameters decided upon by
2673 * av1_encode_strategy() and passed down to av1_encode().
2674 */
2675 typedef struct EncodeFrameParams {
2676 /*!
2677 * Is error resilient mode enabled
2678 */
2679 int error_resilient_mode;
2680 /*!
2681 * Frame type (eg KF vs inter frame etc)
2682 */
2683 FRAME_TYPE frame_type;
2684
2685 /*!\cond */
2686 int primary_ref_frame;
2687 int order_offset;
2688
2689 /*!\endcond */
2690 /*!
2691 * Should the current frame be displayed after being decoded
2692 */
2693 int show_frame;
2694
2695 /*!\cond */
2696 int refresh_frame_flags;
2697
2698 int show_existing_frame;
2699 int existing_fb_idx_to_show;
2700
2701 /*!\endcond */
2702 /*!
2703 * Bitmask of which reference buffers may be referenced by this frame.
2704 */
2705 int ref_frame_flags;
2706
2707 /*!
2708 * Reference buffer assignment for this frame.
2709 */
2710 int remapped_ref_idx[REF_FRAMES];
2711
2712 /*!
2713 * Flags which determine which reference buffers are refreshed by this
2714 * frame.
2715 */
2716 RefreshFrameFlagsInfo refresh_frame;
2717
2718 /*!
2719 * Speed level to use for this frame: Bigger number means faster.
2720 */
2721 int speed;
2722 } EncodeFrameParams;
2723
2724 /*!\cond */
2725
2726 // EncodeFrameResults contains information about the result of encoding a
2727 // single frame
2728 typedef struct {
2729 size_t size; // Size of resulting bitstream
2730 } EncodeFrameResults;
2731
2732 // Must not be called more than once.
2733 void av1_initialize_enc(void);
2734
2735 struct AV1_COMP *av1_create_compressor(AV1EncoderConfig *oxcf,
2736 BufferPool *const pool,
2737 FIRSTPASS_STATS *frame_stats_buf,
2738 COMPRESSOR_STAGE stage,
2739 int num_lap_buffers,
2740 int lap_lag_in_frames,
2741 STATS_BUFFER_CTX *stats_buf_context);
2742 void av1_remove_compressor(AV1_COMP *cpi);
2743
2744 void av1_change_config(AV1_COMP *cpi, const AV1EncoderConfig *oxcf);
2745
2746 void av1_check_initial_width(AV1_COMP *cpi, int use_highbitdepth,
2747 int subsampling_x, int subsampling_y);
2748
2749 void av1_init_seq_coding_tools(SequenceHeader *seq, AV1_COMMON *cm,
2750 const AV1EncoderConfig *oxcf, int use_svc);
2751
2752 /*!\endcond */
2753
2754 /*!\brief Obtain the raw frame data
2755 *
2756 * \ingroup high_level_algo
2757 * This function receives the raw frame data from input.
2758 *
2759 * \param[in] cpi Top-level encoder structure
2760 * \param[in] frame_flags Flags to decide how to encoding the frame
2761 * \param[in] sd Contain raw frame data
2762 * \param[in] time_stamp Time stamp of the frame
2763 * \param[in] end_time_stamp End time stamp
2764 *
2765 * \return Returns a value to indicate if the frame data is received
2766 * successfully.
2767 * \note The caller can assume that a copy of this frame is made and not just a
2768 * copy of the pointer.
2769 */
2770 int av1_receive_raw_frame(AV1_COMP *cpi, aom_enc_frame_flags_t frame_flags,
2771 YV12_BUFFER_CONFIG *sd, int64_t time_stamp,
2772 int64_t end_time_stamp);
2773
2774 /*!\brief Encode a frame
2775 *
2776 * \ingroup high_level_algo
2777 * \callgraph
2778 * \callergraph
2779 * This function encodes the raw frame data, and outputs the frame bit stream
2780 * to the designated buffer. The caller should use the output parameters
2781 * *time_stamp and *time_end only when this function returns AOM_CODEC_OK.
2782 *
2783 * \param[in] cpi Top-level encoder structure
2784 * \param[in] frame_flags Flags to decide how to encoding the frame
2785 * \param[in] size Bitstream size
2786 * \param[in] dest Bitstream output
2787 * \param[out] time_stamp Time stamp of the frame
2788 * \param[out] time_end Time end
2789 * \param[in] flush Decide to encode one frame or the rest of frames
2790 * \param[in] timebase Time base used
2791 *
2792 * \return Returns a value to indicate if the encoding is done successfully.
2793 * \retval #AOM_CODEC_OK
2794 * \retval -1
2795 * No frame encoded; more input is required.
2796 * \retval #AOM_CODEC_ERROR
2797 */
2798 int av1_get_compressed_data(AV1_COMP *cpi, unsigned int *frame_flags,
2799 size_t *size, uint8_t *dest, int64_t *time_stamp,
2800 int64_t *time_end, int flush,
2801 const aom_rational64_t *timebase);
2802
2803 /*!\brief Run 1-pass/2-pass encoding
2804 *
2805 * \ingroup high_level_algo
2806 * \callgraph
2807 * \callergraph
2808 */
2809 int av1_encode(AV1_COMP *const cpi, uint8_t *const dest,
2810 const EncodeFrameInput *const frame_input,
2811 const EncodeFrameParams *const frame_params,
2812 EncodeFrameResults *const frame_results);
2813
2814 /*!\cond */
2815 int av1_get_preview_raw_frame(AV1_COMP *cpi, YV12_BUFFER_CONFIG *dest);
2816
2817 int av1_get_last_show_frame(AV1_COMP *cpi, YV12_BUFFER_CONFIG *frame);
2818
2819 aom_codec_err_t av1_copy_new_frame_enc(AV1_COMMON *cm,
2820 YV12_BUFFER_CONFIG *new_frame,
2821 YV12_BUFFER_CONFIG *sd);
2822
2823 int av1_use_as_reference(int *ext_ref_frame_flags, int ref_frame_flags);
2824
2825 int av1_copy_reference_enc(AV1_COMP *cpi, int idx, YV12_BUFFER_CONFIG *sd);
2826
2827 int av1_set_reference_enc(AV1_COMP *cpi, int idx, YV12_BUFFER_CONFIG *sd);
2828
2829 int av1_set_size_literal(AV1_COMP *cpi, int width, int height);
2830
2831 void av1_set_frame_size(AV1_COMP *cpi, int width, int height);
2832
2833 int av1_set_active_map(AV1_COMP *cpi, unsigned char *map, int rows, int cols);
2834
2835 int av1_get_active_map(AV1_COMP *cpi, unsigned char *map, int rows, int cols);
2836
2837 int av1_set_internal_size(AV1EncoderConfig *const oxcf,
2838 ResizePendingParams *resize_pending_params,
2839 AOM_SCALING horiz_mode, AOM_SCALING vert_mode);
2840
2841 int av1_get_quantizer(struct AV1_COMP *cpi);
2842
2843 int av1_convert_sect5obus_to_annexb(uint8_t *buffer, size_t *input_size);
2844
2845 // Set screen content options.
2846 // This function estimates whether to use screen content tools, by counting
2847 // the portion of blocks that have few luma colors.
2848 // Modifies:
2849 // cpi->commom.features.allow_screen_content_tools
2850 // cpi->common.features.allow_intrabc
2851 // cpi->use_screen_content_tools
2852 // cpi->is_screen_content_type
2853 // However, the estimation is not accurate and may misclassify videos.
2854 // A slower but more accurate approach that determines whether to use screen
2855 // content tools is employed later. See av1_determine_sc_tools_with_encoding().
2856 void av1_set_screen_content_options(struct AV1_COMP *cpi,
2857 FeatureFlags *features);
2858
2859 void av1_update_frame_size(AV1_COMP *cpi);
2860
2861 // TODO(jingning): Move these functions as primitive members for the new cpi
2862 // class.
stack_push(int * stack,int * stack_size,int item)2863 static INLINE void stack_push(int *stack, int *stack_size, int item) {
2864 for (int i = *stack_size - 1; i >= 0; --i) stack[i + 1] = stack[i];
2865 stack[0] = item;
2866 ++*stack_size;
2867 }
2868
stack_pop(int * stack,int * stack_size)2869 static INLINE int stack_pop(int *stack, int *stack_size) {
2870 if (*stack_size <= 0) return -1;
2871
2872 int item = stack[0];
2873 for (int i = 0; i < *stack_size; ++i) stack[i] = stack[i + 1];
2874 --*stack_size;
2875
2876 return item;
2877 }
2878
stack_pop_end(int * stack,int * stack_size)2879 static INLINE int stack_pop_end(int *stack, int *stack_size) {
2880 int item = stack[*stack_size - 1];
2881 stack[*stack_size - 1] = -1;
2882 --*stack_size;
2883
2884 return item;
2885 }
2886
stack_reset(int * stack,int * stack_size)2887 static INLINE void stack_reset(int *stack, int *stack_size) {
2888 for (int i = 0; i < *stack_size; ++i) stack[i] = INVALID_IDX;
2889 *stack_size = 0;
2890 }
2891
2892 // av1 uses 10,000,000 ticks/second as time stamp
2893 #define TICKS_PER_SEC 10000000LL
2894
2895 static INLINE int64_t
timebase_units_to_ticks(const aom_rational64_t * timestamp_ratio,int64_t n)2896 timebase_units_to_ticks(const aom_rational64_t *timestamp_ratio, int64_t n) {
2897 return n * timestamp_ratio->num / timestamp_ratio->den;
2898 }
2899
2900 static INLINE int64_t
ticks_to_timebase_units(const aom_rational64_t * timestamp_ratio,int64_t n)2901 ticks_to_timebase_units(const aom_rational64_t *timestamp_ratio, int64_t n) {
2902 int64_t round = timestamp_ratio->num / 2;
2903 if (round > 0) --round;
2904 return (n * timestamp_ratio->den + round) / timestamp_ratio->num;
2905 }
2906
frame_is_kf_gf_arf(const AV1_COMP * cpi)2907 static INLINE int frame_is_kf_gf_arf(const AV1_COMP *cpi) {
2908 const GF_GROUP *const gf_group = &cpi->gf_group;
2909 const FRAME_UPDATE_TYPE update_type = gf_group->update_type[gf_group->index];
2910
2911 return frame_is_intra_only(&cpi->common) || update_type == ARF_UPDATE ||
2912 update_type == GF_UPDATE;
2913 }
2914
2915 // TODO(huisu@google.com, youzhou@microsoft.com): enable hash-me for HBD.
av1_use_hash_me(const AV1_COMP * const cpi)2916 static INLINE int av1_use_hash_me(const AV1_COMP *const cpi) {
2917 return (cpi->common.features.allow_screen_content_tools &&
2918 cpi->common.features.allow_intrabc &&
2919 frame_is_intra_only(&cpi->common));
2920 }
2921
get_ref_frame_yv12_buf(const AV1_COMMON * const cm,MV_REFERENCE_FRAME ref_frame)2922 static INLINE const YV12_BUFFER_CONFIG *get_ref_frame_yv12_buf(
2923 const AV1_COMMON *const cm, MV_REFERENCE_FRAME ref_frame) {
2924 const RefCntBuffer *const buf = get_ref_frame_buf(cm, ref_frame);
2925 return buf != NULL ? &buf->buf : NULL;
2926 }
2927
enc_is_ref_frame_buf(const AV1_COMMON * const cm,const RefCntBuffer * const frame_buf)2928 static INLINE int enc_is_ref_frame_buf(const AV1_COMMON *const cm,
2929 const RefCntBuffer *const frame_buf) {
2930 MV_REFERENCE_FRAME ref_frame;
2931 for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) {
2932 const RefCntBuffer *const buf = get_ref_frame_buf(cm, ref_frame);
2933 if (buf == NULL) continue;
2934 if (frame_buf == buf) break;
2935 }
2936 return (ref_frame <= ALTREF_FRAME);
2937 }
2938
alloc_frame_mvs(AV1_COMMON * const cm,RefCntBuffer * buf)2939 static INLINE void alloc_frame_mvs(AV1_COMMON *const cm, RefCntBuffer *buf) {
2940 assert(buf != NULL);
2941 ensure_mv_buffer(buf, cm);
2942 buf->width = cm->width;
2943 buf->height = cm->height;
2944 }
2945
2946 // Get the allocated token size for a tile. It does the same calculation as in
2947 // the frame token allocation.
allocated_tokens(TileInfo tile,int sb_size_log2,int num_planes)2948 static INLINE unsigned int allocated_tokens(TileInfo tile, int sb_size_log2,
2949 int num_planes) {
2950 int tile_mb_rows = (tile.mi_row_end - tile.mi_row_start + 2) >> 2;
2951 int tile_mb_cols = (tile.mi_col_end - tile.mi_col_start + 2) >> 2;
2952
2953 return get_token_alloc(tile_mb_rows, tile_mb_cols, sb_size_log2, num_planes);
2954 }
2955
get_start_tok(AV1_COMP * cpi,int tile_row,int tile_col,int mi_row,TokenExtra ** tok,int sb_size_log2,int num_planes)2956 static INLINE void get_start_tok(AV1_COMP *cpi, int tile_row, int tile_col,
2957 int mi_row, TokenExtra **tok, int sb_size_log2,
2958 int num_planes) {
2959 AV1_COMMON *const cm = &cpi->common;
2960 const int tile_cols = cm->tiles.cols;
2961 TileDataEnc *this_tile = &cpi->tile_data[tile_row * tile_cols + tile_col];
2962 const TileInfo *const tile_info = &this_tile->tile_info;
2963
2964 const int tile_mb_cols =
2965 (tile_info->mi_col_end - tile_info->mi_col_start + 2) >> 2;
2966 const int tile_mb_row = (mi_row - tile_info->mi_row_start + 2) >> 2;
2967
2968 *tok = cpi->token_info.tile_tok[tile_row][tile_col] +
2969 get_token_alloc(tile_mb_row, tile_mb_cols, sb_size_log2, num_planes);
2970 }
2971
2972 void av1_apply_encoding_flags(AV1_COMP *cpi, aom_enc_frame_flags_t flags);
2973
2974 #define ALT_MIN_LAG 3
is_altref_enabled(int lag_in_frames,bool enable_auto_arf)2975 static INLINE int is_altref_enabled(int lag_in_frames, bool enable_auto_arf) {
2976 return lag_in_frames >= ALT_MIN_LAG && enable_auto_arf;
2977 }
2978
2979 // Check if statistics generation stage
is_stat_generation_stage(const AV1_COMP * const cpi)2980 static INLINE int is_stat_generation_stage(const AV1_COMP *const cpi) {
2981 assert(IMPLIES(cpi->compressor_stage == LAP_STAGE,
2982 cpi->oxcf.pass == 0 && cpi->lap_enabled));
2983 return (cpi->oxcf.pass == 1 || (cpi->compressor_stage == LAP_STAGE));
2984 }
2985 // Check if statistics consumption stage
is_stat_consumption_stage_twopass(const AV1_COMP * const cpi)2986 static INLINE int is_stat_consumption_stage_twopass(const AV1_COMP *const cpi) {
2987 return (cpi->oxcf.pass == 2);
2988 }
2989
2990 // Check if statistics consumption stage
is_stat_consumption_stage(const AV1_COMP * const cpi)2991 static INLINE int is_stat_consumption_stage(const AV1_COMP *const cpi) {
2992 return (is_stat_consumption_stage_twopass(cpi) ||
2993 (cpi->oxcf.pass == 0 && (cpi->compressor_stage == ENCODE_STAGE) &&
2994 cpi->lap_enabled));
2995 }
2996
2997 /*!\endcond */
2998 /*!\brief Check if the current stage has statistics
2999 *
3000 *\ingroup two_pass_algo
3001 *
3002 * \param[in] cpi Top - level encoder instance structure
3003 *
3004 * \return 0 if no stats for current stage else 1
3005 */
has_no_stats_stage(const AV1_COMP * const cpi)3006 static INLINE int has_no_stats_stage(const AV1_COMP *const cpi) {
3007 assert(IMPLIES(!cpi->lap_enabled, cpi->compressor_stage == ENCODE_STAGE));
3008 return (cpi->oxcf.pass == 0 && !cpi->lap_enabled);
3009 }
3010 /*!\cond */
3011
3012 // Function return size of frame stats buffer
get_stats_buf_size(int num_lap_buffer,int num_lag_buffer)3013 static INLINE int get_stats_buf_size(int num_lap_buffer, int num_lag_buffer) {
3014 /* if lookahead is enabled return num_lap_buffers else num_lag_buffers */
3015 return (num_lap_buffer > 0 ? num_lap_buffer + 1 : num_lag_buffer);
3016 }
3017
3018 // TODO(zoeliu): To set up cpi->oxcf.gf_cfg.enable_auto_brf
3019
set_ref_ptrs(const AV1_COMMON * cm,MACROBLOCKD * xd,MV_REFERENCE_FRAME ref0,MV_REFERENCE_FRAME ref1)3020 static INLINE void set_ref_ptrs(const AV1_COMMON *cm, MACROBLOCKD *xd,
3021 MV_REFERENCE_FRAME ref0,
3022 MV_REFERENCE_FRAME ref1) {
3023 xd->block_ref_scale_factors[0] =
3024 get_ref_scale_factors_const(cm, ref0 >= LAST_FRAME ? ref0 : 1);
3025 xd->block_ref_scale_factors[1] =
3026 get_ref_scale_factors_const(cm, ref1 >= LAST_FRAME ? ref1 : 1);
3027 }
3028
get_chessboard_index(int frame_index)3029 static INLINE int get_chessboard_index(int frame_index) {
3030 return frame_index & 0x1;
3031 }
3032
cond_cost_list_const(const struct AV1_COMP * cpi,const int * cost_list)3033 static INLINE const int *cond_cost_list_const(const struct AV1_COMP *cpi,
3034 const int *cost_list) {
3035 const int use_cost_list = cpi->sf.mv_sf.subpel_search_method != SUBPEL_TREE &&
3036 cpi->sf.mv_sf.use_fullpel_costlist;
3037 return use_cost_list ? cost_list : NULL;
3038 }
3039
cond_cost_list(const struct AV1_COMP * cpi,int * cost_list)3040 static INLINE int *cond_cost_list(const struct AV1_COMP *cpi, int *cost_list) {
3041 const int use_cost_list = cpi->sf.mv_sf.subpel_search_method != SUBPEL_TREE &&
3042 cpi->sf.mv_sf.use_fullpel_costlist;
3043 return use_cost_list ? cost_list : NULL;
3044 }
3045
3046 // Compression ratio of current frame.
3047 double av1_get_compression_ratio(const AV1_COMMON *const cm,
3048 size_t encoded_frame_size);
3049
3050 void av1_new_framerate(AV1_COMP *cpi, double framerate);
3051
3052 void av1_setup_frame_size(AV1_COMP *cpi);
3053
3054 #define LAYER_IDS_TO_IDX(sl, tl, num_tl) ((sl) * (num_tl) + (tl))
3055
3056 // Returns 1 if a frame is scaled and 0 otherwise.
av1_resize_scaled(const AV1_COMMON * cm)3057 static INLINE int av1_resize_scaled(const AV1_COMMON *cm) {
3058 return !(cm->superres_upscaled_width == cm->render_width &&
3059 cm->superres_upscaled_height == cm->render_height);
3060 }
3061
av1_frame_scaled(const AV1_COMMON * cm)3062 static INLINE int av1_frame_scaled(const AV1_COMMON *cm) {
3063 return !av1_superres_scaled(cm) && av1_resize_scaled(cm);
3064 }
3065
3066 // Don't allow a show_existing_frame to coincide with an error resilient
3067 // frame. An exception can be made for a forward keyframe since it has no
3068 // previous dependencies.
encode_show_existing_frame(const AV1_COMMON * cm)3069 static INLINE int encode_show_existing_frame(const AV1_COMMON *cm) {
3070 return cm->show_existing_frame && (!cm->features.error_resilient_mode ||
3071 cm->current_frame.frame_type == KEY_FRAME);
3072 }
3073
3074 // Get index into the 'cpi->mbmi_ext_info.frame_base' array for the given
3075 // 'mi_row' and 'mi_col'.
get_mi_ext_idx(const int mi_row,const int mi_col,const BLOCK_SIZE mi_alloc_bsize,const int mbmi_ext_stride)3076 static INLINE int get_mi_ext_idx(const int mi_row, const int mi_col,
3077 const BLOCK_SIZE mi_alloc_bsize,
3078 const int mbmi_ext_stride) {
3079 const int mi_ext_size_1d = mi_size_wide[mi_alloc_bsize];
3080 const int mi_ext_row = mi_row / mi_ext_size_1d;
3081 const int mi_ext_col = mi_col / mi_ext_size_1d;
3082 return mi_ext_row * mbmi_ext_stride + mi_ext_col;
3083 }
3084
3085 // Lighter version of set_offsets that only sets the mode info
3086 // pointers.
set_mode_info_offsets(const CommonModeInfoParams * const mi_params,const MBMIExtFrameBufferInfo * const mbmi_ext_info,MACROBLOCK * const x,MACROBLOCKD * const xd,int mi_row,int mi_col)3087 static INLINE void set_mode_info_offsets(
3088 const CommonModeInfoParams *const mi_params,
3089 const MBMIExtFrameBufferInfo *const mbmi_ext_info, MACROBLOCK *const x,
3090 MACROBLOCKD *const xd, int mi_row, int mi_col) {
3091 set_mi_offsets(mi_params, xd, mi_row, mi_col);
3092 const int ext_idx = get_mi_ext_idx(mi_row, mi_col, mi_params->mi_alloc_bsize,
3093 mbmi_ext_info->stride);
3094 x->mbmi_ext_frame = mbmi_ext_info->frame_base + ext_idx;
3095 }
3096
3097 // Check to see if the given partition size is allowed for a specified number
3098 // of mi block rows and columns remaining in the image.
3099 // If not then return the largest allowed partition size
find_partition_size(BLOCK_SIZE bsize,int rows_left,int cols_left,int * bh,int * bw)3100 static INLINE BLOCK_SIZE find_partition_size(BLOCK_SIZE bsize, int rows_left,
3101 int cols_left, int *bh, int *bw) {
3102 int int_size = (int)bsize;
3103 if (rows_left <= 0 || cols_left <= 0) {
3104 return AOMMIN(bsize, BLOCK_8X8);
3105 } else {
3106 for (; int_size > 0; int_size -= 3) {
3107 *bh = mi_size_high[int_size];
3108 *bw = mi_size_wide[int_size];
3109 if ((*bh <= rows_left) && (*bw <= cols_left)) {
3110 break;
3111 }
3112 }
3113 }
3114 return (BLOCK_SIZE)int_size;
3115 }
3116
3117 static const uint8_t av1_ref_frame_flag_list[REF_FRAMES] = { 0,
3118 AOM_LAST_FLAG,
3119 AOM_LAST2_FLAG,
3120 AOM_LAST3_FLAG,
3121 AOM_GOLD_FLAG,
3122 AOM_BWD_FLAG,
3123 AOM_ALT2_FLAG,
3124 AOM_ALT_FLAG };
3125
3126 // When more than 'max_allowed_refs' are available, we reduce the number of
3127 // reference frames one at a time based on this order.
3128 static const MV_REFERENCE_FRAME disable_order[] = {
3129 LAST3_FRAME,
3130 LAST2_FRAME,
3131 ALTREF2_FRAME,
3132 GOLDEN_FRAME,
3133 };
3134
3135 static const MV_REFERENCE_FRAME
3136 ref_frame_priority_order[INTER_REFS_PER_FRAME] = {
3137 LAST_FRAME, ALTREF_FRAME, BWDREF_FRAME, GOLDEN_FRAME,
3138 ALTREF2_FRAME, LAST2_FRAME, LAST3_FRAME,
3139 };
3140
get_ref_frame_flags(const SPEED_FEATURES * const sf,const YV12_BUFFER_CONFIG ** ref_frames,const int ext_ref_frame_flags)3141 static INLINE int get_ref_frame_flags(const SPEED_FEATURES *const sf,
3142 const YV12_BUFFER_CONFIG **ref_frames,
3143 const int ext_ref_frame_flags) {
3144 // cpi->ext_flags.ref_frame_flags allows certain reference types to be
3145 // disabled by the external interface. These are set by
3146 // av1_apply_encoding_flags(). Start with what the external interface allows,
3147 // then suppress any reference types which we have found to be duplicates.
3148 int flags = ext_ref_frame_flags;
3149
3150 for (int i = 1; i < INTER_REFS_PER_FRAME; ++i) {
3151 const YV12_BUFFER_CONFIG *const this_ref = ref_frames[i];
3152 // If this_ref has appeared before, mark the corresponding ref frame as
3153 // invalid. For nonrd mode, only disable GOLDEN_FRAME if it's the same
3154 // as LAST_FRAME or ALTREF_FRAME (if ALTREF is being used in nonrd).
3155 int index = (sf->rt_sf.use_nonrd_pick_mode &&
3156 ref_frame_priority_order[i] == GOLDEN_FRAME)
3157 ? (1 + sf->rt_sf.use_nonrd_altref_frame)
3158 : i;
3159 for (int j = 0; j < index; ++j) {
3160 if (this_ref == ref_frames[j]) {
3161 flags &= ~(1 << (ref_frame_priority_order[i] - 1));
3162 break;
3163 }
3164 }
3165 }
3166 return flags;
3167 }
3168
3169 // Returns a Sequence Header OBU stored in an aom_fixed_buf_t, or NULL upon
3170 // failure. When a non-NULL aom_fixed_buf_t pointer is returned by this
3171 // function, the memory must be freed by the caller. Both the buf member of the
3172 // aom_fixed_buf_t, and the aom_fixed_buf_t pointer itself must be freed. Memory
3173 // returned must be freed via call to free().
3174 //
3175 // Note: The OBU returned is in Low Overhead Bitstream Format. Specifically,
3176 // the obu_has_size_field bit is set, and the buffer contains the obu_size
3177 // field.
3178 aom_fixed_buf_t *av1_get_global_headers(AV1_COMP *cpi);
3179
3180 #define MAX_GFUBOOST_FACTOR 10.0
3181 #define MIN_GFUBOOST_FACTOR 4.0
3182
is_frame_tpl_eligible(const GF_GROUP * const gf_group,uint8_t index)3183 static INLINE int is_frame_tpl_eligible(const GF_GROUP *const gf_group,
3184 uint8_t index) {
3185 const FRAME_UPDATE_TYPE update_type = gf_group->update_type[index];
3186 return update_type == ARF_UPDATE || update_type == GF_UPDATE ||
3187 update_type == KF_UPDATE;
3188 }
3189
is_frame_eligible_for_ref_pruning(const GF_GROUP * gf_group,int selective_ref_frame,int prune_ref_frames,int gf_index)3190 static INLINE int is_frame_eligible_for_ref_pruning(const GF_GROUP *gf_group,
3191 int selective_ref_frame,
3192 int prune_ref_frames,
3193 int gf_index) {
3194 return (selective_ref_frame > 0) && (prune_ref_frames > 0) &&
3195 !is_frame_tpl_eligible(gf_group, gf_index);
3196 }
3197
3198 // Get update type of the current frame.
3199 static INLINE FRAME_UPDATE_TYPE
get_frame_update_type(const GF_GROUP * gf_group)3200 get_frame_update_type(const GF_GROUP *gf_group) {
3201 return gf_group->update_type[gf_group->index];
3202 }
3203
av1_pixels_to_mi(int pixels)3204 static INLINE int av1_pixels_to_mi(int pixels) {
3205 return ALIGN_POWER_OF_TWO(pixels, 3) >> MI_SIZE_LOG2;
3206 }
3207
is_psnr_calc_enabled(const AV1_COMP * cpi)3208 static AOM_INLINE int is_psnr_calc_enabled(const AV1_COMP *cpi) {
3209 const AV1_COMMON *const cm = &cpi->common;
3210
3211 return cpi->b_calculate_psnr && !is_stat_generation_stage(cpi) &&
3212 cm->show_frame;
3213 }
3214
3215 #if CONFIG_AV1_TEMPORAL_DENOISING
denoise_svc(const struct AV1_COMP * const cpi)3216 static INLINE int denoise_svc(const struct AV1_COMP *const cpi) {
3217 return (!cpi->use_svc || (cpi->use_svc && cpi->svc.spatial_layer_id >=
3218 cpi->svc.first_layer_denoise));
3219 }
3220 #endif
3221
3222 #if CONFIG_COLLECT_PARTITION_STATS == 2
av1_print_fr_partition_timing_stats(const FramePartitionTimingStats * part_stats,const char * filename)3223 static INLINE void av1_print_fr_partition_timing_stats(
3224 const FramePartitionTimingStats *part_stats, const char *filename) {
3225 FILE *f = fopen(filename, "w");
3226 if (!f) {
3227 return;
3228 }
3229
3230 fprintf(f, "bsize,redo,");
3231 for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
3232 fprintf(f, "decision_%d,", part);
3233 }
3234 for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
3235 fprintf(f, "attempt_%d,", part);
3236 }
3237 for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
3238 fprintf(f, "time_%d,", part);
3239 }
3240 fprintf(f, "\n");
3241
3242 static const int bsizes[6] = { 128, 64, 32, 16, 8, 4 };
3243
3244 for (int bsize_idx = 0; bsize_idx < 6; bsize_idx++) {
3245 fprintf(f, "%d,%d,", bsizes[bsize_idx], part_stats->partition_redo);
3246 for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
3247 fprintf(f, "%d,", part_stats->partition_decisions[bsize_idx][part]);
3248 }
3249 for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
3250 fprintf(f, "%d,", part_stats->partition_attempts[bsize_idx][part]);
3251 }
3252 for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
3253 fprintf(f, "%ld,", part_stats->partition_times[bsize_idx][part]);
3254 }
3255 fprintf(f, "\n");
3256 }
3257 fclose(f);
3258 }
3259 #endif // CONFIG_COLLECT_PARTITION_STATS == 2
3260
3261 #if CONFIG_COLLECT_PARTITION_STATS
av1_get_bsize_idx_for_part_stats(BLOCK_SIZE bsize)3262 static INLINE int av1_get_bsize_idx_for_part_stats(BLOCK_SIZE bsize) {
3263 assert(bsize == BLOCK_128X128 || bsize == BLOCK_64X64 ||
3264 bsize == BLOCK_32X32 || bsize == BLOCK_16X16 || bsize == BLOCK_8X8 ||
3265 bsize == BLOCK_4X4);
3266 switch (bsize) {
3267 case BLOCK_128X128: return 0;
3268 case BLOCK_64X64: return 1;
3269 case BLOCK_32X32: return 2;
3270 case BLOCK_16X16: return 3;
3271 case BLOCK_8X8: return 4;
3272 case BLOCK_4X4: return 5;
3273 default: assert(0 && "Invalid bsize for partition_stats."); return -1;
3274 }
3275 }
3276 #endif // CONFIG_COLLECT_PARTITION_STATS
3277
3278 #if CONFIG_COLLECT_COMPONENT_TIMING
start_timing(AV1_COMP * cpi,int component)3279 static INLINE void start_timing(AV1_COMP *cpi, int component) {
3280 aom_usec_timer_start(&cpi->component_timer[component]);
3281 }
end_timing(AV1_COMP * cpi,int component)3282 static INLINE void end_timing(AV1_COMP *cpi, int component) {
3283 aom_usec_timer_mark(&cpi->component_timer[component]);
3284 cpi->frame_component_time[component] +=
3285 aom_usec_timer_elapsed(&cpi->component_timer[component]);
3286 }
get_frame_type_enum(int type)3287 static INLINE char const *get_frame_type_enum(int type) {
3288 switch (type) {
3289 case 0: return "KEY_FRAME";
3290 case 1: return "INTER_FRAME";
3291 case 2: return "INTRA_ONLY_FRAME";
3292 case 3: return "S_FRAME";
3293 default: assert(0);
3294 }
3295 return "error";
3296 }
3297 #endif
3298
3299 /*!\endcond */
3300
3301 #ifdef __cplusplus
3302 } // extern "C"
3303 #endif
3304
3305 #endif // AOM_AV1_ENCODER_ENCODER_H_
3306