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;
623} RateControlCfg;
624
626typedef struct {
627 // Indicates the number of frames lag before encoding is started.
628 int lag_in_frames;
629 // Indicates the minimum gf/arf interval to be used.
630 int min_gf_interval;
631 // Indicates the maximum gf/arf interval to be used.
632 int max_gf_interval;
633 // Indicates the minimum height for GF group pyramid structure to be used.
634 int gf_min_pyr_height;
635 // Indicates the maximum height for GF group pyramid structure to be used.
636 int gf_max_pyr_height;
637 // Indicates if automatic set and use of altref frames should be enabled.
638 bool enable_auto_arf;
639 // Indicates if automatic set and use of (b)ackward (r)ef (f)rames should be
640 // enabled.
641 bool enable_auto_brf;
642} GFConfig;
643
644typedef struct {
645 // Indicates the number of tile groups.
646 unsigned int num_tile_groups;
647 // Indicates the MTU size for a tile group. If mtu is non-zero,
648 // num_tile_groups is set to DEFAULT_MAX_NUM_TG.
649 unsigned int mtu;
650 // Indicates the number of tile columns in log2.
651 int tile_columns;
652 // Indicates the number of tile rows in log2.
653 int tile_rows;
654 // Indicates the number of widths in the tile_widths[] array.
655 int tile_width_count;
656 // Indicates the number of heights in the tile_heights[] array.
657 int tile_height_count;
658 // Indicates the tile widths, and may be empty.
659 int tile_widths[MAX_TILE_COLS];
660 // Indicates the tile heights, and may be empty.
661 int tile_heights[MAX_TILE_ROWS];
662 // Indicates if large scale tile coding should be used.
663 bool enable_large_scale_tile;
664 // Indicates if single tile decoding mode should be enabled.
665 bool enable_single_tile_decoding;
666 // Indicates if EXT_TILE_DEBUG should be enabled.
667 bool enable_ext_tile_debug;
668} TileConfig;
669
670typedef struct {
671 // Indicates the width of the input frame.
672 int width;
673 // Indicates the height of the input frame.
674 int height;
675 // If forced_max_frame_width is non-zero then it is used to force the maximum
676 // frame width written in write_sequence_header().
677 int forced_max_frame_width;
678 // If forced_max_frame_width is non-zero then it is used to force the maximum
679 // frame height written in write_sequence_header().
680 int forced_max_frame_height;
681 // Indicates the frame width after applying both super-resolution and resize
682 // to the coded frame.
683 int render_width;
684 // Indicates the frame height after applying both super-resolution and resize
685 // to the coded frame.
686 int render_height;
687} FrameDimensionCfg;
688
689typedef struct {
690 // Indicates if warped motion should be enabled.
691 bool enable_warped_motion;
692 // Indicates if warped motion should be evaluated or not.
693 bool allow_warped_motion;
694 // Indicates if OBMC motion should be enabled.
695 bool enable_obmc;
696} MotionModeCfg;
697
698typedef struct {
699 // Timing info for each frame.
700 aom_timing_info_t timing_info;
701 // Indicates the number of time units of a decoding clock.
702 uint32_t num_units_in_decoding_tick;
703 // Indicates if decoder model information is present in the coded sequence
704 // header.
705 bool decoder_model_info_present_flag;
706 // Indicates if display model information is present in the coded sequence
707 // header.
708 bool display_model_info_present_flag;
709 // Indicates if timing info for each frame is present.
710 bool timing_info_present;
711} DecoderModelCfg;
712
713typedef struct {
714 // Indicates the update frequency for coeff costs.
715 COST_UPDATE_TYPE coeff;
716 // Indicates the update frequency for mode costs.
717 COST_UPDATE_TYPE mode;
718 // Indicates the update frequency for mv costs.
719 COST_UPDATE_TYPE mv;
720 // Indicates the update frequency for dv costs.
721 COST_UPDATE_TYPE dv;
722} CostUpdateFreq;
723
724typedef struct {
725 // Indicates the maximum number of reference frames allowed per frame.
726 unsigned int max_reference_frames;
727 // Indicates if the reduced set of references should be enabled.
728 bool enable_reduced_reference_set;
729 // Indicates if one-sided compound should be enabled.
730 bool enable_onesided_comp;
731} RefFrameCfg;
732
733typedef struct {
734 // Indicates the color space that should be used.
735 aom_color_primaries_t color_primaries;
736 // Indicates the characteristics of transfer function to be used.
737 aom_transfer_characteristics_t transfer_characteristics;
738 // Indicates the matrix coefficients to be used for the transfer function.
739 aom_matrix_coefficients_t matrix_coefficients;
740 // Indicates the chroma 4:2:0 sample position info.
741 aom_chroma_sample_position_t chroma_sample_position;
742 // Indicates if a limited color range or full color range should be used.
743 aom_color_range_t color_range;
744} ColorCfg;
745
746typedef struct {
747 // Indicates if extreme motion vector unit test should be enabled or not.
748 unsigned int motion_vector_unit_test;
749 // Indicates if superblock multipass unit test should be enabled or not.
750 unsigned int sb_multipass_unit_test;
751} UnitTestCfg;
752
753typedef struct {
754 // Indicates the file path to the VMAF model.
755 const char *vmaf_model_path;
756 // Indicates the path to the film grain parameters.
757 const char *film_grain_table_filename;
758 // Indicates the visual tuning metric.
759 aom_tune_metric tuning;
760 // Indicates if the current content is screen or default type.
761 aom_tune_content content;
762 // Indicates the film grain parameters.
763 int film_grain_test_vector;
764 // Indicates the in-block distortion metric to use.
765 aom_dist_metric dist_metric;
766} TuneCfg;
767
768typedef struct {
769 // Indicates the framerate of the input video.
770 double init_framerate;
771 // Indicates the actual bit-depth of the input source.
772 unsigned int input_bit_depth;
773 // Indicates the maximum number of frames to be encoded.
774 unsigned int limit;
775 // Indicates the chrome subsampling x value.
776 unsigned int chroma_subsampling_x;
777 // Indicates the chrome subsampling y value.
778 unsigned int chroma_subsampling_y;
779} InputCfg;
780
781typedef struct {
782 // Controls how the encoder applies fixed QP offsets.
783 // If the value is 0, QP offsets are chosen adaptively.
784 // If the value is 1, fixed QP offsets are picked automatically from cq_level.
785 // If the value is 2, no QP offsets will be applied.
786 int use_fixed_qp_offsets;
787 // Indicates the minimum flatness of the quantization matrix.
788 int qm_minlevel;
789 // Indicates the maximum flatness of the quantization matrix.
790 int qm_maxlevel;
791 // Indicates if adaptive quantize_b should be enabled.
792 int quant_b_adapt;
793 // Indicates the Adaptive Quantization mode to be used.
794 AQ_MODE aq_mode;
795 // Indicates the delta q mode to be used.
796 DELTAQ_MODE deltaq_mode;
797 // Indicates the delta q mode strength.
798 unsigned int deltaq_strength;
799 // Indicates if delta quantization should be enabled in chroma planes.
800 bool enable_chroma_deltaq;
801 // Indicates if delta quantization should be enabled for hdr video
802 bool enable_hdr_deltaq;
803 // Indicates if encoding with quantization matrices should be enabled.
804 bool using_qm;
805} QuantizationCfg;
806
811 typedef struct {
825 int sharpness;
826
830 bool enable_adaptive_sharpness;
831
839 int disable_trellis_quant;
840
844 int arnr_max_frames;
845
849 int arnr_strength;
850
857 uint8_t cdf_update_mode;
858
862 bool enable_tpl_model;
863
868 bool enable_overlay;
869
877 LOOPFILTER_CONTROL loopfilter_control;
878
883 bool skip_postproc_filtering;
884
888 aom_screen_detection_mode screen_detection_mode;
889} AlgoCfg;
890
891
892typedef struct {
893 // Indicates the codec bit-depth.
894 aom_bit_depth_t bit_depth;
895 // Indicates the superblock size that should be used by the encoder.
896 aom_superblock_size_t superblock_size;
897 // Indicates if loopfilter modulation should be enabled.
898 bool enable_deltalf_mode;
899 // Indicates how CDEF should be applied.
900 CDEF_CONTROL cdef_control;
901 // Indicates if loop restoration filter should be enabled.
902 bool enable_restoration;
903 // When enabled, video mode should be used even for single frame input.
904 bool force_video_mode;
905 // Indicates if the error resiliency features should be enabled.
906 bool error_resilient_mode;
907 // Indicates if frame parallel decoding feature should be enabled.
908 bool frame_parallel_decoding_mode;
909 // Indicates if the input should be encoded as monochrome.
910 bool enable_monochrome;
911 // When enabled, the encoder will use a full header even for still pictures.
912 // When disabled, a reduced header is used for still pictures.
913 bool full_still_picture_hdr;
914 // Indicates if dual interpolation filters should be enabled.
915 bool enable_dual_filter;
916 // Indicates if frame order hint should be enabled or not.
917 bool enable_order_hint;
918 // Indicates if ref_frame_mvs should be enabled at the sequence level.
919 bool ref_frame_mvs_present;
920 // Indicates if ref_frame_mvs should be enabled at the frame level.
921 bool enable_ref_frame_mvs;
922 // Indicates if interintra compound mode is enabled.
923 bool enable_interintra_comp;
924 // Indicates if global motion should be enabled.
925 bool enable_global_motion;
926 // Indicates if palette should be enabled.
927 bool enable_palette;
928} ToolCfg;
929
934 typedef struct AV1EncoderConfig {
936 // Configuration related to the input video.
937 InputCfg input_cfg;
938
939 // Configuration related to frame-dimensions.
940 FrameDimensionCfg frm_dim_cfg;
941
946 AlgoCfg algo_cfg;
947
951 KeyFrameCfg kf_cfg;
952
956 RateControlCfg rc_cfg;
958
959 // Configuration related to Quantization.
960 QuantizationCfg q_cfg;
961
962 // Internal frame size scaling.
963 ResizeCfg resize_cfg;
964
965 // Frame Super-Resolution size scaling.
966 SuperResCfg superres_cfg;
967
973 aom_fixed_buf_t twopass_stats_in;
975
976 // Configuration related to encoder toolsets.
977 ToolCfg tool_cfg;
978
979 // Configuration related to Group of frames.
980 GFConfig gf_cfg;
981
982 // Tile related configuration parameters.
983 TileConfig tile_cfg;
984
985 // Configuration related to Tune.
986 TuneCfg tune_cfg;
987
988 // Configuration related to color.
989 ColorCfg color_cfg;
990
991 // Configuration related to decoder model.
992 DecoderModelCfg dec_model_cfg;
993
994 // Configuration related to reference frames.
995 RefFrameCfg ref_frm_cfg;
996
997 // Configuration related to unit tests.
998 UnitTestCfg unit_test_cfg;
999
1000 // Flags related to motion mode.
1001 MotionModeCfg motion_mode_cfg;
1002
1003 // Flags related to intra mode search.
1004 IntraModeCfg intra_mode_cfg;
1005
1006 // Flags related to transform size/type.
1007 TxfmSizeTypeCfg txfm_cfg;
1008
1009 // Flags related to compound type.
1010 CompoundTypeCfg comp_type_cfg;
1011
1012 // Partition related information.
1013 PartitionCfg part_cfg;
1014
1015 // Configuration related to frequency of cost update.
1016 CostUpdateFreq cost_upd_freq;
1017
1018#if CONFIG_DENOISE
1019 // Indicates the noise level.
1020 float noise_level;
1021 // Indicates the the denoisers block size.
1022 int noise_block_size;
1023 // Indicates whether to apply denoising to the frame to be encoded
1024 int enable_dnl_denoising;
1025#endif
1026
1027#if CONFIG_AV1_TEMPORAL_DENOISING
1028 // Noise sensitivity.
1029 int noise_sensitivity;
1030#endif
1031 // Bit mask to specify which tier each of the 32 possible operating points
1032 // conforms to.
1033 unsigned int tier_mask;
1034
1035 // Indicates the number of pixels off the edge of a reference frame we're
1036 // allowed to go when forming an inter prediction.
1037 int border_in_pixels;
1038
1039 // Indicates the maximum number of threads that may be used by the encoder.
1040 int max_threads;
1041
1042 // Indicates the speed preset to be used.
1043 int speed;
1044
1045 // Enable the low complexity decode mode.
1046 unsigned int enable_low_complexity_decode;
1047
1048 // Indicates the target sequence level index for each operating point(OP).
1049 AV1_LEVEL target_seq_level_idx[MAX_NUM_OPERATING_POINTS];
1050
1051 // Indicates the bitstream profile to be used.
1052 BITSTREAM_PROFILE profile;
1053
1062 enum aom_enc_pass pass;
1064
1065 // Total number of encoding passes.
1066 int passes;
1067
1068 // the name of the second pass output file when passes > 2
1069 const char *two_pass_output;
1070
1071 // the name of the second pass log file when passes > 2
1072 const char *second_pass_log;
1073
1074 // Indicates if the encoding is GOOD or REALTIME.
1075 MODE mode;
1076
1077 // Indicates if row-based multi-threading should be enabled or not.
1078 bool row_mt;
1079
1080 // Indicates if frame parallel multi-threading should be enabled or not.
1081 bool fp_mt;
1082
1083 // Indicates if 16bit frame buffers are to be used i.e., the content is >
1084 // 8-bit.
1085 bool use_highbitdepth;
1086
1087 // Indicates the bitstream syntax mode. 0 indicates bitstream is saved as
1088 // Section 5 bitstream, while 1 indicates the bitstream is saved in Annex - B
1089 // format.
1090 bool save_as_annexb;
1091
1092 // The path for partition stats reading and writing, used in the experiment
1093 // CONFIG_PARTITION_SEARCH_ORDER.
1094 const char *partition_info_path;
1095
1096 // The flag that indicates whether we use an external rate distribution to
1097 // guide adaptive quantization. It requires --deltaq-mode=3. The rate
1098 // distribution map file name is stored in |rate_distribution_info|.
1099 unsigned int enable_rate_guide_deltaq;
1100
1101 // The input file of rate distribution information used in all intra mode
1102 // to determine delta quantization.
1103 const char *rate_distribution_info;
1104
1105 // Exit the encoder when it fails to encode to a given level.
1106 int strict_level_conformance;
1107
1108 // Max depth for the GOP after a key frame
1109 int kf_max_pyr_height;
1110
1111 // A flag to control if we enable the superblock qp sweep for a given lambda
1112 int sb_qp_sweep;
1114} AV1EncoderConfig;
1115
1117static inline int is_lossless_requested(const RateControlCfg *const rc_cfg) {
1118 return rc_cfg->best_allowed_q == 0 && rc_cfg->worst_allowed_q == 0;
1119}
1121
1125 typedef struct {
1131 int obmc_probs[FRAME_UPDATE_TYPES][BLOCK_SIZES_ALL];
1132
1138 int warped_probs[FRAME_UPDATE_TYPES];
1139
1146 int tx_type_probs[FRAME_UPDATE_TYPES][TX_SIZES_ALL][TX_TYPES];
1147
1154 int switchable_interp_probs[FRAME_UPDATE_TYPES][SWITCHABLE_FILTER_CONTEXTS]
1155 [SWITCHABLE_FILTERS];
1156} FrameProbInfo;
1157
1159
1160typedef struct FRAME_COUNTS {
1161// Note: This structure should only contain 'unsigned int' fields, or
1162// aggregates built solely from 'unsigned int' fields/elements
1163#if CONFIG_ENTROPY_STATS
1164 unsigned int kf_y_mode[KF_MODE_CONTEXTS][KF_MODE_CONTEXTS][INTRA_MODES];
1165 unsigned int angle_delta[DIRECTIONAL_MODES][2 * MAX_ANGLE_DELTA + 1];
1166 unsigned int y_mode[BLOCK_SIZE_GROUPS][INTRA_MODES];
1167 unsigned int uv_mode[CFL_ALLOWED_TYPES][INTRA_MODES][UV_INTRA_MODES];
1168 unsigned int cfl_sign[CFL_JOINT_SIGNS];
1169 unsigned int cfl_alpha[CFL_ALPHA_CONTEXTS][CFL_ALPHABET_SIZE];
1170 unsigned int palette_y_mode[PALATTE_BSIZE_CTXS][PALETTE_Y_MODE_CONTEXTS][2];
1171 unsigned int palette_uv_mode[PALETTE_UV_MODE_CONTEXTS][2];
1172 unsigned int palette_y_size[PALATTE_BSIZE_CTXS][PALETTE_SIZES];
1173 unsigned int palette_uv_size[PALATTE_BSIZE_CTXS][PALETTE_SIZES];
1174 unsigned int palette_y_color_index[PALETTE_SIZES]
1175 [PALETTE_COLOR_INDEX_CONTEXTS]
1176 [PALETTE_COLORS];
1177 unsigned int palette_uv_color_index[PALETTE_SIZES]
1178 [PALETTE_COLOR_INDEX_CONTEXTS]
1179 [PALETTE_COLORS];
1180 unsigned int partition[PARTITION_CONTEXTS][EXT_PARTITION_TYPES];
1181 unsigned int txb_skip[TOKEN_CDF_Q_CTXS][TX_SIZES][TXB_SKIP_CONTEXTS][2];
1182 unsigned int eob_extra[TOKEN_CDF_Q_CTXS][TX_SIZES][PLANE_TYPES]
1183 [EOB_COEF_CONTEXTS][2];
1184 unsigned int dc_sign[PLANE_TYPES][DC_SIGN_CONTEXTS][2];
1185 unsigned int coeff_lps[TX_SIZES][PLANE_TYPES][BR_CDF_SIZE - 1][LEVEL_CONTEXTS]
1186 [2];
1187 unsigned int eob_flag[TX_SIZES][PLANE_TYPES][EOB_COEF_CONTEXTS][2];
1188 unsigned int eob_multi16[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][5];
1189 unsigned int eob_multi32[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][6];
1190 unsigned int eob_multi64[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][7];
1191 unsigned int eob_multi128[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][8];
1192 unsigned int eob_multi256[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][9];
1193 unsigned int eob_multi512[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][10];
1194 unsigned int eob_multi1024[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][11];
1195 unsigned int coeff_lps_multi[TOKEN_CDF_Q_CTXS][TX_SIZES][PLANE_TYPES]
1196 [LEVEL_CONTEXTS][BR_CDF_SIZE];
1197 unsigned int coeff_base_multi[TOKEN_CDF_Q_CTXS][TX_SIZES][PLANE_TYPES]
1198 [SIG_COEF_CONTEXTS][NUM_BASE_LEVELS + 2];
1199 unsigned int coeff_base_eob_multi[TOKEN_CDF_Q_CTXS][TX_SIZES][PLANE_TYPES]
1200 [SIG_COEF_CONTEXTS_EOB][NUM_BASE_LEVELS + 1];
1201 unsigned int newmv_mode[NEWMV_MODE_CONTEXTS][2];
1202 unsigned int zeromv_mode[GLOBALMV_MODE_CONTEXTS][2];
1203 unsigned int refmv_mode[REFMV_MODE_CONTEXTS][2];
1204 unsigned int drl_mode[DRL_MODE_CONTEXTS][2];
1205 unsigned int inter_compound_mode[INTER_MODE_CONTEXTS][INTER_COMPOUND_MODES];
1206 unsigned int wedge_idx[BLOCK_SIZES_ALL][16];
1207 unsigned int interintra[BLOCK_SIZE_GROUPS][2];
1208 unsigned int interintra_mode[BLOCK_SIZE_GROUPS][INTERINTRA_MODES];
1209 unsigned int wedge_interintra[BLOCK_SIZES_ALL][2];
1210 unsigned int compound_type[BLOCK_SIZES_ALL][MASKED_COMPOUND_TYPES];
1211 unsigned int motion_mode[BLOCK_SIZES_ALL][MOTION_MODES];
1212 unsigned int obmc[BLOCK_SIZES_ALL][2];
1213 unsigned int intra_inter[INTRA_INTER_CONTEXTS][2];
1214 unsigned int comp_inter[COMP_INTER_CONTEXTS][2];
1215 unsigned int comp_ref_type[COMP_REF_TYPE_CONTEXTS][2];
1216 unsigned int uni_comp_ref[UNI_COMP_REF_CONTEXTS][UNIDIR_COMP_REFS - 1][2];
1217 unsigned int single_ref[REF_CONTEXTS][SINGLE_REFS - 1][2];
1218 unsigned int comp_ref[REF_CONTEXTS][FWD_REFS - 1][2];
1219 unsigned int comp_bwdref[REF_CONTEXTS][BWD_REFS - 1][2];
1220 unsigned int intrabc[2];
1221
1222 unsigned int txfm_partition[TXFM_PARTITION_CONTEXTS][2];
1223 unsigned int intra_tx_size[MAX_TX_CATS][TX_SIZE_CONTEXTS][MAX_TX_DEPTH + 1];
1224 unsigned int skip_mode[SKIP_MODE_CONTEXTS][2];
1225 unsigned int skip_txfm[SKIP_CONTEXTS][2];
1226 unsigned int compound_index[COMP_INDEX_CONTEXTS][2];
1227 unsigned int comp_group_idx[COMP_GROUP_IDX_CONTEXTS][2];
1228 unsigned int delta_q[DELTA_Q_PROBS][2];
1229 unsigned int delta_lf_multi[FRAME_LF_COUNT][DELTA_LF_PROBS][2];
1230 unsigned int delta_lf[DELTA_LF_PROBS][2];
1231
1232 unsigned int inter_ext_tx[EXT_TX_SETS_INTER][EXT_TX_SIZES][TX_TYPES];
1233 unsigned int intra_ext_tx[EXT_TX_SETS_INTRA][EXT_TX_SIZES][INTRA_MODES]
1234 [TX_TYPES];
1235 unsigned int filter_intra_mode[FILTER_INTRA_MODES];
1236 unsigned int filter_intra[BLOCK_SIZES_ALL][2];
1237 unsigned int switchable_restore[RESTORE_SWITCHABLE_TYPES];
1238 unsigned int wiener_restore[2];
1239 unsigned int sgrproj_restore[2];
1240#endif // CONFIG_ENTROPY_STATS
1241
1242 unsigned int switchable_interp[SWITCHABLE_FILTER_CONTEXTS]
1243 [SWITCHABLE_FILTERS];
1244} FRAME_COUNTS;
1245
1246#define INTER_MODE_RD_DATA_OVERALL_SIZE 6400
1247
1248typedef struct {
1249 int ready;
1250 double a;
1251 double b;
1252 double dist_mean;
1253 double ld_mean;
1254 double sse_mean;
1255 double sse_sse_mean;
1256 double sse_ld_mean;
1257 int num;
1258 double dist_sum;
1259 double ld_sum;
1260 double sse_sum;
1261 double sse_sse_sum;
1262 double sse_ld_sum;
1263} InterModeRdModel;
1264
1265typedef struct {
1266 int idx;
1267 int64_t rd;
1268} RdIdxPair;
1269// TODO(angiebird): This is an estimated size. We still need to figure what is
1270// the maximum number of modes.
1271#define MAX_INTER_MODES 1024
1272// TODO(any): rename this struct to something else. There is already another
1273// struct called inter_mode_info, which makes this terribly confusing.
1281 typedef struct inter_modes_info {
1286 int num;
1290 MB_MODE_INFO mbmi_arr[MAX_INTER_MODES];
1294 int mode_rate_arr[MAX_INTER_MODES];
1298 int64_t sse_arr[MAX_INTER_MODES];
1302 int64_t est_rd_arr[MAX_INTER_MODES];
1306 RdIdxPair rd_idx_pair_arr[MAX_INTER_MODES];
1310 RD_STATS rd_cost_arr[MAX_INTER_MODES];
1314 RD_STATS rd_cost_y_arr[MAX_INTER_MODES];
1318 RD_STATS rd_cost_uv_arr[MAX_INTER_MODES];
1319} InterModesInfo;
1320
1322typedef struct {
1323 // TODO(kyslov): consider changing to 64bit
1324
1325 // This struct is used for computing variance in choose_partitioning(), where
1326 // the max number of samples within a superblock is 32x32 (with 4x4 avg).
1327 // With 8bit bitdepth, uint32_t is enough for sum_square_error (2^8 * 2^8 * 32
1328 // * 32 = 2^26). For high bitdepth we need to consider changing this to 64 bit
1329 uint32_t sum_square_error;
1330 int32_t sum_error;
1331 int log2_count;
1332 int variance;
1333} VPartVar;
1334
1335typedef struct {
1336 VPartVar none;
1337 VPartVar horz[2];
1338 VPartVar vert[2];
1339} VPVariance;
1340
1341typedef struct {
1342 VPVariance part_variances;
1343 VPartVar split[4];
1344} VP4x4;
1345
1346typedef struct {
1347 VPVariance part_variances;
1348 VP4x4 split[4];
1349} VP8x8;
1350
1351typedef struct {
1352 VPVariance part_variances;
1353 VP8x8 split[4];
1354} VP16x16;
1355
1356typedef struct {
1357 VPVariance part_variances;
1358 VP16x16 split[4];
1359} VP32x32;
1360
1361typedef struct {
1362 VPVariance part_variances;
1363 VP32x32 split[4];
1364} VP64x64;
1365
1366typedef struct {
1367 VPVariance part_variances;
1368 VP64x64 *split;
1369} VP128x128;
1370
1372
1376 typedef struct {
1385 int64_t thresholds[5];
1386
1391 int64_t threshold_minmax;
1392} VarBasedPartitionInfo;
1393
1397 typedef struct {
1398#if CONFIG_MULTITHREAD
1403 pthread_mutex_t *mutex_;
1404 pthread_cond_t *cond_;
1406#endif // CONFIG_MULTITHREAD
1412 int *num_finished_cols;
1419 int sync_range;
1426 int intrabc_extra_top_right_sb_delay;
1430 int rows;
1434 int next_mi_row;
1438 int num_threads_working;
1439} AV1EncRowMultiThreadSync;
1440
1442
1443// TODO(jingning) All spatially adaptive variables should go to TileDataEnc.
1444typedef struct TileDataEnc {
1445 TileInfo tile_info;
1446 DECLARE_ALIGNED(16, FRAME_CONTEXT, tctx);
1447 FRAME_CONTEXT *row_ctx;
1448 uint64_t abs_sum_level;
1449 uint8_t allow_update_cdf;
1450 InterModeRdModel inter_mode_rd_models[BLOCK_SIZES_ALL];
1451 AV1EncRowMultiThreadSync row_mt_sync;
1452 MV firstpass_top_mv;
1453} TileDataEnc;
1454
1455typedef struct RD_COUNTS {
1456 int compound_ref_used_flag;
1457 int skip_mode_used_flag;
1458 int tx_type_used[TX_SIZES_ALL][TX_TYPES];
1459 int obmc_used[BLOCK_SIZES_ALL][2];
1460 int warped_used[2];
1461 int newmv_or_intra_blocks;
1462 uint64_t seg_tmp_pred_cost[2];
1463} RD_COUNTS;
1464
1465typedef struct ThreadData {
1466 MACROBLOCK mb;
1467 MvCosts *mv_costs_alloc;
1468 IntraBCMVCosts *dv_costs_alloc;
1469 RD_COUNTS rd_counts;
1470 FRAME_COUNTS *counts;
1471 PC_TREE_SHARED_BUFFERS shared_coeff_buf;
1472 SIMPLE_MOTION_DATA_TREE *sms_tree;
1473 SIMPLE_MOTION_DATA_TREE *sms_root;
1474 // buffers are AOM_BUFFER_SIZE_FOR_BLOCK_HASH elements long
1475 uint32_t *hash_value_buffer[2];
1476 OBMCBuffer obmc_buffer;
1477 PALETTE_BUFFER *palette_buffer;
1478 CompoundTypeRdBuffers comp_rd_buffer;
1479 CONV_BUF_TYPE *tmp_conv_dst;
1480 uint64_t abs_sum_level;
1481 uint8_t *tmp_pred_bufs[2];
1482 uint8_t *upsample_pred;
1483 uint8_t *wiener_tmp_pred_buf;
1484 int intrabc_used;
1485 int deltaq_used;
1486 int coefficient_size;
1487 int max_mv_magnitude;
1488 int interp_filter_selected[SWITCHABLE];
1489 FRAME_CONTEXT *tctx;
1490 VP64x64 *vt64x64;
1491 int32_t num_64x64_blocks;
1492 PICK_MODE_CONTEXT *firstpass_ctx;
1493 TemporalFilterData tf_data;
1494 TplBuffers tpl_tmp_buffers;
1495 TplTxfmStats tpl_txfm_stats;
1496 GlobalMotionData gm_data;
1497 // Pointer to the array of structures to store gradient information of each
1498 // pixel in a superblock. The buffer constitutes of MAX_SB_SQUARE pixel level
1499 // structures for each of the plane types (PLANE_TYPE_Y and PLANE_TYPE_UV).
1500 PixelLevelGradientInfo *pixel_gradient_info;
1501 // Pointer to the array of structures to store source variance information of
1502 // each 4x4 sub-block in a superblock. Block4x4VarInfo structure is used to
1503 // store source variance and log of source variance of each 4x4 sub-block
1504 // for subsequent retrieval.
1505 Block4x4VarInfo *src_var_info_of_4x4_sub_blocks;
1506 // Pointer to pc tree root.
1507 PC_TREE *pc_root;
1508} ThreadData;
1509
1510struct EncWorkerData;
1511
1513
1517 typedef struct {
1521 int allocated_tile_rows;
1525 int allocated_tile_cols;
1532 int allocated_rows;
1539 int allocated_cols;
1540
1544 int thread_id_to_tile_id[MAX_NUM_THREADS];
1545
1550 int *num_tile_cols_done;
1551
1556 int allocated_sb_rows;
1557
1562 bool row_mt_exit;
1563
1569 bool firstpass_mt_exit;
1570
1576 bool mb_wiener_mt_exit;
1577
1578#if CONFIG_MULTITHREAD
1582 pthread_mutex_t *mutex_;
1586 pthread_cond_t *cond_;
1587#endif
1588
1596 void (*sync_read_ptr)(AV1EncRowMultiThreadSync *const, int, int);
1600 void (*sync_write_ptr)(AV1EncRowMultiThreadSync *const, int, int, int);
1602} AV1EncRowMultiThreadInfo;
1603
1607 typedef struct {
1608#if CONFIG_MULTITHREAD
1612 pthread_mutex_t *mutex_;
1616 pthread_cond_t *cond_;
1617#endif
1618
1626 void (*intra_sync_read_ptr)(AV1EncRowMultiThreadSync *const, int, int);
1630 void (*intra_sync_write_ptr)(AV1EncRowMultiThreadSync *const, int, int, int);
1632} AV1EncAllIntraMultiThreadInfo;
1633
1637#define NUM_RECODES_PER_FRAME 10
1638
1642#define MAX_PARALLEL_FRAMES 4
1643
1648 typedef struct RestoreStateBuffers {
1652 uint16_t *cdef_srcbuf;
1653
1657 uint16_t *cdef_colbuf[MAX_MB_PLANE];
1658
1662 int32_t *rst_tmpbuf;
1663
1667 RestorationLineBuffers *rlbs;
1668} RestoreStateBuffers;
1669
1673 typedef struct {
1677 WienerInfo wiener;
1678
1682 SgrprojInfo sgrproj;
1683
1688 RestorationType best_rtype[RESTORE_TYPES - 1];
1689} RestUnitSearchInfo;
1690
1696 typedef struct {
1701 RestUnitSearchInfo *rusi[MAX_MB_PLANE];
1702
1706 int16_t *dgd_avg;
1707} AV1LrPickStruct;
1708
1712 typedef struct PrimaryMultiThreadInfo {
1716 int num_workers;
1717
1721 int num_mod_workers[NUM_MT_MODULES];
1722
1726 AVxWorker *workers;
1727
1732 struct EncWorkerData *tile_thr_data;
1733
1737 AV1CdefWorkerData *cdef_worker;
1738
1743 AVxWorker *p_workers[MAX_PARALLEL_FRAMES];
1744
1748 int p_num_workers;
1749
1753 int prev_num_enc_workers;
1754} PrimaryMultiThreadInfo;
1755
1759 typedef struct MultiThreadInfo {
1763 int num_workers;
1764
1768 int num_mod_workers[NUM_MT_MODULES];
1769
1773 AVxWorker *workers;
1774
1779 struct EncWorkerData *tile_thr_data;
1780
1785 bool row_mt_enabled;
1786
1790 bool pack_bs_mt_enabled;
1791
1795 AV1EncRowMultiThreadInfo enc_row_mt;
1796
1801 AV1EncAllIntraMultiThreadInfo intra_mt;
1802
1806 AV1TplRowMultiThreadInfo tpl_row_mt;
1807
1811 AV1LfSync lf_row_sync;
1812
1816 AV1LrSync lr_row_sync;
1817
1821 AV1EncPackBSSync pack_bs_sync;
1822
1826 AV1GlobalMotionSync gm_sync;
1827
1831 AV1TemporalFilterSync tf_sync;
1832
1836 AV1CdefSync cdef_sync;
1837
1841 AV1CdefWorkerData *cdef_worker;
1842
1846 RestoreStateBuffers restore_state_buf;
1847
1852 int pipeline_lpf_mt_with_enc;
1853} MultiThreadInfo;
1854
1856
1857typedef struct ActiveMap {
1858 int enabled;
1859 int update;
1860 unsigned char *map;
1861} ActiveMap;
1862
1864
1868 typedef struct {
1873 double cs_rate_array[32];
1877 int rate_index;
1881 int rate_size;
1882} ForceIntegerMVInfo;
1883
1885
1886#if CONFIG_INTERNAL_STATS
1887// types of stats
1888enum {
1889 STAT_Y,
1890 STAT_U,
1891 STAT_V,
1892 STAT_ALL,
1893 NUM_STAT_TYPES // This should always be the last member of the enum
1894} UENUM1BYTE(StatType);
1895
1896typedef struct IMAGE_STAT {
1897 double stat[NUM_STAT_TYPES];
1898 double worst;
1899} ImageStat;
1900#endif // CONFIG_INTERNAL_STATS
1901
1902typedef struct {
1903 int ref_count;
1904 YV12_BUFFER_CONFIG buf;
1905} EncRefCntBuffer;
1906
1908
1914 typedef struct {
1919 MB_MODE_INFO_EXT_FRAME *frame_base;
1923 int alloc_size;
1927 int stride;
1928} MBMIExtFrameBufferInfo;
1929
1931
1932#if CONFIG_COLLECT_PARTITION_STATS
1933typedef struct FramePartitionTimingStats {
1934 int partition_decisions[6][EXT_PARTITION_TYPES];
1935 int partition_attempts[6][EXT_PARTITION_TYPES];
1936 int64_t partition_times[6][EXT_PARTITION_TYPES];
1937
1938 int partition_redo;
1939} FramePartitionTimingStats;
1940#endif // CONFIG_COLLECT_PARTITION_STATS
1941
1942#if CONFIG_COLLECT_COMPONENT_TIMING
1943#include "aom_ports/aom_timer.h"
1944// Adjust the following to add new components.
1945enum {
1946 av1_encode_strategy_time,
1947 av1_get_one_pass_rt_params_time,
1948 av1_get_second_pass_params_time,
1949 denoise_and_encode_time,
1950 apply_filtering_time,
1951 av1_tpl_setup_stats_time,
1952 encode_frame_to_data_rate_time,
1953 encode_with_or_without_recode_time,
1954 loop_filter_time,
1955 cdef_time,
1956 loop_restoration_time,
1957 av1_pack_bitstream_final_time,
1958 av1_encode_frame_time,
1959 av1_compute_global_motion_time,
1960 av1_setup_motion_field_time,
1961 encode_sb_row_time,
1962
1963 rd_pick_partition_time,
1964 rd_use_partition_time,
1965 choose_var_based_partitioning_time,
1966 av1_prune_partitions_time,
1967 none_partition_search_time,
1968 split_partition_search_time,
1969 rectangular_partition_search_time,
1970 ab_partitions_search_time,
1971 rd_pick_4partition_time,
1972 encode_sb_time,
1973
1974 rd_pick_sb_modes_time,
1975 av1_rd_pick_intra_mode_sb_time,
1976 av1_rd_pick_inter_mode_sb_time,
1977 set_params_rd_pick_inter_mode_time,
1978 skip_inter_mode_time,
1979 handle_inter_mode_time,
1980 evaluate_motion_mode_for_winner_candidates_time,
1981 do_tx_search_time,
1982 handle_intra_mode_time,
1983 refine_winner_mode_tx_time,
1984 av1_search_palette_mode_time,
1985 handle_newmv_time,
1986 compound_type_rd_time,
1987 interpolation_filter_search_time,
1988 motion_mode_rd_time,
1989
1990 nonrd_use_partition_time,
1991 pick_sb_modes_nonrd_time,
1992 hybrid_intra_mode_search_time,
1993 nonrd_pick_inter_mode_sb_time,
1994 encode_b_nonrd_time,
1995
1996 kTimingComponents,
1997} UENUM1BYTE(TIMING_COMPONENT);
1998
1999static inline char const *get_component_name(int index) {
2000 switch (index) {
2001 case av1_encode_strategy_time: return "av1_encode_strategy_time";
2002 case av1_get_one_pass_rt_params_time:
2003 return "av1_get_one_pass_rt_params_time";
2004 case av1_get_second_pass_params_time:
2005 return "av1_get_second_pass_params_time";
2006 case denoise_and_encode_time: return "denoise_and_encode_time";
2007 case apply_filtering_time: return "apply_filtering_time";
2008 case av1_tpl_setup_stats_time: return "av1_tpl_setup_stats_time";
2009 case encode_frame_to_data_rate_time:
2010 return "encode_frame_to_data_rate_time";
2011 case encode_with_or_without_recode_time:
2012 return "encode_with_or_without_recode_time";
2013 case loop_filter_time: return "loop_filter_time";
2014 case cdef_time: return "cdef_time";
2015 case loop_restoration_time: return "loop_restoration_time";
2016 case av1_pack_bitstream_final_time: return "av1_pack_bitstream_final_time";
2017 case av1_encode_frame_time: return "av1_encode_frame_time";
2018 case av1_compute_global_motion_time:
2019 return "av1_compute_global_motion_time";
2020 case av1_setup_motion_field_time: return "av1_setup_motion_field_time";
2021 case encode_sb_row_time: return "encode_sb_row_time";
2022
2023 case rd_pick_partition_time: return "rd_pick_partition_time";
2024 case rd_use_partition_time: return "rd_use_partition_time";
2025 case choose_var_based_partitioning_time:
2026 return "choose_var_based_partitioning_time";
2027 case av1_prune_partitions_time: return "av1_prune_partitions_time";
2028 case none_partition_search_time: return "none_partition_search_time";
2029 case split_partition_search_time: return "split_partition_search_time";
2030 case rectangular_partition_search_time:
2031 return "rectangular_partition_search_time";
2032 case ab_partitions_search_time: return "ab_partitions_search_time";
2033 case rd_pick_4partition_time: return "rd_pick_4partition_time";
2034 case encode_sb_time: return "encode_sb_time";
2035
2036 case rd_pick_sb_modes_time: return "rd_pick_sb_modes_time";
2037 case av1_rd_pick_intra_mode_sb_time:
2038 return "av1_rd_pick_intra_mode_sb_time";
2039 case av1_rd_pick_inter_mode_sb_time:
2040 return "av1_rd_pick_inter_mode_sb_time";
2041 case set_params_rd_pick_inter_mode_time:
2042 return "set_params_rd_pick_inter_mode_time";
2043 case skip_inter_mode_time: return "skip_inter_mode_time";
2044 case handle_inter_mode_time: return "handle_inter_mode_time";
2045 case evaluate_motion_mode_for_winner_candidates_time:
2046 return "evaluate_motion_mode_for_winner_candidates_time";
2047 case do_tx_search_time: return "do_tx_search_time";
2048 case handle_intra_mode_time: return "handle_intra_mode_time";
2049 case refine_winner_mode_tx_time: return "refine_winner_mode_tx_time";
2050 case av1_search_palette_mode_time: return "av1_search_palette_mode_time";
2051 case handle_newmv_time: return "handle_newmv_time";
2052 case compound_type_rd_time: return "compound_type_rd_time";
2053 case interpolation_filter_search_time:
2054 return "interpolation_filter_search_time";
2055 case motion_mode_rd_time: return "motion_mode_rd_time";
2056
2057 case nonrd_use_partition_time: return "nonrd_use_partition_time";
2058 case pick_sb_modes_nonrd_time: return "pick_sb_modes_nonrd_time";
2059 case hybrid_intra_mode_search_time: return "hybrid_intra_mode_search_time";
2060 case nonrd_pick_inter_mode_sb_time: return "nonrd_pick_inter_mode_sb_time";
2061 case encode_b_nonrd_time: return "encode_b_nonrd_time";
2062
2063 default: assert(0);
2064 }
2065 return "error";
2066}
2067#endif
2068
2069// The maximum number of internal ARFs except ALTREF_FRAME
2070#define MAX_INTERNAL_ARFS (REF_FRAMES - BWDREF_FRAME - 1)
2071
2073
2077 typedef struct {
2081 bool search_done;
2082
2088 YV12_BUFFER_CONFIG *ref_buf[REF_FRAMES];
2089
2095 int num_ref_frames[MAX_DIRECTIONS];
2096
2103 FrameDistPair reference_frames[MAX_DIRECTIONS][REF_FRAMES - 1];
2104
2109 int segment_map_w;
2110 int segment_map_h;
2112} GlobalMotionInfo;
2113
2117 typedef struct {
2122 int default_interp_skip_flags;
2126 uint16_t interp_filter_search_mask;
2127} InterpSearchFlags;
2128
2132 typedef struct {
2138 int max_mv_magnitude;
2143 int mv_step_param;
2152 fractional_mv_step_fp *find_fractional_mv_step;
2159 search_site_config search_site_cfg[SS_CFG_TOTAL][NUM_DISTINCT_SEARCH_METHODS];
2160} MotionVectorSearchParams;
2161
2170 typedef struct {
2171 bool golden_frame;
2172 bool bwd_ref_frame;
2173 bool alt_ref_frame;
2174} RefreshFrameInfo;
2175
2183 typedef struct {
2184 int width;
2185 int height;
2186} ResizePendingParams;
2187
2191 typedef struct {
2195 int ref_relative_dist[INTER_REFS_PER_FRAME];
2199 int8_t nearest_past_ref;
2203 int8_t nearest_future_ref;
2204} RefFrameDistanceInfo;
2205
2221 typedef struct {
2229 unsigned int coeff_opt_thresholds[MODE_EVAL_TYPES][2];
2230
2235 TX_SIZE_SEARCH_METHOD tx_size_search_methods[MODE_EVAL_TYPES];
2236
2243 unsigned int use_transform_domain_distortion[MODE_EVAL_TYPES];
2244
2250 unsigned int tx_domain_dist_threshold[MODE_EVAL_TYPES];
2251
2257 unsigned int skip_txfm_level[MODE_EVAL_TYPES];
2258
2264 unsigned int predict_dc_level[MODE_EVAL_TYPES];
2265} WinnerModeParams;
2266
2274 typedef struct {
2275 bool last_frame;
2276 bool golden_frame;
2277 bool bwd_ref_frame;
2278 bool alt2_ref_frame;
2279 bool alt_ref_frame;
2283 bool update_pending;
2284} ExtRefreshFrameFlagsInfo;
2285
2289 typedef struct {
2293 int ref_frame_flags;
2294
2298 ExtRefreshFrameFlagsInfo refresh_frame;
2299
2303 bool refresh_frame_context;
2304
2309 bool refresh_frame_context_pending;
2310
2314 bool use_ref_frame_mvs;
2315
2319 bool use_error_resilient;
2320
2324 bool use_s_frame;
2325
2330 bool use_primary_ref_none;
2331} ExternalFlags;
2332
2334
2335typedef struct {
2336 // Some misc info
2337 int high_prec;
2338 int q;
2339 int order;
2340
2341 // MV counters
2342 int inter_count;
2343 int intra_count;
2344 int default_mvs;
2345 int mv_joint_count[4];
2346 int last_bit_zero;
2347 int last_bit_nonzero;
2348
2349 // Keep track of the rates
2350 int total_mv_rate;
2351 int hp_total_mv_rate;
2352 int lp_total_mv_rate;
2353
2354 // Texture info
2355 int horz_text;
2356 int vert_text;
2357 int diag_text;
2358
2359 // Whether the current struct contains valid data
2360 int valid;
2361} MV_STATS;
2362
2363typedef struct WeberStats {
2364 int64_t mb_wiener_variance;
2365 int64_t src_variance;
2366 int64_t rec_variance;
2367 int16_t src_pix_max;
2368 int16_t rec_pix_max;
2369 int64_t distortion;
2370 int64_t satd;
2371 double max_scale;
2372} WeberStats;
2373
2377typedef struct {
2378 int show_frame_count;
2379} FRAME_INDEX_SET;
2380
2381typedef struct {
2382 struct loopfilter lf;
2383 CdefInfo cdef_info;
2384 YV12_BUFFER_CONFIG copy_buffer;
2385 RATE_CONTROL rc;
2386 MV_STATS mv_stats;
2387 unsigned int frame_number;
2388 FRAME_INDEX_SET frame_index_set;
2389} CODING_CONTEXT;
2390
2391typedef struct {
2392 int frame_width;
2393 int frame_height;
2394 int mi_rows;
2395 int mi_cols;
2396 int mb_rows;
2397 int mb_cols;
2398 int num_mbs;
2399 aom_bit_depth_t bit_depth;
2400 int subsampling_x;
2401 int subsampling_y;
2402} FRAME_INFO;
2403
2405
2409 typedef struct {
2415 uint8_t *map;
2421 bool has_lossless_segment;
2422} EncSegmentationInfo;
2423
2427 typedef struct {
2431 int64_t prev_ts_start;
2435 int64_t prev_ts_end;
2439 int64_t first_ts_start;
2440} TimeStamps;
2441
2446 typedef struct {
2450 tran_low_t *tcoeff;
2454 uint16_t *eobs;
2458 uint8_t *entropy_ctx;
2459} CoeffBufferPool;
2460
2461#if !CONFIG_REALTIME_ONLY
2463// DUCKY_ENCODE_FRAME_MODE is c version of EncodeFrameMode
2464enum {
2465 DUCKY_ENCODE_FRAME_MODE_NONE, // Let native AV1 determine q index and rdmult
2466 DUCKY_ENCODE_FRAME_MODE_QINDEX, // DuckyEncode determines q index and AV1
2467 // determines rdmult
2468 DUCKY_ENCODE_FRAME_MODE_QINDEX_RDMULT, // DuckyEncode determines q index and
2469 // rdmult
2470} UENUM1BYTE(DUCKY_ENCODE_FRAME_MODE);
2471
2472enum {
2473 DUCKY_ENCODE_GOP_MODE_NONE, // native AV1 decides GOP
2474 DUCKY_ENCODE_GOP_MODE_RCL, // rate control lib decides GOP
2475} UENUM1BYTE(DUCKY_ENCODE_GOP_MODE);
2476
2477typedef struct DuckyEncodeFrameInfo {
2478 DUCKY_ENCODE_FRAME_MODE qp_mode;
2479 DUCKY_ENCODE_GOP_MODE gop_mode;
2480 int q_index;
2481 int rdmult;
2482 // These two arrays are equivalent to std::vector<SuperblockEncodeParameters>
2483 int *superblock_encode_qindex;
2484 int *superblock_encode_rdmult;
2485 int delta_q_enabled;
2486} DuckyEncodeFrameInfo;
2487
2488typedef struct DuckyEncodeFrameResult {
2489 int global_order_idx;
2490 int q_index;
2491 int rdmult;
2492 int rate;
2493 int64_t dist;
2494 double psnr;
2495} DuckyEncodeFrameResult;
2496
2497typedef struct DuckyEncodeInfo {
2498 DuckyEncodeFrameInfo frame_info;
2499 DuckyEncodeFrameResult frame_result;
2500} DuckyEncodeInfo;
2502#endif
2503
2505typedef struct RTC_REF {
2510 int reference[INTER_REFS_PER_FRAME];
2511 int ref_idx[INTER_REFS_PER_FRAME];
2512 int refresh[REF_FRAMES];
2513 int set_ref_frame_config;
2514 int non_reference_frame;
2515 int ref_frame_comp[3];
2516 int gld_idx_1layer;
2520 unsigned int buffer_time_index[REF_FRAMES];
2524 unsigned char buffer_spatial_layer[REF_FRAMES];
2528 bool reference_was_previous_frame;
2533 bool bias_recovery_frame;
2534} RTC_REF;
2536
2540 typedef struct AV1_COMP_DATA {
2544 unsigned char *cx_data;
2545
2549 size_t cx_data_sz;
2550
2554 size_t frame_size;
2555
2559 unsigned int lib_flags;
2560
2564 int64_t ts_frame_start;
2565
2569 int64_t ts_frame_end;
2570
2574 int flush;
2575
2579 const aom_rational64_t *timestamp_ratio;
2580
2584 int pop_lookahead;
2585} AV1_COMP_DATA;
2586
2590 typedef struct AV1_PRIMARY {
2594 struct AV1_COMP *parallel_cpi[MAX_PARALLEL_FRAMES];
2595
2600 struct AV1_COMP_DATA parallel_frames_data[MAX_PARALLEL_FRAMES - 1];
2601#if CONFIG_FPMT_TEST
2607 FPMT_TEST_ENC_CFG fpmt_unit_test_cfg;
2608
2612 FrameProbInfo temp_frame_probs;
2613
2619 FrameProbInfo temp_frame_probs_simulation;
2620
2625 int temp_valid_gm_model_found[FRAME_UPDATE_TYPES];
2626#endif // CONFIG_FPMT_TEST
2632 RefCntBuffer *ref_frame_map_copy[REF_FRAMES];
2633
2637 int64_t ts_start_last_show_frame;
2638
2642 int64_t ts_end_last_show_frame;
2643
2647 int num_fp_contexts;
2648
2652 int filter_level[2];
2653
2657 int filter_level_u;
2658
2662 int filter_level_v;
2663
2668 struct AV1_COMP *cpi;
2669
2673 struct AV1_COMP *cpi_lap;
2674
2678 struct lookahead_ctx *lookahead;
2679
2689 int seq_params_locked;
2690
2695 struct aom_codec_pkt_list *output_pkt_list;
2696
2700 int internal_altref_allowed;
2701
2705 int show_existing_alt_ref;
2706
2710 GF_GROUP gf_group;
2711
2715 GF_STATE gf_state;
2716
2720 int lap_enabled;
2721
2725 AV1LevelParams level_params;
2726
2730 int b_calculate_psnr;
2731
2735 int frames_left;
2736
2740 TWO_PASS twopass;
2741
2745 PRIMARY_RATE_CONTROL p_rc;
2746
2750 TEMPORAL_FILTER_INFO tf_info;
2755 SequenceHeader seq_params;
2756
2760 int use_svc;
2761
2765 bool buffer_removal_time_present;
2766
2770 unsigned int number_temporal_layers;
2771
2775 unsigned int number_spatial_layers;
2776
2780 struct aom_internal_error_info error;
2781
2787 aom_variance_fn_ptr_t fn_ptr[BLOCK_SIZES_ALL];
2788
2793 double *tpl_sb_rdmult_scaling_factors;
2794
2798 TplParams tpl_data;
2799
2803 MV_STATS mv_stats;
2804
2805#if CONFIG_INTERNAL_STATS
2807 uint64_t total_time_receive_data;
2808 uint64_t total_time_compress_data;
2809
2810 unsigned int total_mode_chosen_counts[MAX_MODES];
2811
2812 int count[2];
2813 uint64_t total_sq_error[2];
2814 uint64_t total_samples[2];
2815 ImageStat psnr[2];
2816
2817 double total_blockiness;
2818 double worst_blockiness;
2819
2820 uint64_t total_bytes;
2821 double summed_quality;
2822 double summed_weights;
2823 double summed_quality_hbd;
2824 double summed_weights_hbd;
2825 unsigned int total_recode_hits;
2826 double worst_ssim;
2827 double worst_ssim_hbd;
2828
2829 ImageStat fastssim;
2830 ImageStat psnrhvs;
2831
2832 int b_calculate_blockiness;
2833 int b_calculate_consistency;
2834
2835 double total_inconsistency;
2836 double worst_consistency;
2837 Ssimv *ssim_vars;
2838 Metrics metrics;
2840#endif
2841
2842#if CONFIG_ENTROPY_STATS
2846 FRAME_COUNTS aggregate_fc;
2847#endif // CONFIG_ENTROPY_STATS
2848
2855 int fb_of_context_type[REF_FRAMES];
2856
2860 PrimaryMultiThreadInfo p_mt_info;
2861
2865 FrameProbInfo frame_probs;
2866
2873 int valid_gm_model_found[FRAME_UPDATE_TYPES];
2874
2878 RTC_REF rtc_ref;
2879
2884 AV1EncRowMultiThreadSync intra_row_mt_sync;
2885
2891 int b_freeze_internal_state;
2892} AV1_PRIMARY;
2893
2897 typedef struct AV1_COMP {
2901 AV1_PRIMARY *ppi;
2902
2907 EncQuantDequantParams enc_quant_dequant_params;
2908
2912 ThreadData td;
2913
2917 FRAME_COUNTS counts;
2918
2922 MBMIExtFrameBufferInfo mbmi_ext_info;
2923
2929 CB_COEFF_BUFFER *coeff_buffer_base;
2930
2935 CoeffBufferPool coeff_buffer_pool;
2936
2940 AV1_COMMON common;
2941
2945 AV1EncoderConfig oxcf;
2946
2951 TRELLIS_OPT_TYPE optimize_seg_arr[MAX_SEGMENTS];
2952
2958 YV12_BUFFER_CONFIG *source;
2959
2967 YV12_BUFFER_CONFIG *last_source;
2968
2973 YV12_BUFFER_CONFIG *unscaled_source;
2974
2978 YV12_BUFFER_CONFIG scaled_source;
2979
2983 YV12_BUFFER_CONFIG *unscaled_last_source;
2984
2988 YV12_BUFFER_CONFIG scaled_last_source;
2989
2994 YV12_BUFFER_CONFIG *unfiltered_source;
2995
3000 YV12_BUFFER_CONFIG orig_source;
3001
3005 int skip_tpl_setup_stats;
3006
3015 double *tpl_rdmult_scaling_factors;
3016
3020 TemporalFilterCtx tf_ctx;
3021
3025 CdefSearchCtx *cdef_search_ctx;
3026
3030 ForceIntegerMVInfo force_intpel_info;
3031
3036 RefCntBuffer *scaled_ref_buf[INTER_REFS_PER_FRAME];
3037
3041 RefCntBuffer *last_show_frame_buf;
3042
3046 RefreshFrameInfo refresh_frame;
3047
3051 int rt_reduce_num_ref_buffers;
3052
3056 ExternalFlags ext_flags;
3057
3062 YV12_BUFFER_CONFIG last_frame_uf;
3063
3068 YV12_BUFFER_CONFIG trial_frame_rst;
3069
3073 int64_t ambient_err;
3074
3078 RD_OPT rd;
3079
3084 CODING_CONTEXT coding_context;
3085
3089 GlobalMotionInfo gm_info;
3090
3094 WinnerModeParams winner_mode_params;
3095
3099 TimeStamps time_stamps;
3100
3104 RATE_CONTROL rc;
3105
3109 double framerate;
3110
3114 int ref_frame_flags;
3115
3119 int speed;
3120
3124 SPEED_FEATURES sf;
3125
3129 MotionVectorSearchParams mv_search_params;
3130
3135 int all_one_sided_refs;
3136
3140 EncSegmentationInfo enc_seg;
3141
3145 CYCLIC_REFRESH *cyclic_refresh;
3150 ActiveMap active_map;
3151
3155 unsigned char gf_frame_index;
3156
3157#if CONFIG_INTERNAL_STATS
3159 uint64_t time_compress_data;
3160
3161 unsigned int mode_chosen_counts[MAX_MODES];
3162 int bytes;
3163 unsigned int frame_recode_hits;
3165#endif
3166
3167#if CONFIG_SPEED_STATS
3171 unsigned int tx_search_count;
3172#endif // CONFIG_SPEED_STATS
3173
3178 int droppable;
3179
3183 FRAME_INFO frame_info;
3184
3188 FRAME_INDEX_SET frame_index_set;
3189
3195 int data_alloc_width;
3196
3202 int data_alloc_height;
3203
3210 int initial_mbs;
3211
3216 bool frame_size_related_setup_done;
3217
3222 int last_coded_width;
3223
3228 int last_coded_height;
3229
3233 ResizePendingParams resize_pending_params;
3234
3239 TileDataEnc *tile_data;
3243 int allocated_tiles;
3244
3248 TokenInfo token_info;
3249
3253 int vaq_refresh;
3254
3258 VarBasedPartitionInfo vbp_info;
3259
3263 int num_frame_recode;
3264
3268 FrameProbInfo frame_new_probs[NUM_RECODES_PER_FRAME];
3269
3273 int do_update_frame_probs_txtype[NUM_RECODES_PER_FRAME];
3274
3278 int do_update_frame_probs_obmc[NUM_RECODES_PER_FRAME];
3279
3283 int do_update_frame_probs_warp[NUM_RECODES_PER_FRAME];
3284
3288 int do_update_frame_probs_interpfilter[NUM_RECODES_PER_FRAME];
3289
3290#if CONFIG_FPMT_TEST
3295 double temp_framerate;
3296#endif
3302 double new_framerate;
3303
3307 int do_update_vbr_bits_off_target_fast;
3308
3312 MultiThreadInfo mt_info;
3313
3319 int existing_fb_idx_to_show;
3320
3324 int intrabc_used;
3325
3329 int prune_ref_frame_mask;
3330
3336 int keep_single_ref_frame_mask;
3337
3343 int keep_comp_ref_frame_mask;
3344
3348 AV1LrStruct lr_ctxt;
3349
3353 AV1LrPickStruct pick_lr_ctxt;
3354
3358 aom_film_grain_table_t *film_grain_table;
3359
3360#if CONFIG_DENOISE
3365 struct aom_denoise_and_model_t *denoise_and_model;
3366#endif
3367
3371 InterpSearchFlags interp_search_flags;
3372
3380 int use_screen_content_tools;
3381
3388 int is_screen_content_type;
3389
3390#if CONFIG_COLLECT_PARTITION_STATS
3394 FramePartitionTimingStats partition_stats;
3395#endif // CONFIG_COLLECT_PARTITION_STATS
3396
3397#if CONFIG_COLLECT_COMPONENT_TIMING
3401 uint64_t component_time[kTimingComponents];
3406 struct aom_usec_timer component_timer[kTimingComponents];
3410 uint64_t frame_component_time[kTimingComponents];
3411#endif
3412
3416 int frame_header_count;
3417
3421 int deltaq_used;
3422
3426 RefFrameDistanceInfo ref_frame_dist_info;
3427
3433 double *ssim_rdmult_scaling_factors;
3434
3435#if CONFIG_TUNE_VMAF
3439 TuneVMAFInfo vmaf_info;
3440#endif
3441
3442#if CONFIG_TUNE_BUTTERAUGLI
3446 TuneButteraugliInfo butteraugli_info;
3447#endif
3448
3452 SVC svc;
3453
3457 COMPRESSOR_STAGE compressor_stage;
3458
3463 FRAME_TYPE last_frame_type;
3464
3468 int num_tg;
3469
3475 aom_superres_mode superres_mode;
3476
3480 FirstPassData firstpass_data;
3481
3485 NOISE_ESTIMATE noise_estimate;
3486
3487#if CONFIG_AV1_TEMPORAL_DENOISING
3491 AV1_DENOISER denoiser;
3492#endif
3493
3498 uint8_t *consec_zero_mv;
3499
3503 int consec_zero_mv_alloc_size;
3504
3508 BLOCK_SIZE fp_block_size;
3509
3514 int sb_counter;
3515
3519 size_t available_bs_size;
3520
3525 ExtPartController ext_part_controller;
3526
3531 MV_STATS mv_stats;
3535 int ref_refresh_index;
3536
3541 bool refresh_idx_available;
3542
3548 int ref_idx_to_skip;
3549#if CONFIG_FPMT_TEST
3555
3556 int wanted_fb;
3557#endif // CONFIG_FPMT_TEST
3558
3564 bool do_frame_data_update;
3565
3566#if CONFIG_RD_COMMAND
3570 RD_COMMAND rd_command;
3571#endif // CONFIG_RD_COMMAND
3572
3576 WeberStats *mb_weber_stats;
3577
3582 int *prep_rate_estimates;
3583
3588 double *ext_rate_distribution;
3589
3593 double ext_rate_scale;
3594
3598 BLOCK_SIZE weber_bsize;
3599
3603 int64_t norm_wiener_variance;
3604
3608 int *mb_delta_q;
3609
3613 bool is_dropped_frame;
3614
3615#if CONFIG_BITRATE_ACCURACY
3619 VBR_RATECTRL_INFO vbr_rc_info;
3620#endif
3621
3622#if CONFIG_RATECTRL_LOG
3626 RATECTRL_LOG rc_log;
3627#endif // CONFIG_RATECTRL_LOG
3628
3632 TWO_PASS_FRAME twopass_frame;
3633
3634#if CONFIG_THREE_PASS
3638 THIRD_PASS_DEC_CTX *third_pass_ctx;
3639#endif
3640
3644 FILE *second_pass_log_stream;
3645
3649 uint64_t *src_sad_blk_64x64;
3650
3654 int src_sad_blk_alloc_size;
3655
3661 uint64_t rec_sse;
3662
3667 int use_ducky_encode;
3668
3669#if !CONFIG_REALTIME_ONLY
3673 DuckyEncodeInfo ducky_encode_info;
3674#endif // CONFIG_REALTIME_ONLY
3675 //
3679 int frames_since_last_update;
3680
3684 unsigned int zeromv_skip_thresh_exit_part[BLOCK_SIZES_ALL];
3685
3690 bool alloc_pyramid;
3691
3692#if CONFIG_SALIENCY_MAP
3696 uint8_t *saliency_map;
3697
3701 double *sm_scaling_factor;
3702#endif
3703
3708 int palette_pixel_num;
3709
3714 int scaled_last_source_available;
3715
3719 aom_roi_map_t roi;
3720
3724 AOM_EXT_RATECTRL ext_ratectrl;
3725
3729 AomTplGopStats extrc_tpl_gop_stats;
3730} AV1_COMP;
3731
3735 typedef struct EncodeFrameInput {
3737 YV12_BUFFER_CONFIG *source;
3738 YV12_BUFFER_CONFIG *last_source;
3739 int64_t ts_duration;
3741} EncodeFrameInput;
3742
3747 typedef struct EncodeFrameParams {
3751 int error_resilient_mode;
3755 FRAME_TYPE frame_type;
3756
3758 int primary_ref_frame;
3759 int order_offset;
3760
3765 int show_frame;
3766
3768 int refresh_frame_flags;
3769
3770 int show_existing_frame;
3771 int existing_fb_idx_to_show;
3772
3777 int ref_frame_flags;
3778
3782 int remapped_ref_idx[REF_FRAMES];
3783
3788 RefreshFrameInfo refresh_frame;
3789
3793 int speed;
3794} EncodeFrameParams;
3795
3797
3798void av1_initialize_enc(unsigned int usage, enum aom_rc_mode end_usage);
3799
3800struct AV1_COMP *av1_create_compressor(struct AV1_PRIMARY *ppi,
3801 const AV1EncoderConfig *oxcf,
3802 struct BufferPool *const pool,
3803 COMPRESSOR_STAGE stage,
3804 int lap_lag_in_frames);
3805
3806struct AV1_PRIMARY *av1_create_primary_compressor(
3807 struct aom_codec_pkt_list *pkt_list_head, int num_lap_buffers,
3808 const AV1EncoderConfig *oxcf);
3809
3810void av1_remove_compressor(AV1_COMP *cpi);
3811
3812void av1_remove_primary_compressor(AV1_PRIMARY *ppi);
3813
3814#if CONFIG_ENTROPY_STATS
3815void print_entropy_stats(AV1_PRIMARY *const ppi);
3816#endif
3817#if CONFIG_INTERNAL_STATS
3818void print_internal_stats(AV1_PRIMARY *ppi);
3819#endif
3820
3821void av1_change_config_seq(AV1_PRIMARY *ppi, const AV1EncoderConfig *oxcf,
3822 bool *sb_size_changed);
3823
3824void av1_change_config(AV1_COMP *cpi, const AV1EncoderConfig *oxcf,
3825 bool sb_size_changed);
3826
3827 aom_codec_err_t av1_check_initial_width(AV1_COMP *cpi, int use_highbitdepth,
3828 int subsampling_x, int subsampling_y);
3829
3830void av1_post_encode_updates(AV1_COMP *const cpi,
3831 const AV1_COMP_DATA *const cpi_data);
3832
3833void av1_release_scaled_references_fpmt(AV1_COMP *cpi);
3834
3835void av1_decrement_ref_counts_fpmt(BufferPool *buffer_pool,
3836 int ref_buffers_used_map);
3837
3838void av1_init_sc_decisions(AV1_PRIMARY *const ppi);
3839
3840 AV1_COMP *av1_get_parallel_frame_enc_data(AV1_PRIMARY *const ppi,
3841 AV1_COMP_DATA *const first_cpi_data);
3842
3843int av1_init_parallel_frame_context(const AV1_COMP_DATA *const first_cpi_data,
3844 AV1_PRIMARY *const ppi,
3845 int *ref_buffers_used_map);
3846
3848
3865int av1_receive_raw_frame(AV1_COMP *cpi, aom_enc_frame_flags_t frame_flags,
3866 const YV12_BUFFER_CONFIG *sd, int64_t time_stamp,
3867 int64_t end_time_stamp);
3868
3890int av1_get_compressed_data(AV1_COMP *cpi, AV1_COMP_DATA *const cpi_data);
3891
3898int av1_encode(AV1_COMP *const cpi, uint8_t *const dest, size_t dest_size,
3899 const EncodeFrameInput *const frame_input,
3900 const EncodeFrameParams *const frame_params,
3901 size_t *const frame_size);
3902
3904int av1_get_preview_raw_frame(AV1_COMP *cpi, YV12_BUFFER_CONFIG *dest);
3905
3906int av1_get_last_show_frame(AV1_COMP *cpi, YV12_BUFFER_CONFIG *frame);
3907
3908 aom_codec_err_t av1_copy_new_frame_enc(AV1_COMMON *cm,
3909 YV12_BUFFER_CONFIG *new_frame,
3910 YV12_BUFFER_CONFIG *sd);
3911
3912int av1_use_as_reference(int *ext_ref_frame_flags, int ref_frame_flags);
3913
3914int av1_copy_reference_enc(AV1_COMP *cpi, int idx, YV12_BUFFER_CONFIG *sd);
3915
3916int av1_set_reference_enc(AV1_COMP *cpi, int idx, YV12_BUFFER_CONFIG *sd);
3917
3918void av1_set_frame_size(AV1_COMP *cpi, int width, int height);
3919
3920void av1_set_mv_search_params(AV1_COMP *cpi);
3921
3922int av1_set_roi_map(AV1_COMP *cpi, unsigned char *map, unsigned int rows,
3923 unsigned int cols, int delta_q[8], int delta_lf[8],
3924 int skip[8], int ref_frame[8]);
3925
3926int av1_set_active_map(AV1_COMP *cpi, unsigned char *map, int rows, int cols);
3927
3928int av1_get_active_map(AV1_COMP *cpi, unsigned char *map, int rows, int cols);
3929
3930int av1_set_internal_size(AV1EncoderConfig *const oxcf,
3931 ResizePendingParams *resize_pending_params,
3932 AOM_SCALING_MODE horiz_mode,
3933 AOM_SCALING_MODE vert_mode);
3934
3935int av1_get_quantizer(struct AV1_COMP *cpi);
3936
3937// This function assumes that the input buffer contains valid OBUs. It should
3938// not be called on untrusted input.
3939int av1_convert_sect5obus_to_annexb(uint8_t *buffer, size_t buffer_size,
3940 size_t *input_size);
3941
3942void av1_alloc_mb_wiener_var_pred_buf(AV1_COMMON *cm, ThreadData *td);
3943
3944void av1_dealloc_mb_wiener_var_pred_buf(ThreadData *td);
3945
3946uint8_t av1_find_dominant_value(const uint8_t *src, int stride, int rows,
3947 int cols);
3948
3949void av1_dilate_block(const uint8_t *src, int src_stride, uint8_t *dilated,
3950 int dilated_stride, int rows, int cols);
3951
3952// Set screen content options.
3953// This function estimates whether to use screen content tools, by counting
3954// the portion of blocks that have few luma colors.
3955// Modifies:
3956// cpi->commom.features.allow_screen_content_tools
3957// cpi->common.features.allow_intrabc
3958// cpi->use_screen_content_tools
3959// cpi->is_screen_content_type
3960// However, the estimation is not accurate and may misclassify videos.
3961// A slower but more accurate approach that determines whether to use screen
3962// content tools is employed later. See av1_determine_sc_tools_with_encoding().
3963void av1_set_screen_content_options(struct AV1_COMP *cpi,
3964 FeatureFlags *features);
3965
3966void av1_update_frame_size(AV1_COMP *cpi);
3967
3968void av1_set_svc_seq_params(AV1_PRIMARY *const ppi);
3969
3970typedef struct {
3971 int pyr_level;
3972 int disp_order;
3973} RefFrameMapPair;
3974
3975static inline void init_ref_map_pair(
3976 AV1_COMP *cpi, RefFrameMapPair ref_frame_map_pairs[REF_FRAMES]) {
3977 if (cpi->ppi->gf_group.update_type[cpi->gf_frame_index] == KF_UPDATE) {
3978 memset(ref_frame_map_pairs, -1, sizeof(*ref_frame_map_pairs) * REF_FRAMES);
3979 return;
3980 }
3981 memset(ref_frame_map_pairs, 0, sizeof(*ref_frame_map_pairs) * REF_FRAMES);
3982 for (int map_idx = 0; map_idx < REF_FRAMES; map_idx++) {
3983 // Get reference frame buffer.
3984 const RefCntBuffer *const buf = cpi->common.ref_frame_map[map_idx];
3985 if (ref_frame_map_pairs[map_idx].disp_order == -1) continue;
3986 if (buf == NULL) {
3987 ref_frame_map_pairs[map_idx].disp_order = -1;
3988 ref_frame_map_pairs[map_idx].pyr_level = -1;
3989 continue;
3990 } else if (buf->ref_count > 1) {
3991 // Once the keyframe is coded, the slots in ref_frame_map will all
3992 // point to the same frame. In that case, all subsequent pointers
3993 // matching the current are considered "free" slots. This will find
3994 // the next occurrence of the current pointer if ref_count indicates
3995 // there are multiple instances of it and mark it as free.
3996 for (int idx2 = map_idx + 1; idx2 < REF_FRAMES; ++idx2) {
3997 const RefCntBuffer *const buf2 = cpi->common.ref_frame_map[idx2];
3998 if (buf2 == buf) {
3999 ref_frame_map_pairs[idx2].disp_order = -1;
4000 ref_frame_map_pairs[idx2].pyr_level = -1;
4001 }
4002 }
4003 }
4004 ref_frame_map_pairs[map_idx].disp_order = (int)buf->display_order_hint;
4005 ref_frame_map_pairs[map_idx].pyr_level = buf->pyramid_level;
4006 }
4007}
4008
4009#if CONFIG_FPMT_TEST
4010static inline void calc_frame_data_update_flag(
4011 GF_GROUP *const gf_group, int gf_frame_index,
4012 bool *const do_frame_data_update) {
4013 *do_frame_data_update = true;
4014 // Set the flag to false for all frames in a given parallel encode set except
4015 // the last frame in the set with frame_parallel_level = 2.
4016 if (gf_group->frame_parallel_level[gf_frame_index] == 1) {
4017 *do_frame_data_update = false;
4018 } else if (gf_group->frame_parallel_level[gf_frame_index] == 2) {
4019 // Check if this is the last frame in the set with frame_parallel_level = 2.
4020 for (int i = gf_frame_index + 1; i < gf_group->size; i++) {
4021 if ((gf_group->frame_parallel_level[i] == 0 &&
4022 (gf_group->update_type[i] == ARF_UPDATE ||
4023 gf_group->update_type[i] == INTNL_ARF_UPDATE)) ||
4024 gf_group->frame_parallel_level[i] == 1) {
4025 break;
4026 } else if (gf_group->frame_parallel_level[i] == 2) {
4027 *do_frame_data_update = false;
4028 break;
4029 }
4030 }
4031 }
4032}
4033#endif
4034
4035// av1 uses 10,000,000 ticks/second as time stamp
4036#define TICKS_PER_SEC 10000000LL
4037
4038static inline int64_t timebase_units_to_ticks(
4039 const aom_rational64_t *timestamp_ratio, int64_t n) {
4040 return n * timestamp_ratio->num / timestamp_ratio->den;
4041}
4042
4043static inline int64_t ticks_to_timebase_units(
4044 const aom_rational64_t *timestamp_ratio, int64_t n) {
4045 int64_t round = timestamp_ratio->num / 2;
4046 if (round > 0) --round;
4047 return (n * timestamp_ratio->den + round) / timestamp_ratio->num;
4048}
4049
4050static inline int frame_is_kf_gf_arf(const AV1_COMP *cpi) {
4051 const GF_GROUP *const gf_group = &cpi->ppi->gf_group;
4052 const FRAME_UPDATE_TYPE update_type =
4053 gf_group->update_type[cpi->gf_frame_index];
4054
4055 return frame_is_intra_only(&cpi->common) || update_type == ARF_UPDATE ||
4056 update_type == GF_UPDATE;
4057}
4058
4059// TODO(huisu@google.com, youzhou@microsoft.com): enable hash-me for HBD.
4060static inline int av1_use_hash_me(const AV1_COMP *const cpi) {
4061 return (cpi->common.features.allow_screen_content_tools &&
4062 cpi->common.features.allow_intrabc &&
4063 frame_is_intra_only(&cpi->common));
4064}
4065
4066static inline const YV12_BUFFER_CONFIG *get_ref_frame_yv12_buf(
4067 const AV1_COMMON *const cm, MV_REFERENCE_FRAME ref_frame) {
4068 const RefCntBuffer *const buf = get_ref_frame_buf(cm, ref_frame);
4069 return buf != NULL ? &buf->buf : NULL;
4070}
4071
4072static inline void alloc_frame_mvs(AV1_COMMON *const cm, RefCntBuffer *buf) {
4073 assert(buf != NULL);
4074 ensure_mv_buffer(buf, cm);
4075 buf->width = cm->width;
4076 buf->height = cm->height;
4077}
4078
4079// Get the allocated token size for a tile. It does the same calculation as in
4080// the frame token allocation.
4081static inline unsigned int allocated_tokens(const TileInfo *tile,
4082 int sb_size_log2, int num_planes) {
4083 int tile_mb_rows =
4084 ROUND_POWER_OF_TWO(tile->mi_row_end - tile->mi_row_start, 2);
4085 int tile_mb_cols =
4086 ROUND_POWER_OF_TWO(tile->mi_col_end - tile->mi_col_start, 2);
4087
4088 return get_token_alloc(tile_mb_rows, tile_mb_cols, sb_size_log2, num_planes);
4089}
4090
4091static inline void get_start_tok(AV1_COMP *cpi, int tile_row, int tile_col,
4092 int mi_row, TokenExtra **tok, int sb_size_log2,
4093 int num_planes) {
4094 AV1_COMMON *const cm = &cpi->common;
4095 const int tile_cols = cm->tiles.cols;
4096 TileDataEnc *this_tile = &cpi->tile_data[tile_row * tile_cols + tile_col];
4097 const TileInfo *const tile_info = &this_tile->tile_info;
4098
4099 const int tile_mb_cols =
4100 (tile_info->mi_col_end - tile_info->mi_col_start + 2) >> 2;
4101 const int tile_mb_row = (mi_row - tile_info->mi_row_start + 2) >> 2;
4102
4103 *tok = cpi->token_info.tile_tok[tile_row][tile_col] +
4104 get_token_alloc(tile_mb_row, tile_mb_cols, sb_size_log2, num_planes);
4105}
4106
4107void av1_apply_encoding_flags(AV1_COMP *cpi, aom_enc_frame_flags_t flags);
4108
4109#define ALT_MIN_LAG 3
4110static inline int is_altref_enabled(int lag_in_frames, bool enable_auto_arf) {
4111 return lag_in_frames >= ALT_MIN_LAG && enable_auto_arf;
4112}
4113
4114static inline int can_disable_altref(const GFConfig *gf_cfg) {
4115 return is_altref_enabled(gf_cfg->lag_in_frames, gf_cfg->enable_auto_arf) &&
4116 (gf_cfg->gf_min_pyr_height == 0);
4117}
4118
4119// Helper function to compute number of blocks on either side of the frame.
4120static inline int get_num_blocks(const int frame_length, const int mb_length) {
4121 return (frame_length + mb_length - 1) / mb_length;
4122}
4123
4124// Check if statistics generation stage
4125static inline int is_stat_generation_stage(const AV1_COMP *const cpi) {
4126 assert(IMPLIES(cpi->compressor_stage == LAP_STAGE,
4127 cpi->oxcf.pass == AOM_RC_ONE_PASS && cpi->ppi->lap_enabled));
4128 return (cpi->oxcf.pass == AOM_RC_FIRST_PASS ||
4129 (cpi->compressor_stage == LAP_STAGE));
4130}
4131// Check if statistics consumption stage
4132static inline int is_stat_consumption_stage_twopass(const AV1_COMP *const cpi) {
4133 return (cpi->oxcf.pass >= AOM_RC_SECOND_PASS);
4134}
4135
4136// Check if statistics consumption stage
4137static inline int is_stat_consumption_stage(const AV1_COMP *const cpi) {
4138 return (is_stat_consumption_stage_twopass(cpi) ||
4139 (cpi->oxcf.pass == AOM_RC_ONE_PASS &&
4140 (cpi->compressor_stage == ENCODE_STAGE) && cpi->ppi->lap_enabled &&
4141 cpi->oxcf.mode != REALTIME));
4142}
4143
4144// Decide whether 'dv_costs' need to be allocated/stored during the encoding.
4145static inline bool av1_need_dv_costs(const AV1_COMP *const cpi) {
4146 return !cpi->sf.rt_sf.use_nonrd_pick_mode &&
4147 av1_allow_intrabc(&cpi->common) && !is_stat_generation_stage(cpi);
4148}
4149
4159 static inline int has_no_stats_stage(const AV1_COMP *const cpi) {
4160 assert(
4161 IMPLIES(!cpi->ppi->lap_enabled, cpi->compressor_stage == ENCODE_STAGE));
4162 return (cpi->oxcf.pass == AOM_RC_ONE_PASS &&
4163 (!cpi->ppi->lap_enabled || cpi->oxcf.mode == REALTIME));
4164}
4165
4167
4168static inline int is_one_pass_rt_lag_params(const AV1_COMP *cpi) {
4169 return cpi->oxcf.pass == AOM_RC_ONE_PASS &&
4170 cpi->oxcf.gf_cfg.lag_in_frames > 0 && cpi->oxcf.mode == REALTIME;
4171}
4172
4173static inline int is_one_pass_rt_params(const AV1_COMP *cpi) {
4174 return has_no_stats_stage(cpi) && cpi->oxcf.gf_cfg.lag_in_frames == 0 &&
4175 (cpi->oxcf.mode == REALTIME || cpi->svc.number_spatial_layers > 1);
4176}
4177
4178// Use default/internal reference structure for single-layer RTC.
4179static inline int use_rtc_reference_structure_one_layer(const AV1_COMP *cpi) {
4180 return is_one_pass_rt_params(cpi) && cpi->ppi->number_spatial_layers == 1 &&
4181 cpi->ppi->number_temporal_layers == 1 &&
4182 !cpi->ppi->rtc_ref.set_ref_frame_config;
4183}
4184
4185// Check if postencode drop is allowed.
4186static inline int allow_postencode_drop_rtc(const AV1_COMP *cpi) {
4187 const AV1_COMMON *const cm = &cpi->common;
4188 return is_one_pass_rt_params(cpi) && cpi->oxcf.rc_cfg.mode == AOM_CBR &&
4189 cpi->oxcf.rc_cfg.drop_frames_water_mark > 0 &&
4190 !cpi->rc.rtc_external_ratectrl && !frame_is_intra_only(cm) &&
4191 cpi->svc.spatial_layer_id == 0;
4192}
4193
4194// Function return size of frame stats buffer
4195static inline int get_stats_buf_size(int num_lap_buffer, int num_lag_buffer) {
4196 /* if lookahead is enabled return num_lap_buffers else num_lag_buffers */
4197 if (num_lap_buffer > 0) {
4198 return AOMMAX(num_lap_buffer + 1, MAX_GF_LENGTH_LAP + 1);
4199 }
4200 return num_lag_buffer;
4201}
4202
4203// TODO(zoeliu): To set up cpi->oxcf.gf_cfg.enable_auto_brf
4204
4205static inline void set_ref_ptrs(const AV1_COMMON *cm, MACROBLOCKD *xd,
4206 MV_REFERENCE_FRAME ref0,
4207 MV_REFERENCE_FRAME ref1) {
4208 xd->block_ref_scale_factors[0] =
4209 get_ref_scale_factors_const(cm, ref0 >= LAST_FRAME ? ref0 : 1);
4210 xd->block_ref_scale_factors[1] =
4211 get_ref_scale_factors_const(cm, ref1 >= LAST_FRAME ? ref1 : 1);
4212}
4213
4214static inline int get_chessboard_index(int frame_index) {
4215 return frame_index & 0x1;
4216}
4217
4218static inline const int *cond_cost_list_const(const struct AV1_COMP *cpi,
4219 const int *cost_list) {
4220 const int use_cost_list = cpi->sf.mv_sf.subpel_search_method != SUBPEL_TREE &&
4221 cpi->sf.mv_sf.use_fullpel_costlist;
4222 return use_cost_list ? cost_list : NULL;
4223}
4224
4225static inline int *cond_cost_list(const struct AV1_COMP *cpi, int *cost_list) {
4226 const int use_cost_list = cpi->sf.mv_sf.subpel_search_method != SUBPEL_TREE &&
4227 cpi->sf.mv_sf.use_fullpel_costlist;
4228 return use_cost_list ? cost_list : NULL;
4229}
4230
4231// Compression ratio of current frame.
4232double av1_get_compression_ratio(const AV1_COMMON *const cm,
4233 size_t encoded_frame_size);
4234
4235void av1_new_framerate(AV1_COMP *cpi, double framerate);
4236
4237void av1_setup_frame_size(AV1_COMP *cpi);
4238
4239#define LAYER_IDS_TO_IDX(sl, tl, num_tl) ((sl) * (num_tl) + (tl))
4240
4241// Returns 1 if a frame is scaled and 0 otherwise.
4242static inline int av1_resize_scaled(const AV1_COMMON *cm) {
4243 return cm->superres_upscaled_width != cm->render_width ||
4244 cm->superres_upscaled_height != cm->render_height;
4245}
4246
4247static inline int av1_frame_scaled(const AV1_COMMON *cm) {
4248 return av1_superres_scaled(cm) || av1_resize_scaled(cm);
4249}
4250
4251static inline bool av1_encode_for_extrc(AOM_EXT_RATECTRL const *ext_rc) {
4252 return ext_rc->ready && (ext_rc->funcs.rc_type & AOM_RC_QP) != 0 &&
4253 ext_rc->funcs.get_encodeframe_decision != NULL;
4254}
4255
4256// Don't allow a show_existing_frame to coincide with an error resilient
4257// frame. An exception can be made for a forward keyframe since it has no
4258// previous dependencies.
4259static inline int encode_show_existing_frame(const AV1_COMMON *cm) {
4260 return cm->show_existing_frame && (!cm->features.error_resilient_mode ||
4261 cm->current_frame.frame_type == KEY_FRAME);
4262}
4263
4264// Get index into the 'cpi->mbmi_ext_info.frame_base' array for the given
4265// 'mi_row' and 'mi_col'.
4266static inline int get_mi_ext_idx(const int mi_row, const int mi_col,
4267 const BLOCK_SIZE mi_alloc_bsize,
4268 const int mbmi_ext_stride) {
4269 const int mi_ext_size_1d = mi_size_wide[mi_alloc_bsize];
4270 const int mi_ext_row = mi_row / mi_ext_size_1d;
4271 const int mi_ext_col = mi_col / mi_ext_size_1d;
4272 return mi_ext_row * mbmi_ext_stride + mi_ext_col;
4273}
4274
4275// Lighter version of set_offsets that only sets the mode info
4276// pointers.
4277static inline void set_mode_info_offsets(
4278 const CommonModeInfoParams *const mi_params,
4279 const MBMIExtFrameBufferInfo *const mbmi_ext_info, MACROBLOCK *const x,
4280 MACROBLOCKD *const xd, int mi_row, int mi_col) {
4281 set_mi_offsets(mi_params, xd, mi_row, mi_col);
4282 const int ext_idx = get_mi_ext_idx(mi_row, mi_col, mi_params->mi_alloc_bsize,
4283 mbmi_ext_info->stride);
4284 x->mbmi_ext_frame = mbmi_ext_info->frame_base + ext_idx;
4285}
4286
4287// Check to see if the given partition size is allowed for a specified number
4288// of mi block rows and columns remaining in the image.
4289// If not then return the largest allowed partition size
4290static inline BLOCK_SIZE find_partition_size(BLOCK_SIZE bsize, int rows_left,
4291 int cols_left, int *bh, int *bw) {
4292 int int_size = (int)bsize;
4293 if (rows_left <= 0 || cols_left <= 0) {
4294 return AOMMIN(bsize, BLOCK_8X8);
4295 } else {
4296 for (; int_size > 0; int_size -= 3) {
4297 *bh = mi_size_high[int_size];
4298 *bw = mi_size_wide[int_size];
4299 if ((*bh <= rows_left) && (*bw <= cols_left)) {
4300 break;
4301 }
4302 }
4303 }
4304 return (BLOCK_SIZE)int_size;
4305}
4306
4307static const uint8_t av1_ref_frame_flag_list[REF_FRAMES] = { 0,
4308 AOM_LAST_FLAG,
4309 AOM_LAST2_FLAG,
4310 AOM_LAST3_FLAG,
4311 AOM_GOLD_FLAG,
4312 AOM_BWD_FLAG,
4313 AOM_ALT2_FLAG,
4314 AOM_ALT_FLAG };
4315
4316// When more than 'max_allowed_refs' are available, we reduce the number of
4317// reference frames one at a time based on this order.
4318static const MV_REFERENCE_FRAME disable_order[] = {
4319 LAST3_FRAME,
4320 LAST2_FRAME,
4321 ALTREF2_FRAME,
4322 BWDREF_FRAME,
4323};
4324
4325static const MV_REFERENCE_FRAME
4326 ref_frame_priority_order[INTER_REFS_PER_FRAME] = {
4327 LAST_FRAME, ALTREF_FRAME, BWDREF_FRAME, GOLDEN_FRAME,
4328 ALTREF2_FRAME, LAST2_FRAME, LAST3_FRAME,
4329 };
4330
4331static inline int get_ref_frame_flags(const SPEED_FEATURES *const sf,
4332 const int use_one_pass_rt_params,
4333 const YV12_BUFFER_CONFIG **ref_frames,
4334 const int ext_ref_frame_flags) {
4335 // cpi->ext_flags.ref_frame_flags allows certain reference types to be
4336 // disabled by the external interface. These are set by
4337 // av1_apply_encoding_flags(). Start with what the external interface allows,
4338 // then suppress any reference types which we have found to be duplicates.
4339 int flags = ext_ref_frame_flags;
4340
4341 for (int i = 1; i < INTER_REFS_PER_FRAME; ++i) {
4342 const YV12_BUFFER_CONFIG *const this_ref = ref_frames[i];
4343 // If this_ref has appeared before, mark the corresponding ref frame as
4344 // invalid. For one_pass_rt mode, only disable GOLDEN_FRAME if it's the
4345 // same as LAST_FRAME or ALTREF_FRAME (if ALTREF is being used in nonrd).
4346 int index =
4347 (use_one_pass_rt_params && ref_frame_priority_order[i] == GOLDEN_FRAME)
4348 ? (1 + sf->rt_sf.use_nonrd_altref_frame)
4349 : i;
4350 for (int j = 0; j < index; ++j) {
4351 // If this_ref has appeared before (same as the reference corresponding
4352 // to lower index j), remove it as a reference only if that reference
4353 // (for index j) is actually used as a reference.
4354 if (this_ref == ref_frames[j] &&
4355 (flags & (1 << (ref_frame_priority_order[j] - 1)))) {
4356 flags &= ~(1 << (ref_frame_priority_order[i] - 1));
4357 break;
4358 }
4359 }
4360 }
4361 return flags;
4362}
4363
4364// Returns a Sequence Header OBU stored in an aom_fixed_buf_t, or NULL upon
4365// failure. When a non-NULL aom_fixed_buf_t pointer is returned by this
4366// function, the memory must be freed by the caller. Both the buf member of the
4367// aom_fixed_buf_t, and the aom_fixed_buf_t pointer itself must be freed. Memory
4368// returned must be freed via call to free().
4369//
4370// Note: The OBU returned is in Low Overhead Bitstream Format. Specifically,
4371// the obu_has_size_field bit is set, and the buffer contains the obu_size
4372// field.
4373 aom_fixed_buf_t *av1_get_global_headers(AV1_PRIMARY *ppi);
4374
4375#define MAX_GFUBOOST_FACTOR 10.0
4376#define MIN_GFUBOOST_FACTOR 4.0
4377
4378static inline int is_frame_tpl_eligible(const GF_GROUP *const gf_group,
4379 uint8_t index) {
4380 const FRAME_UPDATE_TYPE update_type = gf_group->update_type[index];
4381 return update_type == ARF_UPDATE || update_type == GF_UPDATE ||
4382 update_type == KF_UPDATE;
4383}
4384
4385static inline int is_frame_eligible_for_ref_pruning(const GF_GROUP *gf_group,
4386 int selective_ref_frame,
4387 int prune_ref_frames,
4388 int gf_index) {
4389 return (selective_ref_frame > 0) && (prune_ref_frames > 0) &&
4390 !is_frame_tpl_eligible(gf_group, gf_index);
4391}
4392
4393// Get update type of the current frame.
4394static inline FRAME_UPDATE_TYPE get_frame_update_type(const GF_GROUP *gf_group,
4395 int gf_frame_index) {
4396 return gf_group->update_type[gf_frame_index];
4397}
4398
4399static inline int av1_pixels_to_mi(int pixels) {
4400 return ALIGN_POWER_OF_TWO(pixels, 3) >> MI_SIZE_LOG2;
4401}
4402
4403static inline int is_psnr_calc_enabled(const AV1_COMP *cpi) {
4404 const AV1_COMMON *const cm = &cpi->common;
4405
4406 return cpi->ppi->b_calculate_psnr && !is_stat_generation_stage(cpi) &&
4407 cm->show_frame && !cpi->is_dropped_frame;
4408}
4409
4410static inline int is_frame_resize_pending(const AV1_COMP *const cpi) {
4411 const ResizePendingParams *const resize_pending_params =
4412 &cpi->resize_pending_params;
4413 return (resize_pending_params->width && resize_pending_params->height &&
4414 (cpi->common.width != resize_pending_params->width ||
4415 cpi->common.height != resize_pending_params->height));
4416}
4417
4418// Check if loop filter is used.
4419static inline int is_loopfilter_used(const AV1_COMMON *const cm) {
4420 return !cm->features.coded_lossless && !cm->tiles.large_scale;
4421}
4422
4423// Check if CDEF is used.
4424static inline int is_cdef_used(const AV1_COMMON *const cm) {
4425 return cm->seq_params->enable_cdef && !cm->features.coded_lossless &&
4426 !cm->tiles.large_scale;
4427}
4428
4429// Check if loop restoration filter is used.
4430static inline int is_restoration_used(const AV1_COMMON *const cm) {
4431 return cm->seq_params->enable_restoration && !cm->features.all_lossless &&
4432 !cm->tiles.large_scale;
4433}
4434
4435// Checks if post-processing filters need to be applied.
4436// NOTE: This function decides if the application of different post-processing
4437// filters on the reconstructed frame can be skipped at the encoder side.
4438// However the computation of different filter parameters that are signaled in
4439// the bitstream is still required.
4440static inline unsigned int derive_skip_apply_postproc_filters(
4441 const AV1_COMP *cpi, int use_loopfilter, int use_cdef, int use_superres,
4442 int use_restoration) {
4443 // Though CDEF parameter selection should be dependent on
4444 // deblocked/loop-filtered pixels for cdef_pick_method <=
4445 // CDEF_FAST_SEARCH_LVL5, CDEF strength values are calculated based on the
4446 // pixel values that are not loop-filtered in svc real-time encoding mode.
4447 // Hence this case is handled separately using the condition below.
4448 if (cpi->ppi->rtc_ref.non_reference_frame)
4449 return (SKIP_APPLY_LOOPFILTER | SKIP_APPLY_CDEF);
4450
4451 if (!cpi->oxcf.algo_cfg.skip_postproc_filtering || cpi->ppi->b_calculate_psnr)
4452 return 0;
4453 assert(cpi->oxcf.mode == ALLINTRA);
4454
4455 // The post-processing filters are applied one after the other in the
4456 // following order: deblocking->cdef->superres->restoration. In case of
4457 // ALLINTRA encoding, the reconstructed frame is not used as a reference
4458 // frame. Hence, the application of these filters can be skipped when
4459 // 1. filter parameters of the subsequent stages are not dependent on the
4460 // filtered output of the current stage or
4461 // 2. subsequent filtering stages are disabled
4462 if (use_restoration) return SKIP_APPLY_RESTORATION;
4463 if (use_superres) return SKIP_APPLY_SUPERRES;
4464 if (use_cdef) {
4465 // CDEF parameter selection is not dependent on the deblocked frame if
4466 // cdef_pick_method is CDEF_PICK_FROM_Q. Hence the application of deblocking
4467 // filters and cdef filters can be skipped in this case.
4468 return (cpi->sf.lpf_sf.cdef_pick_method == CDEF_PICK_FROM_Q &&
4469 use_loopfilter)
4470 ? (SKIP_APPLY_LOOPFILTER | SKIP_APPLY_CDEF)
4471 : SKIP_APPLY_CDEF;
4472 }
4473 if (use_loopfilter) return SKIP_APPLY_LOOPFILTER;
4474
4475 // If we reach here, all post-processing stages are disabled, so none need to
4476 // be skipped.
4477 return 0;
4478}
4479
4480static inline void set_postproc_filter_default_params(AV1_COMMON *cm) {
4481 struct loopfilter *const lf = &cm->lf;
4482 CdefInfo *const cdef_info = &cm->cdef_info;
4483 RestorationInfo *const rst_info = cm->rst_info;
4484
4485 lf->filter_level[0] = 0;
4486 lf->filter_level[1] = 0;
4487 lf->backup_filter_level[0] = 0;
4488 lf->backup_filter_level[1] = 0;
4489 cdef_info->cdef_bits = 0;
4490 cdef_info->cdef_strengths[0] = 0;
4491 cdef_info->nb_cdef_strengths = 1;
4492 cdef_info->cdef_uv_strengths[0] = 0;
4493 rst_info[0].frame_restoration_type = RESTORE_NONE;
4494 rst_info[1].frame_restoration_type = RESTORE_NONE;
4495 rst_info[2].frame_restoration_type = RESTORE_NONE;
4496}
4497
4498static inline int is_inter_tx_size_search_level_one(
4499 const TX_SPEED_FEATURES *tx_sf) {
4500 return (tx_sf->inter_tx_size_search_init_depth_rect >= 1 &&
4501 tx_sf->inter_tx_size_search_init_depth_sqr >= 1);
4502}
4503
4504static inline int get_lpf_opt_level(const SPEED_FEATURES *sf) {
4505 int lpf_opt_level = 0;
4506 if (is_inter_tx_size_search_level_one(&sf->tx_sf))
4507 lpf_opt_level = (sf->lpf_sf.lpf_pick == LPF_PICK_FROM_Q) ? 2 : 1;
4508 return lpf_opt_level;
4509}
4510
4511// Enable switchable motion mode only if warp and OBMC tools are allowed
4512static inline bool is_switchable_motion_mode_allowed(bool allow_warped_motion,
4513 bool enable_obmc) {
4514 return (allow_warped_motion || enable_obmc);
4515}
4516
4517#if CONFIG_AV1_TEMPORAL_DENOISING
4518static inline int denoise_svc(const struct AV1_COMP *const cpi) {
4519 return (!cpi->ppi->use_svc ||
4520 (cpi->ppi->use_svc &&
4521 cpi->svc.spatial_layer_id >= cpi->svc.first_layer_denoise));
4522}
4523#endif
4524
4525#if CONFIG_COLLECT_PARTITION_STATS == 2
4526static inline void av1_print_fr_partition_timing_stats(
4527 const FramePartitionTimingStats *part_stats, const char *filename) {
4528 FILE *f = fopen(filename, "w");
4529 if (!f) {
4530 return;
4531 }
4532
4533 fprintf(f, "bsize,redo,");
4534 for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
4535 fprintf(f, "decision_%d,", part);
4536 }
4537 for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
4538 fprintf(f, "attempt_%d,", part);
4539 }
4540 for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
4541 fprintf(f, "time_%d,", part);
4542 }
4543 fprintf(f, "\n");
4544
4545 static const int bsizes[6] = { 128, 64, 32, 16, 8, 4 };
4546
4547 for (int bsize_idx = 0; bsize_idx < 6; bsize_idx++) {
4548 fprintf(f, "%d,%d,", bsizes[bsize_idx], part_stats->partition_redo);
4549 for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
4550 fprintf(f, "%d,", part_stats->partition_decisions[bsize_idx][part]);
4551 }
4552 for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
4553 fprintf(f, "%d,", part_stats->partition_attempts[bsize_idx][part]);
4554 }
4555 for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
4556 fprintf(f, "%ld,", part_stats->partition_times[bsize_idx][part]);
4557 }
4558 fprintf(f, "\n");
4559 }
4560 fclose(f);
4561}
4562#endif // CONFIG_COLLECT_PARTITION_STATS == 2
4563
4564#if CONFIG_COLLECT_PARTITION_STATS
4565static inline int av1_get_bsize_idx_for_part_stats(BLOCK_SIZE bsize) {
4566 assert(bsize == BLOCK_128X128 || bsize == BLOCK_64X64 ||
4567 bsize == BLOCK_32X32 || bsize == BLOCK_16X16 || bsize == BLOCK_8X8 ||
4568 bsize == BLOCK_4X4);
4569 switch (bsize) {
4570 case BLOCK_128X128: return 0;
4571 case BLOCK_64X64: return 1;
4572 case BLOCK_32X32: return 2;
4573 case BLOCK_16X16: return 3;
4574 case BLOCK_8X8: return 4;
4575 case BLOCK_4X4: return 5;
4576 default: assert(0 && "Invalid bsize for partition_stats."); return -1;
4577 }
4578}
4579#endif // CONFIG_COLLECT_PARTITION_STATS
4580
4581#if CONFIG_COLLECT_COMPONENT_TIMING
4582static inline void start_timing(AV1_COMP *cpi, int component) {
4583 aom_usec_timer_start(&cpi->component_timer[component]);
4584}
4585static inline void end_timing(AV1_COMP *cpi, int component) {
4586 aom_usec_timer_mark(&cpi->component_timer[component]);
4587 cpi->frame_component_time[component] +=
4588 aom_usec_timer_elapsed(&cpi->component_timer[component]);
4589}
4590static inline char const *get_frame_type_enum(int type) {
4591 switch (type) {
4592 case 0: return "KEY_FRAME";
4593 case 1: return "INTER_FRAME";
4594 case 2: return "INTRA_ONLY_FRAME";
4595 case 3: return "S_FRAME";
4596 default: assert(0);
4597 }
4598 return "error";
4599}
4600#endif
4601
4603
4604#ifdef __cplusplus
4605} // extern "C"
4606#endif
4607
4608#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:1637
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:1642
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:1814
aom_tune_content
aom_tune_content
AV1 encoder content type.
Definition aomcx.h:1724
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:1767
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:1732
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:5301
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:4529
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_stamp)
Obtain the raw frame data.
Definition encoder.c:4678
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:4159
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:1607
AV1EncAllIntraMultiThreadInfo::mutex_
pthread_mutex_t * mutex_
Definition encoder.h:1612
AV1EncAllIntraMultiThreadInfo::intra_sync_read_ptr
void(* intra_sync_read_ptr)(AV1EncRowMultiThreadSync *const, int, int)
Definition encoder.h:1626
AV1EncAllIntraMultiThreadInfo::cond_
pthread_cond_t * cond_
Definition encoder.h:1616
AV1EncAllIntraMultiThreadInfo::intra_sync_write_ptr
void(* intra_sync_write_ptr)(AV1EncRowMultiThreadSync *const, int, int, int)
Definition encoder.h:1630
AV1EncRowMultiThreadInfo
Encoder data related to row-based multi-threading.
Definition encoder.h:1517
AV1EncRowMultiThreadInfo::allocated_sb_rows
int allocated_sb_rows
Definition encoder.h:1556
AV1EncRowMultiThreadInfo::mutex_
pthread_mutex_t * mutex_
Definition encoder.h:1582
AV1EncRowMultiThreadInfo::allocated_tile_cols
int allocated_tile_cols
Definition encoder.h:1525
AV1EncRowMultiThreadInfo::firstpass_mt_exit
bool firstpass_mt_exit
Definition encoder.h:1569
AV1EncRowMultiThreadInfo::allocated_cols
int allocated_cols
Definition encoder.h:1539
AV1EncRowMultiThreadInfo::thread_id_to_tile_id
int thread_id_to_tile_id[64]
Definition encoder.h:1544
AV1EncRowMultiThreadInfo::mb_wiener_mt_exit
bool mb_wiener_mt_exit
Definition encoder.h:1576
AV1EncRowMultiThreadInfo::sync_write_ptr
void(* sync_write_ptr)(AV1EncRowMultiThreadSync *const, int, int, int)
Definition encoder.h:1600
AV1EncRowMultiThreadInfo::cond_
pthread_cond_t * cond_
Definition encoder.h:1586
AV1EncRowMultiThreadInfo::row_mt_exit
bool row_mt_exit
Definition encoder.h:1562
AV1EncRowMultiThreadInfo::allocated_tile_rows
int allocated_tile_rows
Definition encoder.h:1521
AV1EncRowMultiThreadInfo::allocated_rows
int allocated_rows
Definition encoder.h:1532
AV1EncRowMultiThreadInfo::num_tile_cols_done
int * num_tile_cols_done
Definition encoder.h:1550
AV1EncRowMultiThreadInfo::sync_read_ptr
void(* sync_read_ptr)(AV1EncRowMultiThreadSync *const, int, int)
Definition encoder.h:1596
AV1EncRowMultiThreadSync
Encoder parameters for synchronization of row based multi-threading.
Definition encoder.h:1397
AV1EncRowMultiThreadSync::rows
int rows
Definition encoder.h:1430
AV1EncRowMultiThreadSync::sync_range
int sync_range
Definition encoder.h:1419
AV1EncRowMultiThreadSync::intrabc_extra_top_right_sb_delay
int intrabc_extra_top_right_sb_delay
Definition encoder.h:1426
AV1EncRowMultiThreadSync::next_mi_row
int next_mi_row
Definition encoder.h:1434
AV1EncRowMultiThreadSync::num_finished_cols
int * num_finished_cols
Definition encoder.h:1412
AV1EncRowMultiThreadSync::mutex_
pthread_mutex_t * mutex_
Definition encoder.h:1403
AV1EncRowMultiThreadSync::cond_
pthread_cond_t * cond_
Definition encoder.h:1404
AV1EncRowMultiThreadSync::num_threads_working
int num_threads_working
Definition encoder.h:1438
AV1EncoderConfig
Main encoder configuration data structure.
Definition encoder.h:934
AV1EncoderConfig::rc_cfg
RateControlCfg rc_cfg
Definition encoder.h:956
AV1EncoderConfig::kf_cfg
KeyFrameCfg kf_cfg
Definition encoder.h:951
AV1EncoderConfig::pass
enum aom_enc_pass pass
Definition encoder.h:1062
AV1EncoderConfig::algo_cfg
AlgoCfg algo_cfg
Definition encoder.h:946
AV1EncoderConfig::twopass_stats_in
aom_fixed_buf_t twopass_stats_in
Definition encoder.h:973
AV1LrPickStruct
Structure to hold search parameter per restoration unit and intermediate buffer of Wiener filter used...
Definition encoder.h:1696
AV1LrPickStruct::rusi
RestUnitSearchInfo * rusi[3]
Definition encoder.h:1701
AV1LrPickStruct::dgd_avg
int16_t * dgd_avg
Definition encoder.h:1706
AV1_COMP_DATA
Structure to hold data corresponding to an encoded frame.
Definition encoder.h:2540
AV1_COMP_DATA::ts_frame_end
int64_t ts_frame_end
Definition encoder.h:2569
AV1_COMP_DATA::pop_lookahead
int pop_lookahead
Definition encoder.h:2584
AV1_COMP_DATA::ts_frame_start
int64_t ts_frame_start
Definition encoder.h:2564
AV1_COMP_DATA::cx_data
unsigned char * cx_data
Definition encoder.h:2544
AV1_COMP_DATA::cx_data_sz
size_t cx_data_sz
Definition encoder.h:2549
AV1_COMP_DATA::flush
int flush
Definition encoder.h:2574
AV1_COMP_DATA::lib_flags
unsigned int lib_flags
Definition encoder.h:2559
AV1_COMP_DATA::frame_size
size_t frame_size
Definition encoder.h:2554
AV1_COMP_DATA::timestamp_ratio
const aom_rational64_t * timestamp_ratio
Definition encoder.h:2579
AV1_COMP
Top level encoder structure.
Definition encoder.h:2897
AV1_COMP::ext_rate_distribution
double * ext_rate_distribution
Definition encoder.h:3588
AV1_COMP::do_update_frame_probs_warp
int do_update_frame_probs_warp[10]
Definition encoder.h:3283
AV1_COMP::consec_zero_mv
uint8_t * consec_zero_mv
Definition encoder.h:3498
AV1_COMP::do_update_frame_probs_obmc
int do_update_frame_probs_obmc[10]
Definition encoder.h:3278
AV1_COMP::denoise_and_model
struct aom_denoise_and_model_t * denoise_and_model
Definition encoder.h:3365
AV1_COMP::skip_tpl_setup_stats
int skip_tpl_setup_stats
Definition encoder.h:3005
AV1_COMP::frames_since_last_update
int frames_since_last_update
Definition encoder.h:3679
AV1_COMP::mb_delta_q
int * mb_delta_q
Definition encoder.h:3608
AV1_COMP::vaq_refresh
int vaq_refresh
Definition encoder.h:3253
AV1_COMP::last_frame_type
FRAME_TYPE last_frame_type
Definition encoder.h:3463
AV1_COMP::unscaled_source
YV12_BUFFER_CONFIG * unscaled_source
Definition encoder.h:2973
AV1_COMP::palette_pixel_num
int palette_pixel_num
Definition encoder.h:3708
AV1_COMP::cyclic_refresh
CYCLIC_REFRESH * cyclic_refresh
Definition encoder.h:3145
AV1_COMP::rc
RATE_CONTROL rc
Definition encoder.h:3104
AV1_COMP::deltaq_used
int deltaq_used
Definition encoder.h:3421
AV1_COMP::active_map
ActiveMap active_map
Definition encoder.h:3150
AV1_COMP::frame_size_related_setup_done
bool frame_size_related_setup_done
Definition encoder.h:3216
AV1_COMP::mb_weber_stats
WeberStats * mb_weber_stats
Definition encoder.h:3576
AV1_COMP::refresh_idx_available
bool refresh_idx_available
Definition encoder.h:3541
AV1_COMP::token_info
TokenInfo token_info
Definition encoder.h:3248
AV1_COMP::ambient_err
int64_t ambient_err
Definition encoder.h:3073
AV1_COMP::film_grain_table
aom_film_grain_table_t * film_grain_table
Definition encoder.h:3358
AV1_COMP::ref_refresh_index
int ref_refresh_index
Definition encoder.h:3535
AV1_COMP::keep_comp_ref_frame_mask
int keep_comp_ref_frame_mask
Definition encoder.h:3343
AV1_COMP::available_bs_size
size_t available_bs_size
Definition encoder.h:3519
AV1_COMP::sf
SPEED_FEATURES sf
Definition encoder.h:3124
AV1_COMP::optimize_seg_arr
TRELLIS_OPT_TYPE optimize_seg_arr[8]
Definition encoder.h:2951
AV1_COMP::ext_part_controller
ExtPartController ext_part_controller
Definition encoder.h:3525
AV1_COMP::second_pass_log_stream
FILE * second_pass_log_stream
Definition encoder.h:3644
AV1_COMP::ssim_rdmult_scaling_factors
double * ssim_rdmult_scaling_factors
Definition encoder.h:3433
AV1_COMP::rd
RD_OPT rd
Definition encoder.h:3078
AV1_COMP::data_alloc_height
int data_alloc_height
Definition encoder.h:3202
AV1_COMP::extrc_tpl_gop_stats
AomTplGopStats extrc_tpl_gop_stats
Definition encoder.h:3729
AV1_COMP::num_tg
int num_tg
Definition encoder.h:3468
AV1_COMP::winner_mode_params
WinnerModeParams winner_mode_params
Definition encoder.h:3094
AV1_COMP::ext_flags
ExternalFlags ext_flags
Definition encoder.h:3056
AV1_COMP::alloc_pyramid
bool alloc_pyramid
Definition encoder.h:3690
AV1_COMP::enc_seg
EncSegmentationInfo enc_seg
Definition encoder.h:3140
AV1_COMP::mv_search_params
MotionVectorSearchParams mv_search_params
Definition encoder.h:3129
AV1_COMP::use_screen_content_tools
int use_screen_content_tools
Definition encoder.h:3380
AV1_COMP::do_update_frame_probs_interpfilter
int do_update_frame_probs_interpfilter[10]
Definition encoder.h:3288
AV1_COMP::coding_context
CODING_CONTEXT coding_context
Definition encoder.h:3084
AV1_COMP::tf_ctx
TemporalFilterCtx tf_ctx
Definition encoder.h:3020
AV1_COMP::force_intpel_info
ForceIntegerMVInfo force_intpel_info
Definition encoder.h:3030
AV1_COMP::gm_info
GlobalMotionInfo gm_info
Definition encoder.h:3089
AV1_COMP::consec_zero_mv_alloc_size
int consec_zero_mv_alloc_size
Definition encoder.h:3503
AV1_COMP::coeff_buffer_pool
CoeffBufferPool coeff_buffer_pool
Definition encoder.h:2935
AV1_COMP::frame_index_set
FRAME_INDEX_SET frame_index_set
Definition encoder.h:3188
AV1_COMP::ref_frame_flags
int ref_frame_flags
Definition encoder.h:3114
AV1_COMP::scaled_ref_buf
RefCntBuffer * scaled_ref_buf[INTER_REFS_PER_FRAME]
Definition encoder.h:3036
AV1_COMP::gf_frame_index
unsigned char gf_frame_index
Definition encoder.h:3155
AV1_COMP::oxcf
AV1EncoderConfig oxcf
Definition encoder.h:2945
AV1_COMP::common
AV1_COMMON common
Definition encoder.h:2940
AV1_COMP::lr_ctxt
AV1LrStruct lr_ctxt
Definition encoder.h:3348
AV1_COMP::do_frame_data_update
bool do_frame_data_update
Definition encoder.h:3564
AV1_COMP::cdef_search_ctx
CdefSearchCtx * cdef_search_ctx
Definition encoder.h:3025
AV1_COMP::data_alloc_width
int data_alloc_width
Definition encoder.h:3195
AV1_COMP::do_update_frame_probs_txtype
int do_update_frame_probs_txtype[10]
Definition encoder.h:3273
AV1_COMP::counts
FRAME_COUNTS counts
Definition encoder.h:2917
AV1_COMP::compressor_stage
COMPRESSOR_STAGE compressor_stage
Definition encoder.h:3457
AV1_COMP::intrabc_used
int intrabc_used
Definition encoder.h:3324
AV1_COMP::num_frame_recode
int num_frame_recode
Definition encoder.h:3263
AV1_COMP::rt_reduce_num_ref_buffers
int rt_reduce_num_ref_buffers
Definition encoder.h:3051
AV1_COMP::refresh_frame
RefreshFrameInfo refresh_frame
Definition encoder.h:3046
AV1_COMP::prune_ref_frame_mask
int prune_ref_frame_mask
Definition encoder.h:3329
AV1_COMP::unscaled_last_source
YV12_BUFFER_CONFIG * unscaled_last_source
Definition encoder.h:2983
AV1_COMP::all_one_sided_refs
int all_one_sided_refs
Definition encoder.h:3135
AV1_COMP::mt_info
MultiThreadInfo mt_info
Definition encoder.h:3312
AV1_COMP::vbp_info
VarBasedPartitionInfo vbp_info
Definition encoder.h:3258
AV1_COMP::scaled_last_source_available
int scaled_last_source_available
Definition encoder.h:3714
AV1_COMP::last_source
YV12_BUFFER_CONFIG * last_source
Definition encoder.h:2967
AV1_COMP::existing_fb_idx_to_show
int existing_fb_idx_to_show
Definition encoder.h:3319
AV1_COMP::unfiltered_source
YV12_BUFFER_CONFIG * unfiltered_source
Definition encoder.h:2994
AV1_COMP::zeromv_skip_thresh_exit_part
unsigned int zeromv_skip_thresh_exit_part[BLOCK_SIZES_ALL]
Definition encoder.h:3684
AV1_COMP::frame_info
FRAME_INFO frame_info
Definition encoder.h:3183
AV1_COMP::last_coded_height
int last_coded_height
Definition encoder.h:3228
AV1_COMP::frame_header_count
int frame_header_count
Definition encoder.h:3416
AV1_COMP::droppable
int droppable
Definition encoder.h:3178
AV1_COMP::last_show_frame_buf
RefCntBuffer * last_show_frame_buf
Definition encoder.h:3041
AV1_COMP::superres_mode
aom_superres_mode superres_mode
Definition encoder.h:3475
AV1_COMP::mbmi_ext_info
MBMIExtFrameBufferInfo mbmi_ext_info
Definition encoder.h:2922
AV1_COMP::pick_lr_ctxt
AV1LrPickStruct pick_lr_ctxt
Definition encoder.h:3353
AV1_COMP::new_framerate
double new_framerate
Definition encoder.h:3302
AV1_COMP::ppi
AV1_PRIMARY * ppi
Definition encoder.h:2901
AV1_COMP::src_sad_blk_64x64
uint64_t * src_sad_blk_64x64
Definition encoder.h:3649
AV1_COMP::norm_wiener_variance
int64_t norm_wiener_variance
Definition encoder.h:3603
AV1_COMP::tpl_rdmult_scaling_factors
double * tpl_rdmult_scaling_factors
Definition encoder.h:3015
AV1_COMP::sb_counter
int sb_counter
Definition encoder.h:3514
AV1_COMP::last_coded_width
int last_coded_width
Definition encoder.h:3222
AV1_COMP::tile_data
TileDataEnc * tile_data
Definition encoder.h:3239
AV1_COMP::is_screen_content_type
int is_screen_content_type
Definition encoder.h:3388
AV1_COMP::weber_bsize
BLOCK_SIZE weber_bsize
Definition encoder.h:3598
AV1_COMP::interp_search_flags
InterpSearchFlags interp_search_flags
Definition encoder.h:3371
AV1_COMP::time_stamps
TimeStamps time_stamps
Definition encoder.h:3099
AV1_COMP::roi
aom_roi_map_t roi
Definition encoder.h:3719
AV1_COMP::ref_idx_to_skip
int ref_idx_to_skip
Definition encoder.h:3548
AV1_COMP::orig_source
YV12_BUFFER_CONFIG orig_source
Definition encoder.h:3000
AV1_COMP::src_sad_blk_alloc_size
int src_sad_blk_alloc_size
Definition encoder.h:3654
AV1_COMP::firstpass_data
FirstPassData firstpass_data
Definition encoder.h:3480
AV1_COMP::framerate
double framerate
Definition encoder.h:3109
AV1_COMP::speed
int speed
Definition encoder.h:3119
AV1_COMP::fp_block_size
BLOCK_SIZE fp_block_size
Definition encoder.h:3508
AV1_COMP::use_ducky_encode
int use_ducky_encode
Definition encoder.h:3667
AV1_COMP::trial_frame_rst
YV12_BUFFER_CONFIG trial_frame_rst
Definition encoder.h:3068
AV1_COMP::is_dropped_frame
bool is_dropped_frame
Definition encoder.h:3613
AV1_COMP::td
ThreadData td
Definition encoder.h:2912
AV1_COMP::resize_pending_params
ResizePendingParams resize_pending_params
Definition encoder.h:3233
AV1_COMP::scaled_source
YV12_BUFFER_CONFIG scaled_source
Definition encoder.h:2978
AV1_COMP::do_update_vbr_bits_off_target_fast
int do_update_vbr_bits_off_target_fast
Definition encoder.h:3307
AV1_COMP::last_frame_uf
YV12_BUFFER_CONFIG last_frame_uf
Definition encoder.h:3062
AV1_COMP::enc_quant_dequant_params
EncQuantDequantParams enc_quant_dequant_params
Definition encoder.h:2907
AV1_COMP::keep_single_ref_frame_mask
int keep_single_ref_frame_mask
Definition encoder.h:3336
AV1_COMP::ref_frame_dist_info
RefFrameDistanceInfo ref_frame_dist_info
Definition encoder.h:3426
AV1_COMP::prep_rate_estimates
int * prep_rate_estimates
Definition encoder.h:3582
AV1_COMP::ducky_encode_info
DuckyEncodeInfo ducky_encode_info
Definition encoder.h:3673
AV1_COMP::ext_rate_scale
double ext_rate_scale
Definition encoder.h:3593
AV1_COMP::initial_mbs
int initial_mbs
Definition encoder.h:3210
AV1_COMP::rec_sse
uint64_t rec_sse
Definition encoder.h:3661
AV1_COMP::scaled_last_source
YV12_BUFFER_CONFIG scaled_last_source
Definition encoder.h:2988
AV1_COMP::mv_stats
MV_STATS mv_stats
Definition encoder.h:3531
AV1_COMP::frame_new_probs
FrameProbInfo frame_new_probs[10]
Definition encoder.h:3268
AV1_COMP::ext_ratectrl
AOM_EXT_RATECTRL ext_ratectrl
Definition encoder.h:3724
AV1_COMP::source
YV12_BUFFER_CONFIG * source
Definition encoder.h:2958
AV1_COMP::allocated_tiles
int allocated_tiles
Definition encoder.h:3243
AV1_COMP::svc
SVC svc
Definition encoder.h:3452
AV1_COMP::coeff_buffer_base
CB_COEFF_BUFFER * coeff_buffer_base
Definition encoder.h:2929
AV1_COMP::noise_estimate
NOISE_ESTIMATE noise_estimate
Definition encoder.h:3485
AV1_COMP::twopass_frame
TWO_PASS_FRAME twopass_frame
Definition encoder.h:3632
AV1_PRIMARY
Top level primary encoder structure.
Definition encoder.h:2590
AV1_PRIMARY::num_fp_contexts
int num_fp_contexts
Definition encoder.h:2647
AV1_PRIMARY::intra_row_mt_sync
AV1EncRowMultiThreadSync intra_row_mt_sync
Definition encoder.h:2884
AV1_PRIMARY::buffer_removal_time_present
bool buffer_removal_time_present
Definition encoder.h:2765
AV1_PRIMARY::valid_gm_model_found
int valid_gm_model_found[FRAME_UPDATE_TYPES]
Definition encoder.h:2873
AV1_PRIMARY::output_pkt_list
struct aom_codec_pkt_list * output_pkt_list
Definition encoder.h:2695
AV1_PRIMARY::filter_level
int filter_level[2]
Definition encoder.h:2652
AV1_PRIMARY::seq_params
SequenceHeader seq_params
Definition encoder.h:2755
AV1_PRIMARY::mv_stats
MV_STATS mv_stats
Definition encoder.h:2803
AV1_PRIMARY::cpi
struct AV1_COMP * cpi
Definition encoder.h:2668
AV1_PRIMARY::level_params
AV1LevelParams level_params
Definition encoder.h:2725
AV1_PRIMARY::internal_altref_allowed
int internal_altref_allowed
Definition encoder.h:2700
AV1_PRIMARY::rtc_ref
RTC_REF rtc_ref
Definition encoder.h:2878
AV1_PRIMARY::b_calculate_psnr
int b_calculate_psnr
Definition encoder.h:2730
AV1_PRIMARY::p_mt_info
PrimaryMultiThreadInfo p_mt_info
Definition encoder.h:2860
AV1_PRIMARY::tf_info
TEMPORAL_FILTER_INFO tf_info
Definition encoder.h:2750
AV1_PRIMARY::twopass
TWO_PASS twopass
Definition encoder.h:2740
AV1_PRIMARY::frames_left
int frames_left
Definition encoder.h:2735
AV1_PRIMARY::ts_start_last_show_frame
int64_t ts_start_last_show_frame
Definition encoder.h:2637
AV1_PRIMARY::p_rc
PRIMARY_RATE_CONTROL p_rc
Definition encoder.h:2745
AV1_PRIMARY::lap_enabled
int lap_enabled
Definition encoder.h:2720
AV1_PRIMARY::frame_probs
FrameProbInfo frame_probs
Definition encoder.h:2865
AV1_PRIMARY::show_existing_alt_ref
int show_existing_alt_ref
Definition encoder.h:2705
AV1_PRIMARY::fb_of_context_type
int fb_of_context_type[REF_FRAMES]
Definition encoder.h:2855
AV1_PRIMARY::use_svc
int use_svc
Definition encoder.h:2760
AV1_PRIMARY::tpl_sb_rdmult_scaling_factors
double * tpl_sb_rdmult_scaling_factors
Definition encoder.h:2793
AV1_PRIMARY::filter_level_v
int filter_level_v
Definition encoder.h:2662
AV1_PRIMARY::filter_level_u
int filter_level_u
Definition encoder.h:2657
AV1_PRIMARY::cpi_lap
struct AV1_COMP * cpi_lap
Definition encoder.h:2673
AV1_PRIMARY::parallel_cpi
struct AV1_COMP * parallel_cpi[4]
Definition encoder.h:2594
AV1_PRIMARY::ts_end_last_show_frame
int64_t ts_end_last_show_frame
Definition encoder.h:2642
AV1_PRIMARY::lookahead
struct lookahead_ctx * lookahead
Definition encoder.h:2678
AV1_PRIMARY::ref_frame_map_copy
RefCntBuffer * ref_frame_map_copy[REF_FRAMES]
Definition encoder.h:2632
AV1_PRIMARY::gf_state
GF_STATE gf_state
Definition encoder.h:2715
AV1_PRIMARY::fn_ptr
aom_variance_fn_ptr_t fn_ptr[BLOCK_SIZES_ALL]
Definition encoder.h:2787
AV1_PRIMARY::gf_group
GF_GROUP gf_group
Definition encoder.h:2710
AV1_PRIMARY::parallel_frames_data
struct AV1_COMP_DATA parallel_frames_data[4 - 1]
Definition encoder.h:2600
AV1_PRIMARY::tpl_data
TplParams tpl_data
Definition encoder.h:2798
AV1_PRIMARY::number_temporal_layers
unsigned int number_temporal_layers
Definition encoder.h:2770
AV1_PRIMARY::number_spatial_layers
unsigned int number_spatial_layers
Definition encoder.h:2775
AV1_PRIMARY::b_freeze_internal_state
int b_freeze_internal_state
Definition encoder.h:2891
AV1_PRIMARY::seq_params_locked
int seq_params_locked
Definition encoder.h:2689
AV1_PRIMARY::error
struct aom_internal_error_info error
Definition encoder.h:2780
AlgoCfg
Algorithm configuration parameters.
Definition encoder.h:811
AlgoCfg::disable_trellis_quant
int disable_trellis_quant
Definition encoder.h:839
AlgoCfg::sharpness
int sharpness
Definition encoder.h:825
AlgoCfg::skip_postproc_filtering
bool skip_postproc_filtering
Definition encoder.h:883
AlgoCfg::enable_adaptive_sharpness
bool enable_adaptive_sharpness
Definition encoder.h:830
AlgoCfg::arnr_max_frames
int arnr_max_frames
Definition encoder.h:844
AlgoCfg::screen_detection_mode
aom_screen_detection_mode screen_detection_mode
Definition encoder.h:888
AlgoCfg::enable_tpl_model
bool enable_tpl_model
Definition encoder.h:862
AlgoCfg::loopfilter_control
LOOPFILTER_CONTROL loopfilter_control
Definition encoder.h:877
AlgoCfg::cdf_update_mode
uint8_t cdf_update_mode
Definition encoder.h:857
AlgoCfg::enable_overlay
bool enable_overlay
Definition encoder.h:868
AlgoCfg::arnr_strength
int arnr_strength
Definition encoder.h:849
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:2446
CoeffBufferPool::entropy_ctx
uint8_t * entropy_ctx
Definition encoder.h:2458
CoeffBufferPool::tcoeff
tran_low_t * tcoeff
Definition encoder.h:2450
CoeffBufferPool::eobs
uint16_t * eobs
Definition encoder.h:2454
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:2409
EncSegmentationInfo::map
uint8_t * map
Definition encoder.h:2415
EncSegmentationInfo::has_lossless_segment
bool has_lossless_segment
Definition encoder.h:2421
EncodeFrameInput
Input frames and last input frame.
Definition encoder.h:3735
EncodeFrameParams
contains per-frame encoding parameters decided upon by av1_encode_strategy() and passed down to av1_e...
Definition encoder.h:3747
EncodeFrameParams::error_resilient_mode
int error_resilient_mode
Definition encoder.h:3751
EncodeFrameParams::remapped_ref_idx
int remapped_ref_idx[REF_FRAMES]
Definition encoder.h:3782
EncodeFrameParams::ref_frame_flags
int ref_frame_flags
Definition encoder.h:3777
EncodeFrameParams::speed
int speed
Definition encoder.h:3793
EncodeFrameParams::frame_type
FRAME_TYPE frame_type
Definition encoder.h:3755
EncodeFrameParams::show_frame
int show_frame
Definition encoder.h:3765
EncodeFrameParams::refresh_frame
RefreshFrameInfo refresh_frame
Definition encoder.h:3788
ExtRefreshFrameFlagsInfo
Frame refresh flags set by the external interface.
Definition encoder.h:2274
ExtRefreshFrameFlagsInfo::golden_frame
bool golden_frame
Definition encoder.h:2276
ExtRefreshFrameFlagsInfo::bwd_ref_frame
bool bwd_ref_frame
Definition encoder.h:2277
ExtRefreshFrameFlagsInfo::update_pending
bool update_pending
Definition encoder.h:2283
ExtRefreshFrameFlagsInfo::last_frame
bool last_frame
Definition encoder.h:2275
ExtRefreshFrameFlagsInfo::alt_ref_frame
bool alt_ref_frame
Definition encoder.h:2279
ExtRefreshFrameFlagsInfo::alt2_ref_frame
bool alt2_ref_frame
Definition encoder.h:2278
ExternalFlags
Flags signalled by the external interface at frame level.
Definition encoder.h:2289
ExternalFlags::use_primary_ref_none
bool use_primary_ref_none
Definition encoder.h:2330
ExternalFlags::use_ref_frame_mvs
bool use_ref_frame_mvs
Definition encoder.h:2314
ExternalFlags::refresh_frame
ExtRefreshFrameFlagsInfo refresh_frame
Definition encoder.h:2298
ExternalFlags::ref_frame_flags
int ref_frame_flags
Definition encoder.h:2293
ExternalFlags::use_error_resilient
bool use_error_resilient
Definition encoder.h:2319
ExternalFlags::use_s_frame
bool use_s_frame
Definition encoder.h:2324
ExternalFlags::refresh_frame_context
bool refresh_frame_context
Definition encoder.h:2303
ExternalFlags::refresh_frame_context_pending
bool refresh_frame_context_pending
Definition encoder.h:2309
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:1868
ForceIntegerMVInfo::cs_rate_array
double cs_rate_array[32]
Definition encoder.h:1873
ForceIntegerMVInfo::rate_size
int rate_size
Definition encoder.h:1881
ForceIntegerMVInfo::rate_index
int rate_index
Definition encoder.h:1877
FrameProbInfo
Encoder-side probabilities for pruning of various AV1 tools.
Definition encoder.h:1125
FrameProbInfo::switchable_interp_probs
int switchable_interp_probs[FRAME_UPDATE_TYPES][((SWITCHABLE_FILTERS+1) *4)][SWITCHABLE_FILTERS]
Definition encoder.h:1155
FrameProbInfo::obmc_probs
int obmc_probs[FRAME_UPDATE_TYPES][BLOCK_SIZES_ALL]
Definition encoder.h:1131
FrameProbInfo::warped_probs
int warped_probs[FRAME_UPDATE_TYPES]
Definition encoder.h:1138
FrameProbInfo::tx_type_probs
int tx_type_probs[FRAME_UPDATE_TYPES][TX_SIZES_ALL][TX_TYPES]
Definition encoder.h:1146
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:2077
GlobalMotionInfo::reference_frames
FrameDistPair reference_frames[2][REF_FRAMES - 1]
Definition encoder.h:2103
GlobalMotionInfo::search_done
bool search_done
Definition encoder.h:2081
GlobalMotionInfo::segment_map_h
int segment_map_h
Definition encoder.h:2110
GlobalMotionInfo::num_ref_frames
int num_ref_frames[2]
Definition encoder.h:2095
GlobalMotionInfo::ref_buf
YV12_BUFFER_CONFIG * ref_buf[REF_FRAMES]
Definition encoder.h:2088
GlobalMotionInfo::segment_map_w
int segment_map_w
Definition encoder.h:2109
InterpSearchFlags
Flags related to interpolation filter search.
Definition encoder.h:2117
InterpSearchFlags::default_interp_skip_flags
int default_interp_skip_flags
Definition encoder.h:2122
InterpSearchFlags::interp_filter_search_mask
uint16_t interp_filter_search_mask
Definition encoder.h:2126
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:1914
MBMIExtFrameBufferInfo::alloc_size
int alloc_size
Definition encoder.h:1923
MBMIExtFrameBufferInfo::stride
int stride
Definition encoder.h:1927
MBMIExtFrameBufferInfo::frame_base
MB_MODE_INFO_EXT_FRAME * frame_base
Definition encoder.h:1919
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
MotionVectorSearchParams
Parameters for motion vector search process.
Definition encoder.h:2132
MotionVectorSearchParams::max_mv_magnitude
int max_mv_magnitude
Definition encoder.h:2138
MotionVectorSearchParams::find_fractional_mv_step
fractional_mv_step_fp * find_fractional_mv_step
Definition encoder.h:2152
MotionVectorSearchParams::mv_step_param
int mv_step_param
Definition encoder.h:2143
MotionVectorSearchParams::search_site_cfg
search_site_config search_site_cfg[SS_CFG_TOTAL][NUM_DISTINCT_SEARCH_METHODS]
Definition encoder.h:2159
MultiThreadInfo
Encoder parameters related to multi-threading.
Definition encoder.h:1759
MultiThreadInfo::restore_state_buf
RestoreStateBuffers restore_state_buf
Definition encoder.h:1846
MultiThreadInfo::cdef_worker
AV1CdefWorkerData * cdef_worker
Definition encoder.h:1841
MultiThreadInfo::lr_row_sync
AV1LrSync lr_row_sync
Definition encoder.h:1816
MultiThreadInfo::tile_thr_data
struct EncWorkerData * tile_thr_data
Definition encoder.h:1779
MultiThreadInfo::tpl_row_mt
AV1TplRowMultiThreadInfo tpl_row_mt
Definition encoder.h:1806
MultiThreadInfo::pack_bs_sync
AV1EncPackBSSync pack_bs_sync
Definition encoder.h:1821
MultiThreadInfo::enc_row_mt
AV1EncRowMultiThreadInfo enc_row_mt
Definition encoder.h:1795
MultiThreadInfo::lf_row_sync
AV1LfSync lf_row_sync
Definition encoder.h:1811
MultiThreadInfo::cdef_sync
AV1CdefSync cdef_sync
Definition encoder.h:1836
MultiThreadInfo::num_mod_workers
int num_mod_workers[NUM_MT_MODULES]
Definition encoder.h:1768
MultiThreadInfo::intra_mt
AV1EncAllIntraMultiThreadInfo intra_mt
Definition encoder.h:1801
MultiThreadInfo::num_workers
int num_workers
Definition encoder.h:1763
MultiThreadInfo::pipeline_lpf_mt_with_enc
int pipeline_lpf_mt_with_enc
Definition encoder.h:1852
MultiThreadInfo::workers
AVxWorker * workers
Definition encoder.h:1773
MultiThreadInfo::pack_bs_mt_enabled
bool pack_bs_mt_enabled
Definition encoder.h:1790
MultiThreadInfo::row_mt_enabled
bool row_mt_enabled
Definition encoder.h:1785
MultiThreadInfo::tf_sync
AV1TemporalFilterSync tf_sync
Definition encoder.h:1831
MultiThreadInfo::gm_sync
AV1GlobalMotionSync gm_sync
Definition encoder.h:1826
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:1712
PrimaryMultiThreadInfo::tile_thr_data
struct EncWorkerData * tile_thr_data
Definition encoder.h:1732
PrimaryMultiThreadInfo::cdef_worker
AV1CdefWorkerData * cdef_worker
Definition encoder.h:1737
PrimaryMultiThreadInfo::num_workers
int num_workers
Definition encoder.h:1716
PrimaryMultiThreadInfo::prev_num_enc_workers
int prev_num_enc_workers
Definition encoder.h:1753
PrimaryMultiThreadInfo::workers
AVxWorker * workers
Definition encoder.h:1726
PrimaryMultiThreadInfo::p_workers
AVxWorker * p_workers[4]
Definition encoder.h:1743
PrimaryMultiThreadInfo::p_num_workers
int p_num_workers
Definition encoder.h:1748
PrimaryMultiThreadInfo::num_mod_workers
int num_mod_workers[NUM_MT_MODULES]
Definition encoder.h:1721
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::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:2191
RefFrameDistanceInfo::nearest_past_ref
int8_t nearest_past_ref
Definition encoder.h:2199
RefFrameDistanceInfo::ref_relative_dist
int ref_relative_dist[INTER_REFS_PER_FRAME]
Definition encoder.h:2195
RefFrameDistanceInfo::nearest_future_ref
int8_t nearest_future_ref
Definition encoder.h:2203
RefreshFrameInfo
Refresh frame flags for different type of frames.
Definition encoder.h:2170
RefreshFrameInfo::bwd_ref_frame
bool bwd_ref_frame
Definition encoder.h:2172
RefreshFrameInfo::golden_frame
bool golden_frame
Definition encoder.h:2171
RefreshFrameInfo::alt_ref_frame
bool alt_ref_frame
Definition encoder.h:2173
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:2183
ResizePendingParams::width
int width
Definition encoder.h:2184
ResizePendingParams::height
int height
Definition encoder.h:2185
RestUnitSearchInfo
Parameters related to restoration types.
Definition encoder.h:1673
RestUnitSearchInfo::best_rtype
RestorationType best_rtype[RESTORE_TYPES - 1]
Definition encoder.h:1688
RestUnitSearchInfo::wiener
WienerInfo wiener
Definition encoder.h:1677
RestUnitSearchInfo::sgrproj
SgrprojInfo sgrproj
Definition encoder.h:1682
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:1648
RestoreStateBuffers::rst_tmpbuf
int32_t * rst_tmpbuf
Definition encoder.h:1662
RestoreStateBuffers::rlbs
RestorationLineBuffers * rlbs
Definition encoder.h:1667
RestoreStateBuffers::cdef_colbuf
uint16_t * cdef_colbuf[3]
Definition encoder.h:1657
RestoreStateBuffers::cdef_srcbuf
uint16_t * cdef_srcbuf
Definition encoder.h:1652
SPEED_FEATURES
Top level speed vs quality trade off data struture.
Definition speed_features.h:2087
SPEED_FEATURES::mv_sf
MV_SPEED_FEATURES mv_sf
Definition speed_features.h:2116
SPEED_FEATURES::lpf_sf
LOOP_FILTER_SPEED_FEATURES lpf_sf
Definition speed_features.h:2151
SPEED_FEATURES::tx_sf
TX_SPEED_FEATURES tx_sf
Definition speed_features.h:2136
SPEED_FEATURES::rt_sf
REAL_TIME_SPEED_FEATURES rt_sf
Definition speed_features.h:2156
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:2427
TimeStamps::prev_ts_start
int64_t prev_ts_start
Definition encoder.h:2431
TimeStamps::first_ts_start
int64_t first_ts_start
Definition encoder.h:2439
TimeStamps::prev_ts_end
int64_t prev_ts_end
Definition encoder.h:2435
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:1376
VarBasedPartitionInfo::thresholds
int64_t thresholds[5]
Definition encoder.h:1385
VarBasedPartitionInfo::threshold_minmax
int64_t threshold_minmax
Definition encoder.h:1391
WienerInfo
Parameters related to Wiener Filter.
Definition blockd.h:494
WinnerModeParams
Parameters used for winner mode processing.
Definition encoder.h:2221
WinnerModeParams::use_transform_domain_distortion
unsigned int use_transform_domain_distortion[MODE_EVAL_TYPES]
Definition encoder.h:2243
WinnerModeParams::tx_size_search_methods
TX_SIZE_SEARCH_METHOD tx_size_search_methods[MODE_EVAL_TYPES]
Definition encoder.h:2235
WinnerModeParams::skip_txfm_level
unsigned int skip_txfm_level[MODE_EVAL_TYPES]
Definition encoder.h:2257
WinnerModeParams::coeff_opt_thresholds
unsigned int coeff_opt_thresholds[MODE_EVAL_TYPES][2]
Definition encoder.h:2229
WinnerModeParams::tx_domain_dist_threshold
unsigned int tx_domain_dist_threshold[MODE_EVAL_TYPES]
Definition encoder.h:2250
WinnerModeParams::predict_dc_level
unsigned int predict_dc_level[MODE_EVAL_TYPES]
Definition encoder.h:2264
inter_modes_info
Struct used to hold inter mode data for fast tx search.
Definition encoder.h:1281
inter_modes_info::rd_cost_arr
RD_STATS rd_cost_arr[MAX_INTER_MODES]
Definition encoder.h:1310
inter_modes_info::est_rd_arr
int64_t est_rd_arr[MAX_INTER_MODES]
Definition encoder.h:1302
inter_modes_info::sse_arr
int64_t sse_arr[MAX_INTER_MODES]
Definition encoder.h:1298
inter_modes_info::rd_cost_y_arr
RD_STATS rd_cost_y_arr[MAX_INTER_MODES]
Definition encoder.h:1314
inter_modes_info::rd_cost_uv_arr
RD_STATS rd_cost_uv_arr[MAX_INTER_MODES]
Definition encoder.h:1318
inter_modes_info::mbmi_arr
MB_MODE_INFO mbmi_arr[MAX_INTER_MODES]
Definition encoder.h:1290
inter_modes_info::rd_idx_pair_arr
RdIdxPair rd_idx_pair_arr[MAX_INTER_MODES]
Definition encoder.h:1306
inter_modes_info::mode_rate_arr
int mode_rate_arr[MAX_INTER_MODES]
Definition encoder.h:1294
inter_modes_info::num
int num
Definition encoder.h:1286
macroblock::mbmi_ext_frame
MB_MODE_INFO_EXT_FRAME * mbmi_ext_frame
Finalized mbmi_ext for the whole frame.
Definition block.h:921
macroblockd::block_ref_scale_factors
const struct scale_factors * block_ref_scale_factors[2]
Definition blockd.h:687