enums.h (19024B)
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 12 #ifndef AOM_AV1_COMMON_ENUMS_H_ 13 #define AOM_AV1_COMMON_ENUMS_H_ 14 15 #include "config/aom_config.h" 16 17 #include "aom/aom_codec.h" 18 #include "aom/aom_integer.h" 19 #include "aom_dsp/txfm_common.h" 20 #include "aom_ports/mem.h" 21 22 #ifdef __cplusplus 23 extern "C" { 24 #endif 25 26 /*! @file */ 27 28 /*!\cond */ 29 30 // Max superblock size 31 #define MAX_SB_SIZE_LOG2 7 32 #define MAX_SB_SIZE (1 << MAX_SB_SIZE_LOG2) 33 #define MAX_SB_SQUARE (MAX_SB_SIZE * MAX_SB_SIZE) 34 35 // Min superblock size 36 #define MIN_SB_SIZE_LOG2 6 37 38 // Pixels per Mode Info (MI) unit 39 #define MI_SIZE_LOG2 2 40 #define MI_SIZE (1 << MI_SIZE_LOG2) 41 42 // MI-units per max superblock (MI Block - MIB) 43 #define MAX_MIB_SIZE_LOG2 (MAX_SB_SIZE_LOG2 - MI_SIZE_LOG2) 44 #define MAX_MIB_SIZE (1 << MAX_MIB_SIZE_LOG2) 45 46 // MI-units per min superblock 47 #define MIN_MIB_SIZE_LOG2 (MIN_SB_SIZE_LOG2 - MI_SIZE_LOG2) 48 49 // Mask to extract MI offset within max MIB 50 #define MAX_MIB_MASK (MAX_MIB_SIZE - 1) 51 52 // Maximum number of tile rows and tile columns 53 #define MAX_TILE_ROWS 64 54 #define MAX_TILE_COLS 64 55 56 #define MAX_VARTX_DEPTH 2 57 58 #define MI_SIZE_64X64 (64 >> MI_SIZE_LOG2) 59 #define MI_SIZE_128X128 (128 >> MI_SIZE_LOG2) 60 61 #define MAX_PALETTE_SQUARE (64 * 64) 62 // Maximum number of colors in a palette. 63 #define PALETTE_MAX_SIZE 8 64 // Minimum number of colors in a palette. 65 #define PALETTE_MIN_SIZE 2 66 67 #define FRAME_OFFSET_BITS 5 68 #define MAX_FRAME_DISTANCE ((1 << FRAME_OFFSET_BITS) - 1) 69 70 // 4 frame filter levels: y plane vertical, y plane horizontal, 71 // u plane, and v plane 72 #define FRAME_LF_COUNT 4 73 #define DEFAULT_DELTA_LF_MULTI 0 74 #define MAX_MODE_LF_DELTAS 2 75 76 #define DIST_PRECISION_BITS 4 77 #define DIST_PRECISION (1 << DIST_PRECISION_BITS) // 16 78 79 #define PROFILE_BITS 3 80 // The following three profiles are currently defined. 81 // Profile 0. 8-bit and 10-bit 4:2:0 and 4:0:0 only. 82 // Profile 1. 8-bit and 10-bit 4:4:4 83 // Profile 2. 8-bit and 10-bit 4:2:2 84 // 12-bit 4:0:0, 4:2:2 and 4:4:4 85 // Since we have three bits for the profiles, it can be extended later. 86 enum { 87 PROFILE_0, 88 PROFILE_1, 89 PROFILE_2, 90 MAX_PROFILES, 91 } SENUM1BYTE(BITSTREAM_PROFILE); 92 93 #define OP_POINTS_CNT_MINUS_1_BITS 5 94 #define OP_POINTS_IDC_BITS 12 95 96 // Note: Some enums use the attribute 'packed' to use smallest possible integer 97 // type, so that we can save memory when they are used in structs/arrays. 98 99 typedef enum ATTRIBUTE_PACKED { 100 BLOCK_4X4, 101 BLOCK_4X8, 102 BLOCK_8X4, 103 BLOCK_8X8, 104 BLOCK_8X16, 105 BLOCK_16X8, 106 BLOCK_16X16, 107 BLOCK_16X32, 108 BLOCK_32X16, 109 BLOCK_32X32, 110 BLOCK_32X64, 111 BLOCK_64X32, 112 BLOCK_64X64, 113 BLOCK_64X128, 114 BLOCK_128X64, 115 BLOCK_128X128, 116 BLOCK_4X16, 117 BLOCK_16X4, 118 BLOCK_8X32, 119 BLOCK_32X8, 120 BLOCK_16X64, 121 BLOCK_64X16, 122 BLOCK_SIZES_ALL, 123 BLOCK_SIZES = BLOCK_4X16, 124 BLOCK_INVALID = 255, 125 BLOCK_LARGEST = (BLOCK_SIZES - 1) 126 } BLOCK_SIZE; 127 128 // 4X4, 8X8, 16X16, 32X32, 64X64, 128X128 129 #define SQR_BLOCK_SIZES 6 130 131 // Partition types. R: Recursive 132 // 133 // NONE HORZ VERT SPLIT 134 // +-------+ +-------+ +---+---+ +---+---+ 135 // | | | | | | | | R | R | 136 // | | +-------+ | | | +---+---+ 137 // | | | | | | | | R | R | 138 // +-------+ +-------+ +---+---+ +---+---+ 139 // 140 // HORZ_A HORZ_B VERT_A VERT_B 141 // +---+---+ +-------+ +---+---+ +---+---+ 142 // | | | | | | | | | | | 143 // +---+---+ +---+---+ +---+ | | +---+ 144 // | | | | | | | | | | | 145 // +-------+ +---+---+ +---+---+ +---+---+ 146 // 147 // HORZ_4 VERT_4 148 // +-----+ +-+-+-+ 149 // +-----+ | | | | 150 // +-----+ | | | | 151 // +-----+ +-+-+-+ 152 enum { 153 PARTITION_NONE, 154 PARTITION_HORZ, 155 PARTITION_VERT, 156 PARTITION_SPLIT, 157 PARTITION_HORZ_A, // HORZ split and the top partition is split again 158 PARTITION_HORZ_B, // HORZ split and the bottom partition is split again 159 PARTITION_VERT_A, // VERT split and the left partition is split again 160 PARTITION_VERT_B, // VERT split and the right partition is split again 161 PARTITION_HORZ_4, // 4:1 horizontal partition 162 PARTITION_VERT_4, // 4:1 vertical partition 163 EXT_PARTITION_TYPES, 164 PARTITION_TYPES = PARTITION_SPLIT + 1, 165 PARTITION_INVALID = 255 166 } UENUM1BYTE(PARTITION_TYPE); 167 168 typedef char PARTITION_CONTEXT; 169 #define PARTITION_PLOFFSET 4 // number of probability models per block size 170 #define PARTITION_BLOCK_SIZES 5 171 #define PARTITION_CONTEXTS (PARTITION_BLOCK_SIZES * PARTITION_PLOFFSET) 172 173 #define TX_SIZE_LUMA_MIN (TX_4X4) 174 /* We don't need to code a transform size unless the allowed size is at least 175 one more than the minimum. */ 176 #define TX_SIZE_CTX_MIN (TX_SIZE_LUMA_MIN + 1) 177 178 // Maximum tx_size categories 179 #define MAX_TX_CATS (TX_SIZES - TX_SIZE_CTX_MIN) 180 #define MAX_TX_DEPTH 2 181 182 #define MAX_TX_SIZE_LOG2 (6) 183 #define MAX_TX_SIZE (1 << MAX_TX_SIZE_LOG2) 184 #define MIN_TX_SIZE_LOG2 2 185 #define MIN_TX_SIZE (1 << MIN_TX_SIZE_LOG2) 186 #define MAX_TX_SQUARE (MAX_TX_SIZE * MAX_TX_SIZE) 187 188 // Pad 4 extra columns to remove horizontal availability check. 189 #define TX_PAD_HOR_LOG2 2 190 #define TX_PAD_HOR 4 191 // Pad 6 extra rows (2 on top and 4 on bottom) to remove vertical availability 192 // check. 193 #define TX_PAD_TOP 0 194 #define TX_PAD_BOTTOM 4 195 #define TX_PAD_VER (TX_PAD_TOP + TX_PAD_BOTTOM) 196 // Pad 16 extra bytes to avoid reading overflow in SIMD optimization. 197 #define TX_PAD_END 16 198 #define TX_PAD_2D ((32 + TX_PAD_HOR) * (32 + TX_PAD_VER) + TX_PAD_END) 199 200 // Number of maximum size transform blocks in the maximum size superblock 201 #define MAX_TX_BLOCKS_IN_MAX_SB_LOG2 ((MAX_SB_SIZE_LOG2 - MAX_TX_SIZE_LOG2) * 2) 202 #define MAX_TX_BLOCKS_IN_MAX_SB (1 << MAX_TX_BLOCKS_IN_MAX_SB_LOG2) 203 204 // frame transform mode 205 enum { 206 ONLY_4X4, // use only 4x4 transform 207 TX_MODE_LARGEST, // transform size is the largest possible for pu size 208 TX_MODE_SELECT, // transform specified for each block 209 TX_MODES, 210 } UENUM1BYTE(TX_MODE); 211 212 // 1D tx types 213 enum { 214 DCT_1D, 215 ADST_1D, 216 FLIPADST_1D, 217 IDTX_1D, 218 TX_TYPES_1D, 219 } UENUM1BYTE(TX_TYPE_1D); 220 221 enum { 222 REG_REG, 223 REG_SMOOTH, 224 REG_SHARP, 225 SMOOTH_REG, 226 SMOOTH_SMOOTH, 227 SMOOTH_SHARP, 228 SHARP_REG, 229 SHARP_SMOOTH, 230 SHARP_SHARP, 231 } UENUM1BYTE(DUAL_FILTER_TYPE); 232 233 #define EXT_TX_SIZES 4 // number of sizes that use extended transforms 234 #define EXT_TX_SETS_INTER 4 // Sets of transform selections for INTER 235 #define EXT_TX_SETS_INTRA 3 // Sets of transform selections for INTRA 236 237 enum { 238 AOM_LAST_FLAG = 1 << 0, 239 AOM_LAST2_FLAG = 1 << 1, 240 AOM_LAST3_FLAG = 1 << 2, 241 AOM_GOLD_FLAG = 1 << 3, 242 AOM_BWD_FLAG = 1 << 4, 243 AOM_ALT2_FLAG = 1 << 5, 244 AOM_ALT_FLAG = 1 << 6, 245 AOM_REFFRAME_ALL = (1 << 7) - 1 246 } UENUM1BYTE(AOM_REFFRAME); 247 248 enum { 249 UNIDIR_COMP_REFERENCE, 250 BIDIR_COMP_REFERENCE, 251 COMP_REFERENCE_TYPES, 252 } UENUM1BYTE(COMP_REFERENCE_TYPE); 253 254 enum { PLANE_TYPE_Y, PLANE_TYPE_UV, PLANE_TYPES } UENUM1BYTE(PLANE_TYPE); 255 256 #define CFL_ALPHABET_SIZE_LOG2 4 257 #define CFL_ALPHABET_SIZE (1 << CFL_ALPHABET_SIZE_LOG2) 258 #define CFL_MAGS_SIZE ((2 << CFL_ALPHABET_SIZE_LOG2) + 1) 259 #define CFL_INDEX_ZERO CFL_ALPHABET_SIZE 260 #define CFL_IDX_U(idx) (idx >> CFL_ALPHABET_SIZE_LOG2) 261 #define CFL_IDX_V(idx) (idx & (CFL_ALPHABET_SIZE - 1)) 262 263 enum { CFL_PRED_U, CFL_PRED_V, CFL_PRED_PLANES } UENUM1BYTE(CFL_PRED_TYPE); 264 265 enum { 266 CFL_SIGN_ZERO, 267 CFL_SIGN_NEG, 268 CFL_SIGN_POS, 269 CFL_SIGNS 270 } UENUM1BYTE(CFL_SIGN_TYPE); 271 272 enum { 273 CFL_DISALLOWED, 274 CFL_ALLOWED, 275 CFL_ALLOWED_TYPES 276 } UENUM1BYTE(CFL_ALLOWED_TYPE); 277 278 // CFL_SIGN_ZERO,CFL_SIGN_ZERO is invalid 279 #define CFL_JOINT_SIGNS (CFL_SIGNS * CFL_SIGNS - 1) 280 // CFL_SIGN_U is equivalent to (js + 1) / 3 for js in 0 to 8 281 #define CFL_SIGN_U(js) (((js + 1) * 11) >> 5) 282 // CFL_SIGN_V is equivalent to (js + 1) % 3 for js in 0 to 8 283 #define CFL_SIGN_V(js) ((js + 1) - CFL_SIGNS * CFL_SIGN_U(js)) 284 285 // There is no context when the alpha for a given plane is zero. 286 // So there are 2 fewer contexts than joint signs. 287 #define CFL_ALPHA_CONTEXTS (CFL_JOINT_SIGNS + 1 - CFL_SIGNS) 288 #define CFL_CONTEXT_U(js) (js + 1 - CFL_SIGNS) 289 // Also, the contexts are symmetric under swapping the planes. 290 #define CFL_CONTEXT_V(js) \ 291 (CFL_SIGN_V(js) * CFL_SIGNS + CFL_SIGN_U(js) - CFL_SIGNS) 292 293 enum { 294 PALETTE_MAP, 295 COLOR_MAP_TYPES, 296 } UENUM1BYTE(COLOR_MAP_TYPE); 297 298 enum { 299 TWO_COLORS, 300 THREE_COLORS, 301 FOUR_COLORS, 302 FIVE_COLORS, 303 SIX_COLORS, 304 SEVEN_COLORS, 305 EIGHT_COLORS, 306 PALETTE_SIZES 307 } UENUM1BYTE(PALETTE_SIZE); 308 309 enum { 310 PALETTE_COLOR_ONE, 311 PALETTE_COLOR_TWO, 312 PALETTE_COLOR_THREE, 313 PALETTE_COLOR_FOUR, 314 PALETTE_COLOR_FIVE, 315 PALETTE_COLOR_SIX, 316 PALETTE_COLOR_SEVEN, 317 PALETTE_COLOR_EIGHT, 318 PALETTE_COLORS 319 } UENUM1BYTE(PALETTE_COLOR); 320 321 // Note: All directional predictors must be between V_PRED and D67_PRED (both 322 // inclusive). 323 enum { 324 DC_PRED, // Average of above and left pixels 325 V_PRED, // Vertical 326 H_PRED, // Horizontal 327 D45_PRED, // Directional 45 degree 328 D135_PRED, // Directional 135 degree 329 D113_PRED, // Directional 113 degree 330 D157_PRED, // Directional 157 degree 331 D203_PRED, // Directional 203 degree 332 D67_PRED, // Directional 67 degree 333 SMOOTH_PRED, // Combination of horizontal and vertical interpolation 334 SMOOTH_V_PRED, // Vertical interpolation 335 SMOOTH_H_PRED, // Horizontal interpolation 336 PAETH_PRED, // Predict from the direction of smallest gradient 337 NEARESTMV, 338 NEARMV, 339 GLOBALMV, 340 NEWMV, 341 // Compound ref compound modes 342 NEAREST_NEARESTMV, 343 NEAR_NEARMV, 344 NEAREST_NEWMV, 345 NEW_NEARESTMV, 346 NEAR_NEWMV, 347 NEW_NEARMV, 348 GLOBAL_GLOBALMV, 349 NEW_NEWMV, 350 MB_MODE_COUNT, 351 PRED_MODE_INVALID = MB_MODE_COUNT, 352 INTRA_MODE_START = DC_PRED, 353 INTRA_MODE_END = NEARESTMV, 354 DIR_MODE_START = V_PRED, 355 DIR_MODE_END = D67_PRED + 1, 356 INTRA_MODE_NUM = INTRA_MODE_END - INTRA_MODE_START, 357 SINGLE_INTER_MODE_START = NEARESTMV, 358 SINGLE_INTER_MODE_END = NEAREST_NEARESTMV, 359 SINGLE_INTER_MODE_NUM = SINGLE_INTER_MODE_END - SINGLE_INTER_MODE_START, 360 COMP_INTER_MODE_START = NEAREST_NEARESTMV, 361 COMP_INTER_MODE_END = MB_MODE_COUNT, 362 COMP_INTER_MODE_NUM = COMP_INTER_MODE_END - COMP_INTER_MODE_START, 363 INTER_MODE_START = NEARESTMV, 364 INTER_MODE_END = MB_MODE_COUNT, 365 INTRA_MODES = PAETH_PRED + 1, // PAETH_PRED has to be the last intra mode. 366 INTRA_INVALID = MB_MODE_COUNT // For uv_mode in inter blocks 367 } UENUM1BYTE(PREDICTION_MODE); 368 369 // TODO(ltrudeau) Do we really want to pack this? 370 // TODO(ltrudeau) Do we match with PREDICTION_MODE? 371 enum { 372 UV_DC_PRED, // Average of above and left pixels 373 UV_V_PRED, // Vertical 374 UV_H_PRED, // Horizontal 375 UV_D45_PRED, // Directional 45 degree 376 UV_D135_PRED, // Directional 135 degree 377 UV_D113_PRED, // Directional 113 degree 378 UV_D157_PRED, // Directional 157 degree 379 UV_D203_PRED, // Directional 203 degree 380 UV_D67_PRED, // Directional 67 degree 381 UV_SMOOTH_PRED, // Combination of horizontal and vertical interpolation 382 UV_SMOOTH_V_PRED, // Vertical interpolation 383 UV_SMOOTH_H_PRED, // Horizontal interpolation 384 UV_PAETH_PRED, // Predict from the direction of smallest gradient 385 UV_CFL_PRED, // Chroma-from-Luma 386 UV_INTRA_MODES, 387 UV_MODE_INVALID, // For uv_mode in inter blocks 388 } UENUM1BYTE(UV_PREDICTION_MODE); 389 390 // Number of top model rd to store for pruning y modes in intra mode decision 391 #define TOP_INTRA_MODEL_COUNT 4 392 // Total number of luma intra prediction modes (include both directional and 393 // non-directional modes) 394 // Because there are 8 directional modes, each has additional 6 delta angles. 395 #define LUMA_MODE_COUNT (PAETH_PRED - DC_PRED + 1 + 6 * 8) 396 397 enum { 398 SIMPLE_TRANSLATION, 399 OBMC_CAUSAL, // 2-sided OBMC 400 WARPED_CAUSAL, // 2-sided WARPED 401 MOTION_MODES 402 } UENUM1BYTE(MOTION_MODE); 403 404 enum { 405 II_DC_PRED, 406 II_V_PRED, 407 II_H_PRED, 408 II_SMOOTH_PRED, 409 INTERINTRA_MODES 410 } UENUM1BYTE(INTERINTRA_MODE); 411 412 enum { 413 COMPOUND_AVERAGE, 414 COMPOUND_DISTWTD, 415 COMPOUND_WEDGE, 416 COMPOUND_DIFFWTD, 417 COMPOUND_TYPES, 418 MASKED_COMPOUND_TYPES = 2, 419 } UENUM1BYTE(COMPOUND_TYPE); 420 421 enum { 422 FILTER_DC_PRED, 423 FILTER_V_PRED, 424 FILTER_H_PRED, 425 FILTER_D157_PRED, 426 FILTER_PAETH_PRED, 427 FILTER_INTRA_MODES, 428 } UENUM1BYTE(FILTER_INTRA_MODE); 429 430 enum { 431 SEQ_LEVEL_2_0, 432 SEQ_LEVEL_2_1, 433 SEQ_LEVEL_2_2, 434 SEQ_LEVEL_2_3, 435 SEQ_LEVEL_3_0, 436 SEQ_LEVEL_3_1, 437 SEQ_LEVEL_3_2, 438 SEQ_LEVEL_3_3, 439 SEQ_LEVEL_4_0, 440 SEQ_LEVEL_4_1, 441 SEQ_LEVEL_4_2, 442 SEQ_LEVEL_4_3, 443 SEQ_LEVEL_5_0, 444 SEQ_LEVEL_5_1, 445 SEQ_LEVEL_5_2, 446 SEQ_LEVEL_5_3, 447 SEQ_LEVEL_6_0, 448 SEQ_LEVEL_6_1, 449 SEQ_LEVEL_6_2, 450 SEQ_LEVEL_6_3, 451 SEQ_LEVEL_7_0, 452 SEQ_LEVEL_7_1, 453 SEQ_LEVEL_7_2, 454 SEQ_LEVEL_7_3, 455 SEQ_LEVEL_8_0, 456 SEQ_LEVEL_8_1, 457 SEQ_LEVEL_8_2, 458 SEQ_LEVEL_8_3, 459 SEQ_LEVELS, 460 SEQ_LEVEL_MAX = 31, 461 SEQ_LEVEL_KEEP_STATS = 32, 462 } UENUM1BYTE(AV1_LEVEL); 463 464 #define LEVEL_BITS 5 465 466 #define DIRECTIONAL_MODES 8 467 #define MAX_ANGLE_DELTA 3 468 #define ANGLE_STEP 3 469 470 #define INTER_MODES (1 + NEWMV - NEARESTMV) 471 472 #define INTER_COMPOUND_MODES (1 + NEW_NEWMV - NEAREST_NEARESTMV) 473 474 #define SKIP_CONTEXTS 3 475 #define SKIP_MODE_CONTEXTS 3 476 477 #define COMP_INDEX_CONTEXTS 6 478 #define COMP_GROUP_IDX_CONTEXTS 6 479 480 #define NMV_CONTEXTS 3 481 482 #define NEWMV_MODE_CONTEXTS 6 483 #define GLOBALMV_MODE_CONTEXTS 2 484 #define REFMV_MODE_CONTEXTS 6 485 #define DRL_MODE_CONTEXTS 3 486 487 #define GLOBALMV_OFFSET 3 488 #define REFMV_OFFSET 4 489 490 #define NEWMV_CTX_MASK ((1 << GLOBALMV_OFFSET) - 1) 491 #define GLOBALMV_CTX_MASK ((1 << (REFMV_OFFSET - GLOBALMV_OFFSET)) - 1) 492 #define REFMV_CTX_MASK ((1 << (8 - REFMV_OFFSET)) - 1) 493 494 #define COMP_NEWMV_CTXS 5 495 #define INTER_MODE_CONTEXTS 8 496 497 #define DELTA_Q_SMALL 3 498 #define DELTA_Q_PROBS (DELTA_Q_SMALL) 499 #define DEFAULT_DELTA_Q_RES_PERCEPTUAL 4 500 #define DEFAULT_DELTA_Q_RES_OBJECTIVE 4 501 #define DEFAULT_DELTA_Q_RES_DUCKY_ENCODE 4 502 503 #define DELTA_LF_SMALL 3 504 #define DELTA_LF_PROBS (DELTA_LF_SMALL) 505 #define DEFAULT_DELTA_LF_RES 2 506 507 /* Segment Feature Masks */ 508 #define MAX_MV_REF_CANDIDATES 2 509 510 #define MAX_REF_MV_STACK_SIZE 8 511 #define USABLE_REF_MV_STACK_SIZE 4 512 #define REF_CAT_LEVEL 640 513 514 #define INTRA_INTER_CONTEXTS 4 515 #define COMP_INTER_CONTEXTS 5 516 #define REF_CONTEXTS 3 517 518 #define COMP_REF_TYPE_CONTEXTS 5 519 #define UNI_COMP_REF_CONTEXTS 3 520 521 #define TXFM_PARTITION_CONTEXTS ((TX_SIZES - TX_8X8) * 6 - 3) 522 typedef uint8_t TXFM_CONTEXT; 523 524 // An enum for single reference types (and some derived values). 525 enum { 526 NONE_FRAME = -1, 527 INTRA_FRAME, 528 LAST_FRAME, 529 LAST2_FRAME, 530 LAST3_FRAME, 531 GOLDEN_FRAME, 532 BWDREF_FRAME, 533 ALTREF2_FRAME, 534 ALTREF_FRAME, 535 REF_FRAMES, 536 537 // Extra/scratch reference frame. It may be: 538 // - used to update the ALTREF2_FRAME ref (see lshift_bwd_ref_frames()), or 539 // - updated from ALTREF2_FRAME ref (see rshift_bwd_ref_frames()). 540 EXTREF_FRAME = REF_FRAMES, 541 542 // Number of inter (non-intra) reference types. 543 INTER_REFS_PER_FRAME = ALTREF_FRAME - LAST_FRAME + 1, 544 545 // Number of forward (aka past) reference types. 546 FWD_REFS = GOLDEN_FRAME - LAST_FRAME + 1, 547 548 // Number of backward (aka future) reference types. 549 BWD_REFS = ALTREF_FRAME - BWDREF_FRAME + 1, 550 551 SINGLE_REFS = FWD_REFS + BWD_REFS, 552 }; 553 554 #define REF_FRAMES_LOG2 3 555 556 // REF_FRAMES for the cm->ref_frame_map array, 1 scratch frame for the new 557 // frame in cm->cur_frame, INTER_REFS_PER_FRAME for scaled references on the 558 // encoder in the cpi->scaled_ref_buf array. 559 // The encoder uses FRAME_BUFFERS only in GOOD and REALTIME encoding modes. 560 // The decoder also uses FRAME_BUFFERS. 561 #define FRAME_BUFFERS (REF_FRAMES + 1 + INTER_REFS_PER_FRAME) 562 563 // During allintra encoding, one reference frame buffer is free to be used again 564 // only after another frame buffer is stored as the reference frame. Hence, it 565 // is necessary and sufficient to maintain only two reference frame buffers in 566 // this case. 567 #define FRAME_BUFFERS_ALLINTRA 2 568 569 #define FWD_RF_OFFSET(ref) (ref - LAST_FRAME) 570 #define BWD_RF_OFFSET(ref) (ref - BWDREF_FRAME) 571 572 // Select all the decoded frame buffer slots 573 #define SELECT_ALL_BUF_SLOTS 0xFF 574 575 enum { 576 LAST_LAST2_FRAMES, // { LAST_FRAME, LAST2_FRAME } 577 LAST_LAST3_FRAMES, // { LAST_FRAME, LAST3_FRAME } 578 LAST_GOLDEN_FRAMES, // { LAST_FRAME, GOLDEN_FRAME } 579 BWDREF_ALTREF_FRAMES, // { BWDREF_FRAME, ALTREF_FRAME } 580 LAST2_LAST3_FRAMES, // { LAST2_FRAME, LAST3_FRAME } 581 LAST2_GOLDEN_FRAMES, // { LAST2_FRAME, GOLDEN_FRAME } 582 LAST3_GOLDEN_FRAMES, // { LAST3_FRAME, GOLDEN_FRAME } 583 BWDREF_ALTREF2_FRAMES, // { BWDREF_FRAME, ALTREF2_FRAME } 584 ALTREF2_ALTREF_FRAMES, // { ALTREF2_FRAME, ALTREF_FRAME } 585 TOTAL_UNIDIR_COMP_REFS, 586 // NOTE: UNIDIR_COMP_REFS is the number of uni-directional reference pairs 587 // that are explicitly signaled. 588 UNIDIR_COMP_REFS = BWDREF_ALTREF_FRAMES + 1, 589 } UENUM1BYTE(UNIDIR_COMP_REF); 590 591 #define TOTAL_COMP_REFS (FWD_REFS * BWD_REFS + TOTAL_UNIDIR_COMP_REFS) 592 593 #define COMP_REFS (FWD_REFS * BWD_REFS + UNIDIR_COMP_REFS) 594 595 // NOTE: A limited number of unidirectional reference pairs can be signalled for 596 // compound prediction. The use of skip mode, on the other hand, makes it 597 // possible to have a reference pair not listed for explicit signaling. 598 #define MODE_CTX_REF_FRAMES (REF_FRAMES + TOTAL_COMP_REFS) 599 600 // Note: It includes single and compound references. So, it can take values from 601 // NONE_FRAME to (MODE_CTX_REF_FRAMES - 1). Hence, it is not defined as an enum. 602 typedef int8_t MV_REFERENCE_FRAME; 603 604 /*!\endcond */ 605 606 /*!\enum RestorationType 607 * \brief This enumeration defines various restoration types supported 608 */ 609 typedef enum { 610 RESTORE_NONE, /**< No restoration */ 611 RESTORE_WIENER, /**< Separable Wiener restoration */ 612 RESTORE_SGRPROJ, /**< Selfguided restoration */ 613 RESTORE_SWITCHABLE, /**< Switchable restoration */ 614 RESTORE_SWITCHABLE_TYPES = RESTORE_SWITCHABLE, /**< Num Switchable types */ 615 RESTORE_TYPES = 4, /**< Num Restore types */ 616 } RestorationType; 617 618 /*!\cond */ 619 // Picture prediction structures (0-13 are predefined) in scalability metadata. 620 enum { 621 SCALABILITY_L1T2 = 0, 622 SCALABILITY_L1T3 = 1, 623 SCALABILITY_L2T1 = 2, 624 SCALABILITY_L2T2 = 3, 625 SCALABILITY_L2T3 = 4, 626 SCALABILITY_S2T1 = 5, 627 SCALABILITY_S2T2 = 6, 628 SCALABILITY_S2T3 = 7, 629 SCALABILITY_L2T1h = 8, 630 SCALABILITY_L2T2h = 9, 631 SCALABILITY_L2T3h = 10, 632 SCALABILITY_S2T1h = 11, 633 SCALABILITY_S2T2h = 12, 634 SCALABILITY_S2T3h = 13, 635 SCALABILITY_SS = 14 636 } UENUM1BYTE(SCALABILITY_STRUCTURES); 637 638 #define SUPERRES_SCALE_BITS 3 639 #define SUPERRES_SCALE_DENOMINATOR_MIN (SCALE_NUMERATOR + 1) 640 641 // In large_scale_tile coding, external references are used. 642 #define MAX_EXTERNAL_REFERENCES 128 643 #define MAX_TILES 512 644 645 /*!\endcond */ 646 647 #ifdef __cplusplus 648 } // extern "C" 649 #endif 650 651 #endif // AOM_AV1_COMMON_ENUMS_H_