1 /* 2 * Copyright (c) 2012 The WebM project authors. All Rights Reserved. 3 * 4 * Use of this source code is governed by a BSD-style license 5 * that can be found in the LICENSE file in the root of the source 6 * tree. An additional intellectual property rights grant can be found 7 * in the file PATENTS. All contributing project authors may 8 * be found in the AUTHORS file in the root of the source tree. 9 */ 10 11 #include <cstdlib> 12 #include <new> 13 14 #include "third_party/googletest/src/include/gtest/gtest.h" 15 16 #include "./vpx_config.h" 17 #include "./vpx_dsp_rtcd.h" 18 #include "test/acm_random.h" 19 #include "test/clear_system_state.h" 20 #include "test/register_state_check.h" 21 #include "vpx/vpx_codec.h" 22 #include "vpx/vpx_integer.h" 23 #include "vpx_mem/vpx_mem.h" 24 #include "vpx_ports/mem.h" 25 #include "vpx_ports/vpx_timer.h" 26 27 namespace { 28 29 typedef unsigned int (*VarianceMxNFunc)(const uint8_t *a, int a_stride, 30 const uint8_t *b, int b_stride, 31 unsigned int *sse); 32 typedef unsigned int (*SubpixVarMxNFunc)(const uint8_t *a, int a_stride, 33 int xoffset, int yoffset, 34 const uint8_t *b, int b_stride, 35 unsigned int *sse); 36 typedef unsigned int (*SubpixAvgVarMxNFunc)(const uint8_t *a, int a_stride, 37 int xoffset, int yoffset, 38 const uint8_t *b, int b_stride, 39 uint32_t *sse, 40 const uint8_t *second_pred); 41 typedef unsigned int (*Get4x4SseFunc)(const uint8_t *a, int a_stride, 42 const uint8_t *b, int b_stride); 43 typedef unsigned int (*SumOfSquaresFunction)(const int16_t *src); 44 45 using libvpx_test::ACMRandom; 46 47 // Truncate high bit depth results by downshifting (with rounding) by: 48 // 2 * (bit_depth - 8) for sse 49 // (bit_depth - 8) for se 50 static void RoundHighBitDepth(int bit_depth, int64_t *se, uint64_t *sse) { 51 switch (bit_depth) { 52 case VPX_BITS_12: 53 *sse = (*sse + 128) >> 8; 54 *se = (*se + 8) >> 4; 55 break; 56 case VPX_BITS_10: 57 *sse = (*sse + 8) >> 4; 58 *se = (*se + 2) >> 2; 59 break; 60 case VPX_BITS_8: 61 default: break; 62 } 63 } 64 65 static unsigned int mb_ss_ref(const int16_t *src) { 66 unsigned int res = 0; 67 for (int i = 0; i < 256; ++i) { 68 res += src[i] * src[i]; 69 } 70 return res; 71 } 72 73 /* Note: 74 * Our codebase calculates the "diff" value in the variance algorithm by 75 * (src - ref). 76 */ 77 static uint32_t variance_ref(const uint8_t *src, const uint8_t *ref, int l2w, 78 int l2h, int src_stride, int ref_stride, 79 uint32_t *sse_ptr, bool use_high_bit_depth_, 80 vpx_bit_depth_t bit_depth) { 81 int64_t se = 0; 82 uint64_t sse = 0; 83 const int w = 1 << l2w; 84 const int h = 1 << l2h; 85 for (int y = 0; y < h; y++) { 86 for (int x = 0; x < w; x++) { 87 int diff; 88 if (!use_high_bit_depth_) { 89 diff = src[y * src_stride + x] - ref[y * ref_stride + x]; 90 se += diff; 91 sse += diff * diff; 92 #if CONFIG_VP9_HIGHBITDEPTH 93 } else { 94 diff = CONVERT_TO_SHORTPTR(src)[y * src_stride + x] - 95 CONVERT_TO_SHORTPTR(ref)[y * ref_stride + x]; 96 se += diff; 97 sse += diff * diff; 98 #endif // CONFIG_VP9_HIGHBITDEPTH 99 } 100 } 101 } 102 RoundHighBitDepth(bit_depth, &se, &sse); 103 *sse_ptr = static_cast<uint32_t>(sse); 104 return static_cast<uint32_t>( 105 sse - ((static_cast<int64_t>(se) * se) >> (l2w + l2h))); 106 } 107 108 /* The subpel reference functions differ from the codec version in one aspect: 109 * they calculate the bilinear factors directly instead of using a lookup table 110 * and therefore upshift xoff and yoff by 1. Only every other calculated value 111 * is used so the codec version shrinks the table to save space and maintain 112 * compatibility with vp8. 113 */ 114 static uint32_t subpel_variance_ref(const uint8_t *ref, const uint8_t *src, 115 int l2w, int l2h, int xoff, int yoff, 116 uint32_t *sse_ptr, bool use_high_bit_depth_, 117 vpx_bit_depth_t bit_depth) { 118 int64_t se = 0; 119 uint64_t sse = 0; 120 const int w = 1 << l2w; 121 const int h = 1 << l2h; 122 123 xoff <<= 1; 124 yoff <<= 1; 125 126 for (int y = 0; y < h; y++) { 127 for (int x = 0; x < w; x++) { 128 // Bilinear interpolation at a 16th pel step. 129 if (!use_high_bit_depth_) { 130 const int a1 = ref[(w + 1) * (y + 0) + x + 0]; 131 const int a2 = ref[(w + 1) * (y + 0) + x + 1]; 132 const int b1 = ref[(w + 1) * (y + 1) + x + 0]; 133 const int b2 = ref[(w + 1) * (y + 1) + x + 1]; 134 const int a = a1 + (((a2 - a1) * xoff + 8) >> 4); 135 const int b = b1 + (((b2 - b1) * xoff + 8) >> 4); 136 const int r = a + (((b - a) * yoff + 8) >> 4); 137 const int diff = r - src[w * y + x]; 138 se += diff; 139 sse += diff * diff; 140 #if CONFIG_VP9_HIGHBITDEPTH 141 } else { 142 uint16_t *ref16 = CONVERT_TO_SHORTPTR(ref); 143 uint16_t *src16 = CONVERT_TO_SHORTPTR(src); 144 const int a1 = ref16[(w + 1) * (y + 0) + x + 0]; 145 const int a2 = ref16[(w + 1) * (y + 0) + x + 1]; 146 const int b1 = ref16[(w + 1) * (y + 1) + x + 0]; 147 const int b2 = ref16[(w + 1) * (y + 1) + x + 1]; 148 const int a = a1 + (((a2 - a1) * xoff + 8) >> 4); 149 const int b = b1 + (((b2 - b1) * xoff + 8) >> 4); 150 const int r = a + (((b - a) * yoff + 8) >> 4); 151 const int diff = r - src16[w * y + x]; 152 se += diff; 153 sse += diff * diff; 154 #endif // CONFIG_VP9_HIGHBITDEPTH 155 } 156 } 157 } 158 RoundHighBitDepth(bit_depth, &se, &sse); 159 *sse_ptr = static_cast<uint32_t>(sse); 160 return static_cast<uint32_t>( 161 sse - ((static_cast<int64_t>(se) * se) >> (l2w + l2h))); 162 } 163 164 static uint32_t subpel_avg_variance_ref(const uint8_t *ref, const uint8_t *src, 165 const uint8_t *second_pred, int l2w, 166 int l2h, int xoff, int yoff, 167 uint32_t *sse_ptr, 168 bool use_high_bit_depth, 169 vpx_bit_depth_t bit_depth) { 170 int64_t se = 0; 171 uint64_t sse = 0; 172 const int w = 1 << l2w; 173 const int h = 1 << l2h; 174 175 xoff <<= 1; 176 yoff <<= 1; 177 178 for (int y = 0; y < h; y++) { 179 for (int x = 0; x < w; x++) { 180 // bilinear interpolation at a 16th pel step 181 if (!use_high_bit_depth) { 182 const int a1 = ref[(w + 1) * (y + 0) + x + 0]; 183 const int a2 = ref[(w + 1) * (y + 0) + x + 1]; 184 const int b1 = ref[(w + 1) * (y + 1) + x + 0]; 185 const int b2 = ref[(w + 1) * (y + 1) + x + 1]; 186 const int a = a1 + (((a2 - a1) * xoff + 8) >> 4); 187 const int b = b1 + (((b2 - b1) * xoff + 8) >> 4); 188 const int r = a + (((b - a) * yoff + 8) >> 4); 189 const int diff = 190 ((r + second_pred[w * y + x] + 1) >> 1) - src[w * y + x]; 191 se += diff; 192 sse += diff * diff; 193 #if CONFIG_VP9_HIGHBITDEPTH 194 } else { 195 const uint16_t *ref16 = CONVERT_TO_SHORTPTR(ref); 196 const uint16_t *src16 = CONVERT_TO_SHORTPTR(src); 197 const uint16_t *sec16 = CONVERT_TO_SHORTPTR(second_pred); 198 const int a1 = ref16[(w + 1) * (y + 0) + x + 0]; 199 const int a2 = ref16[(w + 1) * (y + 0) + x + 1]; 200 const int b1 = ref16[(w + 1) * (y + 1) + x + 0]; 201 const int b2 = ref16[(w + 1) * (y + 1) + x + 1]; 202 const int a = a1 + (((a2 - a1) * xoff + 8) >> 4); 203 const int b = b1 + (((b2 - b1) * xoff + 8) >> 4); 204 const int r = a + (((b - a) * yoff + 8) >> 4); 205 const int diff = ((r + sec16[w * y + x] + 1) >> 1) - src16[w * y + x]; 206 se += diff; 207 sse += diff * diff; 208 #endif // CONFIG_VP9_HIGHBITDEPTH 209 } 210 } 211 } 212 RoundHighBitDepth(bit_depth, &se, &sse); 213 *sse_ptr = static_cast<uint32_t>(sse); 214 return static_cast<uint32_t>( 215 sse - ((static_cast<int64_t>(se) * se) >> (l2w + l2h))); 216 } 217 218 //////////////////////////////////////////////////////////////////////////////// 219 220 class SumOfSquaresTest : public ::testing::TestWithParam<SumOfSquaresFunction> { 221 public: 222 SumOfSquaresTest() : func_(GetParam()) {} 223 224 virtual ~SumOfSquaresTest() { libvpx_test::ClearSystemState(); } 225 226 protected: 227 void ConstTest(); 228 void RefTest(); 229 230 SumOfSquaresFunction func_; 231 ACMRandom rnd_; 232 }; 233 234 void SumOfSquaresTest::ConstTest() { 235 int16_t mem[256]; 236 unsigned int res; 237 for (int v = 0; v < 256; ++v) { 238 for (int i = 0; i < 256; ++i) { 239 mem[i] = v; 240 } 241 ASM_REGISTER_STATE_CHECK(res = func_(mem)); 242 EXPECT_EQ(256u * (v * v), res); 243 } 244 } 245 246 void SumOfSquaresTest::RefTest() { 247 int16_t mem[256]; 248 for (int i = 0; i < 100; ++i) { 249 for (int j = 0; j < 256; ++j) { 250 mem[j] = rnd_.Rand8() - rnd_.Rand8(); 251 } 252 253 const unsigned int expected = mb_ss_ref(mem); 254 unsigned int res; 255 ASM_REGISTER_STATE_CHECK(res = func_(mem)); 256 EXPECT_EQ(expected, res); 257 } 258 } 259 260 //////////////////////////////////////////////////////////////////////////////// 261 // Encapsulating struct to store the function to test along with 262 // some testing context. 263 // Can be used for MSE, SSE, Variance, etc. 264 265 template <typename Func> 266 struct TestParams { 267 TestParams(int log2w = 0, int log2h = 0, Func function = NULL, 268 int bit_depth_value = 0) 269 : log2width(log2w), log2height(log2h), func(function) { 270 use_high_bit_depth = (bit_depth_value > 0); 271 if (use_high_bit_depth) { 272 bit_depth = static_cast<vpx_bit_depth_t>(bit_depth_value); 273 } else { 274 bit_depth = VPX_BITS_8; 275 } 276 width = 1 << log2width; 277 height = 1 << log2height; 278 block_size = width * height; 279 mask = (1u << bit_depth) - 1; 280 } 281 282 int log2width, log2height; 283 int width, height; 284 int block_size; 285 Func func; 286 vpx_bit_depth_t bit_depth; 287 bool use_high_bit_depth; 288 uint32_t mask; 289 }; 290 291 template <typename Func> 292 std::ostream &operator<<(std::ostream &os, const TestParams<Func> &p) { 293 return os << "log2width/height:" << p.log2width << "/" << p.log2height 294 << " function:" << reinterpret_cast<const void *>(p.func) 295 << " bit-depth:" << p.bit_depth; 296 } 297 298 // Main class for testing a function type 299 template <typename FunctionType> 300 class MainTestClass 301 : public ::testing::TestWithParam<TestParams<FunctionType> > { 302 public: 303 virtual void SetUp() { 304 params_ = this->GetParam(); 305 306 rnd_.Reset(ACMRandom::DeterministicSeed()); 307 const size_t unit = 308 use_high_bit_depth() ? sizeof(uint16_t) : sizeof(uint8_t); 309 src_ = reinterpret_cast<uint8_t *>(vpx_memalign(16, block_size() * unit)); 310 ref_ = new uint8_t[block_size() * unit]; 311 ASSERT_TRUE(src_ != NULL); 312 ASSERT_TRUE(ref_ != NULL); 313 #if CONFIG_VP9_HIGHBITDEPTH 314 if (use_high_bit_depth()) { 315 // TODO(skal): remove! 316 src_ = CONVERT_TO_BYTEPTR(src_); 317 ref_ = CONVERT_TO_BYTEPTR(ref_); 318 } 319 #endif 320 } 321 322 virtual void TearDown() { 323 #if CONFIG_VP9_HIGHBITDEPTH 324 if (use_high_bit_depth()) { 325 // TODO(skal): remove! 326 src_ = reinterpret_cast<uint8_t *>(CONVERT_TO_SHORTPTR(src_)); 327 ref_ = reinterpret_cast<uint8_t *>(CONVERT_TO_SHORTPTR(ref_)); 328 } 329 #endif 330 331 vpx_free(src_); 332 delete[] ref_; 333 src_ = NULL; 334 ref_ = NULL; 335 libvpx_test::ClearSystemState(); 336 } 337 338 protected: 339 // We could sub-class MainTestClass into dedicated class for Variance 340 // and MSE/SSE, but it involves a lot of 'this->xxx' dereferencing 341 // to access top class fields xxx. That's cumbersome, so for now we'll just 342 // implement the testing methods here: 343 344 // Variance tests 345 void ZeroTest(); 346 void RefTest(); 347 void RefStrideTest(); 348 void OneQuarterTest(); 349 void SpeedTest(); 350 351 // MSE/SSE tests 352 void RefTestMse(); 353 void RefTestSse(); 354 void MaxTestMse(); 355 void MaxTestSse(); 356 357 protected: 358 ACMRandom rnd_; 359 uint8_t *src_; 360 uint8_t *ref_; 361 TestParams<FunctionType> params_; 362 363 // some relay helpers 364 bool use_high_bit_depth() const { return params_.use_high_bit_depth; } 365 int byte_shift() const { return params_.bit_depth - 8; } 366 int block_size() const { return params_.block_size; } 367 int width() const { return params_.width; } 368 int height() const { return params_.height; } 369 uint32_t mask() const { return params_.mask; } 370 }; 371 372 //////////////////////////////////////////////////////////////////////////////// 373 // Tests related to variance. 374 375 template <typename VarianceFunctionType> 376 void MainTestClass<VarianceFunctionType>::ZeroTest() { 377 for (int i = 0; i <= 255; ++i) { 378 if (!use_high_bit_depth()) { 379 memset(src_, i, block_size()); 380 } else { 381 uint16_t *const src16 = CONVERT_TO_SHORTPTR(src_); 382 for (int k = 0; k < block_size(); ++k) src16[k] = i << byte_shift(); 383 } 384 for (int j = 0; j <= 255; ++j) { 385 if (!use_high_bit_depth()) { 386 memset(ref_, j, block_size()); 387 } else { 388 uint16_t *const ref16 = CONVERT_TO_SHORTPTR(ref_); 389 for (int k = 0; k < block_size(); ++k) ref16[k] = j << byte_shift(); 390 } 391 unsigned int sse, var; 392 ASM_REGISTER_STATE_CHECK( 393 var = params_.func(src_, width(), ref_, width(), &sse)); 394 EXPECT_EQ(0u, var) << "src values: " << i << " ref values: " << j; 395 } 396 } 397 } 398 399 template <typename VarianceFunctionType> 400 void MainTestClass<VarianceFunctionType>::RefTest() { 401 for (int i = 0; i < 10; ++i) { 402 for (int j = 0; j < block_size(); j++) { 403 if (!use_high_bit_depth()) { 404 src_[j] = rnd_.Rand8(); 405 ref_[j] = rnd_.Rand8(); 406 #if CONFIG_VP9_HIGHBITDEPTH 407 } else { 408 CONVERT_TO_SHORTPTR(src_)[j] = rnd_.Rand16() & mask(); 409 CONVERT_TO_SHORTPTR(ref_)[j] = rnd_.Rand16() & mask(); 410 #endif // CONFIG_VP9_HIGHBITDEPTH 411 } 412 } 413 unsigned int sse1, sse2, var1, var2; 414 const int stride = width(); 415 ASM_REGISTER_STATE_CHECK( 416 var1 = params_.func(src_, stride, ref_, stride, &sse1)); 417 var2 = 418 variance_ref(src_, ref_, params_.log2width, params_.log2height, stride, 419 stride, &sse2, use_high_bit_depth(), params_.bit_depth); 420 EXPECT_EQ(sse1, sse2) << "Error at test index: " << i; 421 EXPECT_EQ(var1, var2) << "Error at test index: " << i; 422 } 423 } 424 425 template <typename VarianceFunctionType> 426 void MainTestClass<VarianceFunctionType>::RefStrideTest() { 427 for (int i = 0; i < 10; ++i) { 428 const int ref_stride = (i & 1) * width(); 429 const int src_stride = ((i >> 1) & 1) * width(); 430 for (int j = 0; j < block_size(); j++) { 431 const int ref_ind = (j / width()) * ref_stride + j % width(); 432 const int src_ind = (j / width()) * src_stride + j % width(); 433 if (!use_high_bit_depth()) { 434 src_[src_ind] = rnd_.Rand8(); 435 ref_[ref_ind] = rnd_.Rand8(); 436 #if CONFIG_VP9_HIGHBITDEPTH 437 } else { 438 CONVERT_TO_SHORTPTR(src_)[src_ind] = rnd_.Rand16() & mask(); 439 CONVERT_TO_SHORTPTR(ref_)[ref_ind] = rnd_.Rand16() & mask(); 440 #endif // CONFIG_VP9_HIGHBITDEPTH 441 } 442 } 443 unsigned int sse1, sse2; 444 unsigned int var1, var2; 445 446 ASM_REGISTER_STATE_CHECK( 447 var1 = params_.func(src_, src_stride, ref_, ref_stride, &sse1)); 448 var2 = variance_ref(src_, ref_, params_.log2width, params_.log2height, 449 src_stride, ref_stride, &sse2, use_high_bit_depth(), 450 params_.bit_depth); 451 EXPECT_EQ(sse1, sse2) << "Error at test index: " << i; 452 EXPECT_EQ(var1, var2) << "Error at test index: " << i; 453 } 454 } 455 456 template <typename VarianceFunctionType> 457 void MainTestClass<VarianceFunctionType>::OneQuarterTest() { 458 const int half = block_size() / 2; 459 if (!use_high_bit_depth()) { 460 memset(src_, 255, block_size()); 461 memset(ref_, 255, half); 462 memset(ref_ + half, 0, half); 463 #if CONFIG_VP9_HIGHBITDEPTH 464 } else { 465 vpx_memset16(CONVERT_TO_SHORTPTR(src_), 255 << byte_shift(), block_size()); 466 vpx_memset16(CONVERT_TO_SHORTPTR(ref_), 255 << byte_shift(), half); 467 vpx_memset16(CONVERT_TO_SHORTPTR(ref_) + half, 0, half); 468 #endif // CONFIG_VP9_HIGHBITDEPTH 469 } 470 unsigned int sse, var, expected; 471 ASM_REGISTER_STATE_CHECK( 472 var = params_.func(src_, width(), ref_, width(), &sse)); 473 expected = block_size() * 255 * 255 / 4; 474 EXPECT_EQ(expected, var); 475 } 476 477 template <typename VarianceFunctionType> 478 void MainTestClass<VarianceFunctionType>::SpeedTest() { 479 const int half = block_size() / 2; 480 if (!use_high_bit_depth()) { 481 memset(src_, 255, block_size()); 482 memset(ref_, 255, half); 483 memset(ref_ + half, 0, half); 484 #if CONFIG_VP9_HIGHBITDEPTH 485 } else { 486 vpx_memset16(CONVERT_TO_SHORTPTR(src_), 255 << byte_shift(), block_size()); 487 vpx_memset16(CONVERT_TO_SHORTPTR(ref_), 255 << byte_shift(), half); 488 vpx_memset16(CONVERT_TO_SHORTPTR(ref_) + half, 0, half); 489 #endif // CONFIG_VP9_HIGHBITDEPTH 490 } 491 unsigned int sse; 492 493 vpx_usec_timer timer; 494 vpx_usec_timer_start(&timer); 495 for (int i = 0; i < 100000000 / block_size(); ++i) { 496 const uint32_t variance = params_.func(src_, width(), ref_, width(), &sse); 497 // Ignore return value. 498 (void)variance; 499 } 500 vpx_usec_timer_mark(&timer); 501 const int elapsed_time = static_cast<int>(vpx_usec_timer_elapsed(&timer)); 502 printf("Variance %dx%d time: %5d ms\n", width(), height(), 503 elapsed_time / 1000); 504 } 505 506 //////////////////////////////////////////////////////////////////////////////// 507 // Tests related to MSE / SSE. 508 509 template <typename FunctionType> 510 void MainTestClass<FunctionType>::RefTestMse() { 511 for (int i = 0; i < 10; ++i) { 512 for (int j = 0; j < block_size(); ++j) { 513 src_[j] = rnd_.Rand8(); 514 ref_[j] = rnd_.Rand8(); 515 } 516 unsigned int sse1, sse2; 517 const int stride = width(); 518 ASM_REGISTER_STATE_CHECK(params_.func(src_, stride, ref_, stride, &sse1)); 519 variance_ref(src_, ref_, params_.log2width, params_.log2height, stride, 520 stride, &sse2, false, VPX_BITS_8); 521 EXPECT_EQ(sse1, sse2); 522 } 523 } 524 525 template <typename FunctionType> 526 void MainTestClass<FunctionType>::RefTestSse() { 527 for (int i = 0; i < 10; ++i) { 528 for (int j = 0; j < block_size(); ++j) { 529 src_[j] = rnd_.Rand8(); 530 ref_[j] = rnd_.Rand8(); 531 } 532 unsigned int sse2; 533 unsigned int var1; 534 const int stride = width(); 535 ASM_REGISTER_STATE_CHECK(var1 = params_.func(src_, stride, ref_, stride)); 536 variance_ref(src_, ref_, params_.log2width, params_.log2height, stride, 537 stride, &sse2, false, VPX_BITS_8); 538 EXPECT_EQ(var1, sse2); 539 } 540 } 541 542 template <typename FunctionType> 543 void MainTestClass<FunctionType>::MaxTestMse() { 544 memset(src_, 255, block_size()); 545 memset(ref_, 0, block_size()); 546 unsigned int sse; 547 ASM_REGISTER_STATE_CHECK(params_.func(src_, width(), ref_, width(), &sse)); 548 const unsigned int expected = block_size() * 255 * 255; 549 EXPECT_EQ(expected, sse); 550 } 551 552 template <typename FunctionType> 553 void MainTestClass<FunctionType>::MaxTestSse() { 554 memset(src_, 255, block_size()); 555 memset(ref_, 0, block_size()); 556 unsigned int var; 557 ASM_REGISTER_STATE_CHECK(var = params_.func(src_, width(), ref_, width())); 558 const unsigned int expected = block_size() * 255 * 255; 559 EXPECT_EQ(expected, var); 560 } 561 562 //////////////////////////////////////////////////////////////////////////////// 563 564 using ::std::tr1::get; 565 using ::std::tr1::make_tuple; 566 using ::std::tr1::tuple; 567 568 template <typename SubpelVarianceFunctionType> 569 class SubpelVarianceTest 570 : public ::testing::TestWithParam< 571 tuple<int, int, SubpelVarianceFunctionType, int> > { 572 public: 573 virtual void SetUp() { 574 const tuple<int, int, SubpelVarianceFunctionType, int> ¶ms = 575 this->GetParam(); 576 log2width_ = get<0>(params); 577 width_ = 1 << log2width_; 578 log2height_ = get<1>(params); 579 height_ = 1 << log2height_; 580 subpel_variance_ = get<2>(params); 581 if (get<3>(params)) { 582 bit_depth_ = (vpx_bit_depth_t)get<3>(params); 583 use_high_bit_depth_ = true; 584 } else { 585 bit_depth_ = VPX_BITS_8; 586 use_high_bit_depth_ = false; 587 } 588 mask_ = (1 << bit_depth_) - 1; 589 590 rnd_.Reset(ACMRandom::DeterministicSeed()); 591 block_size_ = width_ * height_; 592 if (!use_high_bit_depth_) { 593 src_ = reinterpret_cast<uint8_t *>(vpx_memalign(16, block_size_)); 594 sec_ = reinterpret_cast<uint8_t *>(vpx_memalign(16, block_size_)); 595 ref_ = new uint8_t[block_size_ + width_ + height_ + 1]; 596 #if CONFIG_VP9_HIGHBITDEPTH 597 } else { 598 src_ = CONVERT_TO_BYTEPTR(reinterpret_cast<uint16_t *>( 599 vpx_memalign(16, block_size_ * sizeof(uint16_t)))); 600 sec_ = CONVERT_TO_BYTEPTR(reinterpret_cast<uint16_t *>( 601 vpx_memalign(16, block_size_ * sizeof(uint16_t)))); 602 ref_ = 603 CONVERT_TO_BYTEPTR(new uint16_t[block_size_ + width_ + height_ + 1]); 604 #endif // CONFIG_VP9_HIGHBITDEPTH 605 } 606 ASSERT_TRUE(src_ != NULL); 607 ASSERT_TRUE(sec_ != NULL); 608 ASSERT_TRUE(ref_ != NULL); 609 } 610 611 virtual void TearDown() { 612 if (!use_high_bit_depth_) { 613 vpx_free(src_); 614 delete[] ref_; 615 vpx_free(sec_); 616 #if CONFIG_VP9_HIGHBITDEPTH 617 } else { 618 vpx_free(CONVERT_TO_SHORTPTR(src_)); 619 delete[] CONVERT_TO_SHORTPTR(ref_); 620 vpx_free(CONVERT_TO_SHORTPTR(sec_)); 621 #endif // CONFIG_VP9_HIGHBITDEPTH 622 } 623 libvpx_test::ClearSystemState(); 624 } 625 626 protected: 627 void RefTest(); 628 void ExtremeRefTest(); 629 630 ACMRandom rnd_; 631 uint8_t *src_; 632 uint8_t *ref_; 633 uint8_t *sec_; 634 bool use_high_bit_depth_; 635 vpx_bit_depth_t bit_depth_; 636 int width_, log2width_; 637 int height_, log2height_; 638 int block_size_, mask_; 639 SubpelVarianceFunctionType subpel_variance_; 640 }; 641 642 template <typename SubpelVarianceFunctionType> 643 void SubpelVarianceTest<SubpelVarianceFunctionType>::RefTest() { 644 for (int x = 0; x < 8; ++x) { 645 for (int y = 0; y < 8; ++y) { 646 if (!use_high_bit_depth_) { 647 for (int j = 0; j < block_size_; j++) { 648 src_[j] = rnd_.Rand8(); 649 } 650 for (int j = 0; j < block_size_ + width_ + height_ + 1; j++) { 651 ref_[j] = rnd_.Rand8(); 652 } 653 #if CONFIG_VP9_HIGHBITDEPTH 654 } else { 655 for (int j = 0; j < block_size_; j++) { 656 CONVERT_TO_SHORTPTR(src_)[j] = rnd_.Rand16() & mask_; 657 } 658 for (int j = 0; j < block_size_ + width_ + height_ + 1; j++) { 659 CONVERT_TO_SHORTPTR(ref_)[j] = rnd_.Rand16() & mask_; 660 } 661 #endif // CONFIG_VP9_HIGHBITDEPTH 662 } 663 unsigned int sse1, sse2; 664 unsigned int var1; 665 ASM_REGISTER_STATE_CHECK( 666 var1 = subpel_variance_(ref_, width_ + 1, x, y, src_, width_, &sse1)); 667 const unsigned int var2 = 668 subpel_variance_ref(ref_, src_, log2width_, log2height_, x, y, &sse2, 669 use_high_bit_depth_, bit_depth_); 670 EXPECT_EQ(sse1, sse2) << "at position " << x << ", " << y; 671 EXPECT_EQ(var1, var2) << "at position " << x << ", " << y; 672 } 673 } 674 } 675 676 template <typename SubpelVarianceFunctionType> 677 void SubpelVarianceTest<SubpelVarianceFunctionType>::ExtremeRefTest() { 678 // Compare against reference. 679 // Src: Set the first half of values to 0, the second half to the maximum. 680 // Ref: Set the first half of values to the maximum, the second half to 0. 681 for (int x = 0; x < 8; ++x) { 682 for (int y = 0; y < 8; ++y) { 683 const int half = block_size_ / 2; 684 if (!use_high_bit_depth_) { 685 memset(src_, 0, half); 686 memset(src_ + half, 255, half); 687 memset(ref_, 255, half); 688 memset(ref_ + half, 0, half + width_ + height_ + 1); 689 #if CONFIG_VP9_HIGHBITDEPTH 690 } else { 691 vpx_memset16(CONVERT_TO_SHORTPTR(src_), mask_, half); 692 vpx_memset16(CONVERT_TO_SHORTPTR(src_) + half, 0, half); 693 vpx_memset16(CONVERT_TO_SHORTPTR(ref_), 0, half); 694 vpx_memset16(CONVERT_TO_SHORTPTR(ref_) + half, mask_, 695 half + width_ + height_ + 1); 696 #endif // CONFIG_VP9_HIGHBITDEPTH 697 } 698 unsigned int sse1, sse2; 699 unsigned int var1; 700 ASM_REGISTER_STATE_CHECK( 701 var1 = subpel_variance_(ref_, width_ + 1, x, y, src_, width_, &sse1)); 702 const unsigned int var2 = 703 subpel_variance_ref(ref_, src_, log2width_, log2height_, x, y, &sse2, 704 use_high_bit_depth_, bit_depth_); 705 EXPECT_EQ(sse1, sse2) << "for xoffset " << x << " and yoffset " << y; 706 EXPECT_EQ(var1, var2) << "for xoffset " << x << " and yoffset " << y; 707 } 708 } 709 } 710 711 template <> 712 void SubpelVarianceTest<SubpixAvgVarMxNFunc>::RefTest() { 713 for (int x = 0; x < 8; ++x) { 714 for (int y = 0; y < 8; ++y) { 715 if (!use_high_bit_depth_) { 716 for (int j = 0; j < block_size_; j++) { 717 src_[j] = rnd_.Rand8(); 718 sec_[j] = rnd_.Rand8(); 719 } 720 for (int j = 0; j < block_size_ + width_ + height_ + 1; j++) { 721 ref_[j] = rnd_.Rand8(); 722 } 723 #if CONFIG_VP9_HIGHBITDEPTH 724 } else { 725 for (int j = 0; j < block_size_; j++) { 726 CONVERT_TO_SHORTPTR(src_)[j] = rnd_.Rand16() & mask_; 727 CONVERT_TO_SHORTPTR(sec_)[j] = rnd_.Rand16() & mask_; 728 } 729 for (int j = 0; j < block_size_ + width_ + height_ + 1; j++) { 730 CONVERT_TO_SHORTPTR(ref_)[j] = rnd_.Rand16() & mask_; 731 } 732 #endif // CONFIG_VP9_HIGHBITDEPTH 733 } 734 uint32_t sse1, sse2; 735 uint32_t var1, var2; 736 ASM_REGISTER_STATE_CHECK(var1 = 737 subpel_variance_(ref_, width_ + 1, x, y, 738 src_, width_, &sse1, sec_)); 739 var2 = subpel_avg_variance_ref(ref_, src_, sec_, log2width_, log2height_, 740 x, y, &sse2, use_high_bit_depth_, 741 static_cast<vpx_bit_depth_t>(bit_depth_)); 742 EXPECT_EQ(sse1, sse2) << "at position " << x << ", " << y; 743 EXPECT_EQ(var1, var2) << "at position " << x << ", " << y; 744 } 745 } 746 } 747 748 typedef MainTestClass<Get4x4SseFunc> VpxSseTest; 749 typedef MainTestClass<VarianceMxNFunc> VpxMseTest; 750 typedef MainTestClass<VarianceMxNFunc> VpxVarianceTest; 751 typedef SubpelVarianceTest<SubpixVarMxNFunc> VpxSubpelVarianceTest; 752 typedef SubpelVarianceTest<SubpixAvgVarMxNFunc> VpxSubpelAvgVarianceTest; 753 754 TEST_P(VpxSseTest, RefSse) { RefTestSse(); } 755 TEST_P(VpxSseTest, MaxSse) { MaxTestSse(); } 756 TEST_P(VpxMseTest, RefMse) { RefTestMse(); } 757 TEST_P(VpxMseTest, MaxMse) { MaxTestMse(); } 758 TEST_P(VpxVarianceTest, Zero) { ZeroTest(); } 759 TEST_P(VpxVarianceTest, Ref) { RefTest(); } 760 TEST_P(VpxVarianceTest, RefStride) { RefStrideTest(); } 761 TEST_P(VpxVarianceTest, OneQuarter) { OneQuarterTest(); } 762 TEST_P(VpxVarianceTest, DISABLED_Speed) { SpeedTest(); } 763 TEST_P(SumOfSquaresTest, Const) { ConstTest(); } 764 TEST_P(SumOfSquaresTest, Ref) { RefTest(); } 765 TEST_P(VpxSubpelVarianceTest, Ref) { RefTest(); } 766 TEST_P(VpxSubpelVarianceTest, ExtremeRef) { ExtremeRefTest(); } 767 TEST_P(VpxSubpelAvgVarianceTest, Ref) { RefTest(); } 768 769 INSTANTIATE_TEST_CASE_P(C, SumOfSquaresTest, 770 ::testing::Values(vpx_get_mb_ss_c)); 771 772 typedef TestParams<Get4x4SseFunc> SseParams; 773 INSTANTIATE_TEST_CASE_P(C, VpxSseTest, 774 ::testing::Values(SseParams(2, 2, 775 &vpx_get4x4sse_cs_c))); 776 777 typedef TestParams<VarianceMxNFunc> MseParams; 778 INSTANTIATE_TEST_CASE_P(C, VpxMseTest, 779 ::testing::Values(MseParams(4, 4, &vpx_mse16x16_c), 780 MseParams(4, 3, &vpx_mse16x8_c), 781 MseParams(3, 4, &vpx_mse8x16_c), 782 MseParams(3, 3, &vpx_mse8x8_c))); 783 784 typedef TestParams<VarianceMxNFunc> VarianceParams; 785 INSTANTIATE_TEST_CASE_P( 786 C, VpxVarianceTest, 787 ::testing::Values(VarianceParams(6, 6, &vpx_variance64x64_c), 788 VarianceParams(6, 5, &vpx_variance64x32_c), 789 VarianceParams(5, 6, &vpx_variance32x64_c), 790 VarianceParams(5, 5, &vpx_variance32x32_c), 791 VarianceParams(5, 4, &vpx_variance32x16_c), 792 VarianceParams(4, 5, &vpx_variance16x32_c), 793 VarianceParams(4, 4, &vpx_variance16x16_c), 794 VarianceParams(4, 3, &vpx_variance16x8_c), 795 VarianceParams(3, 4, &vpx_variance8x16_c), 796 VarianceParams(3, 3, &vpx_variance8x8_c), 797 VarianceParams(3, 2, &vpx_variance8x4_c), 798 VarianceParams(2, 3, &vpx_variance4x8_c), 799 VarianceParams(2, 2, &vpx_variance4x4_c))); 800 801 INSTANTIATE_TEST_CASE_P( 802 C, VpxSubpelVarianceTest, 803 ::testing::Values(make_tuple(6, 6, &vpx_sub_pixel_variance64x64_c, 0), 804 make_tuple(6, 5, &vpx_sub_pixel_variance64x32_c, 0), 805 make_tuple(5, 6, &vpx_sub_pixel_variance32x64_c, 0), 806 make_tuple(5, 5, &vpx_sub_pixel_variance32x32_c, 0), 807 make_tuple(5, 4, &vpx_sub_pixel_variance32x16_c, 0), 808 make_tuple(4, 5, &vpx_sub_pixel_variance16x32_c, 0), 809 make_tuple(4, 4, &vpx_sub_pixel_variance16x16_c, 0), 810 make_tuple(4, 3, &vpx_sub_pixel_variance16x8_c, 0), 811 make_tuple(3, 4, &vpx_sub_pixel_variance8x16_c, 0), 812 make_tuple(3, 3, &vpx_sub_pixel_variance8x8_c, 0), 813 make_tuple(3, 2, &vpx_sub_pixel_variance8x4_c, 0), 814 make_tuple(2, 3, &vpx_sub_pixel_variance4x8_c, 0), 815 make_tuple(2, 2, &vpx_sub_pixel_variance4x4_c, 0))); 816 817 INSTANTIATE_TEST_CASE_P( 818 C, VpxSubpelAvgVarianceTest, 819 ::testing::Values(make_tuple(6, 6, &vpx_sub_pixel_avg_variance64x64_c, 0), 820 make_tuple(6, 5, &vpx_sub_pixel_avg_variance64x32_c, 0), 821 make_tuple(5, 6, &vpx_sub_pixel_avg_variance32x64_c, 0), 822 make_tuple(5, 5, &vpx_sub_pixel_avg_variance32x32_c, 0), 823 make_tuple(5, 4, &vpx_sub_pixel_avg_variance32x16_c, 0), 824 make_tuple(4, 5, &vpx_sub_pixel_avg_variance16x32_c, 0), 825 make_tuple(4, 4, &vpx_sub_pixel_avg_variance16x16_c, 0), 826 make_tuple(4, 3, &vpx_sub_pixel_avg_variance16x8_c, 0), 827 make_tuple(3, 4, &vpx_sub_pixel_avg_variance8x16_c, 0), 828 make_tuple(3, 3, &vpx_sub_pixel_avg_variance8x8_c, 0), 829 make_tuple(3, 2, &vpx_sub_pixel_avg_variance8x4_c, 0), 830 make_tuple(2, 3, &vpx_sub_pixel_avg_variance4x8_c, 0), 831 make_tuple(2, 2, &vpx_sub_pixel_avg_variance4x4_c, 0))); 832 833 #if CONFIG_VP9_HIGHBITDEPTH 834 typedef MainTestClass<VarianceMxNFunc> VpxHBDMseTest; 835 typedef MainTestClass<VarianceMxNFunc> VpxHBDVarianceTest; 836 typedef SubpelVarianceTest<SubpixVarMxNFunc> VpxHBDSubpelVarianceTest; 837 typedef SubpelVarianceTest<SubpixAvgVarMxNFunc> VpxHBDSubpelAvgVarianceTest; 838 839 TEST_P(VpxHBDMseTest, RefMse) { RefTestMse(); } 840 TEST_P(VpxHBDMseTest, MaxMse) { MaxTestMse(); } 841 TEST_P(VpxHBDVarianceTest, Zero) { ZeroTest(); } 842 TEST_P(VpxHBDVarianceTest, Ref) { RefTest(); } 843 TEST_P(VpxHBDVarianceTest, RefStride) { RefStrideTest(); } 844 TEST_P(VpxHBDVarianceTest, OneQuarter) { OneQuarterTest(); } 845 TEST_P(VpxHBDVarianceTest, DISABLED_Speed) { SpeedTest(); } 846 TEST_P(VpxHBDSubpelVarianceTest, Ref) { RefTest(); } 847 TEST_P(VpxHBDSubpelVarianceTest, ExtremeRef) { ExtremeRefTest(); } 848 TEST_P(VpxHBDSubpelAvgVarianceTest, Ref) { RefTest(); } 849 850 /* TODO(debargha): This test does not support the highbd version 851 INSTANTIATE_TEST_CASE_P( 852 C, VpxHBDMseTest, 853 ::testing::Values(make_tuple(4, 4, &vpx_highbd_12_mse16x16_c), 854 make_tuple(4, 4, &vpx_highbd_12_mse16x8_c), 855 make_tuple(4, 4, &vpx_highbd_12_mse8x16_c), 856 make_tuple(4, 4, &vpx_highbd_12_mse8x8_c), 857 make_tuple(4, 4, &vpx_highbd_10_mse16x16_c), 858 make_tuple(4, 4, &vpx_highbd_10_mse16x8_c), 859 make_tuple(4, 4, &vpx_highbd_10_mse8x16_c), 860 make_tuple(4, 4, &vpx_highbd_10_mse8x8_c), 861 make_tuple(4, 4, &vpx_highbd_8_mse16x16_c), 862 make_tuple(4, 4, &vpx_highbd_8_mse16x8_c), 863 make_tuple(4, 4, &vpx_highbd_8_mse8x16_c), 864 make_tuple(4, 4, &vpx_highbd_8_mse8x8_c))); 865 */ 866 867 INSTANTIATE_TEST_CASE_P( 868 C, VpxHBDVarianceTest, 869 ::testing::Values(VarianceParams(6, 6, &vpx_highbd_12_variance64x64_c, 12), 870 VarianceParams(6, 5, &vpx_highbd_12_variance64x32_c, 12), 871 VarianceParams(5, 6, &vpx_highbd_12_variance32x64_c, 12), 872 VarianceParams(5, 5, &vpx_highbd_12_variance32x32_c, 12), 873 VarianceParams(5, 4, &vpx_highbd_12_variance32x16_c, 12), 874 VarianceParams(4, 5, &vpx_highbd_12_variance16x32_c, 12), 875 VarianceParams(4, 4, &vpx_highbd_12_variance16x16_c, 12), 876 VarianceParams(4, 3, &vpx_highbd_12_variance16x8_c, 12), 877 VarianceParams(3, 4, &vpx_highbd_12_variance8x16_c, 12), 878 VarianceParams(3, 3, &vpx_highbd_12_variance8x8_c, 12), 879 VarianceParams(3, 2, &vpx_highbd_12_variance8x4_c, 12), 880 VarianceParams(2, 3, &vpx_highbd_12_variance4x8_c, 12), 881 VarianceParams(2, 2, &vpx_highbd_12_variance4x4_c, 12), 882 VarianceParams(6, 6, &vpx_highbd_10_variance64x64_c, 10), 883 VarianceParams(6, 5, &vpx_highbd_10_variance64x32_c, 10), 884 VarianceParams(5, 6, &vpx_highbd_10_variance32x64_c, 10), 885 VarianceParams(5, 5, &vpx_highbd_10_variance32x32_c, 10), 886 VarianceParams(5, 4, &vpx_highbd_10_variance32x16_c, 10), 887 VarianceParams(4, 5, &vpx_highbd_10_variance16x32_c, 10), 888 VarianceParams(4, 4, &vpx_highbd_10_variance16x16_c, 10), 889 VarianceParams(4, 3, &vpx_highbd_10_variance16x8_c, 10), 890 VarianceParams(3, 4, &vpx_highbd_10_variance8x16_c, 10), 891 VarianceParams(3, 3, &vpx_highbd_10_variance8x8_c, 10), 892 VarianceParams(3, 2, &vpx_highbd_10_variance8x4_c, 10), 893 VarianceParams(2, 3, &vpx_highbd_10_variance4x8_c, 10), 894 VarianceParams(2, 2, &vpx_highbd_10_variance4x4_c, 10), 895 VarianceParams(6, 6, &vpx_highbd_8_variance64x64_c, 8), 896 VarianceParams(6, 5, &vpx_highbd_8_variance64x32_c, 8), 897 VarianceParams(5, 6, &vpx_highbd_8_variance32x64_c, 8), 898 VarianceParams(5, 5, &vpx_highbd_8_variance32x32_c, 8), 899 VarianceParams(5, 4, &vpx_highbd_8_variance32x16_c, 8), 900 VarianceParams(4, 5, &vpx_highbd_8_variance16x32_c, 8), 901 VarianceParams(4, 4, &vpx_highbd_8_variance16x16_c, 8), 902 VarianceParams(4, 3, &vpx_highbd_8_variance16x8_c, 8), 903 VarianceParams(3, 4, &vpx_highbd_8_variance8x16_c, 8), 904 VarianceParams(3, 3, &vpx_highbd_8_variance8x8_c, 8), 905 VarianceParams(3, 2, &vpx_highbd_8_variance8x4_c, 8), 906 VarianceParams(2, 3, &vpx_highbd_8_variance4x8_c, 8), 907 VarianceParams(2, 2, &vpx_highbd_8_variance4x4_c, 8))); 908 909 INSTANTIATE_TEST_CASE_P( 910 C, VpxHBDSubpelVarianceTest, 911 ::testing::Values( 912 make_tuple(6, 6, &vpx_highbd_8_sub_pixel_variance64x64_c, 8), 913 make_tuple(6, 5, &vpx_highbd_8_sub_pixel_variance64x32_c, 8), 914 make_tuple(5, 6, &vpx_highbd_8_sub_pixel_variance32x64_c, 8), 915 make_tuple(5, 5, &vpx_highbd_8_sub_pixel_variance32x32_c, 8), 916 make_tuple(5, 4, &vpx_highbd_8_sub_pixel_variance32x16_c, 8), 917 make_tuple(4, 5, &vpx_highbd_8_sub_pixel_variance16x32_c, 8), 918 make_tuple(4, 4, &vpx_highbd_8_sub_pixel_variance16x16_c, 8), 919 make_tuple(4, 3, &vpx_highbd_8_sub_pixel_variance16x8_c, 8), 920 make_tuple(3, 4, &vpx_highbd_8_sub_pixel_variance8x16_c, 8), 921 make_tuple(3, 3, &vpx_highbd_8_sub_pixel_variance8x8_c, 8), 922 make_tuple(3, 2, &vpx_highbd_8_sub_pixel_variance8x4_c, 8), 923 make_tuple(2, 3, &vpx_highbd_8_sub_pixel_variance4x8_c, 8), 924 make_tuple(2, 2, &vpx_highbd_8_sub_pixel_variance4x4_c, 8), 925 make_tuple(6, 6, &vpx_highbd_10_sub_pixel_variance64x64_c, 10), 926 make_tuple(6, 5, &vpx_highbd_10_sub_pixel_variance64x32_c, 10), 927 make_tuple(5, 6, &vpx_highbd_10_sub_pixel_variance32x64_c, 10), 928 make_tuple(5, 5, &vpx_highbd_10_sub_pixel_variance32x32_c, 10), 929 make_tuple(5, 4, &vpx_highbd_10_sub_pixel_variance32x16_c, 10), 930 make_tuple(4, 5, &vpx_highbd_10_sub_pixel_variance16x32_c, 10), 931 make_tuple(4, 4, &vpx_highbd_10_sub_pixel_variance16x16_c, 10), 932 make_tuple(4, 3, &vpx_highbd_10_sub_pixel_variance16x8_c, 10), 933 make_tuple(3, 4, &vpx_highbd_10_sub_pixel_variance8x16_c, 10), 934 make_tuple(3, 3, &vpx_highbd_10_sub_pixel_variance8x8_c, 10), 935 make_tuple(3, 2, &vpx_highbd_10_sub_pixel_variance8x4_c, 10), 936 make_tuple(2, 3, &vpx_highbd_10_sub_pixel_variance4x8_c, 10), 937 make_tuple(2, 2, &vpx_highbd_10_sub_pixel_variance4x4_c, 10), 938 make_tuple(6, 6, &vpx_highbd_12_sub_pixel_variance64x64_c, 12), 939 make_tuple(6, 5, &vpx_highbd_12_sub_pixel_variance64x32_c, 12), 940 make_tuple(5, 6, &vpx_highbd_12_sub_pixel_variance32x64_c, 12), 941 make_tuple(5, 5, &vpx_highbd_12_sub_pixel_variance32x32_c, 12), 942 make_tuple(5, 4, &vpx_highbd_12_sub_pixel_variance32x16_c, 12), 943 make_tuple(4, 5, &vpx_highbd_12_sub_pixel_variance16x32_c, 12), 944 make_tuple(4, 4, &vpx_highbd_12_sub_pixel_variance16x16_c, 12), 945 make_tuple(4, 3, &vpx_highbd_12_sub_pixel_variance16x8_c, 12), 946 make_tuple(3, 4, &vpx_highbd_12_sub_pixel_variance8x16_c, 12), 947 make_tuple(3, 3, &vpx_highbd_12_sub_pixel_variance8x8_c, 12), 948 make_tuple(3, 2, &vpx_highbd_12_sub_pixel_variance8x4_c, 12), 949 make_tuple(2, 3, &vpx_highbd_12_sub_pixel_variance4x8_c, 12), 950 make_tuple(2, 2, &vpx_highbd_12_sub_pixel_variance4x4_c, 12))); 951 952 INSTANTIATE_TEST_CASE_P( 953 C, VpxHBDSubpelAvgVarianceTest, 954 ::testing::Values( 955 make_tuple(6, 6, &vpx_highbd_8_sub_pixel_avg_variance64x64_c, 8), 956 make_tuple(6, 5, &vpx_highbd_8_sub_pixel_avg_variance64x32_c, 8), 957 make_tuple(5, 6, &vpx_highbd_8_sub_pixel_avg_variance32x64_c, 8), 958 make_tuple(5, 5, &vpx_highbd_8_sub_pixel_avg_variance32x32_c, 8), 959 make_tuple(5, 4, &vpx_highbd_8_sub_pixel_avg_variance32x16_c, 8), 960 make_tuple(4, 5, &vpx_highbd_8_sub_pixel_avg_variance16x32_c, 8), 961 make_tuple(4, 4, &vpx_highbd_8_sub_pixel_avg_variance16x16_c, 8), 962 make_tuple(4, 3, &vpx_highbd_8_sub_pixel_avg_variance16x8_c, 8), 963 make_tuple(3, 4, &vpx_highbd_8_sub_pixel_avg_variance8x16_c, 8), 964 make_tuple(3, 3, &vpx_highbd_8_sub_pixel_avg_variance8x8_c, 8), 965 make_tuple(3, 2, &vpx_highbd_8_sub_pixel_avg_variance8x4_c, 8), 966 make_tuple(2, 3, &vpx_highbd_8_sub_pixel_avg_variance4x8_c, 8), 967 make_tuple(2, 2, &vpx_highbd_8_sub_pixel_avg_variance4x4_c, 8), 968 make_tuple(6, 6, &vpx_highbd_10_sub_pixel_avg_variance64x64_c, 10), 969 make_tuple(6, 5, &vpx_highbd_10_sub_pixel_avg_variance64x32_c, 10), 970 make_tuple(5, 6, &vpx_highbd_10_sub_pixel_avg_variance32x64_c, 10), 971 make_tuple(5, 5, &vpx_highbd_10_sub_pixel_avg_variance32x32_c, 10), 972 make_tuple(5, 4, &vpx_highbd_10_sub_pixel_avg_variance32x16_c, 10), 973 make_tuple(4, 5, &vpx_highbd_10_sub_pixel_avg_variance16x32_c, 10), 974 make_tuple(4, 4, &vpx_highbd_10_sub_pixel_avg_variance16x16_c, 10), 975 make_tuple(4, 3, &vpx_highbd_10_sub_pixel_avg_variance16x8_c, 10), 976 make_tuple(3, 4, &vpx_highbd_10_sub_pixel_avg_variance8x16_c, 10), 977 make_tuple(3, 3, &vpx_highbd_10_sub_pixel_avg_variance8x8_c, 10), 978 make_tuple(3, 2, &vpx_highbd_10_sub_pixel_avg_variance8x4_c, 10), 979 make_tuple(2, 3, &vpx_highbd_10_sub_pixel_avg_variance4x8_c, 10), 980 make_tuple(2, 2, &vpx_highbd_10_sub_pixel_avg_variance4x4_c, 10), 981 make_tuple(6, 6, &vpx_highbd_12_sub_pixel_avg_variance64x64_c, 12), 982 make_tuple(6, 5, &vpx_highbd_12_sub_pixel_avg_variance64x32_c, 12), 983 make_tuple(5, 6, &vpx_highbd_12_sub_pixel_avg_variance32x64_c, 12), 984 make_tuple(5, 5, &vpx_highbd_12_sub_pixel_avg_variance32x32_c, 12), 985 make_tuple(5, 4, &vpx_highbd_12_sub_pixel_avg_variance32x16_c, 12), 986 make_tuple(4, 5, &vpx_highbd_12_sub_pixel_avg_variance16x32_c, 12), 987 make_tuple(4, 4, &vpx_highbd_12_sub_pixel_avg_variance16x16_c, 12), 988 make_tuple(4, 3, &vpx_highbd_12_sub_pixel_avg_variance16x8_c, 12), 989 make_tuple(3, 4, &vpx_highbd_12_sub_pixel_avg_variance8x16_c, 12), 990 make_tuple(3, 3, &vpx_highbd_12_sub_pixel_avg_variance8x8_c, 12), 991 make_tuple(3, 2, &vpx_highbd_12_sub_pixel_avg_variance8x4_c, 12), 992 make_tuple(2, 3, &vpx_highbd_12_sub_pixel_avg_variance4x8_c, 12), 993 make_tuple(2, 2, &vpx_highbd_12_sub_pixel_avg_variance4x4_c, 12))); 994 #endif // CONFIG_VP9_HIGHBITDEPTH 995 996 #if HAVE_SSE2 997 INSTANTIATE_TEST_CASE_P(SSE2, SumOfSquaresTest, 998 ::testing::Values(vpx_get_mb_ss_sse2)); 999 1000 INSTANTIATE_TEST_CASE_P(SSE2, VpxMseTest, 1001 ::testing::Values(MseParams(4, 4, &vpx_mse16x16_sse2), 1002 MseParams(4, 3, &vpx_mse16x8_sse2), 1003 MseParams(3, 4, &vpx_mse8x16_sse2), 1004 MseParams(3, 3, &vpx_mse8x8_sse2))); 1005 1006 INSTANTIATE_TEST_CASE_P( 1007 SSE2, VpxVarianceTest, 1008 ::testing::Values(VarianceParams(6, 6, &vpx_variance64x64_sse2), 1009 VarianceParams(6, 5, &vpx_variance64x32_sse2), 1010 VarianceParams(5, 6, &vpx_variance32x64_sse2), 1011 VarianceParams(5, 5, &vpx_variance32x32_sse2), 1012 VarianceParams(5, 4, &vpx_variance32x16_sse2), 1013 VarianceParams(4, 5, &vpx_variance16x32_sse2), 1014 VarianceParams(4, 4, &vpx_variance16x16_sse2), 1015 VarianceParams(4, 3, &vpx_variance16x8_sse2), 1016 VarianceParams(3, 4, &vpx_variance8x16_sse2), 1017 VarianceParams(3, 3, &vpx_variance8x8_sse2), 1018 VarianceParams(3, 2, &vpx_variance8x4_sse2), 1019 VarianceParams(2, 3, &vpx_variance4x8_sse2), 1020 VarianceParams(2, 2, &vpx_variance4x4_sse2))); 1021 1022 INSTANTIATE_TEST_CASE_P( 1023 SSE2, VpxSubpelVarianceTest, 1024 ::testing::Values(make_tuple(6, 6, &vpx_sub_pixel_variance64x64_sse2, 0), 1025 make_tuple(6, 5, &vpx_sub_pixel_variance64x32_sse2, 0), 1026 make_tuple(5, 6, &vpx_sub_pixel_variance32x64_sse2, 0), 1027 make_tuple(5, 5, &vpx_sub_pixel_variance32x32_sse2, 0), 1028 make_tuple(5, 4, &vpx_sub_pixel_variance32x16_sse2, 0), 1029 make_tuple(4, 5, &vpx_sub_pixel_variance16x32_sse2, 0), 1030 make_tuple(4, 4, &vpx_sub_pixel_variance16x16_sse2, 0), 1031 make_tuple(4, 3, &vpx_sub_pixel_variance16x8_sse2, 0), 1032 make_tuple(3, 4, &vpx_sub_pixel_variance8x16_sse2, 0), 1033 make_tuple(3, 3, &vpx_sub_pixel_variance8x8_sse2, 0), 1034 make_tuple(3, 2, &vpx_sub_pixel_variance8x4_sse2, 0), 1035 make_tuple(2, 3, &vpx_sub_pixel_variance4x8_sse2, 0), 1036 make_tuple(2, 2, &vpx_sub_pixel_variance4x4_sse2, 0))); 1037 1038 INSTANTIATE_TEST_CASE_P( 1039 SSE2, VpxSubpelAvgVarianceTest, 1040 ::testing::Values( 1041 make_tuple(6, 6, &vpx_sub_pixel_avg_variance64x64_sse2, 0), 1042 make_tuple(6, 5, &vpx_sub_pixel_avg_variance64x32_sse2, 0), 1043 make_tuple(5, 6, &vpx_sub_pixel_avg_variance32x64_sse2, 0), 1044 make_tuple(5, 5, &vpx_sub_pixel_avg_variance32x32_sse2, 0), 1045 make_tuple(5, 4, &vpx_sub_pixel_avg_variance32x16_sse2, 0), 1046 make_tuple(4, 5, &vpx_sub_pixel_avg_variance16x32_sse2, 0), 1047 make_tuple(4, 4, &vpx_sub_pixel_avg_variance16x16_sse2, 0), 1048 make_tuple(4, 3, &vpx_sub_pixel_avg_variance16x8_sse2, 0), 1049 make_tuple(3, 4, &vpx_sub_pixel_avg_variance8x16_sse2, 0), 1050 make_tuple(3, 3, &vpx_sub_pixel_avg_variance8x8_sse2, 0), 1051 make_tuple(3, 2, &vpx_sub_pixel_avg_variance8x4_sse2, 0), 1052 make_tuple(2, 3, &vpx_sub_pixel_avg_variance4x8_sse2, 0), 1053 make_tuple(2, 2, &vpx_sub_pixel_avg_variance4x4_sse2, 0))); 1054 1055 #if CONFIG_VP9_HIGHBITDEPTH 1056 /* TODO(debargha): This test does not support the highbd version 1057 INSTANTIATE_TEST_CASE_P( 1058 SSE2, VpxHBDMseTest, 1059 ::testing::Values(MseParams(4, 4, &vpx_highbd_12_mse16x16_sse2), 1060 MseParams(4, 3, &vpx_highbd_12_mse16x8_sse2), 1061 MseParams(3, 4, &vpx_highbd_12_mse8x16_sse2), 1062 MseParams(3, 3, &vpx_highbd_12_mse8x8_sse2), 1063 MseParams(4, 4, &vpx_highbd_10_mse16x16_sse2), 1064 MseParams(4, 3, &vpx_highbd_10_mse16x8_sse2), 1065 MseParams(3, 4, &vpx_highbd_10_mse8x16_sse2), 1066 MseParams(3, 3, &vpx_highbd_10_mse8x8_sse2), 1067 MseParams(4, 4, &vpx_highbd_8_mse16x16_sse2), 1068 MseParams(4, 3, &vpx_highbd_8_mse16x8_sse2), 1069 MseParams(3, 4, &vpx_highbd_8_mse8x16_sse2), 1070 MseParams(3, 3, &vpx_highbd_8_mse8x8_sse2))); 1071 */ 1072 1073 INSTANTIATE_TEST_CASE_P( 1074 SSE2, VpxHBDVarianceTest, 1075 ::testing::Values( 1076 VarianceParams(6, 6, &vpx_highbd_12_variance64x64_sse2, 12), 1077 VarianceParams(6, 5, &vpx_highbd_12_variance64x32_sse2, 12), 1078 VarianceParams(5, 6, &vpx_highbd_12_variance32x64_sse2, 12), 1079 VarianceParams(5, 5, &vpx_highbd_12_variance32x32_sse2, 12), 1080 VarianceParams(5, 4, &vpx_highbd_12_variance32x16_sse2, 12), 1081 VarianceParams(4, 5, &vpx_highbd_12_variance16x32_sse2, 12), 1082 VarianceParams(4, 4, &vpx_highbd_12_variance16x16_sse2, 12), 1083 VarianceParams(4, 3, &vpx_highbd_12_variance16x8_sse2, 12), 1084 VarianceParams(3, 4, &vpx_highbd_12_variance8x16_sse2, 12), 1085 VarianceParams(3, 3, &vpx_highbd_12_variance8x8_sse2, 12), 1086 VarianceParams(6, 6, &vpx_highbd_10_variance64x64_sse2, 10), 1087 VarianceParams(6, 5, &vpx_highbd_10_variance64x32_sse2, 10), 1088 VarianceParams(5, 6, &vpx_highbd_10_variance32x64_sse2, 10), 1089 VarianceParams(5, 5, &vpx_highbd_10_variance32x32_sse2, 10), 1090 VarianceParams(5, 4, &vpx_highbd_10_variance32x16_sse2, 10), 1091 VarianceParams(4, 5, &vpx_highbd_10_variance16x32_sse2, 10), 1092 VarianceParams(4, 4, &vpx_highbd_10_variance16x16_sse2, 10), 1093 VarianceParams(4, 3, &vpx_highbd_10_variance16x8_sse2, 10), 1094 VarianceParams(3, 4, &vpx_highbd_10_variance8x16_sse2, 10), 1095 VarianceParams(3, 3, &vpx_highbd_10_variance8x8_sse2, 10), 1096 VarianceParams(6, 6, &vpx_highbd_8_variance64x64_sse2, 8), 1097 VarianceParams(6, 5, &vpx_highbd_8_variance64x32_sse2, 8), 1098 VarianceParams(5, 6, &vpx_highbd_8_variance32x64_sse2, 8), 1099 VarianceParams(5, 5, &vpx_highbd_8_variance32x32_sse2, 8), 1100 VarianceParams(5, 4, &vpx_highbd_8_variance32x16_sse2, 8), 1101 VarianceParams(4, 5, &vpx_highbd_8_variance16x32_sse2, 8), 1102 VarianceParams(4, 4, &vpx_highbd_8_variance16x16_sse2, 8), 1103 VarianceParams(4, 3, &vpx_highbd_8_variance16x8_sse2, 8), 1104 VarianceParams(3, 4, &vpx_highbd_8_variance8x16_sse2, 8), 1105 VarianceParams(3, 3, &vpx_highbd_8_variance8x8_sse2, 8))); 1106 1107 INSTANTIATE_TEST_CASE_P( 1108 SSE2, VpxHBDSubpelVarianceTest, 1109 ::testing::Values( 1110 make_tuple(6, 6, &vpx_highbd_12_sub_pixel_variance64x64_sse2, 12), 1111 make_tuple(6, 5, &vpx_highbd_12_sub_pixel_variance64x32_sse2, 12), 1112 make_tuple(5, 6, &vpx_highbd_12_sub_pixel_variance32x64_sse2, 12), 1113 make_tuple(5, 5, &vpx_highbd_12_sub_pixel_variance32x32_sse2, 12), 1114 make_tuple(5, 4, &vpx_highbd_12_sub_pixel_variance32x16_sse2, 12), 1115 make_tuple(4, 5, &vpx_highbd_12_sub_pixel_variance16x32_sse2, 12), 1116 make_tuple(4, 4, &vpx_highbd_12_sub_pixel_variance16x16_sse2, 12), 1117 make_tuple(4, 3, &vpx_highbd_12_sub_pixel_variance16x8_sse2, 12), 1118 make_tuple(3, 4, &vpx_highbd_12_sub_pixel_variance8x16_sse2, 12), 1119 make_tuple(3, 3, &vpx_highbd_12_sub_pixel_variance8x8_sse2, 12), 1120 make_tuple(3, 2, &vpx_highbd_12_sub_pixel_variance8x4_sse2, 12), 1121 make_tuple(6, 6, &vpx_highbd_10_sub_pixel_variance64x64_sse2, 10), 1122 make_tuple(6, 5, &vpx_highbd_10_sub_pixel_variance64x32_sse2, 10), 1123 make_tuple(5, 6, &vpx_highbd_10_sub_pixel_variance32x64_sse2, 10), 1124 make_tuple(5, 5, &vpx_highbd_10_sub_pixel_variance32x32_sse2, 10), 1125 make_tuple(5, 4, &vpx_highbd_10_sub_pixel_variance32x16_sse2, 10), 1126 make_tuple(4, 5, &vpx_highbd_10_sub_pixel_variance16x32_sse2, 10), 1127 make_tuple(4, 4, &vpx_highbd_10_sub_pixel_variance16x16_sse2, 10), 1128 make_tuple(4, 3, &vpx_highbd_10_sub_pixel_variance16x8_sse2, 10), 1129 make_tuple(3, 4, &vpx_highbd_10_sub_pixel_variance8x16_sse2, 10), 1130 make_tuple(3, 3, &vpx_highbd_10_sub_pixel_variance8x8_sse2, 10), 1131 make_tuple(3, 2, &vpx_highbd_10_sub_pixel_variance8x4_sse2, 10), 1132 make_tuple(6, 6, &vpx_highbd_8_sub_pixel_variance64x64_sse2, 8), 1133 make_tuple(6, 5, &vpx_highbd_8_sub_pixel_variance64x32_sse2, 8), 1134 make_tuple(5, 6, &vpx_highbd_8_sub_pixel_variance32x64_sse2, 8), 1135 make_tuple(5, 5, &vpx_highbd_8_sub_pixel_variance32x32_sse2, 8), 1136 make_tuple(5, 4, &vpx_highbd_8_sub_pixel_variance32x16_sse2, 8), 1137 make_tuple(4, 5, &vpx_highbd_8_sub_pixel_variance16x32_sse2, 8), 1138 make_tuple(4, 4, &vpx_highbd_8_sub_pixel_variance16x16_sse2, 8), 1139 make_tuple(4, 3, &vpx_highbd_8_sub_pixel_variance16x8_sse2, 8), 1140 make_tuple(3, 4, &vpx_highbd_8_sub_pixel_variance8x16_sse2, 8), 1141 make_tuple(3, 3, &vpx_highbd_8_sub_pixel_variance8x8_sse2, 8), 1142 make_tuple(3, 2, &vpx_highbd_8_sub_pixel_variance8x4_sse2, 8))); 1143 1144 INSTANTIATE_TEST_CASE_P( 1145 SSE2, VpxHBDSubpelAvgVarianceTest, 1146 ::testing::Values( 1147 make_tuple(6, 6, &vpx_highbd_12_sub_pixel_avg_variance64x64_sse2, 12), 1148 make_tuple(6, 5, &vpx_highbd_12_sub_pixel_avg_variance64x32_sse2, 12), 1149 make_tuple(5, 6, &vpx_highbd_12_sub_pixel_avg_variance32x64_sse2, 12), 1150 make_tuple(5, 5, &vpx_highbd_12_sub_pixel_avg_variance32x32_sse2, 12), 1151 make_tuple(5, 4, &vpx_highbd_12_sub_pixel_avg_variance32x16_sse2, 12), 1152 make_tuple(4, 5, &vpx_highbd_12_sub_pixel_avg_variance16x32_sse2, 12), 1153 make_tuple(4, 4, &vpx_highbd_12_sub_pixel_avg_variance16x16_sse2, 12), 1154 make_tuple(4, 3, &vpx_highbd_12_sub_pixel_avg_variance16x8_sse2, 12), 1155 make_tuple(3, 4, &vpx_highbd_12_sub_pixel_avg_variance8x16_sse2, 12), 1156 make_tuple(3, 3, &vpx_highbd_12_sub_pixel_avg_variance8x8_sse2, 12), 1157 make_tuple(3, 2, &vpx_highbd_12_sub_pixel_avg_variance8x4_sse2, 12), 1158 make_tuple(6, 6, &vpx_highbd_10_sub_pixel_avg_variance64x64_sse2, 10), 1159 make_tuple(6, 5, &vpx_highbd_10_sub_pixel_avg_variance64x32_sse2, 10), 1160 make_tuple(5, 6, &vpx_highbd_10_sub_pixel_avg_variance32x64_sse2, 10), 1161 make_tuple(5, 5, &vpx_highbd_10_sub_pixel_avg_variance32x32_sse2, 10), 1162 make_tuple(5, 4, &vpx_highbd_10_sub_pixel_avg_variance32x16_sse2, 10), 1163 make_tuple(4, 5, &vpx_highbd_10_sub_pixel_avg_variance16x32_sse2, 10), 1164 make_tuple(4, 4, &vpx_highbd_10_sub_pixel_avg_variance16x16_sse2, 10), 1165 make_tuple(4, 3, &vpx_highbd_10_sub_pixel_avg_variance16x8_sse2, 10), 1166 make_tuple(3, 4, &vpx_highbd_10_sub_pixel_avg_variance8x16_sse2, 10), 1167 make_tuple(3, 3, &vpx_highbd_10_sub_pixel_avg_variance8x8_sse2, 10), 1168 make_tuple(3, 2, &vpx_highbd_10_sub_pixel_avg_variance8x4_sse2, 10), 1169 make_tuple(6, 6, &vpx_highbd_8_sub_pixel_avg_variance64x64_sse2, 8), 1170 make_tuple(6, 5, &vpx_highbd_8_sub_pixel_avg_variance64x32_sse2, 8), 1171 make_tuple(5, 6, &vpx_highbd_8_sub_pixel_avg_variance32x64_sse2, 8), 1172 make_tuple(5, 5, &vpx_highbd_8_sub_pixel_avg_variance32x32_sse2, 8), 1173 make_tuple(5, 4, &vpx_highbd_8_sub_pixel_avg_variance32x16_sse2, 8), 1174 make_tuple(4, 5, &vpx_highbd_8_sub_pixel_avg_variance16x32_sse2, 8), 1175 make_tuple(4, 4, &vpx_highbd_8_sub_pixel_avg_variance16x16_sse2, 8), 1176 make_tuple(4, 3, &vpx_highbd_8_sub_pixel_avg_variance16x8_sse2, 8), 1177 make_tuple(3, 4, &vpx_highbd_8_sub_pixel_avg_variance8x16_sse2, 8), 1178 make_tuple(3, 3, &vpx_highbd_8_sub_pixel_avg_variance8x8_sse2, 8), 1179 make_tuple(3, 2, &vpx_highbd_8_sub_pixel_avg_variance8x4_sse2, 8))); 1180 #endif // CONFIG_VP9_HIGHBITDEPTH 1181 #endif // HAVE_SSE2 1182 1183 #if HAVE_SSSE3 1184 INSTANTIATE_TEST_CASE_P( 1185 SSSE3, VpxSubpelVarianceTest, 1186 ::testing::Values(make_tuple(6, 6, &vpx_sub_pixel_variance64x64_ssse3, 0), 1187 make_tuple(6, 5, &vpx_sub_pixel_variance64x32_ssse3, 0), 1188 make_tuple(5, 6, &vpx_sub_pixel_variance32x64_ssse3, 0), 1189 make_tuple(5, 5, &vpx_sub_pixel_variance32x32_ssse3, 0), 1190 make_tuple(5, 4, &vpx_sub_pixel_variance32x16_ssse3, 0), 1191 make_tuple(4, 5, &vpx_sub_pixel_variance16x32_ssse3, 0), 1192 make_tuple(4, 4, &vpx_sub_pixel_variance16x16_ssse3, 0), 1193 make_tuple(4, 3, &vpx_sub_pixel_variance16x8_ssse3, 0), 1194 make_tuple(3, 4, &vpx_sub_pixel_variance8x16_ssse3, 0), 1195 make_tuple(3, 3, &vpx_sub_pixel_variance8x8_ssse3, 0), 1196 make_tuple(3, 2, &vpx_sub_pixel_variance8x4_ssse3, 0), 1197 make_tuple(2, 3, &vpx_sub_pixel_variance4x8_ssse3, 0), 1198 make_tuple(2, 2, &vpx_sub_pixel_variance4x4_ssse3, 0))); 1199 1200 INSTANTIATE_TEST_CASE_P( 1201 SSSE3, VpxSubpelAvgVarianceTest, 1202 ::testing::Values( 1203 make_tuple(6, 6, &vpx_sub_pixel_avg_variance64x64_ssse3, 0), 1204 make_tuple(6, 5, &vpx_sub_pixel_avg_variance64x32_ssse3, 0), 1205 make_tuple(5, 6, &vpx_sub_pixel_avg_variance32x64_ssse3, 0), 1206 make_tuple(5, 5, &vpx_sub_pixel_avg_variance32x32_ssse3, 0), 1207 make_tuple(5, 4, &vpx_sub_pixel_avg_variance32x16_ssse3, 0), 1208 make_tuple(4, 5, &vpx_sub_pixel_avg_variance16x32_ssse3, 0), 1209 make_tuple(4, 4, &vpx_sub_pixel_avg_variance16x16_ssse3, 0), 1210 make_tuple(4, 3, &vpx_sub_pixel_avg_variance16x8_ssse3, 0), 1211 make_tuple(3, 4, &vpx_sub_pixel_avg_variance8x16_ssse3, 0), 1212 make_tuple(3, 3, &vpx_sub_pixel_avg_variance8x8_ssse3, 0), 1213 make_tuple(3, 2, &vpx_sub_pixel_avg_variance8x4_ssse3, 0), 1214 make_tuple(2, 3, &vpx_sub_pixel_avg_variance4x8_ssse3, 0), 1215 make_tuple(2, 2, &vpx_sub_pixel_avg_variance4x4_ssse3, 0))); 1216 #endif // HAVE_SSSE3 1217 1218 #if HAVE_AVX2 1219 INSTANTIATE_TEST_CASE_P(AVX2, VpxMseTest, 1220 ::testing::Values(MseParams(4, 4, &vpx_mse16x16_avx2))); 1221 1222 INSTANTIATE_TEST_CASE_P( 1223 AVX2, VpxVarianceTest, 1224 ::testing::Values(VarianceParams(6, 6, &vpx_variance64x64_avx2), 1225 VarianceParams(6, 5, &vpx_variance64x32_avx2), 1226 VarianceParams(5, 5, &vpx_variance32x32_avx2), 1227 VarianceParams(5, 4, &vpx_variance32x16_avx2), 1228 VarianceParams(4, 4, &vpx_variance16x16_avx2))); 1229 1230 INSTANTIATE_TEST_CASE_P( 1231 AVX2, VpxSubpelVarianceTest, 1232 ::testing::Values(make_tuple(6, 6, &vpx_sub_pixel_variance64x64_avx2, 0), 1233 make_tuple(5, 5, &vpx_sub_pixel_variance32x32_avx2, 0))); 1234 1235 INSTANTIATE_TEST_CASE_P( 1236 AVX2, VpxSubpelAvgVarianceTest, 1237 ::testing::Values( 1238 make_tuple(6, 6, &vpx_sub_pixel_avg_variance64x64_avx2, 0), 1239 make_tuple(5, 5, &vpx_sub_pixel_avg_variance32x32_avx2, 0))); 1240 #endif // HAVE_AVX2 1241 1242 #if HAVE_NEON 1243 INSTANTIATE_TEST_CASE_P(NEON, VpxSseTest, 1244 ::testing::Values(SseParams(2, 2, 1245 &vpx_get4x4sse_cs_neon))); 1246 1247 INSTANTIATE_TEST_CASE_P(NEON, VpxMseTest, 1248 ::testing::Values(MseParams(4, 4, &vpx_mse16x16_neon))); 1249 1250 INSTANTIATE_TEST_CASE_P( 1251 NEON, VpxVarianceTest, 1252 ::testing::Values(VarianceParams(6, 6, &vpx_variance64x64_neon), 1253 VarianceParams(6, 5, &vpx_variance64x32_neon), 1254 VarianceParams(5, 6, &vpx_variance32x64_neon), 1255 VarianceParams(5, 5, &vpx_variance32x32_neon), 1256 VarianceParams(5, 4, &vpx_variance32x16_neon), 1257 VarianceParams(4, 5, &vpx_variance16x32_neon), 1258 VarianceParams(4, 4, &vpx_variance16x16_neon), 1259 VarianceParams(4, 3, &vpx_variance16x8_neon), 1260 VarianceParams(3, 4, &vpx_variance8x16_neon), 1261 VarianceParams(3, 3, &vpx_variance8x8_neon), 1262 VarianceParams(3, 2, &vpx_variance8x4_neon), 1263 VarianceParams(2, 3, &vpx_variance4x8_neon), 1264 VarianceParams(2, 2, &vpx_variance4x4_neon))); 1265 1266 INSTANTIATE_TEST_CASE_P( 1267 NEON, VpxSubpelVarianceTest, 1268 ::testing::Values(make_tuple(6, 6, &vpx_sub_pixel_variance64x64_neon, 0), 1269 make_tuple(6, 5, &vpx_sub_pixel_variance64x32_neon, 0), 1270 make_tuple(5, 6, &vpx_sub_pixel_variance32x64_neon, 0), 1271 make_tuple(5, 5, &vpx_sub_pixel_variance32x32_neon, 0), 1272 make_tuple(5, 4, &vpx_sub_pixel_variance32x16_neon, 0), 1273 make_tuple(4, 5, &vpx_sub_pixel_variance16x32_neon, 0), 1274 make_tuple(4, 4, &vpx_sub_pixel_variance16x16_neon, 0), 1275 make_tuple(4, 3, &vpx_sub_pixel_variance16x8_neon, 0), 1276 make_tuple(3, 4, &vpx_sub_pixel_variance8x16_neon, 0), 1277 make_tuple(3, 3, &vpx_sub_pixel_variance8x8_neon, 0), 1278 make_tuple(3, 2, &vpx_sub_pixel_variance8x4_neon, 0))); 1279 #endif // HAVE_NEON 1280 1281 #if HAVE_MSA 1282 INSTANTIATE_TEST_CASE_P(MSA, SumOfSquaresTest, 1283 ::testing::Values(vpx_get_mb_ss_msa)); 1284 1285 INSTANTIATE_TEST_CASE_P(MSA, VpxSseTest, 1286 ::testing::Values(SseParams(2, 2, 1287 &vpx_get4x4sse_cs_msa))); 1288 1289 INSTANTIATE_TEST_CASE_P(MSA, VpxMseTest, 1290 ::testing::Values(MseParams(4, 4, &vpx_mse16x16_msa), 1291 MseParams(4, 3, &vpx_mse16x8_msa), 1292 MseParams(3, 4, &vpx_mse8x16_msa), 1293 MseParams(3, 3, &vpx_mse8x8_msa))); 1294 1295 INSTANTIATE_TEST_CASE_P( 1296 MSA, VpxVarianceTest, 1297 ::testing::Values(VarianceParams(6, 6, &vpx_variance64x64_msa), 1298 VarianceParams(6, 5, &vpx_variance64x32_msa), 1299 VarianceParams(5, 6, &vpx_variance32x64_msa), 1300 VarianceParams(5, 5, &vpx_variance32x32_msa), 1301 VarianceParams(5, 4, &vpx_variance32x16_msa), 1302 VarianceParams(4, 5, &vpx_variance16x32_msa), 1303 VarianceParams(4, 4, &vpx_variance16x16_msa), 1304 VarianceParams(4, 3, &vpx_variance16x8_msa), 1305 VarianceParams(3, 4, &vpx_variance8x16_msa), 1306 VarianceParams(3, 3, &vpx_variance8x8_msa), 1307 VarianceParams(3, 2, &vpx_variance8x4_msa), 1308 VarianceParams(2, 3, &vpx_variance4x8_msa), 1309 VarianceParams(2, 2, &vpx_variance4x4_msa))); 1310 1311 INSTANTIATE_TEST_CASE_P( 1312 MSA, VpxSubpelVarianceTest, 1313 ::testing::Values(make_tuple(2, 2, &vpx_sub_pixel_variance4x4_msa, 0), 1314 make_tuple(2, 3, &vpx_sub_pixel_variance4x8_msa, 0), 1315 make_tuple(3, 2, &vpx_sub_pixel_variance8x4_msa, 0), 1316 make_tuple(3, 3, &vpx_sub_pixel_variance8x8_msa, 0), 1317 make_tuple(3, 4, &vpx_sub_pixel_variance8x16_msa, 0), 1318 make_tuple(4, 3, &vpx_sub_pixel_variance16x8_msa, 0), 1319 make_tuple(4, 4, &vpx_sub_pixel_variance16x16_msa, 0), 1320 make_tuple(4, 5, &vpx_sub_pixel_variance16x32_msa, 0), 1321 make_tuple(5, 4, &vpx_sub_pixel_variance32x16_msa, 0), 1322 make_tuple(5, 5, &vpx_sub_pixel_variance32x32_msa, 0), 1323 make_tuple(5, 6, &vpx_sub_pixel_variance32x64_msa, 0), 1324 make_tuple(6, 5, &vpx_sub_pixel_variance64x32_msa, 0), 1325 make_tuple(6, 6, &vpx_sub_pixel_variance64x64_msa, 0))); 1326 1327 INSTANTIATE_TEST_CASE_P( 1328 MSA, VpxSubpelAvgVarianceTest, 1329 ::testing::Values(make_tuple(6, 6, &vpx_sub_pixel_avg_variance64x64_msa, 0), 1330 make_tuple(6, 5, &vpx_sub_pixel_avg_variance64x32_msa, 0), 1331 make_tuple(5, 6, &vpx_sub_pixel_avg_variance32x64_msa, 0), 1332 make_tuple(5, 5, &vpx_sub_pixel_avg_variance32x32_msa, 0), 1333 make_tuple(5, 4, &vpx_sub_pixel_avg_variance32x16_msa, 0), 1334 make_tuple(4, 5, &vpx_sub_pixel_avg_variance16x32_msa, 0), 1335 make_tuple(4, 4, &vpx_sub_pixel_avg_variance16x16_msa, 0), 1336 make_tuple(4, 3, &vpx_sub_pixel_avg_variance16x8_msa, 0), 1337 make_tuple(3, 4, &vpx_sub_pixel_avg_variance8x16_msa, 0), 1338 make_tuple(3, 3, &vpx_sub_pixel_avg_variance8x8_msa, 0), 1339 make_tuple(3, 2, &vpx_sub_pixel_avg_variance8x4_msa, 0), 1340 make_tuple(2, 3, &vpx_sub_pixel_avg_variance4x8_msa, 0), 1341 make_tuple(2, 2, &vpx_sub_pixel_avg_variance4x4_msa, 0))); 1342 #endif // HAVE_MSA 1343 1344 #if HAVE_VSX 1345 INSTANTIATE_TEST_CASE_P(VSX, SumOfSquaresTest, 1346 ::testing::Values(vpx_get_mb_ss_vsx)); 1347 1348 INSTANTIATE_TEST_CASE_P(VSX, VpxSseTest, 1349 ::testing::Values(SseParams(2, 2, 1350 &vpx_get4x4sse_cs_vsx))); 1351 #endif // HAVE_VSX 1352 } // namespace 1353
