third_party/aom/test/cfl_test.cc

   1 /*
   2  * Copyright (c) 2017, Alliance for Open Media. All rights reserved
   3  *
   4  * This source code is subject to the terms of the BSD 2 Clause License and
   5  * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
   6  * was not distributed with this source code in the LICENSE file, you can
   7  * obtain it at www.aomedia.org/license/software. If the Alliance for Open
   8  * Media Patent License 1.0 was not distributed with this source code in the
   9  * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
  10  */
  11
  12 #include "third_party/googletest/src/googletest/include/gtest/gtest.h"
  13
  14 #include "config/av1_rtcd.h"
  15
  16 #include "aom_ports/aom_timer.h"
  17 #include "test/util.h"
  18 #include "test/acm_random.h"
  19
  20 using ::testing::make_tuple;
  21
  22 using libaom_test::ACMRandom;
  23
  24 #define NUM_ITERATIONS (100)
  25 #define NUM_ITERATIONS_SPEED (INT16_MAX)
  26
  27 #define ALL_CFL_TX_SIZES(function)                                     \
  28   make_tuple(TX_4X4, &function), make_tuple(TX_4X8, &function),        \
  29       make_tuple(TX_4X16, &function), make_tuple(TX_8X4, &function),   \
  30       make_tuple(TX_8X8, &function), make_tuple(TX_8X16, &function),   \
  31       make_tuple(TX_8X32, &function), make_tuple(TX_16X4, &function),  \
  32       make_tuple(TX_16X8, &function), make_tuple(TX_16X16, &function), \
  33       make_tuple(TX_16X32, &function), make_tuple(TX_32X8, &function), \
  34       make_tuple(TX_32X16, &function), make_tuple(TX_32X32, &function)
  35
  36 #define ALL_CFL_TX_SIZES_SUBSAMPLE(fun420, fun422, fun444) \
  37   make_tuple(TX_4X4, &fun420, &fun422, &fun444),           \
  38       make_tuple(TX_4X8, &fun420, &fun422, &fun444),       \
  39       make_tuple(TX_4X16, &fun420, &fun422, &fun444),      \
  40       make_tuple(TX_8X4, &fun420, &fun422, &fun444),       \
  41       make_tuple(TX_8X8, &fun420, &fun422, &fun444),       \
  42       make_tuple(TX_8X16, &fun420, &fun422, &fun444),      \
  43       make_tuple(TX_8X32, &fun420, &fun422, &fun444),      \
  44       make_tuple(TX_16X4, &fun420, &fun422, &fun444),      \
  45       make_tuple(TX_16X8, &fun420, &fun422, &fun444),      \
  46       make_tuple(TX_16X16, &fun420, &fun422, &fun444),     \
  47       make_tuple(TX_16X32, &fun420, &fun422, &fun444),     \
  48       make_tuple(TX_32X8, &fun420, &fun422, &fun444),      \
  49       make_tuple(TX_32X16, &fun420, &fun422, &fun444),     \
  50       make_tuple(TX_32X32, &fun420, &fun422, &fun444)
  51
  52 namespace {
  53
  54 template <typename A>
  55 static void assert_eq(const A *a, const A *b, int width, int height) {
  56   for (int j = 0; j < height; j++) {
  57     for (int i = 0; i < width; i++) {
  58       ASSERT_EQ(a[j * CFL_BUF_LINE + i], b[j * CFL_BUF_LINE + i]);
  59     }
  60   }
  61 }
  62
  63 static void assertFaster(int ref_elapsed_time, int elapsed_time) {
  64   EXPECT_GT(ref_elapsed_time, elapsed_time)
  65       << "Error: CFLSubtractSpeedTest, SIMD slower than C." << std::endl
  66       << "C time: " << ref_elapsed_time << " us" << std::endl
  67       << "SIMD time: " << elapsed_time << " us" << std::endl;
  68 }
  69
  70 static void printSpeed(int ref_elapsed_time, int elapsed_time, int width,
  71                        int height) {
  72   std::cout.precision(2);
  73   std::cout << "[          ] " << width << "x" << height
  74             << ": C time = " << ref_elapsed_time
  75             << " us, SIMD time = " << elapsed_time << " us"
  76             << " (~" << ref_elapsed_time / (double)elapsed_time << "x) "
  77             << std::endl;
  78 }
  79
  80 class CFLTest {
  81  public:
  82   virtual ~CFLTest() {}
  83   void init(TX_SIZE tx) {
  84     tx_size = tx;
  85     width = tx_size_wide[tx_size];
  86     height = tx_size_high[tx_size];
  87     rnd(ACMRandom::DeterministicSeed());
  88   }
  89
  90  protected:
  91   TX_SIZE tx_size;
  92   int width;
  93   int height;
  94   ACMRandom rnd;
  95 };
  96
  97 template <typename I>
  98 class CFLTestWithData : public CFLTest {
  99  public:
 100   virtual ~CFLTestWithData() {}
 101
 102  protected:
 103   I data[CFL_BUF_SQUARE];
 104   I data_ref[CFL_BUF_SQUARE];
 105   void randData(I (ACMRandom::*random)()) {
 106     for (int j = 0; j < this->height; j++) {
 107       for (int i = 0; i < this->width; i++) {
 108         const I d = (this->rnd.*random)();
 109         data[j * CFL_BUF_LINE + i] = d;
 110         data_ref[j * CFL_BUF_LINE + i] = d;
 111       }
 112     }
 113   }
 114 };
 115
 116 template <typename I>
 117 class CFLTestWithAlignedData : public CFLTest {
 118  public:
 119   CFLTestWithAlignedData() {
 120     chroma_pels_ref =
 121         reinterpret_cast<I *>(aom_memalign(32, sizeof(I) * CFL_BUF_SQUARE));
 122     chroma_pels =
 123         reinterpret_cast<I *>(aom_memalign(32, sizeof(I) * CFL_BUF_SQUARE));
 124     sub_luma_pels_ref = reinterpret_cast<int16_t *>(
 125         aom_memalign(32, sizeof(int16_t) * CFL_BUF_SQUARE));
 126     sub_luma_pels = reinterpret_cast<int16_t *>(
 127         aom_memalign(32, sizeof(int16_t) * CFL_BUF_SQUARE));
 128     memset(chroma_pels_ref, 0, sizeof(I) * CFL_BUF_SQUARE);
 129     memset(chroma_pels, 0, sizeof(I) * CFL_BUF_SQUARE);
 130     memset(sub_luma_pels_ref, 0, sizeof(int16_t) * CFL_BUF_SQUARE);
 131     memset(sub_luma_pels, 0, sizeof(int16_t) * CFL_BUF_SQUARE);
 132   }
 133   ~CFLTestWithAlignedData() {
 134     aom_free(chroma_pels_ref);
 135     aom_free(sub_luma_pels_ref);
 136     aom_free(chroma_pels);
 137     aom_free(sub_luma_pels);
 138   }
 139
 140  protected:
 141   I *chroma_pels_ref;
 142   I *chroma_pels;
 143   int16_t *sub_luma_pels_ref;
 144   int16_t *sub_luma_pels;
 145   int alpha_q3;
 146   I dc;
 147   void randData(int bd) {
 148     alpha_q3 = this->rnd(33) - 16;
 149     dc = this->rnd(1 << bd);
 150     for (int j = 0; j < this->height; j++) {
 151       for (int i = 0; i < this->width; i++) {
 152         chroma_pels[j * CFL_BUF_LINE + i] = dc;
 153         chroma_pels_ref[j * CFL_BUF_LINE + i] = dc;
 154         sub_luma_pels_ref[j * CFL_BUF_LINE + i] =
 155             sub_luma_pels[j * CFL_BUF_LINE + i] = this->rnd(1 << (bd + 3));
 156       }
 157     }
 158   }
 159 };
 160
 161 typedef cfl_subtract_average_fn (*sub_avg_fn)(TX_SIZE tx_size);
 162 typedef ::testing::tuple<TX_SIZE, sub_avg_fn> sub_avg_param;
 163 class CFLSubAvgTest : public ::testing::TestWithParam<sub_avg_param>,
 164                       public CFLTestWithData<int16_t> {
 165  public:
 166   virtual void SetUp() {
 167     CFLTest::init(::testing::get<0>(this->GetParam()));
 168     sub_avg = ::testing::get<1>(this->GetParam())(tx_size);
 169     sub_avg_ref = get_subtract_average_fn_c(tx_size);
 170   }
 171   virtual ~CFLSubAvgTest() {}
 172
 173  protected:
 174   cfl_subtract_average_fn sub_avg;
 175   cfl_subtract_average_fn sub_avg_ref;
 176 };
 177
 178 TEST_P(CFLSubAvgTest, SubAvgTest) {
 179   for (int it = 0; it < NUM_ITERATIONS; it++) {
 180     randData(&ACMRandom::Rand15Signed);
 181     sub_avg((uint16_t *)data, data);
 182     sub_avg_ref((uint16_t *)data_ref, data_ref);
 183     assert_eq<int16_t>(data, data_ref, width, height);
 184   }
 185 }
 186
 187 TEST_P(CFLSubAvgTest, DISABLED_SubAvgSpeedTest) {
 188   aom_usec_timer ref_timer;
 189   aom_usec_timer timer;
 190   randData(&ACMRandom::Rand15Signed);
 191   aom_usec_timer_start(&ref_timer);
 192   for (int k = 0; k < NUM_ITERATIONS_SPEED; k++) {
 193     sub_avg_ref((uint16_t *)data_ref, data_ref);
 194   }
 195   aom_usec_timer_mark(&ref_timer);
 196   int ref_elapsed_time = (int)aom_usec_timer_elapsed(&ref_timer);
 197   aom_usec_timer_start(&timer);
 198   for (int k = 0; k < NUM_ITERATIONS_SPEED; k++) {
 199     sub_avg((uint16_t *)data, data);
 200   }
 201   aom_usec_timer_mark(&timer);
 202   int elapsed_time = (int)aom_usec_timer_elapsed(&timer);
 203   printSpeed(ref_elapsed_time, elapsed_time, width, height);
 204   assertFaster(ref_elapsed_time, elapsed_time);
 205 }
 206
 207 template <typename S, typename T, typename I>
 208 class CFLSubsampleTest : public ::testing::TestWithParam<S>,
 209                          public CFLTestWithData<I> {
 210  public:
 211   virtual void SetUp() {
 212     CFLTest::init(::testing::get<0>(this->GetParam()));
 213     fun_420 = ::testing::get<1>(this->GetParam())(this->tx_size);
 214     fun_422 = ::testing::get<2>(this->GetParam())(this->tx_size);
 215     fun_444 = ::testing::get<3>(this->GetParam())(this->tx_size);
 216   }
 217
 218  protected:
 219   T fun_420;
 220   T fun_422;
 221   T fun_444;
 222   T fun_420_ref;
 223   T fun_422_ref;
 224   T fun_444_ref;
 225
 226   void subsampleTest(T fun, T fun_ref, int sub_width, int sub_height,
 227                      I (ACMRandom::*random)()) {
 228     uint16_t sub_luma_pels[CFL_BUF_SQUARE];
 229     uint16_t sub_luma_pels_ref[CFL_BUF_SQUARE];
 230
 231     for (int it = 0; it < NUM_ITERATIONS; it++) {
 232       CFLTestWithData<I>::randData(random);
 233       fun(this->data, CFL_BUF_LINE, sub_luma_pels);
 234       fun_ref(this->data_ref, CFL_BUF_LINE, sub_luma_pels_ref);
 235       assert_eq<uint16_t>(sub_luma_pels, sub_luma_pels_ref, sub_width,
 236                           sub_height);
 237     }
 238   }
 239
 240   void subsampleSpeedTest(T fun, T fun_ref, I (ACMRandom::*random)()) {
 241     uint16_t sub_luma_pels[CFL_BUF_SQUARE];
 242     uint16_t sub_luma_pels_ref[CFL_BUF_SQUARE];
 243     aom_usec_timer ref_timer;
 244     aom_usec_timer timer;
 245
 246     CFLTestWithData<I>::randData(random);
 247     aom_usec_timer_start(&ref_timer);
 248     for (int k = 0; k < NUM_ITERATIONS_SPEED; k++) {
 249       fun_ref(this->data_ref, CFL_BUF_LINE, sub_luma_pels);
 250     }
 251     aom_usec_timer_mark(&ref_timer);
 252     int ref_elapsed_time = (int)aom_usec_timer_elapsed(&ref_timer);
 253     aom_usec_timer_start(&timer);
 254     for (int k = 0; k < NUM_ITERATIONS_SPEED; k++) {
 255       fun(this->data, CFL_BUF_LINE, sub_luma_pels_ref);
 256     }
 257     aom_usec_timer_mark(&timer);
 258     int elapsed_time = (int)aom_usec_timer_elapsed(&timer);
 259     printSpeed(ref_elapsed_time, elapsed_time, this->width, this->height);
 260     assertFaster(ref_elapsed_time, elapsed_time);
 261   }
 262 };
 263
 264 typedef cfl_subsample_lbd_fn (*get_subsample_lbd_fn)(TX_SIZE tx_size);
 265 typedef ::testing::tuple<TX_SIZE, get_subsample_lbd_fn, get_subsample_lbd_fn,
 266                          get_subsample_lbd_fn>
 267     subsample_lbd_param;
 268 class CFLSubsampleLBDTest
 269     : public CFLSubsampleTest<subsample_lbd_param, cfl_subsample_lbd_fn,
 270                               uint8_t> {
 271  public:
 272   virtual ~CFLSubsampleLBDTest() {}
 273   virtual void SetUp() {
 274     CFLSubsampleTest::SetUp();
 275     fun_420_ref = cfl_get_luma_subsampling_420_lbd_c(tx_size);
 276     fun_422_ref = cfl_get_luma_subsampling_422_lbd_c(tx_size);
 277     fun_444_ref = cfl_get_luma_subsampling_444_lbd_c(tx_size);
 278   }
 279 };
 280
 281 TEST_P(CFLSubsampleLBDTest, SubsampleLBD420Test) {
 282   subsampleTest(fun_420, fun_420_ref, width >> 1, height >> 1,
 283                 &ACMRandom::Rand8);
 284 }
 285
 286 TEST_P(CFLSubsampleLBDTest, DISABLED_SubsampleLBD420SpeedTest) {
 287   subsampleSpeedTest(fun_420, fun_420_ref, &ACMRandom::Rand8);
 288 }
 289
 290 TEST_P(CFLSubsampleLBDTest, SubsampleLBD422Test) {
 291   subsampleTest(fun_422, fun_422_ref, width >> 1, height, &ACMRandom::Rand8);
 292 }
 293
 294 TEST_P(CFLSubsampleLBDTest, DISABLED_SubsampleLBD422SpeedTest) {
 295   subsampleSpeedTest(fun_422, fun_422_ref, &ACMRandom::Rand8);
 296 }
 297
 298 TEST_P(CFLSubsampleLBDTest, SubsampleLBD444Test) {
 299   subsampleTest(fun_444, fun_444_ref, width, height, &ACMRandom::Rand8);
 300 }
 301
 302 TEST_P(CFLSubsampleLBDTest, DISABLED_SubsampleLBD444SpeedTest) {
 303   subsampleSpeedTest(fun_444, fun_444_ref, &ACMRandom::Rand8);
 304 }
 305
 306 typedef cfl_subsample_hbd_fn (*get_subsample_hbd_fn)(TX_SIZE tx_size);
 307 typedef ::testing::tuple<TX_SIZE, get_subsample_hbd_fn, get_subsample_hbd_fn,
 308                          get_subsample_hbd_fn>
 309     subsample_hbd_param;
 310 class CFLSubsampleHBDTest
 311     : public CFLSubsampleTest<subsample_hbd_param, cfl_subsample_hbd_fn,
 312                               uint16_t> {
 313  public:
 314   virtual ~CFLSubsampleHBDTest() {}
 315   virtual void SetUp() {
 316     CFLSubsampleTest::SetUp();
 317     fun_420_ref = cfl_get_luma_subsampling_420_hbd_c(tx_size);
 318     fun_422_ref = cfl_get_luma_subsampling_422_hbd_c(tx_size);
 319     fun_444_ref = cfl_get_luma_subsampling_444_hbd_c(tx_size);
 320   }
 321 };
 322
 323 TEST_P(CFLSubsampleHBDTest, SubsampleHBD420Test) {
 324   subsampleTest(fun_420, fun_420_ref, width >> 1, height >> 1,
 325                 &ACMRandom::Rand12);
 326 }
 327
 328 TEST_P(CFLSubsampleHBDTest, DISABLED_SubsampleHBD420SpeedTest) {
 329   subsampleSpeedTest(fun_420, fun_420_ref, &ACMRandom::Rand12);
 330 }
 331
 332 TEST_P(CFLSubsampleHBDTest, SubsampleHBD422Test) {
 333   subsampleTest(fun_422, fun_422_ref, width >> 1, height, &ACMRandom::Rand12);
 334 }
 335
 336 TEST_P(CFLSubsampleHBDTest, DISABLED_SubsampleHBD422SpeedTest) {
 337   subsampleSpeedTest(fun_422, fun_422_ref, &ACMRandom::Rand12);
 338 }
 339
 340 TEST_P(CFLSubsampleHBDTest, SubsampleHBD444Test) {
 341   subsampleTest(fun_444, fun_444_ref, width, height, &ACMRandom::Rand12);
 342 }
 343
 344 TEST_P(CFLSubsampleHBDTest, DISABLED_SubsampleHBD444SpeedTest) {
 345   subsampleSpeedTest(fun_444, fun_444_ref, &ACMRandom::Rand12);
 346 }
 347
 348 typedef cfl_predict_lbd_fn (*get_predict_fn)(TX_SIZE tx_size);
 349 typedef ::testing::tuple<TX_SIZE, get_predict_fn> predict_param;
 350 class CFLPredictTest : public ::testing::TestWithParam<predict_param>,
 351                        public CFLTestWithAlignedData<uint8_t> {
 352  public:
 353   virtual void SetUp() {
 354     CFLTest::init(::testing::get<0>(this->GetParam()));
 355     predict = ::testing::get<1>(this->GetParam())(tx_size);
 356     predict_ref = get_predict_lbd_fn_c(tx_size);
 357   }
 358   virtual ~CFLPredictTest() {}
 359
 360  protected:
 361   cfl_predict_lbd_fn predict;
 362   cfl_predict_lbd_fn predict_ref;
 363 };
 364
 365 TEST_P(CFLPredictTest, PredictTest) {
 366   for (int it = 0; it < NUM_ITERATIONS; it++) {
 367     randData(8);
 368     predict(sub_luma_pels, chroma_pels, CFL_BUF_LINE, alpha_q3);
 369     predict_ref(sub_luma_pels_ref, chroma_pels_ref, CFL_BUF_LINE, alpha_q3);
 370     assert_eq<uint8_t>(chroma_pels, chroma_pels_ref, width, height);
 371   }
 372 }
 373 TEST_P(CFLPredictTest, DISABLED_PredictSpeedTest) {
 374   aom_usec_timer ref_timer;
 375   aom_usec_timer timer;
 376   randData(8);
 377   aom_usec_timer_start(&ref_timer);
 378   for (int k = 0; k < NUM_ITERATIONS_SPEED; k++) {
 379     predict_ref(sub_luma_pels_ref, chroma_pels_ref, CFL_BUF_LINE, alpha_q3);
 380   }
 381   aom_usec_timer_mark(&ref_timer);
 382   int ref_elapsed_time = (int)aom_usec_timer_elapsed(&ref_timer);
 383
 384   aom_usec_timer_start(&timer);
 385   for (int k = 0; k < NUM_ITERATIONS_SPEED; k++) {
 386     predict(sub_luma_pels, chroma_pels, CFL_BUF_LINE, alpha_q3);
 387   }
 388   aom_usec_timer_mark(&timer);
 389   int elapsed_time = (int)aom_usec_timer_elapsed(&timer);
 390   printSpeed(ref_elapsed_time, elapsed_time, width, height);
 391   assertFaster(ref_elapsed_time, elapsed_time);
 392 }
 393
 394 typedef cfl_predict_hbd_fn (*get_predict_fn_hbd)(TX_SIZE tx_size);
 395 typedef ::testing::tuple<TX_SIZE, get_predict_fn_hbd> predict_param_hbd;
 396 class CFLPredictHBDTest : public ::testing::TestWithParam<predict_param_hbd>,
 397                           public CFLTestWithAlignedData<uint16_t> {
 398  public:
 399   virtual void SetUp() {
 400     CFLTest::init(::testing::get<0>(this->GetParam()));
 401     predict = ::testing::get<1>(this->GetParam())(tx_size);
 402     predict_ref = get_predict_hbd_fn_c(tx_size);
 403   }
 404   virtual ~CFLPredictHBDTest() {}
 405
 406  protected:
 407   cfl_predict_hbd_fn predict;
 408   cfl_predict_hbd_fn predict_ref;
 409 };
 410
 411 TEST_P(CFLPredictHBDTest, PredictHBDTest) {
 412   int bd = 12;
 413   for (int it = 0; it < NUM_ITERATIONS; it++) {
 414     randData(bd);
 415     predict(sub_luma_pels, chroma_pels, CFL_BUF_LINE, alpha_q3, bd);
 416     predict_ref(sub_luma_pels_ref, chroma_pels_ref, CFL_BUF_LINE, alpha_q3, bd);
 417     assert_eq<uint16_t>(chroma_pels, chroma_pels_ref, width, height);
 418   }
 419 }
 420 TEST_P(CFLPredictHBDTest, DISABLED_PredictHBDSpeedTest) {
 421   aom_usec_timer ref_timer;
 422   aom_usec_timer timer;
 423   const int bd = 12;
 424   randData(bd);
 425   aom_usec_timer_start(&ref_timer);
 426   for (int k = 0; k < NUM_ITERATIONS_SPEED; k++) {
 427     predict_ref(sub_luma_pels_ref, chroma_pels_ref, CFL_BUF_LINE, alpha_q3, bd);
 428   }
 429   aom_usec_timer_mark(&ref_timer);
 430   int ref_elapsed_time = (int)aom_usec_timer_elapsed(&ref_timer);
 431
 432   aom_usec_timer_start(&timer);
 433   for (int k = 0; k < NUM_ITERATIONS_SPEED; k++) {
 434     predict(sub_luma_pels, chroma_pels, CFL_BUF_LINE, alpha_q3, bd);
 435   }
 436   aom_usec_timer_mark(&timer);
 437   int elapsed_time = (int)aom_usec_timer_elapsed(&timer);
 438   printSpeed(ref_elapsed_time, elapsed_time, width, height);
 439   assertFaster(ref_elapsed_time, elapsed_time);
 440 }
 441
 442 #if HAVE_SSE2
 443 const sub_avg_param sub_avg_sizes_sse2[] = { ALL_CFL_TX_SIZES(
 444     get_subtract_average_fn_sse2) };
 445
 446 INSTANTIATE_TEST_CASE_P(SSE2, CFLSubAvgTest,
 447                         ::testing::ValuesIn(sub_avg_sizes_sse2));
 448
 449 #endif
 450
 451 #if HAVE_SSSE3
 452 const subsample_lbd_param subsample_lbd_sizes_ssse3[] = {
 453   ALL_CFL_TX_SIZES_SUBSAMPLE(cfl_get_luma_subsampling_420_lbd_ssse3,
 454                              cfl_get_luma_subsampling_422_lbd_ssse3,
 455                              cfl_get_luma_subsampling_444_lbd_ssse3)
 456 };
 457
 458 const subsample_hbd_param subsample_hbd_sizes_ssse3[] = {
 459   ALL_CFL_TX_SIZES_SUBSAMPLE(cfl_get_luma_subsampling_420_hbd_ssse3,
 460                              cfl_get_luma_subsampling_422_hbd_ssse3,
 461                              cfl_get_luma_subsampling_444_hbd_ssse3)
 462 };
 463
 464 const predict_param predict_sizes_ssse3[] = { ALL_CFL_TX_SIZES(
 465     get_predict_lbd_fn_ssse3) };
 466
 467 const predict_param_hbd predict_sizes_hbd_ssse3[] = { ALL_CFL_TX_SIZES(
 468     get_predict_hbd_fn_ssse3) };
 469
 470 INSTANTIATE_TEST_CASE_P(SSSE3, CFLSubsampleLBDTest,
 471                         ::testing::ValuesIn(subsample_lbd_sizes_ssse3));
 472
 473 INSTANTIATE_TEST_CASE_P(SSSE3, CFLSubsampleHBDTest,
 474                         ::testing::ValuesIn(subsample_hbd_sizes_ssse3));
 475
 476 INSTANTIATE_TEST_CASE_P(SSSE3, CFLPredictTest,
 477                         ::testing::ValuesIn(predict_sizes_ssse3));
 478
 479 INSTANTIATE_TEST_CASE_P(SSSE3, CFLPredictHBDTest,
 480                         ::testing::ValuesIn(predict_sizes_hbd_ssse3));
 481 #endif
 482
 483 #if HAVE_AVX2
 484 const sub_avg_param sub_avg_sizes_avx2[] = { ALL_CFL_TX_SIZES(
 485     get_subtract_average_fn_avx2) };
 486
 487 const subsample_lbd_param subsample_lbd_sizes_avx2[] = {
 488   ALL_CFL_TX_SIZES_SUBSAMPLE(cfl_get_luma_subsampling_420_lbd_avx2,
 489                              cfl_get_luma_subsampling_422_lbd_avx2,
 490                              cfl_get_luma_subsampling_444_lbd_avx2)
 491 };
 492
 493 const subsample_hbd_param subsample_hbd_sizes_avx2[] = {
 494   ALL_CFL_TX_SIZES_SUBSAMPLE(cfl_get_luma_subsampling_420_hbd_avx2,
 495                              cfl_get_luma_subsampling_422_hbd_avx2,
 496                              cfl_get_luma_subsampling_444_hbd_avx2)
 497 };
 498
 499 const predict_param predict_sizes_avx2[] = { ALL_CFL_TX_SIZES(
 500     get_predict_lbd_fn_avx2) };
 501
 502 const predict_param_hbd predict_sizes_hbd_avx2[] = { ALL_CFL_TX_SIZES(
 503     get_predict_hbd_fn_avx2) };
 504
 505 INSTANTIATE_TEST_CASE_P(AVX2, CFLSubAvgTest,
 506                         ::testing::ValuesIn(sub_avg_sizes_avx2));
 507
 508 INSTANTIATE_TEST_CASE_P(AVX2, CFLSubsampleLBDTest,
 509                         ::testing::ValuesIn(subsample_lbd_sizes_avx2));
 510
 511 INSTANTIATE_TEST_CASE_P(AVX2, CFLSubsampleHBDTest,
 512                         ::testing::ValuesIn(subsample_hbd_sizes_avx2));
 513
 514 INSTANTIATE_TEST_CASE_P(AVX2, CFLPredictTest,
 515                         ::testing::ValuesIn(predict_sizes_avx2));
 516
 517 INSTANTIATE_TEST_CASE_P(AVX2, CFLPredictHBDTest,
 518                         ::testing::ValuesIn(predict_sizes_hbd_avx2));
 519 #endif
 520
 521 #if HAVE_NEON
 522
 523 const sub_avg_param sub_avg_sizes_neon[] = { ALL_CFL_TX_SIZES(
 524     get_subtract_average_fn_neon) };
 525
 526 const subsample_lbd_param subsample_lbd_sizes_neon[] = {
 527   ALL_CFL_TX_SIZES_SUBSAMPLE(cfl_get_luma_subsampling_420_lbd_neon,
 528                              cfl_get_luma_subsampling_422_lbd_neon,
 529                              cfl_get_luma_subsampling_444_lbd_neon)
 530 };
 531
 532 const subsample_hbd_param subsample_hbd_sizes_neon[] = {
 533   ALL_CFL_TX_SIZES_SUBSAMPLE(cfl_get_luma_subsampling_420_hbd_neon,
 534                              cfl_get_luma_subsampling_422_hbd_neon,
 535                              cfl_get_luma_subsampling_444_hbd_neon)
 536 };
 537
 538 const predict_param predict_sizes_neon[] = { ALL_CFL_TX_SIZES(
 539     get_predict_lbd_fn_neon) };
 540
 541 const predict_param_hbd predict_sizes_hbd_neon[] = { ALL_CFL_TX_SIZES(
 542     get_predict_hbd_fn_neon) };
 543
 544 INSTANTIATE_TEST_CASE_P(NEON, CFLSubAvgTest,
 545                         ::testing::ValuesIn(sub_avg_sizes_neon));
 546
 547 INSTANTIATE_TEST_CASE_P(NEON, CFLSubsampleLBDTest,
 548                         ::testing::ValuesIn(subsample_lbd_sizes_neon));
 549
 550 INSTANTIATE_TEST_CASE_P(NEON, CFLSubsampleHBDTest,
 551                         ::testing::ValuesIn(subsample_hbd_sizes_neon));
 552
 553 INSTANTIATE_TEST_CASE_P(NEON, CFLPredictTest,
 554                         ::testing::ValuesIn(predict_sizes_neon));
 555
 556 INSTANTIATE_TEST_CASE_P(NEON, CFLPredictHBDTest,
 557                         ::testing::ValuesIn(predict_sizes_hbd_neon));
 558 #endif
 559
 560 #if HAVE_VSX
 561 const sub_avg_param sub_avg_sizes_vsx[] = { ALL_CFL_TX_SIZES(
 562     get_subtract_average_fn_vsx) };
 563
 564 INSTANTIATE_TEST_CASE_P(VSX, CFLSubAvgTest,
 565                         ::testing::ValuesIn(sub_avg_sizes_vsx));
 566 #endif
 567 }  // namespace