/*
 * Copyright (c) 2021, Alliance for Open Media. All rights reserved
 *
 * This source code is subject to the terms of the BSD 3-Clause Clear License
 * and the Alliance for Open Media Patent License 1.0. If the BSD 3-Clause Clear
 * License was not distributed with this source code in the LICENSE file, you
 * can obtain it at aomedia.org/license/software-license/bsd-3-c-c/.  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
 * aomedia.org/license/patent-license/.
 */

#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 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_bwl(TX_SIZE tx_size) {
  tx_size = av1_get_adjusted_tx_size(tx_size);
  return tx_size_wide_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 width) {
  return levels_buf + TX_PAD_TOP * (width + TX_PAD_HOR);
}

static AOM_FORCE_INLINE int get_padded_idx(const int idx, const int bwl) {
  return idx + ((idx >> bwl) << TX_PAD_HOR_LOG2);
}

// This function sets the signs buffer for coefficient coding.
static INLINE int8_t *set_signs(int8_t *const signs_buf, const int width) {
  return signs_buf + TX_PAD_TOP * (width + TX_PAD_HOR);
}

// This function returns the coefficient index after left padding.
static INLINE int get_padded_idx_left(const int idx, const int bwl) {
  return TX_PAD_LEFT + idx + ((idx >> bwl) << TX_PAD_HOR_LOG2);
}

/*
 This function returns the base range coefficient coding context index
 for forward skip residual coding for a given coefficient index.
 It assumes padding from left and sums left and above level
 samples: levels[pos - 1] + levels[pos - stride].
*/
static AOM_FORCE_INLINE int get_br_ctx_skip(const uint8_t *const levels,
                                            const int c, const int bwl) {
  const int row = c >> bwl;
  const int col = (c - (row << bwl)) + TX_PAD_LEFT;
  const int stride = (1 << bwl) + TX_PAD_LEFT;
  const int pos = row * stride + col;
#if CONFIG_COEFF_HR_LR1
  int mag = AOMMIN(levels[pos - 1], MAX_BASE_BR_RANGE);
  mag += AOMMIN(levels[pos - stride], MAX_BASE_BR_RANGE);
#else
  int mag = levels[pos - 1];
  mag += levels[pos - stride];
#endif  // CONFIG_COEFF_HR_LR1
  mag = AOMMIN(mag, 6);
#if CONFIG_IMPROVEIDTX
  return mag;
#else
  if ((row < 2) && (col < (2 + TX_PAD_LEFT))) return mag;
  return mag + 7;
#endif  // CONFIG_IMPROVEIDTX
}

static INLINE int get_br_ctx_2d(const uint8_t *const levels,
                                const int c,  // raster order
                                const int bwl) {
  assert(c > 0);
  const int row = c >> bwl;
  const int col = c - (row << bwl);
  const int stride = (1 << bwl) + TX_PAD_HOR;
  const int pos = row * stride + col;
  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);
  return mag;
}

#if CONFIG_CHROMA_CODING
static AOM_FORCE_INLINE int get_br_ctx_lf_eob_chroma(const int c,
                                                     const TX_CLASS tx_class) {
  if (tx_class == TX_CLASS_2D && c == 0) return 0;
  return 4;
}

static INLINE int get_br_ctx_2d_chroma(const uint8_t *const levels, const int c,
                                       const int bwl) {
  assert(c > 0);
  const int row = c >> bwl;
  const int col = c - (row << bwl);
  const int stride = (1 << bwl) + TX_PAD_HOR;
  const int pos = row * stride + col;
  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, 3);
  return mag;
}
#endif  // CONFIG_CHROMA_CODING

// This function returns the low range context index for
// the low-frequency region for the EOB coefficient.
static AOM_FORCE_INLINE int get_br_ctx_lf_eob(const int c,  // raster order
                                              const TX_CLASS tx_class) {
  if (tx_class == TX_CLASS_2D && c == 0) return 0;
  return 7;
}

#if CONFIG_CHROMA_CODING
// This function returns the low range context index/increment for the
// coefficients residing in the low-frequency region for 2D transforms.
// For chroma components only and not used for the DC term.
static INLINE int get_br_lf_ctx_2d_chroma(const uint8_t *const levels,
                                          const int c,  // raster order
                                          const int bwl) {
  assert(c > 0);
  const int row = c >> bwl;
  const int col = c - (row << bwl);
  const int stride = (1 << bwl) + TX_PAD_HOR;
  const int pos = row * stride + col;
  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, 3);
  return mag + 4;
}

// This function returns the low range context index/increment for the
// coefficients residing in the low-frequency region for 1D and 2D
// transforms and covers the 1D and 2D TX DC terms. For chroma only.
static AOM_FORCE_INLINE int get_br_lf_ctx_chroma(const uint8_t *const levels,
                                                 const int c,  // raster order
                                                 const int bwl,
                                                 const TX_CLASS tx_class) {
  const int row = c >> bwl;
  const int col = c - (row << bwl);
  const int stride = (1 << bwl) + TX_PAD_HOR;
  const int pos = row * stride + col;
  int mag = AOMMIN(levels[pos + 1], MAX_BASE_BR_RANGE);
  mag += levels[pos + stride];
  switch (tx_class) {
    case TX_CLASS_2D:
      mag += AOMMIN(levels[pos + stride + 1], MAX_BASE_BR_RANGE);
      mag = AOMMIN((mag + 1) >> 1, 3);
      if (c == 0) return mag;
      if ((row < 2) && (col < 2)) return mag + 4;
      break;
    case TX_CLASS_HORIZ:
      mag = AOMMIN((mag + 1) >> 1, 3);
      if (col == 0) return mag + 4;
      break;
    case TX_CLASS_VERT:
      mag = AOMMIN((mag + 1) >> 1, 3);
      if (row == 0) return mag + 4;
      break;
    default: break;
  }
  return mag + 4;
}

// This function returns the low range context index/increment for the
// coefficients residing in the higher-frequency default region
// for 1D and 2D transforms. For chroma.
static AOM_FORCE_INLINE int get_br_ctx_chroma(const uint8_t *const levels,
                                              const int c,  // raster order
                                              const int bwl,
                                              const TX_CLASS tx_class) {
  const int row = c >> bwl;
  const int col = c - (row << bwl);
  const int stride = (1 << bwl) + TX_PAD_HOR;
  const int pos = row * stride + col;
  int mag = levels[pos + 1];
  mag += levels[pos + stride];
  if (tx_class == TX_CLASS_2D) {
    mag += levels[pos + stride + 1];
  }
  mag = AOMMIN((mag + 1) >> 1, 3);
  return mag;
}
#endif  // CONFIG_CHROMA_CODING

// This function returns the low range context index/increment for the
// coefficients residing in the low-frequency region for 2D transforms.
// Not used for the DC term.
static INLINE int get_br_lf_ctx_2d(const uint8_t *const levels,
                                   const int c,  // raster order
                                   const int bwl) {
  assert(c > 0);
  const int row = c >> bwl;
  const int col = c - (row << bwl);
  const int stride = (1 << bwl) + TX_PAD_HOR;
  const int pos = row * stride + col;
  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);
  return mag + 7;
}

// This function returns the low range context index/increment for the
// coefficients residing in the low-frequency region for 1D and 2D
// transforms and covers the 1D and 2D TX DC terms.
static AOM_FORCE_INLINE int get_br_lf_ctx(const uint8_t *const levels,
                                          const int c,  // raster order
                                          const int bwl,
                                          const TX_CLASS tx_class) {
  const int row = c >> bwl;
  const int col = c - (row << bwl);
  const int stride = (1 << bwl) + TX_PAD_HOR;
  const int pos = row * stride + col;
  int mag = AOMMIN(levels[pos + 1], MAX_BASE_BR_RANGE);
#if CONFIG_COEFF_HR_LR1
  mag += AOMMIN(levels[pos + stride], MAX_BASE_BR_RANGE);
#else
  mag += levels[pos + stride];
#endif  // CONFIG_COEFF_HR_LR1
  switch (tx_class) {
    case TX_CLASS_2D:
      mag += AOMMIN(levels[pos + stride + 1], MAX_BASE_BR_RANGE);
      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 += AOMMIN(levels[pos + 2], MAX_BASE_BR_RANGE);
      mag = AOMMIN((mag + 1) >> 1, 6);
      if (col == 0) return mag + 7;
      break;
    case TX_CLASS_VERT:
      mag += AOMMIN(levels[pos + (stride << 1)], MAX_BASE_BR_RANGE);
      mag = AOMMIN((mag + 1) >> 1, 6);
      if (row == 0) return mag + 7;
      break;
    default: break;
  }
  return mag + 7;
}

// This function returns the low range context index/increment for the
// coefficients residing in the higher-frequency default region
// for 1D and 2D transforms.
static AOM_FORCE_INLINE int get_br_ctx(const uint8_t *const levels,
                                       const int c,  // raster order
                                       const int bwl, const TX_CLASS tx_class) {
  const int row = c >> bwl;
  const int col = c - (row << bwl);
  const int stride = (1 << bwl) + TX_PAD_HOR;
  const int pos = row * stride + col;
#if CONFIG_COEFF_HR_LR1
  int mag = AOMMIN(levels[pos + 1], MAX_BASE_BR_RANGE);
  mag += AOMMIN(levels[pos + stride], MAX_BASE_BR_RANGE);
  if (tx_class == TX_CLASS_2D) {
    mag += AOMMIN(levels[pos + stride + 1], MAX_BASE_BR_RANGE);
  } else if (tx_class == TX_CLASS_VERT) {
    mag += AOMMIN(levels[pos + (stride << 1)], MAX_BASE_BR_RANGE);
  } else {
    mag += AOMMIN(levels[pos + 2], MAX_BASE_BR_RANGE);
  }
#else
  int mag = levels[pos + 1];
  mag += levels[pos + stride];
  if (tx_class == TX_CLASS_2D) {
    mag += levels[pos + stride + 1];
  } else if (tx_class == TX_CLASS_VERT) {
    mag += levels[pos + (stride << 1)];
  } else {
    mag += levels[pos + 2];
  }
#endif  // CONFIG_COEFF_HR_LR1
  mag = AOMMIN((mag + 1) >> 1, 6);
  return mag;
}

static const uint8_t clip_max5[256] = {
  0, 1, 2, 3, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5
};

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
};

// This function returns the neighboring left + above levels with clipping.
static AOM_FORCE_INLINE int get_nz_mag_skip(const uint8_t *const levels,
                                            const int bwl) {
  int mag = clip_max3[levels[-1]];                      // { 0, -1 }
  mag += clip_max3[levels[-(1 << bwl) - TX_PAD_LEFT]];  // { -1, 0 }
#if CONFIG_IMPROVEIDTX
  const int ctx = AOMMIN(mag, 6);
  return ctx;
#else
  return mag;
#endif  // CONFIG_IMPROVEIDTX
}

/*
 This helper function computes the sign context index for FSC residual
 coding for a given coefficient index. Bottom, right and bottom-right
 samples are used to derive the index.
*/
static AOM_FORCE_INLINE int get_sign_skip(const int8_t *const signs,
                                          const uint8_t *const levels,
                                          const int bwl) {
  int signc = 0;
#if CONFIG_IMPROVEIDTX
  if (levels[-1]) signc += signs[-1];  // { 0, -1 }
  if (levels[-(1 << bwl) - TX_PAD_LEFT])
    signc += signs[-(1 << bwl) - TX_PAD_LEFT];  // { -1, 0 }
  if (levels[-(1 << bwl) - TX_PAD_LEFT - 1])
    signc += signs[-(1 << bwl) - TX_PAD_LEFT - 1];  // { -1, -1 }
#else
  if (levels[1]) signc += signs[1];  // { 0, +1 }
  if (levels[(1 << bwl) + TX_PAD_LEFT])
    signc += signs[(1 << bwl) + TX_PAD_LEFT];  // { +1, 0 }
  if (levels[(1 << bwl) + TX_PAD_LEFT + 1])
    signc += signs[(1 << bwl) + TX_PAD_LEFT + 1];  // { +1, +1 }
#endif  // CONFIG_IMPROVEIDTX
  if (signc > 2) return 5;
  if (signc < -2) return 6;
  if (signc > 0) return 1;
  if (signc < 0) return 2;
  return 0;
}

// This function returns the sign context index for residual coding.
static INLINE int get_sign_ctx_skip(const int8_t *const signs,
                                    const uint8_t *const levels,
                                    const int coeff_idx, const int bwl) {
#if CONFIG_IMPROVEIDTX
  const int8_t *const signs_pt = signs + get_padded_idx_left(coeff_idx, bwl);
#else
  const int8_t *const signs_pt = signs + get_padded_idx(coeff_idx, bwl);
#endif  // CONFIG_IMPROVEIDTX
  const uint8_t *const level_pt = levels + get_padded_idx_left(coeff_idx, bwl);
  int sign_ctx = get_sign_skip(signs_pt, level_pt, bwl);
  if (level_pt[0] > COEFF_BASE_RANGE && sign_ctx != 0) sign_ctx += 2;
  return sign_ctx;
}

#if CONFIG_CHROMA_CODING
// This function returns the template sum of absolute values
// for coefficient coding for the low-frequency region for chroma.
static AOM_FORCE_INLINE int get_nz_mag_lf_chroma(const uint8_t *const levels,
                                                 const int bwl,
                                                 const TX_CLASS tx_class) {
  int mag;
  // Note: AOMMIN(level, 5) is useless for decoder since level < 5.
  mag = clip_max5[levels[1]];                         // { 0, 1 }
  mag += clip_max5[levels[(1 << bwl) + TX_PAD_HOR]];  // { 1, 0 }
  if (tx_class == TX_CLASS_2D) {
    mag += clip_max5[levels[(1 << bwl) + TX_PAD_HOR + 1]];  // { 1, 1 }
  }
  return mag;
}

// This function returns the template sum of absolute values
// for coefficient coding for the default region for chroma.
static AOM_FORCE_INLINE int get_nz_mag_chroma(const uint8_t *const levels,
                                              const int bwl,
                                              const TX_CLASS tx_class) {
  int mag;
  // Note: AOMMIN(level, 3) is useless for decoder since level < 3.
  mag = clip_max3[levels[1]];                         // { 0, 1 }
  mag += clip_max3[levels[(1 << bwl) + TX_PAD_HOR]];  // { 1, 0 }
  if (tx_class == TX_CLASS_2D) {
    mag += clip_max3[levels[(1 << bwl) + TX_PAD_HOR + 1]];  // { 1, 1 }
  }
  return mag;
}
#endif  // CONFIG_CHROMA_CODING

// This function returns the template sum of absolute values
// for coefficient coding for the low-frequency region.
static AOM_FORCE_INLINE int get_nz_mag_lf(const uint8_t *const levels,
                                          const int bwl,
                                          const TX_CLASS tx_class) {
  int mag;
  // Note: AOMMIN(level, 5) is useless for decoder since level < 5.
  mag = clip_max5[levels[1]];                         // { 0, 1 }
  mag += clip_max5[levels[(1 << bwl) + TX_PAD_HOR]];  // { 1, 0 }
  if (tx_class == TX_CLASS_2D) {
    mag += clip_max5[levels[(1 << bwl) + TX_PAD_HOR + 1]];          // { 1, 1 }
    mag += clip_max5[levels[2]];                                    // { 0, 2 }
    mag += clip_max5[levels[(2 << bwl) + (2 << TX_PAD_HOR_LOG2)]];  // { 2, 0 }
  } else if (tx_class == TX_CLASS_VERT) {
    mag += clip_max3[levels[(2 << bwl) + (2 << TX_PAD_HOR_LOG2)]];  // { 2, 0 }
    mag += clip_max3[levels[(3 << bwl) + (3 << TX_PAD_HOR_LOG2)]];  // { 3, 0 }
    mag += clip_max3[levels[(4 << bwl) + (4 << TX_PAD_HOR_LOG2)]];  // { 4, 0 }
  } else {
    mag += clip_max3[levels[2]];  // { 0, 2 }
    mag += clip_max3[levels[3]];  // { 0, 3 }
    mag += clip_max3[levels[4]];  // { 0, 4 }
  }
  return mag;
}

// This function returns the template sum of absolute values
// for coefficient coding for the higher-frequency default region.
static AOM_FORCE_INLINE int get_nz_mag(const uint8_t *const levels,
                                       const int bwl, const TX_CLASS tx_class) {
  int mag;

  // Note: AOMMIN(level, 3) is useless for decoder since level < 3.
  mag = clip_max3[levels[1]];                         // { 0, 1 }
  mag += clip_max3[levels[(1 << bwl) + TX_PAD_HOR]];  // { 1, 0 }

  if (tx_class == TX_CLASS_2D) {
    mag += clip_max3[levels[(1 << bwl) + TX_PAD_HOR + 1]];          // { 1, 1 }
    mag += clip_max3[levels[2]];                                    // { 0, 2 }
    mag += clip_max3[levels[(2 << bwl) + (2 << TX_PAD_HOR_LOG2)]];  // { 2, 0 }
  } else if (tx_class == TX_CLASS_VERT) {
    mag += clip_max3[levels[(2 << bwl) + (2 << TX_PAD_HOR_LOG2)]];  // { 2, 0 }
    mag += clip_max3[levels[(3 << bwl) + (3 << TX_PAD_HOR_LOG2)]];  // { 3, 0 }
    mag += clip_max3[levels[(4 << bwl) + (4 << TX_PAD_HOR_LOG2)]];  // { 4, 0 }
  } else {
    mag += clip_max3[levels[2]];  // { 0, 2 }
    mag += clip_max3[levels[3]];  // { 0, 3 }
    mag += clip_max3[levels[4]];  // { 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_skip(const int stats,
                                                           const int coeff_idx,
                                                           const int bwl) {
  const int ctx = AOMMIN(stats, 6);
  const int row = (coeff_idx >> bwl);
  const int col = (coeff_idx - (row << bwl)) + TX_PAD_LEFT;
  if ((row < 2) && (col < (2 + TX_PAD_LEFT))) return ctx;
  return ctx + 7;
}

#if CONFIG_CHROMA_CODING
// This function returns the base range context index/increment for the
// coefficients residing in the low-frequency region for 1D/2D transforms for
// chroma.
static AOM_FORCE_INLINE int get_nz_map_ctx_from_stats_lf_chroma(
    const int stats, const TX_CLASS tx_class, int plane) {
  int ctx = AOMMIN((stats + 1) >> 1, 3);
  if (tx_class == TX_CLASS_2D) {
    return plane == AOM_PLANE_U ? ctx : ctx + 4;
  } else if (tx_class == TX_CLASS_HORIZ || tx_class == TX_CLASS_VERT) {
    return ctx + LF_SIG_COEF_CONTEXTS_2D_UV;
  }
  return 0;
}
#endif  // CONFIG_CHROMA_CODING

// This function returns the base range context index/increment for the
// coefficients residing in the low-frequency region for 1D/2D transforms.
static AOM_FORCE_INLINE int get_nz_map_ctx_from_stats_lf(
    const int stats,
    const int coeff_idx,  // raster order
    const int bwl, const TX_CLASS tx_class) {
  int ctx = (stats + 1) >> 1;
  switch (tx_class) {
    case TX_CLASS_2D: {
      const int row = coeff_idx >> bwl;
      const int col = coeff_idx - (row << bwl);
      if (coeff_idx == 0) {
        ctx = AOMMIN(ctx, 8);
        return ctx;
      }
      if (row + col < 2) {
        ctx = AOMMIN(ctx, 6);
        return ctx + 9;
      }
      ctx = AOMMIN(ctx, 4);
      return ctx + 16;
    }
    case TX_CLASS_HORIZ: {
      const int row = coeff_idx >> bwl;
      const int col = coeff_idx - (row << bwl);
      if (col == 0) {
        ctx = AOMMIN(ctx, 6);
        ctx += LF_SIG_COEF_CONTEXTS_2D;
      } else {  // col == 1
        ctx = AOMMIN(ctx, 4);
        ctx += LF_SIG_COEF_CONTEXTS_2D + 7;
      }
      return ctx;
    }
    case TX_CLASS_VERT: {
      const int row = coeff_idx >> bwl;
      if (row == 0) {
        ctx = AOMMIN(ctx, 6);
        ctx += LF_SIG_COEF_CONTEXTS_2D;
      } else {  // row == 1
        ctx = AOMMIN(ctx, 4);
        ctx += LF_SIG_COEF_CONTEXTS_2D + 7;
      }
      return ctx;
    }
    default: break;
  }
  return 0;
}

#if CONFIG_CHROMA_CODING
// This function returns the base range context index/increment for the
// coefficients residing in the higher-frequency region for 1D/2D transforms for
// chroma.
static AOM_FORCE_INLINE int get_nz_map_ctx_from_stats_chroma(
    const int stats,
    const int coeff_idx,  // raster order
    const TX_CLASS tx_class, int plane) {
  if ((tx_class | coeff_idx) == 0) return 0;
  int ctx = AOMMIN((stats + 1) >> 1, 3);
  if (tx_class == TX_CLASS_2D) {
    return plane == AOM_PLANE_U ? ctx : ctx + 4;
  }
  return ctx + LF_SIG_COEF_CONTEXTS_2D_UV;
}
#endif  // CONFIG_CHROMA_CODING

// This function returns the base range context index/increment for the
// coefficients residing in the higher-frequency region for 1D/2D transforms.
static AOM_FORCE_INLINE int get_nz_map_ctx_from_stats(
    const int stats,
    const int coeff_idx,  // raster order
    const int bwl, const TX_CLASS tx_class
#if CONFIG_CHROMA_CODING
    ,
    const int plane
#endif  // CONFIG_CHROMA_CODING
) {
  // 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: {
#if CONFIG_CHROMA_CODING
      if (plane > 0) return ctx;
#endif  // CONFIG_CHROMA_CODING
      const int row = coeff_idx >> bwl;
      const int col = coeff_idx - (row << bwl);
      if (row + col < 6) return ctx;
      if (row + col < 8) return 5 + ctx;
      return 10 + ctx;
    }
    case TX_CLASS_HORIZ: {
      return ctx + 15;
    }
    case TX_CLASS_VERT: {
      return ctx + 15;
    }
    default: break;
  }
  return 0;
}

typedef aom_cdf_prob (*base_lf_cdf_arr)[CDF_SIZE(LF_BASE_SYMBOLS)];
typedef aom_cdf_prob (*base_cdf_arr)[CDF_SIZE(4)];
typedef aom_cdf_prob (*br_cdf_arr)[CDF_SIZE(BR_CDF_SIZE)];
// This function returns the base range context index/increment for the
// coefficients with hidden parity.
static INLINE int get_base_ctx_ph(const uint8_t *levels, int pos, int bwl,
                                  const TX_CLASS tx_class) {
  const int stats =
      get_nz_mag(levels + get_padded_idx(pos, bwl), bwl, tx_class);
  return AOMMIN((stats + 1) >> 1, (COEFF_BASE_PH_CONTEXTS - 1));
}

// This function returns the low range context index/increment for the
// coefficients with hidden parity.
static AOM_FORCE_INLINE int get_par_br_ctx(const uint8_t *const levels,
                                           const int c,  // raster order
                                           const int bwl,
                                           const TX_CLASS tx_class) {
  const int row = c >> bwl;
  const int col = c - (row << bwl);
  const int stride = (1 << bwl) + TX_PAD_HOR;
  const int pos = row * stride + col;
  int mag = AOMMIN(levels[pos + 1], MAX_BASE_BR_RANGE);
  mag += AOMMIN(levels[pos + stride], MAX_BASE_BR_RANGE);
  switch (tx_class) {
    case TX_CLASS_2D:
      mag += AOMMIN(levels[pos + stride + 1], MAX_BASE_BR_RANGE);
      mag = AOMMIN((mag + 1) >> 1, (COEFF_BR_PH_CONTEXTS - 1));
      break;
    case TX_CLASS_HORIZ:
      mag += AOMMIN(levels[pos + 2], MAX_BASE_BR_RANGE);
      mag = AOMMIN((mag + 1) >> 1, (COEFF_BR_PH_CONTEXTS - 1));
      break;
    case TX_CLASS_VERT:
      mag += AOMMIN(levels[pos + (stride << 1)], MAX_BASE_BR_RANGE);
      mag = AOMMIN((mag + 1) >> 1, (COEFF_BR_PH_CONTEXTS - 1));
      break;
    default: break;
  }
  return mag;
}

static AOM_FORCE_INLINE int get_lower_levels_ctx_eob(int bwl, int height,
                                                     int scan_idx) {
  if (scan_idx == 0) return 0;
  if (scan_idx <= (height << bwl) / 8) return 1;
  if (scan_idx <= (height << bwl) / 4) return 2;
  return 3;
}

// Return context index for first position.
static AOM_FORCE_INLINE int get_lower_levels_ctx_bob(int bwl, int height,
                                                     int scan_idx) {
  if (scan_idx <= (height << bwl) / 8) return 0;
  if (scan_idx <= (height << bwl) / 4) return 1;
  return 2;
}

static AOM_FORCE_INLINE int get_upper_levels_ctx_2d(const uint8_t *levels,
                                                    int coeff_idx, int bwl) {
  int mag;
  levels = levels + get_padded_idx_left(coeff_idx, bwl);
  mag = AOMMIN(levels[-1], 3);                          // { 0, -1 }
  mag += AOMMIN(levels[-(1 << bwl) - TX_PAD_LEFT], 3);  // { -1, 0 }
  const int ctx = AOMMIN(mag, 6);
#if CONFIG_IMPROVEIDTX
  return ctx;
#else
  const int row = (coeff_idx >> bwl);
  const int col = (coeff_idx - (row << bwl)) + TX_PAD_LEFT;
  if ((row < 2) && (col < (2 + TX_PAD_LEFT))) return ctx;
  return ctx + 7;
#endif  // CONFIG_IMPROVEIDTX
}

#if CONFIG_CHROMA_CODING
// This function returns the base range context index/increment for the
// coefficients residing in the low-frequency region for 2D transforms.
static AOM_FORCE_INLINE int get_lower_levels_ctx_lf_2d_chroma(
    const uint8_t *levels, int coeff_idx, int bwl, int plane) {
  assert(coeff_idx > 0);
  int mag;
  // Note: AOMMIN(level, 3) is useless for decoder since level < 5.
  levels = levels + get_padded_idx(coeff_idx, bwl);
  mag = AOMMIN(levels[1], 5);                             // { 0, 1 }
  mag += AOMMIN(levels[(1 << bwl) + TX_PAD_HOR], 5);      // { 1, 0 }
  mag += AOMMIN(levels[(1 << bwl) + TX_PAD_HOR + 1], 5);  // { 1, 1 }
  int ctx = AOMMIN((mag + 1) >> 1, 3);
  return plane == AOM_PLANE_U ? ctx : ctx + 4;
}

static AOM_FORCE_INLINE int get_lower_levels_lf_ctx_chroma(
    const uint8_t *levels, int coeff_idx, int bwl, TX_CLASS tx_class,
    int plane) {
  const int stats = get_nz_mag_lf_chroma(
      levels + get_padded_idx(coeff_idx, bwl), bwl, tx_class);
  return get_nz_map_ctx_from_stats_lf_chroma(stats, tx_class, plane);
}

static INLINE int get_lower_levels_ctx_2d_chroma(const uint8_t *levels,
                                                 int coeff_idx, int bwl,
                                                 int plane) {
  assert(coeff_idx > 0);
  int mag;
  // Note: AOMMIN(level, 3) is useless for decoder since level < 3.
  levels = levels + get_padded_idx(coeff_idx, bwl);
  mag = AOMMIN(levels[1], 3);                             // { 0, 1 }
  mag += AOMMIN(levels[(1 << bwl) + TX_PAD_HOR], 3);      // { 1, 0 }
  mag += AOMMIN(levels[(1 << bwl) + TX_PAD_HOR + 1], 3);  // { 1, 1 }
  const int ctx = AOMMIN((mag + 1) >> 1, 3);
  if (plane == AOM_PLANE_U) {
    return ctx;
  } else {
    return ctx + 4;
  }
}
#endif  // CONFIG_CHROMA_CODING

// This function returns the base range context index/increment for the
// coefficients residing in the low-frequency region for 2D transforms.
static INLINE int get_lower_levels_ctx_lf_2d(const uint8_t *levels,
                                             int coeff_idx, int bwl) {
  assert(coeff_idx > 0);
  int mag;
  // Note: AOMMIN(level, 3) is useless for decoder since level < 5.
  levels = levels + get_padded_idx(coeff_idx, bwl);
  mag = AOMMIN(levels[1], 5);                                     // { 0, 1 }
  mag += AOMMIN(levels[(1 << bwl) + TX_PAD_HOR], 5);              // { 1, 0 }
  mag += AOMMIN(levels[(1 << bwl) + TX_PAD_HOR + 1], 5);          // { 1, 1 }
  mag += AOMMIN(levels[2], 5);                                    // { 0, 2 }
  mag += AOMMIN(levels[(2 << bwl) + (2 << TX_PAD_HOR_LOG2)], 5);  // { 2, 0 }
  int ctx = (mag + 1) >> 1;
  const int row = coeff_idx >> bwl;
  const int col = coeff_idx - (row << bwl);
  if (coeff_idx == 0) {
    ctx = AOMMIN(ctx, 8);
    return ctx;
  }
  if (row + col < 2) {
    ctx = AOMMIN(ctx, 6);
    return ctx + 9;
  }
  ctx = AOMMIN(ctx, 4);
  return ctx + 16;
}

static AOM_FORCE_INLINE int get_lower_levels_lf_ctx(const uint8_t *levels,
                                                    int coeff_idx, int bwl,
                                                    TX_CLASS tx_class) {
  const int stats =
      get_nz_mag_lf(levels + get_padded_idx(coeff_idx, bwl), bwl, tx_class);
  return get_nz_map_ctx_from_stats_lf(stats, coeff_idx, bwl, tx_class);
}

static INLINE int get_lower_levels_ctx_2d(const uint8_t *levels, int coeff_idx,
                                          int bwl
#if CONFIG_CHROMA_CODING
                                          ,
                                          int plane
#endif  // CONFIG_CHROMA_CODING
) {
  assert(coeff_idx > 0);
  int mag;
  // Note: AOMMIN(level, 3) is useless for decoder since level < 3.
  levels = levels + get_padded_idx(coeff_idx, bwl);
  mag = AOMMIN(levels[1], 3);                                     // { 0, 1 }
  mag += AOMMIN(levels[(1 << bwl) + TX_PAD_HOR], 3);              // { 1, 0 }
  mag += AOMMIN(levels[(1 << bwl) + TX_PAD_HOR + 1], 3);          // { 1, 1 }
  mag += AOMMIN(levels[2], 3);                                    // { 0, 2 }
  mag += AOMMIN(levels[(2 << bwl) + (2 << TX_PAD_HOR_LOG2)], 3);  // { 2, 0 }

  const int ctx = AOMMIN((mag + 1) >> 1, 4);
#if CONFIG_CHROMA_CODING
  if (plane > 0) return ctx;
#endif  // CONFIG_CHROMA_CODING
  const int row = coeff_idx >> bwl;
  const int col = coeff_idx - (row << bwl);
  if (row + col < 6) return ctx;
  if (row + col < 8) return ctx + 5;
  return ctx + 10;
}

// This function determines the limits to separate the low-frequency
// coefficient coding region from the higher-frequency default
// region. It is based on the diagonal sum (row+col) or row, columns
// of the given coefficient in a scan order.
static AOM_FORCE_INLINE int get_lf_limits(int row, int col, TX_CLASS tx_class,
                                          int plane) {
  int limits = 0;
  if (tx_class == TX_CLASS_2D) {
    limits =
        plane == 0 ? ((row + col) < LF_2D_LIM) : ((row + col) < LF_2D_LIM_UV);
  } else if (tx_class == TX_CLASS_HORIZ) {
    limits = plane == 0 ? (col < LF_RC_LIM) : (col < LF_RC_LIM_UV);
  } else {
    limits = plane == 0 ? (row < LF_RC_LIM) : (row < LF_RC_LIM_UV);
  }
  return limits;
}

#if CONFIG_CHROMA_CODING
static AOM_FORCE_INLINE int get_lower_levels_ctx_chroma(const uint8_t *levels,
                                                        int coeff_idx, int bwl,
                                                        TX_CLASS tx_class,
                                                        int plane) {
  const int stats =
      get_nz_mag_chroma(levels + get_padded_idx(coeff_idx, bwl), bwl, tx_class);
  return get_nz_map_ctx_from_stats_chroma(stats, coeff_idx, tx_class, plane);
}
#endif  // CONFIG_CHROMA_CODING

static AOM_FORCE_INLINE int get_lower_levels_ctx(const uint8_t *levels,
                                                 int coeff_idx, int bwl,
                                                 TX_CLASS tx_class
#if CONFIG_CHROMA_CODING
                                                 ,
                                                 int plane
#endif  // CONFIG_CHROMA_CODING
) {
  const int stats =
      get_nz_mag(levels + get_padded_idx(coeff_idx, bwl), bwl, tx_class);
  return get_nz_map_ctx_from_stats(stats, coeff_idx, bwl, tx_class
#if CONFIG_CHROMA_CODING

                                   ,
                                   plane
#endif  // CONFIG_CHROMA_CODING
  );
}

#if CONFIG_IMPROVEIDTX
// This function determines the context index for 2D IDTX residual coding
// used primarily by the trellis optimization for IDTX.
static INLINE int get_upper_levels_ctx_general(int is_first, int scan_idx,
                                               int bwl, int height,
                                               const uint8_t *levels,
                                               int coeff_idx) {
  if (is_first) {
    if (scan_idx <= (height << bwl) / 8) return 0;
    if (scan_idx <= (height << bwl) / 4) return 1;
    return 2;
  }
  return get_upper_levels_ctx_2d(levels, coeff_idx, bwl);
}
#endif  // CONFIG_IMPROVEIDTX

static INLINE int get_lower_levels_ctx_general(int is_last, int scan_idx,
                                               int bwl, int height,
                                               const uint8_t *levels,
                                               int coeff_idx, TX_CLASS tx_class,
                                               int plane) {
  if (is_last) {
    if (scan_idx == 0) return 0;
    if (scan_idx <= (height << bwl) >> 3) return 1;
    if (scan_idx <= (height << bwl) >> 2) return 2;
    return 3;
  }
  const int row = coeff_idx >> bwl;
  const int col = coeff_idx - (row << bwl);
  int limits = get_lf_limits(row, col, tx_class, plane);

#if CONFIG_CHROMA_CODING
  if (plane > 0) {
    if (limits) {
      return get_lower_levels_lf_ctx_chroma(levels, coeff_idx, bwl, tx_class,
                                            plane);
    } else {
      return get_lower_levels_ctx_chroma(levels, coeff_idx, bwl, tx_class,
                                         plane);
    }
  } else {
    if (limits) {
      return get_lower_levels_lf_ctx(levels, coeff_idx, bwl, tx_class);
    } else {
      return get_lower_levels_ctx(levels, coeff_idx, bwl, tx_class
#if CONFIG_CHROMA_CODING
                                  ,
                                  plane
#endif  // CONFIG_CHROMA_CODING
      );
    }
  }
#else
  if (limits) {
    return get_lower_levels_lf_ctx(levels, coeff_idx, bwl, tx_class);
  } else {
    return get_lower_levels_ctx(levels, coeff_idx, bwl, tx_class
#if CONFIG_CHROMA_CODING
                                ,
                                plane
#endif  // CONFIG_CHROMA_CODING
    );
  }
#endif  // CONFIG_CHROMA_CODING
}

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 INLINE void get_txb_ctx_skip(const BLOCK_SIZE plane_bsize,
                                    const TX_SIZE tx_size,
                                    const ENTROPY_CONTEXT *const a,
                                    const ENTROPY_CONTEXT *const l,
                                    TXB_CTX *const txb_ctx) {
#if CONFIG_TX_SKIP_FLAG_MODE_DEP_CTX
  (void)plane_bsize;
  (void)tx_size;
  (void)a;
  (void)l;
  const int skip_offset = 13;
  txb_ctx->dc_sign_ctx = 0;
  txb_ctx->txb_skip_ctx = skip_offset;
#else
  const int txb_w_unit = tx_size_wide_unit[tx_size];
  const int txb_h_unit = tx_size_high_unit[tx_size];
  const int skip_offset = 13;
  txb_ctx->dc_sign_ctx = 0;
  if (plane_bsize == txsize_to_bsize[tx_size]) {
    txb_ctx->txb_skip_ctx = skip_offset;
  } 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;
    int 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] + skip_offset;
  }
#endif  // CONFIG_TX_SKIP_FLAG_MODE_DEP_CTX
}

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, uint8_t fsc_mode) {
#define MAX_TX_SIZE_UNIT 16
  if (fsc_mode && plane == PLANE_TYPE_Y) {
    get_txb_ctx_skip(plane_bsize, tx_size, a, l, txb_ctx);
    return;
  }
  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 {
#if CONFIG_TX_SKIP_FLAG_MODE_DEP_CTX
      // This is the algorithm to generate table skip_contexts[top][left].
      //    const int diag = top + left;
      //    const int min = AOMMIN(AOMMIN(top, left), 4);
      //    if (diag == 0)
      //      txb_skip_ctx = 1;
      //    else if (diag==1 || diag==2)
      //      txb_skip_ctx = 2;
      //    else if (diag==3 || diag==4)
      //      txb_skip_ctx = 3;
      //    else if (diag==5 || diag==6)
      //      txb_skip_ctx = 4;
      //    else
      //      txb_skip_ctx = 5;
      static const uint8_t skip_contexts[5][5] = { { 1, 2, 2, 3, 3 },
                                                   { 2, 2, 3, 3, 4 },
                                                   { 2, 3, 3, 4, 4 },
                                                   { 3, 3, 4, 4, 5 },
                                                   { 3, 4, 4, 5, 5 } };
#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 } };
#endif  // CONFIG_TX_SKIP_FLAG_MODE_DEP_CTX
      // 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);
#if CONFIG_CONTEXT_DERIVATION
    int ctx_offset = 0;
    if (plane == AOM_PLANE_U) {
#if CONFIG_TX_SKIP_FLAG_MODE_DEP_CTX
      ctx_offset = 7;
#else
      ctx_offset = (num_pels_log2_lookup[plane_bsize] >
                    num_pels_log2_lookup[txsize_to_bsize[tx_size]])
                       ? 10
                       : 7;
#endif  // CONFIG_TX_SKIP_FLAG_MODE_DEP_CTX
    } else {
      ctx_offset = (num_pels_log2_lookup[plane_bsize] >
                    num_pels_log2_lookup[txsize_to_bsize[tx_size]])
                       ? (V_TXB_SKIP_CONTEXT_OFFSET >> 1)
                       : 0;
    }
    txb_ctx->txb_skip_ctx = ctx_base + ctx_offset;
#else
#if CONFIG_TX_SKIP_FLAG_MODE_DEP_CTX
    const int ctx_offset = 7;
#else
    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;
#endif  // CONFIG_TX_SKIP_FLAG_MODE_DEP_CTX
#endif  // CONFIG_CONTEXT_DERIVATION
  }
#undef MAX_TX_SIZE_UNIT
}

#endif  // AOM_AV1_COMMON_TXB_COMMON_H_