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
12 #include <string.h>
13 #include <limits.h>
14 #include <stdio.h>
15 #include <tuple>
16
17 #include "gtest/gtest.h"
18
19 #include "config/aom_config.h"
20 #include "config/aom_dsp_rtcd.h"
21
22 #include "test/acm_random.h"
23 #include "test/register_state_check.h"
24 #include "test/util.h"
25 #include "aom/aom_codec.h"
26 #include "aom_mem/aom_mem.h"
27 #include "aom_ports/mem.h"
28
29 typedef unsigned int (*SadMxNFunc)(const uint8_t *src_ptr, int src_stride,
30 const uint8_t *ref_ptr, int ref_stride);
31 typedef std::tuple<int, int, SadMxNFunc, int> SadMxNParam;
32
33 typedef unsigned int (*SadSkipMxNFunc)(const uint8_t *src_ptr, int src_stride,
34 const uint8_t *ref_ptr, int ref_stride);
35 typedef std::tuple<int, int, SadSkipMxNFunc, int> SadSkipMxNParam;
36
37 typedef uint32_t (*SadMxNAvgFunc)(const uint8_t *src_ptr, int src_stride,
38 const uint8_t *ref_ptr, int ref_stride,
39 const uint8_t *second_pred);
40 typedef std::tuple<int, int, SadMxNAvgFunc, int> SadMxNAvgParam;
41
42 typedef unsigned int (*DistWtdSadMxhFunc)(const uint8_t *src_ptr,
43 int src_stride,
44 const uint8_t *ref_ptr,
45 int ref_stride, int width,
46 int height);
47 typedef std::tuple<int, int, DistWtdSadMxhFunc, int> DistWtdSadMxhParam;
48
49 typedef uint32_t (*DistWtdSadMxNAvgFunc)(const uint8_t *src_ptr, int src_stride,
50 const uint8_t *ref_ptr, int ref_stride,
51 const uint8_t *second_pred,
52 const DIST_WTD_COMP_PARAMS *jcp_param);
53 typedef std::tuple<int, int, DistWtdSadMxNAvgFunc, int> DistWtdSadMxNAvgParam;
54
55 typedef void (*SadMxNx4Func)(const uint8_t *src_ptr, int src_stride,
56 const uint8_t *const ref_ptr[], int ref_stride,
57 uint32_t *sad_array);
58 typedef std::tuple<int, int, SadMxNx4Func, int> SadMxNx4Param;
59
60 typedef void (*SadSkipMxNx4Func)(const uint8_t *src_ptr, int src_stride,
61 const uint8_t *const ref_ptr[], int ref_stride,
62 uint32_t *sad_array);
63 typedef std::tuple<int, int, SadSkipMxNx4Func, int> SadSkipMxNx4Param;
64
65 typedef void (*SadMxNx4AvgFunc)(const uint8_t *src_ptr, int src_stride,
66 const uint8_t *const ref_ptr[], int ref_stride,
67 const uint8_t *second_pred,
68 uint32_t *sad_array);
69 typedef std::tuple<int, int, SadMxNx4AvgFunc, int> SadMxNx4AvgParam;
70
71 using libaom_test::ACMRandom;
72
73 namespace {
74 class SADTestBase : public ::testing::Test {
75 public:
SADTestBase(int width,int height,int bit_depth)76 SADTestBase(int width, int height, int bit_depth)
77 : width_(width), height_(height), bd_(bit_depth) {}
78
SetUpTestSuite()79 static void SetUpTestSuite() {
80 source_data8_ = reinterpret_cast<uint8_t *>(
81 aom_memalign(kDataAlignment, kDataBlockSize));
82 ASSERT_NE(source_data8_, nullptr);
83 reference_data8_ = reinterpret_cast<uint8_t *>(
84 aom_memalign(kDataAlignment, kDataBufferSize));
85 ASSERT_NE(reference_data8_, nullptr);
86 second_pred8_ =
87 reinterpret_cast<uint8_t *>(aom_memalign(kDataAlignment, 128 * 128));
88 ASSERT_NE(second_pred8_, nullptr);
89 comp_pred8_ =
90 reinterpret_cast<uint8_t *>(aom_memalign(kDataAlignment, 128 * 128));
91 ASSERT_NE(comp_pred8_, nullptr);
92 comp_pred8_test_ =
93 reinterpret_cast<uint8_t *>(aom_memalign(kDataAlignment, 128 * 128));
94 ASSERT_NE(comp_pred8_test_, nullptr);
95 source_data16_ = reinterpret_cast<uint16_t *>(
96 aom_memalign(kDataAlignment, kDataBlockSize * sizeof(uint16_t)));
97 ASSERT_NE(source_data16_, nullptr);
98 reference_data16_ = reinterpret_cast<uint16_t *>(
99 aom_memalign(kDataAlignment, kDataBufferSize * sizeof(uint16_t)));
100 ASSERT_NE(reference_data16_, nullptr);
101 second_pred16_ = reinterpret_cast<uint16_t *>(
102 aom_memalign(kDataAlignment, 128 * 128 * sizeof(uint16_t)));
103 ASSERT_NE(second_pred16_, nullptr);
104 comp_pred16_ = reinterpret_cast<uint16_t *>(
105 aom_memalign(kDataAlignment, 128 * 128 * sizeof(uint16_t)));
106 ASSERT_NE(comp_pred16_, nullptr);
107 comp_pred16_test_ = reinterpret_cast<uint16_t *>(
108 aom_memalign(kDataAlignment, 128 * 128 * sizeof(uint16_t)));
109 ASSERT_NE(comp_pred16_test_, nullptr);
110 }
111
TearDownTestSuite()112 static void TearDownTestSuite() {
113 aom_free(source_data8_);
114 source_data8_ = nullptr;
115 aom_free(reference_data8_);
116 reference_data8_ = nullptr;
117 aom_free(second_pred8_);
118 second_pred8_ = nullptr;
119 aom_free(comp_pred8_);
120 comp_pred8_ = nullptr;
121 aom_free(comp_pred8_test_);
122 comp_pred8_test_ = nullptr;
123 aom_free(source_data16_);
124 source_data16_ = nullptr;
125 aom_free(reference_data16_);
126 reference_data16_ = nullptr;
127 aom_free(second_pred16_);
128 second_pred16_ = nullptr;
129 aom_free(comp_pred16_);
130 comp_pred16_ = nullptr;
131 aom_free(comp_pred16_test_);
132 comp_pred16_test_ = nullptr;
133 }
134
135 protected:
136 // Handle up to 4 128x128 blocks, with stride up to 256
137 static const int kDataAlignment = 16;
138 static const int kDataBlockSize = 128 * 256;
139 static const int kDataBufferSize = 4 * kDataBlockSize;
140
SetUp()141 void SetUp() override {
142 if (bd_ == -1) {
143 use_high_bit_depth_ = false;
144 bit_depth_ = AOM_BITS_8;
145 source_data_ = source_data8_;
146 reference_data_ = reference_data8_;
147 second_pred_ = second_pred8_;
148 comp_pred_ = comp_pred8_;
149 comp_pred_test_ = comp_pred8_test_;
150 } else {
151 use_high_bit_depth_ = true;
152 bit_depth_ = static_cast<aom_bit_depth_t>(bd_);
153 source_data_ = CONVERT_TO_BYTEPTR(source_data16_);
154 reference_data_ = CONVERT_TO_BYTEPTR(reference_data16_);
155 second_pred_ = CONVERT_TO_BYTEPTR(second_pred16_);
156 comp_pred_ = CONVERT_TO_BYTEPTR(comp_pred16_);
157 comp_pred_test_ = CONVERT_TO_BYTEPTR(comp_pred16_test_);
158 }
159 mask_ = (1 << bit_depth_) - 1;
160 source_stride_ = (width_ + 31) & ~31;
161 reference_stride_ = width_ * 2;
162 rnd_.Reset(ACMRandom::DeterministicSeed());
163 }
164
GetReference(int block_idx)165 virtual uint8_t *GetReference(int block_idx) {
166 if (use_high_bit_depth_)
167 return CONVERT_TO_BYTEPTR(CONVERT_TO_SHORTPTR(reference_data_) +
168 block_idx * kDataBlockSize);
169 return reference_data_ + block_idx * kDataBlockSize;
170 }
171
172 // Sum of Absolute Differences. Given two blocks, calculate the absolute
173 // difference between two pixels in the same relative location; accumulate.
ReferenceSAD(int block_idx)174 unsigned int ReferenceSAD(int block_idx) {
175 unsigned int sad = 0;
176 const uint8_t *const reference8 = GetReference(block_idx);
177 const uint8_t *const source8 = source_data_;
178 const uint16_t *const reference16 =
179 CONVERT_TO_SHORTPTR(GetReference(block_idx));
180 const uint16_t *const source16 = CONVERT_TO_SHORTPTR(source_data_);
181 for (int h = 0; h < height_; ++h) {
182 for (int w = 0; w < width_; ++w) {
183 if (!use_high_bit_depth_) {
184 sad += abs(source8[h * source_stride_ + w] -
185 reference8[h * reference_stride_ + w]);
186 } else {
187 sad += abs(source16[h * source_stride_ + w] -
188 reference16[h * reference_stride_ + w]);
189 }
190 }
191 }
192 return sad;
193 }
194
195 // Sum of Absolute Differences Skip rows. Given two blocks,
196 // calculate the absolute difference between two pixels in the same
197 // relative location every other row; accumulate and double the result at the
198 // end.
ReferenceSADSkip(int block_idx)199 unsigned int ReferenceSADSkip(int block_idx) {
200 unsigned int sad = 0;
201 const uint8_t *const reference8 = GetReference(block_idx);
202 const uint8_t *const source8 = source_data_;
203 const uint16_t *const reference16 =
204 CONVERT_TO_SHORTPTR(GetReference(block_idx));
205 const uint16_t *const source16 = CONVERT_TO_SHORTPTR(source_data_);
206 for (int h = 0; h < height_; h += 2) {
207 for (int w = 0; w < width_; ++w) {
208 if (!use_high_bit_depth_) {
209 sad += abs(source8[h * source_stride_ + w] -
210 reference8[h * reference_stride_ + w]);
211 } else {
212 sad += abs(source16[h * source_stride_ + w] -
213 reference16[h * reference_stride_ + w]);
214 }
215 }
216 }
217 return sad * 2;
218 }
219
220 // Sum of Absolute Differences Average. Given two blocks, and a prediction
221 // calculate the absolute difference between one pixel and average of the
222 // corresponding and predicted pixels; accumulate.
ReferenceSADavg(int block_idx)223 unsigned int ReferenceSADavg(int block_idx) {
224 unsigned int sad = 0;
225 const uint8_t *const reference8 = GetReference(block_idx);
226 const uint8_t *const source8 = source_data_;
227 const uint8_t *const second_pred8 = second_pred_;
228 const uint16_t *const reference16 =
229 CONVERT_TO_SHORTPTR(GetReference(block_idx));
230 const uint16_t *const source16 = CONVERT_TO_SHORTPTR(source_data_);
231 const uint16_t *const second_pred16 = CONVERT_TO_SHORTPTR(second_pred_);
232 for (int h = 0; h < height_; ++h) {
233 for (int w = 0; w < width_; ++w) {
234 if (!use_high_bit_depth_) {
235 const int tmp = second_pred8[h * width_ + w] +
236 reference8[h * reference_stride_ + w];
237 const uint8_t comp_pred = ROUND_POWER_OF_TWO(tmp, 1);
238 sad += abs(source8[h * source_stride_ + w] - comp_pred);
239 } else {
240 const int tmp = second_pred16[h * width_ + w] +
241 reference16[h * reference_stride_ + w];
242 const uint16_t comp_pred = ROUND_POWER_OF_TWO(tmp, 1);
243 sad += abs(source16[h * source_stride_ + w] - comp_pred);
244 }
245 }
246 }
247 return sad;
248 }
249
ReferenceDistWtdSADavg(int block_idx)250 unsigned int ReferenceDistWtdSADavg(int block_idx) {
251 unsigned int sad = 0;
252 const uint8_t *const reference8 = GetReference(block_idx);
253 const uint8_t *const source8 = source_data_;
254 const uint8_t *const second_pred8 = second_pred_;
255 const uint16_t *const reference16 =
256 CONVERT_TO_SHORTPTR(GetReference(block_idx));
257 const uint16_t *const source16 = CONVERT_TO_SHORTPTR(source_data_);
258 const uint16_t *const second_pred16 = CONVERT_TO_SHORTPTR(second_pred_);
259 for (int h = 0; h < height_; ++h) {
260 for (int w = 0; w < width_; ++w) {
261 if (!use_high_bit_depth_) {
262 const int tmp =
263 second_pred8[h * width_ + w] * jcp_param_.bck_offset +
264 reference8[h * reference_stride_ + w] * jcp_param_.fwd_offset;
265 const uint8_t comp_pred = ROUND_POWER_OF_TWO(tmp, 4);
266 sad += abs(source8[h * source_stride_ + w] - comp_pred);
267 } else {
268 const int tmp =
269 second_pred16[h * width_ + w] * jcp_param_.bck_offset +
270 reference16[h * reference_stride_ + w] * jcp_param_.fwd_offset;
271 const uint16_t comp_pred = ROUND_POWER_OF_TWO(tmp, 4);
272 sad += abs(source16[h * source_stride_ + w] - comp_pred);
273 }
274 }
275 }
276 return sad;
277 }
278
FillConstant(uint8_t * data,int stride,uint16_t fill_constant)279 void FillConstant(uint8_t *data, int stride, uint16_t fill_constant) {
280 uint8_t *data8 = data;
281 uint16_t *data16 = CONVERT_TO_SHORTPTR(data);
282 for (int h = 0; h < height_; ++h) {
283 for (int w = 0; w < width_; ++w) {
284 if (!use_high_bit_depth_) {
285 data8[h * stride + w] = static_cast<uint8_t>(fill_constant);
286 } else {
287 data16[h * stride + w] = fill_constant;
288 }
289 }
290 }
291 }
292
FillRandom(uint8_t * data,int stride)293 void FillRandom(uint8_t *data, int stride) {
294 uint8_t *data8 = data;
295 uint16_t *data16 = CONVERT_TO_SHORTPTR(data);
296 for (int h = 0; h < height_; ++h) {
297 for (int w = 0; w < width_; ++w) {
298 if (!use_high_bit_depth_) {
299 data8[h * stride + w] = rnd_.Rand8();
300 } else {
301 data16[h * stride + w] = rnd_.Rand16() & mask_;
302 }
303 }
304 }
305 }
306
SADForSpeedTest(unsigned int * results,const uint8_t * const * references)307 virtual void SADForSpeedTest(unsigned int *results,
308 const uint8_t *const *references) {
309 (void)results;
310 (void)references;
311 }
312
SpeedSAD()313 void SpeedSAD() {
314 int test_count = 20000000;
315 unsigned int exp_sad[4];
316 const uint8_t *references[] = { GetReference(0), GetReference(1),
317 GetReference(2), GetReference(3) };
318 aom_usec_timer timer;
319 aom_usec_timer_start(&timer);
320 while (test_count > 0) {
321 SADForSpeedTest(exp_sad, references);
322 test_count -= 1;
323 }
324 aom_usec_timer_mark(&timer);
325 const int64_t time = aom_usec_timer_elapsed(&timer) / 1000;
326 std::cout << "BLOCK_" << width_ << "X" << height_
327 << ", bit_depth:" << bit_depth_ << ",Time: " << time << "ms"
328 << std::endl;
329 }
330
331 int width_, height_, mask_, bd_;
332 aom_bit_depth_t bit_depth_;
333 static uint8_t *source_data_;
334 static uint8_t *reference_data_;
335 static uint8_t *second_pred_;
336 int source_stride_;
337 bool use_high_bit_depth_;
338 static uint8_t *source_data8_;
339 static uint8_t *reference_data8_;
340 static uint8_t *second_pred8_;
341 static uint16_t *source_data16_;
342 static uint16_t *reference_data16_;
343 static uint16_t *second_pred16_;
344 int reference_stride_;
345 static uint8_t *comp_pred_;
346 static uint8_t *comp_pred8_;
347 static uint16_t *comp_pred16_;
348 static uint8_t *comp_pred_test_;
349 static uint8_t *comp_pred8_test_;
350 static uint16_t *comp_pred16_test_;
351 DIST_WTD_COMP_PARAMS jcp_param_;
352
353 ACMRandom rnd_;
354 };
355
356 class SADx4Test : public ::testing::WithParamInterface<SadMxNx4Param>,
357 public SADTestBase {
358 public:
SADx4Test()359 SADx4Test() : SADTestBase(GET_PARAM(0), GET_PARAM(1), GET_PARAM(3)) {}
360
361 protected:
SADs(unsigned int * results)362 void SADs(unsigned int *results) {
363 const uint8_t *references[] = { GetReference(0), GetReference(1),
364 GetReference(2), GetReference(3) };
365
366 API_REGISTER_STATE_CHECK(GET_PARAM(2)(
367 source_data_, source_stride_, references, reference_stride_, results));
368 }
369
SADForSpeedTest(unsigned int * results,const uint8_t * const * references)370 void SADForSpeedTest(unsigned int *results,
371 const uint8_t *const *references) override {
372 GET_PARAM(2)
373 (source_data_, source_stride_, references, reference_stride_, results);
374 }
375
CheckSADs()376 void CheckSADs() {
377 unsigned int reference_sad, exp_sad[4];
378 SADs(exp_sad);
379 for (int block = 0; block < 4; ++block) {
380 reference_sad = ReferenceSAD(block);
381
382 EXPECT_EQ(reference_sad, exp_sad[block]) << "block " << block;
383 }
384 }
385 };
386
387 class SADx3Test : public ::testing::WithParamInterface<SadMxNx4Param>,
388 public SADTestBase {
389 public:
SADx3Test()390 SADx3Test() : SADTestBase(GET_PARAM(0), GET_PARAM(1), GET_PARAM(3)) {}
391
392 protected:
SADs(unsigned int * results)393 void SADs(unsigned int *results) {
394 const uint8_t *references[] = { GetReference(0), GetReference(1),
395 GetReference(2), GetReference(3) };
396
397 GET_PARAM(2)
398 (source_data_, source_stride_, references, reference_stride_, results);
399 }
400
SADForSpeedTest(unsigned int * results,const uint8_t * const * references)401 void SADForSpeedTest(unsigned int *results,
402 const uint8_t *const *references) override {
403 GET_PARAM(2)
404 (source_data_, source_stride_, references, reference_stride_, results);
405 }
406
CheckSADs()407 void CheckSADs() {
408 unsigned int reference_sad, exp_sad[4];
409
410 SADs(exp_sad);
411 for (int block = 0; block < 3; ++block) {
412 reference_sad = ReferenceSAD(block);
413
414 EXPECT_EQ(reference_sad, exp_sad[block]) << "block " << block;
415 }
416 }
417 };
418
419 class SADSkipx4Test : public ::testing::WithParamInterface<SadMxNx4Param>,
420 public SADTestBase {
421 public:
SADSkipx4Test()422 SADSkipx4Test() : SADTestBase(GET_PARAM(0), GET_PARAM(1), GET_PARAM(3)) {}
423
424 protected:
SADs(unsigned int * results)425 void SADs(unsigned int *results) {
426 const uint8_t *references[] = { GetReference(0), GetReference(1),
427 GetReference(2), GetReference(3) };
428
429 API_REGISTER_STATE_CHECK(GET_PARAM(2)(
430 source_data_, source_stride_, references, reference_stride_, results));
431 }
432
CheckSADs()433 void CheckSADs() {
434 unsigned int reference_sad, exp_sad[4];
435
436 SADs(exp_sad);
437 for (int block = 0; block < 4; ++block) {
438 reference_sad = ReferenceSADSkip(block);
439
440 EXPECT_EQ(reference_sad, exp_sad[block]) << "block " << block;
441 }
442 }
443
SADForSpeedTest(unsigned int * results,const uint8_t * const * references)444 void SADForSpeedTest(unsigned int *results,
445 const uint8_t *const *references) override {
446 GET_PARAM(2)
447 (source_data_, source_stride_, references, reference_stride_, results);
448 }
449 };
450
451 class SADTest : public ::testing::WithParamInterface<SadMxNParam>,
452 public SADTestBase {
453 public:
SADTest()454 SADTest() : SADTestBase(GET_PARAM(0), GET_PARAM(1), GET_PARAM(3)) {}
455
456 protected:
SAD(int block_idx)457 unsigned int SAD(int block_idx) {
458 unsigned int ret;
459 const uint8_t *const reference = GetReference(block_idx);
460
461 API_REGISTER_STATE_CHECK(ret = GET_PARAM(2)(source_data_, source_stride_,
462 reference, reference_stride_));
463 return ret;
464 }
465
CheckSAD()466 void CheckSAD() {
467 const unsigned int reference_sad = ReferenceSAD(0);
468 const unsigned int exp_sad = SAD(0);
469
470 ASSERT_EQ(reference_sad, exp_sad);
471 }
472
SADForSpeedTest(unsigned int * results,const uint8_t * const * references)473 void SADForSpeedTest(unsigned int *results,
474 const uint8_t *const *references) override {
475 GET_PARAM(2)
476 (source_data_, source_stride_, references[0], reference_stride_);
477 (void)results;
478 }
479 };
480
481 class SADSkipTest : public ::testing::WithParamInterface<SadMxNParam>,
482 public SADTestBase {
483 public:
SADSkipTest()484 SADSkipTest() : SADTestBase(GET_PARAM(0), GET_PARAM(1), GET_PARAM(3)) {}
485
486 protected:
SAD(int block_idx)487 unsigned int SAD(int block_idx) {
488 unsigned int ret;
489 const uint8_t *const reference = GetReference(block_idx);
490
491 API_REGISTER_STATE_CHECK(ret = GET_PARAM(2)(source_data_, source_stride_,
492 reference, reference_stride_));
493 return ret;
494 }
495
CheckSAD()496 void CheckSAD() {
497 const unsigned int reference_sad = ReferenceSADSkip(0);
498 const unsigned int exp_sad = SAD(0);
499
500 ASSERT_EQ(reference_sad, exp_sad);
501 }
502
SADForSpeedTest(unsigned int * results,const uint8_t * const * references)503 void SADForSpeedTest(unsigned int *results,
504 const uint8_t *const *references) override {
505 GET_PARAM(2)
506 (source_data_, source_stride_, references[0], reference_stride_);
507 (void)results;
508 }
509 };
510
511 class SADavgTest : public ::testing::WithParamInterface<SadMxNAvgParam>,
512 public SADTestBase {
513 public:
SADavgTest()514 SADavgTest() : SADTestBase(GET_PARAM(0), GET_PARAM(1), GET_PARAM(3)) {}
515
516 protected:
SAD_avg(int block_idx)517 unsigned int SAD_avg(int block_idx) {
518 unsigned int ret;
519 const uint8_t *const reference = GetReference(block_idx);
520
521 API_REGISTER_STATE_CHECK(ret = GET_PARAM(2)(source_data_, source_stride_,
522 reference, reference_stride_,
523 second_pred_));
524 return ret;
525 }
526
CheckSAD()527 void CheckSAD() {
528 const unsigned int reference_sad = ReferenceSADavg(0);
529 const unsigned int exp_sad = SAD_avg(0);
530
531 ASSERT_EQ(reference_sad, exp_sad);
532 }
533 };
534
535 class DistWtdSADavgTest
536 : public ::testing::WithParamInterface<DistWtdSadMxNAvgParam>,
537 public SADTestBase {
538 public:
DistWtdSADavgTest()539 DistWtdSADavgTest() : SADTestBase(GET_PARAM(0), GET_PARAM(1), GET_PARAM(3)) {}
540
541 protected:
dist_wtd_SAD_avg(int block_idx)542 unsigned int dist_wtd_SAD_avg(int block_idx) {
543 unsigned int ret;
544 const uint8_t *const reference = GetReference(block_idx);
545
546 API_REGISTER_STATE_CHECK(ret = GET_PARAM(2)(source_data_, source_stride_,
547 reference, reference_stride_,
548 second_pred_, &jcp_param_));
549 return ret;
550 }
551
CheckSAD()552 void CheckSAD() {
553 for (int j = 0; j < 2; ++j) {
554 for (int i = 0; i < 4; ++i) {
555 jcp_param_.fwd_offset = quant_dist_lookup_table[i][j];
556 jcp_param_.bck_offset = quant_dist_lookup_table[i][1 - j];
557
558 const unsigned int reference_sad = ReferenceDistWtdSADavg(0);
559 const unsigned int exp_sad = dist_wtd_SAD_avg(0);
560
561 ASSERT_EQ(reference_sad, exp_sad);
562 }
563 }
564 }
565 };
566
567 uint8_t *SADTestBase::source_data_ = nullptr;
568 uint8_t *SADTestBase::reference_data_ = nullptr;
569 uint8_t *SADTestBase::second_pred_ = nullptr;
570 uint8_t *SADTestBase::comp_pred_ = nullptr;
571 uint8_t *SADTestBase::comp_pred_test_ = nullptr;
572 uint8_t *SADTestBase::source_data8_ = nullptr;
573 uint8_t *SADTestBase::reference_data8_ = nullptr;
574 uint8_t *SADTestBase::second_pred8_ = nullptr;
575 uint8_t *SADTestBase::comp_pred8_ = nullptr;
576 uint8_t *SADTestBase::comp_pred8_test_ = nullptr;
577 uint16_t *SADTestBase::source_data16_ = nullptr;
578 uint16_t *SADTestBase::reference_data16_ = nullptr;
579 uint16_t *SADTestBase::second_pred16_ = nullptr;
580 uint16_t *SADTestBase::comp_pred16_ = nullptr;
581 uint16_t *SADTestBase::comp_pred16_test_ = nullptr;
582
TEST_P(SADTest,MaxRef)583 TEST_P(SADTest, MaxRef) {
584 FillConstant(source_data_, source_stride_, 0);
585 FillConstant(reference_data_, reference_stride_, mask_);
586 CheckSAD();
587 }
588
TEST_P(SADTest,MaxSrc)589 TEST_P(SADTest, MaxSrc) {
590 FillConstant(source_data_, source_stride_, mask_);
591 FillConstant(reference_data_, reference_stride_, 0);
592 CheckSAD();
593 }
594
TEST_P(SADTest,ShortRef)595 TEST_P(SADTest, ShortRef) {
596 const int tmp_stride = reference_stride_;
597 reference_stride_ >>= 1;
598 FillRandom(source_data_, source_stride_);
599 FillRandom(reference_data_, reference_stride_);
600 CheckSAD();
601 reference_stride_ = tmp_stride;
602 }
603
TEST_P(SADTest,UnalignedRef)604 TEST_P(SADTest, UnalignedRef) {
605 // The reference frame, but not the source frame, may be unaligned for
606 // certain types of searches.
607 const int tmp_stride = reference_stride_;
608 reference_stride_ -= 1;
609 FillRandom(source_data_, source_stride_);
610 FillRandom(reference_data_, reference_stride_);
611 CheckSAD();
612 reference_stride_ = tmp_stride;
613 }
614
TEST_P(SADTest,ShortSrc)615 TEST_P(SADTest, ShortSrc) {
616 const int tmp_stride = source_stride_;
617 source_stride_ >>= 1;
618 int test_count = 2000;
619 while (test_count > 0) {
620 FillRandom(source_data_, source_stride_);
621 FillRandom(reference_data_, reference_stride_);
622 CheckSAD();
623 if (testing::Test::HasFatalFailure()) break;
624 test_count -= 1;
625 }
626 source_stride_ = tmp_stride;
627 }
628
TEST_P(SADTest,DISABLED_Speed)629 TEST_P(SADTest, DISABLED_Speed) {
630 const int tmp_stride = source_stride_;
631 source_stride_ >>= 1;
632 FillRandom(source_data_, source_stride_);
633 FillRandom(reference_data_, reference_stride_);
634 SpeedSAD();
635 source_stride_ = tmp_stride;
636 }
637
TEST_P(SADSkipTest,MaxRef)638 TEST_P(SADSkipTest, MaxRef) {
639 FillConstant(source_data_, source_stride_, 0);
640 FillConstant(reference_data_, reference_stride_, mask_);
641 CheckSAD();
642 }
643
TEST_P(SADSkipTest,MaxSrc)644 TEST_P(SADSkipTest, MaxSrc) {
645 FillConstant(source_data_, source_stride_, mask_);
646 FillConstant(reference_data_, reference_stride_, 0);
647 CheckSAD();
648 }
649
TEST_P(SADSkipTest,ShortRef)650 TEST_P(SADSkipTest, ShortRef) {
651 const int tmp_stride = reference_stride_;
652 reference_stride_ >>= 1;
653 FillRandom(source_data_, source_stride_);
654 FillRandom(reference_data_, reference_stride_);
655 CheckSAD();
656 reference_stride_ = tmp_stride;
657 }
658
TEST_P(SADSkipTest,UnalignedRef)659 TEST_P(SADSkipTest, UnalignedRef) {
660 // The reference frame, but not the source frame, may be unaligned for
661 // certain types of searches.
662 const int tmp_stride = reference_stride_;
663 reference_stride_ -= 1;
664 FillRandom(source_data_, source_stride_);
665 FillRandom(reference_data_, reference_stride_);
666 CheckSAD();
667 reference_stride_ = tmp_stride;
668 }
669
TEST_P(SADSkipTest,ShortSrc)670 TEST_P(SADSkipTest, ShortSrc) {
671 const int tmp_stride = source_stride_;
672 source_stride_ >>= 1;
673 int test_count = 2000;
674 while (test_count > 0) {
675 FillRandom(source_data_, source_stride_);
676 FillRandom(reference_data_, reference_stride_);
677 CheckSAD();
678 if (testing::Test::HasFatalFailure()) break;
679 test_count -= 1;
680 }
681 source_stride_ = tmp_stride;
682 }
683
TEST_P(SADSkipTest,DISABLED_Speed)684 TEST_P(SADSkipTest, DISABLED_Speed) {
685 const int tmp_stride = source_stride_;
686 source_stride_ >>= 1;
687 FillRandom(source_data_, source_stride_);
688 FillRandom(reference_data_, reference_stride_);
689 SpeedSAD();
690 source_stride_ = tmp_stride;
691 }
692
TEST_P(SADavgTest,MaxRef)693 TEST_P(SADavgTest, MaxRef) {
694 FillConstant(source_data_, source_stride_, 0);
695 FillConstant(reference_data_, reference_stride_, mask_);
696 FillConstant(second_pred_, width_, 0);
697 CheckSAD();
698 }
TEST_P(SADavgTest,MaxSrc)699 TEST_P(SADavgTest, MaxSrc) {
700 FillConstant(source_data_, source_stride_, mask_);
701 FillConstant(reference_data_, reference_stride_, 0);
702 FillConstant(second_pred_, width_, 0);
703 CheckSAD();
704 }
705
TEST_P(SADavgTest,ShortRef)706 TEST_P(SADavgTest, ShortRef) {
707 const int tmp_stride = reference_stride_;
708 reference_stride_ >>= 1;
709 FillRandom(source_data_, source_stride_);
710 FillRandom(reference_data_, reference_stride_);
711 FillRandom(second_pred_, width_);
712 CheckSAD();
713 reference_stride_ = tmp_stride;
714 }
715
TEST_P(SADavgTest,UnalignedRef)716 TEST_P(SADavgTest, UnalignedRef) {
717 // The reference frame, but not the source frame, may be unaligned for
718 // certain types of searches.
719 const int tmp_stride = reference_stride_;
720 reference_stride_ -= 1;
721 FillRandom(source_data_, source_stride_);
722 FillRandom(reference_data_, reference_stride_);
723 FillRandom(second_pred_, width_);
724 CheckSAD();
725 reference_stride_ = tmp_stride;
726 }
727
TEST_P(SADavgTest,ShortSrc)728 TEST_P(SADavgTest, ShortSrc) {
729 const int tmp_stride = source_stride_;
730 source_stride_ >>= 1;
731 int test_count = 2000;
732 while (test_count > 0) {
733 FillRandom(source_data_, source_stride_);
734 FillRandom(reference_data_, reference_stride_);
735 FillRandom(second_pred_, width_);
736 CheckSAD();
737 if (testing::Test::HasFatalFailure()) break;
738 test_count -= 1;
739 }
740 source_stride_ = tmp_stride;
741 }
742
TEST_P(DistWtdSADavgTest,MaxRef)743 TEST_P(DistWtdSADavgTest, MaxRef) {
744 FillConstant(source_data_, source_stride_, 0);
745 FillConstant(reference_data_, reference_stride_, mask_);
746 FillConstant(second_pred_, width_, 0);
747 CheckSAD();
748 }
TEST_P(DistWtdSADavgTest,MaxSrc)749 TEST_P(DistWtdSADavgTest, MaxSrc) {
750 FillConstant(source_data_, source_stride_, mask_);
751 FillConstant(reference_data_, reference_stride_, 0);
752 FillConstant(second_pred_, width_, 0);
753 CheckSAD();
754 }
755
TEST_P(DistWtdSADavgTest,ShortRef)756 TEST_P(DistWtdSADavgTest, ShortRef) {
757 const int tmp_stride = reference_stride_;
758 reference_stride_ >>= 1;
759 FillRandom(source_data_, source_stride_);
760 FillRandom(reference_data_, reference_stride_);
761 FillRandom(second_pred_, width_);
762 CheckSAD();
763 reference_stride_ = tmp_stride;
764 }
765
TEST_P(DistWtdSADavgTest,UnalignedRef)766 TEST_P(DistWtdSADavgTest, UnalignedRef) {
767 // The reference frame, but not the source frame, may be unaligned for
768 // certain types of searches.
769 const int tmp_stride = reference_stride_;
770 reference_stride_ -= 1;
771 FillRandom(source_data_, source_stride_);
772 FillRandom(reference_data_, reference_stride_);
773 FillRandom(second_pred_, width_);
774 CheckSAD();
775 reference_stride_ = tmp_stride;
776 }
777
TEST_P(DistWtdSADavgTest,ShortSrc)778 TEST_P(DistWtdSADavgTest, ShortSrc) {
779 const int tmp_stride = source_stride_;
780 source_stride_ >>= 1;
781 int test_count = 2000;
782 while (test_count > 0) {
783 FillRandom(source_data_, source_stride_);
784 FillRandom(reference_data_, reference_stride_);
785 FillRandom(second_pred_, width_);
786 CheckSAD();
787 if (testing::Test::HasFatalFailure()) break;
788 test_count -= 1;
789 }
790 source_stride_ = tmp_stride;
791 }
792
793 // SADx4
TEST_P(SADx4Test,MaxRef)794 TEST_P(SADx4Test, MaxRef) {
795 FillConstant(source_data_, source_stride_, 0);
796 FillConstant(GetReference(0), reference_stride_, mask_);
797 FillConstant(GetReference(1), reference_stride_, mask_);
798 FillConstant(GetReference(2), reference_stride_, mask_);
799 FillConstant(GetReference(3), reference_stride_, mask_);
800 CheckSADs();
801 }
802
TEST_P(SADx4Test,MaxSrc)803 TEST_P(SADx4Test, MaxSrc) {
804 FillConstant(source_data_, source_stride_, mask_);
805 FillConstant(GetReference(0), reference_stride_, 0);
806 FillConstant(GetReference(1), reference_stride_, 0);
807 FillConstant(GetReference(2), reference_stride_, 0);
808 FillConstant(GetReference(3), reference_stride_, 0);
809 CheckSADs();
810 }
811
TEST_P(SADx4Test,ShortRef)812 TEST_P(SADx4Test, ShortRef) {
813 int tmp_stride = reference_stride_;
814 reference_stride_ >>= 1;
815 FillRandom(source_data_, source_stride_);
816 FillRandom(GetReference(0), reference_stride_);
817 FillRandom(GetReference(1), reference_stride_);
818 FillRandom(GetReference(2), reference_stride_);
819 FillRandom(GetReference(3), reference_stride_);
820 CheckSADs();
821 reference_stride_ = tmp_stride;
822 }
823
TEST_P(SADx4Test,UnalignedRef)824 TEST_P(SADx4Test, UnalignedRef) {
825 // The reference frame, but not the source frame, may be unaligned for
826 // certain types of searches.
827 int tmp_stride = reference_stride_;
828 reference_stride_ -= 1;
829 FillRandom(source_data_, source_stride_);
830 FillRandom(GetReference(0), reference_stride_);
831 FillRandom(GetReference(1), reference_stride_);
832 FillRandom(GetReference(2), reference_stride_);
833 FillRandom(GetReference(3), reference_stride_);
834 CheckSADs();
835 reference_stride_ = tmp_stride;
836 }
837
TEST_P(SADx4Test,ShortSrc)838 TEST_P(SADx4Test, ShortSrc) {
839 int tmp_stride = source_stride_;
840 source_stride_ >>= 1;
841 int test_count = 1000;
842 while (test_count > 0) {
843 FillRandom(source_data_, source_stride_);
844 FillRandom(GetReference(0), reference_stride_);
845 FillRandom(GetReference(1), reference_stride_);
846 FillRandom(GetReference(2), reference_stride_);
847 FillRandom(GetReference(3), reference_stride_);
848 CheckSADs();
849 test_count -= 1;
850 }
851 source_stride_ = tmp_stride;
852 }
853
TEST_P(SADx4Test,SrcAlignedByWidth)854 TEST_P(SADx4Test, SrcAlignedByWidth) {
855 uint8_t *tmp_source_data = source_data_;
856 source_data_ += width_;
857 FillRandom(source_data_, source_stride_);
858 FillRandom(GetReference(0), reference_stride_);
859 FillRandom(GetReference(1), reference_stride_);
860 FillRandom(GetReference(2), reference_stride_);
861 FillRandom(GetReference(3), reference_stride_);
862 CheckSADs();
863 source_data_ = tmp_source_data;
864 }
865
TEST_P(SADx4Test,DISABLED_Speed)866 TEST_P(SADx4Test, DISABLED_Speed) {
867 FillRandom(source_data_, source_stride_);
868 FillRandom(GetReference(0), reference_stride_);
869 FillRandom(GetReference(1), reference_stride_);
870 FillRandom(GetReference(2), reference_stride_);
871 FillRandom(GetReference(3), reference_stride_);
872 SpeedSAD();
873 }
874
875 // SADx3
TEST_P(SADx3Test,MaxRef)876 TEST_P(SADx3Test, MaxRef) {
877 FillConstant(source_data_, source_stride_, 0);
878 FillConstant(GetReference(0), reference_stride_, mask_);
879 FillConstant(GetReference(1), reference_stride_, mask_);
880 FillConstant(GetReference(2), reference_stride_, mask_);
881 FillConstant(GetReference(3), reference_stride_, mask_);
882 CheckSADs();
883 }
884
TEST_P(SADx3Test,MaxSrc)885 TEST_P(SADx3Test, MaxSrc) {
886 FillConstant(source_data_, source_stride_, mask_);
887 FillConstant(GetReference(0), reference_stride_, 0);
888 FillConstant(GetReference(1), reference_stride_, 0);
889 FillConstant(GetReference(2), reference_stride_, 0);
890 FillConstant(GetReference(3), reference_stride_, 0);
891 CheckSADs();
892 }
893
TEST_P(SADx3Test,ShortRef)894 TEST_P(SADx3Test, ShortRef) {
895 int tmp_stride = reference_stride_;
896 reference_stride_ >>= 1;
897 FillRandom(source_data_, source_stride_);
898 FillRandom(GetReference(0), reference_stride_);
899 FillRandom(GetReference(1), reference_stride_);
900 FillRandom(GetReference(2), reference_stride_);
901 FillRandom(GetReference(3), reference_stride_);
902 CheckSADs();
903 reference_stride_ = tmp_stride;
904 }
905
TEST_P(SADx3Test,UnalignedRef)906 TEST_P(SADx3Test, UnalignedRef) {
907 // The reference frame, but not the source frame, may be unaligned for
908 // certain types of searches.
909 int tmp_stride = reference_stride_;
910 reference_stride_ -= 1;
911 FillRandom(source_data_, source_stride_);
912 FillRandom(GetReference(0), reference_stride_);
913 FillRandom(GetReference(1), reference_stride_);
914 FillRandom(GetReference(2), reference_stride_);
915 FillRandom(GetReference(3), reference_stride_);
916 CheckSADs();
917 reference_stride_ = tmp_stride;
918 }
919
TEST_P(SADx3Test,ShortSrc)920 TEST_P(SADx3Test, ShortSrc) {
921 int tmp_stride = source_stride_;
922 source_stride_ >>= 1;
923 int test_count = 1000;
924 while (test_count > 0) {
925 FillRandom(source_data_, source_stride_);
926 FillRandom(GetReference(0), reference_stride_);
927 FillRandom(GetReference(1), reference_stride_);
928 FillRandom(GetReference(2), reference_stride_);
929 FillRandom(GetReference(3), reference_stride_);
930 CheckSADs();
931 test_count -= 1;
932 }
933 source_stride_ = tmp_stride;
934 }
935
TEST_P(SADx3Test,SrcAlignedByWidth)936 TEST_P(SADx3Test, SrcAlignedByWidth) {
937 uint8_t *tmp_source_data = source_data_;
938 source_data_ += width_;
939 FillRandom(source_data_, source_stride_);
940 FillRandom(GetReference(0), reference_stride_);
941 FillRandom(GetReference(1), reference_stride_);
942 FillRandom(GetReference(2), reference_stride_);
943 FillRandom(GetReference(3), reference_stride_);
944 CheckSADs();
945 source_data_ = tmp_source_data;
946 }
947
TEST_P(SADx3Test,DISABLED_Speed)948 TEST_P(SADx3Test, DISABLED_Speed) {
949 FillRandom(source_data_, source_stride_);
950 FillRandom(GetReference(0), reference_stride_);
951 FillRandom(GetReference(1), reference_stride_);
952 FillRandom(GetReference(2), reference_stride_);
953 FillRandom(GetReference(3), reference_stride_);
954 SpeedSAD();
955 }
956
957 // SADSkipx4
TEST_P(SADSkipx4Test,MaxRef)958 TEST_P(SADSkipx4Test, MaxRef) {
959 FillConstant(source_data_, source_stride_, 0);
960 FillConstant(GetReference(0), reference_stride_, mask_);
961 FillConstant(GetReference(1), reference_stride_, mask_);
962 FillConstant(GetReference(2), reference_stride_, mask_);
963 FillConstant(GetReference(3), reference_stride_, mask_);
964 CheckSADs();
965 }
966
TEST_P(SADSkipx4Test,MaxSrc)967 TEST_P(SADSkipx4Test, MaxSrc) {
968 FillConstant(source_data_, source_stride_, mask_);
969 FillConstant(GetReference(0), reference_stride_, 0);
970 FillConstant(GetReference(1), reference_stride_, 0);
971 FillConstant(GetReference(2), reference_stride_, 0);
972 FillConstant(GetReference(3), reference_stride_, 0);
973 CheckSADs();
974 }
975
TEST_P(SADSkipx4Test,ShortRef)976 TEST_P(SADSkipx4Test, ShortRef) {
977 int tmp_stride = reference_stride_;
978 reference_stride_ >>= 1;
979 FillRandom(source_data_, source_stride_);
980 FillRandom(GetReference(0), reference_stride_);
981 FillRandom(GetReference(1), reference_stride_);
982 FillRandom(GetReference(2), reference_stride_);
983 FillRandom(GetReference(3), reference_stride_);
984 CheckSADs();
985 reference_stride_ = tmp_stride;
986 }
987
TEST_P(SADSkipx4Test,UnalignedRef)988 TEST_P(SADSkipx4Test, UnalignedRef) {
989 // The reference frame, but not the source frame, may be unaligned for
990 // certain types of searches.
991 int tmp_stride = reference_stride_;
992 reference_stride_ -= 1;
993 FillRandom(source_data_, source_stride_);
994 FillRandom(GetReference(0), reference_stride_);
995 FillRandom(GetReference(1), reference_stride_);
996 FillRandom(GetReference(2), reference_stride_);
997 FillRandom(GetReference(3), reference_stride_);
998 CheckSADs();
999 reference_stride_ = tmp_stride;
1000 }
1001
TEST_P(SADSkipx4Test,ShortSrc)1002 TEST_P(SADSkipx4Test, ShortSrc) {
1003 int tmp_stride = source_stride_;
1004 source_stride_ >>= 1;
1005 int test_count = 1000;
1006 while (test_count > 0) {
1007 FillRandom(source_data_, source_stride_);
1008 FillRandom(GetReference(0), reference_stride_);
1009 FillRandom(GetReference(1), reference_stride_);
1010 FillRandom(GetReference(2), reference_stride_);
1011 FillRandom(GetReference(3), reference_stride_);
1012 CheckSADs();
1013 test_count -= 1;
1014 }
1015 source_stride_ = tmp_stride;
1016 }
1017
TEST_P(SADSkipx4Test,SrcAlignedByWidth)1018 TEST_P(SADSkipx4Test, SrcAlignedByWidth) {
1019 uint8_t *tmp_source_data = source_data_;
1020 source_data_ += width_;
1021 FillRandom(source_data_, source_stride_);
1022 FillRandom(GetReference(0), reference_stride_);
1023 FillRandom(GetReference(1), reference_stride_);
1024 FillRandom(GetReference(2), reference_stride_);
1025 FillRandom(GetReference(3), reference_stride_);
1026 CheckSADs();
1027 source_data_ = tmp_source_data;
1028 }
1029
TEST_P(SADSkipx4Test,DISABLED_Speed)1030 TEST_P(SADSkipx4Test, DISABLED_Speed) {
1031 FillRandom(source_data_, source_stride_);
1032 FillRandom(GetReference(0), reference_stride_);
1033 FillRandom(GetReference(1), reference_stride_);
1034 FillRandom(GetReference(2), reference_stride_);
1035 FillRandom(GetReference(3), reference_stride_);
1036 SpeedSAD();
1037 }
1038
1039 using std::make_tuple;
1040
1041 //------------------------------------------------------------------------------
1042 // C functions
1043 const SadMxNParam c_tests[] = {
1044 make_tuple(128, 128, &aom_sad128x128_c, -1),
1045 make_tuple(128, 64, &aom_sad128x64_c, -1),
1046 make_tuple(64, 128, &aom_sad64x128_c, -1),
1047 make_tuple(64, 64, &aom_sad64x64_c, -1),
1048 make_tuple(64, 32, &aom_sad64x32_c, -1),
1049 make_tuple(32, 64, &aom_sad32x64_c, -1),
1050 make_tuple(32, 32, &aom_sad32x32_c, -1),
1051 make_tuple(32, 16, &aom_sad32x16_c, -1),
1052 make_tuple(16, 32, &aom_sad16x32_c, -1),
1053 make_tuple(16, 16, &aom_sad16x16_c, -1),
1054 make_tuple(16, 8, &aom_sad16x8_c, -1),
1055 make_tuple(8, 16, &aom_sad8x16_c, -1),
1056 make_tuple(8, 8, &aom_sad8x8_c, -1),
1057 make_tuple(8, 4, &aom_sad8x4_c, -1),
1058 make_tuple(4, 8, &aom_sad4x8_c, -1),
1059 make_tuple(4, 4, &aom_sad4x4_c, -1),
1060 #if CONFIG_AV1_HIGHBITDEPTH
1061 make_tuple(128, 128, &aom_highbd_sad128x128_c, 8),
1062 make_tuple(128, 64, &aom_highbd_sad128x64_c, 8),
1063 make_tuple(64, 128, &aom_highbd_sad64x128_c, 8),
1064 make_tuple(64, 64, &aom_highbd_sad64x64_c, 8),
1065 make_tuple(64, 32, &aom_highbd_sad64x32_c, 8),
1066 make_tuple(32, 64, &aom_highbd_sad32x64_c, 8),
1067 make_tuple(32, 32, &aom_highbd_sad32x32_c, 8),
1068 make_tuple(32, 16, &aom_highbd_sad32x16_c, 8),
1069 make_tuple(16, 32, &aom_highbd_sad16x32_c, 8),
1070 make_tuple(16, 16, &aom_highbd_sad16x16_c, 8),
1071 make_tuple(16, 8, &aom_highbd_sad16x8_c, 8),
1072 make_tuple(8, 16, &aom_highbd_sad8x16_c, 8),
1073 make_tuple(8, 8, &aom_highbd_sad8x8_c, 8),
1074 make_tuple(8, 4, &aom_highbd_sad8x4_c, 8),
1075 make_tuple(4, 8, &aom_highbd_sad4x8_c, 8),
1076 make_tuple(4, 4, &aom_highbd_sad4x4_c, 8),
1077 make_tuple(128, 128, &aom_highbd_sad128x128_c, 10),
1078 make_tuple(128, 64, &aom_highbd_sad128x64_c, 10),
1079 make_tuple(64, 128, &aom_highbd_sad64x128_c, 10),
1080 make_tuple(64, 64, &aom_highbd_sad64x64_c, 10),
1081 make_tuple(64, 32, &aom_highbd_sad64x32_c, 10),
1082 make_tuple(32, 64, &aom_highbd_sad32x64_c, 10),
1083 make_tuple(32, 32, &aom_highbd_sad32x32_c, 10),
1084 make_tuple(32, 16, &aom_highbd_sad32x16_c, 10),
1085 make_tuple(16, 32, &aom_highbd_sad16x32_c, 10),
1086 make_tuple(16, 16, &aom_highbd_sad16x16_c, 10),
1087 make_tuple(16, 8, &aom_highbd_sad16x8_c, 10),
1088 make_tuple(8, 16, &aom_highbd_sad8x16_c, 10),
1089 make_tuple(8, 8, &aom_highbd_sad8x8_c, 10),
1090 make_tuple(8, 4, &aom_highbd_sad8x4_c, 10),
1091 make_tuple(4, 8, &aom_highbd_sad4x8_c, 10),
1092 make_tuple(4, 4, &aom_highbd_sad4x4_c, 10),
1093 make_tuple(128, 128, &aom_highbd_sad128x128_c, 12),
1094 make_tuple(128, 64, &aom_highbd_sad128x64_c, 12),
1095 make_tuple(64, 128, &aom_highbd_sad64x128_c, 12),
1096 make_tuple(64, 64, &aom_highbd_sad64x64_c, 12),
1097 make_tuple(64, 32, &aom_highbd_sad64x32_c, 12),
1098 make_tuple(32, 64, &aom_highbd_sad32x64_c, 12),
1099 make_tuple(32, 32, &aom_highbd_sad32x32_c, 12),
1100 make_tuple(32, 16, &aom_highbd_sad32x16_c, 12),
1101 make_tuple(16, 32, &aom_highbd_sad16x32_c, 12),
1102 make_tuple(16, 16, &aom_highbd_sad16x16_c, 12),
1103 make_tuple(16, 8, &aom_highbd_sad16x8_c, 12),
1104 make_tuple(8, 16, &aom_highbd_sad8x16_c, 12),
1105 make_tuple(8, 8, &aom_highbd_sad8x8_c, 12),
1106 make_tuple(8, 4, &aom_highbd_sad8x4_c, 12),
1107 make_tuple(4, 8, &aom_highbd_sad4x8_c, 12),
1108 make_tuple(4, 4, &aom_highbd_sad4x4_c, 12),
1109 #endif // CONFIG_AV1_HIGHBITDEPTH
1110 #if !CONFIG_REALTIME_ONLY
1111 make_tuple(64, 16, &aom_sad64x16_c, -1),
1112 make_tuple(16, 64, &aom_sad16x64_c, -1),
1113 #if CONFIG_AV1_HIGHBITDEPTH
1114 make_tuple(64, 16, &aom_highbd_sad64x16_c, 8),
1115 make_tuple(16, 64, &aom_highbd_sad16x64_c, 8),
1116 make_tuple(64, 16, &aom_highbd_sad64x16_c, 10),
1117 make_tuple(16, 64, &aom_highbd_sad16x64_c, 10),
1118 make_tuple(64, 16, &aom_highbd_sad64x16_c, 12),
1119 make_tuple(16, 64, &aom_highbd_sad16x64_c, 12),
1120 #endif
1121 make_tuple(32, 8, &aom_sad32x8_c, -1),
1122 make_tuple(8, 32, &aom_sad8x32_c, -1),
1123 #if CONFIG_AV1_HIGHBITDEPTH
1124 make_tuple(32, 8, &aom_highbd_sad32x8_c, 8),
1125 make_tuple(8, 32, &aom_highbd_sad8x32_c, 8),
1126 make_tuple(32, 8, &aom_highbd_sad32x8_c, 10),
1127 make_tuple(8, 32, &aom_highbd_sad8x32_c, 10),
1128 make_tuple(32, 8, &aom_highbd_sad32x8_c, 12),
1129 make_tuple(8, 32, &aom_highbd_sad8x32_c, 12),
1130 #endif
1131 make_tuple(16, 4, &aom_sad16x4_c, -1),
1132 make_tuple(4, 16, &aom_sad4x16_c, -1),
1133 #if CONFIG_AV1_HIGHBITDEPTH
1134 make_tuple(16, 4, &aom_highbd_sad16x4_c, 8),
1135 make_tuple(4, 16, &aom_highbd_sad4x16_c, 8),
1136 make_tuple(16, 4, &aom_highbd_sad16x4_c, 10),
1137 make_tuple(4, 16, &aom_highbd_sad4x16_c, 10),
1138 make_tuple(16, 4, &aom_highbd_sad16x4_c, 12),
1139 make_tuple(4, 16, &aom_highbd_sad4x16_c, 12),
1140 #endif
1141 #endif // !CONFIG_REALTIME_ONLY
1142 };
1143 INSTANTIATE_TEST_SUITE_P(C, SADTest, ::testing::ValuesIn(c_tests));
1144
1145 const SadSkipMxNParam skip_c_tests[] = {
1146 make_tuple(128, 128, &aom_sad_skip_128x128_c, -1),
1147 make_tuple(128, 64, &aom_sad_skip_128x64_c, -1),
1148 make_tuple(64, 128, &aom_sad_skip_64x128_c, -1),
1149 make_tuple(64, 64, &aom_sad_skip_64x64_c, -1),
1150 make_tuple(64, 32, &aom_sad_skip_64x32_c, -1),
1151 make_tuple(32, 64, &aom_sad_skip_32x64_c, -1),
1152 make_tuple(32, 32, &aom_sad_skip_32x32_c, -1),
1153 make_tuple(32, 16, &aom_sad_skip_32x16_c, -1),
1154 make_tuple(16, 32, &aom_sad_skip_16x32_c, -1),
1155 make_tuple(16, 16, &aom_sad_skip_16x16_c, -1),
1156 make_tuple(16, 8, &aom_sad_skip_16x8_c, -1),
1157 make_tuple(8, 16, &aom_sad_skip_8x16_c, -1),
1158 make_tuple(8, 8, &aom_sad_skip_8x8_c, -1),
1159 make_tuple(8, 4, &aom_sad_skip_8x4_c, -1),
1160 make_tuple(4, 8, &aom_sad_skip_4x8_c, -1),
1161 make_tuple(4, 4, &aom_sad_skip_4x4_c, -1),
1162 #if !CONFIG_REALTIME_ONLY
1163 make_tuple(64, 16, &aom_sad_skip_64x16_c, -1),
1164 make_tuple(16, 64, &aom_sad_skip_16x64_c, -1),
1165 make_tuple(32, 8, &aom_sad_skip_32x8_c, -1),
1166 make_tuple(8, 32, &aom_sad_skip_8x32_c, -1),
1167 make_tuple(16, 4, &aom_sad_skip_16x4_c, -1),
1168 make_tuple(4, 16, &aom_sad_skip_4x16_c, -1),
1169 #endif
1170 #if CONFIG_AV1_HIGHBITDEPTH
1171 make_tuple(128, 128, &aom_highbd_sad_skip_128x128_c, 8),
1172 make_tuple(128, 64, &aom_highbd_sad_skip_128x64_c, 8),
1173 make_tuple(64, 128, &aom_highbd_sad_skip_64x128_c, 8),
1174 make_tuple(64, 64, &aom_highbd_sad_skip_64x64_c, 8),
1175 make_tuple(64, 32, &aom_highbd_sad_skip_64x32_c, 8),
1176 make_tuple(32, 64, &aom_highbd_sad_skip_32x64_c, 8),
1177 make_tuple(32, 32, &aom_highbd_sad_skip_32x32_c, 8),
1178 make_tuple(32, 16, &aom_highbd_sad_skip_32x16_c, 8),
1179 make_tuple(16, 32, &aom_highbd_sad_skip_16x32_c, 8),
1180 make_tuple(16, 16, &aom_highbd_sad_skip_16x16_c, 8),
1181 make_tuple(16, 8, &aom_highbd_sad_skip_16x8_c, 8),
1182 make_tuple(8, 16, &aom_highbd_sad_skip_8x16_c, 8),
1183 make_tuple(8, 8, &aom_highbd_sad_skip_8x8_c, 8),
1184 make_tuple(8, 4, &aom_highbd_sad_skip_8x4_c, 8),
1185 make_tuple(4, 8, &aom_highbd_sad_skip_4x8_c, 8),
1186 make_tuple(4, 4, &aom_highbd_sad_skip_4x4_c, 8),
1187 #if !CONFIG_REALTIME_ONLY
1188 make_tuple(64, 16, &aom_highbd_sad_skip_64x16_c, 8),
1189 make_tuple(16, 64, &aom_highbd_sad_skip_16x64_c, 8),
1190 make_tuple(32, 8, &aom_highbd_sad_skip_32x8_c, 8),
1191 make_tuple(8, 32, &aom_highbd_sad_skip_8x32_c, 8),
1192 make_tuple(16, 4, &aom_highbd_sad_skip_16x4_c, 8),
1193 make_tuple(4, 16, &aom_highbd_sad_skip_4x16_c, 8),
1194 #endif
1195 make_tuple(128, 128, &aom_highbd_sad_skip_128x128_c, 10),
1196 make_tuple(128, 64, &aom_highbd_sad_skip_128x64_c, 10),
1197 make_tuple(64, 128, &aom_highbd_sad_skip_64x128_c, 10),
1198 make_tuple(64, 64, &aom_highbd_sad_skip_64x64_c, 10),
1199 make_tuple(64, 32, &aom_highbd_sad_skip_64x32_c, 10),
1200 make_tuple(32, 64, &aom_highbd_sad_skip_32x64_c, 10),
1201 make_tuple(32, 32, &aom_highbd_sad_skip_32x32_c, 10),
1202 make_tuple(32, 16, &aom_highbd_sad_skip_32x16_c, 10),
1203 make_tuple(16, 32, &aom_highbd_sad_skip_16x32_c, 10),
1204 make_tuple(16, 16, &aom_highbd_sad_skip_16x16_c, 10),
1205 make_tuple(16, 8, &aom_highbd_sad_skip_16x8_c, 10),
1206 make_tuple(8, 16, &aom_highbd_sad_skip_8x16_c, 10),
1207 make_tuple(8, 8, &aom_highbd_sad_skip_8x8_c, 10),
1208 make_tuple(8, 4, &aom_highbd_sad_skip_8x4_c, 10),
1209 make_tuple(4, 8, &aom_highbd_sad_skip_4x8_c, 10),
1210 make_tuple(4, 4, &aom_highbd_sad_skip_4x4_c, 10),
1211 #if !CONFIG_REALTIME_ONLY
1212 make_tuple(64, 16, &aom_highbd_sad_skip_64x16_c, 10),
1213 make_tuple(16, 64, &aom_highbd_sad_skip_16x64_c, 10),
1214 make_tuple(32, 8, &aom_highbd_sad_skip_32x8_c, 10),
1215 make_tuple(8, 32, &aom_highbd_sad_skip_8x32_c, 10),
1216 make_tuple(16, 4, &aom_highbd_sad_skip_16x4_c, 10),
1217 make_tuple(4, 16, &aom_highbd_sad_skip_4x16_c, 10),
1218 #endif
1219 make_tuple(128, 128, &aom_highbd_sad_skip_128x128_c, 12),
1220 make_tuple(128, 64, &aom_highbd_sad_skip_128x64_c, 12),
1221 make_tuple(64, 128, &aom_highbd_sad_skip_64x128_c, 12),
1222 make_tuple(64, 64, &aom_highbd_sad_skip_64x64_c, 12),
1223 make_tuple(64, 32, &aom_highbd_sad_skip_64x32_c, 12),
1224 make_tuple(32, 64, &aom_highbd_sad_skip_32x64_c, 12),
1225 make_tuple(32, 32, &aom_highbd_sad_skip_32x32_c, 12),
1226 make_tuple(32, 16, &aom_highbd_sad_skip_32x16_c, 12),
1227 make_tuple(16, 32, &aom_highbd_sad_skip_16x32_c, 12),
1228 make_tuple(16, 16, &aom_highbd_sad_skip_16x16_c, 12),
1229 make_tuple(16, 8, &aom_highbd_sad_skip_16x8_c, 12),
1230 make_tuple(8, 16, &aom_highbd_sad_skip_8x16_c, 12),
1231 make_tuple(8, 8, &aom_highbd_sad_skip_8x8_c, 12),
1232 make_tuple(8, 4, &aom_highbd_sad_skip_8x4_c, 12),
1233 make_tuple(4, 8, &aom_highbd_sad_skip_4x8_c, 12),
1234 make_tuple(4, 4, &aom_highbd_sad_skip_4x4_c, 12),
1235 #if !CONFIG_REALTIME_ONLY
1236 make_tuple(64, 16, &aom_highbd_sad_skip_64x16_c, 12),
1237 make_tuple(16, 64, &aom_highbd_sad_skip_16x64_c, 12),
1238 make_tuple(32, 8, &aom_highbd_sad_skip_32x8_c, 12),
1239 make_tuple(8, 32, &aom_highbd_sad_skip_8x32_c, 12),
1240 make_tuple(16, 4, &aom_highbd_sad_skip_16x4_c, 12),
1241 make_tuple(4, 16, &aom_highbd_sad_skip_4x16_c, 12),
1242 #endif // !CONFIG_REALTIME_ONLY
1243 #endif // CONFIG_AV1_HIGHBITDEPTH
1244 };
1245 INSTANTIATE_TEST_SUITE_P(C, SADSkipTest, ::testing::ValuesIn(skip_c_tests));
1246
1247 const SadMxNAvgParam avg_c_tests[] = {
1248 make_tuple(128, 128, &aom_sad128x128_avg_c, -1),
1249 make_tuple(128, 64, &aom_sad128x64_avg_c, -1),
1250 make_tuple(64, 128, &aom_sad64x128_avg_c, -1),
1251 make_tuple(64, 64, &aom_sad64x64_avg_c, -1),
1252 make_tuple(64, 32, &aom_sad64x32_avg_c, -1),
1253 make_tuple(32, 64, &aom_sad32x64_avg_c, -1),
1254 make_tuple(32, 32, &aom_sad32x32_avg_c, -1),
1255 make_tuple(32, 16, &aom_sad32x16_avg_c, -1),
1256 make_tuple(16, 32, &aom_sad16x32_avg_c, -1),
1257 make_tuple(16, 16, &aom_sad16x16_avg_c, -1),
1258 make_tuple(16, 8, &aom_sad16x8_avg_c, -1),
1259 make_tuple(8, 16, &aom_sad8x16_avg_c, -1),
1260 make_tuple(8, 8, &aom_sad8x8_avg_c, -1),
1261 make_tuple(8, 4, &aom_sad8x4_avg_c, -1),
1262 make_tuple(4, 8, &aom_sad4x8_avg_c, -1),
1263 make_tuple(4, 4, &aom_sad4x4_avg_c, -1),
1264 #if CONFIG_AV1_HIGHBITDEPTH
1265 make_tuple(128, 128, &aom_highbd_sad128x128_avg_c, 8),
1266 make_tuple(128, 64, &aom_highbd_sad128x64_avg_c, 8),
1267 make_tuple(64, 128, &aom_highbd_sad64x128_avg_c, 8),
1268 make_tuple(64, 64, &aom_highbd_sad64x64_avg_c, 8),
1269 make_tuple(64, 32, &aom_highbd_sad64x32_avg_c, 8),
1270 make_tuple(32, 64, &aom_highbd_sad32x64_avg_c, 8),
1271 make_tuple(32, 32, &aom_highbd_sad32x32_avg_c, 8),
1272 make_tuple(32, 16, &aom_highbd_sad32x16_avg_c, 8),
1273 make_tuple(16, 32, &aom_highbd_sad16x32_avg_c, 8),
1274 make_tuple(16, 16, &aom_highbd_sad16x16_avg_c, 8),
1275 make_tuple(16, 8, &aom_highbd_sad16x8_avg_c, 8),
1276 make_tuple(8, 16, &aom_highbd_sad8x16_avg_c, 8),
1277 make_tuple(8, 8, &aom_highbd_sad8x8_avg_c, 8),
1278 make_tuple(8, 4, &aom_highbd_sad8x4_avg_c, 8),
1279 make_tuple(4, 8, &aom_highbd_sad4x8_avg_c, 8),
1280 make_tuple(4, 4, &aom_highbd_sad4x4_avg_c, 8),
1281 make_tuple(128, 128, &aom_highbd_sad128x128_avg_c, 10),
1282 make_tuple(128, 64, &aom_highbd_sad128x64_avg_c, 10),
1283 make_tuple(64, 128, &aom_highbd_sad64x128_avg_c, 10),
1284 make_tuple(64, 64, &aom_highbd_sad64x64_avg_c, 10),
1285 make_tuple(64, 32, &aom_highbd_sad64x32_avg_c, 10),
1286 make_tuple(32, 64, &aom_highbd_sad32x64_avg_c, 10),
1287 make_tuple(32, 32, &aom_highbd_sad32x32_avg_c, 10),
1288 make_tuple(32, 16, &aom_highbd_sad32x16_avg_c, 10),
1289 make_tuple(16, 32, &aom_highbd_sad16x32_avg_c, 10),
1290 make_tuple(16, 16, &aom_highbd_sad16x16_avg_c, 10),
1291 make_tuple(16, 8, &aom_highbd_sad16x8_avg_c, 10),
1292 make_tuple(8, 16, &aom_highbd_sad8x16_avg_c, 10),
1293 make_tuple(8, 8, &aom_highbd_sad8x8_avg_c, 10),
1294 make_tuple(8, 4, &aom_highbd_sad8x4_avg_c, 10),
1295 make_tuple(4, 8, &aom_highbd_sad4x8_avg_c, 10),
1296 make_tuple(4, 4, &aom_highbd_sad4x4_avg_c, 10),
1297 make_tuple(128, 128, &aom_highbd_sad128x128_avg_c, 12),
1298 make_tuple(128, 64, &aom_highbd_sad128x64_avg_c, 12),
1299 make_tuple(64, 128, &aom_highbd_sad64x128_avg_c, 12),
1300 make_tuple(64, 64, &aom_highbd_sad64x64_avg_c, 12),
1301 make_tuple(64, 32, &aom_highbd_sad64x32_avg_c, 12),
1302 make_tuple(32, 64, &aom_highbd_sad32x64_avg_c, 12),
1303 make_tuple(32, 32, &aom_highbd_sad32x32_avg_c, 12),
1304 make_tuple(32, 16, &aom_highbd_sad32x16_avg_c, 12),
1305 make_tuple(16, 32, &aom_highbd_sad16x32_avg_c, 12),
1306 make_tuple(16, 16, &aom_highbd_sad16x16_avg_c, 12),
1307 make_tuple(16, 8, &aom_highbd_sad16x8_avg_c, 12),
1308 make_tuple(8, 16, &aom_highbd_sad8x16_avg_c, 12),
1309 make_tuple(8, 8, &aom_highbd_sad8x8_avg_c, 12),
1310 make_tuple(8, 4, &aom_highbd_sad8x4_avg_c, 12),
1311 make_tuple(4, 8, &aom_highbd_sad4x8_avg_c, 12),
1312 make_tuple(4, 4, &aom_highbd_sad4x4_avg_c, 12),
1313 #endif // CONFIG_AV1_HIGHBITDEPTH
1314 #if !CONFIG_REALTIME_ONLY
1315 make_tuple(64, 16, &aom_sad64x16_avg_c, -1),
1316 make_tuple(16, 64, &aom_sad16x64_avg_c, -1),
1317 #if CONFIG_AV1_HIGHBITDEPTH
1318 make_tuple(64, 16, &aom_highbd_sad64x16_avg_c, 8),
1319 make_tuple(16, 64, &aom_highbd_sad16x64_avg_c, 8),
1320 make_tuple(64, 16, &aom_highbd_sad64x16_avg_c, 10),
1321 make_tuple(16, 64, &aom_highbd_sad16x64_avg_c, 10),
1322 make_tuple(64, 16, &aom_highbd_sad64x16_avg_c, 12),
1323 make_tuple(16, 64, &aom_highbd_sad16x64_avg_c, 12),
1324 #endif
1325 make_tuple(32, 8, &aom_sad32x8_avg_c, -1),
1326 make_tuple(8, 32, &aom_sad8x32_avg_c, -1),
1327 #if CONFIG_AV1_HIGHBITDEPTH
1328 make_tuple(32, 8, &aom_highbd_sad32x8_avg_c, 8),
1329 make_tuple(8, 32, &aom_highbd_sad8x32_avg_c, 8),
1330 make_tuple(32, 8, &aom_highbd_sad32x8_avg_c, 10),
1331 make_tuple(8, 32, &aom_highbd_sad8x32_avg_c, 10),
1332 make_tuple(32, 8, &aom_highbd_sad32x8_avg_c, 12),
1333 make_tuple(8, 32, &aom_highbd_sad8x32_avg_c, 12),
1334 #endif
1335 make_tuple(16, 4, &aom_sad16x4_avg_c, -1),
1336 make_tuple(4, 16, &aom_sad4x16_avg_c, -1),
1337 #if CONFIG_AV1_HIGHBITDEPTH
1338 make_tuple(16, 4, &aom_highbd_sad16x4_avg_c, 8),
1339 make_tuple(4, 16, &aom_highbd_sad4x16_avg_c, 8),
1340 make_tuple(16, 4, &aom_highbd_sad16x4_avg_c, 10),
1341 make_tuple(4, 16, &aom_highbd_sad4x16_avg_c, 10),
1342 make_tuple(16, 4, &aom_highbd_sad16x4_avg_c, 12),
1343 make_tuple(4, 16, &aom_highbd_sad4x16_avg_c, 12),
1344 #endif
1345 #endif // !CONFIG_REALTIME_ONLY
1346 };
1347 INSTANTIATE_TEST_SUITE_P(C, SADavgTest, ::testing::ValuesIn(avg_c_tests));
1348
1349 const DistWtdSadMxNAvgParam dist_wtd_avg_c_tests[] = {
1350 make_tuple(128, 128, &aom_dist_wtd_sad128x128_avg_c, -1),
1351 make_tuple(128, 64, &aom_dist_wtd_sad128x64_avg_c, -1),
1352 make_tuple(64, 128, &aom_dist_wtd_sad64x128_avg_c, -1),
1353 make_tuple(64, 64, &aom_dist_wtd_sad64x64_avg_c, -1),
1354 make_tuple(64, 32, &aom_dist_wtd_sad64x32_avg_c, -1),
1355 make_tuple(32, 64, &aom_dist_wtd_sad32x64_avg_c, -1),
1356 make_tuple(32, 32, &aom_dist_wtd_sad32x32_avg_c, -1),
1357 make_tuple(32, 16, &aom_dist_wtd_sad32x16_avg_c, -1),
1358 make_tuple(16, 32, &aom_dist_wtd_sad16x32_avg_c, -1),
1359 make_tuple(16, 16, &aom_dist_wtd_sad16x16_avg_c, -1),
1360 make_tuple(16, 8, &aom_dist_wtd_sad16x8_avg_c, -1),
1361 make_tuple(8, 16, &aom_dist_wtd_sad8x16_avg_c, -1),
1362 make_tuple(8, 8, &aom_dist_wtd_sad8x8_avg_c, -1),
1363 make_tuple(8, 4, &aom_dist_wtd_sad8x4_avg_c, -1),
1364 make_tuple(4, 8, &aom_dist_wtd_sad4x8_avg_c, -1),
1365 make_tuple(4, 4, &aom_dist_wtd_sad4x4_avg_c, -1),
1366
1367 #if !CONFIG_REALTIME_ONLY
1368 make_tuple(64, 16, &aom_dist_wtd_sad64x16_avg_c, -1),
1369 make_tuple(16, 64, &aom_dist_wtd_sad16x64_avg_c, -1),
1370 make_tuple(32, 8, &aom_dist_wtd_sad32x8_avg_c, -1),
1371 make_tuple(8, 32, &aom_dist_wtd_sad8x32_avg_c, -1),
1372 make_tuple(16, 4, &aom_dist_wtd_sad16x4_avg_c, -1),
1373 make_tuple(4, 16, &aom_dist_wtd_sad4x16_avg_c, -1),
1374 #endif
1375 };
1376
1377 INSTANTIATE_TEST_SUITE_P(C, DistWtdSADavgTest,
1378 ::testing::ValuesIn(dist_wtd_avg_c_tests));
1379
1380 const SadMxNx4Param x4d_c_tests[] = {
1381 make_tuple(128, 128, &aom_sad128x128x4d_c, -1),
1382 make_tuple(128, 64, &aom_sad128x64x4d_c, -1),
1383 make_tuple(64, 128, &aom_sad64x128x4d_c, -1),
1384 make_tuple(64, 64, &aom_sad64x64x4d_c, -1),
1385 make_tuple(64, 32, &aom_sad64x32x4d_c, -1),
1386 make_tuple(32, 64, &aom_sad32x64x4d_c, -1),
1387 make_tuple(32, 32, &aom_sad32x32x4d_c, -1),
1388 make_tuple(32, 16, &aom_sad32x16x4d_c, -1),
1389 make_tuple(16, 32, &aom_sad16x32x4d_c, -1),
1390 make_tuple(16, 16, &aom_sad16x16x4d_c, -1),
1391 make_tuple(16, 8, &aom_sad16x8x4d_c, -1),
1392 make_tuple(8, 16, &aom_sad8x16x4d_c, -1),
1393 make_tuple(8, 8, &aom_sad8x8x4d_c, -1),
1394 make_tuple(8, 4, &aom_sad8x4x4d_c, -1),
1395 make_tuple(4, 8, &aom_sad4x8x4d_c, -1),
1396 make_tuple(4, 4, &aom_sad4x4x4d_c, -1),
1397 #if CONFIG_AV1_HIGHBITDEPTH
1398 make_tuple(128, 128, &aom_highbd_sad128x128x4d_c, 8),
1399 make_tuple(128, 64, &aom_highbd_sad128x64x4d_c, 8),
1400 make_tuple(64, 128, &aom_highbd_sad64x128x4d_c, 8),
1401 make_tuple(64, 64, &aom_highbd_sad64x64x4d_c, 8),
1402 make_tuple(64, 32, &aom_highbd_sad64x32x4d_c, 8),
1403 make_tuple(32, 64, &aom_highbd_sad32x64x4d_c, 8),
1404 make_tuple(32, 32, &aom_highbd_sad32x32x4d_c, 8),
1405 make_tuple(32, 16, &aom_highbd_sad32x16x4d_c, 8),
1406 make_tuple(16, 32, &aom_highbd_sad16x32x4d_c, 8),
1407 make_tuple(16, 16, &aom_highbd_sad16x16x4d_c, 8),
1408 make_tuple(16, 8, &aom_highbd_sad16x8x4d_c, 8),
1409 make_tuple(8, 16, &aom_highbd_sad8x16x4d_c, 8),
1410 make_tuple(8, 8, &aom_highbd_sad8x8x4d_c, 8),
1411 make_tuple(8, 4, &aom_highbd_sad8x4x4d_c, 8),
1412 make_tuple(4, 8, &aom_highbd_sad4x8x4d_c, 8),
1413 make_tuple(4, 4, &aom_highbd_sad4x4x4d_c, 8),
1414 make_tuple(128, 128, &aom_highbd_sad128x128x4d_c, 10),
1415 make_tuple(128, 64, &aom_highbd_sad128x64x4d_c, 10),
1416 make_tuple(64, 128, &aom_highbd_sad64x128x4d_c, 10),
1417 make_tuple(64, 64, &aom_highbd_sad64x64x4d_c, 10),
1418 make_tuple(64, 32, &aom_highbd_sad64x32x4d_c, 10),
1419 make_tuple(32, 64, &aom_highbd_sad32x64x4d_c, 10),
1420 make_tuple(32, 32, &aom_highbd_sad32x32x4d_c, 10),
1421 make_tuple(32, 16, &aom_highbd_sad32x16x4d_c, 10),
1422 make_tuple(16, 32, &aom_highbd_sad16x32x4d_c, 10),
1423 make_tuple(16, 16, &aom_highbd_sad16x16x4d_c, 10),
1424 make_tuple(16, 8, &aom_highbd_sad16x8x4d_c, 10),
1425 make_tuple(8, 16, &aom_highbd_sad8x16x4d_c, 10),
1426 make_tuple(8, 8, &aom_highbd_sad8x8x4d_c, 10),
1427 make_tuple(8, 4, &aom_highbd_sad8x4x4d_c, 10),
1428 make_tuple(4, 8, &aom_highbd_sad4x8x4d_c, 10),
1429 make_tuple(4, 4, &aom_highbd_sad4x4x4d_c, 10),
1430 make_tuple(128, 128, &aom_highbd_sad128x128x4d_c, 12),
1431 make_tuple(128, 64, &aom_highbd_sad128x64x4d_c, 12),
1432 make_tuple(64, 128, &aom_highbd_sad64x128x4d_c, 12),
1433 make_tuple(64, 64, &aom_highbd_sad64x64x4d_c, 12),
1434 make_tuple(64, 32, &aom_highbd_sad64x32x4d_c, 12),
1435 make_tuple(32, 64, &aom_highbd_sad32x64x4d_c, 12),
1436 make_tuple(32, 32, &aom_highbd_sad32x32x4d_c, 12),
1437 make_tuple(32, 16, &aom_highbd_sad32x16x4d_c, 12),
1438 make_tuple(16, 32, &aom_highbd_sad16x32x4d_c, 12),
1439 make_tuple(16, 16, &aom_highbd_sad16x16x4d_c, 12),
1440 make_tuple(16, 8, &aom_highbd_sad16x8x4d_c, 12),
1441 make_tuple(8, 16, &aom_highbd_sad8x16x4d_c, 12),
1442 make_tuple(8, 8, &aom_highbd_sad8x8x4d_c, 12),
1443 make_tuple(8, 4, &aom_highbd_sad8x4x4d_c, 12),
1444 make_tuple(4, 8, &aom_highbd_sad4x8x4d_c, 12),
1445 make_tuple(4, 4, &aom_highbd_sad4x4x4d_c, 12),
1446 #endif
1447 #if !CONFIG_REALTIME_ONLY
1448 make_tuple(64, 16, &aom_sad64x16x4d_c, -1),
1449 make_tuple(16, 64, &aom_sad16x64x4d_c, -1),
1450 #if CONFIG_AV1_HIGHBITDEPTH
1451 make_tuple(64, 16, &aom_highbd_sad64x16x4d_c, 8),
1452 make_tuple(16, 64, &aom_highbd_sad16x64x4d_c, 8),
1453 make_tuple(64, 16, &aom_highbd_sad64x16x4d_c, 10),
1454 make_tuple(16, 64, &aom_highbd_sad16x64x4d_c, 10),
1455 make_tuple(64, 16, &aom_highbd_sad64x16x4d_c, 12),
1456 make_tuple(16, 64, &aom_highbd_sad16x64x4d_c, 12),
1457 #endif
1458 make_tuple(32, 8, &aom_sad32x8x4d_c, -1),
1459 make_tuple(8, 32, &aom_sad8x32x4d_c, -1),
1460 #if CONFIG_AV1_HIGHBITDEPTH
1461 make_tuple(32, 8, &aom_highbd_sad32x8x4d_c, 8),
1462 make_tuple(8, 32, &aom_highbd_sad8x32x4d_c, 8),
1463 make_tuple(32, 8, &aom_highbd_sad32x8x4d_c, 10),
1464 make_tuple(8, 32, &aom_highbd_sad8x32x4d_c, 10),
1465 make_tuple(32, 8, &aom_highbd_sad32x8x4d_c, 12),
1466 make_tuple(8, 32, &aom_highbd_sad8x32x4d_c, 12),
1467 #endif
1468 make_tuple(16, 4, &aom_sad16x4x4d_c, -1),
1469 make_tuple(4, 16, &aom_sad4x16x4d_c, -1),
1470 #if CONFIG_AV1_HIGHBITDEPTH
1471 make_tuple(16, 4, &aom_highbd_sad16x4x4d_c, 8),
1472 make_tuple(4, 16, &aom_highbd_sad4x16x4d_c, 8),
1473 make_tuple(16, 4, &aom_highbd_sad16x4x4d_c, 10),
1474 make_tuple(4, 16, &aom_highbd_sad4x16x4d_c, 10),
1475 make_tuple(16, 4, &aom_highbd_sad16x4x4d_c, 12),
1476 make_tuple(4, 16, &aom_highbd_sad4x16x4d_c, 12),
1477 #endif
1478 #endif // !CONFIG_REALTIME_ONLY
1479 };
1480 INSTANTIATE_TEST_SUITE_P(C, SADx4Test, ::testing::ValuesIn(x4d_c_tests));
1481
1482 const SadMxNx4Param x3d_c_tests[] = {
1483 make_tuple(128, 128, &aom_sad128x128x3d_c, -1),
1484 make_tuple(128, 64, &aom_sad128x64x3d_c, -1),
1485 make_tuple(64, 128, &aom_sad64x128x3d_c, -1),
1486 make_tuple(64, 64, &aom_sad64x64x3d_c, -1),
1487 make_tuple(64, 32, &aom_sad64x32x3d_c, -1),
1488 make_tuple(32, 64, &aom_sad32x64x3d_c, -1),
1489 make_tuple(32, 32, &aom_sad32x32x3d_c, -1),
1490 make_tuple(32, 16, &aom_sad32x16x3d_c, -1),
1491 make_tuple(16, 32, &aom_sad16x32x3d_c, -1),
1492 make_tuple(16, 16, &aom_sad16x16x3d_c, -1),
1493 make_tuple(16, 8, &aom_sad16x8x3d_c, -1),
1494 make_tuple(8, 16, &aom_sad8x16x3d_c, -1),
1495 make_tuple(8, 8, &aom_sad8x8x3d_c, -1),
1496 make_tuple(8, 4, &aom_sad8x4x3d_c, -1),
1497 make_tuple(4, 8, &aom_sad4x8x3d_c, -1),
1498 make_tuple(4, 4, &aom_sad4x4x3d_c, -1),
1499 #if CONFIG_AV1_HIGHBITDEPTH
1500 make_tuple(128, 128, &aom_highbd_sad128x128x3d_c, 8),
1501 make_tuple(128, 64, &aom_highbd_sad128x64x3d_c, 8),
1502 make_tuple(64, 128, &aom_highbd_sad64x128x3d_c, 8),
1503 make_tuple(64, 64, &aom_highbd_sad64x64x3d_c, 8),
1504 make_tuple(64, 32, &aom_highbd_sad64x32x3d_c, 8),
1505 make_tuple(32, 64, &aom_highbd_sad32x64x3d_c, 8),
1506 make_tuple(32, 32, &aom_highbd_sad32x32x3d_c, 8),
1507 make_tuple(32, 16, &aom_highbd_sad32x16x3d_c, 8),
1508 make_tuple(16, 32, &aom_highbd_sad16x32x3d_c, 8),
1509 make_tuple(16, 16, &aom_highbd_sad16x16x3d_c, 8),
1510 make_tuple(16, 8, &aom_highbd_sad16x8x3d_c, 8),
1511 make_tuple(8, 16, &aom_highbd_sad8x16x3d_c, 8),
1512 make_tuple(8, 8, &aom_highbd_sad8x8x3d_c, 8),
1513 make_tuple(8, 4, &aom_highbd_sad8x4x3d_c, 8),
1514 make_tuple(4, 8, &aom_highbd_sad4x8x3d_c, 8),
1515 make_tuple(4, 4, &aom_highbd_sad4x4x3d_c, 8),
1516 make_tuple(128, 128, &aom_highbd_sad128x128x3d_c, 10),
1517 make_tuple(128, 64, &aom_highbd_sad128x64x3d_c, 10),
1518 make_tuple(64, 128, &aom_highbd_sad64x128x3d_c, 10),
1519 make_tuple(64, 64, &aom_highbd_sad64x64x3d_c, 10),
1520 make_tuple(64, 32, &aom_highbd_sad64x32x3d_c, 10),
1521 make_tuple(32, 64, &aom_highbd_sad32x64x3d_c, 10),
1522 make_tuple(32, 32, &aom_highbd_sad32x32x3d_c, 10),
1523 make_tuple(32, 16, &aom_highbd_sad32x16x3d_c, 10),
1524 make_tuple(16, 32, &aom_highbd_sad16x32x3d_c, 10),
1525 make_tuple(16, 16, &aom_highbd_sad16x16x3d_c, 10),
1526 make_tuple(16, 8, &aom_highbd_sad16x8x3d_c, 10),
1527 make_tuple(8, 16, &aom_highbd_sad8x16x3d_c, 10),
1528 make_tuple(8, 8, &aom_highbd_sad8x8x3d_c, 10),
1529 make_tuple(8, 4, &aom_highbd_sad8x4x3d_c, 10),
1530 make_tuple(4, 8, &aom_highbd_sad4x8x3d_c, 10),
1531 make_tuple(4, 4, &aom_highbd_sad4x4x3d_c, 10),
1532 make_tuple(128, 128, &aom_highbd_sad128x128x3d_c, 12),
1533 make_tuple(128, 64, &aom_highbd_sad128x64x3d_c, 12),
1534 make_tuple(64, 128, &aom_highbd_sad64x128x3d_c, 12),
1535 make_tuple(64, 64, &aom_highbd_sad64x64x3d_c, 12),
1536 make_tuple(64, 32, &aom_highbd_sad64x32x3d_c, 12),
1537 make_tuple(32, 64, &aom_highbd_sad32x64x3d_c, 12),
1538 make_tuple(32, 32, &aom_highbd_sad32x32x3d_c, 12),
1539 make_tuple(32, 16, &aom_highbd_sad32x16x3d_c, 12),
1540 make_tuple(16, 32, &aom_highbd_sad16x32x3d_c, 12),
1541 make_tuple(16, 16, &aom_highbd_sad16x16x3d_c, 12),
1542 make_tuple(16, 8, &aom_highbd_sad16x8x3d_c, 12),
1543 make_tuple(8, 16, &aom_highbd_sad8x16x3d_c, 12),
1544 make_tuple(8, 8, &aom_highbd_sad8x8x3d_c, 12),
1545 make_tuple(8, 4, &aom_highbd_sad8x4x3d_c, 12),
1546 make_tuple(4, 8, &aom_highbd_sad4x8x3d_c, 12),
1547 make_tuple(4, 4, &aom_highbd_sad4x4x3d_c, 12),
1548 #endif
1549 #if !CONFIG_REALTIME_ONLY
1550 make_tuple(64, 16, &aom_sad64x16x3d_c, -1),
1551 make_tuple(16, 64, &aom_sad16x64x3d_c, -1),
1552 #if CONFIG_AV1_HIGHBITDEPTH
1553 make_tuple(64, 16, &aom_highbd_sad64x16x3d_c, 8),
1554 make_tuple(16, 64, &aom_highbd_sad16x64x3d_c, 8),
1555 make_tuple(64, 16, &aom_highbd_sad64x16x3d_c, 10),
1556 make_tuple(16, 64, &aom_highbd_sad16x64x3d_c, 10),
1557 make_tuple(64, 16, &aom_highbd_sad64x16x3d_c, 12),
1558 make_tuple(16, 64, &aom_highbd_sad16x64x3d_c, 12),
1559 #endif
1560 make_tuple(32, 8, &aom_sad32x8x3d_c, -1),
1561 make_tuple(8, 32, &aom_sad8x32x3d_c, -1),
1562 #if CONFIG_AV1_HIGHBITDEPTH
1563 make_tuple(32, 8, &aom_highbd_sad32x8x3d_c, 8),
1564 make_tuple(8, 32, &aom_highbd_sad8x32x3d_c, 8),
1565 make_tuple(32, 8, &aom_highbd_sad32x8x3d_c, 10),
1566 make_tuple(8, 32, &aom_highbd_sad8x32x3d_c, 10),
1567 make_tuple(32, 8, &aom_highbd_sad32x8x3d_c, 12),
1568 make_tuple(8, 32, &aom_highbd_sad8x32x3d_c, 12),
1569 #endif
1570 make_tuple(16, 4, &aom_sad16x4x3d_c, -1),
1571 make_tuple(4, 16, &aom_sad4x16x3d_c, -1),
1572 #if CONFIG_AV1_HIGHBITDEPTH
1573 make_tuple(16, 4, &aom_highbd_sad16x4x3d_c, 8),
1574 make_tuple(4, 16, &aom_highbd_sad4x16x3d_c, 8),
1575 make_tuple(16, 4, &aom_highbd_sad16x4x3d_c, 10),
1576 make_tuple(4, 16, &aom_highbd_sad4x16x3d_c, 10),
1577 make_tuple(16, 4, &aom_highbd_sad16x4x3d_c, 12),
1578 make_tuple(4, 16, &aom_highbd_sad4x16x3d_c, 12),
1579 #endif
1580 #endif // !CONFIG_REALTIME_ONLY
1581 };
1582 INSTANTIATE_TEST_SUITE_P(C, SADx3Test, ::testing::ValuesIn(x3d_c_tests));
1583
1584 const SadMxNx4Param skip_x4d_c_tests[] = {
1585 make_tuple(128, 128, &aom_sad_skip_128x128x4d_c, -1),
1586 make_tuple(128, 64, &aom_sad_skip_128x64x4d_c, -1),
1587 make_tuple(64, 128, &aom_sad_skip_64x128x4d_c, -1),
1588 make_tuple(64, 64, &aom_sad_skip_64x64x4d_c, -1),
1589 make_tuple(64, 32, &aom_sad_skip_64x32x4d_c, -1),
1590 make_tuple(32, 64, &aom_sad_skip_32x64x4d_c, -1),
1591 make_tuple(32, 32, &aom_sad_skip_32x32x4d_c, -1),
1592 make_tuple(32, 16, &aom_sad_skip_32x16x4d_c, -1),
1593 make_tuple(16, 32, &aom_sad_skip_16x32x4d_c, -1),
1594 make_tuple(16, 16, &aom_sad_skip_16x16x4d_c, -1),
1595 make_tuple(16, 8, &aom_sad_skip_16x8x4d_c, -1),
1596 make_tuple(8, 16, &aom_sad_skip_8x16x4d_c, -1),
1597 make_tuple(8, 8, &aom_sad_skip_8x8x4d_c, -1),
1598 make_tuple(4, 8, &aom_sad_skip_4x8x4d_c, -1),
1599 #if !CONFIG_REALTIME_ONLY
1600 make_tuple(64, 16, &aom_sad_skip_64x16x4d_c, -1),
1601 make_tuple(16, 64, &aom_sad_skip_16x64x4d_c, -1),
1602 make_tuple(32, 8, &aom_sad_skip_32x8x4d_c, -1),
1603 make_tuple(8, 32, &aom_sad_skip_8x32x4d_c, -1),
1604 make_tuple(4, 16, &aom_sad_skip_4x16x4d_c, -1),
1605 #endif
1606 #if CONFIG_AV1_HIGHBITDEPTH
1607 make_tuple(128, 128, &aom_highbd_sad_skip_128x128x4d_c, 8),
1608 make_tuple(128, 64, &aom_highbd_sad_skip_128x64x4d_c, 8),
1609 make_tuple(64, 128, &aom_highbd_sad_skip_64x128x4d_c, 8),
1610 make_tuple(64, 64, &aom_highbd_sad_skip_64x64x4d_c, 8),
1611 make_tuple(64, 32, &aom_highbd_sad_skip_64x32x4d_c, 8),
1612 make_tuple(32, 64, &aom_highbd_sad_skip_32x64x4d_c, 8),
1613 make_tuple(32, 32, &aom_highbd_sad_skip_32x32x4d_c, 8),
1614 make_tuple(32, 16, &aom_highbd_sad_skip_32x16x4d_c, 8),
1615 make_tuple(16, 32, &aom_highbd_sad_skip_16x32x4d_c, 8),
1616 make_tuple(16, 16, &aom_highbd_sad_skip_16x16x4d_c, 8),
1617 make_tuple(16, 8, &aom_highbd_sad_skip_16x8x4d_c, 8),
1618 make_tuple(8, 16, &aom_highbd_sad_skip_8x16x4d_c, 8),
1619 make_tuple(8, 8, &aom_highbd_sad_skip_8x8x4d_c, 8),
1620 make_tuple(8, 4, &aom_highbd_sad_skip_8x4x4d_c, 8),
1621 make_tuple(4, 8, &aom_highbd_sad_skip_4x8x4d_c, 8),
1622 make_tuple(4, 4, &aom_highbd_sad_skip_4x4x4d_c, 8),
1623 #if !CONFIG_REALTIME_ONLY
1624 make_tuple(64, 16, &aom_highbd_sad_skip_64x16x4d_c, 8),
1625 make_tuple(16, 64, &aom_highbd_sad_skip_16x64x4d_c, 8),
1626 make_tuple(32, 8, &aom_highbd_sad_skip_32x8x4d_c, 8),
1627 make_tuple(8, 32, &aom_highbd_sad_skip_8x32x4d_c, 8),
1628 make_tuple(16, 4, &aom_highbd_sad_skip_16x4x4d_c, 8),
1629 make_tuple(4, 16, &aom_highbd_sad_skip_4x16x4d_c, 8),
1630 #endif
1631
1632 make_tuple(128, 128, &aom_highbd_sad_skip_128x128x4d_c, 10),
1633 make_tuple(128, 64, &aom_highbd_sad_skip_128x64x4d_c, 10),
1634 make_tuple(64, 128, &aom_highbd_sad_skip_64x128x4d_c, 10),
1635 make_tuple(64, 64, &aom_highbd_sad_skip_64x64x4d_c, 10),
1636 make_tuple(64, 32, &aom_highbd_sad_skip_64x32x4d_c, 10),
1637 make_tuple(32, 64, &aom_highbd_sad_skip_32x64x4d_c, 10),
1638 make_tuple(32, 32, &aom_highbd_sad_skip_32x32x4d_c, 10),
1639 make_tuple(32, 16, &aom_highbd_sad_skip_32x16x4d_c, 10),
1640 make_tuple(16, 32, &aom_highbd_sad_skip_16x32x4d_c, 10),
1641 make_tuple(16, 16, &aom_highbd_sad_skip_16x16x4d_c, 10),
1642 make_tuple(16, 8, &aom_highbd_sad_skip_16x8x4d_c, 10),
1643 make_tuple(8, 16, &aom_highbd_sad_skip_8x16x4d_c, 10),
1644 make_tuple(8, 8, &aom_highbd_sad_skip_8x8x4d_c, 10),
1645 make_tuple(8, 4, &aom_highbd_sad_skip_8x4x4d_c, 10),
1646 make_tuple(4, 8, &aom_highbd_sad_skip_4x8x4d_c, 10),
1647 make_tuple(4, 4, &aom_highbd_sad_skip_4x4x4d_c, 10),
1648 #if !CONFIG_REALTIME_ONLY
1649 make_tuple(64, 16, &aom_highbd_sad_skip_64x16x4d_c, 10),
1650 make_tuple(16, 64, &aom_highbd_sad_skip_16x64x4d_c, 10),
1651 make_tuple(32, 8, &aom_highbd_sad_skip_32x8x4d_c, 10),
1652 make_tuple(8, 32, &aom_highbd_sad_skip_8x32x4d_c, 10),
1653 make_tuple(16, 4, &aom_highbd_sad_skip_16x4x4d_c, 10),
1654 make_tuple(4, 16, &aom_highbd_sad_skip_4x16x4d_c, 10),
1655 #endif
1656
1657 make_tuple(128, 128, &aom_highbd_sad_skip_128x128x4d_c, 12),
1658 make_tuple(128, 64, &aom_highbd_sad_skip_128x64x4d_c, 12),
1659 make_tuple(64, 128, &aom_highbd_sad_skip_64x128x4d_c, 12),
1660 make_tuple(64, 64, &aom_highbd_sad_skip_64x64x4d_c, 12),
1661 make_tuple(64, 32, &aom_highbd_sad_skip_64x32x4d_c, 12),
1662 make_tuple(32, 64, &aom_highbd_sad_skip_32x64x4d_c, 12),
1663 make_tuple(32, 32, &aom_highbd_sad_skip_32x32x4d_c, 12),
1664 make_tuple(32, 16, &aom_highbd_sad_skip_32x16x4d_c, 12),
1665 make_tuple(16, 32, &aom_highbd_sad_skip_16x32x4d_c, 12),
1666 make_tuple(16, 16, &aom_highbd_sad_skip_16x16x4d_c, 12),
1667 make_tuple(16, 8, &aom_highbd_sad_skip_16x8x4d_c, 12),
1668 make_tuple(8, 16, &aom_highbd_sad_skip_8x16x4d_c, 12),
1669 make_tuple(8, 8, &aom_highbd_sad_skip_8x8x4d_c, 12),
1670 make_tuple(8, 4, &aom_highbd_sad_skip_8x4x4d_c, 12),
1671 make_tuple(4, 8, &aom_highbd_sad_skip_4x8x4d_c, 12),
1672 make_tuple(4, 4, &aom_highbd_sad_skip_4x4x4d_c, 12),
1673 #if !CONFIG_REALTIME_ONLY
1674 make_tuple(64, 16, &aom_highbd_sad_skip_64x16x4d_c, 12),
1675 make_tuple(16, 64, &aom_highbd_sad_skip_16x64x4d_c, 12),
1676 make_tuple(32, 8, &aom_highbd_sad_skip_32x8x4d_c, 12),
1677 make_tuple(8, 32, &aom_highbd_sad_skip_8x32x4d_c, 12),
1678 make_tuple(16, 4, &aom_highbd_sad_skip_16x4x4d_c, 12),
1679 make_tuple(4, 16, &aom_highbd_sad_skip_4x16x4d_c, 12),
1680 #endif
1681 #endif // CONFIG_AV1_HIGHBITDEPTH
1682 };
1683 INSTANTIATE_TEST_SUITE_P(C, SADSkipx4Test,
1684 ::testing::ValuesIn(skip_x4d_c_tests));
1685
1686 //------------------------------------------------------------------------------
1687 // ARM functions
1688 #if HAVE_NEON
1689 const SadMxNParam neon_tests[] = {
1690 make_tuple(128, 128, &aom_sad128x128_neon, -1),
1691 make_tuple(128, 64, &aom_sad128x64_neon, -1),
1692 make_tuple(64, 128, &aom_sad64x128_neon, -1),
1693 make_tuple(64, 64, &aom_sad64x64_neon, -1),
1694 make_tuple(64, 32, &aom_sad64x32_neon, -1),
1695 make_tuple(32, 64, &aom_sad32x64_neon, -1),
1696 make_tuple(32, 32, &aom_sad32x32_neon, -1),
1697 make_tuple(32, 16, &aom_sad32x16_neon, -1),
1698 make_tuple(16, 32, &aom_sad16x32_neon, -1),
1699 make_tuple(16, 16, &aom_sad16x16_neon, -1),
1700 make_tuple(16, 8, &aom_sad16x8_neon, -1),
1701 make_tuple(8, 16, &aom_sad8x16_neon, -1),
1702 make_tuple(8, 8, &aom_sad8x8_neon, -1),
1703 make_tuple(8, 4, &aom_sad8x4_neon, -1),
1704 make_tuple(4, 8, &aom_sad4x8_neon, -1),
1705 make_tuple(4, 4, &aom_sad4x4_neon, -1),
1706 #if CONFIG_AV1_HIGHBITDEPTH
1707 make_tuple(128, 128, &aom_highbd_sad128x128_neon, 8),
1708 make_tuple(128, 64, &aom_highbd_sad128x64_neon, 8),
1709 make_tuple(64, 128, &aom_highbd_sad64x128_neon, 8),
1710 make_tuple(64, 64, &aom_highbd_sad64x64_neon, 8),
1711 make_tuple(64, 32, &aom_highbd_sad64x32_neon, 8),
1712 make_tuple(32, 64, &aom_highbd_sad32x64_neon, 8),
1713 make_tuple(32, 32, &aom_highbd_sad32x32_neon, 8),
1714 make_tuple(32, 16, &aom_highbd_sad32x16_neon, 8),
1715 make_tuple(16, 32, &aom_highbd_sad16x32_neon, 8),
1716 make_tuple(16, 16, &aom_highbd_sad16x16_neon, 8),
1717 make_tuple(16, 8, &aom_highbd_sad16x8_neon, 8),
1718 make_tuple(8, 16, &aom_highbd_sad8x16_neon, 8),
1719 make_tuple(8, 8, &aom_highbd_sad8x8_neon, 8),
1720 make_tuple(8, 4, &aom_highbd_sad8x4_neon, 8),
1721 make_tuple(4, 8, &aom_highbd_sad4x8_neon, 8),
1722 make_tuple(4, 4, &aom_highbd_sad4x4_neon, 8),
1723 make_tuple(128, 128, &aom_highbd_sad128x128_neon, 10),
1724 make_tuple(128, 64, &aom_highbd_sad128x64_neon, 10),
1725 make_tuple(64, 128, &aom_highbd_sad64x128_neon, 10),
1726 make_tuple(64, 64, &aom_highbd_sad64x64_neon, 10),
1727 make_tuple(64, 32, &aom_highbd_sad64x32_neon, 10),
1728 make_tuple(32, 64, &aom_highbd_sad32x64_neon, 10),
1729 make_tuple(32, 32, &aom_highbd_sad32x32_neon, 10),
1730 make_tuple(32, 16, &aom_highbd_sad32x16_neon, 10),
1731 make_tuple(16, 32, &aom_highbd_sad16x32_neon, 10),
1732 make_tuple(16, 16, &aom_highbd_sad16x16_neon, 10),
1733 make_tuple(16, 8, &aom_highbd_sad16x8_neon, 10),
1734 make_tuple(8, 16, &aom_highbd_sad8x16_neon, 10),
1735 make_tuple(8, 8, &aom_highbd_sad8x8_neon, 10),
1736 make_tuple(8, 4, &aom_highbd_sad8x4_neon, 10),
1737 make_tuple(4, 8, &aom_highbd_sad4x8_neon, 10),
1738 make_tuple(4, 4, &aom_highbd_sad4x4_neon, 10),
1739 make_tuple(128, 128, &aom_highbd_sad128x128_neon, 12),
1740 make_tuple(128, 64, &aom_highbd_sad128x64_neon, 12),
1741 make_tuple(64, 128, &aom_highbd_sad64x128_neon, 12),
1742 make_tuple(64, 64, &aom_highbd_sad64x64_neon, 12),
1743 make_tuple(64, 32, &aom_highbd_sad64x32_neon, 12),
1744 make_tuple(32, 64, &aom_highbd_sad32x64_neon, 12),
1745 make_tuple(32, 32, &aom_highbd_sad32x32_neon, 12),
1746 make_tuple(32, 16, &aom_highbd_sad32x16_neon, 12),
1747 make_tuple(16, 32, &aom_highbd_sad16x32_neon, 12),
1748 make_tuple(16, 16, &aom_highbd_sad16x16_neon, 12),
1749 make_tuple(16, 8, &aom_highbd_sad16x8_neon, 12),
1750 make_tuple(8, 16, &aom_highbd_sad8x16_neon, 12),
1751 make_tuple(8, 8, &aom_highbd_sad8x8_neon, 12),
1752 make_tuple(8, 4, &aom_highbd_sad8x4_neon, 12),
1753 make_tuple(4, 8, &aom_highbd_sad4x8_neon, 12),
1754 make_tuple(4, 4, &aom_highbd_sad4x4_neon, 12),
1755 #endif // CONFIG_AV1_HIGHBITDEPTH
1756 #if !CONFIG_REALTIME_ONLY
1757 make_tuple(64, 16, &aom_sad64x16_neon, -1),
1758 make_tuple(32, 8, &aom_sad32x8_neon, -1),
1759 make_tuple(16, 64, &aom_sad16x64_neon, -1),
1760 make_tuple(16, 4, &aom_sad16x4_neon, -1),
1761 make_tuple(8, 32, &aom_sad8x32_neon, -1),
1762 make_tuple(4, 16, &aom_sad4x16_neon, -1),
1763 #if CONFIG_AV1_HIGHBITDEPTH
1764 make_tuple(64, 16, &aom_highbd_sad64x16_neon, 8),
1765 make_tuple(16, 64, &aom_highbd_sad16x64_neon, 8),
1766 make_tuple(32, 8, &aom_highbd_sad32x8_neon, 8),
1767 make_tuple(8, 32, &aom_highbd_sad8x32_neon, 8),
1768 make_tuple(16, 4, &aom_highbd_sad16x4_neon, 8),
1769 make_tuple(4, 16, &aom_highbd_sad4x16_neon, 8),
1770 make_tuple(64, 16, &aom_highbd_sad64x16_neon, 10),
1771 make_tuple(16, 64, &aom_highbd_sad16x64_neon, 10),
1772 make_tuple(32, 8, &aom_highbd_sad32x8_neon, 10),
1773 make_tuple(8, 32, &aom_highbd_sad8x32_neon, 10),
1774 make_tuple(16, 4, &aom_highbd_sad16x4_neon, 10),
1775 make_tuple(4, 16, &aom_highbd_sad4x16_neon, 10),
1776 make_tuple(64, 16, &aom_highbd_sad64x16_neon, 12),
1777 make_tuple(16, 64, &aom_highbd_sad16x64_neon, 12),
1778 make_tuple(32, 8, &aom_highbd_sad32x8_neon, 12),
1779 make_tuple(8, 32, &aom_highbd_sad8x32_neon, 12),
1780 make_tuple(16, 4, &aom_highbd_sad16x4_neon, 12),
1781 make_tuple(4, 16, &aom_highbd_sad4x16_neon, 12),
1782 #endif // CONFIG_AV1_HIGHBITDEPTH
1783 #endif // !CONFIG_REALTIME_ONLY
1784 };
1785 INSTANTIATE_TEST_SUITE_P(NEON, SADTest, ::testing::ValuesIn(neon_tests));
1786
1787 const SadMxNx4Param x4d_neon_tests[] = {
1788 make_tuple(128, 128, &aom_sad128x128x4d_neon, -1),
1789 make_tuple(128, 64, &aom_sad128x64x4d_neon, -1),
1790 make_tuple(64, 128, &aom_sad64x128x4d_neon, -1),
1791 make_tuple(64, 64, &aom_sad64x64x4d_neon, -1),
1792 make_tuple(64, 32, &aom_sad64x32x4d_neon, -1),
1793 make_tuple(32, 64, &aom_sad32x64x4d_neon, -1),
1794 make_tuple(32, 32, &aom_sad32x32x4d_neon, -1),
1795 make_tuple(32, 16, &aom_sad32x16x4d_neon, -1),
1796 make_tuple(16, 32, &aom_sad16x32x4d_neon, -1),
1797 make_tuple(16, 16, &aom_sad16x16x4d_neon, -1),
1798 make_tuple(16, 8, &aom_sad16x8x4d_neon, -1),
1799 make_tuple(8, 16, &aom_sad8x16x4d_neon, -1),
1800 make_tuple(8, 8, &aom_sad8x8x4d_neon, -1),
1801 make_tuple(8, 4, &aom_sad8x4x4d_neon, -1),
1802 make_tuple(4, 8, &aom_sad4x8x4d_neon, -1),
1803 make_tuple(4, 4, &aom_sad4x4x4d_neon, -1),
1804 #if CONFIG_AV1_HIGHBITDEPTH
1805 make_tuple(128, 128, &aom_highbd_sad128x128x4d_neon, 8),
1806 make_tuple(128, 64, &aom_highbd_sad128x64x4d_neon, 8),
1807 make_tuple(64, 128, &aom_highbd_sad64x128x4d_neon, 8),
1808 make_tuple(64, 64, &aom_highbd_sad64x64x4d_neon, 8),
1809 make_tuple(64, 32, &aom_highbd_sad64x32x4d_neon, 8),
1810 make_tuple(32, 64, &aom_highbd_sad32x64x4d_neon, 8),
1811 make_tuple(32, 32, &aom_highbd_sad32x32x4d_neon, 8),
1812 make_tuple(32, 16, &aom_highbd_sad32x16x4d_neon, 8),
1813 make_tuple(16, 32, &aom_highbd_sad16x32x4d_neon, 8),
1814 make_tuple(16, 16, &aom_highbd_sad16x16x4d_neon, 8),
1815 make_tuple(16, 8, &aom_highbd_sad16x8x4d_neon, 8),
1816 make_tuple(8, 16, &aom_highbd_sad8x16x4d_neon, 8),
1817 make_tuple(8, 8, &aom_highbd_sad8x8x4d_neon, 8),
1818 make_tuple(8, 4, &aom_highbd_sad8x4x4d_neon, 8),
1819 make_tuple(4, 8, &aom_highbd_sad4x8x4d_neon, 8),
1820 make_tuple(4, 4, &aom_highbd_sad4x4x4d_neon, 8),
1821 make_tuple(128, 128, &aom_highbd_sad128x128x4d_neon, 10),
1822 make_tuple(128, 64, &aom_highbd_sad128x64x4d_neon, 10),
1823 make_tuple(64, 128, &aom_highbd_sad64x128x4d_neon, 10),
1824 make_tuple(64, 64, &aom_highbd_sad64x64x4d_neon, 10),
1825 make_tuple(64, 32, &aom_highbd_sad64x32x4d_neon, 10),
1826 make_tuple(32, 64, &aom_highbd_sad32x64x4d_neon, 10),
1827 make_tuple(32, 32, &aom_highbd_sad32x32x4d_neon, 10),
1828 make_tuple(32, 16, &aom_highbd_sad32x16x4d_neon, 10),
1829 make_tuple(16, 32, &aom_highbd_sad16x32x4d_neon, 10),
1830 make_tuple(16, 16, &aom_highbd_sad16x16x4d_neon, 10),
1831 make_tuple(16, 8, &aom_highbd_sad16x8x4d_neon, 10),
1832 make_tuple(8, 16, &aom_highbd_sad8x16x4d_neon, 10),
1833 make_tuple(8, 8, &aom_highbd_sad8x8x4d_neon, 10),
1834 make_tuple(8, 4, &aom_highbd_sad8x4x4d_neon, 10),
1835 make_tuple(4, 8, &aom_highbd_sad4x8x4d_neon, 10),
1836 make_tuple(4, 4, &aom_highbd_sad4x4x4d_neon, 10),
1837 make_tuple(128, 128, &aom_highbd_sad128x128x4d_neon, 12),
1838 make_tuple(128, 64, &aom_highbd_sad128x64x4d_neon, 12),
1839 make_tuple(64, 128, &aom_highbd_sad64x128x4d_neon, 12),
1840 make_tuple(64, 64, &aom_highbd_sad64x64x4d_neon, 12),
1841 make_tuple(64, 32, &aom_highbd_sad64x32x4d_neon, 12),
1842 make_tuple(32, 64, &aom_highbd_sad32x64x4d_neon, 12),
1843 make_tuple(32, 32, &aom_highbd_sad32x32x4d_neon, 12),
1844 make_tuple(32, 16, &aom_highbd_sad32x16x4d_neon, 12),
1845 make_tuple(16, 32, &aom_highbd_sad16x32x4d_neon, 12),
1846 make_tuple(16, 16, &aom_highbd_sad16x16x4d_neon, 12),
1847 make_tuple(16, 8, &aom_highbd_sad16x8x4d_neon, 12),
1848 make_tuple(8, 16, &aom_highbd_sad8x16x4d_neon, 12),
1849 make_tuple(8, 8, &aom_highbd_sad8x8x4d_neon, 12),
1850 make_tuple(8, 4, &aom_highbd_sad8x4x4d_neon, 12),
1851 make_tuple(4, 8, &aom_highbd_sad4x8x4d_neon, 12),
1852 make_tuple(4, 4, &aom_highbd_sad4x4x4d_neon, 12),
1853 #endif // CONFIG_AV1_HIGHBITDEPTH
1854 #if !CONFIG_REALTIME_ONLY
1855 make_tuple(64, 16, &aom_sad64x16x4d_neon, -1),
1856 make_tuple(32, 8, &aom_sad32x8x4d_neon, -1),
1857 make_tuple(16, 64, &aom_sad16x64x4d_neon, -1),
1858 make_tuple(16, 4, &aom_sad16x4x4d_neon, -1),
1859 make_tuple(8, 32, &aom_sad8x32x4d_neon, -1),
1860 make_tuple(4, 16, &aom_sad4x16x4d_neon, -1),
1861 #if CONFIG_AV1_HIGHBITDEPTH
1862 make_tuple(64, 16, &aom_highbd_sad64x16x4d_neon, 8),
1863 make_tuple(16, 64, &aom_highbd_sad16x64x4d_neon, 8),
1864 make_tuple(32, 8, &aom_highbd_sad32x8x4d_neon, 8),
1865 make_tuple(8, 32, &aom_highbd_sad8x32x4d_neon, 8),
1866 make_tuple(16, 4, &aom_highbd_sad16x4x4d_neon, 8),
1867 make_tuple(4, 16, &aom_highbd_sad4x16x4d_neon, 8),
1868 make_tuple(64, 16, &aom_highbd_sad64x16x4d_neon, 10),
1869 make_tuple(16, 64, &aom_highbd_sad16x64x4d_neon, 10),
1870 make_tuple(32, 8, &aom_highbd_sad32x8x4d_neon, 10),
1871 make_tuple(8, 32, &aom_highbd_sad8x32x4d_neon, 10),
1872 make_tuple(16, 4, &aom_highbd_sad16x4x4d_neon, 10),
1873 make_tuple(4, 16, &aom_highbd_sad4x16x4d_neon, 10),
1874 make_tuple(64, 16, &aom_highbd_sad64x16x4d_neon, 12),
1875 make_tuple(16, 64, &aom_highbd_sad16x64x4d_neon, 12),
1876 make_tuple(32, 8, &aom_highbd_sad32x8x4d_neon, 12),
1877 make_tuple(8, 32, &aom_highbd_sad8x32x4d_neon, 12),
1878 make_tuple(16, 4, &aom_highbd_sad16x4x4d_neon, 12),
1879 make_tuple(4, 16, &aom_highbd_sad4x16x4d_neon, 12),
1880 #endif // CONFIG_AV1_HIGHBITDEPTH
1881 #endif // !CONFIG_REALTIME_ONLY
1882 };
1883 INSTANTIATE_TEST_SUITE_P(NEON, SADx4Test, ::testing::ValuesIn(x4d_neon_tests));
1884 const SadSkipMxNParam skip_neon_tests[] = {
1885 make_tuple(128, 128, &aom_sad_skip_128x128_neon, -1),
1886 make_tuple(128, 64, &aom_sad_skip_128x64_neon, -1),
1887 make_tuple(64, 128, &aom_sad_skip_64x128_neon, -1),
1888 make_tuple(64, 64, &aom_sad_skip_64x64_neon, -1),
1889 make_tuple(64, 32, &aom_sad_skip_64x32_neon, -1),
1890 make_tuple(32, 64, &aom_sad_skip_32x64_neon, -1),
1891 make_tuple(32, 32, &aom_sad_skip_32x32_neon, -1),
1892 make_tuple(32, 16, &aom_sad_skip_32x16_neon, -1),
1893 make_tuple(16, 32, &aom_sad_skip_16x32_neon, -1),
1894 make_tuple(16, 16, &aom_sad_skip_16x16_neon, -1),
1895 make_tuple(16, 8, &aom_sad_skip_16x8_neon, -1),
1896 make_tuple(8, 16, &aom_sad_skip_8x16_neon, -1),
1897 make_tuple(8, 8, &aom_sad_skip_8x8_neon, -1),
1898 make_tuple(8, 4, &aom_sad_skip_8x4_neon, -1),
1899 make_tuple(4, 8, &aom_sad_skip_4x8_neon, -1),
1900 make_tuple(4, 4, &aom_sad_skip_4x4_neon, -1),
1901 #if CONFIG_AV1_HIGHBITDEPTH
1902 make_tuple(128, 128, &aom_highbd_sad_skip_128x128_neon, 8),
1903 make_tuple(128, 64, &aom_highbd_sad_skip_128x64_neon, 8),
1904 make_tuple(64, 128, &aom_highbd_sad_skip_64x128_neon, 8),
1905 make_tuple(64, 64, &aom_highbd_sad_skip_64x64_neon, 8),
1906 make_tuple(64, 32, &aom_highbd_sad_skip_64x32_neon, 8),
1907 make_tuple(32, 64, &aom_highbd_sad_skip_32x64_neon, 8),
1908 make_tuple(32, 32, &aom_highbd_sad_skip_32x32_neon, 8),
1909 make_tuple(32, 16, &aom_highbd_sad_skip_32x16_neon, 8),
1910 make_tuple(16, 32, &aom_highbd_sad_skip_16x32_neon, 8),
1911 make_tuple(16, 16, &aom_highbd_sad_skip_16x16_neon, 8),
1912 make_tuple(16, 8, &aom_highbd_sad_skip_16x8_neon, 8),
1913 make_tuple(8, 16, &aom_highbd_sad_skip_8x16_neon, 8),
1914 make_tuple(8, 8, &aom_highbd_sad_skip_8x8_neon, 8),
1915 make_tuple(8, 4, &aom_highbd_sad_skip_8x4_neon, 8),
1916 make_tuple(4, 8, &aom_highbd_sad_skip_4x8_neon, 8),
1917 make_tuple(4, 4, &aom_highbd_sad_skip_4x4_neon, 8),
1918 make_tuple(128, 128, &aom_highbd_sad_skip_128x128_neon, 10),
1919 make_tuple(128, 64, &aom_highbd_sad_skip_128x64_neon, 10),
1920 make_tuple(64, 128, &aom_highbd_sad_skip_64x128_neon, 10),
1921 make_tuple(64, 64, &aom_highbd_sad_skip_64x64_neon, 10),
1922 make_tuple(64, 32, &aom_highbd_sad_skip_64x32_neon, 10),
1923 make_tuple(32, 64, &aom_highbd_sad_skip_32x64_neon, 10),
1924 make_tuple(32, 32, &aom_highbd_sad_skip_32x32_neon, 10),
1925 make_tuple(32, 16, &aom_highbd_sad_skip_32x16_neon, 10),
1926 make_tuple(16, 32, &aom_highbd_sad_skip_16x32_neon, 10),
1927 make_tuple(16, 16, &aom_highbd_sad_skip_16x16_neon, 10),
1928 make_tuple(16, 8, &aom_highbd_sad_skip_16x8_neon, 10),
1929 make_tuple(8, 16, &aom_highbd_sad_skip_8x16_neon, 10),
1930 make_tuple(8, 8, &aom_highbd_sad_skip_8x8_neon, 10),
1931 make_tuple(8, 4, &aom_highbd_sad_skip_8x4_neon, 10),
1932 make_tuple(4, 8, &aom_highbd_sad_skip_4x8_neon, 10),
1933 make_tuple(4, 4, &aom_highbd_sad_skip_4x4_neon, 10),
1934 make_tuple(128, 128, &aom_highbd_sad_skip_128x128_neon, 12),
1935 make_tuple(128, 64, &aom_highbd_sad_skip_128x64_neon, 12),
1936 make_tuple(64, 128, &aom_highbd_sad_skip_64x128_neon, 12),
1937 make_tuple(64, 64, &aom_highbd_sad_skip_64x64_neon, 12),
1938 make_tuple(64, 32, &aom_highbd_sad_skip_64x32_neon, 12),
1939 make_tuple(32, 64, &aom_highbd_sad_skip_32x64_neon, 12),
1940 make_tuple(32, 32, &aom_highbd_sad_skip_32x32_neon, 12),
1941 make_tuple(32, 16, &aom_highbd_sad_skip_32x16_neon, 12),
1942 make_tuple(16, 32, &aom_highbd_sad_skip_16x32_neon, 12),
1943 make_tuple(16, 16, &aom_highbd_sad_skip_16x16_neon, 12),
1944 make_tuple(16, 8, &aom_highbd_sad_skip_16x8_neon, 12),
1945 make_tuple(8, 16, &aom_highbd_sad_skip_8x16_neon, 12),
1946 make_tuple(8, 8, &aom_highbd_sad_skip_8x8_neon, 12),
1947 make_tuple(8, 4, &aom_highbd_sad_skip_8x4_neon, 12),
1948 make_tuple(4, 8, &aom_highbd_sad_skip_4x8_neon, 12),
1949 make_tuple(4, 4, &aom_highbd_sad_skip_4x4_neon, 12),
1950 #endif // CONFIG_AV1_HIGHBITDEPTH
1951 #if !CONFIG_REALTIME_ONLY
1952 make_tuple(64, 16, &aom_sad_skip_64x16_neon, -1),
1953 make_tuple(32, 8, &aom_sad_skip_32x8_neon, -1),
1954 make_tuple(16, 64, &aom_sad_skip_16x64_neon, -1),
1955 make_tuple(16, 4, &aom_sad_skip_16x4_neon, -1),
1956 make_tuple(8, 32, &aom_sad_skip_8x32_neon, -1),
1957 make_tuple(4, 16, &aom_sad_skip_4x16_neon, -1),
1958 #if CONFIG_AV1_HIGHBITDEPTH
1959 make_tuple(64, 16, &aom_highbd_sad_skip_64x16_neon, 8),
1960 make_tuple(16, 64, &aom_highbd_sad_skip_16x64_neon, 8),
1961 make_tuple(32, 8, &aom_highbd_sad_skip_32x8_neon, 8),
1962 make_tuple(8, 32, &aom_highbd_sad_skip_8x32_neon, 8),
1963 make_tuple(16, 4, &aom_highbd_sad_skip_16x4_neon, 8),
1964 make_tuple(4, 16, &aom_highbd_sad_skip_4x16_neon, 8),
1965 make_tuple(64, 16, &aom_highbd_sad_skip_64x16_neon, 10),
1966 make_tuple(16, 64, &aom_highbd_sad_skip_16x64_neon, 10),
1967 make_tuple(32, 8, &aom_highbd_sad_skip_32x8_neon, 10),
1968 make_tuple(8, 32, &aom_highbd_sad_skip_8x32_neon, 10),
1969 make_tuple(16, 4, &aom_highbd_sad_skip_16x4_neon, 10),
1970 make_tuple(4, 16, &aom_highbd_sad_skip_4x16_neon, 10),
1971 make_tuple(64, 16, &aom_highbd_sad_skip_64x16_neon, 12),
1972 make_tuple(16, 64, &aom_highbd_sad_skip_16x64_neon, 12),
1973 make_tuple(32, 8, &aom_highbd_sad_skip_32x8_neon, 12),
1974 make_tuple(8, 32, &aom_highbd_sad_skip_8x32_neon, 12),
1975 make_tuple(16, 4, &aom_highbd_sad_skip_16x4_neon, 12),
1976 make_tuple(4, 16, &aom_highbd_sad_skip_4x16_neon, 12),
1977 #endif // CONFIG_AV1_HIGHBITDEPTH
1978 #endif // !CONFIG_REALTIME_ONLY
1979 };
1980 INSTANTIATE_TEST_SUITE_P(NEON, SADSkipTest,
1981 ::testing::ValuesIn(skip_neon_tests));
1982
1983 const SadSkipMxNx4Param skip_x4d_neon_tests[] = {
1984 make_tuple(128, 128, &aom_sad_skip_128x128x4d_neon, -1),
1985 make_tuple(128, 64, &aom_sad_skip_128x64x4d_neon, -1),
1986 make_tuple(64, 128, &aom_sad_skip_64x128x4d_neon, -1),
1987 make_tuple(64, 64, &aom_sad_skip_64x64x4d_neon, -1),
1988 make_tuple(64, 32, &aom_sad_skip_64x32x4d_neon, -1),
1989 make_tuple(32, 64, &aom_sad_skip_32x64x4d_neon, -1),
1990 make_tuple(32, 32, &aom_sad_skip_32x32x4d_neon, -1),
1991 make_tuple(32, 16, &aom_sad_skip_32x16x4d_neon, -1),
1992 make_tuple(16, 32, &aom_sad_skip_16x32x4d_neon, -1),
1993 make_tuple(16, 16, &aom_sad_skip_16x16x4d_neon, -1),
1994 make_tuple(16, 8, &aom_sad_skip_16x8x4d_neon, -1),
1995 make_tuple(8, 16, &aom_sad_skip_8x16x4d_neon, -1),
1996 make_tuple(8, 8, &aom_sad_skip_8x8x4d_neon, -1),
1997 make_tuple(8, 4, &aom_sad_skip_8x4x4d_neon, -1),
1998 make_tuple(4, 8, &aom_sad_skip_4x8x4d_neon, -1),
1999 make_tuple(4, 4, &aom_sad_skip_4x4x4d_neon, -1),
2000 #if CONFIG_AV1_HIGHBITDEPTH
2001 make_tuple(128, 128, &aom_highbd_sad_skip_128x128x4d_neon, 8),
2002 make_tuple(128, 64, &aom_highbd_sad_skip_128x64x4d_neon, 8),
2003 make_tuple(64, 128, &aom_highbd_sad_skip_64x128x4d_neon, 8),
2004 make_tuple(64, 64, &aom_highbd_sad_skip_64x64x4d_neon, 8),
2005 make_tuple(64, 32, &aom_highbd_sad_skip_64x32x4d_neon, 8),
2006 make_tuple(32, 64, &aom_highbd_sad_skip_32x64x4d_neon, 8),
2007 make_tuple(32, 32, &aom_highbd_sad_skip_32x32x4d_neon, 8),
2008 make_tuple(32, 16, &aom_highbd_sad_skip_32x16x4d_neon, 8),
2009 make_tuple(16, 32, &aom_highbd_sad_skip_16x32x4d_neon, 8),
2010 make_tuple(16, 16, &aom_highbd_sad_skip_16x16x4d_neon, 8),
2011 make_tuple(16, 8, &aom_highbd_sad_skip_16x8x4d_neon, 8),
2012 make_tuple(8, 16, &aom_highbd_sad_skip_8x16x4d_neon, 8),
2013 make_tuple(8, 8, &aom_highbd_sad_skip_8x8x4d_neon, 8),
2014 make_tuple(8, 4, &aom_highbd_sad_skip_8x4x4d_neon, 8),
2015 make_tuple(4, 8, &aom_highbd_sad_skip_4x8x4d_neon, 8),
2016 make_tuple(4, 4, &aom_highbd_sad_skip_4x4x4d_neon, 8),
2017 make_tuple(128, 128, &aom_highbd_sad_skip_128x128x4d_neon, 10),
2018 make_tuple(128, 64, &aom_highbd_sad_skip_128x64x4d_neon, 10),
2019 make_tuple(64, 128, &aom_highbd_sad_skip_64x128x4d_neon, 10),
2020 make_tuple(64, 64, &aom_highbd_sad_skip_64x64x4d_neon, 10),
2021 make_tuple(64, 32, &aom_highbd_sad_skip_64x32x4d_neon, 10),
2022 make_tuple(32, 64, &aom_highbd_sad_skip_32x64x4d_neon, 10),
2023 make_tuple(32, 32, &aom_highbd_sad_skip_32x32x4d_neon, 10),
2024 make_tuple(32, 16, &aom_highbd_sad_skip_32x16x4d_neon, 10),
2025 make_tuple(16, 32, &aom_highbd_sad_skip_16x32x4d_neon, 10),
2026 make_tuple(16, 16, &aom_highbd_sad_skip_16x16x4d_neon, 10),
2027 make_tuple(16, 8, &aom_highbd_sad_skip_16x8x4d_neon, 10),
2028 make_tuple(8, 16, &aom_highbd_sad_skip_8x16x4d_neon, 10),
2029 make_tuple(8, 8, &aom_highbd_sad_skip_8x8x4d_neon, 10),
2030 make_tuple(8, 4, &aom_highbd_sad_skip_8x4x4d_neon, 10),
2031 make_tuple(4, 8, &aom_highbd_sad_skip_4x8x4d_neon, 10),
2032 make_tuple(4, 4, &aom_highbd_sad_skip_4x4x4d_neon, 10),
2033 make_tuple(128, 128, &aom_highbd_sad_skip_128x128x4d_neon, 12),
2034 make_tuple(128, 64, &aom_highbd_sad_skip_128x64x4d_neon, 12),
2035 make_tuple(64, 128, &aom_highbd_sad_skip_64x128x4d_neon, 12),
2036 make_tuple(64, 64, &aom_highbd_sad_skip_64x64x4d_neon, 12),
2037 make_tuple(64, 32, &aom_highbd_sad_skip_64x32x4d_neon, 12),
2038 make_tuple(32, 64, &aom_highbd_sad_skip_32x64x4d_neon, 12),
2039 make_tuple(32, 32, &aom_highbd_sad_skip_32x32x4d_neon, 12),
2040 make_tuple(32, 16, &aom_highbd_sad_skip_32x16x4d_neon, 12),
2041 make_tuple(16, 32, &aom_highbd_sad_skip_16x32x4d_neon, 12),
2042 make_tuple(16, 16, &aom_highbd_sad_skip_16x16x4d_neon, 12),
2043 make_tuple(16, 8, &aom_highbd_sad_skip_16x8x4d_neon, 12),
2044 make_tuple(8, 16, &aom_highbd_sad_skip_8x16x4d_neon, 12),
2045 make_tuple(8, 8, &aom_highbd_sad_skip_8x8x4d_neon, 12),
2046 make_tuple(8, 4, &aom_highbd_sad_skip_8x4x4d_neon, 12),
2047 make_tuple(4, 8, &aom_highbd_sad_skip_4x8x4d_neon, 12),
2048 make_tuple(4, 4, &aom_highbd_sad_skip_4x4x4d_neon, 12),
2049 #endif // CONFIG_AV1_HIGHBITDEPTH
2050 #if !CONFIG_REALTIME_ONLY
2051 make_tuple(64, 16, &aom_sad_skip_64x16x4d_neon, -1),
2052 make_tuple(32, 8, &aom_sad_skip_32x8x4d_neon, -1),
2053 make_tuple(16, 64, &aom_sad_skip_16x64x4d_neon, -1),
2054 make_tuple(16, 4, &aom_sad_skip_16x4x4d_neon, -1),
2055 make_tuple(8, 32, &aom_sad_skip_8x32x4d_neon, -1),
2056 make_tuple(4, 16, &aom_sad_skip_4x16x4d_neon, -1),
2057 #if CONFIG_AV1_HIGHBITDEPTH
2058 make_tuple(64, 16, &aom_highbd_sad_skip_64x16x4d_neon, 8),
2059 make_tuple(16, 64, &aom_highbd_sad_skip_16x64x4d_neon, 8),
2060 make_tuple(32, 8, &aom_highbd_sad_skip_32x8x4d_neon, 8),
2061 make_tuple(8, 32, &aom_highbd_sad_skip_8x32x4d_neon, 8),
2062 make_tuple(16, 4, &aom_highbd_sad_skip_16x4x4d_neon, 8),
2063 make_tuple(4, 16, &aom_highbd_sad_skip_4x16x4d_neon, 8),
2064 make_tuple(64, 16, &aom_highbd_sad_skip_64x16x4d_neon, 10),
2065 make_tuple(16, 64, &aom_highbd_sad_skip_16x64x4d_neon, 10),
2066 make_tuple(32, 8, &aom_highbd_sad_skip_32x8x4d_neon, 10),
2067 make_tuple(8, 32, &aom_highbd_sad_skip_8x32x4d_neon, 10),
2068 make_tuple(16, 4, &aom_highbd_sad_skip_16x4x4d_neon, 10),
2069 make_tuple(4, 16, &aom_highbd_sad_skip_4x16x4d_neon, 10),
2070 make_tuple(64, 16, &aom_highbd_sad_skip_64x16x4d_neon, 12),
2071 make_tuple(16, 64, &aom_highbd_sad_skip_16x64x4d_neon, 12),
2072 make_tuple(32, 8, &aom_highbd_sad_skip_32x8x4d_neon, 12),
2073 make_tuple(8, 32, &aom_highbd_sad_skip_8x32x4d_neon, 12),
2074 make_tuple(16, 4, &aom_highbd_sad_skip_16x4x4d_neon, 12),
2075 make_tuple(4, 16, &aom_highbd_sad_skip_4x16x4d_neon, 12),
2076 #endif // CONFIG_AV1_HIGHBITDEPTH
2077 #endif // !CONFIG_REALTIME_ONLY
2078 };
2079 INSTANTIATE_TEST_SUITE_P(NEON, SADSkipx4Test,
2080 ::testing::ValuesIn(skip_x4d_neon_tests));
2081
2082 const SadMxNAvgParam avg_neon_tests[] = {
2083 make_tuple(128, 128, &aom_sad128x128_avg_neon, -1),
2084 make_tuple(128, 64, &aom_sad128x64_avg_neon, -1),
2085 make_tuple(64, 128, &aom_sad64x128_avg_neon, -1),
2086 make_tuple(64, 64, &aom_sad64x64_avg_neon, -1),
2087 make_tuple(64, 32, &aom_sad64x32_avg_neon, -1),
2088 make_tuple(32, 64, &aom_sad32x64_avg_neon, -1),
2089 make_tuple(32, 32, &aom_sad32x32_avg_neon, -1),
2090 make_tuple(32, 16, &aom_sad32x16_avg_neon, -1),
2091 make_tuple(16, 32, &aom_sad16x32_avg_neon, -1),
2092 make_tuple(16, 16, &aom_sad16x16_avg_neon, -1),
2093 make_tuple(16, 8, &aom_sad16x8_avg_neon, -1),
2094 make_tuple(8, 16, &aom_sad8x16_avg_neon, -1),
2095 make_tuple(8, 8, &aom_sad8x8_avg_neon, -1),
2096 make_tuple(8, 4, &aom_sad8x4_avg_neon, -1),
2097 make_tuple(4, 8, &aom_sad4x8_avg_neon, -1),
2098 make_tuple(4, 4, &aom_sad4x4_avg_neon, -1),
2099 #if CONFIG_AV1_HIGHBITDEPTH
2100 make_tuple(128, 128, &aom_highbd_sad128x128_avg_neon, 8),
2101 make_tuple(128, 64, &aom_highbd_sad128x64_avg_neon, 8),
2102 make_tuple(64, 128, &aom_highbd_sad64x128_avg_neon, 8),
2103 make_tuple(64, 64, &aom_highbd_sad64x64_avg_neon, 8),
2104 make_tuple(64, 32, &aom_highbd_sad64x32_avg_neon, 8),
2105 make_tuple(32, 64, &aom_highbd_sad32x64_avg_neon, 8),
2106 make_tuple(32, 32, &aom_highbd_sad32x32_avg_neon, 8),
2107 make_tuple(32, 16, &aom_highbd_sad32x16_avg_neon, 8),
2108 make_tuple(16, 32, &aom_highbd_sad16x32_avg_neon, 8),
2109 make_tuple(16, 16, &aom_highbd_sad16x16_avg_neon, 8),
2110 make_tuple(16, 8, &aom_highbd_sad16x8_avg_neon, 8),
2111 make_tuple(8, 16, &aom_highbd_sad8x16_avg_neon, 8),
2112 make_tuple(8, 8, &aom_highbd_sad8x8_avg_neon, 8),
2113 make_tuple(8, 4, &aom_highbd_sad8x4_avg_neon, 8),
2114 make_tuple(4, 8, &aom_highbd_sad4x8_avg_neon, 8),
2115 make_tuple(4, 4, &aom_highbd_sad4x4_avg_neon, 8),
2116 make_tuple(128, 128, &aom_highbd_sad128x128_avg_neon, 10),
2117 make_tuple(128, 64, &aom_highbd_sad128x64_avg_neon, 10),
2118 make_tuple(64, 128, &aom_highbd_sad64x128_avg_neon, 10),
2119 make_tuple(64, 64, &aom_highbd_sad64x64_avg_neon, 10),
2120 make_tuple(64, 32, &aom_highbd_sad64x32_avg_neon, 10),
2121 make_tuple(32, 64, &aom_highbd_sad32x64_avg_neon, 10),
2122 make_tuple(32, 32, &aom_highbd_sad32x32_avg_neon, 10),
2123 make_tuple(32, 16, &aom_highbd_sad32x16_avg_neon, 10),
2124 make_tuple(16, 32, &aom_highbd_sad16x32_avg_neon, 10),
2125 make_tuple(16, 16, &aom_highbd_sad16x16_avg_neon, 10),
2126 make_tuple(16, 8, &aom_highbd_sad16x8_avg_neon, 10),
2127 make_tuple(8, 16, &aom_highbd_sad8x16_avg_neon, 10),
2128 make_tuple(8, 8, &aom_highbd_sad8x8_avg_neon, 10),
2129 make_tuple(8, 4, &aom_highbd_sad8x4_avg_neon, 10),
2130 make_tuple(4, 8, &aom_highbd_sad4x8_avg_neon, 10),
2131 make_tuple(4, 4, &aom_highbd_sad4x4_avg_neon, 10),
2132 make_tuple(128, 128, &aom_highbd_sad128x128_avg_neon, 12),
2133 make_tuple(128, 64, &aom_highbd_sad128x64_avg_neon, 12),
2134 make_tuple(64, 128, &aom_highbd_sad64x128_avg_neon, 12),
2135 make_tuple(64, 64, &aom_highbd_sad64x64_avg_neon, 12),
2136 make_tuple(64, 32, &aom_highbd_sad64x32_avg_neon, 12),
2137 make_tuple(32, 64, &aom_highbd_sad32x64_avg_neon, 12),
2138 make_tuple(32, 32, &aom_highbd_sad32x32_avg_neon, 12),
2139 make_tuple(32, 16, &aom_highbd_sad32x16_avg_neon, 12),
2140 make_tuple(16, 32, &aom_highbd_sad16x32_avg_neon, 12),
2141 make_tuple(16, 16, &aom_highbd_sad16x16_avg_neon, 12),
2142 make_tuple(16, 8, &aom_highbd_sad16x8_avg_neon, 12),
2143 make_tuple(8, 16, &aom_highbd_sad8x16_avg_neon, 12),
2144 make_tuple(8, 8, &aom_highbd_sad8x8_avg_neon, 12),
2145 make_tuple(8, 4, &aom_highbd_sad8x4_avg_neon, 12),
2146 make_tuple(4, 8, &aom_highbd_sad4x8_avg_neon, 12),
2147 make_tuple(4, 4, &aom_highbd_sad4x4_avg_neon, 12),
2148 #endif // CONFIG_AV1_HIGHBITDEPTH
2149 #if !CONFIG_REALTIME_ONLY
2150 make_tuple(64, 16, &aom_sad64x16_avg_neon, -1),
2151 make_tuple(32, 8, &aom_sad32x8_avg_neon, -1),
2152 make_tuple(16, 64, &aom_sad16x64_avg_neon, -1),
2153 make_tuple(16, 4, &aom_sad16x4_avg_neon, -1),
2154 make_tuple(8, 32, &aom_sad8x32_avg_neon, -1),
2155 make_tuple(4, 16, &aom_sad4x16_avg_neon, -1),
2156 #if CONFIG_AV1_HIGHBITDEPTH
2157 make_tuple(64, 16, &aom_highbd_sad64x16_avg_neon, 8),
2158 make_tuple(16, 64, &aom_highbd_sad16x64_avg_neon, 8),
2159 make_tuple(32, 8, &aom_highbd_sad32x8_avg_neon, 8),
2160 make_tuple(8, 32, &aom_highbd_sad8x32_avg_neon, 8),
2161 make_tuple(16, 4, &aom_highbd_sad16x4_avg_neon, 8),
2162 make_tuple(4, 16, &aom_highbd_sad4x16_avg_neon, 8),
2163 make_tuple(64, 16, &aom_highbd_sad64x16_avg_neon, 10),
2164 make_tuple(16, 64, &aom_highbd_sad16x64_avg_neon, 10),
2165 make_tuple(32, 8, &aom_highbd_sad32x8_avg_neon, 10),
2166 make_tuple(8, 32, &aom_highbd_sad8x32_avg_neon, 10),
2167 make_tuple(16, 4, &aom_highbd_sad16x4_avg_neon, 10),
2168 make_tuple(4, 16, &aom_highbd_sad4x16_avg_neon, 10),
2169 make_tuple(64, 16, &aom_highbd_sad64x16_avg_neon, 12),
2170 make_tuple(16, 64, &aom_highbd_sad16x64_avg_neon, 12),
2171 make_tuple(32, 8, &aom_highbd_sad32x8_avg_neon, 12),
2172 make_tuple(8, 32, &aom_highbd_sad8x32_avg_neon, 12),
2173 make_tuple(16, 4, &aom_highbd_sad16x4_avg_neon, 12),
2174 make_tuple(4, 16, &aom_highbd_sad4x16_avg_neon, 12),
2175 #endif // CONFIG_AV1_HIGHBITDEPTH
2176 #endif // !CONFIG_REALTIME_ONLY
2177 };
2178 INSTANTIATE_TEST_SUITE_P(NEON, SADavgTest, ::testing::ValuesIn(avg_neon_tests));
2179
2180 const DistWtdSadMxNAvgParam dist_wtd_avg_neon_tests[] = {
2181 make_tuple(128, 128, &aom_dist_wtd_sad128x128_avg_neon, -1),
2182 make_tuple(128, 64, &aom_dist_wtd_sad128x64_avg_neon, -1),
2183 make_tuple(64, 128, &aom_dist_wtd_sad64x128_avg_neon, -1),
2184 make_tuple(64, 64, &aom_dist_wtd_sad64x64_avg_neon, -1),
2185 make_tuple(64, 32, &aom_dist_wtd_sad64x32_avg_neon, -1),
2186 make_tuple(32, 64, &aom_dist_wtd_sad32x64_avg_neon, -1),
2187 make_tuple(32, 32, &aom_dist_wtd_sad32x32_avg_neon, -1),
2188 make_tuple(32, 16, &aom_dist_wtd_sad32x16_avg_neon, -1),
2189 make_tuple(16, 32, &aom_dist_wtd_sad16x32_avg_neon, -1),
2190 make_tuple(16, 16, &aom_dist_wtd_sad16x16_avg_neon, -1),
2191 make_tuple(16, 8, &aom_dist_wtd_sad16x8_avg_neon, -1),
2192 make_tuple(8, 16, &aom_dist_wtd_sad8x16_avg_neon, -1),
2193 make_tuple(8, 8, &aom_dist_wtd_sad8x8_avg_neon, -1),
2194 make_tuple(8, 4, &aom_dist_wtd_sad8x4_avg_neon, -1),
2195 make_tuple(4, 8, &aom_dist_wtd_sad4x8_avg_neon, -1),
2196 make_tuple(4, 4, &aom_dist_wtd_sad4x4_avg_neon, -1),
2197
2198 #if !CONFIG_REALTIME_ONLY
2199 make_tuple(64, 16, &aom_dist_wtd_sad64x16_avg_neon, -1),
2200 make_tuple(16, 64, &aom_dist_wtd_sad16x64_avg_neon, -1),
2201 make_tuple(32, 8, &aom_dist_wtd_sad32x8_avg_neon, -1),
2202 make_tuple(8, 32, &aom_dist_wtd_sad8x32_avg_neon, -1),
2203 make_tuple(16, 4, &aom_dist_wtd_sad16x4_avg_neon, -1),
2204 make_tuple(4, 16, &aom_dist_wtd_sad4x16_avg_neon, -1),
2205 #endif // !CONFIG_REALTIME_ONLY
2206 };
2207
2208 INSTANTIATE_TEST_SUITE_P(NEON, DistWtdSADavgTest,
2209 ::testing::ValuesIn(dist_wtd_avg_neon_tests));
2210
2211 const SadMxNx4Param x3d_neon_tests[] = {
2212 make_tuple(128, 128, &aom_sad128x128x3d_neon, -1),
2213 make_tuple(128, 64, &aom_sad128x64x3d_neon, -1),
2214 make_tuple(64, 128, &aom_sad64x128x3d_neon, -1),
2215 make_tuple(64, 64, &aom_sad64x64x3d_neon, -1),
2216 make_tuple(64, 32, &aom_sad64x32x3d_neon, -1),
2217 make_tuple(32, 64, &aom_sad32x64x3d_neon, -1),
2218 make_tuple(32, 32, &aom_sad32x32x3d_neon, -1),
2219 make_tuple(32, 16, &aom_sad32x16x3d_neon, -1),
2220 make_tuple(16, 32, &aom_sad16x32x3d_neon, -1),
2221 make_tuple(16, 16, &aom_sad16x16x3d_neon, -1),
2222 make_tuple(16, 8, &aom_sad16x8x3d_neon, -1),
2223 make_tuple(8, 16, &aom_sad8x16x3d_neon, -1),
2224 make_tuple(8, 8, &aom_sad8x8x3d_neon, -1),
2225 make_tuple(8, 4, &aom_sad8x4x3d_neon, -1),
2226 make_tuple(4, 8, &aom_sad4x8x3d_neon, -1),
2227 make_tuple(4, 4, &aom_sad4x4x3d_neon, -1),
2228 #if CONFIG_AV1_HIGHBITDEPTH
2229 make_tuple(128, 128, &aom_highbd_sad128x128x3d_neon, 8),
2230 make_tuple(128, 64, &aom_highbd_sad128x64x3d_neon, 8),
2231 make_tuple(64, 128, &aom_highbd_sad64x128x3d_neon, 8),
2232 make_tuple(64, 64, &aom_highbd_sad64x64x3d_neon, 8),
2233 make_tuple(64, 32, &aom_highbd_sad64x32x3d_neon, 8),
2234 make_tuple(32, 64, &aom_highbd_sad32x64x3d_neon, 8),
2235 make_tuple(32, 32, &aom_highbd_sad32x32x3d_neon, 8),
2236 make_tuple(32, 16, &aom_highbd_sad32x16x3d_neon, 8),
2237 make_tuple(16, 32, &aom_highbd_sad16x32x3d_neon, 8),
2238 make_tuple(16, 16, &aom_highbd_sad16x16x3d_neon, 8),
2239 make_tuple(16, 8, &aom_highbd_sad16x8x3d_neon, 8),
2240 make_tuple(8, 16, &aom_highbd_sad8x16x3d_neon, 8),
2241 make_tuple(8, 8, &aom_highbd_sad8x8x3d_neon, 8),
2242 make_tuple(8, 4, &aom_highbd_sad8x4x3d_neon, 8),
2243 make_tuple(4, 8, &aom_highbd_sad4x8x3d_neon, 8),
2244 make_tuple(4, 4, &aom_highbd_sad4x4x3d_neon, 8),
2245 make_tuple(128, 128, &aom_highbd_sad128x128x3d_neon, 10),
2246 make_tuple(128, 64, &aom_highbd_sad128x64x3d_neon, 10),
2247 make_tuple(64, 128, &aom_highbd_sad64x128x3d_neon, 10),
2248 make_tuple(64, 64, &aom_highbd_sad64x64x3d_neon, 10),
2249 make_tuple(64, 32, &aom_highbd_sad64x32x3d_neon, 10),
2250 make_tuple(32, 64, &aom_highbd_sad32x64x3d_neon, 10),
2251 make_tuple(32, 32, &aom_highbd_sad32x32x3d_neon, 10),
2252 make_tuple(32, 16, &aom_highbd_sad32x16x3d_neon, 10),
2253 make_tuple(16, 32, &aom_highbd_sad16x32x3d_neon, 10),
2254 make_tuple(16, 16, &aom_highbd_sad16x16x3d_neon, 10),
2255 make_tuple(16, 8, &aom_highbd_sad16x8x3d_neon, 10),
2256 make_tuple(8, 16, &aom_highbd_sad8x16x3d_neon, 10),
2257 make_tuple(8, 8, &aom_highbd_sad8x8x3d_neon, 10),
2258 make_tuple(8, 4, &aom_highbd_sad8x4x3d_neon, 10),
2259 make_tuple(4, 8, &aom_highbd_sad4x8x3d_neon, 10),
2260 make_tuple(4, 4, &aom_highbd_sad4x4x3d_neon, 10),
2261 make_tuple(128, 128, &aom_highbd_sad128x128x3d_neon, 12),
2262 make_tuple(128, 64, &aom_highbd_sad128x64x3d_neon, 12),
2263 make_tuple(64, 128, &aom_highbd_sad64x128x3d_neon, 12),
2264 make_tuple(64, 64, &aom_highbd_sad64x64x3d_neon, 12),
2265 make_tuple(64, 32, &aom_highbd_sad64x32x3d_neon, 12),
2266 make_tuple(32, 64, &aom_highbd_sad32x64x3d_neon, 12),
2267 make_tuple(32, 32, &aom_highbd_sad32x32x3d_neon, 12),
2268 make_tuple(32, 16, &aom_highbd_sad32x16x3d_neon, 12),
2269 make_tuple(16, 32, &aom_highbd_sad16x32x3d_neon, 12),
2270 make_tuple(16, 16, &aom_highbd_sad16x16x3d_neon, 12),
2271 make_tuple(16, 8, &aom_highbd_sad16x8x3d_neon, 12),
2272 make_tuple(8, 16, &aom_highbd_sad8x16x3d_neon, 12),
2273 make_tuple(8, 8, &aom_highbd_sad8x8x3d_neon, 12),
2274 make_tuple(8, 4, &aom_highbd_sad8x4x3d_neon, 12),
2275 make_tuple(4, 8, &aom_highbd_sad4x8x3d_neon, 12),
2276 make_tuple(4, 4, &aom_highbd_sad4x4x3d_neon, 12),
2277 #endif // CONFIG_AV1_HIGHBITDEPTH
2278 #if !CONFIG_REALTIME_ONLY
2279 make_tuple(64, 16, &aom_sad64x16x3d_neon, -1),
2280 make_tuple(32, 8, &aom_sad32x8x3d_neon, -1),
2281 make_tuple(16, 64, &aom_sad16x64x3d_neon, -1),
2282 make_tuple(16, 4, &aom_sad16x4x3d_neon, -1),
2283 make_tuple(8, 32, &aom_sad8x32x3d_neon, -1),
2284 make_tuple(4, 16, &aom_sad4x16x3d_neon, -1),
2285 #if CONFIG_AV1_HIGHBITDEPTH
2286 make_tuple(64, 16, &aom_highbd_sad64x16x3d_neon, 8),
2287 make_tuple(16, 64, &aom_highbd_sad16x64x3d_neon, 8),
2288 make_tuple(32, 8, &aom_highbd_sad32x8x3d_neon, 8),
2289 make_tuple(8, 32, &aom_highbd_sad8x32x3d_neon, 8),
2290 make_tuple(16, 4, &aom_highbd_sad16x4x3d_neon, 8),
2291 make_tuple(4, 16, &aom_highbd_sad4x16x3d_neon, 8),
2292 make_tuple(64, 16, &aom_highbd_sad64x16x3d_neon, 10),
2293 make_tuple(16, 64, &aom_highbd_sad16x64x3d_neon, 10),
2294 make_tuple(32, 8, &aom_highbd_sad32x8x3d_neon, 10),
2295 make_tuple(8, 32, &aom_highbd_sad8x32x3d_neon, 10),
2296 make_tuple(16, 4, &aom_highbd_sad16x4x3d_neon, 10),
2297 make_tuple(4, 16, &aom_highbd_sad4x16x3d_neon, 10),
2298 make_tuple(64, 16, &aom_highbd_sad64x16x3d_neon, 12),
2299 make_tuple(16, 64, &aom_highbd_sad16x64x3d_neon, 12),
2300 make_tuple(32, 8, &aom_highbd_sad32x8x3d_neon, 12),
2301 make_tuple(8, 32, &aom_highbd_sad8x32x3d_neon, 12),
2302 make_tuple(16, 4, &aom_highbd_sad16x4x3d_neon, 12),
2303 make_tuple(4, 16, &aom_highbd_sad4x16x3d_neon, 12),
2304 #endif // CONFIG_AV1_HIGHBITDEPTH
2305 #endif // !CONFIG_REALTIME_ONLY
2306 };
2307 INSTANTIATE_TEST_SUITE_P(NEON, SADx3Test, ::testing::ValuesIn(x3d_neon_tests));
2308
2309 #endif // HAVE_NEON
2310
2311 #if HAVE_NEON_DOTPROD
2312 const SadMxNParam neon_dotprod_tests[] = {
2313 make_tuple(128, 128, &aom_sad128x128_neon_dotprod, -1),
2314 make_tuple(128, 64, &aom_sad128x64_neon_dotprod, -1),
2315 make_tuple(64, 128, &aom_sad64x128_neon_dotprod, -1),
2316 make_tuple(64, 64, &aom_sad64x64_neon_dotprod, -1),
2317 make_tuple(64, 32, &aom_sad64x32_neon_dotprod, -1),
2318 make_tuple(32, 64, &aom_sad32x64_neon_dotprod, -1),
2319 make_tuple(32, 32, &aom_sad32x32_neon_dotprod, -1),
2320 make_tuple(32, 16, &aom_sad32x16_neon_dotprod, -1),
2321 make_tuple(16, 32, &aom_sad16x32_neon_dotprod, -1),
2322 make_tuple(16, 16, &aom_sad16x16_neon_dotprod, -1),
2323 make_tuple(16, 8, &aom_sad16x8_neon_dotprod, -1),
2324 #if !CONFIG_REALTIME_ONLY
2325 make_tuple(64, 16, &aom_sad64x16_neon_dotprod, -1),
2326 make_tuple(32, 8, &aom_sad32x8_neon_dotprod, -1),
2327 make_tuple(16, 64, &aom_sad16x64_neon_dotprod, -1),
2328 make_tuple(16, 4, &aom_sad16x4_neon_dotprod, -1),
2329 #endif // !CONFIG_REALTIME_ONLY
2330 };
2331 INSTANTIATE_TEST_SUITE_P(NEON_DOTPROD, SADTest,
2332 ::testing::ValuesIn(neon_dotprod_tests));
2333
2334 const SadMxNParam skip_neon_dotprod_tests[] = {
2335 make_tuple(128, 128, &aom_sad_skip_128x128_neon_dotprod, -1),
2336 make_tuple(128, 64, &aom_sad_skip_128x64_neon_dotprod, -1),
2337 make_tuple(64, 128, &aom_sad_skip_64x128_neon_dotprod, -1),
2338 make_tuple(64, 64, &aom_sad_skip_64x64_neon_dotprod, -1),
2339 make_tuple(64, 32, &aom_sad_skip_64x32_neon_dotprod, -1),
2340 make_tuple(32, 64, &aom_sad_skip_32x64_neon_dotprod, -1),
2341 make_tuple(32, 32, &aom_sad_skip_32x32_neon_dotprod, -1),
2342 make_tuple(32, 16, &aom_sad_skip_32x16_neon_dotprod, -1),
2343 make_tuple(16, 32, &aom_sad_skip_16x32_neon_dotprod, -1),
2344 make_tuple(16, 16, &aom_sad_skip_16x16_neon_dotprod, -1),
2345 make_tuple(16, 8, &aom_sad_skip_16x8_neon_dotprod, -1),
2346 #if !CONFIG_REALTIME_ONLY
2347 make_tuple(64, 16, &aom_sad_skip_64x16_neon_dotprod, -1),
2348 make_tuple(32, 8, &aom_sad_skip_32x8_neon_dotprod, -1),
2349 make_tuple(16, 64, &aom_sad_skip_16x64_neon_dotprod, -1),
2350 make_tuple(16, 4, &aom_sad_skip_16x4_neon_dotprod, -1),
2351 #endif // !CONFIG_REALTIME_ONLY
2352 };
2353 INSTANTIATE_TEST_SUITE_P(NEON_DOTPROD, SADSkipTest,
2354 ::testing::ValuesIn(skip_neon_dotprod_tests));
2355
2356 const SadMxNAvgParam avg_neon_dotprod_tests[] = {
2357 make_tuple(128, 128, &aom_sad128x128_avg_neon_dotprod, -1),
2358 make_tuple(128, 64, &aom_sad128x64_avg_neon_dotprod, -1),
2359 make_tuple(64, 128, &aom_sad64x128_avg_neon_dotprod, -1),
2360 make_tuple(64, 64, &aom_sad64x64_avg_neon_dotprod, -1),
2361 make_tuple(64, 32, &aom_sad64x32_avg_neon_dotprod, -1),
2362 make_tuple(32, 64, &aom_sad32x64_avg_neon_dotprod, -1),
2363 make_tuple(32, 32, &aom_sad32x32_avg_neon_dotprod, -1),
2364 make_tuple(32, 16, &aom_sad32x16_avg_neon_dotprod, -1),
2365 make_tuple(16, 32, &aom_sad16x32_avg_neon_dotprod, -1),
2366 make_tuple(16, 16, &aom_sad16x16_avg_neon_dotprod, -1),
2367 make_tuple(16, 8, &aom_sad16x8_avg_neon_dotprod, -1),
2368 #if !CONFIG_REALTIME_ONLY
2369 make_tuple(64, 16, &aom_sad64x16_avg_neon_dotprod, -1),
2370 make_tuple(32, 8, &aom_sad32x8_avg_neon_dotprod, -1),
2371 make_tuple(16, 64, &aom_sad16x64_avg_neon_dotprod, -1),
2372 make_tuple(16, 4, &aom_sad16x4_avg_neon_dotprod, -1),
2373 #endif // !CONFIG_REALTIME_ONLY
2374 };
2375 INSTANTIATE_TEST_SUITE_P(NEON_DOTPROD, SADavgTest,
2376 ::testing::ValuesIn(avg_neon_dotprod_tests));
2377
2378 const DistWtdSadMxNAvgParam dist_wtd_avg_neon_dotprod_tests[] = {
2379 make_tuple(128, 128, &aom_dist_wtd_sad128x128_avg_neon_dotprod, -1),
2380 make_tuple(128, 64, &aom_dist_wtd_sad128x64_avg_neon_dotprod, -1),
2381 make_tuple(64, 128, &aom_dist_wtd_sad64x128_avg_neon_dotprod, -1),
2382 make_tuple(64, 64, &aom_dist_wtd_sad64x64_avg_neon_dotprod, -1),
2383 make_tuple(64, 32, &aom_dist_wtd_sad64x32_avg_neon_dotprod, -1),
2384 make_tuple(32, 64, &aom_dist_wtd_sad32x64_avg_neon_dotprod, -1),
2385 make_tuple(32, 32, &aom_dist_wtd_sad32x32_avg_neon_dotprod, -1),
2386 make_tuple(32, 16, &aom_dist_wtd_sad32x16_avg_neon_dotprod, -1),
2387 make_tuple(16, 32, &aom_dist_wtd_sad16x32_avg_neon_dotprod, -1),
2388 make_tuple(16, 16, &aom_dist_wtd_sad16x16_avg_neon_dotprod, -1),
2389 make_tuple(16, 8, &aom_dist_wtd_sad16x8_avg_neon_dotprod, -1),
2390 #if !CONFIG_REALTIME_ONLY
2391 make_tuple(64, 16, &aom_dist_wtd_sad64x16_avg_neon_dotprod, -1),
2392 make_tuple(16, 64, &aom_dist_wtd_sad16x64_avg_neon_dotprod, -1),
2393 make_tuple(32, 8, &aom_dist_wtd_sad32x8_avg_neon_dotprod, -1),
2394 make_tuple(16, 4, &aom_dist_wtd_sad16x4_avg_neon_dotprod, -1),
2395 #endif // !CONFIG_REALTIME_ONLY
2396 };
2397
2398 INSTANTIATE_TEST_SUITE_P(NEON_DOTPROD, DistWtdSADavgTest,
2399 ::testing::ValuesIn(dist_wtd_avg_neon_dotprod_tests));
2400
2401 const SadMxNx4Param x3d_neon_dotprod_tests[] = {
2402 make_tuple(128, 128, &aom_sad128x128x3d_neon_dotprod, -1),
2403 make_tuple(128, 64, &aom_sad128x64x3d_neon_dotprod, -1),
2404 make_tuple(64, 128, &aom_sad64x128x3d_neon_dotprod, -1),
2405 make_tuple(64, 64, &aom_sad64x64x3d_neon_dotprod, -1),
2406 make_tuple(64, 32, &aom_sad64x32x3d_neon_dotprod, -1),
2407 make_tuple(32, 64, &aom_sad32x64x3d_neon_dotprod, -1),
2408 make_tuple(32, 32, &aom_sad32x32x3d_neon_dotprod, -1),
2409 make_tuple(32, 16, &aom_sad32x16x3d_neon_dotprod, -1),
2410 make_tuple(16, 32, &aom_sad16x32x3d_neon_dotprod, -1),
2411 make_tuple(16, 16, &aom_sad16x16x3d_neon_dotprod, -1),
2412 make_tuple(16, 8, &aom_sad16x8x3d_neon_dotprod, -1),
2413 #if !CONFIG_REALTIME_ONLY
2414 make_tuple(64, 16, &aom_sad64x16x3d_neon_dotprod, -1),
2415 make_tuple(32, 8, &aom_sad32x8x3d_neon_dotprod, -1),
2416 make_tuple(16, 64, &aom_sad16x64x3d_neon_dotprod, -1),
2417 make_tuple(16, 4, &aom_sad16x4x3d_neon_dotprod, -1),
2418 #endif // !CONFIG_REALTIME_ONLY
2419 };
2420 INSTANTIATE_TEST_SUITE_P(NEON_DOTPROD, SADx3Test,
2421 ::testing::ValuesIn(x3d_neon_dotprod_tests));
2422
2423 const SadMxNx4Param x4d_neon_dotprod_tests[] = {
2424 make_tuple(128, 128, &aom_sad128x128x4d_neon_dotprod, -1),
2425 make_tuple(128, 64, &aom_sad128x64x4d_neon_dotprod, -1),
2426 make_tuple(64, 128, &aom_sad64x128x4d_neon_dotprod, -1),
2427 make_tuple(64, 64, &aom_sad64x64x4d_neon_dotprod, -1),
2428 make_tuple(64, 32, &aom_sad64x32x4d_neon_dotprod, -1),
2429 make_tuple(32, 64, &aom_sad32x64x4d_neon_dotprod, -1),
2430 make_tuple(32, 32, &aom_sad32x32x4d_neon_dotprod, -1),
2431 make_tuple(32, 16, &aom_sad32x16x4d_neon_dotprod, -1),
2432 make_tuple(16, 32, &aom_sad16x32x4d_neon_dotprod, -1),
2433 make_tuple(16, 16, &aom_sad16x16x4d_neon_dotprod, -1),
2434 make_tuple(16, 8, &aom_sad16x8x4d_neon_dotprod, -1),
2435 #if !CONFIG_REALTIME_ONLY
2436 make_tuple(64, 16, &aom_sad64x16x4d_neon_dotprod, -1),
2437 make_tuple(32, 8, &aom_sad32x8x4d_neon_dotprod, -1),
2438 make_tuple(16, 64, &aom_sad16x64x4d_neon_dotprod, -1),
2439 make_tuple(16, 4, &aom_sad16x4x4d_neon_dotprod, -1),
2440 #endif // !CONFIG_REALTIME_ONLY
2441 };
2442 INSTANTIATE_TEST_SUITE_P(NEON_DOTPROD, SADx4Test,
2443 ::testing::ValuesIn(x4d_neon_dotprod_tests));
2444
2445 const SadSkipMxNx4Param skip_x4d_neon_dotprod_tests[] = {
2446 make_tuple(128, 128, &aom_sad_skip_128x128x4d_neon_dotprod, -1),
2447 make_tuple(128, 64, &aom_sad_skip_128x64x4d_neon_dotprod, -1),
2448 make_tuple(64, 128, &aom_sad_skip_64x128x4d_neon_dotprod, -1),
2449 make_tuple(64, 64, &aom_sad_skip_64x64x4d_neon_dotprod, -1),
2450 make_tuple(64, 32, &aom_sad_skip_64x32x4d_neon_dotprod, -1),
2451 make_tuple(32, 64, &aom_sad_skip_32x64x4d_neon_dotprod, -1),
2452 make_tuple(32, 32, &aom_sad_skip_32x32x4d_neon_dotprod, -1),
2453 make_tuple(32, 16, &aom_sad_skip_32x16x4d_neon_dotprod, -1),
2454 make_tuple(16, 32, &aom_sad_skip_16x32x4d_neon_dotprod, -1),
2455 make_tuple(16, 16, &aom_sad_skip_16x16x4d_neon_dotprod, -1),
2456 make_tuple(16, 8, &aom_sad_skip_16x8x4d_neon_dotprod, -1),
2457 #if !CONFIG_REALTIME_ONLY
2458 make_tuple(64, 16, &aom_sad_skip_64x16x4d_neon_dotprod, -1),
2459 make_tuple(32, 8, &aom_sad_skip_32x8x4d_neon_dotprod, -1),
2460 make_tuple(16, 64, &aom_sad_skip_16x64x4d_neon_dotprod, -1),
2461 make_tuple(16, 4, &aom_sad_skip_16x4x4d_neon_dotprod, -1),
2462 #endif // !CONFIG_REALTIME_ONLY
2463 };
2464 INSTANTIATE_TEST_SUITE_P(NEON_DOTPROD, SADSkipx4Test,
2465 ::testing::ValuesIn(skip_x4d_neon_dotprod_tests));
2466 #endif // HAVE_NEON_DOTPROD
2467
2468 //------------------------------------------------------------------------------
2469 // x86 functions
2470 #if HAVE_SSE2
2471 const SadMxNParam sse2_tests[] = {
2472 make_tuple(128, 128, &aom_sad128x128_sse2, -1),
2473 make_tuple(128, 64, &aom_sad128x64_sse2, -1),
2474 make_tuple(64, 128, &aom_sad64x128_sse2, -1),
2475 make_tuple(64, 64, &aom_sad64x64_sse2, -1),
2476 make_tuple(64, 32, &aom_sad64x32_sse2, -1),
2477 make_tuple(32, 64, &aom_sad32x64_sse2, -1),
2478 make_tuple(32, 32, &aom_sad32x32_sse2, -1),
2479 make_tuple(32, 16, &aom_sad32x16_sse2, -1),
2480 make_tuple(16, 32, &aom_sad16x32_sse2, -1),
2481 make_tuple(16, 16, &aom_sad16x16_sse2, -1),
2482 make_tuple(16, 8, &aom_sad16x8_sse2, -1),
2483 make_tuple(8, 16, &aom_sad8x16_sse2, -1),
2484 make_tuple(8, 8, &aom_sad8x8_sse2, -1),
2485 make_tuple(8, 4, &aom_sad8x4_sse2, -1),
2486 make_tuple(4, 8, &aom_sad4x8_sse2, -1),
2487 make_tuple(4, 4, &aom_sad4x4_sse2, -1),
2488 #if CONFIG_AV1_HIGHBITDEPTH
2489 make_tuple(64, 64, &aom_highbd_sad64x64_sse2, 8),
2490 make_tuple(64, 32, &aom_highbd_sad64x32_sse2, 8),
2491 make_tuple(32, 64, &aom_highbd_sad32x64_sse2, 8),
2492 make_tuple(32, 32, &aom_highbd_sad32x32_sse2, 8),
2493 make_tuple(32, 16, &aom_highbd_sad32x16_sse2, 8),
2494 make_tuple(16, 32, &aom_highbd_sad16x32_sse2, 8),
2495 make_tuple(16, 16, &aom_highbd_sad16x16_sse2, 8),
2496 make_tuple(16, 8, &aom_highbd_sad16x8_sse2, 8),
2497 make_tuple(8, 16, &aom_highbd_sad8x16_sse2, 8),
2498 make_tuple(8, 8, &aom_highbd_sad8x8_sse2, 8),
2499 make_tuple(8, 4, &aom_highbd_sad8x4_sse2, 8),
2500 make_tuple(4, 8, &aom_highbd_sad4x8_sse2, 8),
2501 make_tuple(4, 4, &aom_highbd_sad4x4_sse2, 8),
2502 make_tuple(64, 64, &aom_highbd_sad64x64_sse2, 10),
2503 make_tuple(64, 32, &aom_highbd_sad64x32_sse2, 10),
2504 make_tuple(32, 64, &aom_highbd_sad32x64_sse2, 10),
2505 make_tuple(32, 32, &aom_highbd_sad32x32_sse2, 10),
2506 make_tuple(32, 16, &aom_highbd_sad32x16_sse2, 10),
2507 make_tuple(16, 32, &aom_highbd_sad16x32_sse2, 10),
2508 make_tuple(16, 16, &aom_highbd_sad16x16_sse2, 10),
2509 make_tuple(16, 8, &aom_highbd_sad16x8_sse2, 10),
2510 make_tuple(8, 16, &aom_highbd_sad8x16_sse2, 10),
2511 make_tuple(8, 8, &aom_highbd_sad8x8_sse2, 10),
2512 make_tuple(8, 4, &aom_highbd_sad8x4_sse2, 10),
2513 make_tuple(4, 8, &aom_highbd_sad4x8_sse2, 10),
2514 make_tuple(4, 4, &aom_highbd_sad4x4_sse2, 10),
2515 make_tuple(64, 64, &aom_highbd_sad64x64_sse2, 12),
2516 make_tuple(64, 32, &aom_highbd_sad64x32_sse2, 12),
2517 make_tuple(32, 64, &aom_highbd_sad32x64_sse2, 12),
2518 make_tuple(32, 32, &aom_highbd_sad32x32_sse2, 12),
2519 make_tuple(32, 16, &aom_highbd_sad32x16_sse2, 12),
2520 make_tuple(16, 32, &aom_highbd_sad16x32_sse2, 12),
2521 make_tuple(16, 16, &aom_highbd_sad16x16_sse2, 12),
2522 make_tuple(16, 8, &aom_highbd_sad16x8_sse2, 12),
2523 make_tuple(8, 16, &aom_highbd_sad8x16_sse2, 12),
2524 make_tuple(8, 8, &aom_highbd_sad8x8_sse2, 12),
2525 make_tuple(8, 4, &aom_highbd_sad8x4_sse2, 12),
2526 make_tuple(4, 8, &aom_highbd_sad4x8_sse2, 12),
2527 make_tuple(4, 4, &aom_highbd_sad4x4_sse2, 12),
2528 #endif
2529 #if !CONFIG_REALTIME_ONLY
2530 make_tuple(64, 16, &aom_sad64x16_sse2, -1),
2531 make_tuple(16, 64, &aom_sad16x64_sse2, -1),
2532 #if CONFIG_AV1_HIGHBITDEPTH
2533 make_tuple(64, 16, &aom_highbd_sad64x16_sse2, 8),
2534 make_tuple(16, 64, &aom_highbd_sad16x64_sse2, 8),
2535 make_tuple(64, 16, &aom_highbd_sad64x16_sse2, 10),
2536 make_tuple(16, 64, &aom_highbd_sad16x64_sse2, 10),
2537 make_tuple(64, 16, &aom_highbd_sad64x16_sse2, 12),
2538 make_tuple(16, 64, &aom_highbd_sad16x64_sse2, 12),
2539 #endif
2540 make_tuple(32, 8, &aom_sad32x8_sse2, -1),
2541 make_tuple(8, 32, &aom_sad8x32_sse2, -1),
2542 #if CONFIG_AV1_HIGHBITDEPTH
2543 make_tuple(32, 8, &aom_highbd_sad32x8_sse2, 8),
2544 make_tuple(8, 32, &aom_highbd_sad8x32_sse2, 8),
2545 make_tuple(32, 8, &aom_highbd_sad32x8_sse2, 10),
2546 make_tuple(8, 32, &aom_highbd_sad8x32_sse2, 10),
2547 make_tuple(32, 8, &aom_highbd_sad32x8_sse2, 12),
2548 make_tuple(8, 32, &aom_highbd_sad8x32_sse2, 12),
2549 #endif
2550 make_tuple(16, 4, &aom_sad16x4_sse2, -1),
2551 make_tuple(4, 16, &aom_sad4x16_sse2, -1),
2552 #if CONFIG_AV1_HIGHBITDEPTH
2553 make_tuple(16, 4, &aom_highbd_sad16x4_sse2, 8),
2554 make_tuple(4, 16, &aom_highbd_sad4x16_sse2, 8),
2555 make_tuple(16, 4, &aom_highbd_sad16x4_sse2, 10),
2556 make_tuple(4, 16, &aom_highbd_sad4x16_sse2, 10),
2557 make_tuple(16, 4, &aom_highbd_sad16x4_sse2, 12),
2558 make_tuple(4, 16, &aom_highbd_sad4x16_sse2, 12),
2559 #endif
2560 #endif // !CONFIG_REALTIME_ONLY
2561 };
2562 INSTANTIATE_TEST_SUITE_P(SSE2, SADTest, ::testing::ValuesIn(sse2_tests));
2563
2564 const SadSkipMxNParam skip_sse2_tests[] = {
2565 make_tuple(128, 128, &aom_sad_skip_128x128_sse2, -1),
2566 make_tuple(128, 64, &aom_sad_skip_128x64_sse2, -1),
2567 make_tuple(64, 128, &aom_sad_skip_64x128_sse2, -1),
2568 make_tuple(64, 64, &aom_sad_skip_64x64_sse2, -1),
2569 make_tuple(64, 32, &aom_sad_skip_64x32_sse2, -1),
2570 make_tuple(32, 64, &aom_sad_skip_32x64_sse2, -1),
2571 make_tuple(32, 32, &aom_sad_skip_32x32_sse2, -1),
2572 make_tuple(32, 16, &aom_sad_skip_32x16_sse2, -1),
2573 make_tuple(16, 32, &aom_sad_skip_16x32_sse2, -1),
2574 make_tuple(16, 16, &aom_sad_skip_16x16_sse2, -1),
2575 make_tuple(16, 8, &aom_sad_skip_16x8_sse2, -1),
2576 make_tuple(8, 16, &aom_sad_skip_8x16_sse2, -1),
2577 make_tuple(8, 8, &aom_sad_skip_8x8_sse2, -1),
2578 make_tuple(4, 8, &aom_sad_skip_4x8_sse2, -1),
2579 #if !CONFIG_REALTIME_ONLY
2580 make_tuple(64, 16, &aom_sad_skip_64x16_sse2, -1),
2581 make_tuple(16, 64, &aom_sad_skip_16x64_sse2, -1),
2582 make_tuple(32, 8, &aom_sad_skip_32x8_sse2, -1),
2583 make_tuple(8, 32, &aom_sad_skip_8x32_sse2, -1),
2584 make_tuple(4, 16, &aom_sad_skip_4x16_sse2, -1),
2585 #endif
2586 #if CONFIG_AV1_HIGHBITDEPTH
2587 make_tuple(64, 64, &aom_highbd_sad_skip_64x64_sse2, 8),
2588 make_tuple(64, 32, &aom_highbd_sad_skip_64x32_sse2, 8),
2589 make_tuple(32, 64, &aom_highbd_sad_skip_32x64_sse2, 8),
2590 make_tuple(32, 32, &aom_highbd_sad_skip_32x32_sse2, 8),
2591 make_tuple(32, 16, &aom_highbd_sad_skip_32x16_sse2, 8),
2592 make_tuple(16, 32, &aom_highbd_sad_skip_16x32_sse2, 8),
2593 make_tuple(16, 16, &aom_highbd_sad_skip_16x16_sse2, 8),
2594 make_tuple(16, 8, &aom_highbd_sad_skip_16x8_sse2, 8),
2595 make_tuple(8, 16, &aom_highbd_sad_skip_8x16_sse2, 8),
2596 make_tuple(8, 8, &aom_highbd_sad_skip_8x8_sse2, 8),
2597 make_tuple(4, 8, &aom_highbd_sad_skip_4x8_sse2, 8),
2598 #if !CONFIG_REALTIME_ONLY
2599 make_tuple(64, 16, &aom_highbd_sad_skip_64x16_sse2, 8),
2600 make_tuple(16, 64, &aom_highbd_sad_skip_16x64_sse2, 8),
2601 make_tuple(32, 8, &aom_highbd_sad_skip_32x8_sse2, 8),
2602 make_tuple(8, 32, &aom_highbd_sad_skip_8x32_sse2, 8),
2603 make_tuple(4, 16, &aom_highbd_sad_skip_4x16_sse2, 8),
2604 #endif
2605
2606 make_tuple(64, 64, &aom_highbd_sad_skip_64x64_sse2, 10),
2607 make_tuple(64, 32, &aom_highbd_sad_skip_64x32_sse2, 10),
2608 make_tuple(32, 64, &aom_highbd_sad_skip_32x64_sse2, 10),
2609 make_tuple(32, 32, &aom_highbd_sad_skip_32x32_sse2, 10),
2610 make_tuple(32, 16, &aom_highbd_sad_skip_32x16_sse2, 10),
2611 make_tuple(16, 32, &aom_highbd_sad_skip_16x32_sse2, 10),
2612 make_tuple(16, 16, &aom_highbd_sad_skip_16x16_sse2, 10),
2613 make_tuple(16, 8, &aom_highbd_sad_skip_16x8_sse2, 10),
2614 make_tuple(8, 16, &aom_highbd_sad_skip_8x16_sse2, 10),
2615 make_tuple(8, 8, &aom_highbd_sad_skip_8x8_sse2, 10),
2616 make_tuple(4, 8, &aom_highbd_sad_skip_4x8_sse2, 10),
2617 #if !CONFIG_REALTIME_ONLY
2618 make_tuple(64, 16, &aom_highbd_sad_skip_64x16_sse2, 10),
2619 make_tuple(16, 64, &aom_highbd_sad_skip_16x64_sse2, 10),
2620 make_tuple(32, 8, &aom_highbd_sad_skip_32x8_sse2, 10),
2621 make_tuple(8, 32, &aom_highbd_sad_skip_8x32_sse2, 10),
2622 make_tuple(4, 16, &aom_highbd_sad_skip_4x16_sse2, 10),
2623 #endif
2624
2625 make_tuple(64, 64, &aom_highbd_sad_skip_64x64_sse2, 12),
2626 make_tuple(64, 32, &aom_highbd_sad_skip_64x32_sse2, 12),
2627 make_tuple(32, 64, &aom_highbd_sad_skip_32x64_sse2, 12),
2628 make_tuple(32, 32, &aom_highbd_sad_skip_32x32_sse2, 12),
2629 make_tuple(32, 16, &aom_highbd_sad_skip_32x16_sse2, 12),
2630 make_tuple(16, 32, &aom_highbd_sad_skip_16x32_sse2, 12),
2631 make_tuple(16, 16, &aom_highbd_sad_skip_16x16_sse2, 12),
2632 make_tuple(16, 8, &aom_highbd_sad_skip_16x8_sse2, 12),
2633 make_tuple(8, 16, &aom_highbd_sad_skip_8x16_sse2, 12),
2634 make_tuple(8, 8, &aom_highbd_sad_skip_8x8_sse2, 12),
2635 make_tuple(4, 8, &aom_highbd_sad_skip_4x8_sse2, 12),
2636 #if !CONFIG_REALTIME_ONLY
2637 make_tuple(64, 16, &aom_highbd_sad_skip_64x16_sse2, 12),
2638 make_tuple(16, 64, &aom_highbd_sad_skip_16x64_sse2, 12),
2639 make_tuple(32, 8, &aom_highbd_sad_skip_32x8_sse2, 12),
2640 make_tuple(8, 32, &aom_highbd_sad_skip_8x32_sse2, 12),
2641 make_tuple(4, 16, &aom_highbd_sad_skip_4x16_sse2, 12),
2642 #endif
2643 #endif // CONFIG_AV1_HIGHBITDEPTH
2644 };
2645 INSTANTIATE_TEST_SUITE_P(SSE2, SADSkipTest,
2646 ::testing::ValuesIn(skip_sse2_tests));
2647
2648 const SadMxNAvgParam avg_sse2_tests[] = {
2649 make_tuple(128, 128, &aom_sad128x128_avg_sse2, -1),
2650 make_tuple(128, 64, &aom_sad128x64_avg_sse2, -1),
2651 make_tuple(64, 128, &aom_sad64x128_avg_sse2, -1),
2652 make_tuple(64, 64, &aom_sad64x64_avg_sse2, -1),
2653 make_tuple(64, 32, &aom_sad64x32_avg_sse2, -1),
2654 make_tuple(32, 64, &aom_sad32x64_avg_sse2, -1),
2655 make_tuple(32, 32, &aom_sad32x32_avg_sse2, -1),
2656 make_tuple(32, 16, &aom_sad32x16_avg_sse2, -1),
2657 make_tuple(16, 32, &aom_sad16x32_avg_sse2, -1),
2658 make_tuple(16, 16, &aom_sad16x16_avg_sse2, -1),
2659 make_tuple(16, 8, &aom_sad16x8_avg_sse2, -1),
2660 make_tuple(8, 16, &aom_sad8x16_avg_sse2, -1),
2661 make_tuple(8, 8, &aom_sad8x8_avg_sse2, -1),
2662 make_tuple(8, 4, &aom_sad8x4_avg_sse2, -1),
2663 make_tuple(4, 8, &aom_sad4x8_avg_sse2, -1),
2664 make_tuple(4, 4, &aom_sad4x4_avg_sse2, -1),
2665 #if CONFIG_AV1_HIGHBITDEPTH
2666 make_tuple(64, 64, &aom_highbd_sad64x64_avg_sse2, 8),
2667 make_tuple(64, 32, &aom_highbd_sad64x32_avg_sse2, 8),
2668 make_tuple(32, 64, &aom_highbd_sad32x64_avg_sse2, 8),
2669 make_tuple(32, 32, &aom_highbd_sad32x32_avg_sse2, 8),
2670 make_tuple(32, 16, &aom_highbd_sad32x16_avg_sse2, 8),
2671 make_tuple(16, 32, &aom_highbd_sad16x32_avg_sse2, 8),
2672 make_tuple(16, 16, &aom_highbd_sad16x16_avg_sse2, 8),
2673 make_tuple(16, 8, &aom_highbd_sad16x8_avg_sse2, 8),
2674 make_tuple(8, 16, &aom_highbd_sad8x16_avg_sse2, 8),
2675 make_tuple(8, 8, &aom_highbd_sad8x8_avg_sse2, 8),
2676 make_tuple(8, 4, &aom_highbd_sad8x4_avg_sse2, 8),
2677 make_tuple(4, 8, &aom_highbd_sad4x8_avg_sse2, 8),
2678 make_tuple(4, 4, &aom_highbd_sad4x4_avg_sse2, 8),
2679 make_tuple(64, 64, &aom_highbd_sad64x64_avg_sse2, 10),
2680 make_tuple(64, 32, &aom_highbd_sad64x32_avg_sse2, 10),
2681 make_tuple(32, 64, &aom_highbd_sad32x64_avg_sse2, 10),
2682 make_tuple(32, 32, &aom_highbd_sad32x32_avg_sse2, 10),
2683 make_tuple(32, 16, &aom_highbd_sad32x16_avg_sse2, 10),
2684 make_tuple(16, 32, &aom_highbd_sad16x32_avg_sse2, 10),
2685 make_tuple(16, 16, &aom_highbd_sad16x16_avg_sse2, 10),
2686 make_tuple(16, 8, &aom_highbd_sad16x8_avg_sse2, 10),
2687 make_tuple(8, 16, &aom_highbd_sad8x16_avg_sse2, 10),
2688 make_tuple(8, 8, &aom_highbd_sad8x8_avg_sse2, 10),
2689 make_tuple(8, 4, &aom_highbd_sad8x4_avg_sse2, 10),
2690 make_tuple(4, 8, &aom_highbd_sad4x8_avg_sse2, 10),
2691 make_tuple(4, 4, &aom_highbd_sad4x4_avg_sse2, 10),
2692 make_tuple(64, 64, &aom_highbd_sad64x64_avg_sse2, 12),
2693 make_tuple(64, 32, &aom_highbd_sad64x32_avg_sse2, 12),
2694 make_tuple(32, 64, &aom_highbd_sad32x64_avg_sse2, 12),
2695 make_tuple(32, 32, &aom_highbd_sad32x32_avg_sse2, 12),
2696 make_tuple(32, 16, &aom_highbd_sad32x16_avg_sse2, 12),
2697 make_tuple(16, 32, &aom_highbd_sad16x32_avg_sse2, 12),
2698 make_tuple(16, 16, &aom_highbd_sad16x16_avg_sse2, 12),
2699 make_tuple(16, 8, &aom_highbd_sad16x8_avg_sse2, 12),
2700 make_tuple(8, 16, &aom_highbd_sad8x16_avg_sse2, 12),
2701 make_tuple(8, 8, &aom_highbd_sad8x8_avg_sse2, 12),
2702 make_tuple(8, 4, &aom_highbd_sad8x4_avg_sse2, 12),
2703 make_tuple(4, 8, &aom_highbd_sad4x8_avg_sse2, 12),
2704 make_tuple(4, 4, &aom_highbd_sad4x4_avg_sse2, 12),
2705 #endif
2706 #if !CONFIG_REALTIME_ONLY
2707 make_tuple(64, 16, &aom_sad64x16_avg_sse2, -1),
2708 make_tuple(16, 64, &aom_sad16x64_avg_sse2, -1),
2709 #if CONFIG_AV1_HIGHBITDEPTH
2710 make_tuple(64, 16, &aom_highbd_sad64x16_avg_sse2, 8),
2711 make_tuple(16, 64, &aom_highbd_sad16x64_avg_sse2, 8),
2712 make_tuple(64, 16, &aom_highbd_sad64x16_avg_sse2, 10),
2713 make_tuple(16, 64, &aom_highbd_sad16x64_avg_sse2, 10),
2714 make_tuple(64, 16, &aom_highbd_sad64x16_avg_sse2, 12),
2715 make_tuple(16, 64, &aom_highbd_sad16x64_avg_sse2, 12),
2716 #endif
2717 make_tuple(32, 8, &aom_sad32x8_avg_sse2, -1),
2718 make_tuple(8, 32, &aom_sad8x32_avg_sse2, -1),
2719 #if CONFIG_AV1_HIGHBITDEPTH
2720 make_tuple(32, 8, &aom_highbd_sad32x8_avg_sse2, 8),
2721 make_tuple(8, 32, &aom_highbd_sad8x32_avg_sse2, 8),
2722 make_tuple(32, 8, &aom_highbd_sad32x8_avg_sse2, 10),
2723 make_tuple(8, 32, &aom_highbd_sad8x32_avg_sse2, 10),
2724 make_tuple(32, 8, &aom_highbd_sad32x8_avg_sse2, 12),
2725 make_tuple(8, 32, &aom_highbd_sad8x32_avg_sse2, 12),
2726 #endif
2727 make_tuple(16, 4, &aom_sad16x4_avg_sse2, -1),
2728 make_tuple(4, 16, &aom_sad4x16_avg_sse2, -1),
2729 #if CONFIG_AV1_HIGHBITDEPTH
2730 make_tuple(16, 4, &aom_highbd_sad16x4_avg_sse2, 8),
2731 make_tuple(4, 16, &aom_highbd_sad4x16_avg_sse2, 8),
2732 make_tuple(16, 4, &aom_highbd_sad16x4_avg_sse2, 10),
2733 make_tuple(4, 16, &aom_highbd_sad4x16_avg_sse2, 10),
2734 make_tuple(16, 4, &aom_highbd_sad16x4_avg_sse2, 12),
2735 make_tuple(4, 16, &aom_highbd_sad4x16_avg_sse2, 12),
2736 #endif
2737 #endif // !CONFIG_REALTIME_ONLY
2738 };
2739 INSTANTIATE_TEST_SUITE_P(SSE2, SADavgTest, ::testing::ValuesIn(avg_sse2_tests));
2740
2741 const SadMxNx4Param x4d_sse2_tests[] = {
2742 make_tuple(128, 128, &aom_sad128x128x4d_sse2, -1),
2743 make_tuple(128, 64, &aom_sad128x64x4d_sse2, -1),
2744 make_tuple(64, 128, &aom_sad64x128x4d_sse2, -1),
2745 make_tuple(64, 64, &aom_sad64x64x4d_sse2, -1),
2746 make_tuple(64, 32, &aom_sad64x32x4d_sse2, -1),
2747 make_tuple(32, 64, &aom_sad32x64x4d_sse2, -1),
2748 make_tuple(32, 32, &aom_sad32x32x4d_sse2, -1),
2749 make_tuple(32, 16, &aom_sad32x16x4d_sse2, -1),
2750 make_tuple(16, 32, &aom_sad16x32x4d_sse2, -1),
2751 make_tuple(16, 16, &aom_sad16x16x4d_sse2, -1),
2752 make_tuple(16, 8, &aom_sad16x8x4d_sse2, -1),
2753 make_tuple(8, 16, &aom_sad8x16x4d_sse2, -1),
2754 make_tuple(8, 8, &aom_sad8x8x4d_sse2, -1),
2755 make_tuple(8, 4, &aom_sad8x4x4d_sse2, -1),
2756 make_tuple(4, 8, &aom_sad4x8x4d_sse2, -1),
2757 make_tuple(4, 4, &aom_sad4x4x4d_sse2, -1),
2758 #if CONFIG_AV1_HIGHBITDEPTH
2759 make_tuple(64, 64, &aom_highbd_sad64x64x4d_sse2, 8),
2760 make_tuple(64, 32, &aom_highbd_sad64x32x4d_sse2, 8),
2761 make_tuple(32, 64, &aom_highbd_sad32x64x4d_sse2, 8),
2762 make_tuple(32, 32, &aom_highbd_sad32x32x4d_sse2, 8),
2763 make_tuple(32, 16, &aom_highbd_sad32x16x4d_sse2, 8),
2764 make_tuple(16, 32, &aom_highbd_sad16x32x4d_sse2, 8),
2765 make_tuple(16, 16, &aom_highbd_sad16x16x4d_sse2, 8),
2766 make_tuple(16, 8, &aom_highbd_sad16x8x4d_sse2, 8),
2767 make_tuple(8, 16, &aom_highbd_sad8x16x4d_sse2, 8),
2768 make_tuple(8, 8, &aom_highbd_sad8x8x4d_sse2, 8),
2769 make_tuple(8, 4, &aom_highbd_sad8x4x4d_sse2, 8),
2770 make_tuple(4, 8, &aom_highbd_sad4x8x4d_sse2, 8),
2771 make_tuple(4, 4, &aom_highbd_sad4x4x4d_sse2, 8),
2772 make_tuple(64, 64, &aom_highbd_sad64x64x4d_sse2, 10),
2773 make_tuple(64, 32, &aom_highbd_sad64x32x4d_sse2, 10),
2774 make_tuple(32, 64, &aom_highbd_sad32x64x4d_sse2, 10),
2775 make_tuple(32, 32, &aom_highbd_sad32x32x4d_sse2, 10),
2776 make_tuple(32, 16, &aom_highbd_sad32x16x4d_sse2, 10),
2777 make_tuple(16, 32, &aom_highbd_sad16x32x4d_sse2, 10),
2778 make_tuple(16, 16, &aom_highbd_sad16x16x4d_sse2, 10),
2779 make_tuple(16, 8, &aom_highbd_sad16x8x4d_sse2, 10),
2780 make_tuple(8, 16, &aom_highbd_sad8x16x4d_sse2, 10),
2781 make_tuple(8, 8, &aom_highbd_sad8x8x4d_sse2, 10),
2782 make_tuple(8, 4, &aom_highbd_sad8x4x4d_sse2, 10),
2783 make_tuple(4, 8, &aom_highbd_sad4x8x4d_sse2, 10),
2784 make_tuple(4, 4, &aom_highbd_sad4x4x4d_sse2, 10),
2785 make_tuple(64, 64, &aom_highbd_sad64x64x4d_sse2, 12),
2786 make_tuple(64, 32, &aom_highbd_sad64x32x4d_sse2, 12),
2787 make_tuple(32, 64, &aom_highbd_sad32x64x4d_sse2, 12),
2788 make_tuple(32, 32, &aom_highbd_sad32x32x4d_sse2, 12),
2789 make_tuple(32, 16, &aom_highbd_sad32x16x4d_sse2, 12),
2790 make_tuple(16, 32, &aom_highbd_sad16x32x4d_sse2, 12),
2791 make_tuple(16, 16, &aom_highbd_sad16x16x4d_sse2, 12),
2792 make_tuple(16, 8, &aom_highbd_sad16x8x4d_sse2, 12),
2793 make_tuple(8, 16, &aom_highbd_sad8x16x4d_sse2, 12),
2794 make_tuple(8, 8, &aom_highbd_sad8x8x4d_sse2, 12),
2795 make_tuple(8, 4, &aom_highbd_sad8x4x4d_sse2, 12),
2796 make_tuple(4, 8, &aom_highbd_sad4x8x4d_sse2, 12),
2797 make_tuple(4, 4, &aom_highbd_sad4x4x4d_sse2, 12),
2798 #endif
2799 #if !CONFIG_REALTIME_ONLY
2800 make_tuple(64, 16, &aom_sad64x16x4d_sse2, -1),
2801 make_tuple(16, 64, &aom_sad16x64x4d_sse2, -1),
2802 #if CONFIG_AV1_HIGHBITDEPTH
2803 make_tuple(64, 16, &aom_highbd_sad64x16x4d_sse2, 8),
2804 make_tuple(16, 64, &aom_highbd_sad16x64x4d_sse2, 8),
2805 make_tuple(64, 16, &aom_highbd_sad64x16x4d_sse2, 10),
2806 make_tuple(16, 64, &aom_highbd_sad16x64x4d_sse2, 10),
2807 make_tuple(64, 16, &aom_highbd_sad64x16x4d_sse2, 12),
2808 make_tuple(16, 64, &aom_highbd_sad16x64x4d_sse2, 12),
2809 #endif
2810 make_tuple(32, 8, &aom_sad32x8x4d_sse2, -1),
2811 make_tuple(8, 32, &aom_sad8x32x4d_sse2, -1),
2812 #if CONFIG_AV1_HIGHBITDEPTH
2813 make_tuple(32, 8, &aom_highbd_sad32x8x4d_sse2, 8),
2814 make_tuple(8, 32, &aom_highbd_sad8x32x4d_sse2, 8),
2815 make_tuple(32, 8, &aom_highbd_sad32x8x4d_sse2, 10),
2816 make_tuple(8, 32, &aom_highbd_sad8x32x4d_sse2, 10),
2817 make_tuple(32, 8, &aom_highbd_sad32x8x4d_sse2, 12),
2818 make_tuple(8, 32, &aom_highbd_sad8x32x4d_sse2, 12),
2819 #endif
2820 make_tuple(16, 4, &aom_sad16x4x4d_sse2, -1),
2821 make_tuple(4, 16, &aom_sad4x16x4d_sse2, -1),
2822 #if CONFIG_AV1_HIGHBITDEPTH
2823 make_tuple(16, 4, &aom_highbd_sad16x4x4d_sse2, 8),
2824 make_tuple(4, 16, &aom_highbd_sad4x16x4d_sse2, 8),
2825 make_tuple(16, 4, &aom_highbd_sad16x4x4d_sse2, 10),
2826 make_tuple(4, 16, &aom_highbd_sad4x16x4d_sse2, 10),
2827 make_tuple(16, 4, &aom_highbd_sad16x4x4d_sse2, 12),
2828 make_tuple(4, 16, &aom_highbd_sad4x16x4d_sse2, 12),
2829 #endif
2830 #endif
2831 };
2832 INSTANTIATE_TEST_SUITE_P(SSE2, SADx4Test, ::testing::ValuesIn(x4d_sse2_tests));
2833
2834 const SadSkipMxNx4Param skip_x4d_sse2_tests[] = {
2835 make_tuple(128, 128, &aom_sad_skip_128x128x4d_sse2, -1),
2836 make_tuple(128, 64, &aom_sad_skip_128x64x4d_sse2, -1),
2837 make_tuple(64, 128, &aom_sad_skip_64x128x4d_sse2, -1),
2838 make_tuple(64, 64, &aom_sad_skip_64x64x4d_sse2, -1),
2839 make_tuple(64, 32, &aom_sad_skip_64x32x4d_sse2, -1),
2840 make_tuple(32, 64, &aom_sad_skip_32x64x4d_sse2, -1),
2841 make_tuple(32, 32, &aom_sad_skip_32x32x4d_sse2, -1),
2842 make_tuple(32, 16, &aom_sad_skip_32x16x4d_sse2, -1),
2843 make_tuple(16, 32, &aom_sad_skip_16x32x4d_sse2, -1),
2844 make_tuple(16, 16, &aom_sad_skip_16x16x4d_sse2, -1),
2845 make_tuple(16, 8, &aom_sad_skip_16x8x4d_sse2, -1),
2846 make_tuple(8, 16, &aom_sad_skip_8x16x4d_sse2, -1),
2847 make_tuple(8, 8, &aom_sad_skip_8x8x4d_sse2, -1),
2848 make_tuple(4, 8, &aom_sad_skip_4x8x4d_sse2, -1),
2849 #if !CONFIG_REALTIME_ONLY
2850 make_tuple(64, 16, &aom_sad_skip_64x16x4d_sse2, -1),
2851 make_tuple(16, 64, &aom_sad_skip_16x64x4d_sse2, -1),
2852 make_tuple(32, 8, &aom_sad_skip_32x8x4d_sse2, -1),
2853 make_tuple(8, 32, &aom_sad_skip_8x32x4d_sse2, -1),
2854 make_tuple(4, 16, &aom_sad_skip_4x16x4d_sse2, -1),
2855 #endif
2856 #if CONFIG_AV1_HIGHBITDEPTH
2857 make_tuple(64, 64, &aom_highbd_sad_skip_64x64x4d_sse2, 8),
2858 make_tuple(64, 32, &aom_highbd_sad_skip_64x32x4d_sse2, 8),
2859 make_tuple(32, 64, &aom_highbd_sad_skip_32x64x4d_sse2, 8),
2860 make_tuple(32, 32, &aom_highbd_sad_skip_32x32x4d_sse2, 8),
2861 make_tuple(32, 16, &aom_highbd_sad_skip_32x16x4d_sse2, 8),
2862 make_tuple(16, 32, &aom_highbd_sad_skip_16x32x4d_sse2, 8),
2863 make_tuple(16, 16, &aom_highbd_sad_skip_16x16x4d_sse2, 8),
2864 make_tuple(16, 8, &aom_highbd_sad_skip_16x8x4d_sse2, 8),
2865 make_tuple(8, 16, &aom_highbd_sad_skip_8x16x4d_sse2, 8),
2866 make_tuple(8, 8, &aom_highbd_sad_skip_8x8x4d_sse2, 8),
2867 make_tuple(4, 8, &aom_highbd_sad_skip_4x8x4d_sse2, 8),
2868 #if !CONFIG_REALTIME_ONLY
2869 make_tuple(64, 16, &aom_highbd_sad_skip_64x16x4d_sse2, 8),
2870 make_tuple(16, 64, &aom_highbd_sad_skip_16x64x4d_sse2, 8),
2871 make_tuple(32, 8, &aom_highbd_sad_skip_32x8x4d_sse2, 8),
2872 make_tuple(8, 32, &aom_highbd_sad_skip_8x32x4d_sse2, 8),
2873 make_tuple(4, 16, &aom_highbd_sad_skip_4x16x4d_sse2, 8),
2874 #endif
2875 make_tuple(64, 64, &aom_highbd_sad_skip_64x64x4d_sse2, 10),
2876 make_tuple(64, 32, &aom_highbd_sad_skip_64x32x4d_sse2, 10),
2877 make_tuple(32, 64, &aom_highbd_sad_skip_32x64x4d_sse2, 10),
2878 make_tuple(32, 32, &aom_highbd_sad_skip_32x32x4d_sse2, 10),
2879 make_tuple(32, 16, &aom_highbd_sad_skip_32x16x4d_sse2, 10),
2880 make_tuple(16, 32, &aom_highbd_sad_skip_16x32x4d_sse2, 10),
2881 make_tuple(16, 16, &aom_highbd_sad_skip_16x16x4d_sse2, 10),
2882 make_tuple(16, 8, &aom_highbd_sad_skip_16x8x4d_sse2, 10),
2883 make_tuple(8, 16, &aom_highbd_sad_skip_8x16x4d_sse2, 10),
2884 make_tuple(8, 8, &aom_highbd_sad_skip_8x8x4d_sse2, 10),
2885 make_tuple(4, 8, &aom_highbd_sad_skip_4x8x4d_sse2, 10),
2886 #if !CONFIG_REALTIME_ONLY
2887 make_tuple(64, 16, &aom_highbd_sad_skip_64x16x4d_sse2, 10),
2888 make_tuple(16, 64, &aom_highbd_sad_skip_16x64x4d_sse2, 10),
2889 make_tuple(32, 8, &aom_highbd_sad_skip_32x8x4d_sse2, 10),
2890 make_tuple(8, 32, &aom_highbd_sad_skip_8x32x4d_sse2, 10),
2891 make_tuple(4, 16, &aom_highbd_sad_skip_4x16x4d_sse2, 10),
2892 #endif
2893 make_tuple(64, 64, &aom_highbd_sad_skip_64x64x4d_sse2, 12),
2894 make_tuple(64, 32, &aom_highbd_sad_skip_64x32x4d_sse2, 12),
2895 make_tuple(32, 64, &aom_highbd_sad_skip_32x64x4d_sse2, 12),
2896 make_tuple(32, 32, &aom_highbd_sad_skip_32x32x4d_sse2, 12),
2897 make_tuple(32, 16, &aom_highbd_sad_skip_32x16x4d_sse2, 12),
2898 make_tuple(16, 32, &aom_highbd_sad_skip_16x32x4d_sse2, 12),
2899 make_tuple(16, 16, &aom_highbd_sad_skip_16x16x4d_sse2, 12),
2900 make_tuple(16, 8, &aom_highbd_sad_skip_16x8x4d_sse2, 12),
2901 make_tuple(8, 16, &aom_highbd_sad_skip_8x16x4d_sse2, 12),
2902 make_tuple(8, 8, &aom_highbd_sad_skip_8x8x4d_sse2, 12),
2903 make_tuple(4, 8, &aom_highbd_sad_skip_4x8x4d_sse2, 12),
2904 #if !CONFIG_REALTIME_ONLY
2905 make_tuple(64, 16, &aom_highbd_sad_skip_64x16x4d_sse2, 12),
2906 make_tuple(16, 64, &aom_highbd_sad_skip_16x64x4d_sse2, 12),
2907 make_tuple(32, 8, &aom_highbd_sad_skip_32x8x4d_sse2, 12),
2908 make_tuple(8, 32, &aom_highbd_sad_skip_8x32x4d_sse2, 12),
2909 make_tuple(4, 16, &aom_highbd_sad_skip_4x16x4d_sse2, 12),
2910 #endif
2911 #endif // CONFIG_AV1_HIGHBITDEPTH
2912 };
2913 INSTANTIATE_TEST_SUITE_P(SSE2, SADSkipx4Test,
2914 ::testing::ValuesIn(skip_x4d_sse2_tests));
2915
2916 const DistWtdSadMxNAvgParam dist_wtd_avg_sse2_tests[] = {
2917 make_tuple(128, 128, &aom_dist_wtd_sad128x128_avg_sse2, -1),
2918 make_tuple(128, 64, &aom_dist_wtd_sad128x64_avg_sse2, -1),
2919 make_tuple(64, 128, &aom_dist_wtd_sad64x128_avg_sse2, -1),
2920 make_tuple(64, 64, &aom_dist_wtd_sad64x64_avg_sse2, -1),
2921 make_tuple(64, 32, &aom_dist_wtd_sad64x32_avg_sse2, -1),
2922 make_tuple(32, 64, &aom_dist_wtd_sad32x64_avg_sse2, -1),
2923 make_tuple(32, 32, &aom_dist_wtd_sad32x32_avg_sse2, -1),
2924 make_tuple(32, 16, &aom_dist_wtd_sad32x16_avg_sse2, -1),
2925 make_tuple(16, 32, &aom_dist_wtd_sad16x32_avg_sse2, -1),
2926 make_tuple(16, 16, &aom_dist_wtd_sad16x16_avg_sse2, -1),
2927 make_tuple(16, 8, &aom_dist_wtd_sad16x8_avg_sse2, -1),
2928 make_tuple(8, 16, &aom_dist_wtd_sad8x16_avg_sse2, -1),
2929 make_tuple(8, 8, &aom_dist_wtd_sad8x8_avg_sse2, -1),
2930 make_tuple(8, 4, &aom_dist_wtd_sad8x4_avg_sse2, -1),
2931 make_tuple(4, 8, &aom_dist_wtd_sad4x8_avg_sse2, -1),
2932 make_tuple(4, 4, &aom_dist_wtd_sad4x4_avg_sse2, -1),
2933 #if !CONFIG_REALTIME_ONLY
2934 make_tuple(64, 16, &aom_dist_wtd_sad64x16_avg_sse2, -1),
2935 make_tuple(16, 64, &aom_dist_wtd_sad16x64_avg_sse2, -1),
2936 make_tuple(32, 8, &aom_dist_wtd_sad32x8_avg_sse2, -1),
2937 make_tuple(8, 32, &aom_dist_wtd_sad8x32_avg_sse2, -1),
2938 make_tuple(16, 4, &aom_dist_wtd_sad16x4_avg_sse2, -1),
2939 make_tuple(4, 16, &aom_dist_wtd_sad4x16_avg_sse2, -1),
2940 #endif
2941 };
2942 INSTANTIATE_TEST_SUITE_P(sse2, DistWtdSADavgTest,
2943 ::testing::ValuesIn(dist_wtd_avg_sse2_tests));
2944 #endif // HAVE_SSE2
2945
2946 #if HAVE_SSE3
2947 // Only functions are x3, which do not have tests.
2948 #endif // HAVE_SSE3
2949
2950 #if HAVE_SSE4_1
2951 // Only functions are x8, which do not have tests.
2952 #endif // HAVE_SSE4_1
2953
2954 #if HAVE_AVX2
2955 const SadMxNParam avx2_tests[] = {
2956 make_tuple(64, 128, &aom_sad64x128_avx2, -1),
2957 make_tuple(128, 64, &aom_sad128x64_avx2, -1),
2958 make_tuple(128, 128, &aom_sad128x128_avx2, -1),
2959 make_tuple(64, 64, &aom_sad64x64_avx2, -1),
2960 make_tuple(64, 32, &aom_sad64x32_avx2, -1),
2961 make_tuple(32, 64, &aom_sad32x64_avx2, -1),
2962 make_tuple(32, 32, &aom_sad32x32_avx2, -1),
2963 make_tuple(32, 16, &aom_sad32x16_avx2, -1),
2964 #if CONFIG_AV1_HIGHBITDEPTH
2965 make_tuple(128, 128, &aom_highbd_sad128x128_avx2, 8),
2966 make_tuple(128, 128, &aom_highbd_sad128x128_avx2, 10),
2967 make_tuple(128, 128, &aom_highbd_sad128x128_avx2, 12),
2968 make_tuple(128, 64, &aom_highbd_sad128x64_avx2, 8),
2969 make_tuple(128, 64, &aom_highbd_sad128x64_avx2, 10),
2970 make_tuple(128, 64, &aom_highbd_sad128x64_avx2, 12),
2971 make_tuple(64, 128, &aom_highbd_sad64x128_avx2, 8),
2972 make_tuple(64, 128, &aom_highbd_sad64x128_avx2, 10),
2973 make_tuple(64, 128, &aom_highbd_sad64x128_avx2, 12),
2974 make_tuple(64, 64, &aom_highbd_sad64x64_avx2, 8),
2975 make_tuple(64, 64, &aom_highbd_sad64x64_avx2, 10),
2976 make_tuple(64, 64, &aom_highbd_sad64x64_avx2, 12),
2977 make_tuple(64, 32, &aom_highbd_sad64x32_avx2, 8),
2978 make_tuple(64, 32, &aom_highbd_sad64x32_avx2, 10),
2979 make_tuple(64, 32, &aom_highbd_sad64x32_avx2, 12),
2980 make_tuple(32, 64, &aom_highbd_sad32x64_avx2, 8),
2981 make_tuple(32, 64, &aom_highbd_sad32x64_avx2, 10),
2982 make_tuple(32, 64, &aom_highbd_sad32x64_avx2, 12),
2983 make_tuple(32, 32, &aom_highbd_sad32x32_avx2, 8),
2984 make_tuple(32, 32, &aom_highbd_sad32x32_avx2, 10),
2985 make_tuple(32, 32, &aom_highbd_sad32x32_avx2, 12),
2986 make_tuple(32, 16, &aom_highbd_sad32x16_avx2, 8),
2987 make_tuple(32, 16, &aom_highbd_sad32x16_avx2, 10),
2988 make_tuple(32, 16, &aom_highbd_sad32x16_avx2, 12),
2989 make_tuple(16, 32, &aom_highbd_sad16x32_avx2, 8),
2990 make_tuple(16, 32, &aom_highbd_sad16x32_avx2, 10),
2991 make_tuple(16, 32, &aom_highbd_sad16x32_avx2, 12),
2992 make_tuple(16, 16, &aom_highbd_sad16x16_avx2, 8),
2993 make_tuple(16, 16, &aom_highbd_sad16x16_avx2, 10),
2994 make_tuple(16, 16, &aom_highbd_sad16x16_avx2, 12),
2995 make_tuple(16, 8, &aom_highbd_sad16x8_avx2, 8),
2996 make_tuple(16, 8, &aom_highbd_sad16x8_avx2, 10),
2997 make_tuple(16, 8, &aom_highbd_sad16x8_avx2, 12),
2998
2999 #if !CONFIG_REALTIME_ONLY
3000 make_tuple(64, 16, &aom_highbd_sad64x16_avx2, 8),
3001 make_tuple(64, 16, &aom_highbd_sad64x16_avx2, 10),
3002 make_tuple(64, 16, &aom_highbd_sad64x16_avx2, 12),
3003 make_tuple(16, 64, &aom_highbd_sad16x64_avx2, 8),
3004 make_tuple(16, 64, &aom_highbd_sad16x64_avx2, 10),
3005 make_tuple(16, 64, &aom_highbd_sad16x64_avx2, 12),
3006 make_tuple(32, 8, &aom_highbd_sad32x8_avx2, 8),
3007 make_tuple(32, 8, &aom_highbd_sad32x8_avx2, 10),
3008 make_tuple(32, 8, &aom_highbd_sad32x8_avx2, 12),
3009 make_tuple(16, 4, &aom_highbd_sad16x4_avx2, 8),
3010 make_tuple(16, 4, &aom_highbd_sad16x4_avx2, 10),
3011 make_tuple(16, 4, &aom_highbd_sad16x4_avx2, 12),
3012 #endif
3013 #endif
3014 };
3015 INSTANTIATE_TEST_SUITE_P(AVX2, SADTest, ::testing::ValuesIn(avx2_tests));
3016
3017 const SadSkipMxNParam skip_avx2_tests[] = {
3018 make_tuple(128, 128, &aom_sad_skip_128x128_avx2, -1),
3019 make_tuple(128, 64, &aom_sad_skip_128x64_avx2, -1),
3020 make_tuple(64, 128, &aom_sad_skip_64x128_avx2, -1),
3021 make_tuple(64, 64, &aom_sad_skip_64x64_avx2, -1),
3022 make_tuple(64, 32, &aom_sad_skip_64x32_avx2, -1),
3023 make_tuple(32, 64, &aom_sad_skip_32x64_avx2, -1),
3024 make_tuple(32, 32, &aom_sad_skip_32x32_avx2, -1),
3025 make_tuple(32, 16, &aom_sad_skip_32x16_avx2, -1),
3026 #if CONFIG_AV1_HIGHBITDEPTH
3027 make_tuple(128, 128, &aom_highbd_sad_skip_128x128_avx2, 8),
3028 make_tuple(128, 64, &aom_highbd_sad_skip_128x64_avx2, 8),
3029 make_tuple(64, 128, &aom_highbd_sad_skip_64x128_avx2, 8),
3030 make_tuple(64, 64, &aom_highbd_sad_skip_64x64_avx2, 8),
3031 make_tuple(64, 32, &aom_highbd_sad_skip_64x32_avx2, 8),
3032 make_tuple(32, 64, &aom_highbd_sad_skip_32x64_avx2, 8),
3033 make_tuple(32, 32, &aom_highbd_sad_skip_32x32_avx2, 8),
3034 make_tuple(32, 16, &aom_highbd_sad_skip_32x16_avx2, 8),
3035 make_tuple(16, 32, &aom_highbd_sad_skip_16x32_avx2, 8),
3036 make_tuple(16, 16, &aom_highbd_sad_skip_16x16_avx2, 8),
3037 make_tuple(16, 8, &aom_highbd_sad_skip_16x8_avx2, 8),
3038
3039 make_tuple(128, 128, &aom_highbd_sad_skip_128x128_avx2, 10),
3040 make_tuple(128, 64, &aom_highbd_sad_skip_128x64_avx2, 10),
3041 make_tuple(64, 128, &aom_highbd_sad_skip_64x128_avx2, 10),
3042 make_tuple(64, 64, &aom_highbd_sad_skip_64x64_avx2, 10),
3043 make_tuple(64, 32, &aom_highbd_sad_skip_64x32_avx2, 10),
3044 make_tuple(32, 64, &aom_highbd_sad_skip_32x64_avx2, 10),
3045 make_tuple(32, 32, &aom_highbd_sad_skip_32x32_avx2, 10),
3046 make_tuple(32, 16, &aom_highbd_sad_skip_32x16_avx2, 10),
3047 make_tuple(16, 32, &aom_highbd_sad_skip_16x32_avx2, 10),
3048 make_tuple(16, 16, &aom_highbd_sad_skip_16x16_avx2, 10),
3049 make_tuple(16, 8, &aom_highbd_sad_skip_16x8_avx2, 10),
3050
3051 make_tuple(128, 128, &aom_highbd_sad_skip_128x128_avx2, 12),
3052 make_tuple(128, 64, &aom_highbd_sad_skip_128x64_avx2, 12),
3053 make_tuple(64, 128, &aom_highbd_sad_skip_64x128_avx2, 12),
3054 make_tuple(64, 64, &aom_highbd_sad_skip_64x64_avx2, 12),
3055 make_tuple(64, 32, &aom_highbd_sad_skip_64x32_avx2, 12),
3056 make_tuple(32, 64, &aom_highbd_sad_skip_32x64_avx2, 12),
3057 make_tuple(32, 32, &aom_highbd_sad_skip_32x32_avx2, 12),
3058 make_tuple(32, 16, &aom_highbd_sad_skip_32x16_avx2, 12),
3059 make_tuple(16, 32, &aom_highbd_sad_skip_16x32_avx2, 12),
3060 make_tuple(16, 16, &aom_highbd_sad_skip_16x16_avx2, 12),
3061 make_tuple(16, 8, &aom_highbd_sad_skip_16x8_avx2, 12),
3062
3063 #if !CONFIG_REALTIME_ONLY
3064 make_tuple(16, 64, &aom_highbd_sad_skip_16x64_avx2, 8),
3065 make_tuple(16, 64, &aom_highbd_sad_skip_16x64_avx2, 10),
3066 make_tuple(16, 64, &aom_highbd_sad_skip_16x64_avx2, 12),
3067 #endif
3068 #endif
3069 };
3070 INSTANTIATE_TEST_SUITE_P(AVX2, SADSkipTest,
3071 ::testing::ValuesIn(skip_avx2_tests));
3072
3073 const SadMxNAvgParam avg_avx2_tests[] = {
3074 make_tuple(64, 128, &aom_sad64x128_avg_avx2, -1),
3075 make_tuple(128, 64, &aom_sad128x64_avg_avx2, -1),
3076 make_tuple(128, 128, &aom_sad128x128_avg_avx2, -1),
3077 make_tuple(64, 64, &aom_sad64x64_avg_avx2, -1),
3078 make_tuple(64, 32, &aom_sad64x32_avg_avx2, -1),
3079 make_tuple(32, 64, &aom_sad32x64_avg_avx2, -1),
3080 make_tuple(32, 32, &aom_sad32x32_avg_avx2, -1),
3081 make_tuple(32, 16, &aom_sad32x16_avg_avx2, -1),
3082 #if CONFIG_AV1_HIGHBITDEPTH
3083 make_tuple(128, 128, &aom_highbd_sad128x128_avg_avx2, 8),
3084 make_tuple(128, 128, &aom_highbd_sad128x128_avg_avx2, 10),
3085 make_tuple(128, 128, &aom_highbd_sad128x128_avg_avx2, 12),
3086 make_tuple(128, 64, &aom_highbd_sad128x64_avg_avx2, 8),
3087 make_tuple(128, 64, &aom_highbd_sad128x64_avg_avx2, 10),
3088 make_tuple(128, 64, &aom_highbd_sad128x64_avg_avx2, 12),
3089 make_tuple(64, 128, &aom_highbd_sad64x128_avg_avx2, 8),
3090 make_tuple(64, 128, &aom_highbd_sad64x128_avg_avx2, 10),
3091 make_tuple(64, 128, &aom_highbd_sad64x128_avg_avx2, 12),
3092 make_tuple(64, 64, &aom_highbd_sad64x64_avg_avx2, 8),
3093 make_tuple(64, 64, &aom_highbd_sad64x64_avg_avx2, 10),
3094 make_tuple(64, 64, &aom_highbd_sad64x64_avg_avx2, 12),
3095 make_tuple(64, 32, &aom_highbd_sad64x32_avg_avx2, 8),
3096 make_tuple(64, 32, &aom_highbd_sad64x32_avg_avx2, 10),
3097 make_tuple(64, 32, &aom_highbd_sad64x32_avg_avx2, 12),
3098 make_tuple(32, 64, &aom_highbd_sad32x64_avg_avx2, 8),
3099 make_tuple(32, 64, &aom_highbd_sad32x64_avg_avx2, 10),
3100 make_tuple(32, 64, &aom_highbd_sad32x64_avg_avx2, 12),
3101 make_tuple(32, 32, &aom_highbd_sad32x32_avg_avx2, 8),
3102 make_tuple(32, 32, &aom_highbd_sad32x32_avg_avx2, 10),
3103 make_tuple(32, 32, &aom_highbd_sad32x32_avg_avx2, 12),
3104 make_tuple(32, 16, &aom_highbd_sad32x16_avg_avx2, 8),
3105 make_tuple(32, 16, &aom_highbd_sad32x16_avg_avx2, 10),
3106 make_tuple(32, 16, &aom_highbd_sad32x16_avg_avx2, 12),
3107 make_tuple(16, 32, &aom_highbd_sad16x32_avg_avx2, 8),
3108 make_tuple(16, 32, &aom_highbd_sad16x32_avg_avx2, 10),
3109 make_tuple(16, 32, &aom_highbd_sad16x32_avg_avx2, 12),
3110 make_tuple(16, 16, &aom_highbd_sad16x16_avg_avx2, 8),
3111 make_tuple(16, 16, &aom_highbd_sad16x16_avg_avx2, 10),
3112 make_tuple(16, 16, &aom_highbd_sad16x16_avg_avx2, 12),
3113 make_tuple(16, 8, &aom_highbd_sad16x8_avg_avx2, 8),
3114 make_tuple(16, 8, &aom_highbd_sad16x8_avg_avx2, 10),
3115 make_tuple(16, 8, &aom_highbd_sad16x8_avg_avx2, 12),
3116
3117 #if !CONFIG_REALTIME_ONLY
3118 make_tuple(64, 16, &aom_highbd_sad64x16_avg_avx2, 8),
3119 make_tuple(64, 16, &aom_highbd_sad64x16_avg_avx2, 10),
3120 make_tuple(64, 16, &aom_highbd_sad64x16_avg_avx2, 12),
3121 make_tuple(16, 64, &aom_highbd_sad16x64_avg_avx2, 8),
3122 make_tuple(16, 64, &aom_highbd_sad16x64_avg_avx2, 10),
3123 make_tuple(16, 64, &aom_highbd_sad16x64_avg_avx2, 12),
3124 make_tuple(32, 8, &aom_highbd_sad32x8_avg_avx2, 8),
3125 make_tuple(32, 8, &aom_highbd_sad32x8_avg_avx2, 10),
3126 make_tuple(32, 8, &aom_highbd_sad32x8_avg_avx2, 12),
3127 make_tuple(16, 4, &aom_highbd_sad16x4_avg_avx2, 8),
3128 make_tuple(16, 4, &aom_highbd_sad16x4_avg_avx2, 10),
3129 make_tuple(16, 4, &aom_highbd_sad16x4_avg_avx2, 12),
3130 #endif
3131 #endif
3132 };
3133 INSTANTIATE_TEST_SUITE_P(AVX2, SADavgTest, ::testing::ValuesIn(avg_avx2_tests));
3134
3135 const SadSkipMxNx4Param skip_x4d_avx2_tests[] = {
3136 make_tuple(128, 128, &aom_sad_skip_128x128x4d_avx2, -1),
3137 make_tuple(128, 64, &aom_sad_skip_128x64x4d_avx2, -1),
3138 make_tuple(64, 128, &aom_sad_skip_64x128x4d_avx2, -1),
3139 make_tuple(64, 64, &aom_sad_skip_64x64x4d_avx2, -1),
3140 make_tuple(64, 32, &aom_sad_skip_64x32x4d_avx2, -1),
3141 make_tuple(32, 64, &aom_sad_skip_32x64x4d_avx2, -1),
3142 make_tuple(32, 32, &aom_sad_skip_32x32x4d_avx2, -1),
3143 make_tuple(32, 16, &aom_sad_skip_32x16x4d_avx2, -1),
3144 make_tuple(16, 32, &aom_sad_skip_16x32x4d_avx2, -1),
3145 make_tuple(16, 16, &aom_sad_skip_16x16x4d_avx2, -1),
3146 make_tuple(16, 8, &aom_sad_skip_16x8x4d_avx2, -1),
3147
3148 #if CONFIG_AV1_HIGHBITDEPTH
3149 make_tuple(128, 128, &aom_highbd_sad_skip_128x128x4d_avx2, 8),
3150 make_tuple(128, 64, &aom_highbd_sad_skip_128x64x4d_avx2, 8),
3151 make_tuple(64, 128, &aom_highbd_sad_skip_64x128x4d_avx2, 8),
3152 make_tuple(64, 64, &aom_highbd_sad_skip_64x64x4d_avx2, 8),
3153 make_tuple(64, 32, &aom_highbd_sad_skip_64x32x4d_avx2, 8),
3154 make_tuple(32, 64, &aom_highbd_sad_skip_32x64x4d_avx2, 8),
3155 make_tuple(32, 32, &aom_highbd_sad_skip_32x32x4d_avx2, 8),
3156 make_tuple(32, 16, &aom_highbd_sad_skip_32x16x4d_avx2, 8),
3157 make_tuple(16, 32, &aom_highbd_sad_skip_16x32x4d_avx2, 8),
3158 make_tuple(16, 16, &aom_highbd_sad_skip_16x16x4d_avx2, 8),
3159 make_tuple(16, 8, &aom_highbd_sad_skip_16x8x4d_avx2, 8),
3160
3161 make_tuple(128, 128, &aom_highbd_sad_skip_128x128x4d_avx2, 10),
3162 make_tuple(128, 64, &aom_highbd_sad_skip_128x64x4d_avx2, 10),
3163 make_tuple(64, 128, &aom_highbd_sad_skip_64x128x4d_avx2, 10),
3164 make_tuple(64, 64, &aom_highbd_sad_skip_64x64x4d_avx2, 10),
3165 make_tuple(64, 32, &aom_highbd_sad_skip_64x32x4d_avx2, 10),
3166 make_tuple(32, 64, &aom_highbd_sad_skip_32x64x4d_avx2, 10),
3167 make_tuple(32, 32, &aom_highbd_sad_skip_32x32x4d_avx2, 10),
3168 make_tuple(32, 16, &aom_highbd_sad_skip_32x16x4d_avx2, 10),
3169 make_tuple(16, 32, &aom_highbd_sad_skip_16x32x4d_avx2, 10),
3170 make_tuple(16, 16, &aom_highbd_sad_skip_16x16x4d_avx2, 10),
3171 make_tuple(16, 8, &aom_highbd_sad_skip_16x8x4d_avx2, 10),
3172
3173 make_tuple(128, 128, &aom_highbd_sad_skip_128x128x4d_avx2, 12),
3174 make_tuple(128, 64, &aom_highbd_sad_skip_128x64x4d_avx2, 12),
3175 make_tuple(64, 128, &aom_highbd_sad_skip_64x128x4d_avx2, 12),
3176 make_tuple(64, 64, &aom_highbd_sad_skip_64x64x4d_avx2, 12),
3177 make_tuple(64, 32, &aom_highbd_sad_skip_64x32x4d_avx2, 12),
3178 make_tuple(32, 64, &aom_highbd_sad_skip_32x64x4d_avx2, 12),
3179 make_tuple(32, 32, &aom_highbd_sad_skip_32x32x4d_avx2, 12),
3180 make_tuple(32, 16, &aom_highbd_sad_skip_32x16x4d_avx2, 12),
3181 make_tuple(16, 32, &aom_highbd_sad_skip_16x32x4d_avx2, 12),
3182 make_tuple(16, 16, &aom_highbd_sad_skip_16x16x4d_avx2, 12),
3183 make_tuple(16, 8, &aom_highbd_sad_skip_16x8x4d_avx2, 12),
3184
3185 #if !CONFIG_REALTIME_ONLY
3186 make_tuple(64, 16, &aom_highbd_sad_skip_64x16x4d_avx2, 8),
3187 make_tuple(32, 8, &aom_highbd_sad_skip_32x8x4d_avx2, 8),
3188 make_tuple(16, 64, &aom_highbd_sad_skip_16x64x4d_avx2, 8),
3189
3190 make_tuple(64, 16, &aom_highbd_sad_skip_64x16x4d_avx2, 10),
3191 make_tuple(32, 8, &aom_highbd_sad_skip_32x8x4d_avx2, 10),
3192 make_tuple(16, 64, &aom_highbd_sad_skip_16x64x4d_avx2, 10),
3193
3194 make_tuple(64, 16, &aom_highbd_sad_skip_64x16x4d_avx2, 12),
3195 make_tuple(32, 8, &aom_highbd_sad_skip_32x8x4d_avx2, 12),
3196 make_tuple(16, 64, &aom_highbd_sad_skip_16x64x4d_avx2, 12),
3197 #endif
3198 #endif
3199
3200 #if !CONFIG_REALTIME_ONLY
3201 make_tuple(64, 16, &aom_sad_skip_64x16x4d_avx2, -1),
3202 make_tuple(32, 8, &aom_sad_skip_32x8x4d_avx2, -1),
3203
3204 make_tuple(16, 64, &aom_sad_skip_16x64x4d_avx2, -1),
3205 make_tuple(16, 4, &aom_sad_skip_16x4x4d_avx2, -1),
3206 #endif
3207 };
3208
3209 INSTANTIATE_TEST_SUITE_P(AVX2, SADSkipx4Test,
3210 ::testing::ValuesIn(skip_x4d_avx2_tests));
3211
3212 const SadMxNx4Param x4d_avx2_tests[] = {
3213 make_tuple(16, 32, &aom_sad16x32x4d_avx2, -1),
3214 make_tuple(16, 16, &aom_sad16x16x4d_avx2, -1),
3215 make_tuple(16, 8, &aom_sad16x8x4d_avx2, -1),
3216 make_tuple(32, 64, &aom_sad32x64x4d_avx2, -1),
3217 make_tuple(32, 32, &aom_sad32x32x4d_avx2, -1),
3218 make_tuple(32, 16, &aom_sad32x16x4d_avx2, -1),
3219 make_tuple(64, 128, &aom_sad64x128x4d_avx2, -1),
3220 make_tuple(64, 64, &aom_sad64x64x4d_avx2, -1),
3221 make_tuple(64, 32, &aom_sad64x32x4d_avx2, -1),
3222 make_tuple(128, 128, &aom_sad128x128x4d_avx2, -1),
3223 make_tuple(128, 64, &aom_sad128x64x4d_avx2, -1),
3224
3225 #if !CONFIG_REALTIME_ONLY
3226 make_tuple(16, 64, &aom_sad16x64x4d_avx2, -1),
3227 make_tuple(16, 4, &aom_sad16x4x4d_avx2, -1),
3228 make_tuple(32, 8, &aom_sad32x8x4d_avx2, -1),
3229 make_tuple(64, 16, &aom_sad64x16x4d_avx2, -1),
3230 #endif
3231
3232 #if CONFIG_AV1_HIGHBITDEPTH
3233 make_tuple(128, 128, &aom_highbd_sad128x128x4d_avx2, 8),
3234 make_tuple(128, 128, &aom_highbd_sad128x128x4d_avx2, 10),
3235 make_tuple(128, 128, &aom_highbd_sad128x128x4d_avx2, 12),
3236 make_tuple(128, 64, &aom_highbd_sad128x64x4d_avx2, 8),
3237 make_tuple(128, 64, &aom_highbd_sad128x64x4d_avx2, 10),
3238 make_tuple(128, 64, &aom_highbd_sad128x64x4d_avx2, 12),
3239 make_tuple(64, 128, &aom_highbd_sad64x128x4d_avx2, 8),
3240 make_tuple(64, 128, &aom_highbd_sad64x128x4d_avx2, 10),
3241 make_tuple(64, 128, &aom_highbd_sad64x128x4d_avx2, 12),
3242 make_tuple(64, 64, &aom_highbd_sad64x64x4d_avx2, 8),
3243 make_tuple(64, 64, &aom_highbd_sad64x64x4d_avx2, 10),
3244 make_tuple(64, 64, &aom_highbd_sad64x64x4d_avx2, 12),
3245 make_tuple(64, 32, &aom_highbd_sad64x32x4d_avx2, 8),
3246 make_tuple(64, 32, &aom_highbd_sad64x32x4d_avx2, 10),
3247 make_tuple(64, 32, &aom_highbd_sad64x32x4d_avx2, 12),
3248 make_tuple(32, 64, &aom_highbd_sad32x64x4d_avx2, 8),
3249 make_tuple(32, 64, &aom_highbd_sad32x64x4d_avx2, 10),
3250 make_tuple(32, 64, &aom_highbd_sad32x64x4d_avx2, 12),
3251 make_tuple(32, 32, &aom_highbd_sad32x32x4d_avx2, 8),
3252 make_tuple(32, 32, &aom_highbd_sad32x32x4d_avx2, 10),
3253 make_tuple(32, 32, &aom_highbd_sad32x32x4d_avx2, 12),
3254 make_tuple(32, 16, &aom_highbd_sad32x16x4d_avx2, 8),
3255 make_tuple(32, 16, &aom_highbd_sad32x16x4d_avx2, 10),
3256 make_tuple(32, 16, &aom_highbd_sad32x16x4d_avx2, 12),
3257 make_tuple(16, 32, &aom_highbd_sad16x32x4d_avx2, 8),
3258 make_tuple(16, 32, &aom_highbd_sad16x32x4d_avx2, 10),
3259 make_tuple(16, 32, &aom_highbd_sad16x32x4d_avx2, 12),
3260 make_tuple(16, 16, &aom_highbd_sad16x16x4d_avx2, 8),
3261 make_tuple(16, 16, &aom_highbd_sad16x16x4d_avx2, 10),
3262 make_tuple(16, 16, &aom_highbd_sad16x16x4d_avx2, 12),
3263 make_tuple(16, 8, &aom_highbd_sad16x8x4d_avx2, 8),
3264 make_tuple(16, 8, &aom_highbd_sad16x8x4d_avx2, 10),
3265 make_tuple(16, 8, &aom_highbd_sad16x8x4d_avx2, 12),
3266
3267 #if !CONFIG_REALTIME_ONLY
3268 make_tuple(16, 64, &aom_highbd_sad16x64x4d_avx2, 8),
3269 make_tuple(16, 64, &aom_highbd_sad16x64x4d_avx2, 10),
3270 make_tuple(16, 64, &aom_highbd_sad16x64x4d_avx2, 12),
3271 make_tuple(64, 16, &aom_highbd_sad64x16x4d_avx2, 8),
3272 make_tuple(64, 16, &aom_highbd_sad64x16x4d_avx2, 10),
3273 make_tuple(64, 16, &aom_highbd_sad64x16x4d_avx2, 12),
3274 make_tuple(32, 8, &aom_highbd_sad32x8x4d_avx2, 8),
3275 make_tuple(32, 8, &aom_highbd_sad32x8x4d_avx2, 10),
3276 make_tuple(32, 8, &aom_highbd_sad32x8x4d_avx2, 12),
3277 make_tuple(16, 4, &aom_highbd_sad16x4x4d_avx2, 8),
3278 make_tuple(16, 4, &aom_highbd_sad16x4x4d_avx2, 10),
3279 make_tuple(16, 4, &aom_highbd_sad16x4x4d_avx2, 12),
3280 #endif
3281 #endif
3282 };
3283 INSTANTIATE_TEST_SUITE_P(AVX2, SADx4Test, ::testing::ValuesIn(x4d_avx2_tests));
3284
3285 const SadMxNx4Param x3d_avx2_tests[] = {
3286 make_tuple(32, 64, &aom_sad32x64x3d_avx2, -1),
3287 make_tuple(32, 32, &aom_sad32x32x3d_avx2, -1),
3288 make_tuple(32, 16, &aom_sad32x16x3d_avx2, -1),
3289 make_tuple(64, 128, &aom_sad64x128x3d_avx2, -1),
3290 make_tuple(64, 64, &aom_sad64x64x3d_avx2, -1),
3291 make_tuple(64, 32, &aom_sad64x32x3d_avx2, -1),
3292 make_tuple(128, 128, &aom_sad128x128x3d_avx2, -1),
3293 make_tuple(128, 64, &aom_sad128x64x3d_avx2, -1),
3294
3295 #if !CONFIG_REALTIME_ONLY
3296 make_tuple(32, 8, &aom_sad32x8x3d_avx2, -1),
3297 make_tuple(64, 16, &aom_sad64x16x3d_avx2, -1),
3298 make_tuple(16, 4, &aom_sad16x4x3d_avx2, -1),
3299 #endif // !CONFIG_REALTIME_ONLY
3300
3301 #if CONFIG_AV1_HIGHBITDEPTH
3302 make_tuple(128, 128, &aom_highbd_sad128x128x3d_avx2, 8),
3303 make_tuple(128, 128, &aom_highbd_sad128x128x3d_avx2, 10),
3304 make_tuple(128, 128, &aom_highbd_sad128x128x3d_avx2, 12),
3305 make_tuple(128, 64, &aom_highbd_sad128x64x3d_avx2, 8),
3306 make_tuple(128, 64, &aom_highbd_sad128x64x3d_avx2, 10),
3307 make_tuple(128, 64, &aom_highbd_sad128x64x3d_avx2, 12),
3308 make_tuple(64, 128, &aom_highbd_sad64x128x3d_avx2, 8),
3309 make_tuple(64, 128, &aom_highbd_sad64x128x3d_avx2, 10),
3310 make_tuple(64, 128, &aom_highbd_sad64x128x3d_avx2, 12),
3311 make_tuple(64, 64, &aom_highbd_sad64x64x3d_avx2, 8),
3312 make_tuple(64, 64, &aom_highbd_sad64x64x3d_avx2, 10),
3313 make_tuple(64, 64, &aom_highbd_sad64x64x3d_avx2, 12),
3314 make_tuple(64, 32, &aom_highbd_sad64x32x3d_avx2, 8),
3315 make_tuple(64, 32, &aom_highbd_sad64x32x3d_avx2, 10),
3316 make_tuple(64, 32, &aom_highbd_sad64x32x3d_avx2, 12),
3317 make_tuple(32, 64, &aom_highbd_sad32x64x3d_avx2, 8),
3318 make_tuple(32, 64, &aom_highbd_sad32x64x3d_avx2, 10),
3319 make_tuple(32, 64, &aom_highbd_sad32x64x3d_avx2, 12),
3320 make_tuple(32, 32, &aom_highbd_sad32x32x3d_avx2, 8),
3321 make_tuple(32, 32, &aom_highbd_sad32x32x3d_avx2, 10),
3322 make_tuple(32, 32, &aom_highbd_sad32x32x3d_avx2, 12),
3323 make_tuple(32, 16, &aom_highbd_sad32x16x3d_avx2, 8),
3324 make_tuple(32, 16, &aom_highbd_sad32x16x3d_avx2, 10),
3325 make_tuple(32, 16, &aom_highbd_sad32x16x3d_avx2, 12),
3326 make_tuple(16, 32, &aom_highbd_sad16x32x3d_avx2, 8),
3327 make_tuple(16, 32, &aom_highbd_sad16x32x3d_avx2, 10),
3328 make_tuple(16, 32, &aom_highbd_sad16x32x3d_avx2, 12),
3329 make_tuple(16, 16, &aom_highbd_sad16x16x3d_avx2, 8),
3330 make_tuple(16, 16, &aom_highbd_sad16x16x3d_avx2, 10),
3331 make_tuple(16, 16, &aom_highbd_sad16x16x3d_avx2, 12),
3332 make_tuple(16, 8, &aom_highbd_sad16x8x3d_avx2, 8),
3333 make_tuple(16, 8, &aom_highbd_sad16x8x3d_avx2, 10),
3334 make_tuple(16, 8, &aom_highbd_sad16x8x3d_avx2, 12),
3335
3336 #if !CONFIG_REALTIME_ONLY
3337 make_tuple(16, 64, &aom_highbd_sad16x64x3d_avx2, 8),
3338 make_tuple(16, 64, &aom_highbd_sad16x64x3d_avx2, 10),
3339 make_tuple(16, 64, &aom_highbd_sad16x64x3d_avx2, 12),
3340 make_tuple(64, 16, &aom_highbd_sad64x16x3d_avx2, 8),
3341 make_tuple(64, 16, &aom_highbd_sad64x16x3d_avx2, 10),
3342 make_tuple(64, 16, &aom_highbd_sad64x16x3d_avx2, 12),
3343 make_tuple(32, 8, &aom_highbd_sad32x8x3d_avx2, 8),
3344 make_tuple(32, 8, &aom_highbd_sad32x8x3d_avx2, 10),
3345 make_tuple(32, 8, &aom_highbd_sad32x8x3d_avx2, 12),
3346 make_tuple(16, 4, &aom_highbd_sad16x4x3d_avx2, 8),
3347 make_tuple(16, 4, &aom_highbd_sad16x4x3d_avx2, 10),
3348 make_tuple(16, 4, &aom_highbd_sad16x4x3d_avx2, 12),
3349 #endif // !CONFIG_REALTIME_ONLY
3350 #endif // CONFIG_AV1_HIGHBITDEPTH
3351 };
3352 INSTANTIATE_TEST_SUITE_P(AVX2, SADx3Test, ::testing::ValuesIn(x3d_avx2_tests));
3353 #endif // HAVE_AVX2
3354
3355 } // namespace
3356