sad_test.cc 17 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);
Johann's avatar
Johann committed
39

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);

Johann's avatar
Johann committed
46
47
48
using libvpx_test::ACMRandom;

namespace {
49
class SADTestBase : public ::testing::Test {
50
 public:
51
52
  SADTestBase(int width, int height) : width_(width), height_(height) {}

53
54
  static void SetUpTestCase() {
    source_data_ = reinterpret_cast<uint8_t*>(
55
        vpx_memalign(kDataAlignment, kDataBlockSize));
56
57
58
59
60
61
62
63
64
65
66
67
    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:
68
  // Handle blocks up to 4 blocks 64x64 with stride up to 128
69
  static const int kDataAlignment = 16;
70
71
  static const int kDataBlockSize = 64 * 128;
  static const int kDataBufferSize = 4 * kDataBlockSize;
72

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

79
80
  virtual uint8_t* GetReference(int block_idx) {
    return reference_data_ + block_idx * kDataBlockSize;
Johann's avatar
Johann committed
81
82
83
84
  }

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

    for (int h = 0; h < height_; ++h) {
      for (int w = 0; w < width_; ++w) {
        sad += abs(source_data_[h * source_stride_ + w]
92
               - reference[h * reference_stride_ + w]);
Johann's avatar
Johann committed
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
      }
      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();
      }
    }
  }

117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
  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,
    public ::testing::WithParamInterface<
        std::tr1::tuple<int, int, sad_m_by_n_fn_t> > {
 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
143
144
145
146
147
148
149
150
151
152
153
154
155
  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);
    }
  }
156
};
Johann's avatar
Johann committed
157

158
159
160
161
162
class SADx4Test : public SADTestBase,
    public ::testing::WithParamInterface<
        std::tr1::tuple<int, int, sad_n_by_n_by_4_fn_t> > {
 public:
  SADx4Test() : SADTestBase(GET_PARAM(0), GET_PARAM(1)) {}
Johann's avatar
Johann committed
163

164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
 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
184
185
};

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

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

195
196
197
198
199
200
201
202
203
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
204
205
206
TEST_P(SADTest, MaxSrc) {
  FillConstant(source_data_, source_stride_, 255);
  FillConstant(reference_data_, reference_stride_, 0);
Johann's avatar
Johann committed
207
  CheckSad(UINT_MAX);
Johann's avatar
Johann committed
208
209
}

210
211
212
213
214
215
216
217
218
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
219
220
221
222
223
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
224
  CheckSad(UINT_MAX);
Johann's avatar
Johann committed
225
226
227
  reference_stride_ = tmp_stride;
}

228
229
230
231
232
233
234
235
236
237
238
239
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
240
241
242
243
244
245
246
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
247
  CheckSad(UINT_MAX);
Johann's avatar
Johann committed
248
249
250
  reference_stride_ = tmp_stride;
}

251
252
253
254
255
256
257
258
259
260
261
262
263
264
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
265
266
267
268
269
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
270
  CheckSad(UINT_MAX);
Johann's avatar
Johann committed
271
272
273
  source_stride_ = tmp_stride;
}

274
275
276
277
278
279
280
281
282
283
284
285
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
286
287
288
289
290
291
292
293
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
294
295
using std::tr1::make_tuple;

296
297
298
299
300
301
302
#if CONFIG_VP8_ENCODER && CONFIG_VP9_ENCODER
#define VP8_VP9_SEPARATOR ,
#else
#define VP8_VP9_SEPARATOR
#endif

#if CONFIG_VP8_ENCODER
James Zern's avatar
James Zern committed
303
304
305
306
307
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;
308
309
310
311
312
313
314
315
316
317
#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;
const sad_m_by_n_fn_t sad_4x4_c_vp9 = vp9_sad4x4_c;
#endif
Johann's avatar
Johann committed
318
INSTANTIATE_TEST_CASE_P(C, SADTest, ::testing::Values(
319
#if CONFIG_VP8_ENCODER
James Zern's avatar
James Zern committed
320
321
322
323
                        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),
324
325
326
327
328
329
330
331
332
333
334
335
336
                        make_tuple(4, 4, sad_4x4_c)
#endif
                        VP8_VP9_SEPARATOR
#if CONFIG_VP9_ENCODER
                        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),
                        make_tuple(4, 4, sad_4x4_c_vp9)
#endif
                        ));
Johann's avatar
Johann committed
337

338
339
340
341
342
343
344
345
346
347
348
349
350
351
#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
352
353
// ARM tests
#if HAVE_MEDIA
James Zern's avatar
James Zern committed
354
const sad_m_by_n_fn_t sad_16x16_armv6 = vp8_sad16x16_armv6;
Johann's avatar
Johann committed
355
INSTANTIATE_TEST_CASE_P(MEDIA, SADTest, ::testing::Values(
James Zern's avatar
James Zern committed
356
                        make_tuple(16, 16, sad_16x16_armv6)));
Johann's avatar
Johann committed
357
358
359

#endif
#if HAVE_NEON
James Zern's avatar
James Zern committed
360
361
362
363
364
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
365
INSTANTIATE_TEST_CASE_P(NEON, SADTest, ::testing::Values(
James Zern's avatar
James Zern committed
366
367
368
369
370
                        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
371
372
373
374
#endif

// X86 tests
#if HAVE_MMX
375
#if CONFIG_VP8_ENCODER
James Zern's avatar
James Zern committed
376
377
378
379
380
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;
381
382
383
384
385
386
387
388
389
#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

Johann's avatar
Johann committed
390
INSTANTIATE_TEST_CASE_P(MMX, SADTest, ::testing::Values(
391
#if CONFIG_VP8_ENCODER
James Zern's avatar
James Zern committed
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),
396
                        make_tuple(4, 4, sad_4x4_mmx)
Johann's avatar
Johann committed
397
#endif
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
                        VP8_VP9_SEPARATOR
#if CONFIG_VP9_ENCODER
                        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)
#endif
                        ));
#endif

#if HAVE_SSE
#if CONFIG_VP9_ENCODER
const sad_m_by_n_fn_t sad_4x4_sse_vp9 = vp9_sad4x4_sse;
INSTANTIATE_TEST_CASE_P(SSE, SADTest, ::testing::Values(
                        make_tuple(4, 4, sad_4x4_sse_vp9)));
414
415
416
417

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)));
418
419
420
#endif
#endif

Johann's avatar
Johann committed
421
#if HAVE_SSE2
422
#if CONFIG_VP8_ENCODER
James Zern's avatar
James Zern committed
423
424
425
426
427
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;
428
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;
#endif
Johann's avatar
Johann committed
437
INSTANTIATE_TEST_CASE_P(SSE2, SADTest, ::testing::Values(
438
#if CONFIG_VP8_ENCODER
James Zern's avatar
James Zern committed
439
440
441
442
                        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),
443
444
445
446
447
448
449
450
451
452
                        make_tuple(4, 4, sad_4x4_wmt)
#endif
                        VP8_VP9_SEPARATOR
#if CONFIG_VP9_ENCODER
                        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)
Johann's avatar
Johann committed
453
#endif
454
                        ));
455
456
457
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

#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
487
488
#endif

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

}  // namespace