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 variance_ref(const uint8_t *ref, const uint8_t *src, 39 int l2w, int l2h, unsigned int *sse_ptr) { 40 int se = 0; 41 unsigned int sse = 0; 42 const int w = 1 << l2w, h = 1 << l2h; 43 for (int y = 0; y < h; y++) { 44 for (int x = 0; x < w; x++) { 45 int diff = ref[w * y + x] - src[w * y + x]; 46 se += diff; 47 sse += diff * diff; 48 } 49 } 50 *sse_ptr = sse; 51 return sse - (((int64_t) se * se) >> (l2w + l2h)); 52 } 53 54 static unsigned int subpel_variance_ref(const uint8_t *ref, const uint8_t *src, 55 int l2w, int l2h, int xoff, int yoff, 56 unsigned int *sse_ptr) { 57 int se = 0; 58 unsigned int sse = 0; 59 const int w = 1 << l2w, h = 1 << l2h; 60 for (int y = 0; y < h; y++) { 61 for (int x = 0; x < w; x++) { 62 // bilinear interpolation at a 16th pel step 63 const int a1 = ref[(w + 1) * (y + 0) + x + 0]; 64 const int a2 = ref[(w + 1) * (y + 0) + x + 1]; 65 const int b1 = ref[(w + 1) * (y + 1) + x + 0]; 66 const int b2 = ref[(w + 1) * (y + 1) + x + 1]; 67 const int a = a1 + (((a2 - a1) * xoff + 8) >> 4); 68 const int b = b1 + (((b2 - b1) * xoff + 8) >> 4); 69 const int r = a + (((b - a) * yoff + 8) >> 4); 70 int diff = r - src[w * y + x]; 71 se += diff; 72 sse += diff * diff; 73 } 74 } 75 *sse_ptr = sse; 76 return sse - (((int64_t) se * se) >> (l2w + l2h)); 77 } 78 79 template<typename VarianceFunctionType> 80 class VarianceTest 81 : public ::testing::TestWithParam<tuple<int, int, VarianceFunctionType> > { 82 public: 83 virtual void SetUp() { 84 const tuple<int, int, VarianceFunctionType>& params = this->GetParam(); 85 log2width_ = get<0>(params); 86 width_ = 1 << log2width_; 87 log2height_ = get<1>(params); 88 height_ = 1 << log2height_; 89 variance_ = get<2>(params); 90 91 rnd(ACMRandom::DeterministicSeed()); 92 block_size_ = width_ * height_; 93 src_ = new uint8_t[block_size_]; 94 ref_ = new uint8_t[block_size_]; 95 ASSERT_TRUE(src_ != NULL); 96 ASSERT_TRUE(ref_ != NULL); 97 } 98 99 virtual void TearDown() { 100 delete[] src_; 101 delete[] ref_; 102 libvpx_test::ClearSystemState(); 103 } 104 105 protected: 106 void ZeroTest(); 107 void RefTest(); 108 void OneQuarterTest(); 109 110 ACMRandom rnd; 111 uint8_t* src_; 112 uint8_t* ref_; 113 int width_, log2width_; 114 int height_, log2height_; 115 int block_size_; 116 VarianceFunctionType variance_; 117 }; 118 119 template<typename VarianceFunctionType> 120 void VarianceTest<VarianceFunctionType>::ZeroTest() { 121 for (int i = 0; i <= 255; ++i) { 122 memset(src_, i, block_size_); 123 for (int j = 0; j <= 255; ++j) { 124 memset(ref_, j, block_size_); 125 unsigned int sse; 126 unsigned int var; 127 REGISTER_STATE_CHECK(var = variance_(src_, width_, ref_, width_, &sse)); 128 EXPECT_EQ(0u, var) << "src values: " << i << "ref values: " << j; 129 } 130 } 131 } 132 133 template<typename VarianceFunctionType> 134 void VarianceTest<VarianceFunctionType>::RefTest() { 135 for (int i = 0; i < 10; ++i) { 136 for (int j = 0; j < block_size_; j++) { 137 src_[j] = rnd.Rand8(); 138 ref_[j] = rnd.Rand8(); 139 } 140 unsigned int sse1, sse2; 141 unsigned int var1; 142 REGISTER_STATE_CHECK(var1 = variance_(src_, width_, ref_, width_, &sse1)); 143 const unsigned int var2 = variance_ref(src_, ref_, log2width_, 144 log2height_, &sse2); 145 EXPECT_EQ(sse1, sse2); 146 EXPECT_EQ(var1, var2); 147 } 148 } 149 150 template<typename VarianceFunctionType> 151 void VarianceTest<VarianceFunctionType>::OneQuarterTest() { 152 memset(src_, 255, block_size_); 153 const int half = block_size_ / 2; 154 memset(ref_, 255, half); 155 memset(ref_ + half, 0, half); 156 unsigned int sse; 157 unsigned int var; 158 REGISTER_STATE_CHECK(var = variance_(src_, width_, ref_, width_, &sse)); 159 const unsigned int expected = block_size_ * 255 * 255 / 4; 160 EXPECT_EQ(expected, var); 161 } 162 163 #if CONFIG_VP9_ENCODER 164 165 unsigned int subpel_avg_variance_ref(const uint8_t *ref, 166 const uint8_t *src, 167 const uint8_t *second_pred, 168 int l2w, int l2h, 169 int xoff, int yoff, 170 unsigned int *sse_ptr) { 171 int se = 0; 172 unsigned int sse = 0; 173 const int w = 1 << l2w, h = 1 << l2h; 174 for (int y = 0; y < h; y++) { 175 for (int x = 0; x < w; x++) { 176 // bilinear interpolation at a 16th pel step 177 const int a1 = ref[(w + 1) * (y + 0) + x + 0]; 178 const int a2 = ref[(w + 1) * (y + 0) + x + 1]; 179 const int b1 = ref[(w + 1) * (y + 1) + x + 0]; 180 const int b2 = ref[(w + 1) * (y + 1) + x + 1]; 181 const int a = a1 + (((a2 - a1) * xoff + 8) >> 4); 182 const int b = b1 + (((b2 - b1) * xoff + 8) >> 4); 183 const int r = a + (((b - a) * yoff + 8) >> 4); 184 int diff = ((r + second_pred[w * y + x] + 1) >> 1) - src[w * y + x]; 185 se += diff; 186 sse += diff * diff; 187 } 188 } 189 *sse_ptr = sse; 190 return sse - (((int64_t) se * se) >> (l2w + l2h)); 191 } 192 193 template<typename SubpelVarianceFunctionType> 194 class SubpelVarianceTest 195 : public ::testing::TestWithParam<tuple<int, int, 196 SubpelVarianceFunctionType> > { 197 public: 198 virtual void SetUp() { 199 const tuple<int, int, SubpelVarianceFunctionType>& params = 200 this->GetParam(); 201 log2width_ = get<0>(params); 202 width_ = 1 << log2width_; 203 log2height_ = get<1>(params); 204 height_ = 1 << log2height_; 205 subpel_variance_ = get<2>(params); 206 207 rnd(ACMRandom::DeterministicSeed()); 208 block_size_ = width_ * height_; 209 src_ = reinterpret_cast<uint8_t *>(vpx_memalign(16, block_size_)); 210 sec_ = reinterpret_cast<uint8_t *>(vpx_memalign(16, block_size_)); 211 ref_ = new uint8_t[block_size_ + width_ + height_ + 1]; 212 ASSERT_TRUE(src_ != NULL); 213 ASSERT_TRUE(sec_ != NULL); 214 ASSERT_TRUE(ref_ != NULL); 215 } 216 217 virtual void TearDown() { 218 vpx_free(src_); 219 delete[] ref_; 220 vpx_free(sec_); 221 libvpx_test::ClearSystemState(); 222 } 223 224 protected: 225 void RefTest(); 226 227 ACMRandom rnd; 228 uint8_t *src_; 229 uint8_t *ref_; 230 uint8_t *sec_; 231 int width_, log2width_; 232 int height_, log2height_; 233 int block_size_; 234 SubpelVarianceFunctionType subpel_variance_; 235 }; 236 237 template<typename SubpelVarianceFunctionType> 238 void SubpelVarianceTest<SubpelVarianceFunctionType>::RefTest() { 239 for (int x = 0; x < 16; ++x) { 240 for (int y = 0; y < 16; ++y) { 241 for (int j = 0; j < block_size_; j++) { 242 src_[j] = rnd.Rand8(); 243 } 244 for (int j = 0; j < block_size_ + width_ + height_ + 1; j++) { 245 ref_[j] = rnd.Rand8(); 246 } 247 unsigned int sse1, sse2; 248 unsigned int var1; 249 REGISTER_STATE_CHECK(var1 = subpel_variance_(ref_, width_ + 1, x, y, 250 src_, width_, &sse1)); 251 const unsigned int var2 = subpel_variance_ref(ref_, src_, log2width_, 252 log2height_, x, y, &sse2); 253 EXPECT_EQ(sse1, sse2) << "at position " << x << ", " << y; 254 EXPECT_EQ(var1, var2) << "at position " << x << ", " << y; 255 } 256 } 257 } 258 259 template<> 260 void SubpelVarianceTest<vp9_subp_avg_variance_fn_t>::RefTest() { 261 for (int x = 0; x < 16; ++x) { 262 for (int y = 0; y < 16; ++y) { 263 for (int j = 0; j < block_size_; j++) { 264 src_[j] = rnd.Rand8(); 265 sec_[j] = rnd.Rand8(); 266 } 267 for (int j = 0; j < block_size_ + width_ + height_ + 1; j++) { 268 ref_[j] = rnd.Rand8(); 269 } 270 unsigned int sse1, sse2; 271 unsigned int var1; 272 REGISTER_STATE_CHECK(var1 = subpel_variance_(ref_, width_ + 1, x, y, 273 src_, width_, &sse1, sec_)); 274 const unsigned int var2 = subpel_avg_variance_ref(ref_, src_, sec_, 275 log2width_, log2height_, 276 x, y, &sse2); 277 EXPECT_EQ(sse1, sse2) << "at position " << x << ", " << y; 278 EXPECT_EQ(var1, var2) << "at position " << x << ", " << y; 279 } 280 } 281 } 282 283 #endif // CONFIG_VP9_ENCODER 284 285 // ----------------------------------------------------------------------------- 286 // VP8 test cases. 287 288 namespace vp8 { 289 290 #if CONFIG_VP8_ENCODER 291 typedef VarianceTest<vp8_variance_fn_t> VP8VarianceTest; 292 293 TEST_P(VP8VarianceTest, Zero) { ZeroTest(); } 294 TEST_P(VP8VarianceTest, Ref) { RefTest(); } 295 TEST_P(VP8VarianceTest, OneQuarter) { OneQuarterTest(); } 296 297 const vp8_variance_fn_t variance4x4_c = vp8_variance4x4_c; 298 const vp8_variance_fn_t variance8x8_c = vp8_variance8x8_c; 299 const vp8_variance_fn_t variance8x16_c = vp8_variance8x16_c; 300 const vp8_variance_fn_t variance16x8_c = vp8_variance16x8_c; 301 const vp8_variance_fn_t variance16x16_c = vp8_variance16x16_c; 302 INSTANTIATE_TEST_CASE_P( 303 C, VP8VarianceTest, 304 ::testing::Values(make_tuple(2, 2, variance4x4_c), 305 make_tuple(3, 3, variance8x8_c), 306 make_tuple(3, 4, variance8x16_c), 307 make_tuple(4, 3, variance16x8_c), 308 make_tuple(4, 4, variance16x16_c))); 309 310 #if HAVE_NEON 311 const vp8_variance_fn_t variance8x8_neon = vp8_variance8x8_neon; 312 const vp8_variance_fn_t variance8x16_neon = vp8_variance8x16_neon; 313 const vp8_variance_fn_t variance16x8_neon = vp8_variance16x8_neon; 314 const vp8_variance_fn_t variance16x16_neon = vp8_variance16x16_neon; 315 INSTANTIATE_TEST_CASE_P( 316 NEON, VP8VarianceTest, 317 ::testing::Values(make_tuple(3, 3, variance8x8_neon), 318 make_tuple(3, 4, variance8x16_neon), 319 make_tuple(4, 3, variance16x8_neon), 320 make_tuple(4, 4, variance16x16_neon))); 321 #endif 322 323 #if HAVE_MMX 324 const vp8_variance_fn_t variance4x4_mmx = vp8_variance4x4_mmx; 325 const vp8_variance_fn_t variance8x8_mmx = vp8_variance8x8_mmx; 326 const vp8_variance_fn_t variance8x16_mmx = vp8_variance8x16_mmx; 327 const vp8_variance_fn_t variance16x8_mmx = vp8_variance16x8_mmx; 328 const vp8_variance_fn_t variance16x16_mmx = vp8_variance16x16_mmx; 329 INSTANTIATE_TEST_CASE_P( 330 MMX, VP8VarianceTest, 331 ::testing::Values(make_tuple(2, 2, variance4x4_mmx), 332 make_tuple(3, 3, variance8x8_mmx), 333 make_tuple(3, 4, variance8x16_mmx), 334 make_tuple(4, 3, variance16x8_mmx), 335 make_tuple(4, 4, variance16x16_mmx))); 336 #endif 337 338 #if HAVE_SSE2 339 const vp8_variance_fn_t variance4x4_wmt = vp8_variance4x4_wmt; 340 const vp8_variance_fn_t variance8x8_wmt = vp8_variance8x8_wmt; 341 const vp8_variance_fn_t variance8x16_wmt = vp8_variance8x16_wmt; 342 const vp8_variance_fn_t variance16x8_wmt = vp8_variance16x8_wmt; 343 const vp8_variance_fn_t variance16x16_wmt = vp8_variance16x16_wmt; 344 INSTANTIATE_TEST_CASE_P( 345 SSE2, VP8VarianceTest, 346 ::testing::Values(make_tuple(2, 2, variance4x4_wmt), 347 make_tuple(3, 3, variance8x8_wmt), 348 make_tuple(3, 4, variance8x16_wmt), 349 make_tuple(4, 3, variance16x8_wmt), 350 make_tuple(4, 4, variance16x16_wmt))); 351 #endif 352 #endif // CONFIG_VP8_ENCODER 353 354 } // namespace vp8 355 356 // ----------------------------------------------------------------------------- 357 // VP9 test cases. 358 359 namespace vp9 { 360 361 #if CONFIG_VP9_ENCODER 362 typedef VarianceTest<vp9_variance_fn_t> VP9VarianceTest; 363 typedef SubpelVarianceTest<vp9_subpixvariance_fn_t> VP9SubpelVarianceTest; 364 typedef SubpelVarianceTest<vp9_subp_avg_variance_fn_t> VP9SubpelAvgVarianceTest; 365 366 TEST_P(VP9VarianceTest, Zero) { ZeroTest(); } 367 TEST_P(VP9VarianceTest, Ref) { RefTest(); } 368 TEST_P(VP9SubpelVarianceTest, Ref) { RefTest(); } 369 TEST_P(VP9SubpelAvgVarianceTest, Ref) { RefTest(); } 370 TEST_P(VP9VarianceTest, OneQuarter) { OneQuarterTest(); } 371 372 const vp9_variance_fn_t variance4x4_c = vp9_variance4x4_c; 373 const vp9_variance_fn_t variance4x8_c = vp9_variance4x8_c; 374 const vp9_variance_fn_t variance8x4_c = vp9_variance8x4_c; 375 const vp9_variance_fn_t variance8x8_c = vp9_variance8x8_c; 376 const vp9_variance_fn_t variance8x16_c = vp9_variance8x16_c; 377 const vp9_variance_fn_t variance16x8_c = vp9_variance16x8_c; 378 const vp9_variance_fn_t variance16x16_c = vp9_variance16x16_c; 379 const vp9_variance_fn_t variance16x32_c = vp9_variance16x32_c; 380 const vp9_variance_fn_t variance32x16_c = vp9_variance32x16_c; 381 const vp9_variance_fn_t variance32x32_c = vp9_variance32x32_c; 382 const vp9_variance_fn_t variance32x64_c = vp9_variance32x64_c; 383 const vp9_variance_fn_t variance64x32_c = vp9_variance64x32_c; 384 const vp9_variance_fn_t variance64x64_c = vp9_variance64x64_c; 385 INSTANTIATE_TEST_CASE_P( 386 C, VP9VarianceTest, 387 ::testing::Values(make_tuple(2, 2, variance4x4_c), 388 make_tuple(2, 3, variance4x8_c), 389 make_tuple(3, 2, variance8x4_c), 390 make_tuple(3, 3, variance8x8_c), 391 make_tuple(3, 4, variance8x16_c), 392 make_tuple(4, 3, variance16x8_c), 393 make_tuple(4, 4, variance16x16_c), 394 make_tuple(4, 5, variance16x32_c), 395 make_tuple(5, 4, variance32x16_c), 396 make_tuple(5, 5, variance32x32_c), 397 make_tuple(5, 6, variance32x64_c), 398 make_tuple(6, 5, variance64x32_c), 399 make_tuple(6, 6, variance64x64_c))); 400 401 const vp9_subpixvariance_fn_t subpel_variance4x4_c = 402 vp9_sub_pixel_variance4x4_c; 403 const vp9_subpixvariance_fn_t subpel_variance4x8_c = 404 vp9_sub_pixel_variance4x8_c; 405 const vp9_subpixvariance_fn_t subpel_variance8x4_c = 406 vp9_sub_pixel_variance8x4_c; 407 const vp9_subpixvariance_fn_t subpel_variance8x8_c = 408 vp9_sub_pixel_variance8x8_c; 409 const vp9_subpixvariance_fn_t subpel_variance8x16_c = 410 vp9_sub_pixel_variance8x16_c; 411 const vp9_subpixvariance_fn_t subpel_variance16x8_c = 412 vp9_sub_pixel_variance16x8_c; 413 const vp9_subpixvariance_fn_t subpel_variance16x16_c = 414 vp9_sub_pixel_variance16x16_c; 415 const vp9_subpixvariance_fn_t subpel_variance16x32_c = 416 vp9_sub_pixel_variance16x32_c; 417 const vp9_subpixvariance_fn_t subpel_variance32x16_c = 418 vp9_sub_pixel_variance32x16_c; 419 const vp9_subpixvariance_fn_t subpel_variance32x32_c = 420 vp9_sub_pixel_variance32x32_c; 421 const vp9_subpixvariance_fn_t subpel_variance32x64_c = 422 vp9_sub_pixel_variance32x64_c; 423 const vp9_subpixvariance_fn_t subpel_variance64x32_c = 424 vp9_sub_pixel_variance64x32_c; 425 const vp9_subpixvariance_fn_t subpel_variance64x64_c = 426 vp9_sub_pixel_variance64x64_c; 427 INSTANTIATE_TEST_CASE_P( 428 C, VP9SubpelVarianceTest, 429 ::testing::Values(make_tuple(2, 2, subpel_variance4x4_c), 430 make_tuple(2, 3, subpel_variance4x8_c), 431 make_tuple(3, 2, subpel_variance8x4_c), 432 make_tuple(3, 3, subpel_variance8x8_c), 433 make_tuple(3, 4, subpel_variance8x16_c), 434 make_tuple(4, 3, subpel_variance16x8_c), 435 make_tuple(4, 4, subpel_variance16x16_c), 436 make_tuple(4, 5, subpel_variance16x32_c), 437 make_tuple(5, 4, subpel_variance32x16_c), 438 make_tuple(5, 5, subpel_variance32x32_c), 439 make_tuple(5, 6, subpel_variance32x64_c), 440 make_tuple(6, 5, subpel_variance64x32_c), 441 make_tuple(6, 6, subpel_variance64x64_c))); 442 443 const vp9_subp_avg_variance_fn_t subpel_avg_variance4x4_c = 444 vp9_sub_pixel_avg_variance4x4_c; 445 const vp9_subp_avg_variance_fn_t subpel_avg_variance4x8_c = 446 vp9_sub_pixel_avg_variance4x8_c; 447 const vp9_subp_avg_variance_fn_t subpel_avg_variance8x4_c = 448 vp9_sub_pixel_avg_variance8x4_c; 449 const vp9_subp_avg_variance_fn_t subpel_avg_variance8x8_c = 450 vp9_sub_pixel_avg_variance8x8_c; 451 const vp9_subp_avg_variance_fn_t subpel_avg_variance8x16_c = 452 vp9_sub_pixel_avg_variance8x16_c; 453 const vp9_subp_avg_variance_fn_t subpel_avg_variance16x8_c = 454 vp9_sub_pixel_avg_variance16x8_c; 455 const vp9_subp_avg_variance_fn_t subpel_avg_variance16x16_c = 456 vp9_sub_pixel_avg_variance16x16_c; 457 const vp9_subp_avg_variance_fn_t subpel_avg_variance16x32_c = 458 vp9_sub_pixel_avg_variance16x32_c; 459 const vp9_subp_avg_variance_fn_t subpel_avg_variance32x16_c = 460 vp9_sub_pixel_avg_variance32x16_c; 461 const vp9_subp_avg_variance_fn_t subpel_avg_variance32x32_c = 462 vp9_sub_pixel_avg_variance32x32_c; 463 const vp9_subp_avg_variance_fn_t subpel_avg_variance32x64_c = 464 vp9_sub_pixel_avg_variance32x64_c; 465 const vp9_subp_avg_variance_fn_t subpel_avg_variance64x32_c = 466 vp9_sub_pixel_avg_variance64x32_c; 467 const vp9_subp_avg_variance_fn_t subpel_avg_variance64x64_c = 468 vp9_sub_pixel_avg_variance64x64_c; 469 INSTANTIATE_TEST_CASE_P( 470 C, VP9SubpelAvgVarianceTest, 471 ::testing::Values(make_tuple(2, 2, subpel_avg_variance4x4_c), 472 make_tuple(2, 3, subpel_avg_variance4x8_c), 473 make_tuple(3, 2, subpel_avg_variance8x4_c), 474 make_tuple(3, 3, subpel_avg_variance8x8_c), 475 make_tuple(3, 4, subpel_avg_variance8x16_c), 476 make_tuple(4, 3, subpel_avg_variance16x8_c), 477 make_tuple(4, 4, subpel_avg_variance16x16_c), 478 make_tuple(4, 5, subpel_avg_variance16x32_c), 479 make_tuple(5, 4, subpel_avg_variance32x16_c), 480 make_tuple(5, 5, subpel_avg_variance32x32_c), 481 make_tuple(5, 6, subpel_avg_variance32x64_c), 482 make_tuple(6, 5, subpel_avg_variance64x32_c), 483 make_tuple(6, 6, subpel_avg_variance64x64_c))); 484 485 #if HAVE_MMX 486 const vp9_variance_fn_t variance4x4_mmx = vp9_variance4x4_mmx; 487 const vp9_variance_fn_t variance8x8_mmx = vp9_variance8x8_mmx; 488 const vp9_variance_fn_t variance8x16_mmx = vp9_variance8x16_mmx; 489 const vp9_variance_fn_t variance16x8_mmx = vp9_variance16x8_mmx; 490 const vp9_variance_fn_t variance16x16_mmx = vp9_variance16x16_mmx; 491 INSTANTIATE_TEST_CASE_P( 492 MMX, VP9VarianceTest, 493 ::testing::Values(make_tuple(2, 2, variance4x4_mmx), 494 make_tuple(3, 3, variance8x8_mmx), 495 make_tuple(3, 4, variance8x16_mmx), 496 make_tuple(4, 3, variance16x8_mmx), 497 make_tuple(4, 4, variance16x16_mmx))); 498 #endif 499 500 #if HAVE_SSE2 501 #if CONFIG_USE_X86INC 502 const vp9_variance_fn_t variance4x4_sse2 = vp9_variance4x4_sse2; 503 const vp9_variance_fn_t variance4x8_sse2 = vp9_variance4x8_sse2; 504 const vp9_variance_fn_t variance8x4_sse2 = vp9_variance8x4_sse2; 505 const vp9_variance_fn_t variance8x8_sse2 = vp9_variance8x8_sse2; 506 const vp9_variance_fn_t variance8x16_sse2 = vp9_variance8x16_sse2; 507 const vp9_variance_fn_t variance16x8_sse2 = vp9_variance16x8_sse2; 508 const vp9_variance_fn_t variance16x16_sse2 = vp9_variance16x16_sse2; 509 const vp9_variance_fn_t variance16x32_sse2 = vp9_variance16x32_sse2; 510 const vp9_variance_fn_t variance32x16_sse2 = vp9_variance32x16_sse2; 511 const vp9_variance_fn_t variance32x32_sse2 = vp9_variance32x32_sse2; 512 const vp9_variance_fn_t variance32x64_sse2 = vp9_variance32x64_sse2; 513 const vp9_variance_fn_t variance64x32_sse2 = vp9_variance64x32_sse2; 514 const vp9_variance_fn_t variance64x64_sse2 = vp9_variance64x64_sse2; 515 INSTANTIATE_TEST_CASE_P( 516 SSE2, VP9VarianceTest, 517 ::testing::Values(make_tuple(2, 2, variance4x4_sse2), 518 make_tuple(2, 3, variance4x8_sse2), 519 make_tuple(3, 2, variance8x4_sse2), 520 make_tuple(3, 3, variance8x8_sse2), 521 make_tuple(3, 4, variance8x16_sse2), 522 make_tuple(4, 3, variance16x8_sse2), 523 make_tuple(4, 4, variance16x16_sse2), 524 make_tuple(4, 5, variance16x32_sse2), 525 make_tuple(5, 4, variance32x16_sse2), 526 make_tuple(5, 5, variance32x32_sse2), 527 make_tuple(5, 6, variance32x64_sse2), 528 make_tuple(6, 5, variance64x32_sse2), 529 make_tuple(6, 6, variance64x64_sse2))); 530 531 const vp9_subpixvariance_fn_t subpel_variance4x4_sse = 532 vp9_sub_pixel_variance4x4_sse; 533 const vp9_subpixvariance_fn_t subpel_variance4x8_sse = 534 vp9_sub_pixel_variance4x8_sse; 535 const vp9_subpixvariance_fn_t subpel_variance8x4_sse2 = 536 vp9_sub_pixel_variance8x4_sse2; 537 const vp9_subpixvariance_fn_t subpel_variance8x8_sse2 = 538 vp9_sub_pixel_variance8x8_sse2; 539 const vp9_subpixvariance_fn_t subpel_variance8x16_sse2 = 540 vp9_sub_pixel_variance8x16_sse2; 541 const vp9_subpixvariance_fn_t subpel_variance16x8_sse2 = 542 vp9_sub_pixel_variance16x8_sse2; 543 const vp9_subpixvariance_fn_t subpel_variance16x16_sse2 = 544 vp9_sub_pixel_variance16x16_sse2; 545 const vp9_subpixvariance_fn_t subpel_variance16x32_sse2 = 546 vp9_sub_pixel_variance16x32_sse2; 547 const vp9_subpixvariance_fn_t subpel_variance32x16_sse2 = 548 vp9_sub_pixel_variance32x16_sse2; 549 const vp9_subpixvariance_fn_t subpel_variance32x32_sse2 = 550 vp9_sub_pixel_variance32x32_sse2; 551 const vp9_subpixvariance_fn_t subpel_variance32x64_sse2 = 552 vp9_sub_pixel_variance32x64_sse2; 553 const vp9_subpixvariance_fn_t subpel_variance64x32_sse2 = 554 vp9_sub_pixel_variance64x32_sse2; 555 const vp9_subpixvariance_fn_t subpel_variance64x64_sse2 = 556 vp9_sub_pixel_variance64x64_sse2; 557 INSTANTIATE_TEST_CASE_P( 558 SSE2, VP9SubpelVarianceTest, 559 ::testing::Values(make_tuple(2, 2, subpel_variance4x4_sse), 560 make_tuple(2, 3, subpel_variance4x8_sse), 561 make_tuple(3, 2, subpel_variance8x4_sse2), 562 make_tuple(3, 3, subpel_variance8x8_sse2), 563 make_tuple(3, 4, subpel_variance8x16_sse2), 564 make_tuple(4, 3, subpel_variance16x8_sse2), 565 make_tuple(4, 4, subpel_variance16x16_sse2), 566 make_tuple(4, 5, subpel_variance16x32_sse2), 567 make_tuple(5, 4, subpel_variance32x16_sse2), 568 make_tuple(5, 5, subpel_variance32x32_sse2), 569 make_tuple(5, 6, subpel_variance32x64_sse2), 570 make_tuple(6, 5, subpel_variance64x32_sse2), 571 make_tuple(6, 6, subpel_variance64x64_sse2))); 572 573 const vp9_subp_avg_variance_fn_t subpel_avg_variance4x4_sse = 574 vp9_sub_pixel_avg_variance4x4_sse; 575 const vp9_subp_avg_variance_fn_t subpel_avg_variance4x8_sse = 576 vp9_sub_pixel_avg_variance4x8_sse; 577 const vp9_subp_avg_variance_fn_t subpel_avg_variance8x4_sse2 = 578 vp9_sub_pixel_avg_variance8x4_sse2; 579 const vp9_subp_avg_variance_fn_t subpel_avg_variance8x8_sse2 = 580 vp9_sub_pixel_avg_variance8x8_sse2; 581 const vp9_subp_avg_variance_fn_t subpel_avg_variance8x16_sse2 = 582 vp9_sub_pixel_avg_variance8x16_sse2; 583 const vp9_subp_avg_variance_fn_t subpel_avg_variance16x8_sse2 = 584 vp9_sub_pixel_avg_variance16x8_sse2; 585 const vp9_subp_avg_variance_fn_t subpel_avg_variance16x16_sse2 = 586 vp9_sub_pixel_avg_variance16x16_sse2; 587 const vp9_subp_avg_variance_fn_t subpel_avg_variance16x32_sse2 = 588 vp9_sub_pixel_avg_variance16x32_sse2; 589 const vp9_subp_avg_variance_fn_t subpel_avg_variance32x16_sse2 = 590 vp9_sub_pixel_avg_variance32x16_sse2; 591 const vp9_subp_avg_variance_fn_t subpel_avg_variance32x32_sse2 = 592 vp9_sub_pixel_avg_variance32x32_sse2; 593 const vp9_subp_avg_variance_fn_t subpel_avg_variance32x64_sse2 = 594 vp9_sub_pixel_avg_variance32x64_sse2; 595 const vp9_subp_avg_variance_fn_t subpel_avg_variance64x32_sse2 = 596 vp9_sub_pixel_avg_variance64x32_sse2; 597 const vp9_subp_avg_variance_fn_t subpel_avg_variance64x64_sse2 = 598 vp9_sub_pixel_avg_variance64x64_sse2; 599 INSTANTIATE_TEST_CASE_P( 600 SSE2, VP9SubpelAvgVarianceTest, 601 ::testing::Values(make_tuple(2, 2, subpel_avg_variance4x4_sse), 602 make_tuple(2, 3, subpel_avg_variance4x8_sse), 603 make_tuple(3, 2, subpel_avg_variance8x4_sse2), 604 make_tuple(3, 3, subpel_avg_variance8x8_sse2), 605 make_tuple(3, 4, subpel_avg_variance8x16_sse2), 606 make_tuple(4, 3, subpel_avg_variance16x8_sse2), 607 make_tuple(4, 4, subpel_avg_variance16x16_sse2), 608 make_tuple(4, 5, subpel_avg_variance16x32_sse2), 609 make_tuple(5, 4, subpel_avg_variance32x16_sse2), 610 make_tuple(5, 5, subpel_avg_variance32x32_sse2), 611 make_tuple(5, 6, subpel_avg_variance32x64_sse2), 612 make_tuple(6, 5, subpel_avg_variance64x32_sse2), 613 make_tuple(6, 6, subpel_avg_variance64x64_sse2))); 614 #endif 615 #endif 616 617 #if HAVE_SSSE3 618 #if CONFIG_USE_X86INC 619 620 const vp9_subpixvariance_fn_t subpel_variance4x4_ssse3 = 621 vp9_sub_pixel_variance4x4_ssse3; 622 const vp9_subpixvariance_fn_t subpel_variance4x8_ssse3 = 623 vp9_sub_pixel_variance4x8_ssse3; 624 const vp9_subpixvariance_fn_t subpel_variance8x4_ssse3 = 625 vp9_sub_pixel_variance8x4_ssse3; 626 const vp9_subpixvariance_fn_t subpel_variance8x8_ssse3 = 627 vp9_sub_pixel_variance8x8_ssse3; 628 const vp9_subpixvariance_fn_t subpel_variance8x16_ssse3 = 629 vp9_sub_pixel_variance8x16_ssse3; 630 const vp9_subpixvariance_fn_t subpel_variance16x8_ssse3 = 631 vp9_sub_pixel_variance16x8_ssse3; 632 const vp9_subpixvariance_fn_t subpel_variance16x16_ssse3 = 633 vp9_sub_pixel_variance16x16_ssse3; 634 const vp9_subpixvariance_fn_t subpel_variance16x32_ssse3 = 635 vp9_sub_pixel_variance16x32_ssse3; 636 const vp9_subpixvariance_fn_t subpel_variance32x16_ssse3 = 637 vp9_sub_pixel_variance32x16_ssse3; 638 const vp9_subpixvariance_fn_t subpel_variance32x32_ssse3 = 639 vp9_sub_pixel_variance32x32_ssse3; 640 const vp9_subpixvariance_fn_t subpel_variance32x64_ssse3 = 641 vp9_sub_pixel_variance32x64_ssse3; 642 const vp9_subpixvariance_fn_t subpel_variance64x32_ssse3 = 643 vp9_sub_pixel_variance64x32_ssse3; 644 const vp9_subpixvariance_fn_t subpel_variance64x64_ssse3 = 645 vp9_sub_pixel_variance64x64_ssse3; 646 INSTANTIATE_TEST_CASE_P( 647 SSSE3, VP9SubpelVarianceTest, 648 ::testing::Values(make_tuple(2, 2, subpel_variance4x4_ssse3), 649 make_tuple(2, 3, subpel_variance4x8_ssse3), 650 make_tuple(3, 2, subpel_variance8x4_ssse3), 651 make_tuple(3, 3, subpel_variance8x8_ssse3), 652 make_tuple(3, 4, subpel_variance8x16_ssse3), 653 make_tuple(4, 3, subpel_variance16x8_ssse3), 654 make_tuple(4, 4, subpel_variance16x16_ssse3), 655 make_tuple(4, 5, subpel_variance16x32_ssse3), 656 make_tuple(5, 4, subpel_variance32x16_ssse3), 657 make_tuple(5, 5, subpel_variance32x32_ssse3), 658 make_tuple(5, 6, subpel_variance32x64_ssse3), 659 make_tuple(6, 5, subpel_variance64x32_ssse3), 660 make_tuple(6, 6, subpel_variance64x64_ssse3))); 661 662 const vp9_subp_avg_variance_fn_t subpel_avg_variance4x4_ssse3 = 663 vp9_sub_pixel_avg_variance4x4_ssse3; 664 const vp9_subp_avg_variance_fn_t subpel_avg_variance4x8_ssse3 = 665 vp9_sub_pixel_avg_variance4x8_ssse3; 666 const vp9_subp_avg_variance_fn_t subpel_avg_variance8x4_ssse3 = 667 vp9_sub_pixel_avg_variance8x4_ssse3; 668 const vp9_subp_avg_variance_fn_t subpel_avg_variance8x8_ssse3 = 669 vp9_sub_pixel_avg_variance8x8_ssse3; 670 const vp9_subp_avg_variance_fn_t subpel_avg_variance8x16_ssse3 = 671 vp9_sub_pixel_avg_variance8x16_ssse3; 672 const vp9_subp_avg_variance_fn_t subpel_avg_variance16x8_ssse3 = 673 vp9_sub_pixel_avg_variance16x8_ssse3; 674 const vp9_subp_avg_variance_fn_t subpel_avg_variance16x16_ssse3 = 675 vp9_sub_pixel_avg_variance16x16_ssse3; 676 const vp9_subp_avg_variance_fn_t subpel_avg_variance16x32_ssse3 = 677 vp9_sub_pixel_avg_variance16x32_ssse3; 678 const vp9_subp_avg_variance_fn_t subpel_avg_variance32x16_ssse3 = 679 vp9_sub_pixel_avg_variance32x16_ssse3; 680 const vp9_subp_avg_variance_fn_t subpel_avg_variance32x32_ssse3 = 681 vp9_sub_pixel_avg_variance32x32_ssse3; 682 const vp9_subp_avg_variance_fn_t subpel_avg_variance32x64_ssse3 = 683 vp9_sub_pixel_avg_variance32x64_ssse3; 684 const vp9_subp_avg_variance_fn_t subpel_avg_variance64x32_ssse3 = 685 vp9_sub_pixel_avg_variance64x32_ssse3; 686 const vp9_subp_avg_variance_fn_t subpel_avg_variance64x64_ssse3 = 687 vp9_sub_pixel_avg_variance64x64_ssse3; 688 INSTANTIATE_TEST_CASE_P( 689 SSSE3, VP9SubpelAvgVarianceTest, 690 ::testing::Values(make_tuple(2, 2, subpel_avg_variance4x4_ssse3), 691 make_tuple(2, 3, subpel_avg_variance4x8_ssse3), 692 make_tuple(3, 2, subpel_avg_variance8x4_ssse3), 693 make_tuple(3, 3, subpel_avg_variance8x8_ssse3), 694 make_tuple(3, 4, subpel_avg_variance8x16_ssse3), 695 make_tuple(4, 3, subpel_avg_variance16x8_ssse3), 696 make_tuple(4, 4, subpel_avg_variance16x16_ssse3), 697 make_tuple(4, 5, subpel_avg_variance16x32_ssse3), 698 make_tuple(5, 4, subpel_avg_variance32x16_ssse3), 699 make_tuple(5, 5, subpel_avg_variance32x32_ssse3), 700 make_tuple(5, 6, subpel_avg_variance32x64_ssse3), 701 make_tuple(6, 5, subpel_avg_variance64x32_ssse3), 702 make_tuple(6, 6, subpel_avg_variance64x64_ssse3))); 703 #endif 704 #endif 705 #endif // CONFIG_VP9_ENCODER 706 707 } // namespace vp9 708 709 } // namespace 710
