From b0d8a75e481dfb08d0125a3c1e26d116f44c0979 Mon Sep 17 00:00:00 2001 From: Yunqing Wang Date: Fri, 20 Jan 2017 09:15:15 -0800 Subject: [PATCH] Add the multi-threaded first pass encoder unit test Added the multi-threaded first pass encoder unit test in VP9. The test is to check if the new multi-threaded first pass encoder(namely, new-mt = 1) still generates matching stats. In the unit test, the new-mt mode will be turned on once the multi-threaded first pass implementation is checked in. Change-Id: Ic21bb1a55c454f024cfd2b397a4c148cfe638218 --- test/encode_test_driver.cc | 2 + test/encode_test_driver.h | 3 + test/vp9_ethread_test.cc | 170 +++++++++++++++++++++++++++++++++++++ 3 files changed, 175 insertions(+) diff --git a/test/encode_test_driver.cc b/test/encode_test_driver.cc index 632c98f05..5d2b4008a 100644 --- a/test/encode_test_driver.cc +++ b/test/encode_test_driver.cc @@ -226,6 +226,8 @@ void EncoderTest::RunLoop(VideoSource *video) { case VPX_CODEC_PSNR_PKT: PSNRPktHook(pkt); break; + case VPX_CODEC_STATS_PKT: StatsPktHook(pkt); break; + default: break; } } diff --git a/test/encode_test_driver.h b/test/encode_test_driver.h index 09b1a7834..08a57ad77 100644 --- a/test/encode_test_driver.h +++ b/test/encode_test_driver.h @@ -218,6 +218,9 @@ class EncoderTest { // Hook to be called on every PSNR packet. virtual void PSNRPktHook(const vpx_codec_cx_pkt_t * /*pkt*/) {} + // Hook to be called on every first pass stats packet. + virtual void StatsPktHook(const vpx_codec_cx_pkt_t * /*pkt*/) {} + // Hook to determine whether the encode loop should continue. virtual bool Continue() const { return !(::testing::Test::HasFatalFailure() || abort_); diff --git a/test/vp9_ethread_test.cc b/test/vp9_ethread_test.cc index 4df40854b..ee522565c 100644 --- a/test/vp9_ethread_test.cc +++ b/test/vp9_ethread_test.cc @@ -16,8 +16,170 @@ #include "test/md5_helper.h" #include "test/util.h" #include "test/y4m_video_source.h" +#include "vp9/encoder/vp9_firstpass.h" namespace { +// FIRSTPASS_STATS struct: +// { +// 23 double members; +// 1 int64_t member; +// } +// Whenever FIRSTPASS_STATS struct is modified, the following constants need to +// be revisited. +const int kDbl = 23; +const int kInt = 1; +const size_t kFirstPassStatsSz = kDbl * sizeof(double) + kInt * sizeof(int64_t); + +class VPxFirstPassEncoderThreadTest + : public ::libvpx_test::EncoderTest, + public ::libvpx_test::CodecTestWith2Params { + protected: + VPxFirstPassEncoderThreadTest() + : EncoderTest(GET_PARAM(0)), encoder_initialized_(false), tiles_(0), + encoding_mode_(GET_PARAM(1)), set_cpu_used_(GET_PARAM(2)) { + init_flags_ = VPX_CODEC_USE_PSNR; + + new_mt_mode_ = 1; + first_pass_only_ = 1; + firstpass_stats_.buf = NULL; + firstpass_stats_.sz = 0; + } + virtual ~VPxFirstPassEncoderThreadTest() { free(firstpass_stats_.buf); } + + virtual void SetUp() { + InitializeConfig(); + SetMode(encoding_mode_); + + cfg_.g_lag_in_frames = 3; + cfg_.rc_end_usage = VPX_VBR; + cfg_.rc_2pass_vbr_minsection_pct = 5; + cfg_.rc_2pass_vbr_maxsection_pct = 2000; + cfg_.rc_max_quantizer = 56; + cfg_.rc_min_quantizer = 0; + } + + virtual void BeginPassHook(unsigned int /*pass*/) { + encoder_initialized_ = false; + abort_ = false; + } + + virtual void EndPassHook() { + // For first pass stats test, only run first pass encoder. + if (first_pass_only_ && cfg_.g_pass == VPX_RC_FIRST_PASS) + abort_ |= first_pass_only_; + } + + virtual void PreEncodeFrameHook(::libvpx_test::VideoSource * /*video*/, + ::libvpx_test::Encoder *encoder) { + if (!encoder_initialized_) { + // Encode in 2-pass mode. + encoder->Control(VP9E_SET_TILE_COLUMNS, tiles_); + encoder->Control(VP8E_SET_CPUUSED, set_cpu_used_); + encoder->Control(VP8E_SET_ENABLEAUTOALTREF, 1); + encoder->Control(VP8E_SET_ARNR_MAXFRAMES, 7); + encoder->Control(VP8E_SET_ARNR_STRENGTH, 5); + encoder->Control(VP8E_SET_ARNR_TYPE, 3); + encoder->Control(VP9E_SET_FRAME_PARALLEL_DECODING, 0); + + // For now, new_mt_mode only works for 2-pass encoding. + // Enable this once the fp mt patch is checked in. + // if (encoding_mode_ == ::libvpx_test::kTwoPassGood) + // encoder->Control(VP9E_SET_NEW_MT, new_mt_mode_); + + encoder_initialized_ = true; + } + } + + virtual void StatsPktHook(const vpx_codec_cx_pkt_t *pkt) { + const uint8_t *const pkt_buf = + reinterpret_cast(pkt->data.twopass_stats.buf); + const size_t pkt_size = pkt->data.twopass_stats.sz; + + // First pass stats size equals sizeof(FIRSTPASS_STATS) + EXPECT_EQ(pkt_size, kFirstPassStatsSz) + << "Error: First pass stats size doesn't equal kFirstPassStatsSz"; + + firstpass_stats_.buf = + realloc(firstpass_stats_.buf, firstpass_stats_.sz + pkt_size); + memcpy((uint8_t *)firstpass_stats_.buf + firstpass_stats_.sz, pkt_buf, + pkt_size); + firstpass_stats_.sz += pkt_size; + } + + bool encoder_initialized_; + int tiles_; + ::libvpx_test::TestMode encoding_mode_; + int set_cpu_used_; + int new_mt_mode_; + int first_pass_only_; + vpx_fixed_buf_t firstpass_stats_; +}; + +static void compare_fp_stats(vpx_fixed_buf_t *fp_stats) { + // fp_stats consists of 2 set of first pass encoding stats. These 2 set of + // stats are compared to check if the stats match or at least are very close. + FIRSTPASS_STATS *stats1 = reinterpret_cast(fp_stats->buf); + int nframes_ = (int)(fp_stats->sz / sizeof(FIRSTPASS_STATS)); + FIRSTPASS_STATS *stats2 = stats1 + nframes_ / 2; + int i, j; + + // The total stats are also output and included in the first pass stats. Here + // ignore that in the comparison. + for (i = 0; i < (nframes_ / 2 - 1); ++i) { + const double *frame_stats1 = reinterpret_cast(stats1); + const double *frame_stats2 = reinterpret_cast(stats2); + + for (j = 0; j < kDbl; ++j) { + EXPECT_LE(fabs(*frame_stats1 - *frame_stats2), + fabs(*frame_stats1) / 1000.0); + frame_stats1++; + frame_stats2++; + } + + stats1++; + stats2++; + } + + // Reset firstpass_stats_ to 0. + memset((uint8_t *)fp_stats->buf, 0, fp_stats->sz); + fp_stats->sz = 0; +} + +TEST_P(VPxFirstPassEncoderThreadTest, FirstPassStatsTest) { + ::libvpx_test::Y4mVideoSource video("niklas_1280_720_30.y4m", 0, 50); + + first_pass_only_ = 1; + cfg_.rc_target_bitrate = 1000; + + // Test new_mt_mode: 0 vs 1 (threads = 1, tiles_ = 0) + tiles_ = 0; + cfg_.g_threads = 1; + + new_mt_mode_ = 0; + init_flags_ = VPX_CODEC_USE_PSNR; + ASSERT_NO_FATAL_FAILURE(RunLoop(&video)); + + new_mt_mode_ = 1; + ASSERT_NO_FATAL_FAILURE(RunLoop(&video)); + + // Compare to check if using or not using new-mt generates matching stats. + compare_fp_stats(&firstpass_stats_); + + // Test multi-threads: single thread vs 4 threads + new_mt_mode_ = 1; + tiles_ = 2; + + cfg_.g_threads = 1; + init_flags_ = VPX_CODEC_USE_PSNR; + ASSERT_NO_FATAL_FAILURE(RunLoop(&video)); + + cfg_.g_threads = 4; + ASSERT_NO_FATAL_FAILURE(RunLoop(&video)); + + // Compare to check if single-thread and multi-thread stats matches. + compare_fp_stats(&firstpass_stats_); +} + class VPxEncoderThreadTest : public ::libvpx_test::EncoderTest, public ::libvpx_test::CodecTestWith4Params(&libvpx_test::kVP9)), + ::testing::Values(::libvpx_test::kTwoPassGood), + ::testing::Range(0, 4))); // cpu_used + // Split this into two instantiations so that we can distinguish // between very slow runs ( ie cpu_speed 0 ) vs ones that can be // run nightly by adding Large to the title. -- 2.40.0