From: Johann Date: Mon, 20 Oct 2014 17:04:45 +0000 (-0700) Subject: vp8 quantize test X-Git-Tag: v1.4.0~541^2 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=53b68de56574514d198814e1dc2c0b6caeccd071;p=platform%2Fupstream%2Flibvpx.git vp8 quantize test Test for Regular, Fast and Pair quantization Change-Id: I0a26c164afe632db869099402189826c0d43f9a2 --- diff --git a/test/quantize_test.cc b/test/quantize_test.cc new file mode 100644 index 0000000..e3fd1c8 --- /dev/null +++ b/test/quantize_test.cc @@ -0,0 +1,248 @@ +/* + * Copyright (c) 2014 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 "third_party/googletest/src/include/gtest/gtest.h" +#include "test/acm_random.h" +#include "test/clear_system_state.h" +#include "test/register_state_check.h" +#include "test/util.h" + +#include "./vpx_config.h" +#include "./vp8_rtcd.h" +#include "vp8/common/blockd.h" +#include "vp8/common/onyx.h" +#include "vp8/encoder/block.h" +#include "vp8/encoder/onyx_int.h" +#include "vp8/encoder/quantize.h" +#include "vpx/vpx_integer.h" +#include "vpx_mem/vpx_mem.h" + +namespace { + +const int kNumBlocks = 25; +const int kNumBlockEntries = 16; + +typedef void (*VP8Quantize)(BLOCK *b, BLOCKD *d); +typedef void (*VP8QuantizePair)(BLOCK *b0, BLOCK *b1, BLOCKD *d0, BLOCKD *d1); + +typedef std::tr1::tuple VP8QuantizeParam; +typedef std::tr1::tuple VP8QuantizePairParam; + +using libvpx_test::ACMRandom; +using std::tr1::make_tuple; + +// Create and populate a VP8_COMP instance which has a complete set of +// quantization inputs as well as a second MACROBLOCKD for output. +class QuantizeTestBase { + public: + virtual ~QuantizeTestBase() { + vp8_remove_compressor(&vp8_comp_); + vp8_comp_ = NULL; + vpx_free(macroblockd_dst_); + macroblockd_dst_ = NULL; + libvpx_test::ClearSystemState(); + } + + protected: + void SetupCompressor() { + rnd_.Reset(ACMRandom::DeterministicSeed()); + + // The full configuration is necessary to generate the quantization tables. + VP8_CONFIG *const vp8_config = + reinterpret_cast(vpx_calloc(sizeof(*vp8_config), 1)); + + vp8_comp_ = vp8_create_compressor(vp8_config); + + // Set the tables based on a quantizer of 0. + vp8_set_quantizer(vp8_comp_, 0); + + // Set up all the block/blockd pointers for the mb in vp8_comp_. + vp8cx_frame_init_quantizer(vp8_comp_); + + // Copy macroblockd from the reference to get pre-set-up dequant values. + macroblockd_dst_ = + reinterpret_cast( + vpx_calloc(sizeof(*macroblockd_dst_), 1)); + vpx_memcpy(macroblockd_dst_, &vp8_comp_->mb.e_mbd, + sizeof(*macroblockd_dst_)); + // Fix block pointers - currently they point to the blocks in the reference + // structure. + vp8_setup_block_dptrs(macroblockd_dst_); + } + + void UpdateQuantizer(int q) { + vp8_set_quantizer(vp8_comp_, q); + + vpx_memcpy(macroblockd_dst_, &vp8_comp_->mb.e_mbd, + sizeof(*macroblockd_dst_)); + vp8_setup_block_dptrs(macroblockd_dst_); + } + + void FillCoeffConstant(int16_t c) { + for (int i = 0; i < kNumBlocks * kNumBlockEntries; ++i) { + vp8_comp_->mb.coeff[i] = c; + } + } + + void FillCoeffRandom() { + for (int i = 0; i < kNumBlocks * kNumBlockEntries; ++i) { + vp8_comp_->mb.coeff[i] = rnd_.Rand8(); + } + } + + void CheckOutput() { + EXPECT_EQ(0, memcmp(vp8_comp_->mb.e_mbd.qcoeff, macroblockd_dst_->qcoeff, + sizeof(*macroblockd_dst_->qcoeff) * kNumBlocks * + kNumBlockEntries)) + << "qcoeff mismatch"; + EXPECT_EQ(0, memcmp(vp8_comp_->mb.e_mbd.dqcoeff, macroblockd_dst_->dqcoeff, + sizeof(*macroblockd_dst_->dqcoeff) * kNumBlocks * + kNumBlockEntries)) + << "dqcoeff mismatch"; + EXPECT_EQ(0, memcmp(vp8_comp_->mb.e_mbd.eobs, macroblockd_dst_->eobs, + sizeof(*macroblockd_dst_->eobs) * kNumBlocks)) + << "eobs mismatch"; + } + + VP8_COMP *vp8_comp_; + MACROBLOCKD *macroblockd_dst_; + + private: + ACMRandom rnd_; +}; + +class QuantizeTest : public QuantizeTestBase, + public ::testing::TestWithParam { + protected: + virtual void SetUp() { + SetupCompressor(); + asm_quant_ = GET_PARAM(0); + c_quant_ = GET_PARAM(1); + } + + void RunComparison() { + for (int i = 0; i < kNumBlocks; ++i) { + ASM_REGISTER_STATE_CHECK( + c_quant_(&vp8_comp_->mb.block[i], &vp8_comp_->mb.e_mbd.block[i])); + ASM_REGISTER_STATE_CHECK( + asm_quant_(&vp8_comp_->mb.block[i], ¯oblockd_dst_->block[i])); + } + + CheckOutput(); + } + + private: + VP8Quantize asm_quant_; + VP8Quantize c_quant_; +}; + +class QuantizeTestPair : public QuantizeTestBase, + public ::testing::TestWithParam { + protected: + virtual void SetUp() { + SetupCompressor(); + asm_quant_pair_ = GET_PARAM(0); + c_quant_pair_ = GET_PARAM(1); + } + + void RunComparison() { + // Skip the last, unpaired, block. + for (int i = 0; i < kNumBlocks - 1; i += 2) { + ASM_REGISTER_STATE_CHECK(c_quant_pair_( + &vp8_comp_->mb.block[i], &vp8_comp_->mb.block[i + 1], + &vp8_comp_->mb.e_mbd.block[i], &vp8_comp_->mb.e_mbd.block[i + 1])); + ASM_REGISTER_STATE_CHECK(asm_quant_pair_( + &vp8_comp_->mb.block[i], &vp8_comp_->mb.block[i + 1], + ¯oblockd_dst_->block[i], ¯oblockd_dst_->block[i + 1])); + } + + CheckOutput(); + } + + private: + VP8QuantizePair asm_quant_pair_; + VP8QuantizePair c_quant_pair_; +}; + +TEST_P(QuantizeTest, TestZeroInput) { + FillCoeffConstant(0); + RunComparison(); +} + +TEST_P(QuantizeTest, TestRandomInput) { + FillCoeffRandom(); + RunComparison(); +} + +TEST_P(QuantizeTest, TestMultipleQ) { + for (int q = 0; q < QINDEX_RANGE; ++q) { + UpdateQuantizer(q); + FillCoeffRandom(); + RunComparison(); + } +} + +TEST_P(QuantizeTestPair, TestZeroInput) { + FillCoeffConstant(0); + RunComparison(); +} + +TEST_P(QuantizeTestPair, TestRandomInput) { + FillCoeffRandom(); + RunComparison(); +} + +TEST_P(QuantizeTestPair, TestMultipleQ) { + for (int q = 0; q < QINDEX_RANGE; ++q) { + UpdateQuantizer(q); + FillCoeffRandom(); + RunComparison(); + } +} + +#if HAVE_SSE2 +INSTANTIATE_TEST_CASE_P( + SSE2, QuantizeTest, + ::testing::Values( + make_tuple(vp8_fast_quantize_b_sse2, vp8_fast_quantize_b_c), + make_tuple(vp8_regular_quantize_b_sse2, vp8_regular_quantize_b_c))); +#endif // HAVE_SSE2 + +#if HAVE_SSSE3 +INSTANTIATE_TEST_CASE_P(SSSE3, QuantizeTest, + ::testing::Values(make_tuple(vp8_fast_quantize_b_ssse3, + vp8_fast_quantize_b_c))); +#endif // HAVE_SSSE3 + +#if HAVE_SSE4_1 +INSTANTIATE_TEST_CASE_P(SSE4_1, QuantizeTest, ::testing::Values(make_tuple( + vp8_regular_quantize_b_sse4_1, + vp8_regular_quantize_b_c))); +#endif // HAVE_SSE4_1 + +#if HAVE_MEDIA +INSTANTIATE_TEST_CASE_P(MEDIA, QuantizeTest, + ::testing::Values(make_tuple(vp8_fast_quantize_b_armv6, + vp8_fast_quantize_b_c))); +#endif // HAVE_MEDIA + +#if HAVE_NEON_ASM +INSTANTIATE_TEST_CASE_P(NEON, QuantizeTest, + ::testing::Values(make_tuple(vp8_fast_quantize_b_neon, + vp8_fast_quantize_b_c))); + +INSTANTIATE_TEST_CASE_P( + NEON, QuantizeTestPair, + ::testing::Values(make_tuple(vp8_fast_quantize_b_pair_neon, + vp8_fast_quantize_b_pair_c))); +#endif // HAVE_NEON_ASM +} // namespace diff --git a/test/test.mk b/test/test.mk index 30c13a1..ab4ebbf 100644 --- a/test/test.mk +++ b/test/test.mk @@ -99,6 +99,7 @@ LIBVPX_TEST_SRCS-$(CONFIG_VP8_ENCODER) += set_roi.cc LIBVPX_TEST_SRCS-$(CONFIG_VP8_ENCODER) += subtract_test.cc LIBVPX_TEST_SRCS-$(CONFIG_VP8_ENCODER) += variance_test.cc LIBVPX_TEST_SRCS-$(CONFIG_VP8_ENCODER) += vp8_fdct4x4_test.cc +LIBVPX_TEST_SRCS-$(CONFIG_VP8_ENCODER) += quantize_test.cc LIBVPX_TEST_SRCS-yes += idct_test.cc LIBVPX_TEST_SRCS-yes += intrapred_test.cc