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 <math.h>
13 #include <stdlib.h>
14 #include <string.h>
15 #include <tuple>
16
17 #include "third_party/googletest/src/googletest/include/gtest/gtest.h"
18 #include "test/acm_random.h"
19 #include "test/register_state_check.h"
20 #include "test/util.h"
21
22 #include "config/aom_config.h"
23 #include "config/aom_dsp_rtcd.h"
24
25 #include "aom/aom_codec.h"
26 #include "aom/aom_integer.h"
27 #include "aom_dsp/aom_filter.h"
28 #include "aom_mem/aom_mem.h"
29
30 using libaom_test::ACMRandom;
31
32 namespace {
33 const int number_of_iterations = 200;
34
35 typedef unsigned int (*MaskedSubPixelVarianceFunc)(
36 const uint8_t *src, int src_stride, int xoffset, int yoffset,
37 const uint8_t *ref, int ref_stride, const uint8_t *second_pred,
38 const uint8_t *msk, int msk_stride, int invert_mask, unsigned int *sse);
39
40 typedef std::tuple<MaskedSubPixelVarianceFunc, MaskedSubPixelVarianceFunc>
41 MaskedSubPixelVarianceParam;
42
43 class MaskedSubPixelVarianceTest
44 : public ::testing::TestWithParam<MaskedSubPixelVarianceParam> {
45 public:
~MaskedSubPixelVarianceTest()46 virtual ~MaskedSubPixelVarianceTest() {}
SetUp()47 virtual void SetUp() {
48 opt_func_ = GET_PARAM(0);
49 ref_func_ = GET_PARAM(1);
50 }
51
TearDown()52 virtual void TearDown() {}
53
54 protected:
55 MaskedSubPixelVarianceFunc opt_func_;
56 MaskedSubPixelVarianceFunc ref_func_;
57 };
58 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(MaskedSubPixelVarianceTest);
59
TEST_P(MaskedSubPixelVarianceTest,OperationCheck)60 TEST_P(MaskedSubPixelVarianceTest, OperationCheck) {
61 unsigned int ref_ret, opt_ret;
62 unsigned int ref_sse, opt_sse;
63 ACMRandom rnd(ACMRandom::DeterministicSeed());
64 // Note: We pad out the input array to a multiple of 16 bytes wide, so that
65 // consecutive rows keep the 16-byte alignment.
66 DECLARE_ALIGNED(16, uint8_t, src_ptr[(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 16)]);
67 DECLARE_ALIGNED(16, uint8_t, ref_ptr[(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 16)]);
68 DECLARE_ALIGNED(16, uint8_t,
69 second_pred_ptr[(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 16)]);
70 DECLARE_ALIGNED(16, uint8_t, msk_ptr[(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 16)]);
71 int err_count = 0;
72 int first_failure = -1;
73 int src_stride = (MAX_SB_SIZE + 16);
74 int ref_stride = (MAX_SB_SIZE + 16);
75 int msk_stride = (MAX_SB_SIZE + 16);
76 int xoffset;
77 int yoffset;
78
79 for (int i = 0; i < number_of_iterations; ++i) {
80 int xoffsets[] = { 0, 4, rnd(BIL_SUBPEL_SHIFTS) };
81 int yoffsets[] = { 0, 4, rnd(BIL_SUBPEL_SHIFTS) };
82 for (int j = 0; j < (MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 16); j++) {
83 src_ptr[j] = rnd.Rand8();
84 ref_ptr[j] = rnd.Rand8();
85 second_pred_ptr[j] = rnd.Rand8();
86 msk_ptr[j] = rnd(65);
87 }
88 for (int k = 0; k < 3; k++) {
89 for (int l = 0; l < 3; l++) {
90 xoffset = xoffsets[k];
91 yoffset = yoffsets[l];
92 for (int invert_mask = 0; invert_mask < 2; ++invert_mask) {
93 ref_ret = ref_func_(src_ptr, src_stride, xoffset, yoffset, ref_ptr,
94 ref_stride, second_pred_ptr, msk_ptr, msk_stride,
95 invert_mask, &ref_sse);
96 API_REGISTER_STATE_CHECK(
97 opt_ret = opt_func_(src_ptr, src_stride, xoffset, yoffset,
98 ref_ptr, ref_stride, second_pred_ptr, msk_ptr,
99 msk_stride, invert_mask, &opt_sse));
100
101 if (opt_ret != ref_ret || opt_sse != ref_sse) {
102 err_count++;
103 if (first_failure == -1) first_failure = i;
104 }
105 }
106 }
107 }
108 }
109
110 EXPECT_EQ(0, err_count)
111 << "Error: Masked Sub Pixel Variance Test OperationCheck,"
112 << "C output doesn't match SSSE3 output. "
113 << "First failed at test case " << first_failure;
114 }
115
TEST_P(MaskedSubPixelVarianceTest,ExtremeValues)116 TEST_P(MaskedSubPixelVarianceTest, ExtremeValues) {
117 unsigned int ref_ret, opt_ret;
118 unsigned int ref_sse, opt_sse;
119 ACMRandom rnd(ACMRandom::DeterministicSeed());
120 DECLARE_ALIGNED(16, uint8_t, src_ptr[(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 16)]);
121 DECLARE_ALIGNED(16, uint8_t, ref_ptr[(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 16)]);
122 DECLARE_ALIGNED(16, uint8_t,
123 second_pred_ptr[(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 16)]);
124 DECLARE_ALIGNED(16, uint8_t, msk_ptr[(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 16)]);
125 int first_failure_x = -1;
126 int first_failure_y = -1;
127 int err_count = 0;
128 int first_failure = -1;
129 int src_stride = (MAX_SB_SIZE + 16);
130 int ref_stride = (MAX_SB_SIZE + 16);
131 int msk_stride = (MAX_SB_SIZE + 16);
132
133 for (int xoffset = 0; xoffset < BIL_SUBPEL_SHIFTS; xoffset++) {
134 for (int yoffset = 0; yoffset < BIL_SUBPEL_SHIFTS; yoffset++) {
135 for (int i = 0; i < 16; ++i) {
136 memset(src_ptr, (i & 0x1) ? 255 : 0,
137 (MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 16));
138 memset(ref_ptr, (i & 0x2) ? 255 : 0,
139 (MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 16));
140 memset(second_pred_ptr, (i & 0x4) ? 255 : 0,
141 (MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 16));
142 memset(msk_ptr, (i & 0x8) ? 64 : 0,
143 (MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 16));
144
145 for (int invert_mask = 0; invert_mask < 2; ++invert_mask) {
146 ref_ret = ref_func_(src_ptr, src_stride, xoffset, yoffset, ref_ptr,
147 ref_stride, second_pred_ptr, msk_ptr, msk_stride,
148 invert_mask, &ref_sse);
149 API_REGISTER_STATE_CHECK(
150 opt_ret = opt_func_(src_ptr, src_stride, xoffset, yoffset,
151 ref_ptr, ref_stride, second_pred_ptr, msk_ptr,
152 msk_stride, invert_mask, &opt_sse));
153
154 if (opt_ret != ref_ret || opt_sse != ref_sse) {
155 err_count++;
156 if (first_failure == -1) {
157 first_failure = i;
158 first_failure_x = xoffset;
159 first_failure_y = yoffset;
160 }
161 }
162 }
163 }
164 }
165 }
166
167 EXPECT_EQ(0, err_count) << "Error: Masked Variance Test ExtremeValues,"
168 << "C output doesn't match SSSE3 output. "
169 << "First failed at test case " << first_failure
170 << " x_offset = " << first_failure_x
171 << " y_offset = " << first_failure_y;
172 }
173
174 #if CONFIG_AV1_HIGHBITDEPTH
175 typedef std::tuple<MaskedSubPixelVarianceFunc, MaskedSubPixelVarianceFunc,
176 aom_bit_depth_t>
177 HighbdMaskedSubPixelVarianceParam;
178
179 class HighbdMaskedSubPixelVarianceTest
180 : public ::testing::TestWithParam<HighbdMaskedSubPixelVarianceParam> {
181 public:
~HighbdMaskedSubPixelVarianceTest()182 virtual ~HighbdMaskedSubPixelVarianceTest() {}
SetUp()183 virtual void SetUp() {
184 opt_func_ = GET_PARAM(0);
185 ref_func_ = GET_PARAM(1);
186 bit_depth_ = GET_PARAM(2);
187 }
188
TearDown()189 virtual void TearDown() {}
190
191 protected:
192 MaskedSubPixelVarianceFunc opt_func_;
193 MaskedSubPixelVarianceFunc ref_func_;
194 aom_bit_depth_t bit_depth_;
195 };
196 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(HighbdMaskedSubPixelVarianceTest);
197
TEST_P(HighbdMaskedSubPixelVarianceTest,OperationCheck)198 TEST_P(HighbdMaskedSubPixelVarianceTest, OperationCheck) {
199 unsigned int ref_ret, opt_ret;
200 unsigned int ref_sse, opt_sse;
201 ACMRandom rnd(ACMRandom::DeterministicSeed());
202 DECLARE_ALIGNED(16, uint16_t, src_ptr[(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 8)]);
203 DECLARE_ALIGNED(16, uint16_t, ref_ptr[(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 8)]);
204 DECLARE_ALIGNED(16, uint16_t,
205 second_pred_ptr[(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 8)]);
206 DECLARE_ALIGNED(16, uint8_t, msk_ptr[(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 8)]);
207 uint8_t *src8_ptr = CONVERT_TO_BYTEPTR(src_ptr);
208 uint8_t *ref8_ptr = CONVERT_TO_BYTEPTR(ref_ptr);
209 uint8_t *second_pred8_ptr = CONVERT_TO_BYTEPTR(second_pred_ptr);
210 int err_count = 0;
211 int first_failure = -1;
212 int first_failure_x = -1;
213 int first_failure_y = -1;
214 int src_stride = (MAX_SB_SIZE + 8);
215 int ref_stride = (MAX_SB_SIZE + 8);
216 int msk_stride = (MAX_SB_SIZE + 8);
217 int xoffset, yoffset;
218
219 for (int i = 0; i < number_of_iterations; ++i) {
220 for (int j = 0; j < (MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 8); j++) {
221 src_ptr[j] = rnd.Rand16() & ((1 << bit_depth_) - 1);
222 ref_ptr[j] = rnd.Rand16() & ((1 << bit_depth_) - 1);
223 second_pred_ptr[j] = rnd.Rand16() & ((1 << bit_depth_) - 1);
224 msk_ptr[j] = rnd(65);
225 }
226 for (xoffset = 0; xoffset < BIL_SUBPEL_SHIFTS; xoffset++) {
227 for (yoffset = 0; yoffset < BIL_SUBPEL_SHIFTS; yoffset++) {
228 for (int invert_mask = 0; invert_mask < 2; ++invert_mask) {
229 ref_ret = ref_func_(src8_ptr, src_stride, xoffset, yoffset, ref8_ptr,
230 ref_stride, second_pred8_ptr, msk_ptr, msk_stride,
231 invert_mask, &ref_sse);
232 API_REGISTER_STATE_CHECK(
233 opt_ret = opt_func_(src8_ptr, src_stride, xoffset, yoffset,
234 ref8_ptr, ref_stride, second_pred8_ptr,
235 msk_ptr, msk_stride, invert_mask, &opt_sse));
236
237 if (opt_ret != ref_ret || opt_sse != ref_sse) {
238 err_count++;
239 if (first_failure == -1) {
240 first_failure = i;
241 first_failure_x = xoffset;
242 first_failure_y = yoffset;
243 }
244 }
245 }
246 }
247 }
248 }
249
250 EXPECT_EQ(0, err_count)
251 << "Error: Masked Sub Pixel Variance Test OperationCheck,"
252 << "C output doesn't match SSSE3 output. "
253 << "First failed at test case " << first_failure
254 << " x_offset = " << first_failure_x << " y_offset = " << first_failure_y;
255 }
256
TEST_P(HighbdMaskedSubPixelVarianceTest,ExtremeValues)257 TEST_P(HighbdMaskedSubPixelVarianceTest, ExtremeValues) {
258 unsigned int ref_ret, opt_ret;
259 unsigned int ref_sse, opt_sse;
260 ACMRandom rnd(ACMRandom::DeterministicSeed());
261 DECLARE_ALIGNED(16, uint16_t, src_ptr[(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 8)]);
262 DECLARE_ALIGNED(16, uint16_t, ref_ptr[(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 8)]);
263 DECLARE_ALIGNED(16, uint8_t, msk_ptr[(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 8)]);
264 DECLARE_ALIGNED(16, uint16_t,
265 second_pred_ptr[(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 8)]);
266 uint8_t *src8_ptr = CONVERT_TO_BYTEPTR(src_ptr);
267 uint8_t *ref8_ptr = CONVERT_TO_BYTEPTR(ref_ptr);
268 uint8_t *second_pred8_ptr = CONVERT_TO_BYTEPTR(second_pred_ptr);
269 int first_failure_x = -1;
270 int first_failure_y = -1;
271 int err_count = 0;
272 int first_failure = -1;
273 int src_stride = (MAX_SB_SIZE + 8);
274 int ref_stride = (MAX_SB_SIZE + 8);
275 int msk_stride = (MAX_SB_SIZE + 8);
276
277 for (int xoffset = 0; xoffset < BIL_SUBPEL_SHIFTS; xoffset++) {
278 for (int yoffset = 0; yoffset < BIL_SUBPEL_SHIFTS; yoffset++) {
279 for (int i = 0; i < 16; ++i) {
280 aom_memset16(src_ptr, (i & 0x1) ? ((1 << bit_depth_) - 1) : 0,
281 (MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 8));
282 aom_memset16(ref_ptr, (i & 0x2) ? ((1 << bit_depth_) - 1) : 0,
283 (MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 8));
284 aom_memset16(second_pred_ptr, (i & 0x4) ? ((1 << bit_depth_) - 1) : 0,
285 (MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 8));
286 memset(msk_ptr, (i & 0x8) ? 64 : 0,
287 (MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 8));
288
289 for (int invert_mask = 0; invert_mask < 2; ++invert_mask) {
290 ref_ret = ref_func_(src8_ptr, src_stride, xoffset, yoffset, ref8_ptr,
291 ref_stride, second_pred8_ptr, msk_ptr, msk_stride,
292 invert_mask, &ref_sse);
293 API_REGISTER_STATE_CHECK(
294 opt_ret = opt_func_(src8_ptr, src_stride, xoffset, yoffset,
295 ref8_ptr, ref_stride, second_pred8_ptr,
296 msk_ptr, msk_stride, invert_mask, &opt_sse));
297
298 if (opt_ret != ref_ret || opt_sse != ref_sse) {
299 err_count++;
300 if (first_failure == -1) {
301 first_failure = i;
302 first_failure_x = xoffset;
303 first_failure_y = yoffset;
304 }
305 }
306 }
307 }
308 }
309 }
310
311 EXPECT_EQ(0, err_count) << "Error: Masked Variance Test ExtremeValues,"
312 << "C output doesn't match SSSE3 output. "
313 << "First failed at test case " << first_failure
314 << " x_offset = " << first_failure_x
315 << " y_offset = " << first_failure_y;
316 }
317 #endif // CONFIG_AV1_HIGHBITDEPTH
318
319 using std::make_tuple;
320
321 #if HAVE_SSSE3
322
323 const MaskedSubPixelVarianceParam sub_pel_var_test[] = {
324 make_tuple(&aom_masked_sub_pixel_variance128x128_ssse3,
325 &aom_masked_sub_pixel_variance128x128_c),
326 make_tuple(&aom_masked_sub_pixel_variance128x64_ssse3,
327 &aom_masked_sub_pixel_variance128x64_c),
328 make_tuple(&aom_masked_sub_pixel_variance64x128_ssse3,
329 &aom_masked_sub_pixel_variance64x128_c),
330 make_tuple(&aom_masked_sub_pixel_variance64x64_ssse3,
331 &aom_masked_sub_pixel_variance64x64_c),
332 make_tuple(&aom_masked_sub_pixel_variance64x32_ssse3,
333 &aom_masked_sub_pixel_variance64x32_c),
334 make_tuple(&aom_masked_sub_pixel_variance32x64_ssse3,
335 &aom_masked_sub_pixel_variance32x64_c),
336 make_tuple(&aom_masked_sub_pixel_variance32x32_ssse3,
337 &aom_masked_sub_pixel_variance32x32_c),
338 make_tuple(&aom_masked_sub_pixel_variance32x16_ssse3,
339 &aom_masked_sub_pixel_variance32x16_c),
340 make_tuple(&aom_masked_sub_pixel_variance16x32_ssse3,
341 &aom_masked_sub_pixel_variance16x32_c),
342 make_tuple(&aom_masked_sub_pixel_variance16x16_ssse3,
343 &aom_masked_sub_pixel_variance16x16_c),
344 make_tuple(&aom_masked_sub_pixel_variance16x8_ssse3,
345 &aom_masked_sub_pixel_variance16x8_c),
346 make_tuple(&aom_masked_sub_pixel_variance8x16_ssse3,
347 &aom_masked_sub_pixel_variance8x16_c),
348 make_tuple(&aom_masked_sub_pixel_variance8x8_ssse3,
349 &aom_masked_sub_pixel_variance8x8_c),
350 make_tuple(&aom_masked_sub_pixel_variance8x4_ssse3,
351 &aom_masked_sub_pixel_variance8x4_c),
352 make_tuple(&aom_masked_sub_pixel_variance4x8_ssse3,
353 &aom_masked_sub_pixel_variance4x8_c),
354 make_tuple(&aom_masked_sub_pixel_variance4x4_ssse3,
355 &aom_masked_sub_pixel_variance4x4_c),
356 #if !CONFIG_REALTIME_ONLY
357 make_tuple(&aom_masked_sub_pixel_variance64x16_ssse3,
358 &aom_masked_sub_pixel_variance64x16_c),
359 make_tuple(&aom_masked_sub_pixel_variance16x64_ssse3,
360 &aom_masked_sub_pixel_variance16x64_c),
361 make_tuple(&aom_masked_sub_pixel_variance32x8_ssse3,
362 &aom_masked_sub_pixel_variance32x8_c),
363 make_tuple(&aom_masked_sub_pixel_variance8x32_ssse3,
364 &aom_masked_sub_pixel_variance8x32_c),
365 make_tuple(&aom_masked_sub_pixel_variance16x4_ssse3,
366 &aom_masked_sub_pixel_variance16x4_c),
367 make_tuple(&aom_masked_sub_pixel_variance4x16_ssse3,
368 &aom_masked_sub_pixel_variance4x16_c),
369 #endif
370 };
371
372 INSTANTIATE_TEST_SUITE_P(SSSE3_C_COMPARE, MaskedSubPixelVarianceTest,
373 ::testing::ValuesIn(sub_pel_var_test));
374
375 #if CONFIG_AV1_HIGHBITDEPTH
376 const HighbdMaskedSubPixelVarianceParam hbd_sub_pel_var_test[] = {
377 make_tuple(&aom_highbd_8_masked_sub_pixel_variance128x128_ssse3,
378 &aom_highbd_8_masked_sub_pixel_variance128x128_c, AOM_BITS_8),
379 make_tuple(&aom_highbd_8_masked_sub_pixel_variance128x64_ssse3,
380 &aom_highbd_8_masked_sub_pixel_variance128x64_c, AOM_BITS_8),
381 make_tuple(&aom_highbd_8_masked_sub_pixel_variance64x128_ssse3,
382 &aom_highbd_8_masked_sub_pixel_variance64x128_c, AOM_BITS_8),
383 make_tuple(&aom_highbd_8_masked_sub_pixel_variance64x64_ssse3,
384 &aom_highbd_8_masked_sub_pixel_variance64x64_c, AOM_BITS_8),
385 make_tuple(&aom_highbd_8_masked_sub_pixel_variance64x32_ssse3,
386 &aom_highbd_8_masked_sub_pixel_variance64x32_c, AOM_BITS_8),
387 make_tuple(&aom_highbd_8_masked_sub_pixel_variance32x64_ssse3,
388 &aom_highbd_8_masked_sub_pixel_variance32x64_c, AOM_BITS_8),
389 make_tuple(&aom_highbd_8_masked_sub_pixel_variance32x32_ssse3,
390 &aom_highbd_8_masked_sub_pixel_variance32x32_c, AOM_BITS_8),
391 make_tuple(&aom_highbd_8_masked_sub_pixel_variance32x16_ssse3,
392 &aom_highbd_8_masked_sub_pixel_variance32x16_c, AOM_BITS_8),
393 make_tuple(&aom_highbd_8_masked_sub_pixel_variance16x32_ssse3,
394 &aom_highbd_8_masked_sub_pixel_variance16x32_c, AOM_BITS_8),
395 make_tuple(&aom_highbd_8_masked_sub_pixel_variance16x16_ssse3,
396 &aom_highbd_8_masked_sub_pixel_variance16x16_c, AOM_BITS_8),
397 make_tuple(&aom_highbd_8_masked_sub_pixel_variance16x8_ssse3,
398 &aom_highbd_8_masked_sub_pixel_variance16x8_c, AOM_BITS_8),
399 make_tuple(&aom_highbd_8_masked_sub_pixel_variance8x16_ssse3,
400 &aom_highbd_8_masked_sub_pixel_variance8x16_c, AOM_BITS_8),
401 make_tuple(&aom_highbd_8_masked_sub_pixel_variance8x8_ssse3,
402 &aom_highbd_8_masked_sub_pixel_variance8x8_c, AOM_BITS_8),
403 make_tuple(&aom_highbd_8_masked_sub_pixel_variance8x4_ssse3,
404 &aom_highbd_8_masked_sub_pixel_variance8x4_c, AOM_BITS_8),
405 make_tuple(&aom_highbd_8_masked_sub_pixel_variance4x8_ssse3,
406 &aom_highbd_8_masked_sub_pixel_variance4x8_c, AOM_BITS_8),
407 make_tuple(&aom_highbd_8_masked_sub_pixel_variance4x4_ssse3,
408 &aom_highbd_8_masked_sub_pixel_variance4x4_c, AOM_BITS_8),
409 make_tuple(&aom_highbd_10_masked_sub_pixel_variance128x128_ssse3,
410 &aom_highbd_10_masked_sub_pixel_variance128x128_c, AOM_BITS_10),
411 make_tuple(&aom_highbd_10_masked_sub_pixel_variance128x64_ssse3,
412 &aom_highbd_10_masked_sub_pixel_variance128x64_c, AOM_BITS_10),
413 make_tuple(&aom_highbd_10_masked_sub_pixel_variance64x128_ssse3,
414 &aom_highbd_10_masked_sub_pixel_variance64x128_c, AOM_BITS_10),
415 make_tuple(&aom_highbd_10_masked_sub_pixel_variance64x64_ssse3,
416 &aom_highbd_10_masked_sub_pixel_variance64x64_c, AOM_BITS_10),
417 make_tuple(&aom_highbd_10_masked_sub_pixel_variance64x32_ssse3,
418 &aom_highbd_10_masked_sub_pixel_variance64x32_c, AOM_BITS_10),
419 make_tuple(&aom_highbd_10_masked_sub_pixel_variance32x64_ssse3,
420 &aom_highbd_10_masked_sub_pixel_variance32x64_c, AOM_BITS_10),
421 make_tuple(&aom_highbd_10_masked_sub_pixel_variance32x32_ssse3,
422 &aom_highbd_10_masked_sub_pixel_variance32x32_c, AOM_BITS_10),
423 make_tuple(&aom_highbd_10_masked_sub_pixel_variance32x16_ssse3,
424 &aom_highbd_10_masked_sub_pixel_variance32x16_c, AOM_BITS_10),
425 make_tuple(&aom_highbd_10_masked_sub_pixel_variance16x32_ssse3,
426 &aom_highbd_10_masked_sub_pixel_variance16x32_c, AOM_BITS_10),
427 make_tuple(&aom_highbd_10_masked_sub_pixel_variance16x16_ssse3,
428 &aom_highbd_10_masked_sub_pixel_variance16x16_c, AOM_BITS_10),
429 make_tuple(&aom_highbd_10_masked_sub_pixel_variance16x8_ssse3,
430 &aom_highbd_10_masked_sub_pixel_variance16x8_c, AOM_BITS_10),
431 make_tuple(&aom_highbd_10_masked_sub_pixel_variance8x16_ssse3,
432 &aom_highbd_10_masked_sub_pixel_variance8x16_c, AOM_BITS_10),
433 make_tuple(&aom_highbd_10_masked_sub_pixel_variance8x8_ssse3,
434 &aom_highbd_10_masked_sub_pixel_variance8x8_c, AOM_BITS_10),
435 make_tuple(&aom_highbd_10_masked_sub_pixel_variance8x4_ssse3,
436 &aom_highbd_10_masked_sub_pixel_variance8x4_c, AOM_BITS_10),
437 make_tuple(&aom_highbd_10_masked_sub_pixel_variance4x8_ssse3,
438 &aom_highbd_10_masked_sub_pixel_variance4x8_c, AOM_BITS_10),
439 make_tuple(&aom_highbd_10_masked_sub_pixel_variance4x4_ssse3,
440 &aom_highbd_10_masked_sub_pixel_variance4x4_c, AOM_BITS_10),
441 make_tuple(&aom_highbd_12_masked_sub_pixel_variance128x128_ssse3,
442 &aom_highbd_12_masked_sub_pixel_variance128x128_c, AOM_BITS_12),
443 make_tuple(&aom_highbd_12_masked_sub_pixel_variance128x64_ssse3,
444 &aom_highbd_12_masked_sub_pixel_variance128x64_c, AOM_BITS_12),
445 make_tuple(&aom_highbd_12_masked_sub_pixel_variance64x128_ssse3,
446 &aom_highbd_12_masked_sub_pixel_variance64x128_c, AOM_BITS_12),
447 make_tuple(&aom_highbd_12_masked_sub_pixel_variance64x64_ssse3,
448 &aom_highbd_12_masked_sub_pixel_variance64x64_c, AOM_BITS_12),
449 make_tuple(&aom_highbd_12_masked_sub_pixel_variance64x32_ssse3,
450 &aom_highbd_12_masked_sub_pixel_variance64x32_c, AOM_BITS_12),
451 make_tuple(&aom_highbd_12_masked_sub_pixel_variance32x64_ssse3,
452 &aom_highbd_12_masked_sub_pixel_variance32x64_c, AOM_BITS_12),
453 make_tuple(&aom_highbd_12_masked_sub_pixel_variance32x32_ssse3,
454 &aom_highbd_12_masked_sub_pixel_variance32x32_c, AOM_BITS_12),
455 make_tuple(&aom_highbd_12_masked_sub_pixel_variance32x16_ssse3,
456 &aom_highbd_12_masked_sub_pixel_variance32x16_c, AOM_BITS_12),
457 make_tuple(&aom_highbd_12_masked_sub_pixel_variance16x32_ssse3,
458 &aom_highbd_12_masked_sub_pixel_variance16x32_c, AOM_BITS_12),
459 make_tuple(&aom_highbd_12_masked_sub_pixel_variance16x16_ssse3,
460 &aom_highbd_12_masked_sub_pixel_variance16x16_c, AOM_BITS_12),
461 make_tuple(&aom_highbd_12_masked_sub_pixel_variance16x8_ssse3,
462 &aom_highbd_12_masked_sub_pixel_variance16x8_c, AOM_BITS_12),
463 make_tuple(&aom_highbd_12_masked_sub_pixel_variance8x16_ssse3,
464 &aom_highbd_12_masked_sub_pixel_variance8x16_c, AOM_BITS_12),
465 make_tuple(&aom_highbd_12_masked_sub_pixel_variance8x8_ssse3,
466 &aom_highbd_12_masked_sub_pixel_variance8x8_c, AOM_BITS_12),
467 make_tuple(&aom_highbd_12_masked_sub_pixel_variance8x4_ssse3,
468 &aom_highbd_12_masked_sub_pixel_variance8x4_c, AOM_BITS_12),
469 make_tuple(&aom_highbd_12_masked_sub_pixel_variance4x8_ssse3,
470 &aom_highbd_12_masked_sub_pixel_variance4x8_c, AOM_BITS_12),
471 make_tuple(&aom_highbd_12_masked_sub_pixel_variance4x4_ssse3,
472 &aom_highbd_12_masked_sub_pixel_variance4x4_c, AOM_BITS_12),
473 #if !CONFIG_REALTIME_ONLY
474 make_tuple(&aom_highbd_8_masked_sub_pixel_variance64x16_ssse3,
475 &aom_highbd_8_masked_sub_pixel_variance64x16_c, AOM_BITS_8),
476 make_tuple(&aom_highbd_8_masked_sub_pixel_variance16x64_ssse3,
477 &aom_highbd_8_masked_sub_pixel_variance16x64_c, AOM_BITS_8),
478 make_tuple(&aom_highbd_8_masked_sub_pixel_variance32x8_ssse3,
479 &aom_highbd_8_masked_sub_pixel_variance32x8_c, AOM_BITS_8),
480 make_tuple(&aom_highbd_8_masked_sub_pixel_variance8x32_ssse3,
481 &aom_highbd_8_masked_sub_pixel_variance8x32_c, AOM_BITS_8),
482 make_tuple(&aom_highbd_8_masked_sub_pixel_variance16x4_ssse3,
483 &aom_highbd_8_masked_sub_pixel_variance16x4_c, AOM_BITS_8),
484 make_tuple(&aom_highbd_8_masked_sub_pixel_variance4x16_ssse3,
485 &aom_highbd_8_masked_sub_pixel_variance4x16_c, AOM_BITS_8),
486 make_tuple(&aom_highbd_10_masked_sub_pixel_variance64x16_ssse3,
487 &aom_highbd_10_masked_sub_pixel_variance64x16_c, AOM_BITS_10),
488 make_tuple(&aom_highbd_10_masked_sub_pixel_variance16x64_ssse3,
489 &aom_highbd_10_masked_sub_pixel_variance16x64_c, AOM_BITS_10),
490 make_tuple(&aom_highbd_10_masked_sub_pixel_variance32x8_ssse3,
491 &aom_highbd_10_masked_sub_pixel_variance32x8_c, AOM_BITS_10),
492 make_tuple(&aom_highbd_10_masked_sub_pixel_variance8x32_ssse3,
493 &aom_highbd_10_masked_sub_pixel_variance8x32_c, AOM_BITS_10),
494 make_tuple(&aom_highbd_10_masked_sub_pixel_variance16x4_ssse3,
495 &aom_highbd_10_masked_sub_pixel_variance16x4_c, AOM_BITS_10),
496 make_tuple(&aom_highbd_10_masked_sub_pixel_variance4x16_ssse3,
497 &aom_highbd_10_masked_sub_pixel_variance4x16_c, AOM_BITS_10),
498 make_tuple(&aom_highbd_12_masked_sub_pixel_variance64x16_ssse3,
499 &aom_highbd_12_masked_sub_pixel_variance64x16_c, AOM_BITS_12),
500 make_tuple(&aom_highbd_12_masked_sub_pixel_variance16x64_ssse3,
501 &aom_highbd_12_masked_sub_pixel_variance16x64_c, AOM_BITS_12),
502 make_tuple(&aom_highbd_12_masked_sub_pixel_variance32x8_ssse3,
503 &aom_highbd_12_masked_sub_pixel_variance32x8_c, AOM_BITS_12),
504 make_tuple(&aom_highbd_12_masked_sub_pixel_variance8x32_ssse3,
505 &aom_highbd_12_masked_sub_pixel_variance8x32_c, AOM_BITS_12),
506 make_tuple(&aom_highbd_12_masked_sub_pixel_variance16x4_ssse3,
507 &aom_highbd_12_masked_sub_pixel_variance16x4_c, AOM_BITS_12),
508 make_tuple(&aom_highbd_12_masked_sub_pixel_variance4x16_ssse3,
509 &aom_highbd_12_masked_sub_pixel_variance4x16_c, AOM_BITS_12),
510 #endif
511 };
512
513 INSTANTIATE_TEST_SUITE_P(SSSE3_C_COMPARE, HighbdMaskedSubPixelVarianceTest,
514 ::testing::ValuesIn(hbd_sub_pel_var_test));
515 #endif // CONFIG_AV1_HIGHBITDEPTH
516 #endif // HAVE_SSSE3
517 } // namespace
518