encoder.h
Go to the documentation of this file.
/*
* Copyright (c) 2016, Alliance for Open Media. All rights reserved.
*
* This source code is subject to the terms of the BSD 2 Clause License and
* the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
* was not distributed with this source code in the LICENSE file, you can
* obtain it at www.aomedia.org/license/software. If the Alliance for Open
* Media Patent License 1.0 was not distributed with this source code in the
* PATENTS file, you can obtain it at www.aomedia.org/license/patent.
*/
#ifndef AOM_AV1_ENCODER_ENCODER_H_
#define AOM_AV1_ENCODER_ENCODER_H_
#include <stdbool.h>
#include <stdio.h>
#include "config/aom_config.h"
#include "aom/aomcx.h"
#include "aom_util/aom_pthread.h"
#include "av1/common/alloccommon.h"
#include "av1/common/av1_common_int.h"
#include "av1/common/blockd.h"
#include "av1/common/entropymode.h"
#include "av1/common/enums.h"
#include "av1/common/reconintra.h"
#include "av1/common/resize.h"
#include "av1/common/thread_common.h"
#include "av1/common/timing.h"
#include "av1/encoder/aq_cyclicrefresh.h"
#include "av1/encoder/av1_ext_ratectrl.h"
#include "av1/encoder/av1_quantize.h"
#include "av1/encoder/block.h"
#include "av1/encoder/context_tree.h"
#include "av1/encoder/enc_enums.h"
#include "av1/encoder/encodemb.h"
#include "av1/encoder/external_partition.h"
#include "av1/encoder/firstpass.h"
#include "av1/encoder/global_motion.h"
#include "av1/encoder/level.h"
#include "av1/encoder/lookahead.h"
#include "av1/encoder/mcomp.h"
#include "av1/encoder/pickcdef.h"
#include "av1/encoder/ratectrl.h"
#include "av1/encoder/rd.h"
#include "av1/encoder/speed_features.h"
#include "av1/encoder/svc_layercontext.h"
#include "av1/encoder/temporal_filter.h"
#if CONFIG_THREE_PASS
#include "av1/encoder/thirdpass.h"
#endif
#include "av1/encoder/tokenize.h"
#include "av1/encoder/tpl_model.h"
#include "av1/encoder/av1_noise_estimate.h"
#include "av1/encoder/bitstream.h"
#if CONFIG_INTERNAL_STATS
#include "aom_dsp/ssim.h"
#endif
#include "aom_dsp/variance.h"
#if CONFIG_DENOISE
#include "aom_dsp/noise_model.h"
#endif
#if CONFIG_TUNE_VMAF
#include "av1/encoder/tune_vmaf.h"
#endif
#if CONFIG_AV1_TEMPORAL_DENOISING
#include "av1/encoder/av1_temporal_denoiser.h"
#endif
#if CONFIG_TUNE_BUTTERAUGLI
#include "av1/encoder/tune_butteraugli.h"
#endif
#include "aom/internal/aom_codec_internal.h"
#ifdef __cplusplus
extern "C" {
#endif
// TODO(yunqing, any): Added suppression tag to quiet Doxygen warnings. Need to
// adjust it while we work on documentation.
// Number of frames required to test for scene cut detection
#define SCENE_CUT_KEY_TEST_INTERVAL 16
// Lookahead index threshold to enable temporal filtering for second arf.
#define TF_LOOKAHEAD_IDX_THR 7
#define HDR_QP_LEVELS 10
#define CHROMA_CB_QP_SCALE 1.04
#define CHROMA_CR_QP_SCALE 1.04
#define CHROMA_QP_SCALE -0.46
#define CHROMA_QP_OFFSET 9.26
#define QP_SCALE_FACTOR 2.0
#define DISABLE_HDR_LUMA_DELTAQ 1
// Rational number with an int64 numerator
// This structure holds a fractional value
typedef struct aom_rational64 {
int64_t num; // fraction numerator
int den; // fraction denominator
} aom_rational64_t; // alias for struct aom_rational
enum {
FRAMEFLAGS_KEY = 1 << 0,
FRAMEFLAGS_GOLDEN = 1 << 1,
FRAMEFLAGS_BWDREF = 1 << 2,
// TODO(zoeliu): To determine whether a frame flag is needed for ALTREF2_FRAME
FRAMEFLAGS_ALTREF = 1 << 3,
FRAMEFLAGS_INTRAONLY = 1 << 4,
FRAMEFLAGS_SWITCH = 1 << 5,
FRAMEFLAGS_ERROR_RESILIENT = 1 << 6,
} UENUM1BYTE(FRAMETYPE_FLAGS);
#if CONFIG_FPMT_TEST
enum {
PARALLEL_ENCODE = 0,
PARALLEL_SIMULATION_ENCODE,
NUM_FPMT_TEST_ENCODES
} UENUM1BYTE(FPMT_TEST_ENC_CFG);
#endif // CONFIG_FPMT_TEST
// 0 level frames are sometimes used for rate control purposes, but for
// reference mapping purposes, the minimum level should be 1.
#define MIN_PYR_LEVEL 1
static inline int get_true_pyr_level(int frame_level, int frame_order,
int max_layer_depth) {
if (frame_order == 0) {
// Keyframe case
return MIN_PYR_LEVEL;
} else if (frame_level == MAX_ARF_LAYERS) {
// Leaves
return max_layer_depth;
} else if (frame_level == (MAX_ARF_LAYERS + 1)) {
// Altrefs
return MIN_PYR_LEVEL;
}
return AOMMAX(MIN_PYR_LEVEL, frame_level);
}
enum {
NO_AQ = 0,
VARIANCE_AQ = 1,
COMPLEXITY_AQ = 2,
CYCLIC_REFRESH_AQ = 3,
AQ_MODE_COUNT // This should always be the last member of the enum
} UENUM1BYTE(AQ_MODE);
enum {
NO_DELTA_Q = 0,
DELTA_Q_OBJECTIVE = 1, // Modulation to improve objective quality
DELTA_Q_PERCEPTUAL = 2, // Modulation to improve video perceptual quality
DELTA_Q_PERCEPTUAL_AI = 3, // Perceptual quality opt for all intra mode
DELTA_Q_USER_RATING_BASED = 4, // User rating based delta q mode
DELTA_Q_HDR = 5, // QP adjustment based on HDR block pixel average
DELTA_Q_VARIANCE_BOOST = 6, // Variance Boost style modulation
DELTA_Q_MODE_COUNT // This should always be the last member of the enum
} UENUM1BYTE(DELTAQ_MODE);
enum {
RESIZE_NONE = 0, // No frame resizing allowed.
RESIZE_FIXED = 1, // All frames are coded at the specified scale.
RESIZE_RANDOM = 2, // All frames are coded at a random scale.
RESIZE_DYNAMIC = 3, // Frames coded at lower scale based on rate control.
RESIZE_MODES
} UENUM1BYTE(RESIZE_MODE);
enum {
SS_CFG_SRC = 0,
SS_CFG_LOOKAHEAD = 1,
SS_CFG_FPF = 2,
SS_CFG_TOTAL = 3
} UENUM1BYTE(SS_CFG_OFFSET);
enum {
DISABLE_SCENECUT, // For LAP, lag_in_frames < 19
ENABLE_SCENECUT_MODE_1, // For LAP, lag_in_frames >=19 and < 33
ENABLE_SCENECUT_MODE_2 // For twopass and LAP - lag_in_frames >=33
} UENUM1BYTE(SCENECUT_MODE);
#define MAX_VBR_CORPUS_COMPLEXITY 10000
typedef enum {
MOD_FP, // First pass
MOD_TF, // Temporal filtering
MOD_TPL, // TPL
MOD_GME, // Global motion estimation
MOD_ENC, // Encode stage
MOD_LPF, // Deblocking loop filter
MOD_CDEF_SEARCH, // CDEF search
MOD_CDEF, // CDEF frame
MOD_LR, // Loop restoration filtering
MOD_PACK_BS, // Pack bitstream
MOD_FRAME_ENC, // Frame Parallel encode
MOD_AI, // All intra
NUM_MT_MODULES
} MULTI_THREADED_MODULES;
typedef enum {
COST_UPD_SB,
COST_UPD_SBROW,
COST_UPD_TILE,
COST_UPD_OFF,
NUM_COST_UPDATE_TYPES,
} COST_UPDATE_TYPE;
typedef enum {
LOOPFILTER_NONE = 0,
LOOPFILTER_ALL = 1,
LOOPFILTER_REFERENCE = 2,
LOOPFILTER_SELECTIVELY =
3,
} LOOPFILTER_CONTROL;
typedef enum {
SKIP_APPLY_RESTORATION = 1 << 0,
SKIP_APPLY_SUPERRES = 1 << 1,
SKIP_APPLY_CDEF = 1 << 2,
SKIP_APPLY_LOOPFILTER = 1 << 3,
} SKIP_APPLY_POSTPROC_FILTER;
typedef struct {
RESIZE_MODE resize_mode;
uint8_t resize_scale_denominator;
uint8_t resize_kf_scale_denominator;
} ResizeCfg;
typedef struct {
bool enable_rect_partitions;
bool enable_ab_partitions;
bool enable_1to4_partitions;
BLOCK_SIZE min_partition_size;
BLOCK_SIZE max_partition_size;
} PartitionCfg;
typedef struct {
bool enable_intra_edge_filter;
bool enable_filter_intra;
bool enable_smooth_intra;
bool enable_paeth_intra;
bool enable_cfl_intra;
bool enable_directional_intra;
bool enable_diagonal_intra;
bool enable_angle_delta;
bool auto_intra_tools_off;
} IntraModeCfg;
typedef struct {
bool enable_tx64;
bool enable_flip_idtx;
bool enable_rect_tx;
bool reduced_tx_type_set;
bool use_intra_dct_only;
bool use_inter_dct_only;
bool use_intra_default_tx_only;
bool enable_tx_size_search;
} TxfmSizeTypeCfg;
typedef struct {
bool enable_dist_wtd_comp;
bool enable_masked_comp;
bool enable_smooth_interintra;
bool enable_diff_wtd_comp;
bool enable_interinter_wedge;
bool enable_interintra_wedge;
} CompoundTypeCfg;
typedef struct {
int superres_qthresh;
int superres_kf_qthresh;
uint8_t superres_scale_denominator;
uint8_t superres_kf_scale_denominator;
aom_superres_mode superres_mode;
bool enable_superres;
} SuperResCfg;
typedef struct {
int key_freq_min;
int key_freq_max;
int enable_keyframe_filtering;
int sframe_dist;
int sframe_mode;
bool auto_key;
int fwd_kf_dist;
bool fwd_kf_enabled;
bool enable_sframe;
bool enable_intrabc;
} KeyFrameCfg;
typedef struct {
// BUFFERING PARAMETERS
int64_t starting_buffer_level_ms;
int64_t optimal_buffer_level_ms;
int64_t maximum_buffer_size_ms;
int64_t target_bandwidth;
unsigned int vbr_corpus_complexity_lap;
unsigned int max_intra_bitrate_pct;
unsigned int max_inter_bitrate_pct;
unsigned int gf_cbr_boost_pct;
unsigned int min_cr;
int drop_frames_water_mark;
int under_shoot_pct;
int over_shoot_pct;
int worst_allowed_q;
int best_allowed_q;
int cq_level;
enum aom_rc_mode mode;
int vbrbias;
int vbrmin_section;
int vbrmax_section;
int max_consec_drop_ms;
} RateControlCfg;
typedef struct {
// Indicates the number of frames lag before encoding is started.
int lag_in_frames;
// Indicates the minimum gf/arf interval to be used.
int min_gf_interval;
// Indicates the maximum gf/arf interval to be used.
int max_gf_interval;
// Indicates the minimum height for GF group pyramid structure to be used.
int gf_min_pyr_height;
// Indicates the maximum height for GF group pyramid structure to be used.
int gf_max_pyr_height;
// Indicates if automatic set and use of altref frames should be enabled.
bool enable_auto_arf;
// Indicates if automatic set and use of (b)ackward (r)ef (f)rames should be
// enabled.
bool enable_auto_brf;
} GFConfig;
typedef struct {
// Indicates the number of tile groups.
unsigned int num_tile_groups;
// Indicates the MTU size for a tile group. If mtu is non-zero,
// num_tile_groups is set to DEFAULT_MAX_NUM_TG.
unsigned int mtu;
// Indicates the number of tile columns in log2.
int tile_columns;
// Indicates the number of tile rows in log2.
int tile_rows;
// Indicates the number of widths in the tile_widths[] array.
int tile_width_count;
// Indicates the number of heights in the tile_heights[] array.
int tile_height_count;
// Indicates the tile widths, and may be empty.
int tile_widths[MAX_TILE_COLS];
// Indicates the tile heights, and may be empty.
int tile_heights[MAX_TILE_ROWS];
// Indicates if large scale tile coding should be used.
bool enable_large_scale_tile;
// Indicates if single tile decoding mode should be enabled.
bool enable_single_tile_decoding;
// Indicates if EXT_TILE_DEBUG should be enabled.
bool enable_ext_tile_debug;
} TileConfig;
typedef struct {
// Indicates the width of the input frame.
int width;
// Indicates the height of the input frame.
int height;
// If forced_max_frame_width is non-zero then it is used to force the maximum
// frame width written in write_sequence_header().
int forced_max_frame_width;
// If forced_max_frame_width is non-zero then it is used to force the maximum
// frame height written in write_sequence_header().
int forced_max_frame_height;
// Indicates the frame width after applying both super-resolution and resize
// to the coded frame.
int render_width;
// Indicates the frame height after applying both super-resolution and resize
// to the coded frame.
int render_height;
} FrameDimensionCfg;
typedef struct {
// Indicates if warped motion should be enabled.
bool enable_warped_motion;
// Indicates if warped motion should be evaluated or not.
bool allow_warped_motion;
// Indicates if OBMC motion should be enabled.
bool enable_obmc;
} MotionModeCfg;
typedef struct {
// Timing info for each frame.
aom_timing_info_t timing_info;
// Indicates the number of time units of a decoding clock.
uint32_t num_units_in_decoding_tick;
// Indicates if decoder model information is present in the coded sequence
// header.
bool decoder_model_info_present_flag;
// Indicates if display model information is present in the coded sequence
// header.
bool display_model_info_present_flag;
// Indicates if timing info for each frame is present.
bool timing_info_present;
} DecoderModelCfg;
typedef struct {
// Indicates the update frequency for coeff costs.
COST_UPDATE_TYPE coeff;
// Indicates the update frequency for mode costs.
COST_UPDATE_TYPE mode;
// Indicates the update frequency for mv costs.
COST_UPDATE_TYPE mv;
// Indicates the update frequency for dv costs.
COST_UPDATE_TYPE dv;
} CostUpdateFreq;
typedef struct {
// Indicates the maximum number of reference frames allowed per frame.
unsigned int max_reference_frames;
// Indicates if the reduced set of references should be enabled.
bool enable_reduced_reference_set;
// Indicates if one-sided compound should be enabled.
bool enable_onesided_comp;
} RefFrameCfg;
typedef struct {
// Indicates the color space that should be used.
aom_color_primaries_t color_primaries;
// Indicates the characteristics of transfer function to be used.
aom_transfer_characteristics_t transfer_characteristics;
// Indicates the matrix coefficients to be used for the transfer function.
aom_matrix_coefficients_t matrix_coefficients;
// Indicates the chroma 4:2:0 sample position info.
aom_chroma_sample_position_t chroma_sample_position;
// Indicates if a limited color range or full color range should be used.
aom_color_range_t color_range;
} ColorCfg;
typedef struct {
// Indicates if extreme motion vector unit test should be enabled or not.
unsigned int motion_vector_unit_test;
// Indicates if superblock multipass unit test should be enabled or not.
unsigned int sb_multipass_unit_test;
} UnitTestCfg;
typedef struct {
// Indicates the file path to the VMAF model.
const char *vmaf_model_path;
// Indicates the path to the film grain parameters.
const char *film_grain_table_filename;
// Indicates the visual tuning metric.
aom_tune_metric tuning;
// Indicates if the current content is screen or default type.
aom_tune_content content;
// Indicates the film grain parameters.
int film_grain_test_vector;
// Indicates the in-block distortion metric to use.
aom_dist_metric dist_metric;
} TuneCfg;
typedef struct {
// Indicates the framerate of the input video.
double init_framerate;
// Indicates the actual bit-depth of the input source.
unsigned int input_bit_depth;
// Indicates the maximum number of frames to be encoded.
unsigned int limit;
// Indicates the chrome subsampling x value.
unsigned int chroma_subsampling_x;
// Indicates the chrome subsampling y value.
unsigned int chroma_subsampling_y;
} InputCfg;
typedef struct {
// Controls how the encoder applies fixed QP offsets.
// If the value is 0, QP offsets are chosen adaptively.
// If the value is 1, fixed QP offsets are picked automatically from cq_level.
// If the value is 2, no QP offsets will be applied.
int use_fixed_qp_offsets;
// Indicates the minimum flatness of the quantization matrix.
int qm_minlevel;
// Indicates the maximum flatness of the quantization matrix.
int qm_maxlevel;
// Indicates if adaptive quantize_b should be enabled.
int quant_b_adapt;
// Indicates the Adaptive Quantization mode to be used.
AQ_MODE aq_mode;
// Indicates the delta q mode to be used.
DELTAQ_MODE deltaq_mode;
// Indicates the delta q mode strength.
unsigned int deltaq_strength;
// Indicates if delta quantization should be enabled in chroma planes.
bool enable_chroma_deltaq;
// Indicates if delta quantization should be enabled for hdr video
bool enable_hdr_deltaq;
// Indicates if encoding with quantization matrices should be enabled.
bool using_qm;
} QuantizationCfg;
typedef struct {
int sharpness;
bool enable_adaptive_sharpness;
int disable_trellis_quant;
int arnr_max_frames;
int arnr_strength;
uint8_t cdf_update_mode;
bool enable_tpl_model;
bool enable_overlay;
LOOPFILTER_CONTROL loopfilter_control;
bool skip_postproc_filtering;
aom_screen_detection_mode screen_detection_mode;
} AlgoCfg;
typedef struct {
// Indicates the codec bit-depth.
aom_bit_depth_t bit_depth;
// Indicates the superblock size that should be used by the encoder.
aom_superblock_size_t superblock_size;
// Indicates if loopfilter modulation should be enabled.
bool enable_deltalf_mode;
// Indicates how CDEF should be applied.
CDEF_CONTROL cdef_control;
// Indicates if loop restoration filter should be enabled.
bool enable_restoration;
// When enabled, video mode should be used even for single frame input.
bool force_video_mode;
// Indicates if the error resiliency features should be enabled.
bool error_resilient_mode;
// Indicates if frame parallel decoding feature should be enabled.
bool frame_parallel_decoding_mode;
// Indicates if the input should be encoded as monochrome.
bool enable_monochrome;
// When enabled, the encoder will use a full header even for still pictures.
// When disabled, a reduced header is used for still pictures.
bool full_still_picture_hdr;
// Indicates if dual interpolation filters should be enabled.
bool enable_dual_filter;
// Indicates if frame order hint should be enabled or not.
bool enable_order_hint;
// Indicates if ref_frame_mvs should be enabled at the sequence level.
bool ref_frame_mvs_present;
// Indicates if ref_frame_mvs should be enabled at the frame level.
bool enable_ref_frame_mvs;
// Indicates if interintra compound mode is enabled.
bool enable_interintra_comp;
// Indicates if global motion should be enabled.
bool enable_global_motion;
// Indicates if palette should be enabled.
bool enable_palette;
} ToolCfg;
typedef struct AV1EncoderConfig {
// Configuration related to the input video.
InputCfg input_cfg;
// Configuration related to frame-dimensions.
FrameDimensionCfg frm_dim_cfg;
AlgoCfg algo_cfg;
KeyFrameCfg kf_cfg;
RateControlCfg rc_cfg;
// Configuration related to Quantization.
QuantizationCfg q_cfg;
// Internal frame size scaling.
ResizeCfg resize_cfg;
// Frame Super-Resolution size scaling.
SuperResCfg superres_cfg;
aom_fixed_buf_t twopass_stats_in;
// Configuration related to encoder toolsets.
ToolCfg tool_cfg;
// Configuration related to Group of frames.
GFConfig gf_cfg;
// Tile related configuration parameters.
TileConfig tile_cfg;
// Configuration related to Tune.
TuneCfg tune_cfg;
// Configuration related to color.
ColorCfg color_cfg;
// Configuration related to decoder model.
DecoderModelCfg dec_model_cfg;
// Configuration related to reference frames.
RefFrameCfg ref_frm_cfg;
// Configuration related to unit tests.
UnitTestCfg unit_test_cfg;
// Flags related to motion mode.
MotionModeCfg motion_mode_cfg;
// Flags related to intra mode search.
IntraModeCfg intra_mode_cfg;
// Flags related to transform size/type.
TxfmSizeTypeCfg txfm_cfg;
// Flags related to compound type.
CompoundTypeCfg comp_type_cfg;
// Partition related information.
PartitionCfg part_cfg;
// Configuration related to frequency of cost update.
CostUpdateFreq cost_upd_freq;
#if CONFIG_DENOISE
// Indicates the noise level.
float noise_level;
// Indicates the the denoisers block size.
int noise_block_size;
// Indicates whether to apply denoising to the frame to be encoded
int enable_dnl_denoising;
#endif
#if CONFIG_AV1_TEMPORAL_DENOISING
// Noise sensitivity.
int noise_sensitivity;
#endif
// Bit mask to specify which tier each of the 32 possible operating points
// conforms to.
unsigned int tier_mask;
// Indicates the number of pixels off the edge of a reference frame we're
// allowed to go when forming an inter prediction.
int border_in_pixels;
// Indicates the maximum number of threads that may be used by the encoder.
int max_threads;
// Indicates the speed preset to be used.
int speed;
// Enable the low complexity decode mode.
unsigned int enable_low_complexity_decode;
// Indicates the target sequence level index for each operating point(OP).
AV1_LEVEL target_seq_level_idx[MAX_NUM_OPERATING_POINTS];
// Indicates the bitstream profile to be used.
BITSTREAM_PROFILE profile;
enum aom_enc_pass pass;
// Total number of encoding passes.
int passes;
// the name of the second pass output file when passes > 2
const char *two_pass_output;
// the name of the second pass log file when passes > 2
const char *second_pass_log;
// Indicates if the encoding is GOOD or REALTIME.
MODE mode;
// Indicates if row-based multi-threading should be enabled or not.
bool row_mt;
// Indicates if frame parallel multi-threading should be enabled or not.
bool fp_mt;
// Indicates if 16bit frame buffers are to be used i.e., the content is >
// 8-bit.
bool use_highbitdepth;
// Indicates the bitstream syntax mode. 0 indicates bitstream is saved as
// Section 5 bitstream, while 1 indicates the bitstream is saved in Annex - B
// format.
bool save_as_annexb;
// The path for partition stats reading and writing, used in the experiment
// CONFIG_PARTITION_SEARCH_ORDER.
const char *partition_info_path;
// The flag that indicates whether we use an external rate distribution to
// guide adaptive quantization. It requires --deltaq-mode=3. The rate
// distribution map file name is stored in |rate_distribution_info|.
unsigned int enable_rate_guide_deltaq;
// The input file of rate distribution information used in all intra mode
// to determine delta quantization.
const char *rate_distribution_info;
// Exit the encoder when it fails to encode to a given level.
int strict_level_conformance;
// Max depth for the GOP after a key frame
int kf_max_pyr_height;
// A flag to control if we enable the superblock qp sweep for a given lambda
int sb_qp_sweep;
} AV1EncoderConfig;
static inline int is_lossless_requested(const RateControlCfg *const rc_cfg) {
return rc_cfg->best_allowed_q == 0 && rc_cfg->worst_allowed_q == 0;
}
typedef struct {
int obmc_probs[FRAME_UPDATE_TYPES][BLOCK_SIZES_ALL];
int warped_probs[FRAME_UPDATE_TYPES];
int tx_type_probs[FRAME_UPDATE_TYPES][TX_SIZES_ALL][TX_TYPES];
int switchable_interp_probs[FRAME_UPDATE_TYPES][SWITCHABLE_FILTER_CONTEXTS]
[SWITCHABLE_FILTERS];
} FrameProbInfo;
typedef struct FRAME_COUNTS {
// Note: This structure should only contain 'unsigned int' fields, or
// aggregates built solely from 'unsigned int' fields/elements
#if CONFIG_ENTROPY_STATS
unsigned int kf_y_mode[KF_MODE_CONTEXTS][KF_MODE_CONTEXTS][INTRA_MODES];
unsigned int angle_delta[DIRECTIONAL_MODES][2 * MAX_ANGLE_DELTA + 1];
unsigned int y_mode[BLOCK_SIZE_GROUPS][INTRA_MODES];
unsigned int uv_mode[CFL_ALLOWED_TYPES][INTRA_MODES][UV_INTRA_MODES];
unsigned int cfl_sign[CFL_JOINT_SIGNS];
unsigned int cfl_alpha[CFL_ALPHA_CONTEXTS][CFL_ALPHABET_SIZE];
unsigned int palette_y_mode[PALATTE_BSIZE_CTXS][PALETTE_Y_MODE_CONTEXTS][2];
unsigned int palette_uv_mode[PALETTE_UV_MODE_CONTEXTS][2];
unsigned int palette_y_size[PALATTE_BSIZE_CTXS][PALETTE_SIZES];
unsigned int palette_uv_size[PALATTE_BSIZE_CTXS][PALETTE_SIZES];
unsigned int palette_y_color_index[PALETTE_SIZES]
[PALETTE_COLOR_INDEX_CONTEXTS]
[PALETTE_COLORS];
unsigned int palette_uv_color_index[PALETTE_SIZES]
[PALETTE_COLOR_INDEX_CONTEXTS]
[PALETTE_COLORS];
unsigned int partition[PARTITION_CONTEXTS][EXT_PARTITION_TYPES];
unsigned int txb_skip[TOKEN_CDF_Q_CTXS][TX_SIZES][TXB_SKIP_CONTEXTS][2];
unsigned int eob_extra[TOKEN_CDF_Q_CTXS][TX_SIZES][PLANE_TYPES]
[EOB_COEF_CONTEXTS][2];
unsigned int dc_sign[PLANE_TYPES][DC_SIGN_CONTEXTS][2];
unsigned int coeff_lps[TX_SIZES][PLANE_TYPES][BR_CDF_SIZE - 1][LEVEL_CONTEXTS]
[2];
unsigned int eob_flag[TX_SIZES][PLANE_TYPES][EOB_COEF_CONTEXTS][2];
unsigned int eob_multi16[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][5];
unsigned int eob_multi32[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][6];
unsigned int eob_multi64[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][7];
unsigned int eob_multi128[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][8];
unsigned int eob_multi256[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][9];
unsigned int eob_multi512[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][10];
unsigned int eob_multi1024[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][11];
unsigned int coeff_lps_multi[TOKEN_CDF_Q_CTXS][TX_SIZES][PLANE_TYPES]
[LEVEL_CONTEXTS][BR_CDF_SIZE];
unsigned int coeff_base_multi[TOKEN_CDF_Q_CTXS][TX_SIZES][PLANE_TYPES]
[SIG_COEF_CONTEXTS][NUM_BASE_LEVELS + 2];
unsigned int coeff_base_eob_multi[TOKEN_CDF_Q_CTXS][TX_SIZES][PLANE_TYPES]
[SIG_COEF_CONTEXTS_EOB][NUM_BASE_LEVELS + 1];
unsigned int newmv_mode[NEWMV_MODE_CONTEXTS][2];
unsigned int zeromv_mode[GLOBALMV_MODE_CONTEXTS][2];
unsigned int refmv_mode[REFMV_MODE_CONTEXTS][2];
unsigned int drl_mode[DRL_MODE_CONTEXTS][2];
unsigned int inter_compound_mode[INTER_MODE_CONTEXTS][INTER_COMPOUND_MODES];
unsigned int wedge_idx[BLOCK_SIZES_ALL][16];
unsigned int interintra[BLOCK_SIZE_GROUPS][2];
unsigned int interintra_mode[BLOCK_SIZE_GROUPS][INTERINTRA_MODES];
unsigned int wedge_interintra[BLOCK_SIZES_ALL][2];
unsigned int compound_type[BLOCK_SIZES_ALL][MASKED_COMPOUND_TYPES];
unsigned int motion_mode[BLOCK_SIZES_ALL][MOTION_MODES];
unsigned int obmc[BLOCK_SIZES_ALL][2];
unsigned int intra_inter[INTRA_INTER_CONTEXTS][2];
unsigned int comp_inter[COMP_INTER_CONTEXTS][2];
unsigned int comp_ref_type[COMP_REF_TYPE_CONTEXTS][2];
unsigned int uni_comp_ref[UNI_COMP_REF_CONTEXTS][UNIDIR_COMP_REFS - 1][2];
unsigned int single_ref[REF_CONTEXTS][SINGLE_REFS - 1][2];
unsigned int comp_ref[REF_CONTEXTS][FWD_REFS - 1][2];
unsigned int comp_bwdref[REF_CONTEXTS][BWD_REFS - 1][2];
unsigned int intrabc[2];
unsigned int txfm_partition[TXFM_PARTITION_CONTEXTS][2];
unsigned int intra_tx_size[MAX_TX_CATS][TX_SIZE_CONTEXTS][MAX_TX_DEPTH + 1];
unsigned int skip_mode[SKIP_MODE_CONTEXTS][2];
unsigned int skip_txfm[SKIP_CONTEXTS][2];
unsigned int compound_index[COMP_INDEX_CONTEXTS][2];
unsigned int comp_group_idx[COMP_GROUP_IDX_CONTEXTS][2];
unsigned int delta_q[DELTA_Q_PROBS][2];
unsigned int delta_lf_multi[FRAME_LF_COUNT][DELTA_LF_PROBS][2];
unsigned int delta_lf[DELTA_LF_PROBS][2];
unsigned int inter_ext_tx[EXT_TX_SETS_INTER][EXT_TX_SIZES][TX_TYPES];
unsigned int intra_ext_tx[EXT_TX_SETS_INTRA][EXT_TX_SIZES][INTRA_MODES]
[TX_TYPES];
unsigned int filter_intra_mode[FILTER_INTRA_MODES];
unsigned int filter_intra[BLOCK_SIZES_ALL][2];
unsigned int switchable_restore[RESTORE_SWITCHABLE_TYPES];
unsigned int wiener_restore[2];
unsigned int sgrproj_restore[2];
#endif // CONFIG_ENTROPY_STATS
unsigned int switchable_interp[SWITCHABLE_FILTER_CONTEXTS]
[SWITCHABLE_FILTERS];
} FRAME_COUNTS;
#define INTER_MODE_RD_DATA_OVERALL_SIZE 6400
typedef struct {
int ready;
double a;
double b;
double dist_mean;
double ld_mean;
double sse_mean;
double sse_sse_mean;
double sse_ld_mean;
int num;
double dist_sum;
double ld_sum;
double sse_sum;
double sse_sse_sum;
double sse_ld_sum;
} InterModeRdModel;
typedef struct {
int idx;
int64_t rd;
} RdIdxPair;
// TODO(angiebird): This is an estimated size. We still need to figure what is
// the maximum number of modes.
#define MAX_INTER_MODES 1024
// TODO(any): rename this struct to something else. There is already another
// struct called inter_mode_info, which makes this terribly confusing.
typedef struct inter_modes_info {
int num;
MB_MODE_INFO mbmi_arr[MAX_INTER_MODES];
int mode_rate_arr[MAX_INTER_MODES];
int64_t sse_arr[MAX_INTER_MODES];
int64_t est_rd_arr[MAX_INTER_MODES];
RdIdxPair rd_idx_pair_arr[MAX_INTER_MODES];
RD_STATS rd_cost_arr[MAX_INTER_MODES];
RD_STATS rd_cost_y_arr[MAX_INTER_MODES];
RD_STATS rd_cost_uv_arr[MAX_INTER_MODES];
} InterModesInfo;
typedef struct {
// TODO(kyslov): consider changing to 64bit
// This struct is used for computing variance in choose_partitioning(), where
// the max number of samples within a superblock is 32x32 (with 4x4 avg).
// With 8bit bitdepth, uint32_t is enough for sum_square_error (2^8 * 2^8 * 32
// * 32 = 2^26). For high bitdepth we need to consider changing this to 64 bit
uint32_t sum_square_error;
int32_t sum_error;
int log2_count;
int variance;
} VPartVar;
typedef struct {
VPartVar none;
VPartVar horz[2];
VPartVar vert[2];
} VPVariance;
typedef struct {
VPVariance part_variances;
VPartVar split[4];
} VP4x4;
typedef struct {
VPVariance part_variances;
VP4x4 split[4];
} VP8x8;
typedef struct {
VPVariance part_variances;
VP8x8 split[4];
} VP16x16;
typedef struct {
VPVariance part_variances;
VP16x16 split[4];
} VP32x32;
typedef struct {
VPVariance part_variances;
VP32x32 split[4];
} VP64x64;
typedef struct {
VPVariance part_variances;
VP64x64 *split;
} VP128x128;
typedef struct {
int64_t thresholds[5];
int64_t threshold_minmax;
} VarBasedPartitionInfo;
typedef struct {
#if CONFIG_MULTITHREAD
pthread_mutex_t *mutex_;
pthread_cond_t *cond_;
#endif // CONFIG_MULTITHREAD
int *num_finished_cols;
int sync_range;
int intrabc_extra_top_right_sb_delay;
int rows;
int next_mi_row;
int num_threads_working;
} AV1EncRowMultiThreadSync;
// TODO(jingning) All spatially adaptive variables should go to TileDataEnc.
typedef struct TileDataEnc {
TileInfo tile_info;
DECLARE_ALIGNED(16, FRAME_CONTEXT, tctx);
FRAME_CONTEXT *row_ctx;
uint64_t abs_sum_level;
uint8_t allow_update_cdf;
InterModeRdModel inter_mode_rd_models[BLOCK_SIZES_ALL];
AV1EncRowMultiThreadSync row_mt_sync;
MV firstpass_top_mv;
} TileDataEnc;
typedef struct RD_COUNTS {
int compound_ref_used_flag;
int skip_mode_used_flag;
int tx_type_used[TX_SIZES_ALL][TX_TYPES];
int obmc_used[BLOCK_SIZES_ALL][2];
int warped_used[2];
int newmv_or_intra_blocks;
uint64_t seg_tmp_pred_cost[2];
} RD_COUNTS;
typedef struct ThreadData {
MACROBLOCK mb;
MvCosts *mv_costs_alloc;
IntraBCMVCosts *dv_costs_alloc;
RD_COUNTS rd_counts;
FRAME_COUNTS *counts;
PC_TREE_SHARED_BUFFERS shared_coeff_buf;
SIMPLE_MOTION_DATA_TREE *sms_tree;
SIMPLE_MOTION_DATA_TREE *sms_root;
// buffers are AOM_BUFFER_SIZE_FOR_BLOCK_HASH elements long
uint32_t *hash_value_buffer[2];
OBMCBuffer obmc_buffer;
PALETTE_BUFFER *palette_buffer;
CompoundTypeRdBuffers comp_rd_buffer;
CONV_BUF_TYPE *tmp_conv_dst;
uint64_t abs_sum_level;
uint8_t *tmp_pred_bufs[2];
uint8_t *upsample_pred;
uint8_t *wiener_tmp_pred_buf;
int intrabc_used;
int deltaq_used;
int coefficient_size;
int max_mv_magnitude;
int interp_filter_selected[SWITCHABLE];
FRAME_CONTEXT *tctx;
VP64x64 *vt64x64;
int32_t num_64x64_blocks;
PICK_MODE_CONTEXT *firstpass_ctx;
TemporalFilterData tf_data;
TplBuffers tpl_tmp_buffers;
TplTxfmStats tpl_txfm_stats;
GlobalMotionData gm_data;
// Pointer to the array of structures to store gradient information of each
// pixel in a superblock. The buffer constitutes of MAX_SB_SQUARE pixel level
// structures for each of the plane types (PLANE_TYPE_Y and PLANE_TYPE_UV).
PixelLevelGradientInfo *pixel_gradient_info;
// Pointer to the array of structures to store source variance information of
// each 4x4 sub-block in a superblock. Block4x4VarInfo structure is used to
// store source variance and log of source variance of each 4x4 sub-block
// for subsequent retrieval.
Block4x4VarInfo *src_var_info_of_4x4_sub_blocks;
// Pointer to pc tree root.
PC_TREE *pc_root;
} ThreadData;
struct EncWorkerData;
typedef struct {
int allocated_tile_rows;
int allocated_tile_cols;
int allocated_rows;
int allocated_cols;
int thread_id_to_tile_id[MAX_NUM_THREADS];
int *num_tile_cols_done;
int allocated_sb_rows;
bool row_mt_exit;
bool firstpass_mt_exit;
bool mb_wiener_mt_exit;
#if CONFIG_MULTITHREAD
pthread_mutex_t *mutex_;
pthread_cond_t *cond_;
#endif
void (*sync_read_ptr)(AV1EncRowMultiThreadSync *const, int, int);
void (*sync_write_ptr)(AV1EncRowMultiThreadSync *const, int, int, int);
} AV1EncRowMultiThreadInfo;
typedef struct {
#if CONFIG_MULTITHREAD
pthread_mutex_t *mutex_;
pthread_cond_t *cond_;
#endif
void (*intra_sync_read_ptr)(AV1EncRowMultiThreadSync *const, int, int);
void (*intra_sync_write_ptr)(AV1EncRowMultiThreadSync *const, int, int, int);
} AV1EncAllIntraMultiThreadInfo;
#define NUM_RECODES_PER_FRAME 10
#define MAX_PARALLEL_FRAMES 4
typedef struct RestoreStateBuffers {
uint16_t *cdef_srcbuf;
uint16_t *cdef_colbuf[MAX_MB_PLANE];
int32_t *rst_tmpbuf;
RestorationLineBuffers *rlbs;
} RestoreStateBuffers;
typedef struct {
WienerInfo wiener;
SgrprojInfo sgrproj;
RestorationType best_rtype[RESTORE_TYPES - 1];
} RestUnitSearchInfo;
typedef struct {
RestUnitSearchInfo *rusi[MAX_MB_PLANE];
int16_t *dgd_avg;
} AV1LrPickStruct;
typedef struct PrimaryMultiThreadInfo {
int num_workers;
int num_mod_workers[NUM_MT_MODULES];
AVxWorker *workers;
struct EncWorkerData *tile_thr_data;
AV1CdefWorkerData *cdef_worker;
AVxWorker *p_workers[MAX_PARALLEL_FRAMES];
int p_num_workers;
int prev_num_enc_workers;
} PrimaryMultiThreadInfo;
typedef struct MultiThreadInfo {
int num_workers;
int num_mod_workers[NUM_MT_MODULES];
AVxWorker *workers;
struct EncWorkerData *tile_thr_data;
bool row_mt_enabled;
bool pack_bs_mt_enabled;
AV1EncRowMultiThreadInfo enc_row_mt;
AV1EncAllIntraMultiThreadInfo intra_mt;
AV1TplRowMultiThreadInfo tpl_row_mt;
AV1LfSync lf_row_sync;
AV1LrSync lr_row_sync;
AV1EncPackBSSync pack_bs_sync;
AV1GlobalMotionSync gm_sync;
AV1TemporalFilterSync tf_sync;
AV1CdefSync cdef_sync;
AV1CdefWorkerData *cdef_worker;
RestoreStateBuffers restore_state_buf;
int pipeline_lpf_mt_with_enc;
} MultiThreadInfo;
typedef struct ActiveMap {
int enabled;
int update;
unsigned char *map;
} ActiveMap;
typedef struct {
double cs_rate_array[32];
int rate_index;
int rate_size;
} ForceIntegerMVInfo;
#if CONFIG_INTERNAL_STATS
// types of stats
enum {
STAT_Y,
STAT_U,
STAT_V,
STAT_ALL,
NUM_STAT_TYPES // This should always be the last member of the enum
} UENUM1BYTE(StatType);
typedef struct IMAGE_STAT {
double stat[NUM_STAT_TYPES];
double worst;
} ImageStat;
#endif // CONFIG_INTERNAL_STATS
typedef struct {
int ref_count;
YV12_BUFFER_CONFIG buf;
} EncRefCntBuffer;
typedef struct {
MB_MODE_INFO_EXT_FRAME *frame_base;
int alloc_size;
int stride;
} MBMIExtFrameBufferInfo;
#if CONFIG_COLLECT_PARTITION_STATS
typedef struct FramePartitionTimingStats {
int partition_decisions[6][EXT_PARTITION_TYPES];
int partition_attempts[6][EXT_PARTITION_TYPES];
int64_t partition_times[6][EXT_PARTITION_TYPES];
int partition_redo;
} FramePartitionTimingStats;
#endif // CONFIG_COLLECT_PARTITION_STATS
#if CONFIG_COLLECT_COMPONENT_TIMING
#include "aom_ports/aom_timer.h"
// Adjust the following to add new components.
enum {
av1_encode_strategy_time,
av1_get_one_pass_rt_params_time,
av1_get_second_pass_params_time,
denoise_and_encode_time,
apply_filtering_time,
av1_tpl_setup_stats_time,
encode_frame_to_data_rate_time,
encode_with_or_without_recode_time,
loop_filter_time,
cdef_time,
loop_restoration_time,
av1_pack_bitstream_final_time,
av1_encode_frame_time,
av1_compute_global_motion_time,
av1_setup_motion_field_time,
encode_sb_row_time,
rd_pick_partition_time,
rd_use_partition_time,
choose_var_based_partitioning_time,
av1_prune_partitions_time,
none_partition_search_time,
split_partition_search_time,
rectangular_partition_search_time,
ab_partitions_search_time,
rd_pick_4partition_time,
encode_sb_time,
rd_pick_sb_modes_time,
av1_rd_pick_intra_mode_sb_time,
av1_rd_pick_inter_mode_sb_time,
set_params_rd_pick_inter_mode_time,
skip_inter_mode_time,
handle_inter_mode_time,
evaluate_motion_mode_for_winner_candidates_time,
do_tx_search_time,
handle_intra_mode_time,
refine_winner_mode_tx_time,
av1_search_palette_mode_time,
handle_newmv_time,
compound_type_rd_time,
interpolation_filter_search_time,
motion_mode_rd_time,
nonrd_use_partition_time,
pick_sb_modes_nonrd_time,
hybrid_intra_mode_search_time,
nonrd_pick_inter_mode_sb_time,
encode_b_nonrd_time,
kTimingComponents,
} UENUM1BYTE(TIMING_COMPONENT);
static inline char const *get_component_name(int index) {
switch (index) {
case av1_encode_strategy_time: return "av1_encode_strategy_time";
case av1_get_one_pass_rt_params_time:
return "av1_get_one_pass_rt_params_time";
case av1_get_second_pass_params_time:
return "av1_get_second_pass_params_time";
case denoise_and_encode_time: return "denoise_and_encode_time";
case apply_filtering_time: return "apply_filtering_time";
case av1_tpl_setup_stats_time: return "av1_tpl_setup_stats_time";
case encode_frame_to_data_rate_time:
return "encode_frame_to_data_rate_time";
case encode_with_or_without_recode_time:
return "encode_with_or_without_recode_time";
case loop_filter_time: return "loop_filter_time";
case cdef_time: return "cdef_time";
case loop_restoration_time: return "loop_restoration_time";
case av1_pack_bitstream_final_time: return "av1_pack_bitstream_final_time";
case av1_encode_frame_time: return "av1_encode_frame_time";
case av1_compute_global_motion_time:
return "av1_compute_global_motion_time";
case av1_setup_motion_field_time: return "av1_setup_motion_field_time";
case encode_sb_row_time: return "encode_sb_row_time";
case rd_pick_partition_time: return "rd_pick_partition_time";
case rd_use_partition_time: return "rd_use_partition_time";
case choose_var_based_partitioning_time:
return "choose_var_based_partitioning_time";
case av1_prune_partitions_time: return "av1_prune_partitions_time";
case none_partition_search_time: return "none_partition_search_time";
case split_partition_search_time: return "split_partition_search_time";
case rectangular_partition_search_time:
return "rectangular_partition_search_time";
case ab_partitions_search_time: return "ab_partitions_search_time";
case rd_pick_4partition_time: return "rd_pick_4partition_time";
case encode_sb_time: return "encode_sb_time";
case rd_pick_sb_modes_time: return "rd_pick_sb_modes_time";
case av1_rd_pick_intra_mode_sb_time:
return "av1_rd_pick_intra_mode_sb_time";
case av1_rd_pick_inter_mode_sb_time:
return "av1_rd_pick_inter_mode_sb_time";
case set_params_rd_pick_inter_mode_time:
return "set_params_rd_pick_inter_mode_time";
case skip_inter_mode_time: return "skip_inter_mode_time";
case handle_inter_mode_time: return "handle_inter_mode_time";
case evaluate_motion_mode_for_winner_candidates_time:
return "evaluate_motion_mode_for_winner_candidates_time";
case do_tx_search_time: return "do_tx_search_time";
case handle_intra_mode_time: return "handle_intra_mode_time";
case refine_winner_mode_tx_time: return "refine_winner_mode_tx_time";
case av1_search_palette_mode_time: return "av1_search_palette_mode_time";
case handle_newmv_time: return "handle_newmv_time";
case compound_type_rd_time: return "compound_type_rd_time";
case interpolation_filter_search_time:
return "interpolation_filter_search_time";
case motion_mode_rd_time: return "motion_mode_rd_time";
case nonrd_use_partition_time: return "nonrd_use_partition_time";
case pick_sb_modes_nonrd_time: return "pick_sb_modes_nonrd_time";
case hybrid_intra_mode_search_time: return "hybrid_intra_mode_search_time";
case nonrd_pick_inter_mode_sb_time: return "nonrd_pick_inter_mode_sb_time";
case encode_b_nonrd_time: return "encode_b_nonrd_time";
default: assert(0);
}
return "error";
}
#endif
// The maximum number of internal ARFs except ALTREF_FRAME
#define MAX_INTERNAL_ARFS (REF_FRAMES - BWDREF_FRAME - 1)
typedef struct {
bool search_done;
YV12_BUFFER_CONFIG *ref_buf[REF_FRAMES];
int num_ref_frames[MAX_DIRECTIONS];
FrameDistPair reference_frames[MAX_DIRECTIONS][REF_FRAMES - 1];
int segment_map_w;
int segment_map_h;
} GlobalMotionInfo;
typedef struct {
int default_interp_skip_flags;
uint16_t interp_filter_search_mask;
} InterpSearchFlags;
typedef struct {
int max_mv_magnitude;
int mv_step_param;
fractional_mv_step_fp *find_fractional_mv_step;
search_site_config search_site_cfg[SS_CFG_TOTAL][NUM_DISTINCT_SEARCH_METHODS];
} MotionVectorSearchParams;
typedef struct {
bool golden_frame;
bool bwd_ref_frame;
bool alt_ref_frame;
} RefreshFrameInfo;
typedef struct {
int width;
int height;
} ResizePendingParams;
typedef struct {
int ref_relative_dist[INTER_REFS_PER_FRAME];
int8_t nearest_past_ref;
int8_t nearest_future_ref;
} RefFrameDistanceInfo;
typedef struct {
unsigned int coeff_opt_thresholds[MODE_EVAL_TYPES][2];
TX_SIZE_SEARCH_METHOD tx_size_search_methods[MODE_EVAL_TYPES];
unsigned int use_transform_domain_distortion[MODE_EVAL_TYPES];
unsigned int tx_domain_dist_threshold[MODE_EVAL_TYPES];
unsigned int skip_txfm_level[MODE_EVAL_TYPES];
unsigned int predict_dc_level[MODE_EVAL_TYPES];
} WinnerModeParams;
typedef struct {
bool last_frame;
bool golden_frame;
bool bwd_ref_frame;
bool alt2_ref_frame;
bool alt_ref_frame;
bool update_pending;
} ExtRefreshFrameFlagsInfo;
typedef struct {
int ref_frame_flags;
ExtRefreshFrameFlagsInfo refresh_frame;
bool refresh_frame_context;
bool refresh_frame_context_pending;
bool use_ref_frame_mvs;
bool use_error_resilient;
bool use_s_frame;
bool use_primary_ref_none;
} ExternalFlags;
typedef struct {
// Some misc info
int high_prec;
int q;
int order;
// MV counters
int inter_count;
int intra_count;
int default_mvs;
int mv_joint_count[4];
int last_bit_zero;
int last_bit_nonzero;
// Keep track of the rates
int total_mv_rate;
int hp_total_mv_rate;
int lp_total_mv_rate;
// Texture info
int horz_text;
int vert_text;
int diag_text;
// Whether the current struct contains valid data
int valid;
} MV_STATS;
typedef struct WeberStats {
int64_t mb_wiener_variance;
int64_t src_variance;
int64_t rec_variance;
int16_t src_pix_max;
int16_t rec_pix_max;
int64_t distortion;
int64_t satd;
double max_scale;
} WeberStats;
typedef struct {
int show_frame_count;
} FRAME_INDEX_SET;
typedef struct {
struct loopfilter lf;
CdefInfo cdef_info;
YV12_BUFFER_CONFIG copy_buffer;
RATE_CONTROL rc;
MV_STATS mv_stats;
unsigned int frame_number;
FRAME_INDEX_SET frame_index_set;
} CODING_CONTEXT;
typedef struct {
int frame_width;
int frame_height;
int mi_rows;
int mi_cols;
int mb_rows;
int mb_cols;
int num_mbs;
aom_bit_depth_t bit_depth;
int subsampling_x;
int subsampling_y;
} FRAME_INFO;
typedef struct {
uint8_t *map;
bool has_lossless_segment;
} EncSegmentationInfo;
typedef struct {
int64_t prev_ts_start;
int64_t prev_ts_end;
int64_t first_ts_start;
} TimeStamps;
typedef struct {
tran_low_t *tcoeff;
uint16_t *eobs;
uint8_t *entropy_ctx;
} CoeffBufferPool;
#if !CONFIG_REALTIME_ONLY
// DUCKY_ENCODE_FRAME_MODE is c version of EncodeFrameMode
enum {
DUCKY_ENCODE_FRAME_MODE_NONE, // Let native AV1 determine q index and rdmult
DUCKY_ENCODE_FRAME_MODE_QINDEX, // DuckyEncode determines q index and AV1
// determines rdmult
DUCKY_ENCODE_FRAME_MODE_QINDEX_RDMULT, // DuckyEncode determines q index and
// rdmult
} UENUM1BYTE(DUCKY_ENCODE_FRAME_MODE);
enum {
DUCKY_ENCODE_GOP_MODE_NONE, // native AV1 decides GOP
DUCKY_ENCODE_GOP_MODE_RCL, // rate control lib decides GOP
} UENUM1BYTE(DUCKY_ENCODE_GOP_MODE);
typedef struct DuckyEncodeFrameInfo {
DUCKY_ENCODE_FRAME_MODE qp_mode;
DUCKY_ENCODE_GOP_MODE gop_mode;
int q_index;
int rdmult;
// These two arrays are equivalent to std::vector<SuperblockEncodeParameters>
int *superblock_encode_qindex;
int *superblock_encode_rdmult;
int delta_q_enabled;
} DuckyEncodeFrameInfo;
typedef struct DuckyEncodeFrameResult {
int global_order_idx;
int q_index;
int rdmult;
int rate;
int64_t dist;
double psnr;
} DuckyEncodeFrameResult;
typedef struct DuckyEncodeInfo {
DuckyEncodeFrameInfo frame_info;
DuckyEncodeFrameResult frame_result;
} DuckyEncodeInfo;
#endif
typedef struct RTC_REF {
int reference[INTER_REFS_PER_FRAME];
int ref_idx[INTER_REFS_PER_FRAME];
int refresh[REF_FRAMES];
int set_ref_frame_config;
int non_reference_frame;
int ref_frame_comp[3];
int gld_idx_1layer;
unsigned int buffer_time_index[REF_FRAMES];
unsigned char buffer_spatial_layer[REF_FRAMES];
bool reference_was_previous_frame;
bool bias_recovery_frame;
} RTC_REF;
typedef struct AV1_COMP_DATA {
unsigned char *cx_data;
size_t cx_data_sz;
size_t frame_size;
unsigned int lib_flags;
int64_t ts_frame_start;
int64_t ts_frame_end;
int flush;
const aom_rational64_t *timestamp_ratio;
int pop_lookahead;
} AV1_COMP_DATA;
typedef struct AV1_PRIMARY {
struct AV1_COMP *parallel_cpi[MAX_PARALLEL_FRAMES];
struct AV1_COMP_DATA parallel_frames_data[MAX_PARALLEL_FRAMES - 1];
#if CONFIG_FPMT_TEST
FPMT_TEST_ENC_CFG fpmt_unit_test_cfg;
FrameProbInfo temp_frame_probs;
FrameProbInfo temp_frame_probs_simulation;
int temp_valid_gm_model_found[FRAME_UPDATE_TYPES];
#endif // CONFIG_FPMT_TEST
RefCntBuffer *ref_frame_map_copy[REF_FRAMES];
int64_t ts_start_last_show_frame;
int64_t ts_end_last_show_frame;
int num_fp_contexts;
int filter_level[2];
int filter_level_u;
int filter_level_v;
struct AV1_COMP *cpi;
struct AV1_COMP *cpi_lap;
struct lookahead_ctx *lookahead;
int seq_params_locked;
struct aom_codec_pkt_list *output_pkt_list;
int internal_altref_allowed;
int show_existing_alt_ref;
GF_GROUP gf_group;
GF_STATE gf_state;
int lap_enabled;
AV1LevelParams level_params;
int b_calculate_psnr;
int frames_left;
TWO_PASS twopass;
PRIMARY_RATE_CONTROL p_rc;
TEMPORAL_FILTER_INFO tf_info;
SequenceHeader seq_params;
int use_svc;
bool buffer_removal_time_present;
unsigned int number_temporal_layers;
unsigned int number_spatial_layers;
struct aom_internal_error_info error;
aom_variance_fn_ptr_t fn_ptr[BLOCK_SIZES_ALL];
double *tpl_sb_rdmult_scaling_factors;
TplParams tpl_data;
MV_STATS mv_stats;
#if CONFIG_INTERNAL_STATS
uint64_t total_time_receive_data;
uint64_t total_time_compress_data;
unsigned int total_mode_chosen_counts[MAX_MODES];
int count[2];
uint64_t total_sq_error[2];
uint64_t total_samples[2];
ImageStat psnr[2];
double total_blockiness;
double worst_blockiness;
uint64_t total_bytes;
double summed_quality;
double summed_weights;
double summed_quality_hbd;
double summed_weights_hbd;
unsigned int total_recode_hits;
double worst_ssim;
double worst_ssim_hbd;
ImageStat fastssim;
ImageStat psnrhvs;
int b_calculate_blockiness;
int b_calculate_consistency;
double total_inconsistency;
double worst_consistency;
Ssimv *ssim_vars;
Metrics metrics;
#endif
#if CONFIG_ENTROPY_STATS
FRAME_COUNTS aggregate_fc;
#endif // CONFIG_ENTROPY_STATS
int fb_of_context_type[REF_FRAMES];
PrimaryMultiThreadInfo p_mt_info;
FrameProbInfo frame_probs;
int valid_gm_model_found[FRAME_UPDATE_TYPES];
RTC_REF rtc_ref;
AV1EncRowMultiThreadSync intra_row_mt_sync;
int b_freeze_internal_state;
} AV1_PRIMARY;
typedef struct AV1_COMP {
AV1_PRIMARY *ppi;
EncQuantDequantParams enc_quant_dequant_params;
ThreadData td;
FRAME_COUNTS counts;
MBMIExtFrameBufferInfo mbmi_ext_info;
CB_COEFF_BUFFER *coeff_buffer_base;
CoeffBufferPool coeff_buffer_pool;
AV1_COMMON common;
AV1EncoderConfig oxcf;
TRELLIS_OPT_TYPE optimize_seg_arr[MAX_SEGMENTS];
YV12_BUFFER_CONFIG *source;
YV12_BUFFER_CONFIG *last_source;
YV12_BUFFER_CONFIG *unscaled_source;
YV12_BUFFER_CONFIG scaled_source;
YV12_BUFFER_CONFIG *unscaled_last_source;
YV12_BUFFER_CONFIG scaled_last_source;
YV12_BUFFER_CONFIG *unfiltered_source;
YV12_BUFFER_CONFIG orig_source;
int skip_tpl_setup_stats;
double *tpl_rdmult_scaling_factors;
TemporalFilterCtx tf_ctx;
CdefSearchCtx *cdef_search_ctx;
ForceIntegerMVInfo force_intpel_info;
RefCntBuffer *scaled_ref_buf[INTER_REFS_PER_FRAME];
RefCntBuffer *last_show_frame_buf;
RefreshFrameInfo refresh_frame;
int rt_reduce_num_ref_buffers;
ExternalFlags ext_flags;
YV12_BUFFER_CONFIG last_frame_uf;
YV12_BUFFER_CONFIG trial_frame_rst;
int64_t ambient_err;
RD_OPT rd;
CODING_CONTEXT coding_context;
GlobalMotionInfo gm_info;
WinnerModeParams winner_mode_params;
TimeStamps time_stamps;
RATE_CONTROL rc;
double framerate;
int ref_frame_flags;
int speed;
SPEED_FEATURES sf;
MotionVectorSearchParams mv_search_params;
int all_one_sided_refs;
EncSegmentationInfo enc_seg;
CYCLIC_REFRESH *cyclic_refresh;
ActiveMap active_map;
unsigned char gf_frame_index;
#if CONFIG_INTERNAL_STATS
uint64_t time_compress_data;
unsigned int mode_chosen_counts[MAX_MODES];
int bytes;
unsigned int frame_recode_hits;
#endif
#if CONFIG_SPEED_STATS
unsigned int tx_search_count;
#endif // CONFIG_SPEED_STATS
int droppable;
FRAME_INFO frame_info;
FRAME_INDEX_SET frame_index_set;
int data_alloc_width;
int data_alloc_height;
int initial_mbs;
bool frame_size_related_setup_done;
int last_coded_width;
int last_coded_height;
ResizePendingParams resize_pending_params;
TileDataEnc *tile_data;
int allocated_tiles;
TokenInfo token_info;
int vaq_refresh;
VarBasedPartitionInfo vbp_info;
int num_frame_recode;
FrameProbInfo frame_new_probs[NUM_RECODES_PER_FRAME];
int do_update_frame_probs_txtype[NUM_RECODES_PER_FRAME];
int do_update_frame_probs_obmc[NUM_RECODES_PER_FRAME];
int do_update_frame_probs_warp[NUM_RECODES_PER_FRAME];
int do_update_frame_probs_interpfilter[NUM_RECODES_PER_FRAME];
#if CONFIG_FPMT_TEST
double temp_framerate;
#endif
double new_framerate;
int do_update_vbr_bits_off_target_fast;
MultiThreadInfo mt_info;
int existing_fb_idx_to_show;
int intrabc_used;
int prune_ref_frame_mask;
int keep_single_ref_frame_mask;
int keep_comp_ref_frame_mask;
AV1LrStruct lr_ctxt;
AV1LrPickStruct pick_lr_ctxt;
aom_film_grain_table_t *film_grain_table;
#if CONFIG_DENOISE
struct aom_denoise_and_model_t *denoise_and_model;
#endif
InterpSearchFlags interp_search_flags;
int use_screen_content_tools;
int is_screen_content_type;
#if CONFIG_COLLECT_PARTITION_STATS
FramePartitionTimingStats partition_stats;
#endif // CONFIG_COLLECT_PARTITION_STATS
#if CONFIG_COLLECT_COMPONENT_TIMING
uint64_t component_time[kTimingComponents];
struct aom_usec_timer component_timer[kTimingComponents];
uint64_t frame_component_time[kTimingComponents];
#endif
int frame_header_count;
int deltaq_used;
RefFrameDistanceInfo ref_frame_dist_info;
double *ssim_rdmult_scaling_factors;
#if CONFIG_TUNE_VMAF
TuneVMAFInfo vmaf_info;
#endif
#if CONFIG_TUNE_BUTTERAUGLI
TuneButteraugliInfo butteraugli_info;
#endif
SVC svc;
COMPRESSOR_STAGE compressor_stage;
FRAME_TYPE last_frame_type;
int num_tg;
aom_superres_mode superres_mode;
FirstPassData firstpass_data;
NOISE_ESTIMATE noise_estimate;
#if CONFIG_AV1_TEMPORAL_DENOISING
AV1_DENOISER denoiser;
#endif
uint8_t *consec_zero_mv;
int consec_zero_mv_alloc_size;
BLOCK_SIZE fp_block_size;
int sb_counter;
size_t available_bs_size;
ExtPartController ext_part_controller;
MV_STATS mv_stats;
int ref_refresh_index;
bool refresh_idx_available;
int ref_idx_to_skip;
#if CONFIG_FPMT_TEST
int wanted_fb;
#endif // CONFIG_FPMT_TEST
bool do_frame_data_update;
#if CONFIG_RD_COMMAND
RD_COMMAND rd_command;
#endif // CONFIG_RD_COMMAND
WeberStats *mb_weber_stats;
int *prep_rate_estimates;
double *ext_rate_distribution;
double ext_rate_scale;
BLOCK_SIZE weber_bsize;
int64_t norm_wiener_variance;
int *mb_delta_q;
bool is_dropped_frame;
#if CONFIG_BITRATE_ACCURACY
VBR_RATECTRL_INFO vbr_rc_info;
#endif
#if CONFIG_RATECTRL_LOG
RATECTRL_LOG rc_log;
#endif // CONFIG_RATECTRL_LOG
TWO_PASS_FRAME twopass_frame;
#if CONFIG_THREE_PASS
THIRD_PASS_DEC_CTX *third_pass_ctx;
#endif
FILE *second_pass_log_stream;
uint64_t *src_sad_blk_64x64;
int src_sad_blk_alloc_size;
uint64_t rec_sse;
int use_ducky_encode;
#if !CONFIG_REALTIME_ONLY
DuckyEncodeInfo ducky_encode_info;
#endif // CONFIG_REALTIME_ONLY
//
int frames_since_last_update;
unsigned int zeromv_skip_thresh_exit_part[BLOCK_SIZES_ALL];
bool alloc_pyramid;
#if CONFIG_SALIENCY_MAP
uint8_t *saliency_map;
double *sm_scaling_factor;
#endif
int palette_pixel_num;
int scaled_last_source_available;
aom_roi_map_t roi;
AOM_EXT_RATECTRL ext_ratectrl;
AomTplGopStats extrc_tpl_gop_stats;
} AV1_COMP;
typedef struct EncodeFrameInput {
YV12_BUFFER_CONFIG *source;
YV12_BUFFER_CONFIG *last_source;
int64_t ts_duration;
} EncodeFrameInput;
typedef struct EncodeFrameParams {
int error_resilient_mode;
FRAME_TYPE frame_type;
int primary_ref_frame;
int order_offset;
int show_frame;
int refresh_frame_flags;
int show_existing_frame;
int existing_fb_idx_to_show;
int ref_frame_flags;
int remapped_ref_idx[REF_FRAMES];
RefreshFrameInfo refresh_frame;
int speed;
} EncodeFrameParams;
void av1_initialize_enc(unsigned int usage, enum aom_rc_mode end_usage);
struct AV1_COMP *av1_create_compressor(struct AV1_PRIMARY *ppi,
const AV1EncoderConfig *oxcf,
struct BufferPool *const pool,
COMPRESSOR_STAGE stage,
int lap_lag_in_frames);
struct AV1_PRIMARY *av1_create_primary_compressor(
struct aom_codec_pkt_list *pkt_list_head, int num_lap_buffers,
const AV1EncoderConfig *oxcf);
void av1_remove_compressor(AV1_COMP *cpi);
void av1_remove_primary_compressor(AV1_PRIMARY *ppi);
#if CONFIG_ENTROPY_STATS
void print_entropy_stats(AV1_PRIMARY *const ppi);
#endif
#if CONFIG_INTERNAL_STATS
void print_internal_stats(AV1_PRIMARY *ppi);
#endif
void av1_change_config_seq(AV1_PRIMARY *ppi, const AV1EncoderConfig *oxcf,
bool *sb_size_changed);
void av1_change_config(AV1_COMP *cpi, const AV1EncoderConfig *oxcf,
bool sb_size_changed);
aom_codec_err_t av1_check_initial_width(AV1_COMP *cpi, int use_highbitdepth,
int subsampling_x, int subsampling_y);
void av1_post_encode_updates(AV1_COMP *const cpi,
const AV1_COMP_DATA *const cpi_data);
void av1_release_scaled_references_fpmt(AV1_COMP *cpi);
void av1_decrement_ref_counts_fpmt(BufferPool *buffer_pool,
int ref_buffers_used_map);
void av1_init_sc_decisions(AV1_PRIMARY *const ppi);
AV1_COMP *av1_get_parallel_frame_enc_data(AV1_PRIMARY *const ppi,
AV1_COMP_DATA *const first_cpi_data);
int av1_init_parallel_frame_context(const AV1_COMP_DATA *const first_cpi_data,
AV1_PRIMARY *const ppi,
int *ref_buffers_used_map);
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);
int av1_get_compressed_data(AV1_COMP *cpi, AV1_COMP_DATA *const cpi_data);
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);
int av1_get_preview_raw_frame(AV1_COMP *cpi, YV12_BUFFER_CONFIG *dest);
int av1_get_last_show_frame(AV1_COMP *cpi, YV12_BUFFER_CONFIG *frame);
aom_codec_err_t av1_copy_new_frame_enc(AV1_COMMON *cm,
YV12_BUFFER_CONFIG *new_frame,
YV12_BUFFER_CONFIG *sd);
int av1_use_as_reference(int *ext_ref_frame_flags, int ref_frame_flags);
int av1_copy_reference_enc(AV1_COMP *cpi, int idx, YV12_BUFFER_CONFIG *sd);
int av1_set_reference_enc(AV1_COMP *cpi, int idx, YV12_BUFFER_CONFIG *sd);
void av1_set_frame_size(AV1_COMP *cpi, int width, int height);
void av1_set_mv_search_params(AV1_COMP *cpi);
int av1_set_roi_map(AV1_COMP *cpi, unsigned char *map, unsigned int rows,
unsigned int cols, int delta_q[8], int delta_lf[8],
int skip[8], int ref_frame[8]);
int av1_set_active_map(AV1_COMP *cpi, unsigned char *map, int rows, int cols);
int av1_get_active_map(AV1_COMP *cpi, unsigned char *map, int rows, int cols);
int av1_set_internal_size(AV1EncoderConfig *const oxcf,
ResizePendingParams *resize_pending_params,
AOM_SCALING_MODE horiz_mode,
AOM_SCALING_MODE vert_mode);
int av1_get_quantizer(struct AV1_COMP *cpi);
// This function assumes that the input buffer contains valid OBUs. It should
// not be called on untrusted input.
int av1_convert_sect5obus_to_annexb(uint8_t *buffer, size_t buffer_size,
size_t *input_size);
void av1_alloc_mb_wiener_var_pred_buf(AV1_COMMON *cm, ThreadData *td);
void av1_dealloc_mb_wiener_var_pred_buf(ThreadData *td);
uint8_t av1_find_dominant_value(const uint8_t *src, int stride, int rows,
int cols);
void av1_dilate_block(const uint8_t *src, int src_stride, uint8_t *dilated,
int dilated_stride, int rows, int cols);
// Set screen content options.
// This function estimates whether to use screen content tools, by counting
// the portion of blocks that have few luma colors.
// Modifies:
// cpi->commom.features.allow_screen_content_tools
// cpi->common.features.allow_intrabc
// cpi->use_screen_content_tools
// cpi->is_screen_content_type
// However, the estimation is not accurate and may misclassify videos.
// A slower but more accurate approach that determines whether to use screen
// content tools is employed later. See av1_determine_sc_tools_with_encoding().
void av1_set_screen_content_options(struct AV1_COMP *cpi,
FeatureFlags *features);
void av1_update_frame_size(AV1_COMP *cpi);
void av1_set_svc_seq_params(AV1_PRIMARY *const ppi);
typedef struct {
int pyr_level;
int disp_order;
} RefFrameMapPair;
static inline void init_ref_map_pair(
AV1_COMP *cpi, RefFrameMapPair ref_frame_map_pairs[REF_FRAMES]) {
if (cpi->ppi->gf_group.update_type[cpi->gf_frame_index] == KF_UPDATE) {
memset(ref_frame_map_pairs, -1, sizeof(*ref_frame_map_pairs) * REF_FRAMES);
return;
}
memset(ref_frame_map_pairs, 0, sizeof(*ref_frame_map_pairs) * REF_FRAMES);
for (int map_idx = 0; map_idx < REF_FRAMES; map_idx++) {
// Get reference frame buffer.
const RefCntBuffer *const buf = cpi->common.ref_frame_map[map_idx];
if (ref_frame_map_pairs[map_idx].disp_order == -1) continue;
if (buf == NULL) {
ref_frame_map_pairs[map_idx].disp_order = -1;
ref_frame_map_pairs[map_idx].pyr_level = -1;
continue;
} else if (buf->ref_count > 1) {
// Once the keyframe is coded, the slots in ref_frame_map will all
// point to the same frame. In that case, all subsequent pointers
// matching the current are considered "free" slots. This will find
// the next occurrence of the current pointer if ref_count indicates
// there are multiple instances of it and mark it as free.
for (int idx2 = map_idx + 1; idx2 < REF_FRAMES; ++idx2) {
const RefCntBuffer *const buf2 = cpi->common.ref_frame_map[idx2];
if (buf2 == buf) {
ref_frame_map_pairs[idx2].disp_order = -1;
ref_frame_map_pairs[idx2].pyr_level = -1;
}
}
}
ref_frame_map_pairs[map_idx].disp_order = (int)buf->display_order_hint;
ref_frame_map_pairs[map_idx].pyr_level = buf->pyramid_level;
}
}
#if CONFIG_FPMT_TEST
static inline void calc_frame_data_update_flag(
GF_GROUP *const gf_group, int gf_frame_index,
bool *const do_frame_data_update) {
*do_frame_data_update = true;
// Set the flag to false for all frames in a given parallel encode set except
// the last frame in the set with frame_parallel_level = 2.
if (gf_group->frame_parallel_level[gf_frame_index] == 1) {
*do_frame_data_update = false;
} else if (gf_group->frame_parallel_level[gf_frame_index] == 2) {
// Check if this is the last frame in the set with frame_parallel_level = 2.
for (int i = gf_frame_index + 1; i < gf_group->size; i++) {
if ((gf_group->frame_parallel_level[i] == 0 &&
(gf_group->update_type[i] == ARF_UPDATE ||
gf_group->update_type[i] == INTNL_ARF_UPDATE)) ||
gf_group->frame_parallel_level[i] == 1) {
break;
} else if (gf_group->frame_parallel_level[i] == 2) {
*do_frame_data_update = false;
break;
}
}
}
}
#endif
// av1 uses 10,000,000 ticks/second as time stamp
#define TICKS_PER_SEC 10000000LL
static inline int64_t timebase_units_to_ticks(
const aom_rational64_t *timestamp_ratio, int64_t n) {
return n * timestamp_ratio->num / timestamp_ratio->den;
}
static inline int64_t ticks_to_timebase_units(
const aom_rational64_t *timestamp_ratio, int64_t n) {
int64_t round = timestamp_ratio->num / 2;
if (round > 0) --round;
return (n * timestamp_ratio->den + round) / timestamp_ratio->num;
}
static inline int frame_is_kf_gf_arf(const AV1_COMP *cpi) {
const GF_GROUP *const gf_group = &cpi->ppi->gf_group;
const FRAME_UPDATE_TYPE update_type =
gf_group->update_type[cpi->gf_frame_index];
return frame_is_intra_only(&cpi->common) || update_type == ARF_UPDATE ||
update_type == GF_UPDATE;
}
// TODO(huisu@google.com, youzhou@microsoft.com): enable hash-me for HBD.
static inline int av1_use_hash_me(const AV1_COMP *const cpi) {
return (cpi->common.features.allow_screen_content_tools &&
cpi->common.features.allow_intrabc &&
frame_is_intra_only(&cpi->common));
}
static inline const YV12_BUFFER_CONFIG *get_ref_frame_yv12_buf(
const AV1_COMMON *const cm, MV_REFERENCE_FRAME ref_frame) {
const RefCntBuffer *const buf = get_ref_frame_buf(cm, ref_frame);
return buf != NULL ? &buf->buf : NULL;
}
static inline void alloc_frame_mvs(AV1_COMMON *const cm, RefCntBuffer *buf) {
assert(buf != NULL);
ensure_mv_buffer(buf, cm);
buf->width = cm->width;
buf->height = cm->height;
}
// Get the allocated token size for a tile. It does the same calculation as in
// the frame token allocation.
static inline unsigned int allocated_tokens(const TileInfo *tile,
int sb_size_log2, int num_planes) {
int tile_mb_rows =
ROUND_POWER_OF_TWO(tile->mi_row_end - tile->mi_row_start, 2);
int tile_mb_cols =
ROUND_POWER_OF_TWO(tile->mi_col_end - tile->mi_col_start, 2);
return get_token_alloc(tile_mb_rows, tile_mb_cols, sb_size_log2, num_planes);
}
static inline void get_start_tok(AV1_COMP *cpi, int tile_row, int tile_col,
int mi_row, TokenExtra **tok, int sb_size_log2,
int num_planes) {
AV1_COMMON *const cm = &cpi->common;
const int tile_cols = cm->tiles.cols;
TileDataEnc *this_tile = &cpi->tile_data[tile_row * tile_cols + tile_col];
const TileInfo *const tile_info = &this_tile->tile_info;
const int tile_mb_cols =
(tile_info->mi_col_end - tile_info->mi_col_start + 2) >> 2;
const int tile_mb_row = (mi_row - tile_info->mi_row_start + 2) >> 2;
*tok = cpi->token_info.tile_tok[tile_row][tile_col] +
get_token_alloc(tile_mb_row, tile_mb_cols, sb_size_log2, num_planes);
}
void av1_apply_encoding_flags(AV1_COMP *cpi, aom_enc_frame_flags_t flags);
#define ALT_MIN_LAG 3
static inline int is_altref_enabled(int lag_in_frames, bool enable_auto_arf) {
return lag_in_frames >= ALT_MIN_LAG && enable_auto_arf;
}
static inline int can_disable_altref(const GFConfig *gf_cfg) {
return is_altref_enabled(gf_cfg->lag_in_frames, gf_cfg->enable_auto_arf) &&
(gf_cfg->gf_min_pyr_height == 0);
}
// Helper function to compute number of blocks on either side of the frame.
static inline int get_num_blocks(const int frame_length, const int mb_length) {
return (frame_length + mb_length - 1) / mb_length;
}
// Check if statistics generation stage
static inline int is_stat_generation_stage(const AV1_COMP *const cpi) {
assert(IMPLIES(cpi->compressor_stage == LAP_STAGE,
cpi->oxcf.pass == AOM_RC_ONE_PASS && cpi->ppi->lap_enabled));
return (cpi->oxcf.pass == AOM_RC_FIRST_PASS ||
(cpi->compressor_stage == LAP_STAGE));
}
// Check if statistics consumption stage
static inline int is_stat_consumption_stage_twopass(const AV1_COMP *const cpi) {
return (cpi->oxcf.pass >= AOM_RC_SECOND_PASS);
}
// Check if statistics consumption stage
static inline int is_stat_consumption_stage(const AV1_COMP *const cpi) {
return (is_stat_consumption_stage_twopass(cpi) ||
(cpi->oxcf.pass == AOM_RC_ONE_PASS &&
(cpi->compressor_stage == ENCODE_STAGE) && cpi->ppi->lap_enabled &&
cpi->oxcf.mode != REALTIME));
}
// Decide whether 'dv_costs' need to be allocated/stored during the encoding.
static inline bool av1_need_dv_costs(const AV1_COMP *const cpi) {
return !cpi->sf.rt_sf.use_nonrd_pick_mode &&
av1_allow_intrabc(&cpi->common) && !is_stat_generation_stage(cpi);
}
static inline int has_no_stats_stage(const AV1_COMP *const cpi) {
assert(
IMPLIES(!cpi->ppi->lap_enabled, cpi->compressor_stage == ENCODE_STAGE));
return (cpi->oxcf.pass == AOM_RC_ONE_PASS &&
(!cpi->ppi->lap_enabled || cpi->oxcf.mode == REALTIME));
}
static inline int is_one_pass_rt_lag_params(const AV1_COMP *cpi) {
return cpi->oxcf.pass == AOM_RC_ONE_PASS &&
cpi->oxcf.gf_cfg.lag_in_frames > 0 && cpi->oxcf.mode == REALTIME;
}
static inline int is_one_pass_rt_params(const AV1_COMP *cpi) {
return has_no_stats_stage(cpi) && cpi->oxcf.gf_cfg.lag_in_frames == 0 &&
(cpi->oxcf.mode == REALTIME || cpi->svc.number_spatial_layers > 1);
}
// Use default/internal reference structure for single-layer RTC.
static inline int use_rtc_reference_structure_one_layer(const AV1_COMP *cpi) {
return is_one_pass_rt_params(cpi) && cpi->ppi->number_spatial_layers == 1 &&
cpi->ppi->number_temporal_layers == 1 &&
!cpi->ppi->rtc_ref.set_ref_frame_config;
}
// Check if postencode drop is allowed.
static inline int allow_postencode_drop_rtc(const AV1_COMP *cpi) {
const AV1_COMMON *const cm = &cpi->common;
return is_one_pass_rt_params(cpi) && cpi->oxcf.rc_cfg.mode == AOM_CBR &&
cpi->oxcf.rc_cfg.drop_frames_water_mark > 0 &&
!cpi->rc.rtc_external_ratectrl && !frame_is_intra_only(cm) &&
cpi->svc.spatial_layer_id == 0;
}
// Function return size of frame stats buffer
static inline int get_stats_buf_size(int num_lap_buffer, int num_lag_buffer) {
/* if lookahead is enabled return num_lap_buffers else num_lag_buffers */
if (num_lap_buffer > 0) {
return AOMMAX(num_lap_buffer + 1, MAX_GF_LENGTH_LAP + 1);
}
return num_lag_buffer;
}
// TODO(zoeliu): To set up cpi->oxcf.gf_cfg.enable_auto_brf
static inline void set_ref_ptrs(const AV1_COMMON *cm, MACROBLOCKD *xd,
MV_REFERENCE_FRAME ref0,
MV_REFERENCE_FRAME ref1) {
xd->block_ref_scale_factors[0] =
get_ref_scale_factors_const(cm, ref0 >= LAST_FRAME ? ref0 : 1);
xd->block_ref_scale_factors[1] =
get_ref_scale_factors_const(cm, ref1 >= LAST_FRAME ? ref1 : 1);
}
static inline int get_chessboard_index(int frame_index) {
return frame_index & 0x1;
}
static inline const int *cond_cost_list_const(const struct AV1_COMP *cpi,
const int *cost_list) {
const int use_cost_list = cpi->sf.mv_sf.subpel_search_method != SUBPEL_TREE &&
cpi->sf.mv_sf.use_fullpel_costlist;
return use_cost_list ? cost_list : NULL;
}
static inline int *cond_cost_list(const struct AV1_COMP *cpi, int *cost_list) {
const int use_cost_list = cpi->sf.mv_sf.subpel_search_method != SUBPEL_TREE &&
cpi->sf.mv_sf.use_fullpel_costlist;
return use_cost_list ? cost_list : NULL;
}
// Compression ratio of current frame.
double av1_get_compression_ratio(const AV1_COMMON *const cm,
size_t encoded_frame_size);
void av1_new_framerate(AV1_COMP *cpi, double framerate);
void av1_setup_frame_size(AV1_COMP *cpi);
#define LAYER_IDS_TO_IDX(sl, tl, num_tl) ((sl) * (num_tl) + (tl))
// Returns 1 if a frame is scaled and 0 otherwise.
static inline int av1_resize_scaled(const AV1_COMMON *cm) {
return cm->superres_upscaled_width != cm->render_width ||
cm->superres_upscaled_height != cm->render_height;
}
static inline int av1_frame_scaled(const AV1_COMMON *cm) {
return av1_superres_scaled(cm) || av1_resize_scaled(cm);
}
static inline bool av1_encode_for_extrc(AOM_EXT_RATECTRL const *ext_rc) {
return ext_rc->ready && (ext_rc->funcs.rc_type & AOM_RC_QP) != 0 &&
ext_rc->funcs.get_encodeframe_decision != NULL;
}
// Don't allow a show_existing_frame to coincide with an error resilient
// frame. An exception can be made for a forward keyframe since it has no
// previous dependencies.
static inline int encode_show_existing_frame(const AV1_COMMON *cm) {
return cm->show_existing_frame && (!cm->features.error_resilient_mode ||
cm->current_frame.frame_type == KEY_FRAME);
}
// Get index into the 'cpi->mbmi_ext_info.frame_base' array for the given
// 'mi_row' and 'mi_col'.
static inline int get_mi_ext_idx(const int mi_row, const int mi_col,
const BLOCK_SIZE mi_alloc_bsize,
const int mbmi_ext_stride) {
const int mi_ext_size_1d = mi_size_wide[mi_alloc_bsize];
const int mi_ext_row = mi_row / mi_ext_size_1d;
const int mi_ext_col = mi_col / mi_ext_size_1d;
return mi_ext_row * mbmi_ext_stride + mi_ext_col;
}
// Lighter version of set_offsets that only sets the mode info
// pointers.
static inline void set_mode_info_offsets(
const CommonModeInfoParams *const mi_params,
const MBMIExtFrameBufferInfo *const mbmi_ext_info, MACROBLOCK *const x,
MACROBLOCKD *const xd, int mi_row, int mi_col) {
set_mi_offsets(mi_params, xd, mi_row, mi_col);
const int ext_idx = get_mi_ext_idx(mi_row, mi_col, mi_params->mi_alloc_bsize,
mbmi_ext_info->stride);
x->mbmi_ext_frame = mbmi_ext_info->frame_base + ext_idx;
}
// Check to see if the given partition size is allowed for a specified number
// of mi block rows and columns remaining in the image.
// If not then return the largest allowed partition size
static inline BLOCK_SIZE find_partition_size(BLOCK_SIZE bsize, int rows_left,
int cols_left, int *bh, int *bw) {
int int_size = (int)bsize;
if (rows_left <= 0 || cols_left <= 0) {
return AOMMIN(bsize, BLOCK_8X8);
} else {
for (; int_size > 0; int_size -= 3) {
*bh = mi_size_high[int_size];
*bw = mi_size_wide[int_size];
if ((*bh <= rows_left) && (*bw <= cols_left)) {
break;
}
}
}
return (BLOCK_SIZE)int_size;
}
static const uint8_t av1_ref_frame_flag_list[REF_FRAMES] = { 0,
AOM_LAST_FLAG,
AOM_LAST2_FLAG,
AOM_LAST3_FLAG,
AOM_GOLD_FLAG,
AOM_BWD_FLAG,
AOM_ALT2_FLAG,
AOM_ALT_FLAG };
// When more than 'max_allowed_refs' are available, we reduce the number of
// reference frames one at a time based on this order.
static const MV_REFERENCE_FRAME disable_order[] = {
LAST3_FRAME,
LAST2_FRAME,
ALTREF2_FRAME,
BWDREF_FRAME,
};
static const MV_REFERENCE_FRAME
ref_frame_priority_order[INTER_REFS_PER_FRAME] = {
LAST_FRAME, ALTREF_FRAME, BWDREF_FRAME, GOLDEN_FRAME,
ALTREF2_FRAME, LAST2_FRAME, LAST3_FRAME,
};
static inline int get_ref_frame_flags(const SPEED_FEATURES *const sf,
const int use_one_pass_rt_params,
const YV12_BUFFER_CONFIG **ref_frames,
const int ext_ref_frame_flags) {
// cpi->ext_flags.ref_frame_flags allows certain reference types to be
// disabled by the external interface. These are set by
// av1_apply_encoding_flags(). Start with what the external interface allows,
// then suppress any reference types which we have found to be duplicates.
int flags = ext_ref_frame_flags;
for (int i = 1; i < INTER_REFS_PER_FRAME; ++i) {
const YV12_BUFFER_CONFIG *const this_ref = ref_frames[i];
// If this_ref has appeared before, mark the corresponding ref frame as
// invalid. For one_pass_rt mode, only disable GOLDEN_FRAME if it's the
// same as LAST_FRAME or ALTREF_FRAME (if ALTREF is being used in nonrd).
int index =
(use_one_pass_rt_params && ref_frame_priority_order[i] == GOLDEN_FRAME)
? (1 + sf->rt_sf.use_nonrd_altref_frame)
: i;
for (int j = 0; j < index; ++j) {
// If this_ref has appeared before (same as the reference corresponding
// to lower index j), remove it as a reference only if that reference
// (for index j) is actually used as a reference.
if (this_ref == ref_frames[j] &&
(flags & (1 << (ref_frame_priority_order[j] - 1)))) {
flags &= ~(1 << (ref_frame_priority_order[i] - 1));
break;
}
}
}
return flags;
}
// Returns a Sequence Header OBU stored in an aom_fixed_buf_t, or NULL upon
// failure. When a non-NULL aom_fixed_buf_t pointer is returned by this
// function, the memory must be freed by the caller. Both the buf member of the
// aom_fixed_buf_t, and the aom_fixed_buf_t pointer itself must be freed. Memory
// returned must be freed via call to free().
//
// Note: The OBU returned is in Low Overhead Bitstream Format. Specifically,
// the obu_has_size_field bit is set, and the buffer contains the obu_size
// field.
aom_fixed_buf_t *av1_get_global_headers(AV1_PRIMARY *ppi);
#define MAX_GFUBOOST_FACTOR 10.0
#define MIN_GFUBOOST_FACTOR 4.0
static inline int is_frame_tpl_eligible(const GF_GROUP *const gf_group,
uint8_t index) {
const FRAME_UPDATE_TYPE update_type = gf_group->update_type[index];
return update_type == ARF_UPDATE || update_type == GF_UPDATE ||
update_type == KF_UPDATE;
}
static inline int is_frame_eligible_for_ref_pruning(const GF_GROUP *gf_group,
int selective_ref_frame,
int prune_ref_frames,
int gf_index) {
return (selective_ref_frame > 0) && (prune_ref_frames > 0) &&
!is_frame_tpl_eligible(gf_group, gf_index);
}
// Get update type of the current frame.
static inline FRAME_UPDATE_TYPE get_frame_update_type(const GF_GROUP *gf_group,
int gf_frame_index) {
return gf_group->update_type[gf_frame_index];
}
static inline int av1_pixels_to_mi(int pixels) {
return ALIGN_POWER_OF_TWO(pixels, 3) >> MI_SIZE_LOG2;
}
static inline int is_psnr_calc_enabled(const AV1_COMP *cpi) {
const AV1_COMMON *const cm = &cpi->common;
return cpi->ppi->b_calculate_psnr && !is_stat_generation_stage(cpi) &&
cm->show_frame && !cpi->is_dropped_frame;
}
static inline int is_frame_resize_pending(const AV1_COMP *const cpi) {
const ResizePendingParams *const resize_pending_params =
&cpi->resize_pending_params;
return (resize_pending_params->width && resize_pending_params->height &&
(cpi->common.width != resize_pending_params->width ||
cpi->common.height != resize_pending_params->height));
}
// Check if loop filter is used.
static inline int is_loopfilter_used(const AV1_COMMON *const cm) {
return !cm->features.coded_lossless && !cm->tiles.large_scale;
}
// Check if CDEF is used.
static inline int is_cdef_used(const AV1_COMMON *const cm) {
return cm->seq_params->enable_cdef && !cm->features.coded_lossless &&
!cm->tiles.large_scale;
}
// Check if loop restoration filter is used.
static inline int is_restoration_used(const AV1_COMMON *const cm) {
return cm->seq_params->enable_restoration && !cm->features.all_lossless &&
!cm->tiles.large_scale;
}
// Checks if post-processing filters need to be applied.
// NOTE: This function decides if the application of different post-processing
// filters on the reconstructed frame can be skipped at the encoder side.
// However the computation of different filter parameters that are signaled in
// the bitstream is still required.
static inline unsigned int derive_skip_apply_postproc_filters(
const AV1_COMP *cpi, int use_loopfilter, int use_cdef, int use_superres,
int use_restoration) {
// Though CDEF parameter selection should be dependent on
// deblocked/loop-filtered pixels for cdef_pick_method <=
// CDEF_FAST_SEARCH_LVL5, CDEF strength values are calculated based on the
// pixel values that are not loop-filtered in svc real-time encoding mode.
// Hence this case is handled separately using the condition below.
if (cpi->ppi->rtc_ref.non_reference_frame)
return (SKIP_APPLY_LOOPFILTER | SKIP_APPLY_CDEF);
if (!cpi->oxcf.algo_cfg.skip_postproc_filtering || cpi->ppi->b_calculate_psnr)
return 0;
assert(cpi->oxcf.mode == ALLINTRA);
// The post-processing filters are applied one after the other in the
// following order: deblocking->cdef->superres->restoration. In case of
// ALLINTRA encoding, the reconstructed frame is not used as a reference
// frame. Hence, the application of these filters can be skipped when
// 1. filter parameters of the subsequent stages are not dependent on the
// filtered output of the current stage or
// 2. subsequent filtering stages are disabled
if (use_restoration) return SKIP_APPLY_RESTORATION;
if (use_superres) return SKIP_APPLY_SUPERRES;
if (use_cdef) {
// CDEF parameter selection is not dependent on the deblocked frame if
// cdef_pick_method is CDEF_PICK_FROM_Q. Hence the application of deblocking
// filters and cdef filters can be skipped in this case.
return (cpi->sf.lpf_sf.cdef_pick_method == CDEF_PICK_FROM_Q &&
use_loopfilter)
? (SKIP_APPLY_LOOPFILTER | SKIP_APPLY_CDEF)
: SKIP_APPLY_CDEF;
}
if (use_loopfilter) return SKIP_APPLY_LOOPFILTER;
// If we reach here, all post-processing stages are disabled, so none need to
// be skipped.
return 0;
}
static inline void set_postproc_filter_default_params(AV1_COMMON *cm) {
struct loopfilter *const lf = &cm->lf;
CdefInfo *const cdef_info = &cm->cdef_info;
RestorationInfo *const rst_info = cm->rst_info;
lf->filter_level[0] = 0;
lf->filter_level[1] = 0;
lf->backup_filter_level[0] = 0;
lf->backup_filter_level[1] = 0;
cdef_info->cdef_bits = 0;
cdef_info->cdef_strengths[0] = 0;
cdef_info->nb_cdef_strengths = 1;
cdef_info->cdef_uv_strengths[0] = 0;
rst_info[0].frame_restoration_type = RESTORE_NONE;
rst_info[1].frame_restoration_type = RESTORE_NONE;
rst_info[2].frame_restoration_type = RESTORE_NONE;
}
static inline int is_inter_tx_size_search_level_one(
const TX_SPEED_FEATURES *tx_sf) {
return (tx_sf->inter_tx_size_search_init_depth_rect >= 1 &&
tx_sf->inter_tx_size_search_init_depth_sqr >= 1);
}
static inline int get_lpf_opt_level(const SPEED_FEATURES *sf) {
int lpf_opt_level = 0;
if (is_inter_tx_size_search_level_one(&sf->tx_sf))
lpf_opt_level = (sf->lpf_sf.lpf_pick == LPF_PICK_FROM_Q) ? 2 : 1;
return lpf_opt_level;
}
// Enable switchable motion mode only if warp and OBMC tools are allowed
static inline bool is_switchable_motion_mode_allowed(bool allow_warped_motion,
bool enable_obmc) {
return (allow_warped_motion || enable_obmc);
}
#if CONFIG_AV1_TEMPORAL_DENOISING
static inline int denoise_svc(const struct AV1_COMP *const cpi) {
return (!cpi->ppi->use_svc ||
(cpi->ppi->use_svc &&
cpi->svc.spatial_layer_id >= cpi->svc.first_layer_denoise));
}
#endif
#if CONFIG_COLLECT_PARTITION_STATS == 2
static inline void av1_print_fr_partition_timing_stats(
const FramePartitionTimingStats *part_stats, const char *filename) {
FILE *f = fopen(filename, "w");
if (!f) {
return;
}
fprintf(f, "bsize,redo,");
for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
fprintf(f, "decision_%d,", part);
}
for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
fprintf(f, "attempt_%d,", part);
}
for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
fprintf(f, "time_%d,", part);
}
fprintf(f, "\n");
static const int bsizes[6] = { 128, 64, 32, 16, 8, 4 };
for (int bsize_idx = 0; bsize_idx < 6; bsize_idx++) {
fprintf(f, "%d,%d,", bsizes[bsize_idx], part_stats->partition_redo);
for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
fprintf(f, "%d,", part_stats->partition_decisions[bsize_idx][part]);
}
for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
fprintf(f, "%d,", part_stats->partition_attempts[bsize_idx][part]);
}
for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
fprintf(f, "%ld,", part_stats->partition_times[bsize_idx][part]);
}
fprintf(f, "\n");
}
fclose(f);
}
#endif // CONFIG_COLLECT_PARTITION_STATS == 2
#if CONFIG_COLLECT_PARTITION_STATS
static inline int av1_get_bsize_idx_for_part_stats(BLOCK_SIZE bsize) {
assert(bsize == BLOCK_128X128 || bsize == BLOCK_64X64 ||
bsize == BLOCK_32X32 || bsize == BLOCK_16X16 || bsize == BLOCK_8X8 ||
bsize == BLOCK_4X4);
switch (bsize) {
case BLOCK_128X128: return 0;
case BLOCK_64X64: return 1;
case BLOCK_32X32: return 2;
case BLOCK_16X16: return 3;
case BLOCK_8X8: return 4;
case BLOCK_4X4: return 5;
default: assert(0 && "Invalid bsize for partition_stats."); return -1;
}
}
#endif // CONFIG_COLLECT_PARTITION_STATS
#if CONFIG_COLLECT_COMPONENT_TIMING
static inline void start_timing(AV1_COMP *cpi, int component) {
aom_usec_timer_start(&cpi->component_timer[component]);
}
static inline void end_timing(AV1_COMP *cpi, int component) {
aom_usec_timer_mark(&cpi->component_timer[component]);
cpi->frame_component_time[component] +=
aom_usec_timer_elapsed(&cpi->component_timer[component]);
}
static inline char const *get_frame_type_enum(int type) {
switch (type) {
case 0: return "KEY_FRAME";
case 1: return "INTER_FRAME";
case 2: return "INTRA_ONLY_FRAME";
case 3: return "S_FRAME";
default: assert(0);
}
return "error";
}
#endif
#ifdef __cplusplus
} // extern "C"
#endif
#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