granicus.if.org Git - libvpx/blob - test/encode_test_driver.h

   1 /*
   2  *  Copyright (c) 2012 The WebM project authors. All Rights Reserved.
   3  *
   4  *  Use of this source code is governed by a BSD-style license
   5  *  that can be found in the LICENSE file in the root of the source
   6  *  tree. An additional intellectual property rights grant can be found
   7  *  in the file PATENTS.  All contributing project authors may
   8  *  be found in the AUTHORS file in the root of the source tree.
   9  */
  10 #ifndef TEST_ENCODE_TEST_DRIVER_H_
  11 #define TEST_ENCODE_TEST_DRIVER_H_
  12
  13 #include <string>
  14 #include <vector>
  15
  16 #include "./vpx_config.h"
  17 #include "third_party/googletest/src/include/gtest/gtest.h"
  18 #include "vpx/vpx_encoder.h"
  19 #if CONFIG_VP8_ENCODER || CONFIG_VP9_ENCODER
  20 #include "vpx/vp8cx.h"
  21 #endif
  22
  23 namespace libvpx_test {
  24
  25 class CodecFactory;
  26 class VideoSource;
  27
  28 enum TestMode {
  29   kRealTime,
  30   kOnePassGood,
  31   kOnePassBest,
  32   kTwoPassGood,
  33   kTwoPassBest
  34 };
  35 #define ALL_TEST_MODES ::testing::Values(::libvpx_test::kRealTime, \
  36                                          ::libvpx_test::kOnePassGood, \
  37                                          ::libvpx_test::kOnePassBest, \
  38                                          ::libvpx_test::kTwoPassGood, \
  39                                          ::libvpx_test::kTwoPassBest)
  40
  41 #define ONE_PASS_TEST_MODES ::testing::Values(::libvpx_test::kRealTime, \
  42                                               ::libvpx_test::kOnePassGood, \
  43                                               ::libvpx_test::kOnePassBest)
  44
  45 #define TWO_PASS_TEST_MODES ::testing::Values(::libvpx_test::kTwoPassGood, \
  46                                               ::libvpx_test::kTwoPassBest)
  47
  48
  49 // Provides an object to handle the libvpx get_cx_data() iteration pattern
  50 class CxDataIterator {
  51  public:
  52   explicit CxDataIterator(vpx_codec_ctx_t *encoder)
  53       : encoder_(encoder), iter_(NULL) {}
  54
  55   const vpx_codec_cx_pkt_t *Next() {
  56     return vpx_codec_get_cx_data(encoder_, &iter_);
  57   }
  58
  59  private:
  60   vpx_codec_ctx_t  *encoder_;
  61   vpx_codec_iter_t  iter_;
  62 };
  63
  64 // Implements an in-memory store for libvpx twopass statistics
  65 class TwopassStatsStore {
  66  public:
  67   void Append(const vpx_codec_cx_pkt_t &pkt) {
  68     buffer_.append(reinterpret_cast<char *>(pkt.data.twopass_stats.buf),
  69                    pkt.data.twopass_stats.sz);
  70   }
  71
  72   vpx_fixed_buf_t buf() {
  73     const vpx_fixed_buf_t buf = { &buffer_[0], buffer_.size() };
  74     return buf;
  75   }
  76
  77   void Reset() {
  78     buffer_.clear();
  79   }
  80
  81  protected:
  82   std::string  buffer_;
  83 };
  84
  85
  86 // Provides a simplified interface to manage one video encoding pass, given
  87 // a configuration and video source.
  88 //
  89 // TODO(jkoleszar): The exact services it provides and the appropriate
  90 // level of abstraction will be fleshed out as more tests are written.
  91 class Encoder {
  92  public:
  93   Encoder(vpx_codec_enc_cfg_t cfg, unsigned long deadline,
  94           const unsigned long init_flags, TwopassStatsStore *stats)
  95       : cfg_(cfg), deadline_(deadline), init_flags_(init_flags), stats_(stats) {
  96     memset(&encoder_, 0, sizeof(encoder_));
  97   }
  98
  99   virtual ~Encoder() {
 100     vpx_codec_destroy(&encoder_);
 101   }
 102
 103   CxDataIterator GetCxData() {
 104     return CxDataIterator(&encoder_);
 105   }
 106
 107   const vpx_image_t *GetPreviewFrame() {
 108     return vpx_codec_get_preview_frame(&encoder_);
 109   }
 110   // This is a thin wrapper around vpx_codec_encode(), so refer to
 111   // vpx_encoder.h for its semantics.
 112   void EncodeFrame(VideoSource *video, const unsigned long frame_flags);
 113
 114   // Convenience wrapper for EncodeFrame()
 115   void EncodeFrame(VideoSource *video) {
 116     EncodeFrame(video, 0);
 117   }
 118
 119   void Control(int ctrl_id, int arg) {
 120     const vpx_codec_err_t res = vpx_codec_control_(&encoder_, ctrl_id, arg);
 121     ASSERT_EQ(VPX_CODEC_OK, res) << EncoderError();
 122   }
 123
 124   void Control(int ctrl_id, struct vpx_scaling_mode *arg) {
 125     const vpx_codec_err_t res = vpx_codec_control_(&encoder_, ctrl_id, arg);
 126     ASSERT_EQ(VPX_CODEC_OK, res) << EncoderError();
 127   }
 128
 129   void Control(int ctrl_id, struct vpx_svc_layer_id *arg) {
 130     const vpx_codec_err_t res = vpx_codec_control_(&encoder_, ctrl_id, arg);
 131     ASSERT_EQ(VPX_CODEC_OK, res) << EncoderError();
 132   }
 133
 134 #if CONFIG_VP8_ENCODER || CONFIG_VP9_ENCODER
 135   void Control(int ctrl_id, vpx_active_map_t *arg) {
 136     const vpx_codec_err_t res = vpx_codec_control_(&encoder_, ctrl_id, arg);
 137     ASSERT_EQ(VPX_CODEC_OK, res) << EncoderError();
 138   }
 139 #endif
 140
 141   void set_deadline(unsigned long deadline) {
 142     deadline_ = deadline;
 143   }
 144
 145  protected:
 146   virtual vpx_codec_iface_t* CodecInterface() const = 0;
 147
 148   const char *EncoderError() {
 149     const char *detail = vpx_codec_error_detail(&encoder_);
 150     return detail ? detail : vpx_codec_error(&encoder_);
 151   }
 152
 153   // Encode an image
 154   void EncodeFrameInternal(const VideoSource &video,
 155                            const unsigned long frame_flags);
 156
 157   // Flush the encoder on EOS
 158   void Flush();
 159
 160   vpx_codec_ctx_t      encoder_;
 161   vpx_codec_enc_cfg_t  cfg_;
 162   unsigned long        deadline_;
 163   unsigned long        init_flags_;
 164   TwopassStatsStore   *stats_;
 165 };
 166
 167 // Common test functionality for all Encoder tests.
 168 //
 169 // This class is a mixin which provides the main loop common to all
 170 // encoder tests. It provides hooks which can be overridden by subclasses
 171 // to implement each test's specific behavior, while centralizing the bulk
 172 // of the boilerplate. Note that it doesn't inherit the gtest testing
 173 // classes directly, so that tests can be parameterized differently.
 174 class EncoderTest {
 175  protected:
 176   explicit EncoderTest(const CodecFactory *codec)
 177       : codec_(codec), abort_(false), init_flags_(0), frame_flags_(0),
 178         last_pts_(0) {}
 179
 180   virtual ~EncoderTest() {}
 181
 182   // Initialize the cfg_ member with the default configuration.
 183   void InitializeConfig();
 184
 185   // Map the TestMode enum to the deadline_ and passes_ variables.
 186   void SetMode(TestMode mode);
 187
 188   // Main loop
 189   virtual void RunLoop(VideoSource *video);
 190
 191   // Hook to be called at the beginning of a pass.
 192   virtual void BeginPassHook(unsigned int /*pass*/) {}
 193
 194   // Hook to be called at the end of a pass.
 195   virtual void EndPassHook() {}
 196
 197   // Hook to be called before encoding a frame.
 198   virtual void PreEncodeFrameHook(VideoSource* /*video*/) {}
 199   virtual void PreEncodeFrameHook(VideoSource* /*video*/,
 200                                   Encoder* /*encoder*/) {}
 201
 202   // Hook to be called on every compressed data packet.
 203   virtual void FramePktHook(const vpx_codec_cx_pkt_t* /*pkt*/) {}
 204
 205   // Hook to be called on every PSNR packet.
 206   virtual void PSNRPktHook(const vpx_codec_cx_pkt_t* /*pkt*/) {}
 207
 208   // Hook to determine whether the encode loop should continue.
 209   virtual bool Continue() const {
 210     return !(::testing::Test::HasFatalFailure() || abort_);
 211   }
 212
 213   const CodecFactory   *codec_;
 214   // Hook to determine whether to decode frame after encoding
 215   virtual bool DoDecode() const { return 1; }
 216
 217   // Hook to handle encode/decode mismatch
 218   virtual void MismatchHook(const vpx_image_t *img1,
 219                             const vpx_image_t *img2);
 220
 221   // Hook to be called on every decompressed frame.
 222   virtual void DecompressedFrameHook(const vpx_image_t& /*img*/,
 223                                      vpx_codec_pts_t /*pts*/) {}
 224
 225   // Hook to be called to handle decode result. Return true to continue.
 226   virtual bool HandleDecodeResult(const vpx_codec_err_t res_dec,
 227                                   const VideoSource& /*video*/,
 228                                   Decoder *decoder) {
 229     EXPECT_EQ(VPX_CODEC_OK, res_dec) << decoder->DecodeError();
 230     return VPX_CODEC_OK == res_dec;
 231   }
 232
 233   // Hook that can modify the encoder's output data
 234   virtual const vpx_codec_cx_pkt_t *MutateEncoderOutputHook(
 235       const vpx_codec_cx_pkt_t *pkt) {
 236     return pkt;
 237   }
 238
 239   bool                 abort_;
 240   vpx_codec_enc_cfg_t  cfg_;
 241   unsigned int         passes_;
 242   unsigned long        deadline_;
 243   TwopassStatsStore    stats_;
 244   unsigned long        init_flags_;
 245   unsigned long        frame_flags_;
 246   vpx_codec_pts_t      last_pts_;
 247 };
 248
 249 }  // namespace libvpx_test
 250
 251 #endif  // TEST_ENCODE_TEST_DRIVER_H_