463 lines
20 KiB
C
463 lines
20 KiB
C
/*
|
|
* Copyright (c) 2017, 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_TXB_COMMON_H_
|
|
#define AOM_AV1_COMMON_TXB_COMMON_H_
|
|
|
|
#include "av1/common/av1_common_int.h"
|
|
|
|
extern const int16_t av1_eob_group_start[12];
|
|
extern const int16_t av1_eob_offset_bits[12];
|
|
|
|
extern const int8_t *av1_nz_map_ctx_offset[TX_SIZES_ALL];
|
|
|
|
typedef struct txb_ctx {
|
|
int txb_skip_ctx;
|
|
int dc_sign_ctx;
|
|
} TXB_CTX;
|
|
|
|
static const int base_level_count_to_index[13] = {
|
|
0, 0, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3,
|
|
};
|
|
|
|
static const TX_CLASS tx_type_to_class[TX_TYPES] = {
|
|
TX_CLASS_2D, // DCT_DCT
|
|
TX_CLASS_2D, // ADST_DCT
|
|
TX_CLASS_2D, // DCT_ADST
|
|
TX_CLASS_2D, // ADST_ADST
|
|
TX_CLASS_2D, // FLIPADST_DCT
|
|
TX_CLASS_2D, // DCT_FLIPADST
|
|
TX_CLASS_2D, // FLIPADST_FLIPADST
|
|
TX_CLASS_2D, // ADST_FLIPADST
|
|
TX_CLASS_2D, // FLIPADST_ADST
|
|
TX_CLASS_2D, // IDTX
|
|
TX_CLASS_VERT, // V_DCT
|
|
TX_CLASS_HORIZ, // H_DCT
|
|
TX_CLASS_VERT, // V_ADST
|
|
TX_CLASS_HORIZ, // H_ADST
|
|
TX_CLASS_VERT, // V_FLIPADST
|
|
TX_CLASS_HORIZ, // H_FLIPADST
|
|
};
|
|
|
|
static inline int get_txb_bhl(TX_SIZE tx_size) {
|
|
tx_size = av1_get_adjusted_tx_size(tx_size);
|
|
return tx_size_high_log2[tx_size];
|
|
}
|
|
|
|
static inline int get_txb_wide(TX_SIZE tx_size) {
|
|
tx_size = av1_get_adjusted_tx_size(tx_size);
|
|
return tx_size_wide[tx_size];
|
|
}
|
|
|
|
static inline int get_txb_high(TX_SIZE tx_size) {
|
|
tx_size = av1_get_adjusted_tx_size(tx_size);
|
|
return tx_size_high[tx_size];
|
|
}
|
|
|
|
static inline uint8_t *set_levels(uint8_t *const levels_buf, const int height) {
|
|
return levels_buf + TX_PAD_TOP * (height + TX_PAD_HOR);
|
|
}
|
|
|
|
static inline int get_padded_idx(const int idx, const int bhl) {
|
|
return idx + ((idx >> bhl) << TX_PAD_HOR_LOG2);
|
|
}
|
|
|
|
static inline int get_br_ctx_2d(const uint8_t *const levels,
|
|
const int c, // raster order
|
|
const int bhl) {
|
|
assert(c > 0);
|
|
const int col = c >> bhl;
|
|
const int row = c - (col << bhl);
|
|
const int stride = (1 << bhl) + TX_PAD_HOR;
|
|
const int pos = col * stride + row;
|
|
int mag = AOMMIN(levels[pos + 1], MAX_BASE_BR_RANGE) +
|
|
AOMMIN(levels[pos + stride], MAX_BASE_BR_RANGE) +
|
|
AOMMIN(levels[pos + 1 + stride], MAX_BASE_BR_RANGE);
|
|
mag = AOMMIN((mag + 1) >> 1, 6);
|
|
//((row | col) < 2) is equivalent to ((row < 2) && (col < 2))
|
|
if ((row | col) < 2) return mag + 7;
|
|
return mag + 14;
|
|
}
|
|
|
|
static AOM_FORCE_INLINE int get_br_ctx_eob(const int c, // raster order
|
|
const int bhl,
|
|
const TX_CLASS tx_class) {
|
|
const int col = c >> bhl;
|
|
const int row = c - (col << bhl);
|
|
if (c == 0) return 0;
|
|
if ((tx_class == TX_CLASS_2D && row < 2 && col < 2) ||
|
|
(tx_class == TX_CLASS_HORIZ && col == 0) ||
|
|
(tx_class == TX_CLASS_VERT && row == 0))
|
|
return 7;
|
|
return 14;
|
|
}
|
|
|
|
static AOM_FORCE_INLINE int get_br_ctx(const uint8_t *const levels,
|
|
const int c, // raster order
|
|
const int bhl, const TX_CLASS tx_class) {
|
|
const int col = c >> bhl;
|
|
const int row = c - (col << bhl);
|
|
const int stride = (1 << bhl) + TX_PAD_HOR;
|
|
const int pos = col * stride + row;
|
|
int mag = levels[pos + 1];
|
|
mag += levels[pos + stride];
|
|
switch (tx_class) {
|
|
case TX_CLASS_2D:
|
|
mag += levels[pos + stride + 1];
|
|
mag = AOMMIN((mag + 1) >> 1, 6);
|
|
if (c == 0) return mag;
|
|
if ((row < 2) && (col < 2)) return mag + 7;
|
|
break;
|
|
case TX_CLASS_HORIZ:
|
|
mag += levels[pos + (stride << 1)];
|
|
mag = AOMMIN((mag + 1) >> 1, 6);
|
|
if (c == 0) return mag;
|
|
if (col == 0) return mag + 7;
|
|
break;
|
|
case TX_CLASS_VERT:
|
|
mag += levels[pos + 2];
|
|
mag = AOMMIN((mag + 1) >> 1, 6);
|
|
if (c == 0) return mag;
|
|
if (row == 0) return mag + 7;
|
|
break;
|
|
default: break;
|
|
}
|
|
|
|
return mag + 14;
|
|
}
|
|
|
|
static const uint8_t clip_max3[256] = {
|
|
0, 1, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
|
|
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
|
|
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
|
|
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
|
|
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
|
|
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
|
|
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
|
|
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
|
|
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
|
|
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3
|
|
};
|
|
|
|
static AOM_FORCE_INLINE int get_nz_mag(const uint8_t *const levels,
|
|
const int bhl, const TX_CLASS tx_class) {
|
|
int mag;
|
|
|
|
// Note: AOMMIN(level, 3) is useless for decoder since level < 3.
|
|
mag = clip_max3[levels[(1 << bhl) + TX_PAD_HOR]]; // { 0, 1 }
|
|
mag += clip_max3[levels[1]]; // { 1, 0 }
|
|
|
|
if (tx_class == TX_CLASS_2D) {
|
|
mag += clip_max3[levels[(1 << bhl) + TX_PAD_HOR + 1]]; // { 1, 1 }
|
|
mag += clip_max3[levels[(2 << bhl) + (2 << TX_PAD_HOR_LOG2)]]; // { 0, 2 }
|
|
mag += clip_max3[levels[2]]; // { 2, 0 }
|
|
} else if (tx_class == TX_CLASS_VERT) {
|
|
mag += clip_max3[levels[2]]; // { 2, 0 }
|
|
mag += clip_max3[levels[3]]; // { 3, 0 }
|
|
mag += clip_max3[levels[4]]; // { 4, 0 }
|
|
} else {
|
|
mag += clip_max3[levels[(2 << bhl) + (2 << TX_PAD_HOR_LOG2)]]; // { 0, 2 }
|
|
mag += clip_max3[levels[(3 << bhl) + (3 << TX_PAD_HOR_LOG2)]]; // { 0, 3 }
|
|
mag += clip_max3[levels[(4 << bhl) + (4 << TX_PAD_HOR_LOG2)]]; // { 0, 4 }
|
|
}
|
|
|
|
return mag;
|
|
}
|
|
|
|
#define NZ_MAP_CTX_0 SIG_COEF_CONTEXTS_2D
|
|
#define NZ_MAP_CTX_5 (NZ_MAP_CTX_0 + 5)
|
|
#define NZ_MAP_CTX_10 (NZ_MAP_CTX_0 + 10)
|
|
|
|
static const int nz_map_ctx_offset_1d[32] = {
|
|
NZ_MAP_CTX_0, NZ_MAP_CTX_5, NZ_MAP_CTX_10, NZ_MAP_CTX_10, NZ_MAP_CTX_10,
|
|
NZ_MAP_CTX_10, NZ_MAP_CTX_10, NZ_MAP_CTX_10, NZ_MAP_CTX_10, NZ_MAP_CTX_10,
|
|
NZ_MAP_CTX_10, NZ_MAP_CTX_10, NZ_MAP_CTX_10, NZ_MAP_CTX_10, NZ_MAP_CTX_10,
|
|
NZ_MAP_CTX_10, NZ_MAP_CTX_10, NZ_MAP_CTX_10, NZ_MAP_CTX_10, NZ_MAP_CTX_10,
|
|
NZ_MAP_CTX_10, NZ_MAP_CTX_10, NZ_MAP_CTX_10, NZ_MAP_CTX_10, NZ_MAP_CTX_10,
|
|
NZ_MAP_CTX_10, NZ_MAP_CTX_10, NZ_MAP_CTX_10, NZ_MAP_CTX_10, NZ_MAP_CTX_10,
|
|
NZ_MAP_CTX_10, NZ_MAP_CTX_10,
|
|
};
|
|
|
|
static AOM_FORCE_INLINE int get_nz_map_ctx_from_stats(
|
|
const int stats,
|
|
const int coeff_idx, // raster order
|
|
const int bhl, const TX_SIZE tx_size, const TX_CLASS tx_class) {
|
|
// tx_class == 0(TX_CLASS_2D)
|
|
if ((tx_class | coeff_idx) == 0) return 0;
|
|
int ctx = (stats + 1) >> 1;
|
|
ctx = AOMMIN(ctx, 4);
|
|
switch (tx_class) {
|
|
case TX_CLASS_2D: {
|
|
// This is the algorithm to generate av1_nz_map_ctx_offset[][]
|
|
// const int width = tx_size_wide[tx_size];
|
|
// const int height = tx_size_high[tx_size];
|
|
// if (width < height) {
|
|
// if (row < 2) return 11 + ctx;
|
|
// } else if (width > height) {
|
|
// if (col < 2) return 16 + ctx;
|
|
// }
|
|
// if (row + col < 2) return ctx + 1;
|
|
// if (row + col < 4) return 5 + ctx + 1;
|
|
// return 21 + ctx;
|
|
return ctx + av1_nz_map_ctx_offset[tx_size][coeff_idx];
|
|
}
|
|
case TX_CLASS_HORIZ: {
|
|
const int col = coeff_idx >> bhl;
|
|
return ctx + nz_map_ctx_offset_1d[col];
|
|
}
|
|
case TX_CLASS_VERT: {
|
|
const int col = coeff_idx >> bhl;
|
|
const int row = coeff_idx - (col << bhl);
|
|
return ctx + nz_map_ctx_offset_1d[row];
|
|
}
|
|
default: break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
typedef aom_cdf_prob (*base_cdf_arr)[CDF_SIZE(4)];
|
|
typedef aom_cdf_prob (*br_cdf_arr)[CDF_SIZE(BR_CDF_SIZE)];
|
|
|
|
static inline int get_lower_levels_ctx_eob(int bhl, int width, int scan_idx) {
|
|
if (scan_idx == 0) return 0;
|
|
if (scan_idx <= (width << bhl) / 8) return 1;
|
|
if (scan_idx <= (width << bhl) / 4) return 2;
|
|
return 3;
|
|
}
|
|
|
|
static inline int get_lower_levels_ctx_2d(const uint8_t *levels, int coeff_idx,
|
|
int bhl, TX_SIZE tx_size) {
|
|
assert(coeff_idx > 0);
|
|
int mag;
|
|
// Note: AOMMIN(level, 3) is useless for decoder since level < 3.
|
|
levels = levels + get_padded_idx(coeff_idx, bhl);
|
|
mag = AOMMIN(levels[(1 << bhl) + TX_PAD_HOR], 3); // { 0, 1 }
|
|
mag += AOMMIN(levels[1], 3); // { 1, 0 }
|
|
mag += AOMMIN(levels[(1 << bhl) + TX_PAD_HOR + 1], 3); // { 1, 1 }
|
|
mag += AOMMIN(levels[(2 << bhl) + (2 << TX_PAD_HOR_LOG2)], 3); // { 0, 2 }
|
|
mag += AOMMIN(levels[2], 3); // { 2, 0 }
|
|
|
|
const int ctx = AOMMIN((mag + 1) >> 1, 4);
|
|
return ctx + av1_nz_map_ctx_offset[tx_size][coeff_idx];
|
|
}
|
|
static AOM_FORCE_INLINE int get_lower_levels_ctx(const uint8_t *levels,
|
|
int coeff_idx, int bhl,
|
|
TX_SIZE tx_size,
|
|
TX_CLASS tx_class) {
|
|
const int stats =
|
|
get_nz_mag(levels + get_padded_idx(coeff_idx, bhl), bhl, tx_class);
|
|
return get_nz_map_ctx_from_stats(stats, coeff_idx, bhl, tx_size, tx_class);
|
|
}
|
|
|
|
static inline int get_lower_levels_ctx_general(int is_last, int scan_idx,
|
|
int bhl, int width,
|
|
const uint8_t *levels,
|
|
int coeff_idx, TX_SIZE tx_size,
|
|
TX_CLASS tx_class) {
|
|
if (is_last) {
|
|
if (scan_idx == 0) return 0;
|
|
if (scan_idx <= (width << bhl) >> 3) return 1;
|
|
if (scan_idx <= (width << bhl) >> 2) return 2;
|
|
return 3;
|
|
}
|
|
return get_lower_levels_ctx(levels, coeff_idx, bhl, tx_size, tx_class);
|
|
}
|
|
|
|
static inline void set_dc_sign(int *cul_level, int dc_val) {
|
|
if (dc_val < 0)
|
|
*cul_level |= 1 << COEFF_CONTEXT_BITS;
|
|
else if (dc_val > 0)
|
|
*cul_level += 2 << COEFF_CONTEXT_BITS;
|
|
}
|
|
|
|
static void get_txb_ctx_general(const BLOCK_SIZE plane_bsize,
|
|
const TX_SIZE tx_size, const int plane,
|
|
const ENTROPY_CONTEXT *const a,
|
|
const ENTROPY_CONTEXT *const l,
|
|
TXB_CTX *const txb_ctx) {
|
|
#define MAX_TX_SIZE_UNIT 16
|
|
static const int8_t signs[3] = { 0, -1, 1 };
|
|
static const int8_t dc_sign_contexts[4 * MAX_TX_SIZE_UNIT + 1] = {
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2
|
|
};
|
|
const int txb_w_unit = tx_size_wide_unit[tx_size];
|
|
const int txb_h_unit = tx_size_high_unit[tx_size];
|
|
int dc_sign = 0;
|
|
int k = 0;
|
|
|
|
do {
|
|
const unsigned int sign = ((uint8_t)a[k]) >> COEFF_CONTEXT_BITS;
|
|
assert(sign <= 2);
|
|
dc_sign += signs[sign];
|
|
} while (++k < txb_w_unit);
|
|
|
|
k = 0;
|
|
do {
|
|
const unsigned int sign = ((uint8_t)l[k]) >> COEFF_CONTEXT_BITS;
|
|
assert(sign <= 2);
|
|
dc_sign += signs[sign];
|
|
} while (++k < txb_h_unit);
|
|
|
|
txb_ctx->dc_sign_ctx = dc_sign_contexts[dc_sign + 2 * MAX_TX_SIZE_UNIT];
|
|
|
|
if (plane == 0) {
|
|
if (plane_bsize == txsize_to_bsize[tx_size]) {
|
|
txb_ctx->txb_skip_ctx = 0;
|
|
} else {
|
|
// This is the algorithm to generate table skip_contexts[top][left].
|
|
// const int max = AOMMIN(top | left, 4);
|
|
// const int min = AOMMIN(AOMMIN(top, left), 4);
|
|
// if (!max)
|
|
// txb_skip_ctx = 1;
|
|
// else if (!min)
|
|
// txb_skip_ctx = 2 + (max > 3);
|
|
// else if (max <= 3)
|
|
// txb_skip_ctx = 4;
|
|
// else if (min <= 3)
|
|
// txb_skip_ctx = 5;
|
|
// else
|
|
// txb_skip_ctx = 6;
|
|
static const uint8_t skip_contexts[5][5] = { { 1, 2, 2, 2, 3 },
|
|
{ 2, 4, 4, 4, 5 },
|
|
{ 2, 4, 4, 4, 5 },
|
|
{ 2, 4, 4, 4, 5 },
|
|
{ 3, 5, 5, 5, 6 } };
|
|
// For top and left, we only care about which of the following three
|
|
// categories they belong to: { 0 }, { 1, 2, 3 }, or { 4, 5, ... }. The
|
|
// spec calculates top and left with the Max() function. We can calculate
|
|
// an approximate max with bitwise OR because the real max and the
|
|
// approximate max belong to the same category.
|
|
int top = 0;
|
|
int left = 0;
|
|
|
|
k = 0;
|
|
do {
|
|
top |= a[k];
|
|
} while (++k < txb_w_unit);
|
|
top &= COEFF_CONTEXT_MASK;
|
|
top = AOMMIN(top, 4);
|
|
|
|
k = 0;
|
|
do {
|
|
left |= l[k];
|
|
} while (++k < txb_h_unit);
|
|
left &= COEFF_CONTEXT_MASK;
|
|
left = AOMMIN(left, 4);
|
|
|
|
txb_ctx->txb_skip_ctx = skip_contexts[top][left];
|
|
}
|
|
} else {
|
|
const int ctx_base = get_entropy_context(tx_size, a, l);
|
|
const int ctx_offset = (num_pels_log2_lookup[plane_bsize] >
|
|
num_pels_log2_lookup[txsize_to_bsize[tx_size]])
|
|
? 10
|
|
: 7;
|
|
txb_ctx->txb_skip_ctx = ctx_base + ctx_offset;
|
|
}
|
|
}
|
|
|
|
#define SPECIALIZE_GET_TXB_CTX(w, h) \
|
|
static void get_txb_ctx_##w##x##h( \
|
|
const BLOCK_SIZE plane_bsize, const int plane, \
|
|
const ENTROPY_CONTEXT *const a, const ENTROPY_CONTEXT *const l, \
|
|
TXB_CTX *const txb_ctx) { \
|
|
static const int8_t signs[3] = { 0, -1, 1 }; \
|
|
static const int8_t dc_sign_contexts[4 * MAX_TX_SIZE_UNIT + 1] = { \
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, \
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 \
|
|
}; \
|
|
const TX_SIZE tx_size = TX_##w##X##h; \
|
|
const int txb_w_unit = tx_size_wide_unit[tx_size]; \
|
|
const int txb_h_unit = tx_size_high_unit[tx_size]; \
|
|
int dc_sign = 0; \
|
|
int k = 0; \
|
|
\
|
|
do { \
|
|
const unsigned int sign = ((uint8_t)a[k]) >> COEFF_CONTEXT_BITS; \
|
|
assert(sign <= 2); \
|
|
dc_sign += signs[sign]; \
|
|
} while (++k < txb_w_unit); \
|
|
\
|
|
k = 0; \
|
|
do { \
|
|
const unsigned int sign = ((uint8_t)l[k]) >> COEFF_CONTEXT_BITS; \
|
|
assert(sign <= 2); \
|
|
dc_sign += signs[sign]; \
|
|
} while (++k < txb_h_unit); \
|
|
\
|
|
txb_ctx->dc_sign_ctx = dc_sign_contexts[dc_sign + 2 * MAX_TX_SIZE_UNIT]; \
|
|
\
|
|
if (plane == 0) { \
|
|
if (plane_bsize == txsize_to_bsize[tx_size]) { \
|
|
txb_ctx->txb_skip_ctx = 0; \
|
|
} else { \
|
|
static const uint8_t skip_contexts[5][5] = { { 1, 2, 2, 2, 3 }, \
|
|
{ 2, 4, 4, 4, 5 }, \
|
|
{ 2, 4, 4, 4, 5 }, \
|
|
{ 2, 4, 4, 4, 5 }, \
|
|
{ 3, 5, 5, 5, 6 } }; \
|
|
int top = 0; \
|
|
int left = 0; \
|
|
\
|
|
k = 0; \
|
|
do { \
|
|
top |= a[k]; \
|
|
} while (++k < txb_w_unit); \
|
|
top &= COEFF_CONTEXT_MASK; \
|
|
top = AOMMIN(top, 4); \
|
|
\
|
|
k = 0; \
|
|
do { \
|
|
left |= l[k]; \
|
|
} while (++k < txb_h_unit); \
|
|
left &= COEFF_CONTEXT_MASK; \
|
|
left = AOMMIN(left, 4); \
|
|
\
|
|
txb_ctx->txb_skip_ctx = skip_contexts[top][left]; \
|
|
} \
|
|
} else { \
|
|
const int ctx_base = get_entropy_context(tx_size, a, l); \
|
|
const int ctx_offset = (num_pels_log2_lookup[plane_bsize] > \
|
|
num_pels_log2_lookup[txsize_to_bsize[tx_size]]) \
|
|
? 10 \
|
|
: 7; \
|
|
txb_ctx->txb_skip_ctx = ctx_base + ctx_offset; \
|
|
} \
|
|
}
|
|
|
|
SPECIALIZE_GET_TXB_CTX(4, 4)
|
|
SPECIALIZE_GET_TXB_CTX(8, 8)
|
|
SPECIALIZE_GET_TXB_CTX(16, 16)
|
|
SPECIALIZE_GET_TXB_CTX(32, 32)
|
|
|
|
// Wrapper for get_txb_ctx that calls the specialized version of get_txb_ctc_*
|
|
// so that the compiler can compile away the while loops.
|
|
static inline void get_txb_ctx(const BLOCK_SIZE plane_bsize,
|
|
const TX_SIZE tx_size, const int plane,
|
|
const ENTROPY_CONTEXT *const a,
|
|
const ENTROPY_CONTEXT *const l,
|
|
TXB_CTX *const txb_ctx) {
|
|
switch (tx_size) {
|
|
case TX_4X4: get_txb_ctx_4x4(plane_bsize, plane, a, l, txb_ctx); break;
|
|
case TX_8X8: get_txb_ctx_8x8(plane_bsize, plane, a, l, txb_ctx); break;
|
|
case TX_16X16: get_txb_ctx_16x16(plane_bsize, plane, a, l, txb_ctx); break;
|
|
case TX_32X32: get_txb_ctx_32x32(plane_bsize, plane, a, l, txb_ctx); break;
|
|
default:
|
|
get_txb_ctx_general(plane_bsize, tx_size, plane, a, l, txb_ctx);
|
|
break;
|
|
}
|
|
}
|
|
#undef MAX_TX_SIZE_UNIT
|
|
|
|
#endif // AOM_AV1_COMMON_TXB_COMMON_H_
|