651 lines
19 KiB
C
651 lines
19 KiB
C
/*
|
|
* 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_
|