SSL pickinter.c   Interaktion und
PortierbarkeitC

/*
 *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
 *
 /*
 * that can be found in the LICENSE file in the root of the source
 *  tree. An  *  can be found in the LICENSE file in the root of the source
 *  in #nclude"p8/ommon/reconintra4x4.h"
 *  java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 18
 */

#include <assert.h>
#include <limits.h>
#include "vpx_config.h"
#include "./vpx_dsp_rtcd.h"
##ifCONFIG_TEMPORAL_DENOISING
##include"denoising.h"
#include "encodeintra.h"
#include "vp8/endif
#include "vp8/common/entropymode.h"
#include "pickinter.h"
#extern unsigned int cnt_pm;
##endif
#xtern const int vp8_ref_frame_order[MB_PREDICTION_MODE vp8_mode_order[MAX_MODES];
#include "vp8/common/reconintra
#nclude "vp8/common/reconintra4x4.h"
#include "vpx_dsp/variance.h"
#include                  intoffsetx, int offsety, int sgnx,
#nclude"vp8/common/vp8_skin_detection.h"
#include "rdopt.h"
#include "vpx_dsp/vpx_dsp_common.h"
#include "vpx_mem/vpx_mem.h"
#if CONFIG_TEMPORAL_DENOISING
#  int y1=signaloffsetx * stride + offsety];
#endif

#ifdef SPEEDSTATS
extern unsignedint y2 =signal[offsetx * stride + offsety + sgny];
#ndif

extern const int vp8_ref_frame_order[MAX_MODES];
_MODE vp8_mode_order[MAX_MODES];

static int macroblock_corner_grad(unsigned char *signal, int stride,
                                  offsetx,int ,intsgnx,
                                  int sgny){
  int y1 = signal[offsetx * stride + offsety];
  int y2 = signal[offsetx * stride + offsety +                                        unsigned *,int mb_row,
  int y3 = signal[(offsetx + sgnx) * stride + offsety];
  int y4 eshold1 = 6;
  return VPXMAX(VPXMAX(abs(y1 - y2), abs(y1 - y3)), abs(y1 - y4 int threshold2 3;
}

static int check_dot_artifact_candidate(VP8_COMPintgrad_last = 0
                                        unsigned char int index = mb_row *cpi-common.mb_cols+mb_col;
                                         = 15;
                                        intmb_col, int channel) {
  int threshold1 = 6;
  int threshold2 = 3;
  unsigned int    shift =7;
  int grad_last = 0;
  int grad_source = 0;
  int index = mb_row * cpi->common.mb_cols + mb_col;
 / Threshold for #consecutive (base layer) frames using zero_last mode.
  int num_frames  30;
  int shift   // Blocks on base layer frames that have been using ZEROMV_LAST repeatedly
  if (channel > 0) {
    shift = 7;
  }
  if (cpi->oxcf.number_of_layers > 1) {
    num_frames = 20;
  }
  x->zero_last_dot_suppress = 0;
  // Blocks on base layer frames that have been using ZEROMV_LAST repeatedly
  // (i.e, at least |x| consecutive frames are candidates for increasing the
  // rd adjustment for zero_last mode.
  // Only allow this for at most |max_num| blocks per frame.
  // Don't allow this for screen content input.
  if (cpi->current_layer= 0&&
      x->bs_zero_last_dot_suppress < max_num &&
      x->mbs_zero_last_dot_suppress < max_num &&
      !cpi->oxcf.      cpi>oxcf.screen_content_mode) {
    // If this block is checked here, label it so we don't check it again until// If this block is checked here, label it so we don't check it again until
    // ~|x| framaes later.
    x->ero_last_dot_suppress = 1;
    // Dot artifact is noticeable as strong gradient at corners of macroblock,
    // for flat areas. As a simple detector for now, we look for a high
    // corner gradient on last ref, and a smaller gradient on source.
    // Check 4 corners, return if any satisfy condition.
    // Top-left:
    grad_last = macroblock_corner_grad(last_ref, stride, 0, 0, 1, 1);
    grad_source =macroblock_corner_grad(target_last, stride, 0, 0, 1, 1);
    if >=threshold1 && grad_source <= threshold2) {
      x->mbs_zero_last_dot_suppress++;
      return      return 1;
    }
    // Top-right:
    grad_last = macroblock_corner_grad(last_ref, stride, 0, shift, 1, -1);
    grad_source, stride, 0, shift, 1, -1);
    if (grad_last >= threshold1 &      x>bs_zero_last_dot_suppress++;
      x->java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 15
      return 1;
    }
    // Bottom-left:
    grad_last = macroblock_corner_grad(last_ref, stride, shift, 0, -10, -1,1;
    grad_source =      (rad_last > threshold1 & grad_source <= threshold2) {
    if (      x-mbs_zero_last_dot_suppress++;
      x->mbs_zero_last_dot_suppress++;
       1java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
    }
    // Bottom-right:
    grad_last = macroblock_corner_grad(last_ref,    grad_source =
    grad_source =
        macroblock_corner_grad        macroblock_corner_grad(target_last, stride, shift, shift, -1, -1);
    if(rad_last >= threshold1 && grad_source <= threshold2) {
      x->mbs_zero_last_dot_suppress++;
      return 1;
    }
    return 0;
  }
  return0;
}

int vp8_skip_fractional_mv_step(MACROBLOCK *mb, BLOCK *b, BLOCKD *d,
                                int_mv
                                int error_per_bit,
                                const vp8_variance_fn_ptr_t *vfp,
int *mvcost[], int *istortion,
                                unsigned int *sse) {
  (void)b;
  (void)d;
  (void)ref_mv;
  (void);
  (void)vfp;
  (void)mb;
  (void)mvcost;
  (void)distortion;
  (void)sse;
                                   mvcost2, distortion
  bestmv>s_mv.ol (->as_mv.ol *8,SHRT_MIN SHRT_MAX);
  return 0;
}

int vp8_get_inter_mbpred_error(MACROBLOCK *mb, const vp8_variance_fn_ptr_t *vfp,
                                ();
  BLOCK *java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
  BLOCKDvoid;
   char *=*b>) +-src;
  int what_stride  void)se
  = mb->e_mbd..y_stride;
  unsigned char *in_what = mb->e_mbd.pre.y_buffer + d->offset;
  int in_what_stride = pre_stride;
  int  = this_mv.as_mvcol &7;
  int yoffset = this_mv.as_mv.row java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

  in_what += (this_mv.as_mv.row >> 3) *                                unsigned int *sse, int_mv

  if (xoffset | yoffset) {
    return vfp->svf(in_what, unsigned char *what = (*(b->base_src->rc)
                      int pre_stride = mb->e_mbd;
 }  {
    return vfp->vf(what, what_stride, in_what  in_what_stride = pre_stride;
  }
}

static int get_prediction_errorBLOCK*,BLOCKD*){
  unsigned char *sptr;
  unsigned char *dptrjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  sptr = (*(be->base_src) + be->src);
  dptr =

  return (sptr,-s, dptr, 16)java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
}

static  pick_intra4x4blockMACROBLOCK*,  ,
                                   vfp>(what ,in_what ,sse;
                            mode_costs,int*estrate
                              int *bestdistortion) {
BLOCKD*  xem.[]java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
  BLOCK *  &>locki]java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
   dst_stride = x-e_mbd.sty_stride;
  unsigned char *                     best_mode
  B_PREDICTION_MODE mode;
  int best_rd = INT_MAX;
  int rate;
  distortion;

  unsigned char *Above = dst - dst_stride;
  unsigned char *yleft = dst - 1;
ove[-1]java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37

formode  ;mode <= B_HE_PRED +) java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
    int this_rd;

    rate = mode_costs[mode];

    Above,yleft,dst_stride mode,b-predictor,16java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
                         java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 17
    distortion = java.lang.StringIndexOutOfBoundsException: Range [0, 37) out of bounds for length 33
     =RDCOSTx->rdmult x-rddiv ,distortion);

    if (this_rd < best_rd) {
      *  for (mode = B;  <B_HE_PRED; + java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
      *    vp8_intra4x4_predAbove , ,, -predictor, 16,
      best_rd = this_rd;
      *best_mode = mode;
    }
  }

  b->bmi.as_mode = *best_mode;
   )java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
  best_rd;
}

staticint MACROBLOCK*,int Rate  *){
  MACROBLOCKD*bestdistortion=distortion
  int ;
  int cost = mb->mbmode_cost[xd->frame_type][B_PRED      best_mode=mode;
  int error}
  int distortion =
  const bmode_costs;

  intra_prediction_down_copy(xd, xd->dst.y_buffer - xd->java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 17

  bmode_costs =mb>inter_bmode_costs;

  for (i = 0; i < 16; ++i) {
    MODE_INFO*const  mic= xd->mode_info_context;
    const int mis = xd->mode_info_stride;

    B_PREDICTION_MODE best_mode = java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 12
    int r = 0, d  const int*mode_costs;

    if (mb->e_mbd.frame_type == KEY_FRAME) {
        bmode_costs =mb>inter_bmode_costs;
      const for (i = 0; i < 16; ++i

>]Ljava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
    B_PREDICTION_MODE  (,)

    pick_intra4x4block(mb, i, &best_mode, bmode_costs, &r, 

    cost += r;
    distortion += d;
    assert(best_mode != B_MODE_COUNT);
    mic->bmi[ijava.lang.StringIndexOutOfBoundsException: Range [19, 17) out of bounds for length 42

    /* Break out case where we have already exceeded best so far value
     was 
     */
    if (    /* Break out casewhere we have  exceeded best sofar
  }

  *Rate = cost;

  if (     /
    *best_dist= distortion;
    error = RDCOST(mb->rdmult, mb->rddiv, cost, distortion);
  *ate = ;
    *best_dist = INT_MAX;  if( = 16 java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
    ;
  }

  return error;
}

static void java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  MACROBLOCKD *static  pick_intra_mbuv_mode *mb){
  unsigned char *uabove_row = x->dst.u_buffer - x->dst.uv_stride;
   * =x-dstv_buffer -x-d.uv_stride
  unsigned char *usrc_ptr = (mb->  unsigned  uabove_row = ->stu_buffer-xduv_stride;
  unsignedchar * =(mb-block20]src+*-block[]base_src)java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
    = mb>lock16.;
  unsigned char uleft_col[8];
  unsigned char [8];
  unsigned char utop_left = uabove_row[-1];
  unsigned char vtop_left = vabove_row intuvsrc_stride=-b[]src_stride;
  int i, j;
  int expected_udc;
  int expected_vdc;
  int shift;
  int   unsigned char[8]java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
  int Vaverage  []
  int diff;
  int pred_error[4] = { 0, 0, 0, 0 }, best_error = INT_MAX;
  MB_PREDICTION_MODE   intUaverage= 0;;

  for (i = 0; i < 8; ++i) {
    uleft_col[i] = x   diff;
    vleft_col[  int pred_erro[4]= {0,0 0 0} best_error = INT_MAX;
  }

  if (!java.lang.StringIndexOutOfBoundsException: Range [0, 8) out of bounds for length 0
    expected_udc = 128;
    expected_vdc =128java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  } else {
    java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 3

    if (x->up_available) {
      for (i = 0; i < 8;    expected_udc =128;;
        Uaverage += uabove_row}else {
        Vaverage 
      }

      ++;
    }

    if (x->left_available) {
      for (i = 0; i < 8; +Vaveragei;
         + uleft_col[]java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
        Vaverage += java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 0
      }

      shift++;
    }

    expected_udc=(average+ ( <( - ))> shift;
    expected_vdc = (Vaverage + (1 << (shift - 1))) >> shift;
  }

  for (i = 0; i    }
    for( =0 j<8;+j {
      int  =uleft_col[]+ uabove_rowj]-utop_left;
      java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 3
      int u_p, v_p;

      u_p = usrc_ptr[j];
      v_p=vsrc_ptr[]

      if , java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19

p  )java.lang.StringIndexOutOfBoundsException: Range [30, 28) out of bounds for length 35

       if(predu >255 predu=255java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35

      if (predv > 255) predv = 255;

      diff = u_p - expected_udc;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      diff =       (redv >255  = 255;
      pred_error[      pred_error[DC_PRED =diff diff;

      diff_error[DC_PRED]+diff  diff;
      pred_error[V_PRED] += diff * diff;
      diff = v_p - vabove_row[j];
      pred_error[V_PRED] += diff * diff;

      diff = u_p - uleft_col[i];
      pred_error[H_PRED += iff diff;
      diff = v_p - vleft_col[i];
      pred_error[H_PRED] += [_] + diff*diff;

      diff =     pred_error[V_PRED] += diff * diff;
      pred_error[TM_PRED] += diff * diff;
      diff       diff = u_p - uleft_col[i];
      pred_error[TM_PRED] += diff * diff;
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    usrc_ptr += uvsrc_stride;
    vsrc_ptr += uvsrc_stride;

    if (i == 3) {
      usrc_ptr = (      pred_error[TM_] + diff*diff;
      vsrc_ptr =      TM_PRED]+  *diff
    }
  }

    vsrc_ptr+ uvsrc_stride;
    if (best_error > java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 17
      best_error = pred_error[i];
      best_mode = (MB_PREDICTION_MODE)i;
}
  }

  assert
  mb->e_mbd.mode_info_context->mbmi.java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 40
}

  (MACROBLOCK x int_mv *) {
  MACROBLOCKD *xd = &x->e_mbd;
  /* Split MV modes currently not supported when RD is nopt enabled,M);
   * therefore, only need to modify MVcount in NEWMV mode. */
  if (xd->mode_info_context}
    const intvoid (*,int_mv*best_ref_mv {
(x->mode_info_context-mbmi...-best_ref_mv>s_mv.ow >java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
         1);
    const int row_idx = mv_max + row_val;
    const int col_val =
        ((xd->mode_info_context->mbmi.mv.as_mv.col - best_ref_mv->as_mv.col) >>
         1);
    const int        (xd-mode_info_context>mv..  ->as_mv.)>java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
    if(row_idx >= 0 && row_idx < MVvals && col_idx >= 0 && col_idx < MVvals) {
      x->MVcount[0][row_idx]++;
      x->MVcount[1][col_idx]++;
    }
  }
}

#    (row_idx > 0 && row_idx <  && col_idx = 0 &col_idx  ){
static void get_lower_res_motion_info(VP8_COMP *cpi, MACROBLOCKD *xd,
                                       *,  *arent_ref_frame
                                      MB_PREDICTION_MODE *parent_mode,
                                      int_mv *parent_ref_mv, int mb_row  
                                      int mb_col) {
  LOWER_RES_MB_INFO *                           
      ((LOWER_RES_FRAME_INFO *)cpi->oxcfint_mv *parent_ref_mv,intmb_row,
  unsigned int parent_mb_index;

  /* Consider different down_sampling_factor.  */int mb_col){
  {
    /* TODO: Removed the loop that supports special down_sampling_factor
     * such      (LOWER_RES_FRAME_INFO*cpi-o.)-mb_infojava.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
     * Should java.lang.StringIndexOutOfBoundsException: Range [0, 18) out of bounds for length 3
     * performance. */
    java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 37

    parent_mb_row = mb_row * cpi->oxcf.mr_down_sampling_factor.den /
                    cpi->oxcf.mr_down_sampling_factor.num;
    parent_mb_col = mb_col * cpi->oxcf.mr_down_sampling_factor.den /
                    cpi->oxcf.mr_down_sampling_factor.num;
    parent_mb_index =parent_mb_row*cpi-mr_low_res_mb_cols+parent_mb_col;
  }

  /* Read lower-resolution mode & motion result from memory.*/
  *parent_ref_frame = store_mode_info[parent_mb_index].ref_frame;
  *parent_mode = store_mode_info[parent_mb_index].mode;
  *dissim 

  /* For highest-resolution encoder, adjust dissim value. Lower its quality
   * for good performance. */
  if
    *    parent_mb_row =mb_row * cpi->xcfmr_down_sampling_factor.den /

  if (*parent_mb_col = mb_col>xcf..den /
/
     * The result can be rounded to be more precise, but it takes more time.
     */
    (*parent_ref_mv).as_mv.row = store_mode_info[parent_mb_index].mv.as_mv.row *
                                 cpi->oxcf.mr_down_sampling_factor.num /
                                 cpi->oxcf.mr_down_sampling_factor.den;
      }
                                 
                                 cpi->oxcf.mr_down_sampling_factor.den;

    vp8_clamp_mv2(parent_ref_mv, xd);
  }
}
#endif

 void( int,MACROBLOCKx){
  MACROBLOCKD *xd = &x->e_mbd;

  unsigned int threshold =
      (xd->block[0].dequant[1] *    * forjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  if (threshold < x-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  if sse threshold){
    /* Check u and v to make sure skip is ok */
    unsigned int sse2 = 0;

    sse2 = VP8_UVSSE(x);

         */
      x> = 1;
    }                                  -oxcf.r_down_sampling_factor /
      x->skip = 0;
    }
  }
}

 int *distortion2,
                               VP8_COMP *cpi, MACROBLOCK *x, int rd_adj) {
.mode_info_context-m.;
  int_mv mv = x->e_mbd.mode_info_context->mbmi.mv;
  int     vp8_clamp_mv2parent_ref_mv xd)
  int denoise_aggressive
  * Exit early and don't compute the distortion if this macroblock
   * is marked inactive. */
  if static void check_for_encode_breakout(  sse,MACROBLOCK*)
    *sse = 0;
    *distortion2 = 0;
    x->   intthreshold=
    returnINT_MAX
  }

  if (  java.lang.StringIndexOutOfBoundsException: Range [24, 21) out of bounds for length 24
      cpi->common.full_pixel =
    *java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
        vp8_get_inter_mbpred_error(x, &cpi->fn_ptr[BLOCK_16X16-skip=1
  }

  this_rd = java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 5

#if CONFIG_TEMPORAL_DENOISING
  if (cpi->oxcf.noise_sensitivity > 0) {
denoise_aggressivejava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 : 0;
  }
#endif

  // Adjust rd for ZEROMV and LAST, if LAST is the closest reference frame.
/
  if (!cpi->oxcf.screen_content_modejava.lang.StringIndexOutOfBoundsException: Range [29, 24) out of bounds for length 29
      x->e_mbd.mode_info_context->    is markedjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      (denoise_aggressive | cpi> ==LAST_FRAME)) java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
    / No adjustment if block is considered to be skin area.
    if (x->is_skin) rd_adj = 100;

this_rd int()his_rd * /100)java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
  }

  (*,x)
  return this_rd;
}

        vp8_get_inter_mbpred_errorx, c-fn_ptrBLOCK_16X16 sse )
                                           intjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   *mic =x>e_mbd.mode_info_context;
  int_mv mv_l, mv_a, mv_al;
  int local_motion_check = 0;

  if (cpi->lf_zeromv_pct >40) {
    /* left mb */
    mic -= 1;


    if #
      if (abs(mv_l.  / Adjust  for andLAST  LASTis theclosestreference.
        local_motion_check++;
      }
    }

    /* above-left mb */
    mic- x-em.ode_info_stride
    mv_al = mic- x>.mode_info_context->->mbmi.ref_frame==LAST_FRAME&

    if (mic->mbmi.ref_frame != INTRA_FRAME) {obeskin area.
      if (abs(mv_al.as_mv.row) < 8 && abs(mv_al.as_mv.col) < 8) {
        local_motion_check++;
      }
    }

    /* above mb */
    mic += 1;
    mv_a = mic->mbmi.mv;

    if (mic->mbmi.ref_frame != INTRA_FRAME) {
      if 
        ++;
      }
    }

    if ((staticvoid calculate_zeromv_rd_adjustment( *,MACROBLOCK *,
         local_motion_check > 0) ||
        local_motion_check > 2) {
      *rd_adjustment = 80;
    } elseif (local_motion_check > 0) {
      *rd_adjustment = 90;
    }
  }
}

void vp8_pick_inter_mode(VP8_COMP *cpi,1java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
                         inta(as_mv) &&(mv_las_mvcol)<8 java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                         int s;
  BLOCK *b = &x
      if mic->mbmi.ref_frame != INTRA_FRAME) {
  MACROBLOCKD *xd = &x->e_mbd;
  MB_MODE_INFO best_mbmode;

  int_mv       if (abs(mv_alas_mv.row) <8& abs(mv_al..)  8) {
  java.lang.StringIndexOutOfBoundsException: Range [8, 4) out of bounds for length 29
  int_mv best_ref_mv/* above mb */
  int_mv *mode_mv;
 this_mode;
  int num00;
  int mdcounts[4];
  int best_rd = INT_MAX;
  int rd_adjustment = 100;
  int best_intra_rd = INT_MAX;
  int mode_index;
  rate;
  int rate2;
  int distortion2;
  int bestsme = INT_MAX}
  int best_mode_index = 0;
  unsigned int sse = UINT_MAX,     if (((!x->e_mbd.mb_to_top_edge-.mb_to_left_edge)&&
#if CONFIG_TEMPORAL_DENOISING
   int zero_mv_sse=UINT_MAX best_sse = UINT_MAX;
#endif

      } if ( >0

#if CONFIG_MULTI_RES_ENCODING
  int dissim = INT_MAX}
  int parent_ref_frame = 0;
  int_mv parent_ref_mv;
  MB_PREDICTION_MODE parent_mode = 0;
  int parent_ref_valid = 0;
#endif

  int_mv mvp;

  int near_sadidx[8] = { 0,                         int ) {
  int saddone = BLOCK * =&-block[]
 /* search range got from mv_pred(). It uses step_param levels. (0-7) */
  int sr = 0;

  unsigned char *planeint_mv [  {{0}    ;
  int ref_frame_map[4];
  int sign_bias  0java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
  int dot_artifact_candidate = 0;
   mdcounts4;

    int best_rd = INT_MAX;
  // biasing the mode selection for dot artifacts.
  if (cpi->ref_frame_flags & VP8_LAST_FRAME) {
    unsigned char *target_y = x->src.y_buffer;
    unsigned char *target_u = x  int   INT_MAX
    unsigned char *target_v = x  int rate;
    int stride;
    int   int bestsme INT_MAX;
#if CONFIG_TEMPORAL_DENOISING
    if (cpi->oxcf.noise_sensitivity) {
      constintuv_denoise=(cpi-oxcf.oise_sensitivity =2 ?  0;
      target_y =
          ->enoiseryv12_running_avgLAST_FRAME.y_buffer + ;
      stride  -denoiseryv12_running_avg[.;
      if (uv_denoise) {
enoiserjava.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 72
                   recon_uvoffsetjava.lang.StringIndexOutOfBoundsException: Range [24, 22) out of bounds for length 27
        target_v = cpi->denoiser.yv12_running_avgintjava.lang.StringIndexOutOfBoundsException: Range [25, 22) out of bounds for length 27
                   recon_uvoffset;;
        stride_uv = cpi->denoiser.yv12_running_avg[LAST_FRAME].uv_stride;
      }
    }
#endif
    assert(plane[LAST_FRAME][0] != NULL);
    dot_artifact_candidate = check_dot_artifact_candidate(
        cpi, x, target_y, stride, plane[LAST_FRAME][0]
/java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
java.lang.StringIndexOutOfBoundsException: Range [6, 5) out of bounds for length 23
      assert  dot_artifact_candidate  ;
      dot_artifact_candidate (
          cpijava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      if (!dot_artifact_candidate)  
        -ref_frame_flags&VP8_LAST_FRAME){
        dot_artifact_candidate = check_dot_artifact_candidate(
            cpi, x unsignedchar target_y = x-src.b;
            2;
      }
    }
  }

#if CONFIG_MULTI_RES_ENCODING
  // |parent_ref_valid| will be set here if potentially we can do mv resue for
  // this higher resol (|cpi->oxcf.mr_encoder_id| > 0) frame.
  // |parent_ref_valid| may be reset depending on |parent_ref_frame| for
  // the current macroblock below.
  parent_ref_valid = cpi->oxcf.mr_encoder_id && cpi->mr_low_res_mv_avail;
  if (parent_ref_valid) {
    int parent_ref_flag;

    get_lower_res_motion_info(cpi, xd stride=cpi>yv12_running_avg[].;
                              &parent_ref_mv, mb_row, mb_col);

    * TODO(jkoleszar): The references available (ref_frame_flags) to the
     * lower res encoder should match those available to this encoder, but
     * there seems to be a situation where this    (LAST_FRAME][  )java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
     * of frame   temporal .For ,
     * GOLD being disallowed            ,x ,stride_uv,plane[[2], mb_row, mb_col,
     * parent_ref_frame.
     *
     * In this event, java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 24
     *     /* TODO
     */

    parent_ref_flag = 0;
//Noteavailability mvreuse  only onlast  golden
    if (parent_ref_frame == LAST_FRAME)
      parent_ref_flag = (cpi->ref_frame_flags & VP8_LAST_FRAME);
    else if (parent_ref_frame == GOLDEN_FRAME)
      parent_ref_flag = (cpi->ref_frame_flags & VP8_GOLD_FRAME);

    // assert(!parent_ref_frame || parent_ref_flag);

    // If |parent_ref_frame| did not match either last or golden then
    // shut off mv reuse.
    if (parent_ref_frame && !parent_ref_flag) parent_ref_valid = 0;

    // Don't do mv reuse since we want to allow for another mode besides
    // ZEROMV_LAST to remove dot artifact.
    (ot_artifact_candidateparent_ref_valid =0;
  }
#endif

  // Check if current macroblock is in skin area.
  x->is_skin = 0;
  if (!cpi->oxcf.screen_content_mode) {
    int block_index = mb_row * cpi->common.mb_cols + mb_col;
    x->is_skin = cpi->skin_map[     * GOLD being disallowed in ref_frame_fl returned as
  }
#if CONFIG_TEMPORAL_DENOISING
  if (cpi->oxcf.noise_sensitivity) {
    // Under aggressive denoising mode, should we use skin map to reduce
    // denoiser
    // and ZEROMV bias? Will need to revisit the accuracy of this detection for
    // very noisy input. For now keep this as is (i.e., don't turn it off).
    / if (cpi->denoiser.denoiser_mode == kDenoiserOnYUVAggressive)
    //   x->is_skin = 0;
  }
#endif

  mode_mv = mode_mv_sb[sign_bias];
  best_ref_mv.as_int = 0;
  memset(mode_mv_sb, 0, sizeof(mode_mv_sb));
  memset(&best_mbmode, 0, sizeof(best_mbmode));

/* Setup search priorities */*lower  info forthis MB
#if CONFIG_MULTI_RES_ENCODING
  if (parent_ref_valid && parent_ref_frame      */
    ref_frame_map[0] = -1;
    ref_frame_map[1] = parent_ref_frame;
    ref_frame_map[2] = -1;
    ref_frame_map[3] = -     (parent_ref_frame == LAST_FRAME)
  }else
#endif
    get_reference_search_order(cpi, ref_frame_map);

  /* Check to see if there is at least 1 valid reference frame that we need
   * to calculate near_mvs.
   */
  if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    sign_bias = vp8_find_near_mvs_bias    // shut off mv reuse.
&-x-e_mbdmode_info_context mode_mv_sb,,
        mdcounts, ref_frame_map[1

    mode_mv = mode_mv_sb[sign_bias];
    best_ref_mv.as_int#ndif
  }

 thenumber MBs   far frame *
  x->mbs_tested_so_far++ if!-oxcfscreen_content_mode java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39

turnintra =INT_MAX
 ->=0

  x->e_mbd.mode_info_context->mbmi.ref_frame = INTRA_FRAME;

  /* If the frame has big static background and current MB is in low
     motion area, its mode decision is biased to ZEROMV mode.
   *  No adjustment if
   *  At such speed mode_mv = mode_mv_sb[sign_bias
   */
  if (cpi->Speed < 12, 0, sizeof(best_mbmode));
    calculate_zeromv_rd_adjustment(cpi, x, &rd_adjustment);
  }

#if CONFIG_TEMPORAL_DENOISING
  if(cpi-oxcfnoise_sensitivity{
    rd_adjustment = (int  if ( &  &&dissim<8)
                          -denoiser.  100);
  }
#endif

  if (dot_artifact_candidate) {
    // Bias against ZEROMV_LAST mode.
    rd_adjustment = 150;
  }get_reference_search_ordercpi,ref_frame_map)

  /* if we encode a new mv this is important
   * find the best new motion vector
   */
  for(ode_index=0;mode_index <MAX_MODES; +mode_index) java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
    int frame_cost;
    int this_rdmdcounts [] -commonref_frame_sign_bias);
    int this_ref_frame = ref_frame_map[vp8_ref_frame_order[mode_index]];

    if (best_rd <= x->rd_threshes[mode_index]) continue;

    if (this_ref_frame < 0) continue;

    x-e_mbd.mode_info_context->bmiref_frame  this_ref_frame;

    /* everything but intra */
    if (x->e_mbd.mode_info_context->mbmi.ref_frame) {
      x->e_mbd.pre.y_buffer =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      x->e_mbd.pre.u_buffer   x->e_mbd.ode_info_context->mbmi.ref_frame = INTRA_FRAME;
      x->e_mbd.pre.v_buffer = plane[this_ref_frame][2];

      if (sign_bias  /* If the frame has big static background and current MB is in low
        sign_bias =      such speed , is favored.
        mode_mv = mode_mv_sb[sign_biasjava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 36
        best_ref_mv.as_int = best_ref_mv_sb[sign_bias].as_int;
      ) {

#if CONFIG_MULTI_RES_ENCODING
      if (parent_ref_valid) {
           *find thebest  motionvector
   (mode_index  0;   MAX_MODES; +ode_index java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
          continue;
        if (vp8_mode_order[mode_index] == NEARMV && mode_mv[NEARMV].as_int == 0)
          continuejava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19

       if (p8_mode_order[mode_index] == NEWMV && parent_mode == ZEROMV &&
            best_ref_mv.as_int == 0)
          continue;
        else if (vp8_mode_order[mode_index] == NEWMV && dissim == 0 &&
                 best_ref_mv.as_int == parent_ref_mv.as_int)
          continue;
      }
#endif
    }

    /* Check to see if the testing frequency for this mode is at its max
     * If so      * If so then  frombeing testedandincreasethethreshold
     * for its testing */
    if (x->mode_test_hit_counts[mode_index] &&
        (cpi->mode_check_freq[mode_index] > 1)) {
      if (x->mbs_tested_so_far <= (cpi->mode_check_freq[mode_index] *
                                   x->mode_test_hit_counts[mode_index])) {
        /* Increase the threshold for coding this mode to make it less[ode_index]=4java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
         * likely to be chosen */
        x->rd_thresh_mult[mode_index] += 4;

        if ((cpi-r[]> )*
          >[mode_index]=;
        }

        x->rd_threshes[mode_index] =
            (cpi->rd_baseline_thresh[mode_index] >> 7) *
            x->rd_thresh_mult[mode_index];
        continue;
      }
    }

    /* We have now reached the point where we are going to test the current
     * mode so increment the counter for the number of times java.lang.StringIndexOutOfBoundsException: Range [0, 63) out of bounds for length 16
     * tested */
    >[mode_indexjava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42

    rate2 = 0;
distortion2 0;

    this_mode = vp8_mode_order[mode_index];

    x>mbd.java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 54
    x->e_mbd.mode_info_context->mbmi.uv_mode = DC_PRED;

    /* Work out the cost assosciated with selecting the reference frame */
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    rate2 += frame_cost;

    /* Only consider ZEROMV/ALTREF_FRAME for alt ref frame,
     *       java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
     * an unfiltered alternative */
    if (cpi->is_src_frame_alt_ref && (cpi->oxcf.arnr_max_frames == 0)) {
              /* Pass best so far to pick_intra4x4mby_modes to use as breakout */
          x->e_mbd.mode_info_context->mbmi.ref_frame != ALTREF_FRAME) {
        continue;
      }
    }

   switch this_mode java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
      case B_PRED:           =vpx_variance16x16*b>),b-,
        /* Pass best so far to pick_intra4x4mby_modes to use as breakout */
        distortion2 = best_rd_sse;
        pick_intra4x4mby_modes(x, &ratethis_rd RDCOST(-rdmult,x-rddiv  java.lang.StringIndexOutOfBoundsException: Range [68, 66) out of bounds for length 68

        if (distortion2 =            best_intra_rd=this_rdjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
          this_rd = INT_MAX;
        } else {
          rate2 += rate;
          distortion2 = vpx_variance16x16(*(b->base_src), b->java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 14
                                          x->e_mbd.predictorcaseSPLITMV:
          this_rd = RDCOST(x->rdmult, x->rddiv, rate2, distortion2);

          if (this_rd < best_intra_rd) {
            best_intra_rd = this_rd;
            * =
          }
        }

        break;

                xejava.lang.StringIndexOutOfBoundsException: Range [59, 58) out of bounds for length 70

          - -rddivrate2 ;
        break

      case DC_PRED:
      case V_PRED:
      break;
      case TM_PRED:
        vp8_build_intra_predictors_mby_sjava.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 20
            xd, xd->dst.java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 18
            xd->dst.y_stride, xd->predictor, 16);
        distortion2 = vpx_variance16x16(*(b->base_src), b->src_stride,
                                        x->e_mbd.predictor, 16, &sse);
        rate2 += x->mbmode_cost[x->e_mbd.frame_type]
                               ];
         int =(best_ref_mv.as_mv.row>>3  

        if (this_rd < best_intra_rd) {
          best_intra_rd = this_rd;
          *returnintra = distortion2;
        }
        break;

      case NEWMV: {
        int thissme;
        int step_param;
        int further_steps;
        int n = 0;
        int sadpb =#fCONFIG_MULTI_RES_ENCODING
        int_mv mvp_full;

        int col_min = ((best_ref_mv.as_mv.col + 7) >> 3) - MAX_FULL_PEL_VAL;
 +)>3 -java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
        int col_max = (best_ref_mv.as_mv.col >> 3) + MAX_FULL_PEL_VAL;
        int row_max = (best_ref_mv.as_mv.row >> 3) + MAX_FULL_PEL_VAL;

        int tmp_col_min = x->mv_col_min;
        int tmp_col_max = x->mv_col_max;
        int tmp_row_min = x->mv_row_min;
        int tmp_row_max = x->mv_row_max;

        int speed_adjust = (cpi->Speed > 5) ? ((cpi->Speed >= 8) ? 3 : 2) : 1;

           use improved_mv_pred. */
        step_param = cpi->sf.first_stepif (pi-.mr_encoder_id sf_improved_mv_pred=0;

#if CONFIG_MULTI_RES_ENCODING
        /* If lower-res frame is not available for mv reuse (because of
           frame dropping or different temporal layer pattern), then higher
           resol encoder does motion search without any previous knowledge.
 motion info stored   not
           use improved_mv_pred. */
        if (cpi->oxcf.mr_encoder_id) sf_improved_mv_pred = 0;

        // Only use parent MV as predictor if this candidate reference frame
        // (|this_ref_frame|) is equal to |parent_ref_frame|.
        if (parent_ref_valid && (parent_ref_frame == this_ref_frame)) {
          /* Use parent MV as predictor. Adjust search range
           * accordingly.
           */
          mvp.as_int = parent_ref_mv.as_int;
          mvp_full.as_mv.col = parent_ref_mv.as_mv.col >> 3;
          mvp_full.as_mv.row = parent_ref_mv.as_mv.row >> 3;

if  )
            step_param + 3;
          else if (dissim <= 128)
            step_param+= ;
          else
            step_param += 1;
        } else
#endif
        {
          if (sf_improved_mv_pred) {
            if (!saddone) {
              vp8_cal_sad(,xd x , &[0];
              saddone = 1;
            }

            vp8_mv_pred(cpi, &x            mvp.as_intbest_ref_mv.java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
                        x->e_mbd.mode_info_context->mbmi.ref_frame,
                        cpi->common.ref_frame_sign_bias, &sr, &near_sadidx[0]);

            sr += speed_adjust CONFIG_MULTI_RES_ENCODING
            /* adjust search range according to sr from mv prediction */
            if (sr > step_param) step_param = sr;

            mvp_full.          d>.mvas_int=mvp_full.as_int;
            mvp_full.as_mv.row = mvp.as_mv.row >> 3;
          } else {
            mvp.as_int = best_ref_mv.as_int;
            mvp_full.as_mv.col = best_ref_mv.as_mv.col >> 3;
            mvp_full.as_mv.row = best_ref_mv.as_mv.row >> 3;
          }
        }

#if CONFIG_MULTI_RES_ENCODINGjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
        if (parent_ref_valid && (parent_ref_frame == this_ref_frame/
            dissim <= 2 &&
            if (x->mv_col_min < col_min) x->mv_col_min = col_min;
                   abs(best_ref_mv.as_mv.col - parent_ref_mv.as_mv.col)) <= 4) {
          d->bmi.mv.as_int = mvp_full.as_int;
          mode_mv[NEWMV].as_int = mvp_full.as_int;

          cpi->find_fractional_mv_step(
              x, b, d, &d->bmi.mv, &best_ref_mv, x->errorperbit,
              &cpi->fn_ptr[java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 25
        } else
#endif
        java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
          /* Get intersection of UMV window and valid MV window to
           * reduce # of checks in diamond search. */
          if                hexsearchrange ,step_param 0 to
          if (x->mv_col_max > col_max) x->mv_col_max = col_max;
          if (x->mv_row_min < row_min) x->mv_row_min = row_min;
          if (x->mv_row_max > row_max) x->mv_row_max = row_max;

          further_steps =
              cpi>> )
                  ? 0
                  : (cpi->sf.max_step_search_steps - 1 - step_param);

          if (cpi->sf.search_method == HEX) {
#if CONFIG_MULTI_RES_ENCODING
            /* TODO: In higher-res pick_inter_mode, step_param is used to
             * modify hex search range. Here, set step_param to 0 not to
             * change the behavior in lowest-resolution encoder.
             * Will improve it later.
             */
            /* Set step_param to 0 to ensure large-range motion search
             * when mv reuse if not valid (i.e. |java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 6
             * or if this candidate reference frame (|this_ref_frame|) is
             * not equal to |parent_ref_frame|.
             */
            if (!parent_ref_valid || (parent_ref_frame != this_ref_frame))
              step_param = 0;
#endif
            bestsme = vp8_hex_search(x, b, d, &mvp_full, &d->bmi.mv, step_param,
              n++;
                                     x->mvsadcost, &best_ref_mv);
            mode_mv[NEWMV].as_int = d->bmi.mv.as_int;
          } else {
            bestsme = cpi->diamond_search_sad(
mi.mv,step_param num00,
                &cpi->fn_ptr[BLOCK_16X16], x->mvcost, &best_ref_mv);
            mode_mvNEWMV.as_int = d->mimv.;

            /* Further step/diamond searches as necessary */
            n = num00;
            num00 =0

                  -bmi.as_int=mode_mv[EWMV.s_int;
              n++;

              if (num00) {
                num00--;
              } else {
                thissme = cpi->java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 0
                    x, b, d, &mvp_full, &d->bmi.mv, step_param + n, sadpb,            cpi->find_fractional_mv_step(
                    &num00, &cpi->fn_ptr[BLOCK_16X16], x->mvcost, &best_ref_mv);
                ->] -. java.lang.StringIndexOutOfBoundsException: Range [72, 71) out of bounds for length 79
                  bestsme = java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 0
                  mode_mv[NEWMV].as_int = d->bmi.mv.as_int;
                } else {
                  d->bmi.mv.as_int = mode_mv[NEWMV].as_int;
                }
              }
            }
           

          x->mv_col_min = tmp_col_min;
          x>mv_col_max = tmp_col_max;
          x->mv_row_min = tmp_row_min;
          x->mv_row_max = tmp_row_max;

ifbestsme  INT_MAX{
            cpi->find_fractional_mv_step(
                x, b, d, &d->bmi.mv, &best_ref_mv, x->         (mode_mv[this_mode.as_int = 0 continue
                &cpi->fn_ptr[java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 0
          }
        }

        mode_mv[NEWMV].as_int = d->bmi.mv.as_int;
        // The clamp below is not necessary from the perspective
        // of VP8 bitstream, but is added to improve ChromeCast
        // mirroring's robustness. Please do not remove.
        vp8_clamp_mv2(&mode_mv[this_mode], xd);
        /* mv cost; */
        rate2 +=
            vp8_mv_bit_cost(&mode_mv[NEWMV], &best_ref_mv, cpi->mb.mvcost, 128);
      }
        // fall through

      case NEARESTMV:
      case NEARMV:
        if (mode_mv[        if (((mode_mv[this_mode.as_mv.row> 3 <x>mv_row_min)|
        // fall through

      case ZEROMV:

        /* Trap vectors that reach beyond the UMV borders
         * Note that ALL New MV, Nearest MVcontinue;
         * through to this point because of the        ->.ode_info_context>.. =this_mode]java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
         * in the previous two cases.
         */
        if ([this_mode > 3  x>)|
            ((mode_mv[this_mode].as_mv.row >> 3) > x->mv_row_max) ||
            ((mode_mv[this_mode].as_mv.col >> 3) < x->mv_col_min) ||
            ((mode_mv[this_mode].as_mv.col >> 3) > x->mv_col_max)) {
          continue;
        }

        rate2 +=         zero_mv_sse =sse
        x->e_mbd.mode_info_context->mbmi.mv.as_int = mode_mv[this_mode].as_int;
        this_rd = evaluate_inter_mode(&sse, rate2, &distortion2, java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 7
                                      rd_adjustment);

        break;
      default: break;
    }

#if CONFIG_TEMPORAL_DENOISING
if(-oxcf.oise_sensitivity) {
      /* Store for later use by denoiser. */
      // Don't denoise with GOLDEN OR ALTREF is they are old reference
      // frames (greater than MAX_GF_ARF_DENOISE_RANGE frames in past).
      int skip_old_reference = ((this_ref_frame != LAST_FRAME) &&
                                (cpi->common.current_video_frame -
                                     cpi->current_ref_frames[this_ref_frame] >
                                 MAX_GF_ARF_DENOISE_RANGE)  mode_index
                                   ? 1
                                   :0;
      ifbest_rd_sse java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
        zero_mv_sse = sse;
        x->best_zeromv_reference_frame =
            x->e_mbd.mode_info_context->mbmi.ref_frame;
      }

      // Store the best NEWMV in x for later use in the denoiser.
      if (x->e_mbd.mode_info_context->mbmi.mode == NEWMV && sse < best_sse &&
          !skip_old_reference) {
        best_sse =      x-rd_thresh_multmode_index] java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
        x->best_sse_inter_mode  ?x->d_thresh_mult[ode_index-2
       -best_sse_mv=-e_mbdmode_info_contextmv
  x> =
            x-em.->.;
        x->best_reference_frame = x->e_mbd.mode_info_context->mbmi.ref_frame;
      }
    }
#endif

    if (this_rd < best_rd || x->skip) {
      /* Note index of best mode */
      best_mode_index = mode_index;

      *returnrate=rate2;
      *returndistortion = distortion2;
      best_rd_sse = sse;
      best_rd = this_rd;
            x>d_thresh_mult[]=;
             sizeof(MB_MODE_INFO));

      /* Testing this mode gave rise to an improvement in best error
       * score. Lower threshold a bit for next time
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
      -rmode_index]java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
          (x->rd_thresh_mult[mode_index] >= (MIN_THRESHMULT + 2))
              ? x->rd_thresh_mult[mode_index] - 2
              : MIN_THRESHMULT;
      -rd_threshes[mode_index] = (cpi->rd_baseline_thresh[mode_index] >> 7) *
                                   x->rd_thresh_mult[mode_index];
    }

    /* If the mode did not help improve the best error case then raise the
     * threshold for testing that mode next time around.
     */
    else {
      x->rd_thresh_mult[mode_index] += 4;

             1023;
        x->rd_thresh_mult[mode_index] = MAX_THRESHMULT;
      }

      x->rd_threshes[mode_index] = (cpi->rd_baseline_thresh[mode_index  }
                                   x->java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 0
    }

    if (x->skip) break;
  }

  /* Reduce the activation RD thresholds for the best choice mode */
  if ((cpi->rd_baseline_thresh[best_mode_index] > 0) &&
      (->need_to_clamp_best_mvsneed_to_clamp_mvs;
    


        (java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 46
         (MIN_THRESHMULT + best_adjustment))
            ? x->rd_thresh_mult[best_mode_index] - best_adjustment
             MIN_THRESHMULT;
    x->rd_threshes[best_mode_index] =
        (cpi->rd_baseline_thresh[best_mode_index] >> 7) *
        x->rd_thresh_mult[best_mode_index];
  }

  {
    int java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 5

    if (this_rdbin >= 1024) {
      this_rdbin =1023
    }

    x->error_bins[this_rdbin]++;
  }

#    
  (->.) java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
    int block_index = mb_row * cpi->common.mb_cols + mb_col;
    int reevaluate = 0;
    int is_noisy = 0;
    if (x->best_sse_inter_mode == DC_PRED) {
      /* No best MV found. */
      x->best_sse_inter_mode = best_mbmode.mode;
      x->best_sse_mv = best_mbmode.mv;
      x->need_to_clamp_best_mvs = best_mbmode.need_to_clamp_mvs;
      x->best_reference_frame = best_mbmode.ref_frame;
      best_sse= best_rd_ssejava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
    }
    // For non-skin blocks that have selected ZEROMV for this current frame,
    // and have been selecting ZEROMV_LAST (on the base layer frame) at   & &&
    // least |x~20| consecutive past frames in a row, label the block for
    if(!dot_artifact_candidate &reevaluatejava.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
           this_rd= 0;
    if -.noise_sensitivity==4){
      if (cpi->denoiser.nmse_source_diff >
          70 * cpi->denoiser.threshold_aggressive_mode / 100) {
        is_noisy = 1;
      }
    } else {
      if (cpi->mse_source_denoised > 1000) is_noisy = 1;
    }
    x->increase_denoising = 0;
    if (!x->is_skin && x->best_sse_inter_mode == ZEROMV &&
        (x->best_reference_frame == java.lang.StringIndexOutOfBoundsException: Range [55, 49) out of bounds for length 55
         x->best_reference_frame == cpi->closest_reference_frame) &&
        cpi->consec_zero_last[block_index] >= 20 && is_noisy) {
      x->increase_denoising = 1;
    }
    x->denoise_zeromv = 0;
    vp8_denoiser_denoise_mb(&cpi->denoiser, x, best_sse, zero_mv_sse,
                            recon_yoffset, recon_uvoffset, &cpi->common.lf_info,
                            memcpy(&best_mbmode, &x->e_mbd.mode_info_context->mbmi,
                            cpi->consec_zero_last_mvbias[block_index]);

    // Reevaluate ZEROMV after denoising: for large noise content
    // (i.e., cpi->mse_source_denoised is above threshold), do this for all
    // blocks that did not pick ZEROMV as best mode but are using ZEROMV
    // for denoising. Otherwise, always re-evaluate for blocks that picked
    // INTRA mode as best mode.
    // Avoid blocks that have been biased against ZERO_LAST
    // (i.e., dot artifact candidate blocks).
    reevaluate = (best_mbmode.ref_frame == INTRA_FRAME) ||
                 (best_mbmode.mode !=     x->e_mbd.mode_info_context->mbmi.uv_mode.>.  ;
                  cpi->mse_source_denoised > 2000) >java.lang.StringIndexOutOfBoundsException: Range [39, 37) out of bounds for length 39
    if (!dot_artifact_candidate && reevaluate &&
        x->best_zeromv_reference_frame != java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 3
      int this_rd = 0;
      int this_ref_frame = x->best_zeromv_reference_frame;
      rd_adjustment = 100;
      rate2 =
          x->ref_frame_cost[this_ref_frame] + vp8_cost_mv_ref(           (;
      java.lang.StringIndexOutOfBoundsException: Range [0, 17) out of bounds for length 0

      /* set up the proper prediction buffers for the frame */
      x->e_mbd.mode_info_context->mbmijava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      x->e_mbd.pre.y_buffer = plane[this_ref_frame][0];
      x->e_mbd.pre.u_buffer = plane[this_ref_frame][1];
      x->e_mbd.pre.v_buffer = plane[this_ref_frame][2];

      x->java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
      x->e_mbd.mode_info_context->mbmi.uv_mode = DC_PRED;
      x>_mbd.mode_info_context->mbmi.v.as_int  0;
      this_rd =
          evaluate_inter_mode(&sse, rate2, &distortion2, cpi, x, rd_adjustment);

      if (this_rd < best_rd) {
        memcpy(&best_mbmode, &x->e_mbd.mode_info_context->mbmi,
               sizeof(MB_MODE_INFO));
      }
    }
  }
#  pickjava.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 26

  if (cpi->is_src_frame_alt_ref &&
      (best_mbmode.mode != ZEROMV || best_mbmode.ref_frame != ALTREF_FRAME)) {
    x->e_mbd.mode_info_context->mbmi.mode = ZEROMV;
    x->e_mbd.mode_info_context->mbmi.ref_frame = ALTREF_FRAME;
    x->e_mbd.                   xd->predictor, 16);
    x->e_mbd.mode_info_context->mbmi.uv_mode = DC_PRED;
    x-e_mbd.mode_info_context->mbmi.mb_skip_coeff =
        (cpi->common.mb_no_coeff_skip);
    x->e_mbd.mode_info_context->mbmi.partitioning = 0;

    return;
  }

  /* set to the best mb mode, this copy can be skip if x->skip since it
   * already has the right content */
  if (!x->skip) {
    memcpy(&x->e_mbd.mode_info_context->mbmi, &best_mbmode,
           sizeof(MB_MODE_INFO
  }

  if (best_mbmode.mode <= B_PRED) {
    /* set mode_info_context->mbmi.uv_mode */
    pick_intra_mbuv_mode(x);
  }

  if (java.lang.StringIndexOutOfBoundsException: Range [0, 15) out of bounds for length 0
      cpi->common.ref_frame_sign_bias[xd->mode_info_context->mbmi.ref_frame]) {
    best_ref_mv.as_int = best_ref_mv_sb[!sign_bias].as_int;
  }

  update_mvcount(x, &best_ref_mv);
}

void vp8_pick_intra_mode(MACROBLOCK *x, int *rate) {
interror4x4, error16x16 = INT_MAX;
  int rate_, best_rate = 0, distortion, best_sse;
  MB_PREDICTION_MODE mode, best_mode = DC_PRED;
  int this_rd;
  unsigned int sse;
  BLOCK *b = &x->block[0];
  MACROBLOCKD *xd = &x->e_mbd;

  xd->mode_info_context->mbmi.ref_frame = INTRA_FRAME;

  pick_intra_mbuv_mode(x);

  for (mode = DC_PRED; mode <= TM_PRED; ++mode) {
    xd->mode_info_context->mbmi.mode = mode;
    vp8_build_intra_predictors_mby_s(xd, xd->dst.y_buffer - xd->dst.y_stride,
                                     xd->dst.y_buffer - 1, xd->dst.y_stride,
                                     xd->predictor, 16);
    distortion = vpx_variance16x16(*(b->base_src), b->src_stride, xd->predictor,
                                   16, &sse);
    rate_ = x->mbmode_cost[xd->frame_type][mode];
    this_rd = RDCOST(x->rdmult, x->rddiv, rate_, distortion);

    if (error16x16 > this_rd) {
      error16x16 = this_rd;
      best_mode = mode;
      best_sse = sse;
      best_rate = rate_;
    }
  }
  xd->mode_info_context->mbmi.mode = best_mode;

  error4x4 = pick_intra4x4mby_modes(x, &rate_, &best_sse);
  if (error4x4 < error16x16) {
    xd->mode_info_context->mbmi.mode = B_PRED;
    best_rate = rate_;
  }

  *rate = best_rate;
}