blob: 517d54bd946e57738787ec38783a917a4408ea00 [file] [log] [blame]
/*
* Copyright (c) 2020, Alliance for Open Media. All rights reserved
*
* This source code is subject to the terms of the BSD 2 Clause License and
* the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
* was not distributed with this source code in the LICENSE file, you can
* obtain it at www.aomedia.org/license/software. 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 www.aomedia.org/license/patent.
*/
#include "aom/aom_codec.h"
#include "aom_dsp/aom_dsp_common.h"
#include "third_party/googletest/src/googletest/include/gtest/gtest.h"
#include "test/codec_factory.h"
#include "test/encode_test_driver.h"
#include "test/y4m_video_source.h"
#include "test/i420_video_source.h"
#include "test/util.h"
namespace {
typedef struct {
// Superblock size
const unsigned int sb_size;
// log2(number of tile rows)
const unsigned int tile_rows;
// log2(number of tile columns)
const unsigned int tile_cols;
} uniformTileConfigParam;
const libaom_test::TestMode kTestModeParams[] =
#if CONFIG_REALTIME_ONLY
{ ::libaom_test::kRealTime };
#else
{ ::libaom_test::kRealTime, ::libaom_test::kOnePassGood,
::libaom_test::kTwoPassGood };
#endif
static const uniformTileConfigParam uniformTileConfigParams[] = {
{ 128, 0, 0 }, { 128, 0, 2 }, { 128, 2, 0 }, { 128, 1, 2 }, { 128, 2, 2 },
{ 128, 3, 2 }, { 64, 0, 0 }, { 64, 0, 2 }, { 64, 2, 0 }, { 64, 1, 2 },
{ 64, 2, 2 }, { 64, 3, 3 }, { 64, 4, 4 }
};
typedef struct {
// Superblock size
const unsigned int sb_size;
// number of tile widths
const unsigned int tile_width_count;
// list of tile widths
int tile_widths[AOM_MAX_TILE_COLS];
// number of tile heights
const unsigned int tile_height_count;
// list of tile heights
int tile_heights[AOM_MAX_TILE_ROWS];
} nonUniformTileConfigParam;
const nonUniformTileConfigParam nonUniformTileConfigParams[] = {
{ 64, 1, { 3 }, 1, { 3 } }, { 64, 2, { 1, 2 }, 2, { 1, 2 } },
{ 64, 3, { 2, 3, 4 }, 2, { 2, 3 } }, { 128, 1, { 3 }, 1, { 3 } },
{ 128, 2, { 1, 2 }, 2, { 1, 2 } }, { 128, 3, { 2, 3, 4 }, 2, { 2, 3 } },
};
// Find smallest k>=0 such that (blk_size << k) >= target
static INLINE int tile_log2(int blk_size, int target) {
int k;
for (k = 0; (blk_size << k) < target; k++) {
}
return k;
}
// This class is used to validate tile configuration for uniform spacing.
class UniformTileConfigTestLarge
: public ::libaom_test::CodecTestWith3Params<
libaom_test::TestMode, uniformTileConfigParam, aom_rc_mode>,
public ::libaom_test::EncoderTest {
protected:
UniformTileConfigTestLarge()
: EncoderTest(GET_PARAM(0)), encoding_mode_(GET_PARAM(1)),
tile_config_param_(GET_PARAM(2)), end_usage_check_(GET_PARAM(3)) {
tile_config_violated_ = false;
max_tile_cols_log2_ = tile_log2(1, AOM_MAX_TILE_COLS);
max_tile_rows_log2_ = tile_log2(1, AOM_MAX_TILE_ROWS);
}
virtual ~UniformTileConfigTestLarge() {}
virtual void SetUp() {
InitializeConfig(encoding_mode_);
const aom_rational timebase = { 1, 30 };
cfg_.g_timebase = timebase;
cfg_.rc_end_usage = end_usage_check_;
cfg_.g_threads = 1;
cfg_.g_lag_in_frames = 19;
}
virtual bool DoDecode() const { return 1; }
virtual void PreEncodeFrameHook(::libaom_test::VideoSource *video,
::libaom_test::Encoder *encoder) {
if (video->frame() == 0) {
encoder->Control(AV1E_SET_TILE_COLUMNS, tile_config_param_.tile_cols);
encoder->Control(AV1E_SET_TILE_ROWS, tile_config_param_.tile_rows);
encoder->Control(AOME_SET_CPUUSED, 5);
encoder->Control(AOME_SET_ENABLEAUTOALTREF, 1);
encoder->Control(AV1E_SET_SUPERBLOCK_SIZE,
tile_config_param_.sb_size == 64
? AOM_SUPERBLOCK_SIZE_64X64
: AOM_SUPERBLOCK_SIZE_128X128);
}
}
virtual bool HandleDecodeResult(const aom_codec_err_t res_dec,
libaom_test::Decoder *decoder) {
EXPECT_EQ(AOM_CODEC_OK, res_dec) << decoder->DecodeError();
if (AOM_CODEC_OK == res_dec) {
aom_codec_ctx_t *ctx_dec = decoder->GetDecoder();
aom_tile_info tile_info;
int config_tile_columns = AOMMIN(1 << (int)tile_config_param_.tile_cols,
1 << max_tile_cols_log2_);
int config_tile_rows = AOMMIN(1 << (int)tile_config_param_.tile_rows,
1 << max_tile_rows_log2_);
AOM_CODEC_CONTROL_TYPECHECKED(ctx_dec, AOMD_GET_TILE_INFO, &tile_info);
if (tile_info.tile_columns != config_tile_columns ||
tile_info.tile_rows != config_tile_rows) {
tile_config_violated_ = true;
}
}
return AOM_CODEC_OK == res_dec;
}
::libaom_test::TestMode encoding_mode_;
const uniformTileConfigParam tile_config_param_;
int max_tile_cols_log2_;
int max_tile_rows_log2_;
bool tile_config_violated_;
aom_rc_mode end_usage_check_;
};
// This class is used to validate tile configuration for non uniform spacing.
class NonUniformTileConfigTestLarge
: public ::libaom_test::CodecTestWith3Params<
libaom_test::TestMode, nonUniformTileConfigParam, aom_rc_mode>,
public ::libaom_test::EncoderTest {
protected:
NonUniformTileConfigTestLarge()
: EncoderTest(GET_PARAM(0)), encoding_mode_(GET_PARAM(1)),
tile_config_param_(GET_PARAM(2)), rc_end_usage_(GET_PARAM(3)) {
tile_config_violated_ = false;
}
virtual ~NonUniformTileConfigTestLarge() {}
virtual void SetUp() {
InitializeConfig(encoding_mode_);
const aom_rational timebase = { 1, 30 };
cfg_.g_timebase = timebase;
cfg_.rc_end_usage = rc_end_usage_;
cfg_.g_threads = 1;
cfg_.g_lag_in_frames = 35;
cfg_.rc_target_bitrate = 1000;
cfg_.tile_width_count = tile_config_param_.tile_width_count;
memcpy(cfg_.tile_widths, tile_config_param_.tile_widths,
sizeof(tile_config_param_.tile_widths[0]) *
tile_config_param_.tile_width_count);
cfg_.tile_height_count = tile_config_param_.tile_height_count;
memcpy(cfg_.tile_heights, tile_config_param_.tile_heights,
sizeof(tile_config_param_.tile_heights[0]) *
tile_config_param_.tile_height_count);
}
virtual bool DoDecode() const { return 1; }
virtual void PreEncodeFrameHook(::libaom_test::VideoSource *video,
::libaom_test::Encoder *encoder) {
if (video->frame() == 0) {
encoder->Control(AOME_SET_CPUUSED, 5);
encoder->Control(AOME_SET_ENABLEAUTOALTREF, 1);
encoder->Control(AV1E_SET_SUPERBLOCK_SIZE,
tile_config_param_.sb_size == 64
? AOM_SUPERBLOCK_SIZE_64X64
: AOM_SUPERBLOCK_SIZE_128X128);
}
}
virtual bool HandleDecodeResult(const aom_codec_err_t res_dec,
libaom_test::Decoder *decoder) {
EXPECT_EQ(AOM_CODEC_OK, res_dec) << decoder->DecodeError();
if (AOM_CODEC_OK == res_dec) {
aom_codec_ctx_t *ctx_dec = decoder->GetDecoder();
aom_tile_info tile_info;
AOM_CODEC_CONTROL_TYPECHECKED(ctx_dec, AOMD_GET_TILE_INFO, &tile_info);
// check validity of tile cols
int tile_col_idx, tile_col = 0;
for (tile_col_idx = 0; tile_col_idx < tile_info.tile_columns - 1;
tile_col_idx++) {
if (tile_config_param_.tile_widths[tile_col] !=
tile_info.tile_widths[tile_col_idx])
tile_config_violated_ = true;
tile_col = (tile_col + 1) % (int)tile_config_param_.tile_width_count;
}
// last column may not be able to accommodate config, but if it is
// greater than what is configured, there is a violation.
if (tile_config_param_.tile_widths[tile_col] <
tile_info.tile_widths[tile_col_idx])
tile_config_violated_ = true;
// check validity of tile rows
int tile_row_idx, tile_row = 0;
for (tile_row_idx = 0; tile_row_idx < tile_info.tile_rows - 1;
tile_row_idx++) {
if (tile_config_param_.tile_heights[tile_row] !=
tile_info.tile_heights[tile_row_idx])
tile_config_violated_ = true;
tile_row = (tile_row + 1) % (int)tile_config_param_.tile_height_count;
}
// last row may not be able to accommodate config, but if it is
// greater than what is configured, there is a violation.
if (tile_config_param_.tile_heights[tile_row] <
tile_info.tile_heights[tile_row_idx])
tile_config_violated_ = true;
}
return AOM_CODEC_OK == res_dec;
}
::libaom_test::TestMode encoding_mode_;
const nonUniformTileConfigParam tile_config_param_;
bool tile_config_violated_;
aom_rc_mode rc_end_usage_;
};
TEST_P(UniformTileConfigTestLarge, UniformTileConfigTest) {
::libaom_test::Y4mVideoSource video("niklas_1280_720_30.y4m", 0, 1);
ASSERT_NO_FATAL_FAILURE(video.Begin());
int max_tiles_cols = video.img()->w / (int)tile_config_param_.sb_size;
int max_tiles_rows = video.img()->h / (int)tile_config_param_.sb_size;
max_tile_cols_log2_ = tile_log2(1, AOMMIN(max_tiles_cols, AOM_MAX_TILE_COLS));
max_tile_rows_log2_ = tile_log2(1, AOMMIN(max_tiles_rows, AOM_MAX_TILE_ROWS));
ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
ASSERT_EQ(tile_config_violated_, false);
}
TEST_P(UniformTileConfigTestLarge, UniformTileConfigTestLowRes) {
::libaom_test::Y4mVideoSource video("screendata.y4m", 0, 1);
ASSERT_NO_FATAL_FAILURE(video.Begin());
int max_tiles_cols = video.img()->w / (int)tile_config_param_.sb_size;
int max_tiles_rows = video.img()->h / (int)tile_config_param_.sb_size;
max_tile_cols_log2_ = tile_log2(1, AOMMIN(max_tiles_cols, AOM_MAX_TILE_COLS));
max_tile_rows_log2_ = tile_log2(1, AOMMIN(max_tiles_rows, AOM_MAX_TILE_ROWS));
ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
ASSERT_EQ(tile_config_violated_, false);
}
TEST_P(NonUniformTileConfigTestLarge, NonUniformTileConfigTest) {
::libaom_test::Y4mVideoSource video("niklas_1280_720_30.y4m", 0, 1);
ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
ASSERT_EQ(tile_config_violated_, false);
}
AV1_INSTANTIATE_TEST_SUITE(UniformTileConfigTestLarge,
::testing::ValuesIn(kTestModeParams),
::testing::ValuesIn(uniformTileConfigParams),
::testing::Values(AOM_Q, AOM_VBR, AOM_CBR, AOM_CQ));
AV1_INSTANTIATE_TEST_SUITE(NonUniformTileConfigTestLarge,
::testing::ValuesIn(kTestModeParams),
::testing::ValuesIn(nonUniformTileConfigParams),
::testing::Values(AOM_Q, AOM_VBR, AOM_CBR, AOM_CQ));
typedef struct {
// Number of tile groups to set.
const int num_tg;
// Number of tile rows to set
const int num_tile_rows;
// Number of tile columns to set
const int num_tile_cols;
} TileGroupConfigParams;
static const TileGroupConfigParams tileGroupTestParams[] = {
{ 5, 4, 4 }, { 3, 3, 3 }, { 5, 3, 3 }, { 7, 5, 5 }, { 7, 3, 3 }, { 7, 4, 4 }
};
std::ostream &operator<<(std::ostream &os,
const TileGroupConfigParams &test_arg) {
return os << "TileGroupConfigParams { num_tg:" << test_arg.num_tg
<< " num_tile_rows:" << test_arg.num_tile_rows
<< " num_tile_cols:" << test_arg.num_tile_cols << " }";
}
// This class is used to test number of tile groups present in header.
class TileGroupTestLarge
: public ::libaom_test::CodecTestWith2Params<libaom_test::TestMode,
TileGroupConfigParams>,
public ::libaom_test::EncoderTest {
protected:
TileGroupTestLarge()
: EncoderTest(GET_PARAM(0)), encoding_mode_(GET_PARAM(1)),
tile_group_config_params_(GET_PARAM(2)) {
tile_group_config_violated_ = false;
}
virtual ~TileGroupTestLarge() {}
virtual void SetUp() {
InitializeConfig(encoding_mode_);
const aom_rational timebase = { 1, 30 };
cfg_.g_timebase = timebase;
cfg_.rc_end_usage = AOM_Q;
cfg_.g_threads = 1;
}
virtual bool DoDecode() const { return 1; }
virtual void PreEncodeFrameHook(::libaom_test::VideoSource *video,
::libaom_test::Encoder *encoder) {
if (video->frame() == 0) {
encoder->Control(AOME_SET_CPUUSED, 5);
encoder->Control(AV1E_SET_NUM_TG, tile_group_config_params_.num_tg);
encoder->Control(AV1E_SET_TILE_COLUMNS,
tile_group_config_params_.num_tile_cols);
encoder->Control(AV1E_SET_TILE_ROWS,
tile_group_config_params_.num_tile_rows);
}
}
virtual bool HandleDecodeResult(const aom_codec_err_t res_dec,
libaom_test::Decoder *decoder) {
EXPECT_EQ(AOM_CODEC_OK, res_dec) << decoder->DecodeError();
if (AOM_CODEC_OK == res_dec) {
aom_tile_info tile_info;
aom_codec_ctx_t *ctx_dec = decoder->GetDecoder();
AOM_CODEC_CONTROL_TYPECHECKED(ctx_dec, AOMD_GET_TILE_INFO, &tile_info);
AOM_CODEC_CONTROL_TYPECHECKED(ctx_dec, AOMD_GET_SHOW_EXISTING_FRAME_FLAG,
&show_existing_frame_);
if (tile_info.num_tile_groups != tile_group_config_params_.num_tg &&
!show_existing_frame_)
tile_group_config_violated_ = true;
EXPECT_EQ(tile_group_config_violated_, false);
}
return AOM_CODEC_OK == res_dec;
}
int show_existing_frame_;
bool tile_group_config_violated_;
aom_rc_mode end_usage_check_;
::libaom_test::TestMode encoding_mode_;
const TileGroupConfigParams tile_group_config_params_;
};
TEST_P(TileGroupTestLarge, TileGroupCountTest) {
libaom_test::I420VideoSource video("niklas_640_480_30.yuv", 640, 480,
cfg_.g_timebase.den, cfg_.g_timebase.num,
0, 5);
ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
}
AV1_INSTANTIATE_TEST_SUITE(TileGroupTestLarge,
::testing::ValuesIn(kTestModeParams),
::testing::ValuesIn(tileGroupTestParams));
} // namespace