ref: 18fd69ee915d6a58cceb59688c149c2c7df29922
parent: 0d2687ef87645469ff20f2562104f630364ec765
parent: caf9a7841eff9e9931f6b85cb4226a4e247b8466
author: Johann Koenig <[email protected]>
date: Tue Sep 20 16:30:48 EDT 2016
Merge "Add vp8_bilinear_filter test"
--- /dev/null
+++ b/test/predict_test.cc
@@ -1,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 <stdlib.h>
+#include <string.h>
+
+#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<int, int, PredictFunc> PredictParam;
+
+class PredictTestBase : public ::testing::TestWithParam<PredictParam> {+ 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<int>(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<uint8_t *>(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
--- a/test/sixtap_predict_test.cc
+++ /dev/null
@@ -1,231 +1,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 <math.h>
-#include <stdlib.h>
-#include <string.h>
-
-#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<int, int, SixtapPredictFunc> SixtapPredictParam;
-
-class SixtapPredictTest : public ::testing::TestWithParam<SixtapPredictParam> {- public:
- static void SetUpTestCase() {- src_ = reinterpret_cast<uint8_t *>(vpx_memalign(kDataAlignment, kSrcSize));
- dst_ = reinterpret_cast<uint8_t *>(vpx_memalign(kDataAlignment, kDstSize));
- dst_c_ =
- reinterpret_cast<uint8_t *>(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<uint8_t *>(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
--- a/test/test.mk
+++ b/test/test.mk
@@ -119,7 +119,7 @@
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)