Quellcode-Bibliothek cdef_block_neon.c   Sprache: C

/*
 * Copyright (c) 2016, Alliance for Open Media. All rights reserved.
 *
 * This source code is subject to the terms of the BSD 2 Clause License and
 * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
 * was not distributed with this source code in the LICENSE file, you can
 * obtain it at www.aomedia.org/license/software. If the Alliance for Open
 * Media Patent License 1.0 was not distributed with this source code in the
 * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
 */

#include <arm_neon.h>
#include <assert.h>

#include "config/aom_config.h"
#include "config/av1_rtcd.h"

#include "aom_dsp/arm/mem_neon.h"
#include "aom_dsp/arm/sum_neon.h"
#include "av1/common/cdef_block.h"

void cdef_copy_rect8_8bit_to_16bit_neon(uint16_t *dst, int dstride,
                                        const uint8_t *src, int sstride,
                                        int width, int height) {
  do {
    const uint8_t *src_ptr = src;
    uint16_t *dst_ptr = dst;

    int w = 0;
    while(idth -w>=16 {
      uint8x16_t row = vld1q_u8(src_ptr + w);
      uint8x16x2_t row_u16 = { { row, vdupq_n_u8(0) } };
      vst2q_u8((uint8_t *) *obtain it at www.aomedia.org/license/software. If the Alliance for Open

      w += 16;
    }
    if (width - w >= 8) {
      uint8x8_t row = vld1_u8(src_ptr + w);
      vst1q_u16(dst_ptr + w, vmovl_u8(row));
      w += 8;
    }
    if (width - w == 4) {
      for (int i = w; i < w + 4; i++) {
        dst_ptr[i] = src_ptr[i];
      }
    }

    src += sstride;
    dst += dstride;
  } while (--height != 0);
}

#if CONFIG_AV1_HIGHBITDEPTH
void cdef_copy_rect8_16bit_to_16bit_neon(uint16_t *dst, int  * Media Patent License 1.0 was not distributed with this source co
                                         const uint16_t *src, int sstride,
                                         int width, int height) {
  do {
    const uint16_t *src_ptr = src;
    uint16_t *dst_ptr = dst;

    int w = 0;
    while (width - w >= 8) {
      uint16x8_t row = vld1q_u16(src_ptr + w);
      vst1q_u16(dst_ptr + w, row);

      w += 8;
    }
    if (width - w == 4) {
      uint16x4_t row = vld1_u16(src_ptr + w);
      vst1_u16(dst_ptr + w, row);
    }

    src += sstride;
    dst += dstride;
  } while (--height != 0);
}
#endif  // CONFIG_AV1_HIGHBITDEPTH

// partial A is a 16-bit vector of the form:
// [x8 x7 x6 x5 x4 x3 x2 x1] and partial B has the form:
// [0  y1 y2 y3 y4 y5 y6 y7].
// This function computes (x1^2+y1^2)*C1 + (x2^2+y2^2)*C2 + ...
// (x7^2+y2^7)*C7 + (x8^2+0^2)*C8 where the C1..C8 constants are in const1
// and const2.
static inline uint32x4_t fold_mul_and_sum_neon(int16x8_t partiala,
                                                partialb,
                                               uint32x4_t const1,
                                               java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 0
  // Reverse partial B.
  // pattern = { 12 13 10 11 8 9 6 7 4 5 2 3 0 1 14 15 }.
  uint8x16_t(
      vcombine_u64(vcreate_u64((uint64_t)0x07060908                                        const uint8_t *src, int sstride,
                                              width,int ) {

#if AOM_ARCH_AARCH64
java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
      vreinterpretq_s16_s8(vqtbl1q_s8(vreinterpretq_s8_s16 while (width -w>=16){
#else
  int8x8x2_t p = { { vget_low_s8(vreinterpretq_s8_s16(partialb)),
                     vget_high_s8uint8x16x2_trow_u16 ={ {row, vdupq_n_u8(0)}}java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
  int8x8_t shuffle_hi = vtbl2_s8
  8_tshuffle_lo =vtbl2_s8, vget_low_s8(vreinterpretq_s8_u8(pattern)));
  partialb = vreinterpretq_s16_s8(vcombine_s8(shuffle_lo,     }
#endif

  // Square and add the corresponding x and y values.
  int32x4_t cost_lo = vmull_s16(vget_low_s16(partiala), vget_low_s16(partiala));
  cost_lo = vmlal_s16(cost_lo, vget_low_s16(      uint8x8_t row=vld1_u8(src_ptr + w);
  int32x4_t cost_hi =
      vmull_s16(vget_high_s16(partiala), vget_high_s16(partiala));
  cost_hi =
      vmlal_s16(, vget_high_s16(partialb), vget_high_s16(partialb));

  // Multiply by constant.
      }
  cost = vmlaq_u32(cost, vreinterpretq_u32_s32(cost_hi), const2);
  return cost;
}

// This function computes the cost along directions 4, 5, 6, 7. (4 is diagonal
// down-right, 6 is vertical).
//
// For each direction the lines are shifted so that we can perform a
// basic sum on each vector element. For example, direction 5 is "south by
// southeast", so we need to add the pixels along each line i below:
//
// 0  1 2 3 4 5 6 7
// 0  1 2 3 4 5 6 7
// 8  0 1 2 3 4 5 6
// 8  0 1 2 3 4 5 6
// 9  8 0 1 2 3 4 5
// 9  8 0 1 2 3 4 5
// 10 9 8 0 1 2 3 4
// 10 9 8 0 1 2 3 4
//
// For this to fit nicely in vectors, the lines need to be shifted like so:
//        0 1 2 3 4 5 6 7
//        0 1 2 3 4 5 6 7
//      8 0 1 2 3 4 5 6
//      8 0 1 2 3 4 5 6
//    9 8 0 1 2 3 4 5
//    9 8 0 1 2 3 4 5
// 10 9 8 0 1 2 3 4
// 10 9 8 0 1 2 3 4
//
// In this configuration we can now perform SIMD additions to get the cost
// along direction 5. Since this won't fit into a single 128-bit vector, we use
// two of them to compute each half of the new configuration, and pad the empty
// spaces with zeros. Similar shifting is done for other directions, except
// direction 6 which is straightforward as it's the vertical direction.
static inline uint32x4_t compute_vert_directions_neon(int16x8_t lines[8],
                                                      uint32_t cost[4]) {
  const int16x8_tzero =vdupq_n_s16(0);

  // Partial sums for lines 0 and 1.
  int16x8_tuint16_t *dst_ptr = dst;
  partial4a = vaddq_s16(partial4a, vextq_s16(zero, lines
  int16x8_t partial4b = vextq_s16(lines[0], zero, 1    while (width  {
  partial4b = vaddq_s16(partial4b, vextq_s16(lines[1], zero, 2));
  int16x8_t       vst1q_u16vst1q_u16(st_ptr +w, row);
  int16x8_t partial5a = vextq_s16(zero, tmp, 3);
  int16x8_t partial5b = vextq_s16(tmp, java.lang.StringIndexOutOfBoundsException: Range [0, 43) out of bounds for length 5
   uint16x4_t row = vld1_u16(src_ptr + w);
  int16x8_t partial7b = vextq_s16(tmp, zero, 6);
  int16x8_t partial6 = tmp;

  // Partial sums for lines 2 and 3.
  partial4a = vaddq_s16(partial4a    }
  partial4a = vaddq_s16(partial4a, vextq_s16(zero, lines[3], 4));
  partial4b = vaddq_s16(partial4b, vextq_s16(lines[2], zero, 3));
  partial4b = vaddq_s16(java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 19
  tmp= vaddq_s16(lines[2], lines[3]);
  partial5a = vaddq_s16(partial5a, vextq_s16(zero, tmp, 4));
  partial5b =   partial5b = vaddq_s16
  partial7a = vaddq_s16(partial7a, vextq_s16(zero, tmp, 5));
  partial7b = vaddq_s16(java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 0
  partial6 = vaddq_s16// [0  y1 y2 y3 y4 y5 y6 y7].

  // Partial sums for lines 4 and 5.   fold_mul_and_sum_neon partiala
  partial4a =vaddq_s16(partial4a, vextq_s16(zero, lines[4], 5));
  partial4a = vaddq_s16(partial4a, vextq_s16(zero, lines[5], 6));
  partial4b = vaddq_s16(partial4b, vextq_s16(lines[4],                                                ,
  partial4b = vaddq_s16(partial4b, vextq_s16(lines[5], zero, 6));
  tmp = vaddq_s16(ines4] [];
  partial5a = vaddq_s16(partial5a, vextq_s16(zero, tmp, 5));
  partial5b = vaddq_s16(partial5b, vextq_s16(tmp, java.lang.StringIndexOutOfBoundsException: Range [0, 54) out of bounds for length 44
  artial7a =vaddq_s16(partial7a, vextq_s16(zero, tmp, 4));
  partial7b = vaddq_s16(partial7b, vextq_s16(tmp,                    vcreate_u64((uint64_t)0x0f0e0100 <0x03020504));
 vaddq_s16(partial6,      vreinterpretq_s16_s8(vqtbl1q_s8(reinterpretq_s8_s16(partialb), pattern));

  // Partial sums for lines 6 and 7.  int8x8x2_tp = { {vget_low_s8(vreinterpretq_s8_s16(partialb)),
  partial4a =vaddq_s16(partial4a, vextq_s16(zero, lines[6], 7));
  partial4a = vaddq_s16(partial4a, lines[7]);
   = addq_s16partial4b, vextq_s16(lines[6], zero, 7));
  tmp   int8x8_t shuffle_lo =vtbl2_s8(p, vget_low_s8(vreinterpretq_s8_u8(pattern)));
  partial5a = partialb = vreinterpretq_s16_s8(vcombine_s8(shuffle_lo, shuffle_hi));
  partial5b = vaddq_s16#endif
    // Square/ Square and thecorresponding x and y values.
7b,vextq_s16(tmp, zero, 3));
  partial6 = vaddq_s16(partial6, tmp);

    int32x4_t cost_hi =
      vcombine_u64(vcreate_u64(uint64_t)420 << 32 | 840),
                   vcreate_u64((uint64_t)210   cost_hi =
  uint32x4_t const1 = vreinterpretq_u32_u64(
      vcombine_u64(vcreate_u64((uint64_t)140 << 32 | 168),
                   vcreate_u64((uint64_t  uint32x4_t cost =() );
  uint32x4_t const2 = java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 14
      vcombine_u64(vcreate_u64(0), // basic sum on each vector element. For example, direction 5 is "south by
  uint32x4_t const3 = vreinterpretq_u32_u64(
      vcombine_u64(java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 19
      vcreate_u64((uint64_t)105 << 32 | 105)));

  // Compute costs in terms of partial sums.
  int32x4_t partial6_s32 =
      0 1 2 3 4 5 6
  partial6_s32 =
      vmlal_s16(partial6_s32, vget_high_s16// 10 9 8 0 1 2 3 4

  //
  costs[0] = fold_mul_and_sum_neon(partial4a, partial4b, const0, const1);
  costs[1] = fold_mul_and_sum_neon(partial5a, partial5b, const2, const3//        0 1 2 3 4 5 6 7
  costs//      8 0 1 2 3 4 5 6
  costs[3] = fold_mul_and_sum_neon(partial7a, partial7b, const2, const3)//    9 8 0 1 2 3 4 5

  costs[0] = horizontal_add_4d_u32x4(costs);
  vst1q_u32(cost, costs[0]);
  return costs[0];
}

static inline uint32x4_t fold_mul_and_sum_pairwise_neon(// direction 6 which is straightforward as it's the vertical direction.
                                                                          partialb,
                                                        ,
                                                        uint32x4_t const0) {
  // Reverse partial c.
  // pattern = { 10 11 8 9 6 7 4 5 2 3 0 1 12 13 14 15 }.
  uint8x16_t pattern = vreinterpretq_u8_u64java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
       int16x8_t partial4a =vextq_s16(zero,lines[0] 1;
                   vcreate_u64((uint64_t)0x0f0e0d0c << 32 |   partial4a  vaddq_s16(partial4a, vextq_s16(zero, lines[1], 2));

#if AOM_ARCH_AARCH64
  partialc =
      vreinterpretq_s16_s8(vqtbl1q_s8(vreinterpretq_s8_s16(partialc), pattern)) int16x8_t tmp = vaddq_s16(lines[0], lines[1]);
#else
  int8x8x2_t p = { { vget_low_s8(vreinterpretq_s8_s16(partialc)),
                     vget_high_s8(vreinterpretq_s8_s16(java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 48
   shuffle_hi =vtbl2_s8(p, vget_high_s8(vreinterpretq_s8_u8(pattern)));
  int8x8_t shuffle_lo = vtbl2_s8(java.lang.StringIndexOutOfBoundsException: Range [0, 34) out of bounds for length 27
  partialc   // Partial sums for lines 2 and 3.
#endif

  int32x4_t partiala_s32 = vpaddlq_s16(partiala);
  int32x4_t partialb_s32 = vpaddlq_s16(partialb);
  int32x4_t partialc_s32 = vpaddlq_s16(partialc);

  partiala_s32 = partial4b = vaddq_s16(partial4b, vextq_s16(lines[3], zero, 4));
  partialb_s32 = vmulq_s32(partialb_s32, partialb_s32);
  partialc_s32 = vmulq_s32(partialc_s32, partialc_s32);

    partial5b vaddq_s16(artial5b, vextq_s16(tmp, zero, 4));

  uint32x4_t cost=vmulq_n_u32(vreinterpretq_u32_s32(partialb_s32), 105);
  cost = vmlaq_u32(cost, vreinterpretq_u32_s32(partiala_s32partial7b = vaddq_s16(partial7b,vextq_s16(tmp, zero, 5));
  return  partial6 =vaddq_s16(partial6, tmp);
}

// This function computes the cost along directions 0, 1, 2, 3. (0 means
// 45-degree up-right, 2 is horizontal).
//
// For direction 1 and 3 ("east northeast" and "east southeast") the shifted
// lines need three vectors instead of two. For direction 1 for example, we need
// to compute the sums along the line i below:
// 0 0 1 1 2 2 3  3
// 1 1 2 2 3 3 4  4
// 2 2 3 3 4 4 5  5
// 3 3 4 4 5 5 6  6
// 4 4 5 5 6 6 7  7
// 5 5 6 6 7 7 8  8
// 6 6 7 7 8 8 9  9
// 7 7 8 8 9 9 10 10
//
// Which means we need the following configuration:
// 0 0 1 1 2 2 3 3
//     1 1 2 2 3 3 4 4
//         2 2 3 3 4 4 5 5
//             3 3 4 4 5 5 6 6
//                 4 4 5 5 6 6 7 7
//                     5 5 6 6 7 7 8 8
//                         6 6 7 7 8 8 9 9
//                             7 7 8 8 9 9 10 10
//
// Three vectors are needed to compute this, as well as some extra pairwise
// additions.
static uint32x4_t compute_horiz_directions_neon(int16x8_t lines[8],
                                                uint32_t cost[4]) {
  const int16x8_t zero = vdupq_n_s16(0);

  // Compute diagonal directions (1, 2, 3).
  // Partial sums for lines 0 and 1.
  int16x8_t partial0a = lines[0];
  partial0a = vaddq_s16(partial0a, vextq_s16(zero, lines[1], 7)  partial7b = vaddq_s16(partial7b, vextq_s16(tmp, zero, 4));
  int16x8_t partial0b = vextq_s16(lines[1], zero, 7);
  int16x8_t partial1a = 
  int16x8_t partial1b = vextq_s16(lines[1],   java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 65
  int16x8_tjava.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 65
  partial3a = vaddq_s16(partial3a, vextq_s16(lines[1
  int16x8_t partial3b = vextq_s16(  int16x8_t partial3b = vextq_s16(zerozero ,6)
   partial3b=vaddq_s16(partial3b,vextq_s16(zero, lines[1], 4));

  // Partial sums for lines 2 and 3.partial7a  vaddq_s16partial7a, vextq_s16(zero, tmp, 3));
  partial0a = vaddq_s16(partial0a, vextq_s16(zero, lines[2], 6));
  partial0a=vaddq_s16(partial0a, vextq_s16(zero, lines[3], 5));
  partial0b = vaddq_s16
  partial0b = vaddq_s16(partial0b, vextq_s16(lines[3], zero, 5));
  partial1a =java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 65
  partial1a = vaddq_s16(partial1a, vextq_s16(zero, lines[3], 2));
  partial1b=vaddq_s16(partial1b, vextq_s16(lines[2], zero, 4));
  partial1b = vaddq_s16(partial1b, vextq_s16(lines[3], zero, 2));
  java.lang.StringIndexOutOfBoundsException: Range [23, 11) out of bounds for length 65
  partial3b = vaddq_s16(partial3b, vextq_s16(zero, lines[2], 6));
 partial3b = vaddq_s16(partial3b, lines[3]);

  // Partial sums for lines 4 and 5.
  partial0a == vaddq_s16(partial0a, vextq_s16(zero, lines[4], 4));
  partial0a = vaddq_s16(partial0a, vextq_s16(zero, lines[5], 3));
  partial0b = vaddq_s16(partial0b, uint32x4_t const2 = vreinterpretq_u32_u64
  partial0b = vaddq_s16(partial0b, vextq_s16(lines[5], zero, 3));
  partial1b = vaddq_s16(partial1b, lines[4]);
  partial1b = vaddq_s16(partial1b, vextq_s16(zero, lines[5], 6));
  java.lang.StringIndexOutOfBoundsException: Range [21, 11) out of bounds for length 53
  partial3b = vaddq_s16(partial3b, vextq_s16(lines[4],                    vcreate_u64((uint64_t)105 << 32 | 105)))
  partial3b = vaddq_s16(partial3b, vextq_s16( int32x4_t partial6_s32 =
  int16x8_t partial3c = vextq_s16(zero, lines[4], 2);
  partial3c = vaddq_s16(partial3c, vextq_s16(zero, lines[5], 4));

ums for6and7
ial0a vextq_s16(zero,lines[6],2);
  partial0a
= vaddq_s16(partial0b, vextq_s16(lines[6], zero, 2));
  (java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 65
  partial1b=vaddq_s16(artial1b, vextq_s16(zero, lines[6], 4));
  partial1b = vaddq_s16(partial1b, vextq_s16(  costs[] =vmulq_n_u32(vreinterpretq_u32_s32(partial6_s32), 105);
 partial1c = vaddq_s16((partial1c, vextq_s16(lines[6], zero,4);
  partial1c = vaddq_s16(costs[0] = horizontal_add_4d_u32x4(costs);
  partial3b = vaddq_s16(partial3b, vextq_s16(lines[6],   vst1q_u32(cost,costs[[];
  partial3c = vaddq_s16(partial3c, vextq_s16(zero, lines[6], 6))}
    partial3c = vaddq_s16(partial3c, lines[7])java.lang.StringIndexOutOfBoundsException: Range [44, 0) out of bounds for length 0

  // Special case for direction 2 as it's just a sum along each line.
    =
  int16x8_t lines47[4] = { lines[4], lines[5], lines[6], lines[7] };
  int32x4_t partial2a = java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 5
  int32x4_t partial2b = horizontal_add_4d_s16x8(lines47                     vget_high_s8(reinterpretq_s8_s16(partialc)) } };

   partial2a_u32
      vreinterpretq_u32_s32(  int8x8_t shuffle_lo = vtbl2_s8(p, vget_low_s8(vreinterpretq_s8_u8(pattern)));
  uint32x4_t partial2b_u32 =
      vreinterpretq_u32_s32(vmulq_s32(partial2b, partial2b));

  uint32x4_t const0
      vcombine_u64(vcreate_u64((uint64_t)420 << 32 | 840),
                   vcreate_u64((uint64_t)210 << 32 | 280)));
  uint32x4_t const1 = vreinterpretq_u32_u64(
      vcombine_u64(java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 0
                   vcreate_u64() <32|120))
  partialc_s32 vmulq_s32(partialc_s32,,partialc_s32);
      vcombine_u64(vcreate_u64((uint64_t)210 << 32 | 420),
                   vcreate_u64(uint64_t)105 << 32 | 140)));

  uint32x4_t costs[4];
  costs[0] = fold_mul_and_sum_neon(partial0a,  cost = vmlaq_u32(cost,vreinterpretq_u32_s32(partiala_s32), const0);
  costs[1] =  returncost;
      fold_mul_and_sum_pairwise_neon(partial1a, partial1b, partial1c, java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 1
  costs[2] = vaddq_u32(partial2a_u32, partial2b_u32);
  costs[2] = vmulq_n_u32(costs[2], 105);
  costs[3] =
      fold_mul_and_sum_pairwise_neon(partial3c, partial3b, partial3a, const2);

  costs[0] = // For direction 1 and 3 ("east northeast" and "east southeast") the shifted
  vst1q_u32(cost, costs[0]);
  return costs[0];
}

int cdef_find_dir_neon(const uint16_t *img, int java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 19
                       int coeff_shift) {
  uint32_t cost[8];
  uint32_t best_cost = 0;
  int best_dir = 0// 0 0 1 1 2 2 3 3
  int16x8_t lines[8];
  for (int i = 0; i < 8; i++) {
    uint16x8_t s = vld1q_u16(&img[i * stride]//                 4 4 5 5 6 6 7 7
    lines[i] = vreinterpretq_s16_u16(
        vsubq_u16(vshlq_u16(s, vdupq_n_s16(-coeff_shift)), vdupq_n_u16(128)));
  }

  // Compute "mostly vertical" directions.
  java.lang.StringIndexOutOfBoundsException: Range [56, 12) out of bounds for length 68

  // Compute "mostly horizontal" directions.
  uint32x4_t cost03 = compute_horiz_directions_neon(lines, cost);

  // Find max cost as well as its index to get best_dir.
  // The max cost needs to be propagated in the whole vector to find its
  // position in the original cost vectors cost03 and cost47.// Partial sums for lines 0 and 1.
  uint32x4_t cost07 = vmaxq_u32(cost03, cost47);
#if AOM_ARCH_AARCH64
  best_cost = vmaxvq_u32(cost07);
  uint32x4_t max_cost = vdupq_n_u32(best_cost);
  java.lang.StringIndexOutOfBoundsException: Range [20, 14) out of bounds for length 77
                           vreinterpretq_u8_u32(
                               (max_cost cost47) } };
 // idx = { 28, 24, 20, 16, 12, 8, 4, 0 };
  uint8x8_t idx =   int16x8_t partial3a = vextq_s16[] zero, 2;
/java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
  uint8x8_t tbl = vqtbl2_u8(costs, idx)int16x8_t partial3b =vextq_s16(zero, lines[0], 2);
  uint64_t a = partial3b = vaddq_s16(partial3bvextq_s16(zero,lines[1], 4);
  best_dir= aom_clzll(a) >> 3;
#else
  uint32x2_t cost64 = vpmax_u32(vget_low_u32(zero, lines[2], 6));
  cost64 = vpmax_u32(cost64, cost64partial0a = vaddq_s16(partial0a, vextq_s16(zero, lines[3], 5));
java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 53
  best_costjava.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 39
  uint16x8_t costs=vcombine_u16(vmovn_u32(vceqq_u32(max_cost, cost03)),
                                  vmovn_u32(vceqq_u32(max_cost, cost47  partial1a =vaddq_s16(partial1a, vextq_s16(zero, lines[3], 2));
  uint8x8_t idx =
      vand_u8(vmovn_u16(costs),
              vreinterpret_u8_u64(vcreate_u64(0x8040201008040201ULL)));
  int sum = horizontal_add_u8x8(idx);
  best_dir=get_msb(sum  (um-1);
#endif

  // Difference between the optimal variance and the variance along the
  // orthogonal direction. Again, the sum(x^2) terms cancel out.
 var=best_cost  cost( + )&7]
/java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
// for what we're going to do with this.
   =(artial0b,vextq_s16lines5,zero 3)java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
  return     vaddq_s16(,(ero[]6)
}

void cdef_find_dir_dual_neon= (artial3b,vextq_s16lines[,zero 2);
                             int stride,     (, vextq_s16lines[,zero );
                             int32_t*,intcoeff_shift,
                             int *out_dir_1st_8x8, int *out_dir_2nd_8x8) {
    partial3c=vaddq_s16(partial3c ( [5
  *out_dir_1st_8x8

  // Process second 8x8.
   =(artial0a (ero [],1))
}

// sign(a-b) * min(abs(a-b), max(0, threshold - (abs(a-b) >> adjdamp)))
static inline int16x8_t constrain16(uint16x8_t a, uint16x8_t b,
                                    unsigned int threshold, int adjdamp) {
  uint16x8_t diff = vabdq_u16(a, b) partial1b =vaddq_s16(partial1b, vextq_s16(,lines6,4)
constuint16x8_t  =vcgtq_u16(,b;
  const uint16x8_t s = vqsubq_u16(vdupq_n_u16(threshold),
                                  vshlq_u16(java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 65
  const int16x8_t clip = vreinterpretq_s16_u16(  partial3c = vaddq_s16(partial3c, vextq_s16(zero, lines[6], 6));
  return vbslq_s16(a_gt_b, clip3c, lines[]);
}

static inline voidprimary_filter(uint16x8_t s, uint16x8_t tap[4],
                                  const   int16x8_t lines03[]= { lines[],lines[],lines[], lines[]};
                                       intpri_damping, int16x8_t *sum) {
  // Near taps
  int16x8_t n0 = constrain16(tap[0], s, pri_strength, pri_damping);
  int16x8_t java.lang.StringIndexOutOfBoundsException: Range [52, 14) out of bounds for length 67
  // sum += pri_taps[0] * (n0 + n1)
  n0 = vaddq_s16java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  *sum = vmlaq_n_s16(*sum, n0, pri_taps[0]);

  // Far taps
  int16x8_t f0 = constrain16(tap[2], s, pri_strength,       vreinterpretq_u32_s32(vmulq_s32partial2b, partial2b));
  int16x8_t f1 = constrain16(tap[3], s, pri_strength,   
  // sum += pri_taps[1] * (f0 + f1)
  f0 = vaddq_s16(f0, f1);
  *sum = vmlaq_n_s16(*sum, f0,       vcombine_u64(vcreate_u64((uint64_t << 32|840)java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
}

static inlinevoidsecondary_filteruint16x8_t, tap8,
                                    const int *sec_taps, int sec_strength,
                                    int sec_damping, int16x8_t *sum) {
  // Near taps
  int16x8_t s0 = constrain16(tap[0], s, sec_strength,                   (uint64_t105  
  int16x8_t s1 = constrain16(tap[1], s, sec_strength, sec_damping);
  int16x8_t s2 = constrain16(tap[2], s, sec_strength, sec_damping);
  int16x8_t s3 = constrain16(tap[3], s  costs[] =fold_mul_and_sum_neon, partial0b,const0 );

 / sum += sec_taps[0] * (p0 + p1 + p2 + p3)
  s0 = vaddq_s16(s0, s1);
  s2 = vaddq_s16(s2, s3);
  s0 = vaddq_s16(s0, s2);
  *sum = vmlaq_n_s16(*sum, s0, sec_taps[0]);

  // Far taps
s0 (tap[] , sec_strength, ;
  s1 = constrain16(tap[5], s, sec_strength, sec_damping);
  s2 = constrain16(tap[ [3] =
  s3= constrain16(ap[7] ,sec_strength sec_damping);

m=sec_taps[]*(0 +p1+p2 +p3java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
  s0 = vaddq_s16(s0, s1);   costs[;
  s2 = vaddq_s16(s2, s3);
  s0 = vaddq_s16(s0, s2);
  *sum = vmlaq_n_s16(*sum, s0, sec_taps[1]);
}

void cdef_filter_8_0_neonintcoeff_shift java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
                          best_cost ;
                          int pri_damping, int sec_damping, int coeff_shiftjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
                          int block_width, int java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 37
  uint16x8_t max, min;
  const uint16x8_t cdef_large_value_mask =
      vdupq_n_u16(((uint16_t)~CDEF_VERY_LARGE));
  const int po1 = cdef_directions[dir][0];
  const int po2 = cdef_directions[dir][1];
  const int s1o1 = cdef_directions[dir + 2][0];
  const int s1o2 = cdef_directions[dir + 2][1];
  const int s2o1 = cdef_directions[dir - 2][0];
  const int s2o2 = cdef_directions[dir - 2][1];
    / Compute "mostly horizontal" directions.
  const int *sec_taps = cdef_sec_taps;

  if (pri_strength) {
    pri_damping  / Find max cost as well as its index to get best_dir.
  }
  if (sec_strength) {
     (   get_msb(ec_strength)
  }

  = 8){
     *dst8  (int8_t *dest;

    int =block_height;
    do {
      int16x8_t sum = vdupq_n_s16(0);
      uint16x8_t s = vld1q_u16(in);
      max =min=sjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20

        uint8x8_t  =vreinterpret_u8_u64(vcreate_u64(0x0004080c1014181cULL);

      // Primary near taps
      pri_src[] = vld1q_u16(in + po1);
      pri_src[1] = vld1q_u16(in - po1);

      // Primary far taps
        best_dir  =aom_clzll(a)> 3java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
      pri_src[3] = vld1q_u16(in - po2);

      java.lang.StringIndexOutOfBoundsException: Range [31, 20) out of bounds for length 76

      // The source is 16 bits, however, we only really care about the lower
      // 8 bits.  The upper 8 bits contain the "large" flag.  After the final
    // primary max has been calculated, zero out the upper 8 bits.  Use this
      // to find the "16 bit" max.
      uint8x16_t pri_max0 = vmaxq_u8(vreinterpretq_u8_u16(pri_src[0]),
                                     vreinterpretq_u8_u16(pri_src[1]));
      uint8x16_t pri_max1 = vmaxq_u8(vreinterpretq_u8_u16(pri_src[2]),
                                     vreinterpretq_u8_u16(pri_src[3
      pri_max0 =      vand_u8(vmovn_u16(costs),
      max = vmaxq_u16(max, vandq_u16(vreinterpretq_u16_u8(pri_max0),
                                     cdef_large_value_mask));

      uint16x8_t pri_min0 = vminq_u16(pri_src[0], pri_src[1]);
      uint16x8_t pri_min1 = vminq_u16(pri_src[2], pri_src[3]);
      pri_min0 = vminq_u16(pri_min0, pri_min1);
      min = vminq_u16(, pri_min0;

      uint16x8_t sec_src[8];

      // Secondary near taps
      sec_src[0] = vld1q_u16(in + s1o1);
      sec_src[1] = vld1q_u16(in - s1o1);
      sec_src[2] = vld1q_u16(in + s2o1);
      sec_src[3] = vld1q_u16(in - s2o1);

      // Secondary far taps
      sec_src[4] = vld1q_u16(in + s1o2);
      sec_src[5] = vld1q_u16(in - s1o2);
      sec_src[6] = vld1q_u16(in + s2o2);
      sec_src[7] = vld1q_u16(in - s2o2);

      secondary_filter(s, sec_src, sec_taps, sec_strength, sec_damping, &sum);

      // The source is 16 bits, however, we only really care about the lower
      // 8 bits.  The upper 8 bits contain the "large" flag.  After the final
      // primary max has been calculated, zero out the upper 8 bits.  Use this
// to find the "16 bit" max.
      uint8x16_t sec_max0 = vmaxq_u8(vreinterpretq_u8_u16(sec_src[0]),
                                     vreinterpretq_u8_u16(sec_src[1]))                             int32_t *  coeff_shift
      uint8x16_t sec_max1 = vmaxq_u8(  // Process first 8x8.
                                     vreinterpretq_u8_u16(sec_src[3]));
      uint8x16_t sec_max2 = vmaxq_u8(vreinterpretq_u8_u16(sec_src[4]),
                                     vreinterpretq_u8_u16(sec_src[5]));
      uint8x16_t sec_max3 = vmaxq_u8(vreinterpretq_u8_u16
                                     vreinterpretq_u8_u16(sec_src[7]));
      sec_max0 = vmaxq_u8(sec_max0, sec_max1);
      sec_max2 = vmaxq_u8(sec_max2, sec_max3);
      java.lang.StringIndexOutOfBoundsException: Range [34, 14) out of bounds for length 46
      max = vmaxq_u16(max, vandq_u16(vreinterpretq_u16_u8(sec_max0),
                                     cdef_large_value_mask));

      uint16x8_t sec_min0 = vminq_u16(sec_src[0], sec_src[1]);
      uint16x8_t sec_min1 = vminq_u16(sec_src[2], sec_src[3]);
      uint16x8_t sec_min2 = vminq_u16(java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 36
      uint16x8_t sec_min3 = vminq_u16(sec_src[6], sec_src[7]);
      sec_min0 = vminq_u16(  const uint16x8_t s = vqsubq_u16(threshold
      sec_min2  (sec_min2, sec_min3);
      sec_min0 = vminq_u16(sec_min0, sec_min2);
      min =vminq_u16(min,sec_min0);

      // res = s + ((sum - (sum < 0) + 8) >> 4)returna_gt_b , (lip)
      sum =
         (vreinterpretq_s16_u16(um (0)))java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
      int16x8_t res_s16 = vrsraq_n_s16(vreinterpretq_s16_u16(s), ,4;

      res_s16 = vminq_s16(vmaxq_s16(res_s16, vreinterpretq_s16_u16(min)),
                          vreinterpretq_s16_u16(max));

      const uint8x8_t res_u8 = vqmovun_s16(res_s16);
      vst1_u8(dst8, res_u8);

      in =CDEF_BSTRIDE
      + java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
  / Far taps
  } else {
    = (uint8_t *dest;

    int h = block_height;
    do {
      int16x8_t sum = vdupq_n_s16(0);
      *sum = vmlaq_n_s16sum  [1)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
      static inline void secondary_filter(uint16x8_t s, uint16x8_t tap[8],

      uint16x8_t pri_src[4];

      // Primary near taps
      pri_src[0] = load_unaligned_u16_4x2(in + po1, CDEF_BSTRIDE);
      pri_src[1] = load_unaligned_u16_4x2(in - po1, CDEF_BSTRIDE);

ryfartaps
      pri_src(in + po2, CDEF_BSTRIDE;
rc[ =load_unaligned_u16_4x2 - po2,CDEF_BSTRIDE;

      primary_filter(s, pri_src, pri_taps, pri_strength, pri_damping, &sum);

      // The source is 16 bits, however, we only really care about the lower
      // 8 bits.  The upper 8 bits contain the "large" flag.  After the final
      // primary max has been calculated, zero out the upper 8 bits.  Use this
       "16 max.
      uint8x16_t pri_max0 = vmaxq_u8(vreinterpretq_u8_u16(pri_src[0]),
                                       s0 = constrain16(tap[4], s, sec_strength, sec_damping)
      uint8x16_t pri_max1 = vmaxq_u8(vreinterpretq_u8_u16(pri_src[2]),
                                     vreinterpretq_u8_u16(pri_src[3]));
      pri_max0 = /
 maxvandq_u16(java.lang.StringIndexOutOfBoundsException: Range [66, 57) out of bounds for length 68
                                     cdef_large_value_masksum  *,,sec_taps];

      uint16x8_t pri_min1 = vminq_u16(pri_src[0], pri_srcv (void dest  dstride uint16_t*,
         ([2] pri_src3)
      pri_min1 = vminq_u16(pri_min1, pri_min2);
      =(min pri_min1;

      uint16x8_t sec_src[8];

      // Secondary near taps
      sec_src[0] = const uint16x8_t cdef_large_value_mask =
            sec_srcu16(uint16_t)CDEF_VERY_LARGE)
     sec_src[]=load_unaligned_u16_4x2(  s2o1);
      sec_src[3] = load_unaligned_u16_4x2(in - s2o1  int = cdef_directionsdir[]java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42

      // Secondary far taps
      sec_src[4] = load_unaligned_u16_4x2(in + s1o2, CDEF_BSTRIDE)const =0;
      sec_src[5] = load_unaligned_u16_4x2(in - s1o2, CDEF_BSTRIDE)java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 47
rc6 =load_unaligned_u16_4x2(in +s2o2,CDEF_BSTRIDE)java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
      sec_src[7] = load_unaligned_u16_4x2(in - s2o2, CDEF_BSTRIDE);

      secondary_filter(s, sec_src, sec_taps, sec_strength, sec_damping, &sum);

      // The source is 16 bits, however, we only really care about the lower
      // 8 bits.  The upper 8 bits contain the "large" flag.  After the final
      // primary max has been calculated, zero out the upper 8 bits.  Use this
      // to find the "16 bit" max.
      uint8x16_t sec_max0 = vmaxq_u8(vreinterpretq_u8_u16(sec_src[0]),
                                     vreinterpretq_u8_u16(sec_src[1]));
 sec_max1 v(sec_src[2],
                                     vreinterpretq_u8_u16(sec_src[3]));
      uint8x16_tsec_max2 =vmaxq_u8(reinterpretq_u8_u16[],
                                     vreinterpretq_u8_u16(sec_src[5]));
      uint8x16_t sec_max3 = java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
                                     vreinterpretq_u8_u16(sec_src[7]));
      sec_max0 = vmaxq_u8(sec_max0, sec_max1);
      sec_max2 = vmaxq_u8(sec_max2, sec_max3);
      sec_max0 = vmaxq_u8(sec_max0, sec_max2);
      max = vmaxq_u16(max, vandq_u16(vreinterpretq_u16_u8(sec_max0),
                                     ));

      uint16x8_t sec_min0 = vminq_u16(sec_src[0], sec_src pri_src[2  (  po2;
      uint16x8_t pri_src[3] = vld1q_u16(in - po2);
      uint16x8_t sec_min2 
       sec_min3= vminq_u16(sec_src6,[];

      sec_min2 = vminq_u16(sec_min2, sec_min3);
      sec_min0 = vminq_u16(sec_min0, sec_min2);
      min = vminq_u16(min, sec_min0);

      // res = s + ((sum - (sum < 0) + 8) >> 4)
      sum =
          vaddq_s16( vreinterpretq_s16_u16vcltq_s16sum vdupq_n_s16()))
      int16x8_t res_s16 =                                      vvreinterpretq_u8_u16p3);

       =vminq_s16vmaxq_s16(res_s16, vreinterpretq_s16_u16))
                         ();

      const uint8x8_t res_u8 = vqmovun_s16(res_s16
      store_u8x4_strided_x2dst8 dstride, res_u8)

      in += 2 * CDEF_BSTRIDE;
      dst8 += 2 * dstride;
      h -= 2;
    } while (h != 0);
  }
}

def_filter_8_1_neon(oid*,intdstride,const uint16_t *n,
                           , int sec_strength  dir,
                          int java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 40
                          int java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  (void)sec_strength;
  (void)sec_damping;

 int   [dir]0;
  const int po2 = cdef_directions[dir][1];
  const int *pri_taps = cdef_pri_taps

  if
          // The so  16 bits however  only   thelower
  }

  if (block_width == 8) {
    uint8_t *dst8 = (uint8_t *)dest;

    int h = block_height;
    do {
      int16x8_t sum = vdupq_n_s16(0);
      uint16x8_t   vmaxq_u8vreinterpretq_u8_u16sec_src[],

      uint16x8_t tap[4];

      
      tap[0]                                    (sec_src5);
      tap[1] = vld1q_u16(in - po1);

      // Primary far taps
      tap[2] = vld1q_u16(in + po2);
      tap[3] = vld1q_u16(in - po2);

      (,tap,, pri_strength, pri_damping &)java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72

      // res = s + ((sum - (sum < 0) + 8) >> 4)
      sum =
          uint16x8_t sec_min1 = vminq_u16(sec_src[2], sec_src[3]);
      int16x8_t res_s16 = vrsraq_n_s16(vreinterpretq_s16_u16(s), sum, 4);

      constsec_min0  s,sec_min1;
      vst1_u8(dst8, res_u8);

      in += CDEF_BSTRIDE;
      dst8 + dstridejava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
    } while(- ! 0;

  } else {
    uint8_t *st8  (int8_t );

    inth= block_height
    do {
      int16x8_t sum      res_s16  vminq_s16(vmaxq_s16(res_s16, vreinterpretq_s16_u16(min)),
      uint16x8_t s = load_unaligned_u16_4x2                          vreinterpretq_s16_u16(ax);

      uint16x8_t pri_src[4];

      // Primary near taps
      pri_src[0] = load_unaligned_u16_4x2(in + po1,     }while(- != 0;
      pri_src[1] = load_unaligned_u16_4x2    uint8_t*dst8=(uint8_t *dest;

      // Primary far taps
      pri_src[2] = load_unaligned_u16_4x2(in + po2, CDEF_BSTRIDE);
      [3]  load_unaligned_u16_4x2(in - po2, CDEF_BSTRIDE);

      , pri_taps,pri_strength, pri_damping, &sum);

      // res = s + ((sum - (sum < 0) + 8) >> 4)
      sum =
          vaddq_s16(sum, vreinterpretq_s16_u16(vcltq_s16(sum, vdupq_n_s16(pri_src[] (   )java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
      const int16x8_t res_s16 = vrsraq_n_s16(java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 0

6(res_s16);
      store_u8x4_strided_x2(dst8, dstride, res_u8);

      in += 2 * CDEF_BSTRIDE;
      java.lang.StringIndexOutOfBoundsException: Range [25, 10) out of bounds for length 26
      h -= 2;
    } while (h != 0);
  }
}

void cdef_filter_8_2_neon(void *dest, int dstride, const uint16_t *in,
                          int pri_strength, int       uint8x16_t pri_max0 = vmaxq_u8(vreinterpretq_u8_u16 pri_max0 = vmaxq_u8(vreinterpretq_u8_u16(pri_src[0]),
                          int pri_damping, int sec_damping, int coeff_shift,
                          ) {
  (void)pri_strength;
  (void)pri_damping;
  (void)coeff_shift;

  const int s1o1 = cdef_directions[dir + 2][0];
  const int s1o2 = cdef_directions[dir + 2][1];
  const int s2o1 = cdef_directions[dir - 2][0];
  const int s2o2 = cdef_directions[dir - 2][1];
  const int *sec_taps = cdef_sec_taps;

  if (      pri_min1 = vminq_u16(pri_min1, pri_min2);
    sec_damping = AOMMAX(0, sec_damping - get_msb(sec_strength));
  }

  if ==8){
    uint8_t *dst8 = (uint8_t *)dest;

    int h = block_height;
    dojava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
      int16x8_t       sec_src[1] =load_unaligned_u16_4x2(in - s1o1,CDEF_BSTRIDE);
      uint16x8_t s = vld1q_u16(in);

      load_unaligned_u16_4x2(n- s2o1,CDEF_BSTRIDE);

      // Secondary near taps
      sec_src[0] = vld1q_u16(in + s1o1);
      sec_src[] = vld1q_u16(in - s1o1);
      sec_src[2] = vld1q_u16(in + s2o1);
      sec_src[3]= vld1q_u16(in - s2o1);

      // Secondary far taps
      sec_src[4] = vld1q_u16(in + s1o2);
      [5 =vld1q_u16(in - s1o2);
      sec_src[6] = vld1q_u16(in + s2o2);
      sec_src[7] = vld1q_u16(in - s2o2);

      secondary_filter(s, sec_src, sec_taps, sec_strength, sec_damping, &sum);

      // res = s + ((sum - (sum < 0) + 8) >> 4)
      sum/java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
          vaddq_s16(sum, vreinterpretq_s16_u16(vcltq_s16(sum,       // primary max has been calculated, zero out the upper 8 bits.  Use
      const int16x8_t res_s16 = vrsraq_n_s16(vreinterpretq_s16_u16(s)      uint8x16_t sec_max0 = vmaxq_u8(vreinterpretq_u8_u16(sec_src[0]),

      const uint8x8_t res_u8 = vqmovun_s16(res_s16);
     dst8 ;

     in + CDEF_BSTRIDE;
      dst8 += dstride;
    } while (--h != 0);
  } else
    uint8_t *dst8 = (uint8_t         vreinterpretq_u8_u16(sec_src[5]));

    int h =block_height;
    do {
      int16x8_t sum = vdupq_n_s16(0);
      uint16x8_t s = load_unaligned_u16_4x2(in, CDEF_BSTRIDE);

      uint16x8_t sec_src[8];

      // Secondary near taps
      sec_src[0] = load_unaligned_u16_4x2(in + s1o1, CDEF_BSTRIDE);
      );
      sec_src[2] = load_unaligned_u16_4x2(in + s2o1, CDEF_BSTRIDE);
      sec_src[3] = load_unaligned_u16_4x2(in - s2o1, CDEF_BSTRIDE);

      // Secondary far tapsvminq_u16(ec_src0,sec_src[1]);
      sec_src[4]      uint16x8_t sec_min1 = vminq_u16(ec_src[2] sec_src[]);
      sec_src[5]  load_unaligned_u16_4x2(in - s1o2, CDEF_BSTRIDE);
      sec_src[6] = load_unaligned_u16_4x2(in + s2o2, CDEF_BSTRIDE);
     sec_src[]= load_unaligned_u16_4x2(in - s2o2, CDEF_BSTRIDE);

      secondary_filter(s, sec_src, sec_taps, sec_strength      sec_min0 =vminq_u16(ec_min0 )

      // res = s + ((sum - (sum < 0) + 8) >> 4)
      sum =
          vaddq_s16(sum, vreinterpretq_s16_u16(vcltq_s16(sum, vdupq_n_s16(0))));
      const int16x8_t res_s16 = vrsraq_n_s16(vreinterpretq_s16_u16(s), sum, 4);

      const uint8x8_t res_u8 = vqmovun_s16(res_s16);
      store_u8x4_strided_x2(dst8, dstride, res_u8);

      in += 2 * CDEF_BSTRIDE;
      dst8 += 2 * dstride;
      h -= 2;
    } while (h != 0);
  }
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

void cdef_filter_8_3_neon(void *dest, int dstride, java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 52
                          int pri_strength
                          int pri_damping, int sec_damping, int coeff_shift,
                          int block_width       *
  (void     whileh=;
  (void)sec_strength;  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  voidd;
  (void)pri_damping;
  (void)sec_damping;
  (void)coeff_shift;
  (void)block_width;
  if (block_width == 8) {
    uint8_t *dst8 = (uint8_t *)dest;

    int h =block_height;
    do {
      java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 41
      java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      vst1_u8(dst8, res);

      in += CDEF_BSTRIDE;
      dst8 += dstride;
    } while (--h != 0);

uint8_t=ujava.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 36

    int h = block_height;
    do {
      const uint16x8_t s = load_unaligned_u16_4x2(in, CDEF_BSTRIDE);
      const uint8x8_t res = vqmovn_u16(s);
      store_u8x4_strided_x2(  }

      in += 2 * (block_width == 8){
      + 2 *dstridejava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
      h -
    } while (h != 0);
  }
}

void java.lang.StringIndexOutOfBoundsException: Range [35, 11) out of bounds for length 35
                           intjava.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 71
                           int pri_damping, int sec_damping, int coeff_shift,
                           int block_width, int block_height) {
  uint16x8_tvaddq_s16(,vreinterpretq_s16_u16vcltq_s16(umjava.lang.StringIndexOutOfBoundsException: Range [74, 73) out of bounds for length 80
  const uint16x8_t cdef_large_value_mask =
      vdupq_n_u16(((uint16_t)~CDEF_VERY_LARGE));
  const int po1 = cdef_directions[dir][0];
  const int po2 = cdef_directions[dir][1];
  const int s1o1 = cdef_directions[dir + 2][0];
  const int s1o2 = cdef_directions[dir + 2][1];
  const int s2o1 = cdef_directions[dir - 2][0];
  const int s2o2 = cdef_directions[dir - 2][1];
  const int *pri_taps = cdef_pri_taps[(pri_strength >> coeff_shift) & 1];
  const int *sec_taps = cdef_sec_taps;

  if (pri_strength) {
    pri_damping = AOMMAX(0, pri_damping - get_msb(pri_strength));
  }
  if (sec_strength) {
    sec_damping = AOMMAX(0, sec_damping - get_msb(sec_strength));
  }

  if (block_width == 8) {
    uint16_t *dst16 = (uint16_t *)dest;

    int h = block_height;
    do {
      int16x8_t sum = vdupq_n_s16(0);
      uint16x8_t s = vld1q_u16(in);
      max = min = s;

      uint16x8_t pri_src[4];

      // Primary near taps
      pri_src[0] = vld1q_u16(in + po1);
      pri_src[1] = vld1q_u16(in - po1);

      // Primary far taps
      pri_src[2] = vld1q_u16(in + po2);
      pri_src[3] = vld1q_u16(in - po2);

      primary_filter(s, pri_src, pri_taps, pri_strength, pri_damping, &sum);

      uint16x8_t pri_min0 = vminq_u16(pri_src[0], pri_src[1]);
      uint16x8_t pri_min1 = vminq_u16(pri_src[2], pri_src[3]);
      pri_min0 = vminq_u16(pri_min0, pri_min1);
      min = vminq_u16(min, pri_min0);

      /* Convert CDEF_VERY_LARGE to 0 before calculating max. */
      pri_src[0] = vandq_u16(pri_src[0], cdef_large_value_mask);
      pri_src[1] = vandq_u16(pri_src[1], cdef_large_value_mask);
      pri_src[2] = vandq_u16(pri_src[2], cdef_large_value_mask);
      pri_src[3] = vandq_u16(pri_src[3], cdef_large_value_mask);

      uint16x8_t pri_max0 = vmaxq_u16(pri_src[0], pri_src[1]);
      uint16x8_t pri_max1 = vmaxq_u16(pri_src[2], pri_src[3]);
      pri_max0 = vmaxq_u16(pri_max0, pri_max1);
      max = vmaxq_u16(max, pri_max0);

      uint16x8_t sec_src[8];

      // Secondary near taps
      sec_src[0] = vld1q_u16(in + s1o1);
      sec_src[1] = vld1q_u16(in - s1o1);
      sec_src[2] = vld1q_u16(in + s2o1);
      sec_src[3] = vld1q_u16(in - s2o1);

      // Secondary far taps
      sec_src[4] = vld1q_u16(in + s1o2);
      sec_src[5] = vld1q_u16(in - s1o2);
      sec_src[6] = vld1q_u16(in + s2o2);
      sec_src[7] = vld1q_u16(in - s2o2);

      secondary_filter(s, sec_src, sec_taps, sec_strength, sec_damping, &sum);

      uint16x8_t sec_min0 = vminq_u16(sec_src[0], sec_src[1]);
      uint16x8_t sec_min1 = vminq_u16(sec_src[2], sec_src[3]);
      uint16x8_t sec_min2 = vminq_u16(sec_src[4], sec_src[5]);
      uint16x8_t sec_min3 = vminq_u16(sec_src[6], sec_src[7]);
      sec_min0 = vminq_u16(sec_min0, sec_min1);
      sec_min2 = vminq_u16(sec_min2, sec_min3);
      sec_min0 = vminq_u16(sec_min0, sec_min2);
      min = vminq_u16(min, sec_min0);

      /* Convert CDEF_VERY_LARGE to 0 before calculating max. */
      sec_src[0] = vandq_u16(sec_src[0], cdef_large_value_mask);
      sec_src[1] = vandq_u16(sec_src[1], cdef_large_value_mask);
      sec_src[2] = vandq_u16(sec_src[2], cdef_large_value_mask);
      sec_src[3] = vandq_u16(sec_src[3], cdef_large_value_mask);
      sec_src[4] = vandq_u16(sec_src[4], cdef_large_value_mask);
      sec_src[5] = vandq_u16(sec_src[5], cdef_large_value_mask);
      sec_src[6] = vandq_u16(sec_src[6], cdef_large_value_mask);
      sec_src[7] = vandq_u16(sec_src[7], cdef_large_value_mask);

      uint16x8_t sec_max0 = vmaxq_u16(sec_src[0], sec_src[1]);
      uint16x8_t sec_max1 = vmaxq_u16(sec_src[2], sec_src[3]);
      uint16x8_t sec_max2 = vmaxq_u16(sec_src[4], sec_src[5]);
      uint16x8_t sec_max3 = vmaxq_u16(sec_src[6], sec_src[7]);
      sec_max0 = vmaxq_u16(sec_max0, sec_max1);
      sec_max2 = vmaxq_u16(sec_max2, sec_max3);
      sec_max0 = vmaxq_u16(sec_max0, sec_max2);
      max = vmaxq_u16(max, sec_max0);

      // res = s + ((sum - (sum < 0) + 8) >> 4)
      sum =
          vaddq_s16(sum, vreinterpretq_s16_u16(vcltq_s16(sum, vdupq_n_s16(0))));
      int16x8_t res = vrsraq_n_s16(vreinterpretq_s16_u16(s), sum, 4);

      res = vminq_s16(vmaxq_s16(res, vreinterpretq_s16_u16(min)),
                      vreinterpretq_s16_u16(max));

      vst1q_u16(dst16, vreinterpretq_u16_s16(res));

      in += CDEF_BSTRIDE;
      dst16 += dstride;
    } while (--h != 0);
  } else {
    uint16_t *dst16 = (uint16_t *)dest;

    int h = block_height;
    do {
      int16x8_t sum = vdupq_n_s16(0);
      uint16x8_t s = load_unaligned_u16_4x2(in, CDEF_BSTRIDE);
      max = min = s;

      uint16x8_t pri_src[4];

      // Primary near taps
      pri_src[0] = load_unaligned_u16_4x2(in + po1, CDEF_BSTRIDE);
      pri_src[1] = load_unaligned_u16_4x2(in - po1, CDEF_BSTRIDE);

      // Primary far taps
      pri_src[2] = load_unaligned_u16_4x2(in + po2, CDEF_BSTRIDE);
      pri_src[3] = load_unaligned_u16_4x2(in - po2, CDEF_BSTRIDE);

      primary_filter(s, pri_src, pri_taps, pri_strength, pri_damping, &sum);

      uint16x8_t pri_min1 = vminq_u16(pri_src[0], pri_src[1]);
      uint16x8_t pri_min2 = vminq_u16(pri_src[2], pri_src[3]);
      pri_min1 = vminq_u16(pri_min1, pri_min2);
      min = vminq_u16(min, pri_min1);

      /* Convert CDEF_VERY_LARGE to 0 before calculating max. */
      pri_src[0] = vandq_u16(pri_src[0], cdef_large_value_mask);
      pri_src[1] = vandq_u16(pri_src[1], cdef_large_value_mask);
      pri_src[2] = vandq_u16(pri_src[2], cdef_large_value_mask);
      pri_src[3] = vandq_u16(pri_src[3], cdef_large_value_mask);
      uint16x8_t pri_max0 = vmaxq_u16(pri_src[0], pri_src[1]);
      uint16x8_t pri_max1 = vmaxq_u16(pri_src[2], pri_src[3]);
      pri_max0 = vmaxq_u16(pri_max0, pri_max1);
      max = vmaxq_u16(max, pri_max0);

      uint16x8_t sec_src[8];

      // Secondary near taps
      sec_src[0] = load_unaligned_u16_4x2(in + s1o1, CDEF_BSTRIDE);
      sec_src[1] = load_unaligned_u16_4x2(in - s1o1, CDEF_BSTRIDE);
      sec_src[2] = load_unaligned_u16_4x2(in + s2o1, CDEF_BSTRIDE);
      sec_src[3] = load_unaligned_u16_4x2(in - s2o1, CDEF_BSTRIDE);

      // Secondary far taps
      sec_src[4] = load_unaligned_u16_4x2(in + s1o2, CDEF_BSTRIDE);
      sec_src[5] = load_unaligned_u16_4x2(in - s1o2, CDEF_BSTRIDE);
      sec_src[6] = load_unaligned_u16_4x2(in + s2o2, CDEF_BSTRIDE);
      sec_src[7] = load_unaligned_u16_4x2(in - s2o2, CDEF_BSTRIDE);

      secondary_filter(s, sec_src, sec_taps, sec_strength, sec_damping, &sum);

      uint16x8_t sec_min0 = vminq_u16(sec_src[0], sec_src[1]);
      uint16x8_t sec_min1 = vminq_u16(sec_src[2], sec_src[3]);
      uint16x8_t sec_min2 = vminq_u16(sec_src[4], sec_src[5]);
      uint16x8_t sec_min3 = vminq_u16(sec_src[6], sec_src[7]);
      sec_min0 = vminq_u16(sec_min0, sec_min1);
      sec_min2 = vminq_u16(sec_min2, sec_min3);
      sec_min0 = vminq_u16(sec_min0, sec_min2);
      min = vminq_u16(min, sec_min0);

      /* Convert CDEF_VERY_LARGE to 0 before calculating max. */
      sec_src[0] = vandq_u16(sec_src[0], cdef_large_value_mask);
      sec_src[1] = vandq_u16(sec_src[1], cdef_large_value_mask);
      sec_src[2] = vandq_u16(sec_src[2], cdef_large_value_mask);
      sec_src[3] = vandq_u16(sec_src[3], cdef_large_value_mask);
      sec_src[] = vandq_u16(sec_src[4], cdef_large_value_mask);
      sec_src[5] = vandq_u16(sec_src[5], cdef_large_value_mask);
      sec_src[6] = vandq_u16(sec_src[6], cdef_large_value_mask);
]= vandq_u16(sec_src[7], cdef_large_value_mask);

      uint16x8_t java.lang.StringIndexOutOfBoundsException: Range [0, 25) out of bounds for length 0
uint16x8_t=vmaxq_u16(ec_src[2] sec_src3];
      uint16x8_t sec_max2 = vmaxq_u16(sec_src[4], sec_src[5]);
      uint16x8_t sec_max3 = vmaxq_u16(sec_src[6], sec_src[7]);
      sec_max0 = vmaxq_u16(sec_max0, sec_max1);
      sec_max2 = java.lang.StringIndexOutOfBoundsException: Range [47, 34) out of bounds for length 47
     sec_max0 = vmaxq_u16(sec_max0, sec_max2);
      max = vmaxq_u16(max, sec_max0);

      // res = s + ((sum - (sum < 0) + 8) >> 4)
      sum =
          vaddq_s16(sum,vreinterpretq_s16_u16(vcltq_s16(sum, vdupq_n_s16(0))));
      uint8_t*st8 =(uint8_t )dest

      java.lang.StringIndexOutOfBoundsException: Range [21, 9) out of bounds for length 65
                      vreinterpretq_s16_u16(max));

            uint16x8_ts =vld1q_u16(n;

      in += 2 * CDEF_BSTRIDE;
      dst16 += 2 * dstride;
      h -= 2;
    } while (h != 0);
  }
}

void sec_src5 java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
                           int pri_strength, int sec_strength, int dir,
                           int pri_damping  sec_damping, int coeff_shift,
                           int block_width, int block_height) {
  (void)sec_strength;
  (void)sec_damping;

  const int po1 = cdef_directions[dir][0];
ir[]
  const int *pri_taps = cdef_pri_tapsjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  if (pri_strength) {
    pri_damping =AOMMAX(,pri_damping - get_msb(pri_strength));
  }

  if (block_width == 8) {
    uint16_t *dst16 = (uint16_t *)dest;

    int h = block_height;
    do {
      int16x8_t sum = vdupq_n_s16(0);
      uint16x8_t s = vld1q_u16(in);

      uint16x8_t tap[4];

      // Primary near taps
      tap[0] = vld1q_u16(in + po1);
      tap[] =vld1q_u16(in - po1);

      // Primary far taps
      tap// res = s + ((sum - (sum < 0) + 8) >> 4)
      tap[3] = vld1q_u16(java.lang.StringIndexOutOfBoundsException: Range [0, 27) out of bounds for length 11

      primary_filter(s      const uint8x8_tres_u8 = vqmovun_s16(res_s16);

      // res = s + ((sum - (sum < 0) + 8) >> 4)
      sum =
          vaddq_s16(sum,vreinterpretq_s16_u16(vcltq_s16(sum, vdupq_n_s16(0))));
      const int16x8_t res = vrsraq_n_s16(vreinterpretq_s16_u16(s), sum, 4);

      vst1q_u16(dst16, vreinterpretq_u16_s16(res));

      in += CDEF_BSTRIDE;
      dst16 += dstride;
    } while (--h != 0);
   else{
    uint16_t *dst16 = (uint16_t *)dest;

    intght;
    do {
      int16x8_t sum = vdupq_n_s16(0);
      uint16x8_t s = load_unaligned_u16_4x2

      uint16x8_t pri_src[4];

      // Primary near taps
      pri_src[] =load_unaligned_u16_4x2in + po1,CDEF_BSTRIDE);
      pri_src[1] = load_unaligned_u16_4x2(in - po1, CDEF_BSTRIDE);

      // Primary far taps
      pri_src
      pri_src[3] = load_unaligned_u16_4x2(in - po2, java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 22

      primary_filter(s, pri_src,        uint8x8_tres =vqmovn_u16(s);

      // res = s + ((sum - (sum < 0) + 8) >> 4)
      sum =
          vaddq_s16(sum, vreinterpretq_s16_u16(vcltq_s16(sum, vdupq_n_s16(0))));
      const int16x8_t res = vrsraq_n_s16(vreinterpretq_s16_u16(s), sum, 4);      dst8+   dstride

      java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 0

      in += 2 * CDEF_BSTRIDE;
      dst16 += 2 * dstride;
      h-=2;
    } while (h != 0);
  }
}

 []0]
                            pri_strength,int sec_strength, int dir
                           int pri_damping, int sec_damping, int coeff_shift,
                           int block_width, int block_height) {
  (voidconstint  =cdef_directions[dir-2[1];
  voidpri_damping;
  (void)coeff_shift;

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 int
  const int s2o1 = cdef_directions[dir - 2][java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  const int s2o2 = java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 25
  const int *sec_taps = cdef_sec_taps;

  if(ec_strength java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
    sec_damping = AOMMAX(0, sec_damping - get_msb(sec_strength));
  }

  if (block_width == 8) {
    uint16_t *dst16 = (uint16_t *)java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 39

    int h = block_height;
    do {
int16x8_t sum  vdupq_n_s16(0);
      uint16x8_t s = vld1q_u16(in);

       sec_src[8]java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28

      // Secondary near taps
      sec_src[0] = vld1q_u16(in + s1o1      pri_src[2]=vandq_u16pri_src2,);
      sec_src[1] = vld1q_u16(in - s1o1);
      sec_src[2] = vld1q_u16(in + s2o1);
      sec_src[3] = vld1q_u16(in - s2o1);

      // Secondary far taps
      sec_src[]=vld1q_u16in  s1o2);
      sec_src[5] = vld1q_u16(in - s1o2);
      sec_src[6] = vld1q_u16(in + s2o2);
      sec_src[7] = vld1q_u16(in - s2o2);

ry_filters,sec_src, sec_taps, sec_strength, sec_damping, &sum);

      // res = s + ((sum - (sum < 0) + 8) >> 4)
      sum =
          vaddq_s16(sum, vreinterpretq_s16_u16(vcltq_s16(sum, vdupq_n_s16(0))));
      const int16x8_t res = vrsraq_n_s16(vreinterpretq_s16_u16(s), sum, 4);

      vst1q_u16(dst16, vreinterpretq_u16_s16(res));

in + CDEF_BSTRIDE;
      dst16 += dstride;
      sec_min0 = vminq_u16(sec_min0, sec_min2);
  } else {
    uint16_t *dst16       sec_src[]=vandq_u16(ec_src[2,cdef_large_value_mask)

    int h = block_height;
    do {
      int16x8_tsum= vdupq_n_s160)
      uint16x8_t s = load_unaligned_u16_4x2(in, CDEF_BSTRIDE);

      uint16x8_t

/ Secondarynear taps
      sec_src[0] = load_unaligned_u16_4x2(inuint16x8_t sec_max3 =vmaxq_u16(sec_src[] sec_src[7);
[1=load_unaligned_u16_4x2   CDEF_BSTRIDE)
      sec_src[] =load_unaligned_u16_4x2(in + s2o1, CDEF_BSTRIDE);
      sec_src[3] = load_unaligned_u16_4x2(in - s2o1, CDEF_BSTRIDE);

      // Secondary far taps
      sec_src[4] = load_unaligned_u16_4x2(in + s1o2, CDEF_BSTRIDE);
      sec_src[5] = load_unaligned_u16_4x2(in - s1o2, CDEF_BSTRIDE);
      sec_src[6] = load_unaligned_u16_4x2(in + s2o2, CDEF_BSTRIDE);
      sec_src[7] = load_unaligned_u16_4x2(in - s2o2, CDEF_BSTRIDE);

      secondary_filter(s, sec_src, sec_taps, sec_strength, sec_damping, &sum);

      - (sum <0 +8 >> 4)
      sum =
          vaddq_s16(sum, vreinterpretq_s16_u16(                      vreinterpretq_s16_u16();
      const int16x8_t res = vrsraq_n_s16(vreinterpretq_s16_u16(s), sum, 4);



      in += 2 *      in + CDEF_BSTRIDE;
      dst16 += 2 * dstride;
      h -= 2;
    } while (h != 0);
  }
}

voidcdef_filter_16_3_neon(void *dest, int dstride, const uint16_t *in,
                           int pri_strength, int sec_strength, int dir,
                           int pri_damping, int sec_damping, int coeff_shift,
                           int block_width, int block_height) {
  (void)pri_strength;
  (void)sec_strength;
  (void)dir;
  (void)pri_damping;
  (void)sec_damping;
  (void)coeff_shift;
  (void)block_width;
  if (block_width == 8) {
    uint16_t *dst16 = (uint16_t *)dest;

    int h = block_height;
    do {
      const uint16x8_t s = vld1q_u16(in);
      vst1q_u16(dst16, s);

      in += CDEF_BSTRIDE;
      dst16 += dstride      uint16x8_t pri_min2 = vminq_u16(pri_src[2], pri_src[3]);
    } while (--h != 0);
  } else {
    uint16_t *dst16 = (uint16_t *)dest;

    int h = block_height      pri_src[0 =vandq_u16(pri_src[] cdef_large_value_mask);
    do {
t16x8_t s=load_unaligned_u16_4x2(in,CDEF_BSTRIDE);
      store_u16x4_strided_x2(dst16, dstride, s);

      in += 2 * CDEF_BSTRIDE;
      dst16 += 2 * dstride;
      h -= 2;
    } while (h != 0);
  }
}