From 090aa88b5a0456c4011a5bf1643bc7c01b7d2b8c Mon Sep 17 00:00:00 2001 From: James Zern Date: Sat, 16 Jul 2016 11:54:21 -0700 Subject: [PATCH] Revert "variance_test partial clean-up" This reverts commit f993ed5c86217e31b92ecc7ef58d7d7860b80108. build warnings under msvc, segfaults with high-bitdepth enabled. Change-Id: I67502651107830bcadb6ef56d8f2709cccbfdf2b --- test/variance_test.cc | 935 ++++++++++++++++++++++-------------------- 1 file changed, 479 insertions(+), 456 deletions(-) diff --git a/test/variance_test.cc b/test/variance_test.cc index 2b6808075..08c84a613 100644 --- a/test/variance_test.cc +++ b/test/variance_test.cc @@ -41,6 +41,10 @@ typedef unsigned int (*Get4x4SseFunc)(const uint8_t *a, int a_stride, const uint8_t *b, int b_stride); typedef unsigned int (*SumOfSquaresFunction)(const int16_t *src); + +using ::std::tr1::get; +using ::std::tr1::make_tuple; +using ::std::tr1::tuple; using libvpx_test::ACMRandom; // Truncate high bit depth results by downshifting (with rounding) by: @@ -75,8 +79,8 @@ static unsigned int mb_ss_ref(const int16_t *src) { * (src - ref). */ static uint32_t variance_ref(const uint8_t *src, const uint8_t *ref, - int l2w, int l2h, int src_stride, - int ref_stride, uint32_t *sse_ptr, + int l2w, int l2h, int src_stride_coeff, + int ref_stride_coeff, uint32_t *sse_ptr, bool use_high_bit_depth_, vpx_bit_depth_t bit_depth) { int64_t se = 0; @@ -87,14 +91,14 @@ static uint32_t variance_ref(const uint8_t *src, const uint8_t *ref, for (int x = 0; x < w; x++) { int diff; if (!use_high_bit_depth_) { - diff = src[y * src_stride + x] - - ref[y * ref_stride + x]; + diff = src[w * y * src_stride_coeff + x] - + ref[w * y * ref_stride_coeff + x]; se += diff; sse += diff * diff; #if CONFIG_VP9_HIGHBITDEPTH } else { - diff = CONVERT_TO_SHORTPTR(src)[y * src_stride + x] - - CONVERT_TO_SHORTPTR(ref)[y * ref_stride + x]; + diff = CONVERT_TO_SHORTPTR(src)[w * y * src_stride_coeff + x] - + CONVERT_TO_SHORTPTR(ref)[w * y * ref_stride_coeff + x]; se += diff; sse += diff * diff; #endif // CONFIG_VP9_HIGHBITDEPTH @@ -166,65 +170,6 @@ static uint32_t subpel_variance_ref(const uint8_t *ref, const uint8_t *src, (l2w + l2h))); } -static uint32_t subpel_avg_variance_ref(const uint8_t *ref, - const uint8_t *src, - const uint8_t *second_pred, - int l2w, int l2h, - int xoff, int yoff, - uint32_t *sse_ptr, - bool use_high_bit_depth, - vpx_bit_depth_t bit_depth) { - int64_t se = 0; - 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++) { - // bilinear interpolation at a 16th pel step - 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 + 8) >> 4); - 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 { - const uint16_t *ref16 = CONVERT_TO_SHORTPTR(ref); - const uint16_t *src16 = CONVERT_TO_SHORTPTR(src); - const uint16_t *sec16 = CONVERT_TO_SHORTPTR(second_pred); - const int a1 = ref16[(w + 1) * (y + 0) + x + 0]; - const int a2 = ref16[(w + 1) * (y + 0) + x + 1]; - const int b1 = ref16[(w + 1) * (y + 1) + x + 0]; - const int b2 = ref16[(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 + sec16[w * y + x] + 1) >> 1) - src16[w * y + x]; - se += diff; - sse += diff * diff; -#endif // CONFIG_VP9_HIGHBITDEPTH - } - } - } - RoundHighBitDepth(bit_depth, &se, &sse); - *sse_ptr = static_cast(sse); - return static_cast(sse - - ((static_cast(se) * se) >> - (l2w + l2h))); -} - -//////////////////////////////////////////////////////////////////////////////// - class SumOfSquaresTest : public ::testing::TestWithParam { public: SumOfSquaresTest() : func_(GetParam()) {} @@ -267,50 +212,206 @@ void SumOfSquaresTest::RefTest() { } } -//////////////////////////////////////////////////////////////////////////////// -// Encapsulating struct to store the function to test along with -// some testing context. -// Can be used for MSE, SSE, Variance, etc. -template -struct TestParams { - TestParams(int log2w = 0, int log2h = 0, - Func function = NULL, int bit_depth_value = 0) - : log2width(log2w), log2height(log2h), func(function) { - use_high_bit_depth = (bit_depth_value > 0); - if (use_high_bit_depth) { - bit_depth = static_cast(bit_depth_value); - } else { - bit_depth = VPX_BITS_8; - } - width = 1 << log2width; - height = 1 << log2height; - block_size = width * height; - mask = (1u << bit_depth) - 1; - } - - int log2width; - int log2height; - int width, height; - int block_size; - Func func; - vpx_bit_depth_t bit_depth; - int use_high_bit_depth; - uint32_t mask; -}; - -// Main class for testing a function type -template -class MainTestClass : - public ::testing::TestWithParam > { +template +class VarianceTest + : public ::testing::TestWithParam > { public: virtual void SetUp() { - params_ = this->GetParam(); + const tuple& params = this->GetParam(); + log2width_ = get<0>(params); + width_ = 1 << log2width_; + log2height_ = get<1>(params); + height_ = 1 << log2height_; + variance_ = get<2>(params); + if (get<3>(params)) { + bit_depth_ = static_cast(get<3>(params)); + use_high_bit_depth_ = true; + } else { + bit_depth_ = VPX_BITS_8; + use_high_bit_depth_ = false; + } + mask_ = (1 << bit_depth_) - 1; rnd_.Reset(ACMRandom::DeterministicSeed()); - const size_t unit = - use_high_bit_depth() ? sizeof(uint16_t) : sizeof(uint8_t); - src_ = reinterpret_cast(vpx_memalign(16, block_size() * unit)); - ref_ = new uint8_t[block_size() * unit]; + block_size_ = width_ * height_; + if (!use_high_bit_depth_) { + src_ = reinterpret_cast(vpx_memalign(16, block_size_ * 2)); + ref_ = new uint8_t[block_size_ * 2]; +#if CONFIG_VP9_HIGHBITDEPTH + } else { + src_ = CONVERT_TO_BYTEPTR(reinterpret_cast( + vpx_memalign(16, block_size_ * 2 * sizeof(uint16_t)))); + ref_ = CONVERT_TO_BYTEPTR(new uint16_t[block_size_ * 2]); +#endif // CONFIG_VP9_HIGHBITDEPTH + } + ASSERT_TRUE(src_ != NULL); + ASSERT_TRUE(ref_ != NULL); + } + + virtual void TearDown() { + 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 + } + libvpx_test::ClearSystemState(); + } + + protected: + void ZeroTest(); + void RefTest(); + void RefStrideTest(); + void OneQuarterTest(); + + ACMRandom rnd_; + uint8_t *src_; + uint8_t *ref_; + int width_, log2width_; + int height_, log2height_; + vpx_bit_depth_t bit_depth_; + int mask_; + bool use_high_bit_depth_; + int block_size_; + VarianceFunctionType variance_; +}; + +template +void VarianceTest::ZeroTest() { + for (int i = 0; i <= 255; ++i) { + 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 + } + for (int j = 0; j <= 255; ++j) { + 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 + } + unsigned int sse; + unsigned int var; + ASM_REGISTER_STATE_CHECK( + var = variance_(src_, width_, ref_, width_, &sse)); + EXPECT_EQ(0u, var) << "src values: " << i << " ref values: " << j; + } + } +} + +template +void VarianceTest::RefTest() { + for (int i = 0; i < 10; ++i) { + for (int j = 0; j < block_size_; j++) { + 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 + } + } + unsigned int sse1, sse2; + unsigned int var1; + const int stride_coeff = 1; + ASM_REGISTER_STATE_CHECK( + var1 = variance_(src_, width_, ref_, width_, &sse1)); + const unsigned int var2 = variance_ref(src_, ref_, log2width_, + log2height_, stride_coeff, + stride_coeff, &sse2, + use_high_bit_depth_, bit_depth_); + EXPECT_EQ(sse1, sse2) + << "Error at test index: " << i; + EXPECT_EQ(var1, var2) + << "Error at test index: " << i; + } +} + +template +void VarianceTest::RefStrideTest() { + for (int i = 0; i < 10; ++i) { + int ref_stride_coeff = i % 2; + int src_stride_coeff = (i >> 1) % 2; + 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 (!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 + } + } + unsigned int sse1, sse2; + unsigned int var1; + + ASM_REGISTER_STATE_CHECK( + var1 = variance_(src_, width_ * src_stride_coeff, + ref_, width_ * ref_stride_coeff, &sse1)); + const unsigned int var2 = variance_ref(src_, ref_, log2width_, + log2height_, src_stride_coeff, + ref_stride_coeff, &sse2, + use_high_bit_depth_, bit_depth_); + EXPECT_EQ(sse1, sse2) + << "Error at test index: " << i; + EXPECT_EQ(var1, var2) + << "Error at test index: " << i; + } +} + +template +void VarianceTest::OneQuarterTest() { + const int half = block_size_ / 2; + 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 + } + unsigned int sse; + unsigned int var; + ASM_REGISTER_STATE_CHECK(var = variance_(src_, width_, ref_, width_, &sse)); + const unsigned int expected = block_size_ * 255 * 255 / 4; + EXPECT_EQ(expected, var); +} + +template +class MseTest + : public ::testing::TestWithParam > { + public: + virtual void SetUp() { + const tuple& params = this->GetParam(); + log2width_ = get<0>(params); + width_ = 1 << log2width_; + log2height_ = get<1>(params); + height_ = 1 << log2height_; + mse_ = get<2>(params); + + rnd(ACMRandom::DeterministicSeed()); + block_size_ = width_ * height_; + src_ = reinterpret_cast(vpx_memalign(16, block_size_)); + ref_ = new uint8_t[block_size_]; ASSERT_TRUE(src_ != NULL); ASSERT_TRUE(ref_ != NULL); } @@ -318,213 +419,132 @@ class MainTestClass : virtual void TearDown() { vpx_free(src_); delete[] ref_; - src_ = NULL; - ref_ = NULL; libvpx_test::ClearSystemState(); } protected: - // We could sub-class MainTestClass into dedicated class for Variance - // and MSE/SSE, but it involves a lot of 'this->xxx' dereferencing - // to access top class fields xxx. That's cumbersome, so for now we'll just - // implement the testing methods here: + void RefTest_mse(); + void RefTest_sse(); + void MaxTest_mse(); + void MaxTest_sse(); - // Variance tests - void ZeroTest(); - void RefTest(); - void RefStrideTest(); - void OneQuarterTest(); - - // MSE/SSE tests - void RefTestMse(); - void RefTestSse(); - void MaxTestMse(); - void MaxTestSse(); - - protected: - ACMRandom rnd_; - uint8_t *src_; - uint8_t *ref_; - TestParams 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; } - int block_size() const { return params_.block_size; } - int width() const { return params_.width; } - uint32_t mask() const { return params_.mask; } + ACMRandom rnd; + uint8_t* src_; + uint8_t* ref_; + int width_, log2width_; + int height_, log2height_; + int block_size_; + MseFunctionType mse_; }; -//////////////////////////////////////////////////////////////////////////////// -// Tests related to variance. - -template -void MainTestClass::ZeroTest() { - for (int i = 0; i <= 255; ++i) { - if (!use_high_bit_depth()) { - memset(src_, i, block_size()); -#if CONFIG_VP9_HIGHBITDEPTH - } else { - vpx_memset16(CONVERT_TO_SHORTPTR(src_), i << byte_shift(), block_size()); -#endif // CONFIG_VP9_HIGHBITDEPTH - } - for (int j = 0; j <= 255; ++j) { - if (!use_high_bit_depth()) { - memset(ref_, j, block_size()); -#if CONFIG_VP9_HIGHBITDEPTH - } else { - vpx_memset16(CONVERT_TO_SHORTPTR(ref_), - j << byte_shift(), block_size()); -#endif // CONFIG_VP9_HIGHBITDEPTH - } - unsigned int sse, var; - ASM_REGISTER_STATE_CHECK( - var = params_.func(src_, width(), ref_, width(), &sse)); - EXPECT_EQ(0u, var) << "src values: " << i << " ref values: " << j; - } - } -} - -template -void MainTestClass::RefTest() { +template +void MseTest::RefTest_mse() { for (int i = 0; i < 10; ++i) { - for (int j = 0; j < block_size(); j++) { - 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 - } - } - unsigned int sse1, sse2, var1, var2; - const int stride = width(); - ASM_REGISTER_STATE_CHECK( - var1 = params_.func(src_, stride, ref_, stride, &sse1)); - var2 = variance_ref(src_, ref_, params_.log2width, params_.log2height, - stride, stride, &sse2, - use_high_bit_depth(), params_.bit_depth); - EXPECT_EQ(sse1, sse2) << "Error at test index: " << i; - EXPECT_EQ(var1, var2) << "Error at test index: " << i; - } -} - -template -void MainTestClass::RefStrideTest() { - for (int i = 0; i < 10; ++i) { - const int ref_stride = (i & 1) * width(); - const int src_stride = ((i >> 1) & 1) * width(); - for (int j = 0; j < block_size(); j++) { - const int ref_ind = (j / width()) * ref_stride + j % width(); - const int src_ind = (j / width()) * src_stride + j % width(); - 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 - } + for (int j = 0; j < block_size_; j++) { + src_[j] = rnd.Rand8(); + ref_[j] = rnd.Rand8(); } unsigned int sse1, sse2; - unsigned int var1, var2; - - ASM_REGISTER_STATE_CHECK( - var1 = params_.func(src_, src_stride, ref_, ref_stride, &sse1)); - var2 = variance_ref(src_, ref_, - params_.log2width, params_.log2height, - src_stride, ref_stride, &sse2, - use_high_bit_depth(), params_.bit_depth); - EXPECT_EQ(sse1, sse2) << "Error at test index: " << i; - EXPECT_EQ(var1, var2) << "Error at test index: " << i; - } -} - -template -void MainTestClass::OneQuarterTest() { - const int half = block_size() / 2; - 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 << byte_shift(), block_size()); - vpx_memset16(CONVERT_TO_SHORTPTR(ref_), 255 << byte_shift(), half); - vpx_memset16(CONVERT_TO_SHORTPTR(ref_) + half, 0, half); -#endif // CONFIG_VP9_HIGHBITDEPTH - } - unsigned int sse, var, expected; - ASM_REGISTER_STATE_CHECK( - var = params_.func(src_, width(), ref_, width(), &sse)); - expected = block_size() * 255 * 255 / 4; - EXPECT_EQ(expected, var); -} - -//////////////////////////////////////////////////////////////////////////////// -// Tests related to MSE / SSE. - -template -void MainTestClass::RefTestMse() { - for (int i = 0; i < 10; ++i) { - for (int j = 0; j < block_size(); ++j) { - src_[j] = rnd_.Rand8(); - ref_[j] = rnd_.Rand8(); - } - unsigned int sse1, sse2; - const int stride = width(); - ASM_REGISTER_STATE_CHECK(params_.func(src_, stride, ref_, stride, &sse1)); - variance_ref(src_, ref_, params_.log2width, params_.log2height, - stride, stride, &sse2, false, VPX_BITS_8); + const int stride_coeff = 1; + ASM_REGISTER_STATE_CHECK(mse_(src_, width_, ref_, width_, &sse1)); + variance_ref(src_, ref_, log2width_, log2height_, stride_coeff, + stride_coeff, &sse2, false, VPX_BITS_8); EXPECT_EQ(sse1, sse2); } } -template -void MainTestClass::RefTestSse() { +template +void MseTest::RefTest_sse() { for (int i = 0; i < 10; ++i) { - for (int j = 0; j < block_size(); ++j) { - src_[j] = rnd_.Rand8(); - ref_[j] = rnd_.Rand8(); + for (int j = 0; j < block_size_; j++) { + src_[j] = rnd.Rand8(); + ref_[j] = rnd.Rand8(); } unsigned int sse2; unsigned int var1; - const int stride = width(); - ASM_REGISTER_STATE_CHECK(var1 = params_.func(src_, stride, ref_, stride)); - variance_ref(src_, ref_, params_.log2width, params_.log2height, - stride, stride, &sse2, false, VPX_BITS_8); + const int stride_coeff = 1; + ASM_REGISTER_STATE_CHECK(var1 = mse_(src_, width_, ref_, width_)); + variance_ref(src_, ref_, log2width_, log2height_, stride_coeff, + stride_coeff, &sse2, false, VPX_BITS_8); EXPECT_EQ(var1, sse2); } } -template -void MainTestClass::MaxTestMse() { - memset(src_, 255, block_size()); - memset(ref_, 0, block_size()); +template +void MseTest::MaxTest_mse() { + memset(src_, 255, block_size_); + memset(ref_, 0, block_size_); unsigned int sse; - ASM_REGISTER_STATE_CHECK(params_.func(src_, width(), ref_, width(), &sse)); - const unsigned int expected = block_size() * 255 * 255; + ASM_REGISTER_STATE_CHECK(mse_(src_, width_, ref_, width_, &sse)); + const unsigned int expected = block_size_ * 255 * 255; EXPECT_EQ(expected, sse); } -template -void MainTestClass::MaxTestSse() { - memset(src_, 255, block_size()); - memset(ref_, 0, block_size()); +template +void MseTest::MaxTest_sse() { + memset(src_, 255, block_size_); + memset(ref_, 0, block_size_); unsigned int var; - ASM_REGISTER_STATE_CHECK(var = params_.func(src_, width(), ref_, width())); - const unsigned int expected = block_size() * 255 * 255; + ASM_REGISTER_STATE_CHECK(var = mse_(src_, width_, ref_, width_)); + const unsigned int expected = block_size_ * 255 * 255; EXPECT_EQ(expected, var); } -//////////////////////////////////////////////////////////////////////////////// +static uint32_t subpel_avg_variance_ref(const uint8_t *ref, + const uint8_t *src, + const uint8_t *second_pred, + int l2w, int l2h, + int xoff, int yoff, + uint32_t *sse_ptr, + bool use_high_bit_depth, + vpx_bit_depth_t bit_depth) { + int64_t se = 0; + uint64_t sse = 0; + const int w = 1 << l2w; + const int h = 1 << l2h; -using ::std::tr1::get; -using ::std::tr1::make_tuple; -using ::std::tr1::tuple; + xoff <<= 1; + yoff <<= 1; + + for (int y = 0; y < h; y++) { + for (int x = 0; x < w; x++) { + // bilinear interpolation at a 16th pel step + 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 + 8) >> 4); + 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); + uint16_t *sec16 = CONVERT_TO_SHORTPTR(second_pred); + const int a1 = ref16[(w + 1) * (y + 0) + x + 0]; + const int a2 = ref16[(w + 1) * (y + 0) + x + 1]; + const int b1 = ref16[(w + 1) * (y + 1) + x + 0]; + const int b2 = ref16[(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 + sec16[w * y + x] + 1) >> 1) - src16[w * y + x]; + se += diff; + sse += diff * diff; +#endif // CONFIG_VP9_HIGHBITDEPTH + } + } + } + RoundHighBitDepth(bit_depth, &se, &sse); + *sse_ptr = static_cast(sse); + return static_cast(sse - + ((static_cast(se) * se) >> + (l2w + l2h))); +} template class SubpelVarianceTest @@ -696,32 +716,32 @@ void SubpelVarianceTest::RefTest() { } #endif // CONFIG_VP9_HIGHBITDEPTH } - uint32_t sse1, sse2; - uint32_t var1, var2; + unsigned int sse1, sse2; + unsigned int var1; ASM_REGISTER_STATE_CHECK( var1 = subpel_variance_(ref_, width_ + 1, x, y, src_, width_, &sse1, sec_)); - var2 = subpel_avg_variance_ref(ref_, src_, sec_, - log2width_, log2height_, - x, y, &sse2, - use_high_bit_depth_, - static_cast(bit_depth_)); + const unsigned int var2 = subpel_avg_variance_ref(ref_, src_, sec_, + log2width_, log2height_, + x, y, &sse2, + use_high_bit_depth_, + bit_depth_); EXPECT_EQ(sse1, sse2) << "at position " << x << ", " << y; EXPECT_EQ(var1, var2) << "at position " << x << ", " << y; } } } -typedef MainTestClass VpxSseTest; -typedef MainTestClass VpxMseTest; -typedef MainTestClass VpxVarianceTest; +typedef MseTest VpxSseTest; +typedef MseTest VpxMseTest; +typedef VarianceTest VpxVarianceTest; typedef SubpelVarianceTest VpxSubpelVarianceTest; typedef SubpelVarianceTest VpxSubpelAvgVarianceTest; -TEST_P(VpxSseTest, RefSse) { RefTestSse(); } -TEST_P(VpxSseTest, MaxSse) { MaxTestSse(); } -TEST_P(VpxMseTest, RefMse) { RefTestMse(); } -TEST_P(VpxMseTest, MaxMse) { MaxTestMse(); } +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(); } @@ -735,33 +755,31 @@ TEST_P(VpxSubpelAvgVarianceTest, Ref) { RefTest(); } INSTANTIATE_TEST_CASE_P(C, SumOfSquaresTest, ::testing::Values(vpx_get_mb_ss_c)); -typedef TestParams SseParams; INSTANTIATE_TEST_CASE_P(C, VpxSseTest, - ::testing::Values(SseParams(2, 2, &vpx_get4x4sse_cs_c))); + ::testing::Values(make_tuple(2, 2, + &vpx_get4x4sse_cs_c))); -typedef TestParams MseParams; INSTANTIATE_TEST_CASE_P(C, VpxMseTest, - ::testing::Values(MseParams(4, 4, &vpx_mse16x16_c), - MseParams(4, 3, &vpx_mse16x8_c), - MseParams(3, 4, &vpx_mse8x16_c), - MseParams(3, 3, &vpx_mse8x8_c))); + ::testing::Values(make_tuple(4, 4, &vpx_mse16x16_c), + make_tuple(4, 3, &vpx_mse16x8_c), + make_tuple(3, 4, &vpx_mse8x16_c), + make_tuple(3, 3, &vpx_mse8x8_c))); -typedef TestParams VarianceParams; INSTANTIATE_TEST_CASE_P( C, VpxVarianceTest, - ::testing::Values(VarianceParams(6, 6, &vpx_variance64x64_c), - VarianceParams(6, 5, &vpx_variance64x32_c), - VarianceParams(5, 6, &vpx_variance32x64_c), - VarianceParams(5, 5, &vpx_variance32x32_c), - VarianceParams(5, 4, &vpx_variance32x16_c), - VarianceParams(4, 5, &vpx_variance16x32_c), - VarianceParams(4, 4, &vpx_variance16x16_c), - VarianceParams(4, 3, &vpx_variance16x8_c), - VarianceParams(3, 4, &vpx_variance8x16_c), - VarianceParams(3, 3, &vpx_variance8x8_c), - VarianceParams(3, 2, &vpx_variance8x4_c), - VarianceParams(2, 3, &vpx_variance4x8_c), - VarianceParams(2, 2, &vpx_variance4x4_c))); + ::testing::Values(make_tuple(6, 6, &vpx_variance64x64_c, 0), + make_tuple(6, 5, &vpx_variance64x32_c, 0), + make_tuple(5, 6, &vpx_variance32x64_c, 0), + make_tuple(5, 5, &vpx_variance32x32_c, 0), + make_tuple(5, 4, &vpx_variance32x16_c, 0), + make_tuple(4, 5, &vpx_variance16x32_c, 0), + make_tuple(4, 4, &vpx_variance16x16_c, 0), + make_tuple(4, 3, &vpx_variance16x8_c, 0), + make_tuple(3, 4, &vpx_variance8x16_c, 0), + make_tuple(3, 3, &vpx_variance8x8_c, 0), + make_tuple(3, 2, &vpx_variance8x4_c, 0), + make_tuple(2, 3, &vpx_variance4x8_c, 0), + make_tuple(2, 2, &vpx_variance4x4_c, 0))); INSTANTIATE_TEST_CASE_P( C, VpxSubpelVarianceTest, @@ -796,14 +814,14 @@ INSTANTIATE_TEST_CASE_P( make_tuple(2, 2, &vpx_sub_pixel_avg_variance4x4_c, 0))); #if CONFIG_VP9_HIGHBITDEPTH -typedef MainTestClass VpxHBDMseTest; -typedef MainTestClass VpxHBDVarianceTest; +typedef MseTest VpxHBDMseTest; +typedef VarianceTest VpxHBDVarianceTest; typedef SubpelVarianceTest VpxHBDSubpelVarianceTest; typedef SubpelVarianceTest VpxHBDSubpelAvgVarianceTest; -TEST_P(VpxHBDMseTest, RefMse) { RefTestMse(); } -TEST_P(VpxHBDMseTest, MaxMse) { MaxTestMse(); } +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(); } @@ -831,45 +849,45 @@ INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P( C, VpxHBDVarianceTest, - ::testing::Values(VarianceParams(6, 6, &vpx_highbd_12_variance64x64_c, 12), - VarianceParams(6, 5, &vpx_highbd_12_variance64x32_c, 12), - VarianceParams(5, 6, &vpx_highbd_12_variance32x64_c, 12), - VarianceParams(5, 5, &vpx_highbd_12_variance32x32_c, 12), - VarianceParams(5, 4, &vpx_highbd_12_variance32x16_c, 12), - VarianceParams(4, 5, &vpx_highbd_12_variance16x32_c, 12), - 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, &vpx_highbd_12_variance4x8_c, 12), - VarianceParams(2, 2, &vpx_highbd_12_variance4x4_c, 12), - VarianceParams(6, 6, &vpx_highbd_10_variance64x64_c, 10), - VarianceParams(6, 5, &vpx_highbd_10_variance64x32_c, 10), - VarianceParams(5, 6, &vpx_highbd_10_variance32x64_c, 10), - VarianceParams(5, 5, &vpx_highbd_10_variance32x32_c, 10), - VarianceParams(5, 4, &vpx_highbd_10_variance32x16_c, 10), - VarianceParams(4, 5, &vpx_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, &vpx_highbd_10_variance8x16_c, 10), - 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), - VarianceParams(5, 6, &vpx_highbd_8_variance32x64_c, 8), - 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))); + ::testing::Values(make_tuple(6, 6, &vpx_highbd_12_variance64x64_c, 12), + make_tuple(6, 5, &vpx_highbd_12_variance64x32_c, 12), + make_tuple(5, 6, &vpx_highbd_12_variance32x64_c, 12), + make_tuple(5, 5, &vpx_highbd_12_variance32x32_c, 12), + make_tuple(5, 4, &vpx_highbd_12_variance32x16_c, 12), + make_tuple(4, 5, &vpx_highbd_12_variance16x32_c, 12), + make_tuple(4, 4, &vpx_highbd_12_variance16x16_c, 12), + make_tuple(4, 3, &vpx_highbd_12_variance16x8_c, 12), + make_tuple(3, 4, &vpx_highbd_12_variance8x16_c, 12), + make_tuple(3, 3, &vpx_highbd_12_variance8x8_c, 12), + make_tuple(3, 2, &vpx_highbd_12_variance8x4_c, 12), + make_tuple(2, 3, &vpx_highbd_12_variance4x8_c, 12), + make_tuple(2, 2, &vpx_highbd_12_variance4x4_c, 12), + make_tuple(6, 6, &vpx_highbd_10_variance64x64_c, 10), + make_tuple(6, 5, &vpx_highbd_10_variance64x32_c, 10), + make_tuple(5, 6, &vpx_highbd_10_variance32x64_c, 10), + make_tuple(5, 5, &vpx_highbd_10_variance32x32_c, 10), + make_tuple(5, 4, &vpx_highbd_10_variance32x16_c, 10), + make_tuple(4, 5, &vpx_highbd_10_variance16x32_c, 10), + make_tuple(4, 4, &vpx_highbd_10_variance16x16_c, 10), + make_tuple(4, 3, &vpx_highbd_10_variance16x8_c, 10), + make_tuple(3, 4, &vpx_highbd_10_variance8x16_c, 10), + make_tuple(3, 3, &vpx_highbd_10_variance8x8_c, 10), + make_tuple(3, 2, &vpx_highbd_10_variance8x4_c, 10), + make_tuple(2, 3, &vpx_highbd_10_variance4x8_c, 10), + make_tuple(2, 2, &vpx_highbd_10_variance4x4_c, 10), + make_tuple(6, 6, &vpx_highbd_8_variance64x64_c, 8), + make_tuple(6, 5, &vpx_highbd_8_variance64x32_c, 8), + make_tuple(5, 6, &vpx_highbd_8_variance32x64_c, 8), + make_tuple(5, 5, &vpx_highbd_8_variance32x32_c, 8), + make_tuple(5, 4, &vpx_highbd_8_variance32x16_c, 8), + make_tuple(4, 5, &vpx_highbd_8_variance16x32_c, 8), + make_tuple(4, 4, &vpx_highbd_8_variance16x16_c, 8), + make_tuple(4, 3, &vpx_highbd_8_variance16x8_c, 8), + make_tuple(3, 4, &vpx_highbd_8_variance8x16_c, 8), + make_tuple(3, 3, &vpx_highbd_8_variance8x8_c, 8), + make_tuple(3, 2, &vpx_highbd_8_variance8x4_c, 8), + make_tuple(2, 3, &vpx_highbd_8_variance4x8_c, 8), + make_tuple(2, 2, &vpx_highbd_8_variance4x4_c, 8))); INSTANTIATE_TEST_CASE_P( C, VpxHBDSubpelVarianceTest, @@ -963,26 +981,26 @@ INSTANTIATE_TEST_CASE_P(SSE2, SumOfSquaresTest, ::testing::Values(vpx_get_mb_ss_sse2)); INSTANTIATE_TEST_CASE_P(SSE2, VpxMseTest, - ::testing::Values(MseParams(4, 4, &vpx_mse16x16_sse2), - MseParams(4, 3, &vpx_mse16x8_sse2), - MseParams(3, 4, &vpx_mse8x16_sse2), - MseParams(3, 3, &vpx_mse8x8_sse2))); + ::testing::Values(make_tuple(4, 4, &vpx_mse16x16_sse2), + make_tuple(4, 3, &vpx_mse16x8_sse2), + make_tuple(3, 4, &vpx_mse8x16_sse2), + make_tuple(3, 3, &vpx_mse8x8_sse2))); INSTANTIATE_TEST_CASE_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, 5, &vpx_variance32x32_sse2), - VarianceParams(5, 4, &vpx_variance32x16_sse2), - VarianceParams(4, 5, &vpx_variance16x32_sse2), - VarianceParams(4, 4, &vpx_variance16x16_sse2), - VarianceParams(4, 3, &vpx_variance16x8_sse2), - VarianceParams(3, 4, &vpx_variance8x16_sse2), - VarianceParams(3, 3, &vpx_variance8x8_sse2), - VarianceParams(3, 2, &vpx_variance8x4_sse2), - VarianceParams(2, 3, &vpx_variance4x8_sse2), - VarianceParams(2, 2, &vpx_variance4x4_sse2))); + ::testing::Values(make_tuple(6, 6, &vpx_variance64x64_sse2, 0), + make_tuple(6, 5, &vpx_variance64x32_sse2, 0), + make_tuple(5, 6, &vpx_variance32x64_sse2, 0), + make_tuple(5, 5, &vpx_variance32x32_sse2, 0), + make_tuple(5, 4, &vpx_variance32x16_sse2, 0), + make_tuple(4, 5, &vpx_variance16x32_sse2, 0), + make_tuple(4, 4, &vpx_variance16x16_sse2, 0), + make_tuple(4, 3, &vpx_variance16x8_sse2, 0), + make_tuple(3, 4, &vpx_variance8x16_sse2, 0), + make_tuple(3, 3, &vpx_variance8x8_sse2, 0), + make_tuple(3, 2, &vpx_variance8x4_sse2, 0), + make_tuple(2, 3, &vpx_variance4x8_sse2, 0), + make_tuple(2, 2, &vpx_variance4x4_sse2, 0))); INSTANTIATE_TEST_CASE_P( SSE2, VpxSubpelVarianceTest, @@ -1021,52 +1039,52 @@ INSTANTIATE_TEST_CASE_P( /* TODO(debargha): This test does not support the highbd version INSTANTIATE_TEST_CASE_P( SSE2, VpxHBDMseTest, - ::testing::Values(MseParams(4, 4, &vpx_highbd_12_mse16x16_sse2), - MseParams(4, 3, &vpx_highbd_12_mse16x8_sse2), - MseParams(3, 4, &vpx_highbd_12_mse8x16_sse2), - MseParams(3, 3, &vpx_highbd_12_mse8x8_sse2), - MseParams(4, 4, &vpx_highbd_10_mse16x16_sse2), - MseParams(4, 3, &vpx_highbd_10_mse16x8_sse2), - MseParams(3, 4, &vpx_highbd_10_mse8x16_sse2), - MseParams(3, 3, &vpx_highbd_10_mse8x8_sse2), - MseParams(4, 4, &vpx_highbd_8_mse16x16_sse2), - MseParams(4, 3, &vpx_highbd_8_mse16x8_sse2), - MseParams(3, 4, &vpx_highbd_8_mse8x16_sse2), - MseParams(3, 3, &vpx_highbd_8_mse8x8_sse2))); + ::testing::Values(make_tuple(4, 4, &vpx_highbd_12_mse16x16_sse2), + make_tuple(4, 3, &vpx_highbd_12_mse16x8_sse2), + make_tuple(3, 4, &vpx_highbd_12_mse8x16_sse2), + make_tuple(3, 3, &vpx_highbd_12_mse8x8_sse2), + make_tuple(4, 4, &vpx_highbd_10_mse16x16_sse2), + make_tuple(4, 3, &vpx_highbd_10_mse16x8_sse2), + make_tuple(3, 4, &vpx_highbd_10_mse8x16_sse2), + make_tuple(3, 3, &vpx_highbd_10_mse8x8_sse2), + make_tuple(4, 4, &vpx_highbd_8_mse16x16_sse2), + make_tuple(4, 3, &vpx_highbd_8_mse16x8_sse2), + make_tuple(3, 4, &vpx_highbd_8_mse8x16_sse2), + make_tuple(3, 3, &vpx_highbd_8_mse8x8_sse2))); */ INSTANTIATE_TEST_CASE_P( - SSE2, VpxHBDVarianceTest, ::testing::Values( - 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), - VarianceParams(4, 4, &vpx_highbd_10_variance16x16_sse2, 10), - VarianceParams(4, 3, &vpx_highbd_10_variance16x8_sse2, 10), - VarianceParams(3, 4, &vpx_highbd_10_variance8x16_sse2, 10), - VarianceParams(3, 3, &vpx_highbd_10_variance8x8_sse2, 10), - VarianceParams(6, 6, &vpx_highbd_8_variance64x64_sse2, 8), - VarianceParams(6, 5, &vpx_highbd_8_variance64x32_sse2, 8), - 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))); + SSE2, VpxHBDVarianceTest, + ::testing::Values(make_tuple(6, 6, &vpx_highbd_12_variance64x64_sse2, 12), + make_tuple(6, 5, &vpx_highbd_12_variance64x32_sse2, 12), + make_tuple(5, 6, &vpx_highbd_12_variance32x64_sse2, 12), + make_tuple(5, 5, &vpx_highbd_12_variance32x32_sse2, 12), + make_tuple(5, 4, &vpx_highbd_12_variance32x16_sse2, 12), + make_tuple(4, 5, &vpx_highbd_12_variance16x32_sse2, 12), + make_tuple(4, 4, &vpx_highbd_12_variance16x16_sse2, 12), + make_tuple(4, 3, &vpx_highbd_12_variance16x8_sse2, 12), + make_tuple(3, 4, &vpx_highbd_12_variance8x16_sse2, 12), + make_tuple(3, 3, &vpx_highbd_12_variance8x8_sse2, 12), + make_tuple(6, 6, &vpx_highbd_10_variance64x64_sse2, 10), + make_tuple(6, 5, &vpx_highbd_10_variance64x32_sse2, 10), + make_tuple(5, 6, &vpx_highbd_10_variance32x64_sse2, 10), + make_tuple(5, 5, &vpx_highbd_10_variance32x32_sse2, 10), + make_tuple(5, 4, &vpx_highbd_10_variance32x16_sse2, 10), + make_tuple(4, 5, &vpx_highbd_10_variance16x32_sse2, 10), + make_tuple(4, 4, &vpx_highbd_10_variance16x16_sse2, 10), + make_tuple(4, 3, &vpx_highbd_10_variance16x8_sse2, 10), + make_tuple(3, 4, &vpx_highbd_10_variance8x16_sse2, 10), + make_tuple(3, 3, &vpx_highbd_10_variance8x8_sse2, 10), + make_tuple(6, 6, &vpx_highbd_8_variance64x64_sse2, 8), + make_tuple(6, 5, &vpx_highbd_8_variance64x32_sse2, 8), + make_tuple(5, 6, &vpx_highbd_8_variance32x64_sse2, 8), + make_tuple(5, 5, &vpx_highbd_8_variance32x32_sse2, 8), + make_tuple(5, 4, &vpx_highbd_8_variance32x16_sse2, 8), + make_tuple(4, 5, &vpx_highbd_8_variance16x32_sse2, 8), + make_tuple(4, 4, &vpx_highbd_8_variance16x16_sse2, 8), + make_tuple(4, 3, &vpx_highbd_8_variance16x8_sse2, 8), + make_tuple(3, 4, &vpx_highbd_8_variance8x16_sse2, 8), + make_tuple(3, 3, &vpx_highbd_8_variance8x8_sse2, 8))); INSTANTIATE_TEST_CASE_P( SSE2, VpxHBDSubpelVarianceTest, @@ -1181,15 +1199,16 @@ INSTANTIATE_TEST_CASE_P( #if HAVE_AVX2 INSTANTIATE_TEST_CASE_P(AVX2, VpxMseTest, - ::testing::Values(MseParams(4, 4, &vpx_mse16x16_avx2))); + ::testing::Values(make_tuple(4, 4, + &vpx_mse16x16_avx2))); INSTANTIATE_TEST_CASE_P( AVX2, VpxVarianceTest, - ::testing::Values(VarianceParams(6, 6, &vpx_variance64x64_avx2), - VarianceParams(6, 5, &vpx_variance64x32_avx2), - VarianceParams(5, 5, &vpx_variance32x32_avx2), - VarianceParams(5, 4, &vpx_variance32x16_avx2), - VarianceParams(4, 4, &vpx_variance16x16_avx2))); + ::testing::Values(make_tuple(6, 6, &vpx_variance64x64_avx2, 0), + make_tuple(6, 5, &vpx_variance64x32_avx2, 0), + make_tuple(5, 5, &vpx_variance32x32_avx2, 0), + make_tuple(5, 4, &vpx_variance32x16_avx2, 0), + make_tuple(4, 4, &vpx_variance16x16_avx2, 0))); INSTANTIATE_TEST_CASE_P( AVX2, VpxSubpelVarianceTest, @@ -1205,12 +1224,13 @@ INSTANTIATE_TEST_CASE_P( #if HAVE_MEDIA INSTANTIATE_TEST_CASE_P(MEDIA, VpxMseTest, - ::testing::Values(MseParams(4, 4, &vpx_mse16x16_media))); + ::testing::Values(make_tuple(4, 4, + &vpx_mse16x16_media))); INSTANTIATE_TEST_CASE_P( MEDIA, VpxVarianceTest, - ::testing::Values(VarianceParams(4, 4, &vpx_variance16x16_media), - VarianceParams(3, 3, &vpx_variance8x8_media))); + ::testing::Values(make_tuple(4, 4, &vpx_variance16x16_media, 0), + make_tuple(3, 3, &vpx_variance8x8_media, 0))); INSTANTIATE_TEST_CASE_P( MEDIA, VpxSubpelVarianceTest, @@ -1220,21 +1240,23 @@ INSTANTIATE_TEST_CASE_P( #if HAVE_NEON INSTANTIATE_TEST_CASE_P(NEON, VpxSseTest, - ::testing::Values(SseParams(2, 2, &vpx_get4x4sse_cs_neon))); + ::testing::Values(make_tuple(2, 2, + &vpx_get4x4sse_cs_neon))); INSTANTIATE_TEST_CASE_P(NEON, VpxMseTest, - ::testing::Values(MseParams(4, 4, &vpx_mse16x16_neon))); + ::testing::Values(make_tuple(4, 4, + &vpx_mse16x16_neon))); INSTANTIATE_TEST_CASE_P( NEON, VpxVarianceTest, - ::testing::Values(VarianceParams(6, 6, &vpx_variance64x64_neon), - VarianceParams(6, 5, &vpx_variance64x32_neon), - VarianceParams(5, 6, &vpx_variance32x64_neon), - VarianceParams(5, 5, &vpx_variance32x32_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))); + ::testing::Values(make_tuple(6, 6, &vpx_variance64x64_neon, 0), + make_tuple(6, 5, &vpx_variance64x32_neon, 0), + make_tuple(5, 6, &vpx_variance32x64_neon, 0), + make_tuple(5, 5, &vpx_variance32x32_neon, 0), + make_tuple(4, 4, &vpx_variance16x16_neon, 0), + make_tuple(4, 3, &vpx_variance16x8_neon, 0), + make_tuple(3, 4, &vpx_variance8x16_neon, 0), + make_tuple(3, 3, &vpx_variance8x8_neon, 0))); INSTANTIATE_TEST_CASE_P( NEON, VpxSubpelVarianceTest, @@ -1249,29 +1271,30 @@ INSTANTIATE_TEST_CASE_P(MSA, SumOfSquaresTest, ::testing::Values(vpx_get_mb_ss_msa)); INSTANTIATE_TEST_CASE_P(MSA, VpxSseTest, - ::testing::Values(SseParams(2, 2, &vpx_get4x4sse_cs_msa))); + ::testing::Values(make_tuple(2, 2, + &vpx_get4x4sse_cs_msa))); INSTANTIATE_TEST_CASE_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))); + ::testing::Values(make_tuple(4, 4, &vpx_mse16x16_msa), + make_tuple(4, 3, &vpx_mse16x8_msa), + make_tuple(3, 4, &vpx_mse8x16_msa), + make_tuple(3, 3, &vpx_mse8x8_msa))); INSTANTIATE_TEST_CASE_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))); + ::testing::Values(make_tuple(6, 6, &vpx_variance64x64_msa, 0), + make_tuple(6, 5, &vpx_variance64x32_msa, 0), + make_tuple(5, 6, &vpx_variance32x64_msa, 0), + make_tuple(5, 5, &vpx_variance32x32_msa, 0), + make_tuple(5, 4, &vpx_variance32x16_msa, 0), + make_tuple(4, 5, &vpx_variance16x32_msa, 0), + make_tuple(4, 4, &vpx_variance16x16_msa, 0), + make_tuple(4, 3, &vpx_variance16x8_msa, 0), + make_tuple(3, 4, &vpx_variance8x16_msa, 0), + make_tuple(3, 3, &vpx_variance8x8_msa, 0), + make_tuple(3, 2, &vpx_variance8x4_msa, 0), + make_tuple(2, 3, &vpx_variance4x8_msa, 0), + make_tuple(2, 2, &vpx_variance4x4_msa, 0))); INSTANTIATE_TEST_CASE_P( MSA, VpxSubpelVarianceTest,