avg_test.cc 8.43 KB
Newer Older
1
/*
2
 * Copyright (c) 2016, Alliance for Open Media. All rights reserved
3
 *
4 5 6 7 8 9
 * This source code is subject to the terms of the BSD 2 Clause License and
 * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
 * was not distributed with this source code in the LICENSE file, you can
 * obtain it at www.aomedia.org/license/software. If the Alliance for Open
 * Media Patent License 1.0 was not distributed with this source code in the
 * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
Johann's avatar
Johann committed
10
 */
11 12 13

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

16
#include "third_party/googletest/src/googletest/include/gtest/gtest.h"
17

18 19
#include "./aom_config.h"
#include "./aom_dsp_rtcd.h"
20 21 22 23 24

#include "test/acm_random.h"
#include "test/clear_system_state.h"
#include "test/register_state_check.h"
#include "test/util.h"
25
#include "aom_mem/aom_mem.h"
26

27
using libaom_test::ACMRandom;
28 29 30 31 32 33 34

namespace {
class AverageTestBase : public ::testing::Test {
 public:
  AverageTestBase(int width, int height) : width_(width), height_(height) {}

  static void SetUpTestCase() {
clang-format's avatar
clang-format committed
35
    source_data_ = reinterpret_cast<uint8_t *>(
36
        aom_memalign(kDataAlignment, kDataBlockSize));
37 38 39
  }

  static void TearDownTestCase() {
40
    aom_free(source_data_);
41 42 43
    source_data_ = NULL;
  }

44
  virtual void TearDown() { libaom_test::ClearSystemState(); }
45 46 47 48 49 50 51 52 53 54 55 56 57

 protected:
  // Handle blocks up to 4 blocks 64x64 with stride up to 128
  static const int kDataAlignment = 16;
  static const int kDataBlockSize = 64 * 128;

  virtual void SetUp() {
    source_stride_ = (width_ + 31) & ~31;
    rnd_.Reset(ACMRandom::DeterministicSeed());
  }

  void FillConstant(uint8_t fill_constant) {
    for (int i = 0; i < width_ * height_; ++i) {
clang-format's avatar
clang-format committed
58
      source_data_[i] = fill_constant;
59 60 61 62 63
    }
  }

  void FillRandom() {
    for (int i = 0; i < width_ * height_; ++i) {
clang-format's avatar
clang-format committed
64
      source_data_[i] = rnd_.Rand8();
65 66 67 68
    }
  }

  int width_, height_;
clang-format's avatar
clang-format committed
69
  static uint8_t *source_data_;
70 71 72 73 74
  int source_stride_;

  ACMRandom rnd_;
};

75 76 77 78 79
typedef void (*IntProRowFunc)(int16_t hbuf[16], uint8_t const *ref,
                              const int ref_stride, const int height);

typedef std::tr1::tuple<int, IntProRowFunc, IntProRowFunc> IntProRowParam;

clang-format's avatar
clang-format committed
80 81
class IntProRowTest : public AverageTestBase,
                      public ::testing::WithParamInterface<IntProRowParam> {
82 83
 public:
  IntProRowTest()
clang-format's avatar
clang-format committed
84
      : AverageTestBase(16, GET_PARAM(0)), hbuf_asm_(NULL), hbuf_c_(NULL) {
85 86 87 88 89 90
    asm_func_ = GET_PARAM(1);
    c_func_ = GET_PARAM(2);
  }

 protected:
  virtual void SetUp() {
clang-format's avatar
clang-format committed
91
    hbuf_asm_ = reinterpret_cast<int16_t *>(
92
        aom_memalign(kDataAlignment, sizeof(*hbuf_asm_) * 16));
clang-format's avatar
clang-format committed
93
    hbuf_c_ = reinterpret_cast<int16_t *>(
94
        aom_memalign(kDataAlignment, sizeof(*hbuf_c_) * 16));
95 96 97
  }

  virtual void TearDown() {
98
    aom_free(hbuf_c_);
99
    hbuf_c_ = NULL;
100
    aom_free(hbuf_asm_);
101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121
    hbuf_asm_ = NULL;
  }

  void RunComparison() {
    ASM_REGISTER_STATE_CHECK(c_func_(hbuf_c_, source_data_, 0, height_));
    ASM_REGISTER_STATE_CHECK(asm_func_(hbuf_asm_, source_data_, 0, height_));
    EXPECT_EQ(0, memcmp(hbuf_c_, hbuf_asm_, sizeof(*hbuf_c_) * 16))
        << "Output mismatch";
  }

 private:
  IntProRowFunc asm_func_;
  IntProRowFunc c_func_;
  int16_t *hbuf_asm_;
  int16_t *hbuf_c_;
};

typedef int16_t (*IntProColFunc)(uint8_t const *ref, const int width);

typedef std::tr1::tuple<int, IntProColFunc, IntProColFunc> IntProColParam;

clang-format's avatar
clang-format committed
122 123
class IntProColTest : public AverageTestBase,
                      public ::testing::WithParamInterface<IntProColParam> {
124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143
 public:
  IntProColTest() : AverageTestBase(GET_PARAM(0), 1), sum_asm_(0), sum_c_(0) {
    asm_func_ = GET_PARAM(1);
    c_func_ = GET_PARAM(2);
  }

 protected:
  void RunComparison() {
    ASM_REGISTER_STATE_CHECK(sum_c_ = c_func_(source_data_, width_));
    ASM_REGISTER_STATE_CHECK(sum_asm_ = asm_func_(source_data_, width_));
    EXPECT_EQ(sum_c_, sum_asm_) << "Output mismatch";
  }

 private:
  IntProColFunc asm_func_;
  IntProColFunc c_func_;
  int16_t sum_asm_;
  int16_t sum_c_;
};

James Zern's avatar
James Zern committed
144 145 146
typedef int (*SatdFunc)(const int16_t *coeffs, int length);
typedef std::tr1::tuple<int, SatdFunc> SatdTestParam;

clang-format's avatar
clang-format committed
147 148
class SatdTest : public ::testing::Test,
                 public ::testing::WithParamInterface<SatdTestParam> {
James Zern's avatar
James Zern committed
149 150 151 152 153
 protected:
  virtual void SetUp() {
    satd_size_ = GET_PARAM(0);
    satd_func_ = GET_PARAM(1);
    rnd_.Reset(ACMRandom::DeterministicSeed());
clang-format's avatar
clang-format committed
154
    src_ = reinterpret_cast<int16_t *>(
155
        aom_memalign(16, sizeof(*src_) * satd_size_));
James Zern's avatar
James Zern committed
156 157 158 159
    ASSERT_TRUE(src_ != NULL);
  }

  virtual void TearDown() {
160
    libaom_test::ClearSystemState();
161
    aom_free(src_);
James Zern's avatar
James Zern committed
162 163 164 165 166 167 168 169 170 171
  }

  void FillConstant(const int16_t val) {
    for (int i = 0; i < satd_size_; ++i) src_[i] = val;
  }

  void FillRandom() {
    for (int i = 0; i < satd_size_; ++i) src_[i] = rnd_.Rand16();
  }

172
  void Check(int expected) {
James Zern's avatar
James Zern committed
173 174 175 176 177 178 179 180 181 182 183 184
    int total;
    ASM_REGISTER_STATE_CHECK(total = satd_func_(src_, satd_size_));
    EXPECT_EQ(expected, total);
  }

  int satd_size_;

 private:
  int16_t *src_;
  SatdFunc satd_func_;
  ACMRandom rnd_;
};
185

clang-format's avatar
clang-format committed
186
uint8_t *AverageTestBase::source_data_ = NULL;
187

188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217
TEST_P(IntProRowTest, MinValue) {
  FillConstant(0);
  RunComparison();
}

TEST_P(IntProRowTest, MaxValue) {
  FillConstant(255);
  RunComparison();
}

TEST_P(IntProRowTest, Random) {
  FillRandom();
  RunComparison();
}

TEST_P(IntProColTest, MinValue) {
  FillConstant(0);
  RunComparison();
}

TEST_P(IntProColTest, MaxValue) {
  FillConstant(255);
  RunComparison();
}

TEST_P(IntProColTest, Random) {
  FillRandom();
  RunComparison();
}

James Zern's avatar
James Zern committed
218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246
TEST_P(SatdTest, MinValue) {
  const int kMin = -32640;
  const int expected = -kMin * satd_size_;
  FillConstant(kMin);
  Check(expected);
}

TEST_P(SatdTest, MaxValue) {
  const int kMax = 32640;
  const int expected = kMax * satd_size_;
  FillConstant(kMax);
  Check(expected);
}

TEST_P(SatdTest, Random) {
  int expected;
  switch (satd_size_) {
    case 16: expected = 205298; break;
    case 64: expected = 1113950; break;
    case 256: expected = 4268415; break;
    case 1024: expected = 16954082; break;
    default:
      FAIL() << "Invalid satd size (" << satd_size_
             << ") valid: 16/64/256/1024";
  }
  FillRandom();
  Check(expected);
}

247 248
using std::tr1::make_tuple;

clang-format's avatar
clang-format committed
249
INSTANTIATE_TEST_CASE_P(C, SatdTest,
250 251 252 253
                        ::testing::Values(make_tuple(16, &aom_satd_c),
                                          make_tuple(64, &aom_satd_c),
                                          make_tuple(256, &aom_satd_c),
                                          make_tuple(1024, &aom_satd_c)));
James Zern's avatar
James Zern committed
254

255
#if HAVE_SSE2
256
INSTANTIATE_TEST_CASE_P(
clang-format's avatar
clang-format committed
257
    SSE2, IntProRowTest,
258 259 260 261
    ::testing::Values(make_tuple(16, &aom_int_pro_row_sse2, &aom_int_pro_row_c),
                      make_tuple(32, &aom_int_pro_row_sse2, &aom_int_pro_row_c),
                      make_tuple(64, &aom_int_pro_row_sse2,
                                 &aom_int_pro_row_c)));
262 263

INSTANTIATE_TEST_CASE_P(
clang-format's avatar
clang-format committed
264
    SSE2, IntProColTest,
265 266 267 268
    ::testing::Values(make_tuple(16, &aom_int_pro_col_sse2, &aom_int_pro_col_c),
                      make_tuple(32, &aom_int_pro_col_sse2, &aom_int_pro_col_c),
                      make_tuple(64, &aom_int_pro_col_sse2,
                                 &aom_int_pro_col_c)));
clang-format's avatar
clang-format committed
269 270

INSTANTIATE_TEST_CASE_P(SSE2, SatdTest,
271 272 273 274
                        ::testing::Values(make_tuple(16, &aom_satd_sse2),
                                          make_tuple(64, &aom_satd_sse2),
                                          make_tuple(256, &aom_satd_sse2),
                                          make_tuple(1024, &aom_satd_sse2)));
275 276
#endif

277
#if HAVE_NEON
Frank Galligan's avatar
Frank Galligan committed
278
INSTANTIATE_TEST_CASE_P(
clang-format's avatar
clang-format committed
279
    NEON, IntProRowTest,
280 281 282 283
    ::testing::Values(make_tuple(16, &aom_int_pro_row_neon, &aom_int_pro_row_c),
                      make_tuple(32, &aom_int_pro_row_neon, &aom_int_pro_row_c),
                      make_tuple(64, &aom_int_pro_row_neon,
                                 &aom_int_pro_row_c)));
James Zern's avatar
James Zern committed
284 285

INSTANTIATE_TEST_CASE_P(
clang-format's avatar
clang-format committed
286
    NEON, IntProColTest,
287 288 289 290
    ::testing::Values(make_tuple(16, &aom_int_pro_col_neon, &aom_int_pro_col_c),
                      make_tuple(32, &aom_int_pro_col_neon, &aom_int_pro_col_c),
                      make_tuple(64, &aom_int_pro_col_neon,
                                 &aom_int_pro_col_c)));
clang-format's avatar
clang-format committed
291 292

INSTANTIATE_TEST_CASE_P(NEON, SatdTest,
293 294 295 296
                        ::testing::Values(make_tuple(16, &aom_satd_neon),
                                          make_tuple(64, &aom_satd_neon),
                                          make_tuple(256, &aom_satd_neon),
                                          make_tuple(1024, &aom_satd_neon)));
297 298
#endif

299
}  // namespace