blob: ce222b996313e001901ce3f9fa72c3fe489a8dd4 [file] [log] [blame]
/*
* Copyright (c) 2021, Alliance for Open Media. All rights reserved
*
* This source code is subject to the terms of the BSD 3-Clause Clear License
* and the Alliance for Open Media Patent License 1.0. If the BSD 3-Clause Clear
* License was not distributed with this source code in the LICENSE file, you
* can obtain it at aomedia.org/license/software-license/bsd-3-c-c/. If the
* Alliance for Open Media Patent License 1.0 was not distributed with this
* source code in the PATENTS file, you can obtain it at
* aomedia.org/license/patent-license/.
*/
#ifndef AOM_TEST_ENCODE_TEST_DRIVER_H_
#define AOM_TEST_ENCODE_TEST_DRIVER_H_
#include <string>
#include <vector>
#include "third_party/googletest/src/googletest/include/gtest/gtest.h"
#include "config/aom_config.h"
#if CONFIG_AV1_ENCODER
#include "aom/aomcx.h"
#endif
#include "aom/aom_encoder.h"
namespace libaom_test {
class CodecFactory;
class VideoSource;
#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
class DxDataIterator;
#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
enum TestMode { kOnePassGood };
#define ALL_TEST_MODES ::testing::Values(::libaom_test::kOnePassGood)
#define ONE_PASS_TEST_MODES ::testing::Values(::libaom_test::kOnePassGood)
#define TWO_PASS_TEST_MODES ::testing::Values()
#define GOODQUALITY_TEST_MODES ::testing::Values(::libaom_test::kOnePassGood)
// Provides an object to handle the libaom get_cx_data() iteration pattern
class CxDataIterator {
public:
explicit CxDataIterator(aom_codec_ctx_t *encoder)
: encoder_(encoder), iter_(NULL) {}
const aom_codec_cx_pkt_t *Next() {
return aom_codec_get_cx_data(encoder_, &iter_);
}
private:
aom_codec_ctx_t *encoder_;
aom_codec_iter_t iter_;
};
// Implements an in-memory store for libaom twopass statistics
class TwopassStatsStore {
public:
void Append(const aom_codec_cx_pkt_t &pkt) {
buffer_.append(reinterpret_cast<char *>(pkt.data.twopass_stats.buf),
pkt.data.twopass_stats.sz);
}
aom_fixed_buf_t buf() {
const aom_fixed_buf_t buf = { &buffer_[0], buffer_.size() };
return buf;
}
void Reset() { buffer_.clear(); }
protected:
std::string buffer_;
};
// Provides a simplified interface to manage one video encoding pass, given
// a configuration and video source.
//
// TODO(jkoleszar): The exact services it provides and the appropriate
// level of abstraction will be fleshed out as more tests are written.
class Encoder {
public:
Encoder(aom_codec_enc_cfg_t cfg, const aom_codec_flags_t init_flags)
: cfg_(cfg), init_flags_(init_flags) {
memset(&encoder_, 0, sizeof(encoder_));
}
virtual ~Encoder() { aom_codec_destroy(&encoder_); }
CxDataIterator GetCxData() { return CxDataIterator(&encoder_); }
void InitEncoder(VideoSource *video);
const aom_image_t *GetPreviewFrame() {
return aom_codec_get_preview_frame(&encoder_);
}
// This is a thin wrapper around aom_codec_encode(), so refer to
// aom_encoder.h for its semantics.
void EncodeFrame(VideoSource *video, const unsigned long frame_flags);
// Convenience wrapper for EncodeFrame()
void EncodeFrame(VideoSource *video) { EncodeFrame(video, 0); }
void Control(int ctrl_id, int arg) {
const aom_codec_err_t res = aom_codec_control(&encoder_, ctrl_id, arg);
ASSERT_EQ(AOM_CODEC_OK, res) << EncoderError();
}
void Control(int ctrl_id, int *arg) {
const aom_codec_err_t res = aom_codec_control(&encoder_, ctrl_id, arg);
ASSERT_EQ(AOM_CODEC_OK, res) << EncoderError();
}
void Control(int ctrl_id, struct aom_scaling_mode *arg) {
const aom_codec_err_t res = aom_codec_control(&encoder_, ctrl_id, arg);
ASSERT_EQ(AOM_CODEC_OK, res) << EncoderError();
}
void Control(int ctrl_id, const char *arg) {
const aom_codec_err_t res = aom_codec_control(&encoder_, ctrl_id, arg);
ASSERT_EQ(AOM_CODEC_OK, res) << EncoderError();
}
void Control(int ctrl_id, const void *arg) {
const aom_codec_err_t res = aom_codec_control(&encoder_, ctrl_id, arg);
ASSERT_EQ(AOM_CODEC_OK, res) << EncoderError();
}
#if CONFIG_AV1_ENCODER
void Control(int ctrl_id, aom_active_map_t *arg) {
const aom_codec_err_t res = aom_codec_control(&encoder_, ctrl_id, arg);
ASSERT_EQ(AOM_CODEC_OK, res) << EncoderError();
}
#endif
void Config(const aom_codec_enc_cfg_t *cfg) {
const aom_codec_err_t res = aom_codec_enc_config_set(&encoder_, cfg);
ASSERT_EQ(AOM_CODEC_OK, res) << EncoderError();
cfg_ = *cfg;
}
protected:
virtual aom_codec_iface_t *CodecInterface() const = 0;
const char *EncoderError() {
const char *detail = aom_codec_error_detail(&encoder_);
return detail ? detail : aom_codec_error(&encoder_);
}
// Encode an image
void EncodeFrameInternal(const VideoSource &video,
const unsigned long frame_flags);
// Flush the encoder on EOS
void Flush();
aom_codec_ctx_t encoder_;
aom_codec_enc_cfg_t cfg_;
aom_codec_flags_t init_flags_;
};
// Common test functionality for all Encoder tests.
//
// This class is a mixin which provides the main loop common to all
// encoder tests. It provides hooks which can be overridden by subclasses
// to implement each test's specific behavior, while centralizing the bulk
// of the boilerplate. Note that it doesn't inherit the gtest testing
// classes directly, so that tests can be parameterized differently.
class EncoderTest {
protected:
explicit EncoderTest(const CodecFactory *codec)
: codec_(codec), abort_(false), init_flags_(0), frame_flags_(0),
last_pts_(0), mode_(kOnePassGood), number_spatial_layers_(1) {
// Default to 1 thread.
cfg_.g_threads = 1;
}
virtual ~EncoderTest() {}
// Initialize the cfg_ member with the default configuration.
void InitializeConfig();
// Map the TestMode enum to the passes_ variables.
void SetMode(TestMode mode);
// Set encoder flag.
void set_init_flags(aom_codec_flags_t flag) { init_flags_ = flag; }
// Main loop
virtual void RunLoop(VideoSource *video);
// Hook to be called at the beginning of a pass.
virtual void BeginPassHook(unsigned int /*pass*/) {}
// Hook to be called at the end of a pass.
virtual void EndPassHook() {}
// Hook to be called before encoding a frame.
virtual void PreEncodeFrameHook(VideoSource * /*video*/) {}
virtual void PreEncodeFrameHook(VideoSource * /*video*/,
Encoder * /*encoder*/) {}
// Hook to be called on every compressed data packet.
virtual void FramePktHook(const aom_codec_cx_pkt_t * /*pkt*/
#if CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
,
DxDataIterator * /*dec_iter*/
#endif // CONFIG_OUTPUT_FRAME_BASED_ON_ORDER_HINT
) {
}
// Hook to be called on every PSNR packet.
virtual void PSNRPktHook(const aom_codec_cx_pkt_t * /*pkt*/) {}
// Hook to be called on every first pass stats packet.
virtual void StatsPktHook(const aom_codec_cx_pkt_t * /*pkt*/) {}
// Hook to determine whether the encode loop should continue.
virtual bool Continue() const {
return !(::testing::Test::HasFatalFailure() || abort_);
}
// Hook to call before decoding a frame.
virtual void PreDecodeFrameHook(VideoSource * /*video*/,
Decoder * /*decoder*/) {}
// Hook to determine whether to decode frame after encoding
virtual bool DoDecode() const { return true; }
// Hook to determine whether to decode invisible frames after encoding
virtual bool DoDecodeInvisible() const { return true; }
// Hook to handle encode/decode mismatch
virtual void MismatchHook(const aom_image_t *img1, const aom_image_t *img2);
// Hook to be called on every decompressed frame.
virtual void DecompressedFrameHook(const aom_image_t & /*img*/,
aom_codec_pts_t /*pts*/) {}
// Hook to be called to handle decode result. Return true to continue.
virtual bool HandleDecodeResult(const aom_codec_err_t res_dec,
Decoder *decoder) {
EXPECT_EQ(AOM_CODEC_OK, res_dec) << decoder->DecodeError();
return AOM_CODEC_OK == res_dec;
}
// Hook to be called to handle encode result. Return true to continue.
virtual bool HandleEncodeResult(VideoSource * /*video*/,
Encoder * /*encoder*/) {
return 1;
}
virtual int GetNumSpatialLayers() { return 1; }
// Hook that can modify the encoder's output data
virtual const aom_codec_cx_pkt_t *MutateEncoderOutputHook(
const aom_codec_cx_pkt_t *pkt) {
return pkt;
}
const CodecFactory *codec_;
bool abort_;
aom_codec_enc_cfg_t cfg_;
unsigned int passes_;
aom_codec_flags_t init_flags_;
unsigned long frame_flags_;
aom_codec_pts_t last_pts_;
TestMode mode_;
int number_spatial_layers_;
};
} // namespace libaom_test
#endif // AOM_TEST_ENCODE_TEST_DRIVER_H_