AOMedia AV1 Codec
encoder.h
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2016, Alliance for Open Media. All rights reserved
3  *
4  * This source code is subject to the terms of the BSD 2 Clause License and
5  * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
6  * was not distributed with this source code in the LICENSE file, you can
7  * obtain it at www.aomedia.org/license/software. If the Alliance for Open
8  * Media Patent License 1.0 was not distributed with this source code in the
9  * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
10  */
11 
15 #ifndef AOM_AV1_ENCODER_ENCODER_H_
16 #define AOM_AV1_ENCODER_ENCODER_H_
17 
18 #include <stdbool.h>
19 #include <stdio.h>
20 
21 #include "config/aom_config.h"
22 
23 #include "aom/aomcx.h"
24 
25 #include "av1/common/alloccommon.h"
26 #include "av1/common/av1_common_int.h"
27 #include "av1/common/blockd.h"
28 #include "av1/common/entropymode.h"
29 #include "av1/common/enums.h"
30 #include "av1/common/resize.h"
31 #include "av1/common/thread_common.h"
32 #include "av1/common/timing.h"
33 #include "av1/encoder/aq_cyclicrefresh.h"
34 #include "av1/encoder/av1_quantize.h"
35 #include "av1/encoder/block.h"
36 #include "av1/encoder/context_tree.h"
37 #include "av1/encoder/encodemb.h"
38 #include "av1/encoder/firstpass.h"
39 #include "av1/encoder/global_motion.h"
40 #include "av1/encoder/level.h"
41 #include "av1/encoder/lookahead.h"
42 #include "av1/encoder/mcomp.h"
43 #include "av1/encoder/pickcdef.h"
44 #include "av1/encoder/ratectrl.h"
45 #include "av1/encoder/rd.h"
47 #include "av1/encoder/svc_layercontext.h"
48 #include "av1/encoder/temporal_filter.h"
49 #include "av1/encoder/tokenize.h"
50 #include "av1/encoder/tpl_model.h"
51 #include "av1/encoder/av1_noise_estimate.h"
52 
53 #if CONFIG_INTERNAL_STATS
54 #include "aom_dsp/ssim.h"
55 #endif
56 #include "aom_dsp/variance.h"
57 #if CONFIG_DENOISE
58 #include "aom_dsp/noise_model.h"
59 #endif
60 #if CONFIG_TUNE_VMAF
61 #include "av1/encoder/tune_vmaf.h"
62 #endif
63 #if CONFIG_AV1_TEMPORAL_DENOISING
64 #include "av1/encoder/av1_temporal_denoiser.h"
65 #endif
66 
67 #include "aom/internal/aom_codec_internal.h"
68 #include "aom_util/aom_thread.h"
69 
70 #ifdef __cplusplus
71 extern "C" {
72 #endif
73 
74 // TODO(yunqing, any): Added suppression tag to quiet Doxygen warnings. Need to
75 // adjust it while we work on documentation.
77 // Number of frames required to test for scene cut detection
78 #define SCENE_CUT_KEY_TEST_INTERVAL 16
79 
80 // Rational number with an int64 numerator
81 // This structure holds a fractional value
82 typedef struct aom_rational64 {
83  int64_t num; // fraction numerator
84  int den; // fraction denominator
85 } aom_rational64_t; // alias for struct aom_rational
86 
87 enum {
88  NORMAL = 0,
89  FOURFIVE = 1,
90  THREEFIVE = 2,
91  THREEFOUR = 3,
92  ONEFOUR = 4,
93  ONEEIGHT = 5,
94  ONETWO = 6
95 } UENUM1BYTE(AOM_SCALING);
96 
97 enum {
98  // Good Quality Fast Encoding. The encoder balances quality with the amount of
99  // time it takes to encode the output. Speed setting controls how fast.
100  GOOD,
101  // Realtime Fast Encoding. Will force some restrictions on bitrate
102  // constraints.
103  REALTIME
104 } UENUM1BYTE(MODE);
105 
106 enum {
107  FRAMEFLAGS_KEY = 1 << 0,
108  FRAMEFLAGS_GOLDEN = 1 << 1,
109  FRAMEFLAGS_BWDREF = 1 << 2,
110  // TODO(zoeliu): To determine whether a frame flag is needed for ALTREF2_FRAME
111  FRAMEFLAGS_ALTREF = 1 << 3,
112  FRAMEFLAGS_INTRAONLY = 1 << 4,
113  FRAMEFLAGS_SWITCH = 1 << 5,
114  FRAMEFLAGS_ERROR_RESILIENT = 1 << 6,
115 } UENUM1BYTE(FRAMETYPE_FLAGS);
116 
117 enum {
118  NO_AQ = 0,
119  VARIANCE_AQ = 1,
120  COMPLEXITY_AQ = 2,
121  CYCLIC_REFRESH_AQ = 3,
122  AQ_MODE_COUNT // This should always be the last member of the enum
123 } UENUM1BYTE(AQ_MODE);
124 enum {
125  NO_DELTA_Q = 0,
126  DELTA_Q_OBJECTIVE = 1, // Modulation to improve objective quality
127  DELTA_Q_PERCEPTUAL = 2, // Modulation to improve perceptual quality
128  DELTA_Q_MODE_COUNT // This should always be the last member of the enum
129 } UENUM1BYTE(DELTAQ_MODE);
130 
131 enum {
132  RESIZE_NONE = 0, // No frame resizing allowed.
133  RESIZE_FIXED = 1, // All frames are coded at the specified scale.
134  RESIZE_RANDOM = 2, // All frames are coded at a random scale.
135  RESIZE_DYNAMIC = 3, // Frames coded at lower scale based on rate control.
136  RESIZE_MODES
137 } UENUM1BYTE(RESIZE_MODE);
138 
139 enum {
140  SS_CFG_SRC = 0,
141  SS_CFG_LOOKAHEAD = 1,
142  SS_CFG_FPF = 2,
143  SS_CFG_TOTAL = 3
144 } UENUM1BYTE(SS_CFG_OFFSET);
145 
146 enum {
147  DISABLE_SCENECUT, // For LAP, lag_in_frames < 19
148  ENABLE_SCENECUT_MODE_1, // For LAP, lag_in_frames >=19 and < 33
149  ENABLE_SCENECUT_MODE_2 // For twopass and LAP - lag_in_frames >=33
150 } UENUM1BYTE(SCENECUT_MODE);
151 
152 #define MAX_VBR_CORPUS_COMPLEXITY 10000
153 
156 typedef enum {
157  COST_UPD_SB,
158  COST_UPD_SBROW,
159  COST_UPD_TILE,
160  COST_UPD_OFF,
161 } COST_UPDATE_TYPE;
162 
163 typedef enum {
164  MOD_FP, // First pass
165  MOD_TF, // Temporal filtering
166  MOD_TPL, // TPL
167  MOD_GME, // Global motion estimation
168  MOD_ENC, // Encode stage
169  MOD_LPF, // Deblocking loop filter
170  MOD_CDEF_SEARCH, // CDEF search
171  MOD_LR, // Loop restoration filtering
172  NUM_MT_MODULES
173 } MULTI_THREADED_MODULES;
174 
180 typedef struct {
184  RESIZE_MODE resize_mode;
195 } ResizeCfg;
196 
200 typedef struct {
217  BLOCK_SIZE min_partition_size;
222  BLOCK_SIZE max_partition_size;
223 } PartitionCfg;
224 
228 typedef struct {
255 } IntraModeCfg;
256 
260 typedef struct {
294 
298 typedef struct {
325 
329 typedef struct {
360 } SuperResCfg;
361 
365 typedef struct {
370 
375 
380 
386 
393 
397  bool auto_key;
398 
403 
408 
413 } KeyFrameCfg;
414 
418 typedef struct {
420  // BUFFERING PARAMETERS
438 
443 
453  unsigned int max_intra_bitrate_pct;
458  unsigned int max_inter_bitrate_pct;
462  unsigned int gf_cbr_boost_pct;
467  unsigned int min_cr;
497  int cq_level;
502  enum aom_rc_mode mode;
509  int vbrbias;
521 
523 typedef struct {
524  // Indicates the number of frames lag before encoding is started.
525  int lag_in_frames;
526  // Indicates the minimum gf/arf interval to be used.
527  int min_gf_interval;
528  // Indicates the maximum gf/arf interval to be used.
529  int max_gf_interval;
530  // Indicates the minimum height for GF group pyramid structure to be used.
531  int gf_min_pyr_height;
532  // Indicates the maximum height for GF group pyramid structure to be used.
533  int gf_max_pyr_height;
534  // Indicates if automatic set and use of altref frames should be enabled.
535  bool enable_auto_arf;
536  // Indicates if automatic set and use of (b)ackward (r)ef (f)rames should be
537  // enabled.
538  bool enable_auto_brf;
539 } GFConfig;
540 
541 typedef struct {
542  // Indicates the number of tile groups.
543  unsigned int num_tile_groups;
544  // Indicates the MTU size for a tile group. If mtu is non-zero,
545  // num_tile_groups is set to DEFAULT_MAX_NUM_TG.
546  unsigned int mtu;
547  // Indicates the number of tile columns in log2.
548  int tile_columns;
549  // Indicates the number of tile rows in log2.
550  int tile_rows;
551  // Indicates the number of widths in the tile_widths[] array.
552  int tile_width_count;
553  // Indicates the number of heights in the tile_heights[] array.
554  int tile_height_count;
555  // Indicates the tile widths, and may be empty.
556  int tile_widths[MAX_TILE_COLS];
557  // Indicates the tile heights, and may be empty.
558  int tile_heights[MAX_TILE_ROWS];
559  // Indicates if large scale tile coding should be used.
560  bool enable_large_scale_tile;
561  // Indicates if single tile decoding mode should be enabled.
562  bool enable_single_tile_decoding;
563  // Indicates if EXT_TILE_DEBUG should be enabled.
564  bool enable_ext_tile_debug;
565 } TileConfig;
566 
567 typedef struct {
568  // Indicates the width of the input frame.
569  int width;
570  // Indicates the height of the input frame.
571  int height;
572  // If forced_max_frame_width is non-zero then it is used to force the maximum
573  // frame width written in write_sequence_header().
574  int forced_max_frame_width;
575  // If forced_max_frame_width is non-zero then it is used to force the maximum
576  // frame height written in write_sequence_header().
577  int forced_max_frame_height;
578  // Indicates the frame width after applying both super-resolution and resize
579  // to the coded frame.
580  int render_width;
581  // Indicates the frame height after applying both super-resolution and resize
582  // to the coded frame.
583  int render_height;
584 } FrameDimensionCfg;
585 
586 typedef struct {
587  // Indicates if warped motion should be enabled.
588  bool enable_warped_motion;
589  // Indicates if warped motion should be evaluated or not.
590  bool allow_warped_motion;
591  // Indicates if OBMC motion should be enabled.
592  bool enable_obmc;
593 } MotionModeCfg;
594 
595 typedef struct {
596  // Timing info for each frame.
597  aom_timing_info_t timing_info;
598  // Indicates the number of time units of a decoding clock.
599  uint32_t num_units_in_decoding_tick;
600  // Indicates if decoder model information is present in the coded sequence
601  // header.
602  bool decoder_model_info_present_flag;
603  // Indicates if display model information is present in the coded sequence
604  // header.
605  bool display_model_info_present_flag;
606  // Indicates if timing info for each frame is present.
607  bool timing_info_present;
608 } DecoderModelCfg;
609 
610 typedef struct {
611  // Indicates the update frequency for coeff costs.
612  COST_UPDATE_TYPE coeff;
613  // Indicates the update frequency for mode costs.
614  COST_UPDATE_TYPE mode;
615  // Indicates the update frequency for mv costs.
616  COST_UPDATE_TYPE mv;
617 } CostUpdateFreq;
618 
619 typedef struct {
620  // Indicates the maximum number of reference frames allowed per frame.
621  unsigned int max_reference_frames;
622  // Indicates if the reduced set of references should be enabled.
623  bool enable_reduced_reference_set;
624  // Indicates if one-sided compound should be enabled.
625  bool enable_onesided_comp;
626 } RefFrameCfg;
627 
628 typedef struct {
629  // Indicates the color space that should be used.
630  aom_color_primaries_t color_primaries;
631  // Indicates the characteristics of transfer function to be used.
632  aom_transfer_characteristics_t transfer_characteristics;
633  // Indicates the matrix coefficients to be used for the transfer function.
634  aom_matrix_coefficients_t matrix_coefficients;
635  // Indicates the chroma 4:2:0 sample position info.
636  aom_chroma_sample_position_t chroma_sample_position;
637  // Indicates if a limited color range or full color range should be used.
638  aom_color_range_t color_range;
639 } ColorCfg;
640 
641 typedef struct {
642  // Indicates if extreme motion vector unit test should be enabled or not.
643  unsigned int motion_vector_unit_test;
644  // Indicates if superblock multipass unit test should be enabled or not.
645  unsigned int sb_multipass_unit_test;
646 } UnitTestCfg;
647 
648 typedef struct {
649  // Indicates the file path to the VMAF model.
650  const char *vmaf_model_path;
651  // Indicates the path to the film grain parameters.
652  const char *film_grain_table_filename;
653  // Indicates the visual tuning metric.
654  aom_tune_metric tuning;
655  // Indicates if the current content is screen or default type.
656  aom_tune_content content;
657  // Indicates the film grain parameters.
658  int film_grain_test_vector;
659 } TuneCfg;
660 
661 typedef struct {
662  // Indicates the framerate of the input video.
663  double init_framerate;
664  // Indicates the bit-depth of the input video.
665  unsigned int input_bit_depth;
666  // Indicates the maximum number of frames to be encoded.
667  unsigned int limit;
668  // Indicates the chrome subsampling x value.
669  unsigned int chroma_subsampling_x;
670  // Indicates the chrome subsampling y value.
671  unsigned int chroma_subsampling_y;
672 } InputCfg;
673 
674 typedef struct {
675  // List of QP offsets for: keyframe, ALTREF, and 3 levels of internal ARFs.
676  // If any of these values are negative, fixed offsets are disabled.
677  // Uses internal q range.
678  double fixed_qp_offsets[FIXED_QP_OFFSET_COUNT];
679  // If true, encoder will use fixed QP offsets, that are either:
680  // - Given by the user, and stored in 'fixed_qp_offsets' array, OR
681  // - Picked automatically from cq_level.
682  int use_fixed_qp_offsets;
683  // Indicates the minimum flatness of the quantization matrix.
684  int qm_minlevel;
685  // Indicates the maximum flatness of the quantization matrix.
686  int qm_maxlevel;
687  // Indicates if adaptive quantize_b should be enabled.
688  int quant_b_adapt;
689  // Indicates the Adaptive Quantization mode to be used.
690  AQ_MODE aq_mode;
691  // Indicates the delta q mode to be used.
692  DELTAQ_MODE deltaq_mode;
693  // Indicates if delta quantization should be enabled in chroma planes.
694  bool enable_chroma_deltaq;
695  // Indicates if encoding with quantization matrices should be enabled.
696  bool using_qm;
697 } QuantizationCfg;
698 
703 typedef struct {
708 
717 
722 
727 
735 
740 
746 } AlgoCfg;
749 typedef struct {
750  // Indicates the codec bit-depth.
751  aom_bit_depth_t bit_depth;
752  // Indicates the superblock size that should be used by the encoder.
753  aom_superblock_size_t superblock_size;
754  // Indicates if loopfilter modulation should be enabled.
755  bool enable_deltalf_mode;
756  // Indicates if CDEF should be enabled.
757  bool enable_cdef;
758  // Indicates if loop restoration filter should be enabled.
759  bool enable_restoration;
760  // When enabled, video mode should be used even for single frame input.
761  bool force_video_mode;
762  // Indicates if the error resiliency features should be enabled.
763  bool error_resilient_mode;
764  // Indicates if frame parallel decoding feature should be enabled.
765  bool frame_parallel_decoding_mode;
766  // Indicates if the input should be encoded as monochrome.
767  bool enable_monochrome;
768  // When enabled, the encoder will use a full header even for still pictures.
769  // When disabled, a reduced header is used for still pictures.
770  bool full_still_picture_hdr;
771  // Indicates if dual interpolation filters should be enabled.
772  bool enable_dual_filter;
773  // Indicates if frame order hint should be enabled or not.
774  bool enable_order_hint;
775  // Indicates if ref_frame_mvs should be enabled at the sequence level.
776  bool ref_frame_mvs_present;
777  // Indicates if ref_frame_mvs should be enabled at the frame level.
778  bool enable_ref_frame_mvs;
779  // Indicates if interintra compound mode is enabled.
780  bool enable_interintra_comp;
781  // Indicates if global motion should be enabled.
782  bool enable_global_motion;
783  // Indicates if palette should be enabled.
784  bool enable_palette;
785 } ToolCfg;
786 
791 typedef struct AV1EncoderConfig {
793  // Configuration related to the input video.
794  InputCfg input_cfg;
795 
796  // Configuration related to frame-dimensions.
797  FrameDimensionCfg frm_dim_cfg;
798 
804 
809 
816  // Configuration related to Quantization.
817  QuantizationCfg q_cfg;
818 
819  // Internal frame size scaling.
820  ResizeCfg resize_cfg;
821 
822  // Frame Super-Resolution size scaling.
823  SuperResCfg superres_cfg;
824 
833  // Configuration related to encoder toolsets.
834  ToolCfg tool_cfg;
835 
836  // Configuration related to Group of frames.
837  GFConfig gf_cfg;
838 
839  // Tile related configuration parameters.
840  TileConfig tile_cfg;
841 
842  // Configuration related to Tune.
843  TuneCfg tune_cfg;
844 
845  // Configuration related to color.
846  ColorCfg color_cfg;
847 
848  // Configuration related to decoder model.
849  DecoderModelCfg dec_model_cfg;
850 
851  // Configuration related to reference frames.
852  RefFrameCfg ref_frm_cfg;
853 
854  // Configuration related to unit tests.
855  UnitTestCfg unit_test_cfg;
856 
857  // Flags related to motion mode.
858  MotionModeCfg motion_mode_cfg;
859 
860  // Flags related to intra mode search.
861  IntraModeCfg intra_mode_cfg;
862 
863  // Flags related to transform size/type.
864  TxfmSizeTypeCfg txfm_cfg;
865 
866  // Flags related to compound type.
867  CompoundTypeCfg comp_type_cfg;
868 
869  // Partition related information.
870  PartitionCfg part_cfg;
871 
872  // Configuration related to frequency of cost update.
873  CostUpdateFreq cost_upd_freq;
874 
875 #if CONFIG_DENOISE
876  // Indicates the noise level.
877  float noise_level;
878  // Indicates the the denoisers block size.
879  int noise_block_size;
880  // Indicates whether to apply denoising to the frame to be encoded
881  int enable_dnl_denoising;
882 #endif
883 
884 #if CONFIG_AV1_TEMPORAL_DENOISING
885  // Noise sensitivity.
886  int noise_sensitivity;
887 #endif
888  // Bit mask to specify which tier each of the 32 possible operating points
889  // conforms to.
890  unsigned int tier_mask;
891 
892  // Indicates the number of pixels off the edge of a reference frame we're
893  // allowed to go when forming an inter prediction.
894  int border_in_pixels;
895 
896  // Indicates the maximum number of threads that may be used by the encoder.
897  int max_threads;
898 
899  // Indicates the speed preset to be used.
900  int speed;
901 
902  // Indicates the target sequence level index for each operating point(OP).
903  AV1_LEVEL target_seq_level_idx[MAX_NUM_OPERATING_POINTS];
904 
905  // Indicates the bitstream profile to be used.
906  BITSTREAM_PROFILE profile;
907 
916  enum aom_enc_pass pass;
919  // Indicates if the encoding is GOOD or REALTIME.
920  MODE mode;
921 
922  // Indicates if row-based multi-threading should be enabled or not.
923  bool row_mt;
924 
925  // Indicates if 16bit frame buffers are to be used i.e., the content is >
926  // 8-bit.
927  bool use_highbitdepth;
928 
929  // Indicates the bitstream syntax mode. 0 indicates bitstream is saved as
930  // Section 5 bitstream, while 1 indicates the bitstream is saved in Annex - B
931  // format.
932  bool save_as_annexb;
933 
936 
938 static INLINE int is_lossless_requested(const RateControlCfg *const rc_cfg) {
939  return rc_cfg->best_allowed_q == 0 && rc_cfg->worst_allowed_q == 0;
940 }
946 typedef struct {
952  int obmc_probs[FRAME_UPDATE_TYPES][BLOCK_SIZES_ALL];
953 
959  int warped_probs[FRAME_UPDATE_TYPES];
960 
967  int tx_type_probs[FRAME_UPDATE_TYPES][TX_SIZES_ALL][TX_TYPES];
968 
975  int switchable_interp_probs[FRAME_UPDATE_TYPES][SWITCHABLE_FILTER_CONTEXTS]
976  [SWITCHABLE_FILTERS];
977 } FrameProbInfo;
978 
981 typedef struct FRAME_COUNTS {
982 // Note: This structure should only contain 'unsigned int' fields, or
983 // aggregates built solely from 'unsigned int' fields/elements
984 #if CONFIG_ENTROPY_STATS
985  unsigned int kf_y_mode[KF_MODE_CONTEXTS][KF_MODE_CONTEXTS][INTRA_MODES];
986  unsigned int angle_delta[DIRECTIONAL_MODES][2 * MAX_ANGLE_DELTA + 1];
987  unsigned int y_mode[BLOCK_SIZE_GROUPS][INTRA_MODES];
988  unsigned int uv_mode[CFL_ALLOWED_TYPES][INTRA_MODES][UV_INTRA_MODES];
989  unsigned int cfl_sign[CFL_JOINT_SIGNS];
990  unsigned int cfl_alpha[CFL_ALPHA_CONTEXTS][CFL_ALPHABET_SIZE];
991  unsigned int palette_y_mode[PALATTE_BSIZE_CTXS][PALETTE_Y_MODE_CONTEXTS][2];
992  unsigned int palette_uv_mode[PALETTE_UV_MODE_CONTEXTS][2];
993  unsigned int palette_y_size[PALATTE_BSIZE_CTXS][PALETTE_SIZES];
994  unsigned int palette_uv_size[PALATTE_BSIZE_CTXS][PALETTE_SIZES];
995  unsigned int palette_y_color_index[PALETTE_SIZES]
996  [PALETTE_COLOR_INDEX_CONTEXTS]
997  [PALETTE_COLORS];
998  unsigned int palette_uv_color_index[PALETTE_SIZES]
999  [PALETTE_COLOR_INDEX_CONTEXTS]
1000  [PALETTE_COLORS];
1001  unsigned int partition[PARTITION_CONTEXTS][EXT_PARTITION_TYPES];
1002  unsigned int txb_skip[TOKEN_CDF_Q_CTXS][TX_SIZES][TXB_SKIP_CONTEXTS][2];
1003  unsigned int eob_extra[TOKEN_CDF_Q_CTXS][TX_SIZES][PLANE_TYPES]
1004  [EOB_COEF_CONTEXTS][2];
1005  unsigned int dc_sign[PLANE_TYPES][DC_SIGN_CONTEXTS][2];
1006  unsigned int coeff_lps[TX_SIZES][PLANE_TYPES][BR_CDF_SIZE - 1][LEVEL_CONTEXTS]
1007  [2];
1008  unsigned int eob_flag[TX_SIZES][PLANE_TYPES][EOB_COEF_CONTEXTS][2];
1009  unsigned int eob_multi16[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][5];
1010  unsigned int eob_multi32[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][6];
1011  unsigned int eob_multi64[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][7];
1012  unsigned int eob_multi128[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][8];
1013  unsigned int eob_multi256[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][9];
1014  unsigned int eob_multi512[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][10];
1015  unsigned int eob_multi1024[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][11];
1016  unsigned int coeff_lps_multi[TOKEN_CDF_Q_CTXS][TX_SIZES][PLANE_TYPES]
1017  [LEVEL_CONTEXTS][BR_CDF_SIZE];
1018  unsigned int coeff_base_multi[TOKEN_CDF_Q_CTXS][TX_SIZES][PLANE_TYPES]
1019  [SIG_COEF_CONTEXTS][NUM_BASE_LEVELS + 2];
1020  unsigned int coeff_base_eob_multi[TOKEN_CDF_Q_CTXS][TX_SIZES][PLANE_TYPES]
1021  [SIG_COEF_CONTEXTS_EOB][NUM_BASE_LEVELS + 1];
1022  unsigned int newmv_mode[NEWMV_MODE_CONTEXTS][2];
1023  unsigned int zeromv_mode[GLOBALMV_MODE_CONTEXTS][2];
1024  unsigned int refmv_mode[REFMV_MODE_CONTEXTS][2];
1025  unsigned int drl_mode[DRL_MODE_CONTEXTS][2];
1026  unsigned int inter_compound_mode[INTER_MODE_CONTEXTS][INTER_COMPOUND_MODES];
1027  unsigned int wedge_idx[BLOCK_SIZES_ALL][16];
1028  unsigned int interintra[BLOCK_SIZE_GROUPS][2];
1029  unsigned int interintra_mode[BLOCK_SIZE_GROUPS][INTERINTRA_MODES];
1030  unsigned int wedge_interintra[BLOCK_SIZES_ALL][2];
1031  unsigned int compound_type[BLOCK_SIZES_ALL][MASKED_COMPOUND_TYPES];
1032  unsigned int motion_mode[BLOCK_SIZES_ALL][MOTION_MODES];
1033  unsigned int obmc[BLOCK_SIZES_ALL][2];
1034  unsigned int intra_inter[INTRA_INTER_CONTEXTS][2];
1035  unsigned int comp_inter[COMP_INTER_CONTEXTS][2];
1036  unsigned int comp_ref_type[COMP_REF_TYPE_CONTEXTS][2];
1037  unsigned int uni_comp_ref[UNI_COMP_REF_CONTEXTS][UNIDIR_COMP_REFS - 1][2];
1038  unsigned int single_ref[REF_CONTEXTS][SINGLE_REFS - 1][2];
1039  unsigned int comp_ref[REF_CONTEXTS][FWD_REFS - 1][2];
1040  unsigned int comp_bwdref[REF_CONTEXTS][BWD_REFS - 1][2];
1041  unsigned int intrabc[2];
1042 
1043  unsigned int txfm_partition[TXFM_PARTITION_CONTEXTS][2];
1044  unsigned int intra_tx_size[MAX_TX_CATS][TX_SIZE_CONTEXTS][MAX_TX_DEPTH + 1];
1045  unsigned int skip_mode[SKIP_MODE_CONTEXTS][2];
1046  unsigned int skip_txfm[SKIP_CONTEXTS][2];
1047  unsigned int compound_index[COMP_INDEX_CONTEXTS][2];
1048  unsigned int comp_group_idx[COMP_GROUP_IDX_CONTEXTS][2];
1049  unsigned int delta_q[DELTA_Q_PROBS][2];
1050  unsigned int delta_lf_multi[FRAME_LF_COUNT][DELTA_LF_PROBS][2];
1051  unsigned int delta_lf[DELTA_LF_PROBS][2];
1052 
1053  unsigned int inter_ext_tx[EXT_TX_SETS_INTER][EXT_TX_SIZES][TX_TYPES];
1054  unsigned int intra_ext_tx[EXT_TX_SETS_INTRA][EXT_TX_SIZES][INTRA_MODES]
1055  [TX_TYPES];
1056  unsigned int filter_intra_mode[FILTER_INTRA_MODES];
1057  unsigned int filter_intra[BLOCK_SIZES_ALL][2];
1058  unsigned int switchable_restore[RESTORE_SWITCHABLE_TYPES];
1059  unsigned int wiener_restore[2];
1060  unsigned int sgrproj_restore[2];
1061 #endif // CONFIG_ENTROPY_STATS
1062 
1063  unsigned int switchable_interp[SWITCHABLE_FILTER_CONTEXTS]
1064  [SWITCHABLE_FILTERS];
1065 } FRAME_COUNTS;
1066 
1067 #define INTER_MODE_RD_DATA_OVERALL_SIZE 6400
1068 
1069 typedef struct {
1070  int ready;
1071  double a;
1072  double b;
1073  double dist_mean;
1074  double ld_mean;
1075  double sse_mean;
1076  double sse_sse_mean;
1077  double sse_ld_mean;
1078  int num;
1079  double dist_sum;
1080  double ld_sum;
1081  double sse_sum;
1082  double sse_sse_sum;
1083  double sse_ld_sum;
1084 } InterModeRdModel;
1085 
1086 typedef struct {
1087  int idx;
1088  int64_t rd;
1089 } RdIdxPair;
1090 // TODO(angiebird): This is an estimated size. We still need to figure what is
1091 // the maximum number of modes.
1092 #define MAX_INTER_MODES 1024
1093 // TODO(any): rename this struct to something else. There is already another
1094 // struct called inter_mode_info, which makes this terribly confusing.
1102 typedef struct inter_modes_info {
1107  int num;
1111  MB_MODE_INFO mbmi_arr[MAX_INTER_MODES];
1115  int mode_rate_arr[MAX_INTER_MODES];
1119  int64_t sse_arr[MAX_INTER_MODES];
1123  int64_t est_rd_arr[MAX_INTER_MODES];
1127  RdIdxPair rd_idx_pair_arr[MAX_INTER_MODES];
1131  RD_STATS rd_cost_arr[MAX_INTER_MODES];
1135  RD_STATS rd_cost_y_arr[MAX_INTER_MODES];
1139  RD_STATS rd_cost_uv_arr[MAX_INTER_MODES];
1141 
1143 typedef struct {
1144  // TODO(kyslov): consider changing to 64bit
1145 
1146  // This struct is used for computing variance in choose_partitioning(), where
1147  // the max number of samples within a superblock is 32x32 (with 4x4 avg).
1148  // With 8bit bitdepth, uint32_t is enough for sum_square_error (2^8 * 2^8 * 32
1149  // * 32 = 2^26). For high bitdepth we need to consider changing this to 64 bit
1150  uint32_t sum_square_error;
1151  int32_t sum_error;
1152  int log2_count;
1153  int variance;
1154 } VPartVar;
1155 
1156 typedef struct {
1157  VPartVar none;
1158  VPartVar horz[2];
1159  VPartVar vert[2];
1160 } VPVariance;
1161 
1162 typedef struct {
1163  VPVariance part_variances;
1164  VPartVar split[4];
1165 } VP4x4;
1166 
1167 typedef struct {
1168  VPVariance part_variances;
1169  VP4x4 split[4];
1170 } VP8x8;
1171 
1172 typedef struct {
1173  VPVariance part_variances;
1174  VP8x8 split[4];
1175 } VP16x16;
1176 
1177 typedef struct {
1178  VPVariance part_variances;
1179  VP16x16 split[4];
1180 } VP32x32;
1181 
1182 typedef struct {
1183  VPVariance part_variances;
1184  VP32x32 split[4];
1185 } VP64x64;
1186 
1187 typedef struct {
1188  VPVariance part_variances;
1189  VP64x64 *split;
1190 } VP128x128;
1191 
1197 typedef struct {
1206  int64_t thresholds[5];
1207 
1214 
1218 typedef struct {
1219 #if CONFIG_MULTITHREAD
1224  pthread_mutex_t *mutex_;
1225  pthread_cond_t *cond_;
1227 #endif // CONFIG_MULTITHREAD
1233  int *num_finished_cols;
1243  int rows;
1253 
1256 // TODO(jingning) All spatially adaptive variables should go to TileDataEnc.
1257 typedef struct TileDataEnc {
1258  TileInfo tile_info;
1259  DECLARE_ALIGNED(16, FRAME_CONTEXT, tctx);
1260  FRAME_CONTEXT *row_ctx;
1261  uint8_t allow_update_cdf;
1262  InterModeRdModel inter_mode_rd_models[BLOCK_SIZES_ALL];
1263  AV1EncRowMultiThreadSync row_mt_sync;
1264  MV firstpass_top_mv;
1265 } TileDataEnc;
1266 
1267 typedef struct RD_COUNTS {
1268  int64_t comp_pred_diff[REFERENCE_MODES];
1269  int compound_ref_used_flag;
1270  int skip_mode_used_flag;
1271  int tx_type_used[TX_SIZES_ALL][TX_TYPES];
1272  int obmc_used[BLOCK_SIZES_ALL][2];
1273  int warped_used[2];
1274 } RD_COUNTS;
1275 
1276 typedef struct ThreadData {
1277  MACROBLOCK mb;
1278  RD_COUNTS rd_counts;
1279  FRAME_COUNTS *counts;
1280  PC_TREE_SHARED_BUFFERS shared_coeff_buf;
1281  SIMPLE_MOTION_DATA_TREE *sms_tree;
1282  SIMPLE_MOTION_DATA_TREE *sms_root;
1284  uint32_t *hash_value_buffer[2][2];
1285  OBMCBuffer obmc_buffer;
1286  PALETTE_BUFFER *palette_buffer;
1287  CompoundTypeRdBuffers comp_rd_buffer;
1288  CONV_BUF_TYPE *tmp_conv_dst;
1289  uint8_t *tmp_pred_bufs[2];
1290  int intrabc_used;
1291  int deltaq_used;
1292  FRAME_CONTEXT *tctx;
1293  VP64x64 *vt64x64;
1294  int32_t num_64x64_blocks;
1295  PICK_MODE_CONTEXT *firstpass_ctx;
1296  TemporalFilterData tf_data;
1297 } ThreadData;
1298 
1299 struct EncWorkerData;
1300 
1306 typedef struct {
1329 
1333  int thread_id_to_tile_id[MAX_NUM_THREADS];
1334 
1335 #if CONFIG_MULTITHREAD
1339  pthread_mutex_t *mutex_;
1340 #endif
1341 
1349  void (*sync_read_ptr)(AV1EncRowMultiThreadSync *const, int, int);
1353  void (*sync_write_ptr)(AV1EncRowMultiThreadSync *const, int, int, int);
1356 
1360 typedef struct MultiThreadInfo {
1365 
1369  int num_mod_workers[NUM_MT_MODULES];
1370 
1376 
1382 
1386  AVxWorker *workers;
1387 
1392  struct EncWorkerData *tile_thr_data;
1393 
1399 
1404 
1408  AV1TplRowMultiThreadInfo tpl_row_mt;
1409 
1413  AV1LfSync lf_row_sync;
1414 
1418  AV1LrSync lr_row_sync;
1419 
1423  AV1GlobalMotionSync gm_sync;
1424 
1428  AV1TemporalFilterSync tf_sync;
1429 
1433  AV1CdefSync cdef_sync;
1435 
1438 typedef struct ActiveMap {
1439  int enabled;
1440  int update;
1441  unsigned char *map;
1442 } ActiveMap;
1443 
1449 typedef struct {
1454  double cs_rate_array[32];
1464 
1467 #if CONFIG_INTERNAL_STATS
1468 // types of stats
1469 enum {
1470  STAT_Y,
1471  STAT_U,
1472  STAT_V,
1473  STAT_ALL,
1474  NUM_STAT_TYPES // This should always be the last member of the enum
1475 } UENUM1BYTE(StatType);
1476 
1477 typedef struct IMAGE_STAT {
1478  double stat[NUM_STAT_TYPES];
1479  double worst;
1480 } ImageStat;
1481 #endif // CONFIG_INTERNAL_STATS
1482 
1483 typedef struct {
1484  int ref_count;
1485  YV12_BUFFER_CONFIG buf;
1486 } EncRefCntBuffer;
1487 
1495 typedef struct {
1508  int stride;
1510 
1513 #if CONFIG_COLLECT_PARTITION_STATS
1514 typedef struct FramePartitionTimingStats {
1515  int partition_decisions[6][EXT_PARTITION_TYPES];
1516  int partition_attempts[6][EXT_PARTITION_TYPES];
1517  int64_t partition_times[6][EXT_PARTITION_TYPES];
1518 
1519  int partition_redo;
1520 } FramePartitionTimingStats;
1521 #endif // CONFIG_COLLECT_PARTITION_STATS
1522 
1523 #if CONFIG_COLLECT_COMPONENT_TIMING
1524 #include "aom_ports/aom_timer.h"
1525 // Adjust the following to add new components.
1526 enum {
1527  av1_encode_strategy_time,
1528  av1_get_second_pass_params_time,
1529  denoise_and_encode_time,
1530  apply_filtering_time,
1531  av1_tpl_setup_stats_time,
1532  encode_frame_to_data_rate_time,
1533  encode_with_recode_loop_time,
1534  loop_filter_time,
1535  cdef_time,
1536  loop_restoration_time,
1537  av1_pack_bitstream_final_time,
1538  av1_encode_frame_time,
1539  av1_compute_global_motion_time,
1540  av1_setup_motion_field_time,
1541  encode_sb_row_time,
1542 
1543  rd_pick_partition_time,
1544  av1_prune_partitions_time,
1545  none_partition_search_time,
1546  split_partition_search_time,
1547  rectangular_partition_search_time,
1548  ab_partitions_search_time,
1549  rd_pick_4partition_time,
1550  encode_sb_time,
1551 
1552  rd_pick_sb_modes_time,
1553  av1_rd_pick_intra_mode_sb_time,
1554  av1_rd_pick_inter_mode_sb_time,
1555  handle_inter_mode_time,
1556  evaluate_motion_mode_for_winner_candidates_time,
1557  handle_intra_mode_time,
1558  do_tx_search_time,
1559  av1_search_palette_mode_time,
1560  handle_newmv_time,
1561  compound_type_rd_time,
1562  interpolation_filter_search_time,
1563  motion_mode_rd_time,
1564  kTimingComponents,
1565 } UENUM1BYTE(TIMING_COMPONENT);
1566 
1567 static INLINE char const *get_component_name(int index) {
1568  switch (index) {
1569  case av1_encode_strategy_time: return "av1_encode_strategy_time";
1570  case av1_get_second_pass_params_time:
1571  return "av1_get_second_pass_params_time";
1572  case denoise_and_encode_time: return "denoise_and_encode_time";
1573  case apply_filtering_time: return "apply_filtering_time";
1574  case av1_tpl_setup_stats_time: return "av1_tpl_setup_stats_time";
1575  case encode_frame_to_data_rate_time:
1576  return "encode_frame_to_data_rate_time";
1577  case encode_with_recode_loop_time: return "encode_with_recode_loop_time";
1578  case loop_filter_time: return "loop_filter_time";
1579  case cdef_time: return "cdef_time";
1580  case loop_restoration_time: return "loop_restoration_time";
1581  case av1_pack_bitstream_final_time: return "av1_pack_bitstream_final_time";
1582  case av1_encode_frame_time: return "av1_encode_frame_time";
1583  case av1_compute_global_motion_time:
1584  return "av1_compute_global_motion_time";
1585  case av1_setup_motion_field_time: return "av1_setup_motion_field_time";
1586  case encode_sb_row_time: return "encode_sb_row_time";
1587 
1588  case rd_pick_partition_time: return "rd_pick_partition_time";
1589  case av1_prune_partitions_time: return "av1_prune_partitions_time";
1590  case none_partition_search_time: return "none_partition_search_time";
1591  case split_partition_search_time: return "split_partition_search_time";
1592  case rectangular_partition_search_time:
1593  return "rectangular_partition_search_time";
1594  case ab_partitions_search_time: return "ab_partitions_search_time";
1595  case rd_pick_4partition_time: return "rd_pick_4partition_time";
1596  case encode_sb_time: return "encode_sb_time";
1597 
1598  case rd_pick_sb_modes_time: return "rd_pick_sb_modes_time";
1599  case av1_rd_pick_intra_mode_sb_time:
1600  return "av1_rd_pick_intra_mode_sb_time";
1601  case av1_rd_pick_inter_mode_sb_time:
1602  return "av1_rd_pick_inter_mode_sb_time";
1603  case handle_inter_mode_time: return "handle_inter_mode_time";
1604  case evaluate_motion_mode_for_winner_candidates_time:
1605  return "evaluate_motion_mode_for_winner_candidates_time";
1606  case handle_intra_mode_time: return "handle_intra_mode_time";
1607  case do_tx_search_time: return "do_tx_search_time";
1608  case av1_search_palette_mode_time: return "av1_search_palette_mode_time";
1609  case handle_newmv_time: return "handle_newmv_time";
1610  case compound_type_rd_time: return "compound_type_rd_time";
1611  case interpolation_filter_search_time:
1612  return "interpolation_filter_search_time";
1613  case motion_mode_rd_time: return "motion_mode_rd_time";
1614  default: assert(0);
1615  }
1616  return "error";
1617 }
1618 #endif
1619 
1620 // The maximum number of internal ARFs except ALTREF_FRAME
1621 #define MAX_INTERNAL_ARFS (REF_FRAMES - BWDREF_FRAME - 1)
1622 
1628 typedef struct {
1633 
1639  YV12_BUFFER_CONFIG *ref_buf[REF_FRAMES];
1640 
1644  unsigned char *src_buffer;
1645 
1651  int num_ref_frames[MAX_DIRECTIONS];
1652 
1659  FrameDistPair reference_frames[MAX_DIRECTIONS][REF_FRAMES - 1];
1660 
1673 
1679  int src_corners[2 * MAX_CORNERS];
1681 
1691 typedef struct {
1692  int width;
1693  int height;
1695 
1699 typedef struct {
1710 
1714 typedef struct {
1734  fractional_mv_step_fp *find_fractional_mv_step;
1741  search_site_config search_site_cfg[SS_CFG_TOTAL][NUM_DISTINCT_SEARCH_METHODS];
1743 
1752 typedef struct {
1757 
1765 typedef struct {
1766  int width;
1767  int height;
1769 
1773 typedef struct {
1777  int ref_relative_dist[INTER_REFS_PER_FRAME];
1787 
1803 typedef struct {
1811  unsigned int coeff_opt_thresholds[MODE_EVAL_TYPES][2];
1812 
1817  TX_SIZE_SEARCH_METHOD tx_size_search_methods[MODE_EVAL_TYPES];
1818 
1825  unsigned int use_transform_domain_distortion[MODE_EVAL_TYPES];
1826 
1832  unsigned int tx_domain_dist_threshold[MODE_EVAL_TYPES];
1833 
1839  unsigned int skip_txfm_level[MODE_EVAL_TYPES];
1840 
1846  unsigned int predict_dc_level[MODE_EVAL_TYPES];
1848 
1856 typedef struct {
1857  bool last_frame;
1867 
1871 typedef struct {
1876 
1881 
1886 
1892 
1897 
1902 
1907 
1913 } ExternalFlags;
1914 
1917 typedef struct {
1918  int arf_stack[FRAME_BUFFERS];
1919  int arf_stack_size;
1920  int lst_stack[FRAME_BUFFERS];
1921  int lst_stack_size;
1922  int gld_stack[FRAME_BUFFERS];
1923  int gld_stack_size;
1924 } RefBufferStack;
1925 
1926 typedef struct {
1927  // Some misc info
1928  int high_prec;
1929  int q;
1930  int order;
1931 
1932  // MV counters
1933  int inter_count;
1934  int intra_count;
1935  int default_mvs;
1936  int mv_joint_count[4];
1937  int last_bit_zero;
1938  int last_bit_nonzero;
1939 
1940  // Keep track of the rates
1941  int total_mv_rate;
1942  int hp_total_mv_rate;
1943  int lp_total_mv_rate;
1944 
1945  // Texture info
1946  int horz_text;
1947  int vert_text;
1948  int diag_text;
1949 
1950  // Whether the current struct contains valid data
1951  int valid;
1952 } MV_STATS;
1953 
1954 typedef struct {
1955  struct loopfilter lf;
1956  CdefInfo cdef_info;
1957  YV12_BUFFER_CONFIG copy_buffer;
1958  RATE_CONTROL rc;
1959  MV_STATS mv_stats;
1960 } CODING_CONTEXT;
1961 
1962 typedef struct {
1963  int frame_width;
1964  int frame_height;
1965  int mi_rows;
1966  int mi_cols;
1967  int mb_rows;
1968  int mb_cols;
1969  int num_mbs;
1970  aom_bit_depth_t bit_depth;
1971  int subsampling_x;
1972  int subsampling_y;
1973 } FRAME_INFO;
1974 
1978 typedef struct {
1979  int show_frame_count;
1980 } FRAME_INDEX_SET;
1981 
1987 typedef struct {
1993  uint8_t *map;
2001 
2005 typedef struct {
2009  int64_t prev_ts_start;
2013  int64_t prev_ts_end;
2018 } TimeStamps;
2019 
2024 typedef struct {
2028  tran_low_t *tcoeff;
2032  uint16_t *eobs;
2036  uint8_t *entropy_ctx;
2037 } CoeffBufferPool;
2038 
2042 typedef struct AV1_COMP {
2047  EncQuantDequantParams enc_quant_dequant_params;
2048 
2052  ThreadData td;
2053 
2057  FRAME_COUNTS counts;
2058 
2063 
2070 
2076 
2081 
2086 
2090  struct lookahead_ctx *lookahead;
2091 
2096 
2101  TRELLIS_OPT_TYPE optimize_seg_arr[MAX_SEGMENTS];
2102 
2109 
2115 
2121 
2126 
2131 
2136 
2142 
2147 
2152 
2157 
2162 
2167  RefCntBuffer *scaled_ref_buf[INTER_REFS_PER_FRAME];
2168 
2172  RefCntBuffer *last_show_frame_buf;
2173 
2178 
2185  int fb_of_context_type[REF_FRAMES];
2186 
2191 
2197 
2203 
2207  int64_t ambient_err;
2208 
2212  RD_OPT rd;
2213 
2218  CODING_CONTEXT coding_context;
2219 
2224 
2229 
2234 
2239 
2243  double framerate;
2244 
2249  struct aom_codec_pkt_list *output_pkt_list;
2250 
2255 
2259  int speed;
2260 
2265 
2270 
2276 
2281 
2290  ActiveMap active_map;
2291 
2297  aom_variance_fn_ptr_t fn_ptr[BLOCK_SIZES_ALL];
2298 
2303 
2308 
2312  GF_STATE gf_state;
2313 
2317  RefBufferStack ref_buffer_stack;
2318 
2324 
2329 
2330 #if CONFIG_INTERNAL_STATS
2332  uint64_t time_receive_data;
2333  uint64_t time_compress_data;
2334 
2335  unsigned int mode_chosen_counts[MAX_MODES];
2336 
2337  int count[2];
2338  uint64_t total_sq_error[2];
2339  uint64_t total_samples[2];
2340  ImageStat psnr[2];
2341 
2342  double total_blockiness;
2343  double worst_blockiness;
2344 
2345  int bytes;
2346  double summed_quality;
2347  double summed_weights;
2348  double summed_quality_hbd;
2349  double summed_weights_hbd;
2350  unsigned int tot_recode_hits;
2351  double worst_ssim;
2352  double worst_ssim_hbd;
2353 
2354  ImageStat fastssim;
2355  ImageStat psnrhvs;
2356 
2357  int b_calculate_blockiness;
2358  int b_calculate_consistency;
2359 
2360  double total_inconsistency;
2361  double worst_consistency;
2362  Ssimv *ssim_vars;
2363  Metrics metrics;
2365 #endif
2366 
2371 
2372 #if CONFIG_SPEED_STATS
2376  unsigned int tx_search_count;
2377 #endif // CONFIG_SPEED_STATS
2378 
2384 
2388  FRAME_INFO frame_info;
2389 
2393  FRAME_INDEX_SET frame_index_set;
2394 
2399 
2407 
2412 
2417  TileDataEnc *tile_data;
2422 
2426  TokenInfo token_info;
2427 
2434 
2439 
2444 
2449 
2454 
2461 
2466 
2471 
2475  IntraBCMVCosts dv_costs;
2476 
2481 
2485  AV1LrStruct lr_ctxt;
2486 
2490  aom_film_grain_table_t *film_grain_table;
2491 
2492 #if CONFIG_DENOISE
2497  struct aom_denoise_and_model_t *denoise_and_model;
2498 #endif
2499 
2504 
2513 
2521 
2522 #if CONFIG_COLLECT_PARTITION_STATS
2526  FramePartitionTimingStats partition_stats;
2527 #endif // CONFIG_COLLECT_PARTITION_STATS
2528 
2529 #if CONFIG_COLLECT_COMPONENT_TIMING
2533  uint64_t component_time[kTimingComponents];
2534  struct aom_usec_timer component_timer[kTimingComponents];
2538  uint64_t frame_component_time[kTimingComponents];
2539 #endif
2540 
2544  AV1LevelParams level_params;
2545 
2550 
2555 
2576 
2577 #if CONFIG_TUNE_VMAF
2581  TuneVMAFInfo vmaf_info;
2582 #endif
2583 
2587  int use_svc;
2592 
2600  COMPRESSOR_STAGE compressor_stage;
2601 
2606  MV_STATS mv_stats;
2607 
2612  FRAME_TYPE last_frame_type;
2613 
2617  int num_tg;
2618 
2625 
2629  FirstPassData firstpass_data;
2630 
2634  NOISE_ESTIMATE noise_estimate;
2635 
2636 #if CONFIG_AV1_TEMPORAL_DENOISING
2640  AV1_DENOISER denoiser;
2641 #endif
2642 
2647  uint8_t *consec_zero_mv;
2648 
2653 
2657  BLOCK_SIZE fp_block_size;
2659 
2663 typedef struct EncodeFrameInput {
2665  YV12_BUFFER_CONFIG *source;
2666  YV12_BUFFER_CONFIG *last_source;
2667  int64_t ts_duration;
2670 
2675 typedef struct EncodeFrameParams {
2683  FRAME_TYPE frame_type;
2684 
2686  int primary_ref_frame;
2687  int order_offset;
2688 
2694 
2696  int refresh_frame_flags;
2697 
2698  int show_existing_frame;
2699  int existing_fb_idx_to_show;
2700 
2706 
2710  int remapped_ref_idx[REF_FRAMES];
2711 
2717 
2721  int speed;
2723 
2726 // EncodeFrameResults contains information about the result of encoding a
2727 // single frame
2728 typedef struct {
2729  size_t size; // Size of resulting bitstream
2730 } EncodeFrameResults;
2731 
2732 // Must not be called more than once.
2733 void av1_initialize_enc(void);
2734 
2735 struct AV1_COMP *av1_create_compressor(AV1EncoderConfig *oxcf,
2736  BufferPool *const pool,
2737  FIRSTPASS_STATS *frame_stats_buf,
2738  COMPRESSOR_STAGE stage,
2739  int num_lap_buffers,
2740  int lap_lag_in_frames,
2741  STATS_BUFFER_CTX *stats_buf_context);
2742 void av1_remove_compressor(AV1_COMP *cpi);
2743 
2744 void av1_change_config(AV1_COMP *cpi, const AV1EncoderConfig *oxcf);
2745 
2746 void av1_check_initial_width(AV1_COMP *cpi, int use_highbitdepth,
2747  int subsampling_x, int subsampling_y);
2748 
2749 void av1_init_seq_coding_tools(SequenceHeader *seq, AV1_COMMON *cm,
2750  const AV1EncoderConfig *oxcf, int use_svc);
2751 
2771  YV12_BUFFER_CONFIG *sd, int64_t time_stamp,
2772  int64_t end_time_stamp);
2773 
2798 int av1_get_compressed_data(AV1_COMP *cpi, unsigned int *frame_flags,
2799  size_t *size, uint8_t *dest, int64_t *time_stamp,
2800  int64_t *time_end, int flush,
2801  const aom_rational64_t *timebase);
2802 
2809 int av1_encode(AV1_COMP *const cpi, uint8_t *const dest,
2810  const EncodeFrameInput *const frame_input,
2811  const EncodeFrameParams *const frame_params,
2812  EncodeFrameResults *const frame_results);
2813 
2815 int av1_get_preview_raw_frame(AV1_COMP *cpi, YV12_BUFFER_CONFIG *dest);
2816 
2817 int av1_get_last_show_frame(AV1_COMP *cpi, YV12_BUFFER_CONFIG *frame);
2818 
2819 aom_codec_err_t av1_copy_new_frame_enc(AV1_COMMON *cm,
2820  YV12_BUFFER_CONFIG *new_frame,
2821  YV12_BUFFER_CONFIG *sd);
2822 
2823 int av1_use_as_reference(int *ext_ref_frame_flags, int ref_frame_flags);
2824 
2825 int av1_copy_reference_enc(AV1_COMP *cpi, int idx, YV12_BUFFER_CONFIG *sd);
2826 
2827 int av1_set_reference_enc(AV1_COMP *cpi, int idx, YV12_BUFFER_CONFIG *sd);
2828 
2829 int av1_set_size_literal(AV1_COMP *cpi, int width, int height);
2830 
2831 void av1_set_frame_size(AV1_COMP *cpi, int width, int height);
2832 
2833 int av1_set_active_map(AV1_COMP *cpi, unsigned char *map, int rows, int cols);
2834 
2835 int av1_get_active_map(AV1_COMP *cpi, unsigned char *map, int rows, int cols);
2836 
2837 int av1_set_internal_size(AV1EncoderConfig *const oxcf,
2839  AOM_SCALING horiz_mode, AOM_SCALING vert_mode);
2840 
2841 int av1_get_quantizer(struct AV1_COMP *cpi);
2842 
2843 int av1_convert_sect5obus_to_annexb(uint8_t *buffer, size_t *input_size);
2844 
2845 // Set screen content options.
2846 // This function estimates whether to use screen content tools, by counting
2847 // the portion of blocks that have few luma colors.
2848 // Modifies:
2849 // cpi->commom.features.allow_screen_content_tools
2850 // cpi->common.features.allow_intrabc
2851 // cpi->use_screen_content_tools
2852 // cpi->is_screen_content_type
2853 // However, the estimation is not accurate and may misclassify videos.
2854 // A slower but more accurate approach that determines whether to use screen
2855 // content tools is employed later. See av1_determine_sc_tools_with_encoding().
2856 void av1_set_screen_content_options(struct AV1_COMP *cpi,
2857  FeatureFlags *features);
2858 
2859 void av1_update_frame_size(AV1_COMP *cpi);
2860 
2861 // TODO(jingning): Move these functions as primitive members for the new cpi
2862 // class.
2863 static INLINE void stack_push(int *stack, int *stack_size, int item) {
2864  for (int i = *stack_size - 1; i >= 0; --i) stack[i + 1] = stack[i];
2865  stack[0] = item;
2866  ++*stack_size;
2867 }
2868 
2869 static INLINE int stack_pop(int *stack, int *stack_size) {
2870  if (*stack_size <= 0) return -1;
2871 
2872  int item = stack[0];
2873  for (int i = 0; i < *stack_size; ++i) stack[i] = stack[i + 1];
2874  --*stack_size;
2875 
2876  return item;
2877 }
2878 
2879 static INLINE int stack_pop_end(int *stack, int *stack_size) {
2880  int item = stack[*stack_size - 1];
2881  stack[*stack_size - 1] = -1;
2882  --*stack_size;
2883 
2884  return item;
2885 }
2886 
2887 static INLINE void stack_reset(int *stack, int *stack_size) {
2888  for (int i = 0; i < *stack_size; ++i) stack[i] = INVALID_IDX;
2889  *stack_size = 0;
2890 }
2891 
2892 // av1 uses 10,000,000 ticks/second as time stamp
2893 #define TICKS_PER_SEC 10000000LL
2894 
2895 static INLINE int64_t
2896 timebase_units_to_ticks(const aom_rational64_t *timestamp_ratio, int64_t n) {
2897  return n * timestamp_ratio->num / timestamp_ratio->den;
2898 }
2899 
2900 static INLINE int64_t
2901 ticks_to_timebase_units(const aom_rational64_t *timestamp_ratio, int64_t n) {
2902  int64_t round = timestamp_ratio->num / 2;
2903  if (round > 0) --round;
2904  return (n * timestamp_ratio->den + round) / timestamp_ratio->num;
2905 }
2906 
2907 static INLINE int frame_is_kf_gf_arf(const AV1_COMP *cpi) {
2908  const GF_GROUP *const gf_group = &cpi->gf_group;
2909  const FRAME_UPDATE_TYPE update_type = gf_group->update_type[gf_group->index];
2910 
2911  return frame_is_intra_only(&cpi->common) || update_type == ARF_UPDATE ||
2912  update_type == GF_UPDATE;
2913 }
2914 
2915 // TODO(huisu@google.com, youzhou@microsoft.com): enable hash-me for HBD.
2916 static INLINE int av1_use_hash_me(const AV1_COMP *const cpi) {
2918  cpi->common.features.allow_intrabc &&
2919  frame_is_intra_only(&cpi->common));
2920 }
2921 
2922 static INLINE const YV12_BUFFER_CONFIG *get_ref_frame_yv12_buf(
2923  const AV1_COMMON *const cm, MV_REFERENCE_FRAME ref_frame) {
2924  const RefCntBuffer *const buf = get_ref_frame_buf(cm, ref_frame);
2925  return buf != NULL ? &buf->buf : NULL;
2926 }
2927 
2928 static INLINE int enc_is_ref_frame_buf(const AV1_COMMON *const cm,
2929  const RefCntBuffer *const frame_buf) {
2930  MV_REFERENCE_FRAME ref_frame;
2931  for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) {
2932  const RefCntBuffer *const buf = get_ref_frame_buf(cm, ref_frame);
2933  if (buf == NULL) continue;
2934  if (frame_buf == buf) break;
2935  }
2936  return (ref_frame <= ALTREF_FRAME);
2937 }
2938 
2939 static INLINE void alloc_frame_mvs(AV1_COMMON *const cm, RefCntBuffer *buf) {
2940  assert(buf != NULL);
2941  ensure_mv_buffer(buf, cm);
2942  buf->width = cm->width;
2943  buf->height = cm->height;
2944 }
2945 
2946 // Get the allocated token size for a tile. It does the same calculation as in
2947 // the frame token allocation.
2948 static INLINE unsigned int allocated_tokens(TileInfo tile, int sb_size_log2,
2949  int num_planes) {
2950  int tile_mb_rows = (tile.mi_row_end - tile.mi_row_start + 2) >> 2;
2951  int tile_mb_cols = (tile.mi_col_end - tile.mi_col_start + 2) >> 2;
2952 
2953  return get_token_alloc(tile_mb_rows, tile_mb_cols, sb_size_log2, num_planes);
2954 }
2955 
2956 static INLINE void get_start_tok(AV1_COMP *cpi, int tile_row, int tile_col,
2957  int mi_row, TokenExtra **tok, int sb_size_log2,
2958  int num_planes) {
2959  AV1_COMMON *const cm = &cpi->common;
2960  const int tile_cols = cm->tiles.cols;
2961  TileDataEnc *this_tile = &cpi->tile_data[tile_row * tile_cols + tile_col];
2962  const TileInfo *const tile_info = &this_tile->tile_info;
2963 
2964  const int tile_mb_cols =
2965  (tile_info->mi_col_end - tile_info->mi_col_start + 2) >> 2;
2966  const int tile_mb_row = (mi_row - tile_info->mi_row_start + 2) >> 2;
2967 
2968  *tok = cpi->token_info.tile_tok[tile_row][tile_col] +
2969  get_token_alloc(tile_mb_row, tile_mb_cols, sb_size_log2, num_planes);
2970 }
2971 
2972 void av1_apply_encoding_flags(AV1_COMP *cpi, aom_enc_frame_flags_t flags);
2973 
2974 #define ALT_MIN_LAG 3
2975 static INLINE int is_altref_enabled(int lag_in_frames, bool enable_auto_arf) {
2976  return lag_in_frames >= ALT_MIN_LAG && enable_auto_arf;
2977 }
2978 
2979 // Check if statistics generation stage
2980 static INLINE int is_stat_generation_stage(const AV1_COMP *const cpi) {
2981  assert(IMPLIES(cpi->compressor_stage == LAP_STAGE,
2982  cpi->oxcf.pass == 0 && cpi->lap_enabled));
2983  return (cpi->oxcf.pass == 1 || (cpi->compressor_stage == LAP_STAGE));
2984 }
2985 // Check if statistics consumption stage
2986 static INLINE int is_stat_consumption_stage_twopass(const AV1_COMP *const cpi) {
2987  return (cpi->oxcf.pass == 2);
2988 }
2989 
2990 // Check if statistics consumption stage
2991 static INLINE int is_stat_consumption_stage(const AV1_COMP *const cpi) {
2992  return (is_stat_consumption_stage_twopass(cpi) ||
2993  (cpi->oxcf.pass == 0 && (cpi->compressor_stage == ENCODE_STAGE) &&
2994  cpi->lap_enabled));
2995 }
2996 
3006 static INLINE int has_no_stats_stage(const AV1_COMP *const cpi) {
3007  assert(IMPLIES(!cpi->lap_enabled, cpi->compressor_stage == ENCODE_STAGE));
3008  return (cpi->oxcf.pass == 0 && !cpi->lap_enabled);
3009 }
3012 // Function return size of frame stats buffer
3013 static INLINE int get_stats_buf_size(int num_lap_buffer, int num_lag_buffer) {
3014  /* if lookahead is enabled return num_lap_buffers else num_lag_buffers */
3015  return (num_lap_buffer > 0 ? num_lap_buffer + 1 : num_lag_buffer);
3016 }
3017 
3018 // TODO(zoeliu): To set up cpi->oxcf.gf_cfg.enable_auto_brf
3019 
3020 static INLINE void set_ref_ptrs(const AV1_COMMON *cm, MACROBLOCKD *xd,
3021  MV_REFERENCE_FRAME ref0,
3022  MV_REFERENCE_FRAME ref1) {
3023  xd->block_ref_scale_factors[0] =
3024  get_ref_scale_factors_const(cm, ref0 >= LAST_FRAME ? ref0 : 1);
3025  xd->block_ref_scale_factors[1] =
3026  get_ref_scale_factors_const(cm, ref1 >= LAST_FRAME ? ref1 : 1);
3027 }
3028 
3029 static INLINE int get_chessboard_index(int frame_index) {
3030  return frame_index & 0x1;
3031 }
3032 
3033 static INLINE const int *cond_cost_list_const(const struct AV1_COMP *cpi,
3034  const int *cost_list) {
3035  const int use_cost_list = cpi->sf.mv_sf.subpel_search_method != SUBPEL_TREE &&
3036  cpi->sf.mv_sf.use_fullpel_costlist;
3037  return use_cost_list ? cost_list : NULL;
3038 }
3039 
3040 static INLINE int *cond_cost_list(const struct AV1_COMP *cpi, int *cost_list) {
3041  const int use_cost_list = cpi->sf.mv_sf.subpel_search_method != SUBPEL_TREE &&
3042  cpi->sf.mv_sf.use_fullpel_costlist;
3043  return use_cost_list ? cost_list : NULL;
3044 }
3045 
3046 // Compression ratio of current frame.
3047 double av1_get_compression_ratio(const AV1_COMMON *const cm,
3048  size_t encoded_frame_size);
3049 
3050 void av1_new_framerate(AV1_COMP *cpi, double framerate);
3051 
3052 void av1_setup_frame_size(AV1_COMP *cpi);
3053 
3054 #define LAYER_IDS_TO_IDX(sl, tl, num_tl) ((sl) * (num_tl) + (tl))
3055 
3056 // Returns 1 if a frame is scaled and 0 otherwise.
3057 static INLINE int av1_resize_scaled(const AV1_COMMON *cm) {
3058  return !(cm->superres_upscaled_width == cm->render_width &&
3060 }
3061 
3062 static INLINE int av1_frame_scaled(const AV1_COMMON *cm) {
3063  return !av1_superres_scaled(cm) && av1_resize_scaled(cm);
3064 }
3065 
3066 // Don't allow a show_existing_frame to coincide with an error resilient
3067 // frame. An exception can be made for a forward keyframe since it has no
3068 // previous dependencies.
3069 static INLINE int encode_show_existing_frame(const AV1_COMMON *cm) {
3070  return cm->show_existing_frame && (!cm->features.error_resilient_mode ||
3071  cm->current_frame.frame_type == KEY_FRAME);
3072 }
3073 
3074 // Get index into the 'cpi->mbmi_ext_info.frame_base' array for the given
3075 // 'mi_row' and 'mi_col'.
3076 static INLINE int get_mi_ext_idx(const int mi_row, const int mi_col,
3077  const BLOCK_SIZE mi_alloc_bsize,
3078  const int mbmi_ext_stride) {
3079  const int mi_ext_size_1d = mi_size_wide[mi_alloc_bsize];
3080  const int mi_ext_row = mi_row / mi_ext_size_1d;
3081  const int mi_ext_col = mi_col / mi_ext_size_1d;
3082  return mi_ext_row * mbmi_ext_stride + mi_ext_col;
3083 }
3084 
3085 // Lighter version of set_offsets that only sets the mode info
3086 // pointers.
3087 static INLINE void set_mode_info_offsets(
3088  const CommonModeInfoParams *const mi_params,
3089  const MBMIExtFrameBufferInfo *const mbmi_ext_info, MACROBLOCK *const x,
3090  MACROBLOCKD *const xd, int mi_row, int mi_col) {
3091  set_mi_offsets(mi_params, xd, mi_row, mi_col);
3092  const int ext_idx = get_mi_ext_idx(mi_row, mi_col, mi_params->mi_alloc_bsize,
3094  x->mbmi_ext_frame = mbmi_ext_info->frame_base + ext_idx;
3095 }
3096 
3097 // Check to see if the given partition size is allowed for a specified number
3098 // of mi block rows and columns remaining in the image.
3099 // If not then return the largest allowed partition size
3100 static INLINE BLOCK_SIZE find_partition_size(BLOCK_SIZE bsize, int rows_left,
3101  int cols_left, int *bh, int *bw) {
3102  int int_size = (int)bsize;
3103  if (rows_left <= 0 || cols_left <= 0) {
3104  return AOMMIN(bsize, BLOCK_8X8);
3105  } else {
3106  for (; int_size > 0; int_size -= 3) {
3107  *bh = mi_size_high[int_size];
3108  *bw = mi_size_wide[int_size];
3109  if ((*bh <= rows_left) && (*bw <= cols_left)) {
3110  break;
3111  }
3112  }
3113  }
3114  return (BLOCK_SIZE)int_size;
3115 }
3116 
3117 static const uint8_t av1_ref_frame_flag_list[REF_FRAMES] = { 0,
3118  AOM_LAST_FLAG,
3119  AOM_LAST2_FLAG,
3120  AOM_LAST3_FLAG,
3121  AOM_GOLD_FLAG,
3122  AOM_BWD_FLAG,
3123  AOM_ALT2_FLAG,
3124  AOM_ALT_FLAG };
3125 
3126 // When more than 'max_allowed_refs' are available, we reduce the number of
3127 // reference frames one at a time based on this order.
3128 static const MV_REFERENCE_FRAME disable_order[] = {
3129  LAST3_FRAME,
3130  LAST2_FRAME,
3131  ALTREF2_FRAME,
3132  GOLDEN_FRAME,
3133 };
3134 
3135 static const MV_REFERENCE_FRAME
3136  ref_frame_priority_order[INTER_REFS_PER_FRAME] = {
3137  LAST_FRAME, ALTREF_FRAME, BWDREF_FRAME, GOLDEN_FRAME,
3138  ALTREF2_FRAME, LAST2_FRAME, LAST3_FRAME,
3139  };
3140 
3141 static INLINE int get_ref_frame_flags(const SPEED_FEATURES *const sf,
3142  const YV12_BUFFER_CONFIG **ref_frames,
3143  const int ext_ref_frame_flags) {
3144  // cpi->ext_flags.ref_frame_flags allows certain reference types to be
3145  // disabled by the external interface. These are set by
3146  // av1_apply_encoding_flags(). Start with what the external interface allows,
3147  // then suppress any reference types which we have found to be duplicates.
3148  int flags = ext_ref_frame_flags;
3149 
3150  for (int i = 1; i < INTER_REFS_PER_FRAME; ++i) {
3151  const YV12_BUFFER_CONFIG *const this_ref = ref_frames[i];
3152  // If this_ref has appeared before, mark the corresponding ref frame as
3153  // invalid. For nonrd mode, only disable GOLDEN_FRAME if it's the same
3154  // as LAST_FRAME or ALTREF_FRAME (if ALTREF is being used in nonrd).
3155  int index = (sf->rt_sf.use_nonrd_pick_mode &&
3156  ref_frame_priority_order[i] == GOLDEN_FRAME)
3157  ? (1 + sf->rt_sf.use_nonrd_altref_frame)
3158  : i;
3159  for (int j = 0; j < index; ++j) {
3160  if (this_ref == ref_frames[j]) {
3161  flags &= ~(1 << (ref_frame_priority_order[i] - 1));
3162  break;
3163  }
3164  }
3165  }
3166  return flags;
3167 }
3168 
3169 // Returns a Sequence Header OBU stored in an aom_fixed_buf_t, or NULL upon
3170 // failure. When a non-NULL aom_fixed_buf_t pointer is returned by this
3171 // function, the memory must be freed by the caller. Both the buf member of the
3172 // aom_fixed_buf_t, and the aom_fixed_buf_t pointer itself must be freed. Memory
3173 // returned must be freed via call to free().
3174 //
3175 // Note: The OBU returned is in Low Overhead Bitstream Format. Specifically,
3176 // the obu_has_size_field bit is set, and the buffer contains the obu_size
3177 // field.
3178 aom_fixed_buf_t *av1_get_global_headers(AV1_COMP *cpi);
3179 
3180 #define MAX_GFUBOOST_FACTOR 10.0
3181 #define MIN_GFUBOOST_FACTOR 4.0
3182 
3183 static INLINE int is_frame_tpl_eligible(const GF_GROUP *const gf_group,
3184  uint8_t index) {
3185  const FRAME_UPDATE_TYPE update_type = gf_group->update_type[index];
3186  return update_type == ARF_UPDATE || update_type == GF_UPDATE ||
3187  update_type == KF_UPDATE;
3188 }
3189 
3190 static INLINE int is_frame_eligible_for_ref_pruning(const GF_GROUP *gf_group,
3191  int selective_ref_frame,
3192  int prune_ref_frames,
3193  int gf_index) {
3194  return (selective_ref_frame > 0) && (prune_ref_frames > 0) &&
3195  !is_frame_tpl_eligible(gf_group, gf_index);
3196 }
3197 
3198 // Get update type of the current frame.
3199 static INLINE FRAME_UPDATE_TYPE
3200 get_frame_update_type(const GF_GROUP *gf_group) {
3201  return gf_group->update_type[gf_group->index];
3202 }
3203 
3204 static INLINE int av1_pixels_to_mi(int pixels) {
3205  return ALIGN_POWER_OF_TWO(pixels, 3) >> MI_SIZE_LOG2;
3206 }
3207 
3208 static AOM_INLINE int is_psnr_calc_enabled(const AV1_COMP *cpi) {
3209  const AV1_COMMON *const cm = &cpi->common;
3210 
3211  return cpi->b_calculate_psnr && !is_stat_generation_stage(cpi) &&
3212  cm->show_frame;
3213 }
3214 
3215 #if CONFIG_AV1_TEMPORAL_DENOISING
3216 static INLINE int denoise_svc(const struct AV1_COMP *const cpi) {
3217  return (!cpi->use_svc || (cpi->use_svc && cpi->svc.spatial_layer_id >=
3218  cpi->svc.first_layer_denoise));
3219 }
3220 #endif
3221 
3222 #if CONFIG_COLLECT_PARTITION_STATS == 2
3223 static INLINE void av1_print_fr_partition_timing_stats(
3224  const FramePartitionTimingStats *part_stats, const char *filename) {
3225  FILE *f = fopen(filename, "w");
3226  if (!f) {
3227  return;
3228  }
3229 
3230  fprintf(f, "bsize,redo,");
3231  for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
3232  fprintf(f, "decision_%d,", part);
3233  }
3234  for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
3235  fprintf(f, "attempt_%d,", part);
3236  }
3237  for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
3238  fprintf(f, "time_%d,", part);
3239  }
3240  fprintf(f, "\n");
3241 
3242  static const int bsizes[6] = { 128, 64, 32, 16, 8, 4 };
3243 
3244  for (int bsize_idx = 0; bsize_idx < 6; bsize_idx++) {
3245  fprintf(f, "%d,%d,", bsizes[bsize_idx], part_stats->partition_redo);
3246  for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
3247  fprintf(f, "%d,", part_stats->partition_decisions[bsize_idx][part]);
3248  }
3249  for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
3250  fprintf(f, "%d,", part_stats->partition_attempts[bsize_idx][part]);
3251  }
3252  for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
3253  fprintf(f, "%ld,", part_stats->partition_times[bsize_idx][part]);
3254  }
3255  fprintf(f, "\n");
3256  }
3257  fclose(f);
3258 }
3259 #endif // CONFIG_COLLECT_PARTITION_STATS == 2
3260 
3261 #if CONFIG_COLLECT_PARTITION_STATS
3262 static INLINE int av1_get_bsize_idx_for_part_stats(BLOCK_SIZE bsize) {
3263  assert(bsize == BLOCK_128X128 || bsize == BLOCK_64X64 ||
3264  bsize == BLOCK_32X32 || bsize == BLOCK_16X16 || bsize == BLOCK_8X8 ||
3265  bsize == BLOCK_4X4);
3266  switch (bsize) {
3267  case BLOCK_128X128: return 0;
3268  case BLOCK_64X64: return 1;
3269  case BLOCK_32X32: return 2;
3270  case BLOCK_16X16: return 3;
3271  case BLOCK_8X8: return 4;
3272  case BLOCK_4X4: return 5;
3273  default: assert(0 && "Invalid bsize for partition_stats."); return -1;
3274  }
3275 }
3276 #endif // CONFIG_COLLECT_PARTITION_STATS
3277 
3278 #if CONFIG_COLLECT_COMPONENT_TIMING
3279 static INLINE void start_timing(AV1_COMP *cpi, int component) {
3280  aom_usec_timer_start(&cpi->component_timer[component]);
3281 }
3282 static INLINE void end_timing(AV1_COMP *cpi, int component) {
3283  aom_usec_timer_mark(&cpi->component_timer[component]);
3284  cpi->frame_component_time[component] +=
3285  aom_usec_timer_elapsed(&cpi->component_timer[component]);
3286 }
3287 static INLINE char const *get_frame_type_enum(int type) {
3288  switch (type) {
3289  case 0: return "KEY_FRAME";
3290  case 1: return "INTER_FRAME";
3291  case 2: return "INTRA_ONLY_FRAME";
3292  case 3: return "S_FRAME";
3293  default: assert(0);
3294  }
3295  return "error";
3296 }
3297 #endif
3298 
3301 #ifdef __cplusplus
3302 } // extern "C"
3303 #endif
3304 
3305 #endif // AOM_AV1_ENCODER_ENCODER_H_
#define FIXED_QP_OFFSET_COUNT
Number of fixed QP offsets.
Definition: aom_encoder.h:876
enum aom_chroma_sample_position aom_chroma_sample_position_t
List of chroma sample positions.
enum aom_transfer_characteristics aom_transfer_characteristics_t
List of supported transfer functions.
enum aom_color_range aom_color_range_t
List of supported color range.
enum aom_color_primaries aom_color_primaries_t
List of supported color primaries.
enum aom_matrix_coefficients aom_matrix_coefficients_t
List of supported matrix coefficients.
Provides definitions for using AOM or AV1 encoder algorithm within the aom Codec Interface.
struct AV1_COMP AV1_COMP
Top level encoder structure.
struct EncodeFrameParams EncodeFrameParams
contains per-frame encoding parameters decided upon by av1_encode_strategy() and passed down to av1_e...
struct EncodeFrameInput EncodeFrameInput
Input frames and last input frame.
struct MultiThreadInfo MultiThreadInfo
Encoder parameters related to multi-threading.
struct inter_modes_info InterModesInfo
Struct used to hold inter mode data for fast tx search.
struct AV1EncoderConfig AV1EncoderConfig
Main encoder configuration data structure.
@ RESTORE_SWITCHABLE_TYPES
Definition: enums.h:654
aom_tune_content
Definition: aomcx.h:1388
aom_tune_metric
Model tuning parameters.
Definition: aomcx.h:1407
enum aom_bit_depth aom_bit_depth_t
Bit depth for codecThis enumeration determines the bit depth of the codec.
enum aom_superblock_size aom_superblock_size_t
Superblock size selection.
aom_codec_err_t
Algorithm return codes.
Definition: aom_codec.h:155
aom_superres_mode
Frame super-resolution mode.
Definition: aom_encoder.h:187
aom_rc_mode
Rate control mode.
Definition: aom_encoder.h:165
aom_enc_pass
Multi-pass Encoding Pass.
Definition: aom_encoder.h:158
long aom_enc_frame_flags_t
Encoded Frame Flags.
Definition: aom_encoder.h:357
int av1_receive_raw_frame(AV1_COMP *cpi, aom_enc_frame_flags_t frame_flags, YV12_BUFFER_CONFIG *sd, int64_t time_stamp, int64_t end_time_stamp)
Obtain the raw frame data.
Definition: encoder.c:3407
int av1_encode(AV1_COMP *const cpi, uint8_t *const dest, const EncodeFrameInput *const frame_input, const EncodeFrameParams *const frame_params, EncodeFrameResults *const frame_results)
Run 1-pass/2-pass encoding.
Definition: encoder.c:3318
int av1_get_compressed_data(AV1_COMP *cpi, unsigned int *frame_flags, size_t *size, uint8_t *dest, int64_t *time_stamp, int64_t *time_end, int flush, const aom_rational64_t *timebase)
Encode a frame.
Definition: encoder.c:3608
static int has_no_stats_stage(const AV1_COMP *const cpi)
Check if the current stage has statistics.
Definition: encoder.h:3006
Describes look ahead buffer operations.
Top level common structure used by both encoder and decoder.
Definition: av1_common_int.h:723
int superres_upscaled_width
Definition: av1_common_int.h:772
int superres_upscaled_height
Definition: av1_common_int.h:773
int width
Definition: av1_common_int.h:748
CurrentFrame current_frame
Definition: av1_common_int.h:727
int show_existing_frame
Definition: av1_common_int.h:877
FeatureFlags features
Definition: av1_common_int.h:882
int show_frame
Definition: av1_common_int.h:862
CommonTileParams tiles
Definition: av1_common_int.h:969
int height
Definition: av1_common_int.h:749
int render_width
Definition: av1_common_int.h:759
int render_height
Definition: av1_common_int.h:760
Encoder data related to row-based multi-threading.
Definition: encoder.h:1306
pthread_mutex_t * mutex_
Definition: encoder.h:1339
int allocated_tile_cols
Definition: encoder.h:1314
int allocated_cols
Definition: encoder.h:1328
int allocated_tile_rows
Definition: encoder.h:1310
int allocated_rows
Definition: encoder.h:1321
Encoder parameters for synchronization of row based multi-threading.
Definition: encoder.h:1218
int rows
Definition: encoder.h:1243
int sync_range
Definition: encoder.h:1239
int next_mi_row
Definition: encoder.h:1247
pthread_mutex_t * mutex_
Definition: encoder.h:1224
pthread_cond_t * cond_
Definition: encoder.h:1225
int num_threads_working
Definition: encoder.h:1251
Main encoder configuration data structure.
Definition: encoder.h:791
RateControlCfg rc_cfg
Definition: encoder.h:813
KeyFrameCfg kf_cfg
Definition: encoder.h:808
enum aom_enc_pass pass
Definition: encoder.h:916
AlgoCfg algo_cfg
Definition: encoder.h:803
aom_fixed_buf_t twopass_stats_in
Definition: encoder.h:830
Top level encoder structure.
Definition: encoder.h:2042
uint8_t * consec_zero_mv
Definition: encoder.h:2647
struct aom_denoise_and_model_t * denoise_and_model
Definition: encoder.h:2497
int vaq_refresh
Definition: encoder.h:2438
FRAME_TYPE last_frame_type
Definition: encoder.h:2612
YV12_BUFFER_CONFIG * unscaled_source
Definition: encoder.h:2120
CYCLIC_REFRESH * cyclic_refresh
Definition: encoder.h:2285
int partition_search_skippable_frame
Definition: encoder.h:2156
aom_variance_fn_ptr_t fn_ptr[BLOCK_SIZES_ALL]
Definition: encoder.h:2297
InitialDimensions initial_dimensions
Definition: encoder.h:2398
RATE_CONTROL rc
Definition: encoder.h:2238
int deltaq_used
Definition: encoder.h:2549
ActiveMap active_map
Definition: encoder.h:2290
TokenInfo token_info
Definition: encoder.h:2426
struct lookahead_ctx * lookahead
Definition: encoder.h:2090
int64_t ambient_err
Definition: encoder.h:2207
aom_film_grain_table_t * film_grain_table
Definition: encoder.h:2490
int b_calculate_psnr
Definition: encoder.h:2370
int lap_enabled
Definition: encoder.h:2596
IntraBCMVCosts dv_costs
Definition: encoder.h:2475
SPEED_FEATURES sf
Definition: encoder.h:2264
TRELLIS_OPT_TYPE optimize_seg_arr[8]
Definition: encoder.h:2101
double * ssim_rdmult_scaling_factors
Definition: encoder.h:2575
RD_OPT rd
Definition: encoder.h:2212
int num_tg
Definition: encoder.h:2617
FrameProbInfo frame_probs
Definition: encoder.h:2448
WinnerModeParams winner_mode_params
Definition: encoder.h:2228
double * tpl_sb_rdmult_scaling_factors
Definition: encoder.h:2569
ExternalFlags ext_flags
Definition: encoder.h:2190
EncSegmentationInfo enc_seg
Definition: encoder.h:2280
MotionVectorSearchParams mv_search_params
Definition: encoder.h:2269
int use_screen_content_tools
Definition: encoder.h:2512
CODING_CONTEXT coding_context
Definition: encoder.h:2218
TemporalFilterCtx tf_ctx
Definition: encoder.h:2151
ForceIntegerMVInfo force_intpel_info
Definition: encoder.h:2161
GlobalMotionInfo gm_info
Definition: encoder.h:2223
CoeffBufferPool coeff_buffer_pool
Definition: encoder.h:2075
FRAME_INDEX_SET frame_index_set
Definition: encoder.h:2393
int ref_frame_flags
Definition: encoder.h:2254
RefCntBuffer * scaled_ref_buf[INTER_REFS_PER_FRAME]
Definition: encoder.h:2167
AV1EncoderConfig oxcf
Definition: encoder.h:2085
AV1_COMMON common
Definition: encoder.h:2080
int show_existing_alt_ref
Definition: encoder.h:2328
AV1LrStruct lr_ctxt
Definition: encoder.h:2485
TplParams tpl_data
Definition: encoder.h:2146
FRAME_COUNTS counts
Definition: encoder.h:2057
GF_GROUP gf_group
Definition: encoder.h:2307
COMPRESSOR_STAGE compressor_stage
Definition: encoder.h:2600
int intrabc_used
Definition: encoder.h:2470
int seq_params_locked
Definition: encoder.h:2433
int no_show_fwd_kf
Definition: encoder.h:2095
int prune_ref_frame_mask
Definition: encoder.h:2480
YV12_BUFFER_CONFIG * unscaled_last_source
Definition: encoder.h:2130
int all_one_sided_refs
Definition: encoder.h:2275
MultiThreadInfo mt_info
Definition: encoder.h:2453
VarBasedPartitionInfo vbp_info
Definition: encoder.h:2443
YV12_BUFFER_CONFIG * last_source
Definition: encoder.h:2114
int existing_fb_idx_to_show
Definition: encoder.h:2460
YV12_BUFFER_CONFIG alt_ref_buffer
Definition: encoder.h:2323
YV12_BUFFER_CONFIG * unfiltered_source
Definition: encoder.h:2141
GF_STATE gf_state
Definition: encoder.h:2312
FRAME_INFO frame_info
Definition: encoder.h:2388
int droppable
Definition: encoder.h:2383
RefCntBuffer * last_show_frame_buf
Definition: encoder.h:2172
aom_superres_mode superres_mode
Definition: encoder.h:2624
MBMIExtFrameBufferInfo mbmi_ext_info
Definition: encoder.h:2062
int use_svc
Definition: encoder.h:2587
double * tpl_rdmult_scaling_factors
Definition: encoder.h:2564
int internal_altref_allowed
Definition: encoder.h:2465
RefBufferStack ref_buffer_stack
Definition: encoder.h:2317
TileDataEnc * tile_data
Definition: encoder.h:2417
int is_screen_content_type
Definition: encoder.h:2520
InterpSearchFlags interp_search_flags
Definition: encoder.h:2503
AV1LevelParams level_params
Definition: encoder.h:2544
TimeStamps time_stamps
Definition: encoder.h:2233
int frames_left
Definition: encoder.h:2652
FirstPassData firstpass_data
Definition: encoder.h:2629
double framerate
Definition: encoder.h:2243
TWO_PASS twopass
Definition: encoder.h:2302
int speed
Definition: encoder.h:2259
BLOCK_SIZE fp_block_size
Definition: encoder.h:2657
int fb_of_context_type[REF_FRAMES]
Definition: encoder.h:2185
YV12_BUFFER_CONFIG trial_frame_rst
Definition: encoder.h:2202
ThreadData td
Definition: encoder.h:2052
ResizePendingParams resize_pending_params
Definition: encoder.h:2411
YV12_BUFFER_CONFIG scaled_source
Definition: encoder.h:2125
YV12_BUFFER_CONFIG last_frame_uf
Definition: encoder.h:2196
EncQuantDequantParams enc_quant_dequant_params
Definition: encoder.h:2047
RefFrameDistanceInfo ref_frame_dist_info
Definition: encoder.h:2554
int initial_mbs
Definition: encoder.h:2406
YV12_BUFFER_CONFIG scaled_last_source
Definition: encoder.h:2135
MV_STATS mv_stats
Definition: encoder.h:2606
YV12_BUFFER_CONFIG * source
Definition: encoder.h:2108
int allocated_tiles
Definition: encoder.h:2421
RefreshFrameFlagsInfo refresh_frame
Definition: encoder.h:2177
struct aom_codec_pkt_list * output_pkt_list
Definition: encoder.h:2249
SVC svc
Definition: encoder.h:2591
CB_COEFF_BUFFER * coeff_buffer_base
Definition: encoder.h:2069
NOISE_ESTIMATE noise_estimate
Definition: encoder.h:2634
Algorithm configuration parameters.
Definition: encoder.h:703
int disable_trellis_quant
Definition: encoder.h:716
int sharpness
Definition: encoder.h:707
int arnr_max_frames
Definition: encoder.h:721
bool enable_tpl_model
Definition: encoder.h:739
uint8_t cdf_update_mode
Definition: encoder.h:734
bool enable_overlay
Definition: encoder.h:745
int arnr_strength
Definition: encoder.h:726
Stores the transforms coefficients for the whole superblock.
Definition: block.h:180
The stucture of CYCLIC_REFRESH.
Definition: aq_cyclicrefresh.h:34
Parameters related to CDEF.
Definition: av1_common_int.h:194
Definition: encoder.h:2024
uint8_t * entropy_ctx
Definition: encoder.h:2036
tran_low_t * tcoeff
Definition: encoder.h:2028
uint16_t * eobs
Definition: encoder.h:2032
Params related to MB_MODE_INFO arrays and related info.
Definition: av1_common_int.h:477
BLOCK_SIZE mi_alloc_bsize
Definition: av1_common_int.h:526
int cols
Definition: av1_common_int.h:404
Encoder flags for compound prediction modes.
Definition: encoder.h:298
bool enable_masked_comp
Definition: encoder.h:307
bool enable_diff_wtd_comp
Definition: encoder.h:315
bool enable_smooth_interintra
Definition: encoder.h:311
bool enable_interintra_wedge
Definition: encoder.h:323
bool enable_interinter_wedge
Definition: encoder.h:319
bool enable_dist_wtd_comp
Definition: encoder.h:302
Contains buffers used by av1_compound_type_rd()
Definition: block.h:372
Segmentation related information for the current frame.
Definition: encoder.h:1987
uint8_t * map
Definition: encoder.h:1993
bool has_lossless_segment
Definition: encoder.h:1999
Input frames and last input frame.
Definition: encoder.h:2663
contains per-frame encoding parameters decided upon by av1_encode_strategy() and passed down to av1_e...
Definition: encoder.h:2675
int error_resilient_mode
Definition: encoder.h:2679
int remapped_ref_idx[REF_FRAMES]
Definition: encoder.h:2710
int ref_frame_flags
Definition: encoder.h:2705
int speed
Definition: encoder.h:2721
FRAME_TYPE frame_type
Definition: encoder.h:2683
int show_frame
Definition: encoder.h:2693
RefreshFrameFlagsInfo refresh_frame
Definition: encoder.h:2716
Frame refresh flags set by the external interface.
Definition: encoder.h:1856
bool golden_frame
Definition: encoder.h:1858
bool bwd_ref_frame
Definition: encoder.h:1859
bool update_pending
Definition: encoder.h:1865
bool last_frame
Definition: encoder.h:1857
bool alt_ref_frame
Definition: encoder.h:1861
bool alt2_ref_frame
Definition: encoder.h:1860
Flags signalled by the external interface at frame level.
Definition: encoder.h:1871
bool use_primary_ref_none
Definition: encoder.h:1912
bool use_ref_frame_mvs
Definition: encoder.h:1896
ExtRefreshFrameFlagsInfo refresh_frame
Definition: encoder.h:1880
int ref_frame_flags
Definition: encoder.h:1875
bool use_error_resilient
Definition: encoder.h:1901
bool use_s_frame
Definition: encoder.h:1906
bool refresh_frame_context
Definition: encoder.h:1885
bool refresh_frame_context_pending
Definition: encoder.h:1891
The stucture of acummulated frame stats in the first pass.
Definition: firstpass.h:36
Frame level features.
Definition: av1_common_int.h:334
bool allow_screen_content_tools
Definition: av1_common_int.h:351
bool allow_intrabc
Definition: av1_common_int.h:352
bool error_resilient_mode
Definition: av1_common_int.h:376
Encoder info used for decision on forcing integer motion vectors.
Definition: encoder.h:1449
int rate_size
Definition: encoder.h:1462
int rate_index
Definition: encoder.h:1458
Encoder-side probabilities for pruning of various AV1 tools.
Definition: encoder.h:946
Data related to the current GF/ARF group and the individual frames within the group.
Definition: firstpass.h:171
Parameters related to global motion search.
Definition: encoder.h:1628
bool search_done
Definition: encoder.h:1632
int segment_map_h
Definition: encoder.h:1666
int num_src_corners
Definition: encoder.h:1672
unsigned char * src_buffer
Definition: encoder.h:1644
int segment_map_w
Definition: encoder.h:1665
Initial frame dimensions.
Definition: encoder.h:1691
int height
Definition: encoder.h:1693
int width
Definition: encoder.h:1692
Flags related to interpolation filter search.
Definition: encoder.h:1699
int default_interp_skip_flags
Definition: encoder.h:1704
uint16_t interp_filter_search_mask
Definition: encoder.h:1708
Encoder flags for intra prediction.
Definition: encoder.h:228
bool enable_smooth_intra
Definition: encoder.h:241
bool enable_filter_intra
Definition: encoder.h:237
bool enable_paeth_intra
Definition: encoder.h:245
bool enable_intra_edge_filter
Definition: encoder.h:232
bool enable_cfl_intra
Definition: encoder.h:249
bool enable_angle_delta
Definition: encoder.h:254
Encoder config related to the coding of key frames.
Definition: encoder.h:365
int key_freq_max
Definition: encoder.h:374
int sframe_mode
Definition: encoder.h:392
bool auto_key
Definition: encoder.h:397
bool enable_intrabc
Definition: encoder.h:412
int sframe_dist
Definition: encoder.h:385
bool enable_sframe
Definition: encoder.h:407
int enable_keyframe_filtering
Definition: encoder.h:379
int key_freq_min
Definition: encoder.h:369
bool fwd_kf_enabled
Definition: encoder.h:402
Buffer to store mode information at mi_alloc_bsize (4x4 or 8x8) level.
Definition: encoder.h:1495
int alloc_size
Definition: encoder.h:1504
int stride
Definition: encoder.h:1508
MB_MODE_INFO_EXT_FRAME * frame_base
Definition: encoder.h:1500
Stores best extended mode information at frame level.
Definition: block.h:216
Stores the prediction/txfm mode of the current coding block.
Definition: blockd.h:221
Parameters for motion vector search process.
Definition: encoder.h:1714
int max_mv_magnitude
Definition: encoder.h:1720
fractional_mv_step_fp * find_fractional_mv_step
Definition: encoder.h:1734
int mv_step_param
Definition: encoder.h:1725
Encoder parameters related to multi-threading.
Definition: encoder.h:1360
AV1LrSync lr_row_sync
Definition: encoder.h:1418
struct EncWorkerData * tile_thr_data
Definition: encoder.h:1392
AV1TplRowMultiThreadInfo tpl_row_mt
Definition: encoder.h:1408
int enc_mt_buf_init_done
Definition: encoder.h:1381
AV1EncRowMultiThreadInfo enc_row_mt
Definition: encoder.h:1403
AV1LfSync lf_row_sync
Definition: encoder.h:1413
AV1CdefSync cdef_sync
Definition: encoder.h:1433
int num_mod_workers[NUM_MT_MODULES]
Definition: encoder.h:1369
int num_workers
Definition: encoder.h:1364
AVxWorker * workers
Definition: encoder.h:1386
int fp_mt_buf_init_done
Definition: encoder.h:1375
bool row_mt_enabled
Definition: encoder.h:1398
AV1TemporalFilterSync tf_sync
Definition: encoder.h:1428
AV1GlobalMotionSync gm_sync
Definition: encoder.h:1423
Contains buffers used to speed up rdopt for obmc.
Definition: block.h:335
Contains color maps used in palette mode.
Definition: block.h:360
Encoder config for coding block partitioning.
Definition: encoder.h:200
bool enable_rect_partitions
Definition: encoder.h:204
bool enable_1to4_partitions
Definition: encoder.h:212
BLOCK_SIZE max_partition_size
Definition: encoder.h:222
bool enable_ab_partitions
Definition: encoder.h:208
BLOCK_SIZE min_partition_size
Definition: encoder.h:217
Rate Control parameters and status.
Definition: ratectrl.h:118
Encoder rate control configuration parameters.
Definition: encoder.h:418
int worst_allowed_q
Definition: encoder.h:488
int over_shoot_pct
Definition: encoder.h:483
unsigned int max_intra_bitrate_pct
Definition: encoder.h:453
int drop_frames_water_mark
Definition: encoder.h:471
int vbrmax_section
Definition: encoder.h:519
int64_t maximum_buffer_size_ms
Definition: encoder.h:437
unsigned int vbr_corpus_complexity_lap
Definition: encoder.h:448
unsigned int min_cr
Definition: encoder.h:467
int vbrbias
Definition: encoder.h:509
unsigned int gf_cbr_boost_pct
Definition: encoder.h:462
int vbrmin_section
Definition: encoder.h:514
unsigned int max_inter_bitrate_pct
Definition: encoder.h:458
int64_t starting_buffer_level_ms
Definition: encoder.h:427
int best_allowed_q
Definition: encoder.h:493
int under_shoot_pct
Definition: encoder.h:477
int64_t target_bandwidth
Definition: encoder.h:442
int64_t optimal_buffer_level_ms
Definition: encoder.h:432
int cq_level
Definition: encoder.h:497
Refrence frame distance related variables.
Definition: encoder.h:1773
int8_t nearest_past_ref
Definition: encoder.h:1781
int8_t nearest_future_ref
Definition: encoder.h:1785
Refresh frame flags for different type of frames.
Definition: encoder.h:1752
bool alt_ref_frame
Definition: encoder.h:1755
bool bwd_ref_frame
Definition: encoder.h:1754
bool golden_frame
Definition: encoder.h:1753
Encoder config related to resize.
Definition: encoder.h:180
uint8_t resize_scale_denominator
Definition: encoder.h:189
uint8_t resize_kf_scale_denominator
Definition: encoder.h:194
RESIZE_MODE resize_mode
Definition: encoder.h:184
Desired dimensions for an externally triggered resize.
Definition: encoder.h:1765
int width
Definition: encoder.h:1766
int height
Definition: encoder.h:1767
Top level speed vs quality trade off data struture.
Definition: speed_features.h:1064
MV_SPEED_FEATURES mv_sf
Definition: speed_features.h:1088
REAL_TIME_SPEED_FEATURES rt_sf
Definition: speed_features.h:1128
The stucture of SVC.
Definition: svc_layercontext.h:91
Encoder config related to frame super-resolution.
Definition: encoder.h:329
uint8_t superres_kf_scale_denominator
Definition: encoder.h:351
aom_superres_mode superres_mode
Definition: encoder.h:355
int superres_kf_qthresh
Definition: encoder.h:339
bool enable_superres
Definition: encoder.h:359
uint8_t superres_scale_denominator
Definition: encoder.h:345
int superres_qthresh
Definition: encoder.h:334
Two pass status and control data.
Definition: firstpass.h:216
Parameters related to temporal filtering.
Definition: temporal_filter.h:75
Frame time stamps.
Definition: encoder.h:2005
int64_t prev_ts_start
Definition: encoder.h:2009
int64_t first_ts_start
Definition: encoder.h:2017
int64_t prev_ts_end
Definition: encoder.h:2013
Params related to temporal dependency model.
Definition: tpl_model.h:120
Encoder flags for transform sizes and types.
Definition: encoder.h:260
bool enable_tx64
Definition: encoder.h:264
bool use_inter_dct_only
Definition: encoder.h:287
bool enable_flip_idtx
Definition: encoder.h:268
bool use_intra_default_tx_only
Definition: encoder.h:292
bool use_intra_dct_only
Definition: encoder.h:282
bool enable_rect_tx
Definition: encoder.h:272
bool reduced_tx_type_set
Definition: encoder.h:277
Thresholds for variance based partitioning.
Definition: encoder.h:1197
int64_t threshold_minmax
Definition: encoder.h:1212
Parameters used for winner mode processing.
Definition: encoder.h:1803
Generic fixed size buffer structure.
Definition: aom_encoder.h:76
Struct used to hold inter mode data for fast tx search.
Definition: encoder.h:1102
RD_STATS rd_cost_arr[MAX_INTER_MODES]
Definition: encoder.h:1131
int64_t est_rd_arr[MAX_INTER_MODES]
Definition: encoder.h:1123
int64_t sse_arr[MAX_INTER_MODES]
Definition: encoder.h:1119
RD_STATS rd_cost_y_arr[MAX_INTER_MODES]
Definition: encoder.h:1135
RD_STATS rd_cost_uv_arr[MAX_INTER_MODES]
Definition: encoder.h:1139
MB_MODE_INFO mbmi_arr[MAX_INTER_MODES]
Definition: encoder.h:1111
RdIdxPair rd_idx_pair_arr[MAX_INTER_MODES]
Definition: encoder.h:1127
int mode_rate_arr[MAX_INTER_MODES]
Definition: encoder.h:1115
int num
Definition: encoder.h:1107
Encoder's parameters related to the current coding block.
Definition: block.h:829
MB_MODE_INFO_EXT_FRAME * mbmi_ext_frame
Finalized mbmi_ext for the whole frame.
Definition: block.h:861
Variables related to current coding block.
Definition: blockd.h:577
const struct scale_factors * block_ref_scale_factors[2]
Definition: blockd.h:694
YV12 frame buffer data structure.
Definition: yv12config.h:38