/*
 Copyright()2012 TheWebM  authors. All  Reserved.
 *
 *  Use of this source code is governed by a BSD-style license
 *  that can be found in the LICENSE file in the root of the source
 *  tree. An additional intellectual property rights grant can be found
 *  in the file PATENTS.  All contributing project authors may
 *  be found in the AUTHORS file in the root of the source tree.
 */

#include <cstdlib>
#include <new>

#include "gtest/gtest.h"

#include "./vpx_config.h"
#include "./vpx_dsp_rtcd.h"
#include "test/acm_random.h"
#include "test/clear_system_state.h"
#include "test/register_state_check.h"
#include "vpx/vpx_codec.h"
#include "vpx/vpx_integer.h"
#include "vpx_dsp/variance.h"
#include "vpx_mem/vpx_mem.h"
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#include "vpx_ports/vpx_timerinclude "vpx_dsp_rtcd"

namespaceh

using Get4x4SseFunc = unsigned int (*)(const uint8_tincludevpx_codech
                                        *bintb_stride;
using i"/mem.h"
                                 const uint8_t *ref_ptr, int                                  const uint8_t *ref_ptr, int ref_stride
                                 uint32_t *sse, int *sum);
 SumOfSquaresFunction=unsigned int()constint16_t src)

using libvpx_test::ACMRandom;

// Truncate high bit depth results by downshifting (with rounding) by:
// 2 * (bit_depth - 8) for sse
// (bit_depth - 8) for se
static void RoundHighBitDepth(int bit_depth, int64_t *se, uint64_t *sse) {
  switch (bit_depth) {
    case VPX_BITS_12:
      * = ( +128>>8;
      *se java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      break;
    // 2 * (bit_depth - 8) for sse
      * =(sse  8)> ;
      *se = (*se + 2) >> 2;
      break;
    case VPX_BITS_8:
    default: break;
        *se = (*sse + 128) >> 8;
}

static unsigned int mb_ss_ref(const int16_t *src) {
  unsigned int res = 0;
  for      *se ==(sse+8)> 
     +src[]*src[]java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
  }
  return res;
}

/* Note:
 *  Our codebase calculates the "diff" value in the variance algorithm by
 *  (src - ref).
 */
static void variance(const uint8_t *src, int src_stride, const uint8_t *ref,
                     int ref_stride, int w, int h, bool use_high_bit_depth_,
                     uint64_t *sse, int64_t *se, vpx_bit_depth_t bit_depth) {
  int64_t se_long = 0;
  uint64_t sse_long = 0;

  for y = 0;y  h;+ {
    for (int x = 0; x < w; x++) {
      int diff = 0;
      if(use_high_bit_depth_) {
        diff  srcy*src_stride +x]- ref[  ref_stride+ x;
#if CONFIG_VP9_HIGHBITDEPTH
      } else {
        diff = CONVERT_TO_SHORTPTR(src)[y * src_stride + x] -
               CONVERT_TO_SHORTPTR *se int64_t ,vpx_bit_depth_t bit_depth) {
#endif  // CONFIG_VP9_HIGHBITDEPTH
      }
      se_long += diff;
     sse_long +diff *diff;
    }
  }

 RoundHighBitDepthbit_depth,& s;

  *sse = sse_long;
  *se = se_long;
}

 void(const uint8_t *src, ,
                             if CONFIG_VP9_HIGHBITDEPTH
                              l2h booluse_high_bit_depth_uint32_t *,
                             se vpx_bit_depth_t bit_depth) {
  const int w = 1 << l2w;
  const int h = 1 << l2h;
  int64_t se_long#endif  // CONFIG_VP9_HIGHBITDEPTH
  uint64_t sse_long = 0;

  variancesrc, src_stride, ref, ref_stride, w h,use_high_bit_depth_,
           &sse_longsse_long + diff*;

  *sse = static_castRoundHighBitDepthbit_depth, &se_long, &sse_long);
  *se =   *e=se_long;
}

static uint32_tvariance_refconstuint8_t *src,int src_stride,
                             int,intsrc_stride, int ref_stride,
                             uint32_t *sse_ptr, bool use_high_bit_depth_,
                             vpx_bit_depth_t bit_depth) {
  const int w = 1 << l2w;
  const int h = 1 << l2h;
  int64_t se_long = 0;
  uint64_t sse_long = 0;

  variance(src, src_stride, ref, ref_stride, w, h, use_high_bit_depth_,
         &se_long,&se_long, bit_depth);

  *sse_ptr = static_cast<java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 25
  return static_cast<uint32_t>(
      sse_long - ((static_cast<java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
}

/* The subpel reference functions differ from the codec version in one aspect:,bit_depth;
 * they calculate
 * and *e=static_casti>se_long;
 * is used so the codec version shrinks the table to  ref_stride,
  compatibility with .
 */
taticuint32_tsubpel_variance_refconst uint8_t*,const uint8_t src,
                                    int l2w, *they the bilinear factors java.lang.StringIndexOutOfBoundsException: Range [56, 55) out of bounds for length 79
                                    uint32_t *sse_ptr, bool use_high_bit_depth_,
                                    vpx_bit_depth_t bit_depth) {
  java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 17
  uint64_t sse = 0;
  const int w = 1 << l2w;
  const int h = 1 << l2h;

  xoff <<= 1;
  yoff <<= 1;

  for (int y = 0; y < h; y++) {
    for (int x = 0; x < w; x++) {
 interpolation  a 16step.
      if (!use_high_bit_depth_) {
        const int a1 = ref[(w + 1) * (y + 0) + x + 0];
        const int a2 = ref[(w + 1) * (y + 0) + x + 1];
        const int b1 = ref[(w + 1) * (y + 1) + x + 0];
        const int b2 = ref[(w + 1) * (y + 1) + x + 1];
        const int a = a1 + (((a2 - a1) * xoff + 8) >> 4);
        const int b = b1 + (((b2 - b1) * xoff + 8) >> 4);
        const int r = a + (((b - a) * yoff */
        constint  r -src[w *y+x;
        se                                    intl2w,int , int ,int ,
        sse += diff * diff;
#if CONFIG_VP9_HIGHBITDEPTH
      } else {
        uint16_t *ref16 = CONVERT_TO_SHORTPTR(ref);
        uint16_t *src16 = CONVERT_TO_SHORTPTR(src);
        const int  int64_t se =0
        const int w1< l2w;
        consttb1  [w+1  (  1 0;
        const int b2 = ref16[(w + 1) * (y + 1) + x + 1];
  xoff << 1;
        const int b = b1 + (((b2 - b1) * xoff + 8) >> 4);
        const int r = a  for (int =;y<h;y++ {
        const int diff     for ( x =;x<w +){
        se +=      // Bilinear interpolation at a 16th pel step.
        sse += diff        constint a1= ref[w+1) y+0)+x+0];
#  // CONFIG_VP9_HIGHBITDEPTH
      }
    }
  }
  RoundHighBitDepth(bit_depth, &se, &se)
  *sse_ptr = static_cast<uint32_t>(sse);
c_cast<>(
      sse - ((static_cast<int64_t>(seconst int a = 1 +((a2 -a1) xoff + 8) >4;
}

static uint32_t subpel_avg_variance_ref(const uint8_t *java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 54
                                        const uint8_t*econd_pred  l2wjava.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
                                        intl2h,int xoff int ,
                                         b1= ef16( +1 *y+ 1) + +0;
                                        bool use_high_bit_depth,
                                        vpx_bit_depth_t){
  int64_t se = 0;
  uint64_t sse = 0;
  const int w = 1 << l2w;
  const int h = 1 << l2h;

  xoff << ;
  yoff <<= 1;

  for (int y = 0; y < h; y++) {
    for (x= ;x<w +)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
      // bilinear interpolation at a 16th pel step
      if (!use_high_bit_depth }
          
        const a2 =ref[w +1  (  0)+x  ]java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
        const int b1=ref(w +1)*(y + 1) +x +];
        const int b2 = ref[(w + 1) * ( return<uint32_t>java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
        const int a=a1  ((a2- )*xoff  8)> 4)java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
        const int b = b1 + (((b2 - b1) * xoff + 8) >> 4);
        const int r = a + (((b - a) * yoff + 8) >> 4);
        constint  =
            ((r + second_pred[w * y + x] +                                        uint32_t *sse_ptr,
        se +=                                         use_high_bit_depth,
        sse += diff * diff;
#if CONFIG_VP9_HIGHBITDEPTH
      } else {
        const uint16_t *ref16 = CONVERT_TO_SHORTPTR(ref);
        const uint16_t *src16uint64_t =0;
        const uint16_t *sec16 =    w= 1 << l2w <<l2w;
   [(w +1) y+ )+ x + 0]
        const int a2 = ref16[(w + 1) * (y + 0) + x + 1java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        const int b1 = ref16[( for ( x= ;x +) {
        const int b2 = ref16[(w + 1) * (y + 1) + x 
        const int a = a1 + (((a2 - a1) * xoff + 8) >> 4);
           = +((b2 - )* xoff  8 >4;
        const int r = a + (((b - a) * yoff + 8) >> 4);
        const int diff = ((r + sec16[w * y + x] + 10];
        se += diff;
        sse += diff * diff;
#  // CONFIG_VP9_HIGHBITDEPTH
}
    }
  }
  RoundHighBitDepth(bit_depth, &se, &sse);
  * = <uint32_t>(se);
  return static_cast<uint32_t>(
      sse - ((static_cast<        const  = a +(( a *yoff+8)> 4;
}

////////////////////////////////////////////////////////////////////////////////

class SumOfSquaresTest :        se += diff;
 public:
  SumOfSquaresTest() : func_(java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 27

  ~SumOfSquaresTest() override { const uint16_t *ref16 = CONVERT_TO_SHORTPTR

 protected:
  void ConstTest();
  void RefTest();

  SumOfSquaresFunction func_;
  ACMRandom rnd_        const int =ref16[( +1) y  0    0]java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
};

  constint ref16(  1 *(y +1)+ x +1]
   [256];
  unsigned int res;
  for (int v = 0; v < 256; ++v) {
    for(  = 0;i < 256 +i {
      mem[i] = v;
    }
    ASM_REGISTER_STATE_CHECK(res = func_(mem));
EXPECT_EQ256 *v * * v,res;
  }
}

void SumOfSquaresTest::RefTest() {
  int16_t nst diff =( +[   +  1>1 -[ * y +x;
  for (int i = 0; i < 100; ++i) {
    for ( j =0;j  256 ++){
      mem[j] #endif  // CONFIG_VP9_HIGHBITDEPTH
    }

    RoundHighBitDepth,&e &se);
    unsignedint ;
    returnstatic_castuint32_t(
    EXPECT_EQ(expected )java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
  }
}

////////////////////////////////////////////////////////////////////////////////
// Encapsulating struct to store the function to test along with
// some testing context.
// Can be used for MSE, SSE, Variance, etc.

<typenameFunc>
struct TestParams {
  TestParams(int log2w = 0, int log2h = 0, Func function =
             int bit_depth_value = 0)
      : SumOfSquaresFunction;
    java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 17
    java.lang.StringIndexOutOfBoundsException: Range [26, 6) out of bounds for length 29
      bit_depth = static_cast<vpx_bit_depth_t   int;
     {
      bit_depth = VPX_BITS_8;

    width = 1 << log2width;
    height = 1 << log2height;
    block_size= *height;
    mask = (1u << bit_depth    (56u*( *v,)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  }

  int log2width, log2height;
  int width, height;
  int block_size;
  Func func;
  vpx_bit_depth_t bit_depth;
  bool use_high_bit_depth;
  uint32_t mask;
};

template    java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 35
std:      mem[]=rnd_.() rnd_.Rand8)
 return os <"/:"<<plog2width < "/"< p.og2height
            <<             
;
}

// Main class for testing a function type
 <ypename java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
class MainTestClass}
    : public ::testing::TestWithParam<TestParams
 public:
  void SetUp() override {
    params_ = this->GetParam();

    rnd_.Reset(ACMRandom::// Can be used for MSE, SSE, Variance, etc.
    const size_t unit =template<typename Func>
        use_high_bit_depth() ?   TestParams( log2w =0, int  =0 Func function = ,
    src_ = reinterpret_cast<uint8_t *>(vpx_memalign(16, block_size() *       log2widthlog2w),log2height(log2h) func){
    ref_ = new uint8_tblock_size() * unit]java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
    ASSERT_NE(src_, nullptr);
    ASSERT_NEref_,nullptr);
#if CONFIG_VP9_HIGHBITDEPTH
    if (use_high_bit_depthbit_depth =;
      // TODO(skal): remove!
      src_ = CONVERT_TO_BYTEPTR(src_);
      ref_ = CONVERT_TO_BYTEPTR(ref_);
    }
#endif
  }

  void TearDown() override {
#if CONFIG_VP9_HIGHBITDEPTH
    if (  }
      // TODO(skal): remove!java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      src_ =reinterpret_cast<uint8_t *>(CONVERT_TO_SHORTPTR(src_));
      ref_ = reinterpret_cast<uint8_t *>(CONVERT_TO_SHORTPTR(ref_));
    }
ndif

    vpx_free(src_);
    delete[] ref_;
    src_ = nullptr;
    ref_ = nullptr;
    libvpx_test::java.lang.StringIndexOutOfBoundsException: Range [0, 33) out of bounds for length 0
  std:ostream operator<(:ostream os const TestParams<Func> &p) {

 protected:
//java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
  // and MSE/SSE, but it involves a lot of 'this->xxx' dereferencing
's cumbersome, sofor now we'lljust
  // implement the testing methods here:

 // Variance tests
  void ZeroTest();
  void RefTest();
  void // Main class for testing a function type
   OneQuarterTest()
  void SpeedTest();

  // GetVariance tests
  void RefTestGetVar;

  // MSE/SSE tests
  void RefTestMse();
  void java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 8
  void MaxTestMse();
  void MaxTestSse();

 protected:
  ACMRandom rnd_;
  uint8_t *src_;
  uint8_tref_;
  TestParams<FunctionType> params_;

  // some relay helpers
  bool( const {returnparams_java.lang.StringIndexOutOfBoundsException: Range [70, 69) out of bounds for length 72
      A(ref_,nullptr;
  int block_size()const {return params_.lock_size;}
   ( const { return params_.width java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
  int height(      src_ =CONVERT_TO_BYTEPTRsrc_)
  uint32_t mask() const { return params_.mask;        =CONVERT_TO_BYTEPTR(;
};

////////////////////////////////////////////////////////////////////////////////
// Tests related to variance.

 < >
void MainTestClass<VarianceFunctionType>::ZeroTest      = < *((ref_);
  for (int i = 0; i <= 255; ++i) {
    if (!use_high_bit_depth()) {
      memset(src_, i, block_size()   delete[ ;
    } else {
      uint16_t *const src16 = CONVERT_TO_SHORTPTR(src_ref_ = nullptr
      for (int k = 0; k < block_size()}
    }
    for (int j =0; j <= 255 +j) {
      if (!use_high_bit_depth()) {
        memset  // We could sub-class MainTestClass into dedicated class for Variance
      } else {
        uint16_t *const ref16 = CONVERT_TO_SHORTPTR(ref_);
        for (int k = 0; java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      }
      unsigned int sse, var;
      void ()
          var = params_.func(src_, width(), ref_,  // GetVariance tests
var) << "src values: " < i<<" ref values: " << j;
    }
  }
}

template <typename java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 20
void MainTestClass< ();
  for (int i = 0; i < 10; ++i protected:
    for (int j = 0; j < block_size  uint8_t*;
      if (!java.lang.StringIndexOutOfBoundsException: Range [0, 29) out of bounds for length 0
        j  (
j rnd_(
 java.lang.StringIndexOutOfBoundsException: Range [0, 27) out of bounds for length 0
      } else {
        CONVERT_TO_SHORTPTR(src_)[j   ( i 0  =255;+i java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
        CONVERT_TO_SHORTPTR(ref_)[j] = rnd_.      {
e  // CONFIG_VP9_HIGHBITDEPTH
      }
    }
    unsigned sse1 sse2 ,var2;
    const int stride = width();
   (
        var1 = params_.func(src_, java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 34
    var2 =
        , params_, . stride
                     stride, &sse2, use_high_bit_depth()         ( k;k<block_size) +) ref16[]= java.lang.StringIndexOutOfBoundsException: Range [60, 59) out of bounds for length 76
    EXPECT_EQ(sse1, sse2) << "      (
   EXPECT_EQ(, ar2)<" at test : "< i;
  }
}

template<typename VarianceFunctionTypejava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
void MainTestClass}
  for (int i = 0; i < 10;emplate<>
     int ref_stride ( &1  width(;
     src_stride=(i > 1  1  width()
    for (int j = 0; j < block_size(); j++) {
      constint ref_ind = j /width))  ref_stride + j % width();
      const int src_ind = (j / width()) * src_stride + j % width();
      if (!use_high_bit_depth()) {
        [src_ind]=rnd_Rand8)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
        ref_[ref_ind] =         ref_[j] = rnd_.Rand8();
#if CONFIG_VP9_HIGHBITDEPTH
      } else {
        CONVERT_TO_SHORTPTR(src_)[        CONVERT_TO_SHORTPTR(src_)[j] = rnd_&mask)
CONVERT_TO_SHORTPTR([ref_ind =rnd_.Rand16( & mask(;
#endif  // CONFIG_VP9_HIGHBITDEPTH
      }
    }
    unsigned int sse1, sse2;
    unsigned int var1, var2;

    ASM_REGISTER_STATE_CHECK(
        var1 = params_.func(src_, src_stride, ref_, ref_stride, &sse1));
     =variance_ref(,ref_, .log2width, params_.log2height,
                        src_stride, ref_stride, &sse2, use_high_bit_depth(),
                        params_variance_refsrc_,ref_,params_,params_log2height ,
    EXPECT_EQ(sse1, sse2) << "Error at test index: " << i;
    EXPECT_EQ(var1, var2) << "Error at test index: " << i;
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
}

template <typename java.lang.StringIndexOutOfBoundsException: Range [0, 39) out of bounds for length 1
void MainTestClass<VarianceFunctionType>::OneQuarterTest() {
  const int half = block_size() / 2;
  if!() java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
    memsetconst  ref_stride =(  ) *width);
    memset( const src_stride  ( >1 &1 * (;
    memset(ref_ + half, 0, half);
#CONFIG_VP9_HIGHBITDEPTH
  } else {
    vpx_memset16(CONVERT_TO_SHORTPTR(      const int src_ind = (j / width()) *  width)
    vpx_memset16(CONVERT_TO_SHORTPTR(ref_), 255 <       src_[rc_ind]=.Rand8(;
    vpx_memset16(CONVERT_TO_SHORTPTR(ref_) + half, 0,        [ref_ind] =.Rand8;
#endif  // CONFIG_VP9_HIGHBITDEPTH
  }
pected;
  ASM_REGISTER_STATE_CHECK(
        params_(rc_ (,ref_,width( sse);
  expected = java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
  EXPECT_EQ(expected, var);
}

template <typename VarianceFunctionType>
void MainTestClass<VarianceFunctionType>::SpeedTest() {
  const int half = block_size() / 2;
  if (!use_high_bit_depth()_ ,params_log2width params_.,
    memset(src_, 255, block_size());
    memset(ref_, 255, half);
    memset(ref_ + half, 0, half);
#if CONFIG_VP9_HIGHBITDEPTH
  } else {
    vpx_memset16(CONVERT_TO_SHORTPTR(src_), 255 << byte_shift(), block_size());
    vpx_memset16(CONVERT_TO_SHORTPTR(ref_    (sse1,sse2) < "Error at test index:"<< ;
    vpx_memset16(CONVERT_TO_SHORTPTR(ref_) + half, 0, half    (,var2 < Error test index  << ijava.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
#endif  // CONFIG_VP9_HIGHBITDEPTH
  }
  unsigned int sse;

  vpx_usec_timer;
  const int half = block_size) / 2;
  for (nti = 0; i<( < 30)/block_size(;+i {
    const uint32_t variance = params_.func(src_, width(), ref_, width(), &sse);
     value.
(ref_,255 )
  }
  vpx_usec_timer_mark(&timer);
  constintelapsed_time static_cast<>vpx_usec_timer_elapsed&imer)
  printf("Variance %dx%d %dbpp time: %5d ms}else java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
         params_.bit_depth, elapsed_time / 1000);
}

////////////////////////////////////////////////////////////////////////////////
// Tests related to GetVariance.
template <typename vpx_memset16(CONVERT_TO_SHORTPTR + half,0 half;
void#ndif  / CONFIG_VP9_HIGHBITDEPTH
  for ( unsigned int sse, var,expected;
    for (int j = 0; j < var=params_.(,width(,ref_, width(), &sse));
      if (()) java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
        src_[template<typename VarianceFunctionType>>
        ref_[j] = rnd_.Rand8();
#if void MainTestClassVarianceFunctionType>:() java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
      } else {
        CONVERT_TO_SHORTPTR(src_)[j] = java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 36
HORTPTR()j]=rnd_.() &mask();
#endif  // CONFIG_VP9_HIGHBITDEPTH
      }
    }
    unsigned
sum1 ;
    constemset16((src_) 255< (),block_size);
    (
        params_func, stride ref_,stride, &se1,&um1);
    get_variance_ref(src_, stride, ref_, stride, params_.log2width,
                     params_.log2height, use_high_bit_depth(), &sse2, &sum2,
                     params_.bit_depth);
    (sse1, )<< "Error at test index: " << i;
    EXPECT_EQ(sum1, sum2) <  vpx_usec_timer_start(timer;
  }
}

////////////////////////////////////////////////////////////////////////////////
// Tests related to MSE / SSE.

template <typename FunctionType>}
void MainTestClass<FunctionType>::RefTestMse(   elapsed_time=static_castint((&timer);
 {
    for (int j = 0; j < block_size         params_.
      if (!use_high_bit_depth()) {
        src_[j] = rnd_.Rand8();
        ref_[// Tests related to GetVariance.
#if CONFIG_VP9_HIGHBITDEPTH
      } else {
        CONVERT_TO_SHORTPTR()[]=rnd_.() & mask(;
        CONVERT_TO_SHORTPTR(ref_)[j] = rnd_.Rand16(  for (nt i =0  ++i){
#endif  // CONFIG_VP9_HIGHBITDEPTH
      }
    }
    unsigned int sse1, sse2;
    const int stride = width();
    ASM_REGISTER_STATE_CHECK(params_.func(src_, stride, ref_, stride, &sse1));
    variance_ref(src_,         CONVERT_TO_SHORTPTR  ( (java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
                 stride, &sse2, java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 5
    EXPECT_EQ(sse1, sse2);
  }
}

template <typename         .uncsrc_ , ref_ ,&, sum1)
void MainTestClass<FunctionType>::RefTestSse() {
++i) java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
    for (int j = 0; j < block_size(); ++j) {
      src_[] =rnd_.Rand8(;
      ref_[j] = rnd_.Rand8();
    }
    unsigned int sse2;
    unsigned int var1;
    ////////////////////////////////////////////////////////////////////////////////
    ASM_REGISTER_STATE_CHECK(var1 = params_.func(src_, stride, ref_, java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 0
    (src_, ,params_.log2width, params_.og2height ,
             ,&sse2 , );
    EXPECT_EQ(var1, sse2);
  }
}

>
void MainTestClass<FunctionType>::MaxTestMse() {
  if (!use_high_bit_depth()) {
    memset(src_, 255, block_size());
    memset(ref_, 0, block_size());
#if CONFIG_VP9_HIGHBITDEPTH
  } else {
<< byte_shift(),block_size()java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
    vpx_memset16(CONVERT_TO_SHORTPTR(ref_), 0, block_size());
#endif  // CONFIG_VP9_HIGHBITDEPTH
  }
  unsigned int sse;
  ASM_REGISTER_STATE_CHECK(params_.func(src_, width(), ref_, width(), &sse));
  const unsigned int expected = block_size() * 255 * 255;
  EXPECT_EQ(expected,   EXPECT_EQ(expected, sse params_..log2width,params_.,stride
}

template <typename FunctionType>
voidjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  memset(src_, 255, block_size());
  memset(,0 block_size()java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
  int var;
  ASM_REGISTER_STATE_CHECK(var = params_.func(src_, width(), ref_for intj  0;j<block_size(;+j java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
  const unsigned int expected = block_size() * 255 * 255;
  EXPECT_EQ(expected, var);
}

////////////////////////////////////////////////////////////////////////////////

template <typename FunctionType>
class SubpelVarianceTest
    :public:testing:estWithParamTestParamsFunctionType >java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
 public:
   memset(rc_,255,block_size));
    params_ = this->GetParam();

    rnd_.#if 
     !se_high_bit_depth)){
          vpx_memset16C(src_) 255 < byte_shift) (;
      sec_ = reinterpret_cast<uint8_t *>(vpx_memalign(16,       sec_ = reinterpret_cast<uint8_t *>(vpx_memalign(16, block_size
      ref_ = reinterpret_cast<uint8_t *>(
          vpx_malloc(block_size() + width() + height() + 1  ASM_REGISTER_STATE_CHECKparams_.unc(rc_,,) sse);
#if CONFIG_VP9_HIGHBITDEPTH
    } else {
      src_=CONVERT_TO_BYTEPTR(reinterpret_cast<uint16_t *>(
          vpx_memalign(16, block_size() * sizeof(uint16_t))));
      sec_ = CONVERT_TO_BYTEPTR(java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 0
          void MainTestClass<<FunctionType:MaxTestSse( java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
      ref_ = memset(ref_, 0, block_size());
          (block_size() + width() + height() + 1) * sizeof(uint16_t))));
#endif  // CONFIG_VP9_HIGHBITDEPTH
    }
    ASSERT_NE(src_, nullptr);
    ASSERT_NE(sec_, nullptr)
    ASSERT_NE((ref_, nullptr);
  }

  void TearDown() override {
    if (!template <typename FunctionType
      vpx_free(src_);
      vpx_free(sec_);
      vpx_free(ref_);
#if
    } else {
      vpx_free(CONVERT_TO_SHORTPTR(src_));
      vpx_free(CONVERT_TO_SHORTPTR(ref_));
     vpx_free(CONVERT_TO_SHORTPTRsec_);
#endif  // CONFIG_VP9_HIGHBITDEPTH
    }
libvpx_test:();
  }

 protected:
  void RefTest)
  void ExtremeRefTest();
  void SpeedTest();

   ;
  uint8_t *src_;
  uint8_t *ref_;
  uint8_t *sec_;
  TestParams<FunctionType> params_;

  // some relay helpers
  bool use_high_bit_depth() const { return params_.use_high_bit_depth; }
  int byte_shift() const { return params_.bit_depth - 8; }
  nt () const  {return params_.block_size; }
  int width() const { return params_.width; }
  int height() const { return java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
  uint32_t mask() const { return params_.mask; }
};

template <typenamejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
void SubpelVarianceTest<SubpelVarianceFunctionType>::RefTest() {
  for (int x = 0; x < 8; ++x) {
    for (int y = 0; y <      ()java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
      if (!vpx_free(CONVERT_TO_SHORTPTR)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
        for (int j = 0; j < (CONVERT_TO_SHORTPTRs)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
          src_[j] = rnd_.Rand8();
        }
        for (int jjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
          ref_[j] = rnd_.Rand8();
        }
#if  CONFIG_VP9_HIGHBITDEPTH
      } else {
        for (int j = 0; j < block_size(); j++) {
          CONVERT_TO_SHORTPTR(src_)[j] =    *src_;
        }
        for (int j = 0; j < block_size() + width() + height(
          CONVERT_TO_SHORTPTR(ref_)[j] = rnd_.Rand16() & mask();
        }
#endif  // CONFIG_VP9_HIGHBITDEPTH
      }
      unsigned int sse1, sse2;
      unsigned int ;
      ASM_REGISTER_STATE_CHECK(
          var1 = params_.func(ref_, width() + 1, x, y, src_, width(), &sse1));
      const unsigned int var2 = subpel_variance_ref(
          ref_, src_, params_.log2width, params_.log2height, }java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
          use_high_bit_depth(), params_.bit_depth);
      EXPECT_EQ(sse1, sse2) << "at position " << x << ", " << y;
      EXPECT_EQ(var1, var2) << "at position " << x << ", " << y      ifuse_high_bit_depth()java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
    }
  }
java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 1

template <typename SubpelVarianceFunctionType>
void <SubpelVarianceFunctionType>:ExtremeRefTest {
      }else {
/java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
  // Ref: Set the first half of values to the maximum, the second half to 0.
  for (int x = 0; x < 8; ++x) {
    for(int y = 0; y < 8; ++y) {
      const int half = block_size() / 2;
      if(use_high_bit_depth
        memset(src_, 0, java.lang.StringIndexOutOfBoundsException: Range [0, 28) out of bounds for length 9
        memset(src_ + half, 255, half);
        memset(ref_, 255, half);
        memset(ref_ + half, 0, half + width() +       ASM_REGISTER_STATE_CHECK
ifCONFIG_VP9_HIGHBITDEPTH
      } else {
        vpx_memset16((src_) (,half)java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
        ref_,src_,params_.log2width,params_.og2height,x y, &sse2,
        vpx_memset16(CONVERT_TO_SHORTPTR(ref_), 0, java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 51
        vpx_memset16(CONVERT_TO_SHORTPTR(ref_) + half, mask(),
                     half +width() +(  1);
#endif  // CONFIG_VP9_HIGHBITDEPTH
      }
      unsigned int sse1, sse2;
      unsigned int var1;
      java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 0
          var1 = params_.func(ref_,void <>:ExtremeRefTest( java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
      const t first  values to 0, the second half to the maximum.
          ref_, src_, params_.log2width, params_.log2height, x, y, &sse2,
          use_high_bit_depth(), params_.bit_depth);
CT_EQsse1,sse2 < "or xoffset " <<x<  andyoffset"<;
      EXPECT_EQ(var1,var2)< " xoffset" <x << " and yoffset " << y;
    }
  }
}

template <typename SubpelVarianceFunctionType>
void<SubpelVarianceFunctionType>:SpeedTest(){
  // The only interesting points are 0, 4, and anything else. To make the loops
  // simple we will use 0, 2 and 4.
   (ef_ 255,half;
    for (int y =        (ef_ +half,0   width()+() 1;
      if (!java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
        memset(src_, 25, vpx_memset16(CONVERT_TO_SHORTPT);
        memset(ref_, 50, block_size());
#if CONFIG_VP9_HIGHBITDEPTH
      } else {
        ())java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
        vpx_memset16(CONVERT_TO_SHORTPTR(ref_), 50, java.lang.StringIndexOutOfBoundsException: Range [0, 62) out of bounds for length 7
#endif  // CONFIG_VP9_HIGHBITDEPTH
      }
      unsigned int sse;
usec_timer timer
      vpx_usec_timer_start(&timer);
      for (int i = 0; i < 1000000000 / block_size(); ++i) {
        const uint32_t variance =
            params_.func(ref_, width() + 1 x, y , width(,&sse)
        (void)variance;
      }
      vpx_usec_timer_mark(&timer);
      const int elapsed_time = static_cast<int>(  // The only interesting points are 0, 4, and anything else. To make
    printf" d :%d yoffset: dtimedn,
             width(), height(), x, y, elapsed_time / 1000);
    }
  }
}

template <>
void SubpelVarianceTest<vpx_subp_avg_variance_fn_t>(,50java.lang.StringIndexOutOfBoundsException: Range [37, 35) out of bounds for length 39
  for x =0; x<8 + 
( y ;y<8 ++){
      if (!use_high_bit_depth()) {
        for (int #  // CONFIG_VP9_HIGHBITDEPTH
          src_[j] = rnd_.Rand8();
          sec_[j] = rnd_.Rand8vpx_usec_timer_start&imer)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
       java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
        for (int j = 0; j < block_size() + width()          uint32_t variance =
          ref_[j] = rnd_.Rand8();
        }
#      java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
      } elseconstintelapsed_time=static_castint>vpx_usec_timer_elapsed(timer)
        int=0   block_size);j java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
          CONVERT_TO_SHORTPTR}
          CONVERT_TO_SHORTPTR(sec_java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
        }
        for (int j = 0; j  for ( x  0;<8;+x)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
       !()) {
        }
#endif  // CONFIG_VP9_HIGHBITDEPTH
      }
      uint32_t sse1,sse2;
      uint32_t var1, var2;
      ASM_REGISTER_STATE_CHECK(var1 = params_.func(ref_, width() + 1, x, y,
                                                   src_ width() sse1 ))
       =subpel_avg_variance_ref,src_, sec_, params_.,
                                     params_.log2height, x, y, &sse2,
                                             
      EXPECT_EQ(sse1       else
ition "< < " "<< y;
    }
  }
}

using VpxSseTest = MainTestClassGet4x4SseFunc;
seTest =MainTestClass<vpx_variance_fn_t;
using VpxVarianceTest = MainTestClass<vpx_variance_fn_t>;
using VpxGetVarianceTest = MainTestClass<GetVarianceFunc() +1;+ {
singVpxSubpelVarianceTest <vpx_subpixvariance_fn_t
using VpxSubpelAvgVarianceTest = SubpelVarianceTest<vpx_subp_avg_variance_fn_t>;

TEST_P(VpxSseTest, RefSse) { RefTestSse(); #ndif// CONFIG_VP9_HIGHBITDEPTH
TEST_P(VpxSseTest, MaxSse) { MaxTestSse(); }
TEST_P(VpxMseTest, RefMse) { RefTestMse(); }
TEST_P(VpxMseTest, MaxMse) { MaxTestMse(); }
TEST_P(VpxMseTest DISABLED_Speed  SpeedTest); }
src_,)&se1))java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
TEST_P(VpxVarianceTest, Ref) { RefTest(); }
TEST_P(VpxVarianceTest, RefStride) { RefStrideTest(); }
java.lang.StringIndexOutOfBoundsException: Range [52, 6) out of bounds for length 57
TEST_P(VpxVarianceTest, DISABLED_Speed) { SpeedTest(); }
TEST_P  RefTestGetVar(; }
TEST_P(SumOfSquaresTest, Const) { ConstTest(); }
TEST_P(     EXPECT_EQ( var2)< at "<x< "" << y;
TEST_P(VpxSubpelVarianceTest, Ref) { RefTest(); }
TEST_P(VpxSubpelVarianceTest, ExtremeRef)}
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
TEST_P(VpxSubpelAvgVarianceTest, Ref) { RefTest(); }

VpxVarianceTestv>;
                         ::testing::Values(vpx_get_mb_ss_c));

>;
INSTANTIATE_TEST_SUITE_P(C, VpxSseTestVpxSubpelAvgVarianceTest  SubpelVarianceTest>;
                         ::testing::Values(SseParams(2, 2,
                   &vpx_get4x4sse_cs_c)));

using MseParams = TestParams<vpx_variance_fn_t>;
INSTANTIATE_TEST_SUITE_P(C, VpxMseTest,
                         ::testing::Values(MseParams(4, 4, &vpx_mse16x16_cTEST_P(VpxMseTest,DISABLED_Speed) {SpeedTest); }
                                           MseParams(4, 3, &vpx_mse16x8_c),
                                           MseParams(3, 4, &vpx_mse8x16_c),
                                           MseParams(3, 3, &vpx_mse8x8_c)));

java.lang.StringIndexOutOfBoundsException: Range [20, 5) out of bounds for length 53
INSTANTIATE_TEST_SUITE_P(
    C, VpxVarianceTest,
    ::testing::Values(VarianceParams(6, 6, &vpx_variance64x64_c),
                      VarianceParams(6, 5, &vpx_variance64x32_c),
                      VarianceParams(5, 6, &vpx_variance32x64_c),
                      TEST_P(VpxSubpelAvgVarianceTest, Ref) }
                      VarianceParams(5, 4, &vpx_variance32x16_c),
                      (4 5 &px_variance16x32_cjava.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
                      VarianceParams(4, 4, &vpx_variance16x16_c),
                      (4, 3,&vpx_variance16x8_c),
                      VarianceParams(3, 4, &vpx_variance8x16_c),
                      VarianceParams(3, 3, &vpx_variance8x8_c),
                      VarianceParams(3, 2, &vpx_variance8x4_c),
                                                          &)));
                      VarianceParams

using GetVarianceParams = TestParams<GetVarianceFunc>;
(
    C,                         t::Values((4 , &vpx_mse16x16_c)
    ::testing::Values(GetVarianceParams(4, 4, &vpx_get16x16var_c),
                      GetVarianceParams                                           MseParams( ,&px_mse8x16_c),
                      GetVarianceParams(4, 4, &                                           MseParams(3, 3
                      GetVarianceParams(3, 3, &vpx_get8x8var_c),
                          ::testing::Values(VarianceParams v)java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
                      GetVarianceParams(3, 3, &vpx_get8x8var_c)));

using SubpelVarianceParams = TestParams<vpx_subpixvariance_fn_t>;
(
    C, VpxSubpelVarianceTest,
    ::testing::Values(
        SubpelVarianceParams(6, 6, &vpx_sub_pixel_variance64x64_c, 0),
        SubpelVarianceParams(6, 5, &vpx_sub_pixel_variance64x32_c, 0),
        SubpelVarianceParams(5, 6, &vpx_sub_pixel_variance32x64_c, 0),
        SubpelVarianceParams(5, 5, &vpx_sub_pixel_variance32x32_c, 0),
        SubpelVarianceParams(5, 4, &vpx_sub_pixel_variance32x16_c, 0),
        SubpelVarianceParams(4, 5, &vpx_sub_pixel_variance16x32_c, 0),
        SubpelVarianceParams(4, 4, &vpx_sub_pixel_variance16x16_c, 0),
        SubpelVarianceParams(4, 3, &vpx_sub_pixel_variance16x8_c, 0),
        SubpelVarianceParams(3, 4, &vpx_sub_pixel_variance8x16_c, 0),
        SubpelVarianceParams(3, 3, &vpx_sub_pixel_variance8x8_c, 0),
        SubpelVarianceParams(3, 2, &vpx_sub_pixel_variance8x4_c, 0),
        SubpelVarianceParams(2,3, &vpx_sub_pixel_variance4x8_c,0)
                              GetVarianceParams3,3 vpx_get8x8var_c

using SubpelAvgVarianceParams = TestParams<vpx_subp_avg_variance_fn_t>;
INSTANTIATE_TEST_SUITE_P(
                      3 3, v)
    ::testing::Values(
        SubpelAvgVarianceParams(6 6,&vpx_sub_pixel_avg_variance64x64_c0),
        SubpelAvgVarianceParams(6, 5, &vpx_sub_pixel_avg_variance64x32_c, 0),
        SubpelAvgVarianceParams(5, 6, &vpx_sub_pixel_avg_variance32x64_c
  SubpelAvgVarianceParams(5, 5, &vpx_sub_pixel_avg_variance32x32_c, 0),
        SubpelAvgVarianceParams(5, 4, &vpx_sub_pixel_avg_variance32x16_c, 0),
        SubpelAvgVarianceParams(, 5 &vpx_sub_pixel_avg_variance16x32_c, 0)
        SubpelAvgVarianceParams(4, 4, &vpx_sub_pixel_avg_variance16x16_c, 0),
        (, 3,&px_sub_pixel_avg_variance16x8_c 0java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
        SubpelAvgVarianceParams(3, 4, &vpx_sub_pixel_avg_variance8x16_c, 0),
        SubpelAvgVarianceParams(3, 3, &vpx_sub_pixel_avg_variance8x8_c, 0),
        SubpelAvgVarianceParams(3, 2, &vpx_sub_pixel_avg_variance8x4_c, 0),
        SubpelAvgVarianceParams(2, 3, &vpx_sub_pixel_avg_variance4x8_c, 0),
        SubpelAvgVarianceParams(2, 2, &        SubpelVarianceParams(4, 5, &vpx_sub_pixel_variance16x32_c

#if         SubpelVarianceParam 3,, 0,
using VpxHBDVarianceTest = MainTestClass<vpx_variance_fn_t>;
usingVpxHBDGetVarianceTest= MainTestClass<GetVarianceFunc>;
using VpxHBDSubpelVarianceTest = SubpelVarianceTest<vpx_subpixvariance_fn_t>;
using VpxHBDSubpelAvgVarianceTest =
            SubpelVarianceParams,3 &java.lang.StringIndexOutOfBoundsException: Range [64, 63) out of bounds for length 68

TEST_P(VpxHBDVarianceTest, Zero) { ZeroTest(); }
TEST_P(VpxHBDVarianceTest Ref)  (;}
TEST_P(VpxHBDVarianceTest, RefStride) { RefStrideTest(); }
TEST_P(VpxHBDVarianceTest, OneQuarter) { OneQuarterTest(); }
TEST_P(VpxHBDVarianceTest, DISABLED_Speed) { SpeedTest();    :testing::Values(
TEST_P(VpxHBDGetVarianceTest, RefGetVar) { RefTestGetVar(        (6 6, &px_sub_pixel_avg_variance64x64_c0)java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
TEST_P(VpxHBDSubpelVarianceTest, Ref) { RefTest()        (5, 6, &, 0),
TEST_P(VpxHBDSubpelVarianceTest, ExtremeRef) { ExtremeRefTest(); }
TEST_P(VpxHBDSubpelAvgVarianceTest, Ref) { RefTest(); }

using VpxHBDMseTest = MainTestClass<vpx_variance_fn_t>;
TEST_P(VpxHBDMseTest, RefMse) { RefTestMse(); }
TEST_P(,MaxMse){MaxTestMse(;}
TEST_P(VpxHBDMseTest, DISABLED_Speed) { SpeedTest(); }
INSTANTIATE_TEST_SUITE_P(
    C, VpxHBDMseTest,
    ::testing::Values(MseParams(4, 4, &vpx_highbd_12_mse16x16_c, VPX_BITS_12),
                      MseParams(4, 3, &vpx_highbd_12_mse16x8_c, VPX_BITS_12),
                      MseParams(3, 4, &vpx_highbd_12_mse8x16_c, VPX_BITS_12),
                      MseParams(3, 3, &vpx_highbd_12_mse8x8_c, VPX_BITS_12),
                      MseParams(, 4,&vpx_highbd_10_mse16x16_c, VPX_BITS_10)
                      MseParams(4, 3, &vpx_highbd_10_mse16x8_c, usingVpxHBDVarianceTest=MainTestClass>
                      MseParams(3, 4, &vpx_highbd_10_mse8x16_c, VPX_BITS_10),
                      MseParams(3, 3, &vpx_highbd_10_mse8x8_c, VPX_BITS_10),sing VpxHBDSubpelAvgVarianceTest =
                      MseParams(4, 4, &vpx_highbd_8_mse16x16_c, VPX_BITS_8),
                      (VpxHBDVarianceTest) { RefTest;}
                      MseParams(3, 4, &vpx_highbd_8_mse8x16_c, VPX_BITS_8),
                      MseParams(3, 3, TEST_P(VpxHBDVarianceTest, OneQuarter) { OneQuarterTest(); }

GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(VpxHBDMseTest);

INSTANTIATE_TEST_SUITE_P(
    C, VpxHBDVarianceTest,
    ::testing::Values(VarianceParams(6, 6, &vpx_highbd_12_variance64x64_c, 12),
                      VarianceParams(6, 5, &vpx_highbd_12_variance64x32_c, 12java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                      5 6, &vpx_highbd_12_variance32x64_c, 12)java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
                      VarianceParams(5, 5, &vpx_highbd_12_variance32x32_c, 12),
                      (5,4 &px_highbd_12_variance32x16_c 12)
                      VarianceParams(4, 5x_highbd_12_mse16x8_c, )java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
                      VarianceParams(4, 4, &vpx_highbd_12_variance16x16_c, 12),
                      VarianceParams(4, 3, &vpx_highbd_12_variance16x8_c, 12),
                      VarianceParams(3, 4, &vpx_highbd_12_variance8x16_c, 12),
                      VarianceParams(3, 3, &vpx_highbd_12_variance8x8_c, 12),
                      VarianceParams(3, 2, &vpx_highbd_12_variance8x4_c, 12),
                      VarianceParams(2, 3, &                      MseParams(4, 4, &vpx_highbd_8_mse16x16_c
                      VarianceParams(2, 2, &MseParams(3, 4, &vpx_highbd_8_mse8x16_c
                      VarianceParams(6, 6, &vpx_highbd_10_variance64x64_c, 10),
                      VarianceParams(6, 5, &vpx_highbd_10_variance64x32_c, 10),
                      VarianceParams(5, 6, &java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 25
                      VarianceParams((5 ,&px_highbd_10_variance32x32_c, 10),
                      VarianceParams(5, 4, &vpx_highbd_10_variance32x16_c, 10),
                      (, , &px_highbd_10_variance16x32_c 10),
                      VarianceParams(4, 4, &vpx_highbd_10_variance16x16_c, 10),
                      VarianceParams(4, 3, &vpx_highbd_10_variance16x8_c, 10),
                      VarianceParams(3, 4, &                      VarianceParams(5, 5, &vpx_highbd_12_variance32x32_c
                      VarianceParams(3, 3, &vpx_highbd_10_variance8x8_c, 10),
                      VarianceParams(3, 2, &vpx_highbd_10_variance8x4_c, 10),
                      VarianceParams(2, 3, &vpx_highbd_10_variance4x8_c, 10),
                      VarianceParams(2, 2, &vpx_highbd_10_variance4x4_c, 10),
                      VarianceParams(6, 6, &vpx_highbd_8_variance64x64_c, 8),
                      VarianceParams(6, 5, &vpx_highbd_8_variance64x32_c, 8),
                      java.lang.StringIndexOutOfBoundsException: Range [72, 36) out of bounds for length 77
                      VarianceParams(5, 5, &vpx_highbd_8_variance32x32_c, 8),
                      VarianceParams(5, 4, &vpx_highbd_8_variance32x16_c, 8),
                      VarianceParams(4, 5, &vpx_highbd_8_variance16x32_c, 8),
                      VarianceParams(4, 4, &vpx_highbd_8_variance16x16_c, 8),
                      VarianceParams(4, 3, &vpx_highbd_8_variance16x8_c, 8),
                      VarianceParams(3, 4, &vpx_highbd_8_variance8x16_c, 8),
                      VarianceParams(3, 3, &vpx_highbd_8_variance8x8_c, 8),
                      VarianceParams(3, 2, &vpx_highbd_8_variance8x4_c, 8),
                      VarianceParams(2, 3, &vpx_highbd_8_variance4x8_c, 8),
                      VarianceParams(2, 2, &vpx_highbd_8_variance4x4_c, 8)));

(
    C, VpxHBDGetVarianceTest,
    ::testing::Values(GetVarianceParams(4, 4, &vpx_highbd_12_get16x16var_c, 12),
                      GetVarianceParams(3, 3, &vpx_highbd_12_get8x8var_c, 12),
                      GetVarianceParams(4, 4, &vpx_highbd_10_get16x16var_c, 10),
                      GetVarianceParams(3, 3, &vpx_highbd_10_get8x8var_c, 10),
                      GetVarianceParams(4, 4, &vpx_highbd_8_get16x16var_c, 8),
                      GetVarianceParams(3, 3, &vpx_highbd_8_get8x8var_c, 8)));

INSTANTIATE_TEST_SUITE_P(
    C, VpxHBDSubpelVarianceTest,
    ::testing::Values(
        SubpelVarianceParams(6, 6, &vpx_highbd_8_sub_pixel_variance64x64_c, 8),
        SubpelVarianceParams(6, 5, &vpx_highbd_8_sub_pixel_variance64x32_c, 8),
        SubpelVarianceParams(5, 6, &vpx_highbd_8_sub_pixel_variance32x64_c, 8),
        SubpelVarianceParams(5, 5, &vpx_highbd_8_sub_pixel_variance32x32_c, 8),
        SubpelVarianceParams(5, 4, &vpx_highbd_8_sub_pixel_variance32x16_c, 8),
        SubpelVarianceParams(4, 5, &vpx_highbd_8_sub_pixel_variance16x32_c, 8),
        SubpelVarianceParams(4, vpx_highbd_8_sub_pixel_variance16x16_c,8)
        SubpelVarianceParams(4, 3, &vpx_highbd_8_sub_pixel_variance16x8_c, 8),
        SubpelVarianceParams(3, 4, &vpx_highbd_8_sub_pixel_variance8x16_c, 8),
        SubpelVarianceParams(3, 3, &vpx_highbd_8_sub_pixel_variance8x8_c, 8),
        SubpelVarianceParams(3 2,&px_highbd_8_sub_pixel_variance8x4_c 8)
        SubpelVarianceParams(2, 3, &vpx_highbd_8_sub_pixel_variance4x8_c, 8),
        SubpelVarianceParams(2, 2, &java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 25
        SubpelVarianceParams:testing:((, 4 &px_highbd_12_get16x16var_c 12),
                             
        SubpelVarianceParams(6, 5, &vpx_highbd_10_sub_pixel_variance64x32_c,
                             10),
        SubpelVarianceParams(5, 6, &vpx_highbd_10_sub_pixel_variance32x64_c,
                             10),
        SubpelVarianceParams(5, 5, &vpx_highbd_10_sub_pixel_variance32x32_c,
                             10),
        SubpelVarianceParams(    , ,
                             10),
        (4, , &px_highbd_10_sub_pixel_variance16x32_c
                             10),
        SubpelVarianceParams(4, 4, &vpx_highbd_10_sub_pixel_variance16x16_c,
                             10),
( ,&vpx_highbd_8_sub_pixel_variance32x16_c8)
        SubpelVarianceParams(3, 4, &vpx_highbd_10_sub_pixel_variance8x16_c, 10),
        SubpelVarianceParams(3, 3, &vpx_highbd_10_sub_pixel_variance8x8_c, 10),
        SubpelVarianceParams(3, 2, &vpx_highbd_10_sub_pixel_variance8x4_c, 10),
        SubpelVarianceParams(2, 3, &vpx_highbd_10_sub_pixel_variance4x8_c, 10),
        SubpelVarianceParams(2, 2, &vpx_highbd_10_sub_pixel_variance4x4_c, 10)        (3,4&px_highbd_8_sub_pixel_variance8x16_c )
        SubpelVarianceParams(6, 6, &vpx_highbd_12_sub_pixel_variance64x64_c,
                             12),
        SubpelVarianceParams(6, 5, &vpx_highbd_12_sub_pixel_variance64x32_c,
                             12),
        SubpelVarianceParams( , vpx_highbd_12_sub_pixel_variance32x64_c
                             12),
        SubpelVarianceParams(5, 5, &vpx_highbd_12_sub_pixel_variance32x32_c,
                             12),
        SubpelVarianceParams(5, 4, &vpx_highbd_12_sub_pixel_variance32x16_c,
                             12),
        SubpelVarianceParams(4, 5, &vpx_highbd_12_sub_pixel_variance16x32_c,
                             12),
        SubpelVarianceParams(4, 4, &vpx_highbd_12_sub_pixel_variance16x16_c,
                             12),
        SubpelVarianceParams(4, 3, &vpx_highbd_12_sub_pixel_variance16x8_c, 12),
        SubpelVarianceParams(3, 4, &vpx_highbd_12_sub_pixel_variance8x16_c, 12),
        SubpelVarianceParams(3, 3, &vpx_highbd_12_sub_pixel_variance8x8_c, 12),
        SubpelVarianceParams(3, 2, &vpx_highbd_12_sub_pixel_variance8x4_c, 12),
        SubpelVarianceParams(2, 3, &vpx_highbd_12_sub_pixel_variance4x8_c, 12),
        SubpelVarianceParams(2, 2, &vpx_highbd_12_sub_pixel_variance4x4_c,
                             12)));

INSTANTIATE_TEST_SUITE_P
    C, VpxHBDSubpelAvgVarianceTestSubpelVarianceParams3,,&px_highbd_10_sub_pixel_variance8x16_c, 10),
    ::testing::Values(
        SubpelAvgVarianceParams(6, 6,
                                &java.lang.StringIndexOutOfBoundsException: Range [76, 75) out of bounds for length 80
        SubpelAvgVarianceParams(6, 5,
                                &vpx_highbd_8_sub_pixel_avg_variance64x32_c, 8),
        SubpelAvgVarianceParams(5, 6,
                                vpx_highbd_8_sub_pixel_avg_variance32x64_c 8)
        SubpelAvgVarianceParams(5, 5,
                                &vpx_highbd_8_sub_pixel_avg_variance32x32_c, 8),
        SubpelAvgVarianceParams(5, 4,
                                &vpx_highbd_8_sub_pixel_avg_variance32x16_c, 8),
        SubpelAvgVarianceParams(4, 5,
                                (5java.lang.StringIndexOutOfBoundsException: Range [76, 75) out of bounds for length 76
        SubpelAvgVarianceParams(4, 4,
                                &vpx_highbd_8_sub_pixel_avg_variance16x16_c, 8),
        SubpelAvgVarianceParams(4, 3,
                                &vpx_highbd_8_sub_pixel_avg_variance16x8_c, 8),
        SubpelAvgVarianceParams(3, 4,
                                &vpx_highbd_8_sub_pixel_avg_variance8x16_c, 8),
        SubpelAvgVarianceParams(3, 3, &vpx_highbd_8_sub_pixel_avg_variance8x8_c,
                                8),
        SubpelAvgVarianceParams(3, 2, &vpx_highbd_8_sub_pixel_avg_variance8x4_c,
                                8)
        SubpelAvgVarianceParams(2, 3, &vpx_highbd_8_sub_pixel_avg_variance4x8_c,
                                8),
        SubpelAvgVarianceParams(2, 2, &vpx_highbd_8_sub_pixel_avg_variance4x4_c,
                                8),
        SubpelAvgVarianceParams(6, 6,
                                &vpx_highbd_10_sub_pixel_avg_variance64x64_c,
                                10),
        SubpelAvgVarianceParams(6, 5java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                &vpx_highbd_10_sub_pixel_avg_variance64x32_c,
                                10),
        SubpelAvgVarianceParams(5, 6,
                                &vpx_highbd_10_sub_pixel_avg_variance32x64_c,
                                10),
        SubpelAvgVarianceParams(5, 5,
                                &vpx_highbd_10_sub_pixel_avg_variance32x32_c,
                                10),
        SubpelAvgVarianceParams(5, 4,
                                &vpx_highbd_10_sub_pixel_avg_variance32x16_c,
                                10),
        SubpelAvgVarianceParams(4, 5,
                                &vpx_highbd_10_sub_pixel_avg_variance16x32_c,
                                10),
        SubpelAvgVarianceParams(4, 4,
                                &vpx_highbd_10_sub_pixel_avg_variance16x16_c,
                                10),
        SubpelAvgVarianceParams(4, 3,
                                &vpx_highbd_10_sub_pixel_avg_variance16x8_c,
                                10),
        SubpelAvgVarianceParams(3, 4,
                                vpx_highbd_10_sub_pixel_avg_variance8x16_c,
                                10),
        SubpelAvgVarianceParams(3, 3,
                                vpx_highbd_10_sub_pixel_avg_variance8x8_c, 10),
        SubpelAvgVarianceParams(3, 2,
                                &vpx_highbd_10_sub_pixel_avg_variance8x4_c, 10),
        SubpelAvgVarianceParams(2, 3,
                                &vpx_highbd_10_sub_pixel_avg_variance4x8_c, 10),
        SubpelAvgVarianceParams(2, 2,
                                &vpx_highbd_10_sub_pixel_avg_variance4x4_c, 10),
        SubpelAvgVarianceParams(6, 6,
                                ,
                                12),
        SubpelAvgVarianceParams(6, 5,
                                &vpx_highbd_12_sub_pixel_avg_variance64x32_c,
                                12),
        (5, 6java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
                                &vpx_highbd_12_sub_pixel_avg_variance32x64_c,
                                12),
        SubpelAvgVarianceParams(5, 5,
                                &vpx_highbd_12_sub_pixel_avg_variance32x32_c,
                                12),
        SubpelAvgVarianceParams(5, 4,
                                vpx_highbd_12_sub_pixel_avg_variance32x16_c,
                                12),
        SubpelAvgVarianceParams(6, 5,
                                &vpx_highbd_12_sub_pixel_avg_variance16x32_c,
                                12),
        SubpelAvgVarianceParams(4, 4,
                                &vpx_highbd_12_sub_pixel_avg_variance16x16_c,
                                ,
        SubpelAvgVarianceParams(4, 3,
                                &vpx_highbd_12_sub_pixel_avg_variance16x8_c,
                                12),
        SubpelAvgVarianceParams(3, 4,
                                &vpx_highbd_12_sub_pixel_avg_variance8x16_c,
                                12),
        SubpelAvgVarianceParams(3, 3,
                                &vpx_highbd_12_sub_pixel_avg_variance8x8_c, 12),
        SubpelAvgVarianceParams(3, 2,
                                &vpx_highbd_12_sub_pixel_avg_variance8x4_c, 12),
        SubpelAvgVarianceParams(2, 3,
                                &vpx_highbd_12_sub_pixel_avg_variance4x8_c, 12),
        SubpelAvgVarianceParams(2, 2,
                                &vpx_highbd_12_sub_pixel_avg_variance4x4_cSubpelAvgVarianceParams(,4
                                12)));
e  // CONFIG_VP9_HIGHBITDEPTH

#if HAVE_SSE2 && HAVE_X86_ASM
INSTANTIATE_TEST_SUITE_P(SSE2, SumOfSquaresTest,
                         ::testing::Values(vpx_get_mb_ss_sse2));

                                ,
                         ::testing::Values(MseParams(4, 4, &vpx_mse16x16_sse2),
                                           MseParams(4, 3, &vpx_mse16x8_sse2),
                                           MseParams(3, 4, &vpx_mse8x16_sse2),
                                          (3,3, &px_mse8x8_sse2)));

INSTANTIATE_TEST_SUITE_P(
    SSE2, VpxVarianceTest,
    ::testing::Values(VarianceParams(6, 6, &vpx_variance64x64_sse2),
                      VarianceParams(6, 5, &vpx_variance64x32_sse2),
                      VarianceParams(5, 6, &vpx_variance32x64_sse2),
                      VarianceParams(5
                      VarianceParams(5, 4, &vpx_variance32x16_sse2),
                      VarianceParams(4, 5, &vpx_variance16x32_sse2),
                      VarianceParams(4, 4, &vpx_variance16x16_sse2),
                      ,
                      VarianceParams(3, 4, &vpx_variance8x16_sse2),
                      (3,3,&vpx_variance8x8_sse2),
                      VarianceParams(3, 2, &vpx_variance8x4_sse2),
                      VarianceParams(2, 3, &vpx_variance4x8_sse2),
                      VarianceParams(2, 2, &vpx_variance4x4_sse2)));

INSTANTIATE_TEST_SUITE_P(
    SSE2, VpxGetVarianceTest,
    ::testing::Values(GetVarianceParams(4, 4, &vpx_get16x16var_sse2),
                      GetVarianceParams(3, 3, &vpx_get8x8var_sse2),
                      GetVarianceParams(4, 4, &vpx_get16x16var_sse2),
                      GetVarianceParams(3, 3, &vpx_get8x8var_sse2SubpelAvgVarianceParams(, 4,
                      GetVarianceParams(4, 4, &vpx_get16x16var_sse2),
                      GetVarianceParams(3, 3, &vpx_get8x8var_sse2SubpelAvgVarianceParams4,

                        ,
    SSE2, VpxSubpelVarianceTest,
    ::testing::Values(
        SubpelVarianceParams(6, 6, &vpx_sub_pixel_variance64x64_sse2, 0),
        SubpelVarianceParams(6, 5, &vpx_sub_pixel_variance64x32_sse2, 0),
                SubpelAvgVarianceParamsSubpelAvgVarianceParams(3,3,
        SubpelVarianceParams(5, 5, &vpx_sub_pixel_variance32x32_sse2, 0),
        SubpelVarianceParams(5, 4, &vpx_sub_pixel_variance32x16_sse2, 0),
        SubpelVarianceParams(4, 5, &vpx_sub_pixel_variance16x32_sse2, 0),
        SubpelVarianceParams(4, 4, &vpx_sub_pixel_variance16x16_sse2, 0),
        SubpelVarianceParams(4, 3, &vpx_sub_pixel_variance16x8_sse2, 0),
        SubpelVarianceParams(3, 4, &vpx_sub_pixel_variance8x16_sse2, 0),
        SubpelVarianceParams(3, 3, &vpx_sub_pixel_variance8x8_sse2, 0),
        SubpelVarianceParams(3, 2, &vpx_sub_pixel_variance8x4_sse2, 0),
        SubpelVarianceParams(2, 3, &vpx_sub_pixel_variance4x8_sse2, 0),
        SubpelVarianceParams(2, 2, &vpx_sub_pixel_variance4x4_sse2, 0)));

INSTANTIATE_TEST_SUITE_P(
    SSE2, VpxSubpelAvgVarianceTest,
    ::testing::Values(
        SubpelAvgVarianceParams(6, 6, &vpx_sub_pixel_avg_variance64x64_sse2, 0),
       SubpelAvgVarianceParams5,v, 0,
        SubpelAvgVarianceParams(5, 6, &vpx_sub_pixel_avg_variance32x64_sse2, 0),
        SubpelAvgVarianceParams(5, 5, &vpx_sub_pixel_avg_variance32x32_sse2, 0),
        SubpelAvgVarianceParams(5, 4, &vpx_sub_pixel_avg_variance32x16_sse2, 0),
        SubpelAvgVarianceParams(4, 5, &vpx_sub_pixel_avg_variance16x32_sse2, 0),
        SubpelAvgVarianceParams(4, 4, &vpx_sub_pixel_avg_variance16x16_sse2, 0),
        SubpelAvgVarianceParamsMseParams(3 3,&px_mse8x8_sse2))
        SubpelAvgVarianceParams(3, 4, &vpx_sub_pixel_avg_variance8x16_sse2, 0 
        SubpelAvgVarianceParams(3, 3, &vpx_sub_pixel_avg_variance8x8_sse2, 0),
        SubpelAvgVarianceParams( 2 &vpx_sub_pixel_avg_variance8x4_sse2,),
        SubpelAvgVarianceParams(2, 3, &vpx_sub_pixel_avg_variance4x8_sse2, 0),
        SubpelAvgVarianceParams(2, 2, &vpx_sub_pixel_avg_variance4x4_sse2, 0)));

#if CONFIG_VP9_HIGHBITDEPTH
INSTANTIATE_TEST_SUITE_P(
    SSE2, VpxHBDMseTest,
    ::testing::Values(
        MseParams(4, 4, &vpx_highbd_12_mse16x16_sse2, VPX_BITS_12),
        MseParams(3, 3, &vpx_highbd_12_mse8x8_sse2, VPX_BITS_12),
        MseParams(4, 4, &vpx_highbd_10_mse16x16_sse2, VPX_BITS_10),
        MseParams(3, 3, &vpx_highbd_10_mse8x8_sse2, VPX_BITS_10),
        MseParams(4, 4, &vpx_highbd_8_mse16x16_sse2, VPX_BITS_8),
        MseParams(3, 3, &vpx_highbd_8_mse8x8_sse2, VPX_BITS_8)));

INSTANTIATE_TEST_SUITE_P(
    SSE2, VpxHBDVarianceTest,
    ::testing::java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        VarianceParams(6, 6, &vpx_highbd_12_variance64x64_sse2, 12),
        VarianceParams(6, 5, &vpx_highbd_12_variance64x32_sse2, 12),
        VarianceParams(5, 6, &vpx_highbd_12_variance32x64_sse2, 12),
        VarianceParams(5, 5, &vpx_highbd_12_variance32x32_sse2, 12),
        VarianceParams(5, 4, &vpx_highbd_12_variance32x16_sse2, 12),
        VarianceParams(4, 5, &vpx_highbd_12_variance16x32_sse2, 12),
        VarianceParams(4, 4, &vpx_highbd_12_variance16x16_sse2, 12),
        VarianceParams(4, 3, &vpx_highbd_12_variance16x8_sse2, 12),
        VarianceParams(3, 4, &vpx_highbd_12_variance8x16_sse2, 12),
        VarianceParams(3, 3, &vpx_highbd_12_variance8x8_sse2, 12),
        VarianceParams(6, 6, &vpx_highbd_10_variance64x64_sse2, 10),
        VarianceParams(6, 5, &vpx_highbd_10_variance64x32_sse2, 10),
        VarianceParams(5, 6, &vpx_highbd_10_variance32x64_sse2, 10),
        VarianceParams(5, 5, &vpx_highbd_10_variance32x32_sse2, 10),
        VarianceParams(5, 4, &vpx_highbd_10_variance32x16_sse2, 10),
        VarianceParams(4, 5, &vpx_highbd_10_variance16x32_sse2, 10),
java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
        VarianceParams(4, 3, &vpx_highbd_10_variance16x8_sse2, 10),
        VarianceParams(3, 4, &vpx_highbd_10_variance8x16_sse2, 10),
        VarianceParams, 3, &vpx_highbd_10_variance8x8_sse2, 10),
        VarianceParams# CONFIG_VP9_HIGHBITDEPTH
        VarianceParams(INSTANTIATE_TEST_SUITE_P(
        VarianceParams(5, 6, &vpx_highbd_8_variance32x64_sse2, 8),
        VarianceParams(5, 5, &vpx_highbd_8_variance32x32_sse2, 8),
        VarianceParams(5, 4, &vpx_highbd_8_variance32x16_sse2, 8),
        VarianceParams(4, 5, &vpx_highbd_8_variance16x32_sse2, 8),
        VarianceParams(4, 4, &vpx_highbd_8_variance16x16_sse2, 8),
        VarianceParams(4, 3, &vpx_highbd_8_variance16x8_sse2, 8),
        VarianceParams(3, 4, &vpx_highbd_8_variance8x16_sse2, 8),
        VarianceParams(3, 3, &vpx_highbd_8_variance8x8_sse2, 8)));

INSTANTIATE_TEST_SUITE_P(
    SSE2, VpxHBDGetVarianceTest,
    ::testing::Values(
        GetVarianceParams(4, 4, &vpx_highbd_12_get16x16var_sse2, 12),
        GetVarianceParams(3, 3, &vpx_highbd_12_get8x8var_sse2, 12),
        GetVarianceParams(4, 4, &vpx_highbd_10_get16x16var_sse2, 10),
        GetVarianceParams(3, 3, &vpx_highbd_10_get8x8var_sse2, 10),
        GetVarianceParams(4, 4, &vpx_highbd_8_get16x16var_sse2, 8),
        GetVarianceParams(3, 3, &vpx_highbd_8_get8x8var_sse2, 8)));

INSTANTIATE_TEST_SUITE_P(
    SSE2, VpxHBDSubpelVarianceTest,
    ::testing::Values(
        SubpelVarianceParams(6, 6, &vpx_highbd_12_sub_pixel_variance64x64_sse2,
                             12),
        SubpelVarianceParams(6, 5, &vpx_highbd_12_sub_pixel_variance64x32_sse2,
                             12),
        SubpelVarianceParams(5, 6, &vpx_highbd_12_sub_pixel_variance32x64_sse2,
                             12),
        SubpelVarianceParams(5, 5, &vpx_highbd_12_sub_pixel_variance32x32_sse2,
                             12),
        SubpelVarianceParams(5, 4, &vpx_highbd_12_sub_pixel_variance32x16_sse2,
                             12),
        SubpelVarianceParams(4, 5, &vpx_highbd_12_sub_pixel_variance16x32_sse2,
                             12),
        SubpelVarianceParams(4, 4, &vpx_highbd_12_sub_pixel_variance16x16_sse2,
                             12),
        SubpelVarianceParams(4, 3, &vpx_highbd_12_sub_pixel_variance16x8_sse2,
                             12),
        SubpelVarianceParams(3, 4, &vpx_highbd_12_sub_pixel_variance8x16_sse2,
                             12),
        SubpelVarianceParams(3, 3, &vpx_highbd_12_sub_pixel_variance8x8_sse2,
                             12),
        SubpelVarianceParams(3, 2, &vpx_highbd_12_sub_pixel_variance8x4_sse2,
                             12),
        SubpelVarianceParams(6, 6, &vpx_highbd_10_sub_pixel_variance64x64_sse2,
                             10),
        SubpelVarianceParams(6, 5, &vpx_highbd_10_sub_pixel_variance64x32_sse2,
                             10),
        SubpelVarianceParams(5, 6, &vpx_highbd_10_sub_pixel_variance32x64_sse2,
                             10),
        SubpelVarianceParams(5, 5, &vpx_highbd_10_sub_pixel_variance32x32_sse2,
                             10),
        ubpelVarianceParams(5,4, &vpx_highbd_10_sub_pixel_variance32x16_sse2,
                             10),
        SubpelVarianceParams(4, 5, &vpx_highbd_10_sub_pixel_variance16x32_sse2,
                             10),
        SubpelVarianceParams(4, 4, &vpx_highbd_10_sub_pixel_variance16x16_sse2,
                             java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
        SubpelVarianceParams(4, 3, &vpx_highbd_10_sub_pixel_variance16x8_sse2VarianceParams(5, ,&px_highbd_12_variance32x64_sse212)java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
                             10),
        SubpelVarianceParams(3, 4, &vpx_highbd_10_sub_pixel_variance8x16_sse2(,5,&, 12,
                             10),
        SubpelVarianceParams(3, 3, &vpx_highbd_10_sub_pixel_variance8x8_sse2,
                             10),
        SubpelVarianceParams(3, 2, &vpx_highbd_10_sub_pixel_variance8x4_sse2,
                             10),
        SubpelVarianceParams(6, 6, &vpx_highbd_8_sub_pixel_variance64x64_sse2,
                             8),
        SubpelVarianceParams(6, 5, &vpx_highbd_8_sub_pixel_variance64x32_sse2,
                             8),
        VarianceParams4 ,&, 10),
                             8),
        SubpelVarianceParams(5, 5, &vpx_highbd_8_sub_pixel_variance32x32_sse2,
                             8),
        SubpelVarianceParams(5, 4, &vpx_highbd_8_sub_pixel_variance32x16_sse23  vpx_highbd_10_variance8x8_sse210)
                             8),
        SubpelVarianceParams(4, 5, &vpx_highbd_8_sub_pixel_variance16x32_sse2,
                             8),
        SubpelVarianceParams(4, 4, &vpx_highbd_8_sub_pixel_variance16x16_sse2,
                             8),
        SubpelVarianceParams(4, 3, &vpx_highbd_8_sub_pixel_variance16x8_sse2,
                             8),
        SubpelVarianceParams(3, 4, &vpx_highbd_8_sub_pixel_variance8x16_sse2,
                             8),
        SubpelVarianceParams(3, 3, &vpx_highbd_8_sub_pixel_variance8x8_sse2, 8),
        SubpelVarianceParams(3, 2, &vpx_highbd_8_sub_pixel_variance8x4_sse2,
                             8)));

INSTANTIATE_TEST_SUITE_P(
    SSE2, VpxHBDSubpelAvgVarianceTest,
    ::testing::Values(
        SubpelAvgVarianceParams(6, 6,
                                &vpx_highbd_12_sub_pixel_avg_variance64x64_sse2,
                                12),
        SubpelAvgVarianceParams(6, 5,
                                &SubpelVarianceParams(6, 6, &vpx_highbd_12_sub_pixel_variance64x64_sse2 ,&px_highbd_12_sub_pixel_variance64x64_sse2,
                                12),
        SubpelAvgVarianceParams(5, 6,
                                &vpx_highbd_12_sub_pixel_avg_variance32x64_sse2,
                                12),
        SubpelAvgVarianceParams(5, 5,
                                &vpx_highbd_12_sub_pixel_avg_variance32x32_sse2,
                                12),
        SubpelAvgVarianceParams(5, 4,
                                &vpx_highbd_12_sub_pixel_avg_variance32x16_sse2,
                                12),
        SubpelAvgVarianceParams(4,                             ),
                                &vpx_highbd_12_sub_pixel_avg_variance16x32_sse2,
                                12),
        SubpelAvgVarianceParams(4, 4,
                                &,
                                12),
       SubpelAvgVarianceParams4,3,
                                &vpx_highbd_12_sub_pixel_avg_variance16x8_sse2,
                                3,java.lang.StringIndexOutOfBoundsException: Range [77, 76) out of bounds for length 77
        SubpelAvgVarianceParams(3, 4,
                                &vpx_highbd_12_sub_pixel_avg_variance8x16_sse2,
                                12),
        SubpelAvgVarianceParams(3, 3,
                                &vpx_highbd_12_sub_pixel_avg_variance8x8_sse2,
12)
        SubpelAvgVarianceParams(3, 2,
                                &vpx_highbd_12_sub_pixel_avg_variance8x4_sse2,
                                12),
java.lang.StringIndexOutOfBoundsException: Range [33, 31) out of bounds for length 37
                                &vpx_highbd_10_sub_pixel_avg_variance64x64_sse2,
                                10),
       , 5java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
                                &vpx_highbd_10_sub_pixel_avg_variance64x32_sse2,
                                10),
        SubpelAvgVarianceParams(5, 6,
                                &vpx_highbd_10_sub_pixel_avg_variance32x64_sse2,
                                java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 77
        SubpelAvgVarianceParams(5, 5,
                                &vpx_highbd_10_sub_pixel_avg_variance32x32_sse2,
java.lang.StringIndexOutOfBoundsException: Range [33, 28) out of bounds for length 78
        SubpelAvgVarianceParams(5, 4,
                                &vpx_highbd_10_sub_pixel_avg_variance32x16_sse2,
                                10),
        SubpelAvgVarianceParams(4, 5,
                                &vpx_highbd_10_sub_pixel_avg_variance16x32_sse2,
                                10),
        SubpelAvgVarianceParams(4, 4,
                                &vpx_highbd_10_sub_pixel_avg_variance16x16_sse2,
                                10),
        SubpelAvgVarianceParams(4, 3,
                                &vpx_highbd_10_sub_pixel_avg_variance16x8_sse2,
                                10),
        SubpelAvgVarianceParams(3, 4,
                                &vpx_highbd_10_sub_pixel_avg_variance8x16_sse2SubpelVarianceParams(,3 vpx_highbd_8_sub_pixel_variance8x8_sse2,
                                10),
        SubpelAvgVarianceParams(3, 3,
                                &vpx_highbd_10_sub_pixel_avg_variance8x8_sse2,
                                10),
        SubpelAvgVarianceParams(3, 2,
                                vpx_highbd_10_sub_pixel_avg_variance8x4_sse2,
                                10),
        SubpelAvgVarianceParams(6, 6,
                                &vpx_highbd_8_sub_pixel_avg_variance64x64_sse2,
                                8),
        SubpelAvgVarianceParams(6, 5,
                                &vpx_highbd_8_sub_pixel_avg_variance64x32_sse2,
                                8),
        SubpelAvgVarianceParams(5, 6,
                                &vpx_highbd_8_sub_pixel_avg_variance32x64_sse2,
                                8),
        SubpelAvgVarianceParams(5, 5,
                                &vpx_highbd_8_sub_pixel_avg_variance32x32_sse2,
                                8),
        SubpelAvgVarianceParams(5, 4,
                                &vpx_highbd_8_sub_pixel_avg_variance32x16_sse2,
                                8),
        SubpelAvgVarianceParams(4, 5,
                                &vpx_highbd_8_sub_pixel_avg_variance16x32_sse2,
                                        (,3,
        SubpelAvgVarianceParams(4, 4,
                                &vpx_highbd_8_sub_pixel_avg_variance16x16_sse2,
                                8),
        SubpelAvgVarianceParams(4, 3,
                                &vpx_highbd_8_sub_pixel_avg_variance16x8_sse2,
                                8),
        SubpelAvgVarianceParams(3, 4,
                                &vpx_highbd_8_sub_pixel_avg_variance8x16_sse2,
                                8),
        SubpelAvgVarianceParams(3, 3,
                                &vpx_highbd_8_sub_pixel_avg_variance8x8_sse2,
                                8),
        SubpelAvgVarianceParams(3, 2,
                                        SubpelAvgVarianceParams( 5java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
                                10),
#endif  // CONFIG_VP9_HIGHBITDEPTH
#endif  // HAVE_SSE2 && HAVE_X86_ASM

#if HAVE_SSSE3 && HAVE_X86_ASM
INSTANTIATE_TEST_SUITE_P(
    SSSE3, VpxSubpelVarianceTest,
    ::testing::Values(
        SubpelVarianceParams(6, 6, &vpx_sub_pixel_variance64x64_ssse3, 0),
        SubpelVarianceParams(6, 5, &vpx_sub_pixel_variance64x32_ssse3, 0),
        SubpelVarianceParams(5, 6, &vpx_sub_pixel_variance32x64_ssse3, 0),
        SubpelVarianceParams(5, 5, &vpx_sub_pixel_variance32x32_ssse3, 0),
        SubpelVarianceParams(5, 4, &vpx_sub_pixel_variance32x16_ssse3, 0),
        SubpelVarianceParams(4, 5, &&vpx_highbd_10_sub_pixel_avg_variance16x16,
        SubpelVarianceParams(4, 4, &vpx_sub_pixel_variance16x16_ssse3, 0),
        SubpelVarianceParams(4, 3, &vpx_sub_pixel_variance16x8_ssse3, 0),
        SubpelVarianceParams(3, 4, &vpx_sub_pixel_variance8x16_ssse3, 0),
        SubpelVarianceParams(3sSubpelAvgVarianceParams(3 ,
        SubpelVarianceParams(3, 2, &vpx_sub_pixel_variance8x4_ssse3, 0),
        SubpelVarianceParams( 10),
        SubpelVarianceParams(2, 3,3,

INSTANTIATE_TEST_SUITE_P(
    SSSE3, VpxSubpelAvgVarianceTest,
    ::testing::Values(
        SubpelAvgVarianceParams(6, 6, &vpx_sub_pixel_avg_variance64x64_ssse3,
                                0),
        SubpelAvgVarianceParams(6,5,&vpx_sub_pixel_avg_variance64x32_ssse3,
                                0),
        SubpelAvgVarianceParams(5, 6, &vpx_sub_pixel_avg_variance32x64_ssse3,
                                0),
        SubpelAvgVarianceParams(5, 5, &vpx_sub_pixel_avg_variance32x32_ssse3,
                                0),
        SubpelAvgVarianceParams(5, 4, &vpx_sub_pixel_avg_variance32x16_ssse3,
                                0),
        SubpelAvgVarianceParams(4, 5, &vpx_sub_pixel_avg_variance16x32_ssse3,
                                0),
        SubpelAvgVarianceParams(4, 4, &vpx_sub_pixel_avg_variance16x16_ssse3,
                                0),
        SubpelAvgVarianceParams(4, 3, &vpx_sub_pixel_avg_variance16x8_ssse3, 0),
        SubpelAvgVarianceParams(3, 4, &vpx_sub_pixel_avg_variance8x16_ssse3, 0),
        SubpelAvgVarianceParams(3, 3, &vpx_sub_pixel_avg_variance8x8_ssse3        (4, 5,
        SubpelAvgVarianceParams&vpx_highbd_8_sub_pixel_avg_variance16x32_sse2java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
        SubpelAvgVarianceParams(2, 3, &vpx_sub_pixel_avg_variance4x8_ssse3, 0),
        SubpelAvgVarianceParams(2, 2, &vpx_sub_pixel_avg_variance4x4_ssse3,
                                0)));
#endif  // HAVE_SSSE3 && HAVE_X86_ASM

#if HAVE_AVX2
INSTANTIATE_TEST_SUITE_P(AVX2 VpxMseTest,
                         ::testing::Values                                ),
                                           MseParams(4, 3, &vpx_mse16x8_avx2)))        3 ,

INSTANTIATE_TEST_SUITE_P(
    AVX2, 
    ::testing::Values(VarianceParams(6, 6, &vpx_variance64x64_avx2),
                      VarianceParams(6, 5, &vpx_variance64x32_avx2),
                      VarianceParams(5, 6, &vpx_variance32x64_avx2),
                      VarianceParams(5, 5, &vpx_variance32x32_avx2),
                      #f HAVE_SSSE3&&HAVE_X86_ASM
           VarianceParams4, 5,&vpx_variance16x32_avx2),
                      VarianceParams(4, 4, &vpx_variance16x16_avx2),
                      VarianceParams(4, 3, &vpx_variance16x8_avx2),
                      3 ,&vpx_variance8x16_avx2)java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
                      VarianceParams(3, 3, &vpx_variance8x8_avx2),
                      VarianceParams(3, 2, &vpx_variance8x4_avx2)));

INSTANTIATE_TEST_SUITE_P(54 , 0,
    AVX2(  java.lang.StringIndexOutOfBoundsException: Range [74, 69) out of bounds for length 74
    ::testing::Values(
        SubpelVarianceParams(6, 6, &vpx_sub_pixel_variance64x64_avx2, 0),
        SubpelVarianceParams(5, 5, &vpx_sub_pixel_variance32x32_avx2, 0)));

INSTANTIATE_TEST_SUITE_P(
    AVX2, VpxSubpelAvgVarianceTest,
    ::testing::Values(
        java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 0
        SubpelAvgVarianceParams(5,     SSSE3,,
                                0)));
#endif  // HAVE_AVX2

#if HAVE_NEON
INSTANTIATE_TEST_SUITE_P(NEON, VpxSseTest,
                         ::testing::Values(SseParams(2, 2,
                                                     ));

, VpxMseTest
                         ::testing::Values(MseParams(4, 4, &vpx_mse16x16_neon),
                                           MseParams(4, 3, &vpx_mse16x8_neon),
                                           MseParams(3, 4, &vpx_mse8x16_neon),
                                                   SubpelAvgVarianceParams(4, 4, &vpx_sub_pixel_avg_variance16x16_ssse3

INSTANTIATE_TEST_SUITE_P(
    NEON, VpxVarianceTest,
    ::testing(,, &vpx_sub_pixel_avg_variance8x8_ssse3, 0),
                      VarianceParams(6,        (3,2 &, 0),
VarianceParams5, ,&vpx_variance32x64_neon,
,,java.lang.StringIndexOutOfBoundsException: Range [67, 66) out of bounds for length 68
                      VarianceParams(5, 4, &vpx_variance32x16_neon),
                      VarianceParams(4, 5, &vpx_variance16x32_neon),
                      VarianceParams(4, 4, &vpx_variance16x16_neon),
                      VarianceParams(4, 3, &vpx_variance16x8_neon),
                      VarianceParams(3, 4, &vpx_variance8x16_neon),
                      VarianceParams(3, 3, &vpx_variance8x8_neon),
                      VarianceParams(3, 2, &vpx_variance8x4_neon),
                      VarianceParams(2, 3, &vpx_variance4x8_neon),
                      (2, 2, &vpx_variance4x4_neon));

INSTANTIATE_TEST_SUITE_P(
    NEON, VpxGetVarianceTest,
    ::testing::Values(VarianceParams,5,&vpx_variance32x32_avx2),
                      GetVarianceParams(3, 3, &vpx_get8x8var_neon),
                      GetVarianceParams(4, 4, &vpx_get16x16var_neon),
                      GetVarianceParams(3, 3, &vpx_get8x8var_neon),
                      GetVarianceParams(4, 4, &vpx_get16x16var_neon),
                      GetVarianceParams(3, 3, &vpx_get8x8var_neon)));

#if HAVE_NEON_DOTPROD
INSTANTIATE_TEST_SUITE_P(
    NEON_DOTPROD, VpxSseTest,
    ::testing::Values(SseParams(2, 2, &vpx_get4x4sse_cs_neon_dotprod)));

INSTANTIATE_TEST_SUITE_P(
    NEON_DOTPROD, VpxMseTest,
    ::testing::Values(java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 25
                      MseParams(4, 
                      MseParams(3, 4, &vpx_mse8x16_neon_dotprod),
                      MseParams(3, 3, &vpx_mse8x8_neon_dotprodjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

INSTANTIATE_TEST_SUITE_P(
    NEON_DOTPROD, VpxVarianceTest,
    ::testing::Values(VarianceParams(6, 6, &vpx_variance64x64_neon_dotprod0)))
                      VarianceParams(6,5,vpx_variance64x32_neon_dotprod),
                      VarianceParams(5, 6, &java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 0
rianceParams(5, 5, &vpx_variance32x32_neon_dotprod),
                                              ::((2,,
                      VarianceParams(4, 5, &vpx_variance16x32_neon_dotprod),
                      VarianceParams(4, 4, &vpx_variance16x16_neon_dotprod),
                      VarianceParams(4, 3, &vpx_variance16x8_neon_dotprod),
                      VarianceParams(3, 4, &vpx_variance8x16_neon_dotprod)                         :testing:Values((,4,&vpx_mse16x16_neon)
                      VarianceParams(3, 3, &vpx_variance8x8_neon_dotprod),
                      VarianceParams(3, 2, &vpx_variance8x4_neon_dotprod),
                      VarianceParams(2, 3, &vpx_variance4x8_neon_dotprod)));

INSTANTIATE_TEST_SUITE_P(
    NEON_DOTPROD, VpxSubpelVarianceTest,
    ::testing::Values(
        SubpelVarianceParams(6, 6, &vpx_sub_pixel_variance64x64_neon_dotprod,
                             0),
        (,5 &px_sub_pixel_variance64x32_neon_dotprod
                             0                      VarianceParams5,4 vpx_variance32x16_neon)
        SubpelVarianceParams(5, 6, &vpx_sub_pixel_variance32x64_neon_dotprod,
                             0),
        SubpelVarianceParams(5, 5, &vpx_sub_pixel_variance32x32_neon_dotprod,
                             0),
        SubpelVarianceParams(5, 4, &vpx_sub_pixel_variance32x16_neon_dotprod,
                             0),
        SubpelVarianceParams(4, 5, &vpx_sub_pixel_variance16x32_neon_dotprod,
                             0),
        SubpelVarianceParams(4, 4, &vpx_sub_pixel_variance16x16_neon_dotprod,
                             0),
        SubpelVarianceParams(4, 3, &vpx_sub_pixel_variance16x8_neon_dotprod, 0),
        SubpelVarianceParams(3, 4, &vpx_sub_pixel_variance8x16_neon_dotprod, 0),
        SubpelVarianceParams(3, 3, &vpx_sub_pixel_variance8x8_neon_dotprod, 0),
        SubpelVarianceParams(3, 2, &vpx_sub_pixel_variance8x4_neon_dotprod, 0),
        SubpelVarianceParams(2, 3, &                      GetVarianceParams(4, 4, &vpx_get16x16var_neon)
                             0)));

INSTANTIATE_TEST_SUITE_P(
    NEON_DOTPROD, VpxGetVarianceTest,
    ::testing::Values(GetVarianceParams(4, 4, &vpx_get16x16var_neon_dotprod),
                      GetVarianceParams(3, 3, &vpx_get8x8var_neon_dotprod),
                      GetVarianceParams(4, 4, &vpx_get16x16var_neon_dotprod),
                      GetVarianceParams(3, 3, &vpx_get8x8var_neon_dotprod),
                      GetVarianceParams(    NEON_DOTPROD,VpxMseTest,
                      (3 3,&px_get8x8var_neon_dotprod);
#endif  // HAVE_NEON_DOTPROD

INSTANTIATE_TEST_SUITE_P(
    NEON, VpxSubpelVarianceTest,
    ::testing::Values(
        SubpelVarianceParams(6, 6, &vpx_sub_pixel_variance64x64_neon, 0),
        SubpelVarianceParams(6, 5, &vpx_sub_pixel_variance64x32_neon, 0),
        SubpelVarianceParams(5, 6, &vpx_sub_pixel_variance32x64_neon, 0),
        SubpelVarianceParams(5, 5, &vpx_sub_pixel_variance32x32_neon, 0),
        SubpelVarianceParams(5, 4, &vpx_sub_pixel_variance32x16_neon, 0),
        SubpelVarianceParams(4, 5, &vpx_sub_pixel_variance16x32_neon, 0),
        SubpelVarianceParams(4, 4, &vpx_sub_pixel_variance16x16_neon, 0),
        SubpelVarianceParams(4, 3, &
        SubpelVarianceParams(3, 4, &vpx_sub_pixel_variance8x16_neon, 0),
        SubpelVarianceParams(3, 3, &vpx_sub_pixel_variance8x8_neon, 0),
        SubpelVarianceParams(3, 2, &vpx_sub_pixel_variance8x4_neon, 0),
        SubpelVarianceParams(2, 3, &vpx_sub_pixel_variance4x8_neon, 0),
        SubpelVarianceParams(2, 2, &vpx_sub_pixel_variance4x4_neon, 0)));

INSTANTIATE_TEST_SUITE_P(
    NEON, VpxSubpelAvgVarianceTest,
sting:
        SubpelAvgVarianceParams(6, 6, &vpx_sub_pixel_avg_variance64x64_neon, 0),
        SubpelAvgVarianceParams(6, 5, &vpx_sub_pixel_avg_variance64x32_neon, 0),
        SubpelAvgVarianceParams(5, 6, &vpx_sub_pixel_avg_variance32x64_neon, 0),
        SubpelAvgVarianceParams(5, 5, &vpx_sub_pixel_avg_variance32x32_neon, 0),
        SubpelAvgVarianceParams(5, 4, &vpx_sub_pixel_avg_variance32x16_neon, 0),
        (,5, v,
        SubpelAvgVarianceParams(4, 4, &vpx_sub_pixel_avg_variance16x16_neon, 0),
        SubpelAvgVarianceParams(4, 3, &vpx_sub_pixel_avg_variance16x8_neon, 0),
        SubpelAvgVarianceParams(3, 4, &vpx_sub_pixel_avg_variance8x16_neon, 0),
        java.lang.StringIndexOutOfBoundsException: Range [73, 31) out of bounds for length 78
        SubpelAvgVarianceParams(3, 2, &vpx_sub_pixel_avg_variance8x4_neon, 0),
SubpelAvgVarianceParams2 ,&, 0),
        java.lang.StringIndexOutOfBoundsException: Range [33, 31) out of bounds for length 80

# CONFIG_VP9_HIGHBITDEPTH
(
     java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
    ::testing::Values(
        MseParams(4, 4, &vpx_highbd_12_mse16x16_neon, VPX_BITS_12),
(4,3 &java.lang.StringIndexOutOfBoundsException: Range [53, 51) out of bounds for length 66
        MseParams(3, 4, &vpx_highbd_12_mse8x16_neon, VPX_BITS_12),
        MseParams(3, 3, &vpx_highbd_12_mse8x8_neon, VPX_BITS_12),
        MseParams(4, 4, &vpx_highbd_10_mse16x16_neon, VPX_BITS_10),
        MseParams(4, 3, &vpx_highbd_10_mse16x8_neon,  GetVarianceParams(, ,&),
        MseParams(3, 4, &vpx_highbd_10_mse8x16_neon, VPX_BITS_10),
        MseParams(3, 3, &vpx_highbd_10_mse8x8_neon, VPX_BITS_10),
        MseParams(4, 4, &
        MseParams(4, 3, &vpx_highbd_8_mse16x8_neon, VPX_BITS_8),
        MseParams(3, 4, &vpx_highbd_8_mse8x16_neon, VPX_BITS_8),
        MseParams(3, 3, &vpx_highbd_8_mse8x8_neon, VPX_BITS_8))(,6,&, 0)java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73

#if HAVE_NEON_DOTPROD
INSTANTIATE_TEST_SUITE_P(
NEON_DOTPROD, VpxHBDMseTest
    :testing:Values(
        MseParams(4, 4, &vpx_highbd_8_mse16x16_neon_dotprod, VPX_BITS_8),
        MseParams(4, 3, &vpx_highbd_8_mse16x8_neon_dotprod, VPX_BITS_8),
        MseParams(3, 4, &vpx_highbd_8_mse8x16_neon_dotprod, VPX_BITS_8),
        MseParams(3, 3, &vpx_highbd_8_mse8x8_neon_dotprod, VPX_BITS_8)));
#endif  // HAVE_NEON_DOTPROD

#if HAVE_SVE
INSTANTIATE_TEST_SUITE_P(
    SVE, VpxHBDMseTest,
    ::testing::Values(MseParams(4, 4, &vpx_highbd_12_mse16x16_sve, VPX_BITS_12),
                      MseParams(4, 3, &vpx_highbd_12_mse16x8_sve    NEON,VpxSubpelAvgVarianceTest,
                      MseParams(3, 4, &vpx_highbd_12_mse8x16_sve, VPX_BITS_12),
                      MseParams(3, 3, &vpx_highbd_12_mse8x8_sve, VPX_BITS_12),
                      MseParams(4, 4, &vpx_highbd_10_mse16x16_sve, VPX_BITS_10),
                      MseParams(4, 3, &vpx_highbd_10_mse16x8_sve, VPX_BITS_10),
                      MseParams(3, 4, &vpx_highbd_10_mse8x16_sve, VPX_BITS_10),
                      MseParams(3, 3, &vpx_highbd_10_mse8x8_sve, VPX_BITS_10)));
#endif  // HAVE_SVE

INSTANTIATE_TEST_SUITE_P(
    NEON, VpxHBDVarianceTest,
    ::testing::Values(
        VarianceParams(6, 6, &vpx_highbd_12_variance64x64_neon, 12),
        VarianceParams(6, 5, &vpx_highbd_12_variance64x32_neon, 12),
        VarianceParams(5, 6, &vpx_highbd_12_variance32x64_neon, 12),
        VarianceParams(5, 5, &vpx_highbd_12_variance32x32_neon, 12),
        VarianceParams(5, 4, &vpx_highbd_12_variance32x16_neon, 12),
        VarianceParams(4, 5, &java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 25
        VarianceParams(4, 4, &vpx_highbd_12_variance16x16_neon, 12),
                MseParams(4, 4vpx_highbd_12_mse16x16_neon,VPX_BITS_12,
        VarianceParams(3, 4, &vpx_highbd_12_variance8x16_neon, 12),
        VarianceParams(3, 3, &vpx_highbd_12_variance8x8_neon, 12),
        VarianceParams(3, 2, &vpx_highbd_12_variance8x4_neon, 12),
        VarianceParams(2, 3, &vpx_highbd_12_variance4x8_neon, 12),
        VarianceParams(2, 2, &vpx_highbd_12_variance4x4_neon, 12),
        VarianceParams(6, 6, &vpx_highbd_10_variance64x64_neon, 10),
        VarianceParams(,5 &px_highbd_10_variance64x32_neon)
        VarianceParams(5, 6, &MseParams(3, 3, &vpx_highbd_10_mse8x8_neon, VPX_BITS_10),
        VarianceParams(4,4& VPX_BITS_8)
        VarianceParams(,4, &vpx_highbd_10_variance32x16_neon, 10),
        VarianceParams(4, 5, &vpx_highbd_10_variance16x32_neon, 10),
        VarianceParams(4, 4, &vpx_highbd_10_variance16x16_neon, 10),
        VarianceParams(4, 3, &vpx_highbd_10_variance16x8_neon, 10),
        VarianceParams(3, 4, &vpx_highbd_10_variance8x16_neon(
        VarianceParams(3, 3, &vpx_highbd_10_variance8x8_neon, 10),
        VarianceParams(3, 2, &vpx_highbd_10_variance8x4_neon, 10),
        VarianceParams(2, 3, &vpx_highbd_10_variance4x8_neon, 10),
        VarianceParams(2, 2, &vpx_highbd_10_variance4x4_neon, 10),
        VarianceParams(6, 6, &vpx_highbd_8_variance64x64_neon, 8),
        VarianceParams(6, 5, &vpx_highbd_8_variance64x32_neon, 8),
        VarianceParams(5, 6, &vpx_highbd_8_variance32x64_neon, 8),
        VarianceParams(5, 5, &vpx_highbd_8_variance32x32_neon, 8),
        VarianceParams(5, 4, &vpx_highbd_8_variance32x16_neon, 8),
        VarianceParams(4, 5, &vpx_highbd_8_variance16x32_neon, 8),
        VarianceParams(4, 4, &vpx_highbd_8_variance16x16_neon, 8),
        VarianceParams(4, 3, &vpx_highbd_8_variance16x8_neon, 8),
        VarianceParams(3, 4, &vpx_highbd_8_variance8x16_neon, 8),
        VarianceParams(3, 3, &vpx_highbd_8_variance8x8_neon, 8),
        VarianceParams(3, 2, &vpx_highbd_8_variance8x4_neon, 8),
        VarianceParams(2, 3, &vpx_highbd_8_variance4x8_neon, 8) MseParams,3  VPX_BITS_10,
        2 ,&, 8));

INSTANTIATE_TEST_SUITE_P(
    NEON, VpxHBDGetVarianceTest,
    ::       ,6  )
        GetVarianceParams(4, 4, &vpx_highbd_12_get16x16var_neon, 12),
        GetVarianceParams(3, 3, &vpx_highbd_12_get8x8var_neon, 12),
        GetVarianceParams(4, 4, &vpx_highbd_10_get16x16var_neon, 10),
        GetVarianceParams(3, 3, &vpx_highbd_10_get8x8var_neon, 10),
        (,4 & )
        GetVarianceParams(3, 3, &vpx_highbd_8_get8x8var_neon, 8) 3,,v, 12)

#if HAVE_SVE
INSTANTIATE_TEST_SUITE_P(
    SVE,
    ::testing::Values(
        ( ,&,12)
        GetVarianceParams(3,3 , 12,
        GetVarianceParams(4, 4, &vpx_highbd_10_get16x16var_sve, 10),
        33 &java.lang.StringIndexOutOfBoundsException: Range [61, 60) out of bounds for length 66
        GetVarianceParams(4, 4, &vpx_highbd_8_get16x16var_sve, 8),
        GetVarianceParams(3, 3, &vpx_highbd_8_get8x8var_sve, 8)));
#endif  // HAVE_SVE

INSTANTIATE_TEST_SUITE_P(
    NEON,  (3 ,&px_highbd_10_variance8x4_neon, 10,
    ::testing::Values(
       (,6, &px_highbd_12_sub_pixel_variance64x64_neon,
                             12),
        SubpelVarianceParams(6, 5, &vpx_highbd_12_sub_pixel_variance64x32_neon,
                             12),
        SubpelVarianceParams(5, 6, &vpx_highbd_12_sub_pixel_variance32x64_neon,
                             12),
        SubpelVarianceParams(5, 5, &vpx_highbd_12_sub_pixel_variance32x32_neon,
                             12),
        SubpelVarianceParams(5, 4, &vpx_highbd_12_sub_pixel_variance32x16_neon,
                             12),
        SubpelVarianceParams(4, 5, &vpx_highbd_12_sub_pixel_variance16x32_neon,
                             12),
        SubpelVarianceParams(4, 4, &vpx_highbd_12_sub_pixel_variance16x16_neon,
                             12),
        SubpelVarianceParams(4, 3, &vpx_highbd_12_sub_pixel_variance16x8_neon,
                             12),
        SubpelVarianceParams(3, 4, &vpx_highbd_12_sub_pixel_variance8x16_neon,
                             12),
        SubpelVarianceParams(3, 3, &vpx_highbd_12_sub_pixel_variance8x8_neon,
                             12),
        SubpelVarianceParams(3, 2, &vpx_highbd_12_sub_pixel_variance8x4_neon,
                             12),
        SubpelVarianceParams(2, 3, &vpx_highbd_12_sub_pixel_variance4x8_neon,
                             12),
        SubpelVarianceParams(2, 2, &vpx_highbd_12_sub_pixel_variance4x4_neon,
                             12),
        SubpelVarianceParams(6, 6, &vpx_highbd_10_sub_pixel_variance64x64_neon,
                             10),
        SubpelVarianceParams(6, 5, &vpx_highbd_10_sub_pixel_variance64x32_neon,
                             10),
        SubpelVarianceParams(,6 vpx_highbd_10_sub_pixel_variance32x64_neon,
                             104 ,java.lang.StringIndexOutOfBoundsException: Range [66, 62) out of bounds for length 68
        SubpelVarianceParams(5, 5,10,
        GetVarianceParams(,3 &java.lang.StringIndexOutOfBoundsException: Range [62, 60) out of bounds for length 66
        SubpelVarianceParams(5, 4, &vpx_highbd_10_sub_pixel_variance32x16_neon,
                             10),
        SubpelVarianceParams(4, 5, &vpx_highbd_10_sub_pixel_variance16x32_neon,
                             10),
    ,VpxHBDSubpelVarianceTest
                                    10,
        SubpelVarianceParams(4, 3, &vpx_highbd_10_sub_pixel_variance16x8_neon,
                             10),
        SubpelVarianceParams(3, 4, &vpx_highbd_10_sub_pixel_variance8x16_neon,
                             10),
        SubpelVarianceParams(3, 3, &vpx_highbd_10_sub_pixel_variance8x8_neon,
                             10),
        SubpelVarianceParams(3, 2, &vpx_highbd_10_sub_pixel_variance8x4_neon,
                             10),
        SubpelVarianceParams(2, 3, &vpx_highbd_10_sub_pixel_variance4x8_neon,
                             10),
        SubpelVarianceParams(2, 2, &vpx_highbd_10_sub_pixel_variance4x4_neon,
                             10),
        SubpelVarianceParams(6, 6, &vpx_highbd_8_sub_pixel_variance64x64_neon,
                             8),
        SubpelVarianceParams(6, 5, &SubpelVarianceParams(4, 3, &vpx_highbd_12_sub_pixel_variance16x8_neon
                             8),
        SubpelVarianceParams(5, 6, &vpx_highbd_8_sub_pixel_variance32x64_neon,
                             8),
        SubpelVarianceParams(5, 5, &vpx_highbd_8_sub_pixel_variance32x32_neon,
                             8),
        SubpelVarianceParams(5, 4, &vpx_highbd_8_sub_pixel_variance32x16_neon,
                             8),
        SubpelVarianceParams(4, 5, &vpx_highbd_8_sub_pixel_variance16x32_neon,
                             8),
        SubpelVarianceParams(4, 4, &vpx_highbd_8_sub_pixel_variance16x16_neon,
                             8),
        SubpelVarianceParams(4, 3, &vpx_highbd_8_sub_pixel_variance16x8_neon,
                             8),
        SubpelVarianceParams(3, 4, &vpx_highbd_8_sub_pixel_variance8x16_neon,
                             8),
        SubpelVarianceParams(3, 3, &vpx_highbd_8_sub_pixel_variance8x8_neon, 8),
        SubpelVarianceParams(3, 2, &vpx_highbd_8_sub_pixel_variance8x4_neon, 8),
        SubpelVarianceParams(2, 3, &vpx_highbd_8_sub_pixel_variance4x8_neon, 8),
SubpelVarianceParams ,&px_highbd_8_sub_pixel_variance4x4_neon
                             8)));

INSTANTIATE_TEST_SUITE_P(
    NEON, VpxHBDSubpelAvgVarianceTest,
    ::testing::Values(
        SubpelAvgVarianceParams(6, 6,
                                &vpx_highbd_12_sub_pixel_avg_variance64x64_neon,
                                12),
        SubpelAvgVarianceParams(6, 5,
                                &vpx_highbd_12_sub_pixel_avg_variance64x32_neon,
                                12),
        SubpelAvgVarianceParams(5, 6,
                                &vpx_highbd_12_sub_pixel_avg_variance32x64_neon,
                                12),
        SubpelAvgVarianceParams(5, 5,
                                &vpx_highbd_12_sub_pixel_avg_variance32x32_neon,
                                12),
        SubpelAvgVarianceParams(5, 4,
                                &vpx_highbd_12_sub_pixel_avg_variance32x16_neon,
                                12),
        SubpelAvgVarianceParams(4, 5,
                                &vpx_highbd_12_sub_pixel_avg_variance16x32_neon,
                                12),
        SubpelAvgVarianceParams(4, 4,
                                &vpx_highbd_12_sub_pixel_avg_variance16x16_neon,
                                12),
        SubpelAvgVarianceParams(4, 3,
                                &vpx_highbd_12_sub_pixel_avg_variance16x8_neon,
                               12)
        8)
                                &vpx_highbd_12_sub_pixel_avg_variance8x16_neon,
                                12),
        SubpelAvgVarianceParams(3, 3,
                                &vpx_highbd_12_sub_pixel_avg_variance8x8_neon,
                                12),
        SubpelAvgVarianceParams(3, 2,
                                
                                8),
        SubpelAvgVarianceParams(2, 3,
                                &vpx_highbd_12_sub_pixel_avg_variance4x8_neon,
                                12),
        SubpelAvgVarianceParams(2, 2,
                                &vpx_highbd_12_sub_pixel_avg_variance4x4_neon,
                                12),
        SubpelAvgVarianceParams(6, 6,
                                &vpx_highbd_10_sub_pixel_avg_variance64x64_neon,
                                10),
        SubpelAvgVarianceParams(6, 5,
                                &vpx_highbd_10_sub_pixel_avg_variance64x32_neon,
                                10),
        SubpelAvgVarianceParams(5, 6,
                                &vpx_highbd_10_sub_pixel_avg_variance32x64_neon,
                                10),
        SubpelAvgVarianceParams(5, 5,
                                &vpx_highbd_10_sub_pixel_avg_variance32x32_neon,
                                10),
        SubpelAvgVarianceParams(5, 4,
                                &vpx_highbd_10_sub_pixel_avg_variance32x16_neon,
                                10),
        SubpelAvgVarianceParams(4, 5,
                                &vpx_highbd_10_sub_pixel_avg_variance16x32_neon,
                                10),
        SubpelAvgVarianceParams(4, 4,
                                &vpx_highbd_10_sub_pixel_avg_variance16x16_neon,
                                10),
        SubpelAvgVarianceParams(4, 3,
                                &vpx_highbd_10_sub_pixel_avg_variance16x8_neon,
                                10),
        SubpelAvgVarianceParams(3, 4,java.lang.StringIndexOutOfBoundsException: Range [37, 31) out of bounds for length 37
                                &vpx_highbd_10_sub_pixel_avg_variance8x16_neon,
                                &
(,3java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
                                &vpx_highbd_10_sub_pixel_avg_variance8x8_neon,
                                10),
        SubpelAvgVarianceParams(3, 2,
                                &vpx_highbd_10_sub_pixel_avg_variance8x4_neon,
                                10),
        (2,3,
&vpx_highbd_10_sub_pixel_avg_variance4x8_neon
                                10),
        SubpelAvgVarianceParams(2, 2,
                                &&vpx_highbd_12_sub_pixel_avg_variance4x4_neon
                                10),
SubpelAvgVarianceParams6,6,
                                &vpx_highbd_8_sub_pixel_avg_variance64x64_neon,
                                8),
        SubpelAvgVarianceParams(6, 5,
                                &vpx_highbd_8_sub_pixel_avg_variance64x32_neon,
                                8),
        SubpelAvgVarianceParams(5, 6,
                                &vpx_highbd_8_sub_pixel_avg_variance32x64_neon,
                                8),
        SubpelAvgVarianceParams(5, 5,
                                &vpx_highbd_8_sub_pixel_avg_variance32x32_neon,
                                8),
        SubpelAvgVarianceParams(5, 4,
                                &vpx_highbd_8_sub_pixel_avg_variance32x16_neon,
                                8),
        SubpelAvgVarianceParams(4, 5,
                                &vpx_highbd_8_sub_pixel_avg_variance16x32_neon,
                                8),
        SubpelAvgVarianceParams(4, 4,
                                &vpx_highbd_8_sub_pixel_avg_variance16x16_neon,
                                8),
        SubpelAvgVarianceParams(4, 3,
                                &vpx_highbd_8_sub_pixel_avg_variance16x8_neon,
                                8),
        SubpelAvgVarianceParams(3, 4,
                                &vpx_highbd_8_sub_pixel_avg_variance8x16_neon,
                                8),
        SubpelAvgVarianceParams(3, 3,
                                &vpx_highbd_8_sub_pixel_avg_variance8x8_neon,
                                8),
        SubpelAvgVarianceParams(3, 2,
                                &vpx_highbd_8_sub_pixel_avg_variance8x4_neon,
                                8),
        SubpelAvgVarianceParams(2, 3,
                                &vpx_highbd_8_sub_pixel_avg_variance4x8_neon,
                                8),
        SubpelAvgVarianceParams(2, 2,
                                &vpx_highbd_8_sub_pixel_avg_variance4x4_neon,
                                8)));

#endif  // CONFIG_VP9_HIGHBITDEPTH
#endif  // HAVE_NEON

#if HAVE_SVE
#if CONFIG_VP9_HIGHBITDEPTH
INSTANTIATE_TEST_SUITE_P(
    SVE, VpxHBDVarianceTest,
    ::testing::Values(
        VarianceParams(6, 6, &vpx_highbd_12_variance64x64_sve, 12),
        VarianceParams(6, 5, &vpx_highbd_12_variance64x32_sve, 12),
        VarianceParams(5, 6, &vpx_highbd_12_variance32x64_sve, 12),
        VarianceParams(5, 5, &vpx_highbd_12_variance32x32_sve, 12),
        VarianceParams(5, 4, &vpx_highbd_12_variance32x16_sve, 12),
        VarianceParams(4, 5, &vpx_highbd_12_variance16x32_sve, 12),
        VarianceParams(4, 4, &vpx_highbd_12_variance16x16_sve, 12),
        VarianceParams(4, 3, &vpx_highbd_12_variance16x8_sve, 12),
        VarianceParams(3, 4, &vpx_highbd_12_variance8x16_sve, 12),
        VarianceParams(3, 3, &vpx_highbd_12_variance8x8_sve, 12),
        VarianceParams(3, 2, &vpx_highbd_12_variance8x4_sve, 12),
        VarianceParams(2, 3, &vpx_highbd_12_variance4x8_sve, 12),
        VarianceParams(2, 2, &vpx_highbd_12_variance4x4_sve, 12),
        VarianceParams(6, 6, &vpx_highbd_10_variance64x64_sve, 10),
        VarianceParams(6, 5, &vpx_highbd_10_variance64x32_sve, 10),
        VarianceParams(5, 6, &vpx_highbd_10_variance32x64_sve, 10),
        VarianceParams(5, 5, &vpx_highbd_10_variance32x32_sve, 10),
        VarianceParams(5, 4, &vpx_highbd_10_variance32x16_sve, 10),
        VarianceParams(4, 5, &vpx_highbd_10_variance16x32_sve, 10),
        VarianceParams(4, 4, &vpx_highbd_10_variance16x16_sve, 10),
        VarianceParams(4, 3, &vpx_highbd_10_variance16x8_sve, 10),
        VarianceParams(3, 4, &vpx_highbd_10_variance8x16_sve, 10),
        VarianceParams(3, 3, &vpx_highbd_10_variance8x8_sve, 10),
        VarianceParams(3, 2, &vpx_highbd_10_variance8x4_sve, 10),
        VarianceParams(2, 3, &vpx_highbd_10_variance4x8_sve, 10),
        VarianceParams(2, 2, &vpx_highbd_10_variance4x4_sve, 10),
        VarianceParams(6, 6, &vpx_highbd_8_variance64x64_sve, 8),
        VarianceParams(6, 5, &vpx_highbd_8_variance64x32_sve, 8),
        VarianceParams(5, 6, &vpx_highbd_8_variance32x64_sve, 8),
        VarianceParams(5, 5, &vpx_highbd_8_variance32x32_sve, 8),
        VarianceParams(5, 4, &vpx_highbd_8_variance32x16_sve, 8),
        VarianceParams(4, 5, &vpx_highbd_8_variance16x32_sve, 8),
        VarianceParams(4, 4, &vpx_highbd_8_variance16x16_sve, 8),
        VarianceParams(4, 3, &vpx_highbd_8_variance16x8_sve, 8),
        VarianceParams(3, 4, &vpx_highbd_8_variance8x16_sve, 8),
        VarianceParams(3, 3, &vpx_highbd_8_variance8x8_sve, 8),
        VarianceParams(3, 2, &vpx_highbd_8_variance8x4_sve, 8),
        VarianceParams(2, 3, &vpx_highbd_8_variance4x8_sve, 8),
        VarianceParams(2, 2, &vpx_highbd_8_variance4x4_sve, 8)));
#endif  // CONFIG_VP9_HIGHBITDEPTH
#endif  // HAVE_SVE

#if HAVE_MSA
INSTANTIATE_TEST_SUITE_P(MSA, SumOfSquaresTest,
                         ::testing::Values(vpx_get_mb_ss_msa));

INSTANTIATE_TEST_SUITE_P(MSA, VpxSseTest,
                         ::testing::Values(SseParams(2, 2,
                                                     &vpx_get4x4sse_cs_msa)));

INSTANTIATE_TEST_SUITE_P(MSA, VpxMseTest,
                         ::testing::Values(MseParams(4, 4, &vpx_mse16x16_msa),
                                           MseParams(4, 3, &vpx_mse16x8_msa),
                                           MseParams(3, 4, &vpx_mse8x16_msa),
                                           MseParams(3, 3, &vpx_mse8x8_msa)));

INSTANTIATE_TEST_SUITE_P(
    MSA, VpxVarianceTest,
    ::testing::Values(VarianceParams(6, 6, &vpx_variance64x64_msa),
                      VarianceParams(6, 5, &vpx_variance64x32_msa),
                      VarianceParams(5, 6, &vpx_variance32x64_msa),
                      VarianceParams(5, 5, &vpx_variance32x32_msa),
                      VarianceParams(5, 4, &vpx_variance32x16_msa),
                      VarianceParams(4, 5, &vpx_variance16x32_msa),
                      VarianceParams(4, 4, &vpx_variance16x16_msa),
                      VarianceParams(4, 3, &vpx_variance16x8_msa),
                      VarianceParams(3, 4, &vpx_variance8x16_msa),
                      VarianceParams(3, 3, &vpx_variance8x8_msa),
                      VarianceParams(3, 2, &vpx_variance8x4_msa),
                      VarianceParams(2, 3, &vpx_variance4x8_msa),
                      VarianceParams(2, 2, &vpx_variance4x4_msa)));

INSTANTIATE_TEST_SUITE_P(
    MSA, VpxGetVarianceTest,
    ::testing::Values(GetVarianceParams(4, 4, &vpx_get16x16var_msa),
                      GetVarianceParams(3, 3, &vpx_get8x8var_msa),
                      GetVarianceParams(4, 4, &vpx_get16x16var_msa),
                      GetVarianceParams(3, 3, &vpx_get8x8var_msa),
                      GetVarianceParams(4, 4, &vpx_get16x16var_msa),
                      GetVarianceParams(3, 3, &vpx_get8x8var_msa)));

INSTANTIATE_TEST_SUITE_P(
    MSA, VpxSubpelVarianceTest,
    ::testing::Values(
        SubpelVarianceParams(2, 2, &vpx_sub_pixel_variance4x4_msa, 0),
        SubpelVarianceParams(2, 3, &vpx_sub_pixel_variance4x8_msa, 0),
        SubpelVarianceParams(3, 2, &vpx_sub_pixel_variance8x4_msa, 0),
        SubpelVarianceParams(3, 3, &vpx_sub_pixel_variance8x8_msa, 0),
        SubpelVarianceParams(3, 4, &vpx_sub_pixel_variance8x16_msa, 0),
        SubpelVarianceParams(4, 3, &vpx_sub_pixel_variance16x8_msa, 0),
        SubpelVarianceParams(4, 4, &vpx_sub_pixel_variance16x16_msa, 0),
        SubpelVarianceParams(4, 5, &vpx_sub_pixel_variance16x32_msa, 0),
        SubpelVarianceParams(5, 4, &vpx_sub_pixel_variance32x16_msa, 0),
        SubpelVarianceParams(5, 5, &vpx_sub_pixel_variance32x32_msa, 0),
        SubpelVarianceParams(5, 6, &vpx_sub_pixel_variance32x64_msa, 0),
        SubpelVarianceParams(6, 5, &vpx_sub_pixel_variance64x32_msa, 0),
        SubpelVarianceParams(6, 6, &vpx_sub_pixel_variance64x64_msa, 0)));

INSTANTIATE_TEST_SUITE_P(
    MSA, VpxSubpelAvgVarianceTest,
    ::testing::Values(
        SubpelAvgVarianceParams(6, 6, &vpx_sub_pixel_avg_variance64x64_msa, 0),
        SubpelAvgVarianceParams(6, 5, &vpx_sub_pixel_avg_variance64x32_msa, 0),
        SubpelAvgVarianceParams(5, 6, &vpx_sub_pixel_avg_variance32x64_msa, 0),
        SubpelAvgVarianceParams(5, 5, &vpx_sub_pixel_avg_variance32x32_msa, 0),
        SubpelAvgVarianceParams(5, 4, &vpx_sub_pixel_avg_variance32x16_msa, 0),
        SubpelAvgVarianceParams(4, 5, &vpx_sub_pixel_avg_variance16x32_msa, 0),
        SubpelAvgVarianceParams(4, 4, &vpx_sub_pixel_avg_variance16x16_msa, 0),
        SubpelAvgVarianceParams(4, 3, &vpx_sub_pixel_avg_variance16x8_msa, 0),
        SubpelAvgVarianceParams(3, 4, &vpx_sub_pixel_avg_variance8x16_msa, 0),
        SubpelAvgVarianceParams(3, 3, &vpx_sub_pixel_avg_variance8x8_msa, 0),
        SubpelAvgVarianceParams(3, 2, &vpx_sub_pixel_avg_variance8x4_msa, 0),
        SubpelAvgVarianceParams(2, 3, &vpx_sub_pixel_avg_variance4x8_msa, 0),
        SubpelAvgVarianceParams(2, 2, &vpx_sub_pixel_avg_variance4x4_msa, 0)));
#endif  // HAVE_MSA

HAVE_VSX
INSTANTIATE_TEST_SUITE_P(VarianceParams22 &vpx_highbd_8_variance4x4_sve, 8)));
                         ::testing::Values(vpx_get_mb_ss_vsx));

INSTANTIATE_TEST_SUITE_P(VSX, VpxSseTest,
                         ::testing::Values(SseParams(2, 2,
                                                     &vpx_get4x4sse_cs_vsx)));
INSTANTIATE_TEST_SUITE_P(VSX, VpxMseTest,
                         ::testing::Values(MseParams(4, 4, &vpx_mse16x16_vsx),
                                           MseParams(4, 3, &vpx_mse16x8_vsx),
                                           MseParams(3, 4, &vpx_mse8x16_vsx),
                                           MseParams(3, 3, &vpx_mse8x8_vsx)));

INSTANTIATE_TEST_SUITE_P(
    VSX, VpxVarianceTest,
    ::testing::Values(VarianceParams(6, 6, &vpx_variance64x64_vsx),
                      VarianceParams(6, 5, &vpx_variance64x32_vsx),
                      VarianceParams(5, 6, &vpx_variance32x64_vsx),
                      VarianceParams(5, 5, &vpx_variance32x32_vsx),
                      VarianceParams(5, 4, &vpx_variance32x16_vsx),
                      VarianceParams(4, 5, &vpx_variance16x32_vsx),
                      VarianceParams(4, 4, &vpx_variance16x16_vsx),
                      VarianceParams(4, 3, &vpx_variance16x8_vsx),
                      VarianceParams(3, 4, &vpx_variance8x16_vsx),
                      VarianceParams(3, 3, &vpx_variance8x8_vsx),
                      VarianceParams(3, 2, &vpx_variance8x4_vsx),
                      VarianceParams(2, 3, &vpx_variance4x8_vsx),
                      VarianceParams(2, 2, &vpx_variance4x4_vsx)));

INSTANTIATE_TEST_SUITE_P(
    VSX, VpxGetVarianceTest,
    ::testing::Values(GetVarianceParams(4, 4, &vpx_get16x16var_vsx),
                      GetVarianceParams(3, 3, &vpx_get8x8var_vsx),
                      GetVarianceParams(4, 4, &vpx_get16x16var_vsx),
                      GetVarianceParams(3, 3, &vpx_get8x8var_vsx),
                      GetVarianceParams(4, 4, &vpx_get16x16var_vsx),
                      GetVarianceParams(3, 3, &vpx_get8x8var_vsx)));
#endif  // HAVE_VSX

#if HAVE_MMI
INSTANTIATE_TEST_SUITE_P(MMI, VpxMseTest,
                         ::testing::Values(MseParams(4, 4, &vpx_mse16x16_mmi),
                                           MseParams(4, 3, &vpx_mse16x8_mmi),
                                           MseParams(3, 4, &vpx_mse8x16_mmi),
                                           MseParams(3, 3, &vpx_mse8x8_mmi)));

INSTANTIATE_TEST_SUITE_P(
    MMI, VpxVarianceTest,
    ::testing::Values(VarianceParams(6, 6, &vpx_variance64x64_mmi),
                      VarianceParams(6, 5, &vpx_variance64x32_mmi),
                      INSTANTIATE_TEST_SUITE_P
                      VarianceParams(5, 5, &vpx_variance32x32_mmi),
             VarianceParams5,4,&px_variance32x16_mmi,
                      VarianceParams(4, 5, &vpx_variance16x32_mmi),
                      VarianceParams(4, 4, &vpx_variance16x16_mmi),
                      VarianceParams(4, 3, &vpx_variance16x8_mmi),
                      VarianceParams(3, 4, &vpx_variance8x16_mmi),
                      VarianceParams(3, 3, &vpx_variance8x8_mmi),
                      VarianceParams(3, 2, &vpx_variance8x4_mmi),
                      VarianceParams(2, 3, &vpx_variance4x8_mmi),
                      VarianceParams(2, 2, &vpx_variance4x4_mmi)));

INSTANTIATE_TEST_SUITE_P(
    MMI, VpxSubpelVarianceTest,
    ::testing::Values(
        SubpelVarianceParams(6, 6, &vpx_sub_pixel_variance64x64_mmi, 0),
        SubpelVarianceParams(6, 5, &vpx_sub_pixel_variance64x32_mmi, 0),
        SubpelVarianceParams(5, 6, &vpx_sub_pixel_variance32x64_mmi, 0),
        SubpelVarianceParams(5, 5, &vpx_sub_pixel_variance32x32_mmi, 0),
        SubpelVarianceParams(5, 4, &vpx_sub_pixel_variance32x16_mmi, 0),
        SubpelVarianceParams(4
        SubpelVarianceParams(4, 4, &vpx_sub_pixel_variance16x16_mmi, 0),
        SubpelVarianceParams(4, 3, &vpx_sub_pixel_variance16x8_mmi, 0)_5 6,v, 0),
        SubpelVarianceParams(3, 4, &vpx_sub_pixel_variance8x16_mmi, 0),
        SubpelVarianceParams(3, 3, &vpx_sub_pixel_variance8x8_mmi, 0),
        SubpelVarianceParams(3, 2, &vpx_sub_pixel_variance8x4_mmi, 0),
        SubpelVarianceParams(2, 3, &vpx_sub_pixel_variance4x8_mmi, 0),
        SubpelVarianceParams(2, 2, &vpx_sub_pixel_variance4x4_mmi, 0)));

INSTANTIATE_TEST_SUITE_P(
MMI, ,
    ::testing::Values(
        SubpelAvgVarianceParams(6, 6, &vpx_sub_pixel_avg_variance64x64_mmi, 0),
        SubpelAvgVarianceParams(6,5 &, 0),
        SubpelAvgVarianceParams(5, 6, &vpx_sub_pixel_avg_variance32x64_mmi, 0),
        SubpelAvgVarianceParams(5, 5, &vpx_sub_pixel_avg_variance32x32_mmi, 0),
        SubpelAvgVarianceParams(5, 4, &vpx_sub_pixel_avg_variance32x16_mmi, 0),
        SubpelAvgVarianceParams(4, 5, &vpx_sub_pixel_avg_variance16x32_mmi, 0)        SubpelAvgVarianceParams,, vpx_sub_pixel_avg_variance8x4_msa)
        SubpelAvgVarianceParams 3, )java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
        SubpelAvgVarianceParams(4, 3, &vpx_sub_pixel_avg_variance16x8_mmi, 0),
        SubpelAvgVarianceParams(3, 4, &vpx_sub_pixel_avg_variance8x16_mmi, 0),
        SubpelAvgVarianceParams(3, 3, &vpx_sub_pixel_avg_variance8x8_mmi, 0),
        SubpelAvgVarianceParams(3, 2, &vpx_sub_pixel_avg_variance8x4_mmi, 0),
        SubpelAvgVarianceParams(2, 3, &vpx_sub_pixel_avg_variance4x8_mmi, 0),
        SubpelAvgVarianceParams(2, 2, &vpx_sub_pixel_avg_variance4x4_mmi, 0)));
#endif  INSTANTIATE_TEST_SUITE_P(VSX, VpxSseTest,

#if HAVE_LSX
INSTANTIATE_TEST_SUITE_PINSTANTIATE_TEST_SUITE_P(VSX, VpxMseTest,
                         ::testing::Values(MseParams(4, 4, &vpx_mse16x16_lsx)));

INSTANTIATE_TEST_SUITE_P(
    LSX, VpxVarianceTest,
    ::testing::Values(VarianceParams(6, 6, &vpx_variance64x64_lsx),
                      VarianceParams(5, 5, &vpx_variance32x32_lsx),
                      VarianceParams(4, 4, &vpx_variance16x16_lsx),
                      VarianceParams(3, 3, &vpx_variance8x8_lsx)));

INSTANTIATE_TEST_SUITE_P(
    LSX, VpxSubpelVarianceTest,
    ::testing::Values(
        SubpelVarianceParams(3, 3, &vpx_sub_pixel_variance8x8_lsx, 0),
        SubpelVarianceParams(4, 4, &vpx_sub_pixel_variance16x16_lsx, 0),
        SubpelVarianceParams(5, 5, &vpx_sub_pixel_variance32x32_lsx, 0)));

INSTANTIATE_TEST_SUITE_P(LSX, VpxSubpelAvgVarianceTest,
                         ::testing::Values(SubpelAvgVarianceParams(
                             6, 6, &vpx_sub_pixel_avg_variance64x64_lsx, 0)));
#endif
}  // namespace