test/lpf_test.cc

   1 /*
   2  *  Copyright (c) 2014 The WebM project authors. All Rights Reserved.
   3  *
   4  *  Use of this source code is governed by a BSD-style license
   5  *  that can be found in the LICENSE file in the root of the source
   6  *  tree. An additional intellectual property rights grant can be found
   7  *  in the file PATENTS.  All contributing project authors may
   8  *  be found in the AUTHORS file in the root of the source tree.
   9  */
  10
  11 #include <cmath>
  12 #include <cstdlib>
  13 #include <string>
  14 #include <tuple>
  15
  16 #include "third_party/googletest/src/include/gtest/gtest.h"
  17
  18 #include "./vpx_config.h"
  19 #include "./vpx_dsp_rtcd.h"
  20 #include "test/acm_random.h"
  21 #include "test/clear_system_state.h"
  22 #include "test/register_state_check.h"
  23 #include "test/util.h"
  24 #include "vp9/common/vp9_entropy.h"
  25 #include "vp9/common/vp9_loopfilter.h"
  26 #include "vpx/vpx_integer.h"
  27
  28 using libvpx_test::ACMRandom;
  29
  30 namespace {
  31 // Horizontally and Vertically need 32x32: 8  Coeffs preceeding filtered section
  32 //                                         16 Coefs within filtered section
  33 //                                         8  Coeffs following filtered section
  34 const int kNumCoeffs = 1024;
  35
  36 const int number_of_iterations = 10000;
  37
  38 #if CONFIG_VP9_HIGHBITDEPTH
  39 typedef uint16_t Pixel;
  40 #define PIXEL_WIDTH 16
  41
  42 typedef void (*loop_op_t)(Pixel *s, int p, const uint8_t *blimit,
  43                           const uint8_t *limit, const uint8_t *thresh, int bd);
  44 typedef void (*dual_loop_op_t)(Pixel *s, int p, const uint8_t *blimit0,
  45                                const uint8_t *limit0, const uint8_t *thresh0,
  46                                const uint8_t *blimit1, const uint8_t *limit1,
  47                                const uint8_t *thresh1, int bd);
  48 #else
  49 typedef uint8_t Pixel;
  50 #define PIXEL_WIDTH 8
  51
  52 typedef void (*loop_op_t)(Pixel *s, int p, const uint8_t *blimit,
  53                           const uint8_t *limit, const uint8_t *thresh);
  54 typedef void (*dual_loop_op_t)(Pixel *s, int p, const uint8_t *blimit0,
  55                                const uint8_t *limit0, const uint8_t *thresh0,
  56                                const uint8_t *blimit1, const uint8_t *limit1,
  57                                const uint8_t *thresh1);
  58 #endif  // CONFIG_VP9_HIGHBITDEPTH
  59
  60 typedef std::tuple<loop_op_t, loop_op_t, int> loop8_param_t;
  61 typedef std::tuple<dual_loop_op_t, dual_loop_op_t, int> dualloop8_param_t;
  62
  63 void InitInput(Pixel *s, Pixel *ref_s, ACMRandom *rnd, const uint8_t limit,
  64                const int mask, const int32_t p, const int i) {
  65   uint16_t tmp_s[kNumCoeffs];
  66
  67   for (int j = 0; j < kNumCoeffs;) {
  68     const uint8_t val = rnd->Rand8();
  69     if (val & 0x80) {  // 50% chance to choose a new value.
  70       tmp_s[j] = rnd->Rand16();
  71       j++;
  72     } else {  // 50% chance to repeat previous value in row X times.
  73       int k = 0;
  74       while (k++ < ((val & 0x1f) + 1) && j < kNumCoeffs) {
  75         if (j < 1) {
  76           tmp_s[j] = rnd->Rand16();
  77         } else if (val & 0x20) {  // Increment by a value within the limit.
  78           tmp_s[j] = static_cast<uint16_t>(tmp_s[j - 1] + (limit - 1));
  79         } else {  // Decrement by a value within the limit.
  80           tmp_s[j] = static_cast<uint16_t>(tmp_s[j - 1] - (limit - 1));
  81         }
  82         j++;
  83       }
  84     }
  85   }
  86
  87   for (int j = 0; j < kNumCoeffs;) {
  88     const uint8_t val = rnd->Rand8();
  89     if (val & 0x80) {
  90       j++;
  91     } else {  // 50% chance to repeat previous value in column X times.
  92       int k = 0;
  93       while (k++ < ((val & 0x1f) + 1) && j < kNumCoeffs) {
  94         if (j < 1) {
  95           tmp_s[j] = rnd->Rand16();
  96         } else if (val & 0x20) {  // Increment by a value within the limit.
  97           tmp_s[(j % 32) * 32 + j / 32] = static_cast<uint16_t>(
  98               tmp_s[((j - 1) % 32) * 32 + (j - 1) / 32] + (limit - 1));
  99         } else {  // Decrement by a value within the limit.
 100           tmp_s[(j % 32) * 32 + j / 32] = static_cast<uint16_t>(
 101               tmp_s[((j - 1) % 32) * 32 + (j - 1) / 32] - (limit - 1));
 102         }
 103         j++;
 104       }
 105     }
 106   }
 107
 108   for (int j = 0; j < kNumCoeffs; j++) {
 109     if (i % 2) {
 110       s[j] = tmp_s[j] & mask;
 111     } else {
 112       s[j] = tmp_s[p * (j % p) + j / p] & mask;
 113     }
 114     ref_s[j] = s[j];
 115   }
 116 }
 117
 118 uint8_t GetOuterThresh(ACMRandom *rnd) {
 119   return static_cast<uint8_t>(rnd->RandRange(3 * MAX_LOOP_FILTER + 5));
 120 }
 121
 122 uint8_t GetInnerThresh(ACMRandom *rnd) {
 123   return static_cast<uint8_t>(rnd->RandRange(MAX_LOOP_FILTER + 1));
 124 }
 125
 126 uint8_t GetHevThresh(ACMRandom *rnd) {
 127   return static_cast<uint8_t>(rnd->RandRange(MAX_LOOP_FILTER + 1) >> 4);
 128 }
 129
 130 class Loop8Test6Param : public ::testing::TestWithParam<loop8_param_t> {
 131  public:
 132   virtual ~Loop8Test6Param() {}
 133   virtual void SetUp() {
 134     loopfilter_op_ = GET_PARAM(0);
 135     ref_loopfilter_op_ = GET_PARAM(1);
 136     bit_depth_ = GET_PARAM(2);
 137     mask_ = (1 << bit_depth_) - 1;
 138   }
 139
 140   virtual void TearDown() { libvpx_test::ClearSystemState(); }
 141
 142  protected:
 143   int bit_depth_;
 144   int mask_;
 145   loop_op_t loopfilter_op_;
 146   loop_op_t ref_loopfilter_op_;
 147 };
 148 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(Loop8Test6Param);
 149
 150 #if HAVE_NEON || HAVE_SSE2 || (HAVE_LSX && !CONFIG_VP9_HIGHBITDEPTH) || \
 151     (HAVE_DSPR2 || HAVE_MSA && !CONFIG_VP9_HIGHBITDEPTH)
 152 class Loop8Test9Param : public ::testing::TestWithParam<dualloop8_param_t> {
 153  public:
 154   virtual ~Loop8Test9Param() {}
 155   virtual void SetUp() {
 156     loopfilter_op_ = GET_PARAM(0);
 157     ref_loopfilter_op_ = GET_PARAM(1);
 158     bit_depth_ = GET_PARAM(2);
 159     mask_ = (1 << bit_depth_) - 1;
 160   }
 161
 162   virtual void TearDown() { libvpx_test::ClearSystemState(); }
 163
 164  protected:
 165   int bit_depth_;
 166   int mask_;
 167   dual_loop_op_t loopfilter_op_;
 168   dual_loop_op_t ref_loopfilter_op_;
 169 };
 170 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(Loop8Test9Param);
 171 #endif  // HAVE_NEON || HAVE_SSE2 || (HAVE_DSPR2 || HAVE_MSA &&
 172         // (!CONFIG_VP9_HIGHBITDEPTH) || (HAVE_LSX && !CONFIG_VP9_HIGHBITDEPTH))
 173
 174 TEST_P(Loop8Test6Param, OperationCheck) {
 175   ACMRandom rnd(ACMRandom::DeterministicSeed());
 176   const int count_test_block = number_of_iterations;
 177   const int32_t p = kNumCoeffs / 32;
 178   DECLARE_ALIGNED(PIXEL_WIDTH, Pixel, s[kNumCoeffs]);
 179   DECLARE_ALIGNED(PIXEL_WIDTH, Pixel, ref_s[kNumCoeffs]);
 180   int err_count_total = 0;
 181   int first_failure = -1;
 182   for (int i = 0; i < count_test_block; ++i) {
 183     int err_count = 0;
 184     uint8_t tmp = GetOuterThresh(&rnd);
 185     DECLARE_ALIGNED(16, const uint8_t,
 186                     blimit[16]) = { tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
 187                                     tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp };
 188     tmp = GetInnerThresh(&rnd);
 189     DECLARE_ALIGNED(16, const uint8_t,
 190                     limit[16]) = { tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
 191                                    tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp };
 192     tmp = GetHevThresh(&rnd);
 193     DECLARE_ALIGNED(16, const uint8_t,
 194                     thresh[16]) = { tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
 195                                     tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp };
 196     InitInput(s, ref_s, &rnd, *limit, mask_, p, i);
 197 #if CONFIG_VP9_HIGHBITDEPTH
 198     ref_loopfilter_op_(ref_s + 8 + p * 8, p, blimit, limit, thresh, bit_depth_);
 199     ASM_REGISTER_STATE_CHECK(
 200         loopfilter_op_(s + 8 + p * 8, p, blimit, limit, thresh, bit_depth_));
 201 #else
 202     ref_loopfilter_op_(ref_s + 8 + p * 8, p, blimit, limit, thresh);
 203     ASM_REGISTER_STATE_CHECK(
 204         loopfilter_op_(s + 8 + p * 8, p, blimit, limit, thresh));
 205 #endif  // CONFIG_VP9_HIGHBITDEPTH
 206
 207     for (int j = 0; j < kNumCoeffs; ++j) {
 208       err_count += ref_s[j] != s[j];
 209     }
 210     if (err_count && !err_count_total) {
 211       first_failure = i;
 212     }
 213     err_count_total += err_count;
 214   }
 215   EXPECT_EQ(0, err_count_total)
 216       << "Error: Loop8Test6Param, C output doesn't match SSE2 "
 217          "loopfilter output. "
 218       << "First failed at test case " << first_failure;
 219 }
 220
 221 TEST_P(Loop8Test6Param, ValueCheck) {
 222   ACMRandom rnd(ACMRandom::DeterministicSeed());
 223   const int count_test_block = number_of_iterations;
 224   DECLARE_ALIGNED(PIXEL_WIDTH, Pixel, s[kNumCoeffs]);
 225   DECLARE_ALIGNED(PIXEL_WIDTH, Pixel, ref_s[kNumCoeffs]);
 226   int err_count_total = 0;
 227   int first_failure = -1;
 228
 229   // NOTE: The code in vp9_loopfilter.c:update_sharpness computes mblim as a
 230   // function of sharpness_lvl and the loopfilter lvl as:
 231   // block_inside_limit = lvl >> ((sharpness_lvl > 0) + (sharpness_lvl > 4));
 232   // ...
 233   // memset(lfi->lfthr[lvl].mblim, (2 * (lvl + 2) + block_inside_limit),
 234   //        SIMD_WIDTH);
 235   // This means that the largest value for mblim will occur when sharpness_lvl
 236   // is equal to 0, and lvl is equal to its greatest value (MAX_LOOP_FILTER).
 237   // In this case block_inside_limit will be equal to MAX_LOOP_FILTER and
 238   // therefore mblim will be equal to (2 * (lvl + 2) + block_inside_limit) =
 239   // 2 * (MAX_LOOP_FILTER + 2) + MAX_LOOP_FILTER = 3 * MAX_LOOP_FILTER + 4
 240
 241   for (int i = 0; i < count_test_block; ++i) {
 242     int err_count = 0;
 243     uint8_t tmp = GetOuterThresh(&rnd);
 244     DECLARE_ALIGNED(16, const uint8_t,
 245                     blimit[16]) = { tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
 246                                     tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp };
 247     tmp = GetInnerThresh(&rnd);
 248     DECLARE_ALIGNED(16, const uint8_t,
 249                     limit[16]) = { tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
 250                                    tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp };
 251     tmp = GetHevThresh(&rnd);
 252     DECLARE_ALIGNED(16, const uint8_t,
 253                     thresh[16]) = { tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
 254                                     tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp };
 255     int32_t p = kNumCoeffs / 32;
 256     for (int j = 0; j < kNumCoeffs; ++j) {
 257       s[j] = rnd.Rand16() & mask_;
 258       ref_s[j] = s[j];
 259     }
 260 #if CONFIG_VP9_HIGHBITDEPTH
 261     ref_loopfilter_op_(ref_s + 8 + p * 8, p, blimit, limit, thresh, bit_depth_);
 262     ASM_REGISTER_STATE_CHECK(
 263         loopfilter_op_(s + 8 + p * 8, p, blimit, limit, thresh, bit_depth_));
 264 #else
 265     ref_loopfilter_op_(ref_s + 8 + p * 8, p, blimit, limit, thresh);
 266     ASM_REGISTER_STATE_CHECK(
 267         loopfilter_op_(s + 8 + p * 8, p, blimit, limit, thresh));
 268 #endif  // CONFIG_VP9_HIGHBITDEPTH
 269
 270     for (int j = 0; j < kNumCoeffs; ++j) {
 271       err_count += ref_s[j] != s[j];
 272     }
 273     if (err_count && !err_count_total) {
 274       first_failure = i;
 275     }
 276     err_count_total += err_count;
 277   }
 278   EXPECT_EQ(0, err_count_total)
 279       << "Error: Loop8Test6Param, C output doesn't match SSE2 "
 280          "loopfilter output. "
 281       << "First failed at test case " << first_failure;
 282 }
 283
 284 #if HAVE_NEON || HAVE_SSE2 || (HAVE_LSX && (!CONFIG_VP9_HIGHBITDEPTH)) || \
 285     (HAVE_DSPR2 || HAVE_MSA && (!CONFIG_VP9_HIGHBITDEPTH))
 286 TEST_P(Loop8Test9Param, OperationCheck) {
 287   ACMRandom rnd(ACMRandom::DeterministicSeed());
 288   const int count_test_block = number_of_iterations;
 289   DECLARE_ALIGNED(PIXEL_WIDTH, Pixel, s[kNumCoeffs]);
 290   DECLARE_ALIGNED(PIXEL_WIDTH, Pixel, ref_s[kNumCoeffs]);
 291   int err_count_total = 0;
 292   int first_failure = -1;
 293   for (int i = 0; i < count_test_block; ++i) {
 294     int err_count = 0;
 295     uint8_t tmp = GetOuterThresh(&rnd);
 296     DECLARE_ALIGNED(16, const uint8_t,
 297                     blimit0[16]) = { tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
 298                                      tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp };
 299     tmp = GetInnerThresh(&rnd);
 300     DECLARE_ALIGNED(16, const uint8_t,
 301                     limit0[16]) = { tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
 302                                     tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp };
 303     tmp = GetHevThresh(&rnd);
 304     DECLARE_ALIGNED(16, const uint8_t,
 305                     thresh0[16]) = { tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
 306                                      tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp };
 307     tmp = GetOuterThresh(&rnd);
 308     DECLARE_ALIGNED(16, const uint8_t,
 309                     blimit1[16]) = { tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
 310                                      tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp };
 311     tmp = GetInnerThresh(&rnd);
 312     DECLARE_ALIGNED(16, const uint8_t,
 313                     limit1[16]) = { tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
 314                                     tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp };
 315     tmp = GetHevThresh(&rnd);
 316     DECLARE_ALIGNED(16, const uint8_t,
 317                     thresh1[16]) = { tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
 318                                      tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp };
 319     int32_t p = kNumCoeffs / 32;
 320     const uint8_t limit = *limit0 < *limit1 ? *limit0 : *limit1;
 321     InitInput(s, ref_s, &rnd, limit, mask_, p, i);
 322 #if CONFIG_VP9_HIGHBITDEPTH
 323     ref_loopfilter_op_(ref_s + 8 + p * 8, p, blimit0, limit0, thresh0, blimit1,
 324                        limit1, thresh1, bit_depth_);
 325     ASM_REGISTER_STATE_CHECK(loopfilter_op_(s + 8 + p * 8, p, blimit0, limit0,
 326                                             thresh0, blimit1, limit1, thresh1,
 327                                             bit_depth_));
 328 #else
 329     ref_loopfilter_op_(ref_s + 8 + p * 8, p, blimit0, limit0, thresh0, blimit1,
 330                        limit1, thresh1);
 331     ASM_REGISTER_STATE_CHECK(loopfilter_op_(s + 8 + p * 8, p, blimit0, limit0,
 332                                             thresh0, blimit1, limit1, thresh1));
 333 #endif  // CONFIG_VP9_HIGHBITDEPTH
 334
 335     for (int j = 0; j < kNumCoeffs; ++j) {
 336       err_count += ref_s[j] != s[j];
 337     }
 338     if (err_count && !err_count_total) {
 339       first_failure = i;
 340     }
 341     err_count_total += err_count;
 342   }
 343   EXPECT_EQ(0, err_count_total)
 344       << "Error: Loop8Test9Param, C output doesn't match SSE2 "
 345          "loopfilter output. "
 346       << "First failed at test case " << first_failure;
 347 }
 348
 349 TEST_P(Loop8Test9Param, ValueCheck) {
 350   ACMRandom rnd(ACMRandom::DeterministicSeed());
 351   const int count_test_block = number_of_iterations;
 352   DECLARE_ALIGNED(PIXEL_WIDTH, Pixel, s[kNumCoeffs]);
 353   DECLARE_ALIGNED(PIXEL_WIDTH, Pixel, ref_s[kNumCoeffs]);
 354   int err_count_total = 0;
 355   int first_failure = -1;
 356   for (int i = 0; i < count_test_block; ++i) {
 357     int err_count = 0;
 358     uint8_t tmp = GetOuterThresh(&rnd);
 359     DECLARE_ALIGNED(16, const uint8_t,
 360                     blimit0[16]) = { tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
 361                                      tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp };
 362     tmp = GetInnerThresh(&rnd);
 363     DECLARE_ALIGNED(16, const uint8_t,
 364                     limit0[16]) = { tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
 365                                     tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp };
 366     tmp = GetHevThresh(&rnd);
 367     DECLARE_ALIGNED(16, const uint8_t,
 368                     thresh0[16]) = { tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
 369                                      tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp };
 370     tmp = GetOuterThresh(&rnd);
 371     DECLARE_ALIGNED(16, const uint8_t,
 372                     blimit1[16]) = { tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
 373                                      tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp };
 374     tmp = GetInnerThresh(&rnd);
 375     DECLARE_ALIGNED(16, const uint8_t,
 376                     limit1[16]) = { tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
 377                                     tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp };
 378     tmp = GetHevThresh(&rnd);
 379     DECLARE_ALIGNED(16, const uint8_t,
 380                     thresh1[16]) = { tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
 381                                      tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp };
 382     int32_t p = kNumCoeffs / 32;  // TODO(pdlf) can we have non-square here?
 383     for (int j = 0; j < kNumCoeffs; ++j) {
 384       s[j] = rnd.Rand16() & mask_;
 385       ref_s[j] = s[j];
 386     }
 387 #if CONFIG_VP9_HIGHBITDEPTH
 388     ref_loopfilter_op_(ref_s + 8 + p * 8, p, blimit0, limit0, thresh0, blimit1,
 389                        limit1, thresh1, bit_depth_);
 390     ASM_REGISTER_STATE_CHECK(loopfilter_op_(s + 8 + p * 8, p, blimit0, limit0,
 391                                             thresh0, blimit1, limit1, thresh1,
 392                                             bit_depth_));
 393 #else
 394     ref_loopfilter_op_(ref_s + 8 + p * 8, p, blimit0, limit0, thresh0, blimit1,
 395                        limit1, thresh1);
 396     ASM_REGISTER_STATE_CHECK(loopfilter_op_(s + 8 + p * 8, p, blimit0, limit0,
 397                                             thresh0, blimit1, limit1, thresh1));
 398 #endif  // CONFIG_VP9_HIGHBITDEPTH
 399
 400     for (int j = 0; j < kNumCoeffs; ++j) {
 401       err_count += ref_s[j] != s[j];
 402     }
 403     if (err_count && !err_count_total) {
 404       first_failure = i;
 405     }
 406     err_count_total += err_count;
 407   }
 408   EXPECT_EQ(0, err_count_total)
 409       << "Error: Loop8Test9Param, C output doesn't match SSE2"
 410          "loopfilter output. "
 411       << "First failed at test case " << first_failure;
 412 }
 413 #endif  // HAVE_NEON || HAVE_SSE2 || (HAVE_DSPR2 || HAVE_MSA &&
 414         // (!CONFIG_VP9_HIGHBITDEPTH)) || (HAVE_LSX &&
 415         // (!CONFIG_VP9_HIGHBITDEPTH))
 416
 417 using std::make_tuple;
 418
 419 #if HAVE_SSE2
 420 #if CONFIG_VP9_HIGHBITDEPTH
 421 INSTANTIATE_TEST_SUITE_P(
 422     SSE2, Loop8Test6Param,
 423     ::testing::Values(make_tuple(&vpx_highbd_lpf_horizontal_4_sse2,
 424                                  &vpx_highbd_lpf_horizontal_4_c, 8),
 425                       make_tuple(&vpx_highbd_lpf_vertical_4_sse2,
 426                                  &vpx_highbd_lpf_vertical_4_c, 8),
 427                       make_tuple(&vpx_highbd_lpf_horizontal_8_sse2,
 428                                  &vpx_highbd_lpf_horizontal_8_c, 8),
 429                       make_tuple(&vpx_highbd_lpf_horizontal_16_sse2,
 430                                  &vpx_highbd_lpf_horizontal_16_c, 8),
 431                       make_tuple(&vpx_highbd_lpf_horizontal_16_dual_sse2,
 432                                  &vpx_highbd_lpf_horizontal_16_dual_c, 8),
 433                       make_tuple(&vpx_highbd_lpf_vertical_8_sse2,
 434                                  &vpx_highbd_lpf_vertical_8_c, 8),
 435                       make_tuple(&vpx_highbd_lpf_vertical_16_sse2,
 436                                  &vpx_highbd_lpf_vertical_16_c, 8),
 437                       make_tuple(&vpx_highbd_lpf_horizontal_4_sse2,
 438                                  &vpx_highbd_lpf_horizontal_4_c, 10),
 439                       make_tuple(&vpx_highbd_lpf_vertical_4_sse2,
 440                                  &vpx_highbd_lpf_vertical_4_c, 10),
 441                       make_tuple(&vpx_highbd_lpf_horizontal_8_sse2,
 442                                  &vpx_highbd_lpf_horizontal_8_c, 10),
 443                       make_tuple(&vpx_highbd_lpf_horizontal_16_sse2,
 444                                  &vpx_highbd_lpf_horizontal_16_c, 10),
 445                       make_tuple(&vpx_highbd_lpf_horizontal_16_dual_sse2,
 446                                  &vpx_highbd_lpf_horizontal_16_dual_c, 10),
 447                       make_tuple(&vpx_highbd_lpf_vertical_8_sse2,
 448                                  &vpx_highbd_lpf_vertical_8_c, 10),
 449                       make_tuple(&vpx_highbd_lpf_vertical_16_sse2,
 450                                  &vpx_highbd_lpf_vertical_16_c, 10),
 451                       make_tuple(&vpx_highbd_lpf_horizontal_4_sse2,
 452                                  &vpx_highbd_lpf_horizontal_4_c, 12),
 453                       make_tuple(&vpx_highbd_lpf_vertical_4_sse2,
 454                                  &vpx_highbd_lpf_vertical_4_c, 12),
 455                       make_tuple(&vpx_highbd_lpf_horizontal_8_sse2,
 456                                  &vpx_highbd_lpf_horizontal_8_c, 12),
 457                       make_tuple(&vpx_highbd_lpf_horizontal_16_sse2,
 458                                  &vpx_highbd_lpf_horizontal_16_c, 12),
 459                       make_tuple(&vpx_highbd_lpf_horizontal_16_dual_sse2,
 460                                  &vpx_highbd_lpf_horizontal_16_dual_c, 12),
 461                       make_tuple(&vpx_highbd_lpf_vertical_8_sse2,
 462                                  &vpx_highbd_lpf_vertical_8_c, 12),
 463                       make_tuple(&vpx_highbd_lpf_vertical_16_sse2,
 464                                  &vpx_highbd_lpf_vertical_16_c, 12),
 465                       make_tuple(&vpx_highbd_lpf_vertical_16_dual_sse2,
 466                                  &vpx_highbd_lpf_vertical_16_dual_c, 8),
 467                       make_tuple(&vpx_highbd_lpf_vertical_16_dual_sse2,
 468                                  &vpx_highbd_lpf_vertical_16_dual_c, 10),
 469                       make_tuple(&vpx_highbd_lpf_vertical_16_dual_sse2,
 470                                  &vpx_highbd_lpf_vertical_16_dual_c, 12)));
 471 #else
 472 INSTANTIATE_TEST_SUITE_P(
 473     SSE2, Loop8Test6Param,
 474     ::testing::Values(
 475         make_tuple(&vpx_lpf_horizontal_4_sse2, &vpx_lpf_horizontal_4_c, 8),
 476         make_tuple(&vpx_lpf_horizontal_8_sse2, &vpx_lpf_horizontal_8_c, 8),
 477         make_tuple(&vpx_lpf_horizontal_16_sse2, &vpx_lpf_horizontal_16_c, 8),
 478         make_tuple(&vpx_lpf_horizontal_16_dual_sse2,
 479                    &vpx_lpf_horizontal_16_dual_c, 8),
 480         make_tuple(&vpx_lpf_vertical_4_sse2, &vpx_lpf_vertical_4_c, 8),
 481         make_tuple(&vpx_lpf_vertical_8_sse2, &vpx_lpf_vertical_8_c, 8),
 482         make_tuple(&vpx_lpf_vertical_16_sse2, &vpx_lpf_vertical_16_c, 8),
 483         make_tuple(&vpx_lpf_vertical_16_dual_sse2, &vpx_lpf_vertical_16_dual_c,
 484                    8)));
 485 #endif  // CONFIG_VP9_HIGHBITDEPTH
 486 #endif
 487
 488 #if HAVE_AVX2 && (!CONFIG_VP9_HIGHBITDEPTH)
 489 INSTANTIATE_TEST_SUITE_P(
 490     AVX2, Loop8Test6Param,
 491     ::testing::Values(make_tuple(&vpx_lpf_horizontal_16_avx2,
 492                                  &vpx_lpf_horizontal_16_c, 8),
 493                       make_tuple(&vpx_lpf_horizontal_16_dual_avx2,
 494                                  &vpx_lpf_horizontal_16_dual_c, 8)));
 495 #endif
 496
 497 #if HAVE_SSE2
 498 #if CONFIG_VP9_HIGHBITDEPTH
 499 INSTANTIATE_TEST_SUITE_P(
 500     SSE2, Loop8Test9Param,
 501     ::testing::Values(make_tuple(&vpx_highbd_lpf_horizontal_4_dual_sse2,
 502                                  &vpx_highbd_lpf_horizontal_4_dual_c, 8),
 503                       make_tuple(&vpx_highbd_lpf_horizontal_8_dual_sse2,
 504                                  &vpx_highbd_lpf_horizontal_8_dual_c, 8),
 505                       make_tuple(&vpx_highbd_lpf_vertical_4_dual_sse2,
 506                                  &vpx_highbd_lpf_vertical_4_dual_c, 8),
 507                       make_tuple(&vpx_highbd_lpf_vertical_8_dual_sse2,
 508                                  &vpx_highbd_lpf_vertical_8_dual_c, 8),
 509                       make_tuple(&vpx_highbd_lpf_horizontal_4_dual_sse2,
 510                                  &vpx_highbd_lpf_horizontal_4_dual_c, 10),
 511                       make_tuple(&vpx_highbd_lpf_horizontal_8_dual_sse2,
 512                                  &vpx_highbd_lpf_horizontal_8_dual_c, 10),
 513                       make_tuple(&vpx_highbd_lpf_vertical_4_dual_sse2,
 514                                  &vpx_highbd_lpf_vertical_4_dual_c, 10),
 515                       make_tuple(&vpx_highbd_lpf_vertical_8_dual_sse2,
 516                                  &vpx_highbd_lpf_vertical_8_dual_c, 10),
 517                       make_tuple(&vpx_highbd_lpf_horizontal_4_dual_sse2,
 518                                  &vpx_highbd_lpf_horizontal_4_dual_c, 12),
 519                       make_tuple(&vpx_highbd_lpf_horizontal_8_dual_sse2,
 520                                  &vpx_highbd_lpf_horizontal_8_dual_c, 12),
 521                       make_tuple(&vpx_highbd_lpf_vertical_4_dual_sse2,
 522                                  &vpx_highbd_lpf_vertical_4_dual_c, 12),
 523                       make_tuple(&vpx_highbd_lpf_vertical_8_dual_sse2,
 524                                  &vpx_highbd_lpf_vertical_8_dual_c, 12)));
 525 #else
 526 INSTANTIATE_TEST_SUITE_P(
 527     SSE2, Loop8Test9Param,
 528     ::testing::Values(make_tuple(&vpx_lpf_horizontal_4_dual_sse2,
 529                                  &vpx_lpf_horizontal_4_dual_c, 8),
 530                       make_tuple(&vpx_lpf_horizontal_8_dual_sse2,
 531                                  &vpx_lpf_horizontal_8_dual_c, 8),
 532                       make_tuple(&vpx_lpf_vertical_4_dual_sse2,
 533                                  &vpx_lpf_vertical_4_dual_c, 8),
 534                       make_tuple(&vpx_lpf_vertical_8_dual_sse2,
 535                                  &vpx_lpf_vertical_8_dual_c, 8)));
 536 #endif  // CONFIG_VP9_HIGHBITDEPTH
 537 #endif
 538
 539 #if HAVE_NEON
 540 #if CONFIG_VP9_HIGHBITDEPTH
 541 INSTANTIATE_TEST_SUITE_P(
 542     NEON, Loop8Test6Param,
 543     ::testing::Values(make_tuple(&vpx_highbd_lpf_horizontal_4_neon,
 544                                  &vpx_highbd_lpf_horizontal_4_c, 8),
 545                       make_tuple(&vpx_highbd_lpf_horizontal_4_neon,
 546                                  &vpx_highbd_lpf_horizontal_4_c, 10),
 547                       make_tuple(&vpx_highbd_lpf_horizontal_4_neon,
 548                                  &vpx_highbd_lpf_horizontal_4_c, 12),
 549                       make_tuple(&vpx_highbd_lpf_horizontal_8_neon,
 550                                  &vpx_highbd_lpf_horizontal_8_c, 8),
 551                       make_tuple(&vpx_highbd_lpf_horizontal_8_neon,
 552                                  &vpx_highbd_lpf_horizontal_8_c, 10),
 553                       make_tuple(&vpx_highbd_lpf_horizontal_8_neon,
 554                                  &vpx_highbd_lpf_horizontal_8_c, 12),
 555                       make_tuple(&vpx_highbd_lpf_horizontal_16_neon,
 556                                  &vpx_highbd_lpf_horizontal_16_c, 8),
 557                       make_tuple(&vpx_highbd_lpf_horizontal_16_neon,
 558                                  &vpx_highbd_lpf_horizontal_16_c, 10),
 559                       make_tuple(&vpx_highbd_lpf_horizontal_16_neon,
 560                                  &vpx_highbd_lpf_horizontal_16_c, 12),
 561                       make_tuple(&vpx_highbd_lpf_horizontal_16_dual_neon,
 562                                  &vpx_highbd_lpf_horizontal_16_dual_c, 8),
 563                       make_tuple(&vpx_highbd_lpf_horizontal_16_dual_neon,
 564                                  &vpx_highbd_lpf_horizontal_16_dual_c, 10),
 565                       make_tuple(&vpx_highbd_lpf_horizontal_16_dual_neon,
 566                                  &vpx_highbd_lpf_horizontal_16_dual_c, 12),
 567                       make_tuple(&vpx_highbd_lpf_vertical_4_neon,
 568                                  &vpx_highbd_lpf_vertical_4_c, 8),
 569                       make_tuple(&vpx_highbd_lpf_vertical_4_neon,
 570                                  &vpx_highbd_lpf_vertical_4_c, 10),
 571                       make_tuple(&vpx_highbd_lpf_vertical_4_neon,
 572                                  &vpx_highbd_lpf_vertical_4_c, 12),
 573                       make_tuple(&vpx_highbd_lpf_vertical_8_neon,
 574                                  &vpx_highbd_lpf_vertical_8_c, 8),
 575                       make_tuple(&vpx_highbd_lpf_vertical_8_neon,
 576                                  &vpx_highbd_lpf_vertical_8_c, 10),
 577                       make_tuple(&vpx_highbd_lpf_vertical_8_neon,
 578                                  &vpx_highbd_lpf_vertical_8_c, 12),
 579                       make_tuple(&vpx_highbd_lpf_vertical_16_neon,
 580                                  &vpx_highbd_lpf_vertical_16_c, 8),
 581                       make_tuple(&vpx_highbd_lpf_vertical_16_neon,
 582                                  &vpx_highbd_lpf_vertical_16_c, 10),
 583                       make_tuple(&vpx_highbd_lpf_vertical_16_neon,
 584                                  &vpx_highbd_lpf_vertical_16_c, 12),
 585                       make_tuple(&vpx_highbd_lpf_vertical_16_dual_neon,
 586                                  &vpx_highbd_lpf_vertical_16_dual_c, 8),
 587                       make_tuple(&vpx_highbd_lpf_vertical_16_dual_neon,
 588                                  &vpx_highbd_lpf_vertical_16_dual_c, 10),
 589                       make_tuple(&vpx_highbd_lpf_vertical_16_dual_neon,
 590                                  &vpx_highbd_lpf_vertical_16_dual_c, 12)));
 591 INSTANTIATE_TEST_SUITE_P(
 592     NEON, Loop8Test9Param,
 593     ::testing::Values(make_tuple(&vpx_highbd_lpf_horizontal_4_dual_neon,
 594                                  &vpx_highbd_lpf_horizontal_4_dual_c, 8),
 595                       make_tuple(&vpx_highbd_lpf_horizontal_4_dual_neon,
 596                                  &vpx_highbd_lpf_horizontal_4_dual_c, 10),
 597                       make_tuple(&vpx_highbd_lpf_horizontal_4_dual_neon,
 598                                  &vpx_highbd_lpf_horizontal_4_dual_c, 12),
 599                       make_tuple(&vpx_highbd_lpf_horizontal_8_dual_neon,
 600                                  &vpx_highbd_lpf_horizontal_8_dual_c, 8),
 601                       make_tuple(&vpx_highbd_lpf_horizontal_8_dual_neon,
 602                                  &vpx_highbd_lpf_horizontal_8_dual_c, 10),
 603                       make_tuple(&vpx_highbd_lpf_horizontal_8_dual_neon,
 604                                  &vpx_highbd_lpf_horizontal_8_dual_c, 12),
 605                       make_tuple(&vpx_highbd_lpf_vertical_4_dual_neon,
 606                                  &vpx_highbd_lpf_vertical_4_dual_c, 8),
 607                       make_tuple(&vpx_highbd_lpf_vertical_4_dual_neon,
 608                                  &vpx_highbd_lpf_vertical_4_dual_c, 10),
 609                       make_tuple(&vpx_highbd_lpf_vertical_4_dual_neon,
 610                                  &vpx_highbd_lpf_vertical_4_dual_c, 12),
 611                       make_tuple(&vpx_highbd_lpf_vertical_8_dual_neon,
 612                                  &vpx_highbd_lpf_vertical_8_dual_c, 8),
 613                       make_tuple(&vpx_highbd_lpf_vertical_8_dual_neon,
 614                                  &vpx_highbd_lpf_vertical_8_dual_c, 10),
 615                       make_tuple(&vpx_highbd_lpf_vertical_8_dual_neon,
 616                                  &vpx_highbd_lpf_vertical_8_dual_c, 12)));
 617 #else
 618 INSTANTIATE_TEST_SUITE_P(
 619     NEON, Loop8Test6Param,
 620     ::testing::Values(
 621         make_tuple(&vpx_lpf_horizontal_16_neon, &vpx_lpf_horizontal_16_c, 8),
 622         make_tuple(&vpx_lpf_horizontal_16_dual_neon,
 623                    &vpx_lpf_horizontal_16_dual_c, 8),
 624         make_tuple(&vpx_lpf_vertical_16_neon, &vpx_lpf_vertical_16_c, 8),
 625         make_tuple(&vpx_lpf_vertical_16_dual_neon, &vpx_lpf_vertical_16_dual_c,
 626                    8),
 627         make_tuple(&vpx_lpf_horizontal_8_neon, &vpx_lpf_horizontal_8_c, 8),
 628         make_tuple(&vpx_lpf_vertical_8_neon, &vpx_lpf_vertical_8_c, 8),
 629         make_tuple(&vpx_lpf_horizontal_4_neon, &vpx_lpf_horizontal_4_c, 8),
 630         make_tuple(&vpx_lpf_vertical_4_neon, &vpx_lpf_vertical_4_c, 8)));
 631 INSTANTIATE_TEST_SUITE_P(
 632     NEON, Loop8Test9Param,
 633     ::testing::Values(make_tuple(&vpx_lpf_horizontal_8_dual_neon,
 634                                  &vpx_lpf_horizontal_8_dual_c, 8),
 635                       make_tuple(&vpx_lpf_vertical_8_dual_neon,
 636                                  &vpx_lpf_vertical_8_dual_c, 8),
 637                       make_tuple(&vpx_lpf_horizontal_4_dual_neon,
 638                                  &vpx_lpf_horizontal_4_dual_c, 8),
 639                       make_tuple(&vpx_lpf_vertical_4_dual_neon,
 640                                  &vpx_lpf_vertical_4_dual_c, 8)));
 641 #endif  // CONFIG_VP9_HIGHBITDEPTH
 642 #endif  // HAVE_NEON
 643
 644 #if HAVE_DSPR2 && !CONFIG_VP9_HIGHBITDEPTH
 645 INSTANTIATE_TEST_SUITE_P(
 646     DSPR2, Loop8Test6Param,
 647     ::testing::Values(
 648         make_tuple(&vpx_lpf_horizontal_4_dspr2, &vpx_lpf_horizontal_4_c, 8),
 649         make_tuple(&vpx_lpf_horizontal_8_dspr2, &vpx_lpf_horizontal_8_c, 8),
 650         make_tuple(&vpx_lpf_horizontal_16_dspr2, &vpx_lpf_horizontal_16_c, 8),
 651         make_tuple(&vpx_lpf_horizontal_16_dual_dspr2,
 652                    &vpx_lpf_horizontal_16_dual_c, 8),
 653         make_tuple(&vpx_lpf_vertical_4_dspr2, &vpx_lpf_vertical_4_c, 8),
 654         make_tuple(&vpx_lpf_vertical_8_dspr2, &vpx_lpf_vertical_8_c, 8),
 655         make_tuple(&vpx_lpf_vertical_16_dspr2, &vpx_lpf_vertical_16_c, 8),
 656         make_tuple(&vpx_lpf_vertical_16_dual_dspr2, &vpx_lpf_vertical_16_dual_c,
 657                    8)));
 658
 659 INSTANTIATE_TEST_SUITE_P(
 660     DSPR2, Loop8Test9Param,
 661     ::testing::Values(make_tuple(&vpx_lpf_horizontal_4_dual_dspr2,
 662                                  &vpx_lpf_horizontal_4_dual_c, 8),
 663                       make_tuple(&vpx_lpf_horizontal_8_dual_dspr2,
 664                                  &vpx_lpf_horizontal_8_dual_c, 8),
 665                       make_tuple(&vpx_lpf_vertical_4_dual_dspr2,
 666                                  &vpx_lpf_vertical_4_dual_c, 8),
 667                       make_tuple(&vpx_lpf_vertical_8_dual_dspr2,
 668                                  &vpx_lpf_vertical_8_dual_c, 8)));
 669 #endif  // HAVE_DSPR2 && !CONFIG_VP9_HIGHBITDEPTH
 670
 671 #if HAVE_MSA && (!CONFIG_VP9_HIGHBITDEPTH)
 672 INSTANTIATE_TEST_SUITE_P(
 673     MSA, Loop8Test6Param,
 674     ::testing::Values(
 675         make_tuple(&vpx_lpf_horizontal_4_msa, &vpx_lpf_horizontal_4_c, 8),
 676         make_tuple(&vpx_lpf_horizontal_8_msa, &vpx_lpf_horizontal_8_c, 8),
 677         make_tuple(&vpx_lpf_horizontal_16_msa, &vpx_lpf_horizontal_16_c, 8),
 678         make_tuple(&vpx_lpf_horizontal_16_dual_msa,
 679                    &vpx_lpf_horizontal_16_dual_c, 8),
 680         make_tuple(&vpx_lpf_vertical_4_msa, &vpx_lpf_vertical_4_c, 8),
 681         make_tuple(&vpx_lpf_vertical_8_msa, &vpx_lpf_vertical_8_c, 8),
 682         make_tuple(&vpx_lpf_vertical_16_msa, &vpx_lpf_vertical_16_c, 8)));
 683
 684 INSTANTIATE_TEST_SUITE_P(
 685     MSA, Loop8Test9Param,
 686     ::testing::Values(make_tuple(&vpx_lpf_horizontal_4_dual_msa,
 687                                  &vpx_lpf_horizontal_4_dual_c, 8),
 688                       make_tuple(&vpx_lpf_horizontal_8_dual_msa,
 689                                  &vpx_lpf_horizontal_8_dual_c, 8),
 690                       make_tuple(&vpx_lpf_vertical_4_dual_msa,
 691                                  &vpx_lpf_vertical_4_dual_c, 8),
 692                       make_tuple(&vpx_lpf_vertical_8_dual_msa,
 693                                  &vpx_lpf_vertical_8_dual_c, 8)));
 694 #endif  // HAVE_MSA && (!CONFIG_VP9_HIGHBITDEPTH)
 695
 696 #if HAVE_LSX && (!CONFIG_VP9_HIGHBITDEPTH)
 697 INSTANTIATE_TEST_SUITE_P(
 698     LSX, Loop8Test6Param,
 699     ::testing::Values(
 700         make_tuple(&vpx_lpf_horizontal_4_lsx, &vpx_lpf_horizontal_4_c, 8),
 701         make_tuple(&vpx_lpf_horizontal_8_lsx, &vpx_lpf_horizontal_8_c, 8),
 702         make_tuple(&vpx_lpf_horizontal_16_dual_lsx,
 703                    &vpx_lpf_horizontal_16_dual_c, 8),
 704         make_tuple(&vpx_lpf_vertical_4_lsx, &vpx_lpf_vertical_4_c, 8),
 705         make_tuple(&vpx_lpf_vertical_8_lsx, &vpx_lpf_vertical_8_c, 8),
 706         make_tuple(&vpx_lpf_vertical_16_dual_lsx, &vpx_lpf_vertical_16_dual_c,
 707                    8)));
 708
 709 INSTANTIATE_TEST_SUITE_P(
 710     LSX, Loop8Test9Param,
 711     ::testing::Values(make_tuple(&vpx_lpf_horizontal_4_dual_lsx,
 712                                  &vpx_lpf_horizontal_4_dual_c, 8),
 713                       make_tuple(&vpx_lpf_horizontal_8_dual_lsx,
 714                                  &vpx_lpf_horizontal_8_dual_c, 8),
 715                       make_tuple(&vpx_lpf_vertical_4_dual_lsx,
 716                                  &vpx_lpf_vertical_4_dual_c, 8),
 717                       make_tuple(&vpx_lpf_vertical_8_dual_lsx,
 718                                  &vpx_lpf_vertical_8_dual_c, 8)));
 719 #endif  // HAVE_LSX && (!CONFIG_VP9_HIGHBITDEPTH)
 720
 721 }  // namespace