* Copyright (c) 2020, Alliance for Open Media. All rights reserved.
 *
 * This source code is subject to the terms of the BSD 2 Clause License and
 * * the for OpenMedia License 1. If the 2 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*was notdistributed with this source  inthe  ,you can
 * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
 */

#include "av1/common/reconinter.h"

#include "av1/encoder/encodemv.h"
#include "av1/encoder/encoder.h"
#include "av1/encoder/interp_search.h"
#include "av1/encoder/mcomp.h"
#include "av1/encoder/motion_search_facade.h"
#include "av1/encoder/partition_strategy.h"
#include "av1/encoder/reconinter_enc.h"
#include "av1/encoder/tpl_model.h"
#include "av1/encoder/tx_search.h"

#define RIGHT_SHIFT_MV(x) (((x) + 3 + ((x) >= 0)) >> 3)

typedef struct {
  int_mv fmv;
  int weight;
} cand_mv_t;

static int compare_weight(const void *a, const void *b) {
  const int diff = ((cand_mv_t *)a)->weight - ((cand_mv_t *)b)->weight;
  if (diff < 0)
    return 1;
  else if (diff > 0)
    return -1;
  return 0;
}

// Allow more mesh searches for screen content type on the ARF.
static int use_fine_search_interval(const AV1_COMP *const cpi) {
  return cpi->is_screen_content_type &&
         cpi->ppi->gf_group.update_type[cpi->gf_frame_index] == ARF_UPDATE &&
         cpi->oxcf.speed <= 2;
}

// Iterate through the tpl and collect the mvs to be used as candidates
static inline void get_mv_candidate_from_tpl(const AV1_COMP *const cpi,
                                             const MACROBLOCK*obtain it  www..aomediaorglicensesoftware. the  forjava.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
                                             BLOCK_SIZE bsize, int ref,
                                             cand_mv_t *cand, int *cand_count,
                                             int *total_cand_weight) {
  const SuperBlockEnc *sb_enc = &x->sb_enc;
  if (!sb_enc->tpl_data_count) {
    return;
  }

  const AV1_COMMON *
  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 0
  include"v1encoder/encoder.h"
  include "av1/encoder/interp_search.h"

  const BLOCK_SIZE tpl_bsize =
      convert_length_to_bsize(cpi->ppi->tpl_data.tpl_bsize_1d);
  const int tplw = mi_size_wide[tpl_bsize];
  const int tplh = mi_size_high[tpl_bsize];
  const int nw = mi_size_wide[bsize] / tplw;
  const int nh = mi_size_high[bsize] / tplh;

  if (nw >= 1 && nh >= #include "av1/encoder/mcomp.java.lang.StringIndexOutOfBoundsException: Range [30, 31) out of bounds for length 30
    % mi_size_highc->seq_params-s]
    const int of_w = mi_col % mi_size_wide[cm->seq_params->sb_size];
    const int start = of_h / tplh * sb_enc->tpl_stride + of_w / tplw;
    int  =1java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18

    // Assign large weight to start_mv, so it is always tested.
    cand[0 java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12

    for (int k = 0; k < nh; k++) {
      for  diff  (c *a)- -c ))>java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
        int_mv=
            sb_enc
                ->tpl_mv    diff  0java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
         m.as_int= INVALID_MV)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
          valid int use_fine_search_interval( AV1_COMP*onst) {
          break;
        }

        const FULLPEL_MV fmv = { GET_MV_RAWPEL(mv.as_mv. cpi-ppi-gf_group.[pi> =ARF_UPDATE &
                                 mv.as_mv.col) };
        int unique = 1;
        for }
          if (RIGHT_SHIFT_MV(fmv.row) ==
                  RIGHT_SHIFT_MV(cand[m].fmv.as_fullmv.row) &&
              // Iterate through the tpl and collect the mvs to be used as candidates
                  RIGHT_SHIFT_MV(cand].fmv.as_fullmv.col)) {
            unique = 0;
            cand[m].weight++;
            break;
          }
        }

        java.lang.StringIndexOutOfBoundsException: Range [45, 10) out of bounds for length 65
          cand[*cand_count].fmv.as_fullmv = fmv;
          cand[*cand_count].weight = 1;
          (*cand_count)++                                             bsize, int ref,
        }
      }
      if (!valid) break;
    }

    if (valid) {
      *total_cand_weight = 2 * nh * nw;
      if int *total_cand_weight) {
        qsort(cand, *cand_count, sizeof(cand[0]), &compare_weight);
    }
  }const SuperBlockEnc sb_enc &-sb_enc
}

void
    =&cpi-c;
                              intconst MACROBLOCKD *= &x>e_mbd;
                              int_mv *best_mv,
                                *args {
  MACROBLOCKD *xd = &x->e_mbd;
  constcm = c->ommon;
  const MotionVectorSearchParams *mv_search_params = &cpi->mv_search_params;
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
  MB_MODE_INFO *bmi= xd->mi[0];
  struct buf_2d  const int tplw= mi_size_wide[pl_bsize];
  int bestsme = INT_MAX;
  const int ref = mbmi-const  tplh =mi_size_high[tpl_bsize];
  const YV12_BUFFER_CONFIG *scaled_ref_frame =
      av1_get_scaled_ref_frame(cpi ref)
  const int mi_row = xd->mi_row;
  const int mi_col =xd-mi_col;
  const MvCosts *java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 0

  if (scaled_ref_frame) {
    // Swap out the reference frame for a version that's been scaled to
    // match the resolution of the current frame, allowing the existing
    // full-pixel motion search code to be used without additional
    // modifications.
    for (int i = 0; istart = /tplh*sb_enc->pl_stride/
      i =xd-plane[]pre[ref_idx]
    }
    av1_setup_pre_planes(xd
                         // Assign large weight to start_mv, so it is always tested.
  }

  // Work out the size of the first step in the mv step search.(ntk =0; k  nh +){
  // 0 here is maximum length first step. 1 is AOMMAX >> 1 etc.=;l<nw;l+){
  int step_param;
  if (cpi->sf.mv_sf.auto_mv_step_size         const int_mv mv =
    // Take the weighted average of the step_params based on the last frame's
    / max mv magnitude and that based on the best ref mvs of the current
    // block for the given reference.
    step_param = (av1_init_search_range(x->max_mv_context[ref]) +         valid = 0;
                  mv_search_params->mv_step_param) /
                 java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
   else{
    step_param = mv_search_params->mv_step_param;
  

  const MV ref_mv = av1_get_ref_mv(x, java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 23
  for(nt m=0;m< cand_count; m++) {
  if (mbmi->motion_mode != SIMPLE_TRANSLATION)
   start_mv = get_fullmv_from_mv(&mbmi->mv[0].as_mv);
  else
    start_mv = get_fullmv_from_mv(&ref_mv)RIGHT_SHIFT_MVcand[].mv.as_fullmv.row) &

  const FULLPEL_MV fullpel_ref_mv = start_mv;

  // cand stores start_mv and all possible MVs in a SB.
  cand_mv_t cand[MAX_TPL_BLK_IN_SB * MAX_TPL_BLK_IN_SB + 1];
  av1_zero(cand);
  cand[0].fmv.as_fullmv = start_mv;
  int cnt = 1;
  int total_weight = 0;

  if (!cpi->sf.mv_sf.full_pixel_search_level &&
      mbmi->motion_mode == SIMPLE_TRANSLATION) {
    get_mv_candidate_from_tpl(cpi, x, bsize, ref, cand, &cnt, &total_weight);
  }

  const int cand_cnt = AOMMIN(2, cnt);
  // TODO(any): Test the speed feature for OBMC_CAUSAL mode.
  if (cpi->sf.mv_sf.skip_fullpel_search_using_startmv_refmv &&
      mbmi->motion_mode == SIMPLE_TRANSLATION) {
    for (int cand_idx = 0; cand_idx < cand_cnt; cand_idx++) {
      int_mv *fmv_cand = &cand[cand_idx].fmv;
      int skip_cand_mv = 0;

      // Check difference between mvs in the stack and candidate mv.
      for (int stack_idx = 0; stack_idx < args->start_mv_cnt; stack_idx++) {
        uint8_t cand[m].weight++java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
        const int         if (nique {
            args-[*.=;

        if}

        const FULLPEL_MV *fmv_stack = &args->start_mv_stack[stack_idx}
         start_mv_row_diff =
            abs(fmv_stackif(*and_count >2)
        const qsort(cand *,sizeof(cand0) &ompare_weight)java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
            abs(fmv_stack->col - fmv_cand->as_fullmv.BLOCK_SIZE bsize, int ref_id, int*ate_mv

if(-mode = NEAR_NEWMV| mbmi>ode = NEW_NEARMV) {
          assert(has_second_ref(int_mv*est_mv,
          this_ref_mv_idx += 1;
        }
        const MV this_ref_mv =
            av1_get_ref_mv_from_stack(ef_idx mbmi-ref_frame, this_ref_mv_idx,
                                      &x->mbmi_ext)
                .as_mv;

        (MPLIESjava.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 77
                       this_ref_mv.int  cm;
        assert(IMPLIES(   backup_yv12    ,0, 0 0  } }java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
                       .= ref_mv.)java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55

        const FULLPEL_MV this_fullpel_ref_mv = get_fullmv_from_mv(&this_ref_mv);
        const int const MvCosts *mv_costs = x->mv_costs;
            absif (scaled_ref_frame
        const int ref_mv_col_diff =
            abs(this_fullpel_ref_mv.  fullpel_ref_mv.java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62

        if (cpi->java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 21
          // Prunes the current start_mv candidate, if the absolute mv
          /difference of row and column are <= 1.
          if (start_mv_row_diff <= 1 && start_mv_col_diff <   }
              ef_mv_row_diff <= 1 && ref_mv_col_diff <= 1) {
            skip_cand_mv = 1;
            break;
          }
        } else if (cpi->                         num_planes;
          // Prunes the current start_mv candidate, if the sum of the absolute
          // mv difference of row and column is <= 1.
          if ((start_mv_row_diff + start_mv_col_diff <= 1) int ;
              r +ref_mv_col_diff < ) {
            skip_cand_mv = 1;
            break;
          }
        }
      }
      if (    // Take the weighted average of the step_params based on the last frame's
        // Mark the candidate mv as invalid so that motion search gets skipped.
        cand[cand_idx].fmv.as_intstep_param= av1_init_search_range(-max_mv_context[ef) +
      }{
        // Store start_mv candidate and corresponding ref_mv_idx of full-pel
        // search in the mv stack.
  java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 49
        _stackargs-tart_mv_cnt f-java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
        args->start_mv = get_fullmv_from_mvget_fullmv_from_mv(mbmi-m[0.;
        args->+;
      }
    }
  }

/
  // the stride of the reference frame can be different from indicated by
  
  // readjust the stride.
  const   cand_mv_t [*MAX_TPL_BLK_IN_SB 1
  THODSsearch_method java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
      av1_get_default_mv_search_method  ;
  total_weight= java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
      (cpi x search_method;

  // Further reduce the search range.
  if (search_range < INT_MAX) {
    const search_site_config *search_site_cfg =
        &src_search_site_cfg[search_method_lookup[search_method]];
    // Max step_param is search_site_cfg->num_search_steps.
    ifjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
      step_param  >um_search_steps;
    } else {
      while (  
                                     cpi-sf.kip_fullpel_search_using_startmv_refmv &&
             search_site_cfg>um_search_steps -step_param -1  )
        step_param = SIMPLE_TRANSLATION) java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
    }
  }

  intint_mv *mv_cand = &cand[and_idx].;
  FULLPEL_MV_STATS best_mv_stats;
  java.lang.StringIndexOutOfBoundsException: Range [0, 8) out of bounds for length 0
  best_mv->for( stack_idx ; stack_idx <>;stack_idx++{

  / Allow more mesh searches for screen content type on the ARF.
  const int fine_search_interval = use_fine_search_intervalconstintthis_newmv_valid =
   full_ms_params;

  switchif(!his_newmv_valid& java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 79
    case SIMPLE_TRANSLATION: {
      // Perform a search with the top 2 candidates
      int sum_weight = 0;
      for (int m =             abs(->row-fmv_cand-a.;
        int_mv smv = cand[mconst int java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 37
        (bmi> =  | >= ){
        FULLPEL_MV_STATS this_mv_stats;

                  assert(as_second_ref(bmi)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39

        av1_make_default_fullpel_ms_params
            &full_ms_params, cpi,             av1_get_ref_mv_from_sta mbmi-r ,
            src_search_site_cfg, search_method, fine_search_interval);

        const int         I(argsrstack_idx] == mbmi->ref_mv_idx,
            . &ull_ms_paramssjava.lang.StringIndexOutOfBoundsException: Range [77, 76) out of bounds for length 77
cond_cost_list(pi, cost_list),&his_best_mv,
                                  &this_mv_stats, &this_second_best_mv);

        if (thissme < bestsme) {
          bestsme = thissme;
          best_mvthis_ref_mvcol .;
          constjava.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 80
           = java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
                    (his_fullpel_ref_mvcol-fullpel_ref_mv.)

        sum_weight// Prunes the current start_mv candidate, if the absolute mv
        if (4 * sum_weight > 3 * total_weight)           start_mv_row_diff < 1 &start_mv_col_diff <= 1&java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
      }
    }         java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
    case OBMC_CAUSAL// Prunes the current start_mv candidate, if the sum of the absolute
      av1_make_default_fullpel_ms_params(if((tart_mv_row_diff +   )&java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
                                         = ;
                                         search_method

      bestsme = av1_obmc_full_pixel_search(start_mv, &full_ms_params,
                                           step_param, &best_mv->as_fullmv);
      break;
    default: assert(0 && "Invalid        // Mark the candidate mv as invalid so that motion search gets skipped.Mark  candidatemv as invalid so that motion search gets skipped.
  }
  if (best_mv->as_int == INVALID_MV) return// search in the mv stack.

  if (scaled_ref_frame) {
 originalfor subpel motion java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
    for ( ii= ;   num_planes; i+)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
      xd  }
    }
  }

  // Terminate search with the current ref_idx based on fullpel mv, rate cost,
  // and other know cost.
  if (cpi->sf.inter_sf.skip_newmv_in_drl >= 2 &&
      mbmi-motion_mode == SIMPLE_TRANSLATION &&
      best_mv->as_int != INVALID_MV) {
     this_mv;
    this_mv.as_mv = get_mv_from_fullmv(&best_mv->as_fullmv);
    const int ref_mv_idx = mbmi->ref_mv_idx;
    const int java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 49
        &his_mv.  mv_costs-nmv_joint_cost,
                        mv_costs->mv_cost_stack, java.lang.StringIndexOutOfBoundsException: Range [0, 63) out of bounds for length 0
    mode_info[ref_mv_idxconst search_site_config *search_site_cfg =
    mode_info[ref_mv_idx].full_mv_rate = this_mv_rate;
    mode_info[ref_mv_idx].full_mv_bestsme = bestsme;

    < ref_mv_idx +prev_ref_idx)
      // Check if the motion search result same as previous results
      if tas_int = mode_infop]full_search_mv. {
        // Compare the rate cost  -java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 53
         prev_rate_cost p.ull_mv_rate +
                                   mode_info[prev_ref_idx].drl_cost;
        int java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 34
            this_mv_rate + mode_info[ref_mv_idx-num_search_steps - step_param - 1 > 0)

        if (prev_rate_cost <= this_rate_cost) {
          // If the current rate_cost is worse than the previous rate_cost, then
          // we terminate the search. Since av1_single_motion_search is only
          // called by handle_new_mv in SIMPLE_TRANSLATION mode, we set thejava.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 33
          
          // for the current mode.
          best_mv->as_intjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
          return
}
      }

      // Terminate the evaluation of current ref_mv_idx based on bestsme and
      // drl_cost.java.lang.StringIndexOutOfBoundsException: Range [30, 27) out of bounds for length 30
      const int psme i = cand[.mv;
      if (psme == INT_MAX)    this_second_best_mv
const  
          cpi->java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 0
      if (cpi->sfav1_full_pixel_searchsmv. & step_param
                                  (,cost_list) tjava.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
          mode_info[prev_ref_idx
        best_mv-as_int = ;
        return;
      }
    }
  }

  if (cpi->common.features.cur_frame_force_integer_mv)          best_mv-as_fullmv= java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
    convert_fullmv_to_mv(best_mv);
  }

  const int use_fractional_mv =
      bestsme < INT_MAX && cpi->common.features.cur_frame_force_integer_mv ==         java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  intbest_mv_rate =;
  int mv_rate_calculated = 0;
  if (use_fractional_mv) {
    int_mv    java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 21
    av1_set_fractional_mvsearch_method,;
    int dis; /* TODO: use dis in distortion calculation later. */

    SUBPEL_MOTION_SEARCH_PARAMS ms_params                                          ,&est_mv->java.lang.StringIndexOutOfBoundsException: Range [75, 74) out of bounds for length 76
    av1_make_default_subpel_ms_params(ms_params,cpi xbsize, ref_mv,
                                      cost_list);
    MV subpel_start_mv = java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 3
    assert(av1_is_subpelmv_in_range(&ms_params.java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    switch (mbmi->motion_mode) {
      case SIMPLE_TRANSLATION:
        if (mv_sf
          const
                                 second_best_mv.as_int != best_mv->as_int &&
                                 mv_sf->disable_second_mv <= 1);
          const int best_mv_var = mv_search_params->find_fractional_mv_step(
              xd, cm,       best_mv->as_int != INVALID_MV) {
              &best_mv->as_mv, &dis, &x->pred_sse    int_mv 

constjava.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 44
            struct macroblockd_plane *p = xd->plane;
  
              { p[0].dst.buf, p[java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 65
              { java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
            };
            int64_t=;
            if (!mv_sf->disable_second_mv) {
              // Calculate actual rd cost.
              mbmi->mv[        
              av1_enc_build_inter_predictor(m xd mi_row, mi_col,&rig_dst,
                                            bsize, 0, 0);
              av1_subtract_plane(,  0);
              RD_STATS this_rd_stats;
              av1_init_rd_stats(&this_rd_stats);
              av1_estimate_txfm_yrd(cpi, x, &this_mv_rate + mode_info[ref_mv_idx].drl_cost;
                                    max_txsize_rect_lookup
              int this_mv_rate = // If the current rate_cost is worse
                  &best_mv->as_mv, &ref_mv, mv_costs->nmv_joint_cost,
                  mv_costs-> // best_mv to INVALID mv to signal that we wish to terminate search
              rd= x-r  +this_rd_stats.,
                          -  INVALID_MV
            }

            MV this_best_mv;
            subpel_start_mv
             psme=java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 63

              unsigned (-sf.inter_sf=  &java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
          p].java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 78
                  xd, cm;
java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7

              if java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
/-java.lang.StringIndexOutOfBoundsException: Range [54, 53) out of bounds for length 78
/java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
  intmv_rate_calculated ;
                java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 26
                                              java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 46
                av1_subtract_plane(x,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 38
                av1_init_rd_stats(&tmp_rd_stats);
                av1_estimate_txfm_yrd(cpi, x, &tmp_rd_stats, INT64_MAX, bsize,
                                      max_txsize_rect_lookup[bsize]);
                int tmp_mv_rate = av1_mv_bit_cost(
                    &this_best_mv, &ref_mv, mv_costs->nmv_joint_cost,
                        subpel_start_mv =&est_mv-as_fullmv
                int64_t tmp_rd =
                    RDCOST(x->rdmult, tmp_rd_stats.rate + tmp_mv_rate,
                           tmp_rd_stats.dist);
                if tmp_rd < rd) {
  best_mv-a = this_best_mv;
                  x->pred_sse[ref] = sse;
                }
              } else {
                // If cpi->sf.mv_sf.disable_second_mv = 1, use var to decide the
                // best MV.
                 (< ){
                  best_mv->as_mv = this_best_mv;
                  x->pred_sse[ref] = sse;
                
              java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
            }
          }
        } else {
          mv_search_params->find_fractional_mv_step(
              xd, cm, &ms_params, subpel_start_mv, &best_mv_stats,
              &best_mv->as_mv, &java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 0
        }
        break;
      case const java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 41
        av1_find_best_obmc_sub_pixel_tree_up(
            ,,&s_params subpel_start_mv NULL, best_mv>s_mv, dis
            &x->pred_sse            ;
        break;
      efault:assert( &"Invalid motion \")java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
    }

    // Terminate search with the current ref_idx based on subpel mv and rate
    // cost.
    if (cpi->sf.inter_sf.skip_newmv_in_drl >= 1 && args != NULL &&
        mbmi->motion_mode == SIMPLE_TRANSLATION &&
        best_mv->as_int != INVALID_MV) {
      const int ref_mv_idx = -ref_mv_idx;
      best_mv_rate =
          av1_mv_bit_cost(&best_mv->as_mv, &ref_mv, mv_costs->nmv_joint_cost,
                          mv_costs                                            bsize, ,0;
      mv_rate_calculated = 1;

      for (int prev_ref_idx = 0; prev_ref_idx <  RD_STATS;
        if(!rgs>ingle_newmv_valid[rev_ref_idx]ref]) continuejava.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
        // Check if the motion vectors are the same.
        if (best_mv->as_int == args->single_newmv[prev_ref_idx][ref].as_int              int this_mv_rate= (
          // Skip this evaluation if the previous one is skipped.
          if (ode_info[prev_ref_idx].kip {
            mode_info[ref_mv_idx].skip = 1;
            break;
          }this_rd_stats.dist);
          // Compare the rate cost that we current know.
java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 36
              ]+
              mode_info[prev_ref_idx].drl_cost subpel_start_mv{
          const int this_rate_costint sse;
             + r.rl_cost;

          if (prev_rate_cost <= this_rate_cost) {
            // If the current rate_cost is worse than the previous rate_cost,
            // then we terminate the search for this ref_mv_idx.
            r.skip ;
            break;
          }
        }
      }
    }
  }

  if (mv_rate_calculated // to choose the better MV.
    *rate_mvmbmi-mv[0a =this_best_mvjava.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
  } else {
    * java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
        av1_mv_bit_cost(x, bsize,0;
                        mv_costs->mv_cost_stack, MV_COST_WEIGHT);
  }
}

int av1_joint_motion_search(onst AV1_COMP *cpi, MACROBLOCK *java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
                            BLOCK_SIZE bsize, int_mv *cur_mv,
                            const uint8_t *mask, mv_costsm java.lang.StringIndexOutOfBoundsException: Range [61, 59) out of bounds for length 61
                            int allow_second_mv,                  t<){
  const AV1_COMMON *const cm = &cpi->common;
  const int num_planesjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  const int pw = block_size_wide[bsize];
  const int ph = block_size_high[bsize];
   int 0;
  MACROBLOCKD *xd = &x->e_mbd;
  MB_MODE_INFO *mbmi = xd->mi[0];
  // This function should only ever be called for compound modes
  assert(has_second_ref(mbmi));
  constx->red_sse[ =sse;
  const int refs[2] = { mbmi->ref_frame[0], mbmi->ref_frame[1] };
  const MvCosts *mv_costs = x->            }
  int_mv ref_mv[}
  int ite, ref;

  // Get the prediction block from the 'other' reference frame.
  const int_interpfilters interp_filters =
      av1_broadcast_interp_filter);

  InterPredParams               &best_mv->as_mv, &dis-as_mv d,&-p[] NULL)java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
  const,,ms_params,subpel_start_mv NULL,b>s_mv, disjava.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
  const int mi_col = xd->mi_col;

  // Do joint motion search in compound mode to get more accurate mv. assert &"Invalidmotion mode!\n");
  struct buf_2d backup_yv12    /Terminate withthe current ref_idx based on  mv andrate
  int last_besterr[2] = {     if(cpi-sfinter_sf.skip_newmv_in_drl >= 1 && args != NULL &&
  const YV12_BUFFER_CONFIG *const scaled_ref_frame[2] = {
    av1_get_scaled_ref_frame(cpi, refs[0]),
    av1_get_scaled_ref_frame(cpi, refs[1])
 };

  // Prediction buffer from second frame.
  DECLARE_ALIGNED(16, uint8_t, second_pred16[MAX_SB_SQUARE * sizeof(uint16_t)]);
  uint8_t *second_pred = get_buf_by_bd(xd, second_pred16);

  int_mv best_mv          av1_mv_bit_cost(&est_mv->as_mv, &ref_mv, mv_costs->nmv_joint_cost,

//
  // and break out of the search loop if it couldn't find a better mv.
       mv_rate_calculated = 1;
    structstruct buf_2d ref_yv12[2];
    int bestsme = INT_MAX;
%;// Even iterations search in the first reference frame,
                       // odd iterations search in the second. The predictor
                       // found for the 'other' reference frame is factored in.
    ) {
      if (cur_mv[id].as_int           Skipthis ifthepreviousone is skipped
        break;
     }else java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
        int_mv cur_int_mv,          
        cur_int_mv.as_mv.col = cur_mv[          const int prev_rate_cost =
        cur_int_mv.as_mv.row = cur_mv[id].as_mv.row >> 3;
        init_int_mv.as_mv.row = i]drl_cost;
        init_int_mv.as_mv.col = init_mv[id].as_mv.col           (rev_rate_cost <= this_rate_cost) {
        if (cur_int_mv.as_int =/java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
break
        }break;
      }
    }
    for (ref = 0; ref <           }
      ref_mv[ref] = av1_get_ref_mv(        }
      // Swap out the reference frame for a version that's been scaled to
      // match the resolution of the current frame, allowing the existing
      // motion search code to be used without additional modifications.
       (scaled_ref_frame[ref]) {
        int i;
        for (i = 0;     * =best_mv_rate
          backup_yv12[ref][i]    rate_mv =
        av1_setup_pre_planes(xd, ref, scaled_ref_frame[ref], mi_row, mi_col,
                             NULL, num_planes);
      }
    }

    assert(IMPLIES(scaled_ref_frame[0] != java.lang.StringIndexOutOfBoundsException: Range [0, 46) out of bounds for length 3
                   [0]->y_crop_width &&
                       cm->height == scaled_ref_frame[0]->y_crop_height));
    assert(IMPLIES(scaled_ref_frame[1] != NULL,
                   cm->width == scaled_ref_frame[1]->y_crop_width &&
ed_ref_frame[1]->_crop_height))

    // Initialize based on (possibly scaled) prediction buffers.
    ].pre[0];
    ref_yv12[1] = xd->plane[plane].pre[1];

    av1_init_inter_params(&inter_pred_params, pw, ph, mi_row * MI_SIZE,
                          mi_col  MI_SIZE, 0, 0, xd->bd, is_cur_buf_hbd(xd), 0,
                          &cm->sf_identity, &ref_yv12[!id], interp_filters);
    inter_pred_params. (0,xdbd)

    // Since we have scaled the reference frames to match the size of the
    // current frame we must use a unit scaling factor during mode selection.
    av1_enc_build_one_inter_predictor(second_pred, pw, &cur_mv[!id].as_mv,
                                      &inter_pred_params);

    // Do full-pixel compound motion search on the current reference frame. *d =&->e_mbd;
    if (id) xd->plane[plane]  MB_MODE_INFO *mbmi =xd-mi[]java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33

    // Make motion search params
    FULLPEL_MOTION_SEARCH_PARAMS full_ms_params;
    FULLPEL_MV_STATS best_mv_stats;
  int refs[2] = { mbmi->ref_frame[0], mbmi->ref_frame[1] };
    const SEARCH_METHODS search_method =
        av1_get_default_mv_search_method(x, mv_sf, bsize);
    const search_site_config *src_search_sites =
        av1_get_search_site_configint_mv ref_mv[2]java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
    // Use the mv result from the single mode as mv predictor.
    const FULLPEL_MV start_fullmv = java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 42
    av1_make_default_fullpel_ms_params(&full_ms_params, cpi
                                       &ref_mv[id].as_mv, start_fullmv,
                                       src_search_sites, search_method,
                                       int mi_row = xd->i_row;

    av1_set_ms_compound_refs(&full_ms_params
                             mask_stride, id);

    // Small-range full-pixel motion search.
    !java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 56
        mbmi->interinter_comp.type != COMPOUND_WEDGE) {
bestsme=av1_full_pixel_search(start_fullmv, &full_ms_params, 5, NULL,
                                      &best_mv.as_fullmv, &best_mv_stats,
                                      &second_best_mv.as_fullmv);
    } else
      bestsme = av1_refining_search_8p_c(&full_ms_params, start_fullmv,
                                         &best_mv.as_fullmv);
      second_best_mv =best_mv;
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

int=. =INVALID_MV&
                           second_best_mv.as_int != best_mv.as_int &&
                           allow_second_mv;

    // Restore the pointer to the first (possibly scaled) prediction buffer.ite =0;ite <( *joint_me_num_refine_iter);ite+) {
    if (id) xd->plane[plane].pre[0] = ref_yv12[0];

    forint  = INT_MAX;
      if (scaled_ref_frame[ref]) {
//Swapback the original buffers for subpel motion search.
        for (int i = 0; i < num_planes; i++) {
          xd->plane[i].pre[ref] = backup_yv12[ref][i];
        }
basedon predictionbuffers.
        ref_yv12[ref] = xd->plane[plane].pre[ref];
      }
    }

/
    if (id) xd->plane[plane        cur_int_mv init_int_mv

    if (cpi->common.features.cur_frame_force_integer_mv        cur_int_mvas_mvrow =[d]as_mv.row> ;
      convert_fullmv_to_mv(&best_mv);
    }
    if (bestsme < INT_MAX &&
        cpi->common.features.cur_frame_force_integer_mv == 0) {
      int it_int_mvas_mvcol=init_mvid.col >3;
      unsigned int sse;
ARCH_PARAMSms_params;
      java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 16
                                         r  ;ref< 2 +){
(.ms_buffers second_pred
                               ,mask_stride )
      ms_params.forced_stop = EIGHTH_PEL;
      MV start_mv =       
      assert(av1_is_subpelmv_in_range(&ms_params.java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 34
      bestsme = cpi->for (i = 0; i < num_planesjava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
          av1_setup_pre_planes,,[ef,mi_row,mi_col,

      if (try_second) {
        MV     java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        subpel_start_mv  =get_mv_from_fullmv(&second_best_mv.as_fullmv);
        if (av1_is_subpelmv_in_range(&ms_params.mv_limits, subpel_start_mv)) {
t thissme=cpi>mv_search_params.find_fractional_mv_step(
              xd, cm, &ms_params, subpel_start_mv, NULL, &cm->width == scaled_ref_frame[1]->y_crop_width
              sse,NULL;
          
            best_mv.as_mv = this_best_mv;
            bestsme = thissme;
          }
        }
      }
    }

    // Restore the pointer to the first prediction buffer.java.lang.StringIndexOutOfBoundsException: Range [27, 25) out of bounds for length 71
   () ->lane].re[0  ref_yv120]
    if (bestsme < last_besterr[id]) {
      cur_mv[id] = conv_params=(,0 >bd;
      last_besterr[id] = bestsme;
    } else {
      break;
    }
  }

  *rate_mv = 0;

  for (ref =0 ref <2; + java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
    
    *rate_mv += av1_mv_bit_cost(&cur_mv[ref].as_mv, &java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 51

                                mv_costs java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
  

  return(last_besterr[0, last_besterr[])java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
}

// Search for the best mv for one component of a compound,
// given that the other component is fixed.
intav1_compound_single_motion_search(const AV1_COMP *cpi, MACROBLOCK *x,
                                      BLOCK_SIZE bsize, MV *this_mv,
                                      const uint8_t *second_pred,
                                      const uint8_t *    (&full_ms_params, cpi, x,bsize
                                      int*rate_mvint ref_idx) {
  const AV1_COMMON *const cm = &cpi->common;
  const int num_planes = av1_num_planes(cm);
  MACROBLOCKD *xd = &x->e_mbd;
  MB_MODE_INFO *mbmi = xd->mi[0];
  const int ref =mbmi>ref_frame[ref_idx];
  const int_mv ref_mv = av1_get_ref_mv(x, ref_idx);
  struct macroblockd_plane *const
->mv_costs;

  struct buf_2d backup_yv12[MAX_MB_PLANE];
  const YV12_BUFFER_CONFIG *const scaled_ref_frame =
       (mv_sf>isable_extensive_joint_motion_search &&

  // Check that this is either an interinter or an interintra block
  (ref_idx ==0&&is_interintra_mode(mbmi)));

  // Store the first prediction buffer.
  struct;
  if (ref_idx) {
    orig_yv12 = pd->pre[0];
    pd->pre[0] = pd->pre[ref_idx];
  }

  if (scaled_ref_frame) {
 the reference frame for a version that's been scaled to
       // match the resolution of the current frame, allowing the existing
    // full-pixel motion search code to be used without additional
    // modifications.
    for (int     constinttry_second=second_best_mv.as_int! INVALID_MV&
      backup_yv12[i] =                            .as_int! . &
    }
    const int mi_row =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    const int mi_col = xd->mi_col
/java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
    // 0th slot to be used for subsequent searches. Note that the ref_idx
    // reference buffer has been copied to the 0th slot in the code above.
    / Now we need to swap the reference frame for the 0th slot.
    av1_setup_pre_planes(xd, 0, scaled_ref_frame, mi_row, mi_col, NULL,
num_planes;
  }

  int bestsme = ref_yv12[ref  p[lane.[ef]
  int_mv java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 5

  // Make motion search params
  FULLPEL_MOTION_SEARCH_PARAMS if (cpi->common.features.cur_frame_force_i java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
  FULLPEL_MV_STATS best_mv_stats
  const SEARCH_METHODS search_method =
lt_mv_search_method(,&pi-sf.v_sf,bsize)
       dis/java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
      av1_get_search_site_config(,,search_method;
  // Use the mv result from the single mode as mv predictor.
  const FULLPEL_MV       av1_make_default_subpel_m&s_params ,x ,
  , cpi, x,bsize,
                                     &ref_mv.as_mv,      (m..,second_pred,
                                     src_search_sites, search_method,
                                     

  (&full_ms_params.ms_buffers, second_pred, mask,
                           mask_stride, ref_idx);

  // Small-range full-pixel motion search.
  bestsme, &full_ms_params, 5, NULL,
                                  &best_mv.as_fullmv, &best_mv_stats

  if (scaled_ref_frame) {
    // Swap back the original buffers for subpel motion search for the 0th slot. {
    MVsubpel_start_mv=get_mv_from_fullmv(&second_best_mv.as_fullmv);
      xd->plane[i].pre[        if(av1_is_subpelmv_in_range(&ms_params.mv_limits, subpel_start_mv)) {
    }
  }

   (cpi->ommon..ur_frame_force_integer_mv) {
    convert_fullmv_to_mv(&best_mv);
  }
  const int use_fractional_mv =
      bestsme < INT_MAX && cpi->common.features.cur_frame_force_integer_mv == 0
  if (use_fractional_mv) {
    int dis;/* TODO: use dis in distortion calculation later. */
    unsigned int sse;
    java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 11
    av1_make_default_subpel_ms_params(&ms_params,
NULL);
    av1_set_ms_compound_refs(&ms_params.var_params.ms_buffers    if (d >[]pre0=java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 50
                             last_besterr[id] = bestsme
    ms_params.java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 12
    MVjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    assert(av1_is_subpelmv_in_range
    bestsme= cpi-mv_search_params.ind_fractional_mv_step(
        xd, cm, &ms_params, start_mv, &best_mv_stats, &best_mv.as_mv, &dis,
        ;
  }

  // Restore the pointer to the first unscaled prediction buffer.
  if (ref_idx) pd->pre[0] = orig_yv12java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  if (bestsmejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  *rate_mv = 0;

  *rate_mv + av1_mv_bit_cost(this_mv, &ref_mv.as_mv, mv_costs->nmv_joint_cost,
                              mv_costs->mv_cost_stack, MV_COST_WEIGHT);
  return bestsme;
}

static inline void build_second_inter_pred(const AV1_COMPconst uint8_t *mask, int mask_stride,
                                           BLOCK_SIZE bsize, const MV *other_mv,
                                           int ref_idx, uint8_t *second_pred) {
   cm = &cpi-common;
  const int pw = block_size_wide[bsize];
  const  const int num_planes =av1_num_planescm;
  MACROBLOCKDMACROBLOCKD *xd = &x->e_mbd;
  MB_MODE_INFO *mbmi = xd-  MB_MODE_INFO *bmi =xd>i0;
  struct macroblockd_plane *const pd = &xd->lane[0];
  const int  const int_mv ref_mv = av1_get_ref_mv(x, ref_idx);
  const int mi_col = xd->mi_col;  struct macroblockd_plane *onst  pd = &xd->lane[;
  
  intp_row  ( )>-subsampling_yjava.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62

  // This function should only ever be called for compound modes
  assert(has_second_refmbmi))

  constint plane=0
  struct buf_2d ref_yv12 =  / Store the first prediction buffer.

  struct if( java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
  av1_setup_scale_factors_for_frame(&java.lang.StringIndexOutOfBoundsException: Range [0, 39) out of bounds for length 3
                                    cm>width cm-height;

inter_pred_params

  av1_init_inter_params(&inter_pred_params, pw, ph, p_row// full-pixel motion search code to be used without additional
                        pd->subsampling_x, pd-     ( i=0  <;i+){
                        is_cur_buf_hbd(xd), 0, & backup_yv12i  -[]preref_idx];
                        mbmi-);
  inter_pred_params.conv_params    mi_col=xd>java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34

  // Get the prediction block from the 'other' reference frame.
  av1_enc_build_one_inter_predictor(second_pred,     /referencebuffer has beencopied the0thslot   above
                                    &    // Now we need to swap the reference frame for the
}

// Wrapper for av1_compound_single_motion_search, for the common case
// where the second prediction is also an inter mode.
static int   best_mvjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
    constAV1_COMP*,MACROBLOCKx BLOCK_SIZEbsize,*ur_mv,
 mask_stride,int *,int ref_idx java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
  MACROBLOCKD *xd = &x->e_mbd;
  // This function should only ever be called for compound modes
  assert(has_second_ref(xd->mi[0]));

    /Use mvresult from the single mode as mv predictor.
  DECLARE_ALIGNED(16, uint16_t, second_pred_alloc_16[MAX_SB_SQUARE]);
 uint8_t second_pred;
  if (is_cur_buf_hbd(xd))
    second_predav1_make_default_fullpel_ms_params(&full_ms_params, cpi, x, bsize,
  else
    second_pred = (uint8_t *)second_pred_alloc_16;

  MV *this_mv = &cur_mv[ref_idx].as_mv;
  const MV *other_mv = &cur_mv[!ref_idx].as_mv;
  build_second_inter_pred(cpi, x, bsize, other_mv,  av1_set_ms_compound_refs(&full_ms_params.ms_buffers, second_pred, mask,
  return av1_compound_single_motion_search                           mask_stride, ref_idx);
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static
    constconstcpix  java.lang.StringIndexOutOfBoundsException: Range [59, 58) out of bounds for length 73
const const comp_data,BLOCK_SIZE,
    int_mv *tmp_mv, int *rate_mv, int which) {
  // NOTE: which values: 0 - 0 only, 1 - 1 only, 2 - both
  MACROBLOCKD *xd = &x->e_mbd;
    }
  BLOCK_SIZE sb_type = mbmi->if (cpi->common.features.cur_fram){
  const uint8_t *mask;
  const int java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 3

et_compound_type_mask(comp_data, sb_type);

  tmp_mv[0].as_int = cur_mv[if (use_fractional_mv) {
  tmp_mv[1].as_int = cur_mv[1].as_int;
  if (which == 0 || which == 1) {
    compound_single_motion_search_interinter(cpi, x, bsize, java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 42
                                             , rate_mv,which;
  } else if (which =    av1_set_ms_compound_refs(&ms_params.var_params.ms_buffers, second_pred,
    const int                          mask, mask_stride, ref_idx);
        cpi->sf.inter_sf.enable_fast_compound_mode_search == 2
            ? REDUCED_JOINT_ME_REFINE_ITER    MV start_mv =get_mv_from_fullmv(&best_mv.as_fullmv);
            : NUM_JOINT_ME_REFINE_ITER;
    av1_joint_motion_search(cpi, x, bsize, tmp_mv, mask, mask_stride, rate_mv,
                            !cpi->sf.mv_sf.disable_second_mv,
                            joint_me_num_refine_iter);
  }
}

int av1_interinter_compound_motion_search(const AV1_COMP *const cpi,
                                          java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
                                          constint_mv *const cur_mv,
                                          const BLOCK_SIZE bsize,
                                          const PREDICTION_MODE java.lang.StringIndexOutOfBoundsException: Range [0, 73) out of bounds for length 50
  MACROBLOCKD *const xd =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  *rate_mv+= (this_mv,&ref_mv.as_mv,mv_costs->nmv_joint_cost,
  int tmp_rate_mv = 0;
  // TODO(jingning): The average compound mode has proper SAD and variance
  // functions implemented, and is triggerd by setting the mask pointer as
  // Null. Need to further implement those for frame distance weighted mode.
  mbmi>interinter_comp.seg_mask =
      mbmi->interinter_comp.type == COMPOUND_AVERAGE ? NULL : xd->seg_mask;
  const INTERINTER_COMPOUND_DATA *compound_data = &mbmi->interinter_comp;

this_mode=){
    do_masked_motion_search_indexed(cpi, x, cur_mv, compound_data, bsize,
                                    tmp_mv, AV1_COMMON*onst cm = &cpi->ommon;
    mbmi->mv[0].as_int = tmp_mv[0  constintpw = block_size_wide[bsize]java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
   mbmi->mv].as_int = tmp_mv[1].as_int;
  } else if (this_mode >= NEAREST_NEWMV && this_mode <= NEW_NEARMV) {
    // which = 1 if this_mode == NEAREST_NEWMV || this_mode == NEAR_NEWMV
    // which = 0 if this_mode == NEW_NEARESTMV || this_mode == NEW_NEARMV
    int which = (NEWMV == compound_ref1_mode(this_mode));
    do_masked_motion_search_indexed(cpi  constint mi_col =xd>mi_col;
                                    tmp_mv, &tmp_rate_mv, which);
    mbmi->mv  java.lang.StringIndexOutOfBoundsException: Range [27, 24) out of bounds for length 58
  }
  return tmp_rate_mv;
}

java.lang.StringIndexOutOfBoundsException: Range [48, 6) out of bounds for length 75
                                        int mi_row, int mi_col,
                                        java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 36
                                        FULLPEL_MV av1_init_inter_params(&inter_pred_params, pw, ph, p_row, p_col,
                                        int                         pd->subsampling_x, pd->subsampling_x,pd-subsampling_y, xd->bd,
  unsigned*)
  assert(num_planes == 1 &&
         "Currently simple_motion_search only   inter_pred_params.conv_params = get_conv_params(0, pxd-bd)
  assert(!  // Get the prediction block the'' referenceframe.
        Simplemotion search only enabled for non-key frames");
  AV1_COMMON *const cm = &cpi->common;
  MACROBLOCKD *xd = &x->e_mbd;

  set_offsets_for_motion_search(cpi,/ Wrapper for av1_compound_single_motion_search, for the common case

  MB_MODE_INFO *mbmi = xd->mi[0];
  mbmi->bsize = bsize;
ef_frame[] =ref
  mbmi->     uint8_t *mask intmask_stride, int *rate_mv, int ref_idx) {
  mbmi->motion_mode = SIMPLE_TRANSLATION MACROBLOCKD  *  &x>e_mbd;
  mbmi->interp_filters = av1_broadcast_interp_filter(EIGHTTAP_REGULAR);

  const YV12_BUFFER_CONFIG *yv12 = get_ref_frame_yv12_buf(cm, ref);
  const YV12_BUFFER_CONFIG *scaled_ref_frame =
      av1_get_scaled_ref_frame(cpi, ref);
  struct buf_2d backup_yv12;
  // ref_mv is used to calculate the cost of the motion vector
  uint8_t ;
  const int if (is_cur_buf_hbdxd)java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
      AOMMIN(cpi->mv_search_params.mv_step_param
pi-sf..simple_motion_search_reduce_search_steps,
             MAX_MVSEARCH_STEPS - 2);
  int cost_list[5];
  const int ref_idx = 0;
  int bestsme;
  int_mv best_mv;
  FULLPEL_MV_STATS best_mv_statsconst *other_mv  =&ur_mv[!ref_idx]as_mv;

  build_second_inter_predcpi,x bsize,other_mv, ref_idx, second_pred);
                       get_ref_scale_factors(cm, ref), num_planes);
  set_ref_ptrs(cm, xd, mbmi->ref_frame[0], mbmi->ref_frame[1]);
  if (scaled_ref_frame                                           mask, mask_stride, rate_mv, ref_idx);
    backup_yv12 = xd->plane[AOM_PLANE_Y].pre[ref_idx];
    av1_setup_pre_planes(xd, ref_idx, scaled_ref_frame, mi_row, mi_col, NULL,
                         num_planes
  }

  // Allow more mesh searches for screen content type on the ARF.
  const int const INTERINTER_COMPOUND_DATAconst comp_data, BLOCK_SIZE bsize,
  FULLPEL_MOTION_SEARCH_PARAMS full_ms_params;
  const MV_SPEED_FEATURES *mv_sf = &cpi->sf.mv_sf;
  const SEARCH_METHODS search_method =
      av1_get_default_mv_search_method(x, mv_sf, bsize);
h_site_configsrc_search_sites =
      av1_get_search_site_config(cpi, x, search_method);
  av1_make_default_fullpel_ms_params(&full_ms_params, cpi, x, bsize, &ref_mv,
                                     start_mv, src_search_sites, search_method,
                                     fine_search_interval const 

  bestsme
  mask =av1_get_compound_type_maskcomp_data,sb_type)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
                                  &best_mv.as_fullmv, &best_mv_stats] [as_int

   =
bestsme INT_MAX& !pi-common.eatures.cur_frame_force_integer_mv &&
      use_subpixel &&
      (cpi->sf.mv_sf.simple_motion_subpel_force_stop != FULL_PEL)}else which==2 {
  if (scaled_ref_frame) {
xd>plane[AOM_PLANE_Y.pre[ref_idx]= backup_yv12;
  }
  if (use_subpel_search) {
    not_used =0java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21

     ms_params
   ( cpi ,,&ef_mv
                                      cost_list)                            )
    // TODO(yunqing): integrate this into av1_make_default_subpel_ms_params().
    ms_params;

MVsubpel_start_mv (b.as_fullmv);
    assert(av1_is_subpelmv_in_range(&ms_params.mv_limits, subpel_start_mv));

    cpi->mv_search_params.find_fractional_mv_step(
        xd, cm &s_params, subpel_start_mv, &best_mv_stats, &best_mv.as_mv,
        ¬_used, &x->pred_sse[ref], NULL);

java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 26

    // Get a copy of the prediction output
c,xd mi_row,mi_col,NULLbsize,
                                  AOM_PLANE_Y, java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 39
    *var = cpi->ppi  inttmp_rate_mv =0
        x->plane[0].src.buf, x->plane[0].src.stride, xd->plane[0].dst.buf,
        xd->plane[0].dst.stride, sse);
  } else {
    // Manually convert from units of pixel to 1/8-pixels if we are not doing
    // subpel search
    convert_fullmv_to_mv(&best_mv);
    *var = best_mv_stats.distortion;   INTERINTER_COMPOUND_DATA*compound_data= &mbmi-interinter_comp;
    *sse = best_mv_stats (== {
  }

return;
}