sad_test.cc 16.6 KB
Newer Older
Johann's avatar
Johann committed
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/*
 *  Copyright (c) 2012 The WebM project authors. All Rights Reserved.
 *
 *  Use of this source code is governed by a BSD-style license
 *  that can be found in the LICENSE file in the root of the source
 *  tree. An additional intellectual property rights grant can be found
 *  in the file PATENTS.  All contributing project authors may
 *  be found in the AUTHORS file in the root of the source tree.
 */


#include <string.h>
#include <limits.h>
#include <stdio.h>

extern "C" {
#include "./vpx_config.h"
18
#if CONFIG_VP8_ENCODER
19
#include "./vp8_rtcd.h"
20
21
22
23
24
//#include "vp8/common/blockd.h"
#endif
#if CONFIG_VP9_ENCODER
#include "./vp9_rtcd.h"
#endif
25
#include "vpx_mem/vpx_mem.h"
Johann's avatar
Johann committed
26
27
28
}

#include "test/acm_random.h"
29
#include "test/register_state_check.h"
Johann's avatar
Johann committed
30
31
32
33
34
35
36
37
#include "test/util.h"
#include "third_party/googletest/src/include/gtest/gtest.h"


typedef unsigned int (*sad_m_by_n_fn_t)(const unsigned char *source_ptr,
                                        int source_stride,
                                        const unsigned char *reference_ptr,
                                        int reference_stride,
Johann's avatar
Johann committed
38
                                        unsigned int max_sad);
James Zern's avatar
James Zern committed
39
typedef std::tr1::tuple<int, int, sad_m_by_n_fn_t> sad_m_by_n_test_param_t;
Johann's avatar
Johann committed
40

41
42
43
44
45
typedef void (*sad_n_by_n_by_4_fn_t)(const uint8_t *src_ptr,
                                     int src_stride,
                                     const unsigned char * const ref_ptr[],
                                     int ref_stride,
                                     unsigned int *sad_array);
James Zern's avatar
James Zern committed
46
47
typedef std::tr1::tuple<int, int, sad_n_by_n_by_4_fn_t>
        sad_n_by_n_by_4_test_param_t;
48

Johann's avatar
Johann committed
49
50
51
using libvpx_test::ACMRandom;

namespace {
52
class SADTestBase : public ::testing::Test {
53
 public:
54
55
  SADTestBase(int width, int height) : width_(width), height_(height) {}

56
57
  static void SetUpTestCase() {
    source_data_ = reinterpret_cast<uint8_t*>(
58
        vpx_memalign(kDataAlignment, kDataBlockSize));
59
60
61
62
63
64
65
66
67
68
69
70
    reference_data_ = reinterpret_cast<uint8_t*>(
        vpx_memalign(kDataAlignment, kDataBufferSize));
  }

  static void TearDownTestCase() {
    vpx_free(source_data_);
    source_data_ = NULL;
    vpx_free(reference_data_);
    reference_data_ = NULL;
  }

 protected:
71
  // Handle blocks up to 4 blocks 64x64 with stride up to 128
72
  static const int kDataAlignment = 16;
73
74
  static const int kDataBlockSize = 64 * 128;
  static const int kDataBufferSize = 4 * kDataBlockSize;
75

Johann's avatar
Johann committed
76
  virtual void SetUp() {
77
    source_stride_ = (width_ + 31) & ~31;
Johann's avatar
Johann committed
78
79
80
81
    reference_stride_ = width_ * 2;
    rnd_.Reset(ACMRandom::DeterministicSeed());
  }

82
83
  virtual uint8_t* GetReference(int block_idx) {
    return reference_data_ + block_idx * kDataBlockSize;
Johann's avatar
Johann committed
84
85
86
87
  }

  // Sum of Absolute Differences. Given two blocks, calculate the absolute
  // difference between two pixels in the same relative location; accumulate.
88
  unsigned int ReferenceSAD(unsigned int max_sad, int block_idx = 0) {
Johann's avatar
Johann committed
89
    unsigned int sad = 0;
90
    const uint8_t* const reference = GetReference(block_idx);
Johann's avatar
Johann committed
91
92
93
94

    for (int h = 0; h < height_; ++h) {
      for (int w = 0; w < width_; ++w) {
        sad += abs(source_data_[h * source_stride_ + w]
95
               - reference[h * reference_stride_ + w]);
Johann's avatar
Johann committed
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
      }
      if (sad > max_sad) {
        break;
      }
    }
    return sad;
  }

  void FillConstant(uint8_t *data, int stride, uint8_t fill_constant) {
    for (int h = 0; h < height_; ++h) {
      for (int w = 0; w < width_; ++w) {
        data[h * stride + w] = fill_constant;
      }
    }
  }

  void FillRandom(uint8_t *data, int stride) {
    for (int h = 0; h < height_; ++h) {
      for (int w = 0; w < width_; ++w) {
        data[h * stride + w] = rnd_.Rand8();
      }
    }
  }

120
121
122
123
124
125
126
127
128
129
  int width_, height_;
  static uint8_t* source_data_;
  int source_stride_;
  static uint8_t* reference_data_;
  int reference_stride_;

  ACMRandom rnd_;
};

class SADTest : public SADTestBase,
James Zern's avatar
James Zern committed
130
    public ::testing::WithParamInterface<sad_m_by_n_test_param_t> {
131
132
133
134
135
136
137
138
139
140
141
142
143
144
 public:
  SADTest() : SADTestBase(GET_PARAM(0), GET_PARAM(1)) {}

 protected:
  unsigned int SAD(unsigned int max_sad, int block_idx = 0) {
    unsigned int ret;
    const uint8_t* const reference = GetReference(block_idx);

    REGISTER_STATE_CHECK(ret = GET_PARAM(2)(source_data_, source_stride_,
                                            reference, reference_stride_,
                                            max_sad));
    return ret;
  }

Johann's avatar
Johann committed
145
146
147
148
149
150
151
152
153
154
155
156
157
  void CheckSad(unsigned int max_sad) {
    unsigned int reference_sad, exp_sad;

    reference_sad = ReferenceSAD(max_sad);
    exp_sad = SAD(max_sad);

    if (reference_sad <= max_sad) {
      ASSERT_EQ(exp_sad, reference_sad);
    } else {
      // Alternative implementations are not required to check max_sad
      ASSERT_GE(exp_sad, reference_sad);
    }
  }
158
};
Johann's avatar
Johann committed
159

160
class SADx4Test : public SADTestBase,
James Zern's avatar
James Zern committed
161
    public ::testing::WithParamInterface<sad_n_by_n_by_4_test_param_t> {
162
163
 public:
  SADx4Test() : SADTestBase(GET_PARAM(0), GET_PARAM(1)) {}
Johann's avatar
Johann committed
164

165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
 protected:
  void SADs(unsigned int *results) {
    const uint8_t* refs[] = {GetReference(0), GetReference(1),
                             GetReference(2), GetReference(3)};

    REGISTER_STATE_CHECK(GET_PARAM(2)(source_data_, source_stride_,
                                      refs, reference_stride_,
                                      results));
  }

  void CheckSADs() {
    unsigned int reference_sad, exp_sad[4];

    SADs(exp_sad);
    for (int block = 0; block < 4; block++) {
      reference_sad = ReferenceSAD(UINT_MAX, block);

      EXPECT_EQ(exp_sad[block], reference_sad) << "block " << block;
    }
  }
Johann's avatar
Johann committed
185
186
};

187
188
uint8_t* SADTestBase::source_data_ = NULL;
uint8_t* SADTestBase::reference_data_ = NULL;
189

Johann's avatar
Johann committed
190
191
192
TEST_P(SADTest, MaxRef) {
  FillConstant(source_data_, source_stride_, 0);
  FillConstant(reference_data_, reference_stride_, 255);
Johann's avatar
Johann committed
193
  CheckSad(UINT_MAX);
Johann's avatar
Johann committed
194
195
}

196
197
198
199
200
201
202
203
204
TEST_P(SADx4Test, MaxRef) {
  FillConstant(source_data_, source_stride_, 0);
  FillConstant(GetReference(0), reference_stride_, 255);
  FillConstant(GetReference(1), reference_stride_, 255);
  FillConstant(GetReference(2), reference_stride_, 255);
  FillConstant(GetReference(3), reference_stride_, 255);
  CheckSADs();
}

Johann's avatar
Johann committed
205
206
207
TEST_P(SADTest, MaxSrc) {
  FillConstant(source_data_, source_stride_, 255);
  FillConstant(reference_data_, reference_stride_, 0);
Johann's avatar
Johann committed
208
  CheckSad(UINT_MAX);
Johann's avatar
Johann committed
209
210
}

211
212
213
214
215
216
217
218
219
TEST_P(SADx4Test, MaxSrc) {
  FillConstant(source_data_, source_stride_, 255);
  FillConstant(GetReference(0), reference_stride_, 0);
  FillConstant(GetReference(1), reference_stride_, 0);
  FillConstant(GetReference(2), reference_stride_, 0);
  FillConstant(GetReference(3), reference_stride_, 0);
  CheckSADs();
}

Johann's avatar
Johann committed
220
221
222
223
224
TEST_P(SADTest, ShortRef) {
  int tmp_stride = reference_stride_;
  reference_stride_ >>= 1;
  FillRandom(source_data_, source_stride_);
  FillRandom(reference_data_, reference_stride_);
Johann's avatar
Johann committed
225
  CheckSad(UINT_MAX);
Johann's avatar
Johann committed
226
227
228
  reference_stride_ = tmp_stride;
}

229
230
231
232
233
234
235
236
237
238
239
240
TEST_P(SADx4Test, ShortRef) {
  int tmp_stride = reference_stride_;
  reference_stride_ >>= 1;
  FillRandom(source_data_, source_stride_);
  FillRandom(GetReference(0), reference_stride_);
  FillRandom(GetReference(1), reference_stride_);
  FillRandom(GetReference(2), reference_stride_);
  FillRandom(GetReference(3), reference_stride_);
  CheckSADs();
  reference_stride_ = tmp_stride;
}

Johann's avatar
Johann committed
241
242
243
244
245
246
247
TEST_P(SADTest, UnalignedRef) {
  // The reference frame, but not the source frame, may be unaligned for
  // certain types of searches.
  int tmp_stride = reference_stride_;
  reference_stride_ -= 1;
  FillRandom(source_data_, source_stride_);
  FillRandom(reference_data_, reference_stride_);
Johann's avatar
Johann committed
248
  CheckSad(UINT_MAX);
Johann's avatar
Johann committed
249
250
251
  reference_stride_ = tmp_stride;
}

252
253
254
255
256
257
258
259
260
261
262
263
264
265
TEST_P(SADx4Test, UnalignedRef) {
  // The reference frame, but not the source frame, may be unaligned for
  // certain types of searches.
  int tmp_stride = reference_stride_;
  reference_stride_ -= 1;
  FillRandom(source_data_, source_stride_);
  FillRandom(GetReference(0), reference_stride_);
  FillRandom(GetReference(1), reference_stride_);
  FillRandom(GetReference(2), reference_stride_);
  FillRandom(GetReference(3), reference_stride_);
  CheckSADs();
  reference_stride_ = tmp_stride;
}

Johann's avatar
Johann committed
266
267
268
269
270
TEST_P(SADTest, ShortSrc) {
  int tmp_stride = source_stride_;
  source_stride_ >>= 1;
  FillRandom(source_data_, source_stride_);
  FillRandom(reference_data_, reference_stride_);
Johann's avatar
Johann committed
271
  CheckSad(UINT_MAX);
Johann's avatar
Johann committed
272
273
274
  source_stride_ = tmp_stride;
}

275
276
277
278
279
280
281
282
283
284
285
286
TEST_P(SADx4Test, ShortSrc) {
  int tmp_stride = source_stride_;
  source_stride_ >>= 1;
  FillRandom(source_data_, source_stride_);
  FillRandom(GetReference(0), reference_stride_);
  FillRandom(GetReference(1), reference_stride_);
  FillRandom(GetReference(2), reference_stride_);
  FillRandom(GetReference(3), reference_stride_);
  CheckSADs();
  source_stride_ = tmp_stride;
}

Johann's avatar
Johann committed
287
288
289
290
291
292
293
294
TEST_P(SADTest, MaxSAD) {
  // Verify that, when max_sad is set, the implementation does not return a
  // value lower than the reference.
  FillConstant(source_data_, source_stride_, 255);
  FillConstant(reference_data_, reference_stride_, 0);
  CheckSad(128);
}

James Zern's avatar
James Zern committed
295
296
using std::tr1::make_tuple;

297
#if CONFIG_VP8_ENCODER
James Zern's avatar
James Zern committed
298
299
300
301
302
const sad_m_by_n_fn_t sad_16x16_c = vp8_sad16x16_c;
const sad_m_by_n_fn_t sad_8x16_c = vp8_sad8x16_c;
const sad_m_by_n_fn_t sad_16x8_c = vp8_sad16x8_c;
const sad_m_by_n_fn_t sad_8x8_c = vp8_sad8x8_c;
const sad_m_by_n_fn_t sad_4x4_c = vp8_sad4x4_c;
303
304
305
306
307
308
309
310
#endif
#if CONFIG_VP9_ENCODER
const sad_m_by_n_fn_t sad_64x64_c_vp9 = vp9_sad64x64_c;
const sad_m_by_n_fn_t sad_32x32_c_vp9 = vp9_sad32x32_c;
const sad_m_by_n_fn_t sad_16x16_c_vp9 = vp9_sad16x16_c;
const sad_m_by_n_fn_t sad_8x16_c_vp9 = vp9_sad8x16_c;
const sad_m_by_n_fn_t sad_16x8_c_vp9 = vp9_sad16x8_c;
const sad_m_by_n_fn_t sad_8x8_c_vp9 = vp9_sad8x8_c;
311
312
const sad_m_by_n_fn_t sad_8x4_c_vp9 = vp9_sad8x4_c;
const sad_m_by_n_fn_t sad_4x8_c_vp9 = vp9_sad4x8_c;
313
314
const sad_m_by_n_fn_t sad_4x4_c_vp9 = vp9_sad4x4_c;
#endif
James Zern's avatar
James Zern committed
315
const sad_m_by_n_test_param_t c_tests[] = {
316
#if CONFIG_VP8_ENCODER
James Zern's avatar
James Zern committed
317
318
319
320
321
  make_tuple(16, 16, sad_16x16_c),
  make_tuple(8, 16, sad_8x16_c),
  make_tuple(16, 8, sad_16x8_c),
  make_tuple(8, 8, sad_8x8_c),
  make_tuple(4, 4, sad_4x4_c),
322
323
#endif
#if CONFIG_VP9_ENCODER
James Zern's avatar
James Zern committed
324
325
326
327
328
329
  make_tuple(64, 64, sad_64x64_c_vp9),
  make_tuple(32, 32, sad_32x32_c_vp9),
  make_tuple(16, 16, sad_16x16_c_vp9),
  make_tuple(8, 16, sad_8x16_c_vp9),
  make_tuple(16, 8, sad_16x8_c_vp9),
  make_tuple(8, 8, sad_8x8_c_vp9),
330
331
  make_tuple(8, 4, sad_8x4_c_vp9),
  make_tuple(4, 8, sad_4x8_c_vp9),
James Zern's avatar
James Zern committed
332
  make_tuple(4, 4, sad_4x4_c_vp9),
333
#endif
James Zern's avatar
James Zern committed
334
335
};
INSTANTIATE_TEST_CASE_P(C, SADTest, ::testing::ValuesIn(c_tests));
Johann's avatar
Johann committed
336

337
338
339
340
341
342
343
344
345
346
347
348
349
350
#if CONFIG_VP9_ENCODER
const sad_n_by_n_by_4_fn_t sad_64x64x4d_c = vp9_sad64x64x4d_c;
const sad_n_by_n_by_4_fn_t sad_32x32x4d_c = vp9_sad32x32x4d_c;
const sad_n_by_n_by_4_fn_t sad_16x16x4d_c = vp9_sad16x16x4d_c;
const sad_n_by_n_by_4_fn_t sad_8x8x4d_c = vp9_sad8x8x4d_c;
const sad_n_by_n_by_4_fn_t sad_4x4x4d_c = vp9_sad4x4x4d_c;
INSTANTIATE_TEST_CASE_P(C, SADx4Test, ::testing::Values(
                        make_tuple(64, 64, sad_64x64x4d_c),
                        make_tuple(32, 32, sad_32x32x4d_c),
                        make_tuple(16, 16, sad_16x16x4d_c),
                        make_tuple(8, 8, sad_8x8x4d_c),
                        make_tuple(4, 4, sad_4x4x4d_c)));
#endif

Johann's avatar
Johann committed
351
352
// ARM tests
#if HAVE_MEDIA
James Zern's avatar
James Zern committed
353
const sad_m_by_n_fn_t sad_16x16_armv6 = vp8_sad16x16_armv6;
Johann's avatar
Johann committed
354
INSTANTIATE_TEST_CASE_P(MEDIA, SADTest, ::testing::Values(
James Zern's avatar
James Zern committed
355
                        make_tuple(16, 16, sad_16x16_armv6)));
Johann's avatar
Johann committed
356
357
358

#endif
#if HAVE_NEON
James Zern's avatar
James Zern committed
359
360
361
362
363
const sad_m_by_n_fn_t sad_16x16_neon = vp8_sad16x16_neon;
const sad_m_by_n_fn_t sad_8x16_neon = vp8_sad8x16_neon;
const sad_m_by_n_fn_t sad_16x8_neon = vp8_sad16x8_neon;
const sad_m_by_n_fn_t sad_8x8_neon = vp8_sad8x8_neon;
const sad_m_by_n_fn_t sad_4x4_neon = vp8_sad4x4_neon;
Johann's avatar
Johann committed
364
INSTANTIATE_TEST_CASE_P(NEON, SADTest, ::testing::Values(
James Zern's avatar
James Zern committed
365
366
367
368
369
                        make_tuple(16, 16, sad_16x16_neon),
                        make_tuple(8, 16, sad_8x16_neon),
                        make_tuple(16, 8, sad_16x8_neon),
                        make_tuple(8, 8, sad_8x8_neon),
                        make_tuple(4, 4, sad_4x4_neon)));
Johann's avatar
Johann committed
370
371
372
373
#endif

// X86 tests
#if HAVE_MMX
374
#if CONFIG_VP8_ENCODER
James Zern's avatar
James Zern committed
375
376
377
378
379
const sad_m_by_n_fn_t sad_16x16_mmx = vp8_sad16x16_mmx;
const sad_m_by_n_fn_t sad_8x16_mmx = vp8_sad8x16_mmx;
const sad_m_by_n_fn_t sad_16x8_mmx = vp8_sad16x8_mmx;
const sad_m_by_n_fn_t sad_8x8_mmx = vp8_sad8x8_mmx;
const sad_m_by_n_fn_t sad_4x4_mmx = vp8_sad4x4_mmx;
380
381
382
383
384
385
386
387
388
#endif
#if CONFIG_VP9_ENCODER
const sad_m_by_n_fn_t sad_16x16_mmx_vp9 = vp9_sad16x16_mmx;
const sad_m_by_n_fn_t sad_8x16_mmx_vp9 = vp9_sad8x16_mmx;
const sad_m_by_n_fn_t sad_16x8_mmx_vp9 = vp9_sad16x8_mmx;
const sad_m_by_n_fn_t sad_8x8_mmx_vp9 = vp9_sad8x8_mmx;
const sad_m_by_n_fn_t sad_4x4_mmx_vp9 = vp9_sad4x4_mmx;
#endif

James Zern's avatar
James Zern committed
389
const sad_m_by_n_test_param_t mmx_tests[] = {
390
#if CONFIG_VP8_ENCODER
James Zern's avatar
James Zern committed
391
392
393
394
395
  make_tuple(16, 16, sad_16x16_mmx),
  make_tuple(8, 16, sad_8x16_mmx),
  make_tuple(16, 8, sad_16x8_mmx),
  make_tuple(8, 8, sad_8x8_mmx),
  make_tuple(4, 4, sad_4x4_mmx),
Johann's avatar
Johann committed
396
#endif
397
#if CONFIG_VP9_ENCODER
James Zern's avatar
James Zern committed
398
399
400
401
402
  make_tuple(16, 16, sad_16x16_mmx_vp9),
  make_tuple(8, 16, sad_8x16_mmx_vp9),
  make_tuple(16, 8, sad_16x8_mmx_vp9),
  make_tuple(8, 8, sad_8x8_mmx_vp9),
  make_tuple(4, 4, sad_4x4_mmx_vp9),
403
#endif
James Zern's avatar
James Zern committed
404
405
};
INSTANTIATE_TEST_CASE_P(MMX, SADTest, ::testing::ValuesIn(mmx_tests));
406
407
408
409
410
#endif

#if HAVE_SSE
#if CONFIG_VP9_ENCODER
const sad_m_by_n_fn_t sad_4x4_sse_vp9 = vp9_sad4x4_sse;
411
const sad_m_by_n_fn_t sad_4x8_sse_vp9 = vp9_sad4x8_sse;
412
INSTANTIATE_TEST_CASE_P(SSE, SADTest, ::testing::Values(
413
414
                        make_tuple(4, 4, sad_4x4_sse_vp9),
                        make_tuple(4, 8, sad_4x8_sse_vp9)));
415
416
417
418

const sad_n_by_n_by_4_fn_t sad_4x4x4d_sse = vp9_sad4x4x4d_sse;
INSTANTIATE_TEST_CASE_P(SSE, SADx4Test, ::testing::Values(
                        make_tuple(4, 4, sad_4x4x4d_sse)));
419
420
421
#endif
#endif

Johann's avatar
Johann committed
422
#if HAVE_SSE2
423
#if CONFIG_VP8_ENCODER
James Zern's avatar
James Zern committed
424
425
426
427
428
const sad_m_by_n_fn_t sad_16x16_wmt = vp8_sad16x16_wmt;
const sad_m_by_n_fn_t sad_8x16_wmt = vp8_sad8x16_wmt;
const sad_m_by_n_fn_t sad_16x8_wmt = vp8_sad16x8_wmt;
const sad_m_by_n_fn_t sad_8x8_wmt = vp8_sad8x8_wmt;
const sad_m_by_n_fn_t sad_4x4_wmt = vp8_sad4x4_wmt;
429
430
431
432
433
434
435
436
#endif
#if CONFIG_VP9_ENCODER
const sad_m_by_n_fn_t sad_64x64_sse2_vp9 = vp9_sad64x64_sse2;
const sad_m_by_n_fn_t sad_32x32_sse2_vp9 = vp9_sad32x32_sse2;
const sad_m_by_n_fn_t sad_16x16_sse2_vp9 = vp9_sad16x16_sse2;
const sad_m_by_n_fn_t sad_8x16_sse2_vp9 = vp9_sad8x16_sse2;
const sad_m_by_n_fn_t sad_16x8_sse2_vp9 = vp9_sad16x8_sse2;
const sad_m_by_n_fn_t sad_8x8_sse2_vp9 = vp9_sad8x8_sse2;
437
const sad_m_by_n_fn_t sad_8x4_sse2_vp9 = vp9_sad8x4_sse2;
438
#endif
James Zern's avatar
James Zern committed
439
const sad_m_by_n_test_param_t sse2_tests[] = {
440
#if CONFIG_VP8_ENCODER
James Zern's avatar
James Zern committed
441
442
443
444
445
  make_tuple(16, 16, sad_16x16_wmt),
  make_tuple(8, 16, sad_8x16_wmt),
  make_tuple(16, 8, sad_16x8_wmt),
  make_tuple(8, 8, sad_8x8_wmt),
  make_tuple(4, 4, sad_4x4_wmt),
446
447
#endif
#if CONFIG_VP9_ENCODER
James Zern's avatar
James Zern committed
448
449
450
451
452
453
  make_tuple(64, 64, sad_64x64_sse2_vp9),
  make_tuple(32, 32, sad_32x32_sse2_vp9),
  make_tuple(16, 16, sad_16x16_sse2_vp9),
  make_tuple(8, 16, sad_8x16_sse2_vp9),
  make_tuple(16, 8, sad_16x8_sse2_vp9),
  make_tuple(8, 8, sad_8x8_sse2_vp9),
454
  make_tuple(8, 4, sad_8x4_sse2_vp9),
Johann's avatar
Johann committed
455
#endif
James Zern's avatar
James Zern committed
456
457
};
INSTANTIATE_TEST_CASE_P(SSE2, SADTest, ::testing::ValuesIn(sse2_tests));
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489

#if CONFIG_VP9_ENCODER
const sad_n_by_n_by_4_fn_t sad_64x64x4d_sse2 = vp9_sad64x64x4d_sse2;
const sad_n_by_n_by_4_fn_t sad_32x32x4d_sse2 = vp9_sad32x32x4d_sse2;
const sad_n_by_n_by_4_fn_t sad_16x16x4d_sse2 = vp9_sad16x16x4d_sse2;
const sad_n_by_n_by_4_fn_t sad_16x8x4d_sse2 = vp9_sad16x8x4d_sse2;
const sad_n_by_n_by_4_fn_t sad_8x16x4d_sse2 = vp9_sad8x16x4d_sse2;
const sad_n_by_n_by_4_fn_t sad_8x8x4d_sse2 = vp9_sad8x8x4d_sse2;
INSTANTIATE_TEST_CASE_P(SSE2, SADx4Test, ::testing::Values(
                        make_tuple(64, 64, sad_64x64x4d_sse2),
                        make_tuple(32, 32, sad_32x32x4d_sse2),
                        make_tuple(16, 16, sad_16x16x4d_sse2),
                        make_tuple(16, 8, sad_16x8x4d_sse2),
                        make_tuple(8, 16, sad_8x16x4d_sse2),
                        make_tuple(8, 8, sad_8x8x4d_sse2)));
#endif
#endif

#if HAVE_SSE3
#if CONFIG_VP8_ENCODER
const sad_n_by_n_by_4_fn_t sad_16x16x4d_sse3 = vp8_sad16x16x4d_sse3;
const sad_n_by_n_by_4_fn_t sad_16x8x4d_sse3 = vp8_sad16x8x4d_sse3;
const sad_n_by_n_by_4_fn_t sad_8x16x4d_sse3 = vp8_sad8x16x4d_sse3;
const sad_n_by_n_by_4_fn_t sad_8x8x4d_sse3 = vp8_sad8x8x4d_sse3;
const sad_n_by_n_by_4_fn_t sad_4x4x4d_sse3 = vp8_sad4x4x4d_sse3;
INSTANTIATE_TEST_CASE_P(SSE3, SADx4Test, ::testing::Values(
                        make_tuple(16, 16, sad_16x16x4d_sse3),
                        make_tuple(16, 8, sad_16x8x4d_sse3),
                        make_tuple(8, 16, sad_8x16x4d_sse3),
                        make_tuple(8, 8, sad_8x8x4d_sse3),
                        make_tuple(4, 4, sad_4x4x4d_sse3)));
#endif
490
491
#endif

Johann's avatar
Johann committed
492
#if HAVE_SSSE3
James Zern's avatar
James Zern committed
493
const sad_m_by_n_fn_t sad_16x16_sse3 = vp8_sad16x16_sse3;
Johann's avatar
Johann committed
494
INSTANTIATE_TEST_CASE_P(SSE3, SADTest, ::testing::Values(
James Zern's avatar
James Zern committed
495
                        make_tuple(16, 16, sad_16x16_sse3)));
Johann's avatar
Johann committed
496
497
498
#endif

}  // namespace