1 /* 2 * Copyright (c) 2017 The WebM project authors. All Rights Reserved. 3 * 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. 9 */ 10 11 #include <math.h> 12 #include <stdlib.h> 13 #include <string.h> 14 15 #include "third_party/googletest/src/include/gtest/gtest.h" 16 17 #include "./vp9_rtcd.h" 18 #include "./vpx_dsp_rtcd.h" 19 #include "test/acm_random.h" 20 #include "test/buffer.h" 21 #include "test/clear_system_state.h" 22 #include "test/register_state_check.h" 23 #include "test/util.h" 24 #include "vp9/common/vp9_entropy.h" 25 #include "vpx/vpx_codec.h" 26 #include "vpx/vpx_integer.h" 27 #include "vpx_ports/mem.h" 28 29 using libvpx_test::ACMRandom; 30 using libvpx_test::Buffer; 31 using std::tr1::tuple; 32 using std::tr1::make_tuple; 33 34 namespace { 35 typedef void (*FdctFunc)(const int16_t *in, tran_low_t *out, int stride); 36 typedef void (*IdctFunc)(const tran_low_t *in, uint8_t *out, int stride); 37 typedef void (*FhtFunc)(const int16_t *in, tran_low_t *out, int stride, 38 int tx_type); 39 typedef void (*FhtFuncRef)(const Buffer<int16_t> &in, Buffer<tran_low_t> *out, 40 int size, int tx_type); 41 typedef void (*IhtFunc)(const tran_low_t *in, uint8_t *out, int stride, 42 int tx_type); 43 44 /* forward transform, inverse transform, size, transform type, bit depth */ 45 typedef tuple<FdctFunc, IdctFunc, int, int, vpx_bit_depth_t> DctParam; 46 typedef tuple<FhtFunc, IhtFunc, int, int, vpx_bit_depth_t> HtParam; 47 48 void fdct_ref(const Buffer<int16_t> &in, Buffer<tran_low_t> *out, int size, 49 int /*tx_type*/) { 50 const int16_t *i = in.TopLeftPixel(); 51 const int i_stride = in.stride(); 52 tran_low_t *o = out->TopLeftPixel(); 53 if (size == 4) { 54 vpx_fdct4x4_c(i, o, i_stride); 55 } else if (size == 8) { 56 vpx_fdct8x8_c(i, o, i_stride); 57 } else if (size == 16) { 58 vpx_fdct16x16_c(i, o, i_stride); 59 } else if (size == 32) { 60 vpx_fdct32x32_c(i, o, i_stride); 61 } 62 } 63 64 void fht_ref(const Buffer<int16_t> &in, Buffer<tran_low_t> *out, int size, 65 int tx_type) { 66 const int16_t *i = in.TopLeftPixel(); 67 const int i_stride = in.stride(); 68 tran_low_t *o = out->TopLeftPixel(); 69 if (size == 4) { 70 vp9_fht4x4_c(i, o, i_stride, tx_type); 71 } else if (size == 8) { 72 vp9_fht8x8_c(i, o, i_stride, tx_type); 73 } else if (size == 16) { 74 vp9_fht16x16_c(i, o, i_stride, tx_type); 75 } 76 } 77 78 void fwht_ref(const Buffer<int16_t> &in, Buffer<tran_low_t> *out, int size, 79 int /*tx_type*/) { 80 ASSERT_EQ(size, 4); 81 vp9_fwht4x4_c(in.TopLeftPixel(), out->TopLeftPixel(), in.stride()); 82 } 83 84 #if CONFIG_VP9_HIGHBITDEPTH 85 #define idctNxN(n, coeffs, bitdepth) \ 86 void idct##n##x##n##_##bitdepth(const tran_low_t *in, uint8_t *out, \ 87 int stride) { \ 88 vpx_highbd_idct##n##x##n##_##coeffs##_add_c(in, CAST_TO_SHORTPTR(out), \ 89 stride, bitdepth); \ 90 } 91 92 idctNxN(4, 16, 10); 93 idctNxN(4, 16, 12); 94 idctNxN(8, 64, 10); 95 idctNxN(8, 64, 12); 96 idctNxN(16, 256, 10); 97 idctNxN(16, 256, 12); 98 idctNxN(32, 1024, 10); 99 idctNxN(32, 1024, 12); 100 101 #define ihtNxN(n, coeffs, bitdepth) \ 102 void iht##n##x##n##_##bitdepth(const tran_low_t *in, uint8_t *out, \ 103 int stride, int tx_type) { \ 104 vp9_highbd_iht##n##x##n##_##coeffs##_add_c(in, CAST_TO_SHORTPTR(out), \ 105 stride, tx_type, bitdepth); \ 106 } 107 108 ihtNxN(4, 16, 10); 109 ihtNxN(4, 16, 12); 110 ihtNxN(8, 64, 10); 111 ihtNxN(8, 64, 12); 112 ihtNxN(16, 256, 10); 113 // ihtNxN(16, 256, 12); 114 115 void iwht4x4_10(const tran_low_t *in, uint8_t *out, int stride) { 116 vpx_highbd_iwht4x4_16_add_c(in, CAST_TO_SHORTPTR(out), stride, 10); 117 } 118 119 void iwht4x4_12(const tran_low_t *in, uint8_t *out, int stride) { 120 vpx_highbd_iwht4x4_16_add_c(in, CAST_TO_SHORTPTR(out), stride, 12); 121 } 122 #endif // CONFIG_VP9_HIGHBITDEPTH 123 124 class TransTestBase { 125 public: 126 virtual void TearDown() { libvpx_test::ClearSystemState(); } 127 128 protected: 129 virtual void RunFwdTxfm(const Buffer<int16_t> &in, 130 Buffer<tran_low_t> *out) = 0; 131 132 virtual void RunInvTxfm(const Buffer<tran_low_t> &in, uint8_t *out) = 0; 133 134 void RunAccuracyCheck(int limit) { 135 ACMRandom rnd(ACMRandom::DeterministicSeed()); 136 Buffer<int16_t> test_input_block = 137 Buffer<int16_t>(size_, size_, 8, size_ == 4 ? 0 : 16); 138 ASSERT_TRUE(test_input_block.Init()); 139 Buffer<tran_low_t> test_temp_block = 140 Buffer<tran_low_t>(size_, size_, 0, 16); 141 ASSERT_TRUE(test_temp_block.Init()); 142 Buffer<uint8_t> dst = Buffer<uint8_t>(size_, size_, 0, 16); 143 ASSERT_TRUE(dst.Init()); 144 Buffer<uint8_t> src = Buffer<uint8_t>(size_, size_, 0, 16); 145 ASSERT_TRUE(src.Init()); 146 #if CONFIG_VP9_HIGHBITDEPTH 147 Buffer<uint16_t> dst16 = Buffer<uint16_t>(size_, size_, 0, 16); 148 ASSERT_TRUE(dst16.Init()); 149 Buffer<uint16_t> src16 = Buffer<uint16_t>(size_, size_, 0, 16); 150 ASSERT_TRUE(src16.Init()); 151 #endif // CONFIG_VP9_HIGHBITDEPTH 152 uint32_t max_error = 0; 153 int64_t total_error = 0; 154 const int count_test_block = 10000; 155 for (int i = 0; i < count_test_block; ++i) { 156 if (bit_depth_ == 8) { 157 src.Set(&rnd, &ACMRandom::Rand8); 158 dst.Set(&rnd, &ACMRandom::Rand8); 159 // Initialize a test block with input range [-255, 255]. 160 for (int h = 0; h < size_; ++h) { 161 for (int w = 0; w < size_; ++w) { 162 test_input_block.TopLeftPixel()[h * test_input_block.stride() + w] = 163 src.TopLeftPixel()[h * src.stride() + w] - 164 dst.TopLeftPixel()[h * dst.stride() + w]; 165 } 166 } 167 #if CONFIG_VP9_HIGHBITDEPTH 168 } else { 169 src16.Set(&rnd, 0, max_pixel_value_); 170 dst16.Set(&rnd, 0, max_pixel_value_); 171 for (int h = 0; h < size_; ++h) { 172 for (int w = 0; w < size_; ++w) { 173 test_input_block.TopLeftPixel()[h * test_input_block.stride() + w] = 174 src16.TopLeftPixel()[h * src16.stride() + w] - 175 dst16.TopLeftPixel()[h * dst16.stride() + w]; 176 } 177 } 178 #endif // CONFIG_VP9_HIGHBITDEPTH 179 } 180 181 ASM_REGISTER_STATE_CHECK(RunFwdTxfm(test_input_block, &test_temp_block)); 182 if (bit_depth_ == VPX_BITS_8) { 183 ASM_REGISTER_STATE_CHECK( 184 RunInvTxfm(test_temp_block, dst.TopLeftPixel())); 185 #if CONFIG_VP9_HIGHBITDEPTH 186 } else { 187 ASM_REGISTER_STATE_CHECK( 188 RunInvTxfm(test_temp_block, CAST_TO_BYTEPTR(dst16.TopLeftPixel()))); 189 #endif // CONFIG_VP9_HIGHBITDEPTH 190 } 191 192 for (int h = 0; h < size_; ++h) { 193 for (int w = 0; w < size_; ++w) { 194 int diff; 195 #if CONFIG_VP9_HIGHBITDEPTH 196 if (bit_depth_ != 8) { 197 diff = dst16.TopLeftPixel()[h * dst16.stride() + w] - 198 src16.TopLeftPixel()[h * src16.stride() + w]; 199 } else { 200 #endif // CONFIG_VP9_HIGHBITDEPTH 201 diff = dst.TopLeftPixel()[h * dst.stride() + w] - 202 src.TopLeftPixel()[h * src.stride() + w]; 203 #if CONFIG_VP9_HIGHBITDEPTH 204 } 205 #endif // CONFIG_VP9_HIGHBITDEPTH 206 const uint32_t error = diff * diff; 207 if (max_error < error) max_error = error; 208 total_error += error; 209 } 210 } 211 } 212 213 EXPECT_GE(static_cast<uint32_t>(limit), max_error) 214 << "Error: 4x4 FHT/IHT has an individual round trip error > " << limit; 215 216 EXPECT_GE(count_test_block * limit, total_error) 217 << "Error: 4x4 FHT/IHT has average round trip error > " << limit 218 << " per block"; 219 } 220 221 void RunCoeffCheck() { 222 ACMRandom rnd(ACMRandom::DeterministicSeed()); 223 const int count_test_block = 5000; 224 Buffer<int16_t> input_block = 225 Buffer<int16_t>(size_, size_, 8, size_ == 4 ? 0 : 16); 226 ASSERT_TRUE(input_block.Init()); 227 Buffer<tran_low_t> output_ref_block = Buffer<tran_low_t>(size_, size_, 0); 228 ASSERT_TRUE(output_ref_block.Init()); 229 Buffer<tran_low_t> output_block = Buffer<tran_low_t>(size_, size_, 0, 16); 230 ASSERT_TRUE(output_block.Init()); 231 232 for (int i = 0; i < count_test_block; ++i) { 233 // Initialize a test block with input range [-max_pixel_value_, 234 // max_pixel_value_]. 235 input_block.Set(&rnd, -max_pixel_value_, max_pixel_value_); 236 237 fwd_txfm_ref(input_block, &output_ref_block, size_, tx_type_); 238 ASM_REGISTER_STATE_CHECK(RunFwdTxfm(input_block, &output_block)); 239 240 // The minimum quant value is 4. 241 EXPECT_TRUE(output_block.CheckValues(output_ref_block)); 242 if (::testing::Test::HasFailure()) { 243 printf("Size: %d Transform type: %d\n", size_, tx_type_); 244 output_block.PrintDifference(output_ref_block); 245 return; 246 } 247 } 248 } 249 250 void RunMemCheck() { 251 ACMRandom rnd(ACMRandom::DeterministicSeed()); 252 const int count_test_block = 5000; 253 Buffer<int16_t> input_extreme_block = 254 Buffer<int16_t>(size_, size_, 8, size_ == 4 ? 0 : 16); 255 ASSERT_TRUE(input_extreme_block.Init()); 256 Buffer<tran_low_t> output_ref_block = Buffer<tran_low_t>(size_, size_, 0); 257 ASSERT_TRUE(output_ref_block.Init()); 258 Buffer<tran_low_t> output_block = Buffer<tran_low_t>(size_, size_, 0, 16); 259 ASSERT_TRUE(output_block.Init()); 260 261 for (int i = 0; i < count_test_block; ++i) { 262 // Initialize a test block with -max_pixel_value_ or max_pixel_value_. 263 if (i == 0) { 264 input_extreme_block.Set(max_pixel_value_); 265 } else if (i == 1) { 266 input_extreme_block.Set(-max_pixel_value_); 267 } else { 268 for (int h = 0; h < size_; ++h) { 269 for (int w = 0; w < size_; ++w) { 270 input_extreme_block 271 .TopLeftPixel()[h * input_extreme_block.stride() + w] = 272 rnd.Rand8() % 2 ? max_pixel_value_ : -max_pixel_value_; 273 } 274 } 275 } 276 277 fwd_txfm_ref(input_extreme_block, &output_ref_block, size_, tx_type_); 278 ASM_REGISTER_STATE_CHECK(RunFwdTxfm(input_extreme_block, &output_block)); 279 280 // The minimum quant value is 4. 281 EXPECT_TRUE(output_block.CheckValues(output_ref_block)); 282 for (int h = 0; h < size_; ++h) { 283 for (int w = 0; w < size_; ++w) { 284 EXPECT_GE( 285 4 * DCT_MAX_VALUE << (bit_depth_ - 8), 286 abs(output_block.TopLeftPixel()[h * output_block.stride() + w])) 287 << "Error: 4x4 FDCT has coefficient larger than " 288 "4*DCT_MAX_VALUE" 289 << " at " << w << "," << h; 290 if (::testing::Test::HasFailure()) { 291 printf("Size: %d Transform type: %d\n", size_, tx_type_); 292 output_block.DumpBuffer(); 293 return; 294 } 295 } 296 } 297 } 298 } 299 300 void RunInvAccuracyCheck(int limit) { 301 ACMRandom rnd(ACMRandom::DeterministicSeed()); 302 const int count_test_block = 1000; 303 Buffer<int16_t> in = Buffer<int16_t>(size_, size_, 4); 304 ASSERT_TRUE(in.Init()); 305 Buffer<tran_low_t> coeff = Buffer<tran_low_t>(size_, size_, 0, 16); 306 ASSERT_TRUE(coeff.Init()); 307 Buffer<uint8_t> dst = Buffer<uint8_t>(size_, size_, 0, 16); 308 ASSERT_TRUE(dst.Init()); 309 Buffer<uint8_t> src = Buffer<uint8_t>(size_, size_, 0); 310 ASSERT_TRUE(src.Init()); 311 Buffer<uint16_t> dst16 = Buffer<uint16_t>(size_, size_, 0, 16); 312 ASSERT_TRUE(dst16.Init()); 313 Buffer<uint16_t> src16 = Buffer<uint16_t>(size_, size_, 0); 314 ASSERT_TRUE(src16.Init()); 315 316 for (int i = 0; i < count_test_block; ++i) { 317 // Initialize a test block with input range [-max_pixel_value_, 318 // max_pixel_value_]. 319 if (bit_depth_ == VPX_BITS_8) { 320 src.Set(&rnd, &ACMRandom::Rand8); 321 dst.Set(&rnd, &ACMRandom::Rand8); 322 for (int h = 0; h < size_; ++h) { 323 for (int w = 0; w < size_; ++w) { 324 in.TopLeftPixel()[h * in.stride() + w] = 325 src.TopLeftPixel()[h * src.stride() + w] - 326 dst.TopLeftPixel()[h * dst.stride() + w]; 327 } 328 } 329 #if CONFIG_VP9_HIGHBITDEPTH 330 } else { 331 src16.Set(&rnd, 0, max_pixel_value_); 332 dst16.Set(&rnd, 0, max_pixel_value_); 333 for (int h = 0; h < size_; ++h) { 334 for (int w = 0; w < size_; ++w) { 335 in.TopLeftPixel()[h * in.stride() + w] = 336 src16.TopLeftPixel()[h * src16.stride() + w] - 337 dst16.TopLeftPixel()[h * dst16.stride() + w]; 338 } 339 } 340 #endif // CONFIG_VP9_HIGHBITDEPTH 341 } 342 343 fwd_txfm_ref(in, &coeff, size_, tx_type_); 344 345 if (bit_depth_ == VPX_BITS_8) { 346 ASM_REGISTER_STATE_CHECK(RunInvTxfm(coeff, dst.TopLeftPixel())); 347 #if CONFIG_VP9_HIGHBITDEPTH 348 } else { 349 ASM_REGISTER_STATE_CHECK( 350 RunInvTxfm(coeff, CAST_TO_BYTEPTR(dst16.TopLeftPixel()))); 351 #endif // CONFIG_VP9_HIGHBITDEPTH 352 } 353 354 for (int h = 0; h < size_; ++h) { 355 for (int w = 0; w < size_; ++w) { 356 int diff; 357 #if CONFIG_VP9_HIGHBITDEPTH 358 if (bit_depth_ != 8) { 359 diff = dst16.TopLeftPixel()[h * dst16.stride() + w] - 360 src16.TopLeftPixel()[h * src16.stride() + w]; 361 } else { 362 #endif // CONFIG_VP9_HIGHBITDEPTH 363 diff = dst.TopLeftPixel()[h * dst.stride() + w] - 364 src.TopLeftPixel()[h * src.stride() + w]; 365 #if CONFIG_VP9_HIGHBITDEPTH 366 } 367 #endif // CONFIG_VP9_HIGHBITDEPTH 368 const uint32_t error = diff * diff; 369 EXPECT_GE(static_cast<uint32_t>(limit), error) 370 << "Error: " << size_ << "x" << size_ << " IDCT has error " 371 << error << " at " << w << "," << h; 372 } 373 } 374 } 375 } 376 377 FhtFuncRef fwd_txfm_ref; 378 vpx_bit_depth_t bit_depth_; 379 int tx_type_; 380 int max_pixel_value_; 381 int size_; 382 }; 383 384 class TransDCT : public TransTestBase, 385 public ::testing::TestWithParam<DctParam> { 386 public: 387 TransDCT() { 388 fwd_txfm_ref = fdct_ref; 389 fwd_txfm_ = GET_PARAM(0); 390 inv_txfm_ = GET_PARAM(1); 391 size_ = GET_PARAM(2); 392 tx_type_ = GET_PARAM(3); 393 bit_depth_ = GET_PARAM(4); 394 max_pixel_value_ = (1 << bit_depth_) - 1; 395 } 396 397 protected: 398 void RunFwdTxfm(const Buffer<int16_t> &in, Buffer<tran_low_t> *out) { 399 fwd_txfm_(in.TopLeftPixel(), out->TopLeftPixel(), in.stride()); 400 } 401 402 void RunInvTxfm(const Buffer<tran_low_t> &in, uint8_t *out) { 403 inv_txfm_(in.TopLeftPixel(), out, in.stride()); 404 } 405 406 FdctFunc fwd_txfm_; 407 IdctFunc inv_txfm_; 408 }; 409 410 TEST_P(TransDCT, AccuracyCheck) { RunAccuracyCheck(1); } 411 412 TEST_P(TransDCT, CoeffCheck) { RunCoeffCheck(); } 413 414 TEST_P(TransDCT, MemCheck) { RunMemCheck(); } 415 416 TEST_P(TransDCT, InvAccuracyCheck) { RunInvAccuracyCheck(1); } 417 418 #if CONFIG_VP9_HIGHBITDEPTH 419 INSTANTIATE_TEST_CASE_P( 420 C, TransDCT, 421 ::testing::Values( 422 make_tuple(&vpx_highbd_fdct32x32_c, &idct32x32_10, 32, 0, VPX_BITS_10), 423 make_tuple(&vpx_highbd_fdct32x32_c, &idct32x32_12, 32, 0, VPX_BITS_10), 424 make_tuple(&vpx_fdct32x32_c, &vpx_idct32x32_1024_add_c, 32, 0, 425 VPX_BITS_8), 426 make_tuple(&vpx_highbd_fdct16x16_c, &idct16x16_10, 16, 0, VPX_BITS_10), 427 make_tuple(&vpx_highbd_fdct16x16_c, &idct16x16_12, 16, 0, VPX_BITS_10), 428 make_tuple(&vpx_fdct16x16_c, &vpx_idct16x16_256_add_c, 16, 0, 429 VPX_BITS_8), 430 make_tuple(&vpx_highbd_fdct8x8_c, &idct8x8_10, 8, 0, VPX_BITS_10), 431 make_tuple(&vpx_highbd_fdct8x8_c, &idct8x8_12, 8, 0, VPX_BITS_10), 432 make_tuple(&vpx_fdct8x8_c, &vpx_idct8x8_64_add_c, 8, 0, VPX_BITS_8), 433 make_tuple(&vpx_highbd_fdct4x4_c, &idct4x4_10, 4, 0, VPX_BITS_10), 434 make_tuple(&vpx_highbd_fdct4x4_c, &idct4x4_12, 4, 0, VPX_BITS_12), 435 make_tuple(&vpx_fdct4x4_c, &vpx_idct4x4_16_add_c, 4, 0, VPX_BITS_8))); 436 #else 437 INSTANTIATE_TEST_CASE_P( 438 C, TransDCT, 439 ::testing::Values( 440 make_tuple(&vpx_fdct32x32_c, &vpx_idct32x32_1024_add_c, 32, 0, 441 VPX_BITS_8), 442 make_tuple(&vpx_fdct16x16_c, &vpx_idct16x16_256_add_c, 16, 0, 443 VPX_BITS_8), 444 make_tuple(&vpx_fdct8x8_c, &vpx_idct8x8_64_add_c, 8, 0, VPX_BITS_8), 445 make_tuple(&vpx_fdct4x4_c, &vpx_idct4x4_16_add_c, 4, 0, VPX_BITS_8))); 446 #endif // CONFIG_VP9_HIGHBITDEPTH 447 448 #if HAVE_SSE2 449 #if !CONFIG_EMULATE_HARDWARE 450 #if CONFIG_VP9_HIGHBITDEPTH 451 /* TODO:(johannkoenig) Determine why these fail AccuracyCheck 452 make_tuple(&vpx_highbd_fdct32x32_sse2, &idct32x32_12, 32, 0, VPX_BITS_12), 453 make_tuple(&vpx_highbd_fdct16x16_sse2, &idct16x16_12, 16, 0, VPX_BITS_12), 454 */ 455 INSTANTIATE_TEST_CASE_P( 456 SSE2, TransDCT, 457 ::testing::Values( 458 make_tuple(&vpx_highbd_fdct32x32_sse2, &idct32x32_10, 32, 0, 459 VPX_BITS_10), 460 make_tuple(&vpx_fdct32x32_sse2, &vpx_idct32x32_1024_add_sse2, 32, 0, 461 VPX_BITS_8), 462 make_tuple(&vpx_highbd_fdct16x16_sse2, &idct16x16_10, 16, 0, 463 VPX_BITS_10), 464 make_tuple(&vpx_fdct16x16_sse2, &vpx_idct16x16_256_add_sse2, 16, 0, 465 VPX_BITS_8), 466 make_tuple(&vpx_highbd_fdct8x8_sse2, &idct8x8_10, 8, 0, VPX_BITS_10), 467 make_tuple(&vpx_highbd_fdct8x8_sse2, &idct8x8_12, 8, 0, VPX_BITS_12), 468 make_tuple(&vpx_fdct8x8_sse2, &vpx_idct8x8_64_add_sse2, 8, 0, 469 VPX_BITS_8), 470 make_tuple(&vpx_highbd_fdct4x4_sse2, &idct4x4_10, 4, 0, VPX_BITS_10), 471 make_tuple(&vpx_highbd_fdct4x4_sse2, &idct4x4_12, 4, 0, VPX_BITS_12), 472 make_tuple(&vpx_fdct4x4_sse2, &vpx_idct4x4_16_add_sse2, 4, 0, 473 VPX_BITS_8))); 474 #else 475 INSTANTIATE_TEST_CASE_P( 476 SSE2, TransDCT, 477 ::testing::Values(make_tuple(&vpx_fdct32x32_sse2, 478 &vpx_idct32x32_1024_add_sse2, 32, 0, 479 VPX_BITS_8), 480 make_tuple(&vpx_fdct16x16_sse2, 481 &vpx_idct16x16_256_add_sse2, 16, 0, 482 VPX_BITS_8), 483 make_tuple(&vpx_fdct8x8_sse2, &vpx_idct8x8_64_add_sse2, 8, 484 0, VPX_BITS_8), 485 make_tuple(&vpx_fdct4x4_sse2, &vpx_idct4x4_16_add_sse2, 4, 486 0, VPX_BITS_8))); 487 #endif // CONFIG_VP9_HIGHBITDEPTH 488 #endif // !CONFIG_EMULATE_HARDWARE 489 #endif // HAVE_SSE2 490 491 #if !CONFIG_VP9_HIGHBITDEPTH 492 #if HAVE_SSSE3 && !CONFIG_EMULATE_HARDWARE 493 #if !ARCH_X86_64 494 // TODO(johannkoenig): high bit depth fdct8x8. 495 INSTANTIATE_TEST_CASE_P( 496 SSSE3, TransDCT, 497 ::testing::Values(make_tuple(&vpx_fdct32x32_c, &vpx_idct32x32_1024_add_sse2, 498 32, 0, VPX_BITS_8), 499 make_tuple(&vpx_fdct8x8_c, &vpx_idct8x8_64_add_sse2, 8, 0, 500 VPX_BITS_8))); 501 #else 502 // vpx_fdct8x8_ssse3 is only available in 64 bit builds. 503 INSTANTIATE_TEST_CASE_P( 504 SSSE3, TransDCT, 505 ::testing::Values(make_tuple(&vpx_fdct32x32_c, &vpx_idct32x32_1024_add_sse2, 506 32, 0, VPX_BITS_8), 507 make_tuple(&vpx_fdct8x8_ssse3, &vpx_idct8x8_64_add_sse2, 508 8, 0, VPX_BITS_8))); 509 #endif // !ARCH_X86_64 510 #endif // HAVE_SSSE3 && !CONFIG_EMULATE_HARDWARE 511 #endif // !CONFIG_VP9_HIGHBITDEPTH 512 513 #if !CONFIG_VP9_HIGHBITDEPTH && HAVE_AVX2 && !CONFIG_EMULATE_HARDWARE 514 // TODO(johannkoenig): high bit depth fdct32x32. 515 INSTANTIATE_TEST_CASE_P( 516 AVX2, TransDCT, ::testing::Values(make_tuple(&vpx_fdct32x32_avx2, 517 &vpx_idct32x32_1024_add_sse2, 518 32, 0, VPX_BITS_8))); 519 520 #endif // !CONFIG_VP9_HIGHBITDEPTH && HAVE_AVX2 && !CONFIG_EMULATE_HARDWARE 521 522 #if HAVE_NEON 523 #if !CONFIG_EMULATE_HARDWARE 524 INSTANTIATE_TEST_CASE_P( 525 NEON, TransDCT, 526 ::testing::Values(make_tuple(&vpx_fdct32x32_neon, 527 &vpx_idct32x32_1024_add_neon, 32, 0, 528 VPX_BITS_8), 529 make_tuple(&vpx_fdct16x16_neon, 530 &vpx_idct16x16_256_add_neon, 16, 0, 531 VPX_BITS_8), 532 make_tuple(&vpx_fdct8x8_neon, &vpx_idct8x8_64_add_neon, 8, 533 0, VPX_BITS_8), 534 make_tuple(&vpx_fdct4x4_neon, &vpx_idct4x4_16_add_neon, 4, 535 0, VPX_BITS_8))); 536 #endif // !CONFIG_EMULATE_HARDWARE 537 #endif // HAVE_NEON 538 539 #if HAVE_MSA 540 #if !CONFIG_VP9_HIGHBITDEPTH 541 #if !CONFIG_EMULATE_HARDWARE 542 INSTANTIATE_TEST_CASE_P( 543 MSA, TransDCT, 544 ::testing::Values( 545 make_tuple(&vpx_fdct32x32_msa, &vpx_idct32x32_1024_add_msa, 32, 0, 546 VPX_BITS_8), 547 make_tuple(&vpx_fdct16x16_msa, &vpx_idct16x16_256_add_msa, 16, 0, 548 VPX_BITS_8), 549 make_tuple(&vpx_fdct8x8_msa, &vpx_idct8x8_64_add_msa, 8, 0, VPX_BITS_8), 550 make_tuple(&vpx_fdct4x4_msa, &vpx_idct4x4_16_add_msa, 4, 0, 551 VPX_BITS_8))); 552 #endif // !CONFIG_EMULATE_HARDWARE 553 #endif // !CONFIG_VP9_HIGHBITDEPTH 554 #endif // HAVE_MSA 555 556 #if HAVE_VSX && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE 557 INSTANTIATE_TEST_CASE_P(VSX, TransDCT, 558 ::testing::Values(make_tuple(&vpx_fdct4x4_c, 559 &vpx_idct4x4_16_add_vsx, 4, 560 0, VPX_BITS_8))); 561 #endif // HAVE_VSX && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE 562 563 class TransHT : public TransTestBase, public ::testing::TestWithParam<HtParam> { 564 public: 565 TransHT() { 566 fwd_txfm_ref = fht_ref; 567 fwd_txfm_ = GET_PARAM(0); 568 inv_txfm_ = GET_PARAM(1); 569 size_ = GET_PARAM(2); 570 tx_type_ = GET_PARAM(3); 571 bit_depth_ = GET_PARAM(4); 572 max_pixel_value_ = (1 << bit_depth_) - 1; 573 } 574 575 protected: 576 void RunFwdTxfm(const Buffer<int16_t> &in, Buffer<tran_low_t> *out) { 577 fwd_txfm_(in.TopLeftPixel(), out->TopLeftPixel(), in.stride(), tx_type_); 578 } 579 580 void RunInvTxfm(const Buffer<tran_low_t> &in, uint8_t *out) { 581 inv_txfm_(in.TopLeftPixel(), out, in.stride(), tx_type_); 582 } 583 584 FhtFunc fwd_txfm_; 585 IhtFunc inv_txfm_; 586 }; 587 588 TEST_P(TransHT, AccuracyCheck) { RunAccuracyCheck(1); } 589 590 TEST_P(TransHT, CoeffCheck) { RunCoeffCheck(); } 591 592 TEST_P(TransHT, MemCheck) { RunMemCheck(); } 593 594 TEST_P(TransHT, InvAccuracyCheck) { RunInvAccuracyCheck(1); } 595 596 /* TODO:(johannkoenig) Determine why these fail AccuracyCheck 597 make_tuple(&vp9_highbd_fht16x16_c, &iht16x16_12, 16, 0, VPX_BITS_12), 598 make_tuple(&vp9_highbd_fht16x16_c, &iht16x16_12, 16, 1, VPX_BITS_12), 599 make_tuple(&vp9_highbd_fht16x16_c, &iht16x16_12, 16, 2, VPX_BITS_12), 600 make_tuple(&vp9_highbd_fht16x16_c, &iht16x16_12, 16, 3, VPX_BITS_12), 601 */ 602 #if CONFIG_VP9_HIGHBITDEPTH 603 INSTANTIATE_TEST_CASE_P( 604 C, TransHT, 605 ::testing::Values( 606 make_tuple(&vp9_highbd_fht16x16_c, &iht16x16_10, 16, 0, VPX_BITS_10), 607 make_tuple(&vp9_highbd_fht16x16_c, &iht16x16_10, 16, 1, VPX_BITS_10), 608 make_tuple(&vp9_highbd_fht16x16_c, &iht16x16_10, 16, 2, VPX_BITS_10), 609 make_tuple(&vp9_highbd_fht16x16_c, &iht16x16_10, 16, 3, VPX_BITS_10), 610 make_tuple(&vp9_fht16x16_c, &vp9_iht16x16_256_add_c, 16, 0, VPX_BITS_8), 611 make_tuple(&vp9_fht16x16_c, &vp9_iht16x16_256_add_c, 16, 1, VPX_BITS_8), 612 make_tuple(&vp9_fht16x16_c, &vp9_iht16x16_256_add_c, 16, 2, VPX_BITS_8), 613 make_tuple(&vp9_fht16x16_c, &vp9_iht16x16_256_add_c, 16, 3, VPX_BITS_8), 614 make_tuple(&vp9_highbd_fht8x8_c, &iht8x8_10, 8, 0, VPX_BITS_10), 615 make_tuple(&vp9_highbd_fht8x8_c, &iht8x8_10, 8, 1, VPX_BITS_10), 616 make_tuple(&vp9_highbd_fht8x8_c, &iht8x8_10, 8, 2, VPX_BITS_10), 617 make_tuple(&vp9_highbd_fht8x8_c, &iht8x8_10, 8, 3, VPX_BITS_10), 618 make_tuple(&vp9_highbd_fht8x8_c, &iht8x8_12, 8, 0, VPX_BITS_12), 619 make_tuple(&vp9_highbd_fht8x8_c, &iht8x8_12, 8, 1, VPX_BITS_12), 620 make_tuple(&vp9_highbd_fht8x8_c, &iht8x8_12, 8, 2, VPX_BITS_12), 621 make_tuple(&vp9_highbd_fht8x8_c, &iht8x8_12, 8, 3, VPX_BITS_12), 622 make_tuple(&vp9_fht8x8_c, &vp9_iht8x8_64_add_c, 8, 0, VPX_BITS_8), 623 make_tuple(&vp9_fht8x8_c, &vp9_iht8x8_64_add_c, 8, 1, VPX_BITS_8), 624 make_tuple(&vp9_fht8x8_c, &vp9_iht8x8_64_add_c, 8, 2, VPX_BITS_8), 625 make_tuple(&vp9_fht8x8_c, &vp9_iht8x8_64_add_c, 8, 3, VPX_BITS_8), 626 make_tuple(&vp9_highbd_fht4x4_c, &iht4x4_10, 4, 0, VPX_BITS_10), 627 make_tuple(&vp9_highbd_fht4x4_c, &iht4x4_10, 4, 1, VPX_BITS_10), 628 make_tuple(&vp9_highbd_fht4x4_c, &iht4x4_10, 4, 2, VPX_BITS_10), 629 make_tuple(&vp9_highbd_fht4x4_c, &iht4x4_10, 4, 3, VPX_BITS_10), 630 make_tuple(&vp9_highbd_fht4x4_c, &iht4x4_12, 4, 0, VPX_BITS_12), 631 make_tuple(&vp9_highbd_fht4x4_c, &iht4x4_12, 4, 1, VPX_BITS_12), 632 make_tuple(&vp9_highbd_fht4x4_c, &iht4x4_12, 4, 2, VPX_BITS_12), 633 make_tuple(&vp9_highbd_fht4x4_c, &iht4x4_12, 4, 3, VPX_BITS_12), 634 make_tuple(&vp9_fht4x4_c, &vp9_iht4x4_16_add_c, 4, 0, VPX_BITS_8), 635 make_tuple(&vp9_fht4x4_c, &vp9_iht4x4_16_add_c, 4, 1, VPX_BITS_8), 636 make_tuple(&vp9_fht4x4_c, &vp9_iht4x4_16_add_c, 4, 2, VPX_BITS_8), 637 make_tuple(&vp9_fht4x4_c, &vp9_iht4x4_16_add_c, 4, 3, VPX_BITS_8))); 638 #else 639 INSTANTIATE_TEST_CASE_P( 640 C, TransHT, 641 ::testing::Values( 642 make_tuple(&vp9_fht16x16_c, &vp9_iht16x16_256_add_c, 16, 0, VPX_BITS_8), 643 make_tuple(&vp9_fht16x16_c, &vp9_iht16x16_256_add_c, 16, 1, VPX_BITS_8), 644 make_tuple(&vp9_fht16x16_c, &vp9_iht16x16_256_add_c, 16, 2, VPX_BITS_8), 645 make_tuple(&vp9_fht16x16_c, &vp9_iht16x16_256_add_c, 16, 3, VPX_BITS_8), 646 647 make_tuple(&vp9_fht8x8_c, &vp9_iht8x8_64_add_c, 8, 0, VPX_BITS_8), 648 make_tuple(&vp9_fht8x8_c, &vp9_iht8x8_64_add_c, 8, 1, VPX_BITS_8), 649 make_tuple(&vp9_fht8x8_c, &vp9_iht8x8_64_add_c, 8, 2, VPX_BITS_8), 650 make_tuple(&vp9_fht8x8_c, &vp9_iht8x8_64_add_c, 8, 3, VPX_BITS_8), 651 652 make_tuple(&vp9_fht4x4_c, &vp9_iht4x4_16_add_c, 4, 0, VPX_BITS_8), 653 make_tuple(&vp9_fht4x4_c, &vp9_iht4x4_16_add_c, 4, 1, VPX_BITS_8), 654 make_tuple(&vp9_fht4x4_c, &vp9_iht4x4_16_add_c, 4, 2, VPX_BITS_8), 655 make_tuple(&vp9_fht4x4_c, &vp9_iht4x4_16_add_c, 4, 3, VPX_BITS_8))); 656 #endif // CONFIG_VP9_HIGHBITDEPTH 657 658 #if HAVE_SSE2 659 INSTANTIATE_TEST_CASE_P( 660 SSE2, TransHT, 661 ::testing::Values( 662 make_tuple(&vp9_fht16x16_sse2, &vp9_iht16x16_256_add_sse2, 16, 0, 663 VPX_BITS_8), 664 make_tuple(&vp9_fht16x16_sse2, &vp9_iht16x16_256_add_sse2, 16, 1, 665 VPX_BITS_8), 666 make_tuple(&vp9_fht16x16_sse2, &vp9_iht16x16_256_add_sse2, 16, 2, 667 VPX_BITS_8), 668 make_tuple(&vp9_fht16x16_sse2, &vp9_iht16x16_256_add_sse2, 16, 3, 669 VPX_BITS_8), 670 671 make_tuple(&vp9_fht8x8_sse2, &vp9_iht8x8_64_add_sse2, 8, 0, VPX_BITS_8), 672 make_tuple(&vp9_fht8x8_sse2, &vp9_iht8x8_64_add_sse2, 8, 1, VPX_BITS_8), 673 make_tuple(&vp9_fht8x8_sse2, &vp9_iht8x8_64_add_sse2, 8, 2, VPX_BITS_8), 674 make_tuple(&vp9_fht8x8_sse2, &vp9_iht8x8_64_add_sse2, 8, 3, VPX_BITS_8), 675 676 make_tuple(&vp9_fht4x4_sse2, &vp9_iht4x4_16_add_sse2, 4, 0, VPX_BITS_8), 677 make_tuple(&vp9_fht4x4_sse2, &vp9_iht4x4_16_add_sse2, 4, 1, VPX_BITS_8), 678 make_tuple(&vp9_fht4x4_sse2, &vp9_iht4x4_16_add_sse2, 4, 2, VPX_BITS_8), 679 make_tuple(&vp9_fht4x4_sse2, &vp9_iht4x4_16_add_sse2, 4, 3, 680 VPX_BITS_8))); 681 #endif // HAVE_SSE2 682 683 class TransWHT : public TransTestBase, 684 public ::testing::TestWithParam<DctParam> { 685 public: 686 TransWHT() { 687 fwd_txfm_ref = fwht_ref; 688 fwd_txfm_ = GET_PARAM(0); 689 inv_txfm_ = GET_PARAM(1); 690 size_ = GET_PARAM(2); 691 tx_type_ = GET_PARAM(3); 692 bit_depth_ = GET_PARAM(4); 693 max_pixel_value_ = (1 << bit_depth_) - 1; 694 } 695 696 protected: 697 void RunFwdTxfm(const Buffer<int16_t> &in, Buffer<tran_low_t> *out) { 698 fwd_txfm_(in.TopLeftPixel(), out->TopLeftPixel(), in.stride()); 699 } 700 701 void RunInvTxfm(const Buffer<tran_low_t> &in, uint8_t *out) { 702 inv_txfm_(in.TopLeftPixel(), out, in.stride()); 703 } 704 705 FdctFunc fwd_txfm_; 706 IdctFunc inv_txfm_; 707 }; 708 709 TEST_P(TransWHT, AccuracyCheck) { RunAccuracyCheck(0); } 710 711 TEST_P(TransWHT, CoeffCheck) { RunCoeffCheck(); } 712 713 TEST_P(TransWHT, MemCheck) { RunMemCheck(); } 714 715 TEST_P(TransWHT, InvAccuracyCheck) { RunInvAccuracyCheck(0); } 716 717 #if CONFIG_VP9_HIGHBITDEPTH 718 INSTANTIATE_TEST_CASE_P( 719 C, TransWHT, 720 ::testing::Values( 721 make_tuple(&vp9_highbd_fwht4x4_c, &iwht4x4_10, 4, 0, VPX_BITS_10), 722 make_tuple(&vp9_highbd_fwht4x4_c, &iwht4x4_12, 4, 0, VPX_BITS_12), 723 make_tuple(&vp9_fwht4x4_c, &vpx_iwht4x4_16_add_c, 4, 0, VPX_BITS_8))); 724 #else 725 INSTANTIATE_TEST_CASE_P(C, TransWHT, 726 ::testing::Values(make_tuple(&vp9_fwht4x4_c, 727 &vpx_iwht4x4_16_add_c, 4, 728 0, VPX_BITS_8))); 729 #endif // CONFIG_VP9_HIGHBITDEPTH 730 731 #if HAVE_SSE2 732 INSTANTIATE_TEST_CASE_P(SSE2, TransWHT, 733 ::testing::Values(make_tuple(&vp9_fwht4x4_sse2, 734 &vpx_iwht4x4_16_add_sse2, 735 4, 0, VPX_BITS_8))); 736 #endif // HAVE_SSE2 737 } // namespace 738
