/* *  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 <memory> #include "third_party/googletest/src/include/gtest/gtest.h" #include "test/codec_factory.h"#include "test/encode_test_driver.h"#include "test/util.h"#include "test/y4m_video_source.h"#include "vp9/vp9_dx_iface.h" namespace { const int kCpuUsed = 2; struct EncodePerfTestVideo {  const char *name;  uint32_t width;  uint32_t height;  uint32_t bitrate;  int frames;}; const EncodePerfTestVideo kVP9EncodePerfTestVectors[] = {  { "niklas_1280_720_30.y4m", 1280, 720, 600, 10 },}; struct EncodeParameters {  int32_t tile_rows;  int32_t tile_cols;  int32_t lossless;  int32_t error_resilient;  int32_t frame_parallel;  vpx_color_range_t color_range;  vpx_color_space_t cs;  int render_size[2];  // TODO(JBB): quantizers / bitrate}; const EncodeParameters kVP9EncodeParameterSet[] = {  { 0, 0, 0, 1, 0, VPX_CR_STUDIO_RANGE, VPX_CS_BT_601, { 0, 0 } },  { 0, 0, 0, 0, 0, VPX_CR_FULL_RANGE, VPX_CS_BT_709, { 0, 0 } },  { 0, 0, 1, 0, 0, VPX_CR_FULL_RANGE, VPX_CS_BT_2020, { 0, 0 } },  { 0, 2, 0, 0, 1, VPX_CR_STUDIO_RANGE, VPX_CS_UNKNOWN, { 640, 480 } },  // TODO(JBB): Test profiles (requires more work).}; class VpxEncoderParmsGetToDecoder    : public ::libvpx_test::EncoderTest,      public ::libvpx_test::CodecTestWith2Params<EncodeParameters,                                                 EncodePerfTestVideo> { protected:  VpxEncoderParmsGetToDecoder()      : EncoderTest(GET_PARAM(0)), encode_parms(GET_PARAM(1)) {}   virtual ~VpxEncoderParmsGetToDecoder() {}   virtual void SetUp() {    InitializeConfig();    SetMode(::libvpx_test::kTwoPassGood);    cfg_.g_lag_in_frames = 25;    cfg_.g_error_resilient = encode_parms.error_resilient;    dec_cfg_.threads = 4;    test_video_ = GET_PARAM(2);    cfg_.rc_target_bitrate = test_video_.bitrate;  }   virtual void PreEncodeFrameHook(::libvpx_test::VideoSource *video,                                  ::libvpx_test::Encoder *encoder) {    if (video->frame() == 0) {      encoder->Control(VP9E_SET_COLOR_SPACE, encode_parms.cs);      encoder->Control(VP9E_SET_COLOR_RANGE, encode_parms.color_range);      encoder->Control(VP9E_SET_LOSSLESS, encode_parms.lossless);      encoder->Control(VP9E_SET_FRAME_PARALLEL_DECODING,                       encode_parms.frame_parallel);      encoder->Control(VP9E_SET_TILE_ROWS, encode_parms.tile_rows);      encoder->Control(VP9E_SET_TILE_COLUMNS, encode_parms.tile_cols);      encoder->Control(VP8E_SET_CPUUSED, kCpuUsed);      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);      if (encode_parms.render_size[0] > 0 && encode_parms.render_size[1] > 0) {        encoder->Control(VP9E_SET_RENDER_SIZE, encode_parms.render_size);      }    }  }   virtual bool HandleDecodeResult(const vpx_codec_err_t res_dec,                                  const libvpx_test::VideoSource & /*video*/,                                  libvpx_test::Decoder *decoder) {    vpx_codec_ctx_t *const vp9_decoder = decoder->GetDecoder();    vpx_codec_alg_priv_t *const priv =        reinterpret_cast<vpx_codec_alg_priv_t *>(vp9_decoder->priv);    VP9_COMMON *const common = &priv->pbi->common;     if (encode_parms.lossless) {      EXPECT_EQ(0, common->base_qindex);      EXPECT_EQ(0, common->y_dc_delta_q);      EXPECT_EQ(0, common->uv_dc_delta_q);      EXPECT_EQ(0, common->uv_ac_delta_q);      EXPECT_EQ(ONLY_4X4, common->tx_mode);    }    EXPECT_EQ(encode_parms.error_resilient, common->error_resilient_mode);    if (encode_parms.error_resilient) {      EXPECT_EQ(1, common->frame_parallel_decoding_mode);      EXPECT_EQ(0, common->use_prev_frame_mvs);    } else {      EXPECT_EQ(encode_parms.frame_parallel,                common->frame_parallel_decoding_mode);    }    EXPECT_EQ(encode_parms.color_range, common->color_range);    EXPECT_EQ(encode_parms.cs, common->color_space);    if (encode_parms.render_size[0] > 0 && encode_parms.render_size[1] > 0) {      EXPECT_EQ(encode_parms.render_size[0], common->render_width);      EXPECT_EQ(encode_parms.render_size[1], common->render_height);    }    EXPECT_EQ(encode_parms.tile_cols, common->log2_tile_cols);    EXPECT_EQ(encode_parms.tile_rows, common->log2_tile_rows);     EXPECT_EQ(VPX_CODEC_OK, res_dec) << decoder->DecodeError();    return VPX_CODEC_OK == res_dec;  }   EncodePerfTestVideo test_video_;  private:  EncodeParameters encode_parms;}; TEST_P(VpxEncoderParmsGetToDecoder, BitstreamParms) {  init_flags_ = VPX_CODEC_USE_PSNR;   std::unique_ptr<libvpx_test::VideoSource> video(      new libvpx_test::Y4mVideoSource(test_video_.name, 0, test_video_.frames));  ASSERT_NE(video.get(), nullptr);   ASSERT_NO_FATAL_FAILURE(RunLoop(video.get()));} VP9_INSTANTIATE_TEST_SUITE(VpxEncoderParmsGetToDecoder,                           ::testing::ValuesIn(kVP9EncodeParameterSet),                           ::testing::ValuesIn(kVP9EncodePerfTestVectors));}  // namespace