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 #include <stdlib.h> 11 #include <new> 12 13 #include "third_party/googletest/src/include/gtest/gtest.h" 14 15 #include "test/clear_system_state.h" 16 #include "test/register_state_check.h" 17 18 #include "vpx/vpx_integer.h" 19 #include "./vpx_config.h" 20 #include "vpx_mem/vpx_mem.h" 21 #if CONFIG_VP8_ENCODER 22 # include "./vp8_rtcd.h" 23 # include "vp8/common/variance.h" 24 #endif 25 #if CONFIG_VP9_ENCODER 26 # include "./vp9_rtcd.h" 27 # include "vp9/encoder/vp9_variance.h" 28 #endif 29 #include "test/acm_random.h" 30 31 namespace { 32 33 using ::std::tr1::get; 34 using ::std::tr1::make_tuple; 35 using ::std::tr1::tuple; 36 using libvpx_test::ACMRandom; 37 38 static unsigned int mb_ss_ref(const int16_t *src) { 39 unsigned int res = 0; 40 for (int i = 0; i < 256; ++i) { 41 res += src[i] * src[i]; 42 } 43 return res; 44 } 45 46 static unsigned int variance_ref(const uint8_t *ref, const uint8_t *src, 47 int l2w, int l2h, unsigned int *sse_ptr) { 48 int se = 0; 49 unsigned int sse = 0; 50 const int w = 1 << l2w, h = 1 << l2h; 51 for (int y = 0; y < h; y++) { 52 for (int x = 0; x < w; x++) { 53 int diff = ref[w * y + x] - src[w * y + x]; 54 se += diff; 55 sse += diff * diff; 56 } 57 } 58 *sse_ptr = sse; 59 return sse - (((int64_t) se * se) >> (l2w + l2h)); 60 } 61 62 static unsigned int subpel_variance_ref(const uint8_t *ref, const uint8_t *src, 63 int l2w, int l2h, int xoff, int yoff, 64 unsigned int *sse_ptr) { 65 int se = 0; 66 unsigned int sse = 0; 67 const int w = 1 << l2w, h = 1 << l2h; 68 for (int y = 0; y < h; y++) { 69 for (int x = 0; x < w; x++) { 70 // bilinear interpolation at a 16th pel step 71 const int a1 = ref[(w + 1) * (y + 0) + x + 0]; 72 const int a2 = ref[(w + 1) * (y + 0) + x + 1]; 73 const int b1 = ref[(w + 1) * (y + 1) + x + 0]; 74 const int b2 = ref[(w + 1) * (y + 1) + x + 1]; 75 const int a = a1 + (((a2 - a1) * xoff + 8) >> 4); 76 const int b = b1 + (((b2 - b1) * xoff + 8) >> 4); 77 const int r = a + (((b - a) * yoff + 8) >> 4); 78 int diff = r - src[w * y + x]; 79 se += diff; 80 sse += diff * diff; 81 } 82 } 83 *sse_ptr = sse; 84 return sse - (((int64_t) se * se) >> (l2w + l2h)); 85 } 86 87 typedef unsigned int (*SumOfSquaresFunction)(const int16_t *src); 88 89 class SumOfSquaresTest : public ::testing::TestWithParam<SumOfSquaresFunction> { 90 public: 91 SumOfSquaresTest() : func_(GetParam()) {} 92 93 virtual ~SumOfSquaresTest() { 94 libvpx_test::ClearSystemState(); 95 } 96 97 protected: 98 void ConstTest(); 99 void RefTest(); 100 101 SumOfSquaresFunction func_; 102 ACMRandom rnd_; 103 }; 104 105 void SumOfSquaresTest::ConstTest() { 106 int16_t mem[256]; 107 unsigned int res; 108 for (int v = 0; v < 256; ++v) { 109 for (int i = 0; i < 256; ++i) { 110 mem[i] = v; 111 } 112 ASM_REGISTER_STATE_CHECK(res = func_(mem)); 113 EXPECT_EQ(256u * (v * v), res); 114 } 115 } 116 117 void SumOfSquaresTest::RefTest() { 118 int16_t mem[256]; 119 for (int i = 0; i < 100; ++i) { 120 for (int j = 0; j < 256; ++j) { 121 mem[j] = rnd_.Rand8() - rnd_.Rand8(); 122 } 123 124 const unsigned int expected = mb_ss_ref(mem); 125 unsigned int res; 126 ASM_REGISTER_STATE_CHECK(res = func_(mem)); 127 EXPECT_EQ(expected, res); 128 } 129 } 130 131 template<typename VarianceFunctionType> 132 class VarianceTest 133 : public ::testing::TestWithParam<tuple<int, int, VarianceFunctionType> > { 134 public: 135 virtual void SetUp() { 136 const tuple<int, int, VarianceFunctionType>& params = this->GetParam(); 137 log2width_ = get<0>(params); 138 width_ = 1 << log2width_; 139 log2height_ = get<1>(params); 140 height_ = 1 << log2height_; 141 variance_ = get<2>(params); 142 143 rnd_.Reset(ACMRandom::DeterministicSeed()); 144 block_size_ = width_ * height_; 145 src_ = reinterpret_cast<uint8_t *>(vpx_memalign(16, block_size_)); 146 ref_ = new uint8_t[block_size_]; 147 ASSERT_TRUE(src_ != NULL); 148 ASSERT_TRUE(ref_ != NULL); 149 } 150 151 virtual void TearDown() { 152 vpx_free(src_); 153 delete[] ref_; 154 libvpx_test::ClearSystemState(); 155 } 156 157 protected: 158 void ZeroTest(); 159 void RefTest(); 160 void OneQuarterTest(); 161 162 ACMRandom rnd_; 163 uint8_t* src_; 164 uint8_t* ref_; 165 int width_, log2width_; 166 int height_, log2height_; 167 int block_size_; 168 VarianceFunctionType variance_; 169 }; 170 171 template<typename VarianceFunctionType> 172 void VarianceTest<VarianceFunctionType>::ZeroTest() { 173 for (int i = 0; i <= 255; ++i) { 174 memset(src_, i, block_size_); 175 for (int j = 0; j <= 255; ++j) { 176 memset(ref_, j, block_size_); 177 unsigned int sse; 178 unsigned int var; 179 ASM_REGISTER_STATE_CHECK( 180 var = variance_(src_, width_, ref_, width_, &sse)); 181 EXPECT_EQ(0u, var) << "src values: " << i << "ref values: " << j; 182 } 183 } 184 } 185 186 template<typename VarianceFunctionType> 187 void VarianceTest<VarianceFunctionType>::RefTest() { 188 for (int i = 0; i < 10; ++i) { 189 for (int j = 0; j < block_size_; j++) { 190 src_[j] = rnd_.Rand8(); 191 ref_[j] = rnd_.Rand8(); 192 } 193 unsigned int sse1, sse2; 194 unsigned int var1; 195 ASM_REGISTER_STATE_CHECK( 196 var1 = variance_(src_, width_, ref_, width_, &sse1)); 197 const unsigned int var2 = variance_ref(src_, ref_, log2width_, 198 log2height_, &sse2); 199 EXPECT_EQ(sse1, sse2); 200 EXPECT_EQ(var1, var2); 201 } 202 } 203 204 template<typename VarianceFunctionType> 205 void VarianceTest<VarianceFunctionType>::OneQuarterTest() { 206 memset(src_, 255, block_size_); 207 const int half = block_size_ / 2; 208 memset(ref_, 255, half); 209 memset(ref_ + half, 0, half); 210 unsigned int sse; 211 unsigned int var; 212 ASM_REGISTER_STATE_CHECK(var = variance_(src_, width_, ref_, width_, &sse)); 213 const unsigned int expected = block_size_ * 255 * 255 / 4; 214 EXPECT_EQ(expected, var); 215 } 216 217 #if CONFIG_VP8_ENCODER 218 template<typename MseFunctionType> 219 class MseTest 220 : public ::testing::TestWithParam<tuple<int, int, MseFunctionType> > { 221 public: 222 virtual void SetUp() { 223 const tuple<int, int, MseFunctionType>& params = this->GetParam(); 224 log2width_ = get<0>(params); 225 width_ = 1 << log2width_; 226 log2height_ = get<1>(params); 227 height_ = 1 << log2height_; 228 mse_ = get<2>(params); 229 230 rnd(ACMRandom::DeterministicSeed()); 231 block_size_ = width_ * height_; 232 src_ = reinterpret_cast<uint8_t *>(vpx_memalign(16, block_size_)); 233 ref_ = new uint8_t[block_size_]; 234 ASSERT_TRUE(src_ != NULL); 235 ASSERT_TRUE(ref_ != NULL); 236 } 237 238 virtual void TearDown() { 239 vpx_free(src_); 240 delete[] ref_; 241 libvpx_test::ClearSystemState(); 242 } 243 244 protected: 245 void RefTest_mse(); 246 void RefTest_sse(); 247 void MaxTest_mse(); 248 void MaxTest_sse(); 249 250 ACMRandom rnd; 251 uint8_t* src_; 252 uint8_t* ref_; 253 int width_, log2width_; 254 int height_, log2height_; 255 int block_size_; 256 MseFunctionType mse_; 257 }; 258 259 template<typename MseFunctionType> 260 void MseTest<MseFunctionType>::RefTest_mse() { 261 for (int i = 0; i < 10; ++i) { 262 for (int j = 0; j < block_size_; j++) { 263 src_[j] = rnd.Rand8(); 264 ref_[j] = rnd.Rand8(); 265 } 266 unsigned int sse1, sse2; 267 ASM_REGISTER_STATE_CHECK(mse_(src_, width_, ref_, width_, &sse1)); 268 variance_ref(src_, ref_, log2width_, log2height_, &sse2); 269 EXPECT_EQ(sse1, sse2); 270 } 271 } 272 273 template<typename MseFunctionType> 274 void MseTest<MseFunctionType>::RefTest_sse() { 275 for (int i = 0; i < 10; ++i) { 276 for (int j = 0; j < block_size_; j++) { 277 src_[j] = rnd.Rand8(); 278 ref_[j] = rnd.Rand8(); 279 } 280 unsigned int sse2; 281 unsigned int var1; 282 ASM_REGISTER_STATE_CHECK( 283 var1 = mse_(src_, width_, ref_, width_)); 284 variance_ref(src_, ref_, log2width_, log2height_, &sse2); 285 EXPECT_EQ(var1, sse2); 286 } 287 } 288 289 template<typename MseFunctionType> 290 void MseTest<MseFunctionType>::MaxTest_mse() { 291 memset(src_, 255, block_size_); 292 memset(ref_, 0, block_size_); 293 unsigned int sse; 294 ASM_REGISTER_STATE_CHECK(mse_(src_, width_, ref_, width_, &sse)); 295 const unsigned int expected = block_size_ * 255 * 255; 296 EXPECT_EQ(expected, sse); 297 } 298 299 template<typename MseFunctionType> 300 void MseTest<MseFunctionType>::MaxTest_sse() { 301 memset(src_, 255, block_size_); 302 memset(ref_, 0, block_size_); 303 unsigned int var; 304 ASM_REGISTER_STATE_CHECK(var = mse_(src_, width_, ref_, width_)); 305 const unsigned int expected = block_size_ * 255 * 255; 306 EXPECT_EQ(expected, var); 307 } 308 #endif 309 310 #if CONFIG_VP9_ENCODER 311 312 unsigned int subpel_avg_variance_ref(const uint8_t *ref, 313 const uint8_t *src, 314 const uint8_t *second_pred, 315 int l2w, int l2h, 316 int xoff, int yoff, 317 unsigned int *sse_ptr) { 318 int se = 0; 319 unsigned int sse = 0; 320 const int w = 1 << l2w, h = 1 << l2h; 321 for (int y = 0; y < h; y++) { 322 for (int x = 0; x < w; x++) { 323 // bilinear interpolation at a 16th pel step 324 const int a1 = ref[(w + 1) * (y + 0) + x + 0]; 325 const int a2 = ref[(w + 1) * (y + 0) + x + 1]; 326 const int b1 = ref[(w + 1) * (y + 1) + x + 0]; 327 const int b2 = ref[(w + 1) * (y + 1) + x + 1]; 328 const int a = a1 + (((a2 - a1) * xoff + 8) >> 4); 329 const int b = b1 + (((b2 - b1) * xoff + 8) >> 4); 330 const int r = a + (((b - a) * yoff + 8) >> 4); 331 int diff = ((r + second_pred[w * y + x] + 1) >> 1) - src[w * y + x]; 332 se += diff; 333 sse += diff * diff; 334 } 335 } 336 *sse_ptr = sse; 337 return sse - (((int64_t) se * se) >> (l2w + l2h)); 338 } 339 340 template<typename SubpelVarianceFunctionType> 341 class SubpelVarianceTest 342 : public ::testing::TestWithParam<tuple<int, int, 343 SubpelVarianceFunctionType> > { 344 public: 345 virtual void SetUp() { 346 const tuple<int, int, SubpelVarianceFunctionType>& params = 347 this->GetParam(); 348 log2width_ = get<0>(params); 349 width_ = 1 << log2width_; 350 log2height_ = get<1>(params); 351 height_ = 1 << log2height_; 352 subpel_variance_ = get<2>(params); 353 354 rnd_.Reset(ACMRandom::DeterministicSeed()); 355 block_size_ = width_ * height_; 356 src_ = reinterpret_cast<uint8_t *>(vpx_memalign(16, block_size_)); 357 sec_ = reinterpret_cast<uint8_t *>(vpx_memalign(16, block_size_)); 358 ref_ = new uint8_t[block_size_ + width_ + height_ + 1]; 359 ASSERT_TRUE(src_ != NULL); 360 ASSERT_TRUE(sec_ != NULL); 361 ASSERT_TRUE(ref_ != NULL); 362 } 363 364 virtual void TearDown() { 365 vpx_free(src_); 366 delete[] ref_; 367 vpx_free(sec_); 368 libvpx_test::ClearSystemState(); 369 } 370 371 protected: 372 void RefTest(); 373 374 ACMRandom rnd_; 375 uint8_t *src_; 376 uint8_t *ref_; 377 uint8_t *sec_; 378 int width_, log2width_; 379 int height_, log2height_; 380 int block_size_; 381 SubpelVarianceFunctionType subpel_variance_; 382 }; 383 384 template<typename SubpelVarianceFunctionType> 385 void SubpelVarianceTest<SubpelVarianceFunctionType>::RefTest() { 386 for (int x = 0; x < 16; ++x) { 387 for (int y = 0; y < 16; ++y) { 388 for (int j = 0; j < block_size_; j++) { 389 src_[j] = rnd_.Rand8(); 390 } 391 for (int j = 0; j < block_size_ + width_ + height_ + 1; j++) { 392 ref_[j] = rnd_.Rand8(); 393 } 394 unsigned int sse1, sse2; 395 unsigned int var1; 396 ASM_REGISTER_STATE_CHECK(var1 = subpel_variance_(ref_, width_ + 1, x, y, 397 src_, width_, &sse1)); 398 const unsigned int var2 = subpel_variance_ref(ref_, src_, log2width_, 399 log2height_, x, y, &sse2); 400 EXPECT_EQ(sse1, sse2) << "at position " << x << ", " << y; 401 EXPECT_EQ(var1, var2) << "at position " << x << ", " << y; 402 } 403 } 404 } 405 406 template<> 407 void SubpelVarianceTest<vp9_subp_avg_variance_fn_t>::RefTest() { 408 for (int x = 0; x < 16; ++x) { 409 for (int y = 0; y < 16; ++y) { 410 for (int j = 0; j < block_size_; j++) { 411 src_[j] = rnd_.Rand8(); 412 sec_[j] = rnd_.Rand8(); 413 } 414 for (int j = 0; j < block_size_ + width_ + height_ + 1; j++) { 415 ref_[j] = rnd_.Rand8(); 416 } 417 unsigned int sse1, sse2; 418 unsigned int var1; 419 ASM_REGISTER_STATE_CHECK( 420 var1 = subpel_variance_(ref_, width_ + 1, x, y, 421 src_, width_, &sse1, sec_)); 422 const unsigned int var2 = subpel_avg_variance_ref(ref_, src_, sec_, 423 log2width_, log2height_, 424 x, y, &sse2); 425 EXPECT_EQ(sse1, sse2) << "at position " << x << ", " << y; 426 EXPECT_EQ(var1, var2) << "at position " << x << ", " << y; 427 } 428 } 429 } 430 431 #endif // CONFIG_VP9_ENCODER 432 433 // ----------------------------------------------------------------------------- 434 // VP8 test cases. 435 436 namespace vp8 { 437 438 #if CONFIG_VP8_ENCODER 439 typedef unsigned int (*vp8_sse_fn_t)(const unsigned char *src_ptr, 440 int source_stride, const unsigned char *ref_ptr, int ref_stride); 441 442 typedef MseTest<vp8_sse_fn_t> VP8SseTest; 443 typedef MseTest<vp8_variance_fn_t> VP8MseTest; 444 typedef VarianceTest<vp8_variance_fn_t> VP8VarianceTest; 445 446 TEST_P(VP8SseTest, Ref_sse) { RefTest_sse(); } 447 TEST_P(VP8SseTest, Max_sse) { MaxTest_sse(); } 448 TEST_P(VP8MseTest, Ref_mse) { RefTest_mse(); } 449 TEST_P(VP8MseTest, Max_mse) { MaxTest_mse(); } 450 TEST_P(VP8VarianceTest, Zero) { ZeroTest(); } 451 TEST_P(VP8VarianceTest, Ref) { RefTest(); } 452 TEST_P(VP8VarianceTest, OneQuarter) { OneQuarterTest(); } 453 454 const vp8_sse_fn_t get4x4sse_cs_c = vp8_get4x4sse_cs_c; 455 INSTANTIATE_TEST_CASE_P( 456 C, VP8SseTest, 457 ::testing::Values(make_tuple(2, 2, get4x4sse_cs_c))); 458 459 const vp8_variance_fn_t mse16x16_c = vp8_mse16x16_c; 460 INSTANTIATE_TEST_CASE_P( 461 C, VP8MseTest, 462 ::testing::Values(make_tuple(4, 4, mse16x16_c))); 463 464 const vp8_variance_fn_t variance4x4_c = vp8_variance4x4_c; 465 const vp8_variance_fn_t variance8x8_c = vp8_variance8x8_c; 466 const vp8_variance_fn_t variance8x16_c = vp8_variance8x16_c; 467 const vp8_variance_fn_t variance16x8_c = vp8_variance16x8_c; 468 const vp8_variance_fn_t variance16x16_c = vp8_variance16x16_c; 469 INSTANTIATE_TEST_CASE_P( 470 C, VP8VarianceTest, 471 ::testing::Values(make_tuple(2, 2, variance4x4_c), 472 make_tuple(3, 3, variance8x8_c), 473 make_tuple(3, 4, variance8x16_c), 474 make_tuple(4, 3, variance16x8_c), 475 make_tuple(4, 4, variance16x16_c))); 476 477 #if HAVE_NEON 478 const vp8_sse_fn_t get4x4sse_cs_neon = vp8_get4x4sse_cs_neon; 479 INSTANTIATE_TEST_CASE_P( 480 NEON, VP8SseTest, 481 ::testing::Values(make_tuple(2, 2, get4x4sse_cs_neon))); 482 483 const vp8_variance_fn_t mse16x16_neon = vp8_mse16x16_neon; 484 INSTANTIATE_TEST_CASE_P( 485 NEON, VP8MseTest, 486 ::testing::Values(make_tuple(4, 4, mse16x16_neon))); 487 488 const vp8_variance_fn_t variance8x8_neon = vp8_variance8x8_neon; 489 const vp8_variance_fn_t variance8x16_neon = vp8_variance8x16_neon; 490 const vp8_variance_fn_t variance16x8_neon = vp8_variance16x8_neon; 491 const vp8_variance_fn_t variance16x16_neon = vp8_variance16x16_neon; 492 INSTANTIATE_TEST_CASE_P( 493 NEON, VP8VarianceTest, 494 ::testing::Values(make_tuple(3, 3, variance8x8_neon), 495 make_tuple(3, 4, variance8x16_neon), 496 make_tuple(4, 3, variance16x8_neon), 497 make_tuple(4, 4, variance16x16_neon))); 498 #endif 499 500 501 #if HAVE_MMX 502 const vp8_variance_fn_t variance4x4_mmx = vp8_variance4x4_mmx; 503 const vp8_variance_fn_t variance8x8_mmx = vp8_variance8x8_mmx; 504 const vp8_variance_fn_t variance8x16_mmx = vp8_variance8x16_mmx; 505 const vp8_variance_fn_t variance16x8_mmx = vp8_variance16x8_mmx; 506 const vp8_variance_fn_t variance16x16_mmx = vp8_variance16x16_mmx; 507 INSTANTIATE_TEST_CASE_P( 508 MMX, VP8VarianceTest, 509 ::testing::Values(make_tuple(2, 2, variance4x4_mmx), 510 make_tuple(3, 3, variance8x8_mmx), 511 make_tuple(3, 4, variance8x16_mmx), 512 make_tuple(4, 3, variance16x8_mmx), 513 make_tuple(4, 4, variance16x16_mmx))); 514 #endif 515 516 #if HAVE_SSE2 517 const vp8_variance_fn_t variance4x4_wmt = vp8_variance4x4_wmt; 518 const vp8_variance_fn_t variance8x8_wmt = vp8_variance8x8_wmt; 519 const vp8_variance_fn_t variance8x16_wmt = vp8_variance8x16_wmt; 520 const vp8_variance_fn_t variance16x8_wmt = vp8_variance16x8_wmt; 521 const vp8_variance_fn_t variance16x16_wmt = vp8_variance16x16_wmt; 522 INSTANTIATE_TEST_CASE_P( 523 SSE2, VP8VarianceTest, 524 ::testing::Values(make_tuple(2, 2, variance4x4_wmt), 525 make_tuple(3, 3, variance8x8_wmt), 526 make_tuple(3, 4, variance8x16_wmt), 527 make_tuple(4, 3, variance16x8_wmt), 528 make_tuple(4, 4, variance16x16_wmt))); 529 #endif 530 #endif // CONFIG_VP8_ENCODER 531 532 } // namespace vp8 533 534 // ----------------------------------------------------------------------------- 535 // VP9 test cases. 536 537 namespace vp9 { 538 539 #if CONFIG_VP9_ENCODER 540 541 TEST_P(SumOfSquaresTest, Const) { ConstTest(); } 542 TEST_P(SumOfSquaresTest, Ref) { RefTest(); } 543 544 INSTANTIATE_TEST_CASE_P(C, SumOfSquaresTest, 545 ::testing::Values(vp9_get_mb_ss_c)); 546 547 typedef VarianceTest<vp9_variance_fn_t> VP9VarianceTest; 548 typedef SubpelVarianceTest<vp9_subpixvariance_fn_t> VP9SubpelVarianceTest; 549 typedef SubpelVarianceTest<vp9_subp_avg_variance_fn_t> VP9SubpelAvgVarianceTest; 550 551 TEST_P(VP9VarianceTest, Zero) { ZeroTest(); } 552 TEST_P(VP9VarianceTest, Ref) { RefTest(); } 553 TEST_P(VP9SubpelVarianceTest, Ref) { RefTest(); } 554 TEST_P(VP9SubpelAvgVarianceTest, Ref) { RefTest(); } 555 TEST_P(VP9VarianceTest, OneQuarter) { OneQuarterTest(); } 556 557 const vp9_variance_fn_t variance4x4_c = vp9_variance4x4_c; 558 const vp9_variance_fn_t variance4x8_c = vp9_variance4x8_c; 559 const vp9_variance_fn_t variance8x4_c = vp9_variance8x4_c; 560 const vp9_variance_fn_t variance8x8_c = vp9_variance8x8_c; 561 const vp9_variance_fn_t variance8x16_c = vp9_variance8x16_c; 562 const vp9_variance_fn_t variance16x8_c = vp9_variance16x8_c; 563 const vp9_variance_fn_t variance16x16_c = vp9_variance16x16_c; 564 const vp9_variance_fn_t variance16x32_c = vp9_variance16x32_c; 565 const vp9_variance_fn_t variance32x16_c = vp9_variance32x16_c; 566 const vp9_variance_fn_t variance32x32_c = vp9_variance32x32_c; 567 const vp9_variance_fn_t variance32x64_c = vp9_variance32x64_c; 568 const vp9_variance_fn_t variance64x32_c = vp9_variance64x32_c; 569 const vp9_variance_fn_t variance64x64_c = vp9_variance64x64_c; 570 INSTANTIATE_TEST_CASE_P( 571 C, VP9VarianceTest, 572 ::testing::Values(make_tuple(2, 2, variance4x4_c), 573 make_tuple(2, 3, variance4x8_c), 574 make_tuple(3, 2, variance8x4_c), 575 make_tuple(3, 3, variance8x8_c), 576 make_tuple(3, 4, variance8x16_c), 577 make_tuple(4, 3, variance16x8_c), 578 make_tuple(4, 4, variance16x16_c), 579 make_tuple(4, 5, variance16x32_c), 580 make_tuple(5, 4, variance32x16_c), 581 make_tuple(5, 5, variance32x32_c), 582 make_tuple(5, 6, variance32x64_c), 583 make_tuple(6, 5, variance64x32_c), 584 make_tuple(6, 6, variance64x64_c))); 585 586 const vp9_subpixvariance_fn_t subpel_variance4x4_c = 587 vp9_sub_pixel_variance4x4_c; 588 const vp9_subpixvariance_fn_t subpel_variance4x8_c = 589 vp9_sub_pixel_variance4x8_c; 590 const vp9_subpixvariance_fn_t subpel_variance8x4_c = 591 vp9_sub_pixel_variance8x4_c; 592 const vp9_subpixvariance_fn_t subpel_variance8x8_c = 593 vp9_sub_pixel_variance8x8_c; 594 const vp9_subpixvariance_fn_t subpel_variance8x16_c = 595 vp9_sub_pixel_variance8x16_c; 596 const vp9_subpixvariance_fn_t subpel_variance16x8_c = 597 vp9_sub_pixel_variance16x8_c; 598 const vp9_subpixvariance_fn_t subpel_variance16x16_c = 599 vp9_sub_pixel_variance16x16_c; 600 const vp9_subpixvariance_fn_t subpel_variance16x32_c = 601 vp9_sub_pixel_variance16x32_c; 602 const vp9_subpixvariance_fn_t subpel_variance32x16_c = 603 vp9_sub_pixel_variance32x16_c; 604 const vp9_subpixvariance_fn_t subpel_variance32x32_c = 605 vp9_sub_pixel_variance32x32_c; 606 const vp9_subpixvariance_fn_t subpel_variance32x64_c = 607 vp9_sub_pixel_variance32x64_c; 608 const vp9_subpixvariance_fn_t subpel_variance64x32_c = 609 vp9_sub_pixel_variance64x32_c; 610 const vp9_subpixvariance_fn_t subpel_variance64x64_c = 611 vp9_sub_pixel_variance64x64_c; 612 INSTANTIATE_TEST_CASE_P( 613 C, VP9SubpelVarianceTest, 614 ::testing::Values(make_tuple(2, 2, subpel_variance4x4_c), 615 make_tuple(2, 3, subpel_variance4x8_c), 616 make_tuple(3, 2, subpel_variance8x4_c), 617 make_tuple(3, 3, subpel_variance8x8_c), 618 make_tuple(3, 4, subpel_variance8x16_c), 619 make_tuple(4, 3, subpel_variance16x8_c), 620 make_tuple(4, 4, subpel_variance16x16_c), 621 make_tuple(4, 5, subpel_variance16x32_c), 622 make_tuple(5, 4, subpel_variance32x16_c), 623 make_tuple(5, 5, subpel_variance32x32_c), 624 make_tuple(5, 6, subpel_variance32x64_c), 625 make_tuple(6, 5, subpel_variance64x32_c), 626 make_tuple(6, 6, subpel_variance64x64_c))); 627 628 const vp9_subp_avg_variance_fn_t subpel_avg_variance4x4_c = 629 vp9_sub_pixel_avg_variance4x4_c; 630 const vp9_subp_avg_variance_fn_t subpel_avg_variance4x8_c = 631 vp9_sub_pixel_avg_variance4x8_c; 632 const vp9_subp_avg_variance_fn_t subpel_avg_variance8x4_c = 633 vp9_sub_pixel_avg_variance8x4_c; 634 const vp9_subp_avg_variance_fn_t subpel_avg_variance8x8_c = 635 vp9_sub_pixel_avg_variance8x8_c; 636 const vp9_subp_avg_variance_fn_t subpel_avg_variance8x16_c = 637 vp9_sub_pixel_avg_variance8x16_c; 638 const vp9_subp_avg_variance_fn_t subpel_avg_variance16x8_c = 639 vp9_sub_pixel_avg_variance16x8_c; 640 const vp9_subp_avg_variance_fn_t subpel_avg_variance16x16_c = 641 vp9_sub_pixel_avg_variance16x16_c; 642 const vp9_subp_avg_variance_fn_t subpel_avg_variance16x32_c = 643 vp9_sub_pixel_avg_variance16x32_c; 644 const vp9_subp_avg_variance_fn_t subpel_avg_variance32x16_c = 645 vp9_sub_pixel_avg_variance32x16_c; 646 const vp9_subp_avg_variance_fn_t subpel_avg_variance32x32_c = 647 vp9_sub_pixel_avg_variance32x32_c; 648 const vp9_subp_avg_variance_fn_t subpel_avg_variance32x64_c = 649 vp9_sub_pixel_avg_variance32x64_c; 650 const vp9_subp_avg_variance_fn_t subpel_avg_variance64x32_c = 651 vp9_sub_pixel_avg_variance64x32_c; 652 const vp9_subp_avg_variance_fn_t subpel_avg_variance64x64_c = 653 vp9_sub_pixel_avg_variance64x64_c; 654 INSTANTIATE_TEST_CASE_P( 655 C, VP9SubpelAvgVarianceTest, 656 ::testing::Values(make_tuple(2, 2, subpel_avg_variance4x4_c), 657 make_tuple(2, 3, subpel_avg_variance4x8_c), 658 make_tuple(3, 2, subpel_avg_variance8x4_c), 659 make_tuple(3, 3, subpel_avg_variance8x8_c), 660 make_tuple(3, 4, subpel_avg_variance8x16_c), 661 make_tuple(4, 3, subpel_avg_variance16x8_c), 662 make_tuple(4, 4, subpel_avg_variance16x16_c), 663 make_tuple(4, 5, subpel_avg_variance16x32_c), 664 make_tuple(5, 4, subpel_avg_variance32x16_c), 665 make_tuple(5, 5, subpel_avg_variance32x32_c), 666 make_tuple(5, 6, subpel_avg_variance32x64_c), 667 make_tuple(6, 5, subpel_avg_variance64x32_c), 668 make_tuple(6, 6, subpel_avg_variance64x64_c))); 669 670 #if HAVE_SSE2 671 #if CONFIG_USE_X86INC 672 673 INSTANTIATE_TEST_CASE_P(SSE2, SumOfSquaresTest, 674 ::testing::Values(vp9_get_mb_ss_sse2)); 675 676 const vp9_variance_fn_t variance4x4_sse2 = vp9_variance4x4_sse2; 677 const vp9_variance_fn_t variance4x8_sse2 = vp9_variance4x8_sse2; 678 const vp9_variance_fn_t variance8x4_sse2 = vp9_variance8x4_sse2; 679 const vp9_variance_fn_t variance8x8_sse2 = vp9_variance8x8_sse2; 680 const vp9_variance_fn_t variance8x16_sse2 = vp9_variance8x16_sse2; 681 const vp9_variance_fn_t variance16x8_sse2 = vp9_variance16x8_sse2; 682 const vp9_variance_fn_t variance16x16_sse2 = vp9_variance16x16_sse2; 683 const vp9_variance_fn_t variance16x32_sse2 = vp9_variance16x32_sse2; 684 const vp9_variance_fn_t variance32x16_sse2 = vp9_variance32x16_sse2; 685 const vp9_variance_fn_t variance32x32_sse2 = vp9_variance32x32_sse2; 686 const vp9_variance_fn_t variance32x64_sse2 = vp9_variance32x64_sse2; 687 const vp9_variance_fn_t variance64x32_sse2 = vp9_variance64x32_sse2; 688 const vp9_variance_fn_t variance64x64_sse2 = vp9_variance64x64_sse2; 689 INSTANTIATE_TEST_CASE_P( 690 SSE2, VP9VarianceTest, 691 ::testing::Values(make_tuple(2, 2, variance4x4_sse2), 692 make_tuple(2, 3, variance4x8_sse2), 693 make_tuple(3, 2, variance8x4_sse2), 694 make_tuple(3, 3, variance8x8_sse2), 695 make_tuple(3, 4, variance8x16_sse2), 696 make_tuple(4, 3, variance16x8_sse2), 697 make_tuple(4, 4, variance16x16_sse2), 698 make_tuple(4, 5, variance16x32_sse2), 699 make_tuple(5, 4, variance32x16_sse2), 700 make_tuple(5, 5, variance32x32_sse2), 701 make_tuple(5, 6, variance32x64_sse2), 702 make_tuple(6, 5, variance64x32_sse2), 703 make_tuple(6, 6, variance64x64_sse2))); 704 705 const vp9_subpixvariance_fn_t subpel_variance4x4_sse = 706 vp9_sub_pixel_variance4x4_sse; 707 const vp9_subpixvariance_fn_t subpel_variance4x8_sse = 708 vp9_sub_pixel_variance4x8_sse; 709 const vp9_subpixvariance_fn_t subpel_variance8x4_sse2 = 710 vp9_sub_pixel_variance8x4_sse2; 711 const vp9_subpixvariance_fn_t subpel_variance8x8_sse2 = 712 vp9_sub_pixel_variance8x8_sse2; 713 const vp9_subpixvariance_fn_t subpel_variance8x16_sse2 = 714 vp9_sub_pixel_variance8x16_sse2; 715 const vp9_subpixvariance_fn_t subpel_variance16x8_sse2 = 716 vp9_sub_pixel_variance16x8_sse2; 717 const vp9_subpixvariance_fn_t subpel_variance16x16_sse2 = 718 vp9_sub_pixel_variance16x16_sse2; 719 const vp9_subpixvariance_fn_t subpel_variance16x32_sse2 = 720 vp9_sub_pixel_variance16x32_sse2; 721 const vp9_subpixvariance_fn_t subpel_variance32x16_sse2 = 722 vp9_sub_pixel_variance32x16_sse2; 723 const vp9_subpixvariance_fn_t subpel_variance32x32_sse2 = 724 vp9_sub_pixel_variance32x32_sse2; 725 const vp9_subpixvariance_fn_t subpel_variance32x64_sse2 = 726 vp9_sub_pixel_variance32x64_sse2; 727 const vp9_subpixvariance_fn_t subpel_variance64x32_sse2 = 728 vp9_sub_pixel_variance64x32_sse2; 729 const vp9_subpixvariance_fn_t subpel_variance64x64_sse2 = 730 vp9_sub_pixel_variance64x64_sse2; 731 INSTANTIATE_TEST_CASE_P( 732 SSE2, VP9SubpelVarianceTest, 733 ::testing::Values(make_tuple(2, 2, subpel_variance4x4_sse), 734 make_tuple(2, 3, subpel_variance4x8_sse), 735 make_tuple(3, 2, subpel_variance8x4_sse2), 736 make_tuple(3, 3, subpel_variance8x8_sse2), 737 make_tuple(3, 4, subpel_variance8x16_sse2), 738 make_tuple(4, 3, subpel_variance16x8_sse2), 739 make_tuple(4, 4, subpel_variance16x16_sse2), 740 make_tuple(4, 5, subpel_variance16x32_sse2), 741 make_tuple(5, 4, subpel_variance32x16_sse2), 742 make_tuple(5, 5, subpel_variance32x32_sse2), 743 make_tuple(5, 6, subpel_variance32x64_sse2), 744 make_tuple(6, 5, subpel_variance64x32_sse2), 745 make_tuple(6, 6, subpel_variance64x64_sse2))); 746 747 const vp9_subp_avg_variance_fn_t subpel_avg_variance4x4_sse = 748 vp9_sub_pixel_avg_variance4x4_sse; 749 const vp9_subp_avg_variance_fn_t subpel_avg_variance4x8_sse = 750 vp9_sub_pixel_avg_variance4x8_sse; 751 const vp9_subp_avg_variance_fn_t subpel_avg_variance8x4_sse2 = 752 vp9_sub_pixel_avg_variance8x4_sse2; 753 const vp9_subp_avg_variance_fn_t subpel_avg_variance8x8_sse2 = 754 vp9_sub_pixel_avg_variance8x8_sse2; 755 const vp9_subp_avg_variance_fn_t subpel_avg_variance8x16_sse2 = 756 vp9_sub_pixel_avg_variance8x16_sse2; 757 const vp9_subp_avg_variance_fn_t subpel_avg_variance16x8_sse2 = 758 vp9_sub_pixel_avg_variance16x8_sse2; 759 const vp9_subp_avg_variance_fn_t subpel_avg_variance16x16_sse2 = 760 vp9_sub_pixel_avg_variance16x16_sse2; 761 const vp9_subp_avg_variance_fn_t subpel_avg_variance16x32_sse2 = 762 vp9_sub_pixel_avg_variance16x32_sse2; 763 const vp9_subp_avg_variance_fn_t subpel_avg_variance32x16_sse2 = 764 vp9_sub_pixel_avg_variance32x16_sse2; 765 const vp9_subp_avg_variance_fn_t subpel_avg_variance32x32_sse2 = 766 vp9_sub_pixel_avg_variance32x32_sse2; 767 const vp9_subp_avg_variance_fn_t subpel_avg_variance32x64_sse2 = 768 vp9_sub_pixel_avg_variance32x64_sse2; 769 const vp9_subp_avg_variance_fn_t subpel_avg_variance64x32_sse2 = 770 vp9_sub_pixel_avg_variance64x32_sse2; 771 const vp9_subp_avg_variance_fn_t subpel_avg_variance64x64_sse2 = 772 vp9_sub_pixel_avg_variance64x64_sse2; 773 INSTANTIATE_TEST_CASE_P( 774 SSE2, VP9SubpelAvgVarianceTest, 775 ::testing::Values(make_tuple(2, 2, subpel_avg_variance4x4_sse), 776 make_tuple(2, 3, subpel_avg_variance4x8_sse), 777 make_tuple(3, 2, subpel_avg_variance8x4_sse2), 778 make_tuple(3, 3, subpel_avg_variance8x8_sse2), 779 make_tuple(3, 4, subpel_avg_variance8x16_sse2), 780 make_tuple(4, 3, subpel_avg_variance16x8_sse2), 781 make_tuple(4, 4, subpel_avg_variance16x16_sse2), 782 make_tuple(4, 5, subpel_avg_variance16x32_sse2), 783 make_tuple(5, 4, subpel_avg_variance32x16_sse2), 784 make_tuple(5, 5, subpel_avg_variance32x32_sse2), 785 make_tuple(5, 6, subpel_avg_variance32x64_sse2), 786 make_tuple(6, 5, subpel_avg_variance64x32_sse2), 787 make_tuple(6, 6, subpel_avg_variance64x64_sse2))); 788 #endif 789 #endif 790 791 #if HAVE_SSSE3 792 #if CONFIG_USE_X86INC 793 794 const vp9_subpixvariance_fn_t subpel_variance4x4_ssse3 = 795 vp9_sub_pixel_variance4x4_ssse3; 796 const vp9_subpixvariance_fn_t subpel_variance4x8_ssse3 = 797 vp9_sub_pixel_variance4x8_ssse3; 798 const vp9_subpixvariance_fn_t subpel_variance8x4_ssse3 = 799 vp9_sub_pixel_variance8x4_ssse3; 800 const vp9_subpixvariance_fn_t subpel_variance8x8_ssse3 = 801 vp9_sub_pixel_variance8x8_ssse3; 802 const vp9_subpixvariance_fn_t subpel_variance8x16_ssse3 = 803 vp9_sub_pixel_variance8x16_ssse3; 804 const vp9_subpixvariance_fn_t subpel_variance16x8_ssse3 = 805 vp9_sub_pixel_variance16x8_ssse3; 806 const vp9_subpixvariance_fn_t subpel_variance16x16_ssse3 = 807 vp9_sub_pixel_variance16x16_ssse3; 808 const vp9_subpixvariance_fn_t subpel_variance16x32_ssse3 = 809 vp9_sub_pixel_variance16x32_ssse3; 810 const vp9_subpixvariance_fn_t subpel_variance32x16_ssse3 = 811 vp9_sub_pixel_variance32x16_ssse3; 812 const vp9_subpixvariance_fn_t subpel_variance32x32_ssse3 = 813 vp9_sub_pixel_variance32x32_ssse3; 814 const vp9_subpixvariance_fn_t subpel_variance32x64_ssse3 = 815 vp9_sub_pixel_variance32x64_ssse3; 816 const vp9_subpixvariance_fn_t subpel_variance64x32_ssse3 = 817 vp9_sub_pixel_variance64x32_ssse3; 818 const vp9_subpixvariance_fn_t subpel_variance64x64_ssse3 = 819 vp9_sub_pixel_variance64x64_ssse3; 820 INSTANTIATE_TEST_CASE_P( 821 SSSE3, VP9SubpelVarianceTest, 822 ::testing::Values(make_tuple(2, 2, subpel_variance4x4_ssse3), 823 make_tuple(2, 3, subpel_variance4x8_ssse3), 824 make_tuple(3, 2, subpel_variance8x4_ssse3), 825 make_tuple(3, 3, subpel_variance8x8_ssse3), 826 make_tuple(3, 4, subpel_variance8x16_ssse3), 827 make_tuple(4, 3, subpel_variance16x8_ssse3), 828 make_tuple(4, 4, subpel_variance16x16_ssse3), 829 make_tuple(4, 5, subpel_variance16x32_ssse3), 830 make_tuple(5, 4, subpel_variance32x16_ssse3), 831 make_tuple(5, 5, subpel_variance32x32_ssse3), 832 make_tuple(5, 6, subpel_variance32x64_ssse3), 833 make_tuple(6, 5, subpel_variance64x32_ssse3), 834 make_tuple(6, 6, subpel_variance64x64_ssse3))); 835 836 const vp9_subp_avg_variance_fn_t subpel_avg_variance4x4_ssse3 = 837 vp9_sub_pixel_avg_variance4x4_ssse3; 838 const vp9_subp_avg_variance_fn_t subpel_avg_variance4x8_ssse3 = 839 vp9_sub_pixel_avg_variance4x8_ssse3; 840 const vp9_subp_avg_variance_fn_t subpel_avg_variance8x4_ssse3 = 841 vp9_sub_pixel_avg_variance8x4_ssse3; 842 const vp9_subp_avg_variance_fn_t subpel_avg_variance8x8_ssse3 = 843 vp9_sub_pixel_avg_variance8x8_ssse3; 844 const vp9_subp_avg_variance_fn_t subpel_avg_variance8x16_ssse3 = 845 vp9_sub_pixel_avg_variance8x16_ssse3; 846 const vp9_subp_avg_variance_fn_t subpel_avg_variance16x8_ssse3 = 847 vp9_sub_pixel_avg_variance16x8_ssse3; 848 const vp9_subp_avg_variance_fn_t subpel_avg_variance16x16_ssse3 = 849 vp9_sub_pixel_avg_variance16x16_ssse3; 850 const vp9_subp_avg_variance_fn_t subpel_avg_variance16x32_ssse3 = 851 vp9_sub_pixel_avg_variance16x32_ssse3; 852 const vp9_subp_avg_variance_fn_t subpel_avg_variance32x16_ssse3 = 853 vp9_sub_pixel_avg_variance32x16_ssse3; 854 const vp9_subp_avg_variance_fn_t subpel_avg_variance32x32_ssse3 = 855 vp9_sub_pixel_avg_variance32x32_ssse3; 856 const vp9_subp_avg_variance_fn_t subpel_avg_variance32x64_ssse3 = 857 vp9_sub_pixel_avg_variance32x64_ssse3; 858 const vp9_subp_avg_variance_fn_t subpel_avg_variance64x32_ssse3 = 859 vp9_sub_pixel_avg_variance64x32_ssse3; 860 const vp9_subp_avg_variance_fn_t subpel_avg_variance64x64_ssse3 = 861 vp9_sub_pixel_avg_variance64x64_ssse3; 862 INSTANTIATE_TEST_CASE_P( 863 SSSE3, VP9SubpelAvgVarianceTest, 864 ::testing::Values(make_tuple(2, 2, subpel_avg_variance4x4_ssse3), 865 make_tuple(2, 3, subpel_avg_variance4x8_ssse3), 866 make_tuple(3, 2, subpel_avg_variance8x4_ssse3), 867 make_tuple(3, 3, subpel_avg_variance8x8_ssse3), 868 make_tuple(3, 4, subpel_avg_variance8x16_ssse3), 869 make_tuple(4, 3, subpel_avg_variance16x8_ssse3), 870 make_tuple(4, 4, subpel_avg_variance16x16_ssse3), 871 make_tuple(4, 5, subpel_avg_variance16x32_ssse3), 872 make_tuple(5, 4, subpel_avg_variance32x16_ssse3), 873 make_tuple(5, 5, subpel_avg_variance32x32_ssse3), 874 make_tuple(5, 6, subpel_avg_variance32x64_ssse3), 875 make_tuple(6, 5, subpel_avg_variance64x32_ssse3), 876 make_tuple(6, 6, subpel_avg_variance64x64_ssse3))); 877 #endif 878 #endif 879 880 #if HAVE_AVX2 881 882 const vp9_variance_fn_t variance16x16_avx2 = vp9_variance16x16_avx2; 883 const vp9_variance_fn_t variance32x16_avx2 = vp9_variance32x16_avx2; 884 const vp9_variance_fn_t variance32x32_avx2 = vp9_variance32x32_avx2; 885 const vp9_variance_fn_t variance64x32_avx2 = vp9_variance64x32_avx2; 886 const vp9_variance_fn_t variance64x64_avx2 = vp9_variance64x64_avx2; 887 INSTANTIATE_TEST_CASE_P( 888 AVX2, VP9VarianceTest, 889 ::testing::Values(make_tuple(4, 4, variance16x16_avx2), 890 make_tuple(5, 4, variance32x16_avx2), 891 make_tuple(5, 5, variance32x32_avx2), 892 make_tuple(6, 5, variance64x32_avx2), 893 make_tuple(6, 6, variance64x64_avx2))); 894 895 const vp9_subpixvariance_fn_t subpel_variance32x32_avx2 = 896 vp9_sub_pixel_variance32x32_avx2; 897 const vp9_subpixvariance_fn_t subpel_variance64x64_avx2 = 898 vp9_sub_pixel_variance64x64_avx2; 899 INSTANTIATE_TEST_CASE_P( 900 AVX2, VP9SubpelVarianceTest, 901 ::testing::Values(make_tuple(5, 5, subpel_variance32x32_avx2), 902 make_tuple(6, 6, subpel_variance64x64_avx2))); 903 904 const vp9_subp_avg_variance_fn_t subpel_avg_variance32x32_avx2 = 905 vp9_sub_pixel_avg_variance32x32_avx2; 906 const vp9_subp_avg_variance_fn_t subpel_avg_variance64x64_avx2 = 907 vp9_sub_pixel_avg_variance64x64_avx2; 908 INSTANTIATE_TEST_CASE_P( 909 AVX2, VP9SubpelAvgVarianceTest, 910 ::testing::Values(make_tuple(5, 5, subpel_avg_variance32x32_avx2), 911 make_tuple(6, 6, subpel_avg_variance64x64_avx2))); 912 #endif // HAVE_AVX2 913 #if HAVE_NEON 914 const vp9_variance_fn_t variance8x8_neon = vp9_variance8x8_neon; 915 const vp9_variance_fn_t variance16x16_neon = vp9_variance16x16_neon; 916 const vp9_variance_fn_t variance32x32_neon = vp9_variance32x32_neon; 917 INSTANTIATE_TEST_CASE_P( 918 NEON, VP9VarianceTest, 919 ::testing::Values(make_tuple(3, 3, variance8x8_neon), 920 make_tuple(4, 4, variance16x16_neon), 921 make_tuple(5, 5, variance32x32_neon))); 922 923 const vp9_subpixvariance_fn_t subpel_variance8x8_neon = 924 vp9_sub_pixel_variance8x8_neon; 925 const vp9_subpixvariance_fn_t subpel_variance16x16_neon = 926 vp9_sub_pixel_variance16x16_neon; 927 const vp9_subpixvariance_fn_t subpel_variance32x32_neon = 928 vp9_sub_pixel_variance32x32_neon; 929 INSTANTIATE_TEST_CASE_P( 930 NEON, VP9SubpelVarianceTest, 931 ::testing::Values(make_tuple(3, 3, subpel_variance8x8_neon), 932 make_tuple(4, 4, subpel_variance16x16_neon), 933 make_tuple(5, 5, subpel_variance32x32_neon))); 934 #endif // HAVE_NEON 935 #endif // CONFIG_VP9_ENCODER 936 937 } // namespace vp9 938 939 } // namespace 940
