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#include "aom_util/aom_pthread.h"
25
26#include "av1/common/alloccommon.h"
27#include "av1/common/av1_common_int.h"
28#include "av1/common/blockd.h"
29#include "av1/common/entropymode.h"
30#include "av1/common/enums.h"
31#include "av1/common/reconintra.h"
32#include "av1/common/resize.h"
33#include "av1/common/thread_common.h"
34#include "av1/common/timing.h"
35
36#include "av1/encoder/aq_cyclicrefresh.h"
37#include "av1/encoder/av1_ext_ratectrl.h"
38#include "av1/encoder/av1_quantize.h"
39#include "av1/encoder/block.h"
40#include "av1/encoder/context_tree.h"
41#include "av1/encoder/enc_enums.h"
42#include "av1/encoder/encodemb.h"
43#include "av1/encoder/external_partition.h"
44#include "av1/encoder/firstpass.h"
45#include "av1/encoder/global_motion.h"
46#include "av1/encoder/level.h"
47#include "av1/encoder/lookahead.h"
48#include "av1/encoder/mcomp.h"
49#include "av1/encoder/pickcdef.h"
50#include "av1/encoder/ratectrl.h"
51#include "av1/encoder/rd.h"
52#include "av1/encoder/speed_features.h"
53#include "av1/encoder/svc_layercontext.h"
54#include "av1/encoder/temporal_filter.h"
55#if CONFIG_THREE_PASS
56#include "av1/encoder/thirdpass.h"
57#endif
58#include "av1/encoder/tokenize.h"
59#include "av1/encoder/tpl_model.h"
60#include "av1/encoder/av1_noise_estimate.h"
61#include "av1/encoder/bitstream.h"
62
63#if CONFIG_INTERNAL_STATS
64#include "aom_dsp/ssim.h"
65#endif
66#include "aom_dsp/variance.h"
67#if CONFIG_DENOISE
68#include "aom_dsp/noise_model.h"
69#endif
70#if CONFIG_TUNE_VMAF
71#include "av1/encoder/tune_vmaf.h"
72#endif
73#if CONFIG_AV1_TEMPORAL_DENOISING
74#include "av1/encoder/av1_temporal_denoiser.h"
75#endif
76#if CONFIG_TUNE_BUTTERAUGLI
77#include "av1/encoder/tune_butteraugli.h"
78#endif
79
80#include "aom/internal/aom_codec_internal.h"
81
82#ifdef __cplusplus
83extern "C" {
84#endif
85
86// TODO(yunqing, any): Added suppression tag to quiet Doxygen warnings. Need to
87// adjust it while we work on documentation.
89// Number of frames required to test for scene cut detection
90#define SCENE_CUT_KEY_TEST_INTERVAL 16
91
92// Lookahead index threshold to enable temporal filtering for second arf.
93#define TF_LOOKAHEAD_IDX_THR 7
94
95#define HDR_QP_LEVELS 10
96#define CHROMA_CB_QP_SCALE 1.04
97#define CHROMA_CR_QP_SCALE 1.04
98#define CHROMA_QP_SCALE -0.46
99#define CHROMA_QP_OFFSET 9.26
100#define QP_SCALE_FACTOR 2.0
101#define DISABLE_HDR_LUMA_DELTAQ 1
102
103// Rational number with an int64 numerator
104// This structure holds a fractional value
105typedef struct aom_rational64 {
106 int64_t num; // fraction numerator
107 int den; // fraction denominator
108} aom_rational64_t; // alias for struct aom_rational
109
110enum {
111 FRAMEFLAGS_KEY = 1 << 0,
112 FRAMEFLAGS_GOLDEN = 1 << 1,
113 FRAMEFLAGS_BWDREF = 1 << 2,
114 // TODO(zoeliu): To determine whether a frame flag is needed for ALTREF2_FRAME
115 FRAMEFLAGS_ALTREF = 1 << 3,
116 FRAMEFLAGS_INTRAONLY = 1 << 4,
117 FRAMEFLAGS_SWITCH = 1 << 5,
118 FRAMEFLAGS_ERROR_RESILIENT = 1 << 6,
119} UENUM1BYTE(FRAMETYPE_FLAGS);
120
121#if CONFIG_FPMT_TEST
122enum {
123 PARALLEL_ENCODE = 0,
124 PARALLEL_SIMULATION_ENCODE,
125 NUM_FPMT_TEST_ENCODES
126} UENUM1BYTE(FPMT_TEST_ENC_CFG);
127#endif // CONFIG_FPMT_TEST
128// 0 level frames are sometimes used for rate control purposes, but for
129// reference mapping purposes, the minimum level should be 1.
130#define MIN_PYR_LEVEL 1
131static inline int get_true_pyr_level(int frame_level, int frame_order,
132 int max_layer_depth) {
133 if (frame_order == 0) {
134 // Keyframe case
135 return MIN_PYR_LEVEL;
136 } else if (frame_level == MAX_ARF_LAYERS) {
137 // Leaves
138 return max_layer_depth;
139 } else if (frame_level == (MAX_ARF_LAYERS + 1)) {
140 // Altrefs
141 return MIN_PYR_LEVEL;
142 }
143 return AOMMAX(MIN_PYR_LEVEL, frame_level);
144}
145
146enum {
147 NO_AQ = 0,
148 VARIANCE_AQ = 1,
149 COMPLEXITY_AQ = 2,
150 CYCLIC_REFRESH_AQ = 3,
151 AQ_MODE_COUNT // This should always be the last member of the enum
152} UENUM1BYTE(AQ_MODE);
153enum {
154 NO_DELTA_Q = 0,
155 DELTA_Q_OBJECTIVE = 1, // Modulation to improve objective quality
156 DELTA_Q_PERCEPTUAL = 2, // Modulation to improve video perceptual quality
157 DELTA_Q_PERCEPTUAL_AI = 3, // Perceptual quality opt for all intra mode
158 DELTA_Q_USER_RATING_BASED = 4, // User rating based delta q mode
159 DELTA_Q_HDR = 5, // QP adjustment based on HDR block pixel average
160 DELTA_Q_VARIANCE_BOOST = 6, // Variance Boost style modulation
161 DELTA_Q_MODE_COUNT // This should always be the last member of the enum
162} UENUM1BYTE(DELTAQ_MODE);
163
164enum {
165 RESIZE_NONE = 0, // No frame resizing allowed.
166 RESIZE_FIXED = 1, // All frames are coded at the specified scale.
167 RESIZE_RANDOM = 2, // All frames are coded at a random scale.
168 RESIZE_DYNAMIC = 3, // Frames coded at lower scale based on rate control.
169 RESIZE_MODES
170} UENUM1BYTE(RESIZE_MODE);
171
172enum {
173 SS_CFG_SRC = 0,
174 SS_CFG_LOOKAHEAD = 1,
175 SS_CFG_FPF = 2,
176 SS_CFG_TOTAL = 3
177} UENUM1BYTE(SS_CFG_OFFSET);
178
179enum {
180 DISABLE_SCENECUT, // For LAP, lag_in_frames < 19
181 ENABLE_SCENECUT_MODE_1, // For LAP, lag_in_frames >=19 and < 33
182 ENABLE_SCENECUT_MODE_2 // For twopass and LAP - lag_in_frames >=33
183} UENUM1BYTE(SCENECUT_MODE);
184
185#define MAX_VBR_CORPUS_COMPLEXITY 10000
186
187typedef enum {
188 MOD_FP, // First pass
189 MOD_TF, // Temporal filtering
190 MOD_TPL, // TPL
191 MOD_GME, // Global motion estimation
192 MOD_ENC, // Encode stage
193 MOD_LPF, // Deblocking loop filter
194 MOD_CDEF_SEARCH, // CDEF search
195 MOD_CDEF, // CDEF frame
196 MOD_LR, // Loop restoration filtering
197 MOD_PACK_BS, // Pack bitstream
198 MOD_FRAME_ENC, // Frame Parallel encode
199 MOD_AI, // All intra
200 NUM_MT_MODULES
201} MULTI_THREADED_MODULES;
202
204
211 typedef enum {
212 COST_UPD_SB,
213 COST_UPD_SBROW,
214 COST_UPD_TILE,
215 COST_UPD_OFF,
216 NUM_COST_UPDATE_TYPES,
217} COST_UPDATE_TYPE;
218
222 typedef enum {
223 LOOPFILTER_NONE = 0,
224 LOOPFILTER_ALL = 1,
225 LOOPFILTER_REFERENCE = 2,
226 LOOPFILTER_SELECTIVELY =
227 3,
228} LOOPFILTER_CONTROL;
229
234 typedef enum {
235 SKIP_APPLY_RESTORATION = 1 << 0,
236 SKIP_APPLY_SUPERRES = 1 << 1,
237 SKIP_APPLY_CDEF = 1 << 2,
238 SKIP_APPLY_LOOPFILTER = 1 << 3,
239} SKIP_APPLY_POSTPROC_FILTER;
240
244 typedef struct {
248 RESIZE_MODE resize_mode;
253 uint8_t resize_scale_denominator;
258 uint8_t resize_kf_scale_denominator;
259} ResizeCfg;
260
264 typedef struct {
268 bool enable_rect_partitions;
272 bool enable_ab_partitions;
276 bool enable_1to4_partitions;
281 BLOCK_SIZE min_partition_size;
286 BLOCK_SIZE max_partition_size;
287} PartitionCfg;
288
292 typedef struct {
296 bool enable_intra_edge_filter;
301 bool enable_filter_intra;
305 bool enable_smooth_intra;
309 bool enable_paeth_intra;
313 bool enable_cfl_intra;
317 bool enable_directional_intra;
322 bool enable_diagonal_intra;
327 bool enable_angle_delta;
341 bool auto_intra_tools_off;
342} IntraModeCfg;
343
347 typedef struct {
351 bool enable_tx64;
355 bool enable_flip_idtx;
359 bool enable_rect_tx;
364 bool reduced_tx_type_set;
369 bool use_intra_dct_only;
374 bool use_inter_dct_only;
379 bool use_intra_default_tx_only;
383 bool enable_tx_size_search;
384} TxfmSizeTypeCfg;
385
389 typedef struct {
393 bool enable_dist_wtd_comp;
398 bool enable_masked_comp;
402 bool enable_smooth_interintra;
406 bool enable_diff_wtd_comp;
410 bool enable_interinter_wedge;
414 bool enable_interintra_wedge;
415} CompoundTypeCfg;
416
420 typedef struct {
425 int superres_qthresh;
430 int superres_kf_qthresh;
436 uint8_t superres_scale_denominator;
442 uint8_t superres_kf_scale_denominator;
446 aom_superres_mode superres_mode;
450 bool enable_superres;
451} SuperResCfg;
452
456 typedef struct {
460 int key_freq_min;
461
465 int key_freq_max;
466
470 int enable_keyframe_filtering;
471
476 int sframe_dist;
477
483 int sframe_mode;
484
488 bool auto_key;
489
493 int fwd_kf_dist;
494
498 bool fwd_kf_enabled;
499
503 bool enable_sframe;
504
508 bool enable_intrabc;
509} KeyFrameCfg;
510
514 typedef struct {
516 // BUFFERING PARAMETERS
523 int64_t starting_buffer_level_ms;
528 int64_t optimal_buffer_level_ms;
533 int64_t maximum_buffer_size_ms;
534
538 int64_t target_bandwidth;
539
544 unsigned int vbr_corpus_complexity_lap;
549 unsigned int max_intra_bitrate_pct;
554 unsigned int max_inter_bitrate_pct;
558 unsigned int gf_cbr_boost_pct;
563 unsigned int min_cr;
567 int drop_frames_water_mark;
573 int under_shoot_pct;
579 int over_shoot_pct;
584 int worst_allowed_q;
589 int best_allowed_q;
593 int cq_level;
598 enum aom_rc_mode mode;
605 int vbrbias;
610 int vbrmin_section;
615 int vbrmax_section;
616
622 int max_consec_drop_ms;
626 int force_max_q;
627} RateControlCfg;
628
630typedef struct {
631 // Indicates the number of frames lag before encoding is started.
632 int lag_in_frames;
633 // Indicates the minimum gf/arf interval to be used.
634 int min_gf_interval;
635 // Indicates the maximum gf/arf interval to be used.
636 int max_gf_interval;
637 // Indicates the minimum height for GF group pyramid structure to be used.
638 int gf_min_pyr_height;
639 // Indicates the maximum height for GF group pyramid structure to be used.
640 int gf_max_pyr_height;
641 // Indicates if automatic set and use of altref frames should be enabled.
642 bool enable_auto_arf;
643 // Indicates if automatic set and use of (b)ackward (r)ef (f)rames should be
644 // enabled.
645 bool enable_auto_brf;
646} GFConfig;
647
648typedef struct {
649 // Indicates the number of tile groups.
650 unsigned int num_tile_groups;
651 // Indicates the MTU size for a tile group. If mtu is non-zero,
652 // num_tile_groups is set to DEFAULT_MAX_NUM_TG.
653 unsigned int mtu;
654 // Indicates the number of tile columns in log2.
655 int tile_columns;
656 // Indicates the number of tile rows in log2.
657 int tile_rows;
658 // Indicates the number of widths in the tile_widths[] array.
659 int tile_width_count;
660 // Indicates the number of heights in the tile_heights[] array.
661 int tile_height_count;
662 // Indicates the tile widths, and may be empty.
663 int tile_widths[MAX_TILE_COLS];
664 // Indicates the tile heights, and may be empty.
665 int tile_heights[MAX_TILE_ROWS];
666 // Indicates if large scale tile coding should be used.
667 bool enable_large_scale_tile;
668 // Indicates if single tile decoding mode should be enabled.
669 bool enable_single_tile_decoding;
670 // Indicates if EXT_TILE_DEBUG should be enabled.
671 bool enable_ext_tile_debug;
672} TileConfig;
673
674typedef struct {
675 // Indicates the width of the input frame.
676 int width;
677 // Indicates the height of the input frame.
678 int height;
679 // If forced_max_frame_width is non-zero then it is used to force the maximum
680 // frame width written in write_sequence_header().
681 int forced_max_frame_width;
682 // If forced_max_frame_width is non-zero then it is used to force the maximum
683 // frame height written in write_sequence_header().
684 int forced_max_frame_height;
685 // Indicates the frame width after applying both super-resolution and resize
686 // to the coded frame.
687 int render_width;
688 // Indicates the frame height after applying both super-resolution and resize
689 // to the coded frame.
690 int render_height;
691} FrameDimensionCfg;
692
693typedef struct {
694 // Indicates if warped motion should be enabled.
695 bool enable_warped_motion;
696 // Indicates if warped motion should be evaluated or not.
697 bool allow_warped_motion;
698 // Indicates if OBMC motion should be enabled.
699 bool enable_obmc;
700} MotionModeCfg;
701
702typedef struct {
703 // Timing info for each frame.
704 aom_timing_info_t timing_info;
705 // Indicates the number of time units of a decoding clock.
706 uint32_t num_units_in_decoding_tick;
707 // Indicates if decoder model information is present in the coded sequence
708 // header.
709 bool decoder_model_info_present_flag;
710 // Indicates if display model information is present in the coded sequence
711 // header.
712 bool display_model_info_present_flag;
713 // Indicates if timing info for each frame is present.
714 bool timing_info_present;
715} DecoderModelCfg;
716
717typedef struct {
718 // Indicates the update frequency for coeff costs.
719 COST_UPDATE_TYPE coeff;
720 // Indicates the update frequency for mode costs.
721 COST_UPDATE_TYPE mode;
722 // Indicates the update frequency for mv costs.
723 COST_UPDATE_TYPE mv;
724 // Indicates the update frequency for dv costs.
725 COST_UPDATE_TYPE dv;
726} CostUpdateFreq;
727
728typedef struct {
729 // Indicates the maximum number of reference frames allowed per frame.
730 unsigned int max_reference_frames;
731 // Indicates if the reduced set of references should be enabled.
732 bool enable_reduced_reference_set;
733 // Indicates if one-sided compound should be enabled.
734 bool enable_onesided_comp;
735} RefFrameCfg;
736
737typedef struct {
738 // Indicates the color space that should be used.
739 aom_color_primaries_t color_primaries;
740 // Indicates the characteristics of transfer function to be used.
741 aom_transfer_characteristics_t transfer_characteristics;
742 // Indicates the matrix coefficients to be used for the transfer function.
743 aom_matrix_coefficients_t matrix_coefficients;
744 // Indicates the chroma 4:2:0 sample position info.
745 aom_chroma_sample_position_t chroma_sample_position;
746 // Indicates if a limited color range or full color range should be used.
747 aom_color_range_t color_range;
748} ColorCfg;
749
750typedef struct {
751 // Indicates if extreme motion vector unit test should be enabled or not.
752 unsigned int motion_vector_unit_test;
753 // Indicates if superblock multipass unit test should be enabled or not.
754 unsigned int sb_multipass_unit_test;
755} UnitTestCfg;
756
757typedef struct {
758 // Indicates the file path to the VMAF model.
759 const char *vmaf_model_path;
760 // Indicates the path to the film grain parameters.
761 const char *film_grain_table_filename;
762 // Indicates the visual tuning metric.
763 aom_tune_metric tuning;
764 // Indicates if the current content is screen or default type.
765 aom_tune_content content;
766 // Indicates the film grain parameters.
767 int film_grain_test_vector;
768 // Indicates the in-block distortion metric to use.
769 aom_dist_metric dist_metric;
770} TuneCfg;
771
772typedef struct {
773 // Indicates the framerate of the input video.
774 double init_framerate;
775 // Indicates the actual bit-depth of the input source.
776 unsigned int input_bit_depth;
777 // Indicates the maximum number of frames to be encoded.
778 unsigned int limit;
779 // Indicates the chrome subsampling x value.
780 unsigned int chroma_subsampling_x;
781 // Indicates the chrome subsampling y value.
782 unsigned int chroma_subsampling_y;
783} InputCfg;
784
785typedef struct {
786 // Controls how the encoder applies fixed QP offsets.
787 // If the value is 0, QP offsets are chosen adaptively.
788 // If the value is 1, fixed QP offsets are picked automatically from cq_level.
789 // If the value is 2, no QP offsets will be applied.
790 int use_fixed_qp_offsets;
791 // Indicates the minimum flatness of the quantization matrix.
792 int qm_minlevel;
793 // Indicates the maximum flatness of the quantization matrix.
794 int qm_maxlevel;
795 // Indicates if adaptive quantize_b should be enabled.
796 int quant_b_adapt;
797 // Indicates the Adaptive Quantization mode to be used.
798 AQ_MODE aq_mode;
799 // Indicates the delta q mode to be used.
800 DELTAQ_MODE deltaq_mode;
801 // Indicates the delta q mode strength.
802 unsigned int deltaq_strength;
803 // Indicates if delta quantization should be enabled in chroma planes.
804 bool enable_chroma_deltaq;
805 // Indicates if delta quantization should be enabled for hdr video
806 bool enable_hdr_deltaq;
807 // Indicates if encoding with quantization matrices should be enabled.
808 bool using_qm;
809} QuantizationCfg;
810
815 typedef struct {
829 int sharpness;
830
834 bool enable_adaptive_sharpness;
835
843 int disable_trellis_quant;
844
848 int arnr_max_frames;
849
853 int arnr_strength;
854
861 uint8_t cdf_update_mode;
862
866 bool enable_tpl_model;
867
872 bool enable_overlay;
873
881 LOOPFILTER_CONTROL loopfilter_control;
882
887 bool skip_postproc_filtering;
888
893 int mode_ref_delta_enabled;
894
898 aom_screen_detection_mode screen_detection_mode;
899} AlgoCfg;
900
901
902typedef struct {
903 // Indicates the codec bit-depth.
904 aom_bit_depth_t bit_depth;
905 // Indicates the superblock size that should be used by the encoder.
906 aom_superblock_size_t superblock_size;
907 // Indicates if loopfilter modulation should be enabled.
908 bool enable_deltalf_mode;
909 // Indicates how CDEF should be applied.
910 CDEF_CONTROL cdef_control;
911 // Indicates if loop restoration filter should be enabled.
912 bool enable_restoration;
913 // When enabled, video mode should be used even for single frame input.
914 bool force_video_mode;
915 // Indicates if the error resiliency features should be enabled.
916 bool error_resilient_mode;
917 // Indicates if frame parallel decoding feature should be enabled.
918 bool frame_parallel_decoding_mode;
919 // Indicates if the input should be encoded as monochrome.
920 bool enable_monochrome;
921 // When enabled, the encoder will use a full header even for still pictures.
922 // When disabled, a reduced header is used for still pictures.
923 bool full_still_picture_hdr;
924 // Indicates if dual interpolation filters should be enabled.
925 bool enable_dual_filter;
926 // Indicates if frame order hint should be enabled or not.
927 bool enable_order_hint;
928 // Indicates if ref_frame_mvs should be enabled at the sequence level.
929 bool ref_frame_mvs_present;
930 // Indicates if ref_frame_mvs should be enabled at the frame level.
931 bool enable_ref_frame_mvs;
932 // Indicates if interintra compound mode is enabled.
933 bool enable_interintra_comp;
934 // Indicates if global motion should be enabled.
935 bool enable_global_motion;
936 // Indicates if palette should be enabled.
937 bool enable_palette;
938} ToolCfg;
939
944 typedef struct AV1EncoderConfig {
946 // Configuration related to the input video.
947 InputCfg input_cfg;
948
949 // Configuration related to frame-dimensions.
950 FrameDimensionCfg frm_dim_cfg;
951
956 AlgoCfg algo_cfg;
957
961 KeyFrameCfg kf_cfg;
962
966 RateControlCfg rc_cfg;
968
969 // Configuration related to Quantization.
970 QuantizationCfg q_cfg;
971
972 // Internal frame size scaling.
973 ResizeCfg resize_cfg;
974
975 // Frame Super-Resolution size scaling.
976 SuperResCfg superres_cfg;
977
983 aom_fixed_buf_t twopass_stats_in;
985
986 // Configuration related to encoder toolsets.
987 ToolCfg tool_cfg;
988
989 // Configuration related to Group of frames.
990 GFConfig gf_cfg;
991
992 // Tile related configuration parameters.
993 TileConfig tile_cfg;
994
995 // Configuration related to Tune.
996 TuneCfg tune_cfg;
997
998 // Configuration related to color.
999 ColorCfg color_cfg;
1000
1001 // Configuration related to decoder model.
1002 DecoderModelCfg dec_model_cfg;
1003
1004 // Configuration related to reference frames.
1005 RefFrameCfg ref_frm_cfg;
1006
1007 // Configuration related to unit tests.
1008 UnitTestCfg unit_test_cfg;
1009
1010 // Flags related to motion mode.
1011 MotionModeCfg motion_mode_cfg;
1012
1013 // Flags related to intra mode search.
1014 IntraModeCfg intra_mode_cfg;
1015
1016 // Flags related to transform size/type.
1017 TxfmSizeTypeCfg txfm_cfg;
1018
1019 // Flags related to compound type.
1020 CompoundTypeCfg comp_type_cfg;
1021
1022 // Partition related information.
1023 PartitionCfg part_cfg;
1024
1025 // Configuration related to frequency of cost update.
1026 CostUpdateFreq cost_upd_freq;
1027
1028#if CONFIG_DENOISE
1029 // Indicates the noise level.
1030 float noise_level;
1031 // Indicates the the denoisers block size.
1032 int noise_block_size;
1033 // Indicates whether to apply denoising to the frame to be encoded
1034 int enable_dnl_denoising;
1035#endif
1036
1037#if CONFIG_AV1_TEMPORAL_DENOISING
1038 // Noise sensitivity.
1039 int noise_sensitivity;
1040#endif
1041 // Bit mask to specify which tier each of the 32 possible operating points
1042 // conforms to.
1043 unsigned int tier_mask;
1044
1045 // Indicates the number of pixels off the edge of a reference frame we're
1046 // allowed to go when forming an inter prediction.
1047 int border_in_pixels;
1048
1049 // Indicates the maximum number of threads that may be used by the encoder.
1050 int max_threads;
1051
1052 // Indicates the speed preset to be used.
1053 int speed;
1054
1055 // Enable the low complexity decode mode.
1056 unsigned int enable_low_complexity_decode;
1057
1058 // Indicates the target sequence level index for each operating point(OP).
1059 AV1_LEVEL target_seq_level_idx[MAX_NUM_OPERATING_POINTS];
1060
1061 // Indicates the bitstream profile to be used.
1062 BITSTREAM_PROFILE profile;
1063
1072 enum aom_enc_pass pass;
1074
1075 // Total number of encoding passes.
1076 int passes;
1077
1078 // the name of the second pass output file when passes > 2
1079 const char *two_pass_output;
1080
1081 // the name of the second pass log file when passes > 2
1082 const char *second_pass_log;
1083
1084 // Indicates if the encoding is GOOD or REALTIME.
1085 MODE mode;
1086
1087 // Indicates if row-based multi-threading should be enabled or not.
1088 bool row_mt;
1089
1090 // Indicates if frame parallel multi-threading should be enabled or not.
1091 bool fp_mt;
1092
1093 // Indicates if 16bit frame buffers are to be used i.e., the content is >
1094 // 8-bit.
1095 bool use_highbitdepth;
1096
1097 // Indicates the bitstream syntax mode. 0 indicates bitstream is saved as
1098 // Section 5 bitstream, while 1 indicates the bitstream is saved in Annex - B
1099 // format.
1100 bool save_as_annexb;
1101
1102 // The path for partition stats reading and writing, used in the experiment
1103 // CONFIG_PARTITION_SEARCH_ORDER.
1104 const char *partition_info_path;
1105
1106 // The flag that indicates whether we use an external rate distribution to
1107 // guide adaptive quantization. It requires --deltaq-mode=3. The rate
1108 // distribution map file name is stored in |rate_distribution_info|.
1109 unsigned int enable_rate_guide_deltaq;
1110
1111 // The input file of rate distribution information used in all intra mode
1112 // to determine delta quantization.
1113 const char *rate_distribution_info;
1114
1115 // Exit the encoder when it fails to encode to a given level.
1116 int strict_level_conformance;
1117
1118 // Max depth for the GOP after a key frame
1119 int kf_max_pyr_height;
1120
1121 // A flag to control if we enable the superblock qp sweep for a given lambda
1122 int sb_qp_sweep;
1124} AV1EncoderConfig;
1125
1127static inline int is_lossless_requested(const RateControlCfg *const rc_cfg) {
1128 return rc_cfg->best_allowed_q == 0 && rc_cfg->worst_allowed_q == 0;
1129}
1131
1135 typedef struct {
1141 int obmc_probs[FRAME_UPDATE_TYPES][BLOCK_SIZES_ALL];
1142
1148 int warped_probs[FRAME_UPDATE_TYPES];
1149
1156 int tx_type_probs[FRAME_UPDATE_TYPES][TX_SIZES_ALL][TX_TYPES];
1157
1164 int switchable_interp_probs[FRAME_UPDATE_TYPES][SWITCHABLE_FILTER_CONTEXTS]
1165 [SWITCHABLE_FILTERS];
1166} FrameProbInfo;
1167
1169
1170typedef struct FRAME_COUNTS {
1171// Note: This structure should only contain 'unsigned int' fields, or
1172// aggregates built solely from 'unsigned int' fields/elements
1173#if CONFIG_ENTROPY_STATS
1174 unsigned int kf_y_mode[KF_MODE_CONTEXTS][KF_MODE_CONTEXTS][INTRA_MODES];
1175 unsigned int angle_delta[DIRECTIONAL_MODES][2 * MAX_ANGLE_DELTA + 1];
1176 unsigned int y_mode[BLOCK_SIZE_GROUPS][INTRA_MODES];
1177 unsigned int uv_mode[CFL_ALLOWED_TYPES][INTRA_MODES][UV_INTRA_MODES];
1178 unsigned int cfl_sign[CFL_JOINT_SIGNS];
1179 unsigned int cfl_alpha[CFL_ALPHA_CONTEXTS][CFL_ALPHABET_SIZE];
1180 unsigned int palette_y_mode[PALATTE_BSIZE_CTXS][PALETTE_Y_MODE_CONTEXTS][2];
1181 unsigned int palette_uv_mode[PALETTE_UV_MODE_CONTEXTS][2];
1182 unsigned int palette_y_size[PALATTE_BSIZE_CTXS][PALETTE_SIZES];
1183 unsigned int palette_uv_size[PALATTE_BSIZE_CTXS][PALETTE_SIZES];
1184 unsigned int palette_y_color_index[PALETTE_SIZES]
1185 [PALETTE_COLOR_INDEX_CONTEXTS]
1186 [PALETTE_COLORS];
1187 unsigned int palette_uv_color_index[PALETTE_SIZES]
1188 [PALETTE_COLOR_INDEX_CONTEXTS]
1189 [PALETTE_COLORS];
1190 unsigned int partition[PARTITION_CONTEXTS][EXT_PARTITION_TYPES];
1191 unsigned int txb_skip[TOKEN_CDF_Q_CTXS][TX_SIZES][TXB_SKIP_CONTEXTS][2];
1192 unsigned int eob_extra[TOKEN_CDF_Q_CTXS][TX_SIZES][PLANE_TYPES]
1193 [EOB_COEF_CONTEXTS][2];
1194 unsigned int dc_sign[PLANE_TYPES][DC_SIGN_CONTEXTS][2];
1195 unsigned int coeff_lps[TX_SIZES][PLANE_TYPES][BR_CDF_SIZE - 1][LEVEL_CONTEXTS]
1196 [2];
1197 unsigned int eob_flag[TX_SIZES][PLANE_TYPES][EOB_COEF_CONTEXTS][2];
1198 unsigned int eob_multi16[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][5];
1199 unsigned int eob_multi32[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][6];
1200 unsigned int eob_multi64[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][7];
1201 unsigned int eob_multi128[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][8];
1202 unsigned int eob_multi256[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][9];
1203 unsigned int eob_multi512[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][10];
1204 unsigned int eob_multi1024[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][11];
1205 unsigned int coeff_lps_multi[TOKEN_CDF_Q_CTXS][TX_SIZES][PLANE_TYPES]
1206 [LEVEL_CONTEXTS][BR_CDF_SIZE];
1207 unsigned int coeff_base_multi[TOKEN_CDF_Q_CTXS][TX_SIZES][PLANE_TYPES]
1208 [SIG_COEF_CONTEXTS][NUM_BASE_LEVELS + 2];
1209 unsigned int coeff_base_eob_multi[TOKEN_CDF_Q_CTXS][TX_SIZES][PLANE_TYPES]
1210 [SIG_COEF_CONTEXTS_EOB][NUM_BASE_LEVELS + 1];
1211 unsigned int newmv_mode[NEWMV_MODE_CONTEXTS][2];
1212 unsigned int zeromv_mode[GLOBALMV_MODE_CONTEXTS][2];
1213 unsigned int refmv_mode[REFMV_MODE_CONTEXTS][2];
1214 unsigned int drl_mode[DRL_MODE_CONTEXTS][2];
1215 unsigned int inter_compound_mode[INTER_MODE_CONTEXTS][INTER_COMPOUND_MODES];
1216 unsigned int wedge_idx[BLOCK_SIZES_ALL][16];
1217 unsigned int interintra[BLOCK_SIZE_GROUPS][2];
1218 unsigned int interintra_mode[BLOCK_SIZE_GROUPS][INTERINTRA_MODES];
1219 unsigned int wedge_interintra[BLOCK_SIZES_ALL][2];
1220 unsigned int compound_type[BLOCK_SIZES_ALL][MASKED_COMPOUND_TYPES];
1221 unsigned int motion_mode[BLOCK_SIZES_ALL][MOTION_MODES];
1222 unsigned int obmc[BLOCK_SIZES_ALL][2];
1223 unsigned int intra_inter[INTRA_INTER_CONTEXTS][2];
1224 unsigned int comp_inter[COMP_INTER_CONTEXTS][2];
1225 unsigned int comp_ref_type[COMP_REF_TYPE_CONTEXTS][2];
1226 unsigned int uni_comp_ref[UNI_COMP_REF_CONTEXTS][UNIDIR_COMP_REFS - 1][2];
1227 unsigned int single_ref[REF_CONTEXTS][SINGLE_REFS - 1][2];
1228 unsigned int comp_ref[REF_CONTEXTS][FWD_REFS - 1][2];
1229 unsigned int comp_bwdref[REF_CONTEXTS][BWD_REFS - 1][2];
1230 unsigned int intrabc[2];
1231
1232 unsigned int txfm_partition[TXFM_PARTITION_CONTEXTS][2];
1233 unsigned int intra_tx_size[MAX_TX_CATS][TX_SIZE_CONTEXTS][MAX_TX_DEPTH + 1];
1234 unsigned int skip_mode[SKIP_MODE_CONTEXTS][2];
1235 unsigned int skip_txfm[SKIP_CONTEXTS][2];
1236 unsigned int compound_index[COMP_INDEX_CONTEXTS][2];
1237 unsigned int comp_group_idx[COMP_GROUP_IDX_CONTEXTS][2];
1238 unsigned int delta_q[DELTA_Q_PROBS][2];
1239 unsigned int delta_lf_multi[FRAME_LF_COUNT][DELTA_LF_PROBS][2];
1240 unsigned int delta_lf[DELTA_LF_PROBS][2];
1241
1242 unsigned int inter_ext_tx[EXT_TX_SETS_INTER][EXT_TX_SIZES][TX_TYPES];
1243 unsigned int intra_ext_tx[EXT_TX_SETS_INTRA][EXT_TX_SIZES][INTRA_MODES]
1244 [TX_TYPES];
1245 unsigned int filter_intra_mode[FILTER_INTRA_MODES];
1246 unsigned int filter_intra[BLOCK_SIZES_ALL][2];
1247 unsigned int switchable_restore[RESTORE_SWITCHABLE_TYPES];
1248 unsigned int wiener_restore[2];
1249 unsigned int sgrproj_restore[2];
1250#endif // CONFIG_ENTROPY_STATS
1251
1252 unsigned int switchable_interp[SWITCHABLE_FILTER_CONTEXTS]
1253 [SWITCHABLE_FILTERS];
1254} FRAME_COUNTS;
1255
1256#define INTER_MODE_RD_DATA_OVERALL_SIZE 6400
1257
1258typedef struct {
1259 int ready;
1260 double a;
1261 double b;
1262 double dist_mean;
1263 double ld_mean;
1264 double sse_mean;
1265 double sse_sse_mean;
1266 double sse_ld_mean;
1267 int num;
1268 double dist_sum;
1269 double ld_sum;
1270 double sse_sum;
1271 double sse_sse_sum;
1272 double sse_ld_sum;
1273} InterModeRdModel;
1274
1275typedef struct {
1276 int idx;
1277 int64_t rd;
1278} RdIdxPair;
1279// TODO(angiebird): This is an estimated size. We still need to figure what is
1280// the maximum number of modes.
1281#define MAX_INTER_MODES 1024
1282// TODO(any): rename this struct to something else. There is already another
1283// struct called inter_mode_info, which makes this terribly confusing.
1291 typedef struct inter_modes_info {
1296 int num;
1300 MB_MODE_INFO mbmi_arr[MAX_INTER_MODES];
1304 int mode_rate_arr[MAX_INTER_MODES];
1308 int64_t sse_arr[MAX_INTER_MODES];
1312 int64_t est_rd_arr[MAX_INTER_MODES];
1316 RdIdxPair rd_idx_pair_arr[MAX_INTER_MODES];
1320 RD_STATS rd_cost_arr[MAX_INTER_MODES];
1324 RD_STATS rd_cost_y_arr[MAX_INTER_MODES];
1328 RD_STATS rd_cost_uv_arr[MAX_INTER_MODES];
1329} InterModesInfo;
1330
1332typedef struct {
1333 // TODO(kyslov): consider changing to 64bit
1334
1335 // This struct is used for computing variance in choose_partitioning(), where
1336 // the max number of samples within a superblock is 32x32 (with 4x4 avg).
1337 // With 8bit bitdepth, uint32_t is enough for sum_square_error (2^8 * 2^8 * 32
1338 // * 32 = 2^26). For high bitdepth we need to consider changing this to 64 bit
1339 uint32_t sum_square_error;
1340 int32_t sum_error;
1341 int log2_count;
1342 int variance;
1343} VPartVar;
1344
1345typedef struct {
1346 VPartVar none;
1347 VPartVar horz[2];
1348 VPartVar vert[2];
1349} VPVariance;
1350
1351typedef struct {
1352 VPVariance part_variances;
1353 VPartVar split[4];
1354} VP4x4;
1355
1356typedef struct {
1357 VPVariance part_variances;
1358 VP4x4 split[4];
1359} VP8x8;
1360
1361typedef struct {
1362 VPVariance part_variances;
1363 VP8x8 split[4];
1364} VP16x16;
1365
1366typedef struct {
1367 VPVariance part_variances;
1368 VP16x16 split[4];
1369} VP32x32;
1370
1371typedef struct {
1372 VPVariance part_variances;
1373 VP32x32 split[4];
1374} VP64x64;
1375
1376typedef struct {
1377 VPVariance part_variances;
1378 VP64x64 *split;
1379} VP128x128;
1380
1382
1386 typedef struct {
1395 int64_t thresholds[5];
1396
1401 int64_t threshold_minmax;
1402} VarBasedPartitionInfo;
1403
1407 typedef struct {
1408#if CONFIG_MULTITHREAD
1413 pthread_mutex_t *mutex_;
1414 pthread_cond_t *cond_;
1416#endif // CONFIG_MULTITHREAD
1422 int *num_finished_cols;
1429 int sync_range;
1436 int intrabc_extra_top_right_sb_delay;
1440 int rows;
1444 int next_mi_row;
1448 int num_threads_working;
1449} AV1EncRowMultiThreadSync;
1450
1452
1453// TODO(jingning) All spatially adaptive variables should go to TileDataEnc.
1454typedef struct TileDataEnc {
1455 TileInfo tile_info;
1456 DECLARE_ALIGNED(16, FRAME_CONTEXT, tctx);
1457 FRAME_CONTEXT *row_ctx;
1458 uint64_t abs_sum_level;
1459 uint8_t allow_update_cdf;
1460 InterModeRdModel inter_mode_rd_models[BLOCK_SIZES_ALL];
1461 AV1EncRowMultiThreadSync row_mt_sync;
1462 MV firstpass_top_mv;
1463} TileDataEnc;
1464
1465typedef struct RD_COUNTS {
1466 int compound_ref_used_flag;
1467 int skip_mode_used_flag;
1468 int tx_type_used[TX_SIZES_ALL][TX_TYPES];
1469 int obmc_used[BLOCK_SIZES_ALL][2];
1470 int warped_used[2];
1471 int newmv_or_intra_blocks;
1472 uint64_t seg_tmp_pred_cost[2];
1473} RD_COUNTS;
1474
1475typedef struct ThreadData {
1476 MACROBLOCK mb;
1477 MvCosts *mv_costs_alloc;
1478 IntraBCMVCosts *dv_costs_alloc;
1479 RD_COUNTS rd_counts;
1480 FRAME_COUNTS *counts;
1481 PC_TREE_SHARED_BUFFERS shared_coeff_buf;
1482 SIMPLE_MOTION_DATA_TREE *sms_tree;
1483 SIMPLE_MOTION_DATA_TREE *sms_root;
1484 // buffers are AOM_BUFFER_SIZE_FOR_BLOCK_HASH elements long
1485 uint32_t *hash_value_buffer[2];
1486 OBMCBuffer obmc_buffer;
1487 PALETTE_BUFFER *palette_buffer;
1488 CompoundTypeRdBuffers comp_rd_buffer;
1489 CONV_BUF_TYPE *tmp_conv_dst;
1490 uint64_t abs_sum_level;
1491 uint8_t *tmp_pred_bufs[2];
1492 uint8_t *upsample_pred;
1493 uint8_t *wiener_tmp_pred_buf;
1494 int intrabc_used;
1495 int deltaq_used;
1496 int coefficient_size;
1497 int max_mv_magnitude;
1498 int interp_filter_selected[SWITCHABLE];
1499 FRAME_CONTEXT *tctx;
1500 VP64x64 *vt64x64;
1501 int32_t num_64x64_blocks;
1502 PICK_MODE_CONTEXT *firstpass_ctx;
1503 TemporalFilterData tf_data;
1504 TplBuffers tpl_tmp_buffers;
1505 TplTxfmStats tpl_txfm_stats;
1506 GlobalMotionData gm_data;
1507 // Pointer to the array of structures to store gradient information of each
1508 // pixel in a superblock. The buffer constitutes of MAX_SB_SQUARE pixel level
1509 // structures for each of the plane types (PLANE_TYPE_Y and PLANE_TYPE_UV).
1510 PixelLevelGradientInfo *pixel_gradient_info;
1511 // Pointer to the array of structures to store source variance information of
1512 // each 4x4 sub-block in a superblock. Block4x4VarInfo structure is used to
1513 // store source variance and log of source variance of each 4x4 sub-block
1514 // for subsequent retrieval.
1515 Block4x4VarInfo *src_var_info_of_4x4_sub_blocks;
1516 // Pointer to pc tree root.
1517 PC_TREE *pc_root;
1518} ThreadData;
1519
1520struct EncWorkerData;
1521
1523
1527 typedef struct {
1531 int allocated_tile_rows;
1535 int allocated_tile_cols;
1542 int allocated_rows;
1549 int allocated_cols;
1550
1554 int thread_id_to_tile_id[MAX_NUM_THREADS];
1555
1560 int *num_tile_cols_done;
1561
1566 int allocated_sb_rows;
1567
1572 bool row_mt_exit;
1573
1579 bool firstpass_mt_exit;
1580
1586 bool mb_wiener_mt_exit;
1587
1588#if CONFIG_MULTITHREAD
1592 pthread_mutex_t *mutex_;
1596 pthread_cond_t *cond_;
1597#endif
1598
1606 void (*sync_read_ptr)(AV1EncRowMultiThreadSync *const, int, int);
1610 void (*sync_write_ptr)(AV1EncRowMultiThreadSync *const, int, int, int);
1612} AV1EncRowMultiThreadInfo;
1613
1617 typedef struct {
1618#if CONFIG_MULTITHREAD
1622 pthread_mutex_t *mutex_;
1626 pthread_cond_t *cond_;
1627#endif
1628
1636 void (*intra_sync_read_ptr)(AV1EncRowMultiThreadSync *const, int, int);
1640 void (*intra_sync_write_ptr)(AV1EncRowMultiThreadSync *const, int, int, int);
1642} AV1EncAllIntraMultiThreadInfo;
1643
1647#define NUM_RECODES_PER_FRAME 10
1648
1652#define MAX_PARALLEL_FRAMES 4
1653
1658 typedef struct RestoreStateBuffers {
1662 uint16_t *cdef_srcbuf;
1663
1667 uint16_t *cdef_colbuf[MAX_MB_PLANE];
1668
1672 int32_t *rst_tmpbuf;
1673
1677 RestorationLineBuffers *rlbs;
1678} RestoreStateBuffers;
1679
1683 typedef struct {
1687 WienerInfo wiener;
1688
1692 SgrprojInfo sgrproj;
1693
1698 RestorationType best_rtype[RESTORE_TYPES - 1];
1699} RestUnitSearchInfo;
1700
1706 typedef struct {
1711 RestUnitSearchInfo *rusi[MAX_MB_PLANE];
1712
1716 int16_t *dgd_avg;
1717} AV1LrPickStruct;
1718
1722 typedef struct PrimaryMultiThreadInfo {
1726 int num_workers;
1727
1731 int num_mod_workers[NUM_MT_MODULES];
1732
1736 AVxWorker *workers;
1737
1742 struct EncWorkerData *tile_thr_data;
1743
1747 AV1CdefWorkerData *cdef_worker;
1748
1753 AVxWorker *p_workers[MAX_PARALLEL_FRAMES];
1754
1758 int p_num_workers;
1759
1763 int prev_num_enc_workers;
1764} PrimaryMultiThreadInfo;
1765
1769 typedef struct MultiThreadInfo {
1773 int num_workers;
1774
1778 int num_mod_workers[NUM_MT_MODULES];
1779
1783 AVxWorker *workers;
1784
1789 struct EncWorkerData *tile_thr_data;
1790
1795 bool row_mt_enabled;
1796
1800 bool pack_bs_mt_enabled;
1801
1805 AV1EncRowMultiThreadInfo enc_row_mt;
1806
1811 AV1EncAllIntraMultiThreadInfo intra_mt;
1812
1816 AV1TplRowMultiThreadInfo tpl_row_mt;
1817
1821 AV1LfSync lf_row_sync;
1822
1826 AV1LrSync lr_row_sync;
1827
1831 AV1EncPackBSSync pack_bs_sync;
1832
1836 AV1GlobalMotionSync gm_sync;
1837
1841 AV1TemporalFilterSync tf_sync;
1842
1846 AV1CdefSync cdef_sync;
1847
1851 AV1CdefWorkerData *cdef_worker;
1852
1856 RestoreStateBuffers restore_state_buf;
1857
1862 int pipeline_lpf_mt_with_enc;
1863} MultiThreadInfo;
1864
1866
1867typedef struct ActiveMap {
1868 int enabled;
1869 int update;
1870 unsigned char *map;
1871} ActiveMap;
1872
1874
1878 typedef struct {
1883 double cs_rate_array[32];
1887 int rate_index;
1891 int rate_size;
1892} ForceIntegerMVInfo;
1893
1895
1896#if CONFIG_INTERNAL_STATS
1897// types of stats
1898enum {
1899 STAT_Y,
1900 STAT_U,
1901 STAT_V,
1902 STAT_ALL,
1903 NUM_STAT_TYPES // This should always be the last member of the enum
1904} UENUM1BYTE(StatType);
1905
1906typedef struct IMAGE_STAT {
1907 double stat[NUM_STAT_TYPES];
1908 double worst;
1909} ImageStat;
1910#endif // CONFIG_INTERNAL_STATS
1911
1912typedef struct {
1913 int ref_count;
1914 YV12_BUFFER_CONFIG buf;
1915} EncRefCntBuffer;
1916
1918
1924 typedef struct {
1929 MB_MODE_INFO_EXT_FRAME *frame_base;
1933 int alloc_size;
1937 int stride;
1938} MBMIExtFrameBufferInfo;
1939
1941
1942#if CONFIG_COLLECT_PARTITION_STATS
1943typedef struct FramePartitionTimingStats {
1944 int partition_decisions[6][EXT_PARTITION_TYPES];
1945 int partition_attempts[6][EXT_PARTITION_TYPES];
1946 int64_t partition_times[6][EXT_PARTITION_TYPES];
1947
1948 int partition_redo;
1949} FramePartitionTimingStats;
1950#endif // CONFIG_COLLECT_PARTITION_STATS
1951
1952#if CONFIG_COLLECT_COMPONENT_TIMING
1953#include "aom_ports/aom_timer.h"
1954// Adjust the following to add new components.
1955enum {
1956 av1_encode_strategy_time,
1957 av1_get_one_pass_rt_params_time,
1958 av1_get_second_pass_params_time,
1959 denoise_and_encode_time,
1960 apply_filtering_time,
1961 av1_tpl_setup_stats_time,
1962 encode_frame_to_data_rate_time,
1963 encode_with_or_without_recode_time,
1964 loop_filter_time,
1965 cdef_time,
1966 loop_restoration_time,
1967 av1_pack_bitstream_final_time,
1968 av1_encode_frame_time,
1969 av1_compute_global_motion_time,
1970 av1_setup_motion_field_time,
1971 encode_sb_row_time,
1972
1973 rd_pick_partition_time,
1974 rd_use_partition_time,
1975 choose_var_based_partitioning_time,
1976 av1_prune_partitions_time,
1977 none_partition_search_time,
1978 split_partition_search_time,
1979 rectangular_partition_search_time,
1980 ab_partitions_search_time,
1981 rd_pick_4partition_time,
1982 encode_sb_time,
1983
1984 rd_pick_sb_modes_time,
1985 av1_rd_pick_intra_mode_sb_time,
1986 av1_rd_pick_inter_mode_sb_time,
1987 set_params_rd_pick_inter_mode_time,
1988 skip_inter_mode_time,
1989 handle_inter_mode_time,
1990 evaluate_motion_mode_for_winner_candidates_time,
1991 do_tx_search_time,
1992 handle_intra_mode_time,
1993 refine_winner_mode_tx_time,
1994 av1_search_palette_mode_time,
1995 handle_newmv_time,
1996 compound_type_rd_time,
1997 interpolation_filter_search_time,
1998 motion_mode_rd_time,
1999
2000 nonrd_use_partition_time,
2001 pick_sb_modes_nonrd_time,
2002 hybrid_intra_mode_search_time,
2003 nonrd_pick_inter_mode_sb_time,
2004 encode_b_nonrd_time,
2005
2006 kTimingComponents,
2007} UENUM1BYTE(TIMING_COMPONENT);
2008
2009static inline char const *get_component_name(int index) {
2010 switch (index) {
2011 case av1_encode_strategy_time: return "av1_encode_strategy_time";
2012 case av1_get_one_pass_rt_params_time:
2013 return "av1_get_one_pass_rt_params_time";
2014 case av1_get_second_pass_params_time:
2015 return "av1_get_second_pass_params_time";
2016 case denoise_and_encode_time: return "denoise_and_encode_time";
2017 case apply_filtering_time: return "apply_filtering_time";
2018 case av1_tpl_setup_stats_time: return "av1_tpl_setup_stats_time";
2019 case encode_frame_to_data_rate_time:
2020 return "encode_frame_to_data_rate_time";
2021 case encode_with_or_without_recode_time:
2022 return "encode_with_or_without_recode_time";
2023 case loop_filter_time: return "loop_filter_time";
2024 case cdef_time: return "cdef_time";
2025 case loop_restoration_time: return "loop_restoration_time";
2026 case av1_pack_bitstream_final_time: return "av1_pack_bitstream_final_time";
2027 case av1_encode_frame_time: return "av1_encode_frame_time";
2028 case av1_compute_global_motion_time:
2029 return "av1_compute_global_motion_time";
2030 case av1_setup_motion_field_time: return "av1_setup_motion_field_time";
2031 case encode_sb_row_time: return "encode_sb_row_time";
2032
2033 case rd_pick_partition_time: return "rd_pick_partition_time";
2034 case rd_use_partition_time: return "rd_use_partition_time";
2035 case choose_var_based_partitioning_time:
2036 return "choose_var_based_partitioning_time";
2037 case av1_prune_partitions_time: return "av1_prune_partitions_time";
2038 case none_partition_search_time: return "none_partition_search_time";
2039 case split_partition_search_time: return "split_partition_search_time";
2040 case rectangular_partition_search_time:
2041 return "rectangular_partition_search_time";
2042 case ab_partitions_search_time: return "ab_partitions_search_time";
2043 case rd_pick_4partition_time: return "rd_pick_4partition_time";
2044 case encode_sb_time: return "encode_sb_time";
2045
2046 case rd_pick_sb_modes_time: return "rd_pick_sb_modes_time";
2047 case av1_rd_pick_intra_mode_sb_time:
2048 return "av1_rd_pick_intra_mode_sb_time";
2049 case av1_rd_pick_inter_mode_sb_time:
2050 return "av1_rd_pick_inter_mode_sb_time";
2051 case set_params_rd_pick_inter_mode_time:
2052 return "set_params_rd_pick_inter_mode_time";
2053 case skip_inter_mode_time: return "skip_inter_mode_time";
2054 case handle_inter_mode_time: return "handle_inter_mode_time";
2055 case evaluate_motion_mode_for_winner_candidates_time:
2056 return "evaluate_motion_mode_for_winner_candidates_time";
2057 case do_tx_search_time: return "do_tx_search_time";
2058 case handle_intra_mode_time: return "handle_intra_mode_time";
2059 case refine_winner_mode_tx_time: return "refine_winner_mode_tx_time";
2060 case av1_search_palette_mode_time: return "av1_search_palette_mode_time";
2061 case handle_newmv_time: return "handle_newmv_time";
2062 case compound_type_rd_time: return "compound_type_rd_time";
2063 case interpolation_filter_search_time:
2064 return "interpolation_filter_search_time";
2065 case motion_mode_rd_time: return "motion_mode_rd_time";
2066
2067 case nonrd_use_partition_time: return "nonrd_use_partition_time";
2068 case pick_sb_modes_nonrd_time: return "pick_sb_modes_nonrd_time";
2069 case hybrid_intra_mode_search_time: return "hybrid_intra_mode_search_time";
2070 case nonrd_pick_inter_mode_sb_time: return "nonrd_pick_inter_mode_sb_time";
2071 case encode_b_nonrd_time: return "encode_b_nonrd_time";
2072
2073 default: assert(0);
2074 }
2075 return "error";
2076}
2077#endif
2078
2079// The maximum number of internal ARFs except ALTREF_FRAME
2080#define MAX_INTERNAL_ARFS (REF_FRAMES - BWDREF_FRAME - 1)
2081
2083
2087 typedef struct {
2091 bool search_done;
2092
2098 YV12_BUFFER_CONFIG *ref_buf[REF_FRAMES];
2099
2105 int num_ref_frames[MAX_DIRECTIONS];
2106
2113 FrameDistPair reference_frames[MAX_DIRECTIONS][REF_FRAMES - 1];
2114
2119 int segment_map_w;
2120 int segment_map_h;
2122} GlobalMotionInfo;
2123
2127 typedef struct {
2132 int default_interp_skip_flags;
2136 uint16_t interp_filter_search_mask;
2137} InterpSearchFlags;
2138
2142 typedef struct {
2148 int max_mv_magnitude;
2153 int mv_step_param;
2162 fractional_mv_step_fp *find_fractional_mv_step;
2169 search_site_config search_site_cfg[SS_CFG_TOTAL][NUM_DISTINCT_SEARCH_METHODS];
2170} MotionVectorSearchParams;
2171
2180 typedef struct {
2181 bool golden_frame;
2182 bool bwd_ref_frame;
2183 bool alt_ref_frame;
2184} RefreshFrameInfo;
2185
2193 typedef struct {
2194 int width;
2195 int height;
2196} ResizePendingParams;
2197
2201 typedef struct {
2205 int ref_relative_dist[INTER_REFS_PER_FRAME];
2209 int8_t nearest_past_ref;
2213 int8_t nearest_future_ref;
2214} RefFrameDistanceInfo;
2215
2231 typedef struct {
2239 unsigned int coeff_opt_thresholds[MODE_EVAL_TYPES][2];
2240
2245 TX_SIZE_SEARCH_METHOD tx_size_search_methods[MODE_EVAL_TYPES];
2246
2253 unsigned int use_transform_domain_distortion[MODE_EVAL_TYPES];
2254
2260 unsigned int tx_domain_dist_threshold[MODE_EVAL_TYPES];
2261
2267 unsigned int skip_txfm_level[MODE_EVAL_TYPES];
2268
2274 unsigned int predict_dc_level[MODE_EVAL_TYPES];
2275} WinnerModeParams;
2276
2284 typedef struct {
2285 bool last_frame;
2286 bool golden_frame;
2287 bool bwd_ref_frame;
2288 bool alt2_ref_frame;
2289 bool alt_ref_frame;
2293 bool update_pending;
2294} ExtRefreshFrameFlagsInfo;
2295
2299 typedef struct {
2303 int ref_frame_flags;
2304
2308 ExtRefreshFrameFlagsInfo refresh_frame;
2309
2313 bool refresh_frame_context;
2314
2319 bool refresh_frame_context_pending;
2320
2324 bool use_ref_frame_mvs;
2325
2329 bool use_error_resilient;
2330
2334 bool use_s_frame;
2335
2340 bool use_primary_ref_none;
2341} ExternalFlags;
2342
2344
2345typedef struct {
2346 // Some misc info
2347 int high_prec;
2348 int q;
2349 int order;
2350
2351 // MV counters
2352 int inter_count;
2353 int intra_count;
2354 int default_mvs;
2355 int mv_joint_count[4];
2356 int last_bit_zero;
2357 int last_bit_nonzero;
2358
2359 // Keep track of the rates
2360 int total_mv_rate;
2361 int hp_total_mv_rate;
2362 int lp_total_mv_rate;
2363
2364 // Texture info
2365 int horz_text;
2366 int vert_text;
2367 int diag_text;
2368
2369 // Whether the current struct contains valid data
2370 int valid;
2371} MV_STATS;
2372
2373typedef struct WeberStats {
2374 int64_t mb_wiener_variance;
2375 int64_t src_variance;
2376 int64_t rec_variance;
2377 int16_t src_pix_max;
2378 int16_t rec_pix_max;
2379 int64_t distortion;
2380 int64_t satd;
2381 double max_scale;
2382} WeberStats;
2383
2387typedef struct {
2388 int show_frame_count;
2389} FRAME_INDEX_SET;
2390
2391typedef struct {
2392 struct loopfilter lf;
2393 CdefInfo cdef_info;
2394 YV12_BUFFER_CONFIG copy_buffer;
2395 RATE_CONTROL rc;
2396 MV_STATS mv_stats;
2397 unsigned int frame_number;
2398 FRAME_INDEX_SET frame_index_set;
2399} CODING_CONTEXT;
2400
2401typedef struct {
2402 int frame_width;
2403 int frame_height;
2404 int mi_rows;
2405 int mi_cols;
2406 int mb_rows;
2407 int mb_cols;
2408 int num_mbs;
2409 aom_bit_depth_t bit_depth;
2410 int subsampling_x;
2411 int subsampling_y;
2412} FRAME_INFO;
2413
2415
2419 typedef struct {
2425 uint8_t *map;
2431 bool has_lossless_segment;
2432} EncSegmentationInfo;
2433
2437 typedef struct {
2441 int64_t prev_ts_start;
2445 int64_t prev_ts_end;
2449 int64_t first_ts_start;
2450} TimeStamps;
2451
2456 typedef struct {
2460 tran_low_t *tcoeff;
2464 uint16_t *eobs;
2468 uint8_t *entropy_ctx;
2469} CoeffBufferPool;
2470
2471#if !CONFIG_REALTIME_ONLY
2473// DUCKY_ENCODE_FRAME_MODE is c version of EncodeFrameMode
2474enum {
2475 DUCKY_ENCODE_FRAME_MODE_NONE, // Let native AV1 determine q index and rdmult
2476 DUCKY_ENCODE_FRAME_MODE_QINDEX, // DuckyEncode determines q index and AV1
2477 // determines rdmult
2478 DUCKY_ENCODE_FRAME_MODE_QINDEX_RDMULT, // DuckyEncode determines q index and
2479 // rdmult
2480} UENUM1BYTE(DUCKY_ENCODE_FRAME_MODE);
2481
2482enum {
2483 DUCKY_ENCODE_GOP_MODE_NONE, // native AV1 decides GOP
2484 DUCKY_ENCODE_GOP_MODE_RCL, // rate control lib decides GOP
2485} UENUM1BYTE(DUCKY_ENCODE_GOP_MODE);
2486
2487typedef struct DuckyEncodeFrameInfo {
2488 DUCKY_ENCODE_FRAME_MODE qp_mode;
2489 DUCKY_ENCODE_GOP_MODE gop_mode;
2490 int q_index;
2491 int rdmult;
2492 // These two arrays are equivalent to std::vector<SuperblockEncodeParameters>
2493 int *superblock_encode_qindex;
2494 int *superblock_encode_rdmult;
2495 int delta_q_enabled;
2496} DuckyEncodeFrameInfo;
2497
2498typedef struct DuckyEncodeFrameResult {
2499 int global_order_idx;
2500 int q_index;
2501 int rdmult;
2502 int rate;
2503 int64_t dist;
2504 double psnr;
2505} DuckyEncodeFrameResult;
2506
2507typedef struct DuckyEncodeInfo {
2508 DuckyEncodeFrameInfo frame_info;
2509 DuckyEncodeFrameResult frame_result;
2510} DuckyEncodeInfo;
2512#endif
2513
2515typedef struct RTC_REF {
2520 int reference[INTER_REFS_PER_FRAME];
2521 int ref_idx[INTER_REFS_PER_FRAME];
2522 int refresh[REF_FRAMES];
2523 int set_ref_frame_config;
2524 int non_reference_frame;
2525 int ref_frame_comp[3];
2526 int gld_idx_1layer;
2530 unsigned int buffer_time_index[REF_FRAMES];
2534 unsigned char buffer_spatial_layer[REF_FRAMES];
2538 bool reference_was_previous_frame;
2543 bool bias_recovery_frame;
2544} RTC_REF;
2546
2550 typedef struct AV1_COMP_DATA {
2554 unsigned char *cx_data;
2555
2559 size_t cx_data_sz;
2560
2564 size_t frame_size;
2565
2569 unsigned int lib_flags;
2570
2574 int64_t ts_frame_start;
2575
2579 int64_t ts_frame_end;
2580
2584 int flush;
2585
2589 const aom_rational64_t *timestamp_ratio;
2590
2594 int pop_lookahead;
2595} AV1_COMP_DATA;
2596
2600 typedef struct AV1_PRIMARY {
2604 struct AV1_COMP *parallel_cpi[MAX_PARALLEL_FRAMES];
2605
2610 struct AV1_COMP_DATA parallel_frames_data[MAX_PARALLEL_FRAMES - 1];
2611#if CONFIG_FPMT_TEST
2617 FPMT_TEST_ENC_CFG fpmt_unit_test_cfg;
2618
2622 FrameProbInfo temp_frame_probs;
2623
2629 FrameProbInfo temp_frame_probs_simulation;
2630
2635 int temp_valid_gm_model_found[FRAME_UPDATE_TYPES];
2636#endif // CONFIG_FPMT_TEST
2642 RefCntBuffer *ref_frame_map_copy[REF_FRAMES];
2643
2647 int64_t ts_start_last_show_frame;
2648
2652 int64_t ts_end_last_show_frame;
2653
2657 int num_fp_contexts;
2658
2662 int filter_level[2];
2663
2667 int filter_level_u;
2668
2672 int filter_level_v;
2673
2678 struct AV1_COMP *cpi;
2679
2683 struct AV1_COMP *cpi_lap;
2684
2688 struct lookahead_ctx *lookahead;
2689
2699 int seq_params_locked;
2700
2705 struct aom_codec_pkt_list *output_pkt_list;
2706
2710 int internal_altref_allowed;
2711
2715 int show_existing_alt_ref;
2716
2720 GF_GROUP gf_group;
2721
2725 GF_STATE gf_state;
2726
2730 int lap_enabled;
2731
2735 AV1LevelParams level_params;
2736
2740 int b_calculate_psnr;
2741
2745 int frames_left;
2746
2750 TWO_PASS twopass;
2751
2755 PRIMARY_RATE_CONTROL p_rc;
2756
2760 TEMPORAL_FILTER_INFO tf_info;
2765 SequenceHeader seq_params;
2766
2770 int use_svc;
2771
2775 bool buffer_removal_time_present;
2776
2780 unsigned int number_temporal_layers;
2781
2785 unsigned int number_spatial_layers;
2786
2790 struct aom_internal_error_info error;
2791
2797 aom_variance_fn_ptr_t fn_ptr[BLOCK_SIZES_ALL];
2798
2803 double *tpl_sb_rdmult_scaling_factors;
2804
2808 TplParams tpl_data;
2809
2813 MV_STATS mv_stats;
2814
2815#if CONFIG_INTERNAL_STATS
2817 uint64_t total_time_receive_data;
2818 uint64_t total_time_compress_data;
2819
2820 unsigned int total_mode_chosen_counts[MAX_MODES];
2821
2822 int count[2];
2823 uint64_t total_sq_error[2];
2824 uint64_t total_samples[2];
2825 ImageStat psnr[2];
2826
2827 double total_blockiness;
2828 double worst_blockiness;
2829
2830 uint64_t total_bytes;
2831 double summed_quality;
2832 double summed_weights;
2833 double summed_quality_hbd;
2834 double summed_weights_hbd;
2835 unsigned int total_recode_hits;
2836 double worst_ssim;
2837 double worst_ssim_hbd;
2838
2839 ImageStat fastssim;
2840 ImageStat psnrhvs;
2841
2842 int b_calculate_blockiness;
2843 int b_calculate_consistency;
2844
2845 double total_inconsistency;
2846 double worst_consistency;
2847 Ssimv *ssim_vars;
2848 Metrics metrics;
2850#endif
2851
2852#if CONFIG_ENTROPY_STATS
2856 FRAME_COUNTS aggregate_fc;
2857#endif // CONFIG_ENTROPY_STATS
2858
2865 int fb_of_context_type[REF_FRAMES];
2866
2870 PrimaryMultiThreadInfo p_mt_info;
2871
2875 FrameProbInfo frame_probs;
2876
2883 int valid_gm_model_found[FRAME_UPDATE_TYPES];
2884
2888 RTC_REF rtc_ref;
2889
2894 AV1EncRowMultiThreadSync intra_row_mt_sync;
2895
2901 int b_freeze_internal_state;
2902} AV1_PRIMARY;
2903
2907 typedef struct AV1_COMP {
2911 AV1_PRIMARY *ppi;
2912
2917 EncQuantDequantParams enc_quant_dequant_params;
2918
2922 ThreadData td;
2923
2927 FRAME_COUNTS counts;
2928
2932 MBMIExtFrameBufferInfo mbmi_ext_info;
2933
2939 CB_COEFF_BUFFER *coeff_buffer_base;
2940
2945 CoeffBufferPool coeff_buffer_pool;
2946
2950 AV1_COMMON common;
2951
2955 AV1EncoderConfig oxcf;
2956
2961 TRELLIS_OPT_TYPE optimize_seg_arr[MAX_SEGMENTS];
2962
2968 YV12_BUFFER_CONFIG *source;
2969
2977 YV12_BUFFER_CONFIG *last_source;
2978
2983 YV12_BUFFER_CONFIG *unscaled_source;
2984
2988 YV12_BUFFER_CONFIG scaled_source;
2989
2993 YV12_BUFFER_CONFIG *unscaled_last_source;
2994
2998 YV12_BUFFER_CONFIG scaled_last_source;
2999
3004 YV12_BUFFER_CONFIG *unfiltered_source;
3005
3010 YV12_BUFFER_CONFIG orig_source;
3011
3015 int skip_tpl_setup_stats;
3016
3020 int cb_delta_rdmult_enabled;
3021
3030 double *tpl_rdmult_scaling_factors;
3031
3035 TemporalFilterCtx tf_ctx;
3036
3040 CdefSearchCtx *cdef_search_ctx;
3041
3045 ForceIntegerMVInfo force_intpel_info;
3046
3051 RefCntBuffer *scaled_ref_buf[INTER_REFS_PER_FRAME];
3052
3056 RefCntBuffer *last_show_frame_buf;
3057
3061 RefreshFrameInfo refresh_frame;
3062
3066 int rt_reduce_num_ref_buffers;
3067
3071 ExternalFlags ext_flags;
3072
3077 YV12_BUFFER_CONFIG last_frame_uf;
3078
3083 YV12_BUFFER_CONFIG trial_frame_rst;
3084
3088 int64_t ambient_err;
3089
3093 RD_OPT rd;
3094
3099 CODING_CONTEXT coding_context;
3100
3104 GlobalMotionInfo gm_info;
3105
3109 WinnerModeParams winner_mode_params;
3110
3114 TimeStamps time_stamps;
3115
3119 RATE_CONTROL rc;
3120
3124 double framerate;
3125
3129 int ref_frame_flags;
3130
3134 int speed;
3135
3139 SPEED_FEATURES sf;
3140
3144 MotionVectorSearchParams mv_search_params;
3145
3150 int all_one_sided_refs;
3151
3155 EncSegmentationInfo enc_seg;
3156
3160 CYCLIC_REFRESH *cyclic_refresh;
3165 ActiveMap active_map;
3166
3170 unsigned char gf_frame_index;
3171
3172#if CONFIG_INTERNAL_STATS
3174 uint64_t time_compress_data;
3175
3176 unsigned int mode_chosen_counts[MAX_MODES];
3177 int bytes;
3178 unsigned int frame_recode_hits;
3180#endif
3181
3182#if CONFIG_SPEED_STATS
3186 unsigned int tx_search_count;
3187#endif // CONFIG_SPEED_STATS
3188
3193 int droppable;
3194
3198 FRAME_INFO frame_info;
3199
3203 FRAME_INDEX_SET frame_index_set;
3204
3210 int data_alloc_width;
3211
3217 int data_alloc_height;
3218
3225 int initial_mbs;
3226
3231 bool frame_size_related_setup_done;
3232
3237 int last_coded_width;
3238
3243 int last_coded_height;
3244
3248 ResizePendingParams resize_pending_params;
3249
3254 TileDataEnc *tile_data;
3258 int allocated_tiles;
3259
3263 TokenInfo token_info;
3264
3268 int vaq_refresh;
3269
3273 VarBasedPartitionInfo vbp_info;
3274
3278 int num_frame_recode;
3279
3283 FrameProbInfo frame_new_probs[NUM_RECODES_PER_FRAME];
3284
3288 int do_update_frame_probs_txtype[NUM_RECODES_PER_FRAME];
3289
3293 int do_update_frame_probs_obmc[NUM_RECODES_PER_FRAME];
3294
3298 int do_update_frame_probs_warp[NUM_RECODES_PER_FRAME];
3299
3303 int do_update_frame_probs_interpfilter[NUM_RECODES_PER_FRAME];
3304
3305#if CONFIG_FPMT_TEST
3310 double temp_framerate;
3311#endif
3317 double new_framerate;
3318
3322 int do_update_vbr_bits_off_target_fast;
3323
3327 MultiThreadInfo mt_info;
3328
3334 int existing_fb_idx_to_show;
3335
3339 int intrabc_used;
3340
3344 int prune_ref_frame_mask;
3345
3351 int keep_single_ref_frame_mask;
3352
3358 int keep_comp_ref_frame_mask;
3359
3363 AV1LrStruct lr_ctxt;
3364
3368 AV1LrPickStruct pick_lr_ctxt;
3369
3373 aom_film_grain_table_t *film_grain_table;
3374
3375#if CONFIG_DENOISE
3380 struct aom_denoise_and_model_t *denoise_and_model;
3381#endif
3382
3386 InterpSearchFlags interp_search_flags;
3387
3395 int use_screen_content_tools;
3396
3403 int is_screen_content_type;
3404
3405#if CONFIG_COLLECT_PARTITION_STATS
3409 FramePartitionTimingStats partition_stats;
3410#endif // CONFIG_COLLECT_PARTITION_STATS
3411
3412#if CONFIG_COLLECT_COMPONENT_TIMING
3416 uint64_t component_time[kTimingComponents];
3421 struct aom_usec_timer component_timer[kTimingComponents];
3425 uint64_t frame_component_time[kTimingComponents];
3426#endif
3427
3431 int frame_header_count;
3432
3436 int deltaq_used;
3437
3441 RefFrameDistanceInfo ref_frame_dist_info;
3442
3448 double *ssim_rdmult_scaling_factors;
3449
3450#if CONFIG_TUNE_VMAF
3454 TuneVMAFInfo vmaf_info;
3455#endif
3456
3457#if CONFIG_TUNE_BUTTERAUGLI
3461 TuneButteraugliInfo butteraugli_info;
3462#endif
3463
3467 SVC svc;
3468
3472 COMPRESSOR_STAGE compressor_stage;
3473
3478 FRAME_TYPE last_frame_type;
3479
3483 int num_tg;
3484
3490 aom_superres_mode superres_mode;
3491
3495 FirstPassData firstpass_data;
3496
3500 NOISE_ESTIMATE noise_estimate;
3501
3502#if CONFIG_AV1_TEMPORAL_DENOISING
3506 AV1_DENOISER denoiser;
3507#endif
3508
3513 uint8_t *consec_zero_mv;
3514
3518 int consec_zero_mv_alloc_size;
3519
3523 BLOCK_SIZE fp_block_size;
3524
3529 int sb_counter;
3530
3535 ExtPartController ext_part_controller;
3536
3541 MV_STATS mv_stats;
3545 int ref_refresh_index;
3546
3551 bool refresh_idx_available;
3552
3558 int ref_idx_to_skip;
3559#if CONFIG_FPMT_TEST
3565
3566 int wanted_fb;
3567#endif // CONFIG_FPMT_TEST
3568
3574 bool do_frame_data_update;
3575
3576#if CONFIG_RD_COMMAND
3580 RD_COMMAND rd_command;
3581#endif // CONFIG_RD_COMMAND
3582
3586 WeberStats *mb_weber_stats;
3587
3592 int *prep_rate_estimates;
3593
3598 double *ext_rate_distribution;
3599
3603 double ext_rate_scale;
3604
3608 BLOCK_SIZE weber_bsize;
3609
3613 int64_t norm_wiener_variance;
3614
3618 int *mb_delta_q;
3619
3623 bool is_dropped_frame;
3624
3625#if CONFIG_BITRATE_ACCURACY
3629 VBR_RATECTRL_INFO vbr_rc_info;
3630#endif
3631
3632#if CONFIG_RATECTRL_LOG
3636 RATECTRL_LOG rc_log;
3637#endif // CONFIG_RATECTRL_LOG
3638
3642 TWO_PASS_FRAME twopass_frame;
3643
3644#if CONFIG_THREE_PASS
3648 THIRD_PASS_DEC_CTX *third_pass_ctx;
3649#endif
3650
3654 FILE *second_pass_log_stream;
3655
3659 uint64_t *src_sad_blk_64x64;
3660
3664 int src_sad_blk_alloc_size;
3665
3671 uint64_t rec_sse;
3672
3677 int use_ducky_encode;
3678
3679#if !CONFIG_REALTIME_ONLY
3683 DuckyEncodeInfo ducky_encode_info;
3684#endif // CONFIG_REALTIME_ONLY
3685 //
3689 int frames_since_last_update;
3690
3694 unsigned int zeromv_skip_thresh_exit_part[BLOCK_SIZES_ALL];
3695
3700 bool alloc_pyramid;
3701
3702#if CONFIG_SALIENCY_MAP
3706 uint8_t *saliency_map;
3707
3711 double *sm_scaling_factor;
3712#endif
3713
3718 int palette_pixel_num;
3719
3724 int scaled_last_source_available;
3725
3729 aom_roi_map_t roi;
3730
3734 AOM_EXT_RATECTRL ext_ratectrl;
3735
3739 AomTplGopStats extrc_tpl_gop_stats;
3740
3744 bool do_border_pad;
3745} AV1_COMP;
3746
3750 typedef struct EncodeFrameInput {
3752 YV12_BUFFER_CONFIG *source;
3753 YV12_BUFFER_CONFIG *last_source;
3754 int64_t ts_duration;
3756} EncodeFrameInput;
3757
3762 typedef struct EncodeFrameParams {
3766 int error_resilient_mode;
3770 FRAME_TYPE frame_type;
3771
3773 int primary_ref_frame;
3774 int order_offset;
3775
3780 int show_frame;
3781
3783 int refresh_frame_flags;
3784
3785 int show_existing_frame;
3786 int existing_fb_idx_to_show;
3787
3792 int ref_frame_flags;
3793
3797 int remapped_ref_idx[REF_FRAMES];
3798
3803 RefreshFrameInfo refresh_frame;
3804
3808 int speed;
3809} EncodeFrameParams;
3810
3812
3813void av1_initialize_enc(unsigned int usage, enum aom_rc_mode end_usage);
3814
3815struct AV1_COMP *av1_create_compressor(struct AV1_PRIMARY *ppi,
3816 const AV1EncoderConfig *oxcf,
3817 struct BufferPool *const pool,
3818 COMPRESSOR_STAGE stage,
3819 int lap_lag_in_frames);
3820
3821struct AV1_PRIMARY *av1_create_primary_compressor(
3822 struct aom_codec_pkt_list *pkt_list_head, int num_lap_buffers,
3823 const AV1EncoderConfig *oxcf);
3824
3825void av1_remove_compressor(AV1_COMP *cpi);
3826
3827void av1_remove_primary_compressor(AV1_PRIMARY *ppi);
3828
3829#if CONFIG_ENTROPY_STATS
3830void print_entropy_stats(AV1_PRIMARY *const ppi);
3831#endif
3832#if CONFIG_INTERNAL_STATS
3833void print_internal_stats(AV1_PRIMARY *ppi);
3834#endif
3835
3836void av1_change_config_seq(AV1_PRIMARY *ppi, const AV1EncoderConfig *oxcf,
3837 bool *sb_size_changed);
3838
3839void av1_change_config(AV1_COMP *cpi, const AV1EncoderConfig *oxcf,
3840 bool sb_size_changed);
3841
3842 aom_codec_err_t av1_check_initial_width(AV1_COMP *cpi, int use_highbitdepth,
3843 int subsampling_x, int subsampling_y);
3844
3845void av1_post_encode_updates(AV1_COMP *const cpi,
3846 const AV1_COMP_DATA *const cpi_data);
3847
3848void av1_release_scaled_references_fpmt(AV1_COMP *cpi);
3849
3850void av1_decrement_ref_counts_fpmt(BufferPool *buffer_pool,
3851 int ref_buffers_used_map);
3852
3853void av1_init_sc_decisions(AV1_PRIMARY *const ppi);
3854
3855 AV1_COMP *av1_get_parallel_frame_enc_data(AV1_PRIMARY *const ppi,
3856 AV1_COMP_DATA *const first_cpi_data);
3857
3858int av1_init_parallel_frame_context(const AV1_COMP_DATA *const first_cpi_data,
3859 AV1_PRIMARY *const ppi,
3860 int *ref_buffers_used_map);
3861
3863
3880int av1_receive_raw_frame(AV1_COMP *cpi, aom_enc_frame_flags_t frame_flags,
3881 const YV12_BUFFER_CONFIG *sd, int64_t time_stamp,
3882 int64_t end_time_stamp);
3883
3905int av1_get_compressed_data(AV1_COMP *cpi, AV1_COMP_DATA *const cpi_data);
3906
3913int av1_encode(AV1_COMP *const cpi, uint8_t *const dest, size_t dest_size,
3914 const EncodeFrameInput *const frame_input,
3915 const EncodeFrameParams *const frame_params,
3916 size_t *const frame_size);
3917
3919int av1_get_preview_raw_frame(AV1_COMP *cpi, YV12_BUFFER_CONFIG *dest);
3920
3921int av1_get_last_show_frame(AV1_COMP *cpi, YV12_BUFFER_CONFIG *frame);
3922
3923 aom_codec_err_t av1_copy_new_frame_enc(AV1_COMMON *cm,
3924 YV12_BUFFER_CONFIG *new_frame,
3925 YV12_BUFFER_CONFIG *sd);
3926
3927int av1_use_as_reference(int *ext_ref_frame_flags, int ref_frame_flags);
3928
3929int av1_copy_reference_enc(AV1_COMP *cpi, int idx, YV12_BUFFER_CONFIG *sd);
3930
3931int av1_set_reference_enc(AV1_COMP *cpi, int idx, YV12_BUFFER_CONFIG *sd);
3932
3933void av1_set_frame_size(AV1_COMP *cpi, int width, int height);
3934
3935void av1_set_mv_search_params(AV1_COMP *cpi);
3936
3937int av1_set_roi_map(AV1_COMP *cpi, unsigned char *map, unsigned int rows,
3938 unsigned int cols, int delta_q[8], int delta_lf[8],
3939 int skip[8], int ref_frame[8]);
3940
3941int av1_set_active_map(AV1_COMP *cpi, unsigned char *map, int rows, int cols);
3942
3943int av1_get_active_map(AV1_COMP *cpi, unsigned char *map, int rows, int cols);
3944
3945int av1_set_internal_size(AV1EncoderConfig *const oxcf,
3946 ResizePendingParams *resize_pending_params,
3947 AOM_SCALING_MODE horiz_mode,
3948 AOM_SCALING_MODE vert_mode);
3949
3950int av1_get_quantizer(struct AV1_COMP *cpi);
3951
3952// This function assumes that the input buffer contains valid OBUs. It should
3953// not be called on untrusted input.
3954int av1_convert_sect5obus_to_annexb(uint8_t *buffer, size_t buffer_size,
3955 size_t *input_size);
3956
3957void av1_alloc_mb_wiener_var_pred_buf(AV1_COMMON *cm, ThreadData *td);
3958
3959void av1_dealloc_mb_wiener_var_pred_buf(ThreadData *td);
3960
3961uint8_t av1_find_dominant_value(const uint8_t *src, int stride, int rows,
3962 int cols);
3963
3964void av1_dilate_block(const uint8_t *src, int src_stride, uint8_t *dilated,
3965 int dilated_stride, int rows, int cols);
3966
3967// Set screen content options.
3968// This function estimates whether to use screen content tools, by counting
3969// the portion of blocks that have few luma colors.
3970// Modifies:
3971// cpi->commom.features.allow_screen_content_tools
3972// cpi->common.features.allow_intrabc
3973// cpi->use_screen_content_tools
3974// cpi->is_screen_content_type
3975// However, the estimation is not accurate and may misclassify videos.
3976// A slower but more accurate approach that determines whether to use screen
3977// content tools is employed later. See av1_determine_sc_tools_with_encoding().
3978void av1_set_screen_content_options(struct AV1_COMP *cpi,
3979 FeatureFlags *features);
3980
3981void av1_update_frame_size(AV1_COMP *cpi);
3982
3983void av1_set_svc_seq_params(AV1_PRIMARY *const ppi);
3984
3985typedef struct {
3986 int pyr_level;
3987 int disp_order;
3988} RefFrameMapPair;
3989
3990static inline void init_ref_map_pair(
3991 AV1_COMP *cpi, RefFrameMapPair ref_frame_map_pairs[REF_FRAMES]) {
3992 if (cpi->ppi->gf_group.update_type[cpi->gf_frame_index] == KF_UPDATE) {
3993 memset(ref_frame_map_pairs, -1, sizeof(*ref_frame_map_pairs) * REF_FRAMES);
3994 return;
3995 }
3996 memset(ref_frame_map_pairs, 0, sizeof(*ref_frame_map_pairs) * REF_FRAMES);
3997 for (int map_idx = 0; map_idx < REF_FRAMES; map_idx++) {
3998 // Get reference frame buffer.
3999 const RefCntBuffer *const buf = cpi->common.ref_frame_map[map_idx];
4000 if (ref_frame_map_pairs[map_idx].disp_order == -1) continue;
4001 if (buf == NULL) {
4002 ref_frame_map_pairs[map_idx].disp_order = -1;
4003 ref_frame_map_pairs[map_idx].pyr_level = -1;
4004 continue;
4005 } else if (buf->ref_count > 1) {
4006 // Once the keyframe is coded, the slots in ref_frame_map will all
4007 // point to the same frame. In that case, all subsequent pointers
4008 // matching the current are considered "free" slots. This will find
4009 // the next occurrence of the current pointer if ref_count indicates
4010 // there are multiple instances of it and mark it as free.
4011 for (int idx2 = map_idx + 1; idx2 < REF_FRAMES; ++idx2) {
4012 const RefCntBuffer *const buf2 = cpi->common.ref_frame_map[idx2];
4013 if (buf2 == buf) {
4014 ref_frame_map_pairs[idx2].disp_order = -1;
4015 ref_frame_map_pairs[idx2].pyr_level = -1;
4016 }
4017 }
4018 }
4019 ref_frame_map_pairs[map_idx].disp_order = (int)buf->display_order_hint;
4020 ref_frame_map_pairs[map_idx].pyr_level = buf->pyramid_level;
4021 }
4022}
4023
4024#if CONFIG_FPMT_TEST
4025static inline void calc_frame_data_update_flag(
4026 GF_GROUP *const gf_group, int gf_frame_index,
4027 bool *const do_frame_data_update) {
4028 *do_frame_data_update = true;
4029 // Set the flag to false for all frames in a given parallel encode set except
4030 // the last frame in the set with frame_parallel_level = 2.
4031 if (gf_group->frame_parallel_level[gf_frame_index] == 1) {
4032 *do_frame_data_update = false;
4033 } else if (gf_group->frame_parallel_level[gf_frame_index] == 2) {
4034 // Check if this is the last frame in the set with frame_parallel_level = 2.
4035 for (int i = gf_frame_index + 1; i < gf_group->size; i++) {
4036 if ((gf_group->frame_parallel_level[i] == 0 &&
4037 (gf_group->update_type[i] == ARF_UPDATE ||
4038 gf_group->update_type[i] == INTNL_ARF_UPDATE)) ||
4039 gf_group->frame_parallel_level[i] == 1) {
4040 break;
4041 } else if (gf_group->frame_parallel_level[i] == 2) {
4042 *do_frame_data_update = false;
4043 break;
4044 }
4045 }
4046 }
4047}
4048#endif
4049
4050// av1 uses 10,000,000 ticks/second as time stamp
4051#define TICKS_PER_SEC 10000000LL
4052
4053static inline int64_t timebase_units_to_ticks(
4054 const aom_rational64_t *timestamp_ratio, int64_t n) {
4055 return n * timestamp_ratio->num / timestamp_ratio->den;
4056}
4057
4058static inline int64_t ticks_to_timebase_units(
4059 const aom_rational64_t *timestamp_ratio, int64_t n) {
4060 int64_t round = timestamp_ratio->num / 2;
4061 if (round > 0) --round;
4062 return (n * timestamp_ratio->den + round) / timestamp_ratio->num;
4063}
4064
4065static inline int frame_is_kf_gf_arf(const AV1_COMP *cpi) {
4066 const GF_GROUP *const gf_group = &cpi->ppi->gf_group;
4067 const FRAME_UPDATE_TYPE update_type =
4068 gf_group->update_type[cpi->gf_frame_index];
4069
4070 return frame_is_intra_only(&cpi->common) || update_type == ARF_UPDATE ||
4071 update_type == GF_UPDATE;
4072}
4073
4074// TODO(huisu@google.com, youzhou@microsoft.com): enable hash-me for HBD.
4075static inline int av1_use_hash_me(const AV1_COMP *const cpi) {
4076 return (cpi->common.features.allow_screen_content_tools &&
4077 cpi->common.features.allow_intrabc &&
4078 frame_is_intra_only(&cpi->common));
4079}
4080
4081static inline const YV12_BUFFER_CONFIG *get_ref_frame_yv12_buf(
4082 const AV1_COMMON *const cm, MV_REFERENCE_FRAME ref_frame) {
4083 const RefCntBuffer *const buf = get_ref_frame_buf(cm, ref_frame);
4084 return buf != NULL ? &buf->buf : NULL;
4085}
4086
4087static inline void alloc_frame_mvs(AV1_COMMON *const cm, RefCntBuffer *buf) {
4088 assert(buf != NULL);
4089 ensure_mv_buffer(buf, cm);
4090 buf->width = cm->width;
4091 buf->height = cm->height;
4092}
4093
4094// Get the allocated token size for a tile. It does the same calculation as in
4095// the frame token allocation.
4096static inline unsigned int allocated_tokens(const TileInfo *tile,
4097 int sb_size_log2, int num_planes) {
4098 int tile_mb_rows =
4099 ROUND_POWER_OF_TWO(tile->mi_row_end - tile->mi_row_start, 2);
4100 int tile_mb_cols =
4101 ROUND_POWER_OF_TWO(tile->mi_col_end - tile->mi_col_start, 2);
4102
4103 return get_token_alloc(tile_mb_rows, tile_mb_cols, sb_size_log2, num_planes);
4104}
4105
4106static inline void get_start_tok(AV1_COMP *cpi, int tile_row, int tile_col,
4107 int mi_row, TokenExtra **tok, int sb_size_log2,
4108 int num_planes) {
4109 AV1_COMMON *const cm = &cpi->common;
4110 const int tile_cols = cm->tiles.cols;
4111 TileDataEnc *this_tile = &cpi->tile_data[tile_row * tile_cols + tile_col];
4112 const TileInfo *const tile_info = &this_tile->tile_info;
4113
4114 const int tile_mb_cols =
4115 (tile_info->mi_col_end - tile_info->mi_col_start + 2) >> 2;
4116 const int tile_mb_row = (mi_row - tile_info->mi_row_start + 2) >> 2;
4117
4118 *tok = cpi->token_info.tile_tok[tile_row][tile_col] +
4119 get_token_alloc(tile_mb_row, tile_mb_cols, sb_size_log2, num_planes);
4120}
4121
4122void av1_apply_encoding_flags(AV1_COMP *cpi, aom_enc_frame_flags_t flags);
4123
4124#define ALT_MIN_LAG 3
4125static inline int is_altref_enabled(int lag_in_frames, bool enable_auto_arf) {
4126 return lag_in_frames >= ALT_MIN_LAG && enable_auto_arf;
4127}
4128
4129static inline int can_disable_altref(const GFConfig *gf_cfg) {
4130 return is_altref_enabled(gf_cfg->lag_in_frames, gf_cfg->enable_auto_arf) &&
4131 (gf_cfg->gf_min_pyr_height == 0);
4132}
4133
4134// Helper function to compute number of blocks on either side of the frame.
4135static inline int get_num_blocks(const int frame_length, const int mb_length) {
4136 return (frame_length + mb_length - 1) / mb_length;
4137}
4138
4139// Check if statistics generation stage
4140static inline int is_stat_generation_stage(const AV1_COMP *const cpi) {
4141 assert(IMPLIES(cpi->compressor_stage == LAP_STAGE,
4142 cpi->oxcf.pass == AOM_RC_ONE_PASS && cpi->ppi->lap_enabled));
4143 return (cpi->oxcf.pass == AOM_RC_FIRST_PASS ||
4144 (cpi->compressor_stage == LAP_STAGE));
4145}
4146// Check if statistics consumption stage
4147static inline int is_stat_consumption_stage_twopass(const AV1_COMP *const cpi) {
4148 return (cpi->oxcf.pass >= AOM_RC_SECOND_PASS);
4149}
4150
4151// Check if statistics consumption stage
4152static inline int is_stat_consumption_stage(const AV1_COMP *const cpi) {
4153 return (is_stat_consumption_stage_twopass(cpi) ||
4154 (cpi->oxcf.pass == AOM_RC_ONE_PASS &&
4155 (cpi->compressor_stage == ENCODE_STAGE) && cpi->ppi->lap_enabled &&
4156 cpi->oxcf.mode != REALTIME));
4157}
4158
4159// Decide whether 'dv_costs' need to be allocated/stored during the encoding.
4160static inline bool av1_need_dv_costs(const AV1_COMP *const cpi) {
4161 return (!cpi->sf.rt_sf.use_nonrd_pick_mode || cpi->sf.rt_sf.rt_use_intrabc) &&
4162 av1_allow_intrabc(&cpi->common) && !is_stat_generation_stage(cpi);
4163}
4164
4174 static inline int has_no_stats_stage(const AV1_COMP *const cpi) {
4175 assert(
4176 IMPLIES(!cpi->ppi->lap_enabled, cpi->compressor_stage == ENCODE_STAGE));
4177 return (cpi->oxcf.pass == AOM_RC_ONE_PASS &&
4178 (!cpi->ppi->lap_enabled || cpi->oxcf.mode == REALTIME));
4179}
4180
4182
4183static inline int is_one_pass_rt_lag_params(const AV1_COMP *cpi) {
4184 return cpi->oxcf.pass == AOM_RC_ONE_PASS &&
4185 cpi->oxcf.gf_cfg.lag_in_frames > 0 && cpi->oxcf.mode == REALTIME;
4186}
4187
4188static inline int is_one_pass_rt_params(const AV1_COMP *cpi) {
4189 return has_no_stats_stage(cpi) && cpi->oxcf.gf_cfg.lag_in_frames == 0 &&
4190 (cpi->oxcf.mode == REALTIME || cpi->svc.number_spatial_layers > 1);
4191}
4192
4193// Use default/internal reference structure for single-layer RTC.
4194static inline int use_rtc_reference_structure_one_layer(const AV1_COMP *cpi) {
4195 return is_one_pass_rt_params(cpi) && cpi->ppi->number_spatial_layers == 1 &&
4196 cpi->ppi->number_temporal_layers == 1 &&
4197 !cpi->ppi->rtc_ref.set_ref_frame_config;
4198}
4199
4200// Check if postencode drop is allowed.
4201static inline int allow_postencode_drop_rtc(const AV1_COMP *cpi) {
4202 const AV1_COMMON *const cm = &cpi->common;
4203 return is_one_pass_rt_params(cpi) && cpi->oxcf.rc_cfg.mode == AOM_CBR &&
4204 cpi->oxcf.rc_cfg.drop_frames_water_mark > 0 &&
4205 !cpi->rc.rtc_external_ratectrl && !frame_is_intra_only(cm) &&
4206 cpi->svc.spatial_layer_id == 0;
4207}
4208
4209// Function return size of frame stats buffer
4210static inline int get_stats_buf_size(int num_lap_buffer, int num_lag_buffer) {
4211 /* if lookahead is enabled return num_lap_buffers else num_lag_buffers */
4212 if (num_lap_buffer > 0) {
4213 return AOMMAX(num_lap_buffer + 1, MAX_GF_LENGTH_LAP + 1);
4214 }
4215 return num_lag_buffer;
4216}
4217
4218// TODO(zoeliu): To set up cpi->oxcf.gf_cfg.enable_auto_brf
4219
4220static inline void set_ref_ptrs(const AV1_COMMON *cm, MACROBLOCKD *xd,
4221 MV_REFERENCE_FRAME ref0,
4222 MV_REFERENCE_FRAME ref1) {
4223 xd->block_ref_scale_factors[0] =
4224 get_ref_scale_factors_const(cm, ref0 >= LAST_FRAME ? ref0 : 1);
4225 xd->block_ref_scale_factors[1] =
4226 get_ref_scale_factors_const(cm, ref1 >= LAST_FRAME ? ref1 : 1);
4227}
4228
4229static inline int get_chessboard_index(int frame_index) {
4230 return frame_index & 0x1;
4231}
4232
4233static inline const int *cond_cost_list_const(const struct AV1_COMP *cpi,
4234 const int *cost_list) {
4235 const int use_cost_list = cpi->sf.mv_sf.subpel_search_method != SUBPEL_TREE &&
4236 cpi->sf.mv_sf.use_fullpel_costlist;
4237 return use_cost_list ? cost_list : NULL;
4238}
4239
4240static inline int *cond_cost_list(const struct AV1_COMP *cpi, int *cost_list) {
4241 const int use_cost_list = cpi->sf.mv_sf.subpel_search_method != SUBPEL_TREE &&
4242 cpi->sf.mv_sf.use_fullpel_costlist;
4243 return use_cost_list ? cost_list : NULL;
4244}
4245
4246// Compression ratio of current frame.
4247double av1_get_compression_ratio(const AV1_COMMON *const cm,
4248 size_t encoded_frame_size);
4249
4250void av1_new_framerate(AV1_COMP *cpi, double framerate);
4251
4252void av1_setup_frame_size(AV1_COMP *cpi);
4253
4254#define LAYER_IDS_TO_IDX(sl, tl, num_tl) ((sl) * (num_tl) + (tl))
4255
4256// Returns 1 if a frame is scaled and 0 otherwise.
4257static inline int av1_resize_scaled(const AV1_COMMON *cm) {
4258 return cm->superres_upscaled_width != cm->render_width ||
4259 cm->superres_upscaled_height != cm->render_height;
4260}
4261
4262static inline int av1_frame_scaled(const AV1_COMMON *cm) {
4263 return av1_superres_scaled(cm) || av1_resize_scaled(cm);
4264}
4265
4266static inline bool av1_encode_for_extrc(AOM_EXT_RATECTRL const *ext_rc) {
4267 return ext_rc->ready && (ext_rc->funcs.rc_type & AOM_RC_QP) != 0 &&
4268 ext_rc->funcs.get_encodeframe_decision != NULL;
4269}
4270
4271// Don't allow a show_existing_frame to coincide with an error resilient
4272// frame. An exception can be made for a forward keyframe since it has no
4273// previous dependencies.
4274static inline int encode_show_existing_frame(const AV1_COMMON *cm) {
4275 return cm->show_existing_frame && (!cm->features.error_resilient_mode ||
4276 cm->current_frame.frame_type == KEY_FRAME);
4277}
4278
4279// Get index into the 'cpi->mbmi_ext_info.frame_base' array for the given
4280// 'mi_row' and 'mi_col'.
4281static inline int get_mi_ext_idx(const int mi_row, const int mi_col,
4282 const BLOCK_SIZE mi_alloc_bsize,
4283 const int mbmi_ext_stride) {
4284 const int mi_ext_size_1d = mi_size_wide[mi_alloc_bsize];
4285 const int mi_ext_row = mi_row / mi_ext_size_1d;
4286 const int mi_ext_col = mi_col / mi_ext_size_1d;
4287 return mi_ext_row * mbmi_ext_stride + mi_ext_col;
4288}
4289
4290// Computes the signed distances from the bottom and right edges of the current
4291// prediction block to the corresponding edges of the frame.
4292static inline void set_pixels_to_frame_edge(MACROBLOCK *x, int bw, int bh,
4293 int mi_col, int mi_row, int mi_cols,
4294 int mi_rows, int frame_width,
4295 int frame_height,
4296 bool do_border_pad) {
4297 // For do_border_pad = true, compute distances using the actual frame
4298 // dimensions.
4299 // For do_border_pad = false, compute distances using the frame dimensions
4300 // aligned to a multiple of 8 pixels to match the dimensions represented
4301 // by mi_cols and mi_rows, which are rounded up to multiples of 8 pixels.
4302 int boundary_frame_width =
4303 do_border_pad ? frame_width : (mi_cols << MI_SIZE_LOG2);
4304 int boundary_frame_height =
4305 do_border_pad ? frame_height : (mi_rows << MI_SIZE_LOG2);
4306
4307 x->pix_to_bottom_edge =
4308 boundary_frame_height - ((mi_row + bh) << MI_SIZE_LOG2);
4309 x->pix_to_right_edge = boundary_frame_width - ((mi_col + bw) << MI_SIZE_LOG2);
4310}
4311
4312// Lighter version of set_offsets that only sets the mode info
4313// pointers.
4314static inline void set_mode_info_offsets(
4315 const CommonModeInfoParams *const mi_params,
4316 const MBMIExtFrameBufferInfo *const mbmi_ext_info, MACROBLOCK *const x,
4317 MACROBLOCKD *const xd, int mi_row, int mi_col) {
4318 set_mi_offsets(mi_params, xd, mi_row, mi_col);
4319 const int ext_idx = get_mi_ext_idx(mi_row, mi_col, mi_params->mi_alloc_bsize,
4320 mbmi_ext_info->stride);
4321 x->mbmi_ext_frame = mbmi_ext_info->frame_base + ext_idx;
4322}
4323
4324// Check to see if the given partition size is allowed for a specified number
4325// of mi block rows and columns remaining in the image.
4326// If not then return the largest allowed partition size
4327static inline BLOCK_SIZE find_partition_size(BLOCK_SIZE bsize, int rows_left,
4328 int cols_left, int *bh, int *bw) {
4329 int int_size = (int)bsize;
4330 if (rows_left <= 0 || cols_left <= 0) {
4331 return AOMMIN(bsize, BLOCK_8X8);
4332 } else {
4333 for (; int_size > 0; int_size -= 3) {
4334 *bh = mi_size_high[int_size];
4335 *bw = mi_size_wide[int_size];
4336 if ((*bh <= rows_left) && (*bw <= cols_left)) {
4337 break;
4338 }
4339 }
4340 }
4341 return (BLOCK_SIZE)int_size;
4342}
4343
4344static const uint8_t av1_ref_frame_flag_list[REF_FRAMES] = { 0,
4345 AOM_LAST_FLAG,
4346 AOM_LAST2_FLAG,
4347 AOM_LAST3_FLAG,
4348 AOM_GOLD_FLAG,
4349 AOM_BWD_FLAG,
4350 AOM_ALT2_FLAG,
4351 AOM_ALT_FLAG };
4352
4353// When more than 'max_allowed_refs' are available, we reduce the number of
4354// reference frames one at a time based on this order.
4355static const MV_REFERENCE_FRAME disable_order[] = {
4356 LAST3_FRAME,
4357 LAST2_FRAME,
4358 ALTREF2_FRAME,
4359 BWDREF_FRAME,
4360};
4361
4362static const MV_REFERENCE_FRAME
4363 ref_frame_priority_order[INTER_REFS_PER_FRAME] = {
4364 LAST_FRAME, ALTREF_FRAME, BWDREF_FRAME, GOLDEN_FRAME,
4365 ALTREF2_FRAME, LAST2_FRAME, LAST3_FRAME,
4366 };
4367
4368static inline int get_ref_frame_flags(const SPEED_FEATURES *const sf,
4369 const int use_one_pass_rt_params,
4370 const YV12_BUFFER_CONFIG **ref_frames,
4371 const int ext_ref_frame_flags) {
4372 // cpi->ext_flags.ref_frame_flags allows certain reference types to be
4373 // disabled by the external interface. These are set by
4374 // av1_apply_encoding_flags(). Start with what the external interface allows,
4375 // then suppress any reference types which we have found to be duplicates.
4376 int flags = ext_ref_frame_flags;
4377
4378 for (int i = 1; i < INTER_REFS_PER_FRAME; ++i) {
4379 const YV12_BUFFER_CONFIG *const this_ref = ref_frames[i];
4380 // If this_ref has appeared before, mark the corresponding ref frame as
4381 // invalid. For one_pass_rt mode, only disable GOLDEN_FRAME if it's the
4382 // same as LAST_FRAME or ALTREF_FRAME (if ALTREF is being used in nonrd).
4383 int index =
4384 (use_one_pass_rt_params && ref_frame_priority_order[i] == GOLDEN_FRAME)
4385 ? (1 + sf->rt_sf.use_nonrd_altref_frame)
4386 : i;
4387 for (int j = 0; j < index; ++j) {
4388 // If this_ref has appeared before (same as the reference corresponding
4389 // to lower index j), remove it as a reference only if that reference
4390 // (for index j) is actually used as a reference.
4391 if (this_ref == ref_frames[j] &&
4392 (flags & (1 << (ref_frame_priority_order[j] - 1)))) {
4393 flags &= ~(1 << (ref_frame_priority_order[i] - 1));
4394 break;
4395 }
4396 }
4397 }
4398 return flags;
4399}
4400
4401// Returns a Sequence Header OBU stored in an aom_fixed_buf_t, or NULL upon
4402// failure. When a non-NULL aom_fixed_buf_t pointer is returned by this
4403// function, the memory must be freed by the caller. Both the buf member of the
4404// aom_fixed_buf_t, and the aom_fixed_buf_t pointer itself must be freed. Memory
4405// returned must be freed via call to free().
4406//
4407// Note: The OBU returned is in Low Overhead Bitstream Format. Specifically,
4408// the obu_has_size_field bit is set, and the buffer contains the obu_size
4409// field.
4410 aom_fixed_buf_t *av1_get_global_headers(AV1_PRIMARY *ppi);
4411
4412#define MAX_GFUBOOST_FACTOR 10.0
4413#define MIN_GFUBOOST_FACTOR 4.0
4414
4415static inline int is_frame_tpl_eligible(const GF_GROUP *const gf_group,
4416 uint8_t index) {
4417 const FRAME_UPDATE_TYPE update_type = gf_group->update_type[index];
4418 return update_type == ARF_UPDATE || update_type == GF_UPDATE ||
4419 update_type == KF_UPDATE;
4420}
4421
4422static inline int is_frame_eligible_for_ref_pruning(const GF_GROUP *gf_group,
4423 int selective_ref_frame,
4424 int prune_ref_frames,
4425 int gf_index) {
4426 return (selective_ref_frame > 0) && (prune_ref_frames > 0) &&
4427 !is_frame_tpl_eligible(gf_group, gf_index);
4428}
4429
4430// Get update type of the current frame.
4431static inline FRAME_UPDATE_TYPE get_frame_update_type(const GF_GROUP *gf_group,
4432 int gf_frame_index) {
4433 return gf_group->update_type[gf_frame_index];
4434}
4435
4436static inline int av1_pixels_to_mi(int pixels) {
4437 return ALIGN_POWER_OF_TWO(pixels, 3) >> MI_SIZE_LOG2;
4438}
4439
4440static inline int is_psnr_calc_enabled(const AV1_COMP *cpi) {
4441 const AV1_COMMON *const cm = &cpi->common;
4442
4443 return cpi->ppi->b_calculate_psnr && !is_stat_generation_stage(cpi) &&
4444 cm->show_frame && !cpi->is_dropped_frame;
4445}
4446
4447static inline int is_frame_resize_pending(const AV1_COMP *const cpi) {
4448 const ResizePendingParams *const resize_pending_params =
4449 &cpi->resize_pending_params;
4450 return (resize_pending_params->width && resize_pending_params->height &&
4451 (cpi->common.width != resize_pending_params->width ||
4452 cpi->common.height != resize_pending_params->height));
4453}
4454
4455// Check if loop filter is used.
4456static inline int is_loopfilter_used(const AV1_COMMON *const cm) {
4457 return !cm->features.coded_lossless && !cm->tiles.large_scale;
4458}
4459
4460// Check if CDEF is used.
4461static inline int is_cdef_used(const AV1_COMMON *const cm) {
4462 return cm->seq_params->enable_cdef && !cm->features.coded_lossless &&
4463 !cm->tiles.large_scale;
4464}
4465
4466// Check if loop restoration filter is used.
4467static inline int is_restoration_used(const AV1_COMMON *const cm) {
4468 return cm->seq_params->enable_restoration && !cm->features.all_lossless &&
4469 !cm->tiles.large_scale;
4470}
4471
4472// Checks if post-processing filters need to be applied.
4473// NOTE: This function decides if the application of different post-processing
4474// filters on the reconstructed frame can be skipped at the encoder side.
4475// However the computation of different filter parameters that are signaled in
4476// the bitstream is still required.
4477static inline unsigned int derive_skip_apply_postproc_filters(
4478 const AV1_COMP *cpi, int use_loopfilter, int use_cdef, int use_superres,
4479 int use_restoration) {
4480 // Though CDEF parameter selection should be dependent on
4481 // deblocked/loop-filtered pixels for cdef_pick_method <=
4482 // CDEF_FAST_SEARCH_LVL5, CDEF strength values are calculated based on the
4483 // pixel values that are not loop-filtered in svc real-time encoding mode.
4484 // Hence this case is handled separately using the condition below.
4485 if (cpi->ppi->rtc_ref.non_reference_frame)
4486 return (SKIP_APPLY_LOOPFILTER | SKIP_APPLY_CDEF);
4487
4488 if (!cpi->oxcf.algo_cfg.skip_postproc_filtering || cpi->ppi->b_calculate_psnr)
4489 return 0;
4490 assert(cpi->oxcf.mode == ALLINTRA);
4491
4492 // The post-processing filters are applied one after the other in the
4493 // following order: deblocking->cdef->superres->restoration. In case of
4494 // ALLINTRA encoding, the reconstructed frame is not used as a reference
4495 // frame. Hence, the application of these filters can be skipped when
4496 // 1. filter parameters of the subsequent stages are not dependent on the
4497 // filtered output of the current stage or
4498 // 2. subsequent filtering stages are disabled
4499 if (use_restoration) return SKIP_APPLY_RESTORATION;
4500 if (use_superres) return SKIP_APPLY_SUPERRES;
4501 if (use_cdef) {
4502 // CDEF parameter selection is not dependent on the deblocked frame if
4503 // cdef_pick_method is CDEF_PICK_FROM_Q. Hence the application of deblocking
4504 // filters and cdef filters can be skipped in this case.
4505 return (cpi->sf.lpf_sf.cdef_pick_method == CDEF_PICK_FROM_Q &&
4506 use_loopfilter)
4507 ? (SKIP_APPLY_LOOPFILTER | SKIP_APPLY_CDEF)
4508 : SKIP_APPLY_CDEF;
4509 }
4510 if (use_loopfilter) return SKIP_APPLY_LOOPFILTER;
4511
4512 // If we reach here, all post-processing stages are disabled, so none need to
4513 // be skipped.
4514 return 0;
4515}
4516
4517static inline void set_postproc_filter_default_params(AV1_COMMON *cm) {
4518 struct loopfilter *const lf = &cm->lf;
4519 CdefInfo *const cdef_info = &cm->cdef_info;
4520 RestorationInfo *const rst_info = cm->rst_info;
4521
4522 lf->filter_level[0] = 0;
4523 lf->filter_level[1] = 0;
4524 lf->backup_filter_level[0] = 0;
4525 lf->backup_filter_level[1] = 0;
4526 cdef_info->cdef_bits = 0;
4527 cdef_info->cdef_strengths[0] = 0;
4528 cdef_info->nb_cdef_strengths = 1;
4529 cdef_info->cdef_uv_strengths[0] = 0;
4530 rst_info[0].frame_restoration_type = RESTORE_NONE;
4531 rst_info[1].frame_restoration_type = RESTORE_NONE;
4532 rst_info[2].frame_restoration_type = RESTORE_NONE;
4533}
4534
4535static inline int is_inter_tx_size_search_level_one(
4536 const TX_SPEED_FEATURES *tx_sf) {
4537 return (tx_sf->inter_tx_size_search_init_depth_rect >= 1 &&
4538 tx_sf->inter_tx_size_search_init_depth_sqr >= 1);
4539}
4540
4541static inline int get_lpf_opt_level(const SPEED_FEATURES *sf) {
4542 int lpf_opt_level = 0;
4543 if (is_inter_tx_size_search_level_one(&sf->tx_sf))
4544 lpf_opt_level = (sf->lpf_sf.lpf_pick == LPF_PICK_FROM_Q) ? 2 : 1;
4545 return lpf_opt_level;
4546}
4547
4548// Enable switchable motion mode only if warp and OBMC tools are allowed
4549static inline bool is_switchable_motion_mode_allowed(bool allow_warped_motion,
4550 bool enable_obmc) {
4551 return (allow_warped_motion || enable_obmc);
4552}
4553
4554static inline int warped_motion_update_num_proj_ref(
4555 const struct AV1_COMP *const cpi, const MB_MODE_INFO *const mi) {
4556 return cpi->oxcf.motion_mode_cfg.allow_warped_motion && is_inter_block(mi) &&
4557 !mi->skip_mode && is_motion_variation_allowed_bsize(mi->bsize) &&
4558 !has_second_ref(mi);
4559}
4560
4561#if CONFIG_AV1_TEMPORAL_DENOISING
4562static inline int denoise_svc(const struct AV1_COMP *const cpi) {
4563 return (!cpi->ppi->use_svc ||
4564 (cpi->ppi->use_svc &&
4565 cpi->svc.spatial_layer_id >= cpi->svc.first_layer_denoise));
4566}
4567#endif
4568
4569#if CONFIG_COLLECT_PARTITION_STATS == 2
4570static inline void av1_print_fr_partition_timing_stats(
4571 const FramePartitionTimingStats *part_stats, const char *filename) {
4572 FILE *f = fopen(filename, "w");
4573 if (!f) {
4574 return;
4575 }
4576
4577 fprintf(f, "bsize,redo,");
4578 for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
4579 fprintf(f, "decision_%d,", part);
4580 }
4581 for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
4582 fprintf(f, "attempt_%d,", part);
4583 }
4584 for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
4585 fprintf(f, "time_%d,", part);
4586 }
4587 fprintf(f, "\n");
4588
4589 static const int bsizes[6] = { 128, 64, 32, 16, 8, 4 };
4590
4591 for (int bsize_idx = 0; bsize_idx < 6; bsize_idx++) {
4592 fprintf(f, "%d,%d,", bsizes[bsize_idx], part_stats->partition_redo);
4593 for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
4594 fprintf(f, "%d,", part_stats->partition_decisions[bsize_idx][part]);
4595 }
4596 for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
4597 fprintf(f, "%d,", part_stats->partition_attempts[bsize_idx][part]);
4598 }
4599 for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
4600 fprintf(f, "%ld,", part_stats->partition_times[bsize_idx][part]);
4601 }
4602 fprintf(f, "\n");
4603 }
4604 fclose(f);
4605}
4606#endif // CONFIG_COLLECT_PARTITION_STATS == 2
4607
4608#if CONFIG_COLLECT_PARTITION_STATS
4609static inline int av1_get_bsize_idx_for_part_stats(BLOCK_SIZE bsize) {
4610 assert(bsize == BLOCK_128X128 || bsize == BLOCK_64X64 ||
4611 bsize == BLOCK_32X32 || bsize == BLOCK_16X16 || bsize == BLOCK_8X8 ||
4612 bsize == BLOCK_4X4);
4613 switch (bsize) {
4614 case BLOCK_128X128: return 0;
4615 case BLOCK_64X64: return 1;
4616 case BLOCK_32X32: return 2;
4617 case BLOCK_16X16: return 3;
4618 case BLOCK_8X8: return 4;
4619 case BLOCK_4X4: return 5;
4620 default: assert(0 && "Invalid bsize for partition_stats."); return -1;
4621 }
4622}
4623#endif // CONFIG_COLLECT_PARTITION_STATS
4624
4625#if CONFIG_COLLECT_COMPONENT_TIMING
4626static inline void start_timing(AV1_COMP *cpi, int component) {
4627 aom_usec_timer_start(&cpi->component_timer[component]);
4628}
4629static inline void end_timing(AV1_COMP *cpi, int component) {
4630 aom_usec_timer_mark(&cpi->component_timer[component]);
4631 cpi->frame_component_time[component] +=
4632 aom_usec_timer_elapsed(&cpi->component_timer[component]);
4633}
4634static inline char const *get_frame_type_enum(int type) {
4635 switch (type) {
4636 case 0: return "KEY_FRAME";
4637 case 1: return "INTER_FRAME";
4638 case 2: return "INTRA_ONLY_FRAME";
4639 case 3: return "S_FRAME";
4640 default: assert(0);
4641 }
4642 return "error";
4643}
4644#endif
4645
4647
4648#ifdef __cplusplus
4649} // extern "C"
4650#endif
4651
4652#endif // AOM_AV1_ENCODER_ENCODER_H_
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
MACROBLOCK
struct macroblock MACROBLOCK
Encoder's parameters related to the current coding block.
COST_UPDATE_TYPE
COST_UPDATE_TYPE
This enum controls how often the entropy costs should be updated.
Definition encoder.h:211
COST_UPD_SBROW
@ COST_UPD_SBROW
Definition encoder.h:213
COST_UPD_TILE
@ COST_UPD_TILE
Definition encoder.h:214
COST_UPD_OFF
@ COST_UPD_OFF
Definition encoder.h:215
NUM_COST_UPDATE_TYPES
@ NUM_COST_UPDATE_TYPES
Definition encoder.h:216
COST_UPD_SB
@ COST_UPD_SB
Definition encoder.h:212
LOOPFILTER_CONTROL
LOOPFILTER_CONTROL
This enum controls to which frames loopfilter is applied.
Definition encoder.h:222
LOOPFILTER_ALL
@ LOOPFILTER_ALL
Definition encoder.h:224
LOOPFILTER_SELECTIVELY
@ LOOPFILTER_SELECTIVELY
Definition encoder.h:226
LOOPFILTER_REFERENCE
@ LOOPFILTER_REFERENCE
Definition encoder.h:225
LOOPFILTER_NONE
@ LOOPFILTER_NONE
Definition encoder.h:223
NUM_RECODES_PER_FRAME
#define NUM_RECODES_PER_FRAME
Max number of recodes used to track the frame probabilities.
Definition encoder.h:1647
InterModesInfo
struct inter_modes_info InterModesInfo
Struct used to hold inter mode data for fast tx search.
SKIP_APPLY_POSTPROC_FILTER
SKIP_APPLY_POSTPROC_FILTER
This enum controls the application of post-processing filters on a reconstructed frame.
Definition encoder.h:234
MAX_PARALLEL_FRAMES
#define MAX_PARALLEL_FRAMES
Max number of frames that can be encoded in a parallel encode set.
Definition encoder.h:1652
enums.h
RestorationType
RestorationType
This enumeration defines various restoration types supported.
Definition enums.h:609
RESTORE_NONE
@ RESTORE_NONE
Definition enums.h:610
RESTORE_SWITCHABLE_TYPES
@ RESTORE_SWITCHABLE_TYPES
Definition enums.h:614
RESTORE_TYPES
@ RESTORE_TYPES
Definition enums.h:615
aom_dist_metric
aom_dist_metric
Distortion metric to use for RD optimization.
Definition aomcx.h:1824
aom_tune_content
aom_tune_content
AV1 encoder content type.
Definition aomcx.h:1734
AOM_SCALING_MODE
enum aom_scaling_mode_1d AOM_SCALING_MODE
aom 1-D scaling mode
aom_tune_metric
aom_tune_metric
Model tuning parameters.
Definition aomcx.h:1777
aom_roi_map_t
struct aom_roi_map aom_roi_map_t
aom region of interest map
aom_screen_detection_mode
aom_screen_detection_mode
Screen content detection mode.
Definition aomcx.h:1742
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:207
aom_rc_mode
aom_rc_mode
Rate control mode.
Definition aom_encoder.h:185
aom_enc_pass
aom_enc_pass
Multi-pass Encoding Pass.
Definition aom_encoder.h:176
aom_fixed_buf_t
struct aom_fixed_buf aom_fixed_buf_t
Generic fixed size buffer structure.
aom_enc_frame_flags_t
long aom_enc_frame_flags_t
Encoded Frame Flags.
Definition aom_encoder.h:377
AOM_CBR
@ AOM_CBR
Definition aom_encoder.h:187
AOM_RC_ONE_PASS
@ AOM_RC_ONE_PASS
Definition aom_encoder.h:177
AOM_RC_SECOND_PASS
@ AOM_RC_SECOND_PASS
Definition aom_encoder.h:179
AOM_RC_FIRST_PASS
@ AOM_RC_FIRST_PASS
Definition aom_encoder.h:178
av1_get_compressed_data
int av1_get_compressed_data(AV1_COMP *cpi, AV1_COMP_DATA *const cpi_data)
Encode a frame.
Definition encoder.c:5357
av1_encode
int av1_encode(AV1_COMP *const cpi, uint8_t *const dest, size_t dest_size, const EncodeFrameInput *const frame_input, const EncodeFrameParams *const frame_params, size_t *const frame_size)
Run 1-pass/2-pass encoding.
Definition encoder.c:4535
av1_receive_raw_frame
int av1_receive_raw_frame(AV1_COMP *cpi, aom_enc_frame_flags_t frame_flags, const YV12_BUFFER_CONFIG *sd, int64_t time_stamp, int64_t end_time)
Obtain the raw frame data.
Definition encoder.c:4734
has_no_stats_stage
static int has_no_stats_stage(const AV1_COMP *const cpi)
Check if the current stage has statistics.
Definition encoder.h:4174
lookahead.h
Describes look ahead buffer operations.
speed_features.h
CDEF_PICK_FROM_Q
@ CDEF_PICK_FROM_Q
Definition speed_features.h:172
AV1Common::rst_info
RestorationInfo rst_info[3]
Definition av1_common_int.h:962
AV1Common::superres_upscaled_width
int superres_upscaled_width
Definition av1_common_int.h:815
AV1Common::superres_upscaled_height
int superres_upscaled_height
Definition av1_common_int.h:816
AV1Common::seq_params
SequenceHeader * seq_params
Definition av1_common_int.h:992
AV1Common::width
int width
Definition av1_common_int.h:791
AV1Common::cdef_info
CdefInfo cdef_info
Definition av1_common_int.h:971
AV1Common::current_frame
CurrentFrame current_frame
Definition av1_common_int.h:770
AV1Common::show_existing_frame
int show_existing_frame
Definition av1_common_int.h:916
AV1Common::lf
struct loopfilter lf
Definition av1_common_int.h:955
AV1Common::features
FeatureFlags features
Definition av1_common_int.h:921
AV1Common::show_frame
int show_frame
Definition av1_common_int.h:901
AV1Common::ref_frame_map
RefCntBuffer * ref_frame_map[REF_FRAMES]
Definition av1_common_int.h:894
AV1Common::tiles
CommonTileParams tiles
Definition av1_common_int.h:1008
AV1Common::height
int height
Definition av1_common_int.h:792
AV1Common::render_width
int render_width
Definition av1_common_int.h:802
AV1Common::render_height
int render_height
Definition av1_common_int.h:803
AV1EncAllIntraMultiThreadInfo
Encoder data related to multi-threading for allintra deltaq-mode=3.
Definition encoder.h:1617
AV1EncAllIntraMultiThreadInfo::mutex_
pthread_mutex_t * mutex_
Definition encoder.h:1622
AV1EncAllIntraMultiThreadInfo::intra_sync_read_ptr
void(*) intra_sync_read_ptr(AV1EncRowMultiThreadSync *const, int, int)
Definition encoder.h:1636
AV1EncAllIntraMultiThreadInfo::cond_
pthread_cond_t * cond_
Definition encoder.h:1626
AV1EncAllIntraMultiThreadInfo::intra_sync_write_ptr
void(*) intra_sync_write_ptr(AV1EncRowMultiThreadSync *const, int, int, int)
Definition encoder.h:1640
AV1EncRowMultiThreadInfo
Encoder data related to row-based multi-threading.
Definition encoder.h:1527
AV1EncRowMultiThreadInfo::allocated_sb_rows
int allocated_sb_rows
Definition encoder.h:1566
AV1EncRowMultiThreadInfo::mutex_
pthread_mutex_t * mutex_
Definition encoder.h:1592
AV1EncRowMultiThreadInfo::allocated_tile_cols
int allocated_tile_cols
Definition encoder.h:1535
AV1EncRowMultiThreadInfo::firstpass_mt_exit
bool firstpass_mt_exit
Definition encoder.h:1579
AV1EncRowMultiThreadInfo::allocated_cols
int allocated_cols
Definition encoder.h:1549
AV1EncRowMultiThreadInfo::thread_id_to_tile_id
int thread_id_to_tile_id[64]
Definition encoder.h:1554
AV1EncRowMultiThreadInfo::mb_wiener_mt_exit
bool mb_wiener_mt_exit
Definition encoder.h:1586
AV1EncRowMultiThreadInfo::sync_write_ptr
void(*) sync_write_ptr(AV1EncRowMultiThreadSync *const, int, int, int)
Definition encoder.h:1610
AV1EncRowMultiThreadInfo::sync_read_ptr
void(*) sync_read_ptr(AV1EncRowMultiThreadSync *const, int, int)
Definition encoder.h:1606
AV1EncRowMultiThreadInfo::cond_
pthread_cond_t * cond_
Definition encoder.h:1596
AV1EncRowMultiThreadInfo::row_mt_exit
bool row_mt_exit
Definition encoder.h:1572
AV1EncRowMultiThreadInfo::allocated_tile_rows
int allocated_tile_rows
Definition encoder.h:1531
AV1EncRowMultiThreadInfo::allocated_rows
int allocated_rows
Definition encoder.h:1542
AV1EncRowMultiThreadInfo::num_tile_cols_done
int * num_tile_cols_done
Definition encoder.h:1560
AV1EncRowMultiThreadSync
Encoder parameters for synchronization of row based multi-threading.
Definition encoder.h:1407
AV1EncRowMultiThreadSync::rows
int rows
Definition encoder.h:1440
AV1EncRowMultiThreadSync::sync_range
int sync_range
Definition encoder.h:1429
AV1EncRowMultiThreadSync::intrabc_extra_top_right_sb_delay
int intrabc_extra_top_right_sb_delay
Definition encoder.h:1436
AV1EncRowMultiThreadSync::next_mi_row
int next_mi_row
Definition encoder.h:1444
AV1EncRowMultiThreadSync::num_finished_cols
int * num_finished_cols
Definition encoder.h:1422
AV1EncRowMultiThreadSync::mutex_
pthread_mutex_t * mutex_
Definition encoder.h:1413
AV1EncRowMultiThreadSync::cond_
pthread_cond_t * cond_
Definition encoder.h:1414
AV1EncRowMultiThreadSync::num_threads_working
int num_threads_working
Definition encoder.h:1448
AV1EncoderConfig
Main encoder configuration data structure.
Definition encoder.h:944
AV1EncoderConfig::rc_cfg
RateControlCfg rc_cfg
Definition encoder.h:966
AV1EncoderConfig::kf_cfg
KeyFrameCfg kf_cfg
Definition encoder.h:961
AV1EncoderConfig::pass
enum aom_enc_pass pass
Definition encoder.h:1072
AV1EncoderConfig::algo_cfg
AlgoCfg algo_cfg
Definition encoder.h:956
AV1EncoderConfig::twopass_stats_in
aom_fixed_buf_t twopass_stats_in
Definition encoder.h:983
AV1LrPickStruct
Structure to hold search parameter per restoration unit and intermediate buffer of Wiener filter used...
Definition encoder.h:1706
AV1LrPickStruct::rusi
RestUnitSearchInfo * rusi[3]
Definition encoder.h:1711
AV1LrPickStruct::dgd_avg
int16_t * dgd_avg
Definition encoder.h:1716
AV1_COMP_DATA
Structure to hold data corresponding to an encoded frame.
Definition encoder.h:2550
AV1_COMP_DATA::ts_frame_end
int64_t ts_frame_end
Definition encoder.h:2579
AV1_COMP_DATA::pop_lookahead
int pop_lookahead
Definition encoder.h:2594
AV1_COMP_DATA::ts_frame_start
int64_t ts_frame_start
Definition encoder.h:2574
AV1_COMP_DATA::cx_data
unsigned char * cx_data
Definition encoder.h:2554
AV1_COMP_DATA::cx_data_sz
size_t cx_data_sz
Definition encoder.h:2559
AV1_COMP_DATA::flush
int flush
Definition encoder.h:2584
AV1_COMP_DATA::lib_flags
unsigned int lib_flags
Definition encoder.h:2569
AV1_COMP_DATA::frame_size
size_t frame_size
Definition encoder.h:2564
AV1_COMP_DATA::timestamp_ratio
const aom_rational64_t * timestamp_ratio
Definition encoder.h:2589
AV1_COMP
Top level encoder structure.
Definition encoder.h:2907
AV1_COMP::ext_rate_distribution
double * ext_rate_distribution
Definition encoder.h:3598
AV1_COMP::do_update_frame_probs_warp
int do_update_frame_probs_warp[10]
Definition encoder.h:3298
AV1_COMP::consec_zero_mv
uint8_t * consec_zero_mv
Definition encoder.h:3513
AV1_COMP::do_update_frame_probs_obmc
int do_update_frame_probs_obmc[10]
Definition encoder.h:3293
AV1_COMP::denoise_and_model
struct aom_denoise_and_model_t * denoise_and_model
Definition encoder.h:3380
AV1_COMP::skip_tpl_setup_stats
int skip_tpl_setup_stats
Definition encoder.h:3015
AV1_COMP::frames_since_last_update
int frames_since_last_update
Definition encoder.h:3689
AV1_COMP::mb_delta_q
int * mb_delta_q
Definition encoder.h:3618
AV1_COMP::vaq_refresh
int vaq_refresh
Definition encoder.h:3268
AV1_COMP::last_frame_type
FRAME_TYPE last_frame_type
Definition encoder.h:3478
AV1_COMP::unscaled_source
YV12_BUFFER_CONFIG * unscaled_source
Definition encoder.h:2983
AV1_COMP::palette_pixel_num
int palette_pixel_num
Definition encoder.h:3718
AV1_COMP::cyclic_refresh
CYCLIC_REFRESH * cyclic_refresh
Definition encoder.h:3160
AV1_COMP::rc
RATE_CONTROL rc
Definition encoder.h:3119
AV1_COMP::deltaq_used
int deltaq_used
Definition encoder.h:3436
AV1_COMP::active_map
ActiveMap active_map
Definition encoder.h:3165
AV1_COMP::frame_size_related_setup_done
bool frame_size_related_setup_done
Definition encoder.h:3231
AV1_COMP::mb_weber_stats
WeberStats * mb_weber_stats
Definition encoder.h:3586
AV1_COMP::refresh_idx_available
bool refresh_idx_available
Definition encoder.h:3551
AV1_COMP::token_info
TokenInfo token_info
Definition encoder.h:3263
AV1_COMP::ambient_err
int64_t ambient_err
Definition encoder.h:3088
AV1_COMP::film_grain_table
aom_film_grain_table_t * film_grain_table
Definition encoder.h:3373
AV1_COMP::ref_refresh_index
int ref_refresh_index
Definition encoder.h:3545
AV1_COMP::keep_comp_ref_frame_mask
int keep_comp_ref_frame_mask
Definition encoder.h:3358
AV1_COMP::sf
SPEED_FEATURES sf
Definition encoder.h:3139
AV1_COMP::optimize_seg_arr
TRELLIS_OPT_TYPE optimize_seg_arr[8]
Definition encoder.h:2961
AV1_COMP::ext_part_controller
ExtPartController ext_part_controller
Definition encoder.h:3535
AV1_COMP::second_pass_log_stream
FILE * second_pass_log_stream
Definition encoder.h:3654
AV1_COMP::ssim_rdmult_scaling_factors
double * ssim_rdmult_scaling_factors
Definition encoder.h:3448
AV1_COMP::rd
RD_OPT rd
Definition encoder.h:3093
AV1_COMP::data_alloc_height
int data_alloc_height
Definition encoder.h:3217
AV1_COMP::extrc_tpl_gop_stats
AomTplGopStats extrc_tpl_gop_stats
Definition encoder.h:3739
AV1_COMP::num_tg
int num_tg
Definition encoder.h:3483
AV1_COMP::winner_mode_params
WinnerModeParams winner_mode_params
Definition encoder.h:3109
AV1_COMP::ext_flags
ExternalFlags ext_flags
Definition encoder.h:3071
AV1_COMP::alloc_pyramid
bool alloc_pyramid
Definition encoder.h:3700
AV1_COMP::enc_seg
EncSegmentationInfo enc_seg
Definition encoder.h:3155
AV1_COMP::mv_search_params
MotionVectorSearchParams mv_search_params
Definition encoder.h:3144
AV1_COMP::use_screen_content_tools
int use_screen_content_tools
Definition encoder.h:3395
AV1_COMP::do_update_frame_probs_interpfilter
int do_update_frame_probs_interpfilter[10]
Definition encoder.h:3303
AV1_COMP::coding_context
CODING_CONTEXT coding_context
Definition encoder.h:3099
AV1_COMP::tf_ctx
TemporalFilterCtx tf_ctx
Definition encoder.h:3035
AV1_COMP::force_intpel_info
ForceIntegerMVInfo force_intpel_info
Definition encoder.h:3045
AV1_COMP::gm_info
GlobalMotionInfo gm_info
Definition encoder.h:3104
AV1_COMP::consec_zero_mv_alloc_size
int consec_zero_mv_alloc_size
Definition encoder.h:3518
AV1_COMP::coeff_buffer_pool
CoeffBufferPool coeff_buffer_pool
Definition encoder.h:2945
AV1_COMP::frame_index_set
FRAME_INDEX_SET frame_index_set
Definition encoder.h:3203
AV1_COMP::ref_frame_flags
int ref_frame_flags
Definition encoder.h:3129
AV1_COMP::scaled_ref_buf
RefCntBuffer * scaled_ref_buf[INTER_REFS_PER_FRAME]
Definition encoder.h:3051
AV1_COMP::gf_frame_index
unsigned char gf_frame_index
Definition encoder.h:3170
AV1_COMP::oxcf
AV1EncoderConfig oxcf
Definition encoder.h:2955
AV1_COMP::common
AV1_COMMON common
Definition encoder.h:2950
AV1_COMP::lr_ctxt
AV1LrStruct lr_ctxt
Definition encoder.h:3363
AV1_COMP::do_frame_data_update
bool do_frame_data_update
Definition encoder.h:3574
AV1_COMP::cdef_search_ctx
CdefSearchCtx * cdef_search_ctx
Definition encoder.h:3040
AV1_COMP::data_alloc_width
int data_alloc_width
Definition encoder.h:3210
AV1_COMP::do_update_frame_probs_txtype
int do_update_frame_probs_txtype[10]
Definition encoder.h:3288
AV1_COMP::counts
FRAME_COUNTS counts
Definition encoder.h:2927
AV1_COMP::compressor_stage
COMPRESSOR_STAGE compressor_stage
Definition encoder.h:3472
AV1_COMP::intrabc_used
int intrabc_used
Definition encoder.h:3339
AV1_COMP::num_frame_recode
int num_frame_recode
Definition encoder.h:3278
AV1_COMP::rt_reduce_num_ref_buffers
int rt_reduce_num_ref_buffers
Definition encoder.h:3066
AV1_COMP::refresh_frame
RefreshFrameInfo refresh_frame
Definition encoder.h:3061
AV1_COMP::prune_ref_frame_mask
int prune_ref_frame_mask
Definition encoder.h:3344
AV1_COMP::unscaled_last_source
YV12_BUFFER_CONFIG * unscaled_last_source
Definition encoder.h:2993
AV1_COMP::all_one_sided_refs
int all_one_sided_refs
Definition encoder.h:3150
AV1_COMP::mt_info
MultiThreadInfo mt_info
Definition encoder.h:3327
AV1_COMP::vbp_info
VarBasedPartitionInfo vbp_info
Definition encoder.h:3273
AV1_COMP::scaled_last_source_available
int scaled_last_source_available
Definition encoder.h:3724
AV1_COMP::last_source
YV12_BUFFER_CONFIG * last_source
Definition encoder.h:2977
AV1_COMP::existing_fb_idx_to_show
int existing_fb_idx_to_show
Definition encoder.h:3334
AV1_COMP::unfiltered_source
YV12_BUFFER_CONFIG * unfiltered_source
Definition encoder.h:3004
AV1_COMP::zeromv_skip_thresh_exit_part
unsigned int zeromv_skip_thresh_exit_part[BLOCK_SIZES_ALL]
Definition encoder.h:3694
AV1_COMP::frame_info
FRAME_INFO frame_info
Definition encoder.h:3198
AV1_COMP::last_coded_height
int last_coded_height
Definition encoder.h:3243
AV1_COMP::frame_header_count
int frame_header_count
Definition encoder.h:3431
AV1_COMP::droppable
int droppable
Definition encoder.h:3193
AV1_COMP::last_show_frame_buf
RefCntBuffer * last_show_frame_buf
Definition encoder.h:3056
AV1_COMP::superres_mode
aom_superres_mode superres_mode
Definition encoder.h:3490
AV1_COMP::mbmi_ext_info
MBMIExtFrameBufferInfo mbmi_ext_info
Definition encoder.h:2932
AV1_COMP::pick_lr_ctxt
AV1LrPickStruct pick_lr_ctxt
Definition encoder.h:3368
AV1_COMP::new_framerate
double new_framerate
Definition encoder.h:3317
AV1_COMP::ppi
AV1_PRIMARY * ppi
Definition encoder.h:2911
AV1_COMP::src_sad_blk_64x64
uint64_t * src_sad_blk_64x64
Definition encoder.h:3659
AV1_COMP::norm_wiener_variance
int64_t norm_wiener_variance
Definition encoder.h:3613
AV1_COMP::tpl_rdmult_scaling_factors
double * tpl_rdmult_scaling_factors
Definition encoder.h:3030
AV1_COMP::sb_counter
int sb_counter
Definition encoder.h:3529
AV1_COMP::last_coded_width
int last_coded_width
Definition encoder.h:3237
AV1_COMP::tile_data
TileDataEnc * tile_data
Definition encoder.h:3254
AV1_COMP::is_screen_content_type
int is_screen_content_type
Definition encoder.h:3403
AV1_COMP::weber_bsize
BLOCK_SIZE weber_bsize
Definition encoder.h:3608
AV1_COMP::interp_search_flags
InterpSearchFlags interp_search_flags
Definition encoder.h:3386
AV1_COMP::time_stamps
TimeStamps time_stamps
Definition encoder.h:3114
AV1_COMP::roi
aom_roi_map_t roi
Definition encoder.h:3729
AV1_COMP::ref_idx_to_skip
int ref_idx_to_skip
Definition encoder.h:3558
AV1_COMP::orig_source
YV12_BUFFER_CONFIG orig_source
Definition encoder.h:3010
AV1_COMP::src_sad_blk_alloc_size
int src_sad_blk_alloc_size
Definition encoder.h:3664
AV1_COMP::firstpass_data
FirstPassData firstpass_data
Definition encoder.h:3495
AV1_COMP::framerate
double framerate
Definition encoder.h:3124
AV1_COMP::speed
int speed
Definition encoder.h:3134
AV1_COMP::fp_block_size
BLOCK_SIZE fp_block_size
Definition encoder.h:3523
AV1_COMP::use_ducky_encode
int use_ducky_encode
Definition encoder.h:3677
AV1_COMP::trial_frame_rst
YV12_BUFFER_CONFIG trial_frame_rst
Definition encoder.h:3083
AV1_COMP::is_dropped_frame
bool is_dropped_frame
Definition encoder.h:3623
AV1_COMP::td
ThreadData td
Definition encoder.h:2922
AV1_COMP::resize_pending_params
ResizePendingParams resize_pending_params
Definition encoder.h:3248
AV1_COMP::scaled_source
YV12_BUFFER_CONFIG scaled_source
Definition encoder.h:2988
AV1_COMP::cb_delta_rdmult_enabled
int cb_delta_rdmult_enabled
Definition encoder.h:3020
AV1_COMP::do_update_vbr_bits_off_target_fast
int do_update_vbr_bits_off_target_fast
Definition encoder.h:3322
AV1_COMP::last_frame_uf
YV12_BUFFER_CONFIG last_frame_uf
Definition encoder.h:3077
AV1_COMP::enc_quant_dequant_params
EncQuantDequantParams enc_quant_dequant_params
Definition encoder.h:2917
AV1_COMP::keep_single_ref_frame_mask
int keep_single_ref_frame_mask
Definition encoder.h:3351
AV1_COMP::ref_frame_dist_info
RefFrameDistanceInfo ref_frame_dist_info
Definition encoder.h:3441
AV1_COMP::prep_rate_estimates
int * prep_rate_estimates
Definition encoder.h:3592
AV1_COMP::ducky_encode_info
DuckyEncodeInfo ducky_encode_info
Definition encoder.h:3683
AV1_COMP::ext_rate_scale
double ext_rate_scale
Definition encoder.h:3603
AV1_COMP::initial_mbs
int initial_mbs
Definition encoder.h:3225
AV1_COMP::rec_sse
uint64_t rec_sse
Definition encoder.h:3671
AV1_COMP::scaled_last_source
YV12_BUFFER_CONFIG scaled_last_source
Definition encoder.h:2998
AV1_COMP::mv_stats
MV_STATS mv_stats
Definition encoder.h:3541
AV1_COMP::frame_new_probs
FrameProbInfo frame_new_probs[10]
Definition encoder.h:3283
AV1_COMP::ext_ratectrl
AOM_EXT_RATECTRL ext_ratectrl
Definition encoder.h:3734
AV1_COMP::source
YV12_BUFFER_CONFIG * source
Definition encoder.h:2968
AV1_COMP::allocated_tiles
int allocated_tiles
Definition encoder.h:3258
AV1_COMP::do_border_pad
bool do_border_pad
Definition encoder.h:3744
AV1_COMP::svc
SVC svc
Definition encoder.h:3467
AV1_COMP::coeff_buffer_base
CB_COEFF_BUFFER * coeff_buffer_base
Definition encoder.h:2939
AV1_COMP::noise_estimate
NOISE_ESTIMATE noise_estimate
Definition encoder.h:3500
AV1_COMP::twopass_frame
TWO_PASS_FRAME twopass_frame
Definition encoder.h:3642
AV1_PRIMARY
Top level primary encoder structure.
Definition encoder.h:2600
AV1_PRIMARY::num_fp_contexts
int num_fp_contexts
Definition encoder.h:2657
AV1_PRIMARY::intra_row_mt_sync
AV1EncRowMultiThreadSync intra_row_mt_sync
Definition encoder.h:2894
AV1_PRIMARY::buffer_removal_time_present
bool buffer_removal_time_present
Definition encoder.h:2775
AV1_PRIMARY::valid_gm_model_found
int valid_gm_model_found[FRAME_UPDATE_TYPES]
Definition encoder.h:2883
AV1_PRIMARY::output_pkt_list
struct aom_codec_pkt_list * output_pkt_list
Definition encoder.h:2705
AV1_PRIMARY::filter_level
int filter_level[2]
Definition encoder.h:2662
AV1_PRIMARY::seq_params
SequenceHeader seq_params
Definition encoder.h:2765
AV1_PRIMARY::mv_stats
MV_STATS mv_stats
Definition encoder.h:2813
AV1_PRIMARY::cpi
struct AV1_COMP * cpi
Definition encoder.h:2678
AV1_PRIMARY::level_params
AV1LevelParams level_params
Definition encoder.h:2735
AV1_PRIMARY::internal_altref_allowed
int internal_altref_allowed
Definition encoder.h:2710
AV1_PRIMARY::rtc_ref
RTC_REF rtc_ref
Definition encoder.h:2888
AV1_PRIMARY::b_calculate_psnr
int b_calculate_psnr
Definition encoder.h:2740
AV1_PRIMARY::p_mt_info
PrimaryMultiThreadInfo p_mt_info
Definition encoder.h:2870
AV1_PRIMARY::tf_info
TEMPORAL_FILTER_INFO tf_info
Definition encoder.h:2760
AV1_PRIMARY::twopass
TWO_PASS twopass
Definition encoder.h:2750
AV1_PRIMARY::frames_left
int frames_left
Definition encoder.h:2745
AV1_PRIMARY::ts_start_last_show_frame
int64_t ts_start_last_show_frame
Definition encoder.h:2647
AV1_PRIMARY::p_rc
PRIMARY_RATE_CONTROL p_rc
Definition encoder.h:2755
AV1_PRIMARY::lap_enabled
int lap_enabled
Definition encoder.h:2730
AV1_PRIMARY::frame_probs
FrameProbInfo frame_probs
Definition encoder.h:2875
AV1_PRIMARY::show_existing_alt_ref
int show_existing_alt_ref
Definition encoder.h:2715
AV1_PRIMARY::fb_of_context_type
int fb_of_context_type[REF_FRAMES]
Definition encoder.h:2865
AV1_PRIMARY::use_svc
int use_svc
Definition encoder.h:2770
AV1_PRIMARY::tpl_sb_rdmult_scaling_factors
double * tpl_sb_rdmult_scaling_factors
Definition encoder.h:2803
AV1_PRIMARY::filter_level_v
int filter_level_v
Definition encoder.h:2672
AV1_PRIMARY::filter_level_u
int filter_level_u
Definition encoder.h:2667
AV1_PRIMARY::cpi_lap
struct AV1_COMP * cpi_lap
Definition encoder.h:2683
AV1_PRIMARY::parallel_cpi
struct AV1_COMP * parallel_cpi[4]
Definition encoder.h:2604
AV1_PRIMARY::ts_end_last_show_frame
int64_t ts_end_last_show_frame
Definition encoder.h:2652
AV1_PRIMARY::lookahead
struct lookahead_ctx * lookahead
Definition encoder.h:2688
AV1_PRIMARY::ref_frame_map_copy
RefCntBuffer * ref_frame_map_copy[REF_FRAMES]
Definition encoder.h:2642
AV1_PRIMARY::gf_state
GF_STATE gf_state
Definition encoder.h:2725
AV1_PRIMARY::fn_ptr
aom_variance_fn_ptr_t fn_ptr[BLOCK_SIZES_ALL]
Definition encoder.h:2797
AV1_PRIMARY::gf_group
GF_GROUP gf_group
Definition encoder.h:2720
AV1_PRIMARY::parallel_frames_data
struct AV1_COMP_DATA parallel_frames_data[4 - 1]
Definition encoder.h:2610
AV1_PRIMARY::tpl_data
TplParams tpl_data
Definition encoder.h:2808
AV1_PRIMARY::number_temporal_layers
unsigned int number_temporal_layers
Definition encoder.h:2780
AV1_PRIMARY::number_spatial_layers
unsigned int number_spatial_layers
Definition encoder.h:2785
AV1_PRIMARY::b_freeze_internal_state
int b_freeze_internal_state
Definition encoder.h:2901
AV1_PRIMARY::seq_params_locked
int seq_params_locked
Definition encoder.h:2699
AV1_PRIMARY::error
struct aom_internal_error_info error
Definition encoder.h:2790
AlgoCfg
Algorithm configuration parameters.
Definition encoder.h:815
AlgoCfg::disable_trellis_quant
int disable_trellis_quant
Definition encoder.h:843
AlgoCfg::sharpness
int sharpness
Definition encoder.h:829
AlgoCfg::skip_postproc_filtering
bool skip_postproc_filtering
Definition encoder.h:887
AlgoCfg::mode_ref_delta_enabled
int mode_ref_delta_enabled
Definition encoder.h:893
AlgoCfg::enable_adaptive_sharpness
bool enable_adaptive_sharpness
Definition encoder.h:834
AlgoCfg::arnr_max_frames
int arnr_max_frames
Definition encoder.h:848
AlgoCfg::screen_detection_mode
aom_screen_detection_mode screen_detection_mode
Definition encoder.h:898
AlgoCfg::enable_tpl_model
bool enable_tpl_model
Definition encoder.h:866
AlgoCfg::loopfilter_control
LOOPFILTER_CONTROL loopfilter_control
Definition encoder.h:881
AlgoCfg::cdf_update_mode
uint8_t cdf_update_mode
Definition encoder.h:861
AlgoCfg::enable_overlay
bool enable_overlay
Definition encoder.h:872
AlgoCfg::arnr_strength
int arnr_strength
Definition encoder.h:853
CB_COEFF_BUFFER
Stores the transforms coefficients for the whole superblock.
Definition block.h:209
CYCLIC_REFRESH
The stucture of CYCLIC_REFRESH.
Definition aq_cyclicrefresh.h:36
CdefInfo
Parameters related to CDEF.
Definition av1_common_int.h:203
CdefInfo::cdef_bits
int cdef_bits
Number of CDEF strength values in bits.
Definition av1_common_int.h:225
CdefInfo::cdef_uv_strengths
int cdef_uv_strengths[16]
CDEF strength values for chroma.
Definition av1_common_int.h:223
CdefInfo::cdef_strengths
int cdef_strengths[16]
CDEF strength values for luma.
Definition av1_common_int.h:221
CdefInfo::nb_cdef_strengths
int nb_cdef_strengths
Number of CDEF strength values.
Definition av1_common_int.h:219
CoeffBufferPool
Definition encoder.h:2456
CoeffBufferPool::entropy_ctx
uint8_t * entropy_ctx
Definition encoder.h:2468
CoeffBufferPool::tcoeff
tran_low_t * tcoeff
Definition encoder.h:2460
CoeffBufferPool::eobs
uint16_t * eobs
Definition encoder.h:2464
CommonModeInfoParams
Params related to MB_MODE_INFO arrays and related info.
Definition av1_common_int.h:511
CommonModeInfoParams::mi_alloc_bsize
BLOCK_SIZE mi_alloc_bsize
Definition av1_common_int.h:560
CommonTileParams::cols
int cols
Definition av1_common_int.h:438
CommonTileParams::large_scale
unsigned int large_scale
Definition av1_common_int.h:498
CompoundTypeCfg
Encoder flags for compound prediction modes.
Definition encoder.h:389
CompoundTypeCfg::enable_masked_comp
bool enable_masked_comp
Definition encoder.h:398
CompoundTypeCfg::enable_diff_wtd_comp
bool enable_diff_wtd_comp
Definition encoder.h:406
CompoundTypeCfg::enable_smooth_interintra
bool enable_smooth_interintra
Definition encoder.h:402
CompoundTypeCfg::enable_interintra_wedge
bool enable_interintra_wedge
Definition encoder.h:414
CompoundTypeCfg::enable_interinter_wedge
bool enable_interinter_wedge
Definition encoder.h:410
CompoundTypeCfg::enable_dist_wtd_comp
bool enable_dist_wtd_comp
Definition encoder.h:393
EncSegmentationInfo
Segmentation related information for the current frame.
Definition encoder.h:2419
EncSegmentationInfo::map
uint8_t * map
Definition encoder.h:2425
EncSegmentationInfo::has_lossless_segment
bool has_lossless_segment
Definition encoder.h:2431
EncodeFrameInput
Input frames and last input frame.
Definition encoder.h:3750
EncodeFrameParams
contains per-frame encoding parameters decided upon by av1_encode_strategy() and passed down to av1_e...
Definition encoder.h:3762
EncodeFrameParams::error_resilient_mode
int error_resilient_mode
Definition encoder.h:3766
EncodeFrameParams::remapped_ref_idx
int remapped_ref_idx[REF_FRAMES]
Definition encoder.h:3797
EncodeFrameParams::ref_frame_flags
int ref_frame_flags
Definition encoder.h:3792
EncodeFrameParams::speed
int speed
Definition encoder.h:3808
EncodeFrameParams::frame_type
FRAME_TYPE frame_type
Definition encoder.h:3770
EncodeFrameParams::show_frame
int show_frame
Definition encoder.h:3780
EncodeFrameParams::refresh_frame
RefreshFrameInfo refresh_frame
Definition encoder.h:3803
ExtRefreshFrameFlagsInfo
Frame refresh flags set by the external interface.
Definition encoder.h:2284
ExtRefreshFrameFlagsInfo::golden_frame
bool golden_frame
Definition encoder.h:2286
ExtRefreshFrameFlagsInfo::bwd_ref_frame
bool bwd_ref_frame
Definition encoder.h:2287
ExtRefreshFrameFlagsInfo::update_pending
bool update_pending
Definition encoder.h:2293
ExtRefreshFrameFlagsInfo::last_frame
bool last_frame
Definition encoder.h:2285
ExtRefreshFrameFlagsInfo::alt_ref_frame
bool alt_ref_frame
Definition encoder.h:2289
ExtRefreshFrameFlagsInfo::alt2_ref_frame
bool alt2_ref_frame
Definition encoder.h:2288
ExternalFlags
Flags signalled by the external interface at frame level.
Definition encoder.h:2299
ExternalFlags::use_primary_ref_none
bool use_primary_ref_none
Definition encoder.h:2340
ExternalFlags::use_ref_frame_mvs
bool use_ref_frame_mvs
Definition encoder.h:2324
ExternalFlags::refresh_frame
ExtRefreshFrameFlagsInfo refresh_frame
Definition encoder.h:2308
ExternalFlags::ref_frame_flags
int ref_frame_flags
Definition encoder.h:2303
ExternalFlags::use_error_resilient
bool use_error_resilient
Definition encoder.h:2329
ExternalFlags::use_s_frame
bool use_s_frame
Definition encoder.h:2334
ExternalFlags::refresh_frame_context
bool refresh_frame_context
Definition encoder.h:2313
ExternalFlags::refresh_frame_context_pending
bool refresh_frame_context_pending
Definition encoder.h:2319
FeatureFlags
Frame level features.
Definition av1_common_int.h:368
FeatureFlags::allow_screen_content_tools
bool allow_screen_content_tools
Definition av1_common_int.h:385
FeatureFlags::allow_intrabc
bool allow_intrabc
Definition av1_common_int.h:386
FeatureFlags::coded_lossless
bool coded_lossless
Definition av1_common_int.h:395
FeatureFlags::error_resilient_mode
bool error_resilient_mode
Definition av1_common_int.h:410
FeatureFlags::all_lossless
bool all_lossless
Definition av1_common_int.h:399
ForceIntegerMVInfo
Encoder info used for decision on forcing integer motion vectors.
Definition encoder.h:1878
ForceIntegerMVInfo::cs_rate_array
double cs_rate_array[32]
Definition encoder.h:1883
ForceIntegerMVInfo::rate_size
int rate_size
Definition encoder.h:1891
ForceIntegerMVInfo::rate_index
int rate_index
Definition encoder.h:1887
FrameProbInfo
Encoder-side probabilities for pruning of various AV1 tools.
Definition encoder.h:1135
FrameProbInfo::switchable_interp_probs
int switchable_interp_probs[FRAME_UPDATE_TYPES][((SWITCHABLE_FILTERS+1) *4)][SWITCHABLE_FILTERS]
Definition encoder.h:1165
FrameProbInfo::obmc_probs
int obmc_probs[FRAME_UPDATE_TYPES][BLOCK_SIZES_ALL]
Definition encoder.h:1141
FrameProbInfo::warped_probs
int warped_probs[FRAME_UPDATE_TYPES]
Definition encoder.h:1148
FrameProbInfo::tx_type_probs
int tx_type_probs[FRAME_UPDATE_TYPES][TX_SIZES_ALL][TX_TYPES]
Definition encoder.h:1156
GF_GROUP
Data related to the current GF/ARF group and the individual frames within the group.
Definition firstpass.h:343
GlobalMotionInfo
Parameters related to global motion search.
Definition encoder.h:2087
GlobalMotionInfo::reference_frames
FrameDistPair reference_frames[2][REF_FRAMES - 1]
Definition encoder.h:2113
GlobalMotionInfo::search_done
bool search_done
Definition encoder.h:2091
GlobalMotionInfo::segment_map_h
int segment_map_h
Definition encoder.h:2120
GlobalMotionInfo::num_ref_frames
int num_ref_frames[2]
Definition encoder.h:2105
GlobalMotionInfo::ref_buf
YV12_BUFFER_CONFIG * ref_buf[REF_FRAMES]
Definition encoder.h:2098
GlobalMotionInfo::segment_map_w
int segment_map_w
Definition encoder.h:2119
InterpSearchFlags
Flags related to interpolation filter search.
Definition encoder.h:2127
InterpSearchFlags::default_interp_skip_flags
int default_interp_skip_flags
Definition encoder.h:2132
InterpSearchFlags::interp_filter_search_mask
uint16_t interp_filter_search_mask
Definition encoder.h:2136
IntraModeCfg
Encoder flags for intra prediction.
Definition encoder.h:292
IntraModeCfg::enable_diagonal_intra
bool enable_diagonal_intra
Definition encoder.h:322
IntraModeCfg::enable_smooth_intra
bool enable_smooth_intra
Definition encoder.h:305
IntraModeCfg::auto_intra_tools_off
bool auto_intra_tools_off
Definition encoder.h:341
IntraModeCfg::enable_filter_intra
bool enable_filter_intra
Definition encoder.h:301
IntraModeCfg::enable_directional_intra
bool enable_directional_intra
Definition encoder.h:317
IntraModeCfg::enable_paeth_intra
bool enable_paeth_intra
Definition encoder.h:309
IntraModeCfg::enable_intra_edge_filter
bool enable_intra_edge_filter
Definition encoder.h:296
IntraModeCfg::enable_cfl_intra
bool enable_cfl_intra
Definition encoder.h:313
IntraModeCfg::enable_angle_delta
bool enable_angle_delta
Definition encoder.h:327
KeyFrameCfg
Encoder config related to the coding of key frames.
Definition encoder.h:456
KeyFrameCfg::key_freq_max
int key_freq_max
Definition encoder.h:465
KeyFrameCfg::sframe_mode
int sframe_mode
Definition encoder.h:483
KeyFrameCfg::auto_key
bool auto_key
Definition encoder.h:488
KeyFrameCfg::enable_intrabc
bool enable_intrabc
Definition encoder.h:508
KeyFrameCfg::sframe_dist
int sframe_dist
Definition encoder.h:476
KeyFrameCfg::enable_sframe
bool enable_sframe
Definition encoder.h:503
KeyFrameCfg::enable_keyframe_filtering
int enable_keyframe_filtering
Definition encoder.h:470
KeyFrameCfg::fwd_kf_dist
int fwd_kf_dist
Definition encoder.h:493
KeyFrameCfg::key_freq_min
int key_freq_min
Definition encoder.h:460
KeyFrameCfg::fwd_kf_enabled
bool fwd_kf_enabled
Definition encoder.h:498
MBMIExtFrameBufferInfo
Buffer to store mode information at mi_alloc_bsize (4x4 or 8x8) level.
Definition encoder.h:1924
MBMIExtFrameBufferInfo::alloc_size
int alloc_size
Definition encoder.h:1933
MBMIExtFrameBufferInfo::stride
int stride
Definition encoder.h:1937
MBMIExtFrameBufferInfo::frame_base
MB_MODE_INFO_EXT_FRAME * frame_base
Definition encoder.h:1929
MB_MODE_INFO_EXT_FRAME
Stores best extended mode information at frame level.
Definition block.h:245
MB_MODE_INFO
Stores the prediction/txfm mode of the current coding block.
Definition blockd.h:222
MB_MODE_INFO::skip_mode
uint8_t skip_mode
Inter skip mode.
Definition blockd.h:316
MB_MODE_INFO::bsize
BLOCK_SIZE bsize
The block size of the current coding block.
Definition blockd.h:228
MotionVectorSearchParams
Parameters for motion vector search process.
Definition encoder.h:2142
MotionVectorSearchParams::max_mv_magnitude
int max_mv_magnitude
Definition encoder.h:2148
MotionVectorSearchParams::find_fractional_mv_step
fractional_mv_step_fp * find_fractional_mv_step
Definition encoder.h:2162
MotionVectorSearchParams::mv_step_param
int mv_step_param
Definition encoder.h:2153
MotionVectorSearchParams::search_site_cfg
search_site_config search_site_cfg[SS_CFG_TOTAL][NUM_DISTINCT_SEARCH_METHODS]
Definition encoder.h:2169
MultiThreadInfo
Encoder parameters related to multi-threading.
Definition encoder.h:1769
MultiThreadInfo::restore_state_buf
RestoreStateBuffers restore_state_buf
Definition encoder.h:1856
MultiThreadInfo::cdef_worker
AV1CdefWorkerData * cdef_worker
Definition encoder.h:1851
MultiThreadInfo::lr_row_sync
AV1LrSync lr_row_sync
Definition encoder.h:1826
MultiThreadInfo::tile_thr_data
struct EncWorkerData * tile_thr_data
Definition encoder.h:1789
MultiThreadInfo::tpl_row_mt
AV1TplRowMultiThreadInfo tpl_row_mt
Definition encoder.h:1816
MultiThreadInfo::pack_bs_sync
AV1EncPackBSSync pack_bs_sync
Definition encoder.h:1831
MultiThreadInfo::enc_row_mt
AV1EncRowMultiThreadInfo enc_row_mt
Definition encoder.h:1805
MultiThreadInfo::lf_row_sync
AV1LfSync lf_row_sync
Definition encoder.h:1821
MultiThreadInfo::cdef_sync
AV1CdefSync cdef_sync
Definition encoder.h:1846
MultiThreadInfo::num_mod_workers
int num_mod_workers[NUM_MT_MODULES]
Definition encoder.h:1778
MultiThreadInfo::intra_mt
AV1EncAllIntraMultiThreadInfo intra_mt
Definition encoder.h:1811
MultiThreadInfo::num_workers
int num_workers
Definition encoder.h:1773
MultiThreadInfo::pipeline_lpf_mt_with_enc
int pipeline_lpf_mt_with_enc
Definition encoder.h:1862
MultiThreadInfo::workers
AVxWorker * workers
Definition encoder.h:1783
MultiThreadInfo::pack_bs_mt_enabled
bool pack_bs_mt_enabled
Definition encoder.h:1800
MultiThreadInfo::row_mt_enabled
bool row_mt_enabled
Definition encoder.h:1795
MultiThreadInfo::tf_sync
AV1TemporalFilterSync tf_sync
Definition encoder.h:1841
MultiThreadInfo::gm_sync
AV1GlobalMotionSync gm_sync
Definition encoder.h:1836
PRIMARY_RATE_CONTROL
Primary Rate Control parameters and status.
Definition ratectrl.h:313
PartitionCfg
Encoder config for coding block partitioning.
Definition encoder.h:264
PartitionCfg::enable_rect_partitions
bool enable_rect_partitions
Definition encoder.h:268
PartitionCfg::enable_1to4_partitions
bool enable_1to4_partitions
Definition encoder.h:276
PartitionCfg::max_partition_size
BLOCK_SIZE max_partition_size
Definition encoder.h:286
PartitionCfg::enable_ab_partitions
bool enable_ab_partitions
Definition encoder.h:272
PartitionCfg::min_partition_size
BLOCK_SIZE min_partition_size
Definition encoder.h:281
PrimaryMultiThreadInfo
Primary Encoder parameters related to multi-threading.
Definition encoder.h:1722
PrimaryMultiThreadInfo::tile_thr_data
struct EncWorkerData * tile_thr_data
Definition encoder.h:1742
PrimaryMultiThreadInfo::cdef_worker
AV1CdefWorkerData * cdef_worker
Definition encoder.h:1747
PrimaryMultiThreadInfo::num_workers
int num_workers
Definition encoder.h:1726
PrimaryMultiThreadInfo::prev_num_enc_workers
int prev_num_enc_workers
Definition encoder.h:1763
PrimaryMultiThreadInfo::workers
AVxWorker * workers
Definition encoder.h:1736
PrimaryMultiThreadInfo::p_workers
AVxWorker * p_workers[4]
Definition encoder.h:1753
PrimaryMultiThreadInfo::p_num_workers
int p_num_workers
Definition encoder.h:1758
PrimaryMultiThreadInfo::num_mod_workers
int num_mod_workers[NUM_MT_MODULES]
Definition encoder.h:1731
RATE_CONTROL
Rate Control parameters and status.
Definition ratectrl.h:134
RateControlCfg
Encoder rate control configuration parameters.
Definition encoder.h:514
RateControlCfg::worst_allowed_q
int worst_allowed_q
Definition encoder.h:584
RateControlCfg::over_shoot_pct
int over_shoot_pct
Definition encoder.h:579
RateControlCfg::max_intra_bitrate_pct
unsigned int max_intra_bitrate_pct
Definition encoder.h:549
RateControlCfg::drop_frames_water_mark
int drop_frames_water_mark
Definition encoder.h:567
RateControlCfg::max_consec_drop_ms
int max_consec_drop_ms
Definition encoder.h:622
RateControlCfg::vbrmax_section
int vbrmax_section
Definition encoder.h:615
RateControlCfg::maximum_buffer_size_ms
int64_t maximum_buffer_size_ms
Definition encoder.h:533
RateControlCfg::vbr_corpus_complexity_lap
unsigned int vbr_corpus_complexity_lap
Definition encoder.h:544
RateControlCfg::min_cr
unsigned int min_cr
Definition encoder.h:563
RateControlCfg::force_max_q
int force_max_q
Definition encoder.h:626
RateControlCfg::vbrbias
int vbrbias
Definition encoder.h:605
RateControlCfg::gf_cbr_boost_pct
unsigned int gf_cbr_boost_pct
Definition encoder.h:558
RateControlCfg::vbrmin_section
int vbrmin_section
Definition encoder.h:610
RateControlCfg::mode
enum aom_rc_mode mode
Definition encoder.h:598
RateControlCfg::max_inter_bitrate_pct
unsigned int max_inter_bitrate_pct
Definition encoder.h:554
RateControlCfg::starting_buffer_level_ms
int64_t starting_buffer_level_ms
Definition encoder.h:523
RateControlCfg::best_allowed_q
int best_allowed_q
Definition encoder.h:589
RateControlCfg::under_shoot_pct
int under_shoot_pct
Definition encoder.h:573
RateControlCfg::target_bandwidth
int64_t target_bandwidth
Definition encoder.h:538
RateControlCfg::optimal_buffer_level_ms
int64_t optimal_buffer_level_ms
Definition encoder.h:528
RateControlCfg::cq_level
int cq_level
Definition encoder.h:593
RefFrameDistanceInfo
Refrence frame distance related variables.
Definition encoder.h:2201
RefFrameDistanceInfo::nearest_past_ref
int8_t nearest_past_ref
Definition encoder.h:2209
RefFrameDistanceInfo::ref_relative_dist
int ref_relative_dist[INTER_REFS_PER_FRAME]
Definition encoder.h:2205
RefFrameDistanceInfo::nearest_future_ref
int8_t nearest_future_ref
Definition encoder.h:2213
RefreshFrameInfo
Refresh frame flags for different type of frames.
Definition encoder.h:2180
RefreshFrameInfo::bwd_ref_frame
bool bwd_ref_frame
Definition encoder.h:2182
RefreshFrameInfo::golden_frame
bool golden_frame
Definition encoder.h:2181
RefreshFrameInfo::alt_ref_frame
bool alt_ref_frame
Definition encoder.h:2183
ResizeCfg
Encoder config related to resize.
Definition encoder.h:244
ResizeCfg::resize_scale_denominator
uint8_t resize_scale_denominator
Definition encoder.h:253
ResizeCfg::resize_kf_scale_denominator
uint8_t resize_kf_scale_denominator
Definition encoder.h:258
ResizeCfg::resize_mode
RESIZE_MODE resize_mode
Definition encoder.h:248
ResizePendingParams
Desired dimensions for an externally triggered resize.
Definition encoder.h:2193
ResizePendingParams::width
int width
Definition encoder.h:2194
ResizePendingParams::height
int height
Definition encoder.h:2195
RestUnitSearchInfo
Parameters related to restoration types.
Definition encoder.h:1683
RestUnitSearchInfo::best_rtype
RestorationType best_rtype[RESTORE_TYPES - 1]
Definition encoder.h:1698
RestUnitSearchInfo::wiener
WienerInfo wiener
Definition encoder.h:1687
RestUnitSearchInfo::sgrproj
SgrprojInfo sgrproj
Definition encoder.h:1692
RestorationInfo
Parameters related to Restoration Info.
Definition restoration.h:246
RestorationInfo::frame_restoration_type
RestorationType frame_restoration_type
Definition restoration.h:250
RestoreStateBuffers
Buffers to be backed up during parallel encode set to be restored later.
Definition encoder.h:1658
RestoreStateBuffers::rst_tmpbuf
int32_t * rst_tmpbuf
Definition encoder.h:1672
RestoreStateBuffers::rlbs
RestorationLineBuffers * rlbs
Definition encoder.h:1677
RestoreStateBuffers::cdef_colbuf
uint16_t * cdef_colbuf[3]
Definition encoder.h:1667
RestoreStateBuffers::cdef_srcbuf
uint16_t * cdef_srcbuf
Definition encoder.h:1662
SPEED_FEATURES
Top level speed vs quality trade off data struture.
Definition speed_features.h:2113
SPEED_FEATURES::mv_sf
MV_SPEED_FEATURES mv_sf
Definition speed_features.h:2142
SPEED_FEATURES::lpf_sf
LOOP_FILTER_SPEED_FEATURES lpf_sf
Definition speed_features.h:2177
SPEED_FEATURES::tx_sf
TX_SPEED_FEATURES tx_sf
Definition speed_features.h:2162
SPEED_FEATURES::rt_sf
REAL_TIME_SPEED_FEATURES rt_sf
Definition speed_features.h:2182
SVC
The stucture of SVC.
Definition svc_layercontext.h:89
SgrprojInfo
Parameters related to Sgrproj Filter.
Definition blockd.h:507
SuperResCfg
Encoder config related to frame super-resolution.
Definition encoder.h:420
SuperResCfg::superres_kf_scale_denominator
uint8_t superres_kf_scale_denominator
Definition encoder.h:442
SuperResCfg::superres_mode
aom_superres_mode superres_mode
Definition encoder.h:446
SuperResCfg::superres_kf_qthresh
int superres_kf_qthresh
Definition encoder.h:430
SuperResCfg::enable_superres
bool enable_superres
Definition encoder.h:450
SuperResCfg::superres_scale_denominator
uint8_t superres_scale_denominator
Definition encoder.h:436
SuperResCfg::superres_qthresh
int superres_qthresh
Definition encoder.h:425
TEMPORAL_FILTER_INFO
Temporal filter info for a gop.
Definition temporal_filter.h:164
TWO_PASS_FRAME
Frame level Two pass status and control data.
Definition firstpass.h:467
TWO_PASS
Two pass status and control data.
Definition firstpass.h:425
TemporalFilterCtx
Parameters related to temporal filtering.
Definition temporal_filter.h:101
TimeStamps
Frame time stamps.
Definition encoder.h:2437
TimeStamps::prev_ts_start
int64_t prev_ts_start
Definition encoder.h:2441
TimeStamps::first_ts_start
int64_t first_ts_start
Definition encoder.h:2449
TimeStamps::prev_ts_end
int64_t prev_ts_end
Definition encoder.h:2445
TplParams
Params related to temporal dependency model.
Definition tpl_model.h:168
TxfmSizeTypeCfg
Encoder flags for transform sizes and types.
Definition encoder.h:347
TxfmSizeTypeCfg::enable_tx64
bool enable_tx64
Definition encoder.h:351
TxfmSizeTypeCfg::use_inter_dct_only
bool use_inter_dct_only
Definition encoder.h:374
TxfmSizeTypeCfg::enable_flip_idtx
bool enable_flip_idtx
Definition encoder.h:355
TxfmSizeTypeCfg::use_intra_default_tx_only
bool use_intra_default_tx_only
Definition encoder.h:379
TxfmSizeTypeCfg::use_intra_dct_only
bool use_intra_dct_only
Definition encoder.h:369
TxfmSizeTypeCfg::enable_rect_tx
bool enable_rect_tx
Definition encoder.h:359
TxfmSizeTypeCfg::reduced_tx_type_set
bool reduced_tx_type_set
Definition encoder.h:364
TxfmSizeTypeCfg::enable_tx_size_search
bool enable_tx_size_search
Definition encoder.h:383
VarBasedPartitionInfo
Thresholds for variance based partitioning.
Definition encoder.h:1386
VarBasedPartitionInfo::thresholds
int64_t thresholds[5]
Definition encoder.h:1395
VarBasedPartitionInfo::threshold_minmax
int64_t threshold_minmax
Definition encoder.h:1401
WienerInfo
Parameters related to Wiener Filter.
Definition blockd.h:494
WinnerModeParams
Parameters used for winner mode processing.
Definition encoder.h:2231
WinnerModeParams::use_transform_domain_distortion
unsigned int use_transform_domain_distortion[MODE_EVAL_TYPES]
Definition encoder.h:2253
WinnerModeParams::tx_size_search_methods
TX_SIZE_SEARCH_METHOD tx_size_search_methods[MODE_EVAL_TYPES]
Definition encoder.h:2245
WinnerModeParams::skip_txfm_level
unsigned int skip_txfm_level[MODE_EVAL_TYPES]
Definition encoder.h:2267
WinnerModeParams::coeff_opt_thresholds
unsigned int coeff_opt_thresholds[MODE_EVAL_TYPES][2]
Definition encoder.h:2239
WinnerModeParams::tx_domain_dist_threshold
unsigned int tx_domain_dist_threshold[MODE_EVAL_TYPES]
Definition encoder.h:2260
WinnerModeParams::predict_dc_level
unsigned int predict_dc_level[MODE_EVAL_TYPES]
Definition encoder.h:2274
inter_modes_info
Struct used to hold inter mode data for fast tx search.
Definition encoder.h:1291
inter_modes_info::rd_cost_arr
RD_STATS rd_cost_arr[MAX_INTER_MODES]
Definition encoder.h:1320
inter_modes_info::est_rd_arr
int64_t est_rd_arr[MAX_INTER_MODES]
Definition encoder.h:1312
inter_modes_info::sse_arr
int64_t sse_arr[MAX_INTER_MODES]
Definition encoder.h:1308
inter_modes_info::rd_cost_y_arr
RD_STATS rd_cost_y_arr[MAX_INTER_MODES]
Definition encoder.h:1324
inter_modes_info::rd_cost_uv_arr
RD_STATS rd_cost_uv_arr[MAX_INTER_MODES]
Definition encoder.h:1328
inter_modes_info::mbmi_arr
MB_MODE_INFO mbmi_arr[MAX_INTER_MODES]
Definition encoder.h:1300
inter_modes_info::rd_idx_pair_arr
RdIdxPair rd_idx_pair_arr[MAX_INTER_MODES]
Definition encoder.h:1316
inter_modes_info::mode_rate_arr
int mode_rate_arr[MAX_INTER_MODES]
Definition encoder.h:1304
inter_modes_info::num
int num
Definition encoder.h:1296
macroblock::mbmi_ext_frame
MB_MODE_INFO_EXT_FRAME * mbmi_ext_frame
Finalized mbmi_ext for the whole frame.
Definition block.h:921
macroblock::pix_to_bottom_edge
int pix_to_bottom_edge
Signed vertical distance, in pixels, from the bottom edge of the current prediction block to the bott...
Definition block.h:1448
macroblock::pix_to_right_edge
int pix_to_right_edge
Signed horizontal distance, in pixels, from the right edge of the current prediction block to the rig...
Definition block.h:1456
macroblockd::block_ref_scale_factors
const struct scale_factors * block_ref_scale_factors[2]
Definition blockd.h:687