1 /*
2 * Copyright (c) 2016, 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 #include <math.h>
12 #include <stdlib.h>
13 #include <string.h>
14 #include <tuple>
15
16 #include "third_party/googletest/src/googletest/include/gtest/gtest.h"
17 #include "test/acm_random.h"
18 #include "test/register_state_check.h"
19 #include "test/util.h"
20
21 #include "config/aom_config.h"
22 #include "config/aom_dsp_rtcd.h"
23
24 #include "aom/aom_integer.h"
25
26 using libaom_test::ACMRandom;
27
28 namespace {
29 const int number_of_iterations = 200;
30
31 typedef unsigned int (*MaskedSADFunc)(const uint8_t *src, int src_stride,
32 const uint8_t *ref, int ref_stride,
33 const uint8_t *second_pred,
34 const uint8_t *msk, int msk_stride,
35 int invert_mask);
36 typedef std::tuple<MaskedSADFunc, MaskedSADFunc> MaskedSADParam;
37
38 typedef void (*MaskedSADx4Func)(const uint8_t *src, int src_stride,
39 const uint8_t *ref[], int ref_stride,
40 const uint8_t *second_pred, const uint8_t *msk,
41 int msk_stride, int invert_mask,
42 unsigned sads[]);
43
44 typedef std::tuple<MaskedSADx4Func, MaskedSADx4Func> MaskedSADx4Param;
45
46 class MaskedSADTestBase : public ::testing::Test {
47 public:
48 ~MaskedSADTestBase() override = default;
49 void SetUp() override = 0;
50 virtual void runRef(const uint8_t *src_ptr, int src_stride,
51 const uint8_t *ref_ptr[], int ref_stride,
52 const uint8_t *second_pred, const uint8_t *msk,
53 int msk_stride, int inv_mask, unsigned sads[],
54 int times) = 0;
55 virtual void runTest(const uint8_t *src_ptr, int src_stride,
56 const uint8_t *ref_ptr[], int ref_stride,
57 const uint8_t *second_pred, const uint8_t *msk,
58 int msk_stride, int inv_mask, unsigned sads[],
59 int times) = 0;
60
61 void runMaskedSADTest(int run_times);
62 };
63
64 class MaskedSADTest : public MaskedSADTestBase,
65 public ::testing::WithParamInterface<MaskedSADParam> {
66 public:
67 ~MaskedSADTest() override = default;
SetUp()68 void SetUp() override {
69 maskedSAD_op_ = GET_PARAM(0);
70 ref_maskedSAD_op_ = GET_PARAM(1);
71 }
72
73 void runRef(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr[],
74 int ref_stride, const uint8_t *second_pred, const uint8_t *msk,
75 int msk_stride, int inv_mask, unsigned sads[],
76 int times) override;
77 void runTest(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr[],
78 int ref_stride, const uint8_t *second_pred, const uint8_t *msk,
79 int msk_stride, int inv_mask, unsigned sads[],
80 int times) override;
81
82 protected:
83 MaskedSADFunc maskedSAD_op_;
84 MaskedSADFunc ref_maskedSAD_op_;
85 };
86 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(MaskedSADTest);
87
88 class MaskedSADx4Test : public MaskedSADTestBase,
89 public ::testing::WithParamInterface<MaskedSADx4Param> {
90 public:
91 ~MaskedSADx4Test() override = default;
SetUp()92 void SetUp() override {
93 maskedSAD_op_ = GET_PARAM(0);
94 ref_maskedSAD_op_ = GET_PARAM(1);
95 }
96 void runRef(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr[],
97 int ref_stride, const uint8_t *second_pred, const uint8_t *msk,
98 int msk_stride, int inv_mask, unsigned sads[],
99 int times) override;
100 void runTest(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr[],
101 int ref_stride, const uint8_t *second_pred, const uint8_t *msk,
102 int msk_stride, int inv_mask, unsigned sads[],
103 int times) override;
104
105 protected:
106 MaskedSADx4Func maskedSAD_op_;
107 MaskedSADx4Func ref_maskedSAD_op_;
108 };
109 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(MaskedSADx4Test);
110
runRef(const uint8_t * src_ptr,int src_stride,const uint8_t * ref_ptr[],int ref_stride,const uint8_t * second_pred,const uint8_t * msk,int msk_stride,int invert_mask,unsigned sads[],int times)111 void MaskedSADTest::runRef(const uint8_t *src_ptr, int src_stride,
112 const uint8_t *ref_ptr[], int ref_stride,
113 const uint8_t *second_pred, const uint8_t *msk,
114 int msk_stride, int invert_mask, unsigned sads[],
115 int times) {
116 for (int repeat = 0; repeat < times; ++repeat) {
117 sads[0] = ref_maskedSAD_op_(src_ptr, src_stride, ref_ptr[0], ref_stride,
118 second_pred, msk, msk_stride, invert_mask);
119 }
120 }
121
runTest(const uint8_t * src_ptr,int src_stride,const uint8_t * ref_ptr[],int ref_stride,const uint8_t * second_pred,const uint8_t * msk,int msk_stride,int invert_mask,unsigned sads[],int times)122 void MaskedSADTest::runTest(const uint8_t *src_ptr, int src_stride,
123 const uint8_t *ref_ptr[], int ref_stride,
124 const uint8_t *second_pred, const uint8_t *msk,
125 int msk_stride, int invert_mask, unsigned sads[],
126 int times) {
127 if (times == 1) {
128 sads[0] = maskedSAD_op_(src_ptr, src_stride, ref_ptr[0], ref_stride,
129 second_pred, msk, msk_stride, invert_mask);
130 } else {
131 for (int repeat = 0; repeat < times; ++repeat) {
132 API_REGISTER_STATE_CHECK(
133 sads[0] = maskedSAD_op_(src_ptr, src_stride, ref_ptr[0], ref_stride,
134 second_pred, msk, msk_stride, invert_mask));
135 }
136 }
137 }
138
runRef(const uint8_t * src_ptr,int src_stride,const uint8_t * ref_ptr[],int ref_stride,const uint8_t * second_pred,const uint8_t * msk,int msk_stride,int invert_mask,unsigned sads[],int times)139 void MaskedSADx4Test::runRef(const uint8_t *src_ptr, int src_stride,
140 const uint8_t *ref_ptr[], int ref_stride,
141 const uint8_t *second_pred, const uint8_t *msk,
142 int msk_stride, int invert_mask, unsigned sads[],
143 int times) {
144 for (int repeat = 0; repeat < times; ++repeat) {
145 ref_maskedSAD_op_(src_ptr, src_stride, ref_ptr, ref_stride, second_pred,
146 msk, msk_stride, invert_mask, sads);
147 }
148 }
149
runTest(const uint8_t * src_ptr,int src_stride,const uint8_t * ref_ptr[],int ref_stride,const uint8_t * second_pred,const uint8_t * msk,int msk_stride,int invert_mask,unsigned sads[],int times)150 void MaskedSADx4Test::runTest(const uint8_t *src_ptr, int src_stride,
151 const uint8_t *ref_ptr[], int ref_stride,
152 const uint8_t *second_pred, const uint8_t *msk,
153 int msk_stride, int invert_mask, unsigned sads[],
154 int times) {
155 if (times == 1) {
156 API_REGISTER_STATE_CHECK(maskedSAD_op_(src_ptr, src_stride, ref_ptr,
157 ref_stride, second_pred, msk,
158 msk_stride, invert_mask, sads));
159 } else {
160 for (int repeat = 0; repeat < times; ++repeat) {
161 maskedSAD_op_(src_ptr, src_stride, ref_ptr, ref_stride, second_pred, msk,
162 msk_stride, invert_mask, sads);
163 }
164 }
165 }
166
runMaskedSADTest(int run_times)167 void MaskedSADTestBase::runMaskedSADTest(int run_times) {
168 ACMRandom rnd(ACMRandom::DeterministicSeed());
169 const unsigned kBlockSize = MAX_SB_SIZE * MAX_SB_SIZE;
170 DECLARE_ALIGNED(16, uint8_t, src_ptr[MAX_SB_SIZE * MAX_SB_SIZE]);
171 DECLARE_ALIGNED(16, uint8_t, ref_ptr[MAX_SB_SIZE * MAX_SB_SIZE * 4]);
172 DECLARE_ALIGNED(16, uint8_t, second_pred_ptr[MAX_SB_SIZE * MAX_SB_SIZE]);
173 DECLARE_ALIGNED(16, uint8_t, msk_ptr[MAX_SB_SIZE * MAX_SB_SIZE]);
174
175 const uint8_t *refs[] = { ref_ptr, ref_ptr + kBlockSize,
176 ref_ptr + 2 * kBlockSize,
177 ref_ptr + 3 * kBlockSize };
178 unsigned sads[] = { 0, 0, 0, 0 };
179 unsigned sads_ref[] = { 0, 0, 0, 0 };
180 int err_count = 0;
181 int first_failure = -1;
182 int src_stride = MAX_SB_SIZE;
183 int ref_stride = MAX_SB_SIZE;
184 int msk_stride = MAX_SB_SIZE;
185 const int iters = run_times == 1 ? number_of_iterations : 1;
186 for (int i = 0; i < iters; ++i) {
187 if (run_times == 1 && i == 0) {
188 // The maximum accumulator value occurs when src=0 and
189 // ref/second_pref=255 (or vice-versa, since we take the absolute
190 // difference). Check this case explicitly to ensure we do not overflow
191 // during accumulation.
192 for (int j = 0; j < MAX_SB_SIZE * MAX_SB_SIZE; j++) {
193 src_ptr[j] = 0;
194 ref_ptr[j] = 255;
195 (ref_ptr + kBlockSize)[j] = 255;
196 (ref_ptr + 2 * kBlockSize)[j] = 255;
197 (ref_ptr + 3 * kBlockSize)[j] = 255;
198 second_pred_ptr[j] = 255;
199 }
200 } else {
201 for (int j = 0; j < MAX_SB_SIZE * MAX_SB_SIZE; j++) {
202 src_ptr[j] = rnd.Rand8();
203 ref_ptr[j] = rnd.Rand8();
204 (ref_ptr + kBlockSize)[j] = rnd.Rand8();
205 (ref_ptr + 2 * kBlockSize)[j] = rnd.Rand8();
206 (ref_ptr + 3 * kBlockSize)[j] = rnd.Rand8();
207 second_pred_ptr[j] = rnd.Rand8();
208 }
209 }
210 for (int j = 0; j < MAX_SB_SIZE * MAX_SB_SIZE; j++) {
211 msk_ptr[j] = ((rnd.Rand8() & 0x7f) > 64) ? rnd.Rand8() & 0x3f : 64;
212 assert(msk_ptr[j] <= 64);
213 }
214
215 for (int invert_mask = 0; invert_mask < 2; ++invert_mask) {
216 aom_usec_timer timer;
217 aom_usec_timer_start(&timer);
218 runRef(src_ptr, src_stride, refs, ref_stride, second_pred_ptr, msk_ptr,
219 msk_stride, invert_mask, sads_ref, run_times);
220 aom_usec_timer_mark(&timer);
221 const double time1 = static_cast<double>(aom_usec_timer_elapsed(&timer));
222
223 aom_usec_timer_start(&timer);
224 runTest(src_ptr, src_stride, refs, ref_stride, second_pred_ptr, msk_ptr,
225 msk_stride, invert_mask, sads, run_times);
226 aom_usec_timer_mark(&timer);
227 const double time2 = static_cast<double>(aom_usec_timer_elapsed(&timer));
228
229 if (run_times > 10) {
230 printf("%7.2f/%7.2fns", time1, time2);
231 printf("(%3.2f)\n", time1 / time2);
232 }
233 if (sads_ref[0] != sads[0] || sads_ref[1] != sads[1] ||
234 sads_ref[2] != sads[2] || sads_ref[3] != sads[3]) {
235 err_count++;
236 if (first_failure == -1) first_failure = i;
237 }
238 }
239 }
240 EXPECT_EQ(0, err_count) << "Error: Masked SAD Test, output doesn't match. "
241 << "First failed at test case " << first_failure;
242 }
243
TEST_P(MaskedSADTest,OperationCheck)244 TEST_P(MaskedSADTest, OperationCheck) { runMaskedSADTest(1); }
245
TEST_P(MaskedSADTest,DISABLED_Speed)246 TEST_P(MaskedSADTest, DISABLED_Speed) { runMaskedSADTest(2000000); }
247
TEST_P(MaskedSADx4Test,OperationCheck)248 TEST_P(MaskedSADx4Test, OperationCheck) { runMaskedSADTest(1); }
249
TEST_P(MaskedSADx4Test,DISABLED_Speed)250 TEST_P(MaskedSADx4Test, DISABLED_Speed) { runMaskedSADTest(2000000); }
251
252 #if CONFIG_AV1_HIGHBITDEPTH
253 typedef unsigned int (*HighbdMaskedSADFunc)(const uint8_t *src, int src_stride,
254 const uint8_t *ref, int ref_stride,
255 const uint8_t *second_pred,
256 const uint8_t *msk, int msk_stride,
257 int invert_mask);
258 typedef std::tuple<HighbdMaskedSADFunc, HighbdMaskedSADFunc>
259 HighbdMaskedSADParam;
260
261 class HighbdMaskedSADTest
262 : public ::testing::TestWithParam<HighbdMaskedSADParam> {
263 public:
264 ~HighbdMaskedSADTest() override = default;
SetUp()265 void SetUp() override {
266 maskedSAD_op_ = GET_PARAM(0);
267 ref_maskedSAD_op_ = GET_PARAM(1);
268 }
269
270 void runHighbdMaskedSADTest(int run_times);
271
272 protected:
273 HighbdMaskedSADFunc maskedSAD_op_;
274 HighbdMaskedSADFunc ref_maskedSAD_op_;
275 };
276 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(HighbdMaskedSADTest);
277
runHighbdMaskedSADTest(int run_times)278 void HighbdMaskedSADTest::runHighbdMaskedSADTest(int run_times) {
279 unsigned int ref_ret = 0, ret = 1;
280 ACMRandom rnd(ACMRandom::DeterministicSeed());
281 DECLARE_ALIGNED(16, uint16_t, src_ptr[MAX_SB_SIZE * MAX_SB_SIZE]);
282 DECLARE_ALIGNED(16, uint16_t, ref_ptr[MAX_SB_SIZE * MAX_SB_SIZE]);
283 DECLARE_ALIGNED(16, uint16_t, second_pred_ptr[MAX_SB_SIZE * MAX_SB_SIZE]);
284 DECLARE_ALIGNED(16, uint8_t, msk_ptr[MAX_SB_SIZE * MAX_SB_SIZE]);
285 uint8_t *src8_ptr = CONVERT_TO_BYTEPTR(src_ptr);
286 uint8_t *ref8_ptr = CONVERT_TO_BYTEPTR(ref_ptr);
287 uint8_t *second_pred8_ptr = CONVERT_TO_BYTEPTR(second_pred_ptr);
288 int err_count = 0;
289 int first_failure = -1;
290 int src_stride = MAX_SB_SIZE;
291 int ref_stride = MAX_SB_SIZE;
292 int msk_stride = MAX_SB_SIZE;
293 const int iters = run_times == 1 ? number_of_iterations : 1;
294 for (int i = 0; i < iters; ++i) {
295 for (int j = 0; j < MAX_SB_SIZE * MAX_SB_SIZE; j++) {
296 src_ptr[j] = rnd.Rand16() & 0xfff;
297 ref_ptr[j] = rnd.Rand16() & 0xfff;
298 second_pred_ptr[j] = rnd.Rand16() & 0xfff;
299 msk_ptr[j] = ((rnd.Rand8() & 0x7f) > 64) ? rnd.Rand8() & 0x3f : 64;
300 }
301
302 for (int invert_mask = 0; invert_mask < 2; ++invert_mask) {
303 aom_usec_timer timer;
304 aom_usec_timer_start(&timer);
305 for (int repeat = 0; repeat < run_times; ++repeat) {
306 ref_ret = ref_maskedSAD_op_(src8_ptr, src_stride, ref8_ptr, ref_stride,
307 second_pred8_ptr, msk_ptr, msk_stride,
308 invert_mask);
309 }
310 aom_usec_timer_mark(&timer);
311 const double time1 = static_cast<double>(aom_usec_timer_elapsed(&timer));
312 aom_usec_timer_start(&timer);
313 if (run_times == 1) {
314 API_REGISTER_STATE_CHECK(ret = maskedSAD_op_(src8_ptr, src_stride,
315 ref8_ptr, ref_stride,
316 second_pred8_ptr, msk_ptr,
317 msk_stride, invert_mask));
318 } else {
319 for (int repeat = 0; repeat < run_times; ++repeat) {
320 ret =
321 maskedSAD_op_(src8_ptr, src_stride, ref8_ptr, ref_stride,
322 second_pred8_ptr, msk_ptr, msk_stride, invert_mask);
323 }
324 }
325 aom_usec_timer_mark(&timer);
326 const double time2 = static_cast<double>(aom_usec_timer_elapsed(&timer));
327 if (run_times > 10) {
328 printf("%7.2f/%7.2fns", time1, time2);
329 printf("(%3.2f)\n", time1 / time2);
330 }
331 if (ret != ref_ret) {
332 err_count++;
333 if (first_failure == -1) first_failure = i;
334 }
335 }
336 }
337 EXPECT_EQ(0, err_count)
338 << "Error: High BD Masked SAD Test, output doesn't match. "
339 << "First failed at test case " << first_failure;
340 }
341
TEST_P(HighbdMaskedSADTest,OperationCheck)342 TEST_P(HighbdMaskedSADTest, OperationCheck) { runHighbdMaskedSADTest(1); }
343
TEST_P(HighbdMaskedSADTest,DISABLED_Speed)344 TEST_P(HighbdMaskedSADTest, DISABLED_Speed) { runHighbdMaskedSADTest(1000000); }
345 #endif // CONFIG_AV1_HIGHBITDEPTH
346
347 using std::make_tuple;
348
349 #if HAVE_SSSE3
350 const MaskedSADParam msad_test[] = {
351 make_tuple(&aom_masked_sad4x4_ssse3, &aom_masked_sad4x4_c),
352 make_tuple(&aom_masked_sad4x8_ssse3, &aom_masked_sad4x8_c),
353 make_tuple(&aom_masked_sad8x4_ssse3, &aom_masked_sad8x4_c),
354 make_tuple(&aom_masked_sad8x8_ssse3, &aom_masked_sad8x8_c),
355 make_tuple(&aom_masked_sad8x16_ssse3, &aom_masked_sad8x16_c),
356 make_tuple(&aom_masked_sad16x8_ssse3, &aom_masked_sad16x8_c),
357 make_tuple(&aom_masked_sad16x16_ssse3, &aom_masked_sad16x16_c),
358 make_tuple(&aom_masked_sad16x32_ssse3, &aom_masked_sad16x32_c),
359 make_tuple(&aom_masked_sad32x16_ssse3, &aom_masked_sad32x16_c),
360 make_tuple(&aom_masked_sad32x32_ssse3, &aom_masked_sad32x32_c),
361 make_tuple(&aom_masked_sad32x64_ssse3, &aom_masked_sad32x64_c),
362 make_tuple(&aom_masked_sad64x32_ssse3, &aom_masked_sad64x32_c),
363 make_tuple(&aom_masked_sad64x64_ssse3, &aom_masked_sad64x64_c),
364 make_tuple(&aom_masked_sad64x128_ssse3, &aom_masked_sad64x128_c),
365 make_tuple(&aom_masked_sad128x64_ssse3, &aom_masked_sad128x64_c),
366 make_tuple(&aom_masked_sad128x128_ssse3, &aom_masked_sad128x128_c),
367 #if !CONFIG_REALTIME_ONLY
368 make_tuple(&aom_masked_sad4x16_ssse3, &aom_masked_sad4x16_c),
369 make_tuple(&aom_masked_sad16x4_ssse3, &aom_masked_sad16x4_c),
370 make_tuple(&aom_masked_sad8x32_ssse3, &aom_masked_sad8x32_c),
371 make_tuple(&aom_masked_sad32x8_ssse3, &aom_masked_sad32x8_c),
372 make_tuple(&aom_masked_sad16x64_ssse3, &aom_masked_sad16x64_c),
373 make_tuple(&aom_masked_sad64x16_ssse3, &aom_masked_sad64x16_c),
374 #endif
375 };
376
377 INSTANTIATE_TEST_SUITE_P(SSSE3, MaskedSADTest, ::testing::ValuesIn(msad_test));
378
379 const MaskedSADx4Param msadx4_test[] = {
380 make_tuple(&aom_masked_sad4x4x4d_ssse3, &aom_masked_sad4x4x4d_c),
381 make_tuple(&aom_masked_sad4x8x4d_ssse3, &aom_masked_sad4x8x4d_c),
382 make_tuple(&aom_masked_sad8x4x4d_ssse3, &aom_masked_sad8x4x4d_c),
383 make_tuple(&aom_masked_sad8x8x4d_ssse3, &aom_masked_sad8x8x4d_c),
384 make_tuple(&aom_masked_sad8x16x4d_ssse3, &aom_masked_sad8x16x4d_c),
385 make_tuple(&aom_masked_sad16x8x4d_ssse3, &aom_masked_sad16x8x4d_c),
386 make_tuple(&aom_masked_sad16x16x4d_ssse3, &aom_masked_sad16x16x4d_c),
387 make_tuple(&aom_masked_sad16x32x4d_ssse3, &aom_masked_sad16x32x4d_c),
388 make_tuple(&aom_masked_sad32x16x4d_ssse3, &aom_masked_sad32x16x4d_c),
389 make_tuple(&aom_masked_sad32x32x4d_ssse3, &aom_masked_sad32x32x4d_c),
390 make_tuple(&aom_masked_sad32x64x4d_ssse3, &aom_masked_sad32x64x4d_c),
391 make_tuple(&aom_masked_sad64x32x4d_ssse3, &aom_masked_sad64x32x4d_c),
392 make_tuple(&aom_masked_sad64x64x4d_ssse3, &aom_masked_sad64x64x4d_c),
393 make_tuple(&aom_masked_sad64x128x4d_ssse3, &aom_masked_sad64x128x4d_c),
394 make_tuple(&aom_masked_sad128x64x4d_ssse3, &aom_masked_sad128x64x4d_c),
395 make_tuple(&aom_masked_sad128x128x4d_ssse3, &aom_masked_sad128x128x4d_c),
396 #if !CONFIG_REALTIME_ONLY
397 make_tuple(&aom_masked_sad4x16x4d_ssse3, &aom_masked_sad4x16x4d_c),
398 make_tuple(&aom_masked_sad16x4x4d_ssse3, &aom_masked_sad16x4x4d_c),
399 make_tuple(&aom_masked_sad8x32x4d_ssse3, &aom_masked_sad8x32x4d_c),
400 make_tuple(&aom_masked_sad32x8x4d_ssse3, &aom_masked_sad32x8x4d_c),
401 make_tuple(&aom_masked_sad16x64x4d_ssse3, &aom_masked_sad16x64x4d_c),
402 make_tuple(&aom_masked_sad64x16x4d_ssse3, &aom_masked_sad64x16x4d_c),
403 #endif
404 };
405
406 INSTANTIATE_TEST_SUITE_P(SSSE3, MaskedSADx4Test,
407 ::testing::ValuesIn(msadx4_test));
408
409 #if CONFIG_AV1_HIGHBITDEPTH
410 const HighbdMaskedSADParam hbd_msad_test[] = {
411 make_tuple(&aom_highbd_masked_sad4x4_ssse3, &aom_highbd_masked_sad4x4_c),
412 make_tuple(&aom_highbd_masked_sad4x8_ssse3, &aom_highbd_masked_sad4x8_c),
413 make_tuple(&aom_highbd_masked_sad8x4_ssse3, &aom_highbd_masked_sad8x4_c),
414 make_tuple(&aom_highbd_masked_sad8x8_ssse3, &aom_highbd_masked_sad8x8_c),
415 make_tuple(&aom_highbd_masked_sad8x16_ssse3, &aom_highbd_masked_sad8x16_c),
416 make_tuple(&aom_highbd_masked_sad16x8_ssse3, &aom_highbd_masked_sad16x8_c),
417 make_tuple(&aom_highbd_masked_sad16x16_ssse3, &aom_highbd_masked_sad16x16_c),
418 make_tuple(&aom_highbd_masked_sad16x32_ssse3, &aom_highbd_masked_sad16x32_c),
419 make_tuple(&aom_highbd_masked_sad32x16_ssse3, &aom_highbd_masked_sad32x16_c),
420 make_tuple(&aom_highbd_masked_sad32x32_ssse3, &aom_highbd_masked_sad32x32_c),
421 make_tuple(&aom_highbd_masked_sad32x64_ssse3, &aom_highbd_masked_sad32x64_c),
422 make_tuple(&aom_highbd_masked_sad64x32_ssse3, &aom_highbd_masked_sad64x32_c),
423 make_tuple(&aom_highbd_masked_sad64x64_ssse3, &aom_highbd_masked_sad64x64_c),
424 make_tuple(&aom_highbd_masked_sad64x128_ssse3,
425 &aom_highbd_masked_sad64x128_c),
426 make_tuple(&aom_highbd_masked_sad128x64_ssse3,
427 &aom_highbd_masked_sad128x64_c),
428 make_tuple(&aom_highbd_masked_sad128x128_ssse3,
429 &aom_highbd_masked_sad128x128_c),
430 #if !CONFIG_REALTIME_ONLY
431 make_tuple(&aom_highbd_masked_sad4x16_ssse3, &aom_highbd_masked_sad4x16_c),
432 make_tuple(&aom_highbd_masked_sad16x4_ssse3, &aom_highbd_masked_sad16x4_c),
433 make_tuple(&aom_highbd_masked_sad8x32_ssse3, &aom_highbd_masked_sad8x32_c),
434 make_tuple(&aom_highbd_masked_sad32x8_ssse3, &aom_highbd_masked_sad32x8_c),
435 make_tuple(&aom_highbd_masked_sad16x64_ssse3, &aom_highbd_masked_sad16x64_c),
436 make_tuple(&aom_highbd_masked_sad64x16_ssse3, &aom_highbd_masked_sad64x16_c),
437 #endif
438 };
439
440 INSTANTIATE_TEST_SUITE_P(SSSE3, HighbdMaskedSADTest,
441 ::testing::ValuesIn(hbd_msad_test));
442 #endif // CONFIG_AV1_HIGHBITDEPTH
443 #endif // HAVE_SSSE3
444
445 #if HAVE_AVX2
446 const MaskedSADParam msad_avx2_test[] = {
447 make_tuple(&aom_masked_sad4x4_avx2, &aom_masked_sad4x4_ssse3),
448 make_tuple(&aom_masked_sad4x8_avx2, &aom_masked_sad4x8_ssse3),
449 make_tuple(&aom_masked_sad8x4_avx2, &aom_masked_sad8x4_ssse3),
450 make_tuple(&aom_masked_sad8x8_avx2, &aom_masked_sad8x8_ssse3),
451 make_tuple(&aom_masked_sad8x16_avx2, &aom_masked_sad8x16_ssse3),
452 make_tuple(&aom_masked_sad16x8_avx2, &aom_masked_sad16x8_ssse3),
453 make_tuple(&aom_masked_sad16x16_avx2, &aom_masked_sad16x16_ssse3),
454 make_tuple(&aom_masked_sad16x32_avx2, &aom_masked_sad16x32_ssse3),
455 make_tuple(&aom_masked_sad32x16_avx2, &aom_masked_sad32x16_ssse3),
456 make_tuple(&aom_masked_sad32x32_avx2, &aom_masked_sad32x32_ssse3),
457 make_tuple(&aom_masked_sad32x64_avx2, &aom_masked_sad32x64_ssse3),
458 make_tuple(&aom_masked_sad64x32_avx2, &aom_masked_sad64x32_ssse3),
459 make_tuple(&aom_masked_sad64x64_avx2, &aom_masked_sad64x64_ssse3),
460 make_tuple(&aom_masked_sad64x128_avx2, &aom_masked_sad64x128_ssse3),
461 make_tuple(&aom_masked_sad128x64_avx2, &aom_masked_sad128x64_ssse3),
462 make_tuple(&aom_masked_sad128x128_avx2, &aom_masked_sad128x128_ssse3),
463 #if !CONFIG_REALTIME_ONLY
464 make_tuple(&aom_masked_sad4x16_avx2, &aom_masked_sad4x16_ssse3),
465 make_tuple(&aom_masked_sad16x4_avx2, &aom_masked_sad16x4_ssse3),
466 make_tuple(&aom_masked_sad8x32_avx2, &aom_masked_sad8x32_ssse3),
467 make_tuple(&aom_masked_sad32x8_avx2, &aom_masked_sad32x8_ssse3),
468 make_tuple(&aom_masked_sad16x64_avx2, &aom_masked_sad16x64_ssse3),
469 make_tuple(&aom_masked_sad64x16_avx2, &aom_masked_sad64x16_ssse3)
470 #endif
471 };
472
473 INSTANTIATE_TEST_SUITE_P(AVX2, MaskedSADTest,
474 ::testing::ValuesIn(msad_avx2_test));
475
476 #if CONFIG_AV1_HIGHBITDEPTH
477 const HighbdMaskedSADParam hbd_msad_avx2_test[] = {
478 make_tuple(&aom_highbd_masked_sad4x4_avx2, &aom_highbd_masked_sad4x4_ssse3),
479 make_tuple(&aom_highbd_masked_sad4x8_avx2, &aom_highbd_masked_sad4x8_ssse3),
480 make_tuple(&aom_highbd_masked_sad8x4_avx2, &aom_highbd_masked_sad8x4_ssse3),
481 make_tuple(&aom_highbd_masked_sad8x8_avx2, &aom_highbd_masked_sad8x8_ssse3),
482 make_tuple(&aom_highbd_masked_sad8x16_avx2, &aom_highbd_masked_sad8x16_ssse3),
483 make_tuple(&aom_highbd_masked_sad16x8_avx2, &aom_highbd_masked_sad16x8_ssse3),
484 make_tuple(&aom_highbd_masked_sad16x16_avx2,
485 &aom_highbd_masked_sad16x16_ssse3),
486 make_tuple(&aom_highbd_masked_sad16x32_avx2,
487 &aom_highbd_masked_sad16x32_ssse3),
488 make_tuple(&aom_highbd_masked_sad32x16_avx2,
489 &aom_highbd_masked_sad32x16_ssse3),
490 make_tuple(&aom_highbd_masked_sad32x32_avx2,
491 &aom_highbd_masked_sad32x32_ssse3),
492 make_tuple(&aom_highbd_masked_sad32x64_avx2,
493 &aom_highbd_masked_sad32x64_ssse3),
494 make_tuple(&aom_highbd_masked_sad64x32_avx2,
495 &aom_highbd_masked_sad64x32_ssse3),
496 make_tuple(&aom_highbd_masked_sad64x64_avx2,
497 &aom_highbd_masked_sad64x64_ssse3),
498 make_tuple(&aom_highbd_masked_sad64x128_avx2,
499 &aom_highbd_masked_sad64x128_ssse3),
500 make_tuple(&aom_highbd_masked_sad128x64_avx2,
501 &aom_highbd_masked_sad128x64_ssse3),
502 make_tuple(&aom_highbd_masked_sad128x128_avx2,
503 &aom_highbd_masked_sad128x128_ssse3),
504 #if !CONFIG_REALTIME_ONLY
505 make_tuple(&aom_highbd_masked_sad4x16_avx2, &aom_highbd_masked_sad4x16_ssse3),
506 make_tuple(&aom_highbd_masked_sad16x4_avx2, &aom_highbd_masked_sad16x4_ssse3),
507 make_tuple(&aom_highbd_masked_sad8x32_avx2, &aom_highbd_masked_sad8x32_ssse3),
508 make_tuple(&aom_highbd_masked_sad32x8_avx2, &aom_highbd_masked_sad32x8_ssse3),
509 make_tuple(&aom_highbd_masked_sad16x64_avx2,
510 &aom_highbd_masked_sad16x64_ssse3),
511 make_tuple(&aom_highbd_masked_sad64x16_avx2,
512 &aom_highbd_masked_sad64x16_ssse3)
513 #endif
514 };
515
516 INSTANTIATE_TEST_SUITE_P(AVX2, HighbdMaskedSADTest,
517 ::testing::ValuesIn(hbd_msad_avx2_test));
518 #endif // CONFIG_AV1_HIGHBITDEPTH
519 #endif // HAVE_AVX2
520
521 #if HAVE_NEON
522 const MaskedSADParam msad_test[] = {
523 make_tuple(&aom_masked_sad4x4_neon, &aom_masked_sad4x4_c),
524 make_tuple(&aom_masked_sad4x8_neon, &aom_masked_sad4x8_c),
525 make_tuple(&aom_masked_sad8x4_neon, &aom_masked_sad8x4_c),
526 make_tuple(&aom_masked_sad8x8_neon, &aom_masked_sad8x8_c),
527 make_tuple(&aom_masked_sad8x16_neon, &aom_masked_sad8x16_c),
528 make_tuple(&aom_masked_sad16x8_neon, &aom_masked_sad16x8_c),
529 make_tuple(&aom_masked_sad16x16_neon, &aom_masked_sad16x16_c),
530 make_tuple(&aom_masked_sad16x32_neon, &aom_masked_sad16x32_c),
531 make_tuple(&aom_masked_sad32x16_neon, &aom_masked_sad32x16_c),
532 make_tuple(&aom_masked_sad32x32_neon, &aom_masked_sad32x32_c),
533 make_tuple(&aom_masked_sad32x64_neon, &aom_masked_sad32x64_c),
534 make_tuple(&aom_masked_sad64x32_neon, &aom_masked_sad64x32_c),
535 make_tuple(&aom_masked_sad64x64_neon, &aom_masked_sad64x64_c),
536 make_tuple(&aom_masked_sad64x128_neon, &aom_masked_sad64x128_c),
537 make_tuple(&aom_masked_sad128x64_neon, &aom_masked_sad128x64_c),
538 make_tuple(&aom_masked_sad128x128_neon, &aom_masked_sad128x128_c),
539 #if !CONFIG_REALTIME_ONLY
540 make_tuple(&aom_masked_sad4x16_neon, &aom_masked_sad4x16_c),
541 make_tuple(&aom_masked_sad16x4_neon, &aom_masked_sad16x4_c),
542 make_tuple(&aom_masked_sad8x32_neon, &aom_masked_sad8x32_c),
543 make_tuple(&aom_masked_sad32x8_neon, &aom_masked_sad32x8_c),
544 make_tuple(&aom_masked_sad16x64_neon, &aom_masked_sad16x64_c),
545 make_tuple(&aom_masked_sad64x16_neon, &aom_masked_sad64x16_c),
546 #endif
547 };
548
549 INSTANTIATE_TEST_SUITE_P(NEON, MaskedSADTest, ::testing::ValuesIn(msad_test));
550
551 const MaskedSADx4Param msadx4_test[] = {
552 make_tuple(&aom_masked_sad4x4x4d_neon, &aom_masked_sad4x4x4d_c),
553 make_tuple(&aom_masked_sad4x8x4d_neon, &aom_masked_sad4x8x4d_c),
554 make_tuple(&aom_masked_sad8x4x4d_neon, &aom_masked_sad8x4x4d_c),
555 make_tuple(&aom_masked_sad8x8x4d_neon, &aom_masked_sad8x8x4d_c),
556 make_tuple(&aom_masked_sad8x16x4d_neon, &aom_masked_sad8x16x4d_c),
557 make_tuple(&aom_masked_sad16x8x4d_neon, &aom_masked_sad16x8x4d_c),
558 make_tuple(&aom_masked_sad16x16x4d_neon, &aom_masked_sad16x16x4d_c),
559 make_tuple(&aom_masked_sad16x32x4d_neon, &aom_masked_sad16x32x4d_c),
560 make_tuple(&aom_masked_sad32x16x4d_neon, &aom_masked_sad32x16x4d_c),
561 make_tuple(&aom_masked_sad32x32x4d_neon, &aom_masked_sad32x32x4d_c),
562 make_tuple(&aom_masked_sad32x64x4d_neon, &aom_masked_sad32x64x4d_c),
563 make_tuple(&aom_masked_sad64x32x4d_neon, &aom_masked_sad64x32x4d_c),
564 make_tuple(&aom_masked_sad64x64x4d_neon, &aom_masked_sad64x64x4d_c),
565 make_tuple(&aom_masked_sad64x128x4d_neon, &aom_masked_sad64x128x4d_c),
566 make_tuple(&aom_masked_sad128x64x4d_neon, &aom_masked_sad128x64x4d_c),
567 make_tuple(&aom_masked_sad128x128x4d_neon, &aom_masked_sad128x128x4d_c),
568 #if !CONFIG_REALTIME_ONLY
569 make_tuple(&aom_masked_sad4x16x4d_neon, &aom_masked_sad4x16x4d_c),
570 make_tuple(&aom_masked_sad16x4x4d_neon, &aom_masked_sad16x4x4d_c),
571 make_tuple(&aom_masked_sad8x32x4d_neon, &aom_masked_sad8x32x4d_c),
572 make_tuple(&aom_masked_sad32x8x4d_neon, &aom_masked_sad32x8x4d_c),
573 make_tuple(&aom_masked_sad16x64x4d_neon, &aom_masked_sad16x64x4d_c),
574 make_tuple(&aom_masked_sad64x16x4d_neon, &aom_masked_sad64x16x4d_c),
575 #endif
576 };
577
578 INSTANTIATE_TEST_SUITE_P(NEON, MaskedSADx4Test,
579 ::testing::ValuesIn(msadx4_test));
580
581 #if CONFIG_AV1_HIGHBITDEPTH
582 const MaskedSADParam hbd_msad_neon_test[] = {
583 make_tuple(&aom_highbd_masked_sad4x4_neon, &aom_highbd_masked_sad4x4_c),
584 make_tuple(&aom_highbd_masked_sad4x8_neon, &aom_highbd_masked_sad4x8_c),
585 make_tuple(&aom_highbd_masked_sad8x4_neon, &aom_highbd_masked_sad8x4_c),
586 make_tuple(&aom_highbd_masked_sad8x8_neon, &aom_highbd_masked_sad8x8_c),
587 make_tuple(&aom_highbd_masked_sad8x16_neon, &aom_highbd_masked_sad8x16_c),
588 make_tuple(&aom_highbd_masked_sad16x8_neon, &aom_highbd_masked_sad16x8_c),
589 make_tuple(&aom_highbd_masked_sad16x16_neon, &aom_highbd_masked_sad16x16_c),
590 make_tuple(&aom_highbd_masked_sad16x32_neon, &aom_highbd_masked_sad16x32_c),
591 make_tuple(&aom_highbd_masked_sad32x16_neon, &aom_highbd_masked_sad32x16_c),
592 make_tuple(&aom_highbd_masked_sad32x32_neon, &aom_highbd_masked_sad32x32_c),
593 make_tuple(&aom_highbd_masked_sad32x64_neon, &aom_highbd_masked_sad32x64_c),
594 make_tuple(&aom_highbd_masked_sad64x32_neon, &aom_highbd_masked_sad64x32_c),
595 make_tuple(&aom_highbd_masked_sad64x64_neon, &aom_highbd_masked_sad64x64_c),
596 make_tuple(&aom_highbd_masked_sad64x128_neon, &aom_highbd_masked_sad64x128_c),
597 make_tuple(&aom_highbd_masked_sad128x64_neon, &aom_highbd_masked_sad128x64_c),
598 make_tuple(&aom_highbd_masked_sad128x128_neon,
599 &aom_highbd_masked_sad128x128_c),
600 #if !CONFIG_REALTIME_ONLY
601 make_tuple(&aom_highbd_masked_sad4x16_neon, &aom_highbd_masked_sad4x16_c),
602 make_tuple(&aom_highbd_masked_sad16x4_neon, &aom_highbd_masked_sad16x4_c),
603 make_tuple(&aom_highbd_masked_sad8x32_neon, &aom_highbd_masked_sad8x32_c),
604 make_tuple(&aom_highbd_masked_sad32x8_neon, &aom_highbd_masked_sad32x8_c),
605 make_tuple(&aom_highbd_masked_sad16x64_neon, &aom_highbd_masked_sad16x64_c),
606 make_tuple(&aom_highbd_masked_sad64x16_neon, &aom_highbd_masked_sad64x16_c),
607 #endif // !CONFIG_REALTIME_ONLY
608 };
609
610 INSTANTIATE_TEST_SUITE_P(NEON, HighbdMaskedSADTest,
611 ::testing::ValuesIn(hbd_msad_neon_test));
612
613 #endif // CONFIG_AV1_HIGHBITDEPTH
614
615 #endif // HAVE_NEON
616
617 } // namespace
618