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 "third_party/googletest/src/googletest/include/gtest/gtest.h"
13 #include "test/acm_random.h"
14 
15 #include "test/function_equivalence_test.h"
16 #include "test/register_state_check.h"
17 
18 #include "config/aom_config.h"
19 #include "config/aom_dsp_rtcd.h"
20 
21 #include "aom/aom_integer.h"
22 
23 #define MAX_SB_SQUARE (MAX_SB_SIZE * MAX_SB_SIZE)
24 
25 using libaom_test::ACMRandom;
26 using libaom_test::FunctionEquivalenceTest;
27 
28 namespace {
29 
30 static const int kIterations = 1000;
31 static const int kMaskMax = 64;
32 
33 typedef unsigned int (*ObmcVarF)(const uint8_t *pre, int pre_stride,
34                                  const int32_t *wsrc, const int32_t *mask,
35                                  unsigned int *sse);
36 typedef libaom_test::FuncParam<ObmcVarF> TestFuncs;
37 
38 ////////////////////////////////////////////////////////////////////////////////
39 // 8 bit
40 ////////////////////////////////////////////////////////////////////////////////
41 
42 class ObmcVarianceTest : public FunctionEquivalenceTest<ObmcVarF> {};
43 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(ObmcVarianceTest);
44 
TEST_P(ObmcVarianceTest,RandomValues)45 TEST_P(ObmcVarianceTest, RandomValues) {
46   DECLARE_ALIGNED(32, uint8_t, pre[MAX_SB_SQUARE]);
47   DECLARE_ALIGNED(32, int32_t, wsrc[MAX_SB_SQUARE]);
48   DECLARE_ALIGNED(32, int32_t, mask[MAX_SB_SQUARE]);
49 
50   for (int iter = 0; iter < kIterations && !HasFatalFailure(); ++iter) {
51     const int pre_stride = this->rng_(MAX_SB_SIZE + 1);
52 
53     for (int i = 0; i < MAX_SB_SQUARE; ++i) {
54       pre[i] = this->rng_.Rand8();
55       wsrc[i] = this->rng_.Rand8() * this->rng_(kMaskMax * kMaskMax + 1);
56       mask[i] = this->rng_(kMaskMax * kMaskMax + 1);
57     }
58 
59     unsigned int ref_sse, tst_sse;
60     const unsigned int ref_res =
61         params_.ref_func(pre, pre_stride, wsrc, mask, &ref_sse);
62     unsigned int tst_res;
63     API_REGISTER_STATE_CHECK(
64         tst_res = params_.tst_func(pre, pre_stride, wsrc, mask, &tst_sse));
65 
66     ASSERT_EQ(ref_res, tst_res);
67     ASSERT_EQ(ref_sse, tst_sse);
68   }
69 }
70 
TEST_P(ObmcVarianceTest,ExtremeValues)71 TEST_P(ObmcVarianceTest, ExtremeValues) {
72   DECLARE_ALIGNED(32, uint8_t, pre[MAX_SB_SQUARE]);
73   DECLARE_ALIGNED(32, int32_t, wsrc[MAX_SB_SQUARE]);
74   DECLARE_ALIGNED(32, int32_t, mask[MAX_SB_SQUARE]);
75 
76   for (int iter = 0; iter < MAX_SB_SIZE && !HasFatalFailure(); ++iter) {
77     const int pre_stride = iter;
78 
79     for (int i = 0; i < MAX_SB_SQUARE; ++i) {
80       pre[i] = UINT8_MAX;
81       wsrc[i] = UINT8_MAX * kMaskMax * kMaskMax;
82       mask[i] = kMaskMax * kMaskMax;
83     }
84 
85     unsigned int ref_sse, tst_sse;
86     const unsigned int ref_res =
87         params_.ref_func(pre, pre_stride, wsrc, mask, &ref_sse);
88     unsigned int tst_res;
89     API_REGISTER_STATE_CHECK(
90         tst_res = params_.tst_func(pre, pre_stride, wsrc, mask, &tst_sse));
91 
92     ASSERT_EQ(ref_res, tst_res);
93     ASSERT_EQ(ref_sse, tst_sse);
94   }
95 }
96 
TEST_P(ObmcVarianceTest,DISABLED_Speed)97 TEST_P(ObmcVarianceTest, DISABLED_Speed) {
98   DECLARE_ALIGNED(32, uint8_t, pre[MAX_SB_SQUARE]);
99   DECLARE_ALIGNED(32, int32_t, wsrc[MAX_SB_SQUARE]);
100   DECLARE_ALIGNED(32, int32_t, mask[MAX_SB_SQUARE]);
101 
102   const int pre_stride = this->rng_(MAX_SB_SIZE + 1);
103 
104   for (int i = 0; i < MAX_SB_SQUARE; ++i) {
105     pre[i] = this->rng_.Rand8();
106     wsrc[i] = this->rng_.Rand8() * this->rng_(kMaskMax * kMaskMax + 1);
107     mask[i] = this->rng_(kMaskMax * kMaskMax + 1);
108   }
109 
110   const int num_loops = 1000000;
111   unsigned int ref_sse, tst_sse;
112   aom_usec_timer ref_timer, test_timer;
113 
114   aom_usec_timer_start(&ref_timer);
115   for (int i = 0; i < num_loops; ++i) {
116     params_.ref_func(pre, pre_stride, wsrc, mask, &ref_sse);
117   }
118   aom_usec_timer_mark(&ref_timer);
119   const int elapsed_time_c =
120       static_cast<int>(aom_usec_timer_elapsed(&ref_timer));
121 
122   aom_usec_timer_start(&test_timer);
123   for (int i = 0; i < num_loops; ++i) {
124     params_.tst_func(pre, pre_stride, wsrc, mask, &tst_sse);
125   }
126   aom_usec_timer_mark(&test_timer);
127   const int elapsed_time_simd =
128       static_cast<int>(aom_usec_timer_elapsed(&test_timer));
129 
130   printf("c_time=%d \t simd_time=%d \t gain=%d \n", elapsed_time_c,
131          elapsed_time_simd, (elapsed_time_c / elapsed_time_simd));
132 }
133 
134 #if HAVE_SSE4_1
135 const ObmcVarianceTest::ParamType sse4_functions[] = {
136   TestFuncs(aom_obmc_variance128x128_c, aom_obmc_variance128x128_sse4_1),
137   TestFuncs(aom_obmc_variance128x64_c, aom_obmc_variance128x64_sse4_1),
138   TestFuncs(aom_obmc_variance64x128_c, aom_obmc_variance64x128_sse4_1),
139   TestFuncs(aom_obmc_variance64x64_c, aom_obmc_variance64x64_sse4_1),
140   TestFuncs(aom_obmc_variance64x32_c, aom_obmc_variance64x32_sse4_1),
141   TestFuncs(aom_obmc_variance32x64_c, aom_obmc_variance32x64_sse4_1),
142   TestFuncs(aom_obmc_variance32x32_c, aom_obmc_variance32x32_sse4_1),
143   TestFuncs(aom_obmc_variance32x16_c, aom_obmc_variance32x16_sse4_1),
144   TestFuncs(aom_obmc_variance16x32_c, aom_obmc_variance16x32_sse4_1),
145   TestFuncs(aom_obmc_variance16x16_c, aom_obmc_variance16x16_sse4_1),
146   TestFuncs(aom_obmc_variance16x8_c, aom_obmc_variance16x8_sse4_1),
147   TestFuncs(aom_obmc_variance8x16_c, aom_obmc_variance8x16_sse4_1),
148   TestFuncs(aom_obmc_variance8x8_c, aom_obmc_variance8x8_sse4_1),
149   TestFuncs(aom_obmc_variance8x4_c, aom_obmc_variance8x4_sse4_1),
150   TestFuncs(aom_obmc_variance4x8_c, aom_obmc_variance4x8_sse4_1),
151   TestFuncs(aom_obmc_variance4x4_c, aom_obmc_variance4x4_sse4_1),
152 
153   TestFuncs(aom_obmc_variance64x16_c, aom_obmc_variance64x16_sse4_1),
154   TestFuncs(aom_obmc_variance16x64_c, aom_obmc_variance16x64_sse4_1),
155   TestFuncs(aom_obmc_variance32x8_c, aom_obmc_variance32x8_sse4_1),
156   TestFuncs(aom_obmc_variance8x32_c, aom_obmc_variance8x32_sse4_1),
157   TestFuncs(aom_obmc_variance16x4_c, aom_obmc_variance16x4_sse4_1),
158   TestFuncs(aom_obmc_variance4x16_c, aom_obmc_variance4x16_sse4_1),
159 };
160 
161 INSTANTIATE_TEST_SUITE_P(SSE4_1, ObmcVarianceTest,
162                          ::testing::ValuesIn(sse4_functions));
163 #endif  // HAVE_SSE4_1
164 
165 #if HAVE_AVX2
166 const ObmcVarianceTest::ParamType avx2_functions[] = {
167   TestFuncs(aom_obmc_variance128x128_c, aom_obmc_variance128x128_avx2),
168   TestFuncs(aom_obmc_variance128x64_c, aom_obmc_variance128x64_avx2),
169   TestFuncs(aom_obmc_variance64x128_c, aom_obmc_variance64x128_avx2),
170   TestFuncs(aom_obmc_variance64x64_c, aom_obmc_variance64x64_avx2),
171   TestFuncs(aom_obmc_variance64x32_c, aom_obmc_variance64x32_avx2),
172   TestFuncs(aom_obmc_variance32x64_c, aom_obmc_variance32x64_avx2),
173   TestFuncs(aom_obmc_variance32x32_c, aom_obmc_variance32x32_avx2),
174   TestFuncs(aom_obmc_variance32x16_c, aom_obmc_variance32x16_avx2),
175   TestFuncs(aom_obmc_variance16x32_c, aom_obmc_variance16x32_avx2),
176   TestFuncs(aom_obmc_variance16x16_c, aom_obmc_variance16x16_avx2),
177   TestFuncs(aom_obmc_variance16x8_c, aom_obmc_variance16x8_avx2),
178   TestFuncs(aom_obmc_variance8x16_c, aom_obmc_variance8x16_avx2),
179   TestFuncs(aom_obmc_variance8x8_c, aom_obmc_variance8x8_avx2),
180   TestFuncs(aom_obmc_variance8x4_c, aom_obmc_variance8x4_avx2),
181   TestFuncs(aom_obmc_variance4x8_c, aom_obmc_variance4x8_avx2),
182   TestFuncs(aom_obmc_variance4x4_c, aom_obmc_variance4x4_avx2),
183 
184   TestFuncs(aom_obmc_variance64x16_c, aom_obmc_variance64x16_avx2),
185   TestFuncs(aom_obmc_variance16x64_c, aom_obmc_variance16x64_avx2),
186   TestFuncs(aom_obmc_variance32x8_c, aom_obmc_variance32x8_avx2),
187   TestFuncs(aom_obmc_variance8x32_c, aom_obmc_variance8x32_avx2),
188   TestFuncs(aom_obmc_variance16x4_c, aom_obmc_variance16x4_avx2),
189   TestFuncs(aom_obmc_variance4x16_c, aom_obmc_variance4x16_avx2),
190 };
191 
192 INSTANTIATE_TEST_SUITE_P(AVX2, ObmcVarianceTest,
193                          ::testing::ValuesIn(avx2_functions));
194 #endif  // HAVE_AVX2
195 
196 ////////////////////////////////////////////////////////////////////////////////
197 // High bit-depth
198 ////////////////////////////////////////////////////////////////////////////////
199 #if CONFIG_AV1_HIGHBITDEPTH
200 class ObmcVarianceHBDTest : public FunctionEquivalenceTest<ObmcVarF> {};
201 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(ObmcVarianceHBDTest);
202 
TEST_P(ObmcVarianceHBDTest,RandomValues)203 TEST_P(ObmcVarianceHBDTest, RandomValues) {
204   DECLARE_ALIGNED(32, uint16_t, pre[MAX_SB_SQUARE]);
205   DECLARE_ALIGNED(32, int32_t, wsrc[MAX_SB_SQUARE]);
206   DECLARE_ALIGNED(32, int32_t, mask[MAX_SB_SQUARE]);
207 
208   for (int iter = 0; iter < kIterations && !HasFatalFailure(); ++iter) {
209     const int pre_stride = this->rng_(MAX_SB_SIZE + 1);
210 
211     for (int i = 0; i < MAX_SB_SQUARE; ++i) {
212       pre[i] = this->rng_(1 << params_.bit_depth);
213       wsrc[i] = this->rng_(1 << params_.bit_depth) *
214                 this->rng_(kMaskMax * kMaskMax + 1);
215       mask[i] = this->rng_(kMaskMax * kMaskMax + 1);
216     }
217 
218     unsigned int ref_sse, tst_sse;
219     const unsigned int ref_res = params_.ref_func(
220         CONVERT_TO_BYTEPTR(pre), pre_stride, wsrc, mask, &ref_sse);
221     unsigned int tst_res;
222     API_REGISTER_STATE_CHECK(tst_res = params_.tst_func(CONVERT_TO_BYTEPTR(pre),
223                                                         pre_stride, wsrc, mask,
224                                                         &tst_sse));
225 
226     ASSERT_EQ(ref_res, tst_res);
227     ASSERT_EQ(ref_sse, tst_sse);
228   }
229 }
230 
TEST_P(ObmcVarianceHBDTest,ExtremeValues)231 TEST_P(ObmcVarianceHBDTest, ExtremeValues) {
232   DECLARE_ALIGNED(32, uint16_t, pre[MAX_SB_SQUARE]);
233   DECLARE_ALIGNED(32, int32_t, wsrc[MAX_SB_SQUARE]);
234   DECLARE_ALIGNED(32, int32_t, mask[MAX_SB_SQUARE]);
235 
236   for (int iter = 0; iter < MAX_SB_SIZE && !HasFatalFailure(); ++iter) {
237     const int pre_stride = iter;
238 
239     for (int i = 0; i < MAX_SB_SQUARE; ++i) {
240       pre[i] = (1 << params_.bit_depth) - 1;
241       wsrc[i] = ((1 << params_.bit_depth) - 1) * kMaskMax * kMaskMax;
242       mask[i] = kMaskMax * kMaskMax;
243     }
244 
245     unsigned int ref_sse, tst_sse;
246     const unsigned int ref_res = params_.ref_func(
247         CONVERT_TO_BYTEPTR(pre), pre_stride, wsrc, mask, &ref_sse);
248     unsigned int tst_res;
249     API_REGISTER_STATE_CHECK(tst_res = params_.tst_func(CONVERT_TO_BYTEPTR(pre),
250                                                         pre_stride, wsrc, mask,
251                                                         &tst_sse));
252 
253     ASSERT_EQ(ref_res, tst_res);
254     ASSERT_EQ(ref_sse, tst_sse);
255   }
256 }
257 
258 #if HAVE_SSE4_1
259 ObmcVarianceHBDTest::ParamType sse4_functions_hbd[] = {
260   TestFuncs(aom_highbd_obmc_variance128x128_c,
261             aom_highbd_obmc_variance128x128_sse4_1, 8),
262   TestFuncs(aom_highbd_obmc_variance128x64_c,
263             aom_highbd_obmc_variance128x64_sse4_1, 8),
264   TestFuncs(aom_highbd_obmc_variance64x128_c,
265             aom_highbd_obmc_variance64x128_sse4_1, 8),
266   TestFuncs(aom_highbd_obmc_variance64x64_c,
267             aom_highbd_obmc_variance64x64_sse4_1, 8),
268   TestFuncs(aom_highbd_obmc_variance64x32_c,
269             aom_highbd_obmc_variance64x32_sse4_1, 8),
270   TestFuncs(aom_highbd_obmc_variance32x64_c,
271             aom_highbd_obmc_variance32x64_sse4_1, 8),
272   TestFuncs(aom_highbd_obmc_variance32x32_c,
273             aom_highbd_obmc_variance32x32_sse4_1, 8),
274   TestFuncs(aom_highbd_obmc_variance32x16_c,
275             aom_highbd_obmc_variance32x16_sse4_1, 8),
276   TestFuncs(aom_highbd_obmc_variance16x32_c,
277             aom_highbd_obmc_variance16x32_sse4_1, 8),
278   TestFuncs(aom_highbd_obmc_variance16x16_c,
279             aom_highbd_obmc_variance16x16_sse4_1, 8),
280   TestFuncs(aom_highbd_obmc_variance16x8_c, aom_highbd_obmc_variance16x8_sse4_1,
281             8),
282   TestFuncs(aom_highbd_obmc_variance8x16_c, aom_highbd_obmc_variance8x16_sse4_1,
283             8),
284   TestFuncs(aom_highbd_obmc_variance8x8_c, aom_highbd_obmc_variance8x8_sse4_1,
285             8),
286   TestFuncs(aom_highbd_obmc_variance8x4_c, aom_highbd_obmc_variance8x4_sse4_1,
287             8),
288   TestFuncs(aom_highbd_obmc_variance4x8_c, aom_highbd_obmc_variance4x8_sse4_1,
289             8),
290   TestFuncs(aom_highbd_obmc_variance4x4_c, aom_highbd_obmc_variance4x4_sse4_1,
291             8),
292   TestFuncs(aom_highbd_10_obmc_variance128x128_c,
293             aom_highbd_10_obmc_variance128x128_sse4_1, 10),
294   TestFuncs(aom_highbd_10_obmc_variance128x64_c,
295             aom_highbd_10_obmc_variance128x64_sse4_1, 10),
296   TestFuncs(aom_highbd_10_obmc_variance64x128_c,
297             aom_highbd_10_obmc_variance64x128_sse4_1, 10),
298   TestFuncs(aom_highbd_10_obmc_variance64x64_c,
299             aom_highbd_10_obmc_variance64x64_sse4_1, 10),
300   TestFuncs(aom_highbd_10_obmc_variance64x32_c,
301             aom_highbd_10_obmc_variance64x32_sse4_1, 10),
302   TestFuncs(aom_highbd_10_obmc_variance32x64_c,
303             aom_highbd_10_obmc_variance32x64_sse4_1, 10),
304   TestFuncs(aom_highbd_10_obmc_variance32x32_c,
305             aom_highbd_10_obmc_variance32x32_sse4_1, 10),
306   TestFuncs(aom_highbd_10_obmc_variance32x16_c,
307             aom_highbd_10_obmc_variance32x16_sse4_1, 10),
308   TestFuncs(aom_highbd_10_obmc_variance16x32_c,
309             aom_highbd_10_obmc_variance16x32_sse4_1, 10),
310   TestFuncs(aom_highbd_10_obmc_variance16x16_c,
311             aom_highbd_10_obmc_variance16x16_sse4_1, 10),
312   TestFuncs(aom_highbd_10_obmc_variance16x8_c,
313             aom_highbd_10_obmc_variance16x8_sse4_1, 10),
314   TestFuncs(aom_highbd_10_obmc_variance8x16_c,
315             aom_highbd_10_obmc_variance8x16_sse4_1, 10),
316   TestFuncs(aom_highbd_10_obmc_variance8x8_c,
317             aom_highbd_10_obmc_variance8x8_sse4_1, 10),
318   TestFuncs(aom_highbd_10_obmc_variance8x4_c,
319             aom_highbd_10_obmc_variance8x4_sse4_1, 10),
320   TestFuncs(aom_highbd_10_obmc_variance4x8_c,
321             aom_highbd_10_obmc_variance4x8_sse4_1, 10),
322   TestFuncs(aom_highbd_10_obmc_variance4x4_c,
323             aom_highbd_10_obmc_variance4x4_sse4_1, 10),
324   TestFuncs(aom_highbd_12_obmc_variance128x128_c,
325             aom_highbd_12_obmc_variance128x128_sse4_1, 12),
326   TestFuncs(aom_highbd_12_obmc_variance128x64_c,
327             aom_highbd_12_obmc_variance128x64_sse4_1, 12),
328   TestFuncs(aom_highbd_12_obmc_variance64x128_c,
329             aom_highbd_12_obmc_variance64x128_sse4_1, 12),
330   TestFuncs(aom_highbd_12_obmc_variance64x64_c,
331             aom_highbd_12_obmc_variance64x64_sse4_1, 12),
332   TestFuncs(aom_highbd_12_obmc_variance64x32_c,
333             aom_highbd_12_obmc_variance64x32_sse4_1, 12),
334   TestFuncs(aom_highbd_12_obmc_variance32x64_c,
335             aom_highbd_12_obmc_variance32x64_sse4_1, 12),
336   TestFuncs(aom_highbd_12_obmc_variance32x32_c,
337             aom_highbd_12_obmc_variance32x32_sse4_1, 12),
338   TestFuncs(aom_highbd_12_obmc_variance32x16_c,
339             aom_highbd_12_obmc_variance32x16_sse4_1, 12),
340   TestFuncs(aom_highbd_12_obmc_variance16x32_c,
341             aom_highbd_12_obmc_variance16x32_sse4_1, 12),
342   TestFuncs(aom_highbd_12_obmc_variance16x16_c,
343             aom_highbd_12_obmc_variance16x16_sse4_1, 12),
344   TestFuncs(aom_highbd_12_obmc_variance16x8_c,
345             aom_highbd_12_obmc_variance16x8_sse4_1, 12),
346   TestFuncs(aom_highbd_12_obmc_variance8x16_c,
347             aom_highbd_12_obmc_variance8x16_sse4_1, 12),
348   TestFuncs(aom_highbd_12_obmc_variance8x8_c,
349             aom_highbd_12_obmc_variance8x8_sse4_1, 12),
350   TestFuncs(aom_highbd_12_obmc_variance8x4_c,
351             aom_highbd_12_obmc_variance8x4_sse4_1, 12),
352   TestFuncs(aom_highbd_12_obmc_variance4x8_c,
353             aom_highbd_12_obmc_variance4x8_sse4_1, 12),
354   TestFuncs(aom_highbd_12_obmc_variance4x4_c,
355             aom_highbd_12_obmc_variance4x4_sse4_1, 12),
356 
357   TestFuncs(aom_highbd_obmc_variance64x16_c,
358             aom_highbd_obmc_variance64x16_sse4_1, 8),
359   TestFuncs(aom_highbd_obmc_variance16x64_c,
360             aom_highbd_obmc_variance16x64_sse4_1, 8),
361   TestFuncs(aom_highbd_obmc_variance32x8_c, aom_highbd_obmc_variance32x8_sse4_1,
362             8),
363   TestFuncs(aom_highbd_obmc_variance8x32_c, aom_highbd_obmc_variance8x32_sse4_1,
364             8),
365   TestFuncs(aom_highbd_obmc_variance16x4_c, aom_highbd_obmc_variance16x4_sse4_1,
366             8),
367   TestFuncs(aom_highbd_obmc_variance4x16_c, aom_highbd_obmc_variance4x16_sse4_1,
368             8),
369   TestFuncs(aom_highbd_10_obmc_variance64x16_c,
370             aom_highbd_10_obmc_variance64x16_sse4_1, 10),
371   TestFuncs(aom_highbd_10_obmc_variance16x64_c,
372             aom_highbd_10_obmc_variance16x64_sse4_1, 10),
373   TestFuncs(aom_highbd_10_obmc_variance32x8_c,
374             aom_highbd_10_obmc_variance32x8_sse4_1, 10),
375   TestFuncs(aom_highbd_10_obmc_variance8x32_c,
376             aom_highbd_10_obmc_variance8x32_sse4_1, 10),
377   TestFuncs(aom_highbd_10_obmc_variance16x4_c,
378             aom_highbd_10_obmc_variance16x4_sse4_1, 10),
379   TestFuncs(aom_highbd_10_obmc_variance4x16_c,
380             aom_highbd_10_obmc_variance4x16_sse4_1, 10),
381   TestFuncs(aom_highbd_12_obmc_variance64x16_c,
382             aom_highbd_12_obmc_variance64x16_sse4_1, 12),
383   TestFuncs(aom_highbd_12_obmc_variance16x64_c,
384             aom_highbd_12_obmc_variance16x64_sse4_1, 12),
385   TestFuncs(aom_highbd_12_obmc_variance32x8_c,
386             aom_highbd_12_obmc_variance32x8_sse4_1, 12),
387   TestFuncs(aom_highbd_12_obmc_variance8x32_c,
388             aom_highbd_12_obmc_variance8x32_sse4_1, 12),
389   TestFuncs(aom_highbd_12_obmc_variance16x4_c,
390             aom_highbd_12_obmc_variance16x4_sse4_1, 12),
391   TestFuncs(aom_highbd_12_obmc_variance4x16_c,
392             aom_highbd_12_obmc_variance4x16_sse4_1, 12),
393 };
394 
395 INSTANTIATE_TEST_SUITE_P(SSE4_1, ObmcVarianceHBDTest,
396                          ::testing::ValuesIn(sse4_functions_hbd));
397 #endif  // HAVE_SSE4_1
398 #endif  // CONFIG_AV1_HIGHBITDEPTH
399 }  // namespace
400