AOMedia AV1 Codec: av1/encoder/encoder.h Source File

| AOMedia AV1 Codec

encoder.h
Go to the documentation of this file.
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
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
34#include "av1/encoder/aq_cyclicrefresh.h"
35#include "av1/encoder/av1_quantize.h"
36#include "av1/encoder/block.h"
37#include "av1/encoder/context_tree.h"
38#include "av1/encoder/encodemb.h"
39#include "av1/encoder/external_partition.h"
40#include "av1/encoder/firstpass.h"
41#include "av1/encoder/global_motion.h"
42#include "av1/encoder/level.h"
43#include "av1/encoder/lookahead.h"
44#include "av1/encoder/mcomp.h"
45#include "av1/encoder/pickcdef.h"
46#include "av1/encoder/ratectrl.h"
47#include "av1/encoder/rd.h"
48#include "av1/encoder/speed_features.h"
49#include "av1/encoder/svc_layercontext.h"
50#include "av1/encoder/temporal_filter.h"
51#include "av1/encoder/thirdpass.h"
52#include "av1/encoder/tokenize.h"
53#include "av1/encoder/tpl_model.h"
54#include "av1/encoder/av1_noise_estimate.h"
55#include "av1/encoder/bitstream.h"
56
57#if CONFIG_INTERNAL_STATS
58#include "aom_dsp/ssim.h"
59#endif
60#include "aom_dsp/variance.h"
61#if CONFIG_DENOISE
62#include "aom_dsp/noise_model.h"
63#endif
64#if CONFIG_TUNE_VMAF
65#include "av1/encoder/tune_vmaf.h"
66#endif
67#if CONFIG_AV1_TEMPORAL_DENOISING
68#include "av1/encoder/av1_temporal_denoiser.h"
69#endif
70#if CONFIG_TUNE_BUTTERAUGLI
71#include "av1/encoder/tune_butteraugli.h"
72#endif
73
74#include "aom/internal/aom_codec_internal.h"
75#include "aom_util/aom_thread.h"
76
77#ifdef __cplusplus
78extern "C" {
79#endif
80
81// TODO(yunqing, any): Added suppression tag to quiet Doxygen warnings. Need to
82// adjust it while we work on documentation.
84// Number of frames required to test for scene cut detection
85#define SCENE_CUT_KEY_TEST_INTERVAL 16
86
87// Lookahead index threshold to enable temporal filtering for second arf.
88#define TF_LOOKAHEAD_IDX_THR 7
89
90#define HDR_QP_LEVELS 10
91#define CHROMA_CB_QP_SCALE 1.04
92#define CHROMA_CR_QP_SCALE 1.04
93#define CHROMA_QP_SCALE -0.46
94#define CHROMA_QP_OFFSET 9.26
95#define QP_SCALE_FACTOR 2.0
96#define DISABLE_HDR_LUMA_DELTAQ 1
97
98// Rational number with an int64 numerator
99// This structure holds a fractional value
100typedef struct aom_rational64 {
101 int64_t num; // fraction numerator
102 int den; // fraction denominator
103} aom_rational64_t; // alias for struct aom_rational
104
105enum {
106 NORMAL = 0,
107 FOURFIVE = 1,
108 THREEFIVE = 2,
109 THREEFOUR = 3,
110 ONEFOUR = 4,
111 ONEEIGHT = 5,
112 ONETWO = 6
113} UENUM1BYTE(AOM_SCALING);
114
115enum {
116 // Good Quality Fast Encoding. The encoder balances quality with the amount of
117 // time it takes to encode the output. Speed setting controls how fast.
118 GOOD,
119 // Realtime Fast Encoding. Will force some restrictions on bitrate
120 // constraints.
121 REALTIME,
122 // All intra mode. All the frames are coded as intra frames.
123 ALLINTRA
124} UENUM1BYTE(MODE);
125
126enum {
127 FRAMEFLAGS_KEY = 1 << 0,
128 FRAMEFLAGS_GOLDEN = 1 << 1,
129 FRAMEFLAGS_BWDREF = 1 << 2,
130 // TODO(zoeliu): To determine whether a frame flag is needed for ALTREF2_FRAME
131 FRAMEFLAGS_ALTREF = 1 << 3,
132 FRAMEFLAGS_INTRAONLY = 1 << 4,
133 FRAMEFLAGS_SWITCH = 1 << 5,
134 FRAMEFLAGS_ERROR_RESILIENT = 1 << 6,
135} UENUM1BYTE(FRAMETYPE_FLAGS);
136
137#if CONFIG_FRAME_PARALLEL_ENCODE
138#if CONFIG_FPMT_TEST
139enum {
140 PARALLEL_ENCODE = 0,
141 PARALLEL_SIMULATION_ENCODE,
142 NUM_FPMT_TEST_ENCODES
143} UENUM1BYTE(FPMT_TEST_ENC_CFG);
144#endif
145// 0 level frames are sometimes used for rate control purposes, but for
146// reference mapping purposes, the minimum level should be 1.
147#define MIN_PYR_LEVEL 1
148static INLINE int get_true_pyr_level(int frame_level, int frame_order,
149 int max_layer_depth) {
150 if (frame_order == 0) {
151 // Keyframe case
152 return MIN_PYR_LEVEL;
153 } else if (frame_level == MAX_ARF_LAYERS) {
154 // Leaves
155 return max_layer_depth;
156 } else if (frame_level == (MAX_ARF_LAYERS + 1)) {
157 // Altrefs
158 return MIN_PYR_LEVEL;
159 }
160 return AOMMAX(MIN_PYR_LEVEL, frame_level);
161}
162#endif // CONFIG_FRAME_PARALLEL_ENCODE
163
164enum {
165 NO_AQ = 0,
166 VARIANCE_AQ = 1,
167 COMPLEXITY_AQ = 2,
168 CYCLIC_REFRESH_AQ = 3,
169 AQ_MODE_COUNT // This should always be the last member of the enum
170} UENUM1BYTE(AQ_MODE);
171enum {
172 NO_DELTA_Q = 0,
173 DELTA_Q_OBJECTIVE = 1, // Modulation to improve objective quality
174 DELTA_Q_PERCEPTUAL = 2, // Modulation to improve video perceptual quality
175 DELTA_Q_PERCEPTUAL_AI = 3, // Perceptual quality opt for all intra mode
176 DELTA_Q_USER_RATING_BASED = 4, // User rating based delta q mode
177 DELTA_Q_HDR = 5, // QP adjustment based on HDR block pixel average
178 DELTA_Q_MODE_COUNT // This should always be the last member of the enum
179} UENUM1BYTE(DELTAQ_MODE);
180
181enum {
182 RESIZE_NONE = 0, // No frame resizing allowed.
183 RESIZE_FIXED = 1, // All frames are coded at the specified scale.
184 RESIZE_RANDOM = 2, // All frames are coded at a random scale.
185 RESIZE_DYNAMIC = 3, // Frames coded at lower scale based on rate control.
186 RESIZE_MODES
187} UENUM1BYTE(RESIZE_MODE);
188
189enum {
190 SS_CFG_SRC = 0,
191 SS_CFG_LOOKAHEAD = 1,
192 SS_CFG_FPF = 2,
193 SS_CFG_TOTAL = 3
194} UENUM1BYTE(SS_CFG_OFFSET);
195
196enum {
197 DISABLE_SCENECUT, // For LAP, lag_in_frames < 19
198 ENABLE_SCENECUT_MODE_1, // For LAP, lag_in_frames >=19 and < 33
199 ENABLE_SCENECUT_MODE_2 // For twopass and LAP - lag_in_frames >=33
200} UENUM1BYTE(SCENECUT_MODE);
201
202#define MAX_VBR_CORPUS_COMPLEXITY 10000
203
206typedef enum {
207 MOD_FP, // First pass
208 MOD_TF, // Temporal filtering
209 MOD_TPL, // TPL
210 MOD_GME, // Global motion estimation
211 MOD_ENC, // Encode stage
212 MOD_LPF, // Deblocking loop filter
213 MOD_CDEF_SEARCH, // CDEF search
214 MOD_CDEF, // CDEF frame
215 MOD_LR, // Loop restoration filtering
216 MOD_PACK_BS, // Pack bitstream
217 MOD_FRAME_ENC, // Frame Parallel encode
218 NUM_MT_MODULES
219} MULTI_THREADED_MODULES;
220
226typedef enum {
227 COST_UPD_SB,
228 COST_UPD_SBROW,
229 COST_UPD_TILE,
230 COST_UPD_OFF,
231} COST_UPDATE_TYPE;
232
236typedef enum {
237 LOOPFILTER_NONE = 0,
238 LOOPFILTER_ALL = 1,
239 LOOPFILTER_REFERENCE = 2,
240 LOOPFILTER_SELECTIVELY =
241 3,
242} LOOPFILTER_CONTROL;
243
247typedef struct {
251 RESIZE_MODE resize_mode;
256 uint8_t resize_scale_denominator;
261 uint8_t resize_kf_scale_denominator;
262} ResizeCfg;
263
267typedef struct {
271 bool enable_rect_partitions;
275 bool enable_ab_partitions;
279 bool enable_1to4_partitions;
284 BLOCK_SIZE min_partition_size;
289 BLOCK_SIZE max_partition_size;
290} PartitionCfg;
291
295typedef struct {
299 bool enable_intra_edge_filter;
304 bool enable_filter_intra;
308 bool enable_smooth_intra;
312 bool enable_paeth_intra;
316 bool enable_cfl_intra;
320 bool enable_directional_intra;
325 bool enable_diagonal_intra;
330 bool enable_angle_delta;
331} IntraModeCfg;
332
336typedef struct {
340 bool enable_tx64;
344 bool enable_flip_idtx;
348 bool enable_rect_tx;
353 bool reduced_tx_type_set;
358 bool use_intra_dct_only;
363 bool use_inter_dct_only;
368 bool use_intra_default_tx_only;
372 bool enable_tx_size_search;
373} TxfmSizeTypeCfg;
374
378typedef struct {
382 bool enable_dist_wtd_comp;
387 bool enable_masked_comp;
391 bool enable_smooth_interintra;
395 bool enable_diff_wtd_comp;
399 bool enable_interinter_wedge;
403 bool enable_interintra_wedge;
404} CompoundTypeCfg;
405
409typedef struct {
414 int superres_qthresh;
419 int superres_kf_qthresh;
425 uint8_t superres_scale_denominator;
431 uint8_t superres_kf_scale_denominator;
435 aom_superres_mode superres_mode;
439 bool enable_superres;
440} SuperResCfg;
441
445typedef struct {
449 int key_freq_min;
450
454 int key_freq_max;
455
459 int enable_keyframe_filtering;
460
465 int sframe_dist;
466
472 int sframe_mode;
473
477 bool auto_key;
478
482 int fwd_kf_dist;
483
487 bool fwd_kf_enabled;
488
492 bool enable_sframe;
493
497 bool enable_intrabc;
498} KeyFrameCfg;
499
503typedef struct {
505 // BUFFERING PARAMETERS
512 int64_t starting_buffer_level_ms;
517 int64_t optimal_buffer_level_ms;
522 int64_t maximum_buffer_size_ms;
523
527 int64_t target_bandwidth;
528
533 unsigned int vbr_corpus_complexity_lap;
538 unsigned int max_intra_bitrate_pct;
543 unsigned int max_inter_bitrate_pct;
547 unsigned int gf_cbr_boost_pct;
552 unsigned int min_cr;
556 int drop_frames_water_mark;
562 int under_shoot_pct;
568 int over_shoot_pct;
573 int worst_allowed_q;
578 int best_allowed_q;
582 int cq_level;
587 enum aom_rc_mode mode;
594 int vbrbias;
599 int vbrmin_section;
604 int vbrmax_section;
605} RateControlCfg;
606
608typedef struct {
609 // Indicates the number of frames lag before encoding is started.
610 int lag_in_frames;
611 // Indicates the minimum gf/arf interval to be used.
612 int min_gf_interval;
613 // Indicates the maximum gf/arf interval to be used.
614 int max_gf_interval;
615 // Indicates the minimum height for GF group pyramid structure to be used.
616 int gf_min_pyr_height;
617 // Indicates the maximum height for GF group pyramid structure to be used.
618 int gf_max_pyr_height;
619 // Indicates if automatic set and use of altref frames should be enabled.
620 bool enable_auto_arf;
621 // Indicates if automatic set and use of (b)ackward (r)ef (f)rames should be
622 // enabled.
623 bool enable_auto_brf;
624} GFConfig;
625
626typedef struct {
627 // Indicates the number of tile groups.
628 unsigned int num_tile_groups;
629 // Indicates the MTU size for a tile group. If mtu is non-zero,
630 // num_tile_groups is set to DEFAULT_MAX_NUM_TG.
631 unsigned int mtu;
632 // Indicates the number of tile columns in log2.
633 int tile_columns;
634 // Indicates the number of tile rows in log2.
635 int tile_rows;
636 // Indicates the number of widths in the tile_widths[] array.
637 int tile_width_count;
638 // Indicates the number of heights in the tile_heights[] array.
639 int tile_height_count;
640 // Indicates the tile widths, and may be empty.
641 int tile_widths[MAX_TILE_COLS];
642 // Indicates the tile heights, and may be empty.
643 int tile_heights[MAX_TILE_ROWS];
644 // Indicates if large scale tile coding should be used.
645 bool enable_large_scale_tile;
646 // Indicates if single tile decoding mode should be enabled.
647 bool enable_single_tile_decoding;
648 // Indicates if EXT_TILE_DEBUG should be enabled.
649 bool enable_ext_tile_debug;
650} TileConfig;
651
652typedef struct {
653 // Indicates the width of the input frame.
654 int width;
655 // Indicates the height of the input frame.
656 int height;
657 // If forced_max_frame_width is non-zero then it is used to force the maximum
658 // frame width written in write_sequence_header().
659 int forced_max_frame_width;
660 // If forced_max_frame_width is non-zero then it is used to force the maximum
661 // frame height written in write_sequence_header().
662 int forced_max_frame_height;
663 // Indicates the frame width after applying both super-resolution and resize
664 // to the coded frame.
665 int render_width;
666 // Indicates the frame height after applying both super-resolution and resize
667 // to the coded frame.
668 int render_height;
669} FrameDimensionCfg;
670
671typedef struct {
672 // Indicates if warped motion should be enabled.
673 bool enable_warped_motion;
674 // Indicates if warped motion should be evaluated or not.
675 bool allow_warped_motion;
676 // Indicates if OBMC motion should be enabled.
677 bool enable_obmc;
678} MotionModeCfg;
679
680typedef struct {
681 // Timing info for each frame.
682 aom_timing_info_t timing_info;
683 // Indicates the number of time units of a decoding clock.
684 uint32_t num_units_in_decoding_tick;
685 // Indicates if decoder model information is present in the coded sequence
686 // header.
687 bool decoder_model_info_present_flag;
688 // Indicates if display model information is present in the coded sequence
689 // header.
690 bool display_model_info_present_flag;
691 // Indicates if timing info for each frame is present.
692 bool timing_info_present;
693} DecoderModelCfg;
694
695typedef struct {
696 // Indicates the update frequency for coeff costs.
697 COST_UPDATE_TYPE coeff;
698 // Indicates the update frequency for mode costs.
699 COST_UPDATE_TYPE mode;
700 // Indicates the update frequency for mv costs.
701 COST_UPDATE_TYPE mv;
702 // Indicates the update frequency for dv costs.
703 COST_UPDATE_TYPE dv;
704} CostUpdateFreq;
705
706typedef struct {
707 // Indicates the maximum number of reference frames allowed per frame.
708 unsigned int max_reference_frames;
709 // Indicates if the reduced set of references should be enabled.
710 bool enable_reduced_reference_set;
711 // Indicates if one-sided compound should be enabled.
712 bool enable_onesided_comp;
713} RefFrameCfg;
714
715typedef struct {
716 // Indicates the color space that should be used.
717 aom_color_primaries_t color_primaries;
718 // Indicates the characteristics of transfer function to be used.
719 aom_transfer_characteristics_t transfer_characteristics;
720 // Indicates the matrix coefficients to be used for the transfer function.
721 aom_matrix_coefficients_t matrix_coefficients;
722 // Indicates the chroma 4:2:0 sample position info.
723 aom_chroma_sample_position_t chroma_sample_position;
724 // Indicates if a limited color range or full color range should be used.
725 aom_color_range_t color_range;
726} ColorCfg;
727
728typedef struct {
729 // Indicates if extreme motion vector unit test should be enabled or not.
730 unsigned int motion_vector_unit_test;
731 // Indicates if superblock multipass unit test should be enabled or not.
732 unsigned int sb_multipass_unit_test;
733} UnitTestCfg;
734
735typedef struct {
736 // Indicates the file path to the VMAF model.
737 const char *vmaf_model_path;
738 // Indicates the path to the film grain parameters.
739 const char *film_grain_table_filename;
740 // Indicates the visual tuning metric.
741 aom_tune_metric tuning;
742 // Indicates if the current content is screen or default type.
743 aom_tune_content content;
744 // Indicates the film grain parameters.
745 int film_grain_test_vector;
746} TuneCfg;
747
748typedef struct {
749 // Indicates the framerate of the input video.
750 double init_framerate;
751 // Indicates the bit-depth of the input video.
752 unsigned int input_bit_depth;
753 // Indicates the maximum number of frames to be encoded.
754 unsigned int limit;
755 // Indicates the chrome subsampling x value.
756 unsigned int chroma_subsampling_x;
757 // Indicates the chrome subsampling y value.
758 unsigned int chroma_subsampling_y;
759} InputCfg;
760
761typedef struct {
762 // List of QP offsets for: keyframe, ALTREF, and 3 levels of internal ARFs.
763 // If any of these values are negative, fixed offsets are disabled.
764 // Uses internal q range.
765 double fixed_qp_offsets[FIXED_QP_OFFSET_COUNT];
766 // If true, encoder will use fixed QP offsets, that are either:
767 // - Given by the user, and stored in 'fixed_qp_offsets' array, OR
768 // - Picked automatically from cq_level.
769 int use_fixed_qp_offsets;
770 // Indicates the minimum flatness of the quantization matrix.
771 int qm_minlevel;
772 // Indicates the maximum flatness of the quantization matrix.
773 int qm_maxlevel;
774 // Indicates if adaptive quantize_b should be enabled.
775 int quant_b_adapt;
776 // Indicates the Adaptive Quantization mode to be used.
777 AQ_MODE aq_mode;
778 // Indicates the delta q mode to be used.
779 DELTAQ_MODE deltaq_mode;
780 // Indicates the delta q mode strength.
781 DELTAQ_MODE deltaq_strength;
782 // Indicates if delta quantization should be enabled in chroma planes.
783 bool enable_chroma_deltaq;
784 // Indicates if delta quantization should be enabled for hdr video
785 bool enable_hdr_deltaq;
786 // Indicates if encoding with quantization matrices should be enabled.
787 bool using_qm;
788} QuantizationCfg;
789
794typedef struct {
801 int sharpness;
802
810 int disable_trellis_quant;
811
815 int arnr_max_frames;
816
820 int arnr_strength;
821
828 uint8_t cdf_update_mode;
829
833 bool enable_tpl_model;
834
839 bool enable_overlay;
840
848 LOOPFILTER_CONTROL loopfilter_control;
849} AlgoCfg;
852typedef struct {
853 // Indicates the codec bit-depth.
854 aom_bit_depth_t bit_depth;
855 // Indicates the superblock size that should be used by the encoder.
856 aom_superblock_size_t superblock_size;
857 // Indicates if loopfilter modulation should be enabled.
858 bool enable_deltalf_mode;
859 // Indicates how CDEF should be applied.
860 CDEF_CONTROL cdef_control;
861 // Indicates if loop restoration filter should be enabled.
862 bool enable_restoration;
863 // When enabled, video mode should be used even for single frame input.
864 bool force_video_mode;
865 // Indicates if the error resiliency features should be enabled.
866 bool error_resilient_mode;
867 // Indicates if frame parallel decoding feature should be enabled.
868 bool frame_parallel_decoding_mode;
869 // Indicates if the input should be encoded as monochrome.
870 bool enable_monochrome;
871 // When enabled, the encoder will use a full header even for still pictures.
872 // When disabled, a reduced header is used for still pictures.
873 bool full_still_picture_hdr;
874 // Indicates if dual interpolation filters should be enabled.
875 bool enable_dual_filter;
876 // Indicates if frame order hint should be enabled or not.
877 bool enable_order_hint;
878 // Indicates if ref_frame_mvs should be enabled at the sequence level.
879 bool ref_frame_mvs_present;
880 // Indicates if ref_frame_mvs should be enabled at the frame level.
881 bool enable_ref_frame_mvs;
882 // Indicates if interintra compound mode is enabled.
883 bool enable_interintra_comp;
884 // Indicates if global motion should be enabled.
885 bool enable_global_motion;
886 // Indicates if palette should be enabled.
887 bool enable_palette;
888} ToolCfg;
889
894typedef struct AV1EncoderConfig {
896 // Configuration related to the input video.
897 InputCfg input_cfg;
898
899 // Configuration related to frame-dimensions.
900 FrameDimensionCfg frm_dim_cfg;
901
906 AlgoCfg algo_cfg;
907
911 KeyFrameCfg kf_cfg;
912
916 RateControlCfg rc_cfg;
919 // Configuration related to Quantization.
920 QuantizationCfg q_cfg;
921
922 // Internal frame size scaling.
923 ResizeCfg resize_cfg;
924
925 // Frame Super-Resolution size scaling.
926 SuperResCfg superres_cfg;
927
933 aom_fixed_buf_t twopass_stats_in;
936 // Configuration related to encoder toolsets.
937 ToolCfg tool_cfg;
938
939 // Configuration related to Group of frames.
940 GFConfig gf_cfg;
941
942 // Tile related configuration parameters.
943 TileConfig tile_cfg;
944
945 // Configuration related to Tune.
946 TuneCfg tune_cfg;
947
948 // Configuration related to color.
949 ColorCfg color_cfg;
950
951 // Configuration related to decoder model.
952 DecoderModelCfg dec_model_cfg;
953
954 // Configuration related to reference frames.
955 RefFrameCfg ref_frm_cfg;
956
957 // Configuration related to unit tests.
958 UnitTestCfg unit_test_cfg;
959
960 // Flags related to motion mode.
961 MotionModeCfg motion_mode_cfg;
962
963 // Flags related to intra mode search.
964 IntraModeCfg intra_mode_cfg;
965
966 // Flags related to transform size/type.
967 TxfmSizeTypeCfg txfm_cfg;
968
969 // Flags related to compound type.
970 CompoundTypeCfg comp_type_cfg;
971
972 // Partition related information.
973 PartitionCfg part_cfg;
974
975 // Configuration related to frequency of cost update.
976 CostUpdateFreq cost_upd_freq;
977
978#if CONFIG_DENOISE
979 // Indicates the noise level.
980 float noise_level;
981 // Indicates the the denoisers block size.
982 int noise_block_size;
983 // Indicates whether to apply denoising to the frame to be encoded
984 int enable_dnl_denoising;
985#endif
986
987#if CONFIG_AV1_TEMPORAL_DENOISING
988 // Noise sensitivity.
989 int noise_sensitivity;
990#endif
991 // Bit mask to specify which tier each of the 32 possible operating points
992 // conforms to.
993 unsigned int tier_mask;
994
995 // Indicates the number of pixels off the edge of a reference frame we're
996 // allowed to go when forming an inter prediction.
997 int border_in_pixels;
998
999 // Indicates the maximum number of threads that may be used by the encoder.
1000 int max_threads;
1001
1002 // Indicates the speed preset to be used.
1003 int speed;
1004
1005 // Indicates the target sequence level index for each operating point(OP).
1006 AV1_LEVEL target_seq_level_idx[MAX_NUM_OPERATING_POINTS];
1007
1008 // Indicates the bitstream profile to be used.
1009 BITSTREAM_PROFILE profile;
1010
1019 enum aom_enc_pass pass;
1022 // Total number of encoding passes.
1023 int passes;
1024
1025 // the name of the second pass output file when passes > 2
1026 const char *two_pass_output;
1027
1028 // the name of the second pass log file when passes > 2
1029 const char *second_pass_log;
1030
1031 // Indicates if the encoding is GOOD or REALTIME.
1032 MODE mode;
1033
1034 // Indicates if row-based multi-threading should be enabled or not.
1035 bool row_mt;
1036
1037 // Indicates if 16bit frame buffers are to be used i.e., the content is >
1038 // 8-bit.
1039 bool use_highbitdepth;
1040
1041 // Indicates the bitstream syntax mode. 0 indicates bitstream is saved as
1042 // Section 5 bitstream, while 1 indicates the bitstream is saved in Annex - B
1043 // format.
1044 bool save_as_annexb;
1045
1046 // The path for partition stats reading and writing, used in the experiment
1047 // CONFIG_PARTITION_SEARCH_ORDER.
1048 const char *partition_info_path;
1050} AV1EncoderConfig;
1051
1053static INLINE int is_lossless_requested(const RateControlCfg *const rc_cfg) {
1054 return rc_cfg->best_allowed_q == 0 && rc_cfg->worst_allowed_q == 0;
1055}
1061typedef struct {
1067 int obmc_probs[FRAME_UPDATE_TYPES][BLOCK_SIZES_ALL];
1068
1074 int warped_probs[FRAME_UPDATE_TYPES];
1075
1082 int tx_type_probs[FRAME_UPDATE_TYPES][TX_SIZES_ALL][TX_TYPES];
1083
1090 int switchable_interp_probs[FRAME_UPDATE_TYPES][SWITCHABLE_FILTER_CONTEXTS]
1091 [SWITCHABLE_FILTERS];
1092} FrameProbInfo;
1093
1096typedef struct FRAME_COUNTS {
1097// Note: This structure should only contain 'unsigned int' fields, or
1098// aggregates built solely from 'unsigned int' fields/elements
1099#if CONFIG_ENTROPY_STATS
1100 unsigned int kf_y_mode[KF_MODE_CONTEXTS][KF_MODE_CONTEXTS][INTRA_MODES];
1101 unsigned int angle_delta[DIRECTIONAL_MODES][2 * MAX_ANGLE_DELTA + 1];
1102 unsigned int y_mode[BLOCK_SIZE_GROUPS][INTRA_MODES];
1103 unsigned int uv_mode[CFL_ALLOWED_TYPES][INTRA_MODES][UV_INTRA_MODES];
1104 unsigned int cfl_sign[CFL_JOINT_SIGNS];
1105 unsigned int cfl_alpha[CFL_ALPHA_CONTEXTS][CFL_ALPHABET_SIZE];
1106 unsigned int palette_y_mode[PALATTE_BSIZE_CTXS][PALETTE_Y_MODE_CONTEXTS][2];
1107 unsigned int palette_uv_mode[PALETTE_UV_MODE_CONTEXTS][2];
1108 unsigned int palette_y_size[PALATTE_BSIZE_CTXS][PALETTE_SIZES];
1109 unsigned int palette_uv_size[PALATTE_BSIZE_CTXS][PALETTE_SIZES];
1110 unsigned int palette_y_color_index[PALETTE_SIZES]
1111 [PALETTE_COLOR_INDEX_CONTEXTS]
1112 [PALETTE_COLORS];
1113 unsigned int palette_uv_color_index[PALETTE_SIZES]
1114 [PALETTE_COLOR_INDEX_CONTEXTS]
1115 [PALETTE_COLORS];
1116 unsigned int partition[PARTITION_CONTEXTS][EXT_PARTITION_TYPES];
1117 unsigned int txb_skip[TOKEN_CDF_Q_CTXS][TX_SIZES][TXB_SKIP_CONTEXTS][2];
1118 unsigned int eob_extra[TOKEN_CDF_Q_CTXS][TX_SIZES][PLANE_TYPES]
1119 [EOB_COEF_CONTEXTS][2];
1120 unsigned int dc_sign[PLANE_TYPES][DC_SIGN_CONTEXTS][2];
1121 unsigned int coeff_lps[TX_SIZES][PLANE_TYPES][BR_CDF_SIZE - 1][LEVEL_CONTEXTS]
1122 [2];
1123 unsigned int eob_flag[TX_SIZES][PLANE_TYPES][EOB_COEF_CONTEXTS][2];
1124 unsigned int eob_multi16[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][5];
1125 unsigned int eob_multi32[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][6];
1126 unsigned int eob_multi64[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][7];
1127 unsigned int eob_multi128[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][8];
1128 unsigned int eob_multi256[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][9];
1129 unsigned int eob_multi512[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][10];
1130 unsigned int eob_multi1024[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][11];
1131 unsigned int coeff_lps_multi[TOKEN_CDF_Q_CTXS][TX_SIZES][PLANE_TYPES]
1132 [LEVEL_CONTEXTS][BR_CDF_SIZE];
1133 unsigned int coeff_base_multi[TOKEN_CDF_Q_CTXS][TX_SIZES][PLANE_TYPES]
1134 [SIG_COEF_CONTEXTS][NUM_BASE_LEVELS + 2];
1135 unsigned int coeff_base_eob_multi[TOKEN_CDF_Q_CTXS][TX_SIZES][PLANE_TYPES]
1136 [SIG_COEF_CONTEXTS_EOB][NUM_BASE_LEVELS + 1];
1137 unsigned int newmv_mode[NEWMV_MODE_CONTEXTS][2];
1138 unsigned int zeromv_mode[GLOBALMV_MODE_CONTEXTS][2];
1139 unsigned int refmv_mode[REFMV_MODE_CONTEXTS][2];
1140 unsigned int drl_mode[DRL_MODE_CONTEXTS][2];
1141 unsigned int inter_compound_mode[INTER_MODE_CONTEXTS][INTER_COMPOUND_MODES];
1142 unsigned int wedge_idx[BLOCK_SIZES_ALL][16];
1143 unsigned int interintra[BLOCK_SIZE_GROUPS][2];
1144 unsigned int interintra_mode[BLOCK_SIZE_GROUPS][INTERINTRA_MODES];
1145 unsigned int wedge_interintra[BLOCK_SIZES_ALL][2];
1146 unsigned int compound_type[BLOCK_SIZES_ALL][MASKED_COMPOUND_TYPES];
1147 unsigned int motion_mode[BLOCK_SIZES_ALL][MOTION_MODES];
1148 unsigned int obmc[BLOCK_SIZES_ALL][2];
1149 unsigned int intra_inter[INTRA_INTER_CONTEXTS][2];
1150 unsigned int comp_inter[COMP_INTER_CONTEXTS][2];
1151 unsigned int comp_ref_type[COMP_REF_TYPE_CONTEXTS][2];
1152 unsigned int uni_comp_ref[UNI_COMP_REF_CONTEXTS][UNIDIR_COMP_REFS - 1][2];
1153 unsigned int single_ref[REF_CONTEXTS][SINGLE_REFS - 1][2];
1154 unsigned int comp_ref[REF_CONTEXTS][FWD_REFS - 1][2];
1155 unsigned int comp_bwdref[REF_CONTEXTS][BWD_REFS - 1][2];
1156 unsigned int intrabc[2];
1157
1158 unsigned int txfm_partition[TXFM_PARTITION_CONTEXTS][2];
1159 unsigned int intra_tx_size[MAX_TX_CATS][TX_SIZE_CONTEXTS][MAX_TX_DEPTH + 1];
1160 unsigned int skip_mode[SKIP_MODE_CONTEXTS][2];
1161 unsigned int skip_txfm[SKIP_CONTEXTS][2];
1162 unsigned int compound_index[COMP_INDEX_CONTEXTS][2];
1163 unsigned int comp_group_idx[COMP_GROUP_IDX_CONTEXTS][2];
1164 unsigned int delta_q[DELTA_Q_PROBS][2];
1165 unsigned int delta_lf_multi[FRAME_LF_COUNT][DELTA_LF_PROBS][2];
1166 unsigned int delta_lf[DELTA_LF_PROBS][2];
1167
1168 unsigned int inter_ext_tx[EXT_TX_SETS_INTER][EXT_TX_SIZES][TX_TYPES];
1169 unsigned int intra_ext_tx[EXT_TX_SETS_INTRA][EXT_TX_SIZES][INTRA_MODES]
1170 [TX_TYPES];
1171 unsigned int filter_intra_mode[FILTER_INTRA_MODES];
1172 unsigned int filter_intra[BLOCK_SIZES_ALL][2];
1173 unsigned int switchable_restore[RESTORE_SWITCHABLE_TYPES];
1174 unsigned int wiener_restore[2];
1175 unsigned int sgrproj_restore[2];
1176#endif // CONFIG_ENTROPY_STATS
1177
1178 unsigned int switchable_interp[SWITCHABLE_FILTER_CONTEXTS]
1179 [SWITCHABLE_FILTERS];
1180} FRAME_COUNTS;
1181
1182#define INTER_MODE_RD_DATA_OVERALL_SIZE 6400
1183
1184typedef struct {
1185 int ready;
1186 double a;
1187 double b;
1188 double dist_mean;
1189 double ld_mean;
1190 double sse_mean;
1191 double sse_sse_mean;
1192 double sse_ld_mean;
1193 int num;
1194 double dist_sum;
1195 double ld_sum;
1196 double sse_sum;
1197 double sse_sse_sum;
1198 double sse_ld_sum;
1199} InterModeRdModel;
1200
1201typedef struct {
1202 int idx;
1203 int64_t rd;
1204} RdIdxPair;
1205// TODO(angiebird): This is an estimated size. We still need to figure what is
1206// the maximum number of modes.
1207#define MAX_INTER_MODES 1024
1208// TODO(any): rename this struct to something else. There is already another
1209// struct called inter_mode_info, which makes this terribly confusing.
1217typedef struct inter_modes_info {
1222 int num;
1226 MB_MODE_INFO mbmi_arr[MAX_INTER_MODES];
1230 int mode_rate_arr[MAX_INTER_MODES];
1234 int64_t sse_arr[MAX_INTER_MODES];
1238 int64_t est_rd_arr[MAX_INTER_MODES];
1242 RdIdxPair rd_idx_pair_arr[MAX_INTER_MODES];
1246 RD_STATS rd_cost_arr[MAX_INTER_MODES];
1250 RD_STATS rd_cost_y_arr[MAX_INTER_MODES];
1254 RD_STATS rd_cost_uv_arr[MAX_INTER_MODES];
1255} InterModesInfo;
1256
1258typedef struct {
1259 // TODO(kyslov): consider changing to 64bit
1260
1261 // This struct is used for computing variance in choose_partitioning(), where
1262 // the max number of samples within a superblock is 32x32 (with 4x4 avg).
1263 // With 8bit bitdepth, uint32_t is enough for sum_square_error (2^8 * 2^8 * 32
1264 // * 32 = 2^26). For high bitdepth we need to consider changing this to 64 bit
1265 uint32_t sum_square_error;
1266 int32_t sum_error;
1267 int log2_count;
1268 int variance;
1269} VPartVar;
1270
1271typedef struct {
1272 VPartVar none;
1273 VPartVar horz[2];
1274 VPartVar vert[2];
1275} VPVariance;
1276
1277typedef struct {
1278 VPVariance part_variances;
1279 VPartVar split[4];
1280} VP4x4;
1281
1282typedef struct {
1283 VPVariance part_variances;
1284 VP4x4 split[4];
1285} VP8x8;
1286
1287typedef struct {
1288 VPVariance part_variances;
1289 VP8x8 split[4];
1290} VP16x16;
1291
1292typedef struct {
1293 VPVariance part_variances;
1294 VP16x16 split[4];
1295} VP32x32;
1296
1297typedef struct {
1298 VPVariance part_variances;
1299 VP32x32 split[4];
1300} VP64x64;
1301
1302typedef struct {
1303 VPVariance part_variances;
1304 VP64x64 *split;
1305} VP128x128;
1306
1312typedef struct {
1321 int64_t thresholds[5];
1322
1327 int64_t threshold_minmax;
1328} VarBasedPartitionInfo;
1329
1333typedef struct {
1334#if CONFIG_MULTITHREAD
1339 pthread_mutex_t *mutex_;
1340 pthread_cond_t *cond_;
1342#endif // CONFIG_MULTITHREAD
1348 int *num_finished_cols;
1354 int sync_range;
1358 int rows;
1362 int next_mi_row;
1366 int num_threads_working;
1367} AV1EncRowMultiThreadSync;
1368
1371// TODO(jingning) All spatially adaptive variables should go to TileDataEnc.
1372typedef struct TileDataEnc {
1373 TileInfo tile_info;
1374 DECLARE_ALIGNED(16, FRAME_CONTEXT, tctx);
1375 FRAME_CONTEXT *row_ctx;
1376 uint64_t abs_sum_level;
1377 uint8_t allow_update_cdf;
1378 InterModeRdModel inter_mode_rd_models[BLOCK_SIZES_ALL];
1379 AV1EncRowMultiThreadSync row_mt_sync;
1380 MV firstpass_top_mv;
1381} TileDataEnc;
1382
1383typedef struct RD_COUNTS {
1384 int compound_ref_used_flag;
1385 int skip_mode_used_flag;
1386 int tx_type_used[TX_SIZES_ALL][TX_TYPES];
1387 int obmc_used[BLOCK_SIZES_ALL][2];
1388 int warped_used[2];
1389 int newmv_or_intra_blocks;
1390} RD_COUNTS;
1391
1392typedef struct ThreadData {
1393 MACROBLOCK mb;
1394 RD_COUNTS rd_counts;
1395 FRAME_COUNTS *counts;
1396 PC_TREE_SHARED_BUFFERS shared_coeff_buf;
1397 SIMPLE_MOTION_DATA_TREE *sms_tree;
1398 SIMPLE_MOTION_DATA_TREE *sms_root;
1399 uint32_t *hash_value_buffer[2][2];
1400 OBMCBuffer obmc_buffer;
1401 PALETTE_BUFFER *palette_buffer;
1402 CompoundTypeRdBuffers comp_rd_buffer;
1403 CONV_BUF_TYPE *tmp_conv_dst;
1404 uint64_t abs_sum_level;
1405 uint8_t *tmp_pred_bufs[2];
1406 int intrabc_used;
1407 int deltaq_used;
1408 int coefficient_size;
1409 int max_mv_magnitude;
1410 int interp_filter_selected[SWITCHABLE];
1411 FRAME_CONTEXT *tctx;
1412 VP64x64 *vt64x64;
1413 int32_t num_64x64_blocks;
1414 PICK_MODE_CONTEXT *firstpass_ctx;
1415 TemporalFilterData tf_data;
1416 TplTxfmStats tpl_txfm_stats;
1417 // Pointer to the array of structures to store gradient information of each
1418 // pixel in a superblock. The buffer constitutes of MAX_SB_SQUARE pixel level
1419 // structures for each of the plane types (PLANE_TYPE_Y and PLANE_TYPE_UV).
1420 PixelLevelGradientInfo *pixel_gradient_info;
1421} ThreadData;
1422
1423struct EncWorkerData;
1424
1430typedef struct {
1434 int allocated_tile_rows;
1438 int allocated_tile_cols;
1445 int allocated_rows;
1452 int allocated_cols;
1453
1457 int thread_id_to_tile_id[MAX_NUM_THREADS];
1458
1459#if CONFIG_MULTITHREAD
1463 pthread_mutex_t *mutex_;
1464#endif
1465
1473 void (*sync_read_ptr)(AV1EncRowMultiThreadSync *const, int, int);
1477 void (*sync_write_ptr)(AV1EncRowMultiThreadSync *const, int, int, int);
1479} AV1EncRowMultiThreadInfo;
1480
1481#if CONFIG_FRAME_PARALLEL_ENCODE
1485#define MAX_PARALLEL_FRAMES 4
1489#define NUM_RECODES_PER_FRAME 10
1490
1495typedef struct RestoreStateBuffers {
1499 uint16_t *cdef_srcbuf;
1500
1504 uint16_t *cdef_colbuf[MAX_MB_PLANE];
1505
1509 int32_t *rst_tmpbuf;
1510
1514 RestorationLineBuffers *rlbs;
1515} RestoreStateBuffers;
1516#endif // CONFIG_FRAME_PARALLEL_ENCODE
1517
1521typedef struct PrimaryMultiThreadInfo {
1525 int num_workers;
1526
1530 int num_mod_workers[NUM_MT_MODULES];
1531
1535 AVxWorker *workers;
1536
1541 struct EncWorkerData *tile_thr_data;
1542
1546 AV1CdefWorkerData *cdef_worker;
1547
1548#if CONFIG_FRAME_PARALLEL_ENCODE
1553 AVxWorker *p_workers[MAX_PARALLEL_FRAMES];
1554
1558 int p_num_workers;
1559#endif // CONFIG_FRAME_PARALLEL_ENCODE
1560} PrimaryMultiThreadInfo;
1561
1565typedef struct MultiThreadInfo {
1569 int num_workers;
1570
1574 int num_mod_workers[NUM_MT_MODULES];
1575
1579 AVxWorker *workers;
1580
1585 struct EncWorkerData *tile_thr_data;
1586
1591 bool row_mt_enabled;
1592
1596 AV1EncRowMultiThreadInfo enc_row_mt;
1597
1601 AV1TplRowMultiThreadInfo tpl_row_mt;
1602
1606 AV1LfSync lf_row_sync;
1607
1611 AV1LrSync lr_row_sync;
1612
1616 AV1EncPackBSSync pack_bs_sync;
1617
1621 AV1GlobalMotionSync gm_sync;
1622
1626 AV1TemporalFilterSync tf_sync;
1627
1631 AV1CdefSync cdef_sync;
1632
1636 AV1CdefWorkerData *cdef_worker;
1637
1638#if CONFIG_FRAME_PARALLEL_ENCODE
1642 RestoreStateBuffers restore_state_buf;
1643#endif // CONFIG_FRAME_PARALLEL_ENCODE
1644} MultiThreadInfo;
1645
1648typedef struct ActiveMap {
1649 int enabled;
1650 int update;
1651 unsigned char *map;
1652} ActiveMap;
1653
1659typedef struct {
1664 double cs_rate_array[32];
1668 int rate_index;
1672 int rate_size;
1673} ForceIntegerMVInfo;
1674
1677#if CONFIG_INTERNAL_STATS
1678// types of stats
1679enum {
1680 STAT_Y,
1681 STAT_U,
1682 STAT_V,
1683 STAT_ALL,
1684 NUM_STAT_TYPES // This should always be the last member of the enum
1685} UENUM1BYTE(StatType);
1686
1687typedef struct IMAGE_STAT {
1688 double stat[NUM_STAT_TYPES];
1689 double worst;
1690} ImageStat;
1691#endif // CONFIG_INTERNAL_STATS
1692
1693typedef struct {
1694 int ref_count;
1695 YV12_BUFFER_CONFIG buf;
1696} EncRefCntBuffer;
1697
1705typedef struct {
1710 MB_MODE_INFO_EXT_FRAME *frame_base;
1714 int alloc_size;
1718 int stride;
1719} MBMIExtFrameBufferInfo;
1720
1723#if CONFIG_COLLECT_PARTITION_STATS
1724typedef struct FramePartitionTimingStats {
1725 int partition_decisions[6][EXT_PARTITION_TYPES];
1726 int partition_attempts[6][EXT_PARTITION_TYPES];
1727 int64_t partition_times[6][EXT_PARTITION_TYPES];
1728
1729 int partition_redo;
1730} FramePartitionTimingStats;
1731#endif // CONFIG_COLLECT_PARTITION_STATS
1732
1733#if CONFIG_COLLECT_COMPONENT_TIMING
1734#include "aom_ports/aom_timer.h"
1735// Adjust the following to add new components.
1736enum {
1737 av1_encode_strategy_time,
1738 av1_get_one_pass_rt_params_time,
1739 av1_get_second_pass_params_time,
1740 denoise_and_encode_time,
1741 apply_filtering_time,
1742 av1_tpl_setup_stats_time,
1743 encode_frame_to_data_rate_time,
1744 encode_with_or_without_recode_time,
1745 loop_filter_time,
1746 cdef_time,
1747 loop_restoration_time,
1748 av1_pack_bitstream_final_time,
1749 av1_encode_frame_time,
1750 av1_compute_global_motion_time,
1751 av1_setup_motion_field_time,
1752 encode_sb_row_time,
1753
1754 rd_pick_partition_time,
1755 rd_use_partition_time,
1756 av1_prune_partitions_time,
1757 none_partition_search_time,
1758 split_partition_search_time,
1759 rectangular_partition_search_time,
1760 ab_partitions_search_time,
1761 rd_pick_4partition_time,
1762 encode_sb_time,
1763
1764 rd_pick_sb_modes_time,
1765 av1_rd_pick_intra_mode_sb_time,
1766 av1_rd_pick_inter_mode_sb_time,
1767 set_params_rd_pick_inter_mode_time,
1768 skip_inter_mode_time,
1769 handle_inter_mode_time,
1770 evaluate_motion_mode_for_winner_candidates_time,
1771 do_tx_search_time,
1772 handle_intra_mode_time,
1773 refine_winner_mode_tx_time,
1774 av1_search_palette_mode_time,
1775 handle_newmv_time,
1776 compound_type_rd_time,
1777 interpolation_filter_search_time,
1778 motion_mode_rd_time,
1779 kTimingComponents,
1780} UENUM1BYTE(TIMING_COMPONENT);
1781
1782static INLINE char const *get_component_name(int index) {
1783 switch (index) {
1784 case av1_encode_strategy_time: return "av1_encode_strategy_time";
1785 case av1_get_one_pass_rt_params_time:
1786 return "av1_get_one_pass_rt_params_time";
1787 case av1_get_second_pass_params_time:
1788 return "av1_get_second_pass_params_time";
1789 case denoise_and_encode_time: return "denoise_and_encode_time";
1790 case apply_filtering_time: return "apply_filtering_time";
1791 case av1_tpl_setup_stats_time: return "av1_tpl_setup_stats_time";
1792 case encode_frame_to_data_rate_time:
1793 return "encode_frame_to_data_rate_time";
1794 case encode_with_or_without_recode_time:
1795 return "encode_with_or_without_recode_time";
1796 case loop_filter_time: return "loop_filter_time";
1797 case cdef_time: return "cdef_time";
1798 case loop_restoration_time: return "loop_restoration_time";
1799 case av1_pack_bitstream_final_time: return "av1_pack_bitstream_final_time";
1800 case av1_encode_frame_time: return "av1_encode_frame_time";
1801 case av1_compute_global_motion_time:
1802 return "av1_compute_global_motion_time";
1803 case av1_setup_motion_field_time: return "av1_setup_motion_field_time";
1804 case encode_sb_row_time: return "encode_sb_row_time";
1805
1806 case rd_pick_partition_time: return "rd_pick_partition_time";
1807 case rd_use_partition_time: return "rd_use_partition_time";
1808 case av1_prune_partitions_time: return "av1_prune_partitions_time";
1809 case none_partition_search_time: return "none_partition_search_time";
1810 case split_partition_search_time: return "split_partition_search_time";
1811 case rectangular_partition_search_time:
1812 return "rectangular_partition_search_time";
1813 case ab_partitions_search_time: return "ab_partitions_search_time";
1814 case rd_pick_4partition_time: return "rd_pick_4partition_time";
1815 case encode_sb_time: return "encode_sb_time";
1816
1817 case rd_pick_sb_modes_time: return "rd_pick_sb_modes_time";
1818 case av1_rd_pick_intra_mode_sb_time:
1819 return "av1_rd_pick_intra_mode_sb_time";
1820 case av1_rd_pick_inter_mode_sb_time:
1821 return "av1_rd_pick_inter_mode_sb_time";
1822 case set_params_rd_pick_inter_mode_time:
1823 return "set_params_rd_pick_inter_mode_time";
1824 case skip_inter_mode_time: return "skip_inter_mode_time";
1825 case handle_inter_mode_time: return "handle_inter_mode_time";
1826 case evaluate_motion_mode_for_winner_candidates_time:
1827 return "evaluate_motion_mode_for_winner_candidates_time";
1828 case do_tx_search_time: return "do_tx_search_time";
1829 case handle_intra_mode_time: return "handle_intra_mode_time";
1830 case refine_winner_mode_tx_time: return "refine_winner_mode_tx_time";
1831 case av1_search_palette_mode_time: return "av1_search_palette_mode_time";
1832 case handle_newmv_time: return "handle_newmv_time";
1833 case compound_type_rd_time: return "compound_type_rd_time";
1834 case interpolation_filter_search_time:
1835 return "interpolation_filter_search_time";
1836 case motion_mode_rd_time: return "motion_mode_rd_time";
1837 default: assert(0);
1838 }
1839 return "error";
1840}
1841#endif
1842
1843// The maximum number of internal ARFs except ALTREF_FRAME
1844#define MAX_INTERNAL_ARFS (REF_FRAMES - BWDREF_FRAME - 1)
1845
1851typedef struct {
1855 bool search_done;
1856
1862 YV12_BUFFER_CONFIG *ref_buf[REF_FRAMES];
1863
1867 unsigned char *src_buffer;
1868
1874 int num_ref_frames[MAX_DIRECTIONS];
1875
1882 FrameDistPair reference_frames[MAX_DIRECTIONS][REF_FRAMES - 1];
1883
1888 int segment_map_w;
1889 int segment_map_h;
1895 int num_src_corners;
1896
1902 int src_corners[2 * MAX_CORNERS];
1903} GlobalMotionInfo;
1904
1914typedef struct {
1915 int width;
1916 int height;
1917} InitialDimensions;
1918
1922typedef struct {
1927 int default_interp_skip_flags;
1931 uint16_t interp_filter_search_mask;
1932} InterpSearchFlags;
1933
1937typedef struct {
1943 int max_mv_magnitude;
1948 int mv_step_param;
1957 fractional_mv_step_fp *find_fractional_mv_step;
1964 search_site_config search_site_cfg[SS_CFG_TOTAL][NUM_DISTINCT_SEARCH_METHODS];
1965} MotionVectorSearchParams;
1966
1975typedef struct {
1976 bool golden_frame;
1977 bool bwd_ref_frame;
1978 bool alt_ref_frame;
1979} RefreshFrameInfo;
1980
1988typedef struct {
1989 int width;
1990 int height;
1991} ResizePendingParams;
1992
1996typedef struct {
2000 int ref_relative_dist[INTER_REFS_PER_FRAME];
2004 int8_t nearest_past_ref;
2008 int8_t nearest_future_ref;
2009} RefFrameDistanceInfo;
2010
2026typedef struct {
2034 unsigned int coeff_opt_thresholds[MODE_EVAL_TYPES][2];
2035
2040 TX_SIZE_SEARCH_METHOD tx_size_search_methods[MODE_EVAL_TYPES];
2041
2048 unsigned int use_transform_domain_distortion[MODE_EVAL_TYPES];
2049
2055 unsigned int tx_domain_dist_threshold[MODE_EVAL_TYPES];
2056
2062 unsigned int skip_txfm_level[MODE_EVAL_TYPES];
2063
2069 unsigned int predict_dc_level[MODE_EVAL_TYPES];
2070} WinnerModeParams;
2071
2079typedef struct {
2080 bool last_frame;
2081 bool golden_frame;
2082 bool bwd_ref_frame;
2083 bool alt2_ref_frame;
2084 bool alt_ref_frame;
2088 bool update_pending;
2089} ExtRefreshFrameFlagsInfo;
2090
2094typedef struct {
2098 int ref_frame_flags;
2099
2103 ExtRefreshFrameFlagsInfo refresh_frame;
2104
2108 bool refresh_frame_context;
2109
2114 bool refresh_frame_context_pending;
2115
2119 bool use_ref_frame_mvs;
2120
2124 bool use_error_resilient;
2125
2129 bool use_s_frame;
2130
2135 bool use_primary_ref_none;
2136} ExternalFlags;
2137
2140typedef struct {
2141 int arf_stack[FRAME_BUFFERS];
2142 int arf_stack_size;
2143 int lst_stack[FRAME_BUFFERS];
2144 int lst_stack_size;
2145 int gld_stack[FRAME_BUFFERS];
2146 int gld_stack_size;
2147} RefBufferStack;
2148
2149typedef struct {
2150 // Some misc info
2151 int high_prec;
2152 int q;
2153 int order;
2154
2155 // MV counters
2156 int inter_count;
2157 int intra_count;
2158 int default_mvs;
2159 int mv_joint_count[4];
2160 int last_bit_zero;
2161 int last_bit_nonzero;
2162
2163 // Keep track of the rates
2164 int total_mv_rate;
2165 int hp_total_mv_rate;
2166 int lp_total_mv_rate;
2167
2168 // Texture info
2169 int horz_text;
2170 int vert_text;
2171 int diag_text;
2172
2173 // Whether the current struct contains valid data
2174 int valid;
2175} MV_STATS;
2176
2177typedef struct WeberStats {
2178 int64_t mb_wiener_variance;
2179 int64_t src_variance;
2180 int64_t rec_variance;
2181 int16_t src_pix_max;
2182 int16_t rec_pix_max;
2183 int64_t distortion;
2184 int64_t satd;
2185 double max_scale;
2186} WeberStats;
2187
2188typedef struct {
2189 struct loopfilter lf;
2190 CdefInfo cdef_info;
2191 YV12_BUFFER_CONFIG copy_buffer;
2192 RATE_CONTROL rc;
2193 MV_STATS mv_stats;
2194} CODING_CONTEXT;
2195
2196typedef struct {
2197 int frame_width;
2198 int frame_height;
2199 int mi_rows;
2200 int mi_cols;
2201 int mb_rows;
2202 int mb_cols;
2203 int num_mbs;
2204 aom_bit_depth_t bit_depth;
2205 int subsampling_x;
2206 int subsampling_y;
2207} FRAME_INFO;
2208
2212typedef struct {
2213 int show_frame_count;
2214} FRAME_INDEX_SET;
2215
2221typedef struct {
2227 uint8_t *map;
2233 bool has_lossless_segment;
2234} EncSegmentationInfo;
2235
2239typedef struct {
2243 int64_t prev_ts_start;
2247 int64_t prev_ts_end;
2251 int64_t first_ts_start;
2252} TimeStamps;
2253
2258typedef struct {
2262 tran_low_t *tcoeff;
2266 uint16_t *eobs;
2270 uint8_t *entropy_ctx;
2271} CoeffBufferPool;
2272
2276typedef struct AV1_COMP_DATA {
2280 unsigned char *cx_data;
2281
2285 size_t cx_data_sz;
2286
2290 size_t frame_size;
2291
2295 unsigned int lib_flags;
2296
2300 int64_t ts_frame_start;
2301
2305 int64_t ts_frame_end;
2306
2310 int flush;
2311
2315 const aom_rational64_t *timestamp_ratio;
2316
2320 int pop_lookahead;
2321#if CONFIG_FRAME_PARALLEL_ENCODE
2325 int frame_display_order_hint;
2326#endif
2327} AV1_COMP_DATA;
2328
2332typedef struct AV1_PRIMARY {
2333#if CONFIG_FRAME_PARALLEL_ENCODE
2337 struct AV1_COMP *parallel_cpi[MAX_PARALLEL_FRAMES];
2338
2342 int num_fp_contexts;
2343
2348 struct AV1_COMP_DATA parallel_frames_data[MAX_PARALLEL_FRAMES - 1];
2349
2353 int filter_level[2];
2354
2358 int filter_level_u;
2359
2363 int filter_level_v;
2364
2365#if CONFIG_FPMT_TEST
2371 FPMT_TEST_ENC_CFG fpmt_unit_test_cfg;
2372
2376 FrameProbInfo temp_frame_probs;
2377
2383 FrameProbInfo temp_frame_probs_simulation;
2384
2389 int temp_valid_gm_model_found[FRAME_UPDATE_TYPES];
2390#endif
2391
2395 int64_t ts_start_last_show_frame;
2396
2400 int64_t ts_end_last_show_frame;
2401#if CONFIG_FRAME_PARALLEL_ENCODE_2
2407 RefCntBuffer *ref_frame_map_copy[REF_FRAMES];
2408#endif // CONFIG_FRAME_PARALLEL_ENCODE_2
2409#endif // CONFIG_FRAME_PARALLEL_ENCODE
2415 struct AV1_COMP *cpi;
2416
2420 struct AV1_COMP *cpi_lap;
2421
2425 struct lookahead_ctx *lookahead;
2426
2432 int seq_params_locked;
2433
2438 struct aom_codec_pkt_list *output_pkt_list;
2439
2443 int internal_altref_allowed;
2444
2448 int show_existing_alt_ref;
2449
2453 GF_GROUP gf_group;
2454
2458 GF_STATE gf_state;
2459
2463 int lap_enabled;
2464
2468 AV1LevelParams level_params;
2469
2473 int b_calculate_psnr;
2474
2478 int frames_left;
2479
2483 TWO_PASS twopass;
2484
2488 PRIMARY_RATE_CONTROL p_rc;
2489
2493 TEMPORAL_FILTER_INFO tf_info;
2498 SequenceHeader seq_params;
2499
2503 int use_svc;
2504
2508 bool buffer_removal_time_present;
2509
2513 unsigned int number_temporal_layers;
2514
2518 unsigned int number_spatial_layers;
2519
2523 struct aom_internal_error_info error;
2524
2530 aom_variance_fn_ptr_t fn_ptr[BLOCK_SIZES_ALL];
2531
2540 double *tpl_rdmult_scaling_factors;
2541
2546 double *tpl_sb_rdmult_scaling_factors;
2547
2551 TplParams tpl_data;
2552
2556 MV_STATS mv_stats;
2557
2558#if CONFIG_INTERNAL_STATS
2560 uint64_t total_time_receive_data;
2561 uint64_t total_time_compress_data;
2562
2563 unsigned int total_mode_chosen_counts[MAX_MODES];
2564
2565 int count[2];
2566 uint64_t total_sq_error[2];
2567 uint64_t total_samples[2];
2568 ImageStat psnr[2];
2569
2570 double total_blockiness;
2571 double worst_blockiness;
2572
2573 int total_bytes;
2574 double summed_quality;
2575 double summed_weights;
2576 double summed_quality_hbd;
2577 double summed_weights_hbd;
2578 unsigned int total_recode_hits;
2579 double worst_ssim;
2580 double worst_ssim_hbd;
2581
2582 ImageStat fastssim;
2583 ImageStat psnrhvs;
2584
2585 int b_calculate_blockiness;
2586 int b_calculate_consistency;
2587
2588 double total_inconsistency;
2589 double worst_consistency;
2590 Ssimv *ssim_vars;
2591 Metrics metrics;
2593#endif
2594
2595#if CONFIG_ENTROPY_STATS
2599 FRAME_COUNTS aggregate_fc;
2600#endif // CONFIG_ENTROPY_STATS
2601
2608 int fb_of_context_type[REF_FRAMES];
2609
2613 PrimaryMultiThreadInfo p_mt_info;
2614
2618 FrameProbInfo frame_probs;
2619
2626 int valid_gm_model_found[FRAME_UPDATE_TYPES];
2627} AV1_PRIMARY;
2628
2632typedef struct AV1_COMP {
2636 AV1_PRIMARY *ppi;
2637
2642 EncQuantDequantParams enc_quant_dequant_params;
2643
2647 ThreadData td;
2648
2652 FRAME_COUNTS counts;
2653
2657 MBMIExtFrameBufferInfo mbmi_ext_info;
2658
2664 CB_COEFF_BUFFER *coeff_buffer_base;
2665
2670 CoeffBufferPool coeff_buffer_pool;
2671
2675 AV1_COMMON common;
2676
2680 AV1EncoderConfig oxcf;
2681
2686 TRELLIS_OPT_TYPE optimize_seg_arr[MAX_SEGMENTS];
2687
2693 YV12_BUFFER_CONFIG *source;
2694
2702 YV12_BUFFER_CONFIG *last_source;
2703
2708 YV12_BUFFER_CONFIG *unscaled_source;
2709
2713 YV12_BUFFER_CONFIG scaled_source;
2714
2718 YV12_BUFFER_CONFIG *unscaled_last_source;
2719
2723 YV12_BUFFER_CONFIG scaled_last_source;
2724
2729 YV12_BUFFER_CONFIG *unfiltered_source;
2730
2734 int skip_tpl_setup_stats;
2735
2739 TemporalFilterCtx tf_ctx;
2740
2744 ForceIntegerMVInfo force_intpel_info;
2745
2750 RefCntBuffer *scaled_ref_buf[INTER_REFS_PER_FRAME];
2751
2755 RefCntBuffer *last_show_frame_buf;
2756
2760 RefreshFrameInfo refresh_frame;
2761
2765 ExternalFlags ext_flags;
2766
2771 YV12_BUFFER_CONFIG last_frame_uf;
2772
2777 YV12_BUFFER_CONFIG trial_frame_rst;
2778
2782 int64_t ambient_err;
2783
2787 RD_OPT rd;
2788
2793 CODING_CONTEXT coding_context;
2794
2798 GlobalMotionInfo gm_info;
2799
2803 WinnerModeParams winner_mode_params;
2804
2808 TimeStamps time_stamps;
2809
2813 RATE_CONTROL rc;
2814
2818 double framerate;
2819
2823 int ref_frame_flags;
2824
2828 int speed;
2829
2833 SPEED_FEATURES sf;
2834
2838 MotionVectorSearchParams mv_search_params;
2839
2844 int all_one_sided_refs;
2845
2849 EncSegmentationInfo enc_seg;
2850
2854 CYCLIC_REFRESH *cyclic_refresh;
2859 ActiveMap active_map;
2860
2864 unsigned char gf_frame_index;
2865
2869 RefBufferStack ref_buffer_stack;
2870
2871#if CONFIG_INTERNAL_STATS
2873 uint64_t time_compress_data;
2874
2875 unsigned int mode_chosen_counts[MAX_MODES];
2876 int bytes;
2877 unsigned int frame_recode_hits;
2879#endif
2880
2881#if CONFIG_SPEED_STATS
2885 unsigned int tx_search_count;
2886#endif // CONFIG_SPEED_STATS
2887
2892 int droppable;
2893
2897 FRAME_INFO frame_info;
2898
2902 FRAME_INDEX_SET frame_index_set;
2903
2907 InitialDimensions initial_dimensions;
2908
2915 int initial_mbs;
2916
2920 ResizePendingParams resize_pending_params;
2921
2926 TileDataEnc *tile_data;
2930 int allocated_tiles;
2931
2935 TokenInfo token_info;
2936
2940 int vaq_refresh;
2941
2945 VarBasedPartitionInfo vbp_info;
2946
2947#if CONFIG_FRAME_PARALLEL_ENCODE
2951 int num_frame_recode;
2952
2956 FrameProbInfo frame_new_probs[NUM_RECODES_PER_FRAME];
2957
2961 int do_update_frame_probs_txtype[NUM_RECODES_PER_FRAME];
2962
2966 int do_update_frame_probs_obmc[NUM_RECODES_PER_FRAME];
2967
2971 int do_update_frame_probs_warp[NUM_RECODES_PER_FRAME];
2972
2976 int do_update_frame_probs_interpfilter[NUM_RECODES_PER_FRAME];
2977
2981 int do_update_vbr_bits_off_target_fast;
2982#if CONFIG_FPMT_TEST
2987 double temp_framerate;
2988#endif
2994 double new_framerate;
2995#endif
2999 MultiThreadInfo mt_info;
3000
3006 int existing_fb_idx_to_show;
3007
3011 int intrabc_used;
3012
3016 int prune_ref_frame_mask;
3017
3021 AV1LrStruct lr_ctxt;
3022
3026 aom_film_grain_table_t *film_grain_table;
3027
3028#if CONFIG_DENOISE
3033 struct aom_denoise_and_model_t *denoise_and_model;
3034#endif
3035
3039 InterpSearchFlags interp_search_flags;
3040
3048 int use_screen_content_tools;
3049
3056 int is_screen_content_type;
3057
3058#if CONFIG_COLLECT_PARTITION_STATS
3062 FramePartitionTimingStats partition_stats;
3063#endif // CONFIG_COLLECT_PARTITION_STATS
3064
3065#if CONFIG_COLLECT_COMPONENT_TIMING
3069 uint64_t component_time[kTimingComponents];
3074 struct aom_usec_timer component_timer[kTimingComponents];
3078 uint64_t frame_component_time[kTimingComponents];
3079#endif
3080
3084 int frame_header_count;
3085
3089 int deltaq_used;
3090
3094 RefFrameDistanceInfo ref_frame_dist_info;
3095
3101 double *ssim_rdmult_scaling_factors;
3102
3103#if CONFIG_TUNE_VMAF
3107 TuneVMAFInfo vmaf_info;
3108#endif
3109
3110#if CONFIG_TUNE_BUTTERAUGLI
3114 TuneButteraugliInfo butteraugli_info;
3115#endif
3116
3120 SVC svc;
3121
3125 COMPRESSOR_STAGE compressor_stage;
3126
3131 FRAME_TYPE last_frame_type;
3132
3136 int num_tg;
3137
3143 aom_superres_mode superres_mode;
3144
3148 FirstPassData firstpass_data;
3149
3153 NOISE_ESTIMATE noise_estimate;
3154
3155#if CONFIG_AV1_TEMPORAL_DENOISING
3159 AV1_DENOISER denoiser;
3160#endif
3161
3166 uint8_t *consec_zero_mv;
3167
3171 BLOCK_SIZE fp_block_size;
3172
3177 int sb_counter;
3178
3182 size_t available_bs_size;
3183
3188 ExtPartController ext_part_controller;
3189
3190#if CONFIG_FRAME_PARALLEL_ENCODE
3196 bool do_frame_data_update;
3197
3202 MV_STATS mv_stats;
3203#if CONFIG_FRAME_PARALLEL_ENCODE_2
3207 int ref_refresh_index;
3208
3213 bool refresh_idx_available;
3214
3220 int ref_idx_to_skip;
3221#if CONFIG_FPMT_TEST
3228 int wanted_fb;
3229#endif
3230#endif // CONFIG_FRAME_PARALLEL_ENCODE_2
3231#endif // CONFIG_FRAME_PARALLEL_ENCODE
3232#if CONFIG_RD_COMMAND
3236 RD_COMMAND rd_command;
3237#endif // CONFIG_RD_COMMAND
3238
3242 WeberStats *mb_weber_stats;
3243
3247 BLOCK_SIZE weber_bsize;
3248
3252 int64_t norm_wiener_variance;
3253
3257 int *mb_delta_q;
3258
3262 bool is_dropped_frame;
3263
3264#if CONFIG_BITRATE_ACCURACY
3268 VBR_RATECTRL_INFO vbr_rc_info;
3269#endif
3270
3274 TWO_PASS_FRAME twopass_frame;
3275
3279 THIRD_PASS_DEC_CTX *third_pass_ctx;
3280
3284 FILE *second_pass_log_stream;
3285} AV1_COMP;
3286
3290typedef struct EncodeFrameInput {
3292 YV12_BUFFER_CONFIG *source;
3293 YV12_BUFFER_CONFIG *last_source;
3294 int64_t ts_duration;
3296} EncodeFrameInput;
3297
3302typedef struct EncodeFrameParams {
3306 int error_resilient_mode;
3310 FRAME_TYPE frame_type;
3311
3313 int primary_ref_frame;
3314 int order_offset;
3315
3320 int show_frame;
3321
3323 int refresh_frame_flags;
3324
3325 int show_existing_frame;
3326 int existing_fb_idx_to_show;
3327
3332 int ref_frame_flags;
3333
3337 int remapped_ref_idx[REF_FRAMES];
3338
3343 RefreshFrameInfo refresh_frame;
3344
3348 int speed;
3349} EncodeFrameParams;
3350
3353// EncodeFrameResults contains information about the result of encoding a
3354// single frame
3355typedef struct {
3356 size_t size; // Size of resulting bitstream
3357} EncodeFrameResults;
3358
3359// Must not be called more than once.
3360void av1_initialize_enc(void);
3361
3362struct AV1_COMP *av1_create_compressor(AV1_PRIMARY *ppi, AV1EncoderConfig *oxcf,
3363 BufferPool *const pool,
3364 COMPRESSOR_STAGE stage,
3365 int lap_lag_in_frames);
3366
3367struct AV1_PRIMARY *av1_create_primary_compressor(
3368 struct aom_codec_pkt_list *pkt_list_head, int num_lap_buffers,
3369 AV1EncoderConfig *oxcf);
3370
3371void av1_remove_compressor(AV1_COMP *cpi);
3372
3373void av1_remove_primary_compressor(AV1_PRIMARY *ppi);
3374
3375#if CONFIG_ENTROPY_STATS
3376void print_entropy_stats(AV1_PRIMARY *const ppi);
3377#endif
3378#if CONFIG_INTERNAL_STATS
3379void print_internal_stats(AV1_PRIMARY *ppi);
3380#endif
3381
3382void av1_change_config_seq(AV1_PRIMARY *ppi, const AV1EncoderConfig *oxcf,
3383 bool *sb_size_changed);
3384
3385void av1_change_config(AV1_COMP *cpi, const AV1EncoderConfig *oxcf,
3386 bool sb_size_changed);
3387
3388void av1_check_initial_width(AV1_COMP *cpi, int use_highbitdepth,
3389 int subsampling_x, int subsampling_y);
3390
3391void av1_init_seq_coding_tools(AV1_PRIMARY *const ppi,
3392 const AV1EncoderConfig *oxcf, int use_svc);
3393
3394void av1_post_encode_updates(AV1_COMP *const cpi,
3395 const AV1_COMP_DATA *const cpi_data);
3396
3397#if CONFIG_FRAME_PARALLEL_ENCODE
3398void av1_scale_references_fpmt(AV1_COMP *cpi, int *ref_buffers_used_map);
3399
3400void av1_increment_scaled_ref_counts_fpmt(BufferPool *buffer_pool,
3401 int ref_buffers_used_map);
3402
3403void av1_release_scaled_references_fpmt(AV1_COMP *cpi);
3404
3405void av1_decrement_ref_counts_fpmt(BufferPool *buffer_pool,
3406 int ref_buffers_used_map);
3407
3408void av1_init_sc_decisions(AV1_PRIMARY *const ppi);
3409
3410AV1_COMP *av1_get_parallel_frame_enc_data(AV1_PRIMARY *const ppi,
3411 AV1_COMP_DATA *const first_cpi_data);
3412
3413int av1_init_parallel_frame_context(const AV1_COMP_DATA *const first_cpi_data,
3414 AV1_PRIMARY *const ppi,
3415 int *ref_buffers_used_map);
3416#endif // CONFIG_FRAME_PARALLEL_ENCODE
3417
3436int av1_receive_raw_frame(AV1_COMP *cpi, aom_enc_frame_flags_t frame_flags,
3437 YV12_BUFFER_CONFIG *sd, int64_t time_stamp,
3438 int64_t end_time_stamp);
3439
3459int av1_get_compressed_data(AV1_COMP *cpi, AV1_COMP_DATA *const cpi_data);
3460
3467int av1_encode(AV1_COMP *const cpi, uint8_t *const dest,
3468 const EncodeFrameInput *const frame_input,
3469 const EncodeFrameParams *const frame_params,
3470 EncodeFrameResults *const frame_results);
3471
3473int av1_get_preview_raw_frame(AV1_COMP *cpi, YV12_BUFFER_CONFIG *dest);
3474
3475int av1_get_last_show_frame(AV1_COMP *cpi, YV12_BUFFER_CONFIG *frame);
3476
3477 aom_codec_err_t av1_copy_new_frame_enc(AV1_COMMON *cm,
3478 YV12_BUFFER_CONFIG *new_frame,
3479 YV12_BUFFER_CONFIG *sd);
3480
3481int av1_use_as_reference(int *ext_ref_frame_flags, int ref_frame_flags);
3482
3483int av1_copy_reference_enc(AV1_COMP *cpi, int idx, YV12_BUFFER_CONFIG *sd);
3484
3485int av1_set_reference_enc(AV1_COMP *cpi, int idx, YV12_BUFFER_CONFIG *sd);
3486
3487int av1_set_size_literal(AV1_COMP *cpi, int width, int height);
3488
3489void av1_set_frame_size(AV1_COMP *cpi, int width, int height);
3490
3491int av1_set_active_map(AV1_COMP *cpi, unsigned char *map, int rows, int cols);
3492
3493int av1_get_active_map(AV1_COMP *cpi, unsigned char *map, int rows, int cols);
3494
3495int av1_set_internal_size(AV1EncoderConfig *const oxcf,
3496 ResizePendingParams *resize_pending_params,
3497 AOM_SCALING horiz_mode, AOM_SCALING vert_mode);
3498
3499int av1_get_quantizer(struct AV1_COMP *cpi);
3500
3501int av1_convert_sect5obus_to_annexb(uint8_t *buffer, size_t *input_size);
3502
3503// Set screen content options.
3504// This function estimates whether to use screen content tools, by counting
3505// the portion of blocks that have few luma colors.
3506// Modifies:
3507// cpi->commom.features.allow_screen_content_tools
3508// cpi->common.features.allow_intrabc
3509// cpi->use_screen_content_tools
3510// cpi->is_screen_content_type
3511// However, the estimation is not accurate and may misclassify videos.
3512// A slower but more accurate approach that determines whether to use screen
3513// content tools is employed later. See av1_determine_sc_tools_with_encoding().
3514void av1_set_screen_content_options(struct AV1_COMP *cpi,
3515 FeatureFlags *features);
3516
3517void av1_update_frame_size(AV1_COMP *cpi);
3518
3519#if CONFIG_FRAME_PARALLEL_ENCODE
3520typedef struct {
3521 int pyr_level;
3522 int disp_order;
3523} RefFrameMapPair;
3524
3525static INLINE void init_ref_map_pair(
3526 AV1_COMP *cpi, RefFrameMapPair ref_frame_map_pairs[REF_FRAMES]) {
3527 if (cpi->ppi->gf_group.update_type[cpi->gf_frame_index] == KF_UPDATE) {
3528 memset(ref_frame_map_pairs, -1, sizeof(*ref_frame_map_pairs) * REF_FRAMES);
3529 return;
3530 }
3531 memset(ref_frame_map_pairs, 0, sizeof(*ref_frame_map_pairs) * REF_FRAMES);
3532 for (int map_idx = 0; map_idx < REF_FRAMES; map_idx++) {
3533 // Get reference frame buffer.
3534 const RefCntBuffer *const buf = cpi->common.ref_frame_map[map_idx];
3535 if (ref_frame_map_pairs[map_idx].disp_order == -1) continue;
3536 if (buf == NULL) {
3537 ref_frame_map_pairs[map_idx].disp_order = -1;
3538 ref_frame_map_pairs[map_idx].pyr_level = -1;
3539 continue;
3540 } else if (buf->ref_count > 1) {
3541 // Once the keyframe is coded, the slots in ref_frame_map will all
3542 // point to the same frame. In that case, all subsequent pointers
3543 // matching the current are considered "free" slots. This will find
3544 // the next occurrence of the current pointer if ref_count indicates
3545 // there are multiple instances of it and mark it as free.
3546 for (int idx2 = map_idx + 1; idx2 < REF_FRAMES; ++idx2) {
3547 const RefCntBuffer *const buf2 = cpi->common.ref_frame_map[idx2];
3548 if (buf2 == buf) {
3549 ref_frame_map_pairs[idx2].disp_order = -1;
3550 ref_frame_map_pairs[idx2].pyr_level = -1;
3551 }
3552 }
3553 }
3554 ref_frame_map_pairs[map_idx].disp_order = (int)buf->display_order_hint;
3555 ref_frame_map_pairs[map_idx].pyr_level = buf->pyramid_level;
3556 }
3557}
3558
3559#if CONFIG_FPMT_TEST
3560static AOM_INLINE void calc_frame_data_update_flag(
3561 GF_GROUP *const gf_group, int gf_frame_index,
3562 bool *const do_frame_data_update) {
3563 *do_frame_data_update = true;
3564 // Set the flag to false for all frames in a given parallel encode set except
3565 // the last frame in the set with frame_parallel_level = 2.
3566 if (gf_group->frame_parallel_level[gf_frame_index] == 1) {
3567 *do_frame_data_update = false;
3568 } else if (gf_group->frame_parallel_level[gf_frame_index] == 2) {
3569 // Check if this is the last frame in the set with frame_parallel_level = 2.
3570 for (int i = gf_frame_index + 1; i < gf_group->size; i++) {
3571 if ((gf_group->frame_parallel_level[i] == 0 &&
3572 (gf_group->update_type[i] == ARF_UPDATE ||
3573 gf_group->update_type[i] == INTNL_ARF_UPDATE)) ||
3574 gf_group->frame_parallel_level[i] == 1) {
3575 break;
3576 } else if (gf_group->frame_parallel_level[i] == 2) {
3577 *do_frame_data_update = false;
3578 break;
3579 }
3580 }
3581 }
3582}
3583#endif
3584#endif // CONFIG_FRAME_PARALLEL_ENCODE
3585
3586// TODO(jingning): Move these functions as primitive members for the new cpi
3587// class.
3588static INLINE void stack_push(int *stack, int *stack_size, int item) {
3589 for (int i = *stack_size - 1; i >= 0; --i) stack[i + 1] = stack[i];
3590 stack[0] = item;
3591 ++*stack_size;
3592}
3593
3594static INLINE int stack_pop(int *stack, int *stack_size) {
3595 if (*stack_size <= 0) return -1;
3596
3597 int item = stack[0];
3598 for (int i = 0; i < *stack_size; ++i) stack[i] = stack[i + 1];
3599 --*stack_size;
3600
3601 return item;
3602}
3603
3604static INLINE int stack_pop_end(int *stack, int *stack_size) {
3605 int item = stack[*stack_size - 1];
3606 stack[*stack_size - 1] = -1;
3607 --*stack_size;
3608
3609 return item;
3610}
3611
3612static INLINE void stack_reset(int *stack, int *stack_size) {
3613 for (int i = 0; i < *stack_size; ++i) stack[i] = INVALID_IDX;
3614 *stack_size = 0;
3615}
3616
3617// av1 uses 10,000,000 ticks/second as time stamp
3618#define TICKS_PER_SEC 10000000LL
3619
3620static INLINE int64_t
3621timebase_units_to_ticks(const aom_rational64_t *timestamp_ratio, int64_t n) {
3622 return n * timestamp_ratio->num / timestamp_ratio->den;
3623}
3624
3625static INLINE int64_t
3626ticks_to_timebase_units(const aom_rational64_t *timestamp_ratio, int64_t n) {
3627 int64_t round = timestamp_ratio->num / 2;
3628 if (round > 0) --round;
3629 return (n * timestamp_ratio->den + round) / timestamp_ratio->num;
3630}
3631
3632static INLINE int frame_is_kf_gf_arf(const AV1_COMP *cpi) {
3633 const GF_GROUP *const gf_group = &cpi->ppi->gf_group;
3634 const FRAME_UPDATE_TYPE update_type =
3635 gf_group->update_type[cpi->gf_frame_index];
3636
3637 return frame_is_intra_only(&cpi->common) || update_type == ARF_UPDATE ||
3638 update_type == GF_UPDATE;
3639}
3640
3641// TODO(huisu@google.com, youzhou@microsoft.com): enable hash-me for HBD.
3642static INLINE int av1_use_hash_me(const AV1_COMP *const cpi) {
3643 return (cpi->common.features.allow_screen_content_tools &&
3644 cpi->common.features.allow_intrabc &&
3645 frame_is_intra_only(&cpi->common));
3646}
3647
3648static INLINE const YV12_BUFFER_CONFIG *get_ref_frame_yv12_buf(
3649 const AV1_COMMON *const cm, MV_REFERENCE_FRAME ref_frame) {
3650 const RefCntBuffer *const buf = get_ref_frame_buf(cm, ref_frame);
3651 return buf != NULL ? &buf->buf : NULL;
3652}
3653
3654static INLINE void alloc_frame_mvs(AV1_COMMON *const cm, RefCntBuffer *buf) {
3655 assert(buf != NULL);
3656 ensure_mv_buffer(buf, cm);
3657 buf->width = cm->width;
3658 buf->height = cm->height;
3659}
3660
3661// Get the allocated token size for a tile. It does the same calculation as in
3662// the frame token allocation.
3663static INLINE unsigned int allocated_tokens(TileInfo tile, int sb_size_log2,
3664 int num_planes) {
3665 int tile_mb_rows = (tile.mi_row_end - tile.mi_row_start + 2) >> 2;
3666 int tile_mb_cols = (tile.mi_col_end - tile.mi_col_start + 2) >> 2;
3667
3668 return get_token_alloc(tile_mb_rows, tile_mb_cols, sb_size_log2, num_planes);
3669}
3670
3671static INLINE void get_start_tok(AV1_COMP *cpi, int tile_row, int tile_col,
3672 int mi_row, TokenExtra **tok, int sb_size_log2,
3673 int num_planes) {
3674 AV1_COMMON *const cm = &cpi->common;
3675 const int tile_cols = cm->tiles.cols;
3676 TileDataEnc *this_tile = &cpi->tile_data[tile_row * tile_cols + tile_col];
3677 const TileInfo *const tile_info = &this_tile->tile_info;
3678
3679 const int tile_mb_cols =
3680 (tile_info->mi_col_end - tile_info->mi_col_start + 2) >> 2;
3681 const int tile_mb_row = (mi_row - tile_info->mi_row_start + 2) >> 2;
3682
3683 *tok = cpi->token_info.tile_tok[tile_row][tile_col] +
3684 get_token_alloc(tile_mb_row, tile_mb_cols, sb_size_log2, num_planes);
3685}
3686
3687void av1_apply_encoding_flags(AV1_COMP *cpi, aom_enc_frame_flags_t flags);
3688
3689#define ALT_MIN_LAG 3
3690static INLINE int is_altref_enabled(int lag_in_frames, bool enable_auto_arf) {
3691 return lag_in_frames >= ALT_MIN_LAG && enable_auto_arf;
3692}
3693
3694static AOM_INLINE int can_disable_altref(const GFConfig *gf_cfg) {
3695 return is_altref_enabled(gf_cfg->lag_in_frames, gf_cfg->enable_auto_arf) &&
3696 (gf_cfg->gf_min_pyr_height == 0);
3697}
3698
3699// Helper function to compute number of blocks on either side of the frame.
3700static INLINE int get_num_blocks(const int frame_length, const int mb_length) {
3701 return (frame_length + mb_length - 1) / mb_length;
3702}
3703
3704// Check if statistics generation stage
3705static INLINE int is_stat_generation_stage(const AV1_COMP *const cpi) {
3706 assert(IMPLIES(cpi->compressor_stage == LAP_STAGE,
3707 cpi->oxcf.pass == AOM_RC_ONE_PASS && cpi->ppi->lap_enabled));
3708 return (cpi->oxcf.pass == AOM_RC_FIRST_PASS ||
3709 (cpi->compressor_stage == LAP_STAGE));
3710}
3711// Check if statistics consumption stage
3712static INLINE int is_stat_consumption_stage_twopass(const AV1_COMP *const cpi) {
3713 return (cpi->oxcf.pass >= AOM_RC_SECOND_PASS);
3714}
3715
3716// Check if statistics consumption stage
3717static INLINE int is_stat_consumption_stage(const AV1_COMP *const cpi) {
3718 return (is_stat_consumption_stage_twopass(cpi) ||
3719 (cpi->oxcf.pass == AOM_RC_ONE_PASS &&
3720 (cpi->compressor_stage == ENCODE_STAGE) && cpi->ppi->lap_enabled));
3721}
3722
3732static INLINE int has_no_stats_stage(const AV1_COMP *const cpi) {
3733 assert(
3734 IMPLIES(!cpi->ppi->lap_enabled, cpi->compressor_stage == ENCODE_STAGE));
3735 return (cpi->oxcf.pass == AOM_RC_ONE_PASS && !cpi->ppi->lap_enabled);
3736}
3737
3740static INLINE int is_one_pass_rt_params(const AV1_COMP *cpi) {
3741 return has_no_stats_stage(cpi) && cpi->oxcf.mode == REALTIME &&
3742 cpi->oxcf.gf_cfg.lag_in_frames == 0;
3743}
3744
3745// Function return size of frame stats buffer
3746static INLINE int get_stats_buf_size(int num_lap_buffer, int num_lag_buffer) {
3747 /* if lookahead is enabled return num_lap_buffers else num_lag_buffers */
3748 return (num_lap_buffer > 0 ? num_lap_buffer + 1 : num_lag_buffer);
3749}
3750
3751// TODO(zoeliu): To set up cpi->oxcf.gf_cfg.enable_auto_brf
3752
3753static INLINE void set_ref_ptrs(const AV1_COMMON *cm, MACROBLOCKD *xd,
3754 MV_REFERENCE_FRAME ref0,
3755 MV_REFERENCE_FRAME ref1) {
3756 xd->block_ref_scale_factors[0] =
3757 get_ref_scale_factors_const(cm, ref0 >= LAST_FRAME ? ref0 : 1);
3758 xd->block_ref_scale_factors[1] =
3759 get_ref_scale_factors_const(cm, ref1 >= LAST_FRAME ? ref1 : 1);
3760}
3761
3762static INLINE int get_chessboard_index(int frame_index) {
3763 return frame_index & 0x1;
3764}
3765
3766static INLINE const int *cond_cost_list_const(const struct AV1_COMP *cpi,
3767 const int *cost_list) {
3768 const int use_cost_list = cpi->sf.mv_sf.subpel_search_method != SUBPEL_TREE &&
3769 cpi->sf.mv_sf.use_fullpel_costlist;
3770 return use_cost_list ? cost_list : NULL;
3771}
3772
3773static INLINE int *cond_cost_list(const struct AV1_COMP *cpi, int *cost_list) {
3774 const int use_cost_list = cpi->sf.mv_sf.subpel_search_method != SUBPEL_TREE &&
3775 cpi->sf.mv_sf.use_fullpel_costlist;
3776 return use_cost_list ? cost_list : NULL;
3777}
3778
3779// Compression ratio of current frame.
3780double av1_get_compression_ratio(const AV1_COMMON *const cm,
3781 size_t encoded_frame_size);
3782
3783void av1_new_framerate(AV1_COMP *cpi, double framerate);
3784
3785void av1_setup_frame_size(AV1_COMP *cpi);
3786
3787#define LAYER_IDS_TO_IDX(sl, tl, num_tl) ((sl) * (num_tl) + (tl))
3788
3789// Returns 1 if a frame is scaled and 0 otherwise.
3790static INLINE int av1_resize_scaled(const AV1_COMMON *cm) {
3791 return !(cm->superres_upscaled_width == cm->render_width &&
3792 cm->superres_upscaled_height == cm->render_height);
3793}
3794
3795static INLINE int av1_frame_scaled(const AV1_COMMON *cm) {
3796 return !av1_superres_scaled(cm) && av1_resize_scaled(cm);
3797}
3798
3799// Don't allow a show_existing_frame to coincide with an error resilient
3800// frame. An exception can be made for a forward keyframe since it has no
3801// previous dependencies.
3802static INLINE int encode_show_existing_frame(const AV1_COMMON *cm) {
3803 return cm->show_existing_frame && (!cm->features.error_resilient_mode ||
3804 cm->current_frame.frame_type == KEY_FRAME);
3805}
3806
3807// Get index into the 'cpi->mbmi_ext_info.frame_base' array for the given
3808// 'mi_row' and 'mi_col'.
3809static INLINE int get_mi_ext_idx(const int mi_row, const int mi_col,
3810 const BLOCK_SIZE mi_alloc_bsize,
3811 const int mbmi_ext_stride) {
3812 const int mi_ext_size_1d = mi_size_wide[mi_alloc_bsize];
3813 const int mi_ext_row = mi_row / mi_ext_size_1d;
3814 const int mi_ext_col = mi_col / mi_ext_size_1d;
3815 return mi_ext_row * mbmi_ext_stride + mi_ext_col;
3816}
3817
3818// Lighter version of set_offsets that only sets the mode info
3819// pointers.
3820static INLINE void set_mode_info_offsets(
3821 const CommonModeInfoParams *const mi_params,
3822 const MBMIExtFrameBufferInfo *const mbmi_ext_info, MACROBLOCK *const x,
3823 MACROBLOCKD *const xd, int mi_row, int mi_col) {
3824 set_mi_offsets(mi_params, xd, mi_row, mi_col);
3825 const int ext_idx = get_mi_ext_idx(mi_row, mi_col, mi_params->mi_alloc_bsize,
3826 mbmi_ext_info->stride);
3827 x->mbmi_ext_frame = mbmi_ext_info->frame_base + ext_idx;
3828}
3829
3830// Check to see if the given partition size is allowed for a specified number
3831// of mi block rows and columns remaining in the image.
3832// If not then return the largest allowed partition size
3833static INLINE BLOCK_SIZE find_partition_size(BLOCK_SIZE bsize, int rows_left,
3834 int cols_left, int *bh, int *bw) {
3835 int int_size = (int)bsize;
3836 if (rows_left <= 0 || cols_left <= 0) {
3837 return AOMMIN(bsize, BLOCK_8X8);
3838 } else {
3839 for (; int_size > 0; int_size -= 3) {
3840 *bh = mi_size_high[int_size];
3841 *bw = mi_size_wide[int_size];
3842 if ((*bh <= rows_left) && (*bw <= cols_left)) {
3843 break;
3844 }
3845 }
3846 }
3847 return (BLOCK_SIZE)int_size;
3848}
3849
3850static const uint8_t av1_ref_frame_flag_list[REF_FRAMES] = { 0,
3851 AOM_LAST_FLAG,
3852 AOM_LAST2_FLAG,
3853 AOM_LAST3_FLAG,
3854 AOM_GOLD_FLAG,
3855 AOM_BWD_FLAG,
3856 AOM_ALT2_FLAG,
3857 AOM_ALT_FLAG };
3858
3859// When more than 'max_allowed_refs' are available, we reduce the number of
3860// reference frames one at a time based on this order.
3861static const MV_REFERENCE_FRAME disable_order[] = {
3862 LAST3_FRAME,
3863 LAST2_FRAME,
3864 ALTREF2_FRAME,
3865 GOLDEN_FRAME,
3866};
3867
3868static const MV_REFERENCE_FRAME
3869 ref_frame_priority_order[INTER_REFS_PER_FRAME] = {
3870 LAST_FRAME, ALTREF_FRAME, BWDREF_FRAME, GOLDEN_FRAME,
3871 ALTREF2_FRAME, LAST2_FRAME, LAST3_FRAME,
3872 };
3873
3874static INLINE int get_ref_frame_flags(const SPEED_FEATURES *const sf,
3875 const int use_one_pass_rt_params,
3876 const YV12_BUFFER_CONFIG **ref_frames,
3877 const int ext_ref_frame_flags) {
3878 // cpi->ext_flags.ref_frame_flags allows certain reference types to be
3879 // disabled by the external interface. These are set by
3880 // av1_apply_encoding_flags(). Start with what the external interface allows,
3881 // then suppress any reference types which we have found to be duplicates.
3882 int flags = ext_ref_frame_flags;
3883
3884 for (int i = 1; i < INTER_REFS_PER_FRAME; ++i) {
3885 const YV12_BUFFER_CONFIG *const this_ref = ref_frames[i];
3886 // If this_ref has appeared before, mark the corresponding ref frame as
3887 // invalid. For one_pass_rt mode, only disable GOLDEN_FRAME if it's the
3888 // same as LAST_FRAME or ALTREF_FRAME (if ALTREF is being used in nonrd).
3889 int index =
3890 (use_one_pass_rt_params && ref_frame_priority_order[i] == GOLDEN_FRAME)
3891 ? (1 + sf->rt_sf.use_nonrd_altref_frame)
3892 : i;
3893 for (int j = 0; j < index; ++j) {
3894 if (this_ref == ref_frames[j]) {
3895 flags &= ~(1 << (ref_frame_priority_order[i] - 1));
3896 break;
3897 }
3898 }
3899 }
3900 return flags;
3901}
3902
3903// Returns a Sequence Header OBU stored in an aom_fixed_buf_t, or NULL upon
3904// failure. When a non-NULL aom_fixed_buf_t pointer is returned by this
3905// function, the memory must be freed by the caller. Both the buf member of the
3906// aom_fixed_buf_t, and the aom_fixed_buf_t pointer itself must be freed. Memory
3907// returned must be freed via call to free().
3908//
3909// Note: The OBU returned is in Low Overhead Bitstream Format. Specifically,
3910// the obu_has_size_field bit is set, and the buffer contains the obu_size
3911// field.
3912 aom_fixed_buf_t *av1_get_global_headers(AV1_PRIMARY *ppi);
3913
3914#define MAX_GFUBOOST_FACTOR 10.0
3915#define MIN_GFUBOOST_FACTOR 4.0
3916
3917static INLINE int is_frame_tpl_eligible(const GF_GROUP *const gf_group,
3918 uint8_t index) {
3919 const FRAME_UPDATE_TYPE update_type = gf_group->update_type[index];
3920 return update_type == ARF_UPDATE || update_type == GF_UPDATE ||
3921 update_type == KF_UPDATE;
3922}
3923
3924static INLINE int is_frame_eligible_for_ref_pruning(const GF_GROUP *gf_group,
3925 int selective_ref_frame,
3926 int prune_ref_frames,
3927 int gf_index) {
3928 return (selective_ref_frame > 0) && (prune_ref_frames > 0) &&
3929 !is_frame_tpl_eligible(gf_group, gf_index);
3930}
3931
3932// Get update type of the current frame.
3933static INLINE FRAME_UPDATE_TYPE get_frame_update_type(const GF_GROUP *gf_group,
3934 int gf_frame_index) {
3935 return gf_group->update_type[gf_frame_index];
3936}
3937
3938static INLINE int av1_pixels_to_mi(int pixels) {
3939 return ALIGN_POWER_OF_TWO(pixels, 3) >> MI_SIZE_LOG2;
3940}
3941
3942static AOM_INLINE int is_psnr_calc_enabled(const AV1_COMP *cpi) {
3943 const AV1_COMMON *const cm = &cpi->common;
3944
3945 return cpi->ppi->b_calculate_psnr && !is_stat_generation_stage(cpi) &&
3946 cm->show_frame;
3947}
3948
3949static INLINE int is_frame_resize_pending(AV1_COMP *const cpi) {
3950 ResizePendingParams *const resize_pending_params =
3951 &cpi->resize_pending_params;
3952 return (resize_pending_params->width && resize_pending_params->height &&
3953 (cpi->common.width != resize_pending_params->width ||
3954 cpi->common.height != resize_pending_params->height));
3955}
3956
3957// Check if loop restoration filter is used.
3958static INLINE int is_restoration_used(const AV1_COMMON *const cm) {
3959 return cm->seq_params->enable_restoration && !cm->features.all_lossless &&
3960 !cm->tiles.large_scale;
3961}
3962
3963#if CONFIG_AV1_TEMPORAL_DENOISING
3964static INLINE int denoise_svc(const struct AV1_COMP *const cpi) {
3965 return (!cpi->ppi->use_svc ||
3966 (cpi->ppi->use_svc &&
3967 cpi->svc.spatial_layer_id >= cpi->svc.first_layer_denoise));
3968}
3969#endif
3970
3971#if CONFIG_COLLECT_PARTITION_STATS == 2
3972static INLINE void av1_print_fr_partition_timing_stats(
3973 const FramePartitionTimingStats *part_stats, const char *filename) {
3974 FILE *f = fopen(filename, "w");
3975 if (!f) {
3976 return;
3977 }
3978
3979 fprintf(f, "bsize,redo,");
3980 for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
3981 fprintf(f, "decision_%d,", part);
3982 }
3983 for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
3984 fprintf(f, "attempt_%d,", part);
3985 }
3986 for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
3987 fprintf(f, "time_%d,", part);
3988 }
3989 fprintf(f, "\n");
3990
3991 static const int bsizes[6] = { 128, 64, 32, 16, 8, 4 };
3992
3993 for (int bsize_idx = 0; bsize_idx < 6; bsize_idx++) {
3994 fprintf(f, "%d,%d,", bsizes[bsize_idx], part_stats->partition_redo);
3995 for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
3996 fprintf(f, "%d,", part_stats->partition_decisions[bsize_idx][part]);
3997 }
3998 for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
3999 fprintf(f, "%d,", part_stats->partition_attempts[bsize_idx][part]);
4000 }
4001 for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
4002 fprintf(f, "%ld,", part_stats->partition_times[bsize_idx][part]);
4003 }
4004 fprintf(f, "\n");
4005 }
4006 fclose(f);
4007}
4008#endif // CONFIG_COLLECT_PARTITION_STATS == 2
4009
4010#if CONFIG_COLLECT_PARTITION_STATS
4011static INLINE int av1_get_bsize_idx_for_part_stats(BLOCK_SIZE bsize) {
4012 assert(bsize == BLOCK_128X128 || bsize == BLOCK_64X64 ||
4013 bsize == BLOCK_32X32 || bsize == BLOCK_16X16 || bsize == BLOCK_8X8 ||
4014 bsize == BLOCK_4X4);
4015 switch (bsize) {
4016 case BLOCK_128X128: return 0;
4017 case BLOCK_64X64: return 1;
4018 case BLOCK_32X32: return 2;
4019 case BLOCK_16X16: return 3;
4020 case BLOCK_8X8: return 4;
4021 case BLOCK_4X4: return 5;
4022 default: assert(0 && "Invalid bsize for partition_stats."); return -1;
4023 }
4024}
4025#endif // CONFIG_COLLECT_PARTITION_STATS
4026
4027#if CONFIG_COLLECT_COMPONENT_TIMING
4028static INLINE void start_timing(AV1_COMP *cpi, int component) {
4029 aom_usec_timer_start(&cpi->component_timer[component]);
4030}
4031static INLINE void end_timing(AV1_COMP *cpi, int component) {
4032 aom_usec_timer_mark(&cpi->component_timer[component]);
4033 cpi->frame_component_time[component] +=
4034 aom_usec_timer_elapsed(&cpi->component_timer[component]);
4035}
4036static INLINE char const *get_frame_type_enum(int type) {
4037 switch (type) {
4038 case 0: return "KEY_FRAME";
4039 case 1: return "INTER_FRAME";
4040 case 2: return "INTRA_ONLY_FRAME";
4041 case 3: return "S_FRAME";
4042 default: assert(0);
4043 }
4044 return "error";
4045}
4046#endif
4047
4050#ifdef __cplusplus
4051} // extern "C"
4052#endif
4053
4054#endif // AOM_AV1_ENCODER_ENCODER_H_
FIXED_QP_OFFSET_COUNT
#define FIXED_QP_OFFSET_COUNT
Number of fixed QP offsets.
Definition: aom_encoder.h:895
aom_chroma_sample_position_t
enum aom_chroma_sample_position aom_chroma_sample_position_t
List of chroma sample positions.
aom_transfer_characteristics_t
enum aom_transfer_characteristics aom_transfer_characteristics_t
List of supported transfer functions.
aom_color_range_t
enum aom_color_range aom_color_range_t
List of supported color range.
aom_color_primaries_t
enum aom_color_primaries aom_color_primaries_t
List of supported color primaries.
aom_matrix_coefficients_t
enum aom_matrix_coefficients aom_matrix_coefficients_t
List of supported matrix coefficients.
aomcx.h
Provides definitions for using AOM or AV1 encoder algorithm within the aom Codec Interface.
block.h
enums.h
RESTORE_SWITCHABLE_TYPES
@ RESTORE_SWITCHABLE_TYPES
Definition: enums.h:602
aom_tune_content
aom_tune_content
Definition: aomcx.h:1474
aom_tune_metric
aom_tune_metric
Model tuning parameters.
Definition: aomcx.h:1493
aom_bit_depth_t
enum aom_bit_depth aom_bit_depth_t
Bit depth for codecThis enumeration determines the bit depth of the codec.
aom_superblock_size_t
enum aom_superblock_size aom_superblock_size_t
Superblock size selection.
aom_codec_err_t
aom_codec_err_t
Algorithm return codes.
Definition: aom_codec.h:155
aom_superres_mode
aom_superres_mode
Frame super-resolution mode.
Definition: aom_encoder.h:206
aom_rc_mode
aom_rc_mode
Rate control mode.
Definition: aom_encoder.h:184
aom_enc_pass
aom_enc_pass
Multi-pass Encoding Pass.
Definition: aom_encoder.h:175
aom_enc_frame_flags_t
long aom_enc_frame_flags_t
Encoded Frame Flags.
Definition: aom_encoder.h:376
AOM_RC_ONE_PASS
@ AOM_RC_ONE_PASS
Definition: aom_encoder.h:176
AOM_RC_SECOND_PASS
@ AOM_RC_SECOND_PASS
Definition: aom_encoder.h:178
AOM_RC_FIRST_PASS
@ AOM_RC_FIRST_PASS
Definition: aom_encoder.h:177
lookahead.h
Describes look ahead buffer operations.
speed_features.h
AV1Common
Top level common structure used by both encoder and decoder.
Definition: av1_common_int.h:755
AV1Common::superres_upscaled_width
int superres_upscaled_width
Definition: av1_common_int.h:804
AV1Common::superres_upscaled_height
int superres_upscaled_height
Definition: av1_common_int.h:805
AV1Common::seq_params
SequenceHeader * seq_params
Definition: av1_common_int.h:981
AV1Common::width
int width
Definition: av1_common_int.h:780
AV1Common::current_frame
CurrentFrame current_frame
Definition: av1_common_int.h:759
AV1Common::show_existing_frame
int show_existing_frame
Definition: av1_common_int.h:905
AV1Common::features
FeatureFlags features
Definition: av1_common_int.h:910
AV1Common::show_frame
int show_frame
Definition: av1_common_int.h:890
AV1Common::tiles
CommonTileParams tiles
Definition: av1_common_int.h:997
AV1Common::height
int height
Definition: av1_common_int.h:781
AV1Common::render_width
int render_width
Definition: av1_common_int.h:791
AV1Common::render_height
int render_height
Definition: av1_common_int.h:792
CB_COEFF_BUFFER
Stores the transforms coefficients for the whole superblock.
Definition: block.h:180
CYCLIC_REFRESH
The stucture of CYCLIC_REFRESH.
Definition: aq_cyclicrefresh.h:36
CdefInfo
Parameters related to CDEF.
Definition: av1_common_int.h:198
CommonModeInfoParams
Params related to MB_MODE_INFO arrays and related info.
Definition: av1_common_int.h:505
CommonModeInfoParams::mi_alloc_bsize
BLOCK_SIZE mi_alloc_bsize
Definition: av1_common_int.h:554
CommonTileParams::cols
int cols
Definition: av1_common_int.h:432
CommonTileParams::large_scale
unsigned int large_scale
Definition: av1_common_int.h:492
CompoundTypeRdBuffers
Contains buffers used by av1_compound_type_rd()
Definition: block.h:340
FeatureFlags
Frame level features.
Definition: av1_common_int.h:362
FeatureFlags::error_resilient_mode
bool error_resilient_mode
Definition: av1_common_int.h:404
FeatureFlags::all_lossless
bool all_lossless
Definition: av1_common_int.h:393
GF_GROUP
Data related to the current GF/ARF group and the individual frames within the group.
Definition: firstpass.h:344
MB_MODE_INFO_EXT_FRAME
Stores best extended mode information at frame level.
Definition: block.h:216
MB_MODE_INFO
Stores the prediction/txfm mode of the current coding block.
Definition: blockd.h:222
OBMCBuffer
Contains buffers used to speed up rdopt for obmc.
Definition: block.h:303
PALETTE_BUFFER
Contains color maps used in palette mode.
Definition: block.h:328
PRIMARY_RATE_CONTROL
Primary Rate Control parameters and status.
Definition: ratectrl.h:243
RATE_CONTROL
Rate Control parameters and status.
Definition: ratectrl.h:121
SPEED_FEATURES
Top level speed vs quality trade off data struture.
Definition: speed_features.h:1388
SPEED_FEATURES::rt_sf
REAL_TIME_SPEED_FEATURES rt_sf
Definition: speed_features.h:1457
SVC
The stucture of SVC.
Definition: svc_layercontext.h:87
TEMPORAL_FILTER_INFO
Temporal filter info for a gop.
Definition: temporal_filter.h:154
TWO_PASS_FRAME
Frame level Two pass status and control data.
Definition: firstpass.h:455
TWO_PASS
Two pass status and control data.
Definition: firstpass.h:412
TemporalFilterCtx
Parameters related to temporal filtering.
Definition: temporal_filter.h:91
TplParams
Params related to temporal dependency model.
Definition: tpl_model.h:139
aom_fixed_buf
Generic fixed size buffer structure.
Definition: aom_encoder.h:87
macroblock
Encoder's parameters related to the current coding block.
Definition: block.h:778
macroblock::mbmi_ext_frame
MB_MODE_INFO_EXT_FRAME * mbmi_ext_frame
Finalized mbmi_ext for the whole frame.
Definition: block.h:810
macroblockd
Variables related to current coding block.
Definition: blockd.h:577
macroblockd::block_ref_scale_factors
const struct scale_factors * block_ref_scale_factors[2]
Definition: blockd.h:694
yv12_buffer_config
YV12 frame buffer data structure.
Definition: yv12config.h:39