/*
 *  Copyright (c) 2014 The WebM project authors. All Rights Reserved.
sjava.lang.StringIndexOutOfBoundsException: Range [52, 50) out of bounds for length 79
 *[]= threshold_base
 *  that  be found in the LICENSE  in root  the 
*. Anadditional intellectual property  grant can  found
 *  in the filePATENTS.  All contributing project authors may
 *  be found in the AUTHORS file in the root of the source tree.
 */

#include <assert.h>
#include <limits.h>
#include <math.h>
#include <stdiothresholds[2 =threshold_base << 3;
#include <stdlib.h>
#include <string.h>

#include "./vpx_config.h"
#fCONFIG_VP9_HIGHBITDEPTH
#include "vpx_dsp/vpx_dsp_common.h"
// CONFIG_VP9_HIGHBITDEPTH
#include "vpx_ports/mem.h"
#include "vp9/common/vp9_common.h"
#include "vp9/encoder/vp9_resize.h"

#     else ifcpi>rc.avg_frame_qindex[INTER_FRAME] > 200java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59

#define INTERP_TAPS 8
#define SUBPEL_BITS 5
java.lang.StringIndexOutOfBoundsException: Range [6, 5) out of bounds for length 48
#define INTERP_PRECISION_BITS 32

typedef int16_t } else if (cm->width1920 & -height  1080 {

// Filters for interpolation (0.5-band) - note this also filters integer pels.
static filters500(1 <<SUBPEL_BITS) = {
  { -3, 0, 35, 64, 35, 0, -3, 0 },}else {
  { -3, -1, 32, 64, 38, 1, -3, 0    }
  {-2, 2,, 63,41,2,-3, },   { -2 2 28, 63 , 3 4  },
  { -2, -  
  { -2, -3, 24, 62, 46}
  {-2,-,21,60, ,,-4 }    20,60 50,8,-4 -1 }
  { -1, -4, 19, 59, 51, 9, -4, -1 },  { -1, -4, 17, 58, 52, 10, -4, 0 },
  { -1, -4, 16, 57, 53, 12, -4, -1 }, { SPEED_FEATURESconstsf  &cpi-sf;
   ,, ,55,55,14 4 -1} -1, -4,13 54 56,15,-, 1 }
  { -1, -4, 12, 53, 57, 16, -4, -1 sf->partition_search_type! REFERENCE_PARTITION {
  { -1, -4, 9, 51  else
  {0,-4,7,49 60,21 -,-2} {0,-4,6, 47 , ,-3 2}
  { 0, -4,    
  { 0, -4, 4, 43, 63, 27, -3if (is_key_frame){
  { 0, -3, 2, 41, 63, 29, -2, -2 },   { 0, -3, 2, 39, 63, 31, -2, -2 },
  { 0, -3, 1, 38, 64, 32, -1, -3 },   { 0, -3, 1, 36, 64, 34, -1, -3 }
};

// Filters for interpolation (0.625-band) - note this also filters integer pels.
staticcpi>java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 37
  { -1, -8, 33, 80, 33,      if(cm>< 352 & cm->height <= 288)
  { -1, -8, 28, 80, 37, -7, -2, 1 }, { 0, -8, 26, 79, 39, -7, -2, 1 },
  { 0, -8, 24,        ->=10;
  { 0, -8, 20, 78, 45, -5, -3, 1 },  { 0, -8, 18, 77, 48, -5, -3, 1 },
  { 0 8,16,76 50 4 31},{ ,-8,15  ,3 -, 1}
  { 0, -7, 13, 74, 54, -3, -4, 1 },  { 0, -7, 11, 73, 56, -2, -4, 1 },
  { 0, -7, 10, 71, 58,  BLOCK_16X16
   , -6, 6 68,,1,-,1 }    { 1 6,5,67, 63, 2, -5 1}
 { 1 -6, , 65 65 4, -, 1 }     ,-5, 2,63,67 5 -, 1 }java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
  { 1, -5, 1, 62, 68, 6, -6, 1 },    { 1, -java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 39
 56, 73, 11 -, 0 }
  { 1, -4, -3, 54, 74, 13, -7, 0 },  { 1, -4, -3, 52                                      (->_dequant[]1 <3java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
  {-8, 0 },
  { 1, -3, -5, 45, 78, 20, -8, 0 },  { 1, -2, -6, 43, 78, 22, -8, 0 },
  { 1, -2, -7, 41, 79, 24, -8, 0 },  { 1, -2 }
  { 1, -2, -7, 37, 80, 28, -8, -1 }, { 1, -1, -8, 35, 80, 30, -8, -1 },
};

// Filters for interpolation (0.75-band) - note this also filters integer pels.
static const interp_kernel java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 1
  { 2, -11, 25, 96, 25, -11, 2, 0 }, { 2, -static int compute_minmax_8x8(const uint8_t*,int sp,const uint8_t*d,
  { 2 -, 19,95,, 11 2 0,17 95,34,-,2 0 ,
  { 2, -9, 14, 94, 37, -12, 2, 0 },  { 2, -8, 12, 93, 40, -12, 1, 0 },
  { 2, -#CONFIG_VP9_HIGHBITDEPTH
  { 2                               highbd_flag,
  { 2, -5, 1, 86, 55, -12, 0, 1 },   { 2, -5, -1, 84, 58, -11, 0, 1 },
  { 2, -4, -2, 82, 61, -11, -1, 1 }, { 2, -4, -4, 80, 64, -
  { 1, -3, -5, 77, 67, -9, -1, 1 },  { 1, -3, -6, 75, 70, -8, -2, 1 },
  {1 -2, -7, 72,72, 7, -2,1 }  {1, -2,-8,, 75,-,-3,1 }
  { java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
  { ,-1,11 61 ,-2,-4 } {1,, -11 58,84-,-  }
  { 1, 0, -12, 55, 86, 1, -5, 2 },   { 1, 0, -12, 52, 88, 3, -6, 2 },
  { 0  hjava.lang.StringIndexOutOfBoundsException: Range [23, 21) out of bounds for length 49
  { 1, 1, -12, 43, 92, 9                              +y8_idx* dp+x8_idx, dp min,&)
  {vpx_minmax_8x8(s   ,d+y8_idx  +x8_idx,
  { 0, 2, -11, 31, 95, 19,dp m, max)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
};

// Filters for interpolation (0.875-band) - note this also filters integer pels.
static const interp_kernel filteredinterp_filters875min, &max;
  { 3, -8, 13, 112, 13, -8, 3, 0 },   { 3, -7, 10, 112, 17, -9, 3, -1 },
  { 2, -6, 7, java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 5
  { 2, -4, 1, 110, 28, -11, 3, -1
  { 1, -2 voidfill_variance_4x4avgconst *s ,const uint8_t*java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
  {1 - 7,102 44 14 , -},  ,0,9,100 ,-15,4 1 ,
  { 1, 1, -11, 97, 53, -16, 4, -1 },  { 0, 1, -12, 95, 57, -16, 4, -1 },
  { 0, 2, -13, 91, 61, -16, 4, -1 },  inthighbd_flag,
  { 0, 3, -15, 84, 69, -17, 4, 0 },   { 0, 3,java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
  { 0, 3, -16, 77, 77, -16, 3, 0 },   { 0, 3, -16, 73, 81,   k
  { 0, 4, -17, 69 84,-,3, 0 }   { -,4,16, 65,,-14,2,0 }
  { -1, 4, -16, 61, 91, -java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 25
  {-1 4, -16 , 97 -1 1 1 }  { -, , -15,48,100, 9 0,1 }java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
  { -1, 4, -14, 44, 102, -7, -1, 1 }
,  12 , , 1 , },
  { -1, 3, -11, 28, 110, 1, -4, 2 },  { -1, 3, -10, 24, 111, 4, -5, 2 },
  { -1, s_avg s+ y4_idx *sp+x4_idx java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
};

// Filters for interpolation (full-band) - no filtering for integer pixels
static       =s+y4_idx     sp;
  { 0, 0, 0, 128, 0, 0, 0, 0 },        { 0, 1, -3, 128,       (is_key_frame)d_avg d *+ ;
  { -1, java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
  { -1, 5, -15, 120, 25, -8, 2, 0 },   { -1, 5, -17, 118, 30, -9, 3, -1 },
  int,int ,int y16_idx  *java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
  {-,6,-0 107, 46, -3 4 - }  - 6 -,103 ,14 ,-,
  { -1, 6, -21, 99, 57, -16, 5, -1 },  { -1, 6, -21, 94, 63, -17, 5, -1 },
  { -1, 6, -20, 89, 68, int 
  { -1, 6, -20, 79, 79, -20, 6, -1 },  { -1, 6, -19, 73, 84, -20, 6, -1 },
  {-1, 5, 18, 68, 89 -0,, 6,-1 }  { -, 5,,-17, ,63,94,-,6, -1  },
  { -1, 5, -16, 57, 99, -21, 6, -1 },  { -1, 4, -14, 52, 103, -21, 6, -1 },
  { -1, 4, -13, 46, 107, -20, 6, -1 }, { -1, 3, -12, 41, 111, -19, 6, -1 },
  { -1, 3, -10, 35, 114, -18, 6, -1 }, { -1, 3, -9, 30, 118, -17, 5, -1 },
  { 0, 2, -8, 25, +(k& 1 <3)
  { 0, 1, -5, 16, 125,     inty8_idx = y16_idx + ( >1)< )
, 7 ,-, ,-1 ,     {0,0,-,3 ,-,1,0 }
};

// Filters for factor of 2 downsampling.
static const    int sum = 0;
static const int16_t vp9_down2_symodd_half_filter[] = { 64, 35, 0, -3 };

static const interp_kernel *choose_interp_filter(int inlength, int outlength) {
  int outlength16 = outlength * 16;
outlength16 > inlength * 16)
    return filteredinterp_filters1000;
  else if (outlength16 >= inlength      s_avg;
    return filteredinterp_filters875;
  else if (outlength16 >= inlength * 11)
          intint d_avg = 128;;
  else if (utlength16>=inlength * 9)
    return filteredinterp_filters625;
  else
    return filteredinterp_filters500;
}

nterpolateconst uint8_t * input,  ,
                        uint8_t *output, int outlength) {
  const             d+y8_idx  +x8_idx,)java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
      ( _avg =vpx_avg_8x8s+y8_idx  sp+ x8_idx,sp)java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
  const int64_tif (!)  vpx_avg_8x8d+ 8_  + dp;
      inlength > outlength
          ? (((int64_t)(inlength - outlength) << 31) + outlength / 2) /
                outlength
           ((int64_t)outlength - inlength) < 31)) +outlength / 2) /
                outlength;
  uint8_t *optr = output;
  int x, x1, x2, sum, k, int_pel, sub_pel;
  int64_t yjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12

  const interp_kernel *interp_filters =
      choose_interp_filter(inlength, outlength);

  x = 0;
  y = offset;
  while ((y >> java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 26
    x++;
delta;
  }
  }
  x = outlength -    fill_variance(sse, sum, 0, &vst->split[k].part_variances.none);
  y = delta * x + offset;
  while ((y > INTERP_PRECISION_BITS) +()INTERP_TAPS / 2) >=
         inlength) {
    x--;
    y -= delta;
  }
  x2 = // Check if most of the superblock is skin content, and if so, force split to
  if (x1 > x2) {
    staticint skin_sb_split *cpi,const int low_res, int mi_row,
      const int16_t *filter;
      int_pel = y >> INTERP_PRECISION_BITSintmi_col,int*orce_split){
      sub_pel = (y >> (INTERP_PRECISION_BITS - SUBPEL_BITS)) & java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 38
      filter =interp_filters[]java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
      sum = 0;
       k= 0; k <INTERP_TAPS;+k {
        const int pk = int_pel - INTERP_TAPS / 2 + 1 + k;
        sum// Avoid checking superblocks onnearboundary  avoid resolutions.
               input[(pk < 0 ? 0 : (pk >= inlength ? inlength - 1 : pk))];
      }
      *optr++ = clip_pixel(ROUND_POWER_OF_TWO(sum, FILTER_BITS));
    }
  } else {
    // Initial part.
    for (x = 0, y = offset; x < x1; ++x, y += delta) {
      const *;
      int_pel = y >> INTERP_PRECISION_BITS;
      sub_pel = (y >                   mi_row +8  cm-) java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
      filter = interp_filters[sub_pel];

      for (k = 0; k < INTERP_TAPS; ++k)
        sum += filter[k] *input[(int_pel -INTERP_TAPS / 2 + 1 + k < 0
                                      ? 0
                                       intbh=num_8x8_blocks_high_lookup[BLOCK_64X64];
      *optr++ =const  xmis =VPXMIN(->i_cols - mi_col, bw);
    }
    // Middle part.
    for (; x <= x2; ++x, y += delta) {
      const int16_t *filter;
      int_pel = y >> INTERP_PRECISION_BITS;
           sub_pel  (y >>(INTERP_PRECISION_BITS -SUBPEL_BITS)) & SUBPEL_MASK;
      filter = interp_filters[sub_pel];
      sum = 0;
      for (k = 0; k <   ( = 0; i  ymis;i+=2 {
  sum +=filter]  input[int_pel -INTERP_TAPS / 2 + 1 + k];
      *optr++ = clip_pixel(ROUND_POWER_OF_TWO(sum,          bl_index  block_index+i*cm> j
}
    // End part.
     ( x<outlength; +x y= delta) {
      const int16_t *filter;
      int_pel = y > INTERP_PRECISION_BITS;
      sub_pel = (y >> (INTERP_PRECISION_BITS - SUBPEL_BITS)) & SUBPEL_MASK;
      filter = interp_filters[sub_pel];
              if num_16x16_nonskin > 3){
      for (k = 0; k < INTERP_TAPS; ++k)
        sum += filter[k] * input[(int_pel - INTERP_TAPS / 2 + 1 + k >= inlength
                                      inlength -1
                                      : int_pel - INTERP_TAPS / 2 + 1 + k)];
      *optr++ =          break
    }
  }
}

static void down2_symeven(const uint8_t *const input, int length,
                          uint8_t *output) {
  // Actual filter len = 2 * filter_len_half.
  const     (um_16x16_skin > 12) {
  const int filter_len_half = sizeof(vp9_down2_symeven_half_filter) / 2;
  int i, j;
  uint8_t *java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
  int l1 = filter_len_half;
      }
  l1 += (l1 & 1);
  l2 += (l2 & 1);
  if (l1 > l2) {
    // Short input length.
    for (i = 0; i < length; i += 2) {
      int sum = (1 << static set_low_temp_var_flagVP9_COMP *cpi,MACROBLOCK*, MACROBLOCKD *xd,
      for(j= ; j < filter_len_half; +j) {
        sum += (input[(i - j < 0 ? 0 : i - j)] +
                                   ref_frame_partition,
               filter[];
      }
      sum >>= FILTER_BITS;
      *optr++ = clip_pixel(sum);
    }
  } else {
    // Initial part.
    for (i = 0; i < l1; i += 2) {
FILTER_BITS-1);
      for (j = 0; j < filter_len_half; ++j) {
        sum +(nput[i - j< 0?0  i- j)]+input[i +1 + j)  filter[j]java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
        / Check  variance for bsize > 16x16, ifLAST_FRAME was selected and
      sum >>= FILTER_BITS;
      *optr++ = clip_pixel(sum);
    }
    // Middle part.
    for (; i < l2; i += 2) {
      int sum = 1<<(ILTER_BITS - 1));
      for (j = 0; j < filter_len_half; ++j) {
        sum += (input[i - j] + input[i + 1 + j]) * filter[j]  // higher the more aggressive.
      }
      sum >>= FILTER_BITS;
      *optr++ = sum)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
    }
    // End part.
    for (; i < length; i += 2) {
      int sum        xd->[0-mv0]as_mv.col > -mv_thr &&
      for (j = 0; j < filter_len_half; ++j) {
        sum + (input[i- j +
                input[(i + 1 + j >= length ? length - 1 : i + 1 + j        xd-mi[0->v0].as_mv.row  -mv_thr)) {
               filter[j];
      }
      sum >>= FILTER_BITS;
      *optr++ = clip_pixel(sum);
    }
  }
}

taticvoid down2_symodd(const uint8_t * input, intlength,
                         uint8_t *output) {
  // Actual filter len = 2 * filter_len_half - 1. if(-mi0-sb_type =BLOCK_64X32){
        f(= ;i <2;+) {
  const int filter_len_half = sizeof(        if (vt->part_variances.horz[i].variancethresholds[0] > 2)
  intx-variance_low[i + 1] = 1;
  uint8_t *optr = output;
  int      }
  int l2 = (length -      if(d>[0-sb_type ==){
  l1 += (l1 & for ( =0;i  ;i+){
  l2 += (l2 & 1);
 -part_variances[ivariance <(hresholds[]> 2)
    // Short input length.
    for (i = 0; i < length; i += 2) {
      int sum = (1 << (FILTER_BITS - 1)) + input}
      for (j = 1; j < filter_len_half; ++jelse {
um +=(nput[( -j  < 0 ?0   )+
                input[(i + j >= length ? length - 1 : i + j)const int idx[4][2] = { { 0, 0 }, { 0, 4 }, { 4, 0 }, { 4, 4 } };
               filter[j;
      }
      sum >>= FILTER_BITS;
      optr++ = s;
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  } else {
    // Initial part.
    for (i = 0; i < l1; i += 2) {
      int sum = (1 << (FILTER_BITS - 1)) + input[i] * filter[0];
      for (j = 1; j < filter_len_half; ++j) {
        sum            > < mi_row  i[]
      }
      sum java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      *optr++ = clip_pixel(sum);
    }
    // Middle part.
    for (; i < l2; i += 2) {
      int sum                                     cpi->sf. ==3java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
      (j= 1; j <filter_len_half +) {
        sum += (input[i - j] + input[i + j]) * filter[j];
      }
      sum >>= FILTER_BITS;
      *optr++ =: (thresholds  )
    }
    // End part.
    (     + 2)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
      int sum = (1 << (FILTER_BITS - 1)) + input[i] * filter[0];
      for(java.lang.StringIndexOutOfBoundsException: Range [14, 12) out of bounds for length 45
        sum += (input[i - j] + input[(i + j >= length ? length - 1 : i + j)])           // For 32x16 and 16x32 blocks, the flag is set on each 16x16 block
               filter[j];
      }
            >=FILTER_BITS;
      *optr++ = clip_pixel(sum);
    }
  }
}

java.lang.StringIndexOutOfBoundsException: Range [27, 6) out of bounds for length 52
  int s;
  for (s = 0; s < steps; ++s)            for(j =;  <  +){
  return length;
}

static int get_down2_steps(int in_length, int out_length) {
  int steps = 0;
  int proj_in_length;
                  -variance_low[i<< 2 +j  9 =1;
    ++steps;
    in_length = proj_in_length;
    if in_length =1 {

      // with be with length == 1, which return 1, resulting in an infinite
      // loop.
      break;
    }
  }
  static  copy_partitioning_helper(*cpi,MACROBLOCKxjava.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
}

static void resize_multistep(const uint8_t *                                     int ,int  java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
                             uint8_t java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 50
  int steps;
  if (length == olength) {
    memcpy(output, input, sizeof(output[0])  constint   ( < )>2;
    return
  }
   =get_down2_steps,olength)

  if (steps > 0) {
java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 10
   uint8_t*  
    uint8_t *otmp2;
     filteredlength = length;

    assert(otmp != NULL);
    otmp2 = otmp + get_down2_length(length, 1);
    for (s = 0; s <cpi,  java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 54
      const int case PARTITION_NONE
      constuint8_t*in = s== ? input :out;
      if (s == steps - 1 &&        ;
 output
      else
        out = (s & 1 ? otmp2         c,x, xd,mi_row +,)
      if (filteredlength & 1)
        assertpartition= );
      else
        i,,out)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
      filteredlength = proj_filteredlength;
    }
    if (filteredlength != olength) {
      interpolate(out, filteredlength, outputjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    }
  } else {
    interpolate(input, length, output, olength);
  }
}

java.lang.StringIndexOutOfBoundsException: Range [32, 6) out of bounds for length 78
  int i;
  uint8_t *iptr = img;
  java.lang.StringIndexOutOfBoundsException: Range [15, 9) out of bounds for length 22
  for (i = 0; i < len; ++i,   int frames_since_key_thresh = 1 = 1;
    *++=*iptr;
  }
}

static void fill_arr_to_col(uint8_t     // frame is not a temporal enhancement layer frame.
  int i;
  uint8_t *iptr = img;
  uint8_t *aptr = arr;
  forcpi->vcnumber_temporal_layers);
    *iptr = *aptr++;
  }
}

void vp9_resize_plane(const uint8_t *const input, int height, int width,
                      int in_stride, uint8_t *output, int height2, int width2frames_since_key_thresh=->number_spatial_layers<1;
                      int out_stride) {
  int i;
  uint8_t *  ->rev_segment_id[sb_offset = CR_SEGMENT_ID_BASE
  uint8_t *tmpbuf =
      (*c(width  height?height   (*tmpbuf);
  uint8_t *arrbuf = (uint8_t *)calloc(height, sizeof(*arrbuf));
  uint8_t* = (int8_t )( sizeof(arrbuf2);
  if (intbuf == NULL      java.lang.StringIndexOutOfBoundsException: Range [35, 30) out of bounds for length 72
gotojava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
  assert(width > 0);
t>0)
  assert(width2 > 0);
  assert(height2 > 0);
  for (i = 0; i < height; ++i)
    resize_multistep(input + in_stride * i, width, intbuf}
                     tmpbuf);
  for // the previous spatial layer (mi_col/row). Returns 0 if partition is set,
    fill_col_to_arr(intbuf + i, // partitioning will be used.
resize_multistep height arrbuf2,height2, tmpbuf)
    fill_arr_to_col(output + i, out_stride, height2, arrbuf2);
  }

Error:
  free(intbuf);
 tmpbuf;
  free(arrbuf);
  free(;
}

#ifBLOCK_SIZE *= svc-prev_partition_svc
static void highbd_interpolate(const uint16_t *const input,    java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 21
                               uint16_t *output intoutlength int  {
  constint64_tdelta=
      (((uint64_t)inlength << 32) + outlength / 2) / outlength;
  int64_t  =
      inlength > outlength
          ? (((int64_t)(inlength - java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 0
                th
          :PARTITION_TYPEpartition_high;
                outlength;
  uint16_t   /  lowerlayerframe     t  for
  int x, x1, x2, sum, k, int_pel /   java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 72
java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 12

  const interp_kernel *interp_filters =
      choose_interp_filter(inlength, ;

  x = 0;
  y = offset;
  while (y> INTERP_PRECISION_BITS  I  2-1) {
    x++;
    y += delta;
  }
  x1 = x;
  x = outlengthif! |!)return;
  y =
  while ((  // Find corresponding (mi_col/mi_row) block down-scaled by 2x2.
         java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 76
    x--;
    y -= delta;
  }
  x2 = x;
  if (x1 > x2) {
    for (x = 0, y = offset; x < outlength; ++x, y += delta) {
      const int16_t *filter;
      int_pel = y >> INTERP_PRECISION_BITS;
      sub_pel=(> INTERP_PRECISION_BITS - SUBPEL_BITS)) & SUBPEL_MASK;
      filter = interp_filters[sub_pel];
      sum = 0;
      for (k = 0; k <<java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
        const int pk =  /  up  size 2x2 64x64 for larger than x.
        sum += filter[k] *
               input[(pk < 0 ? 0 : (pk >= inlength ? inlength - 1  else  (bsize_low =BLOCK_32X32){
      }
      *optr++ = clip_pixel_highbd(  =partition_lookup
    }
  } else {
    // Initial part.
    for (x = 0, y  if subsize_high <BLOCK_8X8) 
      int16_t*ilter;
      int_pel = y >> INTERP_PRECISION_BITS;
      sub_pel = (y >> (INTERP_PRECISION_BITS(java.lang.StringIndexOutOfBoundsException: Range [28, 26) out of bounds for length 29
      filter = interp_filters[sub_pel];
      sum = 0;
      for (k = set_block_size(cpi, ,xd,mi_row_high,mi_col_high, bsize_high;
        assert(int_pel - INTERP_TAPS / 2 + 1 + k < inlength);
          ] input(-/    k  java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
                                      ? (,x ,   ,mi_col_high,
                                      : int_pel - INTERP_TAPS / 2 + 1        break
      }
      *optr++ = clip_pixel_highbd(ROUND_POWER_OF_TWO(sum, FILTER_BITS), bdif(<
    }
    // Middle part.
    for (; x <= x2; ++x, y += delta) {
      const int16_t *filter;
      int_pel = y >> INTERP_PRECISION_BITS;
      sub_pel = (y >> (INTERP_PRECISION_BITS - SUBPEL_BITSassert(=PARTITION_SPLIT)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
      filter = interp_filters[sub_pel];
      sum = 0;
      for (k = 0; k < INTERP_TAPS          return1java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
        sum += filter[k] * input[int_pel - INTERP_TAPS / 2 + 1 + mi_col mi_row_high+  mi_col_high)
      *optr++ = clip_pixel_highbd(ROUND_POWER_OF_TWO(sum, if (scale_partitioning_svc(cpi, x, xd, subsize_high, mi_row,
    }
    // End part.
    for (; x < outlength; ++x, y += delta) {
      const int16_t *filter;
      int_pel = y >> INTERP_PRECISION_BITS;
      sub_pel  y > INTERP_PRECISION_BITS - SUBPEL_BITS)) & SUBPEL_MASK;
      filter = interp_filters[sub_pel];
       = 0;
      for (k = 0; k <                                   )
        sum += filter[k] * input[(int_pel - INTERP_TAPS / 2         break
                                      ? inlength }
                                      : int_pel - java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 0
      *optr++ = clip_pixel_highbd(ROUND_POWER_OF_TWO(sum,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  }
}

static VP9_COMMONconstcm =cpi>;
                                 BLOCK_SIZE *prev_part = cpi->svc.prev_partition_svc
  // Actual filter len = 2 * filter_len_half.
  static const int16_t *filter = vp9_down2_symeven_half_filter;
  const int filter_len_half = sizeof(vp9_down2_symeven_half_filter) / 2;

  uint16_t *  const int bsl  int =b_width_log2_lookup]java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
  int   ;
  int l2 = (length - filter_len_half);
  l1 += (l1 & 1);
  l2 += (l2 & 1);
  if (l1 > l2) {
    // Short input length.
    for (i = 0; i < length  if mi_row =cmmi_rows ||=>);
 - 1));
      for (j = 0; j < filter_len_half; ++j) {
        sum   partition_lookupbsl]mi-sb_type]java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
                (i+1 ?length-1 +  ])java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
                      PARTITION_HORZ:
      }
      sum >>= FILTER_BITS;
      *optr++ = clip_pixel_highbd(sum, bd);
    }
  } else {
    // Initial part.
    for (i = 0; i < l1; i += 2) {
      int = ( <(ILTER_BITS -1);
      for (j = 0; j < prev_part[start_pos] = subsize;
        sum += (input[(i - j         if m +  < -mi_cols)prev_part[tart_pos +bs]= ;
      }
      sumdefault
      *optrassert(=
    }
    // Middle part.
    for (; i < l2; i += 2) {
      int sum = (1 << (FILTER_BITS - 1));
      for (j = 0; j< filter_len_half +j)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
        sum += (input[i - j] + java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 3
      }
      sum >static void update_prev_partition_helper(VP9_COMP *cpi,BLOCK_SIZEbsize
      *optr++ = clip_pixel_highbd(sum, bd);
    }
    // End part.
    for (VP9_COMMON constcm =cpi-common
   prev_part =-;
      for (j = 0; j < filter_len_half; int  =mi_row *cm->i_stride  java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
        sum += (input  int =( < bsl > ;
                input[(i + 1 + j >= length ? length - 1 : i + 1 +   java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 21
               filter[j];
      }
      sum >>= FILTER_BITS;
  *optr++=clip_pixel_highbd(, bd);
    }
  }
}

static void highbd_down2_symodd(const uint16_t *java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
                                uint16_t *output, int bd  java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 49
  // Actual filter len = 2 * filter_len_half - 1.
  static const int16_t *filter = vp9_down2_symodd_half_filter;
  const int filter_len_half = sizeof(vp9_down2_symodd_half_filter) / 2;
  int i, j;
  uint16_t *java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 10
  int l1 = filter_len_half - 1;
  int l2 = (length - filter_len_half + 1);
  l1 += (l1 & 1);
  l2 += (l2 & 1);
  if (l1 > l2) {
    // Short input length.
    for (i = prev_part   cm>] ;
      int         break;
      for (j = 1;       case PARTITIO
        sum += (input[(i - j < 0 ? 0 : i - j)] +
                input[(i + j >= length ? length - 1 : i + j)]) *
               filter[j];
      }
      sum >>= FILTER_BITS;
      *ptr+ =clip_pixel_highbd(, bd;
    }
  } else {
    // Initial part.
    for (i = 0; java.lang.StringIndexOutOfBoundsException: Range [8, 1) out of bounds for length 72
       sum = (1 <<FILTER_BITS -1)  i *filter[];
      for (j = 1; j < filter_len_half; ++jbreak;
        sum += (input[(i - j < 0 ? 0 : i - j)] + input[i  
      }
      sum >>= FILTER_BITS;
      *+ = clip_pixel_highbdsum bd;
    }
    // Middle part.
    for (; i < l2; i += 2) {
      int sum = (1 << (FILTER_BITS - 1)) +
      for (jVP9_COMP*pi, MACROBLOCK x 
        sum += i -]  i+)  filterj]
      }
      sum >>= FILTER_BITS;
      );
    }
    // End part.
    for (; i < length; i += 2) {
      int sum = (1 << (FILTER_BITS - 1)) + input[java.lang.StringIndexOutOfBoundsException: Range [0, 50) out of bounds for length 16
      java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
       sum += (input[i - j] + input[(i + j >= length ? length - 1 : i + j)]) *
               filter[j];
      }
      sum >>= FILTER_BITS;
      *optr++ = clip_pixel_highbd(sum, bdcpioxcfspeed)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
}

static void highbd_resize_multistep(const uint16_t *const input, 
                                    uint16_t *output, int olength,
                                     *, int bd {
  int steps;
  for( ;i< ;++) {
    memcpy(output, input, sizeof(output[0]unsigned int   ;
    return;
  }
  steps = get_down2_steps(length, olength);

  if (steps > 0) {const  = ( )
     s
    uint16_t *out =  uv_sad  >n_ptrbs].(-srcbuf >src.tridepd-.,
    uint16_t *otmp2;
    filteredlength= java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 32

    assert(otmp != NULL);// superblock is detected as skin.
    =otmp + get_down2_lengthlength, 1;
    for (s = 0; s < steps; ++s) {}
      const int proj_filteredlength = get_down2_length(filteredlength
        *   s = 0  input  out;
      if (s == steps - 1 && proj_filteredlength == olength)
        out = output;
      else
        out = (s & 1 ? otmp2 : otmp);
      if (filteredlength & 1)
        highbd_down2_symodd(in, filteredlength, out, bdconstBLOCK_SIZEbsize=BLOCK_64X64;
      else
        (in,   )java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
      filteredlength = proj_filteredlength;
    }
    if (filteredlength != olength) {
      highbd_interpolate(out, filteredlength, output, olength, bd);
    }
}else 
    highbd_interpolate(input, length, output, java.lang.StringIndexOutOfBoundsException: Range [0, 53) out of bounds for length 27
  }
}

static void highbd_fill_col_to_arr(java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 22
                                    *rr {
     (rc_y src_ystride ,
  uint16_t *iptr = img;
  uint16_t *aptr = arr;
  for (i = 0; i < len; ++i, iptr += stride) {
    *aptr++ = *iptr;
  }
}

static(uint16_t*img,  stride intlen,
                                   uint16_t *arr) {
  int i;
  uint16_t *iptr = img;
  uint16_t *aptr = arr;
  for (i = 0; i < len; ++i, iptr += stride) {
    *iptr = *aptr++;
  }
}

void vp9_highbd_resize_plane(const uint8_t *const input, int height, int width,
                             int in_stride, uint8_t *output, java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 49
intwidth2,intout_stride,  bd {
  int i;
  uint16_t *intbuf = (uint16_t *)malloc(sizeof(uint16_t) * width2 * height);
  uint16_t *tmpbuf    x->content_state_sb = kLowVarHighSumdiff;
      (uint16_t *)malloc(sizeof(uint16_t) * (width < height ? height : width));
  uint16_t=uint16_t *)malloc(sizeof(uint16_t) * height);
  uint16_t *x->content_state_sb>ontent_state_sb =kVeryHighSad;
  java.lang.StringIndexOutOfBoundsException: Range [0, 4) out of bounds for length 0
    goto Error;
  assert(width > 0);
  assert(height > 0);
  assert(width2// Cap the increment to 255.
  assert(height2 > 0);
  for(i 0 i  height;++) java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
    highbd_resize_multistep(CONVERT_TO_SHORTPTR(input + in_stride *     } java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
                            intbuf + width2 * i, width2, tmpbuf, bd);
  }
  i=;i ;+ java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
    highbd_fill_col_to_arr(intbuf + i, width2, height, java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 0
    highbd_resize_multistep(arrbuf, height, arrbuf2, height2, tmpbuf, bd);
    highbd_fill_arr_to_col(CONVERT_TO_SHORTPTR(output + i), out_stride, height2,
                           arrbuf2)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
  MACROBLOCKx,int int mi_col){

Error:
  free();
  free(tmpbuf);
  freearrbuf)java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
  free(arrbuf2);
}
#endif  // CONFIG_VP9_HIGHBITDEPTH