2 * Copyright (c) 2016 The WebM project authors. All Rights Reserved.
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
13 #include "third_party/googletest/src/include/gtest/gtest.h"
15 #include "./vpx_dsp_rtcd.h"
17 #include "test/acm_random.h"
18 #include "test/register_state_check.h"
22 using ::libvpx_test::ACMRandom;
24 typedef void (*HadamardFunc)(const int16_t *a, int a_stride, int16_t *b);
26 void hadamard_loop(const int16_t *a, int a_stride, int16_t *out) {
28 for (int i = 0; i < 8; i += 2) {
29 b[i + 0] = a[i * a_stride] + a[(i + 1) * a_stride];
30 b[i + 1] = a[i * a_stride] - a[(i + 1) * a_stride];
33 for (int i = 0; i < 8; i += 4) {
34 c[i + 0] = b[i + 0] + b[i + 2];
35 c[i + 1] = b[i + 1] + b[i + 3];
36 c[i + 2] = b[i + 0] - b[i + 2];
37 c[i + 3] = b[i + 1] - b[i + 3];
49 void reference_hadamard8x8(const int16_t *a, int a_stride, int16_t *b) {
51 for (int i = 0; i < 8; ++i) {
52 hadamard_loop(a + i, a_stride, buf + i * 8);
55 for (int i = 0; i < 8; ++i) {
56 hadamard_loop(buf + i, 8, b + i * 8);
60 void reference_hadamard16x16(const int16_t *a, int a_stride, int16_t *b) {
61 /* The source is a 16x16 block. The destination is rearranged to 8x32.
63 reference_hadamard8x8(a + 0 + 0 * a_stride, a_stride, b + 0);
64 reference_hadamard8x8(a + 8 + 0 * a_stride, a_stride, b + 64);
65 reference_hadamard8x8(a + 0 + 8 * a_stride, a_stride, b + 128);
66 reference_hadamard8x8(a + 8 + 8 * a_stride, a_stride, b + 192);
68 /* Overlay the 8x8 blocks and combine. */
69 for (int i = 0; i < 64; ++i) {
70 /* 8x8 steps the range up to 15 bits. */
71 const int16_t a0 = b[0];
72 const int16_t a1 = b[64];
73 const int16_t a2 = b[128];
74 const int16_t a3 = b[192];
76 /* Prevent the result from escaping int16_t. */
77 const int16_t b0 = (a0 + a1) >> 1;
78 const int16_t b1 = (a0 - a1) >> 1;
79 const int16_t b2 = (a2 + a3) >> 1;
80 const int16_t b3 = (a2 - a3) >> 1;
82 /* Store a 16 bit value. */
92 class HadamardTestBase : public ::testing::TestWithParam<HadamardFunc> {
94 virtual void SetUp() {
96 rnd_.Reset(ACMRandom::DeterministicSeed());
100 HadamardFunc h_func_;
104 class Hadamard8x8Test : public HadamardTestBase {};
106 TEST_P(Hadamard8x8Test, CompareReferenceRandom) {
107 DECLARE_ALIGNED(16, int16_t, a[64]);
108 DECLARE_ALIGNED(16, int16_t, b[64]);
110 for (int i = 0; i < 64; ++i) {
111 a[i] = rnd_.Rand9Signed();
113 memset(b, 0, sizeof(b));
114 memset(b_ref, 0, sizeof(b_ref));
116 reference_hadamard8x8(a, 8, b_ref);
117 ASM_REGISTER_STATE_CHECK(h_func_(a, 8, b));
119 // The order of the output is not important. Sort before checking.
120 std::sort(b, b + 64);
121 std::sort(b_ref, b_ref + 64);
122 EXPECT_EQ(0, memcmp(b, b_ref, sizeof(b)));
125 TEST_P(Hadamard8x8Test, VaryStride) {
126 DECLARE_ALIGNED(16, int16_t, a[64 * 8]);
127 DECLARE_ALIGNED(16, int16_t, b[64]);
129 for (int i = 0; i < 64 * 8; ++i) {
130 a[i] = rnd_.Rand9Signed();
133 for (int i = 8; i < 64; i += 8) {
134 memset(b, 0, sizeof(b));
135 memset(b_ref, 0, sizeof(b_ref));
137 reference_hadamard8x8(a, i, b_ref);
138 ASM_REGISTER_STATE_CHECK(h_func_(a, i, b));
140 // The order of the output is not important. Sort before checking.
141 std::sort(b, b + 64);
142 std::sort(b_ref, b_ref + 64);
143 EXPECT_EQ(0, memcmp(b, b_ref, sizeof(b)));
147 INSTANTIATE_TEST_CASE_P(C, Hadamard8x8Test,
148 ::testing::Values(&vpx_hadamard_8x8_c));
151 INSTANTIATE_TEST_CASE_P(SSE2, Hadamard8x8Test,
152 ::testing::Values(&vpx_hadamard_8x8_sse2));
155 #if HAVE_SSSE3 && CONFIG_USE_X86INC && ARCH_X86_64
156 INSTANTIATE_TEST_CASE_P(SSSE3, Hadamard8x8Test,
157 ::testing::Values(&vpx_hadamard_8x8_ssse3));
158 #endif // HAVE_SSSE3 && CONFIG_USE_X86INC && ARCH_X86_64
161 INSTANTIATE_TEST_CASE_P(NEON, Hadamard8x8Test,
162 ::testing::Values(&vpx_hadamard_8x8_neon));
165 class Hadamard16x16Test : public HadamardTestBase {};
167 TEST_P(Hadamard16x16Test, CompareReferenceRandom) {
168 DECLARE_ALIGNED(16, int16_t, a[16 * 16]);
169 DECLARE_ALIGNED(16, int16_t, b[16 * 16]);
170 int16_t b_ref[16 * 16];
171 for (int i = 0; i < 16 * 16; ++i) {
172 a[i] = rnd_.Rand9Signed();
174 memset(b, 0, sizeof(b));
175 memset(b_ref, 0, sizeof(b_ref));
177 reference_hadamard16x16(a, 16, b_ref);
178 ASM_REGISTER_STATE_CHECK(h_func_(a, 16, b));
180 // The order of the output is not important. Sort before checking.
181 std::sort(b, b + 16 * 16);
182 std::sort(b_ref, b_ref + 16 * 16);
183 EXPECT_EQ(0, memcmp(b, b_ref, sizeof(b)));
186 TEST_P(Hadamard16x16Test, VaryStride) {
187 DECLARE_ALIGNED(16, int16_t, a[16 * 16 * 8]);
188 DECLARE_ALIGNED(16, int16_t, b[16 * 16]);
189 int16_t b_ref[16 * 16];
190 for (int i = 0; i < 16 * 16 * 8; ++i) {
191 a[i] = rnd_.Rand9Signed();
194 for (int i = 8; i < 64; i += 8) {
195 memset(b, 0, sizeof(b));
196 memset(b_ref, 0, sizeof(b_ref));
198 reference_hadamard16x16(a, i, b_ref);
199 ASM_REGISTER_STATE_CHECK(h_func_(a, i, b));
201 // The order of the output is not important. Sort before checking.
202 std::sort(b, b + 16 * 16);
203 std::sort(b_ref, b_ref + 16 * 16);
204 EXPECT_EQ(0, memcmp(b, b_ref, sizeof(b)));
208 INSTANTIATE_TEST_CASE_P(C, Hadamard16x16Test,
209 ::testing::Values(&vpx_hadamard_16x16_c));
212 INSTANTIATE_TEST_CASE_P(SSE2, Hadamard16x16Test,
213 ::testing::Values(&vpx_hadamard_16x16_sse2));