From caf9a7841eff9e9931f6b85cb4226a4e247b8466 Mon Sep 17 00:00:00 2001 From: Johann Date: Fri, 2 Sep 2016 18:42:40 -0700 Subject: [PATCH] Add vp8_bilinear_filter test Build out the sixtap_predict test because the filters are interchangeable. Add verbose failures and border checking. Change-Id: I962f50041750dca6f8d0cd35a943424cf82ddcb1 --- test/predict_test.cc | 369 ++++++++++++++++++++++++++++++++++++++++++++ test/sixtap_predict_test.cc | 231 --------------------------- test/test.mk | 2 +- 3 files changed, 370 insertions(+), 232 deletions(-) create mode 100644 test/predict_test.cc delete mode 100644 test/sixtap_predict_test.cc diff --git a/test/predict_test.cc b/test/predict_test.cc new file mode 100644 index 0000000..dd797c6 --- /dev/null +++ b/test/predict_test.cc @@ -0,0 +1,369 @@ +/* + * Copyright (c) 2013 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 +#include + +#include "third_party/googletest/src/include/gtest/gtest.h" + +#include "./vp8_rtcd.h" +#include "./vpx_config.h" +#include "test/acm_random.h" +#include "test/clear_system_state.h" +#include "test/register_state_check.h" +#include "test/util.h" +#include "vpx/vpx_integer.h" + +namespace { + +using libvpx_test::ACMRandom; +using std::tr1::make_tuple; + +typedef void (*PredictFunc)(uint8_t *src_ptr, int src_pixels_per_line, + int xoffset, int yoffset, uint8_t *dst_ptr, + int dst_pitch); + +typedef std::tr1::tuple PredictParam; + +class PredictTestBase : public ::testing::TestWithParam { + public: + PredictTestBase() + : width_(GET_PARAM(0)), height_(GET_PARAM(1)), predict_(GET_PARAM(2)), + src_(NULL), padded_dst_(NULL), dst_(NULL), dst_c_(NULL) {} + + virtual void SetUp() { + src_ = new uint8_t[kSrcSize]; + ASSERT_TRUE(src_ != NULL); + + // padded_dst_ provides a buffer of kBorderSize around the destination + // memory to facilitate detecting out of bounds writes. + dst_stride_ = kBorderSize + width_ + kBorderSize; + padded_dst_size_ = dst_stride_ * (kBorderSize + height_ + kBorderSize); + padded_dst_ = new uint8_t[padded_dst_size_]; + ASSERT_TRUE(padded_dst_ != NULL); + dst_ = padded_dst_ + (kBorderSize * dst_stride_) + kBorderSize; + + dst_c_ = new uint8_t[16 * 16]; + ASSERT_TRUE(dst_c_ != NULL); + + memset(src_, 0, kSrcSize); + memset(padded_dst_, 128, padded_dst_size_); + memset(dst_c_, 0, 16 * 16); + } + + virtual void TearDown() { + delete[] src_; + src_ = NULL; + delete[] padded_dst_; + padded_dst_ = NULL; + dst_ = NULL; + delete[] dst_c_; + dst_c_ = NULL; + libvpx_test::ClearSystemState(); + } + + protected: + // Make reference arrays big enough for 16x16 functions. Six-tap filters need + // 5 extra pixels outside of the macroblock. + static const int kSrcStride = 21; + static const int kSrcSize = kSrcStride * kSrcStride; + static const int kBorderSize = 16; + + int width_; + int height_; + PredictFunc predict_; + uint8_t *src_; + uint8_t *padded_dst_; + uint8_t *dst_; + int padded_dst_size_; + uint8_t *dst_c_; + int dst_stride_; + + bool CompareBuffers(const uint8_t *a, int a_stride, const uint8_t *b, + int b_stride) const { + for (int height = 0; height < height_; ++height) { + EXPECT_EQ(0, memcmp(a + height * a_stride, b + height * b_stride, + sizeof(*a) * width_)) + << "Row " << height << " does not match."; + } + + return !HasFailure(); + } + + // Given a block of memory 'a' with size 'a_size', determine if all regions + // excepting block 'b' described by 'b_stride', 'b_height', and 'b_width' + // match pixel value 'c'. + bool CheckBorder(const uint8_t *a, int a_size, const uint8_t *b, int b_width, + int b_height, int b_stride, uint8_t c) const { + const uint8_t *a_end = a + a_size; + const int b_size = (b_stride * b_height) + b_width; + const uint8_t *b_end = b + b_size; + const int left_border = (b_stride - b_width) / 2; + const int right_border = left_border + ((b_stride - b_width) % 2); + + EXPECT_GE(b - left_border, a) << "'b' does not start within 'a'"; + EXPECT_LE(b_end + right_border, a_end) << "'b' does not end within 'a'"; + + // Top border. + for (int pixel = 0; pixel < b - a - left_border; ++pixel) { + EXPECT_EQ(c, a[pixel]) << "Mismatch at " << pixel << " in top border."; + } + + // Left border. + for (int height = 0; height < b_height; ++height) { + for (int width = left_border; width > 0; --width) { + EXPECT_EQ(c, b[height * b_stride - width]) + << "Mismatch at row " << height << " column " << left_border - width + << " in left border."; + } + } + + // Right border. + for (int height = 0; height < b_height; ++height) { + for (int width = b_width; width < b_width + right_border; ++width) { + EXPECT_EQ(c, b[height * b_stride + width]) + << "Mismatch at row " << height << " column " << width - b_width + << " in right border."; + } + } + + // Bottom border. + for (int pixel = static_cast(b - a + b_size); pixel < a_size; + ++pixel) { + EXPECT_EQ(c, a[pixel]) << "Mismatch at " << pixel << " in bottom border."; + } + + return !HasFailure(); + } + + void TestWithRandomData(PredictFunc reference) { + ACMRandom rnd(ACMRandom::DeterministicSeed()); + + // Run tests for all possible offsets. + for (int xoffset = 0; xoffset < 8; ++xoffset) { + for (int yoffset = 0; yoffset < 8; ++yoffset) { + for (int i = 0; i < kSrcSize; ++i) { + src_[i] = rnd.Rand8(); + } + reference(&src_[kSrcStride * 2 + 2], kSrcStride, xoffset, yoffset, + dst_c_, 16); + + ASM_REGISTER_STATE_CHECK(predict_(&src_[kSrcStride * 2 + 2], kSrcStride, + xoffset, yoffset, dst_, dst_stride_)); + + ASSERT_TRUE(CompareBuffers(dst_c_, 16, dst_, dst_stride_)); + ASSERT_TRUE(CheckBorder(padded_dst_, padded_dst_size_, dst_, width_, + height_, dst_stride_, 128)); + } + } + } + + void TestWithUnalignedDst(PredictFunc reference) { + ACMRandom rnd(ACMRandom::DeterministicSeed()); + + // Only the 4x4 need to be able to handle unaligned writes. + if (width_ == 4 && height_ == 4) { + for (int xoffset = 0; xoffset < 8; ++xoffset) { + for (int yoffset = 0; yoffset < 8; ++yoffset) { + for (int i = 0; i < kSrcSize; ++i) { + src_[i] = rnd.Rand8(); + } + reference(&src_[kSrcStride * 2 + 2], kSrcStride, xoffset, yoffset, + dst_c_, 16); + + for (int i = 1; i < 4; ++i) { + memset(padded_dst_, 128, padded_dst_size_); + + ASM_REGISTER_STATE_CHECK(predict_(&src_[kSrcStride * 2 + 2], + kSrcStride, xoffset, yoffset, + dst_ + i, dst_stride_ + i)); + + ASSERT_TRUE(CompareBuffers(dst_c_, 16, dst_ + i, dst_stride_ + i)); + ASSERT_TRUE(CheckBorder(padded_dst_, padded_dst_size_, dst_ + i, + width_, height_, dst_stride_ + i, 128)); + } + } + } + } + } +}; + +class SixtapPredictTest : public PredictTestBase {}; + +TEST_P(SixtapPredictTest, TestWithRandomData) { + TestWithRandomData(vp8_sixtap_predict16x16_c); +} +TEST_P(SixtapPredictTest, TestWithUnalignedDst) { + TestWithUnalignedDst(vp8_sixtap_predict16x16_c); +} + +TEST_P(SixtapPredictTest, TestWithPresetData) { + // Test input + static const uint8_t kTestData[kSrcSize] = { + 184, 4, 191, 82, 92, 41, 0, 1, 226, 236, 172, 20, 182, 42, 226, + 177, 79, 94, 77, 179, 203, 206, 198, 22, 192, 19, 75, 17, 192, 44, + 233, 120, 48, 168, 203, 141, 210, 203, 143, 180, 184, 59, 201, 110, 102, + 171, 32, 182, 10, 109, 105, 213, 60, 47, 236, 253, 67, 55, 14, 3, + 99, 247, 124, 148, 159, 71, 34, 114, 19, 177, 38, 203, 237, 239, 58, + 83, 155, 91, 10, 166, 201, 115, 124, 5, 163, 104, 2, 231, 160, 16, + 234, 4, 8, 103, 153, 167, 174, 187, 26, 193, 109, 64, 141, 90, 48, + 200, 174, 204, 36, 184, 114, 237, 43, 238, 242, 207, 86, 245, 182, 247, + 6, 161, 251, 14, 8, 148, 182, 182, 79, 208, 120, 188, 17, 6, 23, + 65, 206, 197, 13, 242, 126, 128, 224, 170, 110, 211, 121, 197, 200, 47, + 188, 207, 208, 184, 221, 216, 76, 148, 143, 156, 100, 8, 89, 117, 14, + 112, 183, 221, 54, 197, 208, 180, 69, 176, 94, 180, 131, 215, 121, 76, + 7, 54, 28, 216, 238, 249, 176, 58, 142, 64, 215, 242, 72, 49, 104, + 87, 161, 32, 52, 216, 230, 4, 141, 44, 181, 235, 224, 57, 195, 89, + 134, 203, 144, 162, 163, 126, 156, 84, 185, 42, 148, 145, 29, 221, 194, + 134, 52, 100, 166, 105, 60, 140, 110, 201, 184, 35, 181, 153, 93, 121, + 243, 227, 68, 131, 134, 232, 2, 35, 60, 187, 77, 209, 76, 106, 174, + 15, 241, 227, 115, 151, 77, 175, 36, 187, 121, 221, 223, 47, 118, 61, + 168, 105, 32, 237, 236, 167, 213, 238, 202, 17, 170, 24, 226, 247, 131, + 145, 6, 116, 117, 121, 11, 194, 41, 48, 126, 162, 13, 93, 209, 131, + 154, 122, 237, 187, 103, 217, 99, 60, 200, 45, 78, 115, 69, 49, 106, + 200, 194, 112, 60, 56, 234, 72, 251, 19, 120, 121, 182, 134, 215, 135, + 10, 114, 2, 247, 46, 105, 209, 145, 165, 153, 191, 243, 12, 5, 36, + 119, 206, 231, 231, 11, 32, 209, 83, 27, 229, 204, 149, 155, 83, 109, + 35, 93, 223, 37, 84, 14, 142, 37, 160, 52, 191, 96, 40, 204, 101, + 77, 67, 52, 53, 43, 63, 85, 253, 147, 113, 226, 96, 6, 125, 179, + 115, 161, 17, 83, 198, 101, 98, 85, 139, 3, 137, 75, 99, 178, 23, + 201, 255, 91, 253, 52, 134, 60, 138, 131, 208, 251, 101, 48, 2, 227, + 228, 118, 132, 245, 202, 75, 91, 44, 160, 231, 47, 41, 50, 147, 220, + 74, 92, 219, 165, 89, 16 + }; + + // Expected results for xoffset = 2 and yoffset = 2. + static const int kExpectedDstStride = 16; + static const uint8_t kExpectedDst[256] = { + 117, 102, 74, 135, 42, 98, 175, 206, 70, 73, 222, 197, 50, 24, 39, + 49, 38, 105, 90, 47, 169, 40, 171, 215, 200, 73, 109, 141, 53, 85, + 177, 164, 79, 208, 124, 89, 212, 18, 81, 145, 151, 164, 217, 153, 91, + 154, 102, 102, 159, 75, 164, 152, 136, 51, 213, 219, 186, 116, 193, 224, + 186, 36, 231, 208, 84, 211, 155, 167, 35, 59, 42, 76, 216, 149, 73, + 201, 78, 149, 184, 100, 96, 196, 189, 198, 188, 235, 195, 117, 129, 120, + 129, 49, 25, 133, 113, 69, 221, 114, 70, 143, 99, 157, 108, 189, 140, + 78, 6, 55, 65, 240, 255, 245, 184, 72, 90, 100, 116, 131, 39, 60, + 234, 167, 33, 160, 88, 185, 200, 157, 159, 176, 127, 151, 138, 102, 168, + 106, 170, 86, 82, 219, 189, 76, 33, 115, 197, 106, 96, 198, 136, 97, + 141, 237, 151, 98, 137, 191, 185, 2, 57, 95, 142, 91, 255, 185, 97, + 137, 76, 162, 94, 173, 131, 193, 161, 81, 106, 72, 135, 222, 234, 137, + 66, 137, 106, 243, 210, 147, 95, 15, 137, 110, 85, 66, 16, 96, 167, + 147, 150, 173, 203, 140, 118, 196, 84, 147, 160, 19, 95, 101, 123, 74, + 132, 202, 82, 166, 12, 131, 166, 189, 170, 159, 85, 79, 66, 57, 152, + 132, 203, 194, 0, 1, 56, 146, 180, 224, 156, 28, 83, 181, 79, 76, + 80, 46, 160, 175, 59, 106, 43, 87, 75, 136, 85, 189, 46, 71, 200, + 90 + }; + + ASM_REGISTER_STATE_CHECK( + predict_(const_cast(kTestData) + kSrcStride * 2 + 2, + kSrcStride, 2, 2, dst_, dst_stride_)); + + ASSERT_TRUE( + CompareBuffers(kExpectedDst, kExpectedDstStride, dst_, dst_stride_)); +} + +INSTANTIATE_TEST_CASE_P( + C, SixtapPredictTest, + ::testing::Values(make_tuple(16, 16, &vp8_sixtap_predict16x16_c), + make_tuple(8, 8, &vp8_sixtap_predict8x8_c), + make_tuple(8, 4, &vp8_sixtap_predict8x4_c), + make_tuple(4, 4, &vp8_sixtap_predict4x4_c))); +#if HAVE_NEON +INSTANTIATE_TEST_CASE_P( + NEON, SixtapPredictTest, + ::testing::Values(make_tuple(16, 16, &vp8_sixtap_predict16x16_neon), + make_tuple(8, 8, &vp8_sixtap_predict8x8_neon), + make_tuple(8, 4, &vp8_sixtap_predict8x4_neon))); +#endif +#if HAVE_MMX +INSTANTIATE_TEST_CASE_P( + MMX, SixtapPredictTest, + ::testing::Values(make_tuple(16, 16, &vp8_sixtap_predict16x16_mmx), + make_tuple(8, 8, &vp8_sixtap_predict8x8_mmx), + make_tuple(8, 4, &vp8_sixtap_predict8x4_mmx), + make_tuple(4, 4, &vp8_sixtap_predict4x4_mmx))); +#endif +#if HAVE_SSE2 +INSTANTIATE_TEST_CASE_P( + SSE2, SixtapPredictTest, + ::testing::Values(make_tuple(16, 16, &vp8_sixtap_predict16x16_sse2), + make_tuple(8, 8, &vp8_sixtap_predict8x8_sse2), + make_tuple(8, 4, &vp8_sixtap_predict8x4_sse2))); +#endif +#if HAVE_SSSE3 +INSTANTIATE_TEST_CASE_P( + SSSE3, SixtapPredictTest, + ::testing::Values(make_tuple(16, 16, &vp8_sixtap_predict16x16_ssse3), + make_tuple(8, 8, &vp8_sixtap_predict8x8_ssse3), + make_tuple(8, 4, &vp8_sixtap_predict8x4_ssse3), + make_tuple(4, 4, &vp8_sixtap_predict4x4_ssse3))); +#endif +#if HAVE_MSA +INSTANTIATE_TEST_CASE_P( + MSA, SixtapPredictTest, + ::testing::Values(make_tuple(16, 16, &vp8_sixtap_predict16x16_msa), + make_tuple(8, 8, &vp8_sixtap_predict8x8_msa), + make_tuple(8, 4, &vp8_sixtap_predict8x4_msa), + make_tuple(4, 4, &vp8_sixtap_predict4x4_msa))); +#endif + +class BilinearPredictTest : public PredictTestBase {}; + +TEST_P(BilinearPredictTest, TestWithRandomData) { + TestWithRandomData(vp8_bilinear_predict16x16_c); +} +TEST_P(BilinearPredictTest, TestWithUnalignedDst) { + TestWithUnalignedDst(vp8_bilinear_predict16x16_c); +} + +INSTANTIATE_TEST_CASE_P( + C, BilinearPredictTest, + ::testing::Values(make_tuple(16, 16, &vp8_bilinear_predict16x16_c), + make_tuple(8, 8, &vp8_bilinear_predict8x8_c), + make_tuple(8, 4, &vp8_bilinear_predict8x4_c), + make_tuple(4, 4, &vp8_bilinear_predict4x4_c))); +#if HAVE_NEON +INSTANTIATE_TEST_CASE_P( + NEON, BilinearPredictTest, + ::testing::Values(make_tuple(16, 16, &vp8_bilinear_predict16x16_neon), + make_tuple(8, 8, &vp8_bilinear_predict8x8_neon), + make_tuple(8, 4, &vp8_bilinear_predict8x4_neon), + make_tuple(4, 4, &vp8_bilinear_predict4x4_neon))); +#endif +#if HAVE_MMX +INSTANTIATE_TEST_CASE_P( + MMX, BilinearPredictTest, + ::testing::Values(make_tuple(16, 16, &vp8_bilinear_predict16x16_mmx), + make_tuple(8, 8, &vp8_bilinear_predict8x8_mmx), + make_tuple(8, 4, &vp8_bilinear_predict8x4_mmx), + make_tuple(4, 4, &vp8_bilinear_predict4x4_mmx))); +#endif +#if HAVE_SSE2 +INSTANTIATE_TEST_CASE_P( + SSE2, BilinearPredictTest, + ::testing::Values(make_tuple(16, 16, &vp8_bilinear_predict16x16_sse2), + make_tuple(8, 8, &vp8_bilinear_predict8x8_sse2))); +#endif +#if HAVE_SSSE3 +INSTANTIATE_TEST_CASE_P( + DISABLED_SSSE3, BilinearPredictTest, + ::testing::Values(make_tuple(16, 16, &vp8_bilinear_predict16x16_ssse3), + make_tuple(8, 8, &vp8_bilinear_predict8x8_ssse3))); +#endif +#if HAVE_MSA +INSTANTIATE_TEST_CASE_P( + MSA, BilinearPredictTest, + ::testing::Values(make_tuple(16, 16, &vp8_bilinear_predict16x16_msa), + make_tuple(8, 8, &vp8_bilinear_predict8x8_msa), + make_tuple(8, 4, &vp8_bilinear_predict8x4_msa), + make_tuple(4, 4, &vp8_bilinear_predict4x4_msa))); +#endif +} // namespace diff --git a/test/sixtap_predict_test.cc b/test/sixtap_predict_test.cc deleted file mode 100644 index 31a6044..0000000 --- a/test/sixtap_predict_test.cc +++ /dev/null @@ -1,231 +0,0 @@ -/* - * Copyright (c) 2013 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 -#include -#include - -#include "third_party/googletest/src/include/gtest/gtest.h" - -#include "./vpx_config.h" -#include "./vp8_rtcd.h" -#include "test/acm_random.h" -#include "test/clear_system_state.h" -#include "test/register_state_check.h" -#include "test/util.h" -#include "vpx/vpx_integer.h" -#include "vpx_mem/vpx_mem.h" - -namespace { - -typedef void (*SixtapPredictFunc)(uint8_t *src_ptr, int src_pixels_per_line, - int xoffset, int yoffset, uint8_t *dst_ptr, - int dst_pitch); - -typedef std::tr1::tuple SixtapPredictParam; - -class SixtapPredictTest : public ::testing::TestWithParam { - public: - static void SetUpTestCase() { - src_ = reinterpret_cast(vpx_memalign(kDataAlignment, kSrcSize)); - dst_ = reinterpret_cast(vpx_memalign(kDataAlignment, kDstSize)); - dst_c_ = - reinterpret_cast(vpx_memalign(kDataAlignment, kDstSize)); - } - - static void TearDownTestCase() { - vpx_free(src_); - src_ = NULL; - vpx_free(dst_); - dst_ = NULL; - vpx_free(dst_c_); - dst_c_ = NULL; - } - - virtual void TearDown() { libvpx_test::ClearSystemState(); } - - protected: - // Make test arrays big enough for 16x16 functions. Six-tap filters - // need 5 extra pixels outside of the macroblock. - static const int kSrcStride = 21; - static const int kDstStride = 16; - static const int kDataAlignment = 16; - static const int kSrcSize = kSrcStride * kSrcStride + 1; - static const int kDstSize = kDstStride * kDstStride; - - virtual void SetUp() { - width_ = GET_PARAM(0); - height_ = GET_PARAM(1); - sixtap_predict_ = GET_PARAM(2); - memset(src_, 0, kSrcSize); - memset(dst_, 0, kDstSize); - memset(dst_c_, 0, kDstSize); - } - - int width_; - int height_; - SixtapPredictFunc sixtap_predict_; - // The src stores the macroblock we will filter on, and makes it 1 byte larger - // in order to test unaligned access. The result is stored in dst and dst_c(c - // reference code result). - static uint8_t *src_; - static uint8_t *dst_; - static uint8_t *dst_c_; -}; - -uint8_t *SixtapPredictTest::src_ = NULL; -uint8_t *SixtapPredictTest::dst_ = NULL; -uint8_t *SixtapPredictTest::dst_c_ = NULL; - -TEST_P(SixtapPredictTest, TestWithPresetData) { - // Test input - static const uint8_t test_data[kSrcSize] = { - 216, 184, 4, 191, 82, 92, 41, 0, 1, 226, 236, 172, 20, 182, 42, - 226, 177, 79, 94, 77, 179, 203, 206, 198, 22, 192, 19, 75, 17, 192, - 44, 233, 120, 48, 168, 203, 141, 210, 203, 143, 180, 184, 59, 201, 110, - 102, 171, 32, 182, 10, 109, 105, 213, 60, 47, 236, 253, 67, 55, 14, - 3, 99, 247, 124, 148, 159, 71, 34, 114, 19, 177, 38, 203, 237, 239, - 58, 83, 155, 91, 10, 166, 201, 115, 124, 5, 163, 104, 2, 231, 160, - 16, 234, 4, 8, 103, 153, 167, 174, 187, 26, 193, 109, 64, 141, 90, - 48, 200, 174, 204, 36, 184, 114, 237, 43, 238, 242, 207, 86, 245, 182, - 247, 6, 161, 251, 14, 8, 148, 182, 182, 79, 208, 120, 188, 17, 6, - 23, 65, 206, 197, 13, 242, 126, 128, 224, 170, 110, 211, 121, 197, 200, - 47, 188, 207, 208, 184, 221, 216, 76, 148, 143, 156, 100, 8, 89, 117, - 14, 112, 183, 221, 54, 197, 208, 180, 69, 176, 94, 180, 131, 215, 121, - 76, 7, 54, 28, 216, 238, 249, 176, 58, 142, 64, 215, 242, 72, 49, - 104, 87, 161, 32, 52, 216, 230, 4, 141, 44, 181, 235, 224, 57, 195, - 89, 134, 203, 144, 162, 163, 126, 156, 84, 185, 42, 148, 145, 29, 221, - 194, 134, 52, 100, 166, 105, 60, 140, 110, 201, 184, 35, 181, 153, 93, - 121, 243, 227, 68, 131, 134, 232, 2, 35, 60, 187, 77, 209, 76, 106, - 174, 15, 241, 227, 115, 151, 77, 175, 36, 187, 121, 221, 223, 47, 118, - 61, 168, 105, 32, 237, 236, 167, 213, 238, 202, 17, 170, 24, 226, 247, - 131, 145, 6, 116, 117, 121, 11, 194, 41, 48, 126, 162, 13, 93, 209, - 131, 154, 122, 237, 187, 103, 217, 99, 60, 200, 45, 78, 115, 69, 49, - 106, 200, 194, 112, 60, 56, 234, 72, 251, 19, 120, 121, 182, 134, 215, - 135, 10, 114, 2, 247, 46, 105, 209, 145, 165, 153, 191, 243, 12, 5, - 36, 119, 206, 231, 231, 11, 32, 209, 83, 27, 229, 204, 149, 155, 83, - 109, 35, 93, 223, 37, 84, 14, 142, 37, 160, 52, 191, 96, 40, 204, - 101, 77, 67, 52, 53, 43, 63, 85, 253, 147, 113, 226, 96, 6, 125, - 179, 115, 161, 17, 83, 198, 101, 98, 85, 139, 3, 137, 75, 99, 178, - 23, 201, 255, 91, 253, 52, 134, 60, 138, 131, 208, 251, 101, 48, 2, - 227, 228, 118, 132, 245, 202, 75, 91, 44, 160, 231, 47, 41, 50, 147, - 220, 74, 92, 219, 165, 89, 16 - }; - - // Expected result - static const uint8_t expected_dst[kDstSize] = { - 117, 102, 74, 135, 42, 98, 175, 206, 70, 73, 222, 197, 50, 24, 39, - 49, 38, 105, 90, 47, 169, 40, 171, 215, 200, 73, 109, 141, 53, 85, - 177, 164, 79, 208, 124, 89, 212, 18, 81, 145, 151, 164, 217, 153, 91, - 154, 102, 102, 159, 75, 164, 152, 136, 51, 213, 219, 186, 116, 193, 224, - 186, 36, 231, 208, 84, 211, 155, 167, 35, 59, 42, 76, 216, 149, 73, - 201, 78, 149, 184, 100, 96, 196, 189, 198, 188, 235, 195, 117, 129, 120, - 129, 49, 25, 133, 113, 69, 221, 114, 70, 143, 99, 157, 108, 189, 140, - 78, 6, 55, 65, 240, 255, 245, 184, 72, 90, 100, 116, 131, 39, 60, - 234, 167, 33, 160, 88, 185, 200, 157, 159, 176, 127, 151, 138, 102, 168, - 106, 170, 86, 82, 219, 189, 76, 33, 115, 197, 106, 96, 198, 136, 97, - 141, 237, 151, 98, 137, 191, 185, 2, 57, 95, 142, 91, 255, 185, 97, - 137, 76, 162, 94, 173, 131, 193, 161, 81, 106, 72, 135, 222, 234, 137, - 66, 137, 106, 243, 210, 147, 95, 15, 137, 110, 85, 66, 16, 96, 167, - 147, 150, 173, 203, 140, 118, 196, 84, 147, 160, 19, 95, 101, 123, 74, - 132, 202, 82, 166, 12, 131, 166, 189, 170, 159, 85, 79, 66, 57, 152, - 132, 203, 194, 0, 1, 56, 146, 180, 224, 156, 28, 83, 181, 79, 76, - 80, 46, 160, 175, 59, 106, 43, 87, 75, 136, 85, 189, 46, 71, 200, - 90 - }; - - uint8_t *src = const_cast(test_data); - - ASM_REGISTER_STATE_CHECK(sixtap_predict_(&src[kSrcStride * 2 + 2 + 1], - kSrcStride, 2, 2, dst_, kDstStride)); - - for (int i = 0; i < height_; ++i) { - for (int j = 0; j < width_; ++j) - ASSERT_EQ(expected_dst[i * kDstStride + j], dst_[i * kDstStride + j]) - << "i==" << (i * width_ + j); - } -} - -using libvpx_test::ACMRandom; - -TEST_P(SixtapPredictTest, TestWithRandomData) { - ACMRandom rnd(ACMRandom::DeterministicSeed()); - for (int i = 0; i < kSrcSize; ++i) src_[i] = rnd.Rand8(); - - // Run tests for all possible offsets. - for (int xoffset = 0; xoffset < 8; ++xoffset) { - for (int yoffset = 0; yoffset < 8; ++yoffset) { - // Call c reference function. - // Move start point to next pixel to test if the function reads - // unaligned data correctly. - vp8_sixtap_predict16x16_c(&src_[kSrcStride * 2 + 2 + 1], kSrcStride, - xoffset, yoffset, dst_c_, kDstStride); - - // Run test. - ASM_REGISTER_STATE_CHECK(sixtap_predict_(&src_[kSrcStride * 2 + 2 + 1], - kSrcStride, xoffset, yoffset, - dst_, kDstStride)); - - for (int i = 0; i < height_; ++i) { - for (int j = 0; j < width_; ++j) - ASSERT_EQ(dst_c_[i * kDstStride + j], dst_[i * kDstStride + j]) - << "i==" << (i * width_ + j); - } - } - } -} - -using std::tr1::make_tuple; - -INSTANTIATE_TEST_CASE_P( - C, SixtapPredictTest, - ::testing::Values(make_tuple(16, 16, &vp8_sixtap_predict16x16_c), - make_tuple(8, 8, &vp8_sixtap_predict8x8_c), - make_tuple(8, 4, &vp8_sixtap_predict8x4_c), - make_tuple(4, 4, &vp8_sixtap_predict4x4_c))); -#if HAVE_NEON -INSTANTIATE_TEST_CASE_P( - NEON, SixtapPredictTest, - ::testing::Values(make_tuple(16, 16, &vp8_sixtap_predict16x16_neon), - make_tuple(8, 8, &vp8_sixtap_predict8x8_neon), - make_tuple(8, 4, &vp8_sixtap_predict8x4_neon))); -#endif -#if HAVE_MMX -INSTANTIATE_TEST_CASE_P( - MMX, SixtapPredictTest, - ::testing::Values(make_tuple(16, 16, &vp8_sixtap_predict16x16_mmx), - make_tuple(8, 8, &vp8_sixtap_predict8x8_mmx), - make_tuple(8, 4, &vp8_sixtap_predict8x4_mmx), - make_tuple(4, 4, &vp8_sixtap_predict4x4_mmx))); -#endif -#if HAVE_SSE2 -INSTANTIATE_TEST_CASE_P( - SSE2, SixtapPredictTest, - ::testing::Values(make_tuple(16, 16, &vp8_sixtap_predict16x16_sse2), - make_tuple(8, 8, &vp8_sixtap_predict8x8_sse2), - make_tuple(8, 4, &vp8_sixtap_predict8x4_sse2))); -#endif -#if HAVE_SSSE3 -INSTANTIATE_TEST_CASE_P( - SSSE3, SixtapPredictTest, - ::testing::Values(make_tuple(16, 16, &vp8_sixtap_predict16x16_ssse3), - make_tuple(8, 8, &vp8_sixtap_predict8x8_ssse3), - make_tuple(8, 4, &vp8_sixtap_predict8x4_ssse3), - make_tuple(4, 4, &vp8_sixtap_predict4x4_ssse3))); -#endif -#if HAVE_MSA -INSTANTIATE_TEST_CASE_P( - MSA, SixtapPredictTest, - ::testing::Values(make_tuple(16, 16, &vp8_sixtap_predict16x16_msa), - make_tuple(8, 8, &vp8_sixtap_predict8x8_msa), - make_tuple(8, 4, &vp8_sixtap_predict8x4_msa), - make_tuple(4, 4, &vp8_sixtap_predict4x4_msa))); -#endif -} // namespace diff --git a/test/test.mk b/test/test.mk index aad2645..60218a7 100644 --- a/test/test.mk +++ b/test/test.mk @@ -119,7 +119,7 @@ LIBVPX_TEST_SRCS-$(CONFIG_VP8_ENCODER) += variance_test.cc LIBVPX_TEST_SRCS-$(CONFIG_VP8_ENCODER) += vp8_fdct4x4_test.cc LIBVPX_TEST_SRCS-yes += idct_test.cc -LIBVPX_TEST_SRCS-yes += sixtap_predict_test.cc +LIBVPX_TEST_SRCS-yes += predict_test.cc LIBVPX_TEST_SRCS-yes += vpx_scale_test.cc ifeq ($(CONFIG_VP8_ENCODER)$(CONFIG_TEMPORAL_DENOISING),yesyes) -- 2.7.4