/*

 * 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.

 */

#include <assert.h>

#include <stdbool.h>

#include <stddef.h>

#include "config/aom_config.h"

#include "config/aom_scale_rtcd.h"

#include "aom/aom_codec.h"

#include "aom/aom_image.h"

#include "aom/internal/aom_codec_internal.h"

#include "aom_dsp/aom_dsp_common.h"

#include "aom_dsp/binary_codes_reader.h"

#include "aom_dsp/bitreader.h"

#include "aom_dsp/bitreader_buffer.h"

#include "aom_dsp/txfm_common.h"

#include "aom_mem/aom_mem.h"

#include "aom_ports/aom_timer.h"

#include "aom_ports/mem.h"

#include "aom_ports/mem_ops.h"

#include "aom_scale/yv12config.h"

#include "aom_util/aom_pthread.h"

#include "aom_util/aom_thread.h"

#if CONFIG_BITSTREAM_DEBUG || CONFIG_MISMATCH_DEBUG

#include "aom_util/debug_util.h"

#endif  // CONFIG_BITSTREAM_DEBUG || CONFIG_MISMATCH_DEBUG

#include "av1/common/alloccommon.h"

#include "av1/common/av1_common_int.h"

#include "av1/common/blockd.h"

#include "av1/common/cdef.h"

#include "av1/common/cfl.h"

#include "av1/common/common_data.h"

#include "av1/common/common.h"

#include "av1/common/entropy.h"

#include "av1/common/entropymode.h"

#include "av1/common/entropymv.h"

#include "av1/common/enums.h"

#include "av1/common/frame_buffers.h"

#include "av1/common/idct.h"

#include "av1/common/mv.h"

#include "av1/common/mvref_common.h"

#include "av1/common/obmc.h"

#include "av1/common/pred_common.h"

#include "av1/common/quant_common.h"

#include "av1/common/reconinter.h"

#include "av1/common/reconintra.h"

#include "av1/common/resize.h"

#include "av1/common/restoration.h"

#include "av1/common/scale.h"

#include "av1/common/seg_common.h"

#include "av1/common/thread_common.h"

#include "av1/common/tile_common.h"

#include "av1/common/warped_motion.h"

#include "av1/decoder/decodeframe.h"

#include "av1/decoder/decodemv.h"

#include "av1/decoder/decoder.h"

#include "av1/decoder/decodetxb.h"

#include "av1/decoder/detokenize.h"

#if CONFIG_INSPECTION

#include "av1/decoder/inspection.h"

#endif

#define ACCT_STR __func__

#define AOM_MIN_THREADS_PER_TILE 1

#define AOM_MAX_THREADS_PER_TILE 2

// This is needed by ext_tile related unit tests.

#define EXT_TILE_DEBUG 1

#define MC_TEMP_BUF_PELS                       \

  (((MAX_SB_SIZE)*2 + (AOM_INTERP_EXTEND)*2) * \

   ((MAX_SB_SIZE)*2 + (AOM_INTERP_EXTEND)*2))

// Checks that the remaining bits start with a 1 and ends with 0s.

// It consumes an additional byte, if already byte aligned before the check.

int av1_check_trailing_bits(AV1Decoder *pbi, struct aom_read_bit_buffer *rb) {

  // bit_offset is set to 0 (mod 8) when the reader is already byte aligned

  int bits_before_alignment = 8 - rb->bit_offset % 8;

  int trailing = aom_rb_read_literal(rb, bits_before_alignment);

  if (trailing != (1 << (bits_before_alignment - 1))) {

    pbi->error.error_code = AOM_CODEC_CORRUPT_FRAME;

    return -1;

  }

  return 0;

}

// Use only_chroma = 1 to only set the chroma planes

static inline void set_planes_to_neutral_grey(

    const SequenceHeader *const seq_params, const YV12_BUFFER_CONFIG *const buf,

    int only_chroma) {

  if (seq_params->use_highbitdepth) {

    const int val = 1 << (seq_params->bit_depth - 1);

    for (int plane = only_chroma; plane < MAX_MB_PLANE; plane++) {

      const int is_uv = plane > 0;

      uint16_t *const base = CONVERT_TO_SHORTPTR(buf->buffers[plane]);

      // Set the first row to neutral grey. Then copy the first row to all

      // subsequent rows.

      if (buf->crop_heights[is_uv] > 0) {

        aom_memset16(base, val, buf->crop_widths[is_uv]);

        for (int row_idx = 1; row_idx < buf->crop_heights[is_uv]; row_idx++) {

          memcpy(&base[row_idx * buf->strides[is_uv]], base,

                 sizeof(*base) * buf->crop_widths[is_uv]);

        }

      }

    }

  } else {

    for (int plane = only_chroma; plane < MAX_MB_PLANE; plane++) {

      const int is_uv = plane > 0;

      for (int row_idx = 0; row_idx < buf->crop_heights[is_uv]; row_idx++) {

        memset(&buf->buffers[plane][row_idx * buf->strides[is_uv]], 1 << 7,

               buf->crop_widths[is_uv]);

      }

    }

  }

}

static inline void loop_restoration_read_sb_coeffs(const AV1_COMMON *const cm,

                                                   MACROBLOCKD *xd,

                                                   aom_reader *const r,

                                                   int plane, int runit_idx);

static int read_is_valid(const uint8_t *start, size_t len, const uint8_t *end) {

  return len != 0 && len <= (size_t)(end - start);

}

static TX_MODE read_tx_mode(struct aom_read_bit_buffer *rb,

                            int coded_lossless) {

  if (coded_lossless) return ONLY_4X4;

  return aom_rb_read_bit(rb) ? TX_MODE_SELECT : TX_MODE_LARGEST;

}

static REFERENCE_MODE read_frame_reference_mode(

    const AV1_COMMON *cm, struct aom_read_bit_buffer *rb) {

  if (frame_is_intra_only(cm)) {

    return SINGLE_REFERENCE;

  } else {

    return aom_rb_read_bit(rb) ? REFERENCE_MODE_SELECT : SINGLE_REFERENCE;

  }

}

static inline void inverse_transform_block(DecoderCodingBlock *dcb, int plane,

                                           const TX_TYPE tx_type,

                                           const TX_SIZE tx_size, uint8_t *dst,

                                           int stride, int reduced_tx_set) {

  tran_low_t *const dqcoeff = dcb->dqcoeff_block[plane] + dcb->cb_offset[plane];

  eob_info *eob_data = dcb->eob_data[plane] + dcb->txb_offset[plane];

  uint16_t scan_line = eob_data->max_scan_line;

  uint16_t eob = eob_data->eob;

  av1_inverse_transform_block(&dcb->xd, dqcoeff, plane, tx_type, tx_size, dst,

                              stride, eob, reduced_tx_set);

  memset(dqcoeff, 0, (scan_line + 1) * sizeof(dqcoeff[0]));

}

static inline void read_coeffs_tx_intra_block(

    const AV1_COMMON *const cm, DecoderCodingBlock *dcb, aom_reader *const r,

    const int plane, const int row, const int col, const TX_SIZE tx_size) {

  MB_MODE_INFO *mbmi = dcb->xd.mi[0];

  if (!mbmi->skip_txfm) {

#if TXCOEFF_TIMER

    struct aom_usec_timer timer;

    aom_usec_timer_start(&timer);

#endif

    av1_read_coeffs_txb(cm, dcb, r, plane, row, col, tx_size);

#if TXCOEFF_TIMER

    aom_usec_timer_mark(&timer);

    const int64_t elapsed_time = aom_usec_timer_elapsed(&timer);

    cm->txcoeff_timer += elapsed_time;

    ++cm->txb_count;

#endif

  }

}

static inline void decode_block_void(const AV1_COMMON *const cm,

                                     DecoderCodingBlock *dcb,

                                     aom_reader *const r, const int plane,

                                     const int row, const int col,

                                     const TX_SIZE tx_size) {

  (void)cm;

  (void)dcb;

  (void)r;

  (void)plane;

  (void)row;

  (void)col;

  (void)tx_size;

}

static inline void predict_inter_block_void(AV1_COMMON *const cm,

                                            DecoderCodingBlock *dcb,

                                            BLOCK_SIZE bsize) {

  (void)cm;

  (void)dcb;

  (void)bsize;

}

static inline void cfl_store_inter_block_void(AV1_COMMON *const cm,

                                              MACROBLOCKD *const xd) {

  (void)cm;

  (void)xd;

}

static inline void predict_and_reconstruct_intra_block(

    const AV1_COMMON *const cm, DecoderCodingBlock *dcb, aom_reader *const r,

    const int plane, const int row, const int col, const TX_SIZE tx_size) {

  (void)r;

  MACROBLOCKD *const xd = &dcb->xd;

  MB_MODE_INFO *mbmi = xd->mi[0];

  PLANE_TYPE plane_type = get_plane_type(plane);

  av1_predict_intra_block_facade(cm, xd, plane, col, row, tx_size);

  if (!mbmi->skip_txfm) {

    eob_info *eob_data = dcb->eob_data[plane] + dcb->txb_offset[plane];

    if (eob_data->eob) {

      const bool reduced_tx_set_used = cm->features.reduced_tx_set_used;

      // tx_type was read out in av1_read_coeffs_txb.

      const TX_TYPE tx_type = av1_get_tx_type(xd, plane_type, row, col, tx_size,

                                              reduced_tx_set_used);

      struct macroblockd_plane *const pd = &xd->plane[plane];

      uint8_t *dst = &pd->dst.buf[(row * pd->dst.stride + col) << MI_SIZE_LOG2];

      inverse_transform_block(dcb, plane, tx_type, tx_size, dst, pd->dst.stride,

                              reduced_tx_set_used);

    }

  }

  if (plane == AOM_PLANE_Y && store_cfl_required(cm, xd)) {

    cfl_store_tx(xd, row, col, tx_size, mbmi->bsize);

  }

}

static inline void inverse_transform_inter_block(

    const AV1_COMMON *const cm, DecoderCodingBlock *dcb, aom_reader *const r,

    const int plane, const int blk_row, const int blk_col,

    const TX_SIZE tx_size) {

  (void)r;

  MACROBLOCKD *const xd = &dcb->xd;

  PLANE_TYPE plane_type = get_plane_type(plane);

  const struct macroblockd_plane *const pd = &xd->plane[plane];

  const bool reduced_tx_set_used = cm->features.reduced_tx_set_used;

  // tx_type was read out in av1_read_coeffs_txb.

  const TX_TYPE tx_type = av1_get_tx_type(xd, plane_type, blk_row, blk_col,

                                          tx_size, reduced_tx_set_used);

  uint8_t *dst =

      &pd->dst.buf[(blk_row * pd->dst.stride + blk_col) << MI_SIZE_LOG2];

  inverse_transform_block(dcb, plane, tx_type, tx_size, dst, pd->dst.stride,

                          reduced_tx_set_used);

#if CONFIG_MISMATCH_DEBUG

  int pixel_c, pixel_r;

  BLOCK_SIZE bsize = txsize_to_bsize[tx_size];

  int blk_w = block_size_wide[bsize];

  int blk_h = block_size_high[bsize];

  const int mi_row = -xd->mb_to_top_edge >> (3 + MI_SIZE_LOG2);

  const int mi_col = -xd->mb_to_left_edge >> (3 + MI_SIZE_LOG2);

  mi_to_pixel_loc(&pixel_c, &pixel_r, mi_col, mi_row, blk_col, blk_row,

                  pd->subsampling_x, pd->subsampling_y);

  mismatch_check_block_tx(dst, pd->dst.stride, cm->current_frame.order_hint,

                          plane, pixel_c, pixel_r, blk_w, blk_h,

                          xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH);

#endif

}

static inline void set_cb_buffer_offsets(DecoderCodingBlock *dcb,

                                         TX_SIZE tx_size, int plane) {

  dcb->cb_offset[plane] += tx_size_wide[tx_size] * tx_size_high[tx_size];

  dcb->txb_offset[plane] =

      dcb->cb_offset[plane] / (TX_SIZE_W_MIN * TX_SIZE_H_MIN);

}

static inline void decode_reconstruct_tx(AV1_COMMON *cm, ThreadData *const td,

                                         aom_reader *r,

                                         MB_MODE_INFO *const mbmi, int plane,

                                         BLOCK_SIZE plane_bsize, int blk_row,

                                         int blk_col, int block,

                                         TX_SIZE tx_size, int *eob_total) {

  DecoderCodingBlock *const dcb = &td->dcb;

  MACROBLOCKD *const xd = &dcb->xd;

  const struct macroblockd_plane *const pd = &xd->plane[plane];

  const TX_SIZE plane_tx_size =

      plane ? av1_get_max_uv_txsize(mbmi->bsize, pd->subsampling_x,

                                    pd->subsampling_y)

            : mbmi->inter_tx_size[av1_get_txb_size_index(plane_bsize, blk_row,

                                                         blk_col)];

  // Scale to match transform block unit.

  const int max_blocks_high = max_block_high(xd, plane_bsize, plane);

  const int max_blocks_wide = max_block_wide(xd, plane_bsize, plane);

  if (blk_row >= max_blocks_high || blk_col >= max_blocks_wide) return;

  if (tx_size == plane_tx_size || plane) {

    td->read_coeffs_tx_inter_block_visit(cm, dcb, r, plane, blk_row, blk_col,

                                         tx_size);

    td->inverse_tx_inter_block_visit(cm, dcb, r, plane, blk_row, blk_col,

                                     tx_size);

    eob_info *eob_data = dcb->eob_data[plane] + dcb->txb_offset[plane];

    *eob_total += eob_data->eob;

    set_cb_buffer_offsets(dcb, tx_size, plane);

  } else {

    const TX_SIZE sub_txs = sub_tx_size_map[tx_size];

    assert(IMPLIES(tx_size <= TX_4X4, sub_txs == tx_size));

    assert(IMPLIES(tx_size > TX_4X4, sub_txs < tx_size));

    const int bsw = tx_size_wide_unit[sub_txs];

    const int bsh = tx_size_high_unit[sub_txs];

    const int sub_step = bsw * bsh;

    const int row_end =

        AOMMIN(tx_size_high_unit[tx_size], max_blocks_high - blk_row);

    const int col_end =

        AOMMIN(tx_size_wide_unit[tx_size], max_blocks_wide - blk_col);

    assert(bsw > 0 && bsh > 0);

    for (int row = 0; row < row_end; row += bsh) {

      const int offsetr = blk_row + row;

      for (int col = 0; col < col_end; col += bsw) {

        const int offsetc = blk_col + col;

        decode_reconstruct_tx(cm, td, r, mbmi, plane, plane_bsize, offsetr,

                              offsetc, block, sub_txs, eob_total);

        block += sub_step;

      }

    }

  }

}

static inline void set_offsets(AV1_COMMON *const cm, MACROBLOCKD *const xd,

                               BLOCK_SIZE bsize, int mi_row, int mi_col, int bw,

                               int bh, int x_mis, int y_mis) {

  const int num_planes = av1_num_planes(cm);

  const CommonModeInfoParams *const mi_params = &cm->mi_params;

  const TileInfo *const tile = &xd->tile;

  set_mi_offsets(mi_params, xd, mi_row, mi_col);

  xd->mi[0]->bsize = bsize;

#if CONFIG_RD_DEBUG

  xd->mi[0]->mi_row = mi_row;

  xd->mi[0]->mi_col = mi_col;

#endif

  assert(x_mis && y_mis);

  for (int x = 1; x < x_mis; ++x) xd->mi[x] = xd->mi[0];

  int idx = mi_params->mi_stride;

  for (int y = 1; y < y_mis; ++y) {

    memcpy(&xd->mi[idx], &xd->mi[0], x_mis * sizeof(xd->mi[0]));

    idx += mi_params->mi_stride;

  }

  set_plane_n4(xd, bw, bh, num_planes);

  set_entropy_context(xd, mi_row, mi_col, num_planes);

  // Distance of Mb to the various image edges. These are specified to 8th pel

  // as they are always compared to values that are in 1/8th pel units

  set_mi_row_col(xd, tile, mi_row, bh, mi_col, bw, mi_params->mi_rows,

                 mi_params->mi_cols);

  av1_setup_dst_planes(xd->plane, bsize, &cm->cur_frame->buf, mi_row, mi_col, 0,

                       num_planes);

}

static inline void decode_mbmi_block(AV1Decoder *const pbi,

                                     DecoderCodingBlock *dcb, int mi_row,

                                     int mi_col, aom_reader *r,

                                     PARTITION_TYPE partition,

                                     BLOCK_SIZE bsize) {

  AV1_COMMON *const cm = &pbi->common;

  const SequenceHeader *const seq_params = cm->seq_params;

  const int bw = mi_size_wide[bsize];

  const int bh = mi_size_high[bsize];

  const int x_mis = AOMMIN(bw, cm->mi_params.mi_cols - mi_col);

  const int y_mis = AOMMIN(bh, cm->mi_params.mi_rows - mi_row);

  MACROBLOCKD *const xd = &dcb->xd;

#if CONFIG_ACCOUNTING

  aom_accounting_set_context(&pbi->accounting, mi_col, mi_row);

#endif

  set_offsets(cm, xd, bsize, mi_row, mi_col, bw, bh, x_mis, y_mis);

  xd->mi[0]->partition = partition;

  av1_read_mode_info(pbi, dcb, r, x_mis, y_mis);

  if (bsize >= BLOCK_8X8 &&

      (seq_params->subsampling_x || seq_params->subsampling_y)) {

    const BLOCK_SIZE uv_subsize =

        av1_ss_size_lookup[bsize][seq_params->subsampling_x]

                          [seq_params->subsampling_y];

    if (uv_subsize == BLOCK_INVALID)

      aom_internal_error(xd->error_info, AOM_CODEC_CORRUPT_FRAME,

                         "Invalid block size.");

  }

}

typedef struct PadBlock {

  int x0;

  int x1;

  int y0;

  int y1;

} PadBlock;

#if CONFIG_AV1_HIGHBITDEPTH

static inline void highbd_build_mc_border(const uint8_t *src8, int src_stride,

                                          uint8_t *dst8, int dst_stride, int x,

                                          int y, int b_w, int b_h, int w,

                                          int h) {

  // Get a pointer to the start of the real data for this row.

  const uint16_t *src = CONVERT_TO_SHORTPTR(src8);

  uint16_t *dst = CONVERT_TO_SHORTPTR(dst8);

  const uint16_t *ref_row = src - x - y * src_stride;

  if (y >= h)

    ref_row += (h - 1) * src_stride;

  else if (y > 0)

    ref_row += y * src_stride;

  do {

    int right = 0, copy;

    int left = x < 0 ? -x : 0;

    if (left > b_w) left = b_w;

    if (x + b_w > w) right = x + b_w - w;

    if (right > b_w) right = b_w;

    copy = b_w - left - right;

    if (left) aom_memset16(dst, ref_row[0], left);

    if (copy) memcpy(dst + left, ref_row + x + left, copy * sizeof(uint16_t));

    if (right) aom_memset16(dst + left + copy, ref_row[w - 1], right);

    dst += dst_stride;

    ++y;

    if (y > 0 && y < h) ref_row += src_stride;

  } while (--b_h);

}

#endif  // CONFIG_AV1_HIGHBITDEPTH

static inline void build_mc_border(const uint8_t *src, int src_stride,

                                   uint8_t *dst, int dst_stride, int x, int y,

                                   int b_w, int b_h, int w, int h) {

  // Get a pointer to the start of the real data for this row.

  const uint8_t *ref_row = src - x - y * src_stride;

  if (y >= h)

    ref_row += (h - 1) * src_stride;

  else if (y > 0)

    ref_row += y * src_stride;

  do {

    int right = 0, copy;

    int left = x < 0 ? -x : 0;

    if (left > b_w) left = b_w;

    if (x + b_w > w) right = x + b_w - w;

    if (right > b_w) right = b_w;

    copy = b_w - left - right;

    if (left) memset(dst, ref_row[0], left);

    if (copy) memcpy(dst + left, ref_row + x + left, copy);

    if (right) memset(dst + left + copy, ref_row[w - 1], right);

    dst += dst_stride;

    ++y;

    if (y > 0 && y < h) ref_row += src_stride;

  } while (--b_h);

}

static inline int update_extend_mc_border_params(

    const struct scale_factors *const sf, struct buf_2d *const pre_buf,

    MV32 scaled_mv, PadBlock *block, int subpel_x_mv, int subpel_y_mv,

    int do_warp, int is_intrabc, int *x_pad, int *y_pad) {

  const int is_scaled = av1_is_scaled(sf);

  // Get reference width and height.

  int frame_width = pre_buf->width;

  int frame_height = pre_buf->height;

  // Do border extension if there is motion or

  // width/height is not a multiple of 8 pixels.

  if ((!is_intrabc) && (!do_warp) &&

      (is_scaled || scaled_mv.col || scaled_mv.row || (frame_width & 0x7) ||

       (frame_height & 0x7))) {

    if (subpel_x_mv || (sf->x_step_q4 != SUBPEL_SHIFTS)) {

      block->x0 -= AOM_INTERP_EXTEND - 1;

      block->x1 += AOM_INTERP_EXTEND;

      *x_pad = 1;

    }

    if (subpel_y_mv || (sf->y_step_q4 != SUBPEL_SHIFTS)) {

      block->y0 -= AOM_INTERP_EXTEND - 1;

      block->y1 += AOM_INTERP_EXTEND;

      *y_pad = 1;

    }

    // Skip border extension if block is inside the frame.

    if (block->x0 < 0 || block->x1 > frame_width - 1 || block->y0 < 0 ||

        block->y1 > frame_height - 1) {

      return 1;

    }

  }

  return 0;

}

static inline void extend_mc_border(const struct scale_factors *const sf,

                                    struct buf_2d *const pre_buf,

                                    MV32 scaled_mv, PadBlock block,

                                    int subpel_x_mv, int subpel_y_mv,

                                    int do_warp, int is_intrabc, int highbd,

                                    uint8_t *mc_buf, uint8_t **pre,

                                    int *src_stride) {

  int x_pad = 0, y_pad = 0;

  if (update_extend_mc_border_params(sf, pre_buf, scaled_mv, &block,

                                     subpel_x_mv, subpel_y_mv, do_warp,

                                     is_intrabc, &x_pad, &y_pad)) {

    // Get reference block pointer.

    const uint8_t *const buf_ptr =

        pre_buf->buf0 + block.y0 * pre_buf->stride + block.x0;

    int buf_stride = pre_buf->stride;

    const int b_w = block.x1 - block.x0;

    const int b_h = block.y1 - block.y0;

#if CONFIG_AV1_HIGHBITDEPTH

    // Extend the border.

    if (highbd) {

      highbd_build_mc_border(buf_ptr, buf_stride, mc_buf, b_w, block.x0,

                             block.y0, b_w, b_h, pre_buf->width,

                             pre_buf->height);

    } else {

      build_mc_border(buf_ptr, buf_stride, mc_buf, b_w, block.x0, block.y0, b_w,

                      b_h, pre_buf->width, pre_buf->height);

    }

#else

    (void)highbd;

    build_mc_border(buf_ptr, buf_stride, mc_buf, b_w, block.x0, block.y0, b_w,

                    b_h, pre_buf->width, pre_buf->height);

#endif

    *src_stride = b_w;

    *pre = mc_buf + y_pad * (AOM_INTERP_EXTEND - 1) * b_w +

           x_pad * (AOM_INTERP_EXTEND - 1);

  }

}

static inline void dec_calc_subpel_params(

    const MV *const src_mv, InterPredParams *const inter_pred_params,

    const MACROBLOCKD *const xd, int mi_x, int mi_y, uint8_t **pre,

    SubpelParams *subpel_params, int *src_stride, PadBlock *block,

    MV32 *scaled_mv, int *subpel_x_mv, int *subpel_y_mv) {

  const struct scale_factors *sf = inter_pred_params->scale_factors;

  struct buf_2d *pre_buf = &inter_pred_params->ref_frame_buf;

  const int bw = inter_pred_params->block_width;

  const int bh = inter_pred_params->block_height;

  const int is_scaled = av1_is_scaled(sf);

  if (is_scaled) {

    int ssx = inter_pred_params->subsampling_x;

    int ssy = inter_pred_params->subsampling_y;

    int orig_pos_y = inter_pred_params->pix_row << SUBPEL_BITS;

    orig_pos_y += src_mv->row * (1 << (1 - ssy));

    int orig_pos_x = inter_pred_params->pix_col << SUBPEL_BITS;

    orig_pos_x += src_mv->col * (1 << (1 - ssx));

    int pos_y = av1_scaled_y(orig_pos_y, sf);

    int pos_x = av1_scaled_x(orig_pos_x, sf);

    pos_x += SCALE_EXTRA_OFF;

    pos_y += SCALE_EXTRA_OFF;

    const int top = -AOM_LEFT_TOP_MARGIN_SCALED(ssy);

    const int left = -AOM_LEFT_TOP_MARGIN_SCALED(ssx);

    const int bottom = (pre_buf->height + AOM_INTERP_EXTEND)

                       << SCALE_SUBPEL_BITS;

    const int right = (pre_buf->width + AOM_INTERP_EXTEND) << SCALE_SUBPEL_BITS;

    pos_y = clamp(pos_y, top, bottom);

    pos_x = clamp(pos_x, left, right);

    subpel_params->subpel_x = pos_x & SCALE_SUBPEL_MASK;

    subpel_params->subpel_y = pos_y & SCALE_SUBPEL_MASK;

    subpel_params->xs = sf->x_step_q4;

    subpel_params->ys = sf->y_step_q4;

    // Get reference block top left coordinate.

    block->x0 = pos_x >> SCALE_SUBPEL_BITS;

    block->y0 = pos_y >> SCALE_SUBPEL_BITS;

    // Get reference block bottom right coordinate.

    block->x1 =

        ((pos_x + (bw - 1) * subpel_params->xs) >> SCALE_SUBPEL_BITS) + 1;

    block->y1 =

        ((pos_y + (bh - 1) * subpel_params->ys) >> SCALE_SUBPEL_BITS) + 1;

    MV temp_mv;

    temp_mv = clamp_mv_to_umv_border_sb(xd, src_mv, bw, bh,

                                        inter_pred_params->subsampling_x,

                                        inter_pred_params->subsampling_y);

    *scaled_mv = av1_scale_mv(&temp_mv, mi_x, mi_y, sf);

    scaled_mv->row += SCALE_EXTRA_OFF;

    scaled_mv->col += SCALE_EXTRA_OFF;

    *subpel_x_mv = scaled_mv->col & SCALE_SUBPEL_MASK;

    *subpel_y_mv = scaled_mv->row & SCALE_SUBPEL_MASK;

  } else {

    // Get block position in current frame.

    int pos_x = inter_pred_params->pix_col << SUBPEL_BITS;

    int pos_y = inter_pred_params->pix_row << SUBPEL_BITS;

    const MV mv_q4 = clamp_mv_to_umv_border_sb(

        xd, src_mv, bw, bh, inter_pred_params->subsampling_x,

        inter_pred_params->subsampling_y);

    subpel_params->xs = subpel_params->ys = SCALE_SUBPEL_SHIFTS;

    subpel_params->subpel_x = (mv_q4.col & SUBPEL_MASK) << SCALE_EXTRA_BITS;

    subpel_params->subpel_y = (mv_q4.row & SUBPEL_MASK) << SCALE_EXTRA_BITS;

    // Get reference block top left coordinate.

    pos_x += mv_q4.col;

    pos_y += mv_q4.row;

    block->x0 = pos_x >> SUBPEL_BITS;

    block->y0 = pos_y >> SUBPEL_BITS;

    // Get reference block bottom right coordinate.

    block->x1 = (pos_x >> SUBPEL_BITS) + (bw - 1) + 1;

    block->y1 = (pos_y >> SUBPEL_BITS) + (bh - 1) + 1;

    scaled_mv->row = mv_q4.row;

    scaled_mv->col = mv_q4.col;

    *subpel_x_mv = scaled_mv->col & SUBPEL_MASK;

    *subpel_y_mv = scaled_mv->row & SUBPEL_MASK;

  }

  *pre = pre_buf->buf0 + block->y0 * pre_buf->stride + block->x0;

  *src_stride = pre_buf->stride;

}

static inline void dec_calc_subpel_params_and_extend(

    const MV *const src_mv, InterPredParams *const inter_pred_params,

    MACROBLOCKD *const xd, int mi_x, int mi_y, int ref, uint8_t **mc_buf,

    uint8_t **pre, SubpelParams *subpel_params, int *src_stride) {

  PadBlock block;

  MV32 scaled_mv;

  int subpel_x_mv, subpel_y_mv;

  dec_calc_subpel_params(src_mv, inter_pred_params, xd, mi_x, mi_y, pre,

                         subpel_params, src_stride, &block, &scaled_mv,

                         &subpel_x_mv, &subpel_y_mv);

  extend_mc_border(

      inter_pred_params->scale_factors, &inter_pred_params->ref_frame_buf,

      scaled_mv, block, subpel_x_mv, subpel_y_mv,

      inter_pred_params->mode == WARP_PRED, inter_pred_params->is_intrabc,

      inter_pred_params->use_hbd_buf, mc_buf[ref], pre, src_stride);

}

#define IS_DEC 1

#include "av1/common/reconinter_template.inc"

#undef IS_DEC

static void dec_build_inter_predictors(const AV1_COMMON *cm,

                                       DecoderCodingBlock *dcb, int plane,

                                       const MB_MODE_INFO *mi,

                                       int build_for_obmc, int bw, int bh,

                                       int mi_x, int mi_y) {

  build_inter_predictors(cm, &dcb->xd, plane, mi, build_for_obmc, bw, bh, mi_x,

                         mi_y, dcb->mc_buf);

}

static inline void dec_build_inter_predictor(const AV1_COMMON *cm,

                                             DecoderCodingBlock *dcb,

                                             int mi_row, int mi_col,

                                             BLOCK_SIZE bsize) {

  MACROBLOCKD *const xd = &dcb->xd;

  const int num_planes = av1_num_planes(cm);

  for (int plane = 0; plane < num_planes; ++plane) {

    if (plane && !xd->is_chroma_ref) break;

    const int mi_x = mi_col * MI_SIZE;

    const int mi_y = mi_row * MI_SIZE;

    dec_build_inter_predictors(cm, dcb, plane, xd->mi[0], 0,

                               xd->plane[plane].width, xd->plane[plane].height,

                               mi_x, mi_y);

    if (is_interintra_pred(xd->mi[0])) {

      BUFFER_SET ctx = { { xd->plane[0].dst.buf, xd->plane[1].dst.buf,

                           xd->plane[2].dst.buf },

                         { xd->plane[0].dst.stride, xd->plane[1].dst.stride,

                           xd->plane[2].dst.stride } };

      av1_build_interintra_predictor(cm, xd, xd->plane[plane].dst.buf,

                                     xd->plane[plane].dst.stride, &ctx, plane,

                                     bsize);

    }

  }

}

static inline void dec_build_prediction_by_above_pred(

    MACROBLOCKD *const xd, int rel_mi_row, int rel_mi_col, uint8_t op_mi_size,

    int dir, MB_MODE_INFO *above_mbmi, void *fun_ctxt, const int num_planes) {

  struct build_prediction_ctxt *ctxt = (struct build_prediction_ctxt *)fun_ctxt;

  const int above_mi_col = xd->mi_col + rel_mi_col;

  int mi_x, mi_y;

  MB_MODE_INFO backup_mbmi = *above_mbmi;

  (void)rel_mi_row;

  (void)dir;

  av1_setup_build_prediction_by_above_pred(xd, rel_mi_col, op_mi_size,

                                           &backup_mbmi, ctxt, num_planes);

  mi_x = above_mi_col << MI_SIZE_LOG2;

  mi_y = xd->mi_row << MI_SIZE_LOG2;

  const BLOCK_SIZE bsize = xd->mi[0]->bsize;

  for (int j = 0; j < num_planes; ++j) {

    const struct macroblockd_plane *pd = &xd->plane[j];

    int bw = (op_mi_size * MI_SIZE) >> pd->subsampling_x;

    int bh = clamp(block_size_high[bsize] >> (pd->subsampling_y + 1), 4,

                   block_size_high[BLOCK_64X64] >> (pd->subsampling_y + 1));

    if (av1_skip_u4x4_pred_in_obmc(bsize, pd, 0)) continue;

    dec_build_inter_predictors(ctxt->cm, (DecoderCodingBlock *)ctxt->dcb, j,

                               &backup_mbmi, 1, bw, bh, mi_x, mi_y);

  }

}

static inline void dec_build_prediction_by_above_preds(

    const AV1_COMMON *cm, DecoderCodingBlock *dcb,

    uint8_t *tmp_buf[MAX_MB_PLANE], int tmp_width[MAX_MB_PLANE],

    int tmp_height[MAX_MB_PLANE], int tmp_stride[MAX_MB_PLANE]) {

  MACROBLOCKD *const xd = &dcb->xd;

  if (!xd->up_available) return;

  // Adjust mb_to_bottom_edge to have the correct value for the OBMC

  // prediction block. This is half the height of the original block,

  // except for 128-wide blocks, where we only use a height of 32.

  const int this_height = xd->height * MI_SIZE;

  const int pred_height = AOMMIN(this_height / 2, 32);

  xd->mb_to_bottom_edge += GET_MV_SUBPEL(this_height - pred_height);

  struct build_prediction_ctxt ctxt = {

    cm, tmp_buf, tmp_width, tmp_height, tmp_stride, xd->mb_to_right_edge, dcb

  };

  const BLOCK_SIZE bsize = xd->mi[0]->bsize;

  foreach_overlappable_nb_above(cm, xd,

                                max_neighbor_obmc[mi_size_wide_log2[bsize]],

                                dec_build_prediction_by_above_pred, &ctxt);

  xd->mb_to_left_edge = -GET_MV_SUBPEL(xd->mi_col * MI_SIZE);

  xd->mb_to_right_edge = ctxt.mb_to_far_edge;

  xd->mb_to_bottom_edge -= GET_MV_SUBPEL(this_height - pred_height);

}

static inline void dec_build_prediction_by_left_pred(

    MACROBLOCKD *const xd, int rel_mi_row, int rel_mi_col, uint8_t op_mi_size,

    int dir, MB_MODE_INFO *left_mbmi, void *fun_ctxt, const int num_planes) {

  struct build_prediction_ctxt *ctxt = (struct build_prediction_ctxt *)fun_ctxt;

  const int left_mi_row = xd->mi_row + rel_mi_row;

  int mi_x, mi_y;

  MB_MODE_INFO backup_mbmi = *left_mbmi;

  (void)rel_mi_col;

  (void)dir;

  av1_setup_build_prediction_by_left_pred(xd, rel_mi_row, op_mi_size,

                                          &backup_mbmi, ctxt, num_planes);

  mi_x = xd->mi_col << MI_SIZE_LOG2;

  mi_y = left_mi_row << MI_SIZE_LOG2;

  const BLOCK_SIZE bsize = xd->mi[0]->bsize;

  for (int j = 0; j < num_planes; ++j) {

    const struct macroblockd_plane *pd = &xd->plane[j];

    int bw = clamp(block_size_wide[bsize] >> (pd->subsampling_x + 1), 4,

                   block_size_wide[BLOCK_64X64] >> (pd->subsampling_x + 1));

    int bh = (op_mi_size << MI_SIZE_LOG2) >> pd->subsampling_y;

    if (av1_skip_u4x4_pred_in_obmc(bsize, pd, 1)) continue;

    dec_build_inter_predictors(ctxt->cm, (DecoderCodingBlock *)ctxt->dcb, j,

                               &backup_mbmi, 1, bw, bh, mi_x, mi_y);

  }

}

static inline void dec_build_prediction_by_left_preds(

    const AV1_COMMON *cm, DecoderCodingBlock *dcb,

    uint8_t *tmp_buf[MAX_MB_PLANE], int tmp_width[MAX_MB_PLANE],

    int tmp_height[MAX_MB_PLANE], int tmp_stride[MAX_MB_PLANE]) {

  MACROBLOCKD *const xd = &dcb->xd;

  if (!xd->left_available) return;

  // Adjust mb_to_right_edge to have the correct value for the OBMC

  // prediction block. This is half the width of the original block,

  // except for 128-wide blocks, where we only use a width of 32.

  const int this_width = xd->width * MI_SIZE;

  const int pred_width = AOMMIN(this_width / 2, 32);

  xd->mb_to_right_edge += GET_MV_SUBPEL(this_width - pred_width);

  struct build_prediction_ctxt ctxt = {

    cm, tmp_buf, tmp_width, tmp_height, tmp_stride, xd->mb_to_bottom_edge, dcb

  };

  const BLOCK_SIZE bsize = xd->mi[0]->bsize;

  foreach_overlappable_nb_left(cm, xd,

                               max_neighbor_obmc[mi_size_high_log2[bsize]],

                               dec_build_prediction_by_left_pred, &ctxt);

  xd->mb_to_top_edge = -GET_MV_SUBPEL(xd->mi_row * MI_SIZE);

  xd->mb_to_right_edge -= GET_MV_SUBPEL(this_width - pred_width);

  xd->mb_to_bottom_edge = ctxt.mb_to_far_edge;

}

static inline void dec_build_obmc_inter_predictors_sb(const AV1_COMMON *cm,

                                                      DecoderCodingBlock *dcb) {

  const int num_planes = av1_num_planes(cm);

  uint8_t *dst_buf1[MAX_MB_PLANE], *dst_buf2[MAX_MB_PLANE];

  int dst_stride1[MAX_MB_PLANE] = { MAX_SB_SIZE, MAX_SB_SIZE, MAX_SB_SIZE };

  int dst_stride2[MAX_MB_PLANE] = { MAX_SB_SIZE, MAX_SB_SIZE, MAX_SB_SIZE };

  int dst_width1[MAX_MB_PLANE] = { MAX_SB_SIZE, MAX_SB_SIZE, MAX_SB_SIZE };

  int dst_width2[MAX_MB_PLANE] = { MAX_SB_SIZE, MAX_SB_SIZE, MAX_SB_SIZE };

  int dst_height1[MAX_MB_PLANE] = { MAX_SB_SIZE, MAX_SB_SIZE, MAX_SB_SIZE };

  int dst_height2[MAX_MB_PLANE] = { MAX_SB_SIZE, MAX_SB_SIZE, MAX_SB_SIZE };

  MACROBLOCKD *const xd = &dcb->xd;

  av1_setup_obmc_dst_bufs(xd, dst_buf1, dst_buf2);

  dec_build_prediction_by_above_preds(cm, dcb, dst_buf1, dst_width1,

                                      dst_height1, dst_stride1);

  dec_build_prediction_by_left_preds(cm, dcb, dst_buf2, dst_width2, dst_height2,

                                     dst_stride2);

  const int mi_row = xd->mi_row;

  const int mi_col = xd->mi_col;

  av1_setup_dst_planes(xd->plane, xd->mi[0]->bsize, &cm->cur_frame->buf, mi_row,

                       mi_col, 0, num_planes);

  av1_build_obmc_inter_prediction(cm, xd, dst_buf1, dst_stride1, dst_buf2,

                                  dst_stride2);

}

static inline void cfl_store_inter_block(AV1_COMMON *const cm,

                                         MACROBLOCKD *const xd) {

  MB_MODE_INFO *mbmi = xd->mi[0];

  if (store_cfl_required(cm, xd)) {

    cfl_store_block(xd, mbmi->bsize, mbmi->tx_size);

  }

}

static inline void predict_inter_block(AV1_COMMON *const cm,

                                       DecoderCodingBlock *dcb,

                                       BLOCK_SIZE bsize) {

  MACROBLOCKD *const xd = &dcb->xd;

  MB_MODE_INFO *mbmi = xd->mi[0];

  const int num_planes = av1_num_planes(cm);

  const int mi_row = xd->mi_row;

  const int mi_col = xd->mi_col;

  for (int ref = 0; ref < 1 + has_second_ref(mbmi); ++ref) {

    const MV_REFERENCE_FRAME frame = mbmi->ref_frame[ref];

    if (frame < LAST_FRAME) {

      assert(is_intrabc_block(mbmi));

      assert(frame == INTRA_FRAME);

      assert(ref == 0);

    } else {

      const RefCntBuffer *ref_buf = get_ref_frame_buf(cm, frame);

      const struct scale_factors *ref_scale_factors =

          get_ref_scale_factors_const(cm, frame);

      xd->block_ref_scale_factors[ref] = ref_scale_factors;

      av1_setup_pre_planes(xd, ref, &ref_buf->buf, mi_row, mi_col,

                           ref_scale_factors, num_planes);

    }

  }

  dec_build_inter_predictor(cm, dcb, mi_row, mi_col, bsize);

  if (mbmi->motion_mode == OBMC_CAUSAL) {

    dec_build_obmc_inter_predictors_sb(cm, dcb);

  }

#if CONFIG_MISMATCH_DEBUG

  for (int plane = 0; plane < num_planes; ++plane) {

    const struct macroblockd_plane *pd = &xd->plane[plane];

    int pixel_c, pixel_r;

    mi_to_pixel_loc(&pixel_c, &pixel_r, mi_col, mi_row, 0, 0, pd->subsampling_x,

                    pd->subsampling_y);

    if (!is_chroma_reference(mi_row, mi_col, bsize, pd->subsampling_x,

                             pd->subsampling_y))

      continue;

    mismatch_check_block_pre(pd->dst.buf, pd->dst.stride,

                             cm->current_frame.order_hint, plane, pixel_c,

                             pixel_r, pd->width, pd->height,

                             xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH);

  }

#endif

}

static inline void set_color_index_map_offset(MACROBLOCKD *const xd, int plane,

                                              aom_reader *r) {

  (void)r;

  Av1ColorMapParam params;

  const MB_MODE_INFO *const mbmi = xd->mi[0];

  av1_get_block_dimensions(mbmi->bsize, plane, xd, &params.plane_width,

                           &params.plane_height, NULL, NULL);

  xd->color_index_map_offset[plane] += params.plane_width * params.plane_height;

}

static inline void decode_token_recon_block(AV1Decoder *const pbi,

                                            ThreadData *const td, aom_reader *r,

                                            BLOCK_SIZE bsize) {

  AV1_COMMON *const cm = &pbi->common;

  DecoderCodingBlock *const dcb = &td->dcb;

  MACROBLOCKD *const xd = &dcb->xd;

  const int num_planes = av1_num_planes(cm);

  MB_MODE_INFO *mbmi = xd->mi[0];

  if (!is_inter_block(mbmi)) {

    int row, col;

    assert(bsize == get_plane_block_size(bsize, xd->plane[0].subsampling_x,

                                         xd->plane[0].subsampling_y));

    const int max_blocks_wide = max_block_wide(xd, bsize, 0);

    const int max_blocks_high = max_block_high(xd, bsize, 0);

    const BLOCK_SIZE max_unit_bsize = BLOCK_64X64;

    int mu_blocks_wide = mi_size_wide[max_unit_bsize];

    int mu_blocks_high = mi_size_high[max_unit_bsize];

    mu_blocks_wide = AOMMIN(max_blocks_wide, mu_blocks_wide);

    mu_blocks_high = AOMMIN(max_blocks_high, mu_blocks_high);

    for (row = 0; row < max_blocks_high; row += mu_blocks_high) {

      for (col = 0; col < max_blocks_wide; col += mu_blocks_wide) {

        for (int plane = 0; plane < num_planes; ++plane) {

          if (plane && !xd->is_chroma_ref) break;

          const struct macroblockd_plane *const pd = &xd->plane[plane];

          const TX_SIZE tx_size = av1_get_tx_size(plane, xd);

          const int stepr = tx_size_high_unit[tx_size];

          const int stepc = tx_size_wide_unit[tx_size];

          const int unit_height = ROUND_POWER_OF_TWO(

              AOMMIN(mu_blocks_high + row, max_blocks_high), pd->subsampling_y);

          const int unit_width = ROUND_POWER_OF_TWO(

              AOMMIN(mu_blocks_wide + col, max_blocks_wide), pd->subsampling_x);

          for (int blk_row = row >> pd->subsampling_y; blk_row < unit_height;

               blk_row += stepr) {

            for (int blk_col = col >> pd->subsampling_x; blk_col < unit_width;

                 blk_col += stepc) {

              td->read_coeffs_tx_intra_block_visit(cm, dcb, r, plane, blk_row,

                                                   blk_col, tx_size);

              td->predict_and_recon_intra_block_visit(

                  cm, dcb, r, plane, blk_row, blk_col, tx_size);

              set_cb_buffer_offsets(dcb, tx_size, plane);

            }

          }

        }

      }

    }

  } else {

    td->predict_inter_block_visit(cm, dcb, bsize);

    // Reconstruction

    if (!mbmi->skip_txfm) {

      int eobtotal = 0;

      const int max_blocks_wide = max_block_wide(xd, bsize, 0);

      const int max_blocks_high = max_block_high(xd, bsize, 0);

      int row, col;

      const BLOCK_SIZE max_unit_bsize = BLOCK_64X64;

      assert(max_unit_bsize ==

             get_plane_block_size(BLOCK_64X64, xd->plane[0].subsampling_x,

                                  xd->plane[0].subsampling_y));

      int mu_blocks_wide = mi_size_wide[max_unit_bsize];

      int mu_blocks_high = mi_size_high[max_unit_bsize];

      mu_blocks_wide = AOMMIN(max_blocks_wide, mu_blocks_wide);

      mu_blocks_high = AOMMIN(max_blocks_high, mu_blocks_high);

      for (row = 0; row < max_blocks_high; row += mu_blocks_high) {

        for (col = 0; col < max_blocks_wide; col += mu_blocks_wide) {

          for (int plane = 0; plane < num_planes; ++plane) {

            if (plane && !xd->is_chroma_ref) break;

            const struct macroblockd_plane *const pd = &xd->plane[plane];

            const int ss_x = pd->subsampling_x;

            const int ss_y = pd->subsampling_y;

            const BLOCK_SIZE plane_bsize =

                get_plane_block_size(bsize, ss_x, ss_y);

            const TX_SIZE max_tx_size =

                get_vartx_max_txsize(xd, plane_bsize, plane);

            const int bh_var_tx = tx_size_high_unit[max_tx_size];

            const int bw_var_tx = tx_size_wide_unit[max_tx_size];

            int block = 0;

            int step =

                tx_size_wide_unit[max_tx_size] * tx_size_high_unit[max_tx_size];

            int blk_row, blk_col;

            const int unit_height = ROUND_POWER_OF_TWO(

                AOMMIN(mu_blocks_high + row, max_blocks_high), ss_y);

            const int unit_width = ROUND_POWER_OF_TWO(

                AOMMIN(mu_blocks_wide + col, max_blocks_wide), ss_x);

            for (blk_row = row >> ss_y; blk_row < unit_height;

                 blk_row += bh_var_tx) {

              for (blk_col = col >> ss_x; blk_col < unit_width;

                   blk_col += bw_var_tx) {

                decode_reconstruct_tx(cm, td, r, mbmi, plane, plane_bsize,

                                      blk_row, blk_col, block, max_tx_size,

                                      &eobtotal);

                block += step;

              }

            }

          }

        }

      }

    }

    td->cfl_store_inter_block_visit(cm, xd);

  }

  av1_visit_palette(pbi, xd, r, set_color_index_map_offset);

}

static inline void set_inter_tx_size(MB_MODE_INFO *mbmi, int stride_log2,

                                     int tx_w_log2, int tx_h_log2, int min_txs,

                                     int split_size, int txs, int blk_row,

                                     int blk_col) {

  for (int idy = 0; idy < tx_size_high_unit[split_size];

       idy += tx_size_high_unit[min_txs]) {

    for (int idx = 0; idx < tx_size_wide_unit[split_size];

         idx += tx_size_wide_unit[min_txs]) {

      const int index = (((blk_row + idy) >> tx_h_log2) << stride_log2) +

                        ((blk_col + idx) >> tx_w_log2);

      mbmi->inter_tx_size[index] = txs;

    }

  }

}

static inline void read_tx_size_vartx(MACROBLOCKD *xd, MB_MODE_INFO *mbmi,

                                      TX_SIZE tx_size, int depth, int blk_row,

                                      int blk_col, aom_reader *r) {

  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;

  int is_split = 0;

  const BLOCK_SIZE bsize = mbmi->bsize;

  const int max_blocks_high = max_block_high(xd, bsize, 0);

  const int max_blocks_wide = max_block_wide(xd, bsize, 0);

  if (blk_row >= max_blocks_high || blk_col >= max_blocks_wide) return;

  assert(tx_size > TX_4X4);

  TX_SIZE txs = max_txsize_rect_lookup[bsize];

  for (int level = 0; level < MAX_VARTX_DEPTH - 1; ++level)

    txs = sub_tx_size_map[txs];

  const int tx_w_log2 = tx_size_wide_log2[txs] - MI_SIZE_LOG2;

  const int tx_h_log2 = tx_size_high_log2[txs] - MI_SIZE_LOG2;

  const int bw_log2 = mi_size_wide_log2[bsize];

  const int stride_log2 = bw_log2 - tx_w_log2;