diff options
author | Johann <johannkoenig@google.com> | 2015-05-15 11:52:03 -0700 |
---|---|---|
committer | Johann <johannkoenig@google.com> | 2015-05-26 12:01:52 -0700 |
commit | c3bdffb0a508ad08d5dfa613c029f368d4293d4c (patch) | |
tree | 4c087783da1d12bfbe09311ebb33f200e789ebf3 /test | |
parent | 976f7f42c1ad1ff3cc0792572f9c4f41f05bb375 (diff) | |
download | libvpx-c3bdffb0a508ad08d5dfa613c029f368d4293d4c.tar libvpx-c3bdffb0a508ad08d5dfa613c029f368d4293d4c.tar.gz libvpx-c3bdffb0a508ad08d5dfa613c029f368d4293d4c.tar.bz2 libvpx-c3bdffb0a508ad08d5dfa613c029f368d4293d4c.zip |
Move variance functions to vpx_dsp
subpel functions will be moved in another patch.
Change-Id: Idb2e049bad0b9b32ac42cc7731cd6903de2826ce
Diffstat (limited to 'test')
-rw-r--r-- | test/variance_test.cc | 977 |
1 files changed, 464 insertions, 513 deletions
diff --git a/test/variance_test.cc b/test/variance_test.cc index e4e27af7c..60ca81578 100644 --- a/test/variance_test.cc +++ b/test/variance_test.cc @@ -21,17 +21,21 @@ #include "vpx/vpx_integer.h" #include "vpx_mem/vpx_mem.h" #include "vpx_ports/mem.h" -#if CONFIG_VP8_ENCODER -# include "./vp8_rtcd.h" -# include "vp8/common/variance.h" -#endif #if CONFIG_VP9_ENCODER # include "./vp9_rtcd.h" # include "vp9/encoder/vp9_variance.h" -#endif +#endif // CONFIG_VP9_ENCODER +#include "./vpx_dsp_rtcd.h" namespace { +typedef unsigned int (*VarianceMxNFunc)(const uint8_t *a, int a_stride, + const uint8_t *b, int b_stride, + unsigned int *sse); +typedef unsigned int (*Get4x4SSEFunc)(const uint8_t *a, int a_stride, + const uint8_t *b, int b_stride); + + using ::std::tr1::get; using ::std::tr1::make_tuple; using ::std::tr1::tuple; @@ -50,7 +54,6 @@ static unsigned int variance_ref(const uint8_t *src, const uint8_t *ref, int ref_stride_coeff, uint32_t *sse_ptr, bool use_high_bit_depth_, vpx_bit_depth_t bit_depth) { -#if CONFIG_VP9_HIGHBITDEPTH int64_t se = 0; uint64_t sse = 0; const int w = 1 << l2w; @@ -63,11 +66,13 @@ static unsigned int variance_ref(const uint8_t *src, const uint8_t *ref, src[w * y * src_stride_coeff + x]; se += diff; sse += diff * diff; +#if CONFIG_VP9_HIGHBITDEPTH } else { diff = CONVERT_TO_SHORTPTR(ref)[w * y * ref_stride_coeff + x] - CONVERT_TO_SHORTPTR(src)[w * y * src_stride_coeff + x]; se += diff; sse += diff * diff; +#endif // CONFIG_VP9_HIGHBITDEPTH } } } @@ -75,20 +80,6 @@ static unsigned int variance_ref(const uint8_t *src, const uint8_t *ref, sse = ROUND_POWER_OF_TWO(sse, 2 * (bit_depth - 8)); se = ROUND_POWER_OF_TWO(se, bit_depth - 8); } -#else - int se = 0; - unsigned int sse = 0; - const int w = 1 << l2w; - const int h = 1 << l2h; - for (int y = 0; y < h; y++) { - for (int x = 0; x < w; x++) { - int diff = ref[w * y * ref_stride_coeff + x] - - src[w * y * src_stride_coeff + x]; - se += diff; - sse += diff * diff; - } - } -#endif // CONFIG_VP9_HIGHBITDEPTH *sse_ptr = sse; return sse - (((int64_t) se * se) >> (l2w + l2h)); } @@ -98,7 +89,6 @@ static unsigned int subpel_variance_ref(const uint8_t *ref, const uint8_t *src, unsigned int *sse_ptr, bool use_high_bit_depth_, vpx_bit_depth_t bit_depth) { -#if CONFIG_VP9_HIGHBITDEPTH int64_t se = 0; uint64_t sse = 0; const int w = 1 << l2w; @@ -117,6 +107,7 @@ static unsigned int subpel_variance_ref(const uint8_t *ref, const uint8_t *src, const int diff = r - src[w * y + x]; se += diff; sse += diff * diff; +#if CONFIG_VP9_HIGHBITDEPTH } else { uint16_t *ref16 = CONVERT_TO_SHORTPTR(ref); uint16_t *src16 = CONVERT_TO_SHORTPTR(src); @@ -130,6 +121,7 @@ static unsigned int subpel_variance_ref(const uint8_t *ref, const uint8_t *src, const int diff = r - src16[w * y + x]; se += diff; sse += diff * diff; +#endif // CONFIG_VP9_HIGHBITDEPTH } } } @@ -137,27 +129,6 @@ static unsigned int subpel_variance_ref(const uint8_t *ref, const uint8_t *src, sse = ROUND_POWER_OF_TWO(sse, 2 * (bit_depth - 8)); se = ROUND_POWER_OF_TWO(se, bit_depth - 8); } -#else - int se = 0; - unsigned int sse = 0; - const int w = 1 << l2w; - const int h = 1 << l2h; - for (int y = 0; y < h; y++) { - for (int x = 0; x < w; x++) { - // Bilinear interpolation at a 16th pel step. - 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 + 8) >> 4); - const int diff = r - src[w * y + x]; - se += diff; - sse += diff * diff; - } - } -#endif // CONFIG_VP9_HIGHBITDEPTH *sse_ptr = sse; return sse - (((int64_t) se * se) >> (l2w + l2h)); } @@ -229,36 +200,30 @@ class VarianceTest rnd_.Reset(ACMRandom::DeterministicSeed()); block_size_ = width_ * height_; -#if CONFIG_VP9_HIGHBITDEPTH if (!use_high_bit_depth_) { src_ = reinterpret_cast<uint8_t *>(vpx_memalign(16, block_size_ * 2)); ref_ = new uint8_t[block_size_ * 2]; +#if CONFIG_VP9_HIGHBITDEPTH } else { src_ = CONVERT_TO_BYTEPTR(reinterpret_cast<uint16_t *>( vpx_memalign(16, block_size_ * 2 * sizeof(uint16_t)))); ref_ = CONVERT_TO_BYTEPTR(new uint16_t[block_size_ * 2]); +#endif // CONFIG_VP9_HIGHBITDEPTH } -#else - src_ = reinterpret_cast<uint8_t *>(vpx_memalign(16, block_size_ * 2)); - ref_ = new uint8_t[block_size_ * 2]; -#endif ASSERT_TRUE(src_ != NULL); ASSERT_TRUE(ref_ != NULL); } virtual void TearDown() { -#if CONFIG_VP9_HIGHBITDEPTH if (!use_high_bit_depth_) { vpx_free(src_); delete[] ref_; +#if CONFIG_VP9_HIGHBITDEPTH } else { vpx_free(CONVERT_TO_SHORTPTR(src_)); delete[] CONVERT_TO_SHORTPTR(ref_); +#endif // CONFIG_VP9_HIGHBITDEPTH } -#else - vpx_free(src_); - delete[] ref_; -#endif libvpx_test::ClearSystemState(); } @@ -283,27 +248,23 @@ class VarianceTest template<typename VarianceFunctionType> void VarianceTest<VarianceFunctionType>::ZeroTest() { for (int i = 0; i <= 255; ++i) { -#if CONFIG_VP9_HIGHBITDEPTH if (!use_high_bit_depth_) { memset(src_, i, block_size_); +#if CONFIG_VP9_HIGHBITDEPTH } else { vpx_memset16(CONVERT_TO_SHORTPTR(src_), i << (bit_depth_ - 8), block_size_); +#endif // CONFIG_VP9_HIGHBITDEPTH } -#else - memset(src_, i, block_size_); -#endif for (int j = 0; j <= 255; ++j) { -#if CONFIG_VP9_HIGHBITDEPTH if (!use_high_bit_depth_) { memset(ref_, j, block_size_); +#if CONFIG_VP9_HIGHBITDEPTH } else { vpx_memset16(CONVERT_TO_SHORTPTR(ref_), j << (bit_depth_ - 8), block_size_); +#endif // CONFIG_VP9_HIGHBITDEPTH } -#else - memset(ref_, j, block_size_); -#endif unsigned int sse; unsigned int var; ASM_REGISTER_STATE_CHECK( @@ -317,18 +278,15 @@ template<typename VarianceFunctionType> void VarianceTest<VarianceFunctionType>::RefTest() { for (int i = 0; i < 10; ++i) { for (int j = 0; j < block_size_; j++) { -#if CONFIG_VP9_HIGHBITDEPTH if (!use_high_bit_depth_) { src_[j] = rnd_.Rand8(); ref_[j] = rnd_.Rand8(); +#if CONFIG_VP9_HIGHBITDEPTH } else { CONVERT_TO_SHORTPTR(src_)[j] = rnd_.Rand16() && mask_; CONVERT_TO_SHORTPTR(ref_)[j] = rnd_.Rand16() && mask_; +#endif // CONFIG_VP9_HIGHBITDEPTH } -#else - src_[j] = rnd_.Rand8(); - ref_[j] = rnd_.Rand8(); -#endif } unsigned int sse1, sse2; unsigned int var1; @@ -352,18 +310,15 @@ void VarianceTest<VarianceFunctionType>::RefStrideTest() { for (int j = 0; j < block_size_; j++) { int ref_ind = (j / width_) * ref_stride_coeff * width_ + j % width_; int src_ind = (j / width_) * src_stride_coeff * width_ + j % width_; -#if CONFIG_VP9_HIGHBITDEPTH if (!use_high_bit_depth_) { src_[src_ind] = rnd_.Rand8(); ref_[ref_ind] = rnd_.Rand8(); +#if CONFIG_VP9_HIGHBITDEPTH } else { CONVERT_TO_SHORTPTR(src_)[src_ind] = rnd_.Rand16() && mask_; CONVERT_TO_SHORTPTR(ref_)[ref_ind] = rnd_.Rand16() && mask_; +#endif // CONFIG_VP9_HIGHBITDEPTH } -#else - src_[src_ind] = rnd_.Rand8(); - ref_[ref_ind] = rnd_.Rand8(); -#endif } unsigned int sse1, sse2; unsigned int var1; @@ -383,22 +338,18 @@ void VarianceTest<VarianceFunctionType>::RefStrideTest() { template<typename VarianceFunctionType> void VarianceTest<VarianceFunctionType>::OneQuarterTest() { const int half = block_size_ / 2; -#if CONFIG_VP9_HIGHBITDEPTH if (!use_high_bit_depth_) { 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 << (bit_depth_ - 8), block_size_); vpx_memset16(CONVERT_TO_SHORTPTR(ref_), 255 << (bit_depth_ - 8), half); vpx_memset16(CONVERT_TO_SHORTPTR(ref_) + half, 0, half); +#endif // CONFIG_VP9_HIGHBITDEPTH } -#else - memset(src_, 255, block_size_); - memset(ref_, 255, half); - memset(ref_ + half, 0, half); -#endif unsigned int sse; unsigned int var; ASM_REGISTER_STATE_CHECK(var = variance_(src_, width_, ref_, width_, &sse)); @@ -406,7 +357,6 @@ void VarianceTest<VarianceFunctionType>::OneQuarterTest() { EXPECT_EQ(expected, var); } -#if CONFIG_VP8_ENCODER template<typename MseFunctionType> class MseTest : public ::testing::TestWithParam<tuple<int, int, MseFunctionType> > { @@ -500,9 +450,7 @@ void MseTest<MseFunctionType>::MaxTest_sse() { const unsigned int expected = block_size_ * 255 * 255; EXPECT_EQ(expected, var); } -#endif -#if CONFIG_VP9_ENCODER unsigned int subpel_avg_variance_ref(const uint8_t *ref, const uint8_t *src, const uint8_t *second_pred, @@ -511,7 +459,6 @@ unsigned int subpel_avg_variance_ref(const uint8_t *ref, unsigned int *sse_ptr, bool use_high_bit_depth, vpx_bit_depth_t bit_depth) { -#if CONFIG_VP9_HIGHBITDEPTH int64_t se = 0; uint64_t sse = 0; const int w = 1 << l2w; @@ -530,6 +477,7 @@ unsigned int subpel_avg_variance_ref(const uint8_t *ref, const int diff = ((r + second_pred[w * y + x] + 1) >> 1) - src[w * y + x]; se += diff; sse += diff * diff; +#if CONFIG_VP9_HIGHBITDEPTH } else { uint16_t *ref16 = CONVERT_TO_SHORTPTR(ref); uint16_t *src16 = CONVERT_TO_SHORTPTR(src); @@ -544,6 +492,7 @@ unsigned int subpel_avg_variance_ref(const uint8_t *ref, const int diff = ((r + sec16[w * y + x] + 1) >> 1) - src16[w * y + x]; se += diff; sse += diff * diff; +#endif // CONFIG_VP9_HIGHBITDEPTH } } } @@ -551,27 +500,6 @@ unsigned int subpel_avg_variance_ref(const uint8_t *ref, sse = ROUND_POWER_OF_TWO(sse, 2*(bit_depth-8)); se = ROUND_POWER_OF_TWO(se, bit_depth-8); } -#else - int se = 0; - unsigned int sse = 0; - const int w = 1 << l2w; - const int h = 1 << l2h; - for (int y = 0; y < h; y++) { - for (int x = 0; x < w; x++) { - // bilinear interpolation at a 16th pel step - 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 + 8) >> 4); - const int diff = ((r + second_pred[w * y + x] + 1) >> 1) - src[w * y + x]; - se += diff; - sse += diff * diff; - } - } -#endif // CONFIG_VP9_HIGHBITDEPTH *sse_ptr = sse; return sse - (((int64_t) se * se) >> (l2w + l2h)); } @@ -600,11 +528,11 @@ class SubpelVarianceTest rnd_.Reset(ACMRandom::DeterministicSeed()); block_size_ = width_ * height_; -#if CONFIG_VP9_HIGHBITDEPTH if (!use_high_bit_depth_) { src_ = reinterpret_cast<uint8_t *>(vpx_memalign(16, block_size_)); sec_ = reinterpret_cast<uint8_t *>(vpx_memalign(16, block_size_)); ref_ = new uint8_t[block_size_ + width_ + height_ + 1]; +#if CONFIG_VP9_HIGHBITDEPTH } else { src_ = CONVERT_TO_BYTEPTR( reinterpret_cast<uint16_t *>( @@ -614,33 +542,25 @@ class SubpelVarianceTest vpx_memalign(16, block_size_*sizeof(uint16_t)))); ref_ = CONVERT_TO_BYTEPTR( new uint16_t[block_size_ + width_ + height_ + 1]); - } -#else - src_ = reinterpret_cast<uint8_t *>(vpx_memalign(16, block_size_)); - sec_ = reinterpret_cast<uint8_t *>(vpx_memalign(16, block_size_)); - ref_ = new uint8_t[block_size_ + width_ + height_ + 1]; #endif // CONFIG_VP9_HIGHBITDEPTH + } ASSERT_TRUE(src_ != NULL); ASSERT_TRUE(sec_ != NULL); ASSERT_TRUE(ref_ != NULL); } virtual void TearDown() { -#if CONFIG_VP9_HIGHBITDEPTH if (!use_high_bit_depth_) { vpx_free(src_); delete[] ref_; vpx_free(sec_); +#if CONFIG_VP9_HIGHBITDEPTH } else { vpx_free(CONVERT_TO_SHORTPTR(src_)); delete[] CONVERT_TO_SHORTPTR(ref_); vpx_free(CONVERT_TO_SHORTPTR(sec_)); +#endif // CONFIG_VP9_HIGHBITDEPTH } -#else - vpx_free(src_); - delete[] ref_; - vpx_free(sec_); -#endif libvpx_test::ClearSystemState(); } @@ -664,7 +584,6 @@ template<typename SubpelVarianceFunctionType> void SubpelVarianceTest<SubpelVarianceFunctionType>::RefTest() { for (int x = 0; x < 16; ++x) { for (int y = 0; y < 16; ++y) { -#if CONFIG_VP9_HIGHBITDEPTH if (!use_high_bit_depth_) { for (int j = 0; j < block_size_; j++) { src_[j] = rnd_.Rand8(); @@ -672,6 +591,7 @@ void SubpelVarianceTest<SubpelVarianceFunctionType>::RefTest() { for (int j = 0; j < block_size_ + width_ + height_ + 1; j++) { ref_[j] = rnd_.Rand8(); } +#if CONFIG_VP9_HIGHBITDEPTH } else { for (int j = 0; j < block_size_; j++) { CONVERT_TO_SHORTPTR(src_)[j] = rnd_.Rand16() & mask_; @@ -679,15 +599,8 @@ void SubpelVarianceTest<SubpelVarianceFunctionType>::RefTest() { for (int j = 0; j < block_size_ + width_ + height_ + 1; j++) { CONVERT_TO_SHORTPTR(ref_)[j] = rnd_.Rand16() & mask_; } - } -#else - for (int j = 0; j < block_size_; j++) { - src_[j] = rnd_.Rand8(); - } - for (int j = 0; j < block_size_ + width_ + height_ + 1; j++) { - ref_[j] = rnd_.Rand8(); - } #endif // CONFIG_VP9_HIGHBITDEPTH + } unsigned int sse1, sse2; unsigned int var1; ASM_REGISTER_STATE_CHECK(var1 = subpel_variance_(ref_, width_ + 1, x, y, @@ -710,25 +623,20 @@ void SubpelVarianceTest<SubpelVarianceFunctionType>::ExtremeRefTest() { for (int x = 0; x < 16; ++x) { for (int y = 0; y < 16; ++y) { const int half = block_size_ / 2; -#if CONFIG_VP9_HIGHBITDEPTH if (!use_high_bit_depth_) { memset(src_, 0, half); memset(src_ + half, 255, half); memset(ref_, 255, half); memset(ref_ + half, 0, half + width_ + height_ + 1); +#if CONFIG_VP9_HIGHBITDEPTH } else { vpx_memset16(CONVERT_TO_SHORTPTR(src_), mask_, half); vpx_memset16(CONVERT_TO_SHORTPTR(src_) + half, 0, half); vpx_memset16(CONVERT_TO_SHORTPTR(ref_), 0, half); vpx_memset16(CONVERT_TO_SHORTPTR(ref_) + half, mask_, half + width_ + height_ + 1); - } -#else - memset(src_, 0, half); - memset(src_ + half, 255, half); - memset(ref_, 255, half); - memset(ref_ + half, 0, half + width_ + height_ + 1); #endif // CONFIG_VP9_HIGHBITDEPTH + } unsigned int sse1, sse2; unsigned int var1; ASM_REGISTER_STATE_CHECK( @@ -742,11 +650,11 @@ void SubpelVarianceTest<SubpelVarianceFunctionType>::ExtremeRefTest() { } } +#if CONFIG_VP9_ENCODER template<> void SubpelVarianceTest<vp9_subp_avg_variance_fn_t>::RefTest() { for (int x = 0; x < 16; ++x) { for (int y = 0; y < 16; ++y) { -#if CONFIG_VP9_HIGHBITDEPTH if (!use_high_bit_depth_) { for (int j = 0; j < block_size_; j++) { src_[j] = rnd_.Rand8(); @@ -755,6 +663,7 @@ void SubpelVarianceTest<vp9_subp_avg_variance_fn_t>::RefTest() { for (int j = 0; j < block_size_ + width_ + height_ + 1; j++) { ref_[j] = rnd_.Rand8(); } +#if CONFIG_VP9_HIGHBITDEPTH } else { for (int j = 0; j < block_size_; j++) { CONVERT_TO_SHORTPTR(src_)[j] = rnd_.Rand16() & mask_; @@ -763,16 +672,8 @@ void SubpelVarianceTest<vp9_subp_avg_variance_fn_t>::RefTest() { for (int j = 0; j < block_size_ + width_ + height_ + 1; j++) { CONVERT_TO_SHORTPTR(ref_)[j] = rnd_.Rand16() & mask_; } +#endif // CONFIG_VP9_HIGHBITDEPTH } -#else - for (int j = 0; j < block_size_; j++) { - src_[j] = rnd_.Rand8(); - sec_[j] = rnd_.Rand8(); - } - for (int j = 0; j < block_size_ + width_ + height_ + 1; j++) { - ref_[j] = rnd_.Rand8(); - } -#endif unsigned int sse1, sse2; unsigned int var1; ASM_REGISTER_STATE_CHECK( @@ -788,272 +689,407 @@ void SubpelVarianceTest<vp9_subp_avg_variance_fn_t>::RefTest() { } } } - #endif // CONFIG_VP9_ENCODER -// ----------------------------------------------------------------------------- -// VP8 test cases. - -namespace vp8 { - -#if CONFIG_VP8_ENCODER -typedef unsigned int (*vp8_sse_fn_t)(const unsigned char *src_ptr, - int source_stride, const unsigned char *ref_ptr, int ref_stride); - -typedef MseTest<vp8_sse_fn_t> VP8SseTest; -typedef MseTest<vp8_variance_fn_t> VP8MseTest; -typedef VarianceTest<vp8_variance_fn_t> VP8VarianceTest; - -TEST_P(VP8SseTest, Ref_sse) { RefTest_sse(); } -TEST_P(VP8SseTest, Max_sse) { MaxTest_sse(); } -TEST_P(VP8MseTest, Ref_mse) { RefTest_mse(); } -TEST_P(VP8MseTest, Max_mse) { MaxTest_mse(); } -TEST_P(VP8VarianceTest, Zero) { ZeroTest(); } -TEST_P(VP8VarianceTest, Ref) { RefTest(); } -TEST_P(VP8VarianceTest, OneQuarter) { OneQuarterTest(); } +typedef MseTest<Get4x4SSEFunc> VpxSseTest; +typedef MseTest<VarianceMxNFunc> VpxMseTest; +typedef VarianceTest<VarianceMxNFunc> VpxVarianceTest; + +TEST_P(VpxSseTest, Ref_sse) { RefTest_sse(); } +TEST_P(VpxSseTest, Max_sse) { MaxTest_sse(); } +TEST_P(VpxMseTest, Ref_mse) { RefTest_mse(); } +TEST_P(VpxMseTest, Max_mse) { MaxTest_mse(); } +TEST_P(VpxVarianceTest, Zero) { ZeroTest(); } +TEST_P(VpxVarianceTest, Ref) { RefTest(); } +TEST_P(VpxVarianceTest, RefStride) { RefStrideTest(); } +TEST_P(VpxVarianceTest, OneQuarter) { OneQuarterTest(); } +TEST_P(SumOfSquaresTest, Const) { ConstTest(); } +TEST_P(SumOfSquaresTest, Ref) { RefTest(); } -const vp8_sse_fn_t get4x4sse_cs_c = vp8_get4x4sse_cs_c; -INSTANTIATE_TEST_CASE_P( - C, VP8SseTest, - ::testing::Values(make_tuple(2, 2, get4x4sse_cs_c))); +INSTANTIATE_TEST_CASE_P(C, SumOfSquaresTest, + ::testing::Values(vpx_get_mb_ss_c)); + +const Get4x4SSEFunc get4x4sse_cs_c = vpx_get4x4sse_cs_c; +INSTANTIATE_TEST_CASE_P(C, VpxSseTest, + ::testing::Values(make_tuple(2, 2, get4x4sse_cs_c))); + +const VarianceMxNFunc mse16x16_c = vpx_mse16x16_c; +const VarianceMxNFunc mse16x8_c = vpx_mse16x8_c; +const VarianceMxNFunc mse8x16_c = vpx_mse8x16_c; +const VarianceMxNFunc mse8x8_c = vpx_mse8x8_c; +INSTANTIATE_TEST_CASE_P(C, VpxMseTest, + ::testing::Values(make_tuple(4, 4, mse16x16_c), + make_tuple(4, 3, mse16x8_c), + make_tuple(3, 4, mse8x16_c), + make_tuple(3, 3, mse8x8_c))); + +const VarianceMxNFunc variance64x64_c = vpx_variance64x64_c; +const VarianceMxNFunc variance64x32_c = vpx_variance64x32_c; +const VarianceMxNFunc variance32x64_c = vpx_variance32x64_c; +const VarianceMxNFunc variance32x32_c = vpx_variance32x32_c; +const VarianceMxNFunc variance32x16_c = vpx_variance32x16_c; +const VarianceMxNFunc variance16x32_c = vpx_variance16x32_c; +const VarianceMxNFunc variance16x16_c = vpx_variance16x16_c; +const VarianceMxNFunc variance16x8_c = vpx_variance16x8_c; +const VarianceMxNFunc variance8x16_c = vpx_variance8x16_c; +const VarianceMxNFunc variance8x8_c = vpx_variance8x8_c; +const VarianceMxNFunc variance8x4_c = vpx_variance8x4_c; +const VarianceMxNFunc variance4x8_c = vpx_variance4x8_c; +const VarianceMxNFunc variance4x4_c = vpx_variance4x4_c; -const vp8_variance_fn_t mse16x16_c = vp8_mse16x16_c; INSTANTIATE_TEST_CASE_P( - C, VP8MseTest, - ::testing::Values(make_tuple(4, 4, mse16x16_c))); - -const vp8_variance_fn_t variance4x4_c = vp8_variance4x4_c; -const vp8_variance_fn_t variance8x8_c = vp8_variance8x8_c; -const vp8_variance_fn_t variance8x16_c = vp8_variance8x16_c; -const vp8_variance_fn_t variance16x8_c = vp8_variance16x8_c; -const vp8_variance_fn_t variance16x16_c = vp8_variance16x16_c; -INSTANTIATE_TEST_CASE_P( - C, VP8VarianceTest, - ::testing::Values(make_tuple(2, 2, variance4x4_c, 0), - make_tuple(3, 3, variance8x8_c, 0), - make_tuple(3, 4, variance8x16_c, 0), + C, VpxVarianceTest, + ::testing::Values(make_tuple(6, 6, variance64x64_c, 0), + make_tuple(6, 5, variance64x32_c, 0), + make_tuple(5, 6, variance32x64_c, 0), + make_tuple(5, 5, variance32x32_c, 0), + make_tuple(5, 4, variance32x16_c, 0), + make_tuple(4, 5, variance16x32_c, 0), + make_tuple(4, 4, variance16x16_c, 0), make_tuple(4, 3, variance16x8_c, 0), - make_tuple(4, 4, variance16x16_c, 0))); + make_tuple(3, 4, variance8x16_c, 0), + make_tuple(3, 3, variance8x8_c, 0), + make_tuple(3, 2, variance8x4_c, 0), + make_tuple(2, 3, variance4x8_c, 0), + make_tuple(2, 2, variance4x4_c, 0))); -#if HAVE_NEON -const vp8_sse_fn_t get4x4sse_cs_neon = vp8_get4x4sse_cs_neon; -INSTANTIATE_TEST_CASE_P( - NEON, VP8SseTest, - ::testing::Values(make_tuple(2, 2, get4x4sse_cs_neon))); +#if CONFIG_VP9_HIGHBITDEPTH +typedef MseTest<VarianceMxNFunc> VpxHBDMseTest; +typedef VarianceTest<VarianceMxNFunc> VpxHBDVarianceTest; + +TEST_P(VpxHBDMseTest, Ref_mse) { RefTest_mse(); } +TEST_P(VpxHBDMseTest, Max_mse) { MaxTest_mse(); } +TEST_P(VpxHBDVarianceTest, Zero) { ZeroTest(); } +TEST_P(VpxHBDVarianceTest, Ref) { RefTest(); } +TEST_P(VpxHBDVarianceTest, RefStride) { RefStrideTest(); } +TEST_P(VpxHBDVarianceTest, OneQuarter) { OneQuarterTest(); } + +/* TODO(debargha): This test does not support the highbd version +const VarianceMxNFunc highbd_12_mse16x16_c = vpx_highbd_12_mse16x16_c; +const VarianceMxNFunc highbd_12_mse16x8_c = vpx_highbd_12_mse16x8_c; +const VarianceMxNFunc highbd_12_mse8x16_c = vpx_highbd_12_mse8x16_c; +const VarianceMxNFunc highbd_12_mse8x8_c = vpx_highbd_12_mse8x8_c; + +const VarianceMxNFunc highbd_10_mse16x16_c = vpx_highbd_10_mse16x16_c; +const VarianceMxNFunc highbd_10_mse16x8_c = vpx_highbd_10_mse16x8_c; +const VarianceMxNFunc highbd_10_mse8x16_c = vpx_highbd_10_mse8x16_c; +const VarianceMxNFunc highbd_10_mse8x8_c = vpx_highbd_10_mse8x8_c; + +const VarianceMxNFunc highbd_8_mse16x16_c = vpx_highbd_8_mse16x16_c; +const VarianceMxNFunc highbd_8_mse16x8_c = vpx_highbd_8_mse16x8_c; +const VarianceMxNFunc highbd_8_mse8x16_c = vpx_highbd_8_mse8x16_c; +const VarianceMxNFunc highbd_8_mse8x8_c = vpx_highbd_8_mse8x8_c; -const vp8_variance_fn_t mse16x16_neon = vp8_mse16x16_neon; INSTANTIATE_TEST_CASE_P( - NEON, VP8MseTest, - ::testing::Values(make_tuple(4, 4, mse16x16_neon))); - -const vp8_variance_fn_t variance8x8_neon = vp8_variance8x8_neon; -const vp8_variance_fn_t variance8x16_neon = vp8_variance8x16_neon; -const vp8_variance_fn_t variance16x8_neon = vp8_variance16x8_neon; -const vp8_variance_fn_t variance16x16_neon = vp8_variance16x16_neon; + C, VpxHBDMseTest, ::testing::Values(make_tuple(4, 4, highbd_12_mse16x16_c), + make_tuple(4, 4, highbd_12_mse16x8_c), + make_tuple(4, 4, highbd_12_mse8x16_c), + make_tuple(4, 4, highbd_12_mse8x8_c), + make_tuple(4, 4, highbd_10_mse16x16_c), + make_tuple(4, 4, highbd_10_mse16x8_c), + make_tuple(4, 4, highbd_10_mse8x16_c), + make_tuple(4, 4, highbd_10_mse8x8_c), + make_tuple(4, 4, highbd_8_mse16x16_c), + make_tuple(4, 4, highbd_8_mse16x8_c), + make_tuple(4, 4, highbd_8_mse8x16_c), + make_tuple(4, 4, highbd_8_mse8x8_c))); +*/ + + +const VarianceMxNFunc highbd_12_variance64x64_c = vpx_highbd_12_variance64x64_c; +const VarianceMxNFunc highbd_12_variance64x32_c = vpx_highbd_12_variance64x32_c; +const VarianceMxNFunc highbd_12_variance32x64_c = vpx_highbd_12_variance32x64_c; +const VarianceMxNFunc highbd_12_variance32x32_c = vpx_highbd_12_variance32x32_c; +const VarianceMxNFunc highbd_12_variance32x16_c = vpx_highbd_12_variance32x16_c; +const VarianceMxNFunc highbd_12_variance16x32_c = vpx_highbd_12_variance16x32_c; +const VarianceMxNFunc highbd_12_variance16x16_c = vpx_highbd_12_variance16x16_c; +const VarianceMxNFunc highbd_12_variance16x8_c = vpx_highbd_12_variance16x8_c; +const VarianceMxNFunc highbd_12_variance8x16_c = vpx_highbd_12_variance8x16_c; +const VarianceMxNFunc highbd_12_variance8x8_c = vpx_highbd_12_variance8x8_c; +const VarianceMxNFunc highbd_12_variance8x4_c = vpx_highbd_12_variance8x4_c; +const VarianceMxNFunc highbd_12_variance4x8_c = vpx_highbd_12_variance4x8_c; +const VarianceMxNFunc highbd_12_variance4x4_c = vpx_highbd_12_variance4x4_c; + +const VarianceMxNFunc highbd_10_variance64x64_c = vpx_highbd_10_variance64x64_c; +const VarianceMxNFunc highbd_10_variance64x32_c = vpx_highbd_10_variance64x32_c; +const VarianceMxNFunc highbd_10_variance32x64_c = vpx_highbd_10_variance32x64_c; +const VarianceMxNFunc highbd_10_variance32x32_c = vpx_highbd_10_variance32x32_c; +const VarianceMxNFunc highbd_10_variance32x16_c = vpx_highbd_10_variance32x16_c; +const VarianceMxNFunc highbd_10_variance16x32_c = vpx_highbd_10_variance16x32_c; +const VarianceMxNFunc highbd_10_variance16x16_c = vpx_highbd_10_variance16x16_c; +const VarianceMxNFunc highbd_10_variance16x8_c = vpx_highbd_10_variance16x8_c; +const VarianceMxNFunc highbd_10_variance8x16_c = vpx_highbd_10_variance8x16_c; +const VarianceMxNFunc highbd_10_variance8x8_c = vpx_highbd_10_variance8x8_c; +const VarianceMxNFunc highbd_10_variance8x4_c = vpx_highbd_10_variance8x4_c; +const VarianceMxNFunc highbd_10_variance4x8_c = vpx_highbd_10_variance4x8_c; +const VarianceMxNFunc highbd_10_variance4x4_c = vpx_highbd_10_variance4x4_c; + +const VarianceMxNFunc highbd_8_variance64x64_c = vpx_highbd_8_variance64x64_c; +const VarianceMxNFunc highbd_8_variance64x32_c = vpx_highbd_8_variance64x32_c; +const VarianceMxNFunc highbd_8_variance32x64_c = vpx_highbd_8_variance32x64_c; +const VarianceMxNFunc highbd_8_variance32x32_c = vpx_highbd_8_variance32x32_c; +const VarianceMxNFunc highbd_8_variance32x16_c = vpx_highbd_8_variance32x16_c; +const VarianceMxNFunc highbd_8_variance16x32_c = vpx_highbd_8_variance16x32_c; +const VarianceMxNFunc highbd_8_variance16x16_c = vpx_highbd_8_variance16x16_c; +const VarianceMxNFunc highbd_8_variance16x8_c = vpx_highbd_8_variance16x8_c; +const VarianceMxNFunc highbd_8_variance8x16_c = vpx_highbd_8_variance8x16_c; +const VarianceMxNFunc highbd_8_variance8x8_c = vpx_highbd_8_variance8x8_c; +const VarianceMxNFunc highbd_8_variance8x4_c = vpx_highbd_8_variance8x4_c; +const VarianceMxNFunc highbd_8_variance4x8_c = vpx_highbd_8_variance4x8_c; +const VarianceMxNFunc highbd_8_variance4x4_c = vpx_highbd_8_variance4x4_c; INSTANTIATE_TEST_CASE_P( - NEON, VP8VarianceTest, - ::testing::Values(make_tuple(3, 3, variance8x8_neon, 0), - make_tuple(3, 4, variance8x16_neon, 0), - make_tuple(4, 3, variance16x8_neon, 0), - make_tuple(4, 4, variance16x16_neon, 0))); -#endif + C, VpxHBDVarianceTest, + ::testing::Values(make_tuple(6, 6, highbd_12_variance64x64_c, 12), + make_tuple(6, 5, highbd_12_variance64x32_c, 12), + make_tuple(5, 6, highbd_12_variance32x64_c, 12), + make_tuple(5, 5, highbd_12_variance32x32_c, 12), + make_tuple(5, 4, highbd_12_variance32x16_c, 12), + make_tuple(4, 5, highbd_12_variance16x32_c, 12), + make_tuple(4, 4, highbd_12_variance16x16_c, 12), + make_tuple(4, 3, highbd_12_variance16x8_c, 12), + make_tuple(3, 4, highbd_12_variance8x16_c, 12), + make_tuple(3, 3, highbd_12_variance8x8_c, 12), + make_tuple(3, 2, highbd_12_variance8x4_c, 12), + make_tuple(2, 3, highbd_12_variance4x8_c, 12), + make_tuple(2, 2, highbd_12_variance4x4_c, 12), + make_tuple(6, 6, highbd_10_variance64x64_c, 10), + make_tuple(6, 5, highbd_10_variance64x32_c, 10), + make_tuple(5, 6, highbd_10_variance32x64_c, 10), + make_tuple(5, 5, highbd_10_variance32x32_c, 10), + make_tuple(5, 4, highbd_10_variance32x16_c, 10), + make_tuple(4, 5, highbd_10_variance16x32_c, 10), + make_tuple(4, 4, highbd_10_variance16x16_c, 10), + make_tuple(4, 3, highbd_10_variance16x8_c, 10), + make_tuple(3, 4, highbd_10_variance8x16_c, 10), + make_tuple(3, 3, highbd_10_variance8x8_c, 10), + make_tuple(3, 2, highbd_10_variance8x4_c, 10), + make_tuple(2, 3, highbd_10_variance4x8_c, 10), + make_tuple(2, 2, highbd_10_variance4x4_c, 10), + make_tuple(6, 6, highbd_8_variance64x64_c, 8), + make_tuple(6, 5, highbd_8_variance64x32_c, 8), + make_tuple(5, 6, highbd_8_variance32x64_c, 8), + make_tuple(5, 5, highbd_8_variance32x32_c, 8), + make_tuple(5, 4, highbd_8_variance32x16_c, 8), + make_tuple(4, 5, highbd_8_variance16x32_c, 8), + make_tuple(4, 4, highbd_8_variance16x16_c, 8), + make_tuple(4, 3, highbd_8_variance16x8_c, 8), + make_tuple(3, 4, highbd_8_variance8x16_c, 8), + make_tuple(3, 3, highbd_8_variance8x8_c, 8), + make_tuple(3, 2, highbd_8_variance8x4_c, 8), + make_tuple(2, 3, highbd_8_variance4x8_c, 8), + make_tuple(2, 2, highbd_8_variance4x4_c, 8))); +#endif // CONFIG_VP9_HIGHBITDEPTH #if HAVE_MMX -const vp8_variance_fn_t variance4x4_mmx = vp8_variance4x4_mmx; -const vp8_variance_fn_t variance8x8_mmx = vp8_variance8x8_mmx; -const vp8_variance_fn_t variance8x16_mmx = vp8_variance8x16_mmx; -const vp8_variance_fn_t variance16x8_mmx = vp8_variance16x8_mmx; -const vp8_variance_fn_t variance16x16_mmx = vp8_variance16x16_mmx; +const VarianceMxNFunc mse16x16_mmx = vpx_mse16x16_mmx; +INSTANTIATE_TEST_CASE_P(MMX, VpxMseTest, + ::testing::Values(make_tuple(4, 4, mse16x16_mmx))); + +INSTANTIATE_TEST_CASE_P(MMX, SumOfSquaresTest, + ::testing::Values(vpx_get_mb_ss_mmx)); + +const VarianceMxNFunc variance16x16_mmx = vpx_variance16x16_mmx; +const VarianceMxNFunc variance16x8_mmx = vpx_variance16x8_mmx; +const VarianceMxNFunc variance8x16_mmx = vpx_variance8x16_mmx; +const VarianceMxNFunc variance8x8_mmx = vpx_variance8x8_mmx; +const VarianceMxNFunc variance4x4_mmx = vpx_variance4x4_mmx; INSTANTIATE_TEST_CASE_P( - MMX, VP8VarianceTest, - ::testing::Values(make_tuple(2, 2, variance4x4_mmx, 0), - make_tuple(3, 3, variance8x8_mmx, 0), - make_tuple(3, 4, variance8x16_mmx, 0), + MMX, VpxVarianceTest, + ::testing::Values(make_tuple(4, 4, variance16x16_mmx, 0), make_tuple(4, 3, variance16x8_mmx, 0), - make_tuple(4, 4, variance16x16_mmx, 0))); -#endif + make_tuple(3, 4, variance8x16_mmx, 0), + make_tuple(3, 3, variance8x8_mmx, 0), + make_tuple(2, 2, variance4x4_mmx, 0))); +#endif // HAVE_MMX #if HAVE_SSE2 -const vp8_variance_fn_t variance4x4_wmt = vp8_variance4x4_wmt; -const vp8_variance_fn_t variance8x8_wmt = vp8_variance8x8_wmt; -const vp8_variance_fn_t variance8x16_wmt = vp8_variance8x16_wmt; -const vp8_variance_fn_t variance16x8_wmt = vp8_variance16x8_wmt; -const vp8_variance_fn_t variance16x16_wmt = vp8_variance16x16_wmt; +INSTANTIATE_TEST_CASE_P(SSE2, SumOfSquaresTest, + ::testing::Values(vpx_get_mb_ss_sse2)); + +const VarianceMxNFunc mse16x16_sse2 = vpx_mse16x16_sse2; +const VarianceMxNFunc mse16x8_sse2 = vpx_mse16x8_sse2; +const VarianceMxNFunc mse8x16_sse2 = vpx_mse8x16_sse2; +const VarianceMxNFunc mse8x8_sse2 = vpx_mse8x8_sse2; +INSTANTIATE_TEST_CASE_P(SSE2, VpxMseTest, + ::testing::Values(make_tuple(4, 4, mse16x16_sse2), + make_tuple(4, 3, mse16x8_sse2), + make_tuple(3, 4, mse8x16_sse2), + make_tuple(3, 3, mse8x8_sse2))); + +const VarianceMxNFunc variance64x64_sse2 = vpx_variance64x64_sse2; +const VarianceMxNFunc variance64x32_sse2 = vpx_variance64x32_sse2; +const VarianceMxNFunc variance32x64_sse2 = vpx_variance32x64_sse2; +const VarianceMxNFunc variance32x32_sse2 = vpx_variance32x32_sse2; +const VarianceMxNFunc variance32x16_sse2 = vpx_variance32x16_sse2; +const VarianceMxNFunc variance16x32_sse2 = vpx_variance16x32_sse2; +const VarianceMxNFunc variance16x16_sse2 = vpx_variance16x16_sse2; +const VarianceMxNFunc variance16x8_sse2 = vpx_variance16x8_sse2; +const VarianceMxNFunc variance8x16_sse2 = vpx_variance8x16_sse2; +const VarianceMxNFunc variance8x8_sse2 = vpx_variance8x8_sse2; +const VarianceMxNFunc variance8x4_sse2 = vpx_variance8x4_sse2; +const VarianceMxNFunc variance4x8_sse2 = vpx_variance4x8_sse2; +const VarianceMxNFunc variance4x4_sse2 = vpx_variance4x4_sse2; INSTANTIATE_TEST_CASE_P( - SSE2, VP8VarianceTest, - ::testing::Values(make_tuple(2, 2, variance4x4_wmt, 0), - make_tuple(3, 3, variance8x8_wmt, 0), - make_tuple(3, 4, variance8x16_wmt, 0), - make_tuple(4, 3, variance16x8_wmt, 0), - make_tuple(4, 4, variance16x16_wmt, 0))); -#endif -#endif // CONFIG_VP8_ENCODER - -} // namespace vp8 + SSE2, VpxVarianceTest, + ::testing::Values(make_tuple(6, 6, variance64x64_sse2, 0), + make_tuple(6, 5, variance64x32_sse2, 0), + make_tuple(5, 6, variance32x64_sse2, 0), + make_tuple(5, 5, variance32x32_sse2, 0), + make_tuple(5, 4, variance32x16_sse2, 0), + make_tuple(4, 5, variance16x32_sse2, 0), + make_tuple(4, 4, variance16x16_sse2, 0), + make_tuple(4, 3, variance16x8_sse2, 0), + make_tuple(3, 4, variance8x16_sse2, 0), + make_tuple(3, 3, variance8x8_sse2, 0), + make_tuple(3, 2, variance8x4_sse2, 0), + make_tuple(2, 3, variance4x8_sse2, 0), + make_tuple(2, 2, variance4x4_sse2, 0))); +#if CONFIG_VP9_HIGHBITDEPTH +/* TODO(debargha): This test does not support the highbd version +const VarianceMxNFunc highbd_12_mse16x16_sse2 = vpx_highbd_12_mse16x16_sse2; +const VarianceMxNFunc highbd_12_mse16x8_sse2 = vpx_highbd_12_mse16x8_sse2; +const VarianceMxNFunc highbd_12_mse8x16_sse2 = vpx_highbd_12_mse8x16_sse2; +const VarianceMxNFunc highbd_12_mse8x8_sse2 = vpx_highbd_12_mse8x8_sse2; + +const VarianceMxNFunc highbd_10_mse16x16_sse2 = vpx_highbd_10_mse16x16_sse2; +const VarianceMxNFunc highbd_10_mse16x8_sse2 = vpx_highbd_10_mse16x8_sse2; +const VarianceMxNFunc highbd_10_mse8x16_sse2 = vpx_highbd_10_mse8x16_sse2; +const VarianceMxNFunc highbd_10_mse8x8_sse2 = vpx_highbd_10_mse8x8_sse2; + +const VarianceMxNFunc highbd_8_mse16x16_sse2 = vpx_highbd_8_mse16x16_sse2; +const VarianceMxNFunc highbd_8_mse16x8_sse2 = vpx_highbd_8_mse16x8_sse2; +const VarianceMxNFunc highbd_8_mse8x16_sse2 = vpx_highbd_8_mse8x16_sse2; +const VarianceMxNFunc highbd_8_mse8x8_sse2 = vpx_highbd_8_mse8x8_sse2; -// ----------------------------------------------------------------------------- -// VP9 test cases. +INSTANTIATE_TEST_CASE_P( + SSE2, VpxHBDMseTest, ::testing::Values(make_tuple(4, 4, highbd_12_mse16x16_sse2), + make_tuple(4, 3, highbd_12_mse16x8_sse2), + make_tuple(3, 4, highbd_12_mse8x16_sse2), + make_tuple(3, 3, highbd_12_mse8x8_sse2), + make_tuple(4, 4, highbd_10_mse16x16_sse2), + make_tuple(4, 3, highbd_10_mse16x8_sse2), + make_tuple(3, 4, highbd_10_mse8x16_sse2), + make_tuple(3, 3, highbd_10_mse8x8_sse2), + make_tuple(4, 4, highbd_8_mse16x16_sse2), + make_tuple(4, 3, highbd_8_mse16x8_sse2), + make_tuple(3, 4, highbd_8_mse8x16_sse2), + make_tuple(3, 3, highbd_8_mse8x8_sse2))); +*/ + +const VarianceMxNFunc highbd_12_variance64x64_sse2 = + vpx_highbd_12_variance64x64_sse2; +const VarianceMxNFunc highbd_12_variance64x32_sse2 = + vpx_highbd_12_variance64x32_sse2; +const VarianceMxNFunc highbd_12_variance32x64_sse2 = + vpx_highbd_12_variance32x64_sse2; +const VarianceMxNFunc highbd_12_variance32x32_sse2 = + vpx_highbd_12_variance32x32_sse2; +const VarianceMxNFunc highbd_12_variance32x16_sse2 = + vpx_highbd_12_variance32x16_sse2; +const VarianceMxNFunc highbd_12_variance16x32_sse2 = + vpx_highbd_12_variance16x32_sse2; +const VarianceMxNFunc highbd_12_variance16x16_sse2 = + vpx_highbd_12_variance16x16_sse2; +const VarianceMxNFunc highbd_12_variance16x8_sse2 = + vpx_highbd_12_variance16x8_sse2; +const VarianceMxNFunc highbd_12_variance8x16_sse2 = + vpx_highbd_12_variance8x16_sse2; +const VarianceMxNFunc highbd_12_variance8x8_sse2 = + vpx_highbd_12_variance8x8_sse2; +const VarianceMxNFunc highbd_10_variance64x64_sse2 = + vpx_highbd_10_variance64x64_sse2; +const VarianceMxNFunc highbd_10_variance64x32_sse2 = + vpx_highbd_10_variance64x32_sse2; +const VarianceMxNFunc highbd_10_variance32x64_sse2 = + vpx_highbd_10_variance32x64_sse2; +const VarianceMxNFunc highbd_10_variance32x32_sse2 = + vpx_highbd_10_variance32x32_sse2; +const VarianceMxNFunc highbd_10_variance32x16_sse2 = + vpx_highbd_10_variance32x16_sse2; +const VarianceMxNFunc highbd_10_variance16x32_sse2 = + vpx_highbd_10_variance16x32_sse2; +const VarianceMxNFunc highbd_10_variance16x16_sse2 = + vpx_highbd_10_variance16x16_sse2; +const VarianceMxNFunc highbd_10_variance16x8_sse2 = + vpx_highbd_10_variance16x8_sse2; +const VarianceMxNFunc highbd_10_variance8x16_sse2 = + vpx_highbd_10_variance8x16_sse2; +const VarianceMxNFunc highbd_10_variance8x8_sse2 = + vpx_highbd_10_variance8x8_sse2; +const VarianceMxNFunc highbd_8_variance64x64_sse2 = + vpx_highbd_8_variance64x64_sse2; +const VarianceMxNFunc highbd_8_variance64x32_sse2 = + vpx_highbd_8_variance64x32_sse2; +const VarianceMxNFunc highbd_8_variance32x64_sse2 = + vpx_highbd_8_variance32x64_sse2; +const VarianceMxNFunc highbd_8_variance32x32_sse2 = + vpx_highbd_8_variance32x32_sse2; +const VarianceMxNFunc highbd_8_variance32x16_sse2 = + vpx_highbd_8_variance32x16_sse2; +const VarianceMxNFunc highbd_8_variance16x32_sse2 = + vpx_highbd_8_variance16x32_sse2; +const VarianceMxNFunc highbd_8_variance16x16_sse2 = + vpx_highbd_8_variance16x16_sse2; +const VarianceMxNFunc highbd_8_variance16x8_sse2 = + vpx_highbd_8_variance16x8_sse2; +const VarianceMxNFunc highbd_8_variance8x16_sse2 = + vpx_highbd_8_variance8x16_sse2; +const VarianceMxNFunc highbd_8_variance8x8_sse2 = + vpx_highbd_8_variance8x8_sse2; -namespace vp9 { +INSTANTIATE_TEST_CASE_P( + SSE2, VpxHBDVarianceTest, + ::testing::Values(make_tuple(6, 6, highbd_12_variance64x64_sse2, 12), + make_tuple(6, 5, highbd_12_variance64x32_sse2, 12), + make_tuple(5, 6, highbd_12_variance32x64_sse2, 12), + make_tuple(5, 5, highbd_12_variance32x32_sse2, 12), + make_tuple(5, 4, highbd_12_variance32x16_sse2, 12), + make_tuple(4, 5, highbd_12_variance16x32_sse2, 12), + make_tuple(4, 4, highbd_12_variance16x16_sse2, 12), + make_tuple(4, 3, highbd_12_variance16x8_sse2, 12), + make_tuple(3, 4, highbd_12_variance8x16_sse2, 12), + make_tuple(3, 3, highbd_12_variance8x8_sse2, 12), + make_tuple(6, 6, highbd_10_variance64x64_sse2, 10), + make_tuple(6, 5, highbd_10_variance64x32_sse2, 10), + make_tuple(5, 6, highbd_10_variance32x64_sse2, 10), + make_tuple(5, 5, highbd_10_variance32x32_sse2, 10), + make_tuple(5, 4, highbd_10_variance32x16_sse2, 10), + make_tuple(4, 5, highbd_10_variance16x32_sse2, 10), + make_tuple(4, 4, highbd_10_variance16x16_sse2, 10), + make_tuple(4, 3, highbd_10_variance16x8_sse2, 10), + make_tuple(3, 4, highbd_10_variance8x16_sse2, 10), + make_tuple(3, 3, highbd_10_variance8x8_sse2, 10), + make_tuple(6, 6, highbd_8_variance64x64_sse2, 8), + make_tuple(6, 5, highbd_8_variance64x32_sse2, 8), + make_tuple(5, 6, highbd_8_variance32x64_sse2, 8), + make_tuple(5, 5, highbd_8_variance32x32_sse2, 8), + make_tuple(5, 4, highbd_8_variance32x16_sse2, 8), + make_tuple(4, 5, highbd_8_variance16x32_sse2, 8), + make_tuple(4, 4, highbd_8_variance16x16_sse2, 8), + make_tuple(4, 3, highbd_8_variance16x8_sse2, 8), + make_tuple(3, 4, highbd_8_variance8x16_sse2, 8), + make_tuple(3, 3, highbd_8_variance8x8_sse2, 8))); +#endif // CONFIG_VP9_HIGHBITDEPTH +#endif // HAVE_SSE2 #if CONFIG_VP9_ENCODER -TEST_P(SumOfSquaresTest, Const) { ConstTest(); } -TEST_P(SumOfSquaresTest, Ref) { RefTest(); } - -INSTANTIATE_TEST_CASE_P(C, SumOfSquaresTest, - ::testing::Values(vp9_get_mb_ss_c)); - -typedef VarianceTest<vp9_variance_fn_t> VP9VarianceTest; typedef SubpelVarianceTest<vp9_subpixvariance_fn_t> VP9SubpelVarianceTest; typedef SubpelVarianceTest<vp9_subp_avg_variance_fn_t> VP9SubpelAvgVarianceTest; -TEST_P(VP9VarianceTest, Zero) { ZeroTest(); } -TEST_P(VP9VarianceTest, Ref) { RefTest(); } -TEST_P(VP9VarianceTest, RefStride) { RefStrideTest(); } TEST_P(VP9SubpelVarianceTest, Ref) { RefTest(); } TEST_P(VP9SubpelVarianceTest, ExtremeRef) { ExtremeRefTest(); } TEST_P(VP9SubpelAvgVarianceTest, Ref) { RefTest(); } -TEST_P(VP9VarianceTest, OneQuarter) { OneQuarterTest(); } #if CONFIG_VP9_HIGHBITDEPTH -typedef VarianceTest<vp9_variance_fn_t> VP9VarianceHighTest; typedef SubpelVarianceTest<vp9_subpixvariance_fn_t> VP9SubpelVarianceHighTest; typedef SubpelVarianceTest<vp9_subp_avg_variance_fn_t> VP9SubpelAvgVarianceHighTest; -TEST_P(VP9VarianceHighTest, Zero) { ZeroTest(); } -TEST_P(VP9VarianceHighTest, Ref) { RefTest(); } -TEST_P(VP9VarianceHighTest, RefStride) { RefStrideTest(); } TEST_P(VP9SubpelVarianceHighTest, Ref) { RefTest(); } TEST_P(VP9SubpelVarianceHighTest, ExtremeRef) { ExtremeRefTest(); } TEST_P(VP9SubpelAvgVarianceHighTest, Ref) { RefTest(); } -TEST_P(VP9VarianceHighTest, OneQuarter) { OneQuarterTest(); } #endif // CONFIG_VP9_HIGHBITDEPTH -const vp9_variance_fn_t variance4x4_c = vp9_variance4x4_c; -const vp9_variance_fn_t variance4x8_c = vp9_variance4x8_c; -const vp9_variance_fn_t variance8x4_c = vp9_variance8x4_c; -const vp9_variance_fn_t variance8x8_c = vp9_variance8x8_c; -const vp9_variance_fn_t variance8x16_c = vp9_variance8x16_c; -const vp9_variance_fn_t variance16x8_c = vp9_variance16x8_c; -const vp9_variance_fn_t variance16x16_c = vp9_variance16x16_c; -const vp9_variance_fn_t variance16x32_c = vp9_variance16x32_c; -const vp9_variance_fn_t variance32x16_c = vp9_variance32x16_c; -const vp9_variance_fn_t variance32x32_c = vp9_variance32x32_c; -const vp9_variance_fn_t variance32x64_c = vp9_variance32x64_c; -const vp9_variance_fn_t variance64x32_c = vp9_variance64x32_c; -const vp9_variance_fn_t variance64x64_c = vp9_variance64x64_c; -INSTANTIATE_TEST_CASE_P( - C, VP9VarianceTest, - ::testing::Values(make_tuple(2, 2, variance4x4_c, 0), - make_tuple(2, 3, variance4x8_c, 0), - make_tuple(3, 2, variance8x4_c, 0), - make_tuple(3, 3, variance8x8_c, 0), - make_tuple(3, 4, variance8x16_c, 0), - make_tuple(4, 3, variance16x8_c, 0), - make_tuple(4, 4, variance16x16_c, 0), - make_tuple(4, 5, variance16x32_c, 0), - make_tuple(5, 4, variance32x16_c, 0), - make_tuple(5, 5, variance32x32_c, 0), - make_tuple(5, 6, variance32x64_c, 0), - make_tuple(6, 5, variance64x32_c, 0), - make_tuple(6, 6, variance64x64_c, 0))); -#if CONFIG_VP9_HIGHBITDEPTH -const vp9_variance_fn_t highbd_10_variance4x4_c = vp9_highbd_10_variance4x4_c; -const vp9_variance_fn_t highbd_10_variance4x8_c = vp9_highbd_10_variance4x8_c; -const vp9_variance_fn_t highbd_10_variance8x4_c = vp9_highbd_10_variance8x4_c; -const vp9_variance_fn_t highbd_10_variance8x8_c = vp9_highbd_10_variance8x8_c; -const vp9_variance_fn_t highbd_10_variance8x16_c = vp9_highbd_10_variance8x16_c; -const vp9_variance_fn_t highbd_10_variance16x8_c = vp9_highbd_10_variance16x8_c; -const vp9_variance_fn_t highbd_10_variance16x16_c = - vp9_highbd_10_variance16x16_c; -const vp9_variance_fn_t highbd_10_variance16x32_c = - vp9_highbd_10_variance16x32_c; -const vp9_variance_fn_t highbd_10_variance32x16_c = - vp9_highbd_10_variance32x16_c; -const vp9_variance_fn_t highbd_10_variance32x32_c = - vp9_highbd_10_variance32x32_c; -const vp9_variance_fn_t highbd_10_variance32x64_c = - vp9_highbd_10_variance32x64_c; -const vp9_variance_fn_t highbd_10_variance64x32_c = - vp9_highbd_10_variance64x32_c; -const vp9_variance_fn_t highbd_10_variance64x64_c = - vp9_highbd_10_variance64x64_c; -const vp9_variance_fn_t highbd_12_variance4x4_c = vp9_highbd_12_variance4x4_c; -const vp9_variance_fn_t highbd_12_variance4x8_c = vp9_highbd_12_variance4x8_c; -const vp9_variance_fn_t highbd_12_variance8x4_c = vp9_highbd_12_variance8x4_c; -const vp9_variance_fn_t highbd_12_variance8x8_c = vp9_highbd_12_variance8x8_c; -const vp9_variance_fn_t highbd_12_variance8x16_c = vp9_highbd_12_variance8x16_c; -const vp9_variance_fn_t highbd_12_variance16x8_c = vp9_highbd_12_variance16x8_c; -const vp9_variance_fn_t highbd_12_variance16x16_c = - vp9_highbd_12_variance16x16_c; -const vp9_variance_fn_t highbd_12_variance16x32_c = - vp9_highbd_12_variance16x32_c; -const vp9_variance_fn_t highbd_12_variance32x16_c = - vp9_highbd_12_variance32x16_c; -const vp9_variance_fn_t highbd_12_variance32x32_c = - vp9_highbd_12_variance32x32_c; -const vp9_variance_fn_t highbd_12_variance32x64_c = - vp9_highbd_12_variance32x64_c; -const vp9_variance_fn_t highbd_12_variance64x32_c = - vp9_highbd_12_variance64x32_c; -const vp9_variance_fn_t highbd_12_variance64x64_c = - vp9_highbd_12_variance64x64_c; -const vp9_variance_fn_t highbd_variance4x4_c = vp9_highbd_variance4x4_c; -const vp9_variance_fn_t highbd_variance4x8_c = vp9_highbd_variance4x8_c; -const vp9_variance_fn_t highbd_variance8x4_c = vp9_highbd_variance8x4_c; -const vp9_variance_fn_t highbd_variance8x8_c = vp9_highbd_variance8x8_c; -const vp9_variance_fn_t highbd_variance8x16_c = vp9_highbd_variance8x16_c; -const vp9_variance_fn_t highbd_variance16x8_c = vp9_highbd_variance16x8_c; -const vp9_variance_fn_t highbd_variance16x16_c = vp9_highbd_variance16x16_c; -const vp9_variance_fn_t highbd_variance16x32_c = vp9_highbd_variance16x32_c; -const vp9_variance_fn_t highbd_variance32x16_c = vp9_highbd_variance32x16_c; -const vp9_variance_fn_t highbd_variance32x32_c = vp9_highbd_variance32x32_c; -const vp9_variance_fn_t highbd_variance32x64_c = vp9_highbd_variance32x64_c; -const vp9_variance_fn_t highbd_variance64x32_c = vp9_highbd_variance64x32_c; -const vp9_variance_fn_t highbd_variance64x64_c = vp9_highbd_variance64x64_c; -INSTANTIATE_TEST_CASE_P( - C, VP9VarianceHighTest, - ::testing::Values(make_tuple(2, 2, highbd_10_variance4x4_c, 10), - make_tuple(2, 3, highbd_10_variance4x8_c, 10), - make_tuple(3, 2, highbd_10_variance8x4_c, 10), - make_tuple(3, 3, highbd_10_variance8x8_c, 10), - make_tuple(3, 4, highbd_10_variance8x16_c, 10), - make_tuple(4, 3, highbd_10_variance16x8_c, 10), - make_tuple(4, 4, highbd_10_variance16x16_c, 10), - make_tuple(4, 5, highbd_10_variance16x32_c, 10), - make_tuple(5, 4, highbd_10_variance32x16_c, 10), - make_tuple(5, 5, highbd_10_variance32x32_c, 10), - make_tuple(5, 6, highbd_10_variance32x64_c, 10), - make_tuple(6, 5, highbd_10_variance64x32_c, 10), - make_tuple(6, 6, highbd_10_variance64x64_c, 10), - make_tuple(2, 2, highbd_12_variance4x4_c, 12), - make_tuple(2, 3, highbd_12_variance4x8_c, 12), - make_tuple(3, 2, highbd_12_variance8x4_c, 12), - make_tuple(3, 3, highbd_12_variance8x8_c, 12), - make_tuple(3, 4, highbd_12_variance8x16_c, 12), - make_tuple(4, 3, highbd_12_variance16x8_c, 12), - make_tuple(4, 4, highbd_12_variance16x16_c, 12), - make_tuple(4, 5, highbd_12_variance16x32_c, 12), - make_tuple(5, 4, highbd_12_variance32x16_c, 12), - make_tuple(5, 5, highbd_12_variance32x32_c, 12), - make_tuple(5, 6, highbd_12_variance32x64_c, 12), - make_tuple(6, 5, highbd_12_variance64x32_c, 12), - make_tuple(6, 6, highbd_12_variance64x64_c, 12), - make_tuple(2, 2, highbd_variance4x4_c, 8), - make_tuple(2, 3, highbd_variance4x8_c, 8), - make_tuple(3, 2, highbd_variance8x4_c, 8), - make_tuple(3, 3, highbd_variance8x8_c, 8), - make_tuple(3, 4, highbd_variance8x16_c, 8), - make_tuple(4, 3, highbd_variance16x8_c, 8), - make_tuple(4, 4, highbd_variance16x16_c, 8), - make_tuple(4, 5, highbd_variance16x32_c, 8), - make_tuple(5, 4, highbd_variance32x16_c, 8), - make_tuple(5, 5, highbd_variance32x32_c, 8), - make_tuple(5, 6, highbd_variance32x64_c, 8), - make_tuple(6, 5, highbd_variance64x32_c, 8), - make_tuple(6, 6, highbd_variance64x64_c, 8))); -#endif // CONFIG_VP9_HIGHBITDEPTH const vp9_subpixvariance_fn_t subpel_variance4x4_c = vp9_sub_pixel_variance4x4_c; const vp9_subpixvariance_fn_t subpel_variance4x8_c = @@ -1377,40 +1413,11 @@ INSTANTIATE_TEST_CASE_P( make_tuple(6, 5, highbd_subpel_avg_variance64x32_c, 8), make_tuple(6, 6, highbd_subpel_avg_variance64x64_c, 8))); #endif // CONFIG_VP9_HIGHBITDEPTH +#endif // CONFIG_VP9_ENCODER +#if CONFIG_VP9_ENCODER #if HAVE_SSE2 #if CONFIG_USE_X86INC -INSTANTIATE_TEST_CASE_P(SSE2, SumOfSquaresTest, - ::testing::Values(vp9_get_mb_ss_sse2)); - -const vp9_variance_fn_t variance4x4_sse2 = vp9_variance4x4_sse2; -const vp9_variance_fn_t variance4x8_sse2 = vp9_variance4x8_sse2; -const vp9_variance_fn_t variance8x4_sse2 = vp9_variance8x4_sse2; -const vp9_variance_fn_t variance8x8_sse2 = vp9_variance8x8_sse2; -const vp9_variance_fn_t variance8x16_sse2 = vp9_variance8x16_sse2; -const vp9_variance_fn_t variance16x8_sse2 = vp9_variance16x8_sse2; -const vp9_variance_fn_t variance16x16_sse2 = vp9_variance16x16_sse2; -const vp9_variance_fn_t variance16x32_sse2 = vp9_variance16x32_sse2; -const vp9_variance_fn_t variance32x16_sse2 = vp9_variance32x16_sse2; -const vp9_variance_fn_t variance32x32_sse2 = vp9_variance32x32_sse2; -const vp9_variance_fn_t variance32x64_sse2 = vp9_variance32x64_sse2; -const vp9_variance_fn_t variance64x32_sse2 = vp9_variance64x32_sse2; -const vp9_variance_fn_t variance64x64_sse2 = vp9_variance64x64_sse2; -INSTANTIATE_TEST_CASE_P( - SSE2, VP9VarianceTest, - ::testing::Values(make_tuple(2, 2, variance4x4_sse2, 0), - make_tuple(2, 3, variance4x8_sse2, 0), - make_tuple(3, 2, variance8x4_sse2, 0), - make_tuple(3, 3, variance8x8_sse2, 0), - make_tuple(3, 4, variance8x16_sse2, 0), - make_tuple(4, 3, variance16x8_sse2, 0), - make_tuple(4, 4, variance16x16_sse2, 0), - make_tuple(4, 5, variance16x32_sse2, 0), - make_tuple(5, 4, variance32x16_sse2, 0), - make_tuple(5, 5, variance32x32_sse2, 0), - make_tuple(5, 6, variance32x64_sse2, 0), - make_tuple(6, 5, variance64x32_sse2, 0), - make_tuple(6, 6, variance64x64_sse2, 0))); const vp9_subpixvariance_fn_t subpel_variance4x4_sse = vp9_sub_pixel_variance4x4_sse; const vp9_subpixvariance_fn_t subpel_variance4x8_sse = @@ -1494,96 +1501,6 @@ INSTANTIATE_TEST_CASE_P( make_tuple(6, 5, subpel_avg_variance64x32_sse2, 0), make_tuple(6, 6, subpel_avg_variance64x64_sse2, 0))); #if CONFIG_VP9_HIGHBITDEPTH -const vp9_variance_fn_t highbd_variance8x8_sse2 = vp9_highbd_variance8x8_sse2; -const vp9_variance_fn_t highbd_10_variance8x8_sse2 = - vp9_highbd_10_variance8x8_sse2; -const vp9_variance_fn_t highbd_12_variance8x8_sse2 = - vp9_highbd_12_variance8x8_sse2; -const vp9_variance_fn_t highbd_variance8x16_sse2 = vp9_highbd_variance8x16_sse2; -const vp9_variance_fn_t highbd_10_variance8x16_sse2 = - vp9_highbd_10_variance8x16_sse2; -const vp9_variance_fn_t highbd_12_variance8x16_sse2 = - vp9_highbd_12_variance8x16_sse2; -const vp9_variance_fn_t highbd_variance16x8_sse2 = - vp9_highbd_variance16x8_sse2; -const vp9_variance_fn_t highbd_10_variance16x8_sse2 = - vp9_highbd_10_variance16x8_sse2; -const vp9_variance_fn_t highbd_12_variance16x8_sse2 = - vp9_highbd_12_variance16x8_sse2; -const vp9_variance_fn_t highbd_variance16x16_sse2 = - vp9_highbd_variance16x16_sse2; -const vp9_variance_fn_t highbd_10_variance16x16_sse2 = - vp9_highbd_10_variance16x16_sse2; -const vp9_variance_fn_t highbd_12_variance16x16_sse2 = - vp9_highbd_12_variance16x16_sse2; -const vp9_variance_fn_t highbd_variance16x32_sse2 = - vp9_highbd_variance16x32_sse2; -const vp9_variance_fn_t highbd_10_variance16x32_sse2 = - vp9_highbd_10_variance16x32_sse2; -const vp9_variance_fn_t highbd_12_variance16x32_sse2 = - vp9_highbd_12_variance16x32_sse2; -const vp9_variance_fn_t highbd_variance32x16_sse2 = - vp9_highbd_variance32x16_sse2; -const vp9_variance_fn_t highbd_10_variance32x16_sse2 = - vp9_highbd_10_variance32x16_sse2; -const vp9_variance_fn_t highbd_12_variance32x16_sse2 = - vp9_highbd_12_variance32x16_sse2; -const vp9_variance_fn_t highbd_variance32x32_sse2 = - vp9_highbd_variance32x32_sse2; -const vp9_variance_fn_t highbd_10_variance32x32_sse2 = - vp9_highbd_10_variance32x32_sse2; -const vp9_variance_fn_t highbd_12_variance32x32_sse2 = - vp9_highbd_12_variance32x32_sse2; -const vp9_variance_fn_t highbd_variance32x64_sse2 = - vp9_highbd_variance32x64_sse2; -const vp9_variance_fn_t highbd_10_variance32x64_sse2 = - vp9_highbd_10_variance32x64_sse2; -const vp9_variance_fn_t highbd_12_variance32x64_sse2 = - vp9_highbd_12_variance32x64_sse2; -const vp9_variance_fn_t highbd_variance64x32_sse2 = - vp9_highbd_variance64x32_sse2; -const vp9_variance_fn_t highbd_10_variance64x32_sse2 = - vp9_highbd_10_variance64x32_sse2; -const vp9_variance_fn_t highbd_12_variance64x32_sse2 = - vp9_highbd_12_variance64x32_sse2; -const vp9_variance_fn_t highbd_variance64x64_sse2 = - vp9_highbd_variance64x64_sse2; -const vp9_variance_fn_t highbd_10_variance64x64_sse2 = - vp9_highbd_10_variance64x64_sse2; -const vp9_variance_fn_t highbd_12_variance64x64_sse2 = - vp9_highbd_12_variance64x64_sse2; -INSTANTIATE_TEST_CASE_P( - SSE2, VP9VarianceHighTest, - ::testing::Values(make_tuple(3, 3, highbd_10_variance8x8_sse2, 10), - make_tuple(3, 4, highbd_10_variance8x16_sse2, 10), - make_tuple(4, 3, highbd_10_variance16x8_sse2, 10), - make_tuple(4, 4, highbd_10_variance16x16_sse2, 10), - make_tuple(4, 5, highbd_10_variance16x32_sse2, 10), - make_tuple(5, 4, highbd_10_variance32x16_sse2, 10), - make_tuple(5, 5, highbd_10_variance32x32_sse2, 10), - make_tuple(5, 6, highbd_10_variance32x64_sse2, 10), - make_tuple(6, 5, highbd_10_variance64x32_sse2, 10), - make_tuple(6, 6, highbd_10_variance64x64_sse2, 10), - make_tuple(3, 3, highbd_12_variance8x8_sse2, 12), - make_tuple(3, 4, highbd_12_variance8x16_sse2, 12), - make_tuple(4, 3, highbd_12_variance16x8_sse2, 12), - make_tuple(4, 4, highbd_12_variance16x16_sse2, 12), - make_tuple(4, 5, highbd_12_variance16x32_sse2, 12), - make_tuple(5, 4, highbd_12_variance32x16_sse2, 12), - make_tuple(5, 5, highbd_12_variance32x32_sse2, 12), - make_tuple(5, 6, highbd_12_variance32x64_sse2, 12), - make_tuple(6, 5, highbd_12_variance64x32_sse2, 12), - make_tuple(6, 6, highbd_12_variance64x64_sse2, 12), - make_tuple(3, 3, highbd_variance8x8_sse2, 8), - make_tuple(3, 4, highbd_variance8x16_sse2, 8), - make_tuple(4, 3, highbd_variance16x8_sse2, 8), - make_tuple(4, 4, highbd_variance16x16_sse2, 8), - make_tuple(4, 5, highbd_variance16x32_sse2, 8), - make_tuple(5, 4, highbd_variance32x16_sse2, 8), - make_tuple(5, 5, highbd_variance32x32_sse2, 8), - make_tuple(5, 6, highbd_variance32x64_sse2, 8), - make_tuple(6, 5, highbd_variance64x32_sse2, 8), - make_tuple(6, 6, highbd_variance64x64_sse2, 8))); const vp9_subpixvariance_fn_t highbd_subpel_variance8x4_sse2 = vp9_highbd_sub_pixel_variance8x4_sse2; const vp9_subpixvariance_fn_t highbd_subpel_variance8x8_sse2 = @@ -1790,6 +1707,9 @@ INSTANTIATE_TEST_CASE_P( #endif // CONFIG_VP9_HIGHBITDEPTH #endif // CONFIG_USE_X86INC #endif // HAVE_SSE2 +#endif // CONFIG_VP9_ENCODER + +#if CONFIG_VP9_ENCODER #if HAVE_SSSE3 #if CONFIG_USE_X86INC @@ -1877,22 +1797,27 @@ INSTANTIATE_TEST_CASE_P( make_tuple(6, 6, subpel_avg_variance64x64_ssse3, 0))); #endif // CONFIG_USE_X86INC #endif // HAVE_SSSE3 +#endif // CONFIG_VP9_ENCODER #if HAVE_AVX2 - -const vp9_variance_fn_t variance16x16_avx2 = vp9_variance16x16_avx2; -const vp9_variance_fn_t variance32x16_avx2 = vp9_variance32x16_avx2; -const vp9_variance_fn_t variance32x32_avx2 = vp9_variance32x32_avx2; -const vp9_variance_fn_t variance64x32_avx2 = vp9_variance64x32_avx2; -const vp9_variance_fn_t variance64x64_avx2 = vp9_variance64x64_avx2; +const VarianceMxNFunc mse16x16_avx2 = vpx_mse16x16_avx2; +INSTANTIATE_TEST_CASE_P(AVX2, VpxMseTest, + ::testing::Values(make_tuple(4, 4, mse16x16_avx2))); + +const VarianceMxNFunc variance64x64_avx2 = vpx_variance64x64_avx2; +const VarianceMxNFunc variance64x32_avx2 = vpx_variance64x32_avx2; +const VarianceMxNFunc variance32x32_avx2 = vpx_variance32x32_avx2; +const VarianceMxNFunc variance32x16_avx2 = vpx_variance32x16_avx2; +const VarianceMxNFunc variance16x16_avx2 = vpx_variance16x16_avx2; INSTANTIATE_TEST_CASE_P( - AVX2, VP9VarianceTest, - ::testing::Values(make_tuple(4, 4, variance16x16_avx2, 0), - make_tuple(5, 4, variance32x16_avx2, 0), - make_tuple(5, 5, variance32x32_avx2, 0), + AVX2, VpxVarianceTest, + ::testing::Values(make_tuple(6, 6, variance64x64_avx2, 0), make_tuple(6, 5, variance64x32_avx2, 0), - make_tuple(6, 6, variance64x64_avx2, 0))); + make_tuple(5, 5, variance32x32_avx2, 0), + make_tuple(5, 4, variance32x16_avx2, 0), + make_tuple(4, 4, variance16x16_avx2, 0))); +#if CONFIG_VP9_ENCODER const vp9_subpixvariance_fn_t subpel_variance32x32_avx2 = vp9_sub_pixel_variance32x32_avx2; const vp9_subpixvariance_fn_t subpel_variance64x64_avx2 = @@ -1910,23 +1835,38 @@ INSTANTIATE_TEST_CASE_P( AVX2, VP9SubpelAvgVarianceTest, ::testing::Values(make_tuple(5, 5, subpel_avg_variance32x32_avx2, 0), make_tuple(6, 6, subpel_avg_variance64x64_avx2, 0))); +#endif // CONFIG_VP9_ENCODER #endif // HAVE_AVX2 + #if HAVE_NEON -const vp9_variance_fn_t variance8x8_neon = vp9_variance8x8_neon; -const vp9_variance_fn_t variance16x16_neon = vp9_variance16x16_neon; -const vp9_variance_fn_t variance32x32_neon = vp9_variance32x32_neon; -const vp9_variance_fn_t variance32x64_neon = vp9_variance32x64_neon; -const vp9_variance_fn_t variance64x32_neon = vp9_variance64x32_neon; -const vp9_variance_fn_t variance64x64_neon = vp9_variance64x64_neon; +const Get4x4SSEFunc get4x4sse_cs_neon = vpx_get4x4sse_cs_neon; +INSTANTIATE_TEST_CASE_P(NEON, VpxSseTest, + ::testing::Values(make_tuple(2, 2, get4x4sse_cs_neon))); + +const VarianceMxNFunc mse16x16_neon = vpx_mse16x16_neon; +INSTANTIATE_TEST_CASE_P(NEON, VpxMseTest, + ::testing::Values(make_tuple(4, 4, mse16x16_neon))); + +const VarianceMxNFunc variance64x64_neon = vpx_variance64x64_neon; +const VarianceMxNFunc variance64x32_neon = vpx_variance64x32_neon; +const VarianceMxNFunc variance32x64_neon = vpx_variance32x64_neon; +const VarianceMxNFunc variance32x32_neon = vpx_variance32x32_neon; +const VarianceMxNFunc variance16x16_neon = vpx_variance16x16_neon; +const VarianceMxNFunc variance16x8_neon = vpx_variance16x8_neon; +const VarianceMxNFunc variance8x16_neon = vpx_variance8x16_neon; +const VarianceMxNFunc variance8x8_neon = vpx_variance8x8_neon; INSTANTIATE_TEST_CASE_P( - NEON, VP9VarianceTest, - ::testing::Values(make_tuple(3, 3, variance8x8_neon, 0), - make_tuple(4, 4, variance16x16_neon, 0), - make_tuple(5, 5, variance32x32_neon, 0), - make_tuple(5, 6, variance32x64_neon, 0), + NEON, VpxVarianceTest, + ::testing::Values(make_tuple(6, 6, variance64x64_neon, 0), make_tuple(6, 5, variance64x32_neon, 0), - make_tuple(6, 6, variance64x64_neon, 0))); + make_tuple(5, 6, variance32x64_neon, 0), + make_tuple(5, 5, variance32x32_neon, 0), + make_tuple(4, 4, variance16x16_neon, 0), + make_tuple(4, 4, variance16x8_neon, 0), + make_tuple(4, 4, variance8x16_neon, 0), + make_tuple(3, 3, variance8x8_neon, 0))); +#if CONFIG_VP9_ENCODER const vp9_subpixvariance_fn_t subpel_variance8x8_neon = vp9_sub_pixel_variance8x8_neon; const vp9_subpixvariance_fn_t subpel_variance16x16_neon = @@ -1941,8 +1881,19 @@ INSTANTIATE_TEST_CASE_P( make_tuple(4, 4, subpel_variance16x16_neon, 0), make_tuple(5, 5, subpel_variance32x32_neon, 0), make_tuple(6, 6, subpel_variance64x64_neon, 0))); -#endif // HAVE_NEON #endif // CONFIG_VP9_ENCODER +#endif // HAVE_NEON -} // namespace vp9 +#if HAVE_MEDIA +const VarianceMxNFunc mse16x16_media = vpx_mse16x16_media; +INSTANTIATE_TEST_CASE_P(MEDIA, VpxMseTest, + ::testing::Values(make_tuple(4, 4, mse16x16_media))); + +const VarianceMxNFunc variance16x16_media = vpx_variance16x16_media; +const VarianceMxNFunc variance8x8_media = vpx_variance8x8_media; +INSTANTIATE_TEST_CASE_P( + MEDIA, VpxVarianceTest, + ::testing::Values(make_tuple(4, 4, variance16x16_media, 0), + make_tuple(3, 3, variance8x8_media, 0))); +#endif // HAVE_MEDIA } // namespace |