summaryrefslogtreecommitdiff
path: root/media/libaom/src/test/sad_test.cc
diff options
context:
space:
mode:
Diffstat (limited to 'media/libaom/src/test/sad_test.cc')
-rw-r--r--media/libaom/src/test/sad_test.cc757
1 files changed, 605 insertions, 152 deletions
diff --git a/media/libaom/src/test/sad_test.cc b/media/libaom/src/test/sad_test.cc
index 845fe79da1..0bdbf37452 100644
--- a/media/libaom/src/test/sad_test.cc
+++ b/media/libaom/src/test/sad_test.cc
@@ -12,6 +12,7 @@
#include <string.h>
#include <limits.h>
#include <stdio.h>
+#include <tuple>
#include "third_party/googletest/src/googletest/include/gtest/gtest.h"
@@ -28,34 +29,42 @@
typedef unsigned int (*SadMxNFunc)(const uint8_t *src_ptr, int src_stride,
const uint8_t *ref_ptr, int ref_stride);
-typedef ::testing::tuple<int, int, SadMxNFunc, int> SadMxNParam;
+typedef std::tuple<int, int, SadMxNFunc, int> SadMxNParam;
typedef uint32_t (*SadMxNAvgFunc)(const uint8_t *src_ptr, int src_stride,
const uint8_t *ref_ptr, int ref_stride,
const uint8_t *second_pred);
-typedef ::testing::tuple<int, int, SadMxNAvgFunc, int> SadMxNAvgParam;
-
-typedef void (*JntCompAvgFunc)(uint8_t *comp_pred, const uint8_t *pred,
- int width, int height, const uint8_t *ref,
- int ref_stride,
- const JNT_COMP_PARAMS *jcp_param);
-typedef ::testing::tuple<int, int, JntCompAvgFunc, int> JntCompAvgParam;
-
-typedef unsigned int (*JntSadMxhFunc)(const uint8_t *src_ptr, int src_stride,
- const uint8_t *ref_ptr, int ref_stride,
- int width, int height);
-typedef ::testing::tuple<int, int, JntSadMxhFunc, int> JntSadMxhParam;
-
-typedef uint32_t (*JntSadMxNAvgFunc)(const uint8_t *src_ptr, int src_stride,
- const uint8_t *ref_ptr, int ref_stride,
- const uint8_t *second_pred,
- const JNT_COMP_PARAMS *jcp_param);
-typedef ::testing::tuple<int, int, JntSadMxNAvgFunc, int> JntSadMxNAvgParam;
+typedef std::tuple<int, int, SadMxNAvgFunc, int> SadMxNAvgParam;
+
+typedef void (*DistWtdCompAvgFunc)(uint8_t *comp_pred, const uint8_t *pred,
+ int width, int height, const uint8_t *ref,
+ int ref_stride,
+ const DIST_WTD_COMP_PARAMS *jcp_param);
+typedef std::tuple<int, int, DistWtdCompAvgFunc, int> DistWtdCompAvgParam;
+
+typedef unsigned int (*DistWtdSadMxhFunc)(const uint8_t *src_ptr,
+ int src_stride,
+ const uint8_t *ref_ptr,
+ int ref_stride, int width,
+ int height);
+typedef std::tuple<int, int, DistWtdSadMxhFunc, int> DistWtdSadMxhParam;
+
+typedef uint32_t (*DistWtdSadMxNAvgFunc)(const uint8_t *src_ptr, int src_stride,
+ const uint8_t *ref_ptr, int ref_stride,
+ const uint8_t *second_pred,
+ const DIST_WTD_COMP_PARAMS *jcp_param);
+typedef std::tuple<int, int, DistWtdSadMxNAvgFunc, int> DistWtdSadMxNAvgParam;
typedef void (*SadMxNx4Func)(const uint8_t *src_ptr, int src_stride,
const uint8_t *const ref_ptr[], int ref_stride,
uint32_t *sad_array);
-typedef ::testing::tuple<int, int, SadMxNx4Func, int> SadMxNx4Param;
+typedef std::tuple<int, int, SadMxNx4Func, int> SadMxNx4Param;
+
+typedef void (*SadMxNx4AvgFunc)(const uint8_t *src_ptr, int src_stride,
+ const uint8_t *const ref_ptr[], int ref_stride,
+ const uint8_t *second_pred,
+ uint32_t *sad_array);
+typedef std::tuple<int, int, SadMxNx4AvgFunc, int> SadMxNx4AvgParam;
using libaom_test::ACMRandom;
@@ -203,7 +212,7 @@ class SADTestBase : public ::testing::Test {
return sad;
}
- void ReferenceJntCompAvg(int block_idx) {
+ void ReferenceDistWtdCompAvg(int block_idx) {
const uint8_t *const reference8 = GetReference(block_idx);
const uint8_t *const second_pred8 = second_pred_;
uint8_t *const comp_pred8 = comp_pred_;
@@ -228,7 +237,7 @@ class SADTestBase : public ::testing::Test {
}
}
- unsigned int ReferenceJntSADavg(int block_idx) {
+ unsigned int ReferenceDistWtdSADavg(int block_idx) {
unsigned int sad = 0;
const uint8_t *const reference8 = GetReference(block_idx);
const uint8_t *const source8 = source_data_;
@@ -305,7 +314,7 @@ class SADTestBase : public ::testing::Test {
static uint8_t *comp_pred_test_;
static uint8_t *comp_pred8_test_;
static uint16_t *comp_pred16_test_;
- JNT_COMP_PARAMS jcp_param_;
+ DIST_WTD_COMP_PARAMS jcp_param_;
ACMRandom rnd_;
};
@@ -336,6 +345,42 @@ class SADx4Test : public ::testing::WithParamInterface<SadMxNx4Param>,
}
};
+class SADx4AvgTest : public ::testing::WithParamInterface<SadMxNx4AvgParam>,
+ public SADTestBase {
+ public:
+ SADx4AvgTest() : SADTestBase(GET_PARAM(0), GET_PARAM(1), GET_PARAM(3)) {}
+
+ protected:
+ void SADs(unsigned int *results) {
+ const uint8_t *references[] = { GetReference(0), GetReference(1),
+ GetReference(2), GetReference(3) };
+
+ ASM_REGISTER_STATE_CHECK(GET_PARAM(2)(source_data_, source_stride_,
+ references, reference_stride_,
+ second_pred_, results));
+ }
+
+ void CheckSADs() {
+ unsigned int reference_sad, exp_sad[4];
+
+ SADs(exp_sad);
+ for (int block = 0; block < 4; ++block) {
+ reference_sad = ReferenceSADavg(block);
+
+ EXPECT_EQ(reference_sad, exp_sad[block]) << "block " << block;
+ }
+ }
+
+ void SpeedSAD() {
+ int test_count = 200000;
+ unsigned int exp_sad[4];
+ while (test_count > 0) {
+ SADs(exp_sad);
+ test_count -= 1;
+ }
+ }
+};
+
class SADTest : public ::testing::WithParamInterface<SadMxNParam>,
public SADTestBase {
public:
@@ -391,13 +436,15 @@ class SADavgTest : public ::testing::WithParamInterface<SadMxNAvgParam>,
}
};
-class JntCompAvgTest : public ::testing::WithParamInterface<JntCompAvgParam>,
- public SADTestBase {
+class DistWtdCompAvgTest
+ : public ::testing::WithParamInterface<DistWtdCompAvgParam>,
+ public SADTestBase {
public:
- JntCompAvgTest() : SADTestBase(GET_PARAM(0), GET_PARAM(1), GET_PARAM(3)) {}
+ DistWtdCompAvgTest()
+ : SADTestBase(GET_PARAM(0), GET_PARAM(1), GET_PARAM(3)) {}
protected:
- void jnt_comp_avg(int block_idx) {
+ void dist_wtd_comp_avg(int block_idx) {
const uint8_t *const reference = GetReference(block_idx);
ASM_REGISTER_STATE_CHECK(GET_PARAM(2)(comp_pred_test_, second_pred_, width_,
@@ -411,8 +458,8 @@ class JntCompAvgTest : public ::testing::WithParamInterface<JntCompAvgParam>,
jcp_param_.fwd_offset = quant_dist_lookup_table[j][i][0];
jcp_param_.bck_offset = quant_dist_lookup_table[j][i][1];
- ReferenceJntCompAvg(0);
- jnt_comp_avg(0);
+ ReferenceDistWtdCompAvg(0);
+ dist_wtd_comp_avg(0);
for (int y = 0; y < height_; ++y)
for (int x = 0; x < width_; ++x)
@@ -423,10 +470,10 @@ class JntCompAvgTest : public ::testing::WithParamInterface<JntCompAvgParam>,
}
};
-class JntSADTest : public ::testing::WithParamInterface<JntSadMxhParam>,
- public SADTestBase {
+class DistWtdSADTest : public ::testing::WithParamInterface<DistWtdSadMxhParam>,
+ public SADTestBase {
public:
- JntSADTest() : SADTestBase(GET_PARAM(0), GET_PARAM(1), GET_PARAM(3)) {}
+ DistWtdSADTest() : SADTestBase(GET_PARAM(0), GET_PARAM(1), GET_PARAM(3)) {}
protected:
unsigned int SAD(int block_idx) {
@@ -455,13 +502,14 @@ class JntSADTest : public ::testing::WithParamInterface<JntSadMxhParam>,
}
};
-class JntSADavgTest : public ::testing::WithParamInterface<JntSadMxNAvgParam>,
- public SADTestBase {
+class DistWtdSADavgTest
+ : public ::testing::WithParamInterface<DistWtdSadMxNAvgParam>,
+ public SADTestBase {
public:
- JntSADavgTest() : SADTestBase(GET_PARAM(0), GET_PARAM(1), GET_PARAM(3)) {}
+ DistWtdSADavgTest() : SADTestBase(GET_PARAM(0), GET_PARAM(1), GET_PARAM(3)) {}
protected:
- unsigned int jnt_SAD_avg(int block_idx) {
+ unsigned int dist_wtd_SAD_avg(int block_idx) {
unsigned int ret;
const uint8_t *const reference = GetReference(block_idx);
@@ -477,8 +525,8 @@ class JntSADavgTest : public ::testing::WithParamInterface<JntSadMxNAvgParam>,
jcp_param_.fwd_offset = quant_dist_lookup_table[j][i][0];
jcp_param_.bck_offset = quant_dist_lookup_table[j][i][1];
- const unsigned int reference_sad = ReferenceJntSADavg(0);
- const unsigned int exp_sad = jnt_SAD_avg(0);
+ const unsigned int reference_sad = ReferenceDistWtdSADavg(0);
+ const unsigned int exp_sad = dist_wtd_SAD_avg(0);
ASSERT_EQ(reference_sad, exp_sad);
}
@@ -608,19 +656,19 @@ TEST_P(SADavgTest, ShortSrc) {
source_stride_ = tmp_stride;
}
-TEST_P(JntCompAvgTest, MaxRef) {
+TEST_P(DistWtdCompAvgTest, MaxRef) {
FillConstant(reference_data_, reference_stride_, mask_);
FillConstant(second_pred_, width_, 0);
CheckCompAvg();
}
-TEST_P(JntCompAvgTest, MaxSecondPred) {
+TEST_P(DistWtdCompAvgTest, MaxSecondPred) {
FillConstant(reference_data_, reference_stride_, 0);
FillConstant(second_pred_, width_, mask_);
CheckCompAvg();
}
-TEST_P(JntCompAvgTest, ShortRef) {
+TEST_P(DistWtdCompAvgTest, ShortRef) {
const int tmp_stride = reference_stride_;
reference_stride_ >>= 1;
FillRandom(reference_data_, reference_stride_);
@@ -629,7 +677,7 @@ TEST_P(JntCompAvgTest, ShortRef) {
reference_stride_ = tmp_stride;
}
-TEST_P(JntCompAvgTest, UnalignedRef) {
+TEST_P(DistWtdCompAvgTest, UnalignedRef) {
// The reference frame, but not the source frame, may be unaligned for
// certain types of searches.
const int tmp_stride = reference_stride_;
@@ -640,19 +688,19 @@ TEST_P(JntCompAvgTest, UnalignedRef) {
reference_stride_ = tmp_stride;
}
-TEST_P(JntSADTest, MaxRef) {
+TEST_P(DistWtdSADTest, MaxRef) {
FillConstant(source_data_, source_stride_, 0);
FillConstant(reference_data_, reference_stride_, mask_);
CheckSAD();
}
-TEST_P(JntSADTest, MaxSrc) {
+TEST_P(DistWtdSADTest, MaxSrc) {
FillConstant(source_data_, source_stride_, mask_);
FillConstant(reference_data_, reference_stride_, 0);
CheckSAD();
}
-TEST_P(JntSADTest, ShortRef) {
+TEST_P(DistWtdSADTest, ShortRef) {
const int tmp_stride = reference_stride_;
reference_stride_ >>= 1;
FillRandom(source_data_, source_stride_);
@@ -661,7 +709,7 @@ TEST_P(JntSADTest, ShortRef) {
reference_stride_ = tmp_stride;
}
-TEST_P(JntSADTest, UnalignedRef) {
+TEST_P(DistWtdSADTest, UnalignedRef) {
// The reference frame, but not the source frame, may be unaligned for
// certain types of searches.
const int tmp_stride = reference_stride_;
@@ -672,7 +720,7 @@ TEST_P(JntSADTest, UnalignedRef) {
reference_stride_ = tmp_stride;
}
-TEST_P(JntSADTest, ShortSrc) {
+TEST_P(DistWtdSADTest, ShortSrc) {
const int tmp_stride = source_stride_;
source_stride_ >>= 1;
int test_count = 2000;
@@ -685,20 +733,20 @@ TEST_P(JntSADTest, ShortSrc) {
source_stride_ = tmp_stride;
}
-TEST_P(JntSADavgTest, MaxRef) {
+TEST_P(DistWtdSADavgTest, MaxRef) {
FillConstant(source_data_, source_stride_, 0);
FillConstant(reference_data_, reference_stride_, mask_);
FillConstant(second_pred_, width_, 0);
CheckSAD();
}
-TEST_P(JntSADavgTest, MaxSrc) {
+TEST_P(DistWtdSADavgTest, MaxSrc) {
FillConstant(source_data_, source_stride_, mask_);
FillConstant(reference_data_, reference_stride_, 0);
FillConstant(second_pred_, width_, 0);
CheckSAD();
}
-TEST_P(JntSADavgTest, ShortRef) {
+TEST_P(DistWtdSADavgTest, ShortRef) {
const int tmp_stride = reference_stride_;
reference_stride_ >>= 1;
FillRandom(source_data_, source_stride_);
@@ -708,7 +756,7 @@ TEST_P(JntSADavgTest, ShortRef) {
reference_stride_ = tmp_stride;
}
-TEST_P(JntSADavgTest, UnalignedRef) {
+TEST_P(DistWtdSADavgTest, UnalignedRef) {
// The reference frame, but not the source frame, may be unaligned for
// certain types of searches.
const int tmp_stride = reference_stride_;
@@ -720,7 +768,7 @@ TEST_P(JntSADavgTest, UnalignedRef) {
reference_stride_ = tmp_stride;
}
-TEST_P(JntSADavgTest, ShortSrc) {
+TEST_P(DistWtdSADavgTest, ShortSrc) {
const int tmp_stride = source_stride_;
source_stride_ >>= 1;
int test_count = 2000;
@@ -806,7 +854,70 @@ TEST_P(SADx4Test, SrcAlignedByWidth) {
source_data_ = tmp_source_data;
}
-using ::testing::make_tuple;
+using std::make_tuple;
+
+#if SPEED_TEST
+TEST_P(SADx4AvgTest, Speed) {
+ int tmp_stride = reference_stride_;
+ reference_stride_ >>= 1;
+ FillRandom(source_data_, source_stride_);
+ FillRandom(GetReference(0), reference_stride_);
+ FillRandom(GetReference(1), reference_stride_);
+ FillRandom(GetReference(2), reference_stride_);
+ FillRandom(GetReference(3), reference_stride_);
+ FillRandom(second_pred_, width_);
+ SpeedSAD();
+ reference_stride_ = tmp_stride;
+}
+#endif
+
+TEST_P(SADx4AvgTest, MaxRef) {
+ FillConstant(source_data_, source_stride_, 0);
+ FillConstant(GetReference(0), reference_stride_, mask_);
+ FillConstant(GetReference(1), reference_stride_, mask_);
+ FillConstant(GetReference(2), reference_stride_, mask_);
+ FillConstant(GetReference(3), reference_stride_, mask_);
+ FillConstant(second_pred_, width_, 0);
+ CheckSADs();
+}
+
+TEST_P(SADx4AvgTest, MaxSrc) {
+ FillConstant(source_data_, source_stride_, mask_);
+ FillConstant(GetReference(0), reference_stride_, 0);
+ FillConstant(GetReference(1), reference_stride_, 0);
+ FillConstant(GetReference(2), reference_stride_, 0);
+ FillConstant(GetReference(3), reference_stride_, 0);
+ FillConstant(second_pred_, width_, 0);
+ CheckSADs();
+}
+
+TEST_P(SADx4AvgTest, ShortRef) {
+ int tmp_stride = reference_stride_;
+ reference_stride_ >>= 1;
+ FillRandom(source_data_, source_stride_);
+ FillRandom(GetReference(0), reference_stride_);
+ FillRandom(GetReference(1), reference_stride_);
+ FillRandom(GetReference(2), reference_stride_);
+ FillRandom(GetReference(3), reference_stride_);
+ FillRandom(second_pred_, width_);
+ CheckSADs();
+ reference_stride_ = tmp_stride;
+}
+
+TEST_P(SADx4AvgTest, UnalignedRef) {
+ // The reference frame, but not the source frame, may be unaligned for
+ // certain types of searches.
+ int tmp_stride = reference_stride_;
+ reference_stride_ -= 1;
+ FillRandom(source_data_, source_stride_);
+ FillRandom(GetReference(0), reference_stride_);
+ FillRandom(GetReference(1), reference_stride_);
+ FillRandom(GetReference(2), reference_stride_);
+ FillRandom(GetReference(3), reference_stride_);
+ FillRandom(second_pred_, width_);
+ CheckSADs();
+ reference_stride_ = tmp_stride;
+}
//------------------------------------------------------------------------------
// C functions
@@ -827,6 +938,7 @@ const SadMxNParam c_tests[] = {
make_tuple(8, 4, &aom_sad8x4_c, -1),
make_tuple(4, 8, &aom_sad4x8_c, -1),
make_tuple(4, 4, &aom_sad4x4_c, -1),
+#if CONFIG_AV1_HIGHBITDEPTH
make_tuple(128, 128, &aom_highbd_sad128x128_c, 8),
make_tuple(128, 64, &aom_highbd_sad128x64_c, 8),
make_tuple(64, 128, &aom_highbd_sad64x128_c, 8),
@@ -875,8 +987,39 @@ const SadMxNParam c_tests[] = {
make_tuple(8, 4, &aom_highbd_sad8x4_c, 12),
make_tuple(4, 8, &aom_highbd_sad4x8_c, 12),
make_tuple(4, 4, &aom_highbd_sad4x4_c, 12),
+#endif // CONFIG_AV1_HIGHBITDEPTH
+ make_tuple(64, 16, &aom_sad64x16_c, -1),
+ make_tuple(16, 64, &aom_sad16x64_c, -1),
+#if CONFIG_AV1_HIGHBITDEPTH
+ make_tuple(64, 16, &aom_highbd_sad64x16_c, 8),
+ make_tuple(16, 64, &aom_highbd_sad16x64_c, 8),
+ make_tuple(64, 16, &aom_highbd_sad64x16_c, 10),
+ make_tuple(16, 64, &aom_highbd_sad16x64_c, 10),
+ make_tuple(64, 16, &aom_highbd_sad64x16_c, 12),
+ make_tuple(16, 64, &aom_highbd_sad16x64_c, 12),
+#endif
+ make_tuple(32, 8, &aom_sad32x8_c, -1),
+ make_tuple(8, 32, &aom_sad8x32_c, -1),
+#if CONFIG_AV1_HIGHBITDEPTH
+ make_tuple(32, 8, &aom_highbd_sad32x8_c, 8),
+ make_tuple(8, 32, &aom_highbd_sad8x32_c, 8),
+ make_tuple(32, 8, &aom_highbd_sad32x8_c, 10),
+ make_tuple(8, 32, &aom_highbd_sad8x32_c, 10),
+ make_tuple(32, 8, &aom_highbd_sad32x8_c, 12),
+ make_tuple(8, 32, &aom_highbd_sad8x32_c, 12),
+#endif
+ make_tuple(16, 4, &aom_sad16x4_c, -1),
+ make_tuple(4, 16, &aom_sad4x16_c, -1),
+#if CONFIG_AV1_HIGHBITDEPTH
+ make_tuple(16, 4, &aom_highbd_sad16x4_c, 8),
+ make_tuple(4, 16, &aom_highbd_sad4x16_c, 8),
+ make_tuple(16, 4, &aom_highbd_sad16x4_c, 10),
+ make_tuple(4, 16, &aom_highbd_sad4x16_c, 10),
+ make_tuple(16, 4, &aom_highbd_sad16x4_c, 12),
+ make_tuple(4, 16, &aom_highbd_sad4x16_c, 12),
+#endif
};
-INSTANTIATE_TEST_CASE_P(C, SADTest, ::testing::ValuesIn(c_tests));
+INSTANTIATE_TEST_SUITE_P(C, SADTest, ::testing::ValuesIn(c_tests));
const SadMxNAvgParam avg_c_tests[] = {
make_tuple(128, 128, &aom_sad128x128_avg_c, -1),
@@ -895,6 +1038,7 @@ const SadMxNAvgParam avg_c_tests[] = {
make_tuple(8, 4, &aom_sad8x4_avg_c, -1),
make_tuple(4, 8, &aom_sad4x8_avg_c, -1),
make_tuple(4, 4, &aom_sad4x4_avg_c, -1),
+#if CONFIG_AV1_HIGHBITDEPTH
make_tuple(128, 128, &aom_highbd_sad128x128_avg_c, 8),
make_tuple(128, 64, &aom_highbd_sad128x64_avg_c, 8),
make_tuple(64, 128, &aom_highbd_sad64x128_avg_c, 8),
@@ -943,51 +1087,98 @@ const SadMxNAvgParam avg_c_tests[] = {
make_tuple(8, 4, &aom_highbd_sad8x4_avg_c, 12),
make_tuple(4, 8, &aom_highbd_sad4x8_avg_c, 12),
make_tuple(4, 4, &aom_highbd_sad4x4_avg_c, 12),
+#endif // CONFIG_AV1_HIGHBITDEPTH
+ make_tuple(64, 16, &aom_sad64x16_avg_c, -1),
+ make_tuple(16, 64, &aom_sad16x64_avg_c, -1),
+#if CONFIG_AV1_HIGHBITDEPTH
+ make_tuple(64, 16, &aom_highbd_sad64x16_avg_c, 8),
+ make_tuple(16, 64, &aom_highbd_sad16x64_avg_c, 8),
+ make_tuple(64, 16, &aom_highbd_sad64x16_avg_c, 10),
+ make_tuple(16, 64, &aom_highbd_sad16x64_avg_c, 10),
+ make_tuple(64, 16, &aom_highbd_sad64x16_avg_c, 12),
+ make_tuple(16, 64, &aom_highbd_sad16x64_avg_c, 12),
+#endif
+ make_tuple(32, 8, &aom_sad32x8_avg_c, -1),
+ make_tuple(8, 32, &aom_sad8x32_avg_c, -1),
+#if CONFIG_AV1_HIGHBITDEPTH
+ make_tuple(32, 8, &aom_highbd_sad32x8_avg_c, 8),
+ make_tuple(8, 32, &aom_highbd_sad8x32_avg_c, 8),
+ make_tuple(32, 8, &aom_highbd_sad32x8_avg_c, 10),
+ make_tuple(8, 32, &aom_highbd_sad8x32_avg_c, 10),
+ make_tuple(32, 8, &aom_highbd_sad32x8_avg_c, 12),
+ make_tuple(8, 32, &aom_highbd_sad8x32_avg_c, 12),
+#endif
+ make_tuple(16, 4, &aom_sad16x4_avg_c, -1),
+ make_tuple(4, 16, &aom_sad4x16_avg_c, -1),
+#if CONFIG_AV1_HIGHBITDEPTH
+ make_tuple(16, 4, &aom_highbd_sad16x4_avg_c, 8),
+ make_tuple(4, 16, &aom_highbd_sad4x16_avg_c, 8),
+ make_tuple(16, 4, &aom_highbd_sad16x4_avg_c, 10),
+ make_tuple(4, 16, &aom_highbd_sad4x16_avg_c, 10),
+ make_tuple(16, 4, &aom_highbd_sad16x4_avg_c, 12),
+ make_tuple(4, 16, &aom_highbd_sad4x16_avg_c, 12),
+#endif
};
-INSTANTIATE_TEST_CASE_P(C, SADavgTest, ::testing::ValuesIn(avg_c_tests));
+INSTANTIATE_TEST_SUITE_P(C, SADavgTest, ::testing::ValuesIn(avg_c_tests));
// TODO(chengchen): add highbd tests
-const JntCompAvgParam jnt_comp_avg_c_tests[] = {
- make_tuple(128, 128, &aom_jnt_comp_avg_pred_c, -1),
- make_tuple(128, 64, &aom_jnt_comp_avg_pred_c, -1),
- make_tuple(64, 128, &aom_jnt_comp_avg_pred_c, -1),
- make_tuple(64, 64, &aom_jnt_comp_avg_pred_c, -1),
- make_tuple(64, 32, &aom_jnt_comp_avg_pred_c, -1),
- make_tuple(32, 64, &aom_jnt_comp_avg_pred_c, -1),
- make_tuple(32, 32, &aom_jnt_comp_avg_pred_c, -1),
- make_tuple(32, 16, &aom_jnt_comp_avg_pred_c, -1),
- make_tuple(16, 32, &aom_jnt_comp_avg_pred_c, -1),
- make_tuple(16, 16, &aom_jnt_comp_avg_pred_c, -1),
- make_tuple(16, 8, &aom_jnt_comp_avg_pred_c, -1),
- make_tuple(8, 16, &aom_jnt_comp_avg_pred_c, -1),
- make_tuple(8, 8, &aom_jnt_comp_avg_pred_c, -1),
- make_tuple(8, 4, &aom_jnt_comp_avg_pred_c, -1),
- make_tuple(4, 8, &aom_jnt_comp_avg_pred_c, -1),
- make_tuple(4, 4, &aom_jnt_comp_avg_pred_c, -1),
+const DistWtdCompAvgParam dist_wtd_comp_avg_c_tests[] = {
+ make_tuple(128, 128, &aom_dist_wtd_comp_avg_pred_c, -1),
+ make_tuple(128, 64, &aom_dist_wtd_comp_avg_pred_c, -1),
+ make_tuple(64, 128, &aom_dist_wtd_comp_avg_pred_c, -1),
+ make_tuple(64, 64, &aom_dist_wtd_comp_avg_pred_c, -1),
+ make_tuple(64, 32, &aom_dist_wtd_comp_avg_pred_c, -1),
+ make_tuple(32, 64, &aom_dist_wtd_comp_avg_pred_c, -1),
+ make_tuple(32, 32, &aom_dist_wtd_comp_avg_pred_c, -1),
+ make_tuple(32, 16, &aom_dist_wtd_comp_avg_pred_c, -1),
+ make_tuple(16, 32, &aom_dist_wtd_comp_avg_pred_c, -1),
+ make_tuple(16, 16, &aom_dist_wtd_comp_avg_pred_c, -1),
+ make_tuple(16, 8, &aom_dist_wtd_comp_avg_pred_c, -1),
+ make_tuple(8, 16, &aom_dist_wtd_comp_avg_pred_c, -1),
+ make_tuple(8, 8, &aom_dist_wtd_comp_avg_pred_c, -1),
+ make_tuple(8, 4, &aom_dist_wtd_comp_avg_pred_c, -1),
+ make_tuple(4, 8, &aom_dist_wtd_comp_avg_pred_c, -1),
+ make_tuple(4, 4, &aom_dist_wtd_comp_avg_pred_c, -1),
+
+ make_tuple(64, 16, &aom_dist_wtd_comp_avg_pred_c, -1),
+ make_tuple(16, 64, &aom_dist_wtd_comp_avg_pred_c, -1),
+ make_tuple(32, 8, &aom_dist_wtd_comp_avg_pred_c, -1),
+ make_tuple(8, 32, &aom_dist_wtd_comp_avg_pred_c, -1),
+ make_tuple(16, 4, &aom_dist_wtd_comp_avg_pred_c, -1),
+ make_tuple(4, 16, &aom_dist_wtd_comp_avg_pred_c, -1),
};
-INSTANTIATE_TEST_CASE_P(C, JntCompAvgTest,
- ::testing::ValuesIn(jnt_comp_avg_c_tests));
-
-const JntSadMxNAvgParam jnt_avg_c_tests[] = {
- make_tuple(128, 128, &aom_jnt_sad128x128_avg_c, -1),
- make_tuple(128, 64, &aom_jnt_sad128x64_avg_c, -1),
- make_tuple(64, 128, &aom_jnt_sad64x128_avg_c, -1),
- make_tuple(64, 64, &aom_jnt_sad64x64_avg_c, -1),
- make_tuple(64, 32, &aom_jnt_sad64x32_avg_c, -1),
- make_tuple(32, 64, &aom_jnt_sad32x64_avg_c, -1),
- make_tuple(32, 32, &aom_jnt_sad32x32_avg_c, -1),
- make_tuple(32, 16, &aom_jnt_sad32x16_avg_c, -1),
- make_tuple(16, 32, &aom_jnt_sad16x32_avg_c, -1),
- make_tuple(16, 16, &aom_jnt_sad16x16_avg_c, -1),
- make_tuple(16, 8, &aom_jnt_sad16x8_avg_c, -1),
- make_tuple(8, 16, &aom_jnt_sad8x16_avg_c, -1),
- make_tuple(8, 8, &aom_jnt_sad8x8_avg_c, -1),
- make_tuple(8, 4, &aom_jnt_sad8x4_avg_c, -1),
- make_tuple(4, 8, &aom_jnt_sad4x8_avg_c, -1),
- make_tuple(4, 4, &aom_jnt_sad4x4_avg_c, -1),
+INSTANTIATE_TEST_SUITE_P(C, DistWtdCompAvgTest,
+ ::testing::ValuesIn(dist_wtd_comp_avg_c_tests));
+
+const DistWtdSadMxNAvgParam dist_wtd_avg_c_tests[] = {
+ make_tuple(128, 128, &aom_dist_wtd_sad128x128_avg_c, -1),
+ make_tuple(128, 64, &aom_dist_wtd_sad128x64_avg_c, -1),
+ make_tuple(64, 128, &aom_dist_wtd_sad64x128_avg_c, -1),
+ make_tuple(64, 64, &aom_dist_wtd_sad64x64_avg_c, -1),
+ make_tuple(64, 32, &aom_dist_wtd_sad64x32_avg_c, -1),
+ make_tuple(32, 64, &aom_dist_wtd_sad32x64_avg_c, -1),
+ make_tuple(32, 32, &aom_dist_wtd_sad32x32_avg_c, -1),
+ make_tuple(32, 16, &aom_dist_wtd_sad32x16_avg_c, -1),
+ make_tuple(16, 32, &aom_dist_wtd_sad16x32_avg_c, -1),
+ make_tuple(16, 16, &aom_dist_wtd_sad16x16_avg_c, -1),
+ make_tuple(16, 8, &aom_dist_wtd_sad16x8_avg_c, -1),
+ make_tuple(8, 16, &aom_dist_wtd_sad8x16_avg_c, -1),
+ make_tuple(8, 8, &aom_dist_wtd_sad8x8_avg_c, -1),
+ make_tuple(8, 4, &aom_dist_wtd_sad8x4_avg_c, -1),
+ make_tuple(4, 8, &aom_dist_wtd_sad4x8_avg_c, -1),
+ make_tuple(4, 4, &aom_dist_wtd_sad4x4_avg_c, -1),
+
+ make_tuple(64, 16, &aom_dist_wtd_sad64x16_avg_c, -1),
+ make_tuple(16, 64, &aom_dist_wtd_sad16x64_avg_c, -1),
+ make_tuple(32, 8, &aom_dist_wtd_sad32x8_avg_c, -1),
+ make_tuple(8, 32, &aom_dist_wtd_sad8x32_avg_c, -1),
+ make_tuple(16, 4, &aom_dist_wtd_sad16x4_avg_c, -1),
+ make_tuple(4, 16, &aom_dist_wtd_sad4x16_avg_c, -1),
};
-INSTANTIATE_TEST_CASE_P(C, JntSADavgTest, ::testing::ValuesIn(jnt_avg_c_tests));
+
+INSTANTIATE_TEST_SUITE_P(C, DistWtdSADavgTest,
+ ::testing::ValuesIn(dist_wtd_avg_c_tests));
const SadMxNx4Param x4d_c_tests[] = {
make_tuple(128, 128, &aom_sad128x128x4d_c, -1),
@@ -1006,6 +1197,7 @@ const SadMxNx4Param x4d_c_tests[] = {
make_tuple(8, 4, &aom_sad8x4x4d_c, -1),
make_tuple(4, 8, &aom_sad4x8x4d_c, -1),
make_tuple(4, 4, &aom_sad4x4x4d_c, -1),
+#if CONFIG_AV1_HIGHBITDEPTH
make_tuple(128, 128, &aom_highbd_sad128x128x4d_c, 8),
make_tuple(128, 64, &aom_highbd_sad128x64x4d_c, 8),
make_tuple(64, 128, &aom_highbd_sad64x128x4d_c, 8),
@@ -1054,8 +1246,65 @@ const SadMxNx4Param x4d_c_tests[] = {
make_tuple(8, 4, &aom_highbd_sad8x4x4d_c, 12),
make_tuple(4, 8, &aom_highbd_sad4x8x4d_c, 12),
make_tuple(4, 4, &aom_highbd_sad4x4x4d_c, 12),
+#endif
+ make_tuple(64, 16, &aom_sad64x16x4d_c, -1),
+ make_tuple(16, 64, &aom_sad16x64x4d_c, -1),
+#if CONFIG_AV1_HIGHBITDEPTH
+ make_tuple(64, 16, &aom_highbd_sad64x16x4d_c, 8),
+ make_tuple(16, 64, &aom_highbd_sad16x64x4d_c, 8),
+ make_tuple(64, 16, &aom_highbd_sad64x16x4d_c, 10),
+ make_tuple(16, 64, &aom_highbd_sad16x64x4d_c, 10),
+ make_tuple(64, 16, &aom_highbd_sad64x16x4d_c, 12),
+ make_tuple(16, 64, &aom_highbd_sad16x64x4d_c, 12),
+#endif
+ make_tuple(32, 8, &aom_sad32x8x4d_c, -1),
+ make_tuple(8, 32, &aom_sad8x32x4d_c, -1),
+#if CONFIG_AV1_HIGHBITDEPTH
+ make_tuple(32, 8, &aom_highbd_sad32x8x4d_c, 8),
+ make_tuple(8, 32, &aom_highbd_sad8x32x4d_c, 8),
+ make_tuple(32, 8, &aom_highbd_sad32x8x4d_c, 10),
+ make_tuple(8, 32, &aom_highbd_sad8x32x4d_c, 10),
+ make_tuple(32, 8, &aom_highbd_sad32x8x4d_c, 12),
+ make_tuple(8, 32, &aom_highbd_sad8x32x4d_c, 12),
+#endif
+ make_tuple(16, 4, &aom_sad16x4x4d_c, -1),
+ make_tuple(4, 16, &aom_sad4x16x4d_c, -1),
+#if CONFIG_AV1_HIGHBITDEPTH
+ make_tuple(16, 4, &aom_highbd_sad16x4x4d_c, 8),
+ make_tuple(4, 16, &aom_highbd_sad4x16x4d_c, 8),
+ make_tuple(16, 4, &aom_highbd_sad16x4x4d_c, 10),
+ make_tuple(4, 16, &aom_highbd_sad4x16x4d_c, 10),
+ make_tuple(16, 4, &aom_highbd_sad16x4x4d_c, 12),
+ make_tuple(4, 16, &aom_highbd_sad4x16x4d_c, 12),
+#endif
+};
+INSTANTIATE_TEST_SUITE_P(C, SADx4Test, ::testing::ValuesIn(x4d_c_tests));
+
+const SadMxNx4AvgParam x4d_avg_c_tests[] = {
+ make_tuple(128, 128, &aom_sad128x128x4d_avg_c, -1),
+ make_tuple(128, 64, &aom_sad128x64x4d_avg_c, -1),
+ make_tuple(64, 128, &aom_sad64x128x4d_avg_c, -1),
+ make_tuple(64, 64, &aom_sad64x64x4d_avg_c, -1),
+ make_tuple(64, 32, &aom_sad64x32x4d_avg_c, -1),
+ make_tuple(32, 64, &aom_sad32x64x4d_avg_c, -1),
+ make_tuple(32, 32, &aom_sad32x32x4d_avg_c, -1),
+ make_tuple(32, 16, &aom_sad32x16x4d_avg_c, -1),
+ make_tuple(16, 32, &aom_sad16x32x4d_avg_c, -1),
+ make_tuple(16, 16, &aom_sad16x16x4d_avg_c, -1),
+ make_tuple(16, 8, &aom_sad16x8x4d_avg_c, -1),
+ make_tuple(8, 16, &aom_sad8x16x4d_avg_c, -1),
+ make_tuple(8, 8, &aom_sad8x8x4d_avg_c, -1),
+ make_tuple(8, 4, &aom_sad8x4x4d_avg_c, -1),
+ make_tuple(4, 8, &aom_sad4x8x4d_avg_c, -1),
+ make_tuple(4, 4, &aom_sad4x4x4d_avg_c, -1),
+ make_tuple(64, 16, &aom_sad64x16x4d_avg_c, -1),
+ make_tuple(16, 64, &aom_sad16x64x4d_avg_c, -1),
+ make_tuple(32, 8, &aom_sad32x8x4d_avg_c, -1),
+ make_tuple(8, 32, &aom_sad8x32x4d_avg_c, -1),
+ make_tuple(16, 4, &aom_sad16x4x4d_avg_c, -1),
+ make_tuple(4, 16, &aom_sad4x16x4d_avg_c, -1),
};
-INSTANTIATE_TEST_CASE_P(C, SADx4Test, ::testing::ValuesIn(x4d_c_tests));
+INSTANTIATE_TEST_SUITE_P(C, SADx4AvgTest, ::testing::ValuesIn(x4d_avg_c_tests));
//------------------------------------------------------------------------------
// ARM functions
@@ -1069,14 +1318,14 @@ const SadMxNParam neon_tests[] = {
make_tuple(8, 8, &aom_sad8x8_neon, -1),
make_tuple(4, 4, &aom_sad4x4_neon, -1),
};
-INSTANTIATE_TEST_CASE_P(NEON, SADTest, ::testing::ValuesIn(neon_tests));
+INSTANTIATE_TEST_SUITE_P(NEON, SADTest, ::testing::ValuesIn(neon_tests));
const SadMxNx4Param x4d_neon_tests[] = {
make_tuple(64, 64, &aom_sad64x64x4d_neon, -1),
make_tuple(32, 32, &aom_sad32x32x4d_neon, -1),
make_tuple(16, 16, &aom_sad16x16x4d_neon, -1),
};
-INSTANTIATE_TEST_CASE_P(NEON, SADx4Test, ::testing::ValuesIn(x4d_neon_tests));
+INSTANTIATE_TEST_SUITE_P(NEON, SADx4Test, ::testing::ValuesIn(x4d_neon_tests));
#endif // HAVE_NEON
//------------------------------------------------------------------------------
@@ -1099,6 +1348,7 @@ const SadMxNParam sse2_tests[] = {
make_tuple(8, 4, &aom_sad8x4_sse2, -1),
make_tuple(4, 8, &aom_sad4x8_sse2, -1),
make_tuple(4, 4, &aom_sad4x4_sse2, -1),
+#if CONFIG_AV1_HIGHBITDEPTH
make_tuple(64, 64, &aom_highbd_sad64x64_sse2, 8),
make_tuple(64, 32, &aom_highbd_sad64x32_sse2, 8),
make_tuple(32, 64, &aom_highbd_sad32x64_sse2, 8),
@@ -1110,6 +1360,8 @@ const SadMxNParam sse2_tests[] = {
make_tuple(8, 16, &aom_highbd_sad8x16_sse2, 8),
make_tuple(8, 8, &aom_highbd_sad8x8_sse2, 8),
make_tuple(8, 4, &aom_highbd_sad8x4_sse2, 8),
+ make_tuple(4, 8, &aom_highbd_sad4x8_sse2, 8),
+ make_tuple(4, 4, &aom_highbd_sad4x4_sse2, 8),
make_tuple(64, 64, &aom_highbd_sad64x64_sse2, 10),
make_tuple(64, 32, &aom_highbd_sad64x32_sse2, 10),
make_tuple(32, 64, &aom_highbd_sad32x64_sse2, 10),
@@ -1121,6 +1373,8 @@ const SadMxNParam sse2_tests[] = {
make_tuple(8, 16, &aom_highbd_sad8x16_sse2, 10),
make_tuple(8, 8, &aom_highbd_sad8x8_sse2, 10),
make_tuple(8, 4, &aom_highbd_sad8x4_sse2, 10),
+ make_tuple(4, 8, &aom_highbd_sad4x8_sse2, 10),
+ make_tuple(4, 4, &aom_highbd_sad4x4_sse2, 10),
make_tuple(64, 64, &aom_highbd_sad64x64_sse2, 12),
make_tuple(64, 32, &aom_highbd_sad64x32_sse2, 12),
make_tuple(32, 64, &aom_highbd_sad32x64_sse2, 12),
@@ -1132,8 +1386,41 @@ const SadMxNParam sse2_tests[] = {
make_tuple(8, 16, &aom_highbd_sad8x16_sse2, 12),
make_tuple(8, 8, &aom_highbd_sad8x8_sse2, 12),
make_tuple(8, 4, &aom_highbd_sad8x4_sse2, 12),
+ make_tuple(4, 8, &aom_highbd_sad4x8_sse2, 12),
+ make_tuple(4, 4, &aom_highbd_sad4x4_sse2, 12),
+#endif
+ make_tuple(64, 16, &aom_sad64x16_sse2, -1),
+ make_tuple(16, 64, &aom_sad16x64_sse2, -1),
+#if CONFIG_AV1_HIGHBITDEPTH
+ make_tuple(64, 16, &aom_highbd_sad64x16_sse2, 8),
+ make_tuple(16, 64, &aom_highbd_sad16x64_sse2, 8),
+ make_tuple(64, 16, &aom_highbd_sad64x16_sse2, 10),
+ make_tuple(16, 64, &aom_highbd_sad16x64_sse2, 10),
+ make_tuple(64, 16, &aom_highbd_sad64x16_sse2, 12),
+ make_tuple(16, 64, &aom_highbd_sad16x64_sse2, 12),
+#endif
+ make_tuple(32, 8, &aom_sad32x8_sse2, -1),
+ make_tuple(8, 32, &aom_sad8x32_sse2, -1),
+#if CONFIG_AV1_HIGHBITDEPTH
+ make_tuple(32, 8, &aom_highbd_sad32x8_sse2, 8),
+ make_tuple(8, 32, &aom_highbd_sad8x32_sse2, 8),
+ make_tuple(32, 8, &aom_highbd_sad32x8_sse2, 10),
+ make_tuple(8, 32, &aom_highbd_sad8x32_sse2, 10),
+ make_tuple(32, 8, &aom_highbd_sad32x8_sse2, 12),
+ make_tuple(8, 32, &aom_highbd_sad8x32_sse2, 12),
+#endif
+ make_tuple(16, 4, &aom_sad16x4_sse2, -1),
+ make_tuple(4, 16, &aom_sad4x16_sse2, -1),
+#if CONFIG_AV1_HIGHBITDEPTH
+ make_tuple(16, 4, &aom_highbd_sad16x4_sse2, 8),
+ make_tuple(4, 16, &aom_highbd_sad4x16_sse2, 8),
+ make_tuple(16, 4, &aom_highbd_sad16x4_sse2, 10),
+ make_tuple(4, 16, &aom_highbd_sad4x16_sse2, 10),
+ make_tuple(16, 4, &aom_highbd_sad16x4_sse2, 12),
+ make_tuple(4, 16, &aom_highbd_sad4x16_sse2, 12),
+#endif
};
-INSTANTIATE_TEST_CASE_P(SSE2, SADTest, ::testing::ValuesIn(sse2_tests));
+INSTANTIATE_TEST_SUITE_P(SSE2, SADTest, ::testing::ValuesIn(sse2_tests));
const SadMxNAvgParam avg_sse2_tests[] = {
make_tuple(128, 128, &aom_sad128x128_avg_sse2, -1),
@@ -1152,6 +1439,7 @@ const SadMxNAvgParam avg_sse2_tests[] = {
make_tuple(8, 4, &aom_sad8x4_avg_sse2, -1),
make_tuple(4, 8, &aom_sad4x8_avg_sse2, -1),
make_tuple(4, 4, &aom_sad4x4_avg_sse2, -1),
+#if CONFIG_AV1_HIGHBITDEPTH
make_tuple(64, 64, &aom_highbd_sad64x64_avg_sse2, 8),
make_tuple(64, 32, &aom_highbd_sad64x32_avg_sse2, 8),
make_tuple(32, 64, &aom_highbd_sad32x64_avg_sse2, 8),
@@ -1163,6 +1451,8 @@ const SadMxNAvgParam avg_sse2_tests[] = {
make_tuple(8, 16, &aom_highbd_sad8x16_avg_sse2, 8),
make_tuple(8, 8, &aom_highbd_sad8x8_avg_sse2, 8),
make_tuple(8, 4, &aom_highbd_sad8x4_avg_sse2, 8),
+ make_tuple(4, 8, &aom_highbd_sad4x8_avg_sse2, 8),
+ make_tuple(4, 4, &aom_highbd_sad4x4_avg_sse2, 8),
make_tuple(64, 64, &aom_highbd_sad64x64_avg_sse2, 10),
make_tuple(64, 32, &aom_highbd_sad64x32_avg_sse2, 10),
make_tuple(32, 64, &aom_highbd_sad32x64_avg_sse2, 10),
@@ -1174,6 +1464,8 @@ const SadMxNAvgParam avg_sse2_tests[] = {
make_tuple(8, 16, &aom_highbd_sad8x16_avg_sse2, 10),
make_tuple(8, 8, &aom_highbd_sad8x8_avg_sse2, 10),
make_tuple(8, 4, &aom_highbd_sad8x4_avg_sse2, 10),
+ make_tuple(4, 8, &aom_highbd_sad4x8_avg_sse2, 10),
+ make_tuple(4, 4, &aom_highbd_sad4x4_avg_sse2, 10),
make_tuple(64, 64, &aom_highbd_sad64x64_avg_sse2, 12),
make_tuple(64, 32, &aom_highbd_sad64x32_avg_sse2, 12),
make_tuple(32, 64, &aom_highbd_sad32x64_avg_sse2, 12),
@@ -1185,8 +1477,41 @@ const SadMxNAvgParam avg_sse2_tests[] = {
make_tuple(8, 16, &aom_highbd_sad8x16_avg_sse2, 12),
make_tuple(8, 8, &aom_highbd_sad8x8_avg_sse2, 12),
make_tuple(8, 4, &aom_highbd_sad8x4_avg_sse2, 12),
+ make_tuple(4, 8, &aom_highbd_sad4x8_avg_sse2, 12),
+ make_tuple(4, 4, &aom_highbd_sad4x4_avg_sse2, 12),
+#endif
+ make_tuple(64, 16, &aom_sad64x16_avg_sse2, -1),
+ make_tuple(16, 64, &aom_sad16x64_avg_sse2, -1),
+#if CONFIG_AV1_HIGHBITDEPTH
+ make_tuple(64, 16, &aom_highbd_sad64x16_avg_sse2, 8),
+ make_tuple(16, 64, &aom_highbd_sad16x64_avg_sse2, 8),
+ make_tuple(64, 16, &aom_highbd_sad64x16_avg_sse2, 10),
+ make_tuple(16, 64, &aom_highbd_sad16x64_avg_sse2, 10),
+ make_tuple(64, 16, &aom_highbd_sad64x16_avg_sse2, 12),
+ make_tuple(16, 64, &aom_highbd_sad16x64_avg_sse2, 12),
+#endif
+ make_tuple(32, 8, &aom_sad32x8_avg_sse2, -1),
+ make_tuple(8, 32, &aom_sad8x32_avg_sse2, -1),
+#if CONFIG_AV1_HIGHBITDEPTH
+ make_tuple(32, 8, &aom_highbd_sad32x8_avg_sse2, 8),
+ make_tuple(8, 32, &aom_highbd_sad8x32_avg_sse2, 8),
+ make_tuple(32, 8, &aom_highbd_sad32x8_avg_sse2, 10),
+ make_tuple(8, 32, &aom_highbd_sad8x32_avg_sse2, 10),
+ make_tuple(32, 8, &aom_highbd_sad32x8_avg_sse2, 12),
+ make_tuple(8, 32, &aom_highbd_sad8x32_avg_sse2, 12),
+#endif
+ make_tuple(16, 4, &aom_sad16x4_avg_sse2, -1),
+ make_tuple(4, 16, &aom_sad4x16_avg_sse2, -1),
+#if CONFIG_AV1_HIGHBITDEPTH
+ make_tuple(16, 4, &aom_highbd_sad16x4_avg_sse2, 8),
+ make_tuple(4, 16, &aom_highbd_sad4x16_avg_sse2, 8),
+ make_tuple(16, 4, &aom_highbd_sad16x4_avg_sse2, 10),
+ make_tuple(4, 16, &aom_highbd_sad4x16_avg_sse2, 10),
+ make_tuple(16, 4, &aom_highbd_sad16x4_avg_sse2, 12),
+ make_tuple(4, 16, &aom_highbd_sad4x16_avg_sse2, 12),
+#endif
};
-INSTANTIATE_TEST_CASE_P(SSE2, SADavgTest, ::testing::ValuesIn(avg_sse2_tests));
+INSTANTIATE_TEST_SUITE_P(SSE2, SADavgTest, ::testing::ValuesIn(avg_sse2_tests));
const SadMxNx4Param x4d_sse2_tests[] = {
make_tuple(128, 128, &aom_sad128x128x4d_sse2, -1),
@@ -1205,6 +1530,7 @@ const SadMxNx4Param x4d_sse2_tests[] = {
make_tuple(8, 4, &aom_sad8x4x4d_sse2, -1),
make_tuple(4, 8, &aom_sad4x8x4d_sse2, -1),
make_tuple(4, 4, &aom_sad4x4x4d_sse2, -1),
+#if CONFIG_AV1_HIGHBITDEPTH
make_tuple(64, 64, &aom_highbd_sad64x64x4d_sse2, 8),
make_tuple(64, 32, &aom_highbd_sad64x32x4d_sse2, 8),
make_tuple(32, 64, &aom_highbd_sad32x64x4d_sse2, 8),
@@ -1244,14 +1570,72 @@ const SadMxNx4Param x4d_sse2_tests[] = {
make_tuple(8, 4, &aom_highbd_sad8x4x4d_sse2, 12),
make_tuple(4, 8, &aom_highbd_sad4x8x4d_sse2, 12),
make_tuple(4, 4, &aom_highbd_sad4x4x4d_sse2, 12),
+#endif
+ make_tuple(64, 16, &aom_sad64x16x4d_sse2, -1),
+ make_tuple(16, 64, &aom_sad16x64x4d_sse2, -1),
+#if CONFIG_AV1_HIGHBITDEPTH
+ make_tuple(64, 16, &aom_highbd_sad64x16x4d_sse2, 8),
+ make_tuple(16, 64, &aom_highbd_sad16x64x4d_sse2, 8),
+ make_tuple(64, 16, &aom_highbd_sad64x16x4d_sse2, 10),
+ make_tuple(16, 64, &aom_highbd_sad16x64x4d_sse2, 10),
+ make_tuple(64, 16, &aom_highbd_sad64x16x4d_sse2, 12),
+ make_tuple(16, 64, &aom_highbd_sad16x64x4d_sse2, 12),
+#endif
+ make_tuple(32, 8, &aom_sad32x8x4d_sse2, -1),
+ make_tuple(8, 32, &aom_sad8x32x4d_sse2, -1),
+#if CONFIG_AV1_HIGHBITDEPTH
+ make_tuple(32, 8, &aom_highbd_sad32x8x4d_sse2, 8),
+ make_tuple(8, 32, &aom_highbd_sad8x32x4d_sse2, 8),
+ make_tuple(32, 8, &aom_highbd_sad32x8x4d_sse2, 10),
+ make_tuple(8, 32, &aom_highbd_sad8x32x4d_sse2, 10),
+ make_tuple(32, 8, &aom_highbd_sad32x8x4d_sse2, 12),
+ make_tuple(8, 32, &aom_highbd_sad8x32x4d_sse2, 12),
+#endif
+ make_tuple(16, 4, &aom_sad16x4x4d_sse2, -1),
+ make_tuple(4, 16, &aom_sad4x16x4d_sse2, -1),
+#if CONFIG_AV1_HIGHBITDEPTH
+ make_tuple(16, 4, &aom_highbd_sad16x4x4d_sse2, 8),
+ make_tuple(4, 16, &aom_highbd_sad4x16x4d_sse2, 8),
+ make_tuple(16, 4, &aom_highbd_sad16x4x4d_sse2, 10),
+ make_tuple(4, 16, &aom_highbd_sad4x16x4d_sse2, 10),
+ make_tuple(16, 4, &aom_highbd_sad16x4x4d_sse2, 12),
+ make_tuple(4, 16, &aom_highbd_sad4x16x4d_sse2, 12),
+#endif
+};
+INSTANTIATE_TEST_SUITE_P(SSE2, SADx4Test, ::testing::ValuesIn(x4d_sse2_tests));
+
+const SadMxNx4AvgParam x4d_avg_sse2_tests[] = {
+ make_tuple(128, 128, &aom_sad128x128x4d_avg_sse2, -1),
+ make_tuple(128, 64, &aom_sad128x64x4d_avg_sse2, -1),
+ make_tuple(64, 128, &aom_sad64x128x4d_avg_sse2, -1),
+ make_tuple(64, 64, &aom_sad64x64x4d_avg_sse2, -1),
+ make_tuple(64, 32, &aom_sad64x32x4d_avg_sse2, -1),
+ make_tuple(32, 64, &aom_sad32x64x4d_avg_sse2, -1),
+ make_tuple(32, 32, &aom_sad32x32x4d_avg_sse2, -1),
+ make_tuple(32, 16, &aom_sad32x16x4d_avg_sse2, -1),
+ make_tuple(16, 32, &aom_sad16x32x4d_avg_sse2, -1),
+ make_tuple(16, 16, &aom_sad16x16x4d_avg_sse2, -1),
+ make_tuple(16, 8, &aom_sad16x8x4d_avg_sse2, -1),
+ make_tuple(8, 16, &aom_sad8x16x4d_avg_sse2, -1),
+ make_tuple(8, 8, &aom_sad8x8x4d_avg_sse2, -1),
+ make_tuple(8, 4, &aom_sad8x4x4d_avg_sse2, -1),
+ make_tuple(4, 8, &aom_sad4x8x4d_avg_sse2, -1),
+ make_tuple(4, 4, &aom_sad4x4x4d_avg_sse2, -1),
+ make_tuple(64, 16, &aom_sad64x16x4d_avg_sse2, -1),
+ make_tuple(16, 64, &aom_sad16x64x4d_avg_sse2, -1),
+ make_tuple(32, 8, &aom_sad32x8x4d_avg_sse2, -1),
+ make_tuple(8, 32, &aom_sad8x32x4d_avg_sse2, -1),
+ make_tuple(16, 4, &aom_sad16x4x4d_avg_sse2, -1),
+ make_tuple(4, 16, &aom_sad4x16x4d_avg_sse2, -1),
};
-INSTANTIATE_TEST_CASE_P(SSE2, SADx4Test, ::testing::ValuesIn(x4d_sse2_tests));
+INSTANTIATE_TEST_SUITE_P(SSE2, SADx4AvgTest,
+ ::testing::ValuesIn(x4d_avg_sse2_tests));
#endif // HAVE_SSE2
#if HAVE_SSSE3
// Note: These are named sse2, but part of ssse3 file and only built and linked
// when ssse3 is enabled.
-const JntSadMxhParam jnt_sad_sse2_tests[] = {
+const DistWtdSadMxhParam dist_wtd_sad_sse2_tests[] = {
make_tuple(4, 4, &aom_sad4xh_sse2, -1),
make_tuple(4, 8, &aom_sad4xh_sse2, -1),
make_tuple(8, 4, &aom_sad8xh_sse2, -1),
@@ -1274,9 +1658,16 @@ const JntSadMxhParam jnt_sad_sse2_tests[] = {
make_tuple(32, 8, &aom_sad32xh_sse2, -1),
make_tuple(16, 64, &aom_sad16xh_sse2, -1),
make_tuple(64, 16, &aom_sad64xh_sse2, -1),
+
+ make_tuple(16, 64, &aom_sad16xh_sse2, -1),
+ make_tuple(64, 16, &aom_sad64xh_sse2, -1),
+ make_tuple(8, 32, &aom_sad8xh_sse2, -1),
+ make_tuple(32, 8, &aom_sad32xh_sse2, -1),
+ make_tuple(4, 16, &aom_sad4xh_sse2, -1),
+ make_tuple(16, 4, &aom_sad16xh_sse2, -1),
};
-INSTANTIATE_TEST_CASE_P(SSE2, JntSADTest,
- ::testing::ValuesIn(jnt_sad_sse2_tests));
+INSTANTIATE_TEST_SUITE_P(SSE2, DistWtdSADTest,
+ ::testing::ValuesIn(dist_wtd_sad_sse2_tests));
#endif // HAVE_SSSE3
@@ -1285,49 +1676,63 @@ INSTANTIATE_TEST_CASE_P(SSE2, JntSADTest,
#endif // HAVE_SSE3
#if HAVE_SSSE3
-const JntCompAvgParam jnt_comp_avg_ssse3_tests[] = {
- make_tuple(128, 128, &aom_jnt_comp_avg_pred_ssse3, -1),
- make_tuple(128, 64, &aom_jnt_comp_avg_pred_ssse3, -1),
- make_tuple(64, 128, &aom_jnt_comp_avg_pred_ssse3, -1),
- make_tuple(64, 64, &aom_jnt_comp_avg_pred_ssse3, -1),
- make_tuple(64, 32, &aom_jnt_comp_avg_pred_ssse3, -1),
- make_tuple(32, 64, &aom_jnt_comp_avg_pred_ssse3, -1),
- make_tuple(32, 32, &aom_jnt_comp_avg_pred_ssse3, -1),
- make_tuple(32, 16, &aom_jnt_comp_avg_pred_ssse3, -1),
- make_tuple(16, 32, &aom_jnt_comp_avg_pred_ssse3, -1),
- make_tuple(16, 16, &aom_jnt_comp_avg_pred_ssse3, -1),
- make_tuple(16, 8, &aom_jnt_comp_avg_pred_ssse3, -1),
- make_tuple(8, 16, &aom_jnt_comp_avg_pred_ssse3, -1),
- make_tuple(8, 8, &aom_jnt_comp_avg_pred_ssse3, -1),
- make_tuple(8, 4, &aom_jnt_comp_avg_pred_ssse3, -1),
- make_tuple(4, 8, &aom_jnt_comp_avg_pred_ssse3, -1),
- make_tuple(4, 4, &aom_jnt_comp_avg_pred_ssse3, -1),
- make_tuple(16, 16, &aom_jnt_comp_avg_pred_ssse3, -1),
+const DistWtdCompAvgParam dist_wtd_comp_avg_ssse3_tests[] = {
+ make_tuple(128, 128, &aom_dist_wtd_comp_avg_pred_ssse3, -1),
+ make_tuple(128, 64, &aom_dist_wtd_comp_avg_pred_ssse3, -1),
+ make_tuple(64, 128, &aom_dist_wtd_comp_avg_pred_ssse3, -1),
+ make_tuple(64, 64, &aom_dist_wtd_comp_avg_pred_ssse3, -1),
+ make_tuple(64, 32, &aom_dist_wtd_comp_avg_pred_ssse3, -1),
+ make_tuple(32, 64, &aom_dist_wtd_comp_avg_pred_ssse3, -1),
+ make_tuple(32, 32, &aom_dist_wtd_comp_avg_pred_ssse3, -1),
+ make_tuple(32, 16, &aom_dist_wtd_comp_avg_pred_ssse3, -1),
+ make_tuple(16, 32, &aom_dist_wtd_comp_avg_pred_ssse3, -1),
+ make_tuple(16, 16, &aom_dist_wtd_comp_avg_pred_ssse3, -1),
+ make_tuple(16, 8, &aom_dist_wtd_comp_avg_pred_ssse3, -1),
+ make_tuple(8, 16, &aom_dist_wtd_comp_avg_pred_ssse3, -1),
+ make_tuple(8, 8, &aom_dist_wtd_comp_avg_pred_ssse3, -1),
+ make_tuple(8, 4, &aom_dist_wtd_comp_avg_pred_ssse3, -1),
+ make_tuple(4, 8, &aom_dist_wtd_comp_avg_pred_ssse3, -1),
+ make_tuple(4, 4, &aom_dist_wtd_comp_avg_pred_ssse3, -1),
+ make_tuple(16, 16, &aom_dist_wtd_comp_avg_pred_ssse3, -1),
+
+ make_tuple(64, 16, &aom_dist_wtd_comp_avg_pred_ssse3, -1),
+ make_tuple(16, 64, &aom_dist_wtd_comp_avg_pred_ssse3, -1),
+ make_tuple(32, 8, &aom_dist_wtd_comp_avg_pred_ssse3, -1),
+ make_tuple(8, 32, &aom_dist_wtd_comp_avg_pred_ssse3, -1),
+ make_tuple(16, 4, &aom_dist_wtd_comp_avg_pred_ssse3, -1),
+ make_tuple(4, 16, &aom_dist_wtd_comp_avg_pred_ssse3, -1),
};
-INSTANTIATE_TEST_CASE_P(SSSE3, JntCompAvgTest,
- ::testing::ValuesIn(jnt_comp_avg_ssse3_tests));
-
-const JntSadMxNAvgParam jnt_avg_ssse3_tests[] = {
- make_tuple(128, 128, &aom_jnt_sad128x128_avg_ssse3, -1),
- make_tuple(128, 64, &aom_jnt_sad128x64_avg_ssse3, -1),
- make_tuple(64, 128, &aom_jnt_sad64x128_avg_ssse3, -1),
- make_tuple(64, 64, &aom_jnt_sad64x64_avg_ssse3, -1),
- make_tuple(64, 32, &aom_jnt_sad64x32_avg_ssse3, -1),
- make_tuple(32, 64, &aom_jnt_sad32x64_avg_ssse3, -1),
- make_tuple(32, 32, &aom_jnt_sad32x32_avg_ssse3, -1),
- make_tuple(32, 16, &aom_jnt_sad32x16_avg_ssse3, -1),
- make_tuple(16, 32, &aom_jnt_sad16x32_avg_ssse3, -1),
- make_tuple(16, 16, &aom_jnt_sad16x16_avg_ssse3, -1),
- make_tuple(16, 8, &aom_jnt_sad16x8_avg_ssse3, -1),
- make_tuple(8, 16, &aom_jnt_sad8x16_avg_ssse3, -1),
- make_tuple(8, 8, &aom_jnt_sad8x8_avg_ssse3, -1),
- make_tuple(8, 4, &aom_jnt_sad8x4_avg_ssse3, -1),
- make_tuple(4, 8, &aom_jnt_sad4x8_avg_ssse3, -1),
- make_tuple(4, 4, &aom_jnt_sad4x4_avg_ssse3, -1),
+INSTANTIATE_TEST_SUITE_P(SSSE3, DistWtdCompAvgTest,
+ ::testing::ValuesIn(dist_wtd_comp_avg_ssse3_tests));
+
+const DistWtdSadMxNAvgParam dist_wtd_avg_ssse3_tests[] = {
+ make_tuple(128, 128, &aom_dist_wtd_sad128x128_avg_ssse3, -1),
+ make_tuple(128, 64, &aom_dist_wtd_sad128x64_avg_ssse3, -1),
+ make_tuple(64, 128, &aom_dist_wtd_sad64x128_avg_ssse3, -1),
+ make_tuple(64, 64, &aom_dist_wtd_sad64x64_avg_ssse3, -1),
+ make_tuple(64, 32, &aom_dist_wtd_sad64x32_avg_ssse3, -1),
+ make_tuple(32, 64, &aom_dist_wtd_sad32x64_avg_ssse3, -1),
+ make_tuple(32, 32, &aom_dist_wtd_sad32x32_avg_ssse3, -1),
+ make_tuple(32, 16, &aom_dist_wtd_sad32x16_avg_ssse3, -1),
+ make_tuple(16, 32, &aom_dist_wtd_sad16x32_avg_ssse3, -1),
+ make_tuple(16, 16, &aom_dist_wtd_sad16x16_avg_ssse3, -1),
+ make_tuple(16, 8, &aom_dist_wtd_sad16x8_avg_ssse3, -1),
+ make_tuple(8, 16, &aom_dist_wtd_sad8x16_avg_ssse3, -1),
+ make_tuple(8, 8, &aom_dist_wtd_sad8x8_avg_ssse3, -1),
+ make_tuple(8, 4, &aom_dist_wtd_sad8x4_avg_ssse3, -1),
+ make_tuple(4, 8, &aom_dist_wtd_sad4x8_avg_ssse3, -1),
+ make_tuple(4, 4, &aom_dist_wtd_sad4x4_avg_ssse3, -1),
+
+ make_tuple(64, 16, &aom_dist_wtd_sad64x16_avg_ssse3, -1),
+ make_tuple(16, 64, &aom_dist_wtd_sad16x64_avg_ssse3, -1),
+ make_tuple(32, 8, &aom_dist_wtd_sad32x8_avg_ssse3, -1),
+ make_tuple(8, 32, &aom_dist_wtd_sad8x32_avg_ssse3, -1),
+ make_tuple(16, 4, &aom_dist_wtd_sad16x4_avg_ssse3, -1),
+ make_tuple(4, 16, &aom_dist_wtd_sad4x16_avg_ssse3, -1),
};
-INSTANTIATE_TEST_CASE_P(SSSE3, JntSADavgTest,
- ::testing::ValuesIn(jnt_avg_ssse3_tests));
+INSTANTIATE_TEST_SUITE_P(SSSE3, DistWtdSADavgTest,
+ ::testing::ValuesIn(dist_wtd_avg_ssse3_tests));
#endif // HAVE_SSSE3
#if HAVE_SSE4_1
@@ -1344,6 +1749,7 @@ const SadMxNParam avx2_tests[] = {
make_tuple(32, 64, &aom_sad32x64_avx2, -1),
make_tuple(32, 32, &aom_sad32x32_avx2, -1),
make_tuple(32, 16, &aom_sad32x16_avx2, -1),
+#if CONFIG_AV1_HIGHBITDEPTH
make_tuple(128, 128, &aom_highbd_sad128x128_avx2, 8),
make_tuple(128, 128, &aom_highbd_sad128x128_avx2, 10),
make_tuple(128, 128, &aom_highbd_sad128x128_avx2, 12),
@@ -1377,8 +1783,22 @@ const SadMxNParam avx2_tests[] = {
make_tuple(16, 8, &aom_highbd_sad16x8_avx2, 8),
make_tuple(16, 8, &aom_highbd_sad16x8_avx2, 10),
make_tuple(16, 8, &aom_highbd_sad16x8_avx2, 12),
+
+ make_tuple(64, 16, &aom_highbd_sad64x16_avx2, 8),
+ make_tuple(64, 16, &aom_highbd_sad64x16_avx2, 10),
+ make_tuple(64, 16, &aom_highbd_sad64x16_avx2, 12),
+ make_tuple(16, 64, &aom_highbd_sad16x64_avx2, 8),
+ make_tuple(16, 64, &aom_highbd_sad16x64_avx2, 10),
+ make_tuple(16, 64, &aom_highbd_sad16x64_avx2, 12),
+ make_tuple(32, 8, &aom_highbd_sad32x8_avx2, 8),
+ make_tuple(32, 8, &aom_highbd_sad32x8_avx2, 10),
+ make_tuple(32, 8, &aom_highbd_sad32x8_avx2, 12),
+ make_tuple(16, 4, &aom_highbd_sad16x4_avx2, 8),
+ make_tuple(16, 4, &aom_highbd_sad16x4_avx2, 10),
+ make_tuple(16, 4, &aom_highbd_sad16x4_avx2, 12),
+#endif
};
-INSTANTIATE_TEST_CASE_P(AVX2, SADTest, ::testing::ValuesIn(avx2_tests));
+INSTANTIATE_TEST_SUITE_P(AVX2, SADTest, ::testing::ValuesIn(avx2_tests));
const SadMxNAvgParam avg_avx2_tests[] = {
make_tuple(64, 128, &aom_sad64x128_avg_avx2, -1),
@@ -1389,6 +1809,7 @@ const SadMxNAvgParam avg_avx2_tests[] = {
make_tuple(32, 64, &aom_sad32x64_avg_avx2, -1),
make_tuple(32, 32, &aom_sad32x32_avg_avx2, -1),
make_tuple(32, 16, &aom_sad32x16_avg_avx2, -1),
+#if CONFIG_AV1_HIGHBITDEPTH
make_tuple(128, 128, &aom_highbd_sad128x128_avg_avx2, 8),
make_tuple(128, 128, &aom_highbd_sad128x128_avg_avx2, 10),
make_tuple(128, 128, &aom_highbd_sad128x128_avg_avx2, 12),
@@ -1422,17 +1843,35 @@ const SadMxNAvgParam avg_avx2_tests[] = {
make_tuple(16, 8, &aom_highbd_sad16x8_avg_avx2, 8),
make_tuple(16, 8, &aom_highbd_sad16x8_avg_avx2, 10),
make_tuple(16, 8, &aom_highbd_sad16x8_avg_avx2, 12),
+
+ make_tuple(64, 16, &aom_highbd_sad64x16_avg_avx2, 8),
+ make_tuple(64, 16, &aom_highbd_sad64x16_avg_avx2, 10),
+ make_tuple(64, 16, &aom_highbd_sad64x16_avg_avx2, 12),
+ make_tuple(16, 64, &aom_highbd_sad16x64_avg_avx2, 8),
+ make_tuple(16, 64, &aom_highbd_sad16x64_avg_avx2, 10),
+ make_tuple(16, 64, &aom_highbd_sad16x64_avg_avx2, 12),
+ make_tuple(32, 8, &aom_highbd_sad32x8_avg_avx2, 8),
+ make_tuple(32, 8, &aom_highbd_sad32x8_avg_avx2, 10),
+ make_tuple(32, 8, &aom_highbd_sad32x8_avg_avx2, 12),
+ make_tuple(16, 4, &aom_highbd_sad16x4_avg_avx2, 8),
+ make_tuple(16, 4, &aom_highbd_sad16x4_avg_avx2, 10),
+ make_tuple(16, 4, &aom_highbd_sad16x4_avg_avx2, 12),
+#endif
};
-INSTANTIATE_TEST_CASE_P(AVX2, SADavgTest, ::testing::ValuesIn(avg_avx2_tests));
+INSTANTIATE_TEST_SUITE_P(AVX2, SADavgTest, ::testing::ValuesIn(avg_avx2_tests));
const SadMxNx4Param x4d_avx2_tests[] = {
+ make_tuple(32, 64, &aom_sad32x64x4d_avx2, -1),
+ make_tuple(32, 32, &aom_sad32x32x4d_avx2, -1),
+ make_tuple(32, 16, &aom_sad32x16x4d_avx2, -1),
+ make_tuple(32, 8, &aom_sad32x8x4d_avx2, -1),
make_tuple(64, 128, &aom_sad64x128x4d_avx2, -1),
- make_tuple(128, 64, &aom_sad128x64x4d_avx2, -1),
- make_tuple(128, 128, &aom_sad128x128x4d_avx2, -1),
make_tuple(64, 64, &aom_sad64x64x4d_avx2, -1),
- make_tuple(32, 64, &aom_sad32x64x4d_avx2, -1),
make_tuple(64, 32, &aom_sad64x32x4d_avx2, -1),
- make_tuple(32, 32, &aom_sad32x32x4d_avx2, -1),
+ make_tuple(64, 16, &aom_sad64x16x4d_avx2, -1),
+ make_tuple(128, 128, &aom_sad128x128x4d_avx2, -1),
+ make_tuple(128, 64, &aom_sad128x64x4d_avx2, -1),
+#if CONFIG_AV1_HIGHBITDEPTH
make_tuple(128, 128, &aom_highbd_sad128x128x4d_avx2, 8),
make_tuple(128, 128, &aom_highbd_sad128x128x4d_avx2, 10),
make_tuple(128, 128, &aom_highbd_sad128x128x4d_avx2, 12),
@@ -1466,8 +1905,22 @@ const SadMxNx4Param x4d_avx2_tests[] = {
make_tuple(16, 8, &aom_highbd_sad16x8x4d_avx2, 8),
make_tuple(16, 8, &aom_highbd_sad16x8x4d_avx2, 10),
make_tuple(16, 8, &aom_highbd_sad16x8x4d_avx2, 12),
+
+ make_tuple(16, 64, &aom_highbd_sad16x64x4d_avx2, 8),
+ make_tuple(16, 64, &aom_highbd_sad16x64x4d_avx2, 10),
+ make_tuple(16, 64, &aom_highbd_sad16x64x4d_avx2, 12),
+ make_tuple(64, 16, &aom_highbd_sad64x16x4d_avx2, 8),
+ make_tuple(64, 16, &aom_highbd_sad64x16x4d_avx2, 10),
+ make_tuple(64, 16, &aom_highbd_sad64x16x4d_avx2, 12),
+ make_tuple(32, 8, &aom_highbd_sad32x8x4d_avx2, 8),
+ make_tuple(32, 8, &aom_highbd_sad32x8x4d_avx2, 10),
+ make_tuple(32, 8, &aom_highbd_sad32x8x4d_avx2, 12),
+ make_tuple(16, 4, &aom_highbd_sad16x4x4d_avx2, 8),
+ make_tuple(16, 4, &aom_highbd_sad16x4x4d_avx2, 10),
+ make_tuple(16, 4, &aom_highbd_sad16x4x4d_avx2, 12),
+#endif
};
-INSTANTIATE_TEST_CASE_P(AVX2, SADx4Test, ::testing::ValuesIn(x4d_avx2_tests));
+INSTANTIATE_TEST_SUITE_P(AVX2, SADx4Test, ::testing::ValuesIn(x4d_avx2_tests));
#endif // HAVE_AVX2
//------------------------------------------------------------------------------
@@ -1488,7 +1941,7 @@ const SadMxNParam msa_tests[] = {
make_tuple(4, 8, &aom_sad4x8_msa, -1),
make_tuple(4, 4, &aom_sad4x4_msa, -1),
};
-INSTANTIATE_TEST_CASE_P(MSA, SADTest, ::testing::ValuesIn(msa_tests));
+INSTANTIATE_TEST_SUITE_P(MSA, SADTest, ::testing::ValuesIn(msa_tests));
const SadMxNAvgParam avg_msa_tests[] = {
make_tuple(64, 64, &aom_sad64x64_avg_msa, -1),
@@ -1505,7 +1958,7 @@ const SadMxNAvgParam avg_msa_tests[] = {
make_tuple(4, 8, &aom_sad4x8_avg_msa, -1),
make_tuple(4, 4, &aom_sad4x4_avg_msa, -1),
};
-INSTANTIATE_TEST_CASE_P(MSA, SADavgTest, ::testing::ValuesIn(avg_msa_tests));
+INSTANTIATE_TEST_SUITE_P(MSA, SADavgTest, ::testing::ValuesIn(avg_msa_tests));
const SadMxNx4Param x4d_msa_tests[] = {
make_tuple(64, 64, &aom_sad64x64x4d_msa, -1),
@@ -1522,7 +1975,7 @@ const SadMxNx4Param x4d_msa_tests[] = {
make_tuple(4, 8, &aom_sad4x8x4d_msa, -1),
make_tuple(4, 4, &aom_sad4x4x4d_msa, -1),
};
-INSTANTIATE_TEST_CASE_P(MSA, SADx4Test, ::testing::ValuesIn(x4d_msa_tests));
+INSTANTIATE_TEST_SUITE_P(MSA, SADx4Test, ::testing::ValuesIn(x4d_msa_tests));
#endif // HAVE_MSA
} // namespace
generated by cgit v1.2.3 (git 2.26.2) at 2024-11-12 22:37:42 +0000