diff options
Diffstat (limited to 'test')
| -rw-r--r-- | test/convolve_test.cc | 22 | ||||
| -rw-r--r-- | test/dct16x16_test.cc | 69 | ||||
| -rw-r--r-- | test/dct32x32_test.cc | 5 | ||||
| -rw-r--r-- | test/fdct4x4_test.cc | 5 | ||||
| -rw-r--r-- | test/fdct8x8_test.cc | 24 | ||||
| -rw-r--r-- | test/sad_test.cc | 352 |
6 files changed, 330 insertions, 147 deletions
diff --git a/test/convolve_test.cc b/test/convolve_test.cc index 2d89429a1..3412ddd23 100644 --- a/test/convolve_test.cc +++ b/test/convolve_test.cc @@ -644,6 +644,28 @@ INSTANTIATE_TEST_CASE_P(SSSE3, ConvolveTest, ::testing::Values( make_tuple(64, 64, &convolve8_ssse3))); #endif +#if HAVE_AVX2 +const ConvolveFunctions convolve8_avx2( + vp9_convolve8_horiz_avx2, vp9_convolve8_avg_horiz_ssse3, + vp9_convolve8_vert_avx2, vp9_convolve8_avg_vert_ssse3, + vp9_convolve8_avx2, vp9_convolve8_avg_ssse3); + +INSTANTIATE_TEST_CASE_P(AVX2, ConvolveTest, ::testing::Values( + make_tuple(4, 4, &convolve8_avx2), + make_tuple(8, 4, &convolve8_avx2), + make_tuple(4, 8, &convolve8_avx2), + make_tuple(8, 8, &convolve8_avx2), + make_tuple(16, 8, &convolve8_avx2), + make_tuple(8, 16, &convolve8_avx2), + make_tuple(16, 16, &convolve8_avx2), + make_tuple(32, 16, &convolve8_avx2), + make_tuple(16, 32, &convolve8_avx2), + make_tuple(32, 32, &convolve8_avx2), + make_tuple(64, 32, &convolve8_avx2), + make_tuple(32, 64, &convolve8_avx2), + make_tuple(64, 64, &convolve8_avx2))); +#endif + #if HAVE_NEON_ASM const ConvolveFunctions convolve8_neon( vp9_convolve8_horiz_neon, vp9_convolve8_avg_horiz_neon, diff --git a/test/dct16x16_test.cc b/test/dct16x16_test.cc index 20b1c8fbd..99c8d0c7c 100644 --- a/test/dct16x16_test.cc +++ b/test/dct16x16_test.cc @@ -272,10 +272,18 @@ void fdct16x16_ref(const int16_t *in, int16_t *out, int stride, int tx_type) { vp9_fdct16x16_c(in, out, stride); } +void idct16x16_ref(const int16_t *in, uint8_t *dest, int stride, int tx_type) { + vp9_idct16x16_256_add_c(in, dest, stride); +} + void fht16x16_ref(const int16_t *in, int16_t *out, int stride, int tx_type) { vp9_fht16x16_c(in, out, stride, tx_type); } +void iht16x16_ref(const int16_t *in, uint8_t *dest, int stride, int tx_type) { + vp9_iht16x16_256_add_c(in, dest, stride, tx_type); +} + class Trans16x16TestBase { public: virtual ~Trans16x16TestBase() {} @@ -358,12 +366,13 @@ class Trans16x16TestBase { input_block[j] = rnd.Rand8() - rnd.Rand8(); input_extreme_block[j] = rnd.Rand8() % 2 ? 255 : -255; } - if (i == 0) + if (i == 0) { for (int j = 0; j < kNumCoeffs; ++j) input_extreme_block[j] = 255; - if (i == 1) + } else if (i == 1) { for (int j = 0; j < kNumCoeffs; ++j) input_extreme_block[j] = -255; + } fwd_txfm_ref(input_extreme_block, output_ref_block, pitch_, tx_type_); REGISTER_STATE_CHECK(RunFwdTxfm(input_extreme_block, @@ -378,6 +387,47 @@ class Trans16x16TestBase { } } + void RunQuantCheck(int dc_thred, int ac_thred) { + ACMRandom rnd(ACMRandom::DeterministicSeed()); + const int count_test_block = 1000; + DECLARE_ALIGNED_ARRAY(16, int16_t, input_block, kNumCoeffs); + DECLARE_ALIGNED_ARRAY(16, int16_t, input_extreme_block, kNumCoeffs); + DECLARE_ALIGNED_ARRAY(16, int16_t, output_ref_block, kNumCoeffs); + + DECLARE_ALIGNED_ARRAY(16, uint8_t, dst, kNumCoeffs); + DECLARE_ALIGNED_ARRAY(16, uint8_t, ref, kNumCoeffs); + + for (int i = 0; i < count_test_block; ++i) { + // Initialize a test block with input range [-255, 255]. + for (int j = 0; j < kNumCoeffs; ++j) { + input_block[j] = rnd.Rand8() - rnd.Rand8(); + input_extreme_block[j] = rnd.Rand8() % 2 ? 255 : -255; + } + if (i == 0) + for (int j = 0; j < kNumCoeffs; ++j) + input_extreme_block[j] = 255; + if (i == 1) + for (int j = 0; j < kNumCoeffs; ++j) + input_extreme_block[j] = -255; + + fwd_txfm_ref(input_extreme_block, output_ref_block, pitch_, tx_type_); + + // clear reconstructed pixel buffers + vpx_memset(dst, 0, kNumCoeffs * sizeof(uint8_t)); + vpx_memset(ref, 0, kNumCoeffs * sizeof(uint8_t)); + + // quantization with maximum allowed step sizes + output_ref_block[0] = (output_ref_block[0] / dc_thred) * dc_thred; + for (int j = 1; j < kNumCoeffs; ++j) + output_ref_block[j] = (output_ref_block[j] / ac_thred) * ac_thred; + inv_txfm_ref(output_ref_block, ref, pitch_, tx_type_); + REGISTER_STATE_CHECK(RunInvTxfm(output_ref_block, dst, pitch_)); + + for (int j = 0; j < kNumCoeffs; ++j) + EXPECT_EQ(ref[j], dst[j]); + } + } + void RunInvAccuracyCheck() { ACMRandom rnd(ACMRandom::DeterministicSeed()); const int count_test_block = 1000; @@ -414,6 +464,7 @@ class Trans16x16TestBase { int pitch_; int tx_type_; fht_t fwd_txfm_ref; + iht_t inv_txfm_ref; }; class Trans16x16DCT @@ -428,6 +479,7 @@ class Trans16x16DCT tx_type_ = GET_PARAM(2); pitch_ = 16; fwd_txfm_ref = fdct16x16_ref; + inv_txfm_ref = idct16x16_ref; } virtual void TearDown() { libvpx_test::ClearSystemState(); } @@ -455,6 +507,12 @@ TEST_P(Trans16x16DCT, MemCheck) { RunMemCheck(); } +TEST_P(Trans16x16DCT, QuantCheck) { + // Use maximally allowed quantization step sizes for DC and AC + // coefficients respectively. + RunQuantCheck(1336, 1828); +} + TEST_P(Trans16x16DCT, InvAccuracyCheck) { RunInvAccuracyCheck(); } @@ -471,6 +529,7 @@ class Trans16x16HT tx_type_ = GET_PARAM(2); pitch_ = 16; fwd_txfm_ref = fht16x16_ref; + inv_txfm_ref = iht16x16_ref; } virtual void TearDown() { libvpx_test::ClearSystemState(); } @@ -498,6 +557,12 @@ TEST_P(Trans16x16HT, MemCheck) { RunMemCheck(); } +TEST_P(Trans16x16HT, QuantCheck) { + // The encoder skips any non-DC intra prediction modes, + // when the quantization step size goes beyond 988. + RunQuantCheck(549, 988); +} + using std::tr1::make_tuple; INSTANTIATE_TEST_CASE_P( diff --git a/test/dct32x32_test.cc b/test/dct32x32_test.cc index 72c0bd69d..501c69621 100644 --- a/test/dct32x32_test.cc +++ b/test/dct32x32_test.cc @@ -179,12 +179,13 @@ TEST_P(Trans32x32Test, MemCheck) { input_block[j] = rnd.Rand8() - rnd.Rand8(); input_extreme_block[j] = rnd.Rand8() & 1 ? 255 : -255; } - if (i == 0) + if (i == 0) { for (int j = 0; j < kNumCoeffs; ++j) input_extreme_block[j] = 255; - if (i == 1) + } else if (i == 1) { for (int j = 0; j < kNumCoeffs; ++j) input_extreme_block[j] = -255; + } const int stride = 32; vp9_fdct32x32_c(input_extreme_block, output_ref_block, stride); diff --git a/test/fdct4x4_test.cc b/test/fdct4x4_test.cc index 030665eda..961eb4d6c 100644 --- a/test/fdct4x4_test.cc +++ b/test/fdct4x4_test.cc @@ -136,12 +136,13 @@ class Trans4x4TestBase { input_block[j] = rnd.Rand8() - rnd.Rand8(); input_extreme_block[j] = rnd.Rand8() % 2 ? 255 : -255; } - if (i == 0) + if (i == 0) { for (int j = 0; j < kNumCoeffs; ++j) input_extreme_block[j] = 255; - if (i == 1) + } else if (i == 1) { for (int j = 0; j < kNumCoeffs; ++j) input_extreme_block[j] = -255; + } fwd_txfm_ref(input_extreme_block, output_ref_block, pitch_, tx_type_); REGISTER_STATE_CHECK(RunFwdTxfm(input_extreme_block, diff --git a/test/fdct8x8_test.cc b/test/fdct8x8_test.cc index c7cf1640c..1d1881a22 100644 --- a/test/fdct8x8_test.cc +++ b/test/fdct8x8_test.cc @@ -177,9 +177,11 @@ class FwdTrans8x8TestBase { ACMRandom rnd(ACMRandom::DeterministicSeed()); int max_error = 0; int total_error = 0; + int total_coeff_error = 0; const int count_test_block = 100000; DECLARE_ALIGNED_ARRAY(16, int16_t, test_input_block, 64); DECLARE_ALIGNED_ARRAY(16, int16_t, test_temp_block, 64); + DECLARE_ALIGNED_ARRAY(16, int16_t, ref_temp_block, 64); DECLARE_ALIGNED_ARRAY(16, uint8_t, dst, 64); DECLARE_ALIGNED_ARRAY(16, uint8_t, src, 64); @@ -187,13 +189,24 @@ class FwdTrans8x8TestBase { // Initialize a test block with input range [-255, 255]. for (int j = 0; j < 64; ++j) { src[j] = rnd.Rand8() % 2 ? 255 : 0; - dst[j] = src[j] > 0 ? 0 : 255; + dst[j] = rnd.Rand8() % 2 ? 255 : 0; + + if (i == 0) { + src[j] = 255; + dst[j] = 0; + } else if (i == 1) { + src[j] = 0; + dst[j] = 255; + } + test_input_block[j] = src[j] - dst[j]; } REGISTER_STATE_CHECK( RunFwdTxfm(test_input_block, test_temp_block, pitch_)); REGISTER_STATE_CHECK( + fwd_txfm_ref(test_input_block, ref_temp_block, pitch_, tx_type_)); + REGISTER_STATE_CHECK( RunInvTxfm(test_temp_block, dst, pitch_)); for (int j = 0; j < 64; ++j) { @@ -202,6 +215,9 @@ class FwdTrans8x8TestBase { if (max_error < error) max_error = error; total_error += error; + + const int coeff_diff = test_temp_block[j] - ref_temp_block[j]; + total_coeff_error += abs(coeff_diff); } EXPECT_GE(1, max_error) @@ -211,6 +227,10 @@ class FwdTrans8x8TestBase { EXPECT_GE(count_test_block/5, total_error) << "Error: Extremal 8x8 FDCT/IDCT or FHT/IHT has average" << " roundtrip error > 1/5 per block"; + + EXPECT_EQ(0, total_coeff_error) + << "Error: Extremal 8x8 FDCT/FHT has" + << "overflow issues in the intermediate steps > 1"; } } @@ -343,7 +363,7 @@ INSTANTIATE_TEST_CASE_P( #if HAVE_SSSE3 && ARCH_X86_64 INSTANTIATE_TEST_CASE_P( - SSSE3, FwdTrans8x8DCT, + DISABLED_SSSE3, FwdTrans8x8DCT, ::testing::Values( make_tuple(&vp9_fdct8x8_ssse3, &vp9_idct8x8_64_add_ssse3, 0))); #endif diff --git a/test/sad_test.cc b/test/sad_test.cc index a692891ad..f9ffa92de 100644 --- a/test/sad_test.cc +++ b/test/sad_test.cc @@ -29,12 +29,22 @@ #include "third_party/googletest/src/include/gtest/gtest.h" +#if CONFIG_VP8_ENCODER typedef unsigned int (*sad_m_by_n_fn_t)(const unsigned char *source_ptr, int source_stride, const unsigned char *reference_ptr, int reference_stride, unsigned int max_sad); typedef std::tr1::tuple<int, int, sad_m_by_n_fn_t> sad_m_by_n_test_param_t; +#endif +#if CONFIG_VP9_ENCODER +typedef unsigned int (*sad_m_by_n_fn_vp9_t)(const unsigned char *source_ptr, + int source_stride, + const unsigned char *reference_ptr, + int reference_stride); +typedef std::tr1::tuple<int, int, sad_m_by_n_fn_vp9_t> + sad_m_by_n_test_param_vp9_t; +#endif typedef void (*sad_n_by_n_by_4_fn_t)(const uint8_t *src_ptr, int src_stride, @@ -87,7 +97,7 @@ class SADTestBase : public ::testing::Test { // Sum of Absolute Differences. Given two blocks, calculate the absolute // difference between two pixels in the same relative location; accumulate. - unsigned int ReferenceSAD(unsigned int max_sad, int block_idx = 0) { + unsigned int ReferenceSAD(unsigned int max_sad, int block_idx) { unsigned int sad = 0; const uint8_t* const reference = GetReference(block_idx); @@ -128,13 +138,43 @@ class SADTestBase : public ::testing::Test { ACMRandom rnd_; }; -class SADTest : public SADTestBase, - public ::testing::WithParamInterface<sad_m_by_n_test_param_t> { +class SADx4Test + : public SADTestBase, + public ::testing::WithParamInterface<sad_n_by_n_by_4_test_param_t> { + public: + SADx4Test() : SADTestBase(GET_PARAM(0), GET_PARAM(1)) {} + + protected: + void SADs(unsigned int *results) { + const uint8_t* refs[] = {GetReference(0), GetReference(1), + GetReference(2), GetReference(3)}; + + REGISTER_STATE_CHECK(GET_PARAM(2)(source_data_, source_stride_, + refs, reference_stride_, + results)); + } + + void CheckSADs() { + unsigned int reference_sad, exp_sad[4]; + + SADs(exp_sad); + for (int block = 0; block < 4; ++block) { + reference_sad = ReferenceSAD(UINT_MAX, block); + + EXPECT_EQ(reference_sad, exp_sad[block]) << "block " << block; + } + } +}; + +#if CONFIG_VP8_ENCODER +class SADTest + : public SADTestBase, + public ::testing::WithParamInterface<sad_m_by_n_test_param_t> { public: SADTest() : SADTestBase(GET_PARAM(0), GET_PARAM(1)) {} protected: - unsigned int SAD(unsigned int max_sad, int block_idx = 0) { + unsigned int SAD(unsigned int max_sad, int block_idx) { unsigned int ret; const uint8_t* const reference = GetReference(block_idx); @@ -144,11 +184,9 @@ class SADTest : public SADTestBase, return ret; } - void CheckSad(unsigned int max_sad) { - unsigned int reference_sad, exp_sad; - - reference_sad = ReferenceSAD(max_sad); - exp_sad = SAD(max_sad); + void CheckSAD(unsigned int max_sad) { + const unsigned int reference_sad = ReferenceSAD(max_sad, 0); + const unsigned int exp_sad = SAD(max_sad, 0); if (reference_sad <= max_sad) { ASSERT_EQ(exp_sad, reference_sad); @@ -158,43 +196,131 @@ class SADTest : public SADTestBase, } } }; +#endif // CONFIG_VP8_ENCODER -class SADx4Test : public SADTestBase, - public ::testing::WithParamInterface<sad_n_by_n_by_4_test_param_t> { +#if CONFIG_VP9_ENCODER +class SADVP9Test + : public SADTestBase, + public ::testing::WithParamInterface<sad_m_by_n_test_param_vp9_t> { public: - SADx4Test() : SADTestBase(GET_PARAM(0), GET_PARAM(1)) {} + SADVP9Test() : SADTestBase(GET_PARAM(0), GET_PARAM(1)) {} protected: - void SADs(unsigned int *results) { - const uint8_t* refs[] = {GetReference(0), GetReference(1), - GetReference(2), GetReference(3)}; + unsigned int SAD(int block_idx) { + unsigned int ret; + const uint8_t* const reference = GetReference(block_idx); - REGISTER_STATE_CHECK(GET_PARAM(2)(source_data_, source_stride_, - refs, reference_stride_, - results)); + REGISTER_STATE_CHECK(ret = GET_PARAM(2)(source_data_, source_stride_, + reference, reference_stride_)); + return ret; } - void CheckSADs() { - unsigned int reference_sad, exp_sad[4]; - - SADs(exp_sad); - for (int block = 0; block < 4; block++) { - reference_sad = ReferenceSAD(UINT_MAX, block); + void CheckSAD() { + const unsigned int reference_sad = ReferenceSAD(UINT_MAX, 0); + const unsigned int exp_sad = SAD(0); - EXPECT_EQ(exp_sad[block], reference_sad) << "block " << block; - } + ASSERT_EQ(reference_sad, exp_sad); } }; +#endif // CONFIG_VP9_ENCODER uint8_t* SADTestBase::source_data_ = NULL; uint8_t* SADTestBase::reference_data_ = NULL; +#if CONFIG_VP8_ENCODER TEST_P(SADTest, MaxRef) { FillConstant(source_data_, source_stride_, 0); FillConstant(reference_data_, reference_stride_, 255); - CheckSad(UINT_MAX); + CheckSAD(UINT_MAX); +} + +TEST_P(SADTest, MaxSrc) { + FillConstant(source_data_, source_stride_, 255); + FillConstant(reference_data_, reference_stride_, 0); + CheckSAD(UINT_MAX); +} + +TEST_P(SADTest, ShortRef) { + int tmp_stride = reference_stride_; + reference_stride_ >>= 1; + FillRandom(source_data_, source_stride_); + FillRandom(reference_data_, reference_stride_); + CheckSAD(UINT_MAX); + reference_stride_ = tmp_stride; +} + +TEST_P(SADTest, UnalignedRef) { + // The reference frame, but not the source frame, may be unaligned for + // certain types of searches. + const int tmp_stride = reference_stride_; + reference_stride_ -= 1; + FillRandom(source_data_, source_stride_); + FillRandom(reference_data_, reference_stride_); + CheckSAD(UINT_MAX); + reference_stride_ = tmp_stride; +} + +TEST_P(SADTest, ShortSrc) { + const int tmp_stride = source_stride_; + source_stride_ >>= 1; + FillRandom(source_data_, source_stride_); + FillRandom(reference_data_, reference_stride_); + CheckSAD(UINT_MAX); + source_stride_ = tmp_stride; +} + +TEST_P(SADTest, MaxSAD) { + // Verify that, when max_sad is set, the implementation does not return a + // value lower than the reference. + FillConstant(source_data_, source_stride_, 255); + FillConstant(reference_data_, reference_stride_, 0); + CheckSAD(128); +} +#endif // CONFIG_VP8_ENCODER + +#if CONFIG_VP9_ENCODER +TEST_P(SADVP9Test, MaxRef) { + FillConstant(source_data_, source_stride_, 0); + FillConstant(reference_data_, reference_stride_, 255); + CheckSAD(); +} + +TEST_P(SADVP9Test, MaxSrc) { + FillConstant(source_data_, source_stride_, 255); + FillConstant(reference_data_, reference_stride_, 0); + CheckSAD(); } +TEST_P(SADVP9Test, ShortRef) { + const int tmp_stride = reference_stride_; + reference_stride_ >>= 1; + FillRandom(source_data_, source_stride_); + FillRandom(reference_data_, reference_stride_); + CheckSAD(); + reference_stride_ = tmp_stride; +} + +TEST_P(SADVP9Test, UnalignedRef) { + // The reference frame, but not the source frame, may be unaligned for + // certain types of searches. + const int tmp_stride = reference_stride_; + reference_stride_ -= 1; + FillRandom(source_data_, source_stride_); + FillRandom(reference_data_, reference_stride_); + CheckSAD(); + reference_stride_ = tmp_stride; +} + +TEST_P(SADVP9Test, ShortSrc) { + const int tmp_stride = source_stride_; + source_stride_ >>= 1; + FillRandom(source_data_, source_stride_); + FillRandom(reference_data_, reference_stride_); + CheckSAD(); + source_stride_ = tmp_stride; +} +#endif // CONFIG_VP9_ENCODER + TEST_P(SADx4Test, MaxRef) { FillConstant(source_data_, source_stride_, 0); FillConstant(GetReference(0), reference_stride_, 255); @@ -204,12 +330,6 @@ TEST_P(SADx4Test, MaxRef) { CheckSADs(); } -TEST_P(SADTest, MaxSrc) { - FillConstant(source_data_, source_stride_, 255); - FillConstant(reference_data_, reference_stride_, 0); - CheckSad(UINT_MAX); -} - TEST_P(SADx4Test, MaxSrc) { FillConstant(source_data_, source_stride_, 255); FillConstant(GetReference(0), reference_stride_, 0); @@ -219,15 +339,6 @@ TEST_P(SADx4Test, MaxSrc) { CheckSADs(); } -TEST_P(SADTest, ShortRef) { - int tmp_stride = reference_stride_; - reference_stride_ >>= 1; - FillRandom(source_data_, source_stride_); - FillRandom(reference_data_, reference_stride_); - CheckSad(UINT_MAX); - reference_stride_ = tmp_stride; -} - TEST_P(SADx4Test, ShortRef) { int tmp_stride = reference_stride_; reference_stride_ >>= 1; @@ -240,17 +351,6 @@ TEST_P(SADx4Test, ShortRef) { reference_stride_ = tmp_stride; } -TEST_P(SADTest, UnalignedRef) { - // The reference frame, but not the source frame, may be unaligned for - // certain types of searches. - int tmp_stride = reference_stride_; - reference_stride_ -= 1; - FillRandom(source_data_, source_stride_); - FillRandom(reference_data_, reference_stride_); - CheckSad(UINT_MAX); - reference_stride_ = tmp_stride; -} - TEST_P(SADx4Test, UnalignedRef) { // The reference frame, but not the source frame, may be unaligned for // certain types of searches. @@ -265,15 +365,6 @@ TEST_P(SADx4Test, UnalignedRef) { reference_stride_ = tmp_stride; } -TEST_P(SADTest, ShortSrc) { - int tmp_stride = source_stride_; - source_stride_ >>= 1; - FillRandom(source_data_, source_stride_); - FillRandom(reference_data_, reference_stride_); - CheckSad(UINT_MAX); - source_stride_ = tmp_stride; -} - TEST_P(SADx4Test, ShortSrc) { int tmp_stride = source_stride_; source_stride_ >>= 1; @@ -286,14 +377,6 @@ TEST_P(SADx4Test, ShortSrc) { source_stride_ = tmp_stride; } -TEST_P(SADTest, MaxSAD) { - // Verify that, when max_sad is set, the implementation does not return a - // value lower than the reference. - FillConstant(source_data_, source_stride_, 255); - FillConstant(reference_data_, reference_stride_, 0); - CheckSad(128); -} - using std::tr1::make_tuple; //------------------------------------------------------------------------------ @@ -304,27 +387,27 @@ const sad_m_by_n_fn_t sad_8x16_c = vp8_sad8x16_c; const sad_m_by_n_fn_t sad_16x8_c = vp8_sad16x8_c; const sad_m_by_n_fn_t sad_8x8_c = vp8_sad8x8_c; const sad_m_by_n_fn_t sad_4x4_c = vp8_sad4x4_c; -#endif -#if CONFIG_VP9_ENCODER -const sad_m_by_n_fn_t sad_64x64_c_vp9 = vp9_sad64x64_c; -const sad_m_by_n_fn_t sad_32x32_c_vp9 = vp9_sad32x32_c; -const sad_m_by_n_fn_t sad_16x16_c_vp9 = vp9_sad16x16_c; -const sad_m_by_n_fn_t sad_8x16_c_vp9 = vp9_sad8x16_c; -const sad_m_by_n_fn_t sad_16x8_c_vp9 = vp9_sad16x8_c; -const sad_m_by_n_fn_t sad_8x8_c_vp9 = vp9_sad8x8_c; -const sad_m_by_n_fn_t sad_8x4_c_vp9 = vp9_sad8x4_c; -const sad_m_by_n_fn_t sad_4x8_c_vp9 = vp9_sad4x8_c; -const sad_m_by_n_fn_t sad_4x4_c_vp9 = vp9_sad4x4_c; -#endif const sad_m_by_n_test_param_t c_tests[] = { -#if CONFIG_VP8_ENCODER make_tuple(16, 16, sad_16x16_c), make_tuple(8, 16, sad_8x16_c), make_tuple(16, 8, sad_16x8_c), make_tuple(8, 8, sad_8x8_c), make_tuple(4, 4, sad_4x4_c), -#endif +}; +INSTANTIATE_TEST_CASE_P(C, SADTest, ::testing::ValuesIn(c_tests)); +#endif // CONFIG_VP8_ENCODER + #if CONFIG_VP9_ENCODER +const sad_m_by_n_fn_vp9_t sad_64x64_c_vp9 = vp9_sad64x64_c; +const sad_m_by_n_fn_vp9_t sad_32x32_c_vp9 = vp9_sad32x32_c; +const sad_m_by_n_fn_vp9_t sad_16x16_c_vp9 = vp9_sad16x16_c; +const sad_m_by_n_fn_vp9_t sad_8x16_c_vp9 = vp9_sad8x16_c; +const sad_m_by_n_fn_vp9_t sad_16x8_c_vp9 = vp9_sad16x8_c; +const sad_m_by_n_fn_vp9_t sad_8x8_c_vp9 = vp9_sad8x8_c; +const sad_m_by_n_fn_vp9_t sad_8x4_c_vp9 = vp9_sad8x4_c; +const sad_m_by_n_fn_vp9_t sad_4x8_c_vp9 = vp9_sad4x8_c; +const sad_m_by_n_fn_vp9_t sad_4x4_c_vp9 = vp9_sad4x4_c; +const sad_m_by_n_test_param_vp9_t c_vp9_tests[] = { make_tuple(64, 64, sad_64x64_c_vp9), make_tuple(32, 32, sad_32x32_c_vp9), make_tuple(16, 16, sad_16x16_c_vp9), @@ -334,11 +417,9 @@ const sad_m_by_n_test_param_t c_tests[] = { make_tuple(8, 4, sad_8x4_c_vp9), make_tuple(4, 8, sad_4x8_c_vp9), make_tuple(4, 4, sad_4x4_c_vp9), -#endif }; -INSTANTIATE_TEST_CASE_P(C, SADTest, ::testing::ValuesIn(c_tests)); +INSTANTIATE_TEST_CASE_P(C, SADVP9Test, ::testing::ValuesIn(c_vp9_tests)); -#if CONFIG_VP9_ENCODER const sad_n_by_n_by_4_fn_t sad_64x64x4d_c = vp9_sad64x64x4d_c; const sad_n_by_n_by_4_fn_t sad_64x32x4d_c = vp9_sad64x32x4d_c; const sad_n_by_n_by_4_fn_t sad_32x64x4d_c = vp9_sad32x64x4d_c; @@ -375,8 +456,8 @@ INSTANTIATE_TEST_CASE_P(C, SADx4Test, ::testing::Values( const sad_m_by_n_fn_t sad_16x16_armv6 = vp8_sad16x16_armv6; INSTANTIATE_TEST_CASE_P(MEDIA, SADTest, ::testing::Values( make_tuple(16, 16, sad_16x16_armv6))); -#endif -#endif +#endif // CONFIG_VP8_ENCODER +#endif // HAVE_MEDIA #if HAVE_NEON #if CONFIG_VP8_ENCODER @@ -391,8 +472,8 @@ INSTANTIATE_TEST_CASE_P(NEON, SADTest, ::testing::Values( make_tuple(16, 8, sad_16x8_neon), make_tuple(8, 8, sad_8x8_neon), make_tuple(4, 4, sad_4x4_neon))); -#endif -#endif +#endif // CONFIG_VP8_ENCODER +#endif // HAVE_NEON //------------------------------------------------------------------------------ // x86 functions @@ -403,40 +484,39 @@ const sad_m_by_n_fn_t sad_8x16_mmx = vp8_sad8x16_mmx; const sad_m_by_n_fn_t sad_16x8_mmx = vp8_sad16x8_mmx; const sad_m_by_n_fn_t sad_8x8_mmx = vp8_sad8x8_mmx; const sad_m_by_n_fn_t sad_4x4_mmx = vp8_sad4x4_mmx; -#endif -#if CONFIG_VP9_ENCODER -const sad_m_by_n_fn_t sad_16x16_mmx_vp9 = vp9_sad16x16_mmx; -const sad_m_by_n_fn_t sad_8x16_mmx_vp9 = vp9_sad8x16_mmx; -const sad_m_by_n_fn_t sad_16x8_mmx_vp9 = vp9_sad16x8_mmx; -const sad_m_by_n_fn_t sad_8x8_mmx_vp9 = vp9_sad8x8_mmx; -const sad_m_by_n_fn_t sad_4x4_mmx_vp9 = vp9_sad4x4_mmx; -#endif - const sad_m_by_n_test_param_t mmx_tests[] = { -#if CONFIG_VP8_ENCODER make_tuple(16, 16, sad_16x16_mmx), make_tuple(8, 16, sad_8x16_mmx), make_tuple(16, 8, sad_16x8_mmx), make_tuple(8, 8, sad_8x8_mmx), make_tuple(4, 4, sad_4x4_mmx), -#endif +}; +INSTANTIATE_TEST_CASE_P(MMX, SADTest, ::testing::ValuesIn(mmx_tests)); +#endif // CONFIG_VP8_ENCODER + #if CONFIG_VP9_ENCODER +const sad_m_by_n_fn_vp9_t sad_16x16_mmx_vp9 = vp9_sad16x16_mmx; +const sad_m_by_n_fn_vp9_t sad_8x16_mmx_vp9 = vp9_sad8x16_mmx; +const sad_m_by_n_fn_vp9_t sad_16x8_mmx_vp9 = vp9_sad16x8_mmx; +const sad_m_by_n_fn_vp9_t sad_8x8_mmx_vp9 = vp9_sad8x8_mmx; +const sad_m_by_n_fn_vp9_t sad_4x4_mmx_vp9 = vp9_sad4x4_mmx; +const sad_m_by_n_test_param_vp9_t mmx_vp9_tests[] = { make_tuple(16, 16, sad_16x16_mmx_vp9), make_tuple(8, 16, sad_8x16_mmx_vp9), make_tuple(16, 8, sad_16x8_mmx_vp9), make_tuple(8, 8, sad_8x8_mmx_vp9), make_tuple(4, 4, sad_4x4_mmx_vp9), -#endif }; -INSTANTIATE_TEST_CASE_P(MMX, SADTest, ::testing::ValuesIn(mmx_tests)); -#endif +INSTANTIATE_TEST_CASE_P(MMX, SADVP9Test, ::testing::ValuesIn(mmx_vp9_tests)); +#endif // CONFIG_VP9_ENCODER +#endif // HAVE_MMX #if HAVE_SSE #if CONFIG_VP9_ENCODER #if CONFIG_USE_X86INC -const sad_m_by_n_fn_t sad_4x4_sse_vp9 = vp9_sad4x4_sse; -const sad_m_by_n_fn_t sad_4x8_sse_vp9 = vp9_sad4x8_sse; -INSTANTIATE_TEST_CASE_P(SSE, SADTest, ::testing::Values( +const sad_m_by_n_fn_vp9_t sad_4x4_sse_vp9 = vp9_sad4x4_sse; +const sad_m_by_n_fn_vp9_t sad_4x8_sse_vp9 = vp9_sad4x8_sse; +INSTANTIATE_TEST_CASE_P(SSE, SADVP9Test, ::testing::Values( make_tuple(4, 4, sad_4x4_sse_vp9), make_tuple(4, 8, sad_4x8_sse_vp9))); @@ -456,32 +536,30 @@ const sad_m_by_n_fn_t sad_8x16_wmt = vp8_sad8x16_wmt; const sad_m_by_n_fn_t sad_16x8_wmt = vp8_sad16x8_wmt; const sad_m_by_n_fn_t sad_8x8_wmt = vp8_sad8x8_wmt; const sad_m_by_n_fn_t sad_4x4_wmt = vp8_sad4x4_wmt; -#endif -#if CONFIG_VP9_ENCODER -#if CONFIG_USE_X86INC -const sad_m_by_n_fn_t sad_64x64_sse2_vp9 = vp9_sad64x64_sse2; -const sad_m_by_n_fn_t sad_64x32_sse2_vp9 = vp9_sad64x32_sse2; -const sad_m_by_n_fn_t sad_32x64_sse2_vp9 = vp9_sad32x64_sse2; -const sad_m_by_n_fn_t sad_32x32_sse2_vp9 = vp9_sad32x32_sse2; -const sad_m_by_n_fn_t sad_32x16_sse2_vp9 = vp9_sad32x16_sse2; -const sad_m_by_n_fn_t sad_16x32_sse2_vp9 = vp9_sad16x32_sse2; -const sad_m_by_n_fn_t sad_16x16_sse2_vp9 = vp9_sad16x16_sse2; -const sad_m_by_n_fn_t sad_16x8_sse2_vp9 = vp9_sad16x8_sse2; -const sad_m_by_n_fn_t sad_8x16_sse2_vp9 = vp9_sad8x16_sse2; -const sad_m_by_n_fn_t sad_8x8_sse2_vp9 = vp9_sad8x8_sse2; -const sad_m_by_n_fn_t sad_8x4_sse2_vp9 = vp9_sad8x4_sse2; -#endif -#endif const sad_m_by_n_test_param_t sse2_tests[] = { -#if CONFIG_VP8_ENCODER make_tuple(16, 16, sad_16x16_wmt), make_tuple(8, 16, sad_8x16_wmt), make_tuple(16, 8, sad_16x8_wmt), make_tuple(8, 8, sad_8x8_wmt), make_tuple(4, 4, sad_4x4_wmt), -#endif +}; +INSTANTIATE_TEST_CASE_P(SSE2, SADTest, ::testing::ValuesIn(sse2_tests)); +#endif // CONFIG_VP8_ENCODER + #if CONFIG_VP9_ENCODER #if CONFIG_USE_X86INC +const sad_m_by_n_fn_vp9_t sad_64x64_sse2_vp9 = vp9_sad64x64_sse2; +const sad_m_by_n_fn_vp9_t sad_64x32_sse2_vp9 = vp9_sad64x32_sse2; +const sad_m_by_n_fn_vp9_t sad_32x64_sse2_vp9 = vp9_sad32x64_sse2; +const sad_m_by_n_fn_vp9_t sad_32x32_sse2_vp9 = vp9_sad32x32_sse2; +const sad_m_by_n_fn_vp9_t sad_32x16_sse2_vp9 = vp9_sad32x16_sse2; +const sad_m_by_n_fn_vp9_t sad_16x32_sse2_vp9 = vp9_sad16x32_sse2; +const sad_m_by_n_fn_vp9_t sad_16x16_sse2_vp9 = vp9_sad16x16_sse2; +const sad_m_by_n_fn_vp9_t sad_16x8_sse2_vp9 = vp9_sad16x8_sse2; +const sad_m_by_n_fn_vp9_t sad_8x16_sse2_vp9 = vp9_sad8x16_sse2; +const sad_m_by_n_fn_vp9_t sad_8x8_sse2_vp9 = vp9_sad8x8_sse2; +const sad_m_by_n_fn_vp9_t sad_8x4_sse2_vp9 = vp9_sad8x4_sse2; +const sad_m_by_n_test_param_vp9_t sse2_vp9_tests[] = { make_tuple(64, 64, sad_64x64_sse2_vp9), make_tuple(64, 32, sad_64x32_sse2_vp9), make_tuple(32, 64, sad_32x64_sse2_vp9), @@ -493,13 +571,9 @@ const sad_m_by_n_test_param_t sse2_tests[] = { make_tuple(8, 16, sad_8x16_sse2_vp9), make_tuple(8, 8, sad_8x8_sse2_vp9), make_tuple(8, 4, sad_8x4_sse2_vp9), -#endif -#endif }; -INSTANTIATE_TEST_CASE_P(SSE2, SADTest, ::testing::ValuesIn(sse2_tests)); +INSTANTIATE_TEST_CASE_P(SSE2, SADVP9Test, ::testing::ValuesIn(sse2_vp9_tests)); -#if CONFIG_VP9_ENCODER -#if CONFIG_USE_X86INC const sad_n_by_n_by_4_fn_t sad_64x64x4d_sse2 = vp9_sad64x64x4d_sse2; const sad_n_by_n_by_4_fn_t sad_64x32x4d_sse2 = vp9_sad64x32x4d_sse2; const sad_n_by_n_by_4_fn_t sad_32x64x4d_sse2 = vp9_sad32x64x4d_sse2; @@ -523,9 +597,9 @@ INSTANTIATE_TEST_CASE_P(SSE2, SADx4Test, ::testing::Values( make_tuple(8, 16, sad_8x16x4d_sse2), make_tuple(8, 8, sad_8x8x4d_sse2), make_tuple(8, 4, sad_8x4x4d_sse2))); -#endif -#endif -#endif +#endif // CONFIG_USE_X86INC +#endif // CONFIG_VP9_ENCODER +#endif // HAVE_SSE2 #if HAVE_SSE3 #if CONFIG_VP8_ENCODER @@ -540,8 +614,8 @@ INSTANTIATE_TEST_CASE_P(SSE3, SADx4Test, ::testing::Values( make_tuple(8, 16, sad_8x16x4d_sse3), make_tuple(8, 8, sad_8x8x4d_sse3), make_tuple(4, 4, sad_4x4x4d_sse3))); -#endif -#endif +#endif // CONFIG_VP8_ENCODER +#endif // HAVE_SSE3 #if HAVE_SSSE3 #if CONFIG_USE_X86INC @@ -549,8 +623,8 @@ INSTANTIATE_TEST_CASE_P(SSE3, SADx4Test, ::testing::Values( const sad_m_by_n_fn_t sad_16x16_sse3 = vp8_sad16x16_sse3; INSTANTIATE_TEST_CASE_P(SSE3, SADTest, ::testing::Values( make_tuple(16, 16, sad_16x16_sse3))); -#endif -#endif -#endif +#endif // CONFIG_VP8_ENCODER +#endif // CONFIG_USE_X86INC +#endif // HAVE_SSSE3 } // namespace |