shithub: libvpx

--- a/test/decode_perf_test.cc

+++ b/test/decode_perf_test.cc

@@ -8,13 +8,17 @@

  *  be found in the AUTHORS file in the root of the source tree.

*/

+#include <string>

 #include "test/codec_factory.h"

 #include "test/decode_test_driver.h"

+#include "test/encode_test_driver.h"

+#include "test/i420_video_source.h"

 #include "test/ivf_video_source.h"

 #include "test/md5_helper.h"

 #include "test/util.h"

 #include "test/webm_video_source.h"

 #include "vpx_ports/vpx_timer.h"

+#include "./ivfenc.h"

 #include "./vpx_version.h"

 using std::tr1::make_tuple;

@@ -24,7 +28,9 @@

 #define VIDEO_NAME 0

 #define THREADS 1

+const int kMaxPsnr = 100;

 const double kUsecsInSec = 1000000.0;

+static const char *kNewEncodeOutputFile = "new_encode.ivf";

/*

  DecodePerfTest takes a tuple of filename + number of threads to decode with

@@ -105,4 +111,161 @@

 INSTANTIATE_TEST_CASE_P(VP9, DecodePerfTest,

                         ::testing::ValuesIn(kVP9DecodePerfVectors));

+class VP9NewEncodeDecodePerfTest : public ::libvpx_test::EncoderTest,

+    public ::libvpx_test::CodecTestWithParam<libvpx_test::TestMode> {

+ protected:

+  VP9NewEncodeDecodePerfTest()

+      : EncoderTest(GET_PARAM(0)),

+        encoding_mode_(GET_PARAM(1)),

+        speed_(0),

+        outfile_(0),

+        out_frames_(0) {

+  }

+  virtual ~VP9NewEncodeDecodePerfTest() {}

+  virtual void SetUp() {

+    InitializeConfig();

+    SetMode(encoding_mode_);

+    cfg_.g_lag_in_frames = 25;

+    cfg_.rc_min_quantizer = 2;

+    cfg_.rc_max_quantizer = 56;

+    cfg_.rc_dropframe_thresh = 0;

+    cfg_.rc_undershoot_pct = 50;

+    cfg_.rc_overshoot_pct = 50;

+    cfg_.rc_buf_sz = 1000;

+    cfg_.rc_buf_initial_sz = 500;

+    cfg_.rc_buf_optimal_sz = 600;

+    cfg_.rc_resize_allowed = 0;

+    cfg_.rc_end_usage = VPX_VBR;

+  }

+  virtual void PreEncodeFrameHook(::libvpx_test::VideoSource *video,

+                                  ::libvpx_test::Encoder *encoder) {

+    if (video->frame() == 1) {

+      encoder->Control(VP8E_SET_CPUUSED, speed_);

+      encoder->Control(VP9E_SET_FRAME_PARALLEL_DECODING, 1);

+      encoder->Control(VP9E_SET_TILE_COLUMNS, 2);

+    }

+  }

+  virtual void BeginPassHook(unsigned int /*pass*/) {

+    const std::string data_path = getenv("LIBVPX_TEST_DATA_PATH");

+    const std::string path_to_source = data_path + "/" + kNewEncodeOutputFile;

+    outfile_ = fopen(path_to_source.c_str(), "wb");

+  }

+  virtual void EndPassHook() {

+    if (outfile_) {

+      if (!fseek(outfile_, 0, SEEK_SET))

+        ivf_write_file_header(outfile_, &cfg_, VP9_FOURCC, out_frames_);

+      fclose(outfile_);

+      outfile_ = NULL;

+    }

+  }

+  virtual void FramePktHook(const vpx_codec_cx_pkt_t *pkt) {

+    ++out_frames_;

+    // Write initial file header if first frame.

+    if (pkt->data.frame.pts == 0)

+      ivf_write_file_header(outfile_, &cfg_, VP9_FOURCC, out_frames_);

+    // Write frame header and data.

+    ivf_write_frame_header(outfile_, out_frames_, pkt->data.frame.sz);

+    (void)fwrite(pkt->data.frame.buf, 1, pkt->data.frame.sz, outfile_);

+  }

+  virtual bool DoDecode() { return 0; }

+  void set_speed(unsigned int speed) {

+    speed_ = speed;

+  }

+ private:

+  libvpx_test::TestMode encoding_mode_;

+  uint32_t speed_;

+  FILE *outfile_;

+  uint32_t out_frames_;

+};

+struct EncodePerfTestVideo {

+  EncodePerfTestVideo(const char *name_, uint32_t width_, uint32_t height_,

+                      uint32_t bitrate_, int frames_)

+      : name(name_),

+        width(width_),

+        height(height_),

+        bitrate(bitrate_),

+        frames(frames_) {}

+  const char *name;

+  uint32_t width;

+  uint32_t height;

+  uint32_t bitrate;

+  int frames;

+};

+const EncodePerfTestVideo kVP9EncodePerfTestVectors[] = {

+  EncodePerfTestVideo("niklas_1280_720_30.yuv", 1280, 720, 600, 470),

+};

+TEST_P(VP9NewEncodeDecodePerfTest, PerfTest) {

+  SetUp();

+  // TODO(JBB): Make this work by going through the set of given files.

+  const int i = 0;

+  const vpx_rational timebase = { 33333333, 1000000000 };

+  cfg_.g_timebase = timebase;

+  cfg_.rc_target_bitrate = kVP9EncodePerfTestVectors[i].bitrate;

+  init_flags_ = VPX_CODEC_USE_PSNR;

+  const char *video_name = kVP9EncodePerfTestVectors[i].name;

+  libvpx_test::I420VideoSource video(

+      video_name,

+      kVP9EncodePerfTestVectors[i].width,

+      kVP9EncodePerfTestVectors[i].height,

+      timebase.den, timebase.num, 0,

+      kVP9EncodePerfTestVectors[i].frames);

+  set_speed(2);

+  ASSERT_NO_FATAL_FAILURE(RunLoop(&video));

+  const uint32_t threads = 4;

+  libvpx_test::IVFVideoSource decode_video(kNewEncodeOutputFile);

+  decode_video.Init();

+  vpx_codec_dec_cfg_t cfg = vpx_codec_dec_cfg_t();

+  cfg.threads = threads;

+  libvpx_test::VP9Decoder decoder(cfg, 0);

+  vpx_usec_timer t;

+  vpx_usec_timer_start(&t);

+  for (decode_video.Begin(); decode_video.cxdata() != NULL;

+       decode_video.Next()) {

+    decoder.DecodeFrame(decode_video.cxdata(), decode_video.frame_size());

+  }

+  vpx_usec_timer_mark(&t);

+  const double elapsed_secs =

+      double(vpx_usec_timer_elapsed(&t)) / kUsecsInSec;

+  const unsigned decode_frames = decode_video.frame_number();

+  const double fps = double(decode_frames) / elapsed_secs;

+  printf("{\n");

+  printf("\t\"type\" : \"decode_perf_test\",\n");

+  printf("\t\"version\" : \"%s\",\n", VERSION_STRING_NOSP);

+  printf("\t\"videoName\" : \"%s\",\n", kNewEncodeOutputFile);

+  printf("\t\"threadCount\" : %u,\n", threads);

+  printf("\t\"decodeTimeSecs\" : %f,\n", elapsed_secs);

+  printf("\t\"totalFrames\" : %u,\n", decode_frames);

+  printf("\t\"framesPerSecond\" : %f\n", fps);

+  printf("}\n");

+}

+VP9_INSTANTIATE_TEST_CASE(

+  VP9NewEncodeDecodePerfTest, ::testing::Values(::libvpx_test::kTwoPassGood));

 }  // namespace

--- a/test/test-data.mk

+++ b/test/test-data.mk

@@ -713,6 +713,8 @@

 LIBVPX_TEST_DATA-$(CONFIG_VP9_DECODER) += invalid-vp91-2-mixedrefcsp-444to420.ivf.res

 ifeq ($(CONFIG_DECODE_PERF_TESTS),yes)

+# NewEncode Test

+LIBVPX_TEST_DATA-$(CONFIG_VP9_DECODER) += niklas_1280_720_30.yuv

 # BBB VP9 streams

 LIBVPX_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-bbb_426x240_tile_1x1_180kbps.webm

 LIBVPX_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-bbb_640x360_tile_1x2_337kbps.webm

@@ -742,7 +744,9 @@

 LIBVPX_TEST_DATA-$(CONFIG_VP9_ENCODER) += kirland_640_480_30.yuv

 LIBVPX_TEST_DATA-$(CONFIG_VP9_ENCODER) += macmarcomoving_640_480_30.yuv

 LIBVPX_TEST_DATA-$(CONFIG_VP9_ENCODER) += macmarcostationary_640_480_30.yuv

+ifneq ($(CONFIG_DECODE_PERF_TESTS),yes)

 LIBVPX_TEST_DATA-$(CONFIG_VP9_ENCODER) += niklas_1280_720_30.yuv

+endif

 LIBVPX_TEST_DATA-$(CONFIG_VP9_ENCODER) += niklas_640_480_30.yuv

 LIBVPX_TEST_DATA-$(CONFIG_VP9_ENCODER) += tacomanarrows_640_480_30.yuv

 LIBVPX_TEST_DATA-$(CONFIG_VP9_ENCODER) += tacomasmallcameramovement_640_480_30.yuv

--- a/test/test.mk

+++ b/test/test.mk

@@ -46,6 +46,9 @@

 LIBVPX_TEST_SRCS-yes                   += encode_test_driver.cc

 LIBVPX_TEST_SRCS-yes                   += encode_test_driver.h

+## IVF writing.

+LIBVPX_TEST_SRCS-$(CONFIG_ENCODERS)    += ../ivfenc.c ../ivfenc.h

 ## Y4m parsing.

 LIBVPX_TEST_SRCS-$(CONFIG_ENCODERS)    += y4m_test.cc ../y4menc.c ../y4menc.h