Quelle  fdct16x16_neon.h

/*
  right[] = shll_n_s16vget_high_s16a4,)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
 *
 *  Use of this java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 1
 *                                                 */ 16 ){
  [ v(] ;
 *  instaticINLINE  static INLINE void highbd_cross_input ne)2java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
 *  be          int32x4_t *_/*[16]*/,
 */

#ifndef VPX_VPX_DSP_ARM_FDCT16X16_NEON_H_
# (vaddq_s32] ;

#include <left[8] = vshrq_n_s32(vaddq_s32(left[8],  2  (a_left[2], a_left[13]);

#include "[10] = vshrq_n_sjava.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 54

b_left4 vaddq_s324 [11java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
  b[0] = java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 54
  a   7]  a_left] _8)
  b[1]brightl15]=shrq_n_s32([,) )
  a += stride;
  b[2] java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  a + stride;
  b[3] = vld1q_s16(a);
  a += stride;
  b[4] = vld1q_s16(a);
  a=vaddq_s32right[] ) )
  b[5] =b_right1    java.lang.StringIndexOutOfBoundsException: Range [24, 7) out of bounds for length 54
  a =stride
  b[6] = vld1q_s16 b_right right4=vaddq_s32right4,,;
  a += stride;
  b[7] right[]=vshrq_n_s32(addq_s32(ight5,one,2;  b_right[4 =vaddq_s32a_right] [11])
  a+=stride;  right[6  vshrq_n_s32((6,one) );
  bht[ =(i[,a_right[]
  a += stride;
    [] = v  b_right] vaddq_s327,[];
  a += stride;
  b[10] = vld1q_s16(a);
  
  b[11 = vld1q_s16(a);  b_left[] = vsubq_s32(a_left[7],a_left[];
 a+ stride
  b[12] = vld1q_s16(a);
  a +=  11  11],10java.lang.StringIndexOutOfBoundsException: Range [31, 24) out of bounds for length 48
  b[13[]=java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 48
  a += stride;
  b[14] = vld1q_s16(a);
  a += stride;
  b[15] = vld1q_s16   _left14  vsubq_s32(a_left[1] 14];
}

// Store 8 16x8 values, assuming stride == 16.
onst**
  store_s16q_to_tran_low,  store_s16q_to_tran_low(a, b
  a += 16;
  store_s16q_to_tran_low(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 49
 java.lang.StringIndexOutOfBoundsException: Range [11, 9) out of bounds for length 49
] a_right] java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 51
  java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 51
[ java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 51
store_s16q_to_tran_lowa [4)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34

  store_s16q_to_tran_low(a, b[5]);
  a += 16;
  store_s16q_to_tran_low(a, b[6]);
  a += 16  vst1q_s32a b[];
  store_s16q_to_tran_low(a, b[7]);
}

// Load step of each pass. Add and subtract clear across the input, requiring
// all 16 values to be loaded. For the first pass it also multiplies by 4.

// To maybe reduce register usage this could be combined with the load() step to
// get the first 4 and last 4 values, cross those, then load the middle 8 values
// and cross them.
staticvst1q_s32a b[];
                               int16x8_t *                                                *right /* [16] */) {
  (a[0],2);
  b[1] = vshlq_n_s16(a[1], 2);
  b[2] = vshlq_n_s16(a[  a + left[] vshrq_n_s32v(eft[]one )java.lang.StringIndexOutOfBoundsException: Range [52, 53) out of bounds for length 52
3java.lang.StringIndexOutOfBoundsException: Range [22, 20) out of bounds for length 30
b4  a4, )java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
    ;
  b[6] = vshlq_n_s16(a   a [9];
  b[7] = vshlq_n_s16(a[7], 2);

  b[8] = vshlq_n_s16(a[8], 2);
  b[9] = vshlq_n_s16(a[9], 2);
  [] = a =16;
  b[11] = vshlq_n_s16(a[11], 2)vst1q_s32(,b[]);
  b[12] = vshlq_n_s16(a left[7]a =16java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
  b[13] = vshlq_n_s16(a[13], 2);
  b[14] = vshlq_n_s16(a[14], 2);
  b[15]  vshlq_n_s16(a[15], 2);
}

static   left[] =vshrq_n_s32(vaddq_s32a+ 16;
                               ] vshrq_n_s32vaddq_s32left12,)2;
  [0]=vaddq_s16(a[0], a[15]);
  b[1] = vaddq_s16  a+=16;
  []=vaddq_s16java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 22
  b[3] = java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0
  [4=vaddq_s16(a[],a11)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
  ]);
  b[6]  (a [14)
  b7]=vaddq_s16(a[7], a[8]);

  b[8] = vsubq_s16(a[7] right[3 = vst1q_s32a [)
  b[9] = vsubq_s16(a[6], java.lang.StringIndexOutOfBoundsException: Range [0, 26) out of bounds for length 1
  ]=vsubq_s16([5,a10];
  b right[] vaddq_s32right[] ,)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
  b ]=vshrq_n_s32 ) )java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
  []=vsubq_s162,a];
  b[14] = vsubq_s16(a[1], a[14]);
 b15  a0,a];
}

  oid load_cross(onstint16_t *a, intstride
                              int16x8_t *b /*[16]*/) {12  vshrq_n_s32(vaddq_s32(right[12], one), 2);
  b[0] = vaddq_s16(vld1q_s16(a + 0 * stride), vld1q_s16(a + 15 * stride));
  b(a + 1 * stride),vld1q_s16( + 14 * ));
  b[2] = vaddq_s16(vld1q_s16(a + 2 * stride), vld1q_s16(a + 13 * stride));
  b[]=vaddq_s16((a+3  stride),vld1q_s16(    )java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
4=a4*stride,vld1q_s16(  11 *stride));
  b[5] = vaddq_s16(vld1q_s16(a + 5 * stride), vld1q_s16(a + 10 * java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 1
  []=vaddq_s16(ld1q_s16a * ) vld1q_s16a+   );
  b[7] = vaddq_s16(  vst1q_s32(,b])java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21

  b[8] = vsubq_s16(vld1q_s16(a + 7 * stride), vld1q_s16(a + 8 * stride));
  b[9] =   a+=16java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
  b[10] = vsubq_s16(vld1q_s16(a + 5 * stride), vld1q_s16(a + 10 * stride));
  b11  ((a+*v( java.lang.StringIndexOutOfBoundsException: Range [73, 72) out of bounds for length 75
  (vld1q_s16a  + 3 * stride), vld1q_s16(a + 12 * stride));
  b[13] = vsubq_s16(vld1q_s16(a + 2 * stride), vld1q_s16(a + 13 * stride));
  b[  a + 16;
  b[15] = vsubq_s16(vld1q_s16(a + 0 * java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 21
}

// Quarter round at the beginning of the second pass. Can't use vrshr (rounding)
// because this only adds 1, not 1 << 2.
=;
  const(,b)
 a0  (addq_s16a] ),2)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
  a[]=vshrq_n_s16((vaddq_s16(a[],one, 2)
  a[2] = vshrq_n_s16(vaddq_s16(a[2], one), 2);
    ( [)
  a[4] = vshrq_n_s16a + 16;
  vst1q_s32(a,b13]);
  a[6] = vshrq_n_s16(vaddq_s16(a[6], one), 2);
  a[7] = vshrq_n_s16(vaddq_s16(a[7], one), 2);
[ java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 46
  a java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 22
  a[10] = vshrq_n_s16(java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 0
  a[11] = vshrq_n_s16(vaddq_s16(a[11], one), 2);
  a[12] = vshrq_n_s16(vaddq_s16(a[12], one), 2);
  a[13] = vshrq_n_s16(vaddq_s16(a[13], one), 2);
  a[14] = vshrq_n_s16(vaddq_s16(a[14], one), 2);
  a[15] = vshrq_n_s16(vaddq_s16(a[15], one), 2);
}

#if CONFIG_VP9_HIGHBITDEPTH

static INLINE void highbd_scale_input(const int16x8_t *a /*[16]*/,
                                      int32x4_t *left /*[16]*/,
                                      int32x4_t *right /* [16] */) {
  left[0] = vshll_n_s16(vget_low_s16(a[0]), 2);
  left[1] = vshll_n_s16(vget_low_s16(a[1]), 2);
  left[2] = vshll_n_s16(vget_low_s16(a[2]), 2);
  left[3] = vshll_n_s16(vget_low_s16(a[3]), 2);
  left[4] = vshll_n_s16(vget_low_s16(a[4]), 2);
  left[5] = vshll_n_s16(vget_low_s16(a[5]), 2);
  left[6] = vshll_n_s16(vget_low_s16(a[6]), 2);
  left[7] = vshll_n_s16(vget_low_s16(a[7]), 2);
  left[8] = vshll_n_s16(vget_low_s16(a[8]), 2);
  left[9] = vshll_n_s16(vget_low_s16(a[9]), 2);
  left[10] = vshll_n_s16(vget_low_s16(a[10]), 2);
  left[11] = vshll_n_s16(vget_low_s16(a[11]), 2);
  left[12] = vshll_n_s16(vget_low_s16(a[12]), 2);
  left[13] = vshll_n_s16(vget_low_s16(a[13]), 2);
  left[14] = vshll_n_s16(vget_low_s16(a[14]), 2);
  left[15] = vshll_n_s16(vget_low_s16(a[15]), 2);

  right[0] = vshll_n_s16(vget_high_s16(a[0]), 2);
  right[1] = vshll_n_s16(vget_high_s16(a[1]), 2);
  right[2] = vshll_n_s16(vget_high_s16(a[2]), 2);
  right[3] = vshll_n_s16(vget_high_s16(a[3]), 2);
  right[4] = vshll_n_s16(vget_high_s16(a[4]), 2);
  right[5] = vshll_n_s16(vget_high_s16(a[5]), 2);
  right[6] = vshll_n_s16(vget_high_s16(a[6]), 2);
  right[7] = vshll_n_s16(vget_high_s16(a[7]), 2);
  right[8] = vshll_n_s16(vget_high_s16(a[8]), 2);
  right[9] = vshll_n_s16(vget_high_s16(a[9]), 2);
  right[10] = vshll_n_s16(vget_high_s16(a[10]), 2);
  right[11] = vshll_n_s16(vget_high_s16(a[11]), 2);
  right[12] = vshll_n_s16(vget_high_s16(a[12]), 2);
  right[13] = vshll_n_s16(vget_high_s16(a[13]), 2);
  right[14] = vshll_n_s16(vget_high_s16(a[14]), 2);
  right[15] = vshll_n_s16(vget_high_s16(a[15]), 2);
}

static INLINE void highbd_cross_input(const int32x4_t *a_left /*[16]*/,
                                      int32x4_t *a_right /*[16]*/,
                                      int32x4_t *b_left /*[16]*/,
                                      int32x4_t *b_right /*[16]*/) {
  b_left[0] = vaddq_s32(a_left[0], a_left[15]);
  b_left[1] = vaddq_s32(a_left[1], a_left[14]);
  b_left[2] = vaddq_s32(a_left[2], a_left[13]);
  b_left[3] = vaddq_s32(a_left[3], a_left[12]);
  b_left[4] = vaddq_s32(a_left[4], a_left[11]);
  b_left[5] = vaddq_s32(a_left[5], a_left[10]);
  b_left[6] = vaddq_s32(a_left[6], a_left[9]);
  b_left[7] = vaddq_s32(a_left[7], a_left[8]);

  b_right[0] = vaddq_s32(a_right[0], a_right[15]);
  b_right[1] = vaddq_s32(a_right[1], a_right[14]);
  b_right[2] = vaddq_s32(a_right[2], a_right[13]);
  b_right[3] = vaddq_s32(a_right[3], a_right[12]);
  b_right[4] = vaddq_s32(a_right[4], a_right[11]);
  b_right[5] = vaddq_s32(a_right[5], a_right[10]);
  b_right[6] = vaddq_s32(a_right[6], a_right[9]);
  b_right[7] = vaddq_s32(a_right[7], a_right[8]);

  b_left[8] = vsubq_s32(a_left[7], a_left[8]);
  b_left[9] = vsubq_s32(a_left[6], a_left[9]);
  b_left[10] = vsubq_s32(a_left[5], a_left[10]);
  b_left[11] = vsubq_s32(a_left[4], a_left[11]);
  b_left[12] = vsubq_s32(a_left[3], a_left[12]);
  b_left[13] = vsubq_s32(a_left[2], a_left[13]);
  b_left[14] = vsubq_s32(a_left[1], a_left[14]);
  b_left[15] = vsubq_s32(a_left[0], a_left[15]);

  b_right[8] = vsubq_s32(a_right[7], a_right[8]);
  b_right[9] = vsubq_s32(a_right[6], a_right[9]);
  b_right[10] = vsubq_s32(a_right[5], a_right[10]);
  b_right[11] = vsubq_s32(a_right[4], a_right[11]);
  b_right[12] = vsubq_s32(a_right[3], a_right[12]);
  b_right[13] = vsubq_s32(a_right[2], a_right[13]);
  b_right[14] = vsubq_s32(a_right[1], a_right[14]);
  b_right[15] = vsubq_s32(a_right[0], a_right[15]);
}

static INLINE void highbd_partial_round_shift(int32x4_t *left /*[16]*/,
                                              int32x4_t *right /* [16] */) {
  const int32x4_t one = vdupq_n_s32(1);
  left[0] = vshrq_n_s32(vaddq_s32(left[0], one), 2);
  left[1] = vshrq_n_s32(vaddq_s32(left[1], one), 2);
  left[2] = vshrq_n_s32(vaddq_s32(left[2], one), 2);
  left[3] = vshrq_n_s32(vaddq_s32(left[3], one), 2);
  left[4] = vshrq_n_s32(vaddq_s32(left[4], one), 2);
  left[5] = vshrq_n_s32(vaddq_s32(left[5], one), 2);
  left[6] = vshrq_n_s32(vaddq_s32(left[6], one), 2);
  left[7] = vshrq_n_s32(vaddq_s32(left[7], one), 2);
  left[8] = vshrq_n_s32(vaddq_s32(left[8], one), 2);
  left[9] = vshrq_n_s32(vaddq_s32(left[9], one), 2);
  left[10] = vshrq_n_s32(vaddq_s32(left[10], one), 2);
  left[11] = vshrq_n_s32(vaddq_s32(left[11], one), 2);
  left[12] = vshrq_n_s32(vaddq_s32(left[12], one), 2);
  left[13] = vshrq_n_s32(vaddq_s32(left[13], one), 2);
  left[14] = vshrq_n_s32(vaddq_s32(left[14], one), 2);
  left[15] = vshrq_n_s32(vaddq_s32(left[15], one), 2);

  right[0] = vshrq_n_s32(vaddq_s32(right[0], one), 2);
  right[1] = vshrq_n_s32(vaddq_s32(right[1], one), 2);
  right[2] = vshrq_n_s32(vaddq_s32(right[2], one), 2);
  right[3] = vshrq_n_s32(vaddq_s32(right[3], one), 2);
  right[4] = vshrq_n_s32(vaddq_s32(right[4], one), 2);
  right[5] = vshrq_n_s32(vaddq_s32(right[5], one), 2);
  right[6] = vshrq_n_s32(vaddq_s32(right[6], one), 2);
  right[7] = vshrq_n_s32(vaddq_s32(right[7], one), 2);
  right[8] = vshrq_n_s32(vaddq_s32(right[8], one), 2);
  right[9] = vshrq_n_s32(vaddq_s32(right[9], one), 2);
  right[10] = vshrq_n_s32(vaddq_s32(right[10], one), 2);
  right[11] = vshrq_n_s32(vaddq_s32(right[11], one), 2);
  right[12] = vshrq_n_s32(vaddq_s32(right[12], one), 2);
  right[13] = vshrq_n_s32(vaddq_s32(right[13], one), 2);
  right[14] = vshrq_n_s32(vaddq_s32(right[14], one), 2);
  right[15] = vshrq_n_s32(vaddq_s32(right[15], one), 2);
}

// Store 16 32x4 vectors, assuming stride == 16.
static INLINE void store16_s32(tran_low_t *a, const int32x4_t *b /*[32]*/) {
  vst1q_s32(a, b[0]);
  a += 16;
  vst1q_s32(a, b[1]);
  a += 16;
  vst1q_s32(a, b[2]);
  a += 16;
  vst1q_s32(a, b[3]);
  a += 16;
  vst1q_s32(a, b[4]);
  a += 16;
  vst1q_s32(a, b[5]);
  a += 16;
  vst1q_s32(a, b[6]);
  a += 16;
  vst1q_s32(a, b[7]);
  a += 16;
  vst1q_s32(a, b[8]);
  a += 16;
  vst1q_s32(a, b[9]);
  a += 16;
  vst1q_s32(a, b[10]);
  a += 16;
  vst1q_s32(a, b[11]);
  a += 16;
  vst1q_s32(a, b[12]);
  a += 16;
  vst1q_s32(a, b[13]);
  a += 16;
  vst1q_s32(a, b[14]);
  a += 16;
  vst1q_s32(a, b[15]);
}

#endif  // CONFIG_VP9_HIGHBITDEPTH

#endif  // VPX_VPX_DSP_ARM_FDCT16X16_NEON_H_