/* * 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_COMMON_ENUMS_H_ #define AOM_AV1_COMMON_ENUMS_H_ #include "config/aom_config.h" #include "aom/aom_codec.h" #include "aom/aom_integer.h" #include "aom_dsp/txfm_common.h" #include "aom_ports/mem.h" #ifdef __cplusplus extern "C" { #endif /*! @file */ /*!\cond */ // Max superblock size #define MAX_SB_SIZE_LOG2 7 #define MAX_SB_SIZE (1 << MAX_SB_SIZE_LOG2) #define MAX_SB_SQUARE (MAX_SB_SIZE * MAX_SB_SIZE) // Min superblock size #define MIN_SB_SIZE_LOG2 6 // Pixels per Mode Info (MI) unit #define MI_SIZE_LOG2 2 #define MI_SIZE (1 << MI_SIZE_LOG2) // MI-units per max superblock (MI Block - MIB) #define MAX_MIB_SIZE_LOG2 (MAX_SB_SIZE_LOG2 - MI_SIZE_LOG2) #define MAX_MIB_SIZE (1 << MAX_MIB_SIZE_LOG2) // MI-units per min superblock #define MIN_MIB_SIZE_LOG2 (MIN_SB_SIZE_LOG2 - MI_SIZE_LOG2) // Mask to extract MI offset within max MIB #define MAX_MIB_MASK (MAX_MIB_SIZE - 1) // Maximum number of tile rows and tile columns #define MAX_TILE_ROWS 64 #define MAX_TILE_COLS 64 #define MAX_VARTX_DEPTH 2 #define MI_SIZE_64X64 (64 >> MI_SIZE_LOG2) #define MI_SIZE_128X128 (128 >> MI_SIZE_LOG2) #define MAX_PALETTE_SQUARE (64 * 64) // Maximum number of colors in a palette. #define PALETTE_MAX_SIZE 8 // Minimum number of colors in a palette. #define PALETTE_MIN_SIZE 2 #define FRAME_OFFSET_BITS 5 #define MAX_FRAME_DISTANCE ((1 << FRAME_OFFSET_BITS) - 1) // 4 frame filter levels: y plane vertical, y plane horizontal, // u plane, and v plane #define FRAME_LF_COUNT 4 #define DEFAULT_DELTA_LF_MULTI 0 #define MAX_MODE_LF_DELTAS 2 #define DIST_PRECISION_BITS 4 #define DIST_PRECISION (1 << DIST_PRECISION_BITS) // 16 #define PROFILE_BITS 3 // The following three profiles are currently defined. // Profile 0. 8-bit and 10-bit 4:2:0 and 4:0:0 only. // Profile 1. 8-bit and 10-bit 4:4:4 // Profile 2. 8-bit and 10-bit 4:2:2 // 12-bit 4:0:0, 4:2:2 and 4:4:4 // Since we have three bits for the profiles, it can be extended later. enum { PROFILE_0, PROFILE_1, PROFILE_2, MAX_PROFILES, } SENUM1BYTE(BITSTREAM_PROFILE); #define OP_POINTS_CNT_MINUS_1_BITS 5 #define OP_POINTS_IDC_BITS 12 // Note: Some enums use the attribute 'packed' to use smallest possible integer // type, so that we can save memory when they are used in structs/arrays. typedef enum ATTRIBUTE_PACKED { BLOCK_4X4, BLOCK_4X8, BLOCK_8X4, BLOCK_8X8, BLOCK_8X16, BLOCK_16X8, BLOCK_16X16, BLOCK_16X32, BLOCK_32X16, BLOCK_32X32, BLOCK_32X64, BLOCK_64X32, BLOCK_64X64, BLOCK_64X128, BLOCK_128X64, BLOCK_128X128, BLOCK_4X16, BLOCK_16X4, BLOCK_8X32, BLOCK_32X8, BLOCK_16X64, BLOCK_64X16, BLOCK_SIZES_ALL, BLOCK_SIZES = BLOCK_4X16, BLOCK_INVALID = 255, BLOCK_LARGEST = (BLOCK_SIZES - 1) } BLOCK_SIZE; // 4X4, 8X8, 16X16, 32X32, 64X64, 128X128 #define SQR_BLOCK_SIZES 6 // Partition types. R: Recursive // // NONE HORZ VERT SPLIT // +-------+ +-------+ +---+---+ +---+---+ // | | | | | | | | R | R | // | | +-------+ | | | +---+---+ // | | | | | | | | R | R | // +-------+ +-------+ +---+---+ +---+---+ // // HORZ_A HORZ_B VERT_A VERT_B // +---+---+ +-------+ +---+---+ +---+---+ // | | | | | | | | | | | // +---+---+ +---+---+ +---+ | | +---+ // | | | | | | | | | | | // +-------+ +---+---+ +---+---+ +---+---+ // // HORZ_4 VERT_4 // +-----+ +-+-+-+ // +-----+ | | | | // +-----+ | | | | // +-----+ +-+-+-+ enum { PARTITION_NONE, PARTITION_HORZ, PARTITION_VERT, PARTITION_SPLIT, PARTITION_HORZ_A, // HORZ split and the top partition is split again PARTITION_HORZ_B, // HORZ split and the bottom partition is split again PARTITION_VERT_A, // VERT split and the left partition is split again PARTITION_VERT_B, // VERT split and the right partition is split again PARTITION_HORZ_4, // 4:1 horizontal partition PARTITION_VERT_4, // 4:1 vertical partition EXT_PARTITION_TYPES, PARTITION_TYPES = PARTITION_SPLIT + 1, PARTITION_INVALID = 255 } UENUM1BYTE(PARTITION_TYPE); typedef char PARTITION_CONTEXT; #define PARTITION_PLOFFSET 4 // number of probability models per block size #define PARTITION_BLOCK_SIZES 5 #define PARTITION_CONTEXTS (PARTITION_BLOCK_SIZES * PARTITION_PLOFFSET) #define TX_SIZE_LUMA_MIN (TX_4X4) /* We don't need to code a transform size unless the allowed size is at least one more than the minimum. */ #define TX_SIZE_CTX_MIN (TX_SIZE_LUMA_MIN + 1) // Maximum tx_size categories #define MAX_TX_CATS (TX_SIZES - TX_SIZE_CTX_MIN) #define MAX_TX_DEPTH 2 #define MAX_TX_SIZE_LOG2 (6) #define MAX_TX_SIZE (1 << MAX_TX_SIZE_LOG2) #define MIN_TX_SIZE_LOG2 2 #define MIN_TX_SIZE (1 << MIN_TX_SIZE_LOG2) #define MAX_TX_SQUARE (MAX_TX_SIZE * MAX_TX_SIZE) // Pad 4 extra columns to remove horizontal availability check. #define TX_PAD_HOR_LOG2 2 #define TX_PAD_HOR 4 // Pad 6 extra rows (2 on top and 4 on bottom) to remove vertical availability // check. #define TX_PAD_TOP 0 #define TX_PAD_BOTTOM 4 #define TX_PAD_VER (TX_PAD_TOP + TX_PAD_BOTTOM) // Pad 16 extra bytes to avoid reading overflow in SIMD optimization. #define TX_PAD_END 16 #define TX_PAD_2D ((32 + TX_PAD_HOR) * (32 + TX_PAD_VER) + TX_PAD_END) // Number of maximum size transform blocks in the maximum size superblock #define MAX_TX_BLOCKS_IN_MAX_SB_LOG2 ((MAX_SB_SIZE_LOG2 - MAX_TX_SIZE_LOG2) * 2) #define MAX_TX_BLOCKS_IN_MAX_SB (1 << MAX_TX_BLOCKS_IN_MAX_SB_LOG2) // frame transform mode enum { ONLY_4X4, // use only 4x4 transform TX_MODE_LARGEST, // transform size is the largest possible for pu size TX_MODE_SELECT, // transform specified for each block TX_MODES, } UENUM1BYTE(TX_MODE); // 1D tx types enum { DCT_1D, ADST_1D, FLIPADST_1D, IDTX_1D, TX_TYPES_1D, } UENUM1BYTE(TX_TYPE_1D); enum { REG_REG, REG_SMOOTH, REG_SHARP, SMOOTH_REG, SMOOTH_SMOOTH, SMOOTH_SHARP, SHARP_REG, SHARP_SMOOTH, SHARP_SHARP, } UENUM1BYTE(DUAL_FILTER_TYPE); #define EXT_TX_SIZES 4 // number of sizes that use extended transforms #define EXT_TX_SETS_INTER 4 // Sets of transform selections for INTER #define EXT_TX_SETS_INTRA 3 // Sets of transform selections for INTRA enum { AOM_LAST_FLAG = 1 << 0, AOM_LAST2_FLAG = 1 << 1, AOM_LAST3_FLAG = 1 << 2, AOM_GOLD_FLAG = 1 << 3, AOM_BWD_FLAG = 1 << 4, AOM_ALT2_FLAG = 1 << 5, AOM_ALT_FLAG = 1 << 6, AOM_REFFRAME_ALL = (1 << 7) - 1 } UENUM1BYTE(AOM_REFFRAME); enum { UNIDIR_COMP_REFERENCE, BIDIR_COMP_REFERENCE, COMP_REFERENCE_TYPES, } UENUM1BYTE(COMP_REFERENCE_TYPE); enum { PLANE_TYPE_Y, PLANE_TYPE_UV, PLANE_TYPES } UENUM1BYTE(PLANE_TYPE); #define CFL_ALPHABET_SIZE_LOG2 4 #define CFL_ALPHABET_SIZE (1 << CFL_ALPHABET_SIZE_LOG2) #define CFL_MAGS_SIZE ((2 << CFL_ALPHABET_SIZE_LOG2) + 1) #define CFL_INDEX_ZERO CFL_ALPHABET_SIZE #define CFL_IDX_U(idx) (idx >> CFL_ALPHABET_SIZE_LOG2) #define CFL_IDX_V(idx) (idx & (CFL_ALPHABET_SIZE - 1)) enum { CFL_PRED_U, CFL_PRED_V, CFL_PRED_PLANES } UENUM1BYTE(CFL_PRED_TYPE); enum { CFL_SIGN_ZERO, CFL_SIGN_NEG, CFL_SIGN_POS, CFL_SIGNS } UENUM1BYTE(CFL_SIGN_TYPE); enum { CFL_DISALLOWED, CFL_ALLOWED, CFL_ALLOWED_TYPES } UENUM1BYTE(CFL_ALLOWED_TYPE); // CFL_SIGN_ZERO,CFL_SIGN_ZERO is invalid #define CFL_JOINT_SIGNS (CFL_SIGNS * CFL_SIGNS - 1) // CFL_SIGN_U is equivalent to (js + 1) / 3 for js in 0 to 8 #define CFL_SIGN_U(js) (((js + 1) * 11) >> 5) // CFL_SIGN_V is equivalent to (js + 1) % 3 for js in 0 to 8 #define CFL_SIGN_V(js) ((js + 1) - CFL_SIGNS * CFL_SIGN_U(js)) // There is no context when the alpha for a given plane is zero. // So there are 2 fewer contexts than joint signs. #define CFL_ALPHA_CONTEXTS (CFL_JOINT_SIGNS + 1 - CFL_SIGNS) #define CFL_CONTEXT_U(js) (js + 1 - CFL_SIGNS) // Also, the contexts are symmetric under swapping the planes. #define CFL_CONTEXT_V(js) \ (CFL_SIGN_V(js) * CFL_SIGNS + CFL_SIGN_U(js) - CFL_SIGNS) enum { PALETTE_MAP, COLOR_MAP_TYPES, } UENUM1BYTE(COLOR_MAP_TYPE); enum { TWO_COLORS, THREE_COLORS, FOUR_COLORS, FIVE_COLORS, SIX_COLORS, SEVEN_COLORS, EIGHT_COLORS, PALETTE_SIZES } UENUM1BYTE(PALETTE_SIZE); enum { PALETTE_COLOR_ONE, PALETTE_COLOR_TWO, PALETTE_COLOR_THREE, PALETTE_COLOR_FOUR, PALETTE_COLOR_FIVE, PALETTE_COLOR_SIX, PALETTE_COLOR_SEVEN, PALETTE_COLOR_EIGHT, PALETTE_COLORS } UENUM1BYTE(PALETTE_COLOR); // Note: All directional predictors must be between V_PRED and D67_PRED (both // inclusive). enum { DC_PRED, // Average of above and left pixels V_PRED, // Vertical H_PRED, // Horizontal D45_PRED, // Directional 45 degree D135_PRED, // Directional 135 degree D113_PRED, // Directional 113 degree D157_PRED, // Directional 157 degree D203_PRED, // Directional 203 degree D67_PRED, // Directional 67 degree SMOOTH_PRED, // Combination of horizontal and vertical interpolation SMOOTH_V_PRED, // Vertical interpolation SMOOTH_H_PRED, // Horizontal interpolation PAETH_PRED, // Predict from the direction of smallest gradient NEARESTMV, NEARMV, GLOBALMV, NEWMV, // Compound ref compound modes NEAREST_NEARESTMV, NEAR_NEARMV, NEAREST_NEWMV, NEW_NEARESTMV, NEAR_NEWMV, NEW_NEARMV, GLOBAL_GLOBALMV, NEW_NEWMV, MB_MODE_COUNT, PRED_MODE_INVALID = MB_MODE_COUNT, INTRA_MODE_START = DC_PRED, INTRA_MODE_END = NEARESTMV, DIR_MODE_START = V_PRED, DIR_MODE_END = D67_PRED + 1, INTRA_MODE_NUM = INTRA_MODE_END - INTRA_MODE_START, SINGLE_INTER_MODE_START = NEARESTMV, SINGLE_INTER_MODE_END = NEAREST_NEARESTMV, SINGLE_INTER_MODE_NUM = SINGLE_INTER_MODE_END - SINGLE_INTER_MODE_START, COMP_INTER_MODE_START = NEAREST_NEARESTMV, COMP_INTER_MODE_END = MB_MODE_COUNT, COMP_INTER_MODE_NUM = COMP_INTER_MODE_END - COMP_INTER_MODE_START, INTER_MODE_START = NEARESTMV, INTER_MODE_END = MB_MODE_COUNT, INTRA_MODES = PAETH_PRED + 1, // PAETH_PRED has to be the last intra mode. INTRA_INVALID = MB_MODE_COUNT // For uv_mode in inter blocks } UENUM1BYTE(PREDICTION_MODE); // TODO(ltrudeau) Do we really want to pack this? // TODO(ltrudeau) Do we match with PREDICTION_MODE? enum { UV_DC_PRED, // Average of above and left pixels UV_V_PRED, // Vertical UV_H_PRED, // Horizontal UV_D45_PRED, // Directional 45 degree UV_D135_PRED, // Directional 135 degree UV_D113_PRED, // Directional 113 degree UV_D157_PRED, // Directional 157 degree UV_D203_PRED, // Directional 203 degree UV_D67_PRED, // Directional 67 degree UV_SMOOTH_PRED, // Combination of horizontal and vertical interpolation UV_SMOOTH_V_PRED, // Vertical interpolation UV_SMOOTH_H_PRED, // Horizontal interpolation UV_PAETH_PRED, // Predict from the direction of smallest gradient UV_CFL_PRED, // Chroma-from-Luma UV_INTRA_MODES, UV_MODE_INVALID, // For uv_mode in inter blocks } UENUM1BYTE(UV_PREDICTION_MODE); // Number of top model rd to store for pruning y modes in intra mode decision #define TOP_INTRA_MODEL_COUNT 4 // Total number of luma intra prediction modes (include both directional and // non-directional modes) // Because there are 8 directional modes, each has additional 6 delta angles. #define LUMA_MODE_COUNT (PAETH_PRED - DC_PRED + 1 + 6 * 8) enum { SIMPLE_TRANSLATION, OBMC_CAUSAL, // 2-sided OBMC WARPED_CAUSAL, // 2-sided WARPED MOTION_MODES } UENUM1BYTE(MOTION_MODE); enum { II_DC_PRED, II_V_PRED, II_H_PRED, II_SMOOTH_PRED, INTERINTRA_MODES } UENUM1BYTE(INTERINTRA_MODE); enum { COMPOUND_AVERAGE, COMPOUND_DISTWTD, COMPOUND_WEDGE, COMPOUND_DIFFWTD, COMPOUND_TYPES, MASKED_COMPOUND_TYPES = 2, } UENUM1BYTE(COMPOUND_TYPE); enum { FILTER_DC_PRED, FILTER_V_PRED, FILTER_H_PRED, FILTER_D157_PRED, FILTER_PAETH_PRED, FILTER_INTRA_MODES, } UENUM1BYTE(FILTER_INTRA_MODE); enum { SEQ_LEVEL_2_0, SEQ_LEVEL_2_1, SEQ_LEVEL_2_2, SEQ_LEVEL_2_3, SEQ_LEVEL_3_0, SEQ_LEVEL_3_1, SEQ_LEVEL_3_2, SEQ_LEVEL_3_3, SEQ_LEVEL_4_0, SEQ_LEVEL_4_1, SEQ_LEVEL_4_2, SEQ_LEVEL_4_3, SEQ_LEVEL_5_0, SEQ_LEVEL_5_1, SEQ_LEVEL_5_2, SEQ_LEVEL_5_3, SEQ_LEVEL_6_0, SEQ_LEVEL_6_1, SEQ_LEVEL_6_2, SEQ_LEVEL_6_3, SEQ_LEVEL_7_0, SEQ_LEVEL_7_1, SEQ_LEVEL_7_2, SEQ_LEVEL_7_3, SEQ_LEVEL_8_0, SEQ_LEVEL_8_1, SEQ_LEVEL_8_2, SEQ_LEVEL_8_3, SEQ_LEVELS, SEQ_LEVEL_MAX = 31, SEQ_LEVEL_KEEP_STATS = 32, } UENUM1BYTE(AV1_LEVEL); #define LEVEL_BITS 5 #define DIRECTIONAL_MODES 8 #define MAX_ANGLE_DELTA 3 #define ANGLE_STEP 3 #define INTER_MODES (1 + NEWMV - NEARESTMV) #define INTER_COMPOUND_MODES (1 + NEW_NEWMV - NEAREST_NEARESTMV) #define SKIP_CONTEXTS 3 #define SKIP_MODE_CONTEXTS 3 #define COMP_INDEX_CONTEXTS 6 #define COMP_GROUP_IDX_CONTEXTS 6 #define NMV_CONTEXTS 3 #define NEWMV_MODE_CONTEXTS 6 #define GLOBALMV_MODE_CONTEXTS 2 #define REFMV_MODE_CONTEXTS 6 #define DRL_MODE_CONTEXTS 3 #define GLOBALMV_OFFSET 3 #define REFMV_OFFSET 4 #define NEWMV_CTX_MASK ((1 << GLOBALMV_OFFSET) - 1) #define GLOBALMV_CTX_MASK ((1 << (REFMV_OFFSET - GLOBALMV_OFFSET)) - 1) #define REFMV_CTX_MASK ((1 << (8 - REFMV_OFFSET)) - 1) #define COMP_NEWMV_CTXS 5 #define INTER_MODE_CONTEXTS 8 #define DELTA_Q_SMALL 3 #define DELTA_Q_PROBS (DELTA_Q_SMALL) #define DEFAULT_DELTA_Q_RES_PERCEPTUAL 4 #define DEFAULT_DELTA_Q_RES_OBJECTIVE 4 #define DEFAULT_DELTA_Q_RES_DUCKY_ENCODE 4 #define DELTA_LF_SMALL 3 #define DELTA_LF_PROBS (DELTA_LF_SMALL) #define DEFAULT_DELTA_LF_RES 2 /* Segment Feature Masks */ #define MAX_MV_REF_CANDIDATES 2 #define MAX_REF_MV_STACK_SIZE 8 #define USABLE_REF_MV_STACK_SIZE 4 #define REF_CAT_LEVEL 640 #define INTRA_INTER_CONTEXTS 4 #define COMP_INTER_CONTEXTS 5 #define REF_CONTEXTS 3 #define COMP_REF_TYPE_CONTEXTS 5 #define UNI_COMP_REF_CONTEXTS 3 #define TXFM_PARTITION_CONTEXTS ((TX_SIZES - TX_8X8) * 6 - 3) typedef uint8_t TXFM_CONTEXT; // An enum for single reference types (and some derived values). enum { NONE_FRAME = -1, INTRA_FRAME, LAST_FRAME, LAST2_FRAME, LAST3_FRAME, GOLDEN_FRAME, BWDREF_FRAME, ALTREF2_FRAME, ALTREF_FRAME, REF_FRAMES, // Extra/scratch reference frame. It may be: // - used to update the ALTREF2_FRAME ref (see lshift_bwd_ref_frames()), or // - updated from ALTREF2_FRAME ref (see rshift_bwd_ref_frames()). EXTREF_FRAME = REF_FRAMES, // Number of inter (non-intra) reference types. INTER_REFS_PER_FRAME = ALTREF_FRAME - LAST_FRAME + 1, // Number of forward (aka past) reference types. FWD_REFS = GOLDEN_FRAME - LAST_FRAME + 1, // Number of backward (aka future) reference types. BWD_REFS = ALTREF_FRAME - BWDREF_FRAME + 1, SINGLE_REFS = FWD_REFS + BWD_REFS, }; #define REF_FRAMES_LOG2 3 // REF_FRAMES for the cm->ref_frame_map array, 1 scratch frame for the new // frame in cm->cur_frame, INTER_REFS_PER_FRAME for scaled references on the // encoder in the cpi->scaled_ref_buf array. // The encoder uses FRAME_BUFFERS only in GOOD and REALTIME encoding modes. // The decoder also uses FRAME_BUFFERS. #define FRAME_BUFFERS (REF_FRAMES + 1 + INTER_REFS_PER_FRAME) // During allintra encoding, one reference frame buffer is free to be used again // only after another frame buffer is stored as the reference frame. Hence, it // is necessary and sufficient to maintain only two reference frame buffers in // this case. #define FRAME_BUFFERS_ALLINTRA 2 #define FWD_RF_OFFSET(ref) (ref - LAST_FRAME) #define BWD_RF_OFFSET(ref) (ref - BWDREF_FRAME) // Select all the decoded frame buffer slots #define SELECT_ALL_BUF_SLOTS 0xFF enum { LAST_LAST2_FRAMES, // { LAST_FRAME, LAST2_FRAME } LAST_LAST3_FRAMES, // { LAST_FRAME, LAST3_FRAME } LAST_GOLDEN_FRAMES, // { LAST_FRAME, GOLDEN_FRAME } BWDREF_ALTREF_FRAMES, // { BWDREF_FRAME, ALTREF_FRAME } LAST2_LAST3_FRAMES, // { LAST2_FRAME, LAST3_FRAME } LAST2_GOLDEN_FRAMES, // { LAST2_FRAME, GOLDEN_FRAME } LAST3_GOLDEN_FRAMES, // { LAST3_FRAME, GOLDEN_FRAME } BWDREF_ALTREF2_FRAMES, // { BWDREF_FRAME, ALTREF2_FRAME } ALTREF2_ALTREF_FRAMES, // { ALTREF2_FRAME, ALTREF_FRAME } TOTAL_UNIDIR_COMP_REFS, // NOTE: UNIDIR_COMP_REFS is the number of uni-directional reference pairs // that are explicitly signaled. UNIDIR_COMP_REFS = BWDREF_ALTREF_FRAMES + 1, } UENUM1BYTE(UNIDIR_COMP_REF); #define TOTAL_COMP_REFS (FWD_REFS * BWD_REFS + TOTAL_UNIDIR_COMP_REFS) #define COMP_REFS (FWD_REFS * BWD_REFS + UNIDIR_COMP_REFS) // NOTE: A limited number of unidirectional reference pairs can be signalled for // compound prediction. The use of skip mode, on the other hand, makes it // possible to have a reference pair not listed for explicit signaling. #define MODE_CTX_REF_FRAMES (REF_FRAMES + TOTAL_COMP_REFS) // Note: It includes single and compound references. So, it can take values from // NONE_FRAME to (MODE_CTX_REF_FRAMES - 1). Hence, it is not defined as an enum. typedef int8_t MV_REFERENCE_FRAME; /*!\endcond */ /*!\enum RestorationType * \brief This enumeration defines various restoration types supported */ typedef enum { RESTORE_NONE, /**< No restoration */ RESTORE_WIENER, /**< Separable Wiener restoration */ RESTORE_SGRPROJ, /**< Selfguided restoration */ RESTORE_SWITCHABLE, /**< Switchable restoration */ RESTORE_SWITCHABLE_TYPES = RESTORE_SWITCHABLE, /**< Num Switchable types */ RESTORE_TYPES = 4, /**< Num Restore types */ } RestorationType; /*!\cond */ // Picture prediction structures (0-13 are predefined) in scalability metadata. enum { SCALABILITY_L1T2 = 0, SCALABILITY_L1T3 = 1, SCALABILITY_L2T1 = 2, SCALABILITY_L2T2 = 3, SCALABILITY_L2T3 = 4, SCALABILITY_S2T1 = 5, SCALABILITY_S2T2 = 6, SCALABILITY_S2T3 = 7, SCALABILITY_L2T1h = 8, SCALABILITY_L2T2h = 9, SCALABILITY_L2T3h = 10, SCALABILITY_S2T1h = 11, SCALABILITY_S2T2h = 12, SCALABILITY_S2T3h = 13, SCALABILITY_SS = 14 } UENUM1BYTE(SCALABILITY_STRUCTURES); #define SUPERRES_SCALE_BITS 3 #define SUPERRES_SCALE_DENOMINATOR_MIN (SCALE_NUMERATOR + 1) // In large_scale_tile coding, external references are used. #define MAX_EXTERNAL_REFERENCES 128 #define MAX_TILES 512 /*!\endcond */ #ifdef __cplusplus } // extern "C" #endif #endif // AOM_AV1_COMMON_ENUMS_H_