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 < (1 << 30) / 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 template <typename FunctionType> 565 class SubpelVarianceTest 566 : public ::testing::TestWithParam<TestParams<FunctionType> > { 567 public: 568 virtual void SetUp() { 569 params_ = this->GetParam(); 570 571 rnd_.Reset(ACMRandom::DeterministicSeed()); 572 if (!use_high_bit_depth()) { 573 src_ = reinterpret_cast<uint8_t *>(vpx_memalign(16, block_size())); 574 sec_ = reinterpret_cast<uint8_t *>(vpx_memalign(16, block_size())); 575 ref_ = new uint8_t[block_size() + width() + height() + 1]; 576 #if CONFIG_VP9_HIGHBITDEPTH 577 } else { 578 src_ = CONVERT_TO_BYTEPTR(reinterpret_cast<uint16_t *>( 579 vpx_memalign(16, block_size() * sizeof(uint16_t)))); 580 sec_ = CONVERT_TO_BYTEPTR(reinterpret_cast<uint16_t *>( 581 vpx_memalign(16, block_size() * sizeof(uint16_t)))); 582 ref_ = CONVERT_TO_BYTEPTR( 583 new uint16_t[block_size() + width() + height() + 1]); 584 #endif // CONFIG_VP9_HIGHBITDEPTH 585 } 586 ASSERT_TRUE(src_ != NULL); 587 ASSERT_TRUE(sec_ != NULL); 588 ASSERT_TRUE(ref_ != NULL); 589 } 590 591 virtual void TearDown() { 592 if (!use_high_bit_depth()) { 593 vpx_free(src_); 594 delete[] ref_; 595 vpx_free(sec_); 596 #if CONFIG_VP9_HIGHBITDEPTH 597 } else { 598 vpx_free(CONVERT_TO_SHORTPTR(src_)); 599 delete[] CONVERT_TO_SHORTPTR(ref_); 600 vpx_free(CONVERT_TO_SHORTPTR(sec_)); 601 #endif // CONFIG_VP9_HIGHBITDEPTH 602 } 603 libvpx_test::ClearSystemState(); 604 } 605 606 protected: 607 void RefTest(); 608 void ExtremeRefTest(); 609 610 ACMRandom rnd_; 611 uint8_t *src_; 612 uint8_t *ref_; 613 uint8_t *sec_; 614 TestParams<FunctionType> params_; 615 616 // some relay helpers 617 bool use_high_bit_depth() const { return params_.use_high_bit_depth; } 618 int byte_shift() const { return params_.bit_depth - 8; } 619 int block_size() const { return params_.block_size; } 620 int width() const { return params_.width; } 621 int height() const { return params_.height; } 622 uint32_t mask() const { return params_.mask; } 623 }; 624 625 template <typename SubpelVarianceFunctionType> 626 void SubpelVarianceTest<SubpelVarianceFunctionType>::RefTest() { 627 for (int x = 0; x < 8; ++x) { 628 for (int y = 0; y < 8; ++y) { 629 if (!use_high_bit_depth()) { 630 for (int j = 0; j < block_size(); j++) { 631 src_[j] = rnd_.Rand8(); 632 } 633 for (int j = 0; j < block_size() + width() + height() + 1; j++) { 634 ref_[j] = rnd_.Rand8(); 635 } 636 #if CONFIG_VP9_HIGHBITDEPTH 637 } else { 638 for (int j = 0; j < block_size(); j++) { 639 CONVERT_TO_SHORTPTR(src_)[j] = rnd_.Rand16() & mask(); 640 } 641 for (int j = 0; j < block_size() + width() + height() + 1; j++) { 642 CONVERT_TO_SHORTPTR(ref_)[j] = rnd_.Rand16() & mask(); 643 } 644 #endif // CONFIG_VP9_HIGHBITDEPTH 645 } 646 unsigned int sse1, sse2; 647 unsigned int var1; 648 ASM_REGISTER_STATE_CHECK( 649 var1 = params_.func(ref_, width() + 1, x, y, src_, width(), &sse1)); 650 const unsigned int var2 = subpel_variance_ref( 651 ref_, src_, params_.log2width, params_.log2height, x, y, &sse2, 652 use_high_bit_depth(), params_.bit_depth); 653 EXPECT_EQ(sse1, sse2) << "at position " << x << ", " << y; 654 EXPECT_EQ(var1, var2) << "at position " << x << ", " << y; 655 } 656 } 657 } 658 659 template <typename SubpelVarianceFunctionType> 660 void SubpelVarianceTest<SubpelVarianceFunctionType>::ExtremeRefTest() { 661 // Compare against reference. 662 // Src: Set the first half of values to 0, the second half to the maximum. 663 // Ref: Set the first half of values to the maximum, the second half to 0. 664 for (int x = 0; x < 8; ++x) { 665 for (int y = 0; y < 8; ++y) { 666 const int half = block_size() / 2; 667 if (!use_high_bit_depth()) { 668 memset(src_, 0, half); 669 memset(src_ + half, 255, half); 670 memset(ref_, 255, half); 671 memset(ref_ + half, 0, half + width() + height() + 1); 672 #if CONFIG_VP9_HIGHBITDEPTH 673 } else { 674 vpx_memset16(CONVERT_TO_SHORTPTR(src_), mask(), half); 675 vpx_memset16(CONVERT_TO_SHORTPTR(src_) + half, 0, half); 676 vpx_memset16(CONVERT_TO_SHORTPTR(ref_), 0, half); 677 vpx_memset16(CONVERT_TO_SHORTPTR(ref_) + half, mask(), 678 half + width() + height() + 1); 679 #endif // CONFIG_VP9_HIGHBITDEPTH 680 } 681 unsigned int sse1, sse2; 682 unsigned int var1; 683 ASM_REGISTER_STATE_CHECK( 684 var1 = params_.func(ref_, width() + 1, x, y, src_, width(), &sse1)); 685 const unsigned int var2 = subpel_variance_ref( 686 ref_, src_, params_.log2width, params_.log2height, x, y, &sse2, 687 use_high_bit_depth(), params_.bit_depth); 688 EXPECT_EQ(sse1, sse2) << "for xoffset " << x << " and yoffset " << y; 689 EXPECT_EQ(var1, var2) << "for xoffset " << x << " and yoffset " << y; 690 } 691 } 692 } 693 694 template <> 695 void SubpelVarianceTest<SubpixAvgVarMxNFunc>::RefTest() { 696 for (int x = 0; x < 8; ++x) { 697 for (int y = 0; y < 8; ++y) { 698 if (!use_high_bit_depth()) { 699 for (int j = 0; j < block_size(); j++) { 700 src_[j] = rnd_.Rand8(); 701 sec_[j] = rnd_.Rand8(); 702 } 703 for (int j = 0; j < block_size() + width() + height() + 1; j++) { 704 ref_[j] = rnd_.Rand8(); 705 } 706 #if CONFIG_VP9_HIGHBITDEPTH 707 } else { 708 for (int j = 0; j < block_size(); j++) { 709 CONVERT_TO_SHORTPTR(src_)[j] = rnd_.Rand16() & mask(); 710 CONVERT_TO_SHORTPTR(sec_)[j] = rnd_.Rand16() & mask(); 711 } 712 for (int j = 0; j < block_size() + width() + height() + 1; j++) { 713 CONVERT_TO_SHORTPTR(ref_)[j] = rnd_.Rand16() & mask(); 714 } 715 #endif // CONFIG_VP9_HIGHBITDEPTH 716 } 717 uint32_t sse1, sse2; 718 uint32_t var1, var2; 719 ASM_REGISTER_STATE_CHECK(var1 = params_.func(ref_, width() + 1, x, y, 720 src_, width(), &sse1, sec_)); 721 var2 = subpel_avg_variance_ref(ref_, src_, sec_, params_.log2width, 722 params_.log2height, x, y, &sse2, 723 use_high_bit_depth(), params_.bit_depth); 724 EXPECT_EQ(sse1, sse2) << "at position " << x << ", " << y; 725 EXPECT_EQ(var1, var2) << "at position " << x << ", " << y; 726 } 727 } 728 } 729 730 typedef MainTestClass<Get4x4SseFunc> VpxSseTest; 731 typedef MainTestClass<VarianceMxNFunc> VpxMseTest; 732 typedef MainTestClass<VarianceMxNFunc> VpxVarianceTest; 733 typedef SubpelVarianceTest<SubpixVarMxNFunc> VpxSubpelVarianceTest; 734 typedef SubpelVarianceTest<SubpixAvgVarMxNFunc> VpxSubpelAvgVarianceTest; 735 736 TEST_P(VpxSseTest, RefSse) { RefTestSse(); } 737 TEST_P(VpxSseTest, MaxSse) { MaxTestSse(); } 738 TEST_P(VpxMseTest, RefMse) { RefTestMse(); } 739 TEST_P(VpxMseTest, MaxMse) { MaxTestMse(); } 740 TEST_P(VpxVarianceTest, Zero) { ZeroTest(); } 741 TEST_P(VpxVarianceTest, Ref) { RefTest(); } 742 TEST_P(VpxVarianceTest, RefStride) { RefStrideTest(); } 743 TEST_P(VpxVarianceTest, OneQuarter) { OneQuarterTest(); } 744 TEST_P(VpxVarianceTest, DISABLED_Speed) { SpeedTest(); } 745 TEST_P(SumOfSquaresTest, Const) { ConstTest(); } 746 TEST_P(SumOfSquaresTest, Ref) { RefTest(); } 747 TEST_P(VpxSubpelVarianceTest, Ref) { RefTest(); } 748 TEST_P(VpxSubpelVarianceTest, ExtremeRef) { ExtremeRefTest(); } 749 TEST_P(VpxSubpelAvgVarianceTest, Ref) { RefTest(); } 750 751 INSTANTIATE_TEST_CASE_P(C, SumOfSquaresTest, 752 ::testing::Values(vpx_get_mb_ss_c)); 753 754 typedef TestParams<Get4x4SseFunc> SseParams; 755 INSTANTIATE_TEST_CASE_P(C, VpxSseTest, 756 ::testing::Values(SseParams(2, 2, 757 &vpx_get4x4sse_cs_c))); 758 759 typedef TestParams<VarianceMxNFunc> MseParams; 760 INSTANTIATE_TEST_CASE_P(C, VpxMseTest, 761 ::testing::Values(MseParams(4, 4, &vpx_mse16x16_c), 762 MseParams(4, 3, &vpx_mse16x8_c), 763 MseParams(3, 4, &vpx_mse8x16_c), 764 MseParams(3, 3, &vpx_mse8x8_c))); 765 766 typedef TestParams<VarianceMxNFunc> VarianceParams; 767 INSTANTIATE_TEST_CASE_P( 768 C, VpxVarianceTest, 769 ::testing::Values(VarianceParams(6, 6, &vpx_variance64x64_c), 770 VarianceParams(6, 5, &vpx_variance64x32_c), 771 VarianceParams(5, 6, &vpx_variance32x64_c), 772 VarianceParams(5, 5, &vpx_variance32x32_c), 773 VarianceParams(5, 4, &vpx_variance32x16_c), 774 VarianceParams(4, 5, &vpx_variance16x32_c), 775 VarianceParams(4, 4, &vpx_variance16x16_c), 776 VarianceParams(4, 3, &vpx_variance16x8_c), 777 VarianceParams(3, 4, &vpx_variance8x16_c), 778 VarianceParams(3, 3, &vpx_variance8x8_c), 779 VarianceParams(3, 2, &vpx_variance8x4_c), 780 VarianceParams(2, 3, &vpx_variance4x8_c), 781 VarianceParams(2, 2, &vpx_variance4x4_c))); 782 783 typedef TestParams<SubpixVarMxNFunc> SubpelVarianceParams; 784 INSTANTIATE_TEST_CASE_P( 785 C, VpxSubpelVarianceTest, 786 ::testing::Values( 787 SubpelVarianceParams(6, 6, &vpx_sub_pixel_variance64x64_c, 0), 788 SubpelVarianceParams(6, 5, &vpx_sub_pixel_variance64x32_c, 0), 789 SubpelVarianceParams(5, 6, &vpx_sub_pixel_variance32x64_c, 0), 790 SubpelVarianceParams(5, 5, &vpx_sub_pixel_variance32x32_c, 0), 791 SubpelVarianceParams(5, 4, &vpx_sub_pixel_variance32x16_c, 0), 792 SubpelVarianceParams(4, 5, &vpx_sub_pixel_variance16x32_c, 0), 793 SubpelVarianceParams(4, 4, &vpx_sub_pixel_variance16x16_c, 0), 794 SubpelVarianceParams(4, 3, &vpx_sub_pixel_variance16x8_c, 0), 795 SubpelVarianceParams(3, 4, &vpx_sub_pixel_variance8x16_c, 0), 796 SubpelVarianceParams(3, 3, &vpx_sub_pixel_variance8x8_c, 0), 797 SubpelVarianceParams(3, 2, &vpx_sub_pixel_variance8x4_c, 0), 798 SubpelVarianceParams(2, 3, &vpx_sub_pixel_variance4x8_c, 0), 799 SubpelVarianceParams(2, 2, &vpx_sub_pixel_variance4x4_c, 0))); 800 801 typedef TestParams<SubpixAvgVarMxNFunc> SubpelAvgVarianceParams; 802 INSTANTIATE_TEST_CASE_P( 803 C, VpxSubpelAvgVarianceTest, 804 ::testing::Values( 805 SubpelAvgVarianceParams(6, 6, &vpx_sub_pixel_avg_variance64x64_c, 0), 806 SubpelAvgVarianceParams(6, 5, &vpx_sub_pixel_avg_variance64x32_c, 0), 807 SubpelAvgVarianceParams(5, 6, &vpx_sub_pixel_avg_variance32x64_c, 0), 808 SubpelAvgVarianceParams(5, 5, &vpx_sub_pixel_avg_variance32x32_c, 0), 809 SubpelAvgVarianceParams(5, 4, &vpx_sub_pixel_avg_variance32x16_c, 0), 810 SubpelAvgVarianceParams(4, 5, &vpx_sub_pixel_avg_variance16x32_c, 0), 811 SubpelAvgVarianceParams(4, 4, &vpx_sub_pixel_avg_variance16x16_c, 0), 812 SubpelAvgVarianceParams(4, 3, &vpx_sub_pixel_avg_variance16x8_c, 0), 813 SubpelAvgVarianceParams(3, 4, &vpx_sub_pixel_avg_variance8x16_c, 0), 814 SubpelAvgVarianceParams(3, 3, &vpx_sub_pixel_avg_variance8x8_c, 0), 815 SubpelAvgVarianceParams(3, 2, &vpx_sub_pixel_avg_variance8x4_c, 0), 816 SubpelAvgVarianceParams(2, 3, &vpx_sub_pixel_avg_variance4x8_c, 0), 817 SubpelAvgVarianceParams(2, 2, &vpx_sub_pixel_avg_variance4x4_c, 0))); 818 819 #if CONFIG_VP9_HIGHBITDEPTH 820 typedef MainTestClass<VarianceMxNFunc> VpxHBDMseTest; 821 typedef MainTestClass<VarianceMxNFunc> VpxHBDVarianceTest; 822 typedef SubpelVarianceTest<SubpixVarMxNFunc> VpxHBDSubpelVarianceTest; 823 typedef SubpelVarianceTest<SubpixAvgVarMxNFunc> VpxHBDSubpelAvgVarianceTest; 824 825 TEST_P(VpxHBDMseTest, RefMse) { RefTestMse(); } 826 TEST_P(VpxHBDMseTest, MaxMse) { MaxTestMse(); } 827 TEST_P(VpxHBDVarianceTest, Zero) { ZeroTest(); } 828 TEST_P(VpxHBDVarianceTest, Ref) { RefTest(); } 829 TEST_P(VpxHBDVarianceTest, RefStride) { RefStrideTest(); } 830 TEST_P(VpxHBDVarianceTest, OneQuarter) { OneQuarterTest(); } 831 TEST_P(VpxHBDVarianceTest, DISABLED_Speed) { SpeedTest(); } 832 TEST_P(VpxHBDSubpelVarianceTest, Ref) { RefTest(); } 833 TEST_P(VpxHBDSubpelVarianceTest, ExtremeRef) { ExtremeRefTest(); } 834 TEST_P(VpxHBDSubpelAvgVarianceTest, Ref) { RefTest(); } 835 836 /* TODO(debargha): This test does not support the highbd version 837 INSTANTIATE_TEST_CASE_P( 838 C, VpxHBDMseTest, 839 ::testing::Values(MseParams(4, 4, &vpx_highbd_12_mse16x16_c), 840 MseParams(4, 4, &vpx_highbd_12_mse16x8_c), 841 MseParams(4, 4, &vpx_highbd_12_mse8x16_c), 842 MseParams(4, 4, &vpx_highbd_12_mse8x8_c), 843 MseParams(4, 4, &vpx_highbd_10_mse16x16_c), 844 MseParams(4, 4, &vpx_highbd_10_mse16x8_c), 845 MseParams(4, 4, &vpx_highbd_10_mse8x16_c), 846 MseParams(4, 4, &vpx_highbd_10_mse8x8_c), 847 MseParams(4, 4, &vpx_highbd_8_mse16x16_c), 848 MseParams(4, 4, &vpx_highbd_8_mse16x8_c), 849 MseParams(4, 4, &vpx_highbd_8_mse8x16_c), 850 MseParams(4, 4, &vpx_highbd_8_mse8x8_c))); 851 */ 852 853 INSTANTIATE_TEST_CASE_P( 854 C, VpxHBDVarianceTest, 855 ::testing::Values(VarianceParams(6, 6, &vpx_highbd_12_variance64x64_c, 12), 856 VarianceParams(6, 5, &vpx_highbd_12_variance64x32_c, 12), 857 VarianceParams(5, 6, &vpx_highbd_12_variance32x64_c, 12), 858 VarianceParams(5, 5, &vpx_highbd_12_variance32x32_c, 12), 859 VarianceParams(5, 4, &vpx_highbd_12_variance32x16_c, 12), 860 VarianceParams(4, 5, &vpx_highbd_12_variance16x32_c, 12), 861 VarianceParams(4, 4, &vpx_highbd_12_variance16x16_c, 12), 862 VarianceParams(4, 3, &vpx_highbd_12_variance16x8_c, 12), 863 VarianceParams(3, 4, &vpx_highbd_12_variance8x16_c, 12), 864 VarianceParams(3, 3, &vpx_highbd_12_variance8x8_c, 12), 865 VarianceParams(3, 2, &vpx_highbd_12_variance8x4_c, 12), 866 VarianceParams(2, 3, &vpx_highbd_12_variance4x8_c, 12), 867 VarianceParams(2, 2, &vpx_highbd_12_variance4x4_c, 12), 868 VarianceParams(6, 6, &vpx_highbd_10_variance64x64_c, 10), 869 VarianceParams(6, 5, &vpx_highbd_10_variance64x32_c, 10), 870 VarianceParams(5, 6, &vpx_highbd_10_variance32x64_c, 10), 871 VarianceParams(5, 5, &vpx_highbd_10_variance32x32_c, 10), 872 VarianceParams(5, 4, &vpx_highbd_10_variance32x16_c, 10), 873 VarianceParams(4, 5, &vpx_highbd_10_variance16x32_c, 10), 874 VarianceParams(4, 4, &vpx_highbd_10_variance16x16_c, 10), 875 VarianceParams(4, 3, &vpx_highbd_10_variance16x8_c, 10), 876 VarianceParams(3, 4, &vpx_highbd_10_variance8x16_c, 10), 877 VarianceParams(3, 3, &vpx_highbd_10_variance8x8_c, 10), 878 VarianceParams(3, 2, &vpx_highbd_10_variance8x4_c, 10), 879 VarianceParams(2, 3, &vpx_highbd_10_variance4x8_c, 10), 880 VarianceParams(2, 2, &vpx_highbd_10_variance4x4_c, 10), 881 VarianceParams(6, 6, &vpx_highbd_8_variance64x64_c, 8), 882 VarianceParams(6, 5, &vpx_highbd_8_variance64x32_c, 8), 883 VarianceParams(5, 6, &vpx_highbd_8_variance32x64_c, 8), 884 VarianceParams(5, 5, &vpx_highbd_8_variance32x32_c, 8), 885 VarianceParams(5, 4, &vpx_highbd_8_variance32x16_c, 8), 886 VarianceParams(4, 5, &vpx_highbd_8_variance16x32_c, 8), 887 VarianceParams(4, 4, &vpx_highbd_8_variance16x16_c, 8), 888 VarianceParams(4, 3, &vpx_highbd_8_variance16x8_c, 8), 889 VarianceParams(3, 4, &vpx_highbd_8_variance8x16_c, 8), 890 VarianceParams(3, 3, &vpx_highbd_8_variance8x8_c, 8), 891 VarianceParams(3, 2, &vpx_highbd_8_variance8x4_c, 8), 892 VarianceParams(2, 3, &vpx_highbd_8_variance4x8_c, 8), 893 VarianceParams(2, 2, &vpx_highbd_8_variance4x4_c, 8))); 894 895 INSTANTIATE_TEST_CASE_P( 896 C, VpxHBDSubpelVarianceTest, 897 ::testing::Values( 898 SubpelVarianceParams(6, 6, &vpx_highbd_8_sub_pixel_variance64x64_c, 8), 899 SubpelVarianceParams(6, 5, &vpx_highbd_8_sub_pixel_variance64x32_c, 8), 900 SubpelVarianceParams(5, 6, &vpx_highbd_8_sub_pixel_variance32x64_c, 8), 901 SubpelVarianceParams(5, 5, &vpx_highbd_8_sub_pixel_variance32x32_c, 8), 902 SubpelVarianceParams(5, 4, &vpx_highbd_8_sub_pixel_variance32x16_c, 8), 903 SubpelVarianceParams(4, 5, &vpx_highbd_8_sub_pixel_variance16x32_c, 8), 904 SubpelVarianceParams(4, 4, &vpx_highbd_8_sub_pixel_variance16x16_c, 8), 905 SubpelVarianceParams(4, 3, &vpx_highbd_8_sub_pixel_variance16x8_c, 8), 906 SubpelVarianceParams(3, 4, &vpx_highbd_8_sub_pixel_variance8x16_c, 8), 907 SubpelVarianceParams(3, 3, &vpx_highbd_8_sub_pixel_variance8x8_c, 8), 908 SubpelVarianceParams(3, 2, &vpx_highbd_8_sub_pixel_variance8x4_c, 8), 909 SubpelVarianceParams(2, 3, &vpx_highbd_8_sub_pixel_variance4x8_c, 8), 910 SubpelVarianceParams(2, 2, &vpx_highbd_8_sub_pixel_variance4x4_c, 8), 911 SubpelVarianceParams(6, 6, &vpx_highbd_10_sub_pixel_variance64x64_c, 912 10), 913 SubpelVarianceParams(6, 5, &vpx_highbd_10_sub_pixel_variance64x32_c, 914 10), 915 SubpelVarianceParams(5, 6, &vpx_highbd_10_sub_pixel_variance32x64_c, 916 10), 917 SubpelVarianceParams(5, 5, &vpx_highbd_10_sub_pixel_variance32x32_c, 918 10), 919 SubpelVarianceParams(5, 4, &vpx_highbd_10_sub_pixel_variance32x16_c, 920 10), 921 SubpelVarianceParams(4, 5, &vpx_highbd_10_sub_pixel_variance16x32_c, 922 10), 923 SubpelVarianceParams(4, 4, &vpx_highbd_10_sub_pixel_variance16x16_c, 924 10), 925 SubpelVarianceParams(4, 3, &vpx_highbd_10_sub_pixel_variance16x8_c, 10), 926 SubpelVarianceParams(3, 4, &vpx_highbd_10_sub_pixel_variance8x16_c, 10), 927 SubpelVarianceParams(3, 3, &vpx_highbd_10_sub_pixel_variance8x8_c, 10), 928 SubpelVarianceParams(3, 2, &vpx_highbd_10_sub_pixel_variance8x4_c, 10), 929 SubpelVarianceParams(2, 3, &vpx_highbd_10_sub_pixel_variance4x8_c, 10), 930 SubpelVarianceParams(2, 2, &vpx_highbd_10_sub_pixel_variance4x4_c, 10), 931 SubpelVarianceParams(6, 6, &vpx_highbd_12_sub_pixel_variance64x64_c, 932 12), 933 SubpelVarianceParams(6, 5, &vpx_highbd_12_sub_pixel_variance64x32_c, 934 12), 935 SubpelVarianceParams(5, 6, &vpx_highbd_12_sub_pixel_variance32x64_c, 936 12), 937 SubpelVarianceParams(5, 5, &vpx_highbd_12_sub_pixel_variance32x32_c, 938 12), 939 SubpelVarianceParams(5, 4, &vpx_highbd_12_sub_pixel_variance32x16_c, 940 12), 941 SubpelVarianceParams(4, 5, &vpx_highbd_12_sub_pixel_variance16x32_c, 942 12), 943 SubpelVarianceParams(4, 4, &vpx_highbd_12_sub_pixel_variance16x16_c, 944 12), 945 SubpelVarianceParams(4, 3, &vpx_highbd_12_sub_pixel_variance16x8_c, 12), 946 SubpelVarianceParams(3, 4, &vpx_highbd_12_sub_pixel_variance8x16_c, 12), 947 SubpelVarianceParams(3, 3, &vpx_highbd_12_sub_pixel_variance8x8_c, 12), 948 SubpelVarianceParams(3, 2, &vpx_highbd_12_sub_pixel_variance8x4_c, 12), 949 SubpelVarianceParams(2, 3, &vpx_highbd_12_sub_pixel_variance4x8_c, 12), 950 SubpelVarianceParams(2, 2, &vpx_highbd_12_sub_pixel_variance4x4_c, 951 12))); 952 953 INSTANTIATE_TEST_CASE_P( 954 C, VpxHBDSubpelAvgVarianceTest, 955 ::testing::Values( 956 SubpelAvgVarianceParams(6, 6, 957 &vpx_highbd_8_sub_pixel_avg_variance64x64_c, 8), 958 SubpelAvgVarianceParams(6, 5, 959 &vpx_highbd_8_sub_pixel_avg_variance64x32_c, 8), 960 SubpelAvgVarianceParams(5, 6, 961 &vpx_highbd_8_sub_pixel_avg_variance32x64_c, 8), 962 SubpelAvgVarianceParams(5, 5, 963 &vpx_highbd_8_sub_pixel_avg_variance32x32_c, 8), 964 SubpelAvgVarianceParams(5, 4, 965 &vpx_highbd_8_sub_pixel_avg_variance32x16_c, 8), 966 SubpelAvgVarianceParams(4, 5, 967 &vpx_highbd_8_sub_pixel_avg_variance16x32_c, 8), 968 SubpelAvgVarianceParams(4, 4, 969 &vpx_highbd_8_sub_pixel_avg_variance16x16_c, 8), 970 SubpelAvgVarianceParams(4, 3, 971 &vpx_highbd_8_sub_pixel_avg_variance16x8_c, 8), 972 SubpelAvgVarianceParams(3, 4, 973 &vpx_highbd_8_sub_pixel_avg_variance8x16_c, 8), 974 SubpelAvgVarianceParams(3, 3, &vpx_highbd_8_sub_pixel_avg_variance8x8_c, 975 8), 976 SubpelAvgVarianceParams(3, 2, &vpx_highbd_8_sub_pixel_avg_variance8x4_c, 977 8), 978 SubpelAvgVarianceParams(2, 3, &vpx_highbd_8_sub_pixel_avg_variance4x8_c, 979 8), 980 SubpelAvgVarianceParams(2, 2, &vpx_highbd_8_sub_pixel_avg_variance4x4_c, 981 8), 982 SubpelAvgVarianceParams(6, 6, 983 &vpx_highbd_10_sub_pixel_avg_variance64x64_c, 984 10), 985 SubpelAvgVarianceParams(6, 5, 986 &vpx_highbd_10_sub_pixel_avg_variance64x32_c, 987 10), 988 SubpelAvgVarianceParams(5, 6, 989 &vpx_highbd_10_sub_pixel_avg_variance32x64_c, 990 10), 991 SubpelAvgVarianceParams(5, 5, 992 &vpx_highbd_10_sub_pixel_avg_variance32x32_c, 993 10), 994 SubpelAvgVarianceParams(5, 4, 995 &vpx_highbd_10_sub_pixel_avg_variance32x16_c, 996 10), 997 SubpelAvgVarianceParams(4, 5, 998 &vpx_highbd_10_sub_pixel_avg_variance16x32_c, 999 10), 1000 SubpelAvgVarianceParams(4, 4, 1001 &vpx_highbd_10_sub_pixel_avg_variance16x16_c, 1002 10), 1003 SubpelAvgVarianceParams(4, 3, 1004 &vpx_highbd_10_sub_pixel_avg_variance16x8_c, 1005 10), 1006 SubpelAvgVarianceParams(3, 4, 1007 &vpx_highbd_10_sub_pixel_avg_variance8x16_c, 1008 10), 1009 SubpelAvgVarianceParams(3, 3, 1010 &vpx_highbd_10_sub_pixel_avg_variance8x8_c, 10), 1011 SubpelAvgVarianceParams(3, 2, 1012 &vpx_highbd_10_sub_pixel_avg_variance8x4_c, 10), 1013 SubpelAvgVarianceParams(2, 3, 1014 &vpx_highbd_10_sub_pixel_avg_variance4x8_c, 10), 1015 SubpelAvgVarianceParams(2, 2, 1016 &vpx_highbd_10_sub_pixel_avg_variance4x4_c, 10), 1017 SubpelAvgVarianceParams(6, 6, 1018 &vpx_highbd_12_sub_pixel_avg_variance64x64_c, 1019 12), 1020 SubpelAvgVarianceParams(6, 5, 1021 &vpx_highbd_12_sub_pixel_avg_variance64x32_c, 1022 12), 1023 SubpelAvgVarianceParams(5, 6, 1024 &vpx_highbd_12_sub_pixel_avg_variance32x64_c, 1025 12), 1026 SubpelAvgVarianceParams(5, 5, 1027 &vpx_highbd_12_sub_pixel_avg_variance32x32_c, 1028 12), 1029 SubpelAvgVarianceParams(5, 4, 1030 &vpx_highbd_12_sub_pixel_avg_variance32x16_c, 1031 12), 1032 SubpelAvgVarianceParams(4, 5, 1033 &vpx_highbd_12_sub_pixel_avg_variance16x32_c, 1034 12), 1035 SubpelAvgVarianceParams(4, 4, 1036 &vpx_highbd_12_sub_pixel_avg_variance16x16_c, 1037 12), 1038 SubpelAvgVarianceParams(4, 3, 1039 &vpx_highbd_12_sub_pixel_avg_variance16x8_c, 1040 12), 1041 SubpelAvgVarianceParams(3, 4, 1042 &vpx_highbd_12_sub_pixel_avg_variance8x16_c, 1043 12), 1044 SubpelAvgVarianceParams(3, 3, 1045 &vpx_highbd_12_sub_pixel_avg_variance8x8_c, 12), 1046 SubpelAvgVarianceParams(3, 2, 1047 &vpx_highbd_12_sub_pixel_avg_variance8x4_c, 12), 1048 SubpelAvgVarianceParams(2, 3, 1049 &vpx_highbd_12_sub_pixel_avg_variance4x8_c, 12), 1050 SubpelAvgVarianceParams(2, 2, 1051 &vpx_highbd_12_sub_pixel_avg_variance4x4_c, 1052 12))); 1053 #endif // CONFIG_VP9_HIGHBITDEPTH 1054 1055 #if HAVE_SSE2 1056 INSTANTIATE_TEST_CASE_P(SSE2, SumOfSquaresTest, 1057 ::testing::Values(vpx_get_mb_ss_sse2)); 1058 1059 INSTANTIATE_TEST_CASE_P(SSE2, VpxMseTest, 1060 ::testing::Values(MseParams(4, 4, &vpx_mse16x16_sse2), 1061 MseParams(4, 3, &vpx_mse16x8_sse2), 1062 MseParams(3, 4, &vpx_mse8x16_sse2), 1063 MseParams(3, 3, &vpx_mse8x8_sse2))); 1064 1065 INSTANTIATE_TEST_CASE_P( 1066 SSE2, VpxVarianceTest, 1067 ::testing::Values(VarianceParams(6, 6, &vpx_variance64x64_sse2), 1068 VarianceParams(6, 5, &vpx_variance64x32_sse2), 1069 VarianceParams(5, 6, &vpx_variance32x64_sse2), 1070 VarianceParams(5, 5, &vpx_variance32x32_sse2), 1071 VarianceParams(5, 4, &vpx_variance32x16_sse2), 1072 VarianceParams(4, 5, &vpx_variance16x32_sse2), 1073 VarianceParams(4, 4, &vpx_variance16x16_sse2), 1074 VarianceParams(4, 3, &vpx_variance16x8_sse2), 1075 VarianceParams(3, 4, &vpx_variance8x16_sse2), 1076 VarianceParams(3, 3, &vpx_variance8x8_sse2), 1077 VarianceParams(3, 2, &vpx_variance8x4_sse2), 1078 VarianceParams(2, 3, &vpx_variance4x8_sse2), 1079 VarianceParams(2, 2, &vpx_variance4x4_sse2))); 1080 1081 INSTANTIATE_TEST_CASE_P( 1082 SSE2, VpxSubpelVarianceTest, 1083 ::testing::Values( 1084 SubpelVarianceParams(6, 6, &vpx_sub_pixel_variance64x64_sse2, 0), 1085 SubpelVarianceParams(6, 5, &vpx_sub_pixel_variance64x32_sse2, 0), 1086 SubpelVarianceParams(5, 6, &vpx_sub_pixel_variance32x64_sse2, 0), 1087 SubpelVarianceParams(5, 5, &vpx_sub_pixel_variance32x32_sse2, 0), 1088 SubpelVarianceParams(5, 4, &vpx_sub_pixel_variance32x16_sse2, 0), 1089 SubpelVarianceParams(4, 5, &vpx_sub_pixel_variance16x32_sse2, 0), 1090 SubpelVarianceParams(4, 4, &vpx_sub_pixel_variance16x16_sse2, 0), 1091 SubpelVarianceParams(4, 3, &vpx_sub_pixel_variance16x8_sse2, 0), 1092 SubpelVarianceParams(3, 4, &vpx_sub_pixel_variance8x16_sse2, 0), 1093 SubpelVarianceParams(3, 3, &vpx_sub_pixel_variance8x8_sse2, 0), 1094 SubpelVarianceParams(3, 2, &vpx_sub_pixel_variance8x4_sse2, 0), 1095 SubpelVarianceParams(2, 3, &vpx_sub_pixel_variance4x8_sse2, 0), 1096 SubpelVarianceParams(2, 2, &vpx_sub_pixel_variance4x4_sse2, 0))); 1097 1098 INSTANTIATE_TEST_CASE_P( 1099 SSE2, VpxSubpelAvgVarianceTest, 1100 ::testing::Values( 1101 SubpelAvgVarianceParams(6, 6, &vpx_sub_pixel_avg_variance64x64_sse2, 0), 1102 SubpelAvgVarianceParams(6, 5, &vpx_sub_pixel_avg_variance64x32_sse2, 0), 1103 SubpelAvgVarianceParams(5, 6, &vpx_sub_pixel_avg_variance32x64_sse2, 0), 1104 SubpelAvgVarianceParams(5, 5, &vpx_sub_pixel_avg_variance32x32_sse2, 0), 1105 SubpelAvgVarianceParams(5, 4, &vpx_sub_pixel_avg_variance32x16_sse2, 0), 1106 SubpelAvgVarianceParams(4, 5, &vpx_sub_pixel_avg_variance16x32_sse2, 0), 1107 SubpelAvgVarianceParams(4, 4, &vpx_sub_pixel_avg_variance16x16_sse2, 0), 1108 SubpelAvgVarianceParams(4, 3, &vpx_sub_pixel_avg_variance16x8_sse2, 0), 1109 SubpelAvgVarianceParams(3, 4, &vpx_sub_pixel_avg_variance8x16_sse2, 0), 1110 SubpelAvgVarianceParams(3, 3, &vpx_sub_pixel_avg_variance8x8_sse2, 0), 1111 SubpelAvgVarianceParams(3, 2, &vpx_sub_pixel_avg_variance8x4_sse2, 0), 1112 SubpelAvgVarianceParams(2, 3, &vpx_sub_pixel_avg_variance4x8_sse2, 0), 1113 SubpelAvgVarianceParams(2, 2, &vpx_sub_pixel_avg_variance4x4_sse2, 0))); 1114 1115 #if CONFIG_VP9_HIGHBITDEPTH 1116 /* TODO(debargha): This test does not support the highbd version 1117 INSTANTIATE_TEST_CASE_P( 1118 SSE2, VpxHBDMseTest, 1119 ::testing::Values(MseParams(4, 4, &vpx_highbd_12_mse16x16_sse2), 1120 MseParams(4, 3, &vpx_highbd_12_mse16x8_sse2), 1121 MseParams(3, 4, &vpx_highbd_12_mse8x16_sse2), 1122 MseParams(3, 3, &vpx_highbd_12_mse8x8_sse2), 1123 MseParams(4, 4, &vpx_highbd_10_mse16x16_sse2), 1124 MseParams(4, 3, &vpx_highbd_10_mse16x8_sse2), 1125 MseParams(3, 4, &vpx_highbd_10_mse8x16_sse2), 1126 MseParams(3, 3, &vpx_highbd_10_mse8x8_sse2), 1127 MseParams(4, 4, &vpx_highbd_8_mse16x16_sse2), 1128 MseParams(4, 3, &vpx_highbd_8_mse16x8_sse2), 1129 MseParams(3, 4, &vpx_highbd_8_mse8x16_sse2), 1130 MseParams(3, 3, &vpx_highbd_8_mse8x8_sse2))); 1131 */ 1132 1133 INSTANTIATE_TEST_CASE_P( 1134 SSE2, VpxHBDVarianceTest, 1135 ::testing::Values( 1136 VarianceParams(6, 6, &vpx_highbd_12_variance64x64_sse2, 12), 1137 VarianceParams(6, 5, &vpx_highbd_12_variance64x32_sse2, 12), 1138 VarianceParams(5, 6, &vpx_highbd_12_variance32x64_sse2, 12), 1139 VarianceParams(5, 5, &vpx_highbd_12_variance32x32_sse2, 12), 1140 VarianceParams(5, 4, &vpx_highbd_12_variance32x16_sse2, 12), 1141 VarianceParams(4, 5, &vpx_highbd_12_variance16x32_sse2, 12), 1142 VarianceParams(4, 4, &vpx_highbd_12_variance16x16_sse2, 12), 1143 VarianceParams(4, 3, &vpx_highbd_12_variance16x8_sse2, 12), 1144 VarianceParams(3, 4, &vpx_highbd_12_variance8x16_sse2, 12), 1145 VarianceParams(3, 3, &vpx_highbd_12_variance8x8_sse2, 12), 1146 VarianceParams(6, 6, &vpx_highbd_10_variance64x64_sse2, 10), 1147 VarianceParams(6, 5, &vpx_highbd_10_variance64x32_sse2, 10), 1148 VarianceParams(5, 6, &vpx_highbd_10_variance32x64_sse2, 10), 1149 VarianceParams(5, 5, &vpx_highbd_10_variance32x32_sse2, 10), 1150 VarianceParams(5, 4, &vpx_highbd_10_variance32x16_sse2, 10), 1151 VarianceParams(4, 5, &vpx_highbd_10_variance16x32_sse2, 10), 1152 VarianceParams(4, 4, &vpx_highbd_10_variance16x16_sse2, 10), 1153 VarianceParams(4, 3, &vpx_highbd_10_variance16x8_sse2, 10), 1154 VarianceParams(3, 4, &vpx_highbd_10_variance8x16_sse2, 10), 1155 VarianceParams(3, 3, &vpx_highbd_10_variance8x8_sse2, 10), 1156 VarianceParams(6, 6, &vpx_highbd_8_variance64x64_sse2, 8), 1157 VarianceParams(6, 5, &vpx_highbd_8_variance64x32_sse2, 8), 1158 VarianceParams(5, 6, &vpx_highbd_8_variance32x64_sse2, 8), 1159 VarianceParams(5, 5, &vpx_highbd_8_variance32x32_sse2, 8), 1160 VarianceParams(5, 4, &vpx_highbd_8_variance32x16_sse2, 8), 1161 VarianceParams(4, 5, &vpx_highbd_8_variance16x32_sse2, 8), 1162 VarianceParams(4, 4, &vpx_highbd_8_variance16x16_sse2, 8), 1163 VarianceParams(4, 3, &vpx_highbd_8_variance16x8_sse2, 8), 1164 VarianceParams(3, 4, &vpx_highbd_8_variance8x16_sse2, 8), 1165 VarianceParams(3, 3, &vpx_highbd_8_variance8x8_sse2, 8))); 1166 1167 INSTANTIATE_TEST_CASE_P( 1168 SSE2, VpxHBDSubpelVarianceTest, 1169 ::testing::Values( 1170 SubpelVarianceParams(6, 6, &vpx_highbd_12_sub_pixel_variance64x64_sse2, 1171 12), 1172 SubpelVarianceParams(6, 5, &vpx_highbd_12_sub_pixel_variance64x32_sse2, 1173 12), 1174 SubpelVarianceParams(5, 6, &vpx_highbd_12_sub_pixel_variance32x64_sse2, 1175 12), 1176 SubpelVarianceParams(5, 5, &vpx_highbd_12_sub_pixel_variance32x32_sse2, 1177 12), 1178 SubpelVarianceParams(5, 4, &vpx_highbd_12_sub_pixel_variance32x16_sse2, 1179 12), 1180 SubpelVarianceParams(4, 5, &vpx_highbd_12_sub_pixel_variance16x32_sse2, 1181 12), 1182 SubpelVarianceParams(4, 4, &vpx_highbd_12_sub_pixel_variance16x16_sse2, 1183 12), 1184 SubpelVarianceParams(4, 3, &vpx_highbd_12_sub_pixel_variance16x8_sse2, 1185 12), 1186 SubpelVarianceParams(3, 4, &vpx_highbd_12_sub_pixel_variance8x16_sse2, 1187 12), 1188 SubpelVarianceParams(3, 3, &vpx_highbd_12_sub_pixel_variance8x8_sse2, 1189 12), 1190 SubpelVarianceParams(3, 2, &vpx_highbd_12_sub_pixel_variance8x4_sse2, 1191 12), 1192 SubpelVarianceParams(6, 6, &vpx_highbd_10_sub_pixel_variance64x64_sse2, 1193 10), 1194 SubpelVarianceParams(6, 5, &vpx_highbd_10_sub_pixel_variance64x32_sse2, 1195 10), 1196 SubpelVarianceParams(5, 6, &vpx_highbd_10_sub_pixel_variance32x64_sse2, 1197 10), 1198 SubpelVarianceParams(5, 5, &vpx_highbd_10_sub_pixel_variance32x32_sse2, 1199 10), 1200 SubpelVarianceParams(5, 4, &vpx_highbd_10_sub_pixel_variance32x16_sse2, 1201 10), 1202 SubpelVarianceParams(4, 5, &vpx_highbd_10_sub_pixel_variance16x32_sse2, 1203 10), 1204 SubpelVarianceParams(4, 4, &vpx_highbd_10_sub_pixel_variance16x16_sse2, 1205 10), 1206 SubpelVarianceParams(4, 3, &vpx_highbd_10_sub_pixel_variance16x8_sse2, 1207 10), 1208 SubpelVarianceParams(3, 4, &vpx_highbd_10_sub_pixel_variance8x16_sse2, 1209 10), 1210 SubpelVarianceParams(3, 3, &vpx_highbd_10_sub_pixel_variance8x8_sse2, 1211 10), 1212 SubpelVarianceParams(3, 2, &vpx_highbd_10_sub_pixel_variance8x4_sse2, 1213 10), 1214 SubpelVarianceParams(6, 6, &vpx_highbd_8_sub_pixel_variance64x64_sse2, 1215 8), 1216 SubpelVarianceParams(6, 5, &vpx_highbd_8_sub_pixel_variance64x32_sse2, 1217 8), 1218 SubpelVarianceParams(5, 6, &vpx_highbd_8_sub_pixel_variance32x64_sse2, 1219 8), 1220 SubpelVarianceParams(5, 5, &vpx_highbd_8_sub_pixel_variance32x32_sse2, 1221 8), 1222 SubpelVarianceParams(5, 4, &vpx_highbd_8_sub_pixel_variance32x16_sse2, 1223 8), 1224 SubpelVarianceParams(4, 5, &vpx_highbd_8_sub_pixel_variance16x32_sse2, 1225 8), 1226 SubpelVarianceParams(4, 4, &vpx_highbd_8_sub_pixel_variance16x16_sse2, 1227 8), 1228 SubpelVarianceParams(4, 3, &vpx_highbd_8_sub_pixel_variance16x8_sse2, 1229 8), 1230 SubpelVarianceParams(3, 4, &vpx_highbd_8_sub_pixel_variance8x16_sse2, 1231 8), 1232 SubpelVarianceParams(3, 3, &vpx_highbd_8_sub_pixel_variance8x8_sse2, 8), 1233 SubpelVarianceParams(3, 2, &vpx_highbd_8_sub_pixel_variance8x4_sse2, 1234 8))); 1235 1236 INSTANTIATE_TEST_CASE_P( 1237 SSE2, VpxHBDSubpelAvgVarianceTest, 1238 ::testing::Values( 1239 SubpelAvgVarianceParams(6, 6, 1240 &vpx_highbd_12_sub_pixel_avg_variance64x64_sse2, 1241 12), 1242 SubpelAvgVarianceParams(6, 5, 1243 &vpx_highbd_12_sub_pixel_avg_variance64x32_sse2, 1244 12), 1245 SubpelAvgVarianceParams(5, 6, 1246 &vpx_highbd_12_sub_pixel_avg_variance32x64_sse2, 1247 12), 1248 SubpelAvgVarianceParams(5, 5, 1249 &vpx_highbd_12_sub_pixel_avg_variance32x32_sse2, 1250 12), 1251 SubpelAvgVarianceParams(5, 4, 1252 &vpx_highbd_12_sub_pixel_avg_variance32x16_sse2, 1253 12), 1254 SubpelAvgVarianceParams(4, 5, 1255 &vpx_highbd_12_sub_pixel_avg_variance16x32_sse2, 1256 12), 1257 SubpelAvgVarianceParams(4, 4, 1258 &vpx_highbd_12_sub_pixel_avg_variance16x16_sse2, 1259 12), 1260 SubpelAvgVarianceParams(4, 3, 1261 &vpx_highbd_12_sub_pixel_avg_variance16x8_sse2, 1262 12), 1263 SubpelAvgVarianceParams(3, 4, 1264 &vpx_highbd_12_sub_pixel_avg_variance8x16_sse2, 1265 12), 1266 SubpelAvgVarianceParams(3, 3, 1267 &vpx_highbd_12_sub_pixel_avg_variance8x8_sse2, 1268 12), 1269 SubpelAvgVarianceParams(3, 2, 1270 &vpx_highbd_12_sub_pixel_avg_variance8x4_sse2, 1271 12), 1272 SubpelAvgVarianceParams(6, 6, 1273 &vpx_highbd_10_sub_pixel_avg_variance64x64_sse2, 1274 10), 1275 SubpelAvgVarianceParams(6, 5, 1276 &vpx_highbd_10_sub_pixel_avg_variance64x32_sse2, 1277 10), 1278 SubpelAvgVarianceParams(5, 6, 1279 &vpx_highbd_10_sub_pixel_avg_variance32x64_sse2, 1280 10), 1281 SubpelAvgVarianceParams(5, 5, 1282 &vpx_highbd_10_sub_pixel_avg_variance32x32_sse2, 1283 10), 1284 SubpelAvgVarianceParams(5, 4, 1285 &vpx_highbd_10_sub_pixel_avg_variance32x16_sse2, 1286 10), 1287 SubpelAvgVarianceParams(4, 5, 1288 &vpx_highbd_10_sub_pixel_avg_variance16x32_sse2, 1289 10), 1290 SubpelAvgVarianceParams(4, 4, 1291 &vpx_highbd_10_sub_pixel_avg_variance16x16_sse2, 1292 10), 1293 SubpelAvgVarianceParams(4, 3, 1294 &vpx_highbd_10_sub_pixel_avg_variance16x8_sse2, 1295 10), 1296 SubpelAvgVarianceParams(3, 4, 1297 &vpx_highbd_10_sub_pixel_avg_variance8x16_sse2, 1298 10), 1299 SubpelAvgVarianceParams(3, 3, 1300 &vpx_highbd_10_sub_pixel_avg_variance8x8_sse2, 1301 10), 1302 SubpelAvgVarianceParams(3, 2, 1303 &vpx_highbd_10_sub_pixel_avg_variance8x4_sse2, 1304 10), 1305 SubpelAvgVarianceParams(6, 6, 1306 &vpx_highbd_8_sub_pixel_avg_variance64x64_sse2, 1307 8), 1308 SubpelAvgVarianceParams(6, 5, 1309 &vpx_highbd_8_sub_pixel_avg_variance64x32_sse2, 1310 8), 1311 SubpelAvgVarianceParams(5, 6, 1312 &vpx_highbd_8_sub_pixel_avg_variance32x64_sse2, 1313 8), 1314 SubpelAvgVarianceParams(5, 5, 1315 &vpx_highbd_8_sub_pixel_avg_variance32x32_sse2, 1316 8), 1317 SubpelAvgVarianceParams(5, 4, 1318 &vpx_highbd_8_sub_pixel_avg_variance32x16_sse2, 1319 8), 1320 SubpelAvgVarianceParams(4, 5, 1321 &vpx_highbd_8_sub_pixel_avg_variance16x32_sse2, 1322 8), 1323 SubpelAvgVarianceParams(4, 4, 1324 &vpx_highbd_8_sub_pixel_avg_variance16x16_sse2, 1325 8), 1326 SubpelAvgVarianceParams(4, 3, 1327 &vpx_highbd_8_sub_pixel_avg_variance16x8_sse2, 1328 8), 1329 SubpelAvgVarianceParams(3, 4, 1330 &vpx_highbd_8_sub_pixel_avg_variance8x16_sse2, 1331 8), 1332 SubpelAvgVarianceParams(3, 3, 1333 &vpx_highbd_8_sub_pixel_avg_variance8x8_sse2, 1334 8), 1335 SubpelAvgVarianceParams(3, 2, 1336 &vpx_highbd_8_sub_pixel_avg_variance8x4_sse2, 1337 8))); 1338 #endif // CONFIG_VP9_HIGHBITDEPTH 1339 #endif // HAVE_SSE2 1340 1341 #if HAVE_SSSE3 1342 INSTANTIATE_TEST_CASE_P( 1343 SSSE3, VpxSubpelVarianceTest, 1344 ::testing::Values( 1345 SubpelVarianceParams(6, 6, &vpx_sub_pixel_variance64x64_ssse3, 0), 1346 SubpelVarianceParams(6, 5, &vpx_sub_pixel_variance64x32_ssse3, 0), 1347 SubpelVarianceParams(5, 6, &vpx_sub_pixel_variance32x64_ssse3, 0), 1348 SubpelVarianceParams(5, 5, &vpx_sub_pixel_variance32x32_ssse3, 0), 1349 SubpelVarianceParams(5, 4, &vpx_sub_pixel_variance32x16_ssse3, 0), 1350 SubpelVarianceParams(4, 5, &vpx_sub_pixel_variance16x32_ssse3, 0), 1351 SubpelVarianceParams(4, 4, &vpx_sub_pixel_variance16x16_ssse3, 0), 1352 SubpelVarianceParams(4, 3, &vpx_sub_pixel_variance16x8_ssse3, 0), 1353 SubpelVarianceParams(3, 4, &vpx_sub_pixel_variance8x16_ssse3, 0), 1354 SubpelVarianceParams(3, 3, &vpx_sub_pixel_variance8x8_ssse3, 0), 1355 SubpelVarianceParams(3, 2, &vpx_sub_pixel_variance8x4_ssse3, 0), 1356 SubpelVarianceParams(2, 3, &vpx_sub_pixel_variance4x8_ssse3, 0), 1357 SubpelVarianceParams(2, 2, &vpx_sub_pixel_variance4x4_ssse3, 0))); 1358 1359 INSTANTIATE_TEST_CASE_P( 1360 SSSE3, VpxSubpelAvgVarianceTest, 1361 ::testing::Values( 1362 SubpelAvgVarianceParams(6, 6, &vpx_sub_pixel_avg_variance64x64_ssse3, 1363 0), 1364 SubpelAvgVarianceParams(6, 5, &vpx_sub_pixel_avg_variance64x32_ssse3, 1365 0), 1366 SubpelAvgVarianceParams(5, 6, &vpx_sub_pixel_avg_variance32x64_ssse3, 1367 0), 1368 SubpelAvgVarianceParams(5, 5, &vpx_sub_pixel_avg_variance32x32_ssse3, 1369 0), 1370 SubpelAvgVarianceParams(5, 4, &vpx_sub_pixel_avg_variance32x16_ssse3, 1371 0), 1372 SubpelAvgVarianceParams(4, 5, &vpx_sub_pixel_avg_variance16x32_ssse3, 1373 0), 1374 SubpelAvgVarianceParams(4, 4, &vpx_sub_pixel_avg_variance16x16_ssse3, 1375 0), 1376 SubpelAvgVarianceParams(4, 3, &vpx_sub_pixel_avg_variance16x8_ssse3, 0), 1377 SubpelAvgVarianceParams(3, 4, &vpx_sub_pixel_avg_variance8x16_ssse3, 0), 1378 SubpelAvgVarianceParams(3, 3, &vpx_sub_pixel_avg_variance8x8_ssse3, 0), 1379 SubpelAvgVarianceParams(3, 2, &vpx_sub_pixel_avg_variance8x4_ssse3, 0), 1380 SubpelAvgVarianceParams(2, 3, &vpx_sub_pixel_avg_variance4x8_ssse3, 0), 1381 SubpelAvgVarianceParams(2, 2, &vpx_sub_pixel_avg_variance4x4_ssse3, 1382 0))); 1383 #endif // HAVE_SSSE3 1384 1385 #if HAVE_AVX2 1386 INSTANTIATE_TEST_CASE_P(AVX2, VpxMseTest, 1387 ::testing::Values(MseParams(4, 4, &vpx_mse16x16_avx2))); 1388 1389 INSTANTIATE_TEST_CASE_P( 1390 AVX2, VpxVarianceTest, 1391 ::testing::Values(VarianceParams(6, 6, &vpx_variance64x64_avx2), 1392 VarianceParams(6, 5, &vpx_variance64x32_avx2), 1393 VarianceParams(5, 5, &vpx_variance32x32_avx2), 1394 VarianceParams(5, 4, &vpx_variance32x16_avx2), 1395 VarianceParams(4, 4, &vpx_variance16x16_avx2))); 1396 1397 INSTANTIATE_TEST_CASE_P( 1398 AVX2, VpxSubpelVarianceTest, 1399 ::testing::Values( 1400 SubpelVarianceParams(6, 6, &vpx_sub_pixel_variance64x64_avx2, 0), 1401 SubpelVarianceParams(5, 5, &vpx_sub_pixel_variance32x32_avx2, 0))); 1402 1403 INSTANTIATE_TEST_CASE_P( 1404 AVX2, VpxSubpelAvgVarianceTest, 1405 ::testing::Values( 1406 SubpelAvgVarianceParams(6, 6, &vpx_sub_pixel_avg_variance64x64_avx2, 0), 1407 SubpelAvgVarianceParams(5, 5, &vpx_sub_pixel_avg_variance32x32_avx2, 1408 0))); 1409 #endif // HAVE_AVX2 1410 1411 #if HAVE_NEON 1412 INSTANTIATE_TEST_CASE_P(NEON, VpxSseTest, 1413 ::testing::Values(SseParams(2, 2, 1414 &vpx_get4x4sse_cs_neon))); 1415 1416 INSTANTIATE_TEST_CASE_P(NEON, VpxMseTest, 1417 ::testing::Values(MseParams(4, 4, &vpx_mse16x16_neon))); 1418 1419 INSTANTIATE_TEST_CASE_P( 1420 NEON, VpxVarianceTest, 1421 ::testing::Values(VarianceParams(6, 6, &vpx_variance64x64_neon), 1422 VarianceParams(6, 5, &vpx_variance64x32_neon), 1423 VarianceParams(5, 6, &vpx_variance32x64_neon), 1424 VarianceParams(5, 5, &vpx_variance32x32_neon), 1425 VarianceParams(5, 4, &vpx_variance32x16_neon), 1426 VarianceParams(4, 5, &vpx_variance16x32_neon), 1427 VarianceParams(4, 4, &vpx_variance16x16_neon), 1428 VarianceParams(4, 3, &vpx_variance16x8_neon), 1429 VarianceParams(3, 4, &vpx_variance8x16_neon), 1430 VarianceParams(3, 3, &vpx_variance8x8_neon), 1431 VarianceParams(3, 2, &vpx_variance8x4_neon), 1432 VarianceParams(2, 3, &vpx_variance4x8_neon), 1433 VarianceParams(2, 2, &vpx_variance4x4_neon))); 1434 1435 INSTANTIATE_TEST_CASE_P( 1436 NEON, VpxSubpelVarianceTest, 1437 ::testing::Values( 1438 SubpelVarianceParams(6, 6, &vpx_sub_pixel_variance64x64_neon, 0), 1439 SubpelVarianceParams(6, 5, &vpx_sub_pixel_variance64x32_neon, 0), 1440 SubpelVarianceParams(5, 6, &vpx_sub_pixel_variance32x64_neon, 0), 1441 SubpelVarianceParams(5, 5, &vpx_sub_pixel_variance32x32_neon, 0), 1442 SubpelVarianceParams(5, 4, &vpx_sub_pixel_variance32x16_neon, 0), 1443 SubpelVarianceParams(4, 5, &vpx_sub_pixel_variance16x32_neon, 0), 1444 SubpelVarianceParams(4, 4, &vpx_sub_pixel_variance16x16_neon, 0), 1445 SubpelVarianceParams(4, 3, &vpx_sub_pixel_variance16x8_neon, 0), 1446 SubpelVarianceParams(3, 4, &vpx_sub_pixel_variance8x16_neon, 0), 1447 SubpelVarianceParams(3, 3, &vpx_sub_pixel_variance8x8_neon, 0), 1448 SubpelVarianceParams(3, 2, &vpx_sub_pixel_variance8x4_neon, 0), 1449 SubpelVarianceParams(2, 3, &vpx_sub_pixel_variance4x8_neon, 0), 1450 SubpelVarianceParams(2, 2, &vpx_sub_pixel_variance4x4_neon, 0))); 1451 1452 INSTANTIATE_TEST_CASE_P( 1453 NEON, VpxSubpelAvgVarianceTest, 1454 ::testing::Values( 1455 SubpelAvgVarianceParams(6, 6, &vpx_sub_pixel_avg_variance64x64_neon, 0), 1456 SubpelAvgVarianceParams(6, 5, &vpx_sub_pixel_avg_variance64x32_neon, 0), 1457 SubpelAvgVarianceParams(5, 6, &vpx_sub_pixel_avg_variance32x64_neon, 0), 1458 SubpelAvgVarianceParams(5, 5, &vpx_sub_pixel_avg_variance32x32_neon, 0), 1459 SubpelAvgVarianceParams(5, 4, &vpx_sub_pixel_avg_variance32x16_neon, 0), 1460 SubpelAvgVarianceParams(4, 5, &vpx_sub_pixel_avg_variance16x32_neon, 0), 1461 SubpelAvgVarianceParams(4, 4, &vpx_sub_pixel_avg_variance16x16_neon, 0), 1462 SubpelAvgVarianceParams(4, 3, &vpx_sub_pixel_avg_variance16x8_neon, 0), 1463 SubpelAvgVarianceParams(3, 4, &vpx_sub_pixel_avg_variance8x16_neon, 0), 1464 SubpelAvgVarianceParams(3, 3, &vpx_sub_pixel_avg_variance8x8_neon, 0), 1465 SubpelAvgVarianceParams(3, 2, &vpx_sub_pixel_avg_variance8x4_neon, 0), 1466 SubpelAvgVarianceParams(2, 3, &vpx_sub_pixel_avg_variance4x8_neon, 0), 1467 SubpelAvgVarianceParams(2, 2, &vpx_sub_pixel_avg_variance4x4_neon, 0))); 1468 #endif // HAVE_NEON 1469 1470 #if HAVE_MSA 1471 INSTANTIATE_TEST_CASE_P(MSA, SumOfSquaresTest, 1472 ::testing::Values(vpx_get_mb_ss_msa)); 1473 1474 INSTANTIATE_TEST_CASE_P(MSA, VpxSseTest, 1475 ::testing::Values(SseParams(2, 2, 1476 &vpx_get4x4sse_cs_msa))); 1477 1478 INSTANTIATE_TEST_CASE_P(MSA, VpxMseTest, 1479 ::testing::Values(MseParams(4, 4, &vpx_mse16x16_msa), 1480 MseParams(4, 3, &vpx_mse16x8_msa), 1481 MseParams(3, 4, &vpx_mse8x16_msa), 1482 MseParams(3, 3, &vpx_mse8x8_msa))); 1483 1484 INSTANTIATE_TEST_CASE_P( 1485 MSA, VpxVarianceTest, 1486 ::testing::Values(VarianceParams(6, 6, &vpx_variance64x64_msa), 1487 VarianceParams(6, 5, &vpx_variance64x32_msa), 1488 VarianceParams(5, 6, &vpx_variance32x64_msa), 1489 VarianceParams(5, 5, &vpx_variance32x32_msa), 1490 VarianceParams(5, 4, &vpx_variance32x16_msa), 1491 VarianceParams(4, 5, &vpx_variance16x32_msa), 1492 VarianceParams(4, 4, &vpx_variance16x16_msa), 1493 VarianceParams(4, 3, &vpx_variance16x8_msa), 1494 VarianceParams(3, 4, &vpx_variance8x16_msa), 1495 VarianceParams(3, 3, &vpx_variance8x8_msa), 1496 VarianceParams(3, 2, &vpx_variance8x4_msa), 1497 VarianceParams(2, 3, &vpx_variance4x8_msa), 1498 VarianceParams(2, 2, &vpx_variance4x4_msa))); 1499 1500 INSTANTIATE_TEST_CASE_P( 1501 MSA, VpxSubpelVarianceTest, 1502 ::testing::Values( 1503 SubpelVarianceParams(2, 2, &vpx_sub_pixel_variance4x4_msa, 0), 1504 SubpelVarianceParams(2, 3, &vpx_sub_pixel_variance4x8_msa, 0), 1505 SubpelVarianceParams(3, 2, &vpx_sub_pixel_variance8x4_msa, 0), 1506 SubpelVarianceParams(3, 3, &vpx_sub_pixel_variance8x8_msa, 0), 1507 SubpelVarianceParams(3, 4, &vpx_sub_pixel_variance8x16_msa, 0), 1508 SubpelVarianceParams(4, 3, &vpx_sub_pixel_variance16x8_msa, 0), 1509 SubpelVarianceParams(4, 4, &vpx_sub_pixel_variance16x16_msa, 0), 1510 SubpelVarianceParams(4, 5, &vpx_sub_pixel_variance16x32_msa, 0), 1511 SubpelVarianceParams(5, 4, &vpx_sub_pixel_variance32x16_msa, 0), 1512 SubpelVarianceParams(5, 5, &vpx_sub_pixel_variance32x32_msa, 0), 1513 SubpelVarianceParams(5, 6, &vpx_sub_pixel_variance32x64_msa, 0), 1514 SubpelVarianceParams(6, 5, &vpx_sub_pixel_variance64x32_msa, 0), 1515 SubpelVarianceParams(6, 6, &vpx_sub_pixel_variance64x64_msa, 0))); 1516 1517 INSTANTIATE_TEST_CASE_P( 1518 MSA, VpxSubpelAvgVarianceTest, 1519 ::testing::Values( 1520 SubpelAvgVarianceParams(6, 6, &vpx_sub_pixel_avg_variance64x64_msa, 0), 1521 SubpelAvgVarianceParams(6, 5, &vpx_sub_pixel_avg_variance64x32_msa, 0), 1522 SubpelAvgVarianceParams(5, 6, &vpx_sub_pixel_avg_variance32x64_msa, 0), 1523 SubpelAvgVarianceParams(5, 5, &vpx_sub_pixel_avg_variance32x32_msa, 0), 1524 SubpelAvgVarianceParams(5, 4, &vpx_sub_pixel_avg_variance32x16_msa, 0), 1525 SubpelAvgVarianceParams(4, 5, &vpx_sub_pixel_avg_variance16x32_msa, 0), 1526 SubpelAvgVarianceParams(4, 4, &vpx_sub_pixel_avg_variance16x16_msa, 0), 1527 SubpelAvgVarianceParams(4, 3, &vpx_sub_pixel_avg_variance16x8_msa, 0), 1528 SubpelAvgVarianceParams(3, 4, &vpx_sub_pixel_avg_variance8x16_msa, 0), 1529 SubpelAvgVarianceParams(3, 3, &vpx_sub_pixel_avg_variance8x8_msa, 0), 1530 SubpelAvgVarianceParams(3, 2, &vpx_sub_pixel_avg_variance8x4_msa, 0), 1531 SubpelAvgVarianceParams(2, 3, &vpx_sub_pixel_avg_variance4x8_msa, 0), 1532 SubpelAvgVarianceParams(2, 2, &vpx_sub_pixel_avg_variance4x4_msa, 0))); 1533 #endif // HAVE_MSA 1534 1535 #if HAVE_VSX 1536 INSTANTIATE_TEST_CASE_P(VSX, SumOfSquaresTest, 1537 ::testing::Values(vpx_get_mb_ss_vsx)); 1538 1539 INSTANTIATE_TEST_CASE_P(VSX, VpxSseTest, 1540 ::testing::Values(SseParams(2, 2, 1541 &vpx_get4x4sse_cs_vsx))); 1542 #endif // HAVE_VSX 1543 1544 #if HAVE_MMI 1545 INSTANTIATE_TEST_CASE_P(MMI, VpxMseTest, 1546 ::testing::Values(MseParams(4, 4, &vpx_mse16x16_mmi), 1547 MseParams(4, 3, &vpx_mse16x8_mmi), 1548 MseParams(3, 4, &vpx_mse8x16_mmi), 1549 MseParams(3, 3, &vpx_mse8x8_mmi))); 1550 1551 INSTANTIATE_TEST_CASE_P( 1552 MMI, VpxVarianceTest, 1553 ::testing::Values(VarianceParams(6, 6, &vpx_variance64x64_mmi), 1554 VarianceParams(6, 5, &vpx_variance64x32_mmi), 1555 VarianceParams(5, 6, &vpx_variance32x64_mmi), 1556 VarianceParams(5, 5, &vpx_variance32x32_mmi), 1557 VarianceParams(5, 4, &vpx_variance32x16_mmi), 1558 VarianceParams(4, 5, &vpx_variance16x32_mmi), 1559 VarianceParams(4, 4, &vpx_variance16x16_mmi), 1560 VarianceParams(4, 3, &vpx_variance16x8_mmi), 1561 VarianceParams(3, 4, &vpx_variance8x16_mmi), 1562 VarianceParams(3, 3, &vpx_variance8x8_mmi), 1563 VarianceParams(3, 2, &vpx_variance8x4_mmi), 1564 VarianceParams(2, 3, &vpx_variance4x8_mmi), 1565 VarianceParams(2, 2, &vpx_variance4x4_mmi))); 1566 1567 INSTANTIATE_TEST_CASE_P( 1568 MMI, VpxSubpelVarianceTest, 1569 ::testing::Values( 1570 SubpelVarianceParams(6, 6, &vpx_sub_pixel_variance64x64_mmi, 0), 1571 SubpelVarianceParams(6, 5, &vpx_sub_pixel_variance64x32_mmi, 0), 1572 SubpelVarianceParams(5, 6, &vpx_sub_pixel_variance32x64_mmi, 0), 1573 SubpelVarianceParams(5, 5, &vpx_sub_pixel_variance32x32_mmi, 0), 1574 SubpelVarianceParams(5, 4, &vpx_sub_pixel_variance32x16_mmi, 0), 1575 SubpelVarianceParams(4, 5, &vpx_sub_pixel_variance16x32_mmi, 0), 1576 SubpelVarianceParams(4, 4, &vpx_sub_pixel_variance16x16_mmi, 0), 1577 SubpelVarianceParams(4, 3, &vpx_sub_pixel_variance16x8_mmi, 0), 1578 SubpelVarianceParams(3, 4, &vpx_sub_pixel_variance8x16_mmi, 0), 1579 SubpelVarianceParams(3, 3, &vpx_sub_pixel_variance8x8_mmi, 0), 1580 SubpelVarianceParams(3, 2, &vpx_sub_pixel_variance8x4_mmi, 0), 1581 SubpelVarianceParams(2, 3, &vpx_sub_pixel_variance4x8_mmi, 0), 1582 SubpelVarianceParams(2, 2, &vpx_sub_pixel_variance4x4_mmi, 0))); 1583 1584 INSTANTIATE_TEST_CASE_P( 1585 MMI, VpxSubpelAvgVarianceTest, 1586 ::testing::Values( 1587 SubpelAvgVarianceParams(6, 6, &vpx_sub_pixel_avg_variance64x64_mmi, 0), 1588 SubpelAvgVarianceParams(6, 5, &vpx_sub_pixel_avg_variance64x32_mmi, 0), 1589 SubpelAvgVarianceParams(5, 6, &vpx_sub_pixel_avg_variance32x64_mmi, 0), 1590 SubpelAvgVarianceParams(5, 5, &vpx_sub_pixel_avg_variance32x32_mmi, 0), 1591 SubpelAvgVarianceParams(5, 4, &vpx_sub_pixel_avg_variance32x16_mmi, 0), 1592 SubpelAvgVarianceParams(4, 5, &vpx_sub_pixel_avg_variance16x32_mmi, 0), 1593 SubpelAvgVarianceParams(4, 4, &vpx_sub_pixel_avg_variance16x16_mmi, 0), 1594 SubpelAvgVarianceParams(4, 3, &vpx_sub_pixel_avg_variance16x8_mmi, 0), 1595 SubpelAvgVarianceParams(3, 4, &vpx_sub_pixel_avg_variance8x16_mmi, 0), 1596 SubpelAvgVarianceParams(3, 3, &vpx_sub_pixel_avg_variance8x8_mmi, 0), 1597 SubpelAvgVarianceParams(3, 2, &vpx_sub_pixel_avg_variance8x4_mmi, 0), 1598 SubpelAvgVarianceParams(2, 3, &vpx_sub_pixel_avg_variance4x8_mmi, 0), 1599 SubpelAvgVarianceParams(2, 2, &vpx_sub_pixel_avg_variance4x4_mmi, 0))); 1600 #endif // HAVE_MMI 1601 } // namespace 1602
