/*

 * 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 "av2/common/tip.h"

#include "config/avm_scale_rtcd.h"

#include "config/avm_dsp_rtcd.h"

#include "av2/common/reconinter.h"

// Percentage threshold of number of blocks with available motion

// projection in a frame to allow TIP mode

#define TIP_ENABLE_COUNT_THRESHOLD 60

static void tip_temporal_scale_motion_field(AV2_COMMON *cm,

                                            const int ref_frames_offset) {

  const int mvs_rows =

      ROUND_POWER_OF_TWO(cm->mi_params.mi_rows, TMVP_SHIFT_BITS);

  const int mvs_cols =

      ROUND_POWER_OF_TWO(cm->mi_params.mi_cols, TMVP_SHIFT_BITS);

  for (int blk_row = 0; blk_row < mvs_rows; ++blk_row) {

    for (int blk_col = 0; blk_col < mvs_cols; ++blk_col) {

      TPL_MV_REF *tpl_mvs = cm->tpl_mvs_rows[blk_row] + blk_col;

      if (tpl_mvs->mfmv0.as_int != INVALID_MV) {

        int_mv this_refmv;

        get_mv_projection_clamp(&this_refmv.as_mv, tpl_mvs->mfmv0.as_mv,

                                ref_frames_offset, tpl_mvs->ref_frame_offset,

                                -REFMVS_LIMIT, REFMVS_LIMIT);

        tpl_mvs->mfmv0.as_int = this_refmv.as_int;

        tpl_mvs->ref_frame_offset = ref_frames_offset;

      } else {

        tpl_mvs->ref_frame_offset = ref_frames_offset;

      }

    }

  }

}

// Compute number of rows/columns/stride in TMVP unit (8x8)

static void compute_tmvp_mi_info(const AV2_COMMON *cm, int *mvs_rows,

                                 int *mvs_cols, int *mvs_stride,

                                 int *sb_tmvp_size) {

  *mvs_rows = ROUND_POWER_OF_TWO(cm->mi_params.mi_rows, TMVP_SHIFT_BITS);

  *mvs_cols = ROUND_POWER_OF_TWO(cm->mi_params.mi_cols, TMVP_SHIFT_BITS);

  *mvs_stride = *mvs_cols;

  const SequenceHeader *const seq_params = &cm->seq_params;

  const int mf_sb_size_log2 =

      get_mf_sb_size_log2(block_size_high[seq_params->sb_size],

                          cm->mib_size_log2, cm->tmvp_sample_step);

  const int mf_sb_size = (1 << mf_sb_size_log2);

  *sb_tmvp_size = (mf_sb_size >> TMVP_MI_SZ_LOG2);

}

static void tip_fill_motion_field_holes(AV2_COMMON *cm) {

  int mvs_rows = 0;

  int mvs_cols = 0;

  int mvs_stride = 0;

  int sb_tmvp_size = 0;

  assert(cm->tmvp_sample_step > 0);

  int sample = cm->tmvp_sample_step;

  compute_tmvp_mi_info(cm, &mvs_rows, &mvs_cols, &mvs_stride, &sb_tmvp_size);

  const int dirs[4][2] = { { -1, 0 }, { 0, -1 }, { 1, 0 }, { 0, 1 } };

  for (int sb_row = 0; sb_row < mvs_rows; sb_row += sb_tmvp_size) {

    const int start_row = sb_row;

    const int end_row = AVMMIN(sb_row + sb_tmvp_size, mvs_rows);

    for (int sb_col = 0; sb_col < mvs_cols; sb_col += sb_tmvp_size) {

      const int start_col = sb_col;

      const int end_col = AVMMIN(sb_col + sb_tmvp_size, mvs_cols);

      for (int row = start_row; row < end_row; row += sample) {

        for (int col = start_col; col < end_col; col += sample) {

          const TPL_MV_REF *cur_tpl_mvs = cm->tpl_mvs_rows[row] + col;

          if (cur_tpl_mvs->mfmv0.as_int != INVALID_MV) {

            for (int dir = 0; dir < 4; ++dir) {

              const int neighbor_row = row + dirs[dir][0] * sample;

              const int neighbor_col = col + dirs[dir][1] * sample;

              if (neighbor_row >= start_row && neighbor_row < end_row &&

                  neighbor_col >= start_col && neighbor_col < end_col &&

                  cm->tpl_mvs_rows[neighbor_row][neighbor_col].mfmv0.as_int ==

                      INVALID_MV) {

                cm->tpl_mvs_rows[neighbor_row][neighbor_col].mfmv0.as_int =

                    cur_tpl_mvs->mfmv0.as_int;

                cm->tpl_mvs_rows[neighbor_row][neighbor_col].ref_frame_offset =

                    cur_tpl_mvs->ref_frame_offset;

              }

            }

          }

        }

      }

    }

  }

}

static void tip_blk_average_filter_mv(AV2_COMMON *cm) {

  int mvs_rows = 0;

  int mvs_cols = 0;

  int mvs_stride = 0;

  int sb_tmvp_size = 0;

  assert(cm->tmvp_sample_step > 0);

  int sample = cm->tmvp_sample_step;

  compute_tmvp_mi_info(cm, &mvs_rows, &mvs_cols, &mvs_stride, &sb_tmvp_size);

#define DIV_SHIFT_BITS 16

  // Avoid the division operation. Maximum 5 MVs would be used for MV smoothing.

  // weight_div_mult[i] where i is the number of MVs are available.

  // The value of weight_div_mult[i] is to implement 1/i without division with

  // the shift of (weight_div_mult[i] >> 16)

  const int weight_div_mult[6] = { 0, 65536, 32768, 21845, 16384, 13107 };

  const int sb_stride = MAX_SB_TMVP_SIZE;

  int_mv tpl_mfs[MAX_SB_TMVP_SIZE * MAX_SB_TMVP_SIZE];

  for (int sb_row = 0; sb_row < mvs_rows; sb_row += sb_tmvp_size) {

    const int start_row = sb_row;

    const int end_row = AVMMIN(sb_row + sb_tmvp_size, mvs_rows);

    for (int sb_col = 0; sb_col < mvs_cols; sb_col += sb_tmvp_size) {

      const int start_col = sb_col;

      const int end_col = AVMMIN(sb_col + sb_tmvp_size, mvs_cols);

      for (int row = start_row; row < end_row; row += sample) {

        const int i0 = row - sample;

        const int i1 = row + sample;

        for (int col = start_col; col < end_col; col += sample) {

          const int j0 = col - sample;

          const int j1 = col + sample;

          int weights = 0;

          int sum_mv_row = 0;

          int sum_mv_col = 0;

          if (cm->tpl_mvs_rows[row][col].mfmv0.as_int != INVALID_MV) {

            weights++;

            sum_mv_row += cm->tpl_mvs_rows[row][col].mfmv0.as_mv.row;

            sum_mv_col += cm->tpl_mvs_rows[row][col].mfmv0.as_mv.col;

          }

          if (i0 >= start_row) {

            if (cm->tpl_mvs_rows[i0][col].mfmv0.as_int != INVALID_MV) {

              weights++;

              sum_mv_row += cm->tpl_mvs_rows[i0][col].mfmv0.as_mv.row;

              sum_mv_col += cm->tpl_mvs_rows[i0][col].mfmv0.as_mv.col;

            }

          }

          if (i1 < end_row) {

            if (cm->tpl_mvs_rows[i1][col].mfmv0.as_int != INVALID_MV) {

              weights++;

              sum_mv_row += cm->tpl_mvs_rows[i1][col].mfmv0.as_mv.row;

              sum_mv_col += cm->tpl_mvs_rows[i1][col].mfmv0.as_mv.col;

            }

          }

          if (j0 >= start_col) {

            if (cm->tpl_mvs_rows[row][j0].mfmv0.as_int != INVALID_MV) {

              weights++;

              sum_mv_row += cm->tpl_mvs_rows[row][j0].mfmv0.as_mv.row;

              sum_mv_col += cm->tpl_mvs_rows[row][j0].mfmv0.as_mv.col;

            }

          }

          if (j1 < end_col) {

            if (cm->tpl_mvs_rows[row][j1].mfmv0.as_int != INVALID_MV) {

              weights++;

              sum_mv_row += cm->tpl_mvs_rows[row][j1].mfmv0.as_mv.row;

              sum_mv_col += cm->tpl_mvs_rows[row][j1].mfmv0.as_mv.col;

            }

          }

          const int blk_pos_in_sb = (row - sb_row) * sb_stride + (col - sb_col);

          if (weights) {

            const int scale_factor = weight_div_mult[weights];

            const int64_t scale_mv_row = (int64_t)sum_mv_row * scale_factor;

            const int64_t scale_mv_col = (int64_t)sum_mv_col * scale_factor;

            tpl_mfs[blk_pos_in_sb].as_mv.row =

                (MV_COMP_DATA_TYPE)ROUND_POWER_OF_TWO_SIGNED_64(scale_mv_row,

                                                                DIV_SHIFT_BITS);

            tpl_mfs[blk_pos_in_sb].as_mv.col =

                (MV_COMP_DATA_TYPE)ROUND_POWER_OF_TWO_SIGNED_64(scale_mv_col,

                                                                DIV_SHIFT_BITS);

          } else {

            tpl_mfs[blk_pos_in_sb].as_int = INVALID_MV;

          }

        }

      }

      for (int row = start_row; row < end_row; row += sample) {

        for (int col = start_col; col < end_col; col += sample) {

          const int blk_pos_in_sb = (row - sb_row) * sb_stride + (col - sb_col);

          cm->tpl_mvs_rows[row][col].mfmv0.as_int =

              tpl_mfs[blk_pos_in_sb].as_int;

        }

      }

    }

  }

}

static void tip_config_tip_parameter(AV2_COMMON *cm) {

  TIP *tip_ref = &cm->tip_ref;

  const OrderHintInfo *const order_hint_info = &cm->seq_params.order_hint_info;

  const int cur_order_hint = cm->cur_frame->display_order_hint;

  MV_REFERENCE_FRAME nearest_rf[2] = { tip_ref->ref_frame[0],

                                       tip_ref->ref_frame[1] };

  RefCntBuffer *ref0_frame_buf = get_ref_frame_buf(cm, nearest_rf[0]);

  const int ref0_frame_order_hint = ref0_frame_buf->display_order_hint;

  const int cur_to_ref0_offset =

      get_relative_dist(order_hint_info, cur_order_hint, ref0_frame_order_hint);

  RefCntBuffer *ref1_frame_buf = get_ref_frame_buf(cm, nearest_rf[1]);

  const int ref1_frame_order_hint = ref1_frame_buf->display_order_hint;

  const int cur_to_ref1_offset =

      get_relative_dist(order_hint_info, cur_order_hint, ref1_frame_order_hint);

  int ref_frames_offset = 0;

  if (cm->has_both_sides_refs) {

    ref_frames_offset = get_relative_dist(

        order_hint_info, ref1_frame_order_hint, ref0_frame_order_hint);

  } else {

    ref_frames_offset = get_relative_dist(

        order_hint_info, ref0_frame_order_hint, ref1_frame_order_hint);

  }

  tip_ref->ref_frame_buffer[0] = ref0_frame_buf;

  tip_ref->ref_frame_buffer[1] = ref1_frame_buf;

  tip_ref->ref_scale_factor[0] = get_ref_scale_factors_const(cm, nearest_rf[0]);

  tip_ref->ref_scale_factor[1] = get_ref_scale_factors_const(cm, nearest_rf[1]);

  tip_ref->ref_frames_offset_sf[0] =

      tip_derive_scale_factor(cur_to_ref0_offset, ref_frames_offset);

  tip_ref->ref_frames_offset_sf[1] =

      tip_derive_scale_factor(cur_to_ref1_offset, ref_frames_offset);

  tip_ref->ref_frames_offset = AVMMIN(ref_frames_offset, MAX_FRAME_DISTANCE);

  tip_ref->ref_offset[0] = cur_to_ref0_offset;

  tip_ref->ref_offset[1] = cur_to_ref1_offset;

  tip_ref->ref_order_hint[0] = ref0_frame_order_hint;

  tip_ref->ref_order_hint[1] = ref1_frame_order_hint;

}

void av2_setup_tip_motion_field(AV2_COMMON *cm) {

  if (cm->features.tip_frame_mode) {

    tip_config_tip_parameter(cm);

    tip_temporal_scale_motion_field(cm, cm->tip_ref.ref_frames_offset);

    if (cm->features.allow_tip_hole_fill) {

      tip_fill_motion_field_holes(cm);

      tip_blk_average_filter_mv(cm);

    }

    av2_fill_tpl_mvs_sample_gap(cm);

    cm->features.use_optflow_tip =

        cm->features.tip_frame_mode && cm->has_both_sides_refs;

  }

}

static void enc_check_enable_tip_mode(AV2_COMMON *cm) {

  const TPL_MV_REF *tpl_mvs_base = cm->tpl_mvs;

  const int mvs_rows =

      ROUND_POWER_OF_TWO(cm->mi_params.mi_rows, TMVP_SHIFT_BITS);

  const int mvs_cols =

      ROUND_POWER_OF_TWO(cm->mi_params.mi_cols, TMVP_SHIFT_BITS);

  const int mvs_stride = mvs_cols;

  assert(cm->tmvp_sample_step > 0);

  const int sample = cm->tmvp_sample_step;

  int count = 0;

  for (int blk_row = 0; blk_row < mvs_rows; blk_row += sample) {

    for (int blk_col = 0; blk_col < mvs_cols; blk_col += sample) {

      const int tpl_offset = blk_row * mvs_stride + blk_col;

      const TPL_MV_REF *tpl_mvs = tpl_mvs_base + tpl_offset;

      if (tpl_mvs->mfmv0.as_int != INVALID_MV) {

        ++count;

      }

    }

  }

  count *= sample * sample;

  // Percentage of number of blocks with available motion field

  const int percent = (count * 100) / (mvs_rows * mvs_cols);

  if (percent < TIP_ENABLE_COUNT_THRESHOLD) {

    cm->features.tip_frame_mode = TIP_FRAME_DISABLED;

  } else {

    cm->features.tip_frame_mode = TIP_FRAME_AS_REF;

  }

}

static void enc_decide_tip_mode(AV2_COMMON *cm) {

  TIP *tip_ref = &cm->tip_ref;

  if (cm->current_frame.frame_type == KEY_FRAME ||

      cm->current_frame.frame_type == INTRA_ONLY_FRAME ||

      cm->current_frame.frame_type == S_FRAME) {

    cm->features.tip_frame_mode = TIP_FRAME_DISABLED;

    tip_ref->ref_frame[0] = NONE_FRAME;

    tip_ref->ref_frame[1] = NONE_FRAME;

    return;

  }

  MV_REFERENCE_FRAME nearest_rf[2] = { tip_ref->ref_frame[0],

                                       tip_ref->ref_frame[1] };

  const int tip_mode_allowed = nearest_rf[0] != NONE_FRAME &&

                               nearest_rf[1] != NONE_FRAME &&

                               is_ref_motion_field_eligible_by_frame_size(

                                   cm, get_ref_frame_buf(cm, nearest_rf[0])) &&

                               is_ref_motion_field_eligible_by_frame_size(

                                   cm, get_ref_frame_buf(cm, nearest_rf[1]));

  if (tip_mode_allowed && (is_ref_motion_field_eligible_by_frame_type(

                               get_ref_frame_buf(cm, nearest_rf[0])) ||

                           is_ref_motion_field_eligible_by_frame_type(

                               get_ref_frame_buf(cm, nearest_rf[1])))) {

    enc_check_enable_tip_mode(cm);

    if (cm->features.tip_frame_mode) {

      cm->features.allow_tip_hole_fill = cm->seq_params.enable_tip_hole_fill;

    }

  } else {

    cm->features.tip_frame_mode = TIP_FRAME_DISABLED;

    cm->features.allow_tip_hole_fill = false;

    tip_ref->ref_frame[0] = NONE_FRAME;

    tip_ref->ref_frame[1] = NONE_FRAME;

  }

}

void av2_enc_setup_tip_motion_field(AV2_COMMON *cm) {

  enc_decide_tip_mode(cm);

  av2_setup_tip_motion_field(cm);

}

MAKE_BFP_SAD_WRAPPER_COMMON(avm_highbd_sad8x8)

MAKE_BFP_SAD_WRAPPER_COMMON(avm_highbd_sad16x8)

MAKE_BFP_SAD_WRAPPER_COMMON(avm_highbd_sad8x16)

MAKE_BFP_SAD_WRAPPER_COMMON(avm_highbd_sad16x16)

unsigned int get_highbd_sad(const uint16_t *src_ptr, int source_stride,

                            const uint16_t *ref_ptr, int ref_stride, int bd,

                            int bw, int bh) {

  if (bd == 8) {

    if (bw == 8 && bh == 8)

      return avm_highbd_sad8x8_8(src_ptr, source_stride, ref_ptr, ref_stride);

    else if (bw == 16 && bh == 8)

      return avm_highbd_sad16x8_8(src_ptr, source_stride, ref_ptr, ref_stride);

    else if (bw == 8 && bh == 16)

      return avm_highbd_sad8x16_8(src_ptr, source_stride, ref_ptr, ref_stride);

    else if (bw == 16 && bh == 16)

      return avm_highbd_sad16x16_8(src_ptr, source_stride, ref_ptr, ref_stride);

    else if (bw == 12 && bh == 12)

      return avm_highbd_sad12x12(src_ptr, source_stride, ref_ptr, ref_stride);

    else if (bw == 20 && bh == 12)

      return avm_highbd_sad20x12(src_ptr, source_stride, ref_ptr, ref_stride);

    else if (bw == 12 && bh == 20)

      return avm_highbd_sad12x20(src_ptr, source_stride, ref_ptr, ref_stride);

    else if (bw == 20 && bh == 20)

      return avm_highbd_sad20x20(src_ptr, source_stride, ref_ptr, ref_stride);

    else {

      assert(0);

      return 0;

    }

  } else if (bd == 10) {

    if (bw == 8 && bh == 8)

      return avm_highbd_sad8x8_10(src_ptr, source_stride, ref_ptr, ref_stride);

    else if (bw == 16 && bh == 8)

      return avm_highbd_sad16x8_10(src_ptr, source_stride, ref_ptr, ref_stride);

    else if (bw == 8 && bh == 16)

      return avm_highbd_sad8x16_10(src_ptr, source_stride, ref_ptr, ref_stride);

    else if (bw == 16 && bh == 16)

      return avm_highbd_sad16x16_10(src_ptr, source_stride, ref_ptr,

                                    ref_stride);

    else {

      assert(0);

      return 0;

    }

  } else if (bd == 12) {

    if (bw == 8 && bh == 8)

      return avm_highbd_sad8x8_12(src_ptr, source_stride, ref_ptr, ref_stride);

    else if (bw == 16 && bh == 8)

      return avm_highbd_sad16x8_12(src_ptr, source_stride, ref_ptr, ref_stride);

    else if (bw == 8 && bh == 16)

      return avm_highbd_sad8x16_12(src_ptr, source_stride, ref_ptr, ref_stride);

    else if (bw == 16 && bh == 16)

      return avm_highbd_sad16x16_12(src_ptr, source_stride, ref_ptr,

                                    ref_stride);

    else {

      assert(0);

      return 0;

    }

  } else {

    assert(0);

    return 0;

  }

}

// Build an 8x8 block in the TIP frame

static AVM_INLINE void tip_build_inter_predictors_8x8(

    const AV2_COMMON *cm, MACROBLOCKD *xd, int plane, BLOCK_SIZE unit_bsize,

    const MV mv[2], int mi_x, int mi_y, uint16_t **mc_buf,

    CONV_BUF_TYPE *tmp_conv_dst, CalcSubpelParamsFunc calc_subpel_params_func,

    uint16_t *dst, int dst_stride, uint16_t *dst0_16_refinemv,

    uint16_t *dst1_16_refinemv, ReferenceArea ref_area[2]) {

  // TODO(any): currently this only works for y plane

  assert(plane == 0);

  int bw = block_size_wide[unit_bsize];

  int bh = block_size_high[unit_bsize];

  const int bd = cm->seq_params.bit_depth;

  const int ss_x = plane ? cm->seq_params.subsampling_x : 0;

  const int ss_y = plane ? cm->seq_params.subsampling_y : 0;

  const int comp_pixel_x = (mi_x >> ss_x);

  const int comp_pixel_y = (mi_y >> ss_y);

  const int comp_bw = bw >> ss_x;

  const int comp_bh = bh >> ss_y;

  MB_MODE_INFO mbmi_buf;

  av2_zero(mbmi_buf);

  MB_MODE_INFO *mbmi = &mbmi_buf;

  int_mv mv_refined[2 * 4];

  memset(mv_refined, 0, 2 * 4 * sizeof(int_mv));

  CONV_BUF_TYPE *org_buf = xd->tmp_conv_dst;

  xd->tmp_conv_dst = tmp_conv_dst;

  mbmi->mv[0].as_mv = mv[0];

  mbmi->mv[1].as_mv = mv[1];

  mbmi->ref_frame[0] = TIP_FRAME;

  mbmi->ref_frame[1] = NONE_FRAME;

  mbmi->interp_fltr = cm->tip_interp_filter;

  mbmi->use_intrabc[xd->tree_type == CHROMA_PART] = 0;

  mbmi->use_intrabc[0] = 0;

  mbmi->motion_mode = SIMPLE_TRANSLATION;

  mbmi->sb_type[PLANE_TYPE_Y] = unit_bsize;

  mbmi->interinter_comp.type = COMPOUND_AVERAGE;

  mbmi->max_mv_precision = MV_PRECISION_ONE_EIGHTH_PEL;

  mbmi->pb_mv_precision = MV_PRECISION_ONE_EIGHTH_PEL;

  mbmi->morph_pred = 0;

  uint16_t *refinemv_ref0 = NULL;

  uint16_t *refinemv_ref1 = NULL;

  MV best_mv_ref[2] = { { mbmi->mv[0].as_mv.row, mbmi->mv[0].as_mv.col },

                        { mbmi->mv[1].as_mv.row, mbmi->mv[1].as_mv.col } };

  int apply_refinemv = (is_refinemv_allowed_tip_blocks(cm, mbmi) && plane == 0);

  assert(IMPLIES(bw > 16, !apply_refinemv));

  if (apply_refinemv) {

    uint16_t *dst_ref0 = NULL, *dst_ref1 = NULL;

    dst_ref0 = &dst0_16_refinemv[0];

    dst_ref1 = &dst1_16_refinemv[0];

    mbmi->refinemv_flag = 1;

    apply_mv_refinement(cm, xd, plane, mbmi, bw, bh, mi_x, mi_y, mc_buf, mv,

                        calc_subpel_params_func, comp_pixel_x, comp_pixel_y,

                        dst_ref0, dst_ref1, &refinemv_ref0, &refinemv_ref1,

                        best_mv_ref, bw, bh, ref_area);

    REFINEMV_SUBMB_INFO *refinemv_subinfo = &xd->refinemv_subinfo[0];

    fill_subblock_refine_mv(refinemv_subinfo, bw, bh, best_mv_ref[0],

                            best_mv_ref[1]);

  }

  if (plane == 0) {

    mv_refined[0].as_mv = convert_mv_to_1_16th_pel(&best_mv_ref[0]);

    mv_refined[1].as_mv = convert_mv_to_1_16th_pel(&best_mv_ref[1]);

  }

  // Arrays to hold optical flow offsets.

  int vxy_bufs[4 * 4] = { 0 };

  int *vx0 = vxy_bufs;

  int *vx1 = vxy_bufs + (4 * 1);

  int *vy0 = vxy_bufs + (4 * 2);

  int *vy1 = vxy_bufs + (4 * 3);

  // Pointers to gradient and dst buffers

  int16_t *gx0 = xd->opfl_gxy_bufs,

          *gy0 = xd->opfl_gxy_bufs + (MAX_SB_SQUARE * 1),

          *gx1 = xd->opfl_gxy_bufs + (MAX_SB_SQUARE * 2),

          *gy1 = xd->opfl_gxy_bufs + (MAX_SB_SQUARE * 3);

  uint16_t *dst0 = NULL, *dst1 = NULL;

  dst0 = xd->opfl_dst_bufs;

  dst1 = xd->opfl_dst_bufs + MAX_SB_SQUARE;

  int do_pred = 1;

  int opfl_dst_stride = bw;

  if (refinemv_ref0 != NULL && refinemv_ref1 != NULL) {

    dst0 = refinemv_ref0;

    dst1 = refinemv_ref1;

    opfl_dst_stride = REFINEMV_SUBBLOCK_WIDTH +

                      2 * (SUBBLK_REF_EXT_LINES + SMVR_SEARCH_EXT_LINES);

    do_pred = 0;

  }

  int do_opfl =

      is_optflow_refinement_enabled(cm, xd, mbmi, plane, 1 /* tip_ref_frame */);

  assert(IMPLIES(bw > 8, !do_opfl));

  const unsigned int sad_thres =

      cm->features.tip_frame_mode == TIP_FRAME_AS_OUTPUT ? 15 : 6;

  const int use_4x4 = 0;

  if (do_opfl) {

    if (do_pred) {

      assert(opfl_dst_stride == bw);

      InterPredParams params0, params1;

      av2_opfl_build_inter_predictor(cm, xd, plane, mbmi, bw, bh, mi_x, mi_y,

                                     mc_buf, &params0, calc_subpel_params_func,

                                     0, dst0, &best_mv_ref[0], bw, bh);

      av2_opfl_build_inter_predictor(cm, xd, plane, mbmi, bw, bh, mi_x, mi_y,

                                     mc_buf, &params1, calc_subpel_params_func,

                                     1, dst1, &best_mv_ref[1], bw, bh);

    }

    const unsigned int sad = get_highbd_sad(dst0, opfl_dst_stride, dst1,

                                            opfl_dst_stride, bd, bw, bh);

    if (sad < sad_thres) {

      do_opfl = 0;

    }

  }

  if (do_opfl) {

    // Initialize refined mv

    const MV mv0 = best_mv_ref[0];

    const MV mv1 = best_mv_ref[1];

    for (int mvi = 0; mvi < 4; mvi++) {

      mv_refined[mvi * 2].as_mv = mv0;

      mv_refined[mvi * 2 + 1].as_mv = mv1;

    }

    // Refine MV using optical flow. The final output MV will be in 1/16

    // precision.

    av2_get_optflow_based_mv(cm, xd, plane, mbmi, mv_refined, bw, bh, mi_x,

                             mi_y, 0 /* build_for_decode */, mc_buf,

                             calc_subpel_params_func, gx0, gy0, gx1, gy1, vx0,

                             vy0, vx1, vy1, dst0, dst1, opfl_dst_stride, 0,

                             use_4x4, best_mv_ref, bw, bh);

    xd->opfl_vxy_bufs[0] = *vx0;

    xd->opfl_vxy_bufs[N_OF_OFFSETS * 1] = *vx1;

    xd->opfl_vxy_bufs[N_OF_OFFSETS * 2] = *vy0;

    xd->opfl_vxy_bufs[N_OF_OFFSETS * 3] = *vy1;

  }

  if (plane == 0) {

    xd->mv_refined[0] = mv_refined[0];

    xd->mv_refined[1] = mv_refined[1];

  }

  BacpBlockData bacp_block_data[2 * N_OF_OFFSETS];

  const struct scale_factors *const sf0 = cm->tip_ref.ref_scale_factor[0];

  const struct scale_factors *const sf1 = cm->tip_ref.ref_scale_factor[1];

  uint8_t use_bacp = cm->features.enable_imp_msk_bld && !av2_is_scaled(sf0) &&

                     !av2_is_scaled(sf1);

  for (int ref = 0; ref < 2; ++ref) {

    const struct scale_factors *const sf = cm->tip_ref.ref_scale_factor[ref];

    struct buf_2d *const pred_buf = &xd->plane[plane].pre[ref];

    InterPredParams inter_pred_params;

    av2_init_inter_params(&inter_pred_params, comp_bw, comp_bh, comp_pixel_y,

                          comp_pixel_x, ss_x, ss_y, bd, 0, sf, pred_buf,

                          cm->tip_interp_filter);

    if (apply_refinemv || do_opfl) {

      inter_pred_params.use_ref_padding = 1;

      inter_pred_params.ref_area = &ref_area[ref];

    }

    inter_pred_params.comp_mode = UNIFORM_COMP;

    inter_pred_params.border_data.enable_bacp = use_bacp;

    inter_pred_params.border_data.bacp_block_data =

        &bacp_block_data[0];  // Always point to the first ref

    inter_pred_params.sb_type = mbmi->sb_type[PLANE_TYPE_Y];

    inter_pred_params.mask_comp = mbmi->interinter_comp;

    inter_pred_params.conv_params =

        get_conv_params_no_round(ref, plane, tmp_conv_dst, MAX_SB_SIZE, 1, bd);

    if (do_opfl) {

      av2_opfl_rebuild_inter_predictor(

          dst, dst_stride, plane, mv_refined, &inter_pred_params, xd, mi_x,

          mi_y, 0 /* build_for_decode */, cm, bw, ref, mc_buf,

          calc_subpel_params_func, use_4x4, mbmi, bh, mv, 0);

    } else {

      const MV mv_1_16th_pel = convert_mv_to_1_16th_pel(&best_mv_ref[ref]);

      av2_build_one_inter_predictor(dst, dst_stride, &mv_1_16th_pel,

                                    &inter_pred_params, xd, mi_x, mi_y, ref,

                                    mc_buf, calc_subpel_params_func);

    }

  }

  xd->tmp_conv_dst = org_buf;

}

static AVM_INLINE void tip_build_inter_predictors_8x8_and_bigger(

    const AV2_COMMON *cm, MACROBLOCKD *xd, int plane, TIP_PLANE *tip_plane,

    const MV mv[2], int bw, int bh, int mi_x, int mi_y, uint16_t **mc_buf,

    CONV_BUF_TYPE *tmp_conv_dst, CalcSubpelParamsFunc calc_subpel_params_func) {

  TIP_PLANE *const tip = &tip_plane[plane];

  struct buf_2d *const dst_buf = &tip->dst;

  uint16_t *const dst = dst_buf->buf;

  BLOCK_SIZE unit_bsize = get_tip_bsize_from_bw_bh(bw, bh);

  int unit_bw = block_size_wide[unit_bsize];

  int unit_bh = block_size_high[unit_bsize];

  xd->tree_type = SHARED_PART;

  const int width = (cm->mi_params.mi_cols << MI_SIZE_LOG2);

  const int height = (cm->mi_params.mi_rows << MI_SIZE_LOG2);

  xd->mb_to_top_edge = -GET_MV_SUBPEL(mi_y);

  xd->mb_to_bottom_edge = GET_MV_SUBPEL(height - bh - mi_y);

  xd->mb_to_left_edge = -GET_MV_SUBPEL(mi_x);

  xd->mb_to_right_edge = GET_MV_SUBPEL(width - bw - mi_x);

  const int ss_x = plane ? cm->seq_params.subsampling_x : 0;

  const int ss_y = plane ? cm->seq_params.subsampling_y : 0;

  const int comp_pixel_x = (mi_x >> ss_x);

  const int comp_pixel_y = (mi_y >> ss_y);

  const int comp_bw = bw >> ss_x;

  const int comp_bh = bh >> ss_y;

  const int has_both_sides_refs = cm->has_both_sides_refs;

  const int tip_wtd_index = cm->tip_global_wtd_index;

  const int8_t tip_weight = tip_weighting_factors[tip_wtd_index];

  const int is_compound = tip_weight != TIP_SINGLE_WTD;

  uint16_t

      dst0_16_refinemv[2 *

                       (REFINEMV_SUBBLOCK_WIDTH +

                        2 * (SUBBLK_REF_EXT_LINES + SMVR_SEARCH_EXT_LINES)) *

                       (REFINEMV_SUBBLOCK_HEIGHT +

                        2 * (SUBBLK_REF_EXT_LINES + SMVR_SEARCH_EXT_LINES))];

  uint16_t

      dst1_16_refinemv[2 *

                       (REFINEMV_SUBBLOCK_WIDTH +

                        2 * (SUBBLK_REF_EXT_LINES + SMVR_SEARCH_EXT_LINES)) *

                       (REFINEMV_SUBBLOCK_HEIGHT +

                        2 * (SUBBLK_REF_EXT_LINES + SMVR_SEARCH_EXT_LINES))];

  const int apply_refinemv =

      (cm->seq_params.enable_refinemv && cm->seq_params.enable_tip_refinemv &&

       plane == 0 && has_both_sides_refs && is_compound &&

       tip_weight == TIP_EQUAL_WTD);

  ReferenceArea ref_area[2];

  const int do_opfl = cm->features.opfl_refine_type != REFINE_NONE &&

                      cm->seq_params.enable_tip_refinemv &&

                      cm->features.use_optflow_tip && plane == 0;

  int is_tip_mv_refine_disabled_for_unit_size_16x16 =

      is_tip_mv_refinement_disabled_for_unit_size_16x16(

          unit_bh, cm->seq_params.enable_tip_refinemv,

          cm->features.tip_frame_mode);

  const int do_ref_area_pad = cm->seq_params.enable_tip_refinemv &&

                              cm->has_both_sides_refs &&

                              !is_tip_mv_refine_disabled_for_unit_size_16x16;

  if (do_ref_area_pad) {

    MB_MODE_INFO *mbmi = avm_calloc(1, sizeof(*mbmi));

    mbmi->mv[0].as_mv = mv[0];

    mbmi->mv[1].as_mv = mv[1];

    mbmi->ref_frame[0] = TIP_FRAME;

    mbmi->ref_frame[1] = NONE_FRAME;

    mbmi->interp_fltr = EIGHTTAP_REGULAR;

    mbmi->use_intrabc[xd->tree_type == CHROMA_PART] = 0;

    mbmi->use_intrabc[0] = 0;

    mbmi->morph_pred = 0;

    mbmi->motion_mode = SIMPLE_TRANSLATION;

    mbmi->sb_type[PLANE_TYPE_Y] = unit_bsize;

    mbmi->interinter_comp.type = COMPOUND_AVERAGE;

    mbmi->max_mv_precision = MV_PRECISION_ONE_EIGHTH_PEL;

    mbmi->pb_mv_precision = MV_PRECISION_ONE_EIGHTH_PEL;

    const int mi_row = -xd->mb_to_top_edge >> MI_SUBPEL_SIZE_LOG2;

    const int mi_col = -xd->mb_to_left_edge >> MI_SUBPEL_SIZE_LOG2;

    mbmi->chroma_ref_info.mi_row_chroma_base = mi_row;

    mbmi->chroma_ref_info.mi_col_chroma_base = mi_col;

    av2_get_reference_area_with_padding(cm, xd, plane, mbmi, mv, comp_bw,

                                        comp_bh, mi_x, mi_y, ref_area, comp_bw,

                                        comp_bh);

    avm_free(mbmi);

  }

  int dst_stride = dst_buf->stride;

  if (plane == 0 && !is_tip_mv_refine_disabled_for_unit_size_16x16 &&

      is_any_mv_refinement_allowed_in_tip(cm) && is_compound &&

      tip_weight == TIP_EQUAL_WTD && (do_opfl || apply_refinemv)) {

    if (bw != unit_bw || bh != unit_bh) {

      for (int h = 0; h < bh; h += unit_bh) {

        for (int w = 0; w < bw; w += unit_bw) {

          dst_buf->buf = dst + h * dst_stride + w;

          tip_build_inter_predictors_8x8_and_bigger(

              cm, xd, plane, tip_plane, mv, unit_bw, unit_bh, mi_x + w,

              mi_y + h, mc_buf, tmp_conv_dst, calc_subpel_params_func);

        }

      }

      dst_buf->buf = dst;

      return;

    }

    tip_build_inter_predictors_8x8(

        cm, xd, plane, unit_bsize, mv, mi_x, mi_y, mc_buf, tmp_conv_dst,

        calc_subpel_params_func, dst, dst_stride, dst0_16_refinemv,

        dst1_16_refinemv, ref_area);

    return;

  }

  const int bd = cm->seq_params.bit_depth;

  if (plane == 0) {

    xd->mv_refined[0].as_mv = convert_mv_to_1_16th_pel(&mv[0]);

    xd->mv_refined[1].as_mv = convert_mv_to_1_16th_pel(&mv[1]);

  }

  BacpBlockData bacp_block_data[2 * N_OF_OFFSETS];

  const struct scale_factors *const sf0 = cm->tip_ref.ref_scale_factor[0];

  const struct scale_factors *const sf1 = cm->tip_ref.ref_scale_factor[1];

  uint8_t use_bacp = is_compound && tip_weight == TIP_EQUAL_WTD &&

                     cm->features.enable_imp_msk_bld && !av2_is_scaled(sf0) &&

                     !av2_is_scaled(sf1);

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

    const struct scale_factors *const sf = cm->tip_ref.ref_scale_factor[ref];

    struct buf_2d *const pred_buf = &xd->plane[plane].pre[ref];

    InterPredParams inter_pred_params;

    av2_init_inter_params(&inter_pred_params, comp_bw, comp_bh, comp_pixel_y,

                          comp_pixel_x, ss_x, ss_y, bd, 0, sf, pred_buf,

                          cm->tip_interp_filter);

    if (is_compound) {

      inter_pred_params.comp_mode = UNIFORM_COMP;

    }

    inter_pred_params.border_data.enable_bacp = use_bacp;

    inter_pred_params.border_data.bacp_block_data =

        &bacp_block_data[0];  // Always point to the first ref

    inter_pred_params.sb_type = unit_bsize;

    if (is_compound) {

      inter_pred_params.mask_comp.type = COMPOUND_AVERAGE;

    }

    inter_pred_params.conv_params = get_conv_params_no_round(

        ref, plane, tmp_conv_dst, MAX_SB_SIZE, is_compound, bd);

    set_tip_interp_weight_factor(cm, ref, &inter_pred_params);

    if (do_ref_area_pad) {

      inter_pred_params.use_ref_padding = 1;

      inter_pred_params.ref_area = &ref_area[ref];

    }

    const MV mv_1_16th_pel =

        plane ? xd->mv_refined[ref].as_mv : convert_mv_to_1_16th_pel(&mv[ref]);

    av2_build_one_inter_predictor(dst, dst_buf->stride, &mv_1_16th_pel,

                                  &inter_pred_params, xd, mi_x, mi_y, ref,

                                  mc_buf, calc_subpel_params_func);

  }

}

static AVM_INLINE void tip_component_build_inter_predictors(

    const AV2_COMMON *cm, MACROBLOCKD *xd, int plane, TIP_PLANE *tip_plane,

    const MV mv[2], int bw, int bh, int mi_x, int mi_y, uint16_t **mc_buf,

    CONV_BUF_TYPE *tmp_conv_dst, CalcSubpelParamsFunc calc_subpel_params_func) {

  tip_build_inter_predictors_8x8_and_bigger(

      cm, xd, plane, tip_plane, mv, bw, bh, mi_x, mi_y, mc_buf, tmp_conv_dst,

      calc_subpel_params_func);

}

static INLINE void tip_setup_pred_plane(struct buf_2d *dst, uint16_t *src,

                                        int width, int height, int crop_width,

                                        int crop_height, int stride,

                                        int tpl_row, int tpl_col,

                                        const struct scale_factors *scale,

                                        int subsampling_x, int subsampling_y) {

  const int x = tpl_col >> subsampling_x;

  const int y = tpl_row >> subsampling_y;

  dst->buf = src + scaled_buffer_offset(x, y, stride, scale);

  dst->buf0 = src;

  dst->width = width;

  dst->height = height;

  dst->crop_width = crop_width;

  dst->crop_height = crop_height;

  dst->stride = stride;

}

static AVM_INLINE void tip_component_setup_dst_planes(

    AV2_COMMON *const cm, TIP_PLANE *const tip_plane, const int plane,

    const int tpl_row, const int tpl_col) {

  const YV12_BUFFER_CONFIG *src = &cm->tip_ref.tip_frame->buf;

  TIP_PLANE *const pd = &tip_plane[plane];

  int is_uv = 0;

  int subsampling_x = 0;

  int subsampling_y = 0;

  if (plane > 0) {

    is_uv = 1;

    subsampling_x = cm->seq_params.subsampling_x;

    subsampling_y = cm->seq_params.subsampling_y;

  }

  tip_setup_pred_plane(&pd->dst, src->buffers[plane], src->widths[is_uv],

                       src->heights[is_uv], src->crop_widths[is_uv],

                       src->crop_heights[is_uv], src->strides[is_uv], tpl_row,

                       tpl_col, NULL, subsampling_x, subsampling_y);

}

void av2_tip_setup_tip_frame_row(AV2_COMMON *cm, MACROBLOCKD *xd, int blk_row,

                                 int blk_col_start, int blk_row_end,

                                 int blk_col_end, int mvs_stride,

                                 int unit_blk_size, int max_allow_blk_size,

                                 uint16_t **mc_buf, CONV_BUF_TYPE *tmp_conv_dst,

                                 CalcSubpelParamsFunc calc_subpel_params_func,

                                 int copy_refined_mvs) {

  TIP *tip_ref = &cm->tip_ref;

  const TPL_MV_REF *tpl_mvs_base = cm->tpl_mvs;

  int enable_tip_refinemv = cm->seq_params.enable_tip_refinemv;

  MV zero_mv[2];

  memset(zero_mv, 0, sizeof(zero_mv));

  const int step = (unit_blk_size >> TMVP_MI_SZ_LOG2);

  for (int blk_col = blk_col_start; blk_col < blk_col_end; blk_col += step) {

    const int tpl_offset = blk_row * mvs_stride;

    const TPL_MV_REF *tpl_mvs = tpl_mvs_base + tpl_offset;

    const int tpl_row = blk_row << TMVP_MI_SZ_LOG2;

    const int tpl_col = blk_col << TMVP_MI_SZ_LOG2;

    int blk_width = unit_blk_size;

    int blk_height = unit_blk_size;

    if (is_tip_mv_refinement_disabled_for_unit_size_16x16(

            unit_blk_size, enable_tip_refinemv, cm->features.tip_frame_mode)) {

      blk_width = get_tip_block_width_with_same_mv(

          cm, tpl_mvs, unit_blk_size, blk_col, blk_col_end, max_allow_blk_size);

    }

    tpl_mvs = tpl_mvs + blk_col;

    MV mv[2];

    if (tpl_mvs->mfmv0.as_int != 0 && tpl_mvs->mfmv0.as_int != INVALID_MV) {

      tip_get_mv_projection(&mv[0], tpl_mvs->mfmv0.as_mv,

                            tip_ref->ref_frames_offset_sf[0]);

      tip_get_mv_projection(&mv[1], tpl_mvs->mfmv0.as_mv,

                            tip_ref->ref_frames_offset_sf[1]);

      mv[0].row = (MV_COMP_DATA_TYPE)clamp(

          mv[0].row + cm->tip_global_motion.as_mv.row, MV_LOW + 1, MV_UPP - 1);