src/third_party/libvpx/source/libvpx/test/variance_test.cc

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