/*

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

 */

#include <assert.h>

#include <stdbool.h>

#include <stddef.h>

#include <string.h>

#include "av2/common/av2_common_int.h"

#include "av2/common/blockd.h"

#include "av2/common/bru.h"

#include "av2/common/enums.h"

#include "av2/common/filter.h"

#include "av2/common/scan.h"

#include "config/avm_config.h"

#include "config/avm_dsp_rtcd.h"

#include "config/avm_scale_rtcd.h"

#include "config/av2_rtcd.h"

#include "av2/common/level.h"

#include "avm/avm_codec.h"

#include "avm_dsp/avm_dsp_common.h"

#include "avm_dsp/binary_codes_reader.h"

#include "avm_dsp/bitreader.h"

#include "avm_dsp/bitreader_buffer.h"

#include "avm_mem/avm_mem.h"

#include "avm_ports/avm_timer.h"

#include "avm_ports/mem.h"

#include "avm_ports/mem_ops.h"

#include "avm_scale/avm_scale.h"

#include "avm_util/avm_thread.h"

#if CONFIG_BITSTREAM_DEBUG || CONFIG_MISMATCH_DEBUG

#include "avm_util/debug_util.h"

#endif  // CONFIG_BITSTREAM_DEBUG || CONFIG_MISMATCH_DEBUG

#include "av2/common/alloccommon.h"

#include "av2/common/cdef.h"

#include "av2/common/gdf.h"

#include "av2/common/ccso.h"

#include "av2/common/cfl.h"

#if CONFIG_INSPECTION

#include "av2/decoder/inspection.h"

#endif

#include "av2/common/common.h"

#include "av2/common/entropy.h"

#include "av2/common/entropymode.h"

#include "av2/common/entropymv.h"

#include "av2/common/frame_buffers.h"

#include "av2/common/idct.h"

#include "av2/common/mvref_common.h"

#include "av2/common/pred_common.h"

#include "av2/common/quant_common.h"

#include "av2/common/reconinter.h"

#include "av2/common/reconintra.h"

#include "av2/common/resize.h"

#include "av2/common/seg_common.h"

#include "av2/common/thread_common.h"

#include "av2/common/tile_common.h"

#include "av2/common/tip.h"

#include "av2/common/warped_motion.h"

#include "av2/decoder/decodeframe.h"

#include "av2/decoder/decodemv.h"

#include "av2/decoder/decoder.h"

#include "av2/decoder/decodetxb.h"

#include "av2/decoder/detokenize.h"

#include "av2/decoder/obu.h"

#define AVM_MIN_THREADS_PER_TILE 1

#define AVM_MAX_THREADS_PER_TILE 2

#define MC_TEMP_BUF_PELS                           \

  (((MAX_SB_SIZE) * 2 + (AVM_INTERP_EXTEND) * 2) * \

   ((MAX_SB_SIZE) * 2 + (AVM_INTERP_EXTEND) * 2))

static void read_wienerns_framefilters_hdr(AV2_COMMON *cm, int plane,

                                           struct avm_read_bit_buffer *rb);

void copy_frame_filters_to_runits_if_needed(AV2_COMMON *cm) {

  const int num_planes = av2_num_planes(cm);

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

    if (!is_frame_filters_enabled(plane)) continue;

    RestorationInfo *rsi = &cm->rst_info[plane];

    if ((rsi->frame_restoration_type == RESTORE_WIENER_NONSEP ||

         rsi->frame_restoration_type == RESTORE_SWITCHABLE) &&

        rsi->frame_filters_on) {

      assert(rsi->frame_filters_initialized);

      for (int runit_idx = 0;

           runit_idx < rsi->horz_units_per_frame * rsi->vert_units_per_frame;

           ++runit_idx) {

        RestorationUnitInfo *rui = &rsi->unit_info[runit_idx];

        if (rui->restoration_type == RESTORE_WIENER_NONSEP) {

          copy_nsfilter_taps(&rui->wienerns_info, &rsi->frame_filters);

        }

      }

    }

  }

}

#if CONFIG_THROUGHPUT_ANALYSIS

int64_t tot_ctx_syms = { 0 };

int64_t tot_bypass_syms = { 0 };

int64_t max_ctx_syms = { 0 };

int64_t max_bypass_syms = { 0 };

int64_t max_bits = { 0 };

int64_t tot_bits = { 0 };

int64_t tot_frames = { 0 };

int64_t total_context_switch = { 0 };

int64_t total_total_hits = { 0 };

#endif  // CONFIG_THROUGHPUT_ANALYSIS

int av2_check_byte_alignment(AV2_COMMON *const cm,

                             struct avm_read_bit_buffer *const rb) {

  while (rb->bit_offset & 7) {

    if (avm_rb_read_bit(rb)) {

      cm->error.error_code = AVM_CODEC_CORRUPT_FRAME;

      return -1;

    }

  }

  return 0;

}

// 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 av2_check_trailing_bits(AV2Decoder *pbi, struct avm_read_bit_buffer *rb) {

  AV2_COMMON *const cm = &pbi->common;

  // 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 = avm_rb_read_literal(rb, bits_before_alignment);

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

    cm->error.error_code = AVM_CODEC_CORRUPT_FRAME;

    return -1;

  }

  return 0;

}

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

static AVM_INLINE void set_planes_to_neutral_grey(

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

    int only_chroma) {

  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 = 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) {

      avm_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]);

      }

    }

  }

}

static AVM_INLINE void loop_restoration_read_sb_coeffs(AV2_COMMON *cm,

                                                       MACROBLOCKD *xd,

                                                       avm_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 avm_read_bit_buffer *rb,

                            int coded_lossless) {

  if (coded_lossless) return ONLY_4X4;

  return avm_rb_read_bit(rb) ? TX_MODE_SELECT : TX_MODE_LARGEST;

}

static REFERENCE_MODE read_frame_reference_mode(

    const AV2_COMMON *cm, struct avm_read_bit_buffer *rb) {

  if (frame_is_intra_only(cm)) {

    return SINGLE_REFERENCE;

  } else {

    return avm_rb_read_bit(rb) ? REFERENCE_MODE_SELECT : SINGLE_REFERENCE;

  }

}

static AVM_INLINE void inverse_transform_block(DecoderCodingBlock *dcb,

                                               const AV2_COMMON *cm, int plane,

                                               const TX_TYPE tx_type,

                                               const TX_SIZE tx_size,

                                               uint16_t *dst, int stride,

                                               int reduced_tx_set) {

  tran_low_t *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;

  // Update eob and scan_line according to those of the other chroma plane

  if (plane && is_cctx_allowed(cm, &dcb->xd)) {

    eob_info *eob_data_c1 =

        dcb->eob_data[AVM_PLANE_U] + dcb->txb_offset[AVM_PLANE_U];

    eob_info *eob_data_c2 =

        dcb->eob_data[AVM_PLANE_V] + dcb->txb_offset[AVM_PLANE_V];

    scan_line = AVMMAX(eob_data_c1->max_scan_line, eob_data_c2->max_scan_line);

    eob = AVMMAX(eob_data_c1->eob, eob_data_c2->eob);

  }

  av2_inverse_transform_block(

      &dcb->xd, dqcoeff, plane, tx_type, tx_size, dst, stride, eob,

      replace_adst_by_ddt(cm->seq_params.enable_inter_ddt,

                          cm->features.allow_screen_content_tools, &dcb->xd),

      reduced_tx_set);

  const int width = tx_size_wide[tx_size] <= 32 ? tx_size_wide[tx_size] : 32;

  const int height = tx_size_high[tx_size] <= 32 ? tx_size_high[tx_size] : 32;

  const int sbSize = (width >= 8 && height >= 8) ? 8 : 4;

  int32_t nz0 = (sbSize - 1) * tx_size_wide[tx_size] + sbSize;

  int32_t nz1 = (scan_line + 1);

  memset(dqcoeff, 0, AVMMAX(nz0, nz1) * sizeof(dqcoeff[0]));

}

static AVM_INLINE void read_coeffs_tx_intra_block(

    const AV2_COMMON *const cm, DecoderCodingBlock *dcb, avm_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[dcb->xd.tree_type == CHROMA_PART]) {

#if TXCOEFF_TIMER

    struct avm_usec_timer timer;

    avm_usec_timer_start(&timer);

#endif

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

#if TXCOEFF_TIMER

    avm_usec_timer_mark(&timer);

    const int64_t elapsed_time = avm_usec_timer_elapsed(&timer);

    cm->txcoeff_timer += elapsed_time;

    ++cm->txb_count;

#endif

  } else {

    // all tx blocks are skipped.

    av2_update_txk_skip_array(cm, dcb->xd.mi_row, dcb->xd.mi_col,

                              dcb->xd.tree_type, &mbmi->chroma_ref_info, plane,

                              row, col, tx_size);

  }

}

static AVM_INLINE void decode_block_void(const AV2_COMMON *const cm,

                                         DecoderCodingBlock *dcb,

                                         avm_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 AVM_INLINE void predict_inter_block_void(AV2_COMMON *const cm,

                                                DecoderCodingBlock *dcb,

                                                BLOCK_SIZE bsize) {

  (void)cm;

  (void)dcb;

  (void)bsize;

}

static AVM_INLINE void predict_and_reconstruct_intra_block(

    const AV2_COMMON *const cm, DecoderCodingBlock *dcb, avm_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);

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

#if CONFIG_INSPECTION

  {

    const int txwpx = tx_size_wide[tx_size];

    const int txhpx = tx_size_high[tx_size];

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

    const int dst_stride = pd->dst.stride;

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

    for (int i = 0; i < txhpx; i++) {

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

        uint16_t pixel = dst[i * dst_stride + j];

        int stride = cm->predicted_pixels.strides[plane > 0];

        int pixel_c, pixel_r;

        if (plane) {

          mi_to_pixel_loc(&pixel_c, &pixel_r,

                          mbmi->chroma_ref_info.mi_col_chroma_base,

                          mbmi->chroma_ref_info.mi_row_chroma_base, col, row,

                          pd->subsampling_x, pd->subsampling_y);

        } else {

          mi_to_pixel_loc(&pixel_c, &pixel_r, xd->mi_col, xd->mi_row, col, row,

                          pd->subsampling_x, pd->subsampling_y);

        }

        pixel_c += j;

        pixel_r += i;

        cm->predicted_pixels.buffers[plane][pixel_r * stride + pixel_c] = pixel;

      }

    }

  }

#endif  // CONFIG_INSPECTION

#if CONFIG_MISMATCH_DEBUG

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

  int pixel_c, pixel_r;

  const int blk_w = tx_size_wide[tx_size];

  const int blk_h = tx_size_high[tx_size];

  if (plane == 0 || xd->is_chroma_ref) {

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

    if (plane) {

      mi_to_pixel_loc(&pixel_c, &pixel_r,

                      mbmi->chroma_ref_info.mi_col_chroma_base,

                      mbmi->chroma_ref_info.mi_row_chroma_base, col, row,

                      pd->subsampling_x, pd->subsampling_y);

    } else {

      mi_to_pixel_loc(&pixel_c, &pixel_r, mi_col, mi_row, col, row,

                      pd->subsampling_x, pd->subsampling_y);

    }

    int pixels_c = (cm->mi_params.mi_cols * MI_SIZE) >> pd->subsampling_x;

    int pixels_r = (cm->mi_params.mi_rows * MI_SIZE) >> pd->subsampling_y;

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

                             cm->current_frame.display_order_hint, pixels_c,

                             pixels_r, plane, pixel_c, pixel_r, blk_w, blk_h);

  }

#endif  // CONFIG_MISMATCH_DEBUG

  if (!mbmi->skip_txfm[xd->tree_type == CHROMA_PART]) {

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

    // In CCTX, when C2 eob = 0 but C1 eob > 0, plane V reconstruction is

    // still needed

    int recon_with_cctx = 0;

    if (is_cctx_allowed(cm, xd) && plane == AVM_PLANE_V &&

        av2_get_cctx_type(xd, row, col) > CCTX_NONE) {

      eob_info *eob_data_c1 =

          dcb->eob_data[AVM_PLANE_U] + dcb->txb_offset[AVM_PLANE_U];

      recon_with_cctx = eob_data_c1->eob > 0;

    }

    if (eob_data->eob || recon_with_cctx) {

      const uint8_t reduced_tx_set_used =

          is_reduced_tx_set_used(cm, plane_type);

      // tx_type was read out in av2_read_coeffs_txb.

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

                                              reduced_tx_set_used);

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

      uint16_t *dst =

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

      inverse_transform_block(dcb, cm, plane, tx_type, tx_size, dst,

                              pd->dst.stride, reduced_tx_set_used);

    }

  }

#if CONFIG_MISMATCH_DEBUG

  {

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

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

    if (plane) {

      mi_to_pixel_loc(&pixel_c, &pixel_r,

                      mbmi->chroma_ref_info.mi_col_chroma_base,

                      mbmi->chroma_ref_info.mi_row_chroma_base, col, row,

                      pd->subsampling_x, pd->subsampling_y);

    } else {

      mi_to_pixel_loc(&pixel_c, &pixel_r, mi_col, mi_row, col, row,

                      pd->subsampling_x, pd->subsampling_y);

    }

    int pixels_c = (cm->mi_params.mi_cols * MI_SIZE) >> pd->subsampling_x;

    int pixels_r = (cm->mi_params.mi_rows * MI_SIZE) >> pd->subsampling_y;

    mismatch_check_block_tx(dst, pd->dst.stride,

                            cm->current_frame.display_order_hint, pixels_c,

                            pixels_r, plane, pixel_c, pixel_r, blk_w, blk_h);

  }

#endif  // CONFIG_MISMATCH_DEBUG

}

// Facade function for inverse cross chroma component transform

static AVM_INLINE void inverse_cross_chroma_transform_block(

    const AV2_COMMON *const cm, DecoderCodingBlock *dcb, avm_reader *const r,

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

    const TX_SIZE tx_size) {

  (void)cm;

  (void)r;

  (void)plane;

  tran_low_t *dqcoeff_c1 =

      dcb->dqcoeff_block[AVM_PLANE_U] + dcb->cb_offset[AVM_PLANE_U];

  tran_low_t *dqcoeff_c2 =

      dcb->dqcoeff_block[AVM_PLANE_V] + dcb->cb_offset[AVM_PLANE_V];

  MACROBLOCKD *const xd = &dcb->xd;

  const CctxType cctx_type = av2_get_cctx_type(xd, blk_row, blk_col);

  av2_inv_cross_chroma_tx_block(dqcoeff_c1, dqcoeff_c2, tx_size, cctx_type,

                                xd->bd);

}

static AVM_INLINE void inverse_transform_inter_block(

    const AV2_COMMON *const cm, DecoderCodingBlock *dcb, avm_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 uint8_t reduced_tx_set_used = is_reduced_tx_set_used(cm, plane_type);

  // tx_type was read out in av2_read_coeffs_txb.

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

                                          tx_size, reduced_tx_set_used);

  uint16_t *dst =

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

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

                          reduced_tx_set_used);

#if CONFIG_MISMATCH_DEBUG

  int pixel_c, pixel_r;

  const int blk_w = tx_size_wide[tx_size];

  const int blk_h = tx_size_high[tx_size];

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

  if (plane) {

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

    mi_to_pixel_loc(&pixel_c, &pixel_r,

                    mbmi->chroma_ref_info.mi_col_chroma_base,

                    mbmi->chroma_ref_info.mi_row_chroma_base, blk_col, blk_row,

                    pd->subsampling_x, pd->subsampling_y);

  } else {

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

                    pd->subsampling_x, pd->subsampling_y);

  }

  int pixels_c = (cm->mi_params.mi_cols * MI_SIZE) >> pd->subsampling_x;

  int pixels_r = (cm->mi_params.mi_rows * MI_SIZE) >> pd->subsampling_y;

  mismatch_check_block_tx(dst, pd->dst.stride,

                          cm->current_frame.display_order_hint, pixels_c,

                          pixels_r, plane, pixel_c, pixel_r, blk_w, blk_h);

#endif  // CONFIG_MISMATCH_DEBUG

}

static AVM_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 AVM_INLINE void decode_reconstruct_tx(

    AV2_COMMON *cm, ThreadData *const td, avm_reader *r,

    MB_MODE_INFO *const mbmi, int plane, BLOCK_SIZE plane_bsize, int blk_row,

    int blk_col, TX_SIZE tx_size, int *eob_total) {

  DecoderCodingBlock *const dcb = &td->dcb;

  MACROBLOCKD *const xd = &dcb->xd;

  if (plane == AVM_PLANE_U && is_cctx_allowed(cm, xd)) return;

  int txp_index = av2_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 (mbmi->tx_partition_type[txp_index] == TX_PARTITION_NONE || plane) {

    if (plane == AVM_PLANE_V && is_cctx_allowed(cm, xd)) {

      td->read_coeffs_tx_inter_block_visit(cm, dcb, r, AVM_PLANE_U, blk_row,

                                           blk_col, tx_size);

      td->read_coeffs_tx_inter_block_visit(cm, dcb, r, AVM_PLANE_V, blk_row,

                                           blk_col, tx_size);

      td->inverse_cctx_block_visit(cm, dcb, r, -1, blk_row, blk_col, tx_size);

      td->inverse_tx_inter_block_visit(cm, dcb, r, AVM_PLANE_U, blk_row,

                                       blk_col, tx_size);

      td->inverse_tx_inter_block_visit(cm, dcb, r, AVM_PLANE_V, blk_row,

                                       blk_col, tx_size);

      eob_info *eob_data_c1 =

          dcb->eob_data[AVM_PLANE_U] + dcb->txb_offset[AVM_PLANE_U];

      eob_info *eob_data_c2 =

          dcb->eob_data[AVM_PLANE_V] + dcb->txb_offset[AVM_PLANE_V];

      *eob_total += eob_data_c1->eob + eob_data_c2->eob;

      set_cb_buffer_offsets(dcb, tx_size, AVM_PLANE_U);

      set_cb_buffer_offsets(dcb, tx_size, AVM_PLANE_V);

    } else {

      assert(plane == AVM_PLANE_Y || !is_cctx_allowed(cm, xd));

      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 {

    get_tx_partition_sizes(mbmi->tx_partition_type[txp_index], tx_size,

                           &mbmi->txb_pos, mbmi->sub_txs, xd->error_info);

    for (int txb_idx = 0; txb_idx < mbmi->txb_pos.n_partitions; ++txb_idx) {

      mbmi->txb_idx = 0;

      const TX_SIZE sub_tx = mbmi->sub_txs[txb_idx];

      const int offsetr = blk_row + mbmi->txb_pos.row_offset[txb_idx];

      const int offsetc = blk_col + mbmi->txb_pos.col_offset[txb_idx];

      if (offsetr >= max_blocks_high || offsetc >= max_blocks_wide) continue;

      td->read_coeffs_tx_inter_block_visit(cm, dcb, r, plane, offsetr, offsetc,

                                           sub_tx);

      td->inverse_tx_inter_block_visit(cm, dcb, r, plane, offsetr, offsetc,

                                       sub_tx);

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

      *eob_total += eob_data->eob;

      set_cb_buffer_offsets(dcb, sub_tx, plane);

    }

  }

}

static AVM_INLINE void set_offsets(AV2_COMMON *const cm, MACROBLOCKD *const xd,

                                   BLOCK_SIZE bsize, int mi_row, int mi_col,

                                   int bw, int bh, int x_inside_boundary,

                                   int y_inside_boundary,

                                   PARTITION_TREE *parent, int index) {

  const int num_planes = av2_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, x_inside_boundary,

                 y_inside_boundary);

  xd->mi[0]->sb_type[xd->tree_type == CHROMA_PART] = bsize;

  if (xd->tree_type != CHROMA_PART) {

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

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

  }

#if CONFIG_RD_DEBUG

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

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

#endif

  if (xd->tree_type == SHARED_PART) {

    assert(x_inside_boundary && y_inside_boundary);

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

    int idx = mi_params->mi_stride;

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

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

      idx += mi_params->mi_stride;

    }

  }

  CHROMA_REF_INFO *chroma_ref_info = &xd->mi[0]->chroma_ref_info;

  set_chroma_ref_info(xd->tree_type, mi_row, mi_col, index, bsize,

                      chroma_ref_info, parent ? &parent->chroma_ref_info : NULL,

                      parent ? parent->bsize : BLOCK_INVALID,

                      parent ? parent->partition : PARTITION_NONE,

                      xd->plane[1].subsampling_x, xd->plane[1].subsampling_y);

  set_plane_n4(xd, bw, bh, num_planes, chroma_ref_info);

  set_entropy_context(xd, mi_row, mi_col, num_planes, chroma_ref_info);

  // 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(cm, xd, tile, mi_row, bh, mi_col, bw, mi_params->mi_rows,

                 mi_params->mi_cols, chroma_ref_info);

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

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

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

                       num_planes, chroma_ref_info);

}

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,

                                    uint16_t *mc_buf, uint16_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, NULL)) {

    // Get reference block pointer.

    const uint16_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;

    // Extend the border.

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

    *src_stride = b_w;

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

           x_pad * (AVM_INTERP_EXTEND - 1);

  }

}

static 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,

    int use_optflow_refinement, uint16_t **mc_buf, uint16_t **pre,

    SubpelParams *subpel_params, int *src_stride) {

  if (inter_pred_params->use_ref_padding) {

    common_calc_subpel_params_and_extend(

        src_mv, inter_pred_params, xd, mi_x, mi_y, ref, use_optflow_refinement,

        mc_buf, pre, subpel_params, src_stride);

    return;

  }

  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, use_optflow_refinement, &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, mc_buf[ref], pre, src_stride);

}

// Allocate and copy data for TIP multi threading.

static void copy_tip_worker_data(AV2Decoder *pbi, AV2_COMMON *cm) {

  int num_worker = pbi->max_threads;

  avm_free(pbi->tip_worker_data);

  CHECK_MEM_ERROR(

      cm, pbi->tip_worker_data,

      avm_memalign(32, num_worker * sizeof(*(pbi->tip_worker_data))));

  for (int worker_idx = 0; worker_idx < num_worker; ++worker_idx) {

    DecWorkerData *const thread_data = pbi->thread_data + worker_idx;

    TIPWorkerData *const tip_worker_data = pbi->tip_worker_data + worker_idx;

    tip_worker_data->xd = pbi->dcb.xd;

    tip_worker_data->mc_buf[0] = thread_data->td->mc_buf[0];

    tip_worker_data->mc_buf[1] = thread_data->td->mc_buf[1];

    tip_worker_data->tmp_conv_dst = thread_data->td->tmp_conv_dst;

    // Temporary buffers used during the SMVR and OPFL processing.

    tip_worker_data->xd.opfl_vxy_bufs = thread_data->td->opfl_vxy_bufs;

    tip_worker_data->xd.opfl_gxy_bufs = thread_data->td->opfl_gxy_bufs;

    tip_worker_data->xd.opfl_dst_bufs = thread_data->td->opfl_dst_bufs;

  }

}

static void av2_dec_setup_tip_frame(AV2Decoder *pbi, AV2_COMMON *cm,

                                    MACROBLOCKD *xd) {

  av2_setup_tip_motion_field(cm);

  if (pbi->num_workers > 1) {

    copy_tip_worker_data(pbi, cm);

    av2_setup_tip_frame_mt(cm, dec_calc_subpel_params_and_extend,

                           1 /* copy_refined_mvs */, pbi->tile_workers,

                           pbi->num_workers, &pbi->tip_sync,

                           pbi->tip_worker_data);

  } else {

    xd->opfl_vxy_bufs = pbi->td.opfl_vxy_bufs;

    xd->opfl_gxy_bufs = pbi->td.opfl_gxy_bufs;

    xd->opfl_dst_bufs = pbi->td.opfl_dst_bufs;

    av2_setup_tip_frame(cm, xd, pbi->td.mc_buf, pbi->td.tmp_conv_dst,

                        dec_calc_subpel_params_and_extend,

                        1 /* copy_refined_mvs */

    );

  }

  if (cm->seq_params.enable_tip_explicit_qp == 0) {

    const int avg_u_ac_delta_q =

        (cm->tip_ref.ref_frame_buffer[0]->u_ac_delta_q +

         cm->tip_ref.ref_frame_buffer[1]->u_ac_delta_q + 1) >>

        1;

    const int avg_v_ac_delta_q =

        (cm->tip_ref.ref_frame_buffer[0]->v_ac_delta_q +

         cm->tip_ref.ref_frame_buffer[1]->v_ac_delta_q + 1) >>

        1;

    const int base_qindex =

        (cm->tip_ref.ref_frame_buffer[0]->base_qindex +

         cm->tip_ref.ref_frame_buffer[1]->base_qindex + 1) >>

        1;

    cm->cur_frame->base_qindex = cm->quant_params.base_qindex = base_qindex;

    cm->cur_frame->u_ac_delta_q = cm->quant_params.u_ac_delta_q =

        avg_u_ac_delta_q;

    cm->cur_frame->v_ac_delta_q = cm->quant_params.v_ac_delta_q =

        avg_v_ac_delta_q;

  }

  if (cm->seq_params.enable_lf_sub_pu && cm->features.allow_lf_sub_pu) {

    init_tip_lf_parameter(cm, 0, av2_num_planes(cm));

    loop_filter_tip_frame(cm, xd, 0, av2_num_planes(cm));

  }

}

static AVM_INLINE void decode_mbmi_block(AV2Decoder *const pbi,

                                         DecoderCodingBlock *dcb, int mi_row,

                                         int mi_col, avm_reader *r,

                                         PARTITION_TYPE partition,

                                         BLOCK_SIZE bsize,

                                         PARTITION_TREE *parent, int index) {

  AV2_COMMON *const cm = &pbi->common;

  const int bw = mi_size_wide[bsize];

  const int bh = mi_size_high[bsize];

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

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

  MACROBLOCKD *const xd = &dcb->xd;

#if CONFIG_ACCOUNTING

  avm_accounting_set_context(&pbi->accounting, mi_col, mi_row, xd->tree_type);

#endif

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

              index);

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

  // set region_type for each mbmi

  xd->mi[0]->region_type = parent->region_type;

  // set tree_type for each mbmi

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

  xd->mi[0]->sb_root_partition_info = parent->sb_root_partition_info;

  xd->mi[0]->local_rest_type =

      1;  // set non zero default type, it is only matter 1 or 0 in SW

  xd->mi[0]->local_ccso_blk_flag =

      1;  // set non zero default type, it is only matter 1 or 0 in SW

  xd->mi[0]->local_gdf_mode =

      1;  // set non zero default type, it is only matter 1 or 0 in SW

  if (!bru_is_sb_active(cm, mi_col, mi_row) ||

      cm->bridge_frame_info.is_bridge_frame) {

    xd->mi[0]->sb_active_mode = xd->sbi->sb_active_mode;

    bru_set_default_inter_mb_mode_info(cm, xd, xd->mi[0], bsize);

    const int w = mi_size_wide[cm->seq_params.sb_size];

    const int h = mi_size_high[cm->seq_params.sb_size];

    const int x_inside_boundary = AVMMIN(w, cm->mi_params.mi_cols - mi_col);

    const int y_inside_boundary = AVMMIN(h, cm->mi_params.mi_rows - mi_row);

    if (cm->bridge_frame_info.is_bridge_frame) {

      bru_zero_sb_mvs(cm, -1, mi_row, mi_col, x_inside_boundary,

                      y_inside_boundary);

    } else if (pbi->bru_opt_mode && cm->bru.enabled) {

      // only update ref MVS for optimized decoder

      bru_zero_sb_mvs(cm, cm->bru.update_ref_idx, mi_row, mi_col,

                      x_inside_boundary, y_inside_boundary);

    }

    if (!cm->bru.frame_inactive_flag &&

        !cm->bridge_frame_info.is_bridge_frame) {

      if (xd->tree_type != CHROMA_PART) {

        read_gdf(cm, r, xd);

      }

      if (cm->seq_params.enable_ccso && xd->tree_type != CHROMA_PART) {

        read_ccso(cm, r, xd);

      }

    }

  } else

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

  if (xd->tree_type != LUMA_PART) {

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

    const BLOCK_SIZE chroma_bsize_base =

        get_bsize_base(xd, xd->mi[0], AVM_PLANE_U);

    assert(chroma_bsize_base < BLOCK_SIZES_ALL);

    if (get_plane_block_size(chroma_bsize_base, pd_u->subsampling_x,

                             pd_u->subsampling_y) == BLOCK_INVALID) {

      avm_internal_error(xd->error_info, AVM_CODEC_CORRUPT_FRAME,

                         "Block size %dx%d invalid with this subsampling mode",

                         block_size_wide[chroma_bsize_base],

                         block_size_high[chroma_bsize_base]);

    }

  }

}

static void dec_build_inter_predictors(const AV2_COMMON *cm,

                                       DecoderCodingBlock *dcb, int plane,

                                       MB_MODE_INFO *mi, int bw, int bh,

                                       int mi_x, int mi_y,

                                       int build_for_refine_mv_only) {

  av2_build_inter_predictors(cm, &dcb->xd, plane, mi, NULL,

                             build_for_refine_mv_only, 1 /* build_for_decode */,

                             bw, bh, mi_x, mi_y, dcb->mc_buf,

                             dec_calc_subpel_params_and_extend);

}

static AVM_INLINE void dec_build_inter_predictor(const AV2_COMMON *cm,

                                                 DecoderCodingBlock *dcb,

                                                 int mi_row, int mi_col,

                                                 BLOCK_SIZE bsize) {

  MACROBLOCKD *const xd = &dcb->xd;

  const int num_planes = av2_num_planes(cm);

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

  int need_subblock_mvs = xd->is_chroma_ref && mbmi->refinemv_flag &&

                          !is_intrabc_block(mbmi, xd->tree_type);

  assert(IMPLIES(need_subblock_mvs, !is_interintra_pred(mbmi)));

  if (need_subblock_mvs && default_refinemv_modes(mbmi))

    need_subblock_mvs &= (mbmi->comp_group_idx == 0 &&

                          mbmi->interinter_comp.type == COMPOUND_AVERAGE);

  if (need_subblock_mvs) {

    fill_subblock_refine_mv(xd->refinemv_subinfo, xd->plane[0].width,

                            xd->plane[0].height, mbmi->mv[0].as_mv,

                            mbmi->mv[1].as_mv);

  }

  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],

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

                               mi_x, mi_y, 0);

    int is_intra_inter_allowed = 1;

    if (mbmi->tree_type == SHARED_PART &&

        mbmi->region_type == MIXED_INTER_INTRA_REGION &&

        mbmi->chroma_ref_info.offset_started && plane > 0) {

      is_intra_inter_allowed = 0;

    }

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

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

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

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

                                     bsize);

    }

  }

  if (mbmi->morph_pred) {

    assert(av2_allow_intrabc(cm, xd, bsize));

    assert(av2_allow_intrabc_morph_pred(cm));

    assert(is_intrabc_block(mbmi, xd->tree_type));

    av2_build_morph_pred(cm, xd, bsize, mi_row, mi_col);

  }

}

static AVM_INLINE void predict_inter_block(AV2_COMMON *const cm,

                                           DecoderCodingBlock *dcb,

                                           BLOCK_SIZE bsize) {

  MACROBLOCKD *const xd = &dcb->xd;

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

  const int num_planes = av2_num_planes(cm);

  const int mi_row = xd->mi_row;

  const int mi_col = xd->mi_col;

  const int is_compound =

      has_second_ref(mbmi) || is_tip_ref_frame(mbmi->ref_frame[0]);

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

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

    if (frame == INTRA_FRAME) {

      assert(is_intrabc_block(mbmi, xd->tree_type));

      assert(ref == 0);

    } else {

      const RefCntBuffer *ref_buf = is_tip_ref_frame(mbmi->ref_frame[0])

                                        ? cm->tip_ref.ref_frame_buffer[ref]

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

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

                           ref_scale_factors, num_planes,

                           &mbmi->chroma_ref_info);

    }

  }

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

#if CONFIG_MISMATCH_DEBUG

  const int plane_start = get_partition_plane_start(xd->tree_type);

  const int plane_end = get_partition_plane_end(xd->tree_type, num_planes);

  for (int plane = plane_start; plane < plane_end; ++plane) {

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

    int pixel_c, pixel_r;

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

    if (plane) {

      mi_to_pixel_loc(&pixel_c, &pixel_r,

                      mbmi->chroma_ref_info.mi_col_chroma_base,

                      mbmi->chroma_ref_info.mi_row_chroma_base, 0, 0,

                      pd->subsampling_x, pd->subsampling_y);

    } else {

      mi_to_pixel_loc(&pixel_c, &pixel_r, mi_col, mi_row, 0, 0,

                      pd->subsampling_x, pd->subsampling_y);

    }

    int pixels_c = (cm->mi_params.mi_cols * MI_SIZE) >> pd->subsampling_x;

    int pixels_r = (cm->mi_params.mi_rows * MI_SIZE) >> pd->subsampling_y;

    mismatch_check_block_pre(

        pd->dst.buf, pd->dst.stride, cm->current_frame.display_order_hint,

        pixels_c, pixels_r, plane, pixel_c, pixel_r, pd->width, pd->height);

  }

#endif  // CONFIG_MISMATCH_DEBUG

#if CONFIG_INSPECTION

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

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

    const int dst_stride = pd->dst.stride;

    const int plane_block_size =

        get_plane_block_size(bsize, pd->subsampling_x, pd->subsampling_y);

    const int plane_width = mi_size_wide[plane_block_size];

    const int plane_height = mi_size_high[plane_block_size];

    for (int i = 0; i < plane_height * MI_SIZE; i++) {

      for (int j = 0; j < plane_width * MI_SIZE; j++) {

        uint16_t pixel = pd->dst.buf[i * dst_stride + j];

        int stride = cm->predicted_pixels.strides[plane > 0];

        int pixel_c, pixel_r;

        if (plane) {

          mi_to_pixel_loc(&pixel_c, &pixel_r,

                          mbmi->chroma_ref_info.mi_col_chroma_base,

                          mbmi->chroma_ref_info.mi_row_chroma_base, 0, 0,

                          pd->subsampling_x, pd->subsampling_y);

        } else {

          mi_to_pixel_loc(&pixel_c, &pixel_r, xd->mi_col, xd->mi_row, 0, 0,

                          pd->subsampling_x, pd->subsampling_y);

        }

        pixel_c += j;

        pixel_r += i;

        cm->predicted_pixels.buffers[plane][pixel_r * stride + pixel_c] = pixel;

      }

    }

  }

#endif  // CONFIG_INSPECTION

}

static AVM_INLINE void copy_frame_mvs_inter_block(AV2_COMMON *const cm,

                                                  DecoderCodingBlock *dcb,

                                                  BLOCK_SIZE bsize) {

  if (!frame_is_intra_only(cm) &&

      cm->seq_params.order_hint_info.enable_ref_frame_mvs) {

    MACROBLOCKD *const xd = &dcb->xd;

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

    const int bw = mi_size_wide[bsize];

    const int bh = mi_size_high[bsize];

    const int x_inside_boundary =

        AVMMIN(bw, cm->mi_params.mi_cols - xd->mi_col);

    const int y_inside_boundary =

        AVMMIN(bh, cm->mi_params.mi_rows - xd->mi_row);

    if (enable_refined_mvs_in_tmvp(cm, xd, mi)) {

      av2_copy_frame_refined_mvs(cm, xd, mi, xd->mi_row, xd->mi_col,

                                 x_inside_boundary, y_inside_boundary);

    } else {

      av2_copy_frame_mvs(cm, xd, mi, xd->mi_row, xd->mi_col, x_inside_boundary,

                         y_inside_boundary);

    }

  }

}

static AVM_INLINE void set_color_index_map_offset(MACROBLOCKD *const xd,

                                                  int plane, avm_reader *r) {

  (void)r;

  Av2ColorMapParam params;

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

  av2_get_block_dimensions(mbmi->sb_type[plane > 0], plane, xd,

                           &params.plane_width, &params.plane_height, NULL,

                           NULL);

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

}

void dec_bru_swap_stage(AV2_COMMON *cm, MACROBLOCKD *const xd) {

  if (cm->bru.enabled) {

    RefCntBuffer *tmp_buf = cm->cur_frame;

    if (bru_swap_common(cm)) {

      BufferPool *pool = cm->buffer_pool;

      lock_buffer_pool(pool);

      if (tmp_buf != NULL) {

        assert(tmp_buf->ref_count == 0);

        if (tmp_buf->ref_count == 0 && tmp_buf->raw_frame_buffer.data) {

          pool->release_fb_cb(pool->cb_priv, &tmp_buf->raw_frame_buffer);

          tmp_buf->raw_frame_buffer.data = NULL;

          tmp_buf->raw_frame_buffer.size = 0;

          tmp_buf->raw_frame_buffer.priv = NULL;

        }

      }

      unlock_buffer_pool(pool);

      xd->cur_buf = &cm->cur_frame->buf;

    } else {

      avm_internal_error(&cm->error, AVM_CODEC_ERROR,

                         "Decoder BRU swap stage error");

    }

    // correctly extend borders after swap

    // todo: this can be simplified by only extend support SB border

    // avm_extend_frame_borders(&cm->cur_frame->buf, num_planes);

    // Note, do not touch any recon region except the border

    // first col of sb

    const int sb_cols =

        (cm->mi_params.mi_cols + cm->mib_size - 1) / cm->mib_size;

    const int sb_rows =

        (cm->mi_params.mi_rows + cm->mib_size - 1) / cm->mib_size;

    for (int sb_row = 0; sb_row < sb_rows; sb_row++) {

      const int sb_mi_row = sb_row << cm->mib_size_log2;

      const int sb_mi_col = 0;

      BruActiveMode active_mode =

          av2_get_sb_info(cm, sb_mi_row, sb_mi_col)->sb_active_mode;

      if (active_mode == BRU_SUPPORT_SB) {

        bru_extend_mc_border(cm, sb_mi_row, sb_mi_col, cm->sb_size,

                             &cm->cur_frame->buf);

      }

    }

    // first row of sb

    for (int sb_col = 0; sb_col < sb_cols; sb_col++) {

      const int sb_mi_row = 0;

      const int sb_mi_col = sb_col << cm->mib_size_log2;

      BruActiveMode active_mode =

          av2_get_sb_info(cm, sb_mi_row, sb_mi_col)->sb_active_mode;

      if (active_mode == BRU_SUPPORT_SB) {

        bru_extend_mc_border(cm, sb_mi_row, sb_mi_col, cm->sb_size,

                             &cm->cur_frame->buf);

      }

    }

    // last col of sb

    for (int sb_row = 0; sb_row < sb_rows; sb_row++) {

      const int sb_mi_row = sb_row << cm->mib_size_log2;

      const int sb_mi_col = (sb_cols - 1) << cm->mib_size_log2;

      BruActiveMode active_mode =

          av2_get_sb_info(cm, sb_mi_row, sb_mi_col)->sb_active_mode;

      if (active_mode == BRU_SUPPORT_SB) {