Merge "vp9: Update to rc-metric for keeping track of average frame size."
diff --git a/test/convolve_test.cc b/test/convolve_test.cc
index 9c71f23..73b0edb 100644
--- a/test/convolve_test.cc
+++ b/test/convolve_test.cc
@@ -231,7 +231,8 @@
* and filter_max_width = 16
*/
uint16_t intermediate_buffer[71 * kMaxDimension];
- const int intermediate_next_stride = 1 - intermediate_height * output_width;
+ const int intermediate_next_stride =
+ 1 - static_cast<int>(intermediate_height * output_width);
// Horizontal pass (src -> transposed intermediate).
{
diff --git a/test/level_test.cc b/test/level_test.cc
new file mode 100644
index 0000000..5b9ce41
--- /dev/null
+++ b/test/level_test.cc
@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) 2016 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 "third_party/googletest/src/include/gtest/gtest.h"
+#include "test/codec_factory.h"
+#include "test/encode_test_driver.h"
+#include "test/i420_video_source.h"
+#include "test/util.h"
+
+namespace {
+class LevelTest
+ : public ::libvpx_test::EncoderTest,
+ public ::libvpx_test::CodecTestWith2Params<libvpx_test::TestMode, int> {
+ protected:
+ LevelTest()
+ : EncoderTest(GET_PARAM(0)),
+ encoding_mode_(GET_PARAM(1)),
+ cpu_used_(GET_PARAM(2)),
+ target_level_(0) {}
+ virtual ~LevelTest() {}
+
+ virtual void SetUp() {
+ InitializeConfig();
+ SetMode(encoding_mode_);
+ if (encoding_mode_ != ::libvpx_test::kRealTime) {
+ cfg_.g_lag_in_frames = 25;
+ cfg_.rc_end_usage = VPX_VBR;
+ } else {
+ cfg_.g_lag_in_frames = 0;
+ cfg_.rc_end_usage = VPX_CBR;
+ }
+ cfg_.rc_2pass_vbr_minsection_pct = 5;
+ cfg_.rc_2pass_vbr_maxsection_pct = 2000;
+ cfg_.rc_target_bitrate = 400;
+ cfg_.rc_max_quantizer = 63;
+ cfg_.rc_min_quantizer = 0;
+ }
+
+ virtual void PreEncodeFrameHook(::libvpx_test::VideoSource *video,
+ ::libvpx_test::Encoder *encoder) {
+ if (video->frame() == 0) {
+ encoder->Control(VP8E_SET_CPUUSED, cpu_used_);
+ encoder->Control(VP9E_SET_TARGET_LEVEL, target_level_);
+ if (encoding_mode_ != ::libvpx_test::kRealTime) {
+ 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);
+ }
+ }
+ }
+
+ ::libvpx_test::TestMode encoding_mode_;
+ int cpu_used_;
+ int target_level_;
+};
+
+TEST_P(LevelTest, TestTargetLevel0) {
+ ::libvpx_test::I420VideoSource video("hantro_odd.yuv", 208, 144, 30, 1, 0,
+ 30);
+ target_level_ = 0;
+ ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
+}
+
+TEST_P(LevelTest, TestTargetLevel255) {
+ ::libvpx_test::I420VideoSource video("hantro_odd.yuv", 208, 144, 30, 1, 0,
+ 30);
+ target_level_ = 255;
+ ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
+}
+
+TEST_P(LevelTest, TestTargetLevelApi) {
+ ::libvpx_test::I420VideoSource video("hantro_odd.yuv", 208, 144, 30, 1, 0, 1);
+ static const vpx_codec_iface_t *codec = &vpx_codec_vp9_cx_algo;
+ vpx_codec_ctx_t enc;
+ vpx_codec_enc_cfg_t cfg;
+ EXPECT_EQ(VPX_CODEC_OK, vpx_codec_enc_config_default(codec, &cfg, 0));
+ EXPECT_EQ(VPX_CODEC_OK, vpx_codec_enc_init(&enc, codec, &cfg, 0));
+ for (int level = 0; level <= 256; ++level) {
+ if (level == 10 || level == 11 || level == 20 || level == 21 ||
+ level == 30 || level == 31 || level == 40 || level == 41 ||
+ level == 50 || level == 51 || level == 52 || level == 60 ||
+ level == 61 || level == 62 || level == 0 || level == 255)
+ EXPECT_EQ(VPX_CODEC_OK,
+ vpx_codec_control(&enc, VP9E_SET_TARGET_LEVEL, level));
+ else
+ EXPECT_EQ(VPX_CODEC_INVALID_PARAM,
+ vpx_codec_control(&enc, VP9E_SET_TARGET_LEVEL, level));
+ }
+ EXPECT_EQ(VPX_CODEC_OK, vpx_codec_destroy(&enc));
+}
+
+VP9_INSTANTIATE_TEST_CASE(LevelTest,
+ ::testing::Values(::libvpx_test::kTwoPassGood,
+ ::libvpx_test::kOnePassGood,
+ ::libvpx_test::kRealTime),
+ ::testing::Range(0, 9));
+} // namespace
diff --git a/test/test.mk b/test/test.mk
index 390bc23..1eb702f 100644
--- a/test/test.mk
+++ b/test/test.mk
@@ -45,6 +45,7 @@
LIBVPX_TEST_SRCS-$(CONFIG_VP9_ENCODER) += vp9_lossless_test.cc
LIBVPX_TEST_SRCS-$(CONFIG_VP9_ENCODER) += vp9_end_to_end_test.cc
LIBVPX_TEST_SRCS-$(CONFIG_VP9_ENCODER) += vp9_ethread_test.cc
+LIBVPX_TEST_SRCS-$(CONFIG_VP9_ENCODER) += level_test.cc
LIBVPX_TEST_SRCS-yes += decode_test_driver.cc
LIBVPX_TEST_SRCS-yes += decode_test_driver.h
diff --git a/vp9/encoder/vp9_pickmode.c b/vp9/encoder/vp9_pickmode.c
index d2ecafc..9f220d6 100644
--- a/vp9/encoder/vp9_pickmode.c
+++ b/vp9/encoder/vp9_pickmode.c
@@ -1161,6 +1161,27 @@
*ref_frame_skip_mask |= (1 << ref_frame);
}
}
+
+static void vp9_large_block_mv_bias(const NOISE_ESTIMATE *ne, RD_COST *this_rdc,
+ BLOCK_SIZE bsize, int mv_row, int mv_col,
+ int is_last_frame) {
+ // Bias against non-zero (above some threshold) motion for large blocks.
+ // This is temporary fix to avoid selection of large mv for big blocks.
+ if (mv_row > 64 || mv_row < -64 || mv_col > 64 || mv_col < -64) {
+ if (bsize == BLOCK_64X64)
+ this_rdc->rdcost = this_rdc->rdcost << 1;
+ else if (bsize >= BLOCK_32X32)
+ this_rdc->rdcost = 3 * this_rdc->rdcost >> 1;
+ }
+ // If noise estimation is enabled, and estimated level is above threshold,
+ // add a bias to LAST reference with small motion, for large blocks.
+ if (ne->enabled && ne->level >= kMedium &&
+ bsize >= BLOCK_32X32 && is_last_frame &&
+ mv_row < 8 && mv_row > -8 && mv_col < 8 && mv_col > -8) {
+ this_rdc->rdcost = 7 * this_rdc->rdcost >> 3;
+ }
+}
+
void vp9_pick_inter_mode(VP9_COMP *cpi, MACROBLOCK *x,
TileDataEnc *tile_data,
int mi_row, int mi_col, RD_COST *rd_cost,
@@ -1607,32 +1628,15 @@
this_rdc.rate += ref_frame_cost[ref_frame];
this_rdc.rdcost = RDCOST(x->rdmult, x->rddiv, this_rdc.rate, this_rdc.dist);
+ // Bias against non-zero motion
if (cpi->oxcf.rc_mode == VPX_CBR &&
cpi->oxcf.speed >= 5 &&
cpi->oxcf.content != VP9E_CONTENT_SCREEN &&
!x->sb_is_skin) {
- // Bias against non-zero (above some threshold) motion for large blocks.
- // This is temporary fix to avoid selection of large mv for big blocks.
- if (frame_mv[this_mode][ref_frame].as_mv.row > 64 ||
- frame_mv[this_mode][ref_frame].as_mv.row < -64 ||
- frame_mv[this_mode][ref_frame].as_mv.col > 64 ||
- frame_mv[this_mode][ref_frame].as_mv.col < -64) {
- if (bsize == BLOCK_64X64)
- this_rdc.rdcost = this_rdc.rdcost << 1;
- else if (bsize >= BLOCK_32X32)
- this_rdc.rdcost = 3 * this_rdc.rdcost >> 1;
- }
- // If noise estimation is enabled, and estimated level is above threshold,
- // add a bias to LAST reference with small motion, for large blocks.
- if (cpi->noise_estimate.enabled &&
- cpi->noise_estimate.level >= kMedium &&
- bsize >= BLOCK_32X32 &&
- ref_frame == LAST_FRAME &&
- frame_mv[this_mode][ref_frame].as_mv.row < 8 &&
- frame_mv[this_mode][ref_frame].as_mv.row > -8 &&
- frame_mv[this_mode][ref_frame].as_mv.col < 8 &&
- frame_mv[this_mode][ref_frame].as_mv.col > -8)
- this_rdc.rdcost = 7 * this_rdc.rdcost >> 3;
+ vp9_large_block_mv_bias(&cpi->noise_estimate, &this_rdc, bsize,
+ frame_mv[this_mode][ref_frame].as_mv.row,
+ frame_mv[this_mode][ref_frame].as_mv.col,
+ ref_frame == LAST_FRAME);
}
// Skipping checking: test to see if this block can be reconstructed by
