generic-library/vpx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

test: apply clang-format

Browse Source 
Change-Id: I0d9ab85855eb723f653a7bb09b3d0d31dd6cfd2f
This commit is contained in:
clang-format 2016-07-25 22:50:48 -07:00 committed by James Zern
parent e4290800b2
commit 33e40cb5db
88 changed files with 2928 additions and 3653 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
test/acm_random.h
View File

@ -23,9 +23,7 @@ class ACMRandom {
explicit ACMRandom(int seed) : random_(seed) {} explicit ACMRandom(int seed) : random_(seed) {}
void Reset(int seed) { void Reset(int seed) { random_.Reseed(seed); }
random_.Reseed(seed);
}
uint16_t Rand16(void) { uint16_t Rand16(void) {
const uint32_t value = const uint32_t value =
random_.Generate(testing::internal::Random::kMaxRange); random_.Generate(testing::internal::Random::kMaxRange);
@ -52,17 +50,11 @@ class ACMRandom {
return r < 128 ? r << 4 : r >> 4; return r < 128 ? r << 4 : r >> 4;
} }
int PseudoUniform(int range) { int PseudoUniform(int range) { return random_.Generate(range); }
return random_.Generate(range);
}
int operator()(int n) { int operator()(int n) { return PseudoUniform(n); }
return PseudoUniform(n);
}
static int DeterministicSeed(void) { static int DeterministicSeed(void) { return 0xbaba; }
return 0xbaba;
}
private: private:
testing::internal::Random random_; testing::internal::Random random_;

4
test/active_map_refresh_test.cc
View File

@ -17,8 +17,8 @@
namespace { namespace {
// Check if any pixel in a 16x16 macroblock varies between frames. // Check if any pixel in a 16x16 macroblock varies between frames.
int CheckMb(const vpx_image_t &current, const vpx_image_t &previous, int CheckMb(const vpx_image_t &current, const vpx_image_t &previous, int mb_r,
int mb_r, int mb_c) { int mb_c) {
for (int plane = 0; plane < 3; plane++) { for (int plane = 0; plane < 3; plane++) {
int r = 16 * mb_r; int r = 16 * mb_r;
int c0 = 16 * mb_c; int c0 = 16 * mb_c;

6
test/active_map_test.cc
View File

@ -39,6 +39,7 @@ class ActiveMapTest
encoder->Control(VP8E_SET_CPUUSED, cpu_used_); encoder->Control(VP8E_SET_CPUUSED, cpu_used_);
} else if (video->frame() == 3) { } else if (video->frame() == 3) {
vpx_active_map_t map = vpx_active_map_t(); vpx_active_map_t map = vpx_active_map_t();
/* clang-format off */
uint8_t active_map[9 * 13] = { uint8_t active_map[9 * 13] = {
1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0,
1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0,
@ -50,6 +51,7 @@ class ActiveMapTest
0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1,
1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0,
}; };
/* clang-format on */
map.cols = (kWidth + 15) / 16; map.cols = (kWidth + 15) / 16;
map.rows = (kHeight + 15) / 16; map.rows = (kHeight + 15) / 16;
ASSERT_EQ(map.cols, 13u); ASSERT_EQ(map.cols, 13u);
@ -77,8 +79,8 @@ TEST_P(ActiveMapTest, Test) {
cfg_.rc_end_usage = VPX_CBR; cfg_.rc_end_usage = VPX_CBR;
cfg_.kf_max_dist = 90000; cfg_.kf_max_dist = 90000;
::libvpx_test::I420VideoSource video("hantro_odd.yuv", kWidth, kHeight, 30, ::libvpx_test::I420VideoSource video("hantro_odd.yuv", kWidth, kHeight, 30, 1,
1, 0, 20); 0, 20);
ASSERT_NO_FATAL_FAILURE(RunLoop(&video)); ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
} }

31
test/add_noise_test.cc
View File

@ -22,15 +22,12 @@ static const int kNoiseSize = 3072;
// TODO(jimbankoski): make width and height integers not unsigned. // TODO(jimbankoski): make width and height integers not unsigned.
typedef void (*AddNoiseFunc)(uint8_t *start, const int8_t *noise, typedef void (*AddNoiseFunc)(uint8_t *start, const int8_t *noise,
int blackclamp, int whiteclamp, int blackclamp, int whiteclamp, int width,
int width, int height, int pitch); int height, int pitch);
class AddNoiseTest class AddNoiseTest : public ::testing::TestWithParam<AddNoiseFunc> {
: public ::testing::TestWithParam<AddNoiseFunc> {
public: public:
virtual void TearDown() { virtual void TearDown() { libvpx_test::ClearSystemState(); }
libvpx_test::ClearSystemState();
}
virtual ~AddNoiseTest() {} virtual ~AddNoiseTest() {}
}; };
@ -43,18 +40,18 @@ double stddev6(char a, char b, char c, char d, char e, char f) {
} }
TEST_P(AddNoiseTest, CheckNoiseAdded) { TEST_P(AddNoiseTest, CheckNoiseAdded) {
const int width = 64; const int width = 64;
const int height = 64; const int height = 64;
const int image_size = width * height; const int image_size = width * height;
int8_t noise[kNoiseSize]; int8_t noise[kNoiseSize];
const int clamp = vpx_setup_noise(4.4, noise, kNoiseSize); const int clamp = vpx_setup_noise(4.4, noise, kNoiseSize);
uint8_t *const s = reinterpret_cast<uint8_t *>(vpx_calloc(image_size, uint8_t *const s =
sizeof(*s))); reinterpret_cast<uint8_t *>(vpx_calloc(image_size, sizeof(*s)));
ASSERT_TRUE(s != NULL); ASSERT_TRUE(s != NULL);
memset(s, 99, image_size * sizeof(*s)); memset(s, 99, image_size * sizeof(*s));
ASM_REGISTER_STATE_CHECK(GetParam()(s, noise, clamp, clamp, ASM_REGISTER_STATE_CHECK(
width, height, width)); GetParam()(s, noise, clamp, clamp, width, height, width));
// Check to make sure we don't end up having either the same or no added // Check to make sure we don't end up having either the same or no added
// noise either vertically or horizontally. // noise either vertically or horizontally.
@ -72,8 +69,8 @@ TEST_P(AddNoiseTest, CheckNoiseAdded) {
// Initialize pixels in the image to 255 and check for roll over. // Initialize pixels in the image to 255 and check for roll over.
memset(s, 255, image_size); memset(s, 255, image_size);
ASM_REGISTER_STATE_CHECK(GetParam()(s, noise, clamp, clamp, ASM_REGISTER_STATE_CHECK(
width, height, width)); GetParam()(s, noise, clamp, clamp, width, height, width));
// Check to make sure don't roll over. // Check to make sure don't roll over.
for (int i = 0; i < image_size; ++i) { for (int i = 0; i < image_size; ++i) {
@ -83,8 +80,8 @@ TEST_P(AddNoiseTest, CheckNoiseAdded) {
// Initialize pixels in the image to 0 and check for roll under. // Initialize pixels in the image to 0 and check for roll under.
memset(s, 0, image_size); memset(s, 0, image_size);
ASM_REGISTER_STATE_CHECK(GetParam()(s, noise, clamp, clamp, ASM_REGISTER_STATE_CHECK(
width, height, width)); GetParam()(s, noise, clamp, clamp, width, height, width));
// Check to make sure don't roll under. // Check to make sure don't roll under.
for (int i = 0; i < image_size; ++i) { for (int i = 0; i < image_size; ++i) {
@ -95,7 +92,7 @@ TEST_P(AddNoiseTest, CheckNoiseAdded) {
} }
TEST_P(AddNoiseTest, CheckCvsAssembly) { TEST_P(AddNoiseTest, CheckCvsAssembly) {
const int width = 64; const int width = 64;
const int height = 64; const int height = 64;
const int image_size = width * height; const int image_size = width * height;
int8_t noise[kNoiseSize]; int8_t noise[kNoiseSize];

29
test/altref_test.cc
View File

@ -21,7 +21,7 @@ const int kLookAheadMin = 5;
const int kLookAheadMax = 26; const int kLookAheadMax = 26;
class AltRefTest : public ::libvpx_test::EncoderTest, class AltRefTest : public ::libvpx_test::EncoderTest,
public ::libvpx_test::CodecTestWithParam<int> { public ::libvpx_test::CodecTestWithParam<int> {
protected: protected:
AltRefTest() : EncoderTest(GET_PARAM(0)), altref_count_(0) {} AltRefTest() : EncoderTest(GET_PARAM(0)), altref_count_(0) {}
virtual ~AltRefTest() {} virtual ~AltRefTest() {}
@ -31,9 +31,7 @@ class AltRefTest : public ::libvpx_test::EncoderTest,
SetMode(libvpx_test::kTwoPassGood); SetMode(libvpx_test::kTwoPassGood);
} }
virtual void BeginPassHook(unsigned int pass) { virtual void BeginPassHook(unsigned int pass) { altref_count_ = 0; }
altref_count_ = 0;
}
virtual void PreEncodeFrameHook(libvpx_test::VideoSource *video, virtual void PreEncodeFrameHook(libvpx_test::VideoSource *video,
libvpx_test::Encoder *encoder) { libvpx_test::Encoder *encoder) {
@ -75,11 +73,8 @@ class AltRefForcedKeyTestLarge
public ::libvpx_test::CodecTestWith2Params<libvpx_test::TestMode, int> { public ::libvpx_test::CodecTestWith2Params<libvpx_test::TestMode, int> {
protected: protected:
AltRefForcedKeyTestLarge() AltRefForcedKeyTestLarge()
: EncoderTest(GET_PARAM(0)), : EncoderTest(GET_PARAM(0)), encoding_mode_(GET_PARAM(1)),
encoding_mode_(GET_PARAM(1)), cpu_used_(GET_PARAM(2)), forced_kf_frame_num_(1), frame_num_(0) {}
cpu_used_(GET_PARAM(2)),
forced_kf_frame_num_(1),
frame_num_(0) {}
virtual ~AltRefForcedKeyTestLarge() {} virtual ~AltRefForcedKeyTestLarge() {}
virtual void SetUp() { virtual void SetUp() {
@ -94,8 +89,8 @@ class AltRefForcedKeyTestLarge
if (video->frame() == 0) { if (video->frame() == 0) {
encoder->Control(VP8E_SET_CPUUSED, cpu_used_); encoder->Control(VP8E_SET_CPUUSED, cpu_used_);
encoder->Control(VP8E_SET_ENABLEAUTOALTREF, 1); encoder->Control(VP8E_SET_ENABLEAUTOALTREF, 1);
// override test default for tile columns if necessary.
#if CONFIG_VP9_ENCODER #if CONFIG_VP9_ENCODER
// override test default for tile columns if necessary.
if (GET_PARAM(0) == &libvpx_test::kVP9) { if (GET_PARAM(0) == &libvpx_test::kVP9) {
encoder->Control(VP9E_SET_TILE_COLUMNS, 6); encoder->Control(VP9E_SET_TILE_COLUMNS, 6);
} }
@ -147,13 +142,11 @@ TEST_P(AltRefForcedKeyTestLarge, ForcedFrameIsKey) {
} }
} }
VP8_INSTANTIATE_TEST_CASE( VP8_INSTANTIATE_TEST_CASE(AltRefForcedKeyTestLarge,
AltRefForcedKeyTestLarge, ::testing::Values(::libvpx_test::kOnePassGood),
::testing::Values(::libvpx_test::kOnePassGood), ::testing::Range(0, 9));
::testing::Range(0, 9));
VP9_INSTANTIATE_TEST_CASE( VP9_INSTANTIATE_TEST_CASE(AltRefForcedKeyTestLarge,
AltRefForcedKeyTestLarge, ::testing::Values(::libvpx_test::kOnePassGood),
::testing::Values(::libvpx_test::kOnePassGood), ::testing::Range(0, 9));
::testing::Range(0, 9));
} // namespace } // namespace

6
test/aq_segment_test.cc
View File

@ -57,7 +57,7 @@ TEST_P(AqSegmentTest, TestNoMisMatchAQ1) {
aq_mode_ = 1; aq_mode_ = 1;
::libvpx_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352, 288, ::libvpx_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352, 288,
30, 1, 0, 100); 30, 1, 0, 100);
ASSERT_NO_FATAL_FAILURE(RunLoop(&video)); ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
} }
@ -77,7 +77,7 @@ TEST_P(AqSegmentTest, TestNoMisMatchAQ2) {
aq_mode_ = 2; aq_mode_ = 2;
::libvpx_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352, 288, ::libvpx_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352, 288,
30, 1, 0, 100); 30, 1, 0, 100);
ASSERT_NO_FATAL_FAILURE(RunLoop(&video)); ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
} }
@ -97,7 +97,7 @@ TEST_P(AqSegmentTest, TestNoMisMatchAQ3) {
aq_mode_ = 3; aq_mode_ = 3;
::libvpx_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352, 288, ::libvpx_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352, 288,
30, 1, 0, 100); 30, 1, 0, 100);
ASSERT_NO_FATAL_FAILURE(RunLoop(&video)); ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
} }

191
test/avg_test.cc
View File

@ -31,7 +31,7 @@ class AverageTestBase : public ::testing::Test {
AverageTestBase(int width, int height) : width_(width), height_(height) {} AverageTestBase(int width, int height) : width_(width), height_(height) {}
static void SetUpTestCase() { static void SetUpTestCase() {
source_data_ = reinterpret_cast<uint8_t*>( source_data_ = reinterpret_cast<uint8_t *>(
vpx_memalign(kDataAlignment, kDataBlockSize)); vpx_memalign(kDataAlignment, kDataBlockSize));
} }
@ -40,9 +40,7 @@ class AverageTestBase : public ::testing::Test {
source_data_ = NULL; source_data_ = NULL;
} }
virtual void TearDown() { virtual void TearDown() { libvpx_test::ClearSystemState(); }
libvpx_test::ClearSystemState();
}
protected: protected:
// Handle blocks up to 4 blocks 64x64 with stride up to 128 // Handle blocks up to 4 blocks 64x64 with stride up to 128
@ -55,47 +53,44 @@ class AverageTestBase : public ::testing::Test {
} }
// Sum Pixels // Sum Pixels
unsigned int ReferenceAverage8x8(const uint8_t* source, int pitch) { unsigned int ReferenceAverage8x8(const uint8_t *source, int pitch) {
unsigned int average = 0; unsigned int average = 0;
for (int h = 0; h < 8; ++h) for (int h = 0; h < 8; ++h)
for (int w = 0; w < 8; ++w) for (int w = 0; w < 8; ++w) average += source[h * pitch + w];
average += source[h * pitch + w];
return ((average + 32) >> 6); return ((average + 32) >> 6);
} }
unsigned int ReferenceAverage4x4(const uint8_t* source, int pitch) { unsigned int ReferenceAverage4x4(const uint8_t *source, int pitch) {
unsigned int average = 0; unsigned int average = 0;
for (int h = 0; h < 4; ++h) for (int h = 0; h < 4; ++h)
for (int w = 0; w < 4; ++w) for (int w = 0; w < 4; ++w) average += source[h * pitch + w];
average += source[h * pitch + w];
return ((average + 8) >> 4); return ((average + 8) >> 4);
} }
void FillConstant(uint8_t fill_constant) { void FillConstant(uint8_t fill_constant) {
for (int i = 0; i < width_ * height_; ++i) { for (int i = 0; i < width_ * height_; ++i) {
source_data_[i] = fill_constant; source_data_[i] = fill_constant;
} }
} }
void FillRandom() { void FillRandom() {
for (int i = 0; i < width_ * height_; ++i) { for (int i = 0; i < width_ * height_; ++i) {
source_data_[i] = rnd_.Rand8(); source_data_[i] = rnd_.Rand8();
} }
} }
int width_, height_; int width_, height_;
static uint8_t* source_data_; static uint8_t *source_data_;
int source_stride_; int source_stride_;
ACMRandom rnd_; ACMRandom rnd_;
}; };
typedef unsigned int (*AverageFunction)(const uint8_t* s, int pitch); typedef unsigned int (*AverageFunction)(const uint8_t *s, int pitch);
typedef std::tr1::tuple<int, int, int, int, AverageFunction> AvgFunc; typedef std::tr1::tuple<int, int, int, int, AverageFunction> AvgFunc;
class AverageTest class AverageTest : public AverageTestBase,
: public AverageTestBase, public ::testing::WithParamInterface<AvgFunc> {
public ::testing::WithParamInterface<AvgFunc>{
public: public:
AverageTest() : AverageTestBase(GET_PARAM(0), GET_PARAM(1)) {} AverageTest() : AverageTestBase(GET_PARAM(0), GET_PARAM(1)) {}
@ -103,17 +98,17 @@ class AverageTest
void CheckAverages() { void CheckAverages() {
unsigned int expected = 0; unsigned int expected = 0;
if (GET_PARAM(3) == 8) { if (GET_PARAM(3) == 8) {
expected = ReferenceAverage8x8(source_data_+ GET_PARAM(2), expected =
source_stride_); ReferenceAverage8x8(source_data_ + GET_PARAM(2), source_stride_);
} else if (GET_PARAM(3) == 4) { } else if (GET_PARAM(3) == 4) {
expected = ReferenceAverage4x4(source_data_+ GET_PARAM(2), expected =
source_stride_); ReferenceAverage4x4(source_data_ + GET_PARAM(2), source_stride_);
} }
ASM_REGISTER_STATE_CHECK(GET_PARAM(4)(source_data_+ GET_PARAM(2), ASM_REGISTER_STATE_CHECK(
source_stride_)); GET_PARAM(4)(source_data_ + GET_PARAM(2), source_stride_));
unsigned int actual = GET_PARAM(4)(source_data_+ GET_PARAM(2), unsigned int actual =
source_stride_); GET_PARAM(4)(source_data_ + GET_PARAM(2), source_stride_);
EXPECT_EQ(expected, actual); EXPECT_EQ(expected, actual);
} }
@ -124,23 +119,20 @@ typedef void (*IntProRowFunc)(int16_t hbuf[16], uint8_t const *ref,
typedef std::tr1::tuple<int, IntProRowFunc, IntProRowFunc> IntProRowParam; typedef std::tr1::tuple<int, IntProRowFunc, IntProRowFunc> IntProRowParam;
class IntProRowTest class IntProRowTest : public AverageTestBase,
: public AverageTestBase, public ::testing::WithParamInterface<IntProRowParam> {
public ::testing::WithParamInterface<IntProRowParam> {
public: public:
IntProRowTest() IntProRowTest()
: AverageTestBase(16, GET_PARAM(0)), : AverageTestBase(16, GET_PARAM(0)), hbuf_asm_(NULL), hbuf_c_(NULL) {
hbuf_asm_(NULL),
hbuf_c_(NULL) {
asm_func_ = GET_PARAM(1); asm_func_ = GET_PARAM(1);
c_func_ = GET_PARAM(2); c_func_ = GET_PARAM(2);
} }
protected: protected:
virtual void SetUp() { virtual void SetUp() {
hbuf_asm_ = reinterpret_cast<int16_t*>( hbuf_asm_ = reinterpret_cast<int16_t *>(
vpx_memalign(kDataAlignment, sizeof(*hbuf_asm_) * 16)); vpx_memalign(kDataAlignment, sizeof(*hbuf_asm_) * 16));
hbuf_c_ = reinterpret_cast<int16_t*>( hbuf_c_ = reinterpret_cast<int16_t *>(
vpx_memalign(kDataAlignment, sizeof(*hbuf_c_) * 16)); vpx_memalign(kDataAlignment, sizeof(*hbuf_c_) * 16));
} }
@ -169,9 +161,8 @@ typedef int16_t (*IntProColFunc)(uint8_t const *ref, const int width);
typedef std::tr1::tuple<int, IntProColFunc, IntProColFunc> IntProColParam; typedef std::tr1::tuple<int, IntProColFunc, IntProColFunc> IntProColParam;
class IntProColTest class IntProColTest : public AverageTestBase,
: public AverageTestBase, public ::testing::WithParamInterface<IntProColParam> {
public ::testing::WithParamInterface<IntProColParam> {
public: public:
IntProColTest() : AverageTestBase(GET_PARAM(0), 1), sum_asm_(0), sum_c_(0) { IntProColTest() : AverageTestBase(GET_PARAM(0), 1), sum_asm_(0), sum_c_(0) {
asm_func_ = GET_PARAM(1); asm_func_ = GET_PARAM(1);
@ -195,15 +186,14 @@ class IntProColTest
typedef int (*SatdFunc)(const int16_t *coeffs, int length); typedef int (*SatdFunc)(const int16_t *coeffs, int length);
typedef std::tr1::tuple<int, SatdFunc> SatdTestParam; typedef std::tr1::tuple<int, SatdFunc> SatdTestParam;
class SatdTest class SatdTest : public ::testing::Test,
: public ::testing::Test, public ::testing::WithParamInterface<SatdTestParam> {
public ::testing::WithParamInterface<SatdTestParam> {
protected: protected:
virtual void SetUp() { virtual void SetUp() {
satd_size_ = GET_PARAM(0); satd_size_ = GET_PARAM(0);
satd_func_ = GET_PARAM(1); satd_func_ = GET_PARAM(1);
rnd_.Reset(ACMRandom::DeterministicSeed()); rnd_.Reset(ACMRandom::DeterministicSeed());
src_ = reinterpret_cast<int16_t*>( src_ = reinterpret_cast<int16_t *>(
vpx_memalign(16, sizeof(*src_) * satd_size_)); vpx_memalign(16, sizeof(*src_) * satd_size_));
ASSERT_TRUE(src_ != NULL); ASSERT_TRUE(src_ != NULL);
} }
@ -235,7 +225,7 @@ class SatdTest
ACMRandom rnd_; ACMRandom rnd_;
}; };
uint8_t* AverageTestBase::source_data_ = NULL; uint8_t *AverageTestBase::source_data_ = NULL;
TEST_P(AverageTest, MinValue) { TEST_P(AverageTest, MinValue) {
FillConstant(0); FillConstant(0);
@ -286,7 +276,6 @@ TEST_P(IntProColTest, Random) {
RunComparison(); RunComparison();
} }
TEST_P(SatdTest, MinValue) { TEST_P(SatdTest, MinValue) {
const int kMin = -32640; const int kMin = -32640;
const int expected = -kMin * satd_size_; const int expected = -kMin * satd_size_;
@ -320,92 +309,86 @@ using std::tr1::make_tuple;
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
C, AverageTest, C, AverageTest,
::testing::Values( ::testing::Values(make_tuple(16, 16, 1, 8, &vpx_avg_8x8_c),
make_tuple(16, 16, 1, 8, &vpx_avg_8x8_c), make_tuple(16, 16, 1, 4, &vpx_avg_4x4_c)));
make_tuple(16, 16, 1, 4, &vpx_avg_4x4_c)));
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(C, SatdTest,
C, SatdTest, ::testing::Values(make_tuple(16, &vpx_satd_c),
::testing::Values( make_tuple(64, &vpx_satd_c),
make_tuple(16, &vpx_satd_c), make_tuple(256, &vpx_satd_c),
make_tuple(64, &vpx_satd_c), make_tuple(1024, &vpx_satd_c)));
make_tuple(256, &vpx_satd_c),
make_tuple(1024, &vpx_satd_c)));
#if HAVE_SSE2 #if HAVE_SSE2
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
SSE2, AverageTest, SSE2, AverageTest,
::testing::Values( ::testing::Values(make_tuple(16, 16, 0, 8, &vpx_avg_8x8_sse2),
make_tuple(16, 16, 0, 8, &vpx_avg_8x8_sse2), make_tuple(16, 16, 5, 8, &vpx_avg_8x8_sse2),
make_tuple(16, 16, 5, 8, &vpx_avg_8x8_sse2), make_tuple(32, 32, 15, 8, &vpx_avg_8x8_sse2),
make_tuple(32, 32, 15, 8, &vpx_avg_8x8_sse2), make_tuple(16, 16, 0, 4, &vpx_avg_4x4_sse2),
make_tuple(16, 16, 0, 4, &vpx_avg_4x4_sse2), make_tuple(16, 16, 5, 4, &vpx_avg_4x4_sse2),
make_tuple(16, 16, 5, 4, &vpx_avg_4x4_sse2), make_tuple(32, 32, 15, 4, &vpx_avg_4x4_sse2)));
make_tuple(32, 32, 15, 4, &vpx_avg_4x4_sse2)));
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
SSE2, IntProRowTest, ::testing::Values( SSE2, IntProRowTest,
make_tuple(16, &vpx_int_pro_row_sse2, &vpx_int_pro_row_c), ::testing::Values(make_tuple(16, &vpx_int_pro_row_sse2, &vpx_int_pro_row_c),
make_tuple(32, &vpx_int_pro_row_sse2, &vpx_int_pro_row_c), make_tuple(32, &vpx_int_pro_row_sse2, &vpx_int_pro_row_c),
make_tuple(64, &vpx_int_pro_row_sse2, &vpx_int_pro_row_c))); make_tuple(64, &vpx_int_pro_row_sse2,
&vpx_int_pro_row_c)));
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
SSE2, IntProColTest, ::testing::Values( SSE2, IntProColTest,
make_tuple(16, &vpx_int_pro_col_sse2, &vpx_int_pro_col_c), ::testing::Values(make_tuple(16, &vpx_int_pro_col_sse2, &vpx_int_pro_col_c),
make_tuple(32, &vpx_int_pro_col_sse2, &vpx_int_pro_col_c), make_tuple(32, &vpx_int_pro_col_sse2, &vpx_int_pro_col_c),
make_tuple(64, &vpx_int_pro_col_sse2, &vpx_int_pro_col_c))); make_tuple(64, &vpx_int_pro_col_sse2,
&vpx_int_pro_col_c)));
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(SSE2, SatdTest,
SSE2, SatdTest, ::testing::Values(make_tuple(16, &vpx_satd_sse2),
::testing::Values( make_tuple(64, &vpx_satd_sse2),
make_tuple(16, &vpx_satd_sse2), make_tuple(256, &vpx_satd_sse2),
make_tuple(64, &vpx_satd_sse2), make_tuple(1024, &vpx_satd_sse2)));
make_tuple(256, &vpx_satd_sse2),
make_tuple(1024, &vpx_satd_sse2)));
#endif #endif
#if HAVE_NEON #if HAVE_NEON
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
NEON, AverageTest, NEON, AverageTest,
::testing::Values( ::testing::Values(make_tuple(16, 16, 0, 8, &vpx_avg_8x8_neon),
make_tuple(16, 16, 0, 8, &vpx_avg_8x8_neon), make_tuple(16, 16, 5, 8, &vpx_avg_8x8_neon),
make_tuple(16, 16, 5, 8, &vpx_avg_8x8_neon), make_tuple(32, 32, 15, 8, &vpx_avg_8x8_neon),
make_tuple(32, 32, 15, 8, &vpx_avg_8x8_neon), make_tuple(16, 16, 0, 4, &vpx_avg_4x4_neon),
make_tuple(16, 16, 0, 4, &vpx_avg_4x4_neon), make_tuple(16, 16, 5, 4, &vpx_avg_4x4_neon),
make_tuple(16, 16, 5, 4, &vpx_avg_4x4_neon), make_tuple(32, 32, 15, 4, &vpx_avg_4x4_neon)));
make_tuple(32, 32, 15, 4, &vpx_avg_4x4_neon)));
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
NEON, IntProRowTest, ::testing::Values( NEON, IntProRowTest,
make_tuple(16, &vpx_int_pro_row_neon, &vpx_int_pro_row_c), ::testing::Values(make_tuple(16, &vpx_int_pro_row_neon, &vpx_int_pro_row_c),
make_tuple(32, &vpx_int_pro_row_neon, &vpx_int_pro_row_c), make_tuple(32, &vpx_int_pro_row_neon, &vpx_int_pro_row_c),
make_tuple(64, &vpx_int_pro_row_neon, &vpx_int_pro_row_c))); make_tuple(64, &vpx_int_pro_row_neon,
&vpx_int_pro_row_c)));
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
NEON, IntProColTest, ::testing::Values( NEON, IntProColTest,
make_tuple(16, &vpx_int_pro_col_neon, &vpx_int_pro_col_c), ::testing::Values(make_tuple(16, &vpx_int_pro_col_neon, &vpx_int_pro_col_c),
make_tuple(32, &vpx_int_pro_col_neon, &vpx_int_pro_col_c), make_tuple(32, &vpx_int_pro_col_neon, &vpx_int_pro_col_c),
make_tuple(64, &vpx_int_pro_col_neon, &vpx_int_pro_col_c))); make_tuple(64, &vpx_int_pro_col_neon,
&vpx_int_pro_col_c)));
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(NEON, SatdTest,
NEON, SatdTest, ::testing::Values(make_tuple(16, &vpx_satd_neon),
::testing::Values( make_tuple(64, &vpx_satd_neon),
make_tuple(16, &vpx_satd_neon), make_tuple(256, &vpx_satd_neon),
make_tuple(64, &vpx_satd_neon), make_tuple(1024, &vpx_satd_neon)));
make_tuple(256, &vpx_satd_neon),
make_tuple(1024, &vpx_satd_neon)));
#endif #endif
#if HAVE_MSA #if HAVE_MSA
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
MSA, AverageTest, MSA, AverageTest,
::testing::Values( ::testing::Values(make_tuple(16, 16, 0, 8, &vpx_avg_8x8_msa),
make_tuple(16, 16, 0, 8, &vpx_avg_8x8_msa), make_tuple(16, 16, 5, 8, &vpx_avg_8x8_msa),
make_tuple(16, 16, 5, 8, &vpx_avg_8x8_msa), make_tuple(32, 32, 15, 8, &vpx_avg_8x8_msa),
make_tuple(32, 32, 15, 8, &vpx_avg_8x8_msa), make_tuple(16, 16, 0, 4, &vpx_avg_4x4_msa),
make_tuple(16, 16, 0, 4, &vpx_avg_4x4_msa), make_tuple(16, 16, 5, 4, &vpx_avg_4x4_msa),
make_tuple(16, 16, 5, 4, &vpx_avg_4x4_msa), make_tuple(32, 32, 15, 4, &vpx_avg_4x4_msa)));
make_tuple(32, 32, 15, 4, &vpx_avg_4x4_msa)));
#endif #endif
} // namespace } // namespace

42
test/blockiness_test.cc
View File

@ -26,11 +26,9 @@
#include "vpx_mem/vpx_mem.h" #include "vpx_mem/vpx_mem.h"
extern "C" double vp9_get_blockiness(const unsigned char *img1, int img1_pitch,
extern "C" const unsigned char *img2, int img2_pitch,
double vp9_get_blockiness(const unsigned char *img1, int img1_pitch, int width, int height);
const unsigned char *img2, int img2_pitch,
int width, int height);
using libvpx_test::ACMRandom; using libvpx_test::ACMRandom;
@ -40,9 +38,9 @@ class BlockinessTestBase : public ::testing::Test {
BlockinessTestBase(int width, int height) : width_(width), height_(height) {} BlockinessTestBase(int width, int height) : width_(width), height_(height) {}
static void SetUpTestCase() { static void SetUpTestCase() {
source_data_ = reinterpret_cast<uint8_t*>( source_data_ = reinterpret_cast<uint8_t *>(
vpx_memalign(kDataAlignment, kDataBufferSize)); vpx_memalign(kDataAlignment, kDataBufferSize));
reference_data_ = reinterpret_cast<uint8_t*>( reference_data_ = reinterpret_cast<uint8_t *>(
vpx_memalign(kDataAlignment, kDataBufferSize)); vpx_memalign(kDataAlignment, kDataBufferSize));
} }
@ -53,14 +51,12 @@ class BlockinessTestBase : public ::testing::Test {
reference_data_ = NULL; reference_data_ = NULL;
} }
virtual void TearDown() { virtual void TearDown() { libvpx_test::ClearSystemState(); }
libvpx_test::ClearSystemState();
}
protected: protected:
// Handle frames up to 640x480 // Handle frames up to 640x480
static const int kDataAlignment = 16; static const int kDataAlignment = 16;
static const int kDataBufferSize = 640*480; static const int kDataBufferSize = 640 * 480;
virtual void SetUp() { virtual void SetUp() {
source_stride_ = (width_ + 31) & ~31; source_stride_ = (width_ + 31) & ~31;
@ -68,8 +64,8 @@ class BlockinessTestBase : public ::testing::Test {
rnd_.Reset(ACMRandom::DeterministicSeed()); rnd_.Reset(ACMRandom::DeterministicSeed());
} }
void FillConstant(uint8_t *data, int stride, uint8_t fill_constant, void FillConstant(uint8_t *data, int stride, uint8_t fill_constant, int width,
int width, int height) { int height) {
for (int h = 0; h < height; ++h) { for (int h = 0; h < height; ++h) {
for (int w = 0; w < width; ++w) { for (int w = 0; w < width; ++w) {
data[h * stride + w] = fill_constant; data[h * stride + w] = fill_constant;
@ -104,7 +100,7 @@ class BlockinessTestBase : public ::testing::Test {
void FillCheckerboard(uint8_t *data, int stride) { void FillCheckerboard(uint8_t *data, int stride) {
for (int h = 0; h < height_; h += 4) { for (int h = 0; h < height_; h += 4) {
for (int w = 0; w < width_; w += 4) { for (int w = 0; w < width_; w += 4) {
if (((h/4) ^ (w/4)) & 1) if (((h / 4) ^ (w / 4)) & 1)
FillConstant(data + h * stride + w, stride, 255, 4, 4); FillConstant(data + h * stride + w, stride, 255, 4, 4);
else else
FillConstant(data + h * stride + w, stride, 0, 4, 4); FillConstant(data + h * stride + w, stride, 0, 4, 4);
@ -135,9 +131,9 @@ class BlockinessTestBase : public ::testing::Test {
} }
} }
int width_, height_; int width_, height_;
static uint8_t* source_data_; static uint8_t *source_data_;
int source_stride_; int source_stride_;
static uint8_t* reference_data_; static uint8_t *reference_data_;
int reference_stride_; int reference_stride_;
ACMRandom rnd_; ACMRandom rnd_;
@ -153,15 +149,14 @@ class BlockinessVP9Test
protected: protected:
double GetBlockiness() const { double GetBlockiness() const {
return vp9_get_blockiness(source_data_, source_stride_, return vp9_get_blockiness(source_data_, source_stride_, reference_data_,
reference_data_, reference_stride_, reference_stride_, width_, height_);
width_, height_);
} }
}; };
#endif // CONFIG_VP9_ENCODER #endif // CONFIG_VP9_ENCODER
uint8_t* BlockinessTestBase::source_data_ = NULL; uint8_t *BlockinessTestBase::source_data_ = NULL;
uint8_t* BlockinessTestBase::reference_data_ = NULL; uint8_t *BlockinessTestBase::reference_data_ = NULL;
#if CONFIG_VP9_ENCODER #if CONFIG_VP9_ENCODER
TEST_P(BlockinessVP9Test, SourceBlockierThanReference) { TEST_P(BlockinessVP9Test, SourceBlockierThanReference) {
@ -212,7 +207,6 @@ TEST_P(BlockinessVP9Test, WorstCaseBlockiness) {
} }
#endif // CONFIG_VP9_ENCODER #endif // CONFIG_VP9_ENCODER
using std::tr1::make_tuple; using std::tr1::make_tuple;
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
@ -220,9 +214,7 @@ using std::tr1::make_tuple;
#if CONFIG_VP9_ENCODER #if CONFIG_VP9_ENCODER
const BlockinessParam c_vp9_tests[] = { const BlockinessParam c_vp9_tests[] = {
make_tuple(320, 240), make_tuple(320, 240), make_tuple(318, 242), make_tuple(318, 238),
make_tuple(318, 242),
make_tuple(318, 238),
}; };
INSTANTIATE_TEST_CASE_P(C, BlockinessVP9Test, ::testing::ValuesIn(c_vp9_tests)); INSTANTIATE_TEST_CASE_P(C, BlockinessVP9Test, ::testing::ValuesIn(c_vp9_tests));
#endif #endif

9
test/borders_test.cc
View File

@ -17,8 +17,9 @@
namespace { namespace {
class BordersTest : public ::libvpx_test::EncoderTest, class BordersTest
public ::libvpx_test::CodecTestWithParam<libvpx_test::TestMode> { : public ::libvpx_test::EncoderTest,
public ::libvpx_test::CodecTestWithParam<libvpx_test::TestMode> {
protected: protected:
BordersTest() : EncoderTest(GET_PARAM(0)) {} BordersTest() : EncoderTest(GET_PARAM(0)) {}
virtual ~BordersTest() {} virtual ~BordersTest() {}
@ -78,6 +79,6 @@ TEST_P(BordersTest, TestLowBitrate) {
ASSERT_NO_FATAL_FAILURE(RunLoop(&video)); ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
} }
VP9_INSTANTIATE_TEST_CASE(BordersTest, ::testing::Values( VP9_INSTANTIATE_TEST_CASE(BordersTest,
::libvpx_test::kTwoPassGood)); ::testing::Values(::libvpx_test::kTwoPassGood));
} // namespace } // namespace

46
test/byte_alignment_test.cc
View File

@ -36,29 +36,26 @@ struct ByteAlignmentTestParam {
}; };
const ByteAlignmentTestParam kBaTestParams[] = { const ByteAlignmentTestParam kBaTestParams[] = {
{kLegacyByteAlignment, VPX_CODEC_OK, true}, { kLegacyByteAlignment, VPX_CODEC_OK, true },
{32, VPX_CODEC_OK, true}, { 32, VPX_CODEC_OK, true },
{64, VPX_CODEC_OK, true}, { 64, VPX_CODEC_OK, true },
{128, VPX_CODEC_OK, true}, { 128, VPX_CODEC_OK, true },
{256, VPX_CODEC_OK, true}, { 256, VPX_CODEC_OK, true },
{512, VPX_CODEC_OK, true}, { 512, VPX_CODEC_OK, true },
{1024, VPX_CODEC_OK, true}, { 1024, VPX_CODEC_OK, true },
{1, VPX_CODEC_INVALID_PARAM, false}, { 1, VPX_CODEC_INVALID_PARAM, false },
{-2, VPX_CODEC_INVALID_PARAM, false}, { -2, VPX_CODEC_INVALID_PARAM, false },
{4, VPX_CODEC_INVALID_PARAM, false}, { 4, VPX_CODEC_INVALID_PARAM, false },
{16, VPX_CODEC_INVALID_PARAM, false}, { 16, VPX_CODEC_INVALID_PARAM, false },
{255, VPX_CODEC_INVALID_PARAM, false}, { 255, VPX_CODEC_INVALID_PARAM, false },
{2048, VPX_CODEC_INVALID_PARAM, false}, { 2048, VPX_CODEC_INVALID_PARAM, false },
}; };
// Class for testing byte alignment of reference buffers. // Class for testing byte alignment of reference buffers.
class ByteAlignmentTest class ByteAlignmentTest
: public ::testing::TestWithParam<ByteAlignmentTestParam> { : public ::testing::TestWithParam<ByteAlignmentTestParam> {
protected: protected:
ByteAlignmentTest() ByteAlignmentTest() : video_(NULL), decoder_(NULL), md5_file_(NULL) {}
: video_(NULL),
decoder_(NULL),
md5_file_(NULL) {}
virtual void SetUp() { virtual void SetUp() {
video_ = new libvpx_test::WebMVideoSource(kVP9TestFile); video_ = new libvpx_test::WebMVideoSource(kVP9TestFile);
@ -74,8 +71,7 @@ class ByteAlignmentTest
} }
virtual void TearDown() { virtual void TearDown() {
if (md5_file_ != NULL) if (md5_file_ != NULL) fclose(md5_file_);
fclose(md5_file_);
delete decoder_; delete decoder_;
delete video_; delete video_;
@ -89,8 +85,7 @@ class ByteAlignmentTest
const vpx_codec_err_t res = const vpx_codec_err_t res =
decoder_->DecodeFrame(video_->cxdata(), video_->frame_size()); decoder_->DecodeFrame(video_->cxdata(), video_->frame_size());
CheckDecodedFrames(byte_alignment_to_check); CheckDecodedFrames(byte_alignment_to_check);
if (res == VPX_CODEC_OK) if (res == VPX_CODEC_OK) video_->Next();
video_->Next();
return res; return res;
} }
@ -98,8 +93,7 @@ class ByteAlignmentTest
for (; video_->cxdata() != NULL; video_->Next()) { for (; video_->cxdata() != NULL; video_->Next()) {
const vpx_codec_err_t res = const vpx_codec_err_t res =
decoder_->DecodeFrame(video_->cxdata(), video_->frame_size()); decoder_->DecodeFrame(video_->cxdata(), video_->frame_size());
if (res != VPX_CODEC_OK) if (res != VPX_CODEC_OK) return res;
return res;
CheckDecodedFrames(byte_alignment_to_check); CheckDecodedFrames(byte_alignment_to_check);
} }
return VPX_CODEC_OK; return VPX_CODEC_OK;
@ -135,7 +129,7 @@ class ByteAlignmentTest
void OpenMd5File(const std::string &md5_file_name_) { void OpenMd5File(const std::string &md5_file_name_) {
md5_file_ = libvpx_test::OpenTestDataFile(md5_file_name_); md5_file_ = libvpx_test::OpenTestDataFile(md5_file_name_);
ASSERT_TRUE(md5_file_ != NULL) << "MD5 file open failed. Filename: " ASSERT_TRUE(md5_file_ != NULL) << "MD5 file open failed. Filename: "
<< md5_file_name_; << md5_file_name_;
} }
void CheckMd5(const vpx_image_t &img) { void CheckMd5(const vpx_image_t &img) {
@ -163,8 +157,8 @@ class ByteAlignmentTest
TEST_F(ByteAlignmentTest, SwitchByteAlignment) { TEST_F(ByteAlignmentTest, SwitchByteAlignment) {
const int num_elements = 14; const int num_elements = 14;
const int byte_alignments[] = { 0, 32, 64, 128, 256, 512, 1024, const int byte_alignments[] = { 0, 32, 64, 128, 256, 512, 1024,
0, 1024, 32, 512, 64, 256, 128 }; 0, 1024, 32, 512, 64, 256, 128 };
for (int i = 0; i < num_elements; ++i) { for (int i = 0; i < num_elements; ++i) {
SetByteAlignment(byte_alignments[i], VPX_CODEC_OK); SetByteAlignment(byte_alignments[i], VPX_CODEC_OK);

2
test/clear_system_state.h
View File

@ -12,7 +12,7 @@
#include "./vpx_config.h" #include "./vpx_config.h"
#if ARCH_X86 || ARCH_X86_64 #if ARCH_X86 || ARCH_X86_64
# include "vpx_ports/x86.h" #include "vpx_ports/x86.h"
#endif #endif
namespace libvpx_test { namespace libvpx_test {

75
test/codec_factory.h
View File

@ -32,15 +32,15 @@ class CodecFactory {
virtual ~CodecFactory() {} virtual ~CodecFactory() {}
virtual Decoder* CreateDecoder(vpx_codec_dec_cfg_t cfg, virtual Decoder *CreateDecoder(vpx_codec_dec_cfg_t cfg,
unsigned long deadline) const = 0; unsigned long deadline) const = 0;
virtual Decoder* CreateDecoder(vpx_codec_dec_cfg_t cfg, virtual Decoder *CreateDecoder(vpx_codec_dec_cfg_t cfg,
const vpx_codec_flags_t flags, const vpx_codec_flags_t flags,
unsigned long deadline) // NOLINT(runtime/int) unsigned long deadline) // NOLINT(runtime/int)
const = 0; const = 0;
virtual Encoder* CreateEncoder(vpx_codec_enc_cfg_t cfg, virtual Encoder *CreateEncoder(vpx_codec_enc_cfg_t cfg,
unsigned long deadline, unsigned long deadline,
const unsigned long init_flags, const unsigned long init_flags,
TwopassStatsStore *stats) const = 0; TwopassStatsStore *stats) const = 0;
@ -53,20 +53,20 @@ class CodecFactory {
* to avoid having to include a pointer to the CodecFactory in every test * to avoid having to include a pointer to the CodecFactory in every test
* definition. * definition.
*/ */
template<class T1> template <class T1>
class CodecTestWithParam : public ::testing::TestWithParam< class CodecTestWithParam
std::tr1::tuple< const libvpx_test::CodecFactory*, T1 > > { : public ::testing::TestWithParam<
}; std::tr1::tuple<const libvpx_test::CodecFactory *, T1> > {};
template<class T1, class T2> template <class T1, class T2>
class CodecTestWith2Params : public ::testing::TestWithParam< class CodecTestWith2Params
std::tr1::tuple< const libvpx_test::CodecFactory*, T1, T2 > > { : public ::testing::TestWithParam<
}; std::tr1::tuple<const libvpx_test::CodecFactory *, T1, T2> > {};
template<class T1, class T2, class T3> template <class T1, class T2, class T3>
class CodecTestWith3Params : public ::testing::TestWithParam< class CodecTestWith3Params
std::tr1::tuple< const libvpx_test::CodecFactory*, T1, T2, T3 > > { : public ::testing::TestWithParam<
}; std::tr1::tuple<const libvpx_test::CodecFactory *, T1, T2, T3> > {};
/* /*
* VP8 Codec Definitions * VP8 Codec Definitions
@ -82,7 +82,7 @@ class VP8Decoder : public Decoder {
: Decoder(cfg, flag, deadline) {} : Decoder(cfg, flag, deadline) {}
protected: protected:
virtual vpx_codec_iface_t* CodecInterface() const { virtual vpx_codec_iface_t *CodecInterface() const {
#if CONFIG_VP8_DECODER #if CONFIG_VP8_DECODER
return &vpx_codec_vp8_dx_algo; return &vpx_codec_vp8_dx_algo;
#else #else
@ -98,7 +98,7 @@ class VP8Encoder : public Encoder {
: Encoder(cfg, deadline, init_flags, stats) {} : Encoder(cfg, deadline, init_flags, stats) {}
protected: protected:
virtual vpx_codec_iface_t* CodecInterface() const { virtual vpx_codec_iface_t *CodecInterface() const {
#if CONFIG_VP8_ENCODER #if CONFIG_VP8_ENCODER
return &vpx_codec_vp8_cx_algo; return &vpx_codec_vp8_cx_algo;
#else #else
@ -111,12 +111,12 @@ class VP8CodecFactory : public CodecFactory {
public: public:
VP8CodecFactory() : CodecFactory() {} VP8CodecFactory() : CodecFactory() {}
virtual Decoder* CreateDecoder(vpx_codec_dec_cfg_t cfg, virtual Decoder *CreateDecoder(vpx_codec_dec_cfg_t cfg,
unsigned long deadline) const { unsigned long deadline) const {
return CreateDecoder(cfg, 0, deadline); return CreateDecoder(cfg, 0, deadline);
} }
virtual Decoder* CreateDecoder(vpx_codec_dec_cfg_t cfg, virtual Decoder *CreateDecoder(vpx_codec_dec_cfg_t cfg,
const vpx_codec_flags_t flags, const vpx_codec_flags_t flags,
unsigned long deadline) const { // NOLINT unsigned long deadline) const { // NOLINT
#if CONFIG_VP8_DECODER #if CONFIG_VP8_DECODER
@ -126,7 +126,7 @@ class VP8CodecFactory : public CodecFactory {
#endif #endif
} }
virtual Encoder* CreateEncoder(vpx_codec_enc_cfg_t cfg, virtual Encoder *CreateEncoder(vpx_codec_enc_cfg_t cfg,
unsigned long deadline, unsigned long deadline,
const unsigned long init_flags, const unsigned long init_flags,
TwopassStatsStore *stats) const { TwopassStatsStore *stats) const {
@ -149,17 +149,17 @@ class VP8CodecFactory : public CodecFactory {
const libvpx_test::VP8CodecFactory kVP8; const libvpx_test::VP8CodecFactory kVP8;
#define VP8_INSTANTIATE_TEST_CASE(test, ...)\ #define VP8_INSTANTIATE_TEST_CASE(test, ...) \
INSTANTIATE_TEST_CASE_P(VP8, test, \ INSTANTIATE_TEST_CASE_P( \
::testing::Combine( \ VP8, test, \
::testing::Values(static_cast<const libvpx_test::CodecFactory*>( \ ::testing::Combine( \
&libvpx_test::kVP8)), \ ::testing::Values(static_cast<const libvpx_test::CodecFactory *>( \
&libvpx_test::kVP8)), \
__VA_ARGS__)) __VA_ARGS__))
#else #else
#define VP8_INSTANTIATE_TEST_CASE(test, ...) #define VP8_INSTANTIATE_TEST_CASE(test, ...)
#endif // CONFIG_VP8 #endif // CONFIG_VP8
/* /*
* VP9 Codec Definitions * VP9 Codec Definitions
*/ */
@ -174,7 +174,7 @@ class VP9Decoder : public Decoder {
: Decoder(cfg, flag, deadline) {} : Decoder(cfg, flag, deadline) {}
protected: protected:
virtual vpx_codec_iface_t* CodecInterface() const { virtual vpx_codec_iface_t *CodecInterface() const {
#if CONFIG_VP9_DECODER #if CONFIG_VP9_DECODER
return &vpx_codec_vp9_dx_algo; return &vpx_codec_vp9_dx_algo;
#else #else
@ -190,7 +190,7 @@ class VP9Encoder : public Encoder {
: Encoder(cfg, deadline, init_flags, stats) {} : Encoder(cfg, deadline, init_flags, stats) {}
protected: protected:
virtual vpx_codec_iface_t* CodecInterface() const { virtual vpx_codec_iface_t *CodecInterface() const {
#if CONFIG_VP9_ENCODER #if CONFIG_VP9_ENCODER
return &vpx_codec_vp9_cx_algo; return &vpx_codec_vp9_cx_algo;
#else #else
@ -203,12 +203,12 @@ class VP9CodecFactory : public CodecFactory {
public: public:
VP9CodecFactory() : CodecFactory() {} VP9CodecFactory() : CodecFactory() {}
virtual Decoder* CreateDecoder(vpx_codec_dec_cfg_t cfg, virtual Decoder *CreateDecoder(vpx_codec_dec_cfg_t cfg,
unsigned long deadline) const { unsigned long deadline) const {
return CreateDecoder(cfg, 0, deadline); return CreateDecoder(cfg, 0, deadline);
} }
virtual Decoder* CreateDecoder(vpx_codec_dec_cfg_t cfg, virtual Decoder *CreateDecoder(vpx_codec_dec_cfg_t cfg,
const vpx_codec_flags_t flags, const vpx_codec_flags_t flags,
unsigned long deadline) const { // NOLINT unsigned long deadline) const { // NOLINT
#if CONFIG_VP9_DECODER #if CONFIG_VP9_DECODER
@ -218,7 +218,7 @@ class VP9CodecFactory : public CodecFactory {
#endif #endif
} }
virtual Encoder* CreateEncoder(vpx_codec_enc_cfg_t cfg, virtual Encoder *CreateEncoder(vpx_codec_enc_cfg_t cfg,
unsigned long deadline, unsigned long deadline,
const unsigned long init_flags, const unsigned long init_flags,
TwopassStatsStore *stats) const { TwopassStatsStore *stats) const {
@ -241,11 +241,12 @@ class VP9CodecFactory : public CodecFactory {
const libvpx_test::VP9CodecFactory kVP9; const libvpx_test::VP9CodecFactory kVP9;
#define VP9_INSTANTIATE_TEST_CASE(test, ...)\ #define VP9_INSTANTIATE_TEST_CASE(test, ...) \
INSTANTIATE_TEST_CASE_P(VP9, test, \ INSTANTIATE_TEST_CASE_P( \
::testing::Combine( \ VP9, test, \
::testing::Values(static_cast<const libvpx_test::CodecFactory*>( \ ::testing::Combine( \
&libvpx_test::kVP9)), \ ::testing::Values(static_cast<const libvpx_test::CodecFactory *>( \
&libvpx_test::kVP9)), \
__VA_ARGS__)) __VA_ARGS__))
#else #else
#define VP9_INSTANTIATE_TEST_CASE(test, ...) #define VP9_INSTANTIATE_TEST_CASE(test, ...)

14
test/config_test.cc
View File

@ -15,11 +15,13 @@
namespace { namespace {
class ConfigTest : public ::libvpx_test::EncoderTest, class ConfigTest
public ::libvpx_test::CodecTestWithParam<libvpx_test::TestMode> { : public ::libvpx_test::EncoderTest,
public ::libvpx_test::CodecTestWithParam<libvpx_test::TestMode> {
protected: protected:
ConfigTest() : EncoderTest(GET_PARAM(0)), ConfigTest()
frame_count_in_(0), frame_count_out_(0), frame_count_max_(0) {} : EncoderTest(GET_PARAM(0)), frame_count_in_(0), frame_count_out_(0),
frame_count_max_(0) {}
virtual ~ConfigTest() {} virtual ~ConfigTest() {}
virtual void SetUp() { virtual void SetUp() {
@ -32,12 +34,12 @@ class ConfigTest : public ::libvpx_test::EncoderTest,
frame_count_out_ = 0; frame_count_out_ = 0;
} }
virtual void PreEncodeFrameHook(libvpx_test::VideoSource* /*video*/) { virtual void PreEncodeFrameHook(libvpx_test::VideoSource * /*video*/) {
++frame_count_in_; ++frame_count_in_;
abort_ |= (frame_count_in_ >= frame_count_max_); abort_ |= (frame_count_in_ >= frame_count_max_);
} }
virtual void FramePktHook(const vpx_codec_cx_pkt_t* /*pkt*/) { virtual void FramePktHook(const vpx_codec_cx_pkt_t * /*pkt*/) {
++frame_count_out_; ++frame_count_out_;
} }

52
test/consistency_test.cc
View File

@ -26,12 +26,10 @@
#include "vpx_dsp/ssim.h" #include "vpx_dsp/ssim.h"
#include "vpx_mem/vpx_mem.h" #include "vpx_mem/vpx_mem.h"
extern "C" extern "C" double vpx_get_ssim_metrics(uint8_t *img1, int img1_pitch,
double vpx_get_ssim_metrics(uint8_t *img1, int img1_pitch, uint8_t *img2, int img2_pitch, int width,
uint8_t *img2, int img2_pitch, int height, Ssimv *sv2, Metrics *m,
int width, int height, int do_inconsistency);
Ssimv *sv2, Metrics *m,
int do_inconsistency);
using libvpx_test::ACMRandom; using libvpx_test::ACMRandom;
@ -41,20 +39,18 @@ class ConsistencyTestBase : public ::testing::Test {
ConsistencyTestBase(int width, int height) : width_(width), height_(height) {} ConsistencyTestBase(int width, int height) : width_(width), height_(height) {}
static void SetUpTestCase() { static void SetUpTestCase() {
source_data_[0] = reinterpret_cast<uint8_t*>( source_data_[0] = reinterpret_cast<uint8_t *>(
vpx_memalign(kDataAlignment, kDataBufferSize)); vpx_memalign(kDataAlignment, kDataBufferSize));
reference_data_[0] = reinterpret_cast<uint8_t*>( reference_data_[0] = reinterpret_cast<uint8_t *>(
vpx_memalign(kDataAlignment, kDataBufferSize)); vpx_memalign(kDataAlignment, kDataBufferSize));
source_data_[1] = reinterpret_cast<uint8_t*>( source_data_[1] = reinterpret_cast<uint8_t *>(
vpx_memalign(kDataAlignment, kDataBufferSize)); vpx_memalign(kDataAlignment, kDataBufferSize));
reference_data_[1] = reinterpret_cast<uint8_t*>( reference_data_[1] = reinterpret_cast<uint8_t *>(
vpx_memalign(kDataAlignment, kDataBufferSize)); vpx_memalign(kDataAlignment, kDataBufferSize));
ssim_array_ = new Ssimv[kDataBufferSize / 16]; ssim_array_ = new Ssimv[kDataBufferSize / 16];
} }
static void ClearSsim() { static void ClearSsim() { memset(ssim_array_, 0, kDataBufferSize / 16); }
memset(ssim_array_, 0, kDataBufferSize / 16);
}
static void TearDownTestCase() { static void TearDownTestCase() {
vpx_free(source_data_[0]); vpx_free(source_data_[0]);
source_data_[0] = NULL; source_data_[0] = NULL;
@ -68,14 +64,12 @@ class ConsistencyTestBase : public ::testing::Test {
delete[] ssim_array_; delete[] ssim_array_;
} }
virtual void TearDown() { virtual void TearDown() { libvpx_test::ClearSystemState(); }
libvpx_test::ClearSystemState();
}
protected: protected:
// Handle frames up to 640x480 // Handle frames up to 640x480
static const int kDataAlignment = 16; static const int kDataAlignment = 16;
static const int kDataBufferSize = 640*480; static const int kDataBufferSize = 640 * 480;
virtual void SetUp() { virtual void SetUp() {
source_stride_ = (width_ + 31) & ~31; source_stride_ = (width_ + 31) & ~31;
@ -122,9 +116,9 @@ class ConsistencyTestBase : public ::testing::Test {
} }
} }
int width_, height_; int width_, height_;
static uint8_t* source_data_[2]; static uint8_t *source_data_[2];
int source_stride_; int source_stride_;
static uint8_t* reference_data_[2]; static uint8_t *reference_data_[2];
int reference_stride_; int reference_stride_;
static Ssimv *ssim_array_; static Ssimv *ssim_array_;
Metrics metrics_; Metrics metrics_;
@ -142,18 +136,17 @@ class ConsistencyVP9Test
protected: protected:
double CheckConsistency(int frame) { double CheckConsistency(int frame) {
EXPECT_LT(frame, 2)<< "Frame to check has to be less than 2."; EXPECT_LT(frame, 2) << "Frame to check has to be less than 2.";
return return vpx_get_ssim_metrics(source_data_[frame], source_stride_,
vpx_get_ssim_metrics(source_data_[frame], source_stride_, reference_data_[frame], reference_stride_,
reference_data_[frame], reference_stride_, width_, height_, ssim_array_, &metrics_, 1);
width_, height_, ssim_array_, &metrics_, 1);
} }
}; };
#endif // CONFIG_VP9_ENCODER #endif // CONFIG_VP9_ENCODER
uint8_t* ConsistencyTestBase::source_data_[2] = {NULL, NULL}; uint8_t *ConsistencyTestBase::source_data_[2] = { NULL, NULL };
uint8_t* ConsistencyTestBase::reference_data_[2] = {NULL, NULL}; uint8_t *ConsistencyTestBase::reference_data_[2] = { NULL, NULL };
Ssimv* ConsistencyTestBase::ssim_array_ = NULL; Ssimv *ConsistencyTestBase::ssim_array_ = NULL;
#if CONFIG_VP9_ENCODER #if CONFIG_VP9_ENCODER
TEST_P(ConsistencyVP9Test, ConsistencyIsZero) { TEST_P(ConsistencyVP9Test, ConsistencyIsZero) {
@ -205,7 +198,6 @@ TEST_P(ConsistencyVP9Test, ConsistencyIsZero) {
} }
#endif // CONFIG_VP9_ENCODER #endif // CONFIG_VP9_ENCODER
using std::tr1::make_tuple; using std::tr1::make_tuple;
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
@ -213,9 +205,7 @@ using std::tr1::make_tuple;
#if CONFIG_VP9_ENCODER #if CONFIG_VP9_ENCODER
const ConsistencyParam c_vp9_tests[] = { const ConsistencyParam c_vp9_tests[] = {
make_tuple(320, 240), make_tuple(320, 240), make_tuple(318, 242), make_tuple(318, 238),
make_tuple(318, 242),
make_tuple(318, 238),
}; };
INSTANTIATE_TEST_CASE_P(C, ConsistencyVP9Test, INSTANTIATE_TEST_CASE_P(C, ConsistencyVP9Test,
::testing::ValuesIn(c_vp9_tests)); ::testing::ValuesIn(c_vp9_tests));

640
test/convolve_test.cc
View File

@ -37,14 +37,12 @@ typedef void (*ConvolveFunc)(const uint8_t *src, ptrdiff_t src_stride,
int w, int h); int w, int h);
struct ConvolveFunctions { struct ConvolveFunctions {
ConvolveFunctions(ConvolveFunc copy, ConvolveFunc avg, ConvolveFunctions(ConvolveFunc copy, ConvolveFunc avg, ConvolveFunc h8,
ConvolveFunc h8, ConvolveFunc h8_avg, ConvolveFunc h8_avg, ConvolveFunc v8, ConvolveFunc v8_avg,
ConvolveFunc v8, ConvolveFunc v8_avg, ConvolveFunc hv8, ConvolveFunc hv8_avg, ConvolveFunc sh8,
ConvolveFunc hv8, ConvolveFunc hv8_avg, ConvolveFunc sh8_avg, ConvolveFunc sv8,
ConvolveFunc sh8, ConvolveFunc sh8_avg, ConvolveFunc sv8_avg, ConvolveFunc shv8,
ConvolveFunc sv8, ConvolveFunc sv8_avg, ConvolveFunc shv8_avg, int bd)
ConvolveFunc shv8, ConvolveFunc shv8_avg,
int bd)
: copy_(copy), avg_(avg), h8_(h8), v8_(v8), hv8_(hv8), h8_avg_(h8_avg), : copy_(copy), avg_(avg), h8_(h8), v8_(v8), hv8_(hv8), h8_avg_(h8_avg),
v8_avg_(v8_avg), hv8_avg_(hv8_avg), sh8_(sh8), sv8_(sv8), shv8_(shv8), v8_avg_(v8_avg), hv8_avg_(hv8_avg), sh8_(sh8), sv8_(sv8), shv8_(shv8),
sh8_avg_(sh8_avg), sv8_avg_(sv8_avg), shv8_avg_(shv8_avg), sh8_avg_(sh8_avg), sv8_avg_(sv8_avg), shv8_avg_(shv8_avg),
@ -58,49 +56,35 @@ struct ConvolveFunctions {
ConvolveFunc h8_avg_; ConvolveFunc h8_avg_;
ConvolveFunc v8_avg_; ConvolveFunc v8_avg_;
ConvolveFunc hv8_avg_; ConvolveFunc hv8_avg_;
ConvolveFunc sh8_; // scaled horiz ConvolveFunc sh8_; // scaled horiz
ConvolveFunc sv8_; // scaled vert ConvolveFunc sv8_; // scaled vert
ConvolveFunc shv8_; // scaled horiz/vert ConvolveFunc shv8_; // scaled horiz/vert
ConvolveFunc sh8_avg_; // scaled avg horiz ConvolveFunc sh8_avg_; // scaled avg horiz
ConvolveFunc sv8_avg_; // scaled avg vert ConvolveFunc sv8_avg_; // scaled avg vert
ConvolveFunc shv8_avg_; // scaled avg horiz/vert ConvolveFunc shv8_avg_; // scaled avg horiz/vert
int use_highbd_; // 0 if high bitdepth not used, else the actual bit depth. int use_highbd_; // 0 if high bitdepth not used, else the actual bit depth.
}; };
typedef std::tr1::tuple<int, int, const ConvolveFunctions *> ConvolveParam; typedef std::tr1::tuple<int, int, const ConvolveFunctions *> ConvolveParam;
#define ALL_SIZES(convolve_fn) \ #define ALL_SIZES(convolve_fn) \
make_tuple(4, 4, &convolve_fn), \ make_tuple(4, 4, &convolve_fn), make_tuple(8, 4, &convolve_fn), \
make_tuple(8, 4, &convolve_fn), \ make_tuple(4, 8, &convolve_fn), make_tuple(8, 8, &convolve_fn), \
make_tuple(4, 8, &convolve_fn), \ make_tuple(16, 8, &convolve_fn), make_tuple(8, 16, &convolve_fn), \
make_tuple(8, 8, &convolve_fn), \ make_tuple(16, 16, &convolve_fn), make_tuple(32, 16, &convolve_fn), \
make_tuple(16, 8, &convolve_fn), \ make_tuple(16, 32, &convolve_fn), make_tuple(32, 32, &convolve_fn), \
make_tuple(8, 16, &convolve_fn), \ make_tuple(64, 32, &convolve_fn), make_tuple(32, 64, &convolve_fn), \
make_tuple(16, 16, &convolve_fn), \ make_tuple(64, 64, &convolve_fn)
make_tuple(32, 16, &convolve_fn), \
make_tuple(16, 32, &convolve_fn), \
make_tuple(32, 32, &convolve_fn), \
make_tuple(64, 32, &convolve_fn), \
make_tuple(32, 64, &convolve_fn), \
make_tuple(64, 64, &convolve_fn)
// Reference 8-tap subpixel filter, slightly modified to fit into this test. // Reference 8-tap subpixel filter, slightly modified to fit into this test.
#define VP9_FILTER_WEIGHT 128 #define VP9_FILTER_WEIGHT 128
#define VP9_FILTER_SHIFT 7 #define VP9_FILTER_SHIFT 7
uint8_t clip_pixel(int x) { uint8_t clip_pixel(int x) { return x < 0 ? 0 : x > 255 ? 255 : x; }
return x < 0 ? 0 :
x > 255 ? 255 :
x;
}
void filter_block2d_8_c(const uint8_t *src_ptr, void filter_block2d_8_c(const uint8_t *src_ptr, const unsigned int src_stride,
const unsigned int src_stride, const int16_t *HFilter, const int16_t *VFilter,
const int16_t *HFilter, uint8_t *dst_ptr, unsigned int dst_stride,
const int16_t *VFilter, unsigned int output_width, unsigned int output_height) {
uint8_t *dst_ptr,
unsigned int dst_stride,
unsigned int output_width,
unsigned int output_height) {
// Between passes, we use an intermediate buffer whose height is extended to // Between passes, we use an intermediate buffer whose height is extended to
// have enough horizontally filtered values as input for the vertical pass. // have enough horizontally filtered values as input for the vertical pass.
// This buffer is allocated to be big enough for the largest block type we // This buffer is allocated to be big enough for the largest block type we
@ -128,15 +112,11 @@ void filter_block2d_8_c(const uint8_t *src_ptr,
for (i = 0; i < intermediate_height; ++i) { for (i = 0; i < intermediate_height; ++i) {
for (j = 0; j < output_width; ++j) { for (j = 0; j < output_width; ++j) {
// Apply filter... // Apply filter...
const int temp = (src_ptr[0] * HFilter[0]) + const int temp = (src_ptr[0] * HFilter[0]) + (src_ptr[1] * HFilter[1]) +
(src_ptr[1] * HFilter[1]) + (src_ptr[2] * HFilter[2]) + (src_ptr[3] * HFilter[3]) +
(src_ptr[2] * HFilter[2]) + (src_ptr[4] * HFilter[4]) + (src_ptr[5] * HFilter[5]) +
(src_ptr[3] * HFilter[3]) + (src_ptr[6] * HFilter[6]) + (src_ptr[7] * HFilter[7]) +
(src_ptr[4] * HFilter[4]) + (VP9_FILTER_WEIGHT >> 1); // Rounding
(src_ptr[5] * HFilter[5]) +
(src_ptr[6] * HFilter[6]) +
(src_ptr[7] * HFilter[7]) +
(VP9_FILTER_WEIGHT >> 1); // Rounding
// Normalize back to 0-255... // Normalize back to 0-255...
*output_ptr = clip_pixel(temp >> VP9_FILTER_SHIFT); *output_ptr = clip_pixel(temp >> VP9_FILTER_SHIFT);
@ -153,15 +133,11 @@ void filter_block2d_8_c(const uint8_t *src_ptr,
for (i = 0; i < output_height; ++i) { for (i = 0; i < output_height; ++i) {
for (j = 0; j < output_width; ++j) { for (j = 0; j < output_width; ++j) {
// Apply filter... // Apply filter...
const int temp = (src_ptr[0] * VFilter[0]) + const int temp = (src_ptr[0] * VFilter[0]) + (src_ptr[1] * VFilter[1]) +
(src_ptr[1] * VFilter[1]) + (src_ptr[2] * VFilter[2]) + (src_ptr[3] * VFilter[3]) +
(src_ptr[2] * VFilter[2]) + (src_ptr[4] * VFilter[4]) + (src_ptr[5] * VFilter[5]) +
(src_ptr[3] * VFilter[3]) + (src_ptr[6] * VFilter[6]) + (src_ptr[7] * VFilter[7]) +
(src_ptr[4] * VFilter[4]) + (VP9_FILTER_WEIGHT >> 1); // Rounding
(src_ptr[5] * VFilter[5]) +
(src_ptr[6] * VFilter[6]) +
(src_ptr[7] * VFilter[7]) +
(VP9_FILTER_WEIGHT >> 1); // Rounding
// Normalize back to 0-255... // Normalize back to 0-255...
*dst_ptr++ = clip_pixel(temp >> VP9_FILTER_SHIFT); *dst_ptr++ = clip_pixel(temp >> VP9_FILTER_SHIFT);
@ -172,12 +148,9 @@ void filter_block2d_8_c(const uint8_t *src_ptr,
} }
} }
void block2d_average_c(uint8_t *src, void block2d_average_c(uint8_t *src, unsigned int src_stride,
unsigned int src_stride, uint8_t *output_ptr, unsigned int output_stride,
uint8_t *output_ptr, unsigned int output_width, unsigned int output_height) {
unsigned int output_stride,
unsigned int output_width,
unsigned int output_height) {
unsigned int i, j; unsigned int i, j;
for (i = 0; i < output_height; ++i) { for (i = 0; i < output_height; ++i) {
for (j = 0; j < output_width; ++j) { for (j = 0; j < output_width; ++j) {
@ -189,10 +162,8 @@ void block2d_average_c(uint8_t *src,
void filter_average_block2d_8_c(const uint8_t *src_ptr, void filter_average_block2d_8_c(const uint8_t *src_ptr,
const unsigned int src_stride, const unsigned int src_stride,
const int16_t *HFilter, const int16_t *HFilter, const int16_t *VFilter,
const int16_t *VFilter, uint8_t *dst_ptr, unsigned int dst_stride,
uint8_t *dst_ptr,
unsigned int dst_stride,
unsigned int output_width, unsigned int output_width,
unsigned int output_height) { unsigned int output_height) {
uint8_t tmp[kMaxDimension * kMaxDimension]; uint8_t tmp[kMaxDimension * kMaxDimension];
@ -201,20 +172,16 @@ void filter_average_block2d_8_c(const uint8_t *src_ptr,
assert(output_height <= kMaxDimension); assert(output_height <= kMaxDimension);
filter_block2d_8_c(src_ptr, src_stride, HFilter, VFilter, tmp, 64, filter_block2d_8_c(src_ptr, src_stride, HFilter, VFilter, tmp, 64,
output_width, output_height); output_width, output_height);
block2d_average_c(tmp, 64, dst_ptr, dst_stride, block2d_average_c(tmp, 64, dst_ptr, dst_stride, output_width, output_height);
output_width, output_height);
} }
#if CONFIG_VP9_HIGHBITDEPTH #if CONFIG_VP9_HIGHBITDEPTH
void highbd_filter_block2d_8_c(const uint16_t *src_ptr, void highbd_filter_block2d_8_c(const uint16_t *src_ptr,
const unsigned int src_stride, const unsigned int src_stride,
const int16_t *HFilter, const int16_t *HFilter, const int16_t *VFilter,
const int16_t *VFilter, uint16_t *dst_ptr, unsigned int dst_stride,
uint16_t *dst_ptr,
unsigned int dst_stride,
unsigned int output_width, unsigned int output_width,
unsigned int output_height, unsigned int output_height, int bd) {
int bd) {
// Between passes, we use an intermediate buffer whose height is extended to // Between passes, we use an intermediate buffer whose height is extended to
// have enough horizontally filtered values as input for the vertical pass. // have enough horizontally filtered values as input for the vertical pass.
// This buffer is allocated to be big enough for the largest block type we // This buffer is allocated to be big enough for the largest block type we
@ -243,14 +210,10 @@ void highbd_filter_block2d_8_c(const uint16_t *src_ptr,
for (i = 0; i < intermediate_height; ++i) { for (i = 0; i < intermediate_height; ++i) {
for (j = 0; j < output_width; ++j) { for (j = 0; j < output_width; ++j) {
// Apply filter... // Apply filter...
const int temp = (src_ptr[0] * HFilter[0]) + const int temp = (src_ptr[0] * HFilter[0]) + (src_ptr[1] * HFilter[1]) +
(src_ptr[1] * HFilter[1]) + (src_ptr[2] * HFilter[2]) + (src_ptr[3] * HFilter[3]) +
(src_ptr[2] * HFilter[2]) + (src_ptr[4] * HFilter[4]) + (src_ptr[5] * HFilter[5]) +
(src_ptr[3] * HFilter[3]) + (src_ptr[6] * HFilter[6]) + (src_ptr[7] * HFilter[7]) +
(src_ptr[4] * HFilter[4]) +
(src_ptr[5] * HFilter[5]) +
(src_ptr[6] * HFilter[6]) +
(src_ptr[7] * HFilter[7]) +
(VP9_FILTER_WEIGHT >> 1); // Rounding (VP9_FILTER_WEIGHT >> 1); // Rounding
// Normalize back to 0-255... // Normalize back to 0-255...
@ -271,14 +234,10 @@ void highbd_filter_block2d_8_c(const uint16_t *src_ptr,
for (i = 0; i < output_height; ++i) { for (i = 0; i < output_height; ++i) {
for (j = 0; j < output_width; ++j) { for (j = 0; j < output_width; ++j) {
// Apply filter... // Apply filter...
const int temp = (src_ptr[0] * VFilter[0]) + const int temp = (src_ptr[0] * VFilter[0]) + (src_ptr[1] * VFilter[1]) +
(src_ptr[1] * VFilter[1]) + (src_ptr[2] * VFilter[2]) + (src_ptr[3] * VFilter[3]) +
(src_ptr[2] * VFilter[2]) + (src_ptr[4] * VFilter[4]) + (src_ptr[5] * VFilter[5]) +
(src_ptr[3] * VFilter[3]) + (src_ptr[6] * VFilter[6]) + (src_ptr[7] * VFilter[7]) +
(src_ptr[4] * VFilter[4]) +
(src_ptr[5] * VFilter[5]) +
(src_ptr[6] * VFilter[6]) +
(src_ptr[7] * VFilter[7]) +
(VP9_FILTER_WEIGHT >> 1); // Rounding (VP9_FILTER_WEIGHT >> 1); // Rounding
// Normalize back to 0-255... // Normalize back to 0-255...
@ -291,10 +250,8 @@ void highbd_filter_block2d_8_c(const uint16_t *src_ptr,
} }
} }
void highbd_block2d_average_c(uint16_t *src, void highbd_block2d_average_c(uint16_t *src, unsigned int src_stride,
unsigned int src_stride, uint16_t *output_ptr, unsigned int output_stride,
uint16_t *output_ptr,
unsigned int output_stride,
unsigned int output_width, unsigned int output_width,
unsigned int output_height) { unsigned int output_height) {
unsigned int i, j; unsigned int i, j;
@ -306,23 +263,19 @@ void highbd_block2d_average_c(uint16_t *src,
} }
} }
void highbd_filter_average_block2d_8_c(const uint16_t *src_ptr, void highbd_filter_average_block2d_8_c(
const unsigned int src_stride, const uint16_t *src_ptr, const unsigned int src_stride,
const int16_t *HFilter, const int16_t *HFilter, const int16_t *VFilter, uint16_t *dst_ptr,
const int16_t *VFilter, unsigned int dst_stride, unsigned int output_width,
uint16_t *dst_ptr, unsigned int output_height, int bd) {
unsigned int dst_stride,
unsigned int output_width,
unsigned int output_height,
int bd) {
uint16_t tmp[kMaxDimension * kMaxDimension]; uint16_t tmp[kMaxDimension * kMaxDimension];
assert(output_width <= kMaxDimension); assert(output_width <= kMaxDimension);
assert(output_height <= kMaxDimension); assert(output_height <= kMaxDimension);
highbd_filter_block2d_8_c(src_ptr, src_stride, HFilter, VFilter, tmp, 64, highbd_filter_block2d_8_c(src_ptr, src_stride, HFilter, VFilter, tmp, 64,
output_width, output_height, bd); output_width, output_height, bd);
highbd_block2d_average_c(tmp, 64, dst_ptr, dst_stride, highbd_block2d_average_c(tmp, 64, dst_ptr, dst_stride, output_width,
output_width, output_height); output_height);
} }
#endif // CONFIG_VP9_HIGHBITDEPTH #endif // CONFIG_VP9_HIGHBITDEPTH
@ -330,19 +283,20 @@ class ConvolveTest : public ::testing::TestWithParam<ConvolveParam> {
public: public:
static void SetUpTestCase() { static void SetUpTestCase() {
// Force input_ to be unaligned, output to be 16 byte aligned. // Force input_ to be unaligned, output to be 16 byte aligned.
input_ = reinterpret_cast<uint8_t*>( input_ = reinterpret_cast<uint8_t *>(
vpx_memalign(kDataAlignment, kInputBufferSize + 1)) + 1; vpx_memalign(kDataAlignment, kInputBufferSize + 1)) +
output_ = reinterpret_cast<uint8_t*>( 1;
output_ = reinterpret_cast<uint8_t *>(
vpx_memalign(kDataAlignment, kOutputBufferSize)); vpx_memalign(kDataAlignment, kOutputBufferSize));
output_ref_ = reinterpret_cast<uint8_t*>( output_ref_ = reinterpret_cast<uint8_t *>(
vpx_memalign(kDataAlignment, kOutputBufferSize)); vpx_memalign(kDataAlignment, kOutputBufferSize));
#if CONFIG_VP9_HIGHBITDEPTH #if CONFIG_VP9_HIGHBITDEPTH
input16_ = reinterpret_cast<uint16_t*>( input16_ = reinterpret_cast<uint16_t *>(vpx_memalign(
vpx_memalign(kDataAlignment, kDataAlignment, (kInputBufferSize + 1) * sizeof(uint16_t))) +
(kInputBufferSize + 1) * sizeof(uint16_t))) + 1; 1;
output16_ = reinterpret_cast<uint16_t*>( output16_ = reinterpret_cast<uint16_t *>(
vpx_memalign(kDataAlignment, (kOutputBufferSize) * sizeof(uint16_t))); vpx_memalign(kDataAlignment, (kOutputBufferSize) * sizeof(uint16_t)));
output16_ref_ = reinterpret_cast<uint16_t*>( output16_ref_ = reinterpret_cast<uint16_t *>(
vpx_memalign(kDataAlignment, (kOutputBufferSize) * sizeof(uint16_t))); vpx_memalign(kDataAlignment, (kOutputBufferSize) * sizeof(uint16_t)));
#endif #endif
} }
@ -438,8 +392,7 @@ class ConvolveTest : public ::testing::TestWithParam<ConvolveParam> {
void CheckGuardBlocks() { void CheckGuardBlocks() {
for (int i = 0; i < kOutputBufferSize; ++i) { for (int i = 0; i < kOutputBufferSize; ++i) {
if (IsIndexInBorder(i)) if (IsIndexInBorder(i)) EXPECT_EQ(255, output_[i]);
EXPECT_EQ(255, output_[i]);
} }
} }
@ -497,98 +450,88 @@ class ConvolveTest : public ::testing::TestWithParam<ConvolveParam> {
void assign_val(uint8_t *list, int index, uint16_t val) const { void assign_val(uint8_t *list, int index, uint16_t val) const {
#if CONFIG_VP9_HIGHBITDEPTH #if CONFIG_VP9_HIGHBITDEPTH
if (UUT_->use_highbd_ == 0) { if (UUT_->use_highbd_ == 0) {
list[index] = (uint8_t) val; list[index] = (uint8_t)val;
} else { } else {
CONVERT_TO_SHORTPTR(list)[index] = val; CONVERT_TO_SHORTPTR(list)[index] = val;
} }
#else #else
list[index] = (uint8_t) val; list[index] = (uint8_t)val;
#endif #endif
} }
void wrapper_filter_average_block2d_8_c(const uint8_t *src_ptr, void wrapper_filter_average_block2d_8_c(
const unsigned int src_stride, const uint8_t *src_ptr, const unsigned int src_stride,
const int16_t *HFilter, const int16_t *HFilter, const int16_t *VFilter, uint8_t *dst_ptr,
const int16_t *VFilter, unsigned int dst_stride, unsigned int output_width,
uint8_t *dst_ptr, unsigned int output_height) {
unsigned int dst_stride,
unsigned int output_width,
unsigned int output_height) {
#if CONFIG_VP9_HIGHBITDEPTH #if CONFIG_VP9_HIGHBITDEPTH
if (UUT_->use_highbd_ == 0) { if (UUT_->use_highbd_ == 0) {
filter_average_block2d_8_c(src_ptr, src_stride, HFilter, VFilter, filter_average_block2d_8_c(src_ptr, src_stride, HFilter, VFilter, dst_ptr,
dst_ptr, dst_stride, output_width, dst_stride, output_width, output_height);
output_height);
} else { } else {
highbd_filter_average_block2d_8_c(CONVERT_TO_SHORTPTR(src_ptr), highbd_filter_average_block2d_8_c(
src_stride, HFilter, VFilter, CONVERT_TO_SHORTPTR(src_ptr), src_stride, HFilter, VFilter,
CONVERT_TO_SHORTPTR(dst_ptr), CONVERT_TO_SHORTPTR(dst_ptr), dst_stride, output_width, output_height,
dst_stride, output_width, output_height, UUT_->use_highbd_);
UUT_->use_highbd_);
} }
#else #else
filter_average_block2d_8_c(src_ptr, src_stride, HFilter, VFilter, filter_average_block2d_8_c(src_ptr, src_stride, HFilter, VFilter, dst_ptr,
dst_ptr, dst_stride, output_width, dst_stride, output_width, output_height);
output_height);
#endif #endif
} }
void wrapper_filter_block2d_8_c(const uint8_t *src_ptr, void wrapper_filter_block2d_8_c(const uint8_t *src_ptr,
const unsigned int src_stride, const unsigned int src_stride,
const int16_t *HFilter, const int16_t *HFilter,
const int16_t *VFilter, const int16_t *VFilter, uint8_t *dst_ptr,
uint8_t *dst_ptr,
unsigned int dst_stride, unsigned int dst_stride,
unsigned int output_width, unsigned int output_width,
unsigned int output_height) { unsigned int output_height) {
#if CONFIG_VP9_HIGHBITDEPTH #if CONFIG_VP9_HIGHBITDEPTH
if (UUT_->use_highbd_ == 0) { if (UUT_->use_highbd_ == 0) {
filter_block2d_8_c(src_ptr, src_stride, HFilter, VFilter, filter_block2d_8_c(src_ptr, src_stride, HFilter, VFilter, dst_ptr,
dst_ptr, dst_stride, output_width, output_height); dst_stride, output_width, output_height);
} else { } else {
highbd_filter_block2d_8_c(CONVERT_TO_SHORTPTR(src_ptr), src_stride, highbd_filter_block2d_8_c(CONVERT_TO_SHORTPTR(src_ptr), src_stride,
HFilter, VFilter, HFilter, VFilter, CONVERT_TO_SHORTPTR(dst_ptr),
CONVERT_TO_SHORTPTR(dst_ptr), dst_stride, dst_stride, output_width, output_height,
output_width, output_height, UUT_->use_highbd_); UUT_->use_highbd_);
} }
#else #else
filter_block2d_8_c(src_ptr, src_stride, HFilter, VFilter, filter_block2d_8_c(src_ptr, src_stride, HFilter, VFilter, dst_ptr,
dst_ptr, dst_stride, output_width, output_height); dst_stride, output_width, output_height);
#endif #endif
} }
const ConvolveFunctions* UUT_; const ConvolveFunctions *UUT_;
static uint8_t* input_; static uint8_t *input_;
static uint8_t* output_; static uint8_t *output_;
static uint8_t* output_ref_; static uint8_t *output_ref_;
#if CONFIG_VP9_HIGHBITDEPTH #if CONFIG_VP9_HIGHBITDEPTH
static uint16_t* input16_; static uint16_t *input16_;
static uint16_t* output16_; static uint16_t *output16_;
static uint16_t* output16_ref_; static uint16_t *output16_ref_;
int mask_; int mask_;
#endif #endif
}; };
uint8_t* ConvolveTest::input_ = NULL; uint8_t *ConvolveTest::input_ = NULL;
uint8_t* ConvolveTest::output_ = NULL; uint8_t *ConvolveTest::output_ = NULL;
uint8_t* ConvolveTest::output_ref_ = NULL; uint8_t *ConvolveTest::output_ref_ = NULL;
#if CONFIG_VP9_HIGHBITDEPTH #if CONFIG_VP9_HIGHBITDEPTH
uint16_t* ConvolveTest::input16_ = NULL; uint16_t *ConvolveTest::input16_ = NULL;
uint16_t* ConvolveTest::output16_ = NULL; uint16_t *ConvolveTest::output16_ = NULL;
uint16_t* ConvolveTest::output16_ref_ = NULL; uint16_t *ConvolveTest::output16_ref_ = NULL;
#endif #endif
TEST_P(ConvolveTest, GuardBlocks) { TEST_P(ConvolveTest, GuardBlocks) { CheckGuardBlocks(); }
CheckGuardBlocks();
}
TEST_P(ConvolveTest, Copy) { TEST_P(ConvolveTest, Copy) {
uint8_t* const in = input(); uint8_t *const in = input();
uint8_t* const out = output(); uint8_t *const out = output();
ASM_REGISTER_STATE_CHECK( ASM_REGISTER_STATE_CHECK(UUT_->copy_(in, kInputStride, out, kOutputStride,
UUT_->copy_(in, kInputStride, out, kOutputStride, NULL, 0, NULL, 0, NULL, 0, NULL, 0, Width(), Height()));
Width(), Height()));
CheckGuardBlocks(); CheckGuardBlocks();
@ -600,14 +543,13 @@ TEST_P(ConvolveTest, Copy) {
} }
TEST_P(ConvolveTest, Avg) { TEST_P(ConvolveTest, Avg) {
uint8_t* const in = input(); uint8_t *const in = input();
uint8_t* const out = output(); uint8_t *const out = output();
uint8_t* const out_ref = output_ref(); uint8_t *const out_ref = output_ref();
CopyOutputToRef(); CopyOutputToRef();
ASM_REGISTER_STATE_CHECK( ASM_REGISTER_STATE_CHECK(UUT_->avg_(in, kInputStride, out, kOutputStride,
UUT_->avg_(in, kInputStride, out, kOutputStride, NULL, 0, NULL, 0, NULL, 0, NULL, 0, Width(), Height()));
Width(), Height()));
CheckGuardBlocks(); CheckGuardBlocks();
@ -615,18 +557,20 @@ TEST_P(ConvolveTest, Avg) {
for (int x = 0; x < Width(); ++x) for (int x = 0; x < Width(); ++x)
ASSERT_EQ(lookup(out, y * kOutputStride + x), ASSERT_EQ(lookup(out, y * kOutputStride + x),
ROUND_POWER_OF_TWO(lookup(in, y * kInputStride + x) + ROUND_POWER_OF_TWO(lookup(in, y * kInputStride + x) +
lookup(out_ref, y * kOutputStride + x), 1)) lookup(out_ref, y * kOutputStride + x),
1))
<< "(" << x << "," << y << ")"; << "(" << x << "," << y << ")";
} }
TEST_P(ConvolveTest, CopyHoriz) { TEST_P(ConvolveTest, CopyHoriz) {
uint8_t* const in = input(); uint8_t *const in = input();
uint8_t* const out = output(); uint8_t *const out = output();
DECLARE_ALIGNED(256, const int16_t, filter8[8]) = {0, 0, 0, 128, 0, 0, 0, 0}; DECLARE_ALIGNED(256, const int16_t,
filter8[8]) = { 0, 0, 0, 128, 0, 0, 0, 0 };
ASM_REGISTER_STATE_CHECK( ASM_REGISTER_STATE_CHECK(UUT_->sh8_(in, kInputStride, out, kOutputStride,
UUT_->sh8_(in, kInputStride, out, kOutputStride, filter8, 16, filter8, 16, filter8, 16, filter8, 16, Width(),
Width(), Height())); Height()));
CheckGuardBlocks(); CheckGuardBlocks();
@ -638,13 +582,14 @@ TEST_P(ConvolveTest, CopyHoriz) {
} }
TEST_P(ConvolveTest, CopyVert) { TEST_P(ConvolveTest, CopyVert) {
uint8_t* const in = input(); uint8_t *const in = input();
uint8_t* const out = output(); uint8_t *const out = output();
DECLARE_ALIGNED(256, const int16_t, filter8[8]) = {0, 0, 0, 128, 0, 0, 0, 0}; DECLARE_ALIGNED(256, const int16_t,
filter8[8]) = { 0, 0, 0, 128, 0, 0, 0, 0 };
ASM_REGISTER_STATE_CHECK( ASM_REGISTER_STATE_CHECK(UUT_->sv8_(in, kInputStride, out, kOutputStride,
UUT_->sv8_(in, kInputStride, out, kOutputStride, filter8, 16, filter8, 16, filter8, 16, filter8, 16, Width(),
Width(), Height())); Height()));
CheckGuardBlocks(); CheckGuardBlocks();
@ -656,13 +601,14 @@ TEST_P(ConvolveTest, CopyVert) {
} }
TEST_P(ConvolveTest, Copy2D) { TEST_P(ConvolveTest, Copy2D) {
uint8_t* const in = input(); uint8_t *const in = input();
uint8_t* const out = output(); uint8_t *const out = output();
DECLARE_ALIGNED(256, const int16_t, filter8[8]) = {0, 0, 0, 128, 0, 0, 0, 0}; DECLARE_ALIGNED(256, const int16_t,
filter8[8]) = { 0, 0, 0, 128, 0, 0, 0, 0 };
ASM_REGISTER_STATE_CHECK( ASM_REGISTER_STATE_CHECK(UUT_->shv8_(in, kInputStride, out, kOutputStride,
UUT_->shv8_(in, kInputStride, out, kOutputStride, filter8, 16, filter8, filter8, 16, filter8, 16, Width(),
16, Width(), Height())); Height()));
CheckGuardBlocks(); CheckGuardBlocks();
@ -700,12 +646,12 @@ TEST(ConvolveTest, FiltersWontSaturateWhenAddedPairwise) {
const int16_t kInvalidFilter[8] = { 0 }; const int16_t kInvalidFilter[8] = { 0 };
TEST_P(ConvolveTest, MatchesReferenceSubpixelFilter) { TEST_P(ConvolveTest, MatchesReferenceSubpixelFilter) {
uint8_t* const in = input(); uint8_t *const in = input();
uint8_t* const out = output(); uint8_t *const out = output();
#if CONFIG_VP9_HIGHBITDEPTH #if CONFIG_VP9_HIGHBITDEPTH
uint8_t ref8[kOutputStride * kMaxDimension]; uint8_t ref8[kOutputStride * kMaxDimension];
uint16_t ref16[kOutputStride * kMaxDimension]; uint16_t ref16[kOutputStride * kMaxDimension];
uint8_t* ref; uint8_t *ref;
if (UUT_->use_highbd_ == 0) { if (UUT_->use_highbd_ == 0) {
ref = ref8; ref = ref8;
} else { } else {
@ -721,31 +667,26 @@ TEST_P(ConvolveTest, MatchesReferenceSubpixelFilter) {
for (int filter_x = 0; filter_x < kNumFilters; ++filter_x) { for (int filter_x = 0; filter_x < kNumFilters; ++filter_x) {
for (int filter_y = 0; filter_y < kNumFilters; ++filter_y) { for (int filter_y = 0; filter_y < kNumFilters; ++filter_y) {
wrapper_filter_block2d_8_c(in, kInputStride, wrapper_filter_block2d_8_c(in, kInputStride, filters[filter_x],
filters[filter_x], filters[filter_y], filters[filter_y], ref, kOutputStride,
ref, kOutputStride,
Width(), Height()); Width(), Height());
if (filter_x && filter_y) if (filter_x && filter_y)
ASM_REGISTER_STATE_CHECK( ASM_REGISTER_STATE_CHECK(UUT_->hv8_(
UUT_->hv8_(in, kInputStride, out, kOutputStride, in, kInputStride, out, kOutputStride, filters[filter_x], 16,
filters[filter_x], 16, filters[filter_y], 16, filters[filter_y], 16, Width(), Height()));
Width(), Height()));
else if (filter_y) else if (filter_y)
ASM_REGISTER_STATE_CHECK( ASM_REGISTER_STATE_CHECK(
UUT_->v8_(in, kInputStride, out, kOutputStride, UUT_->v8_(in, kInputStride, out, kOutputStride, kInvalidFilter,
kInvalidFilter, 16, filters[filter_y], 16, 16, filters[filter_y], 16, Width(), Height()));
Width(), Height()));
else if (filter_x) else if (filter_x)
ASM_REGISTER_STATE_CHECK( ASM_REGISTER_STATE_CHECK(
UUT_->h8_(in, kInputStride, out, kOutputStride, UUT_->h8_(in, kInputStride, out, kOutputStride, filters[filter_x],
filters[filter_x], 16, kInvalidFilter, 16, 16, kInvalidFilter, 16, Width(), Height()));
Width(), Height()));
else else
ASM_REGISTER_STATE_CHECK( ASM_REGISTER_STATE_CHECK(
UUT_->copy_(in, kInputStride, out, kOutputStride, UUT_->copy_(in, kInputStride, out, kOutputStride, kInvalidFilter,
kInvalidFilter, 0, kInvalidFilter, 0, 0, kInvalidFilter, 0, Width(), Height()));
Width(), Height()));
CheckGuardBlocks(); CheckGuardBlocks();
@ -754,20 +695,20 @@ TEST_P(ConvolveTest, MatchesReferenceSubpixelFilter) {
ASSERT_EQ(lookup(ref, y * kOutputStride + x), ASSERT_EQ(lookup(ref, y * kOutputStride + x),
lookup(out, y * kOutputStride + x)) lookup(out, y * kOutputStride + x))
<< "mismatch at (" << x << "," << y << "), " << "mismatch at (" << x << "," << y << "), "
<< "filters (" << filter_bank << "," << "filters (" << filter_bank << "," << filter_x << ","
<< filter_x << "," << filter_y << ")"; << filter_y << ")";
} }
} }
} }
} }
TEST_P(ConvolveTest, MatchesReferenceAveragingSubpixelFilter) { TEST_P(ConvolveTest, MatchesReferenceAveragingSubpixelFilter) {
uint8_t* const in = input(); uint8_t *const in = input();
uint8_t* const out = output(); uint8_t *const out = output();
#if CONFIG_VP9_HIGHBITDEPTH #if CONFIG_VP9_HIGHBITDEPTH
uint8_t ref8[kOutputStride * kMaxDimension]; uint8_t ref8[kOutputStride * kMaxDimension];
uint16_t ref16[kOutputStride * kMaxDimension]; uint16_t ref16[kOutputStride * kMaxDimension];
uint8_t* ref; uint8_t *ref;
if (UUT_->use_highbd_ == 0) { if (UUT_->use_highbd_ == 0) {
ref = ref8; ref = ref8;
} else { } else {
@ -803,31 +744,26 @@ TEST_P(ConvolveTest, MatchesReferenceAveragingSubpixelFilter) {
for (int filter_x = 0; filter_x < kNumFilters; ++filter_x) { for (int filter_x = 0; filter_x < kNumFilters; ++filter_x) {
for (int filter_y = 0; filter_y < kNumFilters; ++filter_y) { for (int filter_y = 0; filter_y < kNumFilters; ++filter_y) {
wrapper_filter_average_block2d_8_c(in, kInputStride, wrapper_filter_average_block2d_8_c(in, kInputStride, filters[filter_x],
filters[filter_x], filters[filter_y], filters[filter_y], ref,
ref, kOutputStride, kOutputStride, Width(), Height());
Width(), Height());
if (filter_x && filter_y) if (filter_x && filter_y)
ASM_REGISTER_STATE_CHECK( ASM_REGISTER_STATE_CHECK(UUT_->hv8_avg_(
UUT_->hv8_avg_(in, kInputStride, out, kOutputStride, in, kInputStride, out, kOutputStride, filters[filter_x], 16,
filters[filter_x], 16, filters[filter_y], 16, filters[filter_y], 16, Width(), Height()));
Width(), Height()));
else if (filter_y) else if (filter_y)
ASM_REGISTER_STATE_CHECK( ASM_REGISTER_STATE_CHECK(UUT_->v8_avg_(
UUT_->v8_avg_(in, kInputStride, out, kOutputStride, in, kInputStride, out, kOutputStride, kInvalidFilter, 16,
kInvalidFilter, 16, filters[filter_y], 16, filters[filter_y], 16, Width(), Height()));
Width(), Height()));
else if (filter_x) else if (filter_x)
ASM_REGISTER_STATE_CHECK( ASM_REGISTER_STATE_CHECK(UUT_->h8_avg_(
UUT_->h8_avg_(in, kInputStride, out, kOutputStride, in, kInputStride, out, kOutputStride, filters[filter_x], 16,
filters[filter_x], 16, kInvalidFilter, 16, kInvalidFilter, 16, Width(), Height()));
Width(), Height()));
else else
ASM_REGISTER_STATE_CHECK( ASM_REGISTER_STATE_CHECK(
UUT_->avg_(in, kInputStride, out, kOutputStride, UUT_->avg_(in, kInputStride, out, kOutputStride, kInvalidFilter,
kInvalidFilter, 0, kInvalidFilter, 0, 0, kInvalidFilter, 0, Width(), Height()));
Width(), Height()));
CheckGuardBlocks(); CheckGuardBlocks();
@ -836,8 +772,8 @@ TEST_P(ConvolveTest, MatchesReferenceAveragingSubpixelFilter) {
ASSERT_EQ(lookup(ref, y * kOutputStride + x), ASSERT_EQ(lookup(ref, y * kOutputStride + x),
lookup(out, y * kOutputStride + x)) lookup(out, y * kOutputStride + x))
<< "mismatch at (" << x << "," << y << "), " << "mismatch at (" << x << "," << y << "), "
<< "filters (" << filter_bank << "," << "filters (" << filter_bank << "," << filter_x << ","
<< filter_x << "," << filter_y << ")"; << filter_y << ")";
} }
} }
} }
@ -884,16 +820,16 @@ TEST_P(ConvolveTest, FilterExtremes) {
for (int y = 0; y < 8; ++y) { for (int y = 0; y < 8; ++y) {
for (int x = 0; x < 8; ++x) { for (int x = 0; x < 8; ++x) {
#if CONFIG_VP9_HIGHBITDEPTH #if CONFIG_VP9_HIGHBITDEPTH
assign_val(in, y * kOutputStride + x - SUBPEL_TAPS / 2 + 1, assign_val(in, y * kOutputStride + x - SUBPEL_TAPS / 2 + 1,
((seed_val >> (axis ? y : x)) & 1) * mask_); ((seed_val >> (axis ? y : x)) & 1) * mask_);
#else #else
assign_val(in, y * kOutputStride + x - SUBPEL_TAPS / 2 + 1, assign_val(in, y * kOutputStride + x - SUBPEL_TAPS / 2 + 1,
((seed_val >> (axis ? y : x)) & 1) * 255); ((seed_val >> (axis ? y : x)) & 1) * 255);
#endif #endif
if (axis) seed_val++; if (axis) seed_val++;
} }
if (axis) if (axis)
seed_val-= 8; seed_val -= 8;
else else
seed_val++; seed_val++;
} }
@ -904,38 +840,33 @@ TEST_P(ConvolveTest, FilterExtremes) {
vp9_filter_kernels[static_cast<INTERP_FILTER>(filter_bank)]; vp9_filter_kernels[static_cast<INTERP_FILTER>(filter_bank)];
for (int filter_x = 0; filter_x < kNumFilters; ++filter_x) { for (int filter_x = 0; filter_x < kNumFilters; ++filter_x) {
for (int filter_y = 0; filter_y < kNumFilters; ++filter_y) { for (int filter_y = 0; filter_y < kNumFilters; ++filter_y) {
wrapper_filter_block2d_8_c(in, kInputStride, wrapper_filter_block2d_8_c(in, kInputStride, filters[filter_x],
filters[filter_x], filters[filter_y], filters[filter_y], ref, kOutputStride,
ref, kOutputStride,
Width(), Height()); Width(), Height());
if (filter_x && filter_y) if (filter_x && filter_y)
ASM_REGISTER_STATE_CHECK( ASM_REGISTER_STATE_CHECK(UUT_->hv8_(
UUT_->hv8_(in, kInputStride, out, kOutputStride, in, kInputStride, out, kOutputStride, filters[filter_x], 16,
filters[filter_x], 16, filters[filter_y], 16, filters[filter_y], 16, Width(), Height()));
Width(), Height()));
else if (filter_y) else if (filter_y)
ASM_REGISTER_STATE_CHECK( ASM_REGISTER_STATE_CHECK(UUT_->v8_(
UUT_->v8_(in, kInputStride, out, kOutputStride, in, kInputStride, out, kOutputStride, kInvalidFilter, 16,
kInvalidFilter, 16, filters[filter_y], 16, filters[filter_y], 16, Width(), Height()));
Width(), Height()));
else if (filter_x) else if (filter_x)
ASM_REGISTER_STATE_CHECK( ASM_REGISTER_STATE_CHECK(UUT_->h8_(
UUT_->h8_(in, kInputStride, out, kOutputStride, in, kInputStride, out, kOutputStride, filters[filter_x], 16,
filters[filter_x], 16, kInvalidFilter, 16, kInvalidFilter, 16, Width(), Height()));
Width(), Height()));
else else
ASM_REGISTER_STATE_CHECK( ASM_REGISTER_STATE_CHECK(UUT_->copy_(
UUT_->copy_(in, kInputStride, out, kOutputStride, in, kInputStride, out, kOutputStride, kInvalidFilter, 0,
kInvalidFilter, 0, kInvalidFilter, 0, kInvalidFilter, 0, Width(), Height()));
Width(), Height()));
for (int y = 0; y < Height(); ++y) for (int y = 0; y < Height(); ++y)
for (int x = 0; x < Width(); ++x) for (int x = 0; x < Width(); ++x)
ASSERT_EQ(lookup(ref, y * kOutputStride + x), ASSERT_EQ(lookup(ref, y * kOutputStride + x),
lookup(out, y * kOutputStride + x)) lookup(out, y * kOutputStride + x))
<< "mismatch at (" << x << "," << y << "), " << "mismatch at (" << x << "," << y << "), "
<< "filters (" << filter_bank << "," << "filters (" << filter_bank << "," << filter_x << ","
<< filter_x << "," << filter_y << ")"; << filter_y << ")";
} }
} }
} }
@ -946,8 +877,8 @@ TEST_P(ConvolveTest, FilterExtremes) {
/* This test exercises that enough rows and columns are filtered with every /* This test exercises that enough rows and columns are filtered with every
possible initial fractional positions and scaling steps. */ possible initial fractional positions and scaling steps. */
TEST_P(ConvolveTest, CheckScalingFiltering) { TEST_P(ConvolveTest, CheckScalingFiltering) {
uint8_t* const in = input(); uint8_t *const in = input();
uint8_t* const out = output(); uint8_t *const out = output();
const InterpKernel *const eighttap = vp9_filter_kernels[EIGHTTAP]; const InterpKernel *const eighttap = vp9_filter_kernels[EIGHTTAP];
SetConstantInput(127); SetConstantInput(127);
@ -956,9 +887,8 @@ TEST_P(ConvolveTest, CheckScalingFiltering) {
for (int step = 1; step <= 32; ++step) { for (int step = 1; step <= 32; ++step) {
/* Test the horizontal and vertical filters in combination. */ /* Test the horizontal and vertical filters in combination. */
ASM_REGISTER_STATE_CHECK(UUT_->shv8_(in, kInputStride, out, kOutputStride, ASM_REGISTER_STATE_CHECK(UUT_->shv8_(in, kInputStride, out, kOutputStride,
eighttap[frac], step, eighttap[frac], step, eighttap[frac],
eighttap[frac], step, step, Width(), Height()));
Width(), Height()));
CheckGuardBlocks(); CheckGuardBlocks();
@ -966,8 +896,8 @@ TEST_P(ConvolveTest, CheckScalingFiltering) {
for (int x = 0; x < Width(); ++x) { for (int x = 0; x < Width(); ++x) {
ASSERT_EQ(lookup(in, y * kInputStride + x), ASSERT_EQ(lookup(in, y * kInputStride + x),
lookup(out, y * kOutputStride + x)) lookup(out, y * kOutputStride + x))
<< "x == " << x << ", y == " << y << "x == " << x << ", y == " << y << ", frac == " << frac
<< ", frac == " << frac << ", step == " << step; << ", step == " << step;
} }
} }
} }
@ -977,18 +907,14 @@ TEST_P(ConvolveTest, CheckScalingFiltering) {
using std::tr1::make_tuple; using std::tr1::make_tuple;
#if CONFIG_VP9_HIGHBITDEPTH #if CONFIG_VP9_HIGHBITDEPTH
#define WRAP(func, bd) \ #define WRAP(func, bd) \
void wrap_ ## func ## _ ## bd(const uint8_t *src, ptrdiff_t src_stride, \ void wrap_##func##_##bd( \
uint8_t *dst, ptrdiff_t dst_stride, \ const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, \
const int16_t *filter_x, \ ptrdiff_t dst_stride, const int16_t *filter_x, int filter_x_stride, \
int filter_x_stride, \ const int16_t *filter_y, int filter_y_stride, int w, int h) { \
const int16_t *filter_y, \ vpx_highbd_##func(src, src_stride, dst, dst_stride, filter_x, \
int filter_y_stride, \ filter_x_stride, filter_y, filter_y_stride, w, h, bd); \
int w, int h) { \ }
vpx_highbd_ ## func(src, src_stride, dst, dst_stride, filter_x, \
filter_x_stride, filter_y, filter_y_stride, \
w, h, bd); \
}
#if HAVE_SSE2 && ARCH_X86_64 #if HAVE_SSE2 && ARCH_X86_64
WRAP(convolve_copy_sse2, 8) WRAP(convolve_copy_sse2, 8)
WRAP(convolve_avg_sse2, 8) WRAP(convolve_avg_sse2, 8)
@ -1043,48 +969,40 @@ WRAP(convolve8_avg_c, 12)
#undef WRAP #undef WRAP
const ConvolveFunctions convolve8_c( const ConvolveFunctions convolve8_c(
wrap_convolve_copy_c_8, wrap_convolve_avg_c_8, wrap_convolve_copy_c_8, wrap_convolve_avg_c_8, wrap_convolve8_horiz_c_8,
wrap_convolve8_avg_horiz_c_8, wrap_convolve8_vert_c_8,
wrap_convolve8_avg_vert_c_8, wrap_convolve8_c_8, wrap_convolve8_avg_c_8,
wrap_convolve8_horiz_c_8, wrap_convolve8_avg_horiz_c_8, wrap_convolve8_horiz_c_8, wrap_convolve8_avg_horiz_c_8,
wrap_convolve8_vert_c_8, wrap_convolve8_avg_vert_c_8, wrap_convolve8_vert_c_8, wrap_convolve8_avg_vert_c_8, wrap_convolve8_c_8,
wrap_convolve8_c_8, wrap_convolve8_avg_c_8, wrap_convolve8_avg_c_8, 8);
wrap_convolve8_horiz_c_8, wrap_convolve8_avg_horiz_c_8,
wrap_convolve8_vert_c_8, wrap_convolve8_avg_vert_c_8,
wrap_convolve8_c_8, wrap_convolve8_avg_c_8, 8);
const ConvolveFunctions convolve10_c( const ConvolveFunctions convolve10_c(
wrap_convolve_copy_c_10, wrap_convolve_avg_c_10, wrap_convolve_copy_c_10, wrap_convolve_avg_c_10, wrap_convolve8_horiz_c_10,
wrap_convolve8_avg_horiz_c_10, wrap_convolve8_vert_c_10,
wrap_convolve8_avg_vert_c_10, wrap_convolve8_c_10, wrap_convolve8_avg_c_10,
wrap_convolve8_horiz_c_10, wrap_convolve8_avg_horiz_c_10, wrap_convolve8_horiz_c_10, wrap_convolve8_avg_horiz_c_10,
wrap_convolve8_vert_c_10, wrap_convolve8_avg_vert_c_10, wrap_convolve8_vert_c_10, wrap_convolve8_avg_vert_c_10, wrap_convolve8_c_10,
wrap_convolve8_c_10, wrap_convolve8_avg_c_10, wrap_convolve8_avg_c_10, 10);
wrap_convolve8_horiz_c_10, wrap_convolve8_avg_horiz_c_10,
wrap_convolve8_vert_c_10, wrap_convolve8_avg_vert_c_10,
wrap_convolve8_c_10, wrap_convolve8_avg_c_10, 10);
const ConvolveFunctions convolve12_c( const ConvolveFunctions convolve12_c(
wrap_convolve_copy_c_12, wrap_convolve_avg_c_12, wrap_convolve_copy_c_12, wrap_convolve_avg_c_12, wrap_convolve8_horiz_c_12,
wrap_convolve8_avg_horiz_c_12, wrap_convolve8_vert_c_12,
wrap_convolve8_avg_vert_c_12, wrap_convolve8_c_12, wrap_convolve8_avg_c_12,
wrap_convolve8_horiz_c_12, wrap_convolve8_avg_horiz_c_12, wrap_convolve8_horiz_c_12, wrap_convolve8_avg_horiz_c_12,
wrap_convolve8_vert_c_12, wrap_convolve8_avg_vert_c_12, wrap_convolve8_vert_c_12, wrap_convolve8_avg_vert_c_12, wrap_convolve8_c_12,
wrap_convolve8_c_12, wrap_convolve8_avg_c_12, wrap_convolve8_avg_c_12, 12);
wrap_convolve8_horiz_c_12, wrap_convolve8_avg_horiz_c_12,
wrap_convolve8_vert_c_12, wrap_convolve8_avg_vert_c_12,
wrap_convolve8_c_12, wrap_convolve8_avg_c_12, 12);
const ConvolveParam kArrayConvolve_c[] = { const ConvolveParam kArrayConvolve_c[] = {
ALL_SIZES(convolve8_c), ALL_SIZES(convolve8_c), ALL_SIZES(convolve10_c), ALL_SIZES(convolve12_c)
ALL_SIZES(convolve10_c),
ALL_SIZES(convolve12_c)
}; };
#else #else
const ConvolveFunctions convolve8_c( const ConvolveFunctions convolve8_c(
vpx_convolve_copy_c, vpx_convolve_avg_c, vpx_convolve_copy_c, vpx_convolve_avg_c, vpx_convolve8_horiz_c,
vpx_convolve8_horiz_c, vpx_convolve8_avg_horiz_c, vpx_convolve8_avg_horiz_c, vpx_convolve8_vert_c, vpx_convolve8_avg_vert_c,
vpx_convolve8_vert_c, vpx_convolve8_avg_vert_c, vpx_convolve8_c, vpx_convolve8_avg_c, vpx_scaled_horiz_c,
vpx_convolve8_c, vpx_convolve8_avg_c, vpx_scaled_avg_horiz_c, vpx_scaled_vert_c, vpx_scaled_avg_vert_c,
vpx_scaled_horiz_c, vpx_scaled_avg_horiz_c,
vpx_scaled_vert_c, vpx_scaled_avg_vert_c,
vpx_scaled_2d_c, vpx_scaled_avg_2d_c, 0); vpx_scaled_2d_c, vpx_scaled_avg_2d_c, 0);
const ConvolveParam kArrayConvolve_c[] = { ALL_SIZES(convolve8_c) }; const ConvolveParam kArrayConvolve_c[] = { ALL_SIZES(convolve8_c) };
#endif #endif
INSTANTIATE_TEST_CASE_P(C, ConvolveTest, INSTANTIATE_TEST_CASE_P(C, ConvolveTest, ::testing::ValuesIn(kArrayConvolve_c));
::testing::ValuesIn(kArrayConvolve_c));
#if HAVE_SSE2 && ARCH_X86_64 #if HAVE_SSE2 && ARCH_X86_64
#if CONFIG_VP9_HIGHBITDEPTH #if CONFIG_VP9_HIGHBITDEPTH
@ -1112,20 +1030,16 @@ const ConvolveFunctions convolve12_sse2(
wrap_convolve8_horiz_sse2_12, wrap_convolve8_avg_horiz_sse2_12, wrap_convolve8_horiz_sse2_12, wrap_convolve8_avg_horiz_sse2_12,
wrap_convolve8_vert_sse2_12, wrap_convolve8_avg_vert_sse2_12, wrap_convolve8_vert_sse2_12, wrap_convolve8_avg_vert_sse2_12,
wrap_convolve8_sse2_12, wrap_convolve8_avg_sse2_12, 12); wrap_convolve8_sse2_12, wrap_convolve8_avg_sse2_12, 12);
const ConvolveParam kArrayConvolve_sse2[] = { const ConvolveParam kArrayConvolve_sse2[] = { ALL_SIZES(convolve8_sse2),
ALL_SIZES(convolve8_sse2), ALL_SIZES(convolve10_sse2),
ALL_SIZES(convolve10_sse2), ALL_SIZES(convolve12_sse2) };
ALL_SIZES(convolve12_sse2)
};
#else #else
const ConvolveFunctions convolve8_sse2( const ConvolveFunctions convolve8_sse2(
vpx_convolve_copy_sse2, vpx_convolve_avg_sse2, vpx_convolve_copy_sse2, vpx_convolve_avg_sse2, vpx_convolve8_horiz_sse2,
vpx_convolve8_horiz_sse2, vpx_convolve8_avg_horiz_sse2, vpx_convolve8_avg_horiz_sse2, vpx_convolve8_vert_sse2,
vpx_convolve8_vert_sse2, vpx_convolve8_avg_vert_sse2, vpx_convolve8_avg_vert_sse2, vpx_convolve8_sse2, vpx_convolve8_avg_sse2,
vpx_convolve8_sse2, vpx_convolve8_avg_sse2, vpx_scaled_horiz_c, vpx_scaled_avg_horiz_c, vpx_scaled_vert_c,
vpx_scaled_horiz_c, vpx_scaled_avg_horiz_c, vpx_scaled_avg_vert_c, vpx_scaled_2d_c, vpx_scaled_avg_2d_c, 0);
vpx_scaled_vert_c, vpx_scaled_avg_vert_c,
vpx_scaled_2d_c, vpx_scaled_avg_2d_c, 0);
const ConvolveParam kArrayConvolve_sse2[] = { ALL_SIZES(convolve8_sse2) }; const ConvolveParam kArrayConvolve_sse2[] = { ALL_SIZES(convolve8_sse2) };
#endif // CONFIG_VP9_HIGHBITDEPTH #endif // CONFIG_VP9_HIGHBITDEPTH
@ -1135,13 +1049,11 @@ INSTANTIATE_TEST_CASE_P(SSE2, ConvolveTest,
#if HAVE_SSSE3 #if HAVE_SSSE3
const ConvolveFunctions convolve8_ssse3( const ConvolveFunctions convolve8_ssse3(
vpx_convolve_copy_c, vpx_convolve_avg_c, vpx_convolve_copy_c, vpx_convolve_avg_c, vpx_convolve8_horiz_ssse3,
vpx_convolve8_horiz_ssse3, vpx_convolve8_avg_horiz_ssse3, vpx_convolve8_avg_horiz_ssse3, vpx_convolve8_vert_ssse3,
vpx_convolve8_vert_ssse3, vpx_convolve8_avg_vert_ssse3, vpx_convolve8_avg_vert_ssse3, vpx_convolve8_ssse3, vpx_convolve8_avg_ssse3,
vpx_convolve8_ssse3, vpx_convolve8_avg_ssse3, vpx_scaled_horiz_c, vpx_scaled_avg_horiz_c, vpx_scaled_vert_c,
vpx_scaled_horiz_c, vpx_scaled_avg_horiz_c, vpx_scaled_avg_vert_c, vpx_scaled_2d_ssse3, vpx_scaled_avg_2d_c, 0);
vpx_scaled_vert_c, vpx_scaled_avg_vert_c,
vpx_scaled_2d_ssse3, vpx_scaled_avg_2d_c, 0);
const ConvolveParam kArrayConvolve8_ssse3[] = { ALL_SIZES(convolve8_ssse3) }; const ConvolveParam kArrayConvolve8_ssse3[] = { ALL_SIZES(convolve8_ssse3) };
INSTANTIATE_TEST_CASE_P(SSSE3, ConvolveTest, INSTANTIATE_TEST_CASE_P(SSSE3, ConvolveTest,
@ -1150,13 +1062,11 @@ INSTANTIATE_TEST_CASE_P(SSSE3, ConvolveTest,
#if HAVE_AVX2 && HAVE_SSSE3 #if HAVE_AVX2 && HAVE_SSSE3
const ConvolveFunctions convolve8_avx2( const ConvolveFunctions convolve8_avx2(
vpx_convolve_copy_c, vpx_convolve_avg_c, vpx_convolve_copy_c, vpx_convolve_avg_c, vpx_convolve8_horiz_avx2,
vpx_convolve8_horiz_avx2, vpx_convolve8_avg_horiz_ssse3, vpx_convolve8_avg_horiz_ssse3, vpx_convolve8_vert_avx2,
vpx_convolve8_vert_avx2, vpx_convolve8_avg_vert_ssse3, vpx_convolve8_avg_vert_ssse3, vpx_convolve8_avx2, vpx_convolve8_avg_ssse3,
vpx_convolve8_avx2, vpx_convolve8_avg_ssse3, vpx_scaled_horiz_c, vpx_scaled_avg_horiz_c, vpx_scaled_vert_c,
vpx_scaled_horiz_c, vpx_scaled_avg_horiz_c, vpx_scaled_avg_vert_c, vpx_scaled_2d_c, vpx_scaled_avg_2d_c, 0);
vpx_scaled_vert_c, vpx_scaled_avg_vert_c,
vpx_scaled_2d_c, vpx_scaled_avg_2d_c, 0);
const ConvolveParam kArrayConvolve8_avx2[] = { ALL_SIZES(convolve8_avx2) }; const ConvolveParam kArrayConvolve8_avx2[] = { ALL_SIZES(convolve8_avx2) };
INSTANTIATE_TEST_CASE_P(AVX2, ConvolveTest, INSTANTIATE_TEST_CASE_P(AVX2, ConvolveTest,
@ -1166,22 +1076,18 @@ INSTANTIATE_TEST_CASE_P(AVX2, ConvolveTest,
#if HAVE_NEON #if HAVE_NEON
#if HAVE_NEON_ASM #if HAVE_NEON_ASM
const ConvolveFunctions convolve8_neon( const ConvolveFunctions convolve8_neon(
vpx_convolve_copy_neon, vpx_convolve_avg_neon, vpx_convolve_copy_neon, vpx_convolve_avg_neon, vpx_convolve8_horiz_neon,
vpx_convolve8_horiz_neon, vpx_convolve8_avg_horiz_neon, vpx_convolve8_avg_horiz_neon, vpx_convolve8_vert_neon,
vpx_convolve8_vert_neon, vpx_convolve8_avg_vert_neon, vpx_convolve8_avg_vert_neon, vpx_convolve8_neon, vpx_convolve8_avg_neon,
vpx_convolve8_neon, vpx_convolve8_avg_neon, vpx_scaled_horiz_c, vpx_scaled_avg_horiz_c, vpx_scaled_vert_c,
vpx_scaled_horiz_c, vpx_scaled_avg_horiz_c, vpx_scaled_avg_vert_c, vpx_scaled_2d_c, vpx_scaled_avg_2d_c, 0);
vpx_scaled_vert_c, vpx_scaled_avg_vert_c, #else // HAVE_NEON
vpx_scaled_2d_c, vpx_scaled_avg_2d_c, 0);
#else // HAVE_NEON
const ConvolveFunctions convolve8_neon( const ConvolveFunctions convolve8_neon(
vpx_convolve_copy_neon, vpx_convolve_avg_neon, vpx_convolve_copy_neon, vpx_convolve_avg_neon, vpx_convolve8_horiz_neon,
vpx_convolve8_horiz_neon, vpx_convolve8_avg_horiz_neon, vpx_convolve8_avg_horiz_neon, vpx_convolve8_vert_neon,
vpx_convolve8_vert_neon, vpx_convolve8_avg_vert_neon, vpx_convolve8_avg_vert_neon, vpx_convolve8_neon, vpx_convolve8_avg_neon,
vpx_convolve8_neon, vpx_convolve8_avg_neon, vpx_scaled_horiz_c, vpx_scaled_avg_horiz_c, vpx_scaled_vert_c,
vpx_scaled_horiz_c, vpx_scaled_avg_horiz_c, vpx_scaled_avg_vert_c, vpx_scaled_2d_c, vpx_scaled_avg_2d_c, 0);
vpx_scaled_vert_c, vpx_scaled_avg_vert_c,
vpx_scaled_2d_c, vpx_scaled_avg_2d_c, 0);
#endif // HAVE_NEON_ASM #endif // HAVE_NEON_ASM
const ConvolveParam kArrayConvolve8_neon[] = { ALL_SIZES(convolve8_neon) }; const ConvolveParam kArrayConvolve8_neon[] = { ALL_SIZES(convolve8_neon) };
@ -1191,13 +1097,11 @@ INSTANTIATE_TEST_CASE_P(NEON, ConvolveTest,
#if HAVE_DSPR2 #if HAVE_DSPR2
const ConvolveFunctions convolve8_dspr2( const ConvolveFunctions convolve8_dspr2(
vpx_convolve_copy_dspr2, vpx_convolve_avg_dspr2, vpx_convolve_copy_dspr2, vpx_convolve_avg_dspr2, vpx_convolve8_horiz_dspr2,
vpx_convolve8_horiz_dspr2, vpx_convolve8_avg_horiz_dspr2, vpx_convolve8_avg_horiz_dspr2, vpx_convolve8_vert_dspr2,
vpx_convolve8_vert_dspr2, vpx_convolve8_avg_vert_dspr2, vpx_convolve8_avg_vert_dspr2, vpx_convolve8_dspr2, vpx_convolve8_avg_dspr2,
vpx_convolve8_dspr2, vpx_convolve8_avg_dspr2, vpx_scaled_horiz_c, vpx_scaled_avg_horiz_c, vpx_scaled_vert_c,
vpx_scaled_horiz_c, vpx_scaled_avg_horiz_c, vpx_scaled_avg_vert_c, vpx_scaled_2d_c, vpx_scaled_avg_2d_c, 0);
vpx_scaled_vert_c, vpx_scaled_avg_vert_c,
vpx_scaled_2d_c, vpx_scaled_avg_2d_c, 0);
const ConvolveParam kArrayConvolve8_dspr2[] = { ALL_SIZES(convolve8_dspr2) }; const ConvolveParam kArrayConvolve8_dspr2[] = { ALL_SIZES(convolve8_dspr2) };
INSTANTIATE_TEST_CASE_P(DSPR2, ConvolveTest, INSTANTIATE_TEST_CASE_P(DSPR2, ConvolveTest,
@ -1206,13 +1110,11 @@ INSTANTIATE_TEST_CASE_P(DSPR2, ConvolveTest,
#if HAVE_MSA #if HAVE_MSA
const ConvolveFunctions convolve8_msa( const ConvolveFunctions convolve8_msa(
vpx_convolve_copy_msa, vpx_convolve_avg_msa, vpx_convolve_copy_msa, vpx_convolve_avg_msa, vpx_convolve8_horiz_msa,
vpx_convolve8_horiz_msa, vpx_convolve8_avg_horiz_msa, vpx_convolve8_avg_horiz_msa, vpx_convolve8_vert_msa,
vpx_convolve8_vert_msa, vpx_convolve8_avg_vert_msa, vpx_convolve8_avg_vert_msa, vpx_convolve8_msa, vpx_convolve8_avg_msa,
vpx_convolve8_msa, vpx_convolve8_avg_msa, vpx_scaled_horiz_c, vpx_scaled_avg_horiz_c, vpx_scaled_vert_c,
vpx_scaled_horiz_c, vpx_scaled_avg_horiz_c, vpx_scaled_avg_vert_c, vpx_scaled_2d_c, vpx_scaled_avg_2d_c, 0);
vpx_scaled_vert_c, vpx_scaled_avg_vert_c,
vpx_scaled_2d_c, vpx_scaled_avg_2d_c, 0);
const ConvolveParam kArrayConvolve8_msa[] = { ALL_SIZES(convolve8_msa) }; const ConvolveParam kArrayConvolve8_msa[] = { ALL_SIZES(convolve8_msa) };
INSTANTIATE_TEST_CASE_P(MSA, ConvolveTest, INSTANTIATE_TEST_CASE_P(MSA, ConvolveTest,

23
test/cpu_speed_test.cc
View File

@ -23,10 +23,8 @@ class CpuSpeedTest
public ::libvpx_test::CodecTestWith2Params<libvpx_test::TestMode, int> { public ::libvpx_test::CodecTestWith2Params<libvpx_test::TestMode, int> {
protected: protected:
CpuSpeedTest() CpuSpeedTest()
: EncoderTest(GET_PARAM(0)), : EncoderTest(GET_PARAM(0)), encoding_mode_(GET_PARAM(1)),
encoding_mode_(GET_PARAM(1)), set_cpu_used_(GET_PARAM(2)), min_psnr_(kMaxPSNR),
set_cpu_used_(GET_PARAM(2)),
min_psnr_(kMaxPSNR),
tune_content_(VP9E_CONTENT_DEFAULT) {} tune_content_(VP9E_CONTENT_DEFAULT) {}
virtual ~CpuSpeedTest() {} virtual ~CpuSpeedTest() {}
@ -42,9 +40,7 @@ class CpuSpeedTest
} }
} }
virtual void BeginPassHook(unsigned int /*pass*/) { virtual void BeginPassHook(unsigned int /*pass*/) { min_psnr_ = kMaxPSNR; }
min_psnr_ = kMaxPSNR;
}
virtual void PreEncodeFrameHook(::libvpx_test::VideoSource *video, virtual void PreEncodeFrameHook(::libvpx_test::VideoSource *video,
::libvpx_test::Encoder *encoder) { ::libvpx_test::Encoder *encoder) {
@ -61,8 +57,7 @@ class CpuSpeedTest
} }
virtual void PSNRPktHook(const vpx_codec_cx_pkt_t *pkt) { virtual void PSNRPktHook(const vpx_codec_cx_pkt_t *pkt) {
if (pkt->data.psnr.psnr[0] < min_psnr_) if (pkt->data.psnr.psnr[0] < min_psnr_) min_psnr_ = pkt->data.psnr.psnr[0];
min_psnr_ = pkt->data.psnr.psnr[0];
} }
::libvpx_test::TestMode encoding_mode_; ::libvpx_test::TestMode encoding_mode_;
@ -153,9 +148,9 @@ TEST_P(CpuSpeedTest, TestLowBitrate) {
ASSERT_NO_FATAL_FAILURE(RunLoop(&video)); ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
} }
VP9_INSTANTIATE_TEST_CASE( VP9_INSTANTIATE_TEST_CASE(CpuSpeedTest,
CpuSpeedTest, ::testing::Values(::libvpx_test::kTwoPassGood,
::testing::Values(::libvpx_test::kTwoPassGood, ::libvpx_test::kOnePassGood, ::libvpx_test::kOnePassGood,
::libvpx_test::kRealTime), ::libvpx_test::kRealTime),
::testing::Range(0, 9)); ::testing::Range(0, 9));
} // namespace } // namespace

11
test/cq_test.cc
View File

@ -24,14 +24,12 @@ const int kCQLevelStep = 8;
const unsigned int kCQTargetBitrate = 2000; const unsigned int kCQTargetBitrate = 2000;
class CQTest : public ::libvpx_test::EncoderTest, class CQTest : public ::libvpx_test::EncoderTest,
public ::libvpx_test::CodecTestWithParam<int> { public ::libvpx_test::CodecTestWithParam<int> {
public: public:
// maps the cqlevel to the bitrate produced. // maps the cqlevel to the bitrate produced.
typedef std::map<int, uint32_t> BitrateMap; typedef std::map<int, uint32_t> BitrateMap;
static void SetUpTestCase() { static void SetUpTestCase() { bitrates_.clear(); }
bitrates_.clear();
}
static void TearDownTestCase() { static void TearDownTestCase() {
ASSERT_TRUE(!HasFailure()) ASSERT_TRUE(!HasFailure())
@ -128,7 +126,6 @@ TEST_P(CQTest, LinearPSNRIsHigherForCQLevel) {
EXPECT_GE(cq_psnr_lin, vbr_psnr_lin); EXPECT_GE(cq_psnr_lin, vbr_psnr_lin);
} }
VP8_INSTANTIATE_TEST_CASE(CQTest, VP8_INSTANTIATE_TEST_CASE(CQTest, ::testing::Range(kCQLevelMin, kCQLevelMax,
::testing::Range(kCQLevelMin, kCQLevelMax, kCQLevelStep));
kCQLevelStep));
} // namespace } // namespace

174
test/datarate_test.cc
View File

@ -18,8 +18,9 @@
namespace { namespace {
class DatarateTestLarge : public ::libvpx_test::EncoderTest, class DatarateTestLarge
public ::libvpx_test::CodecTestWithParam<libvpx_test::TestMode> { : public ::libvpx_test::EncoderTest,
public ::libvpx_test::CodecTestWithParam<libvpx_test::TestMode> {
public: public:
DatarateTestLarge() : EncoderTest(GET_PARAM(0)) {} DatarateTestLarge() : EncoderTest(GET_PARAM(0)) {}
@ -71,8 +72,7 @@ class DatarateTestLarge : public ::libvpx_test::EncoderTest,
// http://code.google.com/p/webm/issues/detail?id=496 is fixed. // http://code.google.com/p/webm/issues/detail?id=496 is fixed.
// For now the codec assumes buffer starts at starting buffer rate // For now the codec assumes buffer starts at starting buffer rate
// plus one frame's time. // plus one frame's time.
if (last_pts_ == 0) if (last_pts_ == 0) duration = 1;
duration = 1;
// Add to the buffer the bits we'd expect from a constant bitrate server. // Add to the buffer the bits we'd expect from a constant bitrate server.
bits_in_buffer_model_ += static_cast<int64_t>( bits_in_buffer_model_ += static_cast<int64_t>(
@ -83,11 +83,11 @@ class DatarateTestLarge : public ::libvpx_test::EncoderTest,
* empty - and then stop showing frames until we've got enough bits to * empty - and then stop showing frames until we've got enough bits to
* show one. As noted in comment below (issue 495), this does not currently * show one. As noted in comment below (issue 495), this does not currently
* apply to key frames. For now exclude key frames in condition below. */ * apply to key frames. For now exclude key frames in condition below. */
const bool key_frame = (pkt->data.frame.flags & VPX_FRAME_IS_KEY) const bool key_frame =
? true: false; (pkt->data.frame.flags & VPX_FRAME_IS_KEY) ? true : false;
if (!key_frame) { if (!key_frame) {
ASSERT_GE(bits_in_buffer_model_, 0) << "Buffer Underrun at frame " ASSERT_GE(bits_in_buffer_model_, 0) << "Buffer Underrun at frame "
<< pkt->data.frame.pts; << pkt->data.frame.pts;
} }
const int64_t frame_size_in_bits = pkt->data.frame.sz * 8; const int64_t frame_size_in_bits = pkt->data.frame.sz * 8;
@ -99,8 +99,7 @@ class DatarateTestLarge : public ::libvpx_test::EncoderTest,
bits_total_ += frame_size_in_bits; bits_total_ += frame_size_in_bits;
// If first drop not set and we have a drop set it to this time. // If first drop not set and we have a drop set it to this time.
if (!first_drop_ && duration > 1) if (!first_drop_ && duration > 1) first_drop_ = last_pts_ + 1;
first_drop_ = last_pts_ + 1;
// Update the most recent pts. // Update the most recent pts.
last_pts_ = pkt->data.frame.pts; last_pts_ = pkt->data.frame.pts;
@ -119,8 +118,8 @@ class DatarateTestLarge : public ::libvpx_test::EncoderTest,
duration_ = (last_pts_ + 1) * timebase_; duration_ = (last_pts_ + 1) * timebase_;
// Effective file datarate includes the time spent prebuffering. // Effective file datarate includes the time spent prebuffering.
effective_datarate_ = (bits_total_ - bits_in_last_frame_) / 1000.0 effective_datarate_ = (bits_total_ - bits_in_last_frame_) / 1000.0 /
/ (cfg_.rc_buf_initial_sz / 1000.0 + duration_); (cfg_.rc_buf_initial_sz / 1000.0 + duration_);
file_datarate_ = file_size_in_kb / duration_; file_datarate_ = file_size_in_kb / duration_;
} }
@ -256,8 +255,9 @@ TEST_P(DatarateTestLarge, ChangingDropFrameThresh) {
} }
} }
class DatarateTestVP9Large : public ::libvpx_test::EncoderTest, class DatarateTestVP9Large
public ::libvpx_test::CodecTestWith2Params<libvpx_test::TestMode, int> { : public ::libvpx_test::EncoderTest,
public ::libvpx_test::CodecTestWith2Params<libvpx_test::TestMode, int> {
public: public:
DatarateTestVP9Large() : EncoderTest(GET_PARAM(0)) {} DatarateTestVP9Large() : EncoderTest(GET_PARAM(0)) {}
@ -307,8 +307,8 @@ class DatarateTestVP9Large : public ::libvpx_test::EncoderTest,
if (num_temp_layers == 2) { if (num_temp_layers == 2) {
if (frame_num % 2 == 0) { if (frame_num % 2 == 0) {
// Layer 0: predict from L and ARF, update L. // Layer 0: predict from L and ARF, update L.
frame_flags = VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_UPD_GF | frame_flags =
VP8_EFLAG_NO_UPD_ARF; VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF;
} else { } else {
// Layer 1: predict from L, G and ARF, and update G. // Layer 1: predict from L, G and ARF, and update G.
frame_flags = VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST | frame_flags = VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST |
@ -317,15 +317,15 @@ class DatarateTestVP9Large : public ::libvpx_test::EncoderTest,
} else if (num_temp_layers == 3) { } else if (num_temp_layers == 3) {
if (frame_num % 4 == 0) { if (frame_num % 4 == 0) {
// Layer 0: predict from L and ARF; update L. // Layer 0: predict from L and ARF; update L.
frame_flags = VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF | frame_flags =
VP8_EFLAG_NO_REF_GF; VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_REF_GF;
} else if ((frame_num - 2) % 4 == 0) { } else if ((frame_num - 2) % 4 == 0) {
// Layer 1: predict from L, G, ARF; update G. // Layer 1: predict from L, G, ARF; update G.
frame_flags = VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST; frame_flags = VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST;
} else if ((frame_num - 1) % 2 == 0) { } else if ((frame_num - 1) % 2 == 0) {
// Layer 2: predict from L, G, ARF; update none. // Layer 2: predict from L, G, ARF; update none.
frame_flags = VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF | frame_flags =
VP8_EFLAG_NO_UPD_LAST; VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST;
} }
} }
return frame_flags; return frame_flags;
@ -353,8 +353,7 @@ class DatarateTestVP9Large : public ::libvpx_test::EncoderTest,
virtual void PreEncodeFrameHook(::libvpx_test::VideoSource *video, virtual void PreEncodeFrameHook(::libvpx_test::VideoSource *video,
::libvpx_test::Encoder *encoder) { ::libvpx_test::Encoder *encoder) {
if (video->frame() == 0) if (video->frame() == 0) encoder->Control(VP8E_SET_CPUUSED, set_cpu_used_);
encoder->Control(VP8E_SET_CPUUSED, set_cpu_used_);
if (denoiser_offon_test_) { if (denoiser_offon_test_) {
ASSERT_GT(denoiser_offon_period_, 0) ASSERT_GT(denoiser_offon_period_, 0)
@ -374,8 +373,8 @@ class DatarateTestVP9Large : public ::libvpx_test::EncoderTest,
vpx_svc_layer_id_t layer_id; vpx_svc_layer_id_t layer_id;
layer_id.spatial_layer_id = 0; layer_id.spatial_layer_id = 0;
frame_flags_ = SetFrameFlags(video->frame(), cfg_.ts_number_layers); frame_flags_ = SetFrameFlags(video->frame(), cfg_.ts_number_layers);
layer_id.temporal_layer_id = SetLayerId(video->frame(), layer_id.temporal_layer_id =
cfg_.ts_number_layers); SetLayerId(video->frame(), cfg_.ts_number_layers);
encoder->Control(VP9E_SET_SVC_LAYER_ID, &layer_id); encoder->Control(VP9E_SET_SVC_LAYER_ID, &layer_id);
} }
const vpx_rational_t tb = video->timebase(); const vpx_rational_t tb = video->timebase();
@ -383,15 +382,13 @@ class DatarateTestVP9Large : public ::libvpx_test::EncoderTest,
duration_ = 0; duration_ = 0;
} }
virtual void FramePktHook(const vpx_codec_cx_pkt_t *pkt) { virtual void FramePktHook(const vpx_codec_cx_pkt_t *pkt) {
// Time since last timestamp = duration. // Time since last timestamp = duration.
vpx_codec_pts_t duration = pkt->data.frame.pts - last_pts_; vpx_codec_pts_t duration = pkt->data.frame.pts - last_pts_;
if (duration > 1) { if (duration > 1) {
// If first drop not set and we have a drop set it to this time. // If first drop not set and we have a drop set it to this time.
if (!first_drop_) if (!first_drop_) first_drop_ = last_pts_ + 1;
first_drop_ = last_pts_ + 1;
// Update the number of frame drops. // Update the number of frame drops.
num_drops_ += static_cast<int>(duration - 1); num_drops_ += static_cast<int>(duration - 1);
// Update counter for total number of frames (#frames input to encoder). // Update counter for total number of frames (#frames input to encoder).
@ -407,7 +404,7 @@ class DatarateTestVP9Large : public ::libvpx_test::EncoderTest,
// Buffer should not go negative. // Buffer should not go negative.
ASSERT_GE(bits_in_buffer_model_, 0) << "Buffer Underrun at frame " ASSERT_GE(bits_in_buffer_model_, 0) << "Buffer Underrun at frame "
<< pkt->data.frame.pts; << pkt->data.frame.pts;
const size_t frame_size_in_bits = pkt->data.frame.sz * 8; const size_t frame_size_in_bits = pkt->data.frame.sz * 8;
@ -425,7 +422,7 @@ class DatarateTestVP9Large : public ::libvpx_test::EncoderTest,
virtual void EndPassHook(void) { virtual void EndPassHook(void) {
for (int layer = 0; layer < static_cast<int>(cfg_.ts_number_layers); for (int layer = 0; layer < static_cast<int>(cfg_.ts_number_layers);
++layer) { ++layer) {
duration_ = (last_pts_ + 1) * timebase_; duration_ = (last_pts_ + 1) * timebase_;
if (bits_total_[layer]) { if (bits_total_[layer]) {
// Effective file datarate: // Effective file datarate:
@ -546,7 +543,7 @@ TEST_P(DatarateTestVP9Large, BasicRateTargeting444) {
ASSERT_LE(static_cast<double>(cfg_.rc_target_bitrate), ASSERT_LE(static_cast<double>(cfg_.rc_target_bitrate),
effective_datarate_[0] * 1.15) effective_datarate_[0] * 1.15)
<< " The datarate for the file missed the target!" << " The datarate for the file missed the target!"
<< cfg_.rc_target_bitrate << " "<< effective_datarate_; << cfg_.rc_target_bitrate << " " << effective_datarate_;
} }
} }
@ -616,8 +613,7 @@ TEST_P(DatarateTestVP9Large, BasicRateTargeting2TemporalLayers) {
cfg_.temporal_layering_mode = VP9E_TEMPORAL_LAYERING_MODE_BYPASS; cfg_.temporal_layering_mode = VP9E_TEMPORAL_LAYERING_MODE_BYPASS;
if (deadline_ == VPX_DL_REALTIME) if (deadline_ == VPX_DL_REALTIME) cfg_.g_error_resilient = 1;
cfg_.g_error_resilient = 1;
::libvpx_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352, 288, ::libvpx_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352, 288,
30, 1, 0, 200); 30, 1, 0, 200);
@ -631,10 +627,12 @@ TEST_P(DatarateTestVP9Large, BasicRateTargeting2TemporalLayers) {
for (int j = 0; j < static_cast<int>(cfg_.ts_number_layers); ++j) { for (int j = 0; j < static_cast<int>(cfg_.ts_number_layers); ++j) {
ASSERT_GE(effective_datarate_[j], cfg_.layer_target_bitrate[j] * 0.85) ASSERT_GE(effective_datarate_[j], cfg_.layer_target_bitrate[j] * 0.85)
<< " The datarate for the file is lower than target by too much, " << " The datarate for the file is lower than target by too much, "
"for layer: " << j; "for layer: "
<< j;
ASSERT_LE(effective_datarate_[j], cfg_.layer_target_bitrate[j] * 1.15) ASSERT_LE(effective_datarate_[j], cfg_.layer_target_bitrate[j] * 1.15)
<< " The datarate for the file is greater than target by too much, " << " The datarate for the file is greater than target by too much, "
"for layer: " << j; "for layer: "
<< j;
} }
} }
} }
@ -674,12 +672,14 @@ TEST_P(DatarateTestVP9Large, BasicRateTargeting3TemporalLayers) {
// Adjust the thresholds to be tighter than .75. // Adjust the thresholds to be tighter than .75.
ASSERT_GE(effective_datarate_[j], cfg_.layer_target_bitrate[j] * 0.75) ASSERT_GE(effective_datarate_[j], cfg_.layer_target_bitrate[j] * 0.75)
<< " The datarate for the file is lower than target by too much, " << " The datarate for the file is lower than target by too much, "
"for layer: " << j; "for layer: "
<< j;
// TODO(yaowu): Work out more stable rc control strategy and // TODO(yaowu): Work out more stable rc control strategy and
// Adjust the thresholds to be tighter than 1.25. // Adjust the thresholds to be tighter than 1.25.
ASSERT_LE(effective_datarate_[j], cfg_.layer_target_bitrate[j] * 1.25) ASSERT_LE(effective_datarate_[j], cfg_.layer_target_bitrate[j] * 1.25)
<< " The datarate for the file is greater than target by too much, " << " The datarate for the file is greater than target by too much, "
"for layer: " << j; "for layer: "
<< j;
} }
} }
} }
@ -719,10 +719,12 @@ TEST_P(DatarateTestVP9Large, BasicRateTargeting3TemporalLayersFrameDropping) {
for (int j = 0; j < static_cast<int>(cfg_.ts_number_layers); ++j) { for (int j = 0; j < static_cast<int>(cfg_.ts_number_layers); ++j) {
ASSERT_GE(effective_datarate_[j], cfg_.layer_target_bitrate[j] * 0.85) ASSERT_GE(effective_datarate_[j], cfg_.layer_target_bitrate[j] * 0.85)
<< " The datarate for the file is lower than target by too much, " << " The datarate for the file is lower than target by too much, "
"for layer: " << j; "for layer: "
<< j;
ASSERT_LE(effective_datarate_[j], cfg_.layer_target_bitrate[j] * 1.15) ASSERT_LE(effective_datarate_[j], cfg_.layer_target_bitrate[j] * 1.15)
<< " The datarate for the file is greater than target by too much, " << " The datarate for the file is greater than target by too much, "
"for layer: " << j; "for layer: "
<< j;
// Expect some frame drops in this test: for this 200 frames test, // Expect some frame drops in this test: for this 200 frames test,
// expect at least 10% and not more than 60% drops. // expect at least 10% and not more than 60% drops.
ASSERT_GE(num_drops_, 20); ASSERT_GE(num_drops_, 20);
@ -792,11 +794,13 @@ TEST_P(DatarateTestVP9Large, DenoiserOffOn) {
} }
#endif // CONFIG_VP9_TEMPORAL_DENOISING #endif // CONFIG_VP9_TEMPORAL_DENOISING
class DatarateOnePassCbrSvc : public ::libvpx_test::EncoderTest, class DatarateOnePassCbrSvc
public ::libvpx_test::CodecTestWith2Params<libvpx_test::TestMode, int> { : public ::libvpx_test::EncoderTest,
public ::libvpx_test::CodecTestWith2Params<libvpx_test::TestMode, int> {
public: public:
DatarateOnePassCbrSvc() : EncoderTest(GET_PARAM(0)) {} DatarateOnePassCbrSvc() : EncoderTest(GET_PARAM(0)) {}
virtual ~DatarateOnePassCbrSvc() {} virtual ~DatarateOnePassCbrSvc() {}
protected: protected:
virtual void SetUp() { virtual void SetUp() {
InitializeConfig(); InitializeConfig();
@ -814,8 +818,7 @@ class DatarateOnePassCbrSvc : public ::libvpx_test::EncoderTest,
mismatch_psnr_ = 0.0; mismatch_psnr_ = 0.0;
mismatch_nframes_ = 0; mismatch_nframes_ = 0;
} }
virtual void BeginPassHook(unsigned int /*pass*/) { virtual void BeginPassHook(unsigned int /*pass*/) {}
}
virtual void PreEncodeFrameHook(::libvpx_test::VideoSource *video, virtual void PreEncodeFrameHook(::libvpx_test::VideoSource *video,
::libvpx_test::Encoder *encoder) { ::libvpx_test::Encoder *encoder) {
if (video->frame() == 0) { if (video->frame() == 0) {
@ -837,21 +840,19 @@ class DatarateOnePassCbrSvc : public ::libvpx_test::EncoderTest,
} }
virtual void FramePktHook(const vpx_codec_cx_pkt_t *pkt) { virtual void FramePktHook(const vpx_codec_cx_pkt_t *pkt) {
vpx_codec_pts_t duration = pkt->data.frame.pts - last_pts_; vpx_codec_pts_t duration = pkt->data.frame.pts - last_pts_;
if (last_pts_ == 0) if (last_pts_ == 0) duration = 1;
duration = 1;
bits_in_buffer_model_ += static_cast<int64_t>( bits_in_buffer_model_ += static_cast<int64_t>(
duration * timebase_ * cfg_.rc_target_bitrate * 1000); duration * timebase_ * cfg_.rc_target_bitrate * 1000);
const bool key_frame = (pkt->data.frame.flags & VPX_FRAME_IS_KEY) const bool key_frame =
? true: false; (pkt->data.frame.flags & VPX_FRAME_IS_KEY) ? true : false;
if (!key_frame) { if (!key_frame) {
ASSERT_GE(bits_in_buffer_model_, 0) << "Buffer Underrun at frame " ASSERT_GE(bits_in_buffer_model_, 0) << "Buffer Underrun at frame "
<< pkt->data.frame.pts; << pkt->data.frame.pts;
} }
const size_t frame_size_in_bits = pkt->data.frame.sz * 8; const size_t frame_size_in_bits = pkt->data.frame.sz * 8;
bits_in_buffer_model_ -= frame_size_in_bits; bits_in_buffer_model_ -= frame_size_in_bits;
bits_total_ += frame_size_in_bits; bits_total_ += frame_size_in_bits;
if (!first_drop_ && duration > 1) if (!first_drop_ && duration > 1) first_drop_ = last_pts_ + 1;
first_drop_ = last_pts_ + 1;
last_pts_ = pkt->data.frame.pts; last_pts_ = pkt->data.frame.pts;
bits_in_last_frame_ = frame_size_in_bits; bits_in_last_frame_ = frame_size_in_bits;
++frame_number_; ++frame_number_;
@ -864,16 +865,13 @@ class DatarateOnePassCbrSvc : public ::libvpx_test::EncoderTest,
} }
} }
virtual void MismatchHook(const vpx_image_t *img1, virtual void MismatchHook(const vpx_image_t *img1, const vpx_image_t *img2) {
const vpx_image_t *img2) {
double mismatch_psnr = compute_psnr(img1, img2); double mismatch_psnr = compute_psnr(img1, img2);
mismatch_psnr_ += mismatch_psnr; mismatch_psnr_ += mismatch_psnr;
++mismatch_nframes_; ++mismatch_nframes_;
} }
unsigned int GetMismatchFrames() { unsigned int GetMismatchFrames() { return mismatch_nframes_; }
return mismatch_nframes_;
}
vpx_codec_pts_t last_pts_; vpx_codec_pts_t last_pts_;
int64_t bits_in_buffer_model_; int64_t bits_in_buffer_model_;
@ -890,37 +888,31 @@ class DatarateOnePassCbrSvc : public ::libvpx_test::EncoderTest,
int mismatch_nframes_; int mismatch_nframes_;
}; };
static void assign_layer_bitrates(vpx_codec_enc_cfg_t *const enc_cfg, static void assign_layer_bitrates(vpx_codec_enc_cfg_t *const enc_cfg,
const vpx_svc_extra_cfg_t *svc_params, const vpx_svc_extra_cfg_t *svc_params,
int spatial_layers, int spatial_layers, int temporal_layers,
int temporal_layers, int temporal_layering_mode) {
int temporal_layering_mode) {
int sl, spatial_layer_target; int sl, spatial_layer_target;
float total = 0; float total = 0;
float alloc_ratio[VPX_MAX_LAYERS] = {0}; float alloc_ratio[VPX_MAX_LAYERS] = { 0 };
for (sl = 0; sl < spatial_layers; ++sl) { for (sl = 0; sl < spatial_layers; ++sl) {
if (svc_params->scaling_factor_den[sl] > 0) { if (svc_params->scaling_factor_den[sl] > 0) {
alloc_ratio[sl] = (float)(svc_params->scaling_factor_num[sl] * alloc_ratio[sl] = (float)(svc_params->scaling_factor_num[sl] * 1.0 /
1.0 / svc_params->scaling_factor_den[sl]); svc_params->scaling_factor_den[sl]);
total += alloc_ratio[sl]; total += alloc_ratio[sl];
} }
} }
for (sl = 0; sl < spatial_layers; ++sl) { for (sl = 0; sl < spatial_layers; ++sl) {
enc_cfg->ss_target_bitrate[sl] = spatial_layer_target = enc_cfg->ss_target_bitrate[sl] = spatial_layer_target =
(unsigned int)(enc_cfg->rc_target_bitrate * (unsigned int)(enc_cfg->rc_target_bitrate * alloc_ratio[sl] / total);
alloc_ratio[sl] / total);
const int index = sl * temporal_layers; const int index = sl * temporal_layers;
if (temporal_layering_mode == 3) { if (temporal_layering_mode == 3) {
enc_cfg->layer_target_bitrate[index] = enc_cfg->layer_target_bitrate[index] = spatial_layer_target >> 1;
spatial_layer_target >> 1;
enc_cfg->layer_target_bitrate[index + 1] = enc_cfg->layer_target_bitrate[index + 1] =
(spatial_layer_target >> 1) + (spatial_layer_target >> 2); (spatial_layer_target >> 1) + (spatial_layer_target >> 2);
enc_cfg->layer_target_bitrate[index + 2] = enc_cfg->layer_target_bitrate[index + 2] = spatial_layer_target;
spatial_layer_target;
} else if (temporal_layering_mode == 2) { } else if (temporal_layering_mode == 2) {
enc_cfg->layer_target_bitrate[index] = enc_cfg->layer_target_bitrate[index] = spatial_layer_target * 2 / 3;
spatial_layer_target * 2 / 3; enc_cfg->layer_target_bitrate[index + 1] = spatial_layer_target;
enc_cfg->layer_target_bitrate[index + 1] =
spatial_layer_target;
} }
} }
} }
@ -957,10 +949,10 @@ TEST_P(DatarateOnePassCbrSvc, OnePassCbrSvc2SpatialLayers) {
cfg_.rc_target_bitrate = i; cfg_.rc_target_bitrate = i;
ResetModel(); ResetModel();
assign_layer_bitrates(&cfg_, &svc_params_, cfg_.ss_number_layers, assign_layer_bitrates(&cfg_, &svc_params_, cfg_.ss_number_layers,
cfg_.ts_number_layers, cfg_.temporal_layering_mode); cfg_.ts_number_layers, cfg_.temporal_layering_mode);
ASSERT_NO_FATAL_FAILURE(RunLoop(&video)); ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
ASSERT_GE(cfg_.rc_target_bitrate, file_datarate_ * 0.85) ASSERT_GE(cfg_.rc_target_bitrate, file_datarate_ * 0.85)
<< " The datarate for the file exceeds the target by too much!"; << " The datarate for the file exceeds the target by too much!";
ASSERT_LE(cfg_.rc_target_bitrate, file_datarate_ * 1.15) ASSERT_LE(cfg_.rc_target_bitrate, file_datarate_ * 1.15)
<< " The datarate for the file is lower than the target by too much!"; << " The datarate for the file is lower than the target by too much!";
EXPECT_EQ(static_cast<unsigned int>(0), GetMismatchFrames()); EXPECT_EQ(static_cast<unsigned int>(0), GetMismatchFrames());
@ -999,10 +991,10 @@ TEST_P(DatarateOnePassCbrSvc, OnePassCbrSvc2SpatialLayersSmallKf) {
cfg_.kf_max_dist = j; cfg_.kf_max_dist = j;
ResetModel(); ResetModel();
assign_layer_bitrates(&cfg_, &svc_params_, cfg_.ss_number_layers, assign_layer_bitrates(&cfg_, &svc_params_, cfg_.ss_number_layers,
cfg_.ts_number_layers, cfg_.temporal_layering_mode); cfg_.ts_number_layers, cfg_.temporal_layering_mode);
ASSERT_NO_FATAL_FAILURE(RunLoop(&video)); ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
ASSERT_GE(cfg_.rc_target_bitrate, file_datarate_ * 0.85) ASSERT_GE(cfg_.rc_target_bitrate, file_datarate_ * 0.85)
<< " The datarate for the file exceeds the target by too much!"; << " The datarate for the file exceeds the target by too much!";
ASSERT_LE(cfg_.rc_target_bitrate, file_datarate_ * 1.15) ASSERT_LE(cfg_.rc_target_bitrate, file_datarate_ * 1.15)
<< " The datarate for the file is lower than the target by too much!"; << " The datarate for the file is lower than the target by too much!";
EXPECT_EQ(static_cast<unsigned int>(0), GetMismatchFrames()); EXPECT_EQ(static_cast<unsigned int>(0), GetMismatchFrames());
@ -1033,15 +1025,15 @@ TEST_P(DatarateOnePassCbrSvc, OnePassCbrSvc2SpatialLayers4threads) {
svc_params_.scaling_factor_den[1] = 288; svc_params_.scaling_factor_den[1] = 288;
cfg_.rc_dropframe_thresh = 10; cfg_.rc_dropframe_thresh = 10;
cfg_.kf_max_dist = 9999; cfg_.kf_max_dist = 9999;
::libvpx_test::I420VideoSource video("niklas_1280_720_30.y4m", 1280, 720, ::libvpx_test::I420VideoSource video("niklas_1280_720_30.y4m", 1280, 720, 30,
30, 1, 0, 300); 1, 0, 300);
cfg_.rc_target_bitrate = 800; cfg_.rc_target_bitrate = 800;
ResetModel(); ResetModel();
assign_layer_bitrates(&cfg_, &svc_params_, cfg_.ss_number_layers, assign_layer_bitrates(&cfg_, &svc_params_, cfg_.ss_number_layers,
cfg_.ts_number_layers, cfg_.temporal_layering_mode); cfg_.ts_number_layers, cfg_.temporal_layering_mode);
ASSERT_NO_FATAL_FAILURE(RunLoop(&video)); ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
ASSERT_GE(cfg_.rc_target_bitrate, file_datarate_ * 0.85) ASSERT_GE(cfg_.rc_target_bitrate, file_datarate_ * 0.85)
<< " The datarate for the file exceeds the target by too much!"; << " The datarate for the file exceeds the target by too much!";
ASSERT_LE(cfg_.rc_target_bitrate, file_datarate_ * 1.15) ASSERT_LE(cfg_.rc_target_bitrate, file_datarate_ * 1.15)
<< " The datarate for the file is lower than the target by too much!"; << " The datarate for the file is lower than the target by too much!";
EXPECT_EQ(static_cast<unsigned int>(0), GetMismatchFrames()); EXPECT_EQ(static_cast<unsigned int>(0), GetMismatchFrames());
@ -1073,15 +1065,15 @@ TEST_P(DatarateOnePassCbrSvc, OnePassCbrSvc3SpatialLayers) {
svc_params_.scaling_factor_den[2] = 288; svc_params_.scaling_factor_den[2] = 288;
cfg_.rc_dropframe_thresh = 10; cfg_.rc_dropframe_thresh = 10;
cfg_.kf_max_dist = 9999; cfg_.kf_max_dist = 9999;
::libvpx_test::I420VideoSource video("niklas_1280_720_30.y4m", 1280, 720, ::libvpx_test::I420VideoSource video("niklas_1280_720_30.y4m", 1280, 720, 30,
30, 1, 0, 300); 1, 0, 300);
cfg_.rc_target_bitrate = 800; cfg_.rc_target_bitrate = 800;
ResetModel(); ResetModel();
assign_layer_bitrates(&cfg_, &svc_params_, cfg_.ss_number_layers, assign_layer_bitrates(&cfg_, &svc_params_, cfg_.ss_number_layers,
cfg_.ts_number_layers, cfg_.temporal_layering_mode); cfg_.ts_number_layers, cfg_.temporal_layering_mode);
ASSERT_NO_FATAL_FAILURE(RunLoop(&video)); ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
ASSERT_GE(cfg_.rc_target_bitrate, file_datarate_ * 0.85) ASSERT_GE(cfg_.rc_target_bitrate, file_datarate_ * 0.85)
<< " The datarate for the file exceeds the target by too much!"; << " The datarate for the file exceeds the target by too much!";
ASSERT_LE(cfg_.rc_target_bitrate, file_datarate_ * 1.22) ASSERT_LE(cfg_.rc_target_bitrate, file_datarate_ * 1.22)
<< " The datarate for the file is lower than the target by too much!"; << " The datarate for the file is lower than the target by too much!";
EXPECT_EQ(static_cast<unsigned int>(0), GetMismatchFrames()); EXPECT_EQ(static_cast<unsigned int>(0), GetMismatchFrames());
@ -1112,8 +1104,8 @@ TEST_P(DatarateOnePassCbrSvc, OnePassCbrSvc3SpatialLayersSmallKf) {
svc_params_.scaling_factor_num[2] = 288; svc_params_.scaling_factor_num[2] = 288;
svc_params_.scaling_factor_den[2] = 288; svc_params_.scaling_factor_den[2] = 288;
cfg_.rc_dropframe_thresh = 10; cfg_.rc_dropframe_thresh = 10;
::libvpx_test::I420VideoSource video("niklas_1280_720_30.y4m", 1280, 720, ::libvpx_test::I420VideoSource video("niklas_1280_720_30.y4m", 1280, 720, 30,
30, 1, 0, 300); 1, 0, 300);
cfg_.rc_target_bitrate = 800; cfg_.rc_target_bitrate = 800;
// For this 3 temporal layer case, pattern repeats every 4 frames, so choose // For this 3 temporal layer case, pattern repeats every 4 frames, so choose
// 4 key neighboring key frame periods (so key frame will land on 0-2-1-2). // 4 key neighboring key frame periods (so key frame will land on 0-2-1-2).
@ -1121,10 +1113,10 @@ TEST_P(DatarateOnePassCbrSvc, OnePassCbrSvc3SpatialLayersSmallKf) {
cfg_.kf_max_dist = j; cfg_.kf_max_dist = j;
ResetModel(); ResetModel();
assign_layer_bitrates(&cfg_, &svc_params_, cfg_.ss_number_layers, assign_layer_bitrates(&cfg_, &svc_params_, cfg_.ss_number_layers,
cfg_.ts_number_layers, cfg_.temporal_layering_mode); cfg_.ts_number_layers, cfg_.temporal_layering_mode);
ASSERT_NO_FATAL_FAILURE(RunLoop(&video)); ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
ASSERT_GE(cfg_.rc_target_bitrate, file_datarate_ * 0.85) ASSERT_GE(cfg_.rc_target_bitrate, file_datarate_ * 0.85)
<< " The datarate for the file exceeds the target by too much!"; << " The datarate for the file exceeds the target by too much!";
ASSERT_LE(cfg_.rc_target_bitrate, file_datarate_ * 1.30) ASSERT_LE(cfg_.rc_target_bitrate, file_datarate_ * 1.30)
<< " The datarate for the file is lower than the target by too much!"; << " The datarate for the file is lower than the target by too much!";
EXPECT_EQ(static_cast<unsigned int>(0), GetMismatchFrames()); EXPECT_EQ(static_cast<unsigned int>(0), GetMismatchFrames());
@ -1157,15 +1149,15 @@ TEST_P(DatarateOnePassCbrSvc, OnePassCbrSvc3SpatialLayers4threads) {
svc_params_.scaling_factor_den[2] = 288; svc_params_.scaling_factor_den[2] = 288;
cfg_.rc_dropframe_thresh = 10; cfg_.rc_dropframe_thresh = 10;
cfg_.kf_max_dist = 9999; cfg_.kf_max_dist = 9999;
::libvpx_test::I420VideoSource video("niklas_1280_720_30.y4m", 1280, 720, ::libvpx_test::I420VideoSource video("niklas_1280_720_30.y4m", 1280, 720, 30,
30, 1, 0, 300); 1, 0, 300);
cfg_.rc_target_bitrate = 800; cfg_.rc_target_bitrate = 800;
ResetModel(); ResetModel();
assign_layer_bitrates(&cfg_, &svc_params_, cfg_.ss_number_layers, assign_layer_bitrates(&cfg_, &svc_params_, cfg_.ss_number_layers,
cfg_.ts_number_layers, cfg_.temporal_layering_mode); cfg_.ts_number_layers, cfg_.temporal_layering_mode);
ASSERT_NO_FATAL_FAILURE(RunLoop(&video)); ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
ASSERT_GE(cfg_.rc_target_bitrate, file_datarate_ * 0.85) ASSERT_GE(cfg_.rc_target_bitrate, file_datarate_ * 0.85)
<< " The datarate for the file exceeds the target by too much!"; << " The datarate for the file exceeds the target by too much!";
ASSERT_LE(cfg_.rc_target_bitrate, file_datarate_ * 1.22) ASSERT_LE(cfg_.rc_target_bitrate, file_datarate_ * 1.22)
<< " The datarate for the file is lower than the target by too much!"; << " The datarate for the file is lower than the target by too much!";
EXPECT_EQ(static_cast<unsigned int>(0), GetMismatchFrames()); EXPECT_EQ(static_cast<unsigned int>(0), GetMismatchFrames());

314
test/dct16x16_test.cc
View File

@ -54,16 +54,16 @@ void butterfly_16x16_dct_1d(double input[16], double output[16]) {
double temp1, temp2; double temp1, temp2;
// step 1 // step 1
step[ 0] = input[0] + input[15]; step[0] = input[0] + input[15];
step[ 1] = input[1] + input[14]; step[1] = input[1] + input[14];
step[ 2] = input[2] + input[13]; step[2] = input[2] + input[13];
step[ 3] = input[3] + input[12]; step[3] = input[3] + input[12];
step[ 4] = input[4] + input[11]; step[4] = input[4] + input[11];
step[ 5] = input[5] + input[10]; step[5] = input[5] + input[10];
step[ 6] = input[6] + input[ 9]; step[6] = input[6] + input[9];
step[ 7] = input[7] + input[ 8]; step[7] = input[7] + input[8];
step[ 8] = input[7] - input[ 8]; step[8] = input[7] - input[8];
step[ 9] = input[6] - input[ 9]; step[9] = input[6] - input[9];
step[10] = input[5] - input[10]; step[10] = input[5] - input[10];
step[11] = input[4] - input[11]; step[11] = input[4] - input[11];
step[12] = input[3] - input[12]; step[12] = input[3] - input[12];
@ -81,13 +81,13 @@ void butterfly_16x16_dct_1d(double input[16], double output[16]) {
output[6] = step[1] - step[6]; output[6] = step[1] - step[6];
output[7] = step[0] - step[7]; output[7] = step[0] - step[7];
temp1 = step[ 8] * C7; temp1 = step[8] * C7;
temp2 = step[15] * C9; temp2 = step[15] * C9;
output[ 8] = temp1 + temp2; output[8] = temp1 + temp2;
temp1 = step[ 9] * C11; temp1 = step[9] * C11;
temp2 = step[14] * C5; temp2 = step[14] * C5;
output[ 9] = temp1 - temp2; output[9] = temp1 - temp2;
temp1 = step[10] * C3; temp1 = step[10] * C3;
temp2 = step[13] * C13; temp2 = step[13] * C13;
@ -105,40 +105,40 @@ void butterfly_16x16_dct_1d(double input[16], double output[16]) {
temp2 = step[13] * C3; temp2 = step[13] * C3;
output[13] = temp2 - temp1; output[13] = temp2 - temp1;
temp1 = step[ 9] * C5; temp1 = step[9] * C5;
temp2 = step[14] * C11; temp2 = step[14] * C11;
output[14] = temp2 + temp1; output[14] = temp2 + temp1;
temp1 = step[ 8] * C9; temp1 = step[8] * C9;
temp2 = step[15] * C7; temp2 = step[15] * C7;
output[15] = temp2 - temp1; output[15] = temp2 - temp1;
// step 3 // step 3
step[ 0] = output[0] + output[3]; step[0] = output[0] + output[3];
step[ 1] = output[1] + output[2]; step[1] = output[1] + output[2];
step[ 2] = output[1] - output[2]; step[2] = output[1] - output[2];
step[ 3] = output[0] - output[3]; step[3] = output[0] - output[3];
temp1 = output[4] * C14; temp1 = output[4] * C14;
temp2 = output[7] * C2; temp2 = output[7] * C2;
step[ 4] = temp1 + temp2; step[4] = temp1 + temp2;
temp1 = output[5] * C10; temp1 = output[5] * C10;
temp2 = output[6] * C6; temp2 = output[6] * C6;
step[ 5] = temp1 + temp2; step[5] = temp1 + temp2;
temp1 = output[5] * C6; temp1 = output[5] * C6;
temp2 = output[6] * C10; temp2 = output[6] * C10;
step[ 6] = temp2 - temp1; step[6] = temp2 - temp1;
temp1 = output[4] * C2; temp1 = output[4] * C2;
temp2 = output[7] * C14; temp2 = output[7] * C14;
step[ 7] = temp2 - temp1; step[7] = temp2 - temp1;
step[ 8] = output[ 8] + output[11]; step[8] = output[8] + output[11];
step[ 9] = output[ 9] + output[10]; step[9] = output[9] + output[10];
step[10] = output[ 9] - output[10]; step[10] = output[9] - output[10];
step[11] = output[ 8] - output[11]; step[11] = output[8] - output[11];
step[12] = output[12] + output[15]; step[12] = output[12] + output[15];
step[13] = output[13] + output[14]; step[13] = output[13] + output[14];
@ -146,25 +146,25 @@ void butterfly_16x16_dct_1d(double input[16], double output[16]) {
step[15] = output[12] - output[15]; step[15] = output[12] - output[15];
// step 4 // step 4
output[ 0] = (step[ 0] + step[ 1]); output[0] = (step[0] + step[1]);
output[ 8] = (step[ 0] - step[ 1]); output[8] = (step[0] - step[1]);
temp1 = step[2] * C12; temp1 = step[2] * C12;
temp2 = step[3] * C4; temp2 = step[3] * C4;
temp1 = temp1 + temp2; temp1 = temp1 + temp2;
output[ 4] = 2*(temp1 * C8); output[4] = 2 * (temp1 * C8);
temp1 = step[2] * C4; temp1 = step[2] * C4;
temp2 = step[3] * C12; temp2 = step[3] * C12;
temp1 = temp2 - temp1; temp1 = temp2 - temp1;
output[12] = 2 * (temp1 * C8); output[12] = 2 * (temp1 * C8);
output[ 2] = 2 * ((step[4] + step[ 5]) * C8); output[2] = 2 * ((step[4] + step[5]) * C8);
output[14] = 2 * ((step[7] - step[ 6]) * C8); output[14] = 2 * ((step[7] - step[6]) * C8);
temp1 = step[4] - step[5]; temp1 = step[4] - step[5];
temp2 = step[6] + step[7]; temp2 = step[6] + step[7];
output[ 6] = (temp1 + temp2); output[6] = (temp1 + temp2);
output[10] = (temp1 - temp2); output[10] = (temp1 - temp2);
intermediate[8] = step[8] + step[14]; intermediate[8] = step[8] + step[14];
@ -180,18 +180,18 @@ void butterfly_16x16_dct_1d(double input[16], double output[16]) {
temp1 = temp2 + temp1; temp1 = temp2 + temp1;
output[13] = 2 * (temp1 * C8); output[13] = 2 * (temp1 * C8);
output[ 9] = 2 * ((step[10] + step[11]) * C8); output[9] = 2 * ((step[10] + step[11]) * C8);
intermediate[11] = step[10] - step[11]; intermediate[11] = step[10] - step[11];
intermediate[12] = step[12] + step[13]; intermediate[12] = step[12] + step[13];
intermediate[13] = step[12] - step[13]; intermediate[13] = step[12] - step[13];
intermediate[14] = step[ 8] - step[14]; intermediate[14] = step[8] - step[14];
intermediate[15] = step[ 9] - step[15]; intermediate[15] = step[9] - step[15];
output[15] = (intermediate[11] + intermediate[12]); output[15] = (intermediate[11] + intermediate[12]);
output[ 1] = -(intermediate[11] - intermediate[12]); output[1] = -(intermediate[11] - intermediate[12]);
output[ 7] = 2 * (intermediate[13] * C8); output[7] = 2 * (intermediate[13] * C8);
temp1 = intermediate[14] * C12; temp1 = intermediate[14] * C12;
temp2 = intermediate[15] * C4; temp2 = intermediate[15] * C4;
@ -201,28 +201,24 @@ void butterfly_16x16_dct_1d(double input[16], double output[16]) {
temp1 = intermediate[14] * C4; temp1 = intermediate[14] * C4;
temp2 = intermediate[15] * C12; temp2 = intermediate[15] * C12;
temp1 = temp2 + temp1; temp1 = temp2 + temp1;
output[ 5] = 2 * (temp1 * C8); output[5] = 2 * (temp1 * C8);
} }
void reference_16x16_dct_2d(int16_t input[256], double output[256]) { void reference_16x16_dct_2d(int16_t input[256], double output[256]) {
// First transform columns // First transform columns
for (int i = 0; i < 16; ++i) { for (int i = 0; i < 16; ++i) {
double temp_in[16], temp_out[16]; double temp_in[16], temp_out[16];
for (int j = 0; j < 16; ++j) for (int j = 0; j < 16; ++j) temp_in[j] = input[j * 16 + i];
temp_in[j] = input[j * 16 + i];
butterfly_16x16_dct_1d(temp_in, temp_out); butterfly_16x16_dct_1d(temp_in, temp_out);
for (int j = 0; j < 16; ++j) for (int j = 0; j < 16; ++j) output[j * 16 + i] = temp_out[j];
output[j * 16 + i] = temp_out[j];
} }
// Then transform rows // Then transform rows
for (int i = 0; i < 16; ++i) { for (int i = 0; i < 16; ++i) {
double temp_in[16], temp_out[16]; double temp_in[16], temp_out[16];
for (int j = 0; j < 16; ++j) for (int j = 0; j < 16; ++j) temp_in[j] = output[j + i * 16];
temp_in[j] = output[j + i * 16];
butterfly_16x16_dct_1d(temp_in, temp_out); butterfly_16x16_dct_1d(temp_in, temp_out);
// Scale by some magic number // Scale by some magic number
for (int j = 0; j < 16; ++j) for (int j = 0; j < 16; ++j) output[j + i * 16] = temp_out[j] / 2;
output[j + i * 16] = temp_out[j]/2;
} }
} }
@ -248,8 +244,7 @@ void idct16x16_ref(const tran_low_t *in, uint8_t *dest, int stride,
vpx_idct16x16_256_add_c(in, dest, stride); vpx_idct16x16_256_add_c(in, dest, stride);
} }
void fht16x16_ref(const int16_t *in, tran_low_t *out, int stride, void fht16x16_ref(const int16_t *in, tran_low_t *out, int stride, int tx_type) {
int tx_type) {
vp9_fht16x16_c(in, out, stride, tx_type); vp9_fht16x16_c(in, out, stride, tx_type);
} }
@ -351,11 +346,10 @@ class Trans16x16TestBase {
} }
} }
ASM_REGISTER_STATE_CHECK(RunFwdTxfm(test_input_block, ASM_REGISTER_STATE_CHECK(
test_temp_block, pitch_)); RunFwdTxfm(test_input_block, test_temp_block, pitch_));
if (bit_depth_ == VPX_BITS_8) { if (bit_depth_ == VPX_BITS_8) {
ASM_REGISTER_STATE_CHECK( ASM_REGISTER_STATE_CHECK(RunInvTxfm(test_temp_block, dst, pitch_));
RunInvTxfm(test_temp_block, dst, pitch_));
#if CONFIG_VP9_HIGHBITDEPTH #if CONFIG_VP9_HIGHBITDEPTH
} else { } else {
ASM_REGISTER_STATE_CHECK( ASM_REGISTER_STATE_CHECK(
@ -366,18 +360,17 @@ class Trans16x16TestBase {
for (int j = 0; j < kNumCoeffs; ++j) { for (int j = 0; j < kNumCoeffs; ++j) {
#if CONFIG_VP9_HIGHBITDEPTH #if CONFIG_VP9_HIGHBITDEPTH
const int32_t diff = const int32_t diff =
bit_depth_ == VPX_BITS_8 ? dst[j] - src[j] : dst16[j] - src16[j]; bit_depth_ == VPX_BITS_8 ? dst[j] - src[j] : dst16[j] - src16[j];
#else #else
const int32_t diff = dst[j] - src[j]; const int32_t diff = dst[j] - src[j];
#endif #endif
const uint32_t error = diff * diff; const uint32_t error = diff * diff;
if (max_error < error) if (max_error < error) max_error = error;
max_error = error;
total_error += error; total_error += error;
} }
} }
EXPECT_GE(1u << 2 * (bit_depth_ - 8), max_error) EXPECT_GE(1u << 2 * (bit_depth_ - 8), max_error)
<< "Error: 16x16 FHT/IHT has an individual round trip error > 1"; << "Error: 16x16 FHT/IHT has an individual round trip error > 1";
EXPECT_GE(count_test_block << 2 * (bit_depth_ - 8), total_error) EXPECT_GE(count_test_block << 2 * (bit_depth_ - 8), total_error)
@ -418,16 +411,14 @@ class Trans16x16TestBase {
input_extreme_block[j] = rnd.Rand8() % 2 ? mask_ : -mask_; input_extreme_block[j] = rnd.Rand8() % 2 ? mask_ : -mask_;
} }
if (i == 0) { if (i == 0) {
for (int j = 0; j < kNumCoeffs; ++j) for (int j = 0; j < kNumCoeffs; ++j) input_extreme_block[j] = mask_;
input_extreme_block[j] = mask_;
} else if (i == 1) { } else if (i == 1) {
for (int j = 0; j < kNumCoeffs; ++j) for (int j = 0; j < kNumCoeffs; ++j) input_extreme_block[j] = -mask_;
input_extreme_block[j] = -mask_;
} }
fwd_txfm_ref(input_extreme_block, output_ref_block, pitch_, tx_type_); fwd_txfm_ref(input_extreme_block, output_ref_block, pitch_, tx_type_);
ASM_REGISTER_STATE_CHECK(RunFwdTxfm(input_extreme_block, ASM_REGISTER_STATE_CHECK(
output_block, pitch_)); RunFwdTxfm(input_extreme_block, output_block, pitch_));
// The minimum quant value is 4. // The minimum quant value is 4.
for (int j = 0; j < kNumCoeffs; ++j) { for (int j = 0; j < kNumCoeffs; ++j) {
@ -457,11 +448,9 @@ class Trans16x16TestBase {
input_extreme_block[j] = rnd.Rand8() % 2 ? mask_ : -mask_; input_extreme_block[j] = rnd.Rand8() % 2 ? mask_ : -mask_;
} }
if (i == 0) if (i == 0)
for (int j = 0; j < kNumCoeffs; ++j) for (int j = 0; j < kNumCoeffs; ++j) input_extreme_block[j] = mask_;
input_extreme_block[j] = mask_;
if (i == 1) if (i == 1)
for (int j = 0; j < kNumCoeffs; ++j) for (int j = 0; j < kNumCoeffs; ++j) input_extreme_block[j] = -mask_;
input_extreme_block[j] = -mask_;
fwd_txfm_ref(input_extreme_block, output_ref_block, pitch_, tx_type_); fwd_txfm_ref(input_extreme_block, output_ref_block, pitch_, tx_type_);
@ -484,17 +473,15 @@ class Trans16x16TestBase {
} else { } else {
inv_txfm_ref(output_ref_block, CONVERT_TO_BYTEPTR(ref16), pitch_, inv_txfm_ref(output_ref_block, CONVERT_TO_BYTEPTR(ref16), pitch_,
tx_type_); tx_type_);
ASM_REGISTER_STATE_CHECK(RunInvTxfm(output_ref_block, ASM_REGISTER_STATE_CHECK(
CONVERT_TO_BYTEPTR(dst16), pitch_)); RunInvTxfm(output_ref_block, CONVERT_TO_BYTEPTR(dst16), pitch_));
#endif #endif
} }
if (bit_depth_ == VPX_BITS_8) { if (bit_depth_ == VPX_BITS_8) {
for (int j = 0; j < kNumCoeffs; ++j) for (int j = 0; j < kNumCoeffs; ++j) EXPECT_EQ(ref[j], dst[j]);
EXPECT_EQ(ref[j], dst[j]);
#if CONFIG_VP9_HIGHBITDEPTH #if CONFIG_VP9_HIGHBITDEPTH
} else { } else {
for (int j = 0; j < kNumCoeffs; ++j) for (int j = 0; j < kNumCoeffs; ++j) EXPECT_EQ(ref16[j], dst16[j]);
EXPECT_EQ(ref16[j], dst16[j]);
#endif #endif
} }
} }
@ -538,8 +525,8 @@ class Trans16x16TestBase {
ASM_REGISTER_STATE_CHECK(RunInvTxfm(coeff, dst, 16)); ASM_REGISTER_STATE_CHECK(RunInvTxfm(coeff, dst, 16));
#if CONFIG_VP9_HIGHBITDEPTH #if CONFIG_VP9_HIGHBITDEPTH
} else { } else {
ASM_REGISTER_STATE_CHECK(RunInvTxfm(coeff, CONVERT_TO_BYTEPTR(dst16), ASM_REGISTER_STATE_CHECK(
16)); RunInvTxfm(coeff, CONVERT_TO_BYTEPTR(dst16), 16));
#endif // CONFIG_VP9_HIGHBITDEPTH #endif // CONFIG_VP9_HIGHBITDEPTH
} }
@ -551,9 +538,8 @@ class Trans16x16TestBase {
const uint32_t diff = dst[j] - src[j]; const uint32_t diff = dst[j] - src[j];
#endif // CONFIG_VP9_HIGHBITDEPTH #endif // CONFIG_VP9_HIGHBITDEPTH
const uint32_t error = diff * diff; const uint32_t error = diff * diff;
EXPECT_GE(1u, error) EXPECT_GE(1u, error) << "Error: 16x16 IDCT has error " << error
<< "Error: 16x16 IDCT has error " << error << " at index " << j;
<< " at index " << j;
} }
} }
} }
@ -595,8 +581,8 @@ class Trans16x16TestBase {
} else { } else {
#if CONFIG_VP9_HIGHBITDEPTH #if CONFIG_VP9_HIGHBITDEPTH
ref_txfm(coeff, CONVERT_TO_BYTEPTR(ref16), pitch_); ref_txfm(coeff, CONVERT_TO_BYTEPTR(ref16), pitch_);
ASM_REGISTER_STATE_CHECK(RunInvTxfm(coeff, CONVERT_TO_BYTEPTR(dst16), ASM_REGISTER_STATE_CHECK(
pitch_)); RunInvTxfm(coeff, CONVERT_TO_BYTEPTR(dst16), pitch_));
#endif // CONFIG_VP9_HIGHBITDEPTH #endif // CONFIG_VP9_HIGHBITDEPTH
} }
@ -608,9 +594,8 @@ class Trans16x16TestBase {
const uint32_t diff = dst[j] - ref[j]; const uint32_t diff = dst[j] - ref[j];
#endif // CONFIG_VP9_HIGHBITDEPTH #endif // CONFIG_VP9_HIGHBITDEPTH
const uint32_t error = diff * diff; const uint32_t error = diff * diff;
EXPECT_EQ(0u, error) EXPECT_EQ(0u, error) << "Error: 16x16 IDCT Comparison has error "
<< "Error: 16x16 IDCT Comparison has error " << error << error << " at index " << j;
<< " at index " << j;
} }
} }
} }
@ -623,32 +608,25 @@ class Trans16x16TestBase {
IhtFunc inv_txfm_ref; IhtFunc inv_txfm_ref;
}; };
class Trans16x16DCT class Trans16x16DCT : public Trans16x16TestBase,
: public Trans16x16TestBase, public ::testing::TestWithParam<Dct16x16Param> {
public ::testing::TestWithParam<Dct16x16Param> {
public: public:
virtual ~Trans16x16DCT() {} virtual ~Trans16x16DCT() {}
virtual void SetUp() { virtual void SetUp() {
fwd_txfm_ = GET_PARAM(0); fwd_txfm_ = GET_PARAM(0);
inv_txfm_ = GET_PARAM(1); inv_txfm_ = GET_PARAM(1);
tx_type_ = GET_PARAM(2); tx_type_ = GET_PARAM(2);
bit_depth_ = GET_PARAM(3); bit_depth_ = GET_PARAM(3);
pitch_ = 16; pitch_ = 16;
fwd_txfm_ref = fdct16x16_ref; fwd_txfm_ref = fdct16x16_ref;
inv_txfm_ref = idct16x16_ref; inv_txfm_ref = idct16x16_ref;
mask_ = (1 << bit_depth_) - 1; mask_ = (1 << bit_depth_) - 1;
#if CONFIG_VP9_HIGHBITDEPTH #if CONFIG_VP9_HIGHBITDEPTH
switch (bit_depth_) { switch (bit_depth_) {
case VPX_BITS_10: case VPX_BITS_10: inv_txfm_ref = idct16x16_10_ref; break;
inv_txfm_ref = idct16x16_10_ref; case VPX_BITS_12: inv_txfm_ref = idct16x16_12_ref; break;
break; default: inv_txfm_ref = idct16x16_ref; break;
case VPX_BITS_12:
inv_txfm_ref = idct16x16_12_ref;
break;
default:
inv_txfm_ref = idct16x16_ref;
break;
} }
#else #else
inv_txfm_ref = idct16x16_ref; inv_txfm_ref = idct16x16_ref;
@ -668,17 +646,11 @@ class Trans16x16DCT
IdctFunc inv_txfm_; IdctFunc inv_txfm_;
}; };
TEST_P(Trans16x16DCT, AccuracyCheck) { TEST_P(Trans16x16DCT, AccuracyCheck) { RunAccuracyCheck(); }
RunAccuracyCheck();
}
TEST_P(Trans16x16DCT, CoeffCheck) { TEST_P(Trans16x16DCT, CoeffCheck) { RunCoeffCheck(); }
RunCoeffCheck();
}
TEST_P(Trans16x16DCT, MemCheck) { TEST_P(Trans16x16DCT, MemCheck) { RunMemCheck(); }
RunMemCheck();
}
TEST_P(Trans16x16DCT, QuantCheck) { TEST_P(Trans16x16DCT, QuantCheck) {
// Use maximally allowed quantization step sizes for DC and AC // Use maximally allowed quantization step sizes for DC and AC
@ -686,36 +658,27 @@ TEST_P(Trans16x16DCT, QuantCheck) {
RunQuantCheck(1336, 1828); RunQuantCheck(1336, 1828);
} }
TEST_P(Trans16x16DCT, InvAccuracyCheck) { TEST_P(Trans16x16DCT, InvAccuracyCheck) { RunInvAccuracyCheck(); }
RunInvAccuracyCheck();
}
class Trans16x16HT class Trans16x16HT : public Trans16x16TestBase,
: public Trans16x16TestBase, public ::testing::TestWithParam<Ht16x16Param> {
public ::testing::TestWithParam<Ht16x16Param> {
public: public:
virtual ~Trans16x16HT() {} virtual ~Trans16x16HT() {}
virtual void SetUp() { virtual void SetUp() {
fwd_txfm_ = GET_PARAM(0); fwd_txfm_ = GET_PARAM(0);
inv_txfm_ = GET_PARAM(1); inv_txfm_ = GET_PARAM(1);
tx_type_ = GET_PARAM(2); tx_type_ = GET_PARAM(2);
bit_depth_ = GET_PARAM(3); bit_depth_ = GET_PARAM(3);
pitch_ = 16; pitch_ = 16;
fwd_txfm_ref = fht16x16_ref; fwd_txfm_ref = fht16x16_ref;
inv_txfm_ref = iht16x16_ref; inv_txfm_ref = iht16x16_ref;
mask_ = (1 << bit_depth_) - 1; mask_ = (1 << bit_depth_) - 1;
#if CONFIG_VP9_HIGHBITDEPTH #if CONFIG_VP9_HIGHBITDEPTH
switch (bit_depth_) { switch (bit_depth_) {
case VPX_BITS_10: case VPX_BITS_10: inv_txfm_ref = iht16x16_10; break;
inv_txfm_ref = iht16x16_10; case VPX_BITS_12: inv_txfm_ref = iht16x16_12; break;
break; default: inv_txfm_ref = iht16x16_ref; break;
case VPX_BITS_12:
inv_txfm_ref = iht16x16_12;
break;
default:
inv_txfm_ref = iht16x16_ref;
break;
} }
#else #else
inv_txfm_ref = iht16x16_ref; inv_txfm_ref = iht16x16_ref;
@ -735,17 +698,11 @@ class Trans16x16HT
IhtFunc inv_txfm_; IhtFunc inv_txfm_;
}; };
TEST_P(Trans16x16HT, AccuracyCheck) { TEST_P(Trans16x16HT, AccuracyCheck) { RunAccuracyCheck(); }
RunAccuracyCheck();
}
TEST_P(Trans16x16HT, CoeffCheck) { TEST_P(Trans16x16HT, CoeffCheck) { RunCoeffCheck(); }
RunCoeffCheck();
}
TEST_P(Trans16x16HT, MemCheck) { TEST_P(Trans16x16HT, MemCheck) { RunMemCheck(); }
RunMemCheck();
}
TEST_P(Trans16x16HT, QuantCheck) { TEST_P(Trans16x16HT, QuantCheck) {
// The encoder skips any non-DC intra prediction modes, // The encoder skips any non-DC intra prediction modes,
@ -753,9 +710,8 @@ TEST_P(Trans16x16HT, QuantCheck) {
RunQuantCheck(429, 729); RunQuantCheck(429, 729);
} }
class InvTrans16x16DCT class InvTrans16x16DCT : public Trans16x16TestBase,
: public Trans16x16TestBase, public ::testing::TestWithParam<Idct16x16Param> {
public ::testing::TestWithParam<Idct16x16Param> {
public: public:
virtual ~InvTrans16x16DCT() {} virtual ~InvTrans16x16DCT() {}
@ -766,7 +722,7 @@ class InvTrans16x16DCT
bit_depth_ = GET_PARAM(3); bit_depth_ = GET_PARAM(3);
pitch_ = 16; pitch_ = 16;
mask_ = (1 << bit_depth_) - 1; mask_ = (1 << bit_depth_) - 1;
} }
virtual void TearDown() { libvpx_test::ClearSystemState(); } virtual void TearDown() { libvpx_test::ClearSystemState(); }
protected: protected:
@ -784,9 +740,8 @@ TEST_P(InvTrans16x16DCT, CompareReference) {
CompareInvReference(ref_txfm_, thresh_); CompareInvReference(ref_txfm_, thresh_);
} }
class PartialTrans16x16Test class PartialTrans16x16Test : public ::testing::TestWithParam<
: public ::testing::TestWithParam< std::tr1::tuple<FdctFunc, vpx_bit_depth_t> > {
std::tr1::tuple<FdctFunc, vpx_bit_depth_t> > {
public: public:
virtual ~PartialTrans16x16Test() {} virtual ~PartialTrans16x16Test() {}
virtual void SetUp() { virtual void SetUp() {
@ -855,10 +810,10 @@ INSTANTIATE_TEST_CASE_P(
make_tuple(&vpx_highbd_fdct16x16_c, &idct16x16_12, 0, VPX_BITS_12), make_tuple(&vpx_highbd_fdct16x16_c, &idct16x16_12, 0, VPX_BITS_12),
make_tuple(&vpx_fdct16x16_c, &vpx_idct16x16_256_add_c, 0, VPX_BITS_8))); make_tuple(&vpx_fdct16x16_c, &vpx_idct16x16_256_add_c, 0, VPX_BITS_8)));
#else #else
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(C, Trans16x16DCT,
C, Trans16x16DCT, ::testing::Values(make_tuple(&vpx_fdct16x16_c,
::testing::Values( &vpx_idct16x16_256_add_c,
make_tuple(&vpx_fdct16x16_c, &vpx_idct16x16_256_add_c, 0, VPX_BITS_8))); 0, VPX_BITS_8)));
#endif // CONFIG_VP9_HIGHBITDEPTH #endif // CONFIG_VP9_HIGHBITDEPTH
#if CONFIG_VP9_HIGHBITDEPTH #if CONFIG_VP9_HIGHBITDEPTH
@ -898,28 +853,25 @@ INSTANTIATE_TEST_CASE_P(C, PartialTrans16x16Test,
#if HAVE_NEON_ASM && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE #if HAVE_NEON_ASM && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
NEON, Trans16x16DCT, NEON, Trans16x16DCT,
::testing::Values( ::testing::Values(make_tuple(&vpx_fdct16x16_c, &vpx_idct16x16_256_add_neon,
make_tuple(&vpx_fdct16x16_c, 0, VPX_BITS_8)));
&vpx_idct16x16_256_add_neon, 0, VPX_BITS_8)));
#endif #endif
#if HAVE_SSE2 && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE #if HAVE_SSE2 && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
SSE2, Trans16x16DCT, SSE2, Trans16x16DCT,
::testing::Values( ::testing::Values(make_tuple(&vpx_fdct16x16_sse2,
make_tuple(&vpx_fdct16x16_sse2, &vpx_idct16x16_256_add_sse2, 0, VPX_BITS_8)));
&vpx_idct16x16_256_add_sse2, 0, VPX_BITS_8)));
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
SSE2, Trans16x16HT, SSE2, Trans16x16HT,
::testing::Values( ::testing::Values(make_tuple(&vp9_fht16x16_sse2, &vp9_iht16x16_256_add_sse2,
make_tuple(&vp9_fht16x16_sse2, &vp9_iht16x16_256_add_sse2, 0, 0, VPX_BITS_8),
VPX_BITS_8), make_tuple(&vp9_fht16x16_sse2, &vp9_iht16x16_256_add_sse2,
make_tuple(&vp9_fht16x16_sse2, &vp9_iht16x16_256_add_sse2, 1, 1, VPX_BITS_8),
VPX_BITS_8), make_tuple(&vp9_fht16x16_sse2, &vp9_iht16x16_256_add_sse2,
make_tuple(&vp9_fht16x16_sse2, &vp9_iht16x16_256_add_sse2, 2, 2, VPX_BITS_8),
VPX_BITS_8), make_tuple(&vp9_fht16x16_sse2, &vp9_iht16x16_256_add_sse2,
make_tuple(&vp9_fht16x16_sse2, &vp9_iht16x16_256_add_sse2, 3, 3, VPX_BITS_8)));
VPX_BITS_8)));
INSTANTIATE_TEST_CASE_P(SSE2, PartialTrans16x16Test, INSTANTIATE_TEST_CASE_P(SSE2, PartialTrans16x16Test,
::testing::Values(make_tuple(&vpx_fdct16x16_1_sse2, ::testing::Values(make_tuple(&vpx_fdct16x16_1_sse2,
VPX_BITS_8))); VPX_BITS_8)));
@ -929,16 +881,14 @@ INSTANTIATE_TEST_CASE_P(SSE2, PartialTrans16x16Test,
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
SSE2, Trans16x16DCT, SSE2, Trans16x16DCT,
::testing::Values( ::testing::Values(
make_tuple(&vpx_highbd_fdct16x16_sse2, make_tuple(&vpx_highbd_fdct16x16_sse2, &idct16x16_10, 0, VPX_BITS_10),
&idct16x16_10, 0, VPX_BITS_10), make_tuple(&vpx_highbd_fdct16x16_c, &idct16x16_256_add_10_sse2, 0,
make_tuple(&vpx_highbd_fdct16x16_c, VPX_BITS_10),
&idct16x16_256_add_10_sse2, 0, VPX_BITS_10), make_tuple(&vpx_highbd_fdct16x16_sse2, &idct16x16_12, 0, VPX_BITS_12),
make_tuple(&vpx_highbd_fdct16x16_sse2, make_tuple(&vpx_highbd_fdct16x16_c, &idct16x16_256_add_12_sse2, 0,
&idct16x16_12, 0, VPX_BITS_12), VPX_BITS_12),
make_tuple(&vpx_highbd_fdct16x16_c, make_tuple(&vpx_fdct16x16_sse2, &vpx_idct16x16_256_add_c, 0,
&idct16x16_256_add_12_sse2, 0, VPX_BITS_12), VPX_BITS_8)));
make_tuple(&vpx_fdct16x16_sse2,
&vpx_idct16x16_256_add_c, 0, VPX_BITS_8)));
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
SSE2, Trans16x16HT, SSE2, Trans16x16HT,
::testing::Values( ::testing::Values(
@ -951,26 +901,24 @@ INSTANTIATE_TEST_CASE_P(
// that to test both branches. // that to test both branches.
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
SSE2, InvTrans16x16DCT, SSE2, InvTrans16x16DCT,
::testing::Values( ::testing::Values(make_tuple(&idct16x16_10_add_10_c,
make_tuple(&idct16x16_10_add_10_c, &idct16x16_10_add_10_sse2, 3167, VPX_BITS_10),
&idct16x16_10_add_10_sse2, 3167, VPX_BITS_10), make_tuple(&idct16x16_10, &idct16x16_256_add_10_sse2,
make_tuple(&idct16x16_10, 3167, VPX_BITS_10),
&idct16x16_256_add_10_sse2, 3167, VPX_BITS_10), make_tuple(&idct16x16_10_add_12_c,
make_tuple(&idct16x16_10_add_12_c, &idct16x16_10_add_12_sse2, 3167, VPX_BITS_12),
&idct16x16_10_add_12_sse2, 3167, VPX_BITS_12), make_tuple(&idct16x16_12, &idct16x16_256_add_12_sse2,
make_tuple(&idct16x16_12, 3167, VPX_BITS_12)));
&idct16x16_256_add_12_sse2, 3167, VPX_BITS_12)));
INSTANTIATE_TEST_CASE_P(SSE2, PartialTrans16x16Test, INSTANTIATE_TEST_CASE_P(SSE2, PartialTrans16x16Test,
::testing::Values(make_tuple(&vpx_fdct16x16_1_sse2, ::testing::Values(make_tuple(&vpx_fdct16x16_1_sse2,
VPX_BITS_8))); VPX_BITS_8)));
#endif // HAVE_SSE2 && CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE #endif // HAVE_SSE2 && CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
#if HAVE_MSA && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE #if HAVE_MSA && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(MSA, Trans16x16DCT,
MSA, Trans16x16DCT, ::testing::Values(make_tuple(&vpx_fdct16x16_msa,
::testing::Values( &vpx_idct16x16_256_add_msa,
make_tuple(&vpx_fdct16x16_msa, 0, VPX_BITS_8)));
&vpx_idct16x16_256_add_msa, 0, VPX_BITS_8)));
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
MSA, Trans16x16HT, MSA, Trans16x16HT,
::testing::Values( ::testing::Values(

101
test/dct32x32_test.cc
View File

@ -39,8 +39,7 @@ void reference_32x32_dct_1d(const double in[32], double out[32]) {
out[k] = 0.0; out[k] = 0.0;
for (int n = 0; n < 32; n++) for (int n = 0; n < 32; n++)
out[k] += in[n] * cos(kPi * (2 * n + 1) * k / 64.0); out[k] += in[n] * cos(kPi * (2 * n + 1) * k / 64.0);
if (k == 0) if (k == 0) out[k] = out[k] * kInvSqrt2;
out[k] = out[k] * kInvSqrt2;
} }
} }
@ -49,21 +48,17 @@ void reference_32x32_dct_2d(const int16_t input[kNumCoeffs],
// First transform columns // First transform columns
for (int i = 0; i < 32; ++i) { for (int i = 0; i < 32; ++i) {
double temp_in[32], temp_out[32]; double temp_in[32], temp_out[32];
for (int j = 0; j < 32; ++j) for (int j = 0; j < 32; ++j) temp_in[j] = input[j * 32 + i];
temp_in[j] = input[j*32 + i];
reference_32x32_dct_1d(temp_in, temp_out); reference_32x32_dct_1d(temp_in, temp_out);
for (int j = 0; j < 32; ++j) for (int j = 0; j < 32; ++j) output[j * 32 + i] = temp_out[j];
output[j * 32 + i] = temp_out[j];
} }
// Then transform rows // Then transform rows
for (int i = 0; i < 32; ++i) { for (int i = 0; i < 32; ++i) {
double temp_in[32], temp_out[32]; double temp_in[32], temp_out[32];
for (int j = 0; j < 32; ++j) for (int j = 0; j < 32; ++j) temp_in[j] = output[j + i * 32];
temp_in[j] = output[j + i*32];
reference_32x32_dct_1d(temp_in, temp_out); reference_32x32_dct_1d(temp_in, temp_out);
// Scale by some magic number // Scale by some magic number
for (int j = 0; j < 32; ++j) for (int j = 0; j < 32; ++j) output[j + i * 32] = temp_out[j] / 4;
output[j + i * 32] = temp_out[j] / 4;
} }
} }
@ -89,8 +84,8 @@ class Trans32x32Test : public ::testing::TestWithParam<Trans32x32Param> {
virtual void SetUp() { virtual void SetUp() {
fwd_txfm_ = GET_PARAM(0); fwd_txfm_ = GET_PARAM(0);
inv_txfm_ = GET_PARAM(1); inv_txfm_ = GET_PARAM(1);
version_ = GET_PARAM(2); // 0: high precision forward transform version_ = GET_PARAM(2); // 0: high precision forward transform
// 1: low precision version for rd loop // 1: low precision version for rd loop
bit_depth_ = GET_PARAM(3); bit_depth_ = GET_PARAM(3);
mask_ = (1 << bit_depth_) - 1; mask_ = (1 << bit_depth_) - 1;
} }
@ -140,8 +135,8 @@ TEST_P(Trans32x32Test, AccuracyCheck) {
ASM_REGISTER_STATE_CHECK(inv_txfm_(test_temp_block, dst, 32)); ASM_REGISTER_STATE_CHECK(inv_txfm_(test_temp_block, dst, 32));
#if CONFIG_VP9_HIGHBITDEPTH #if CONFIG_VP9_HIGHBITDEPTH
} else { } else {
ASM_REGISTER_STATE_CHECK(inv_txfm_(test_temp_block, ASM_REGISTER_STATE_CHECK(
CONVERT_TO_BYTEPTR(dst16), 32)); inv_txfm_(test_temp_block, CONVERT_TO_BYTEPTR(dst16), 32));
#endif #endif
} }
@ -153,8 +148,7 @@ TEST_P(Trans32x32Test, AccuracyCheck) {
const int32_t diff = dst[j] - src[j]; const int32_t diff = dst[j] - src[j];
#endif #endif
const uint32_t error = diff * diff; const uint32_t error = diff * diff;
if (max_error < error) if (max_error < error) max_error = error;
max_error = error;
total_error += error; total_error += error;
} }
} }
@ -213,11 +207,9 @@ TEST_P(Trans32x32Test, MemCheck) {
input_extreme_block[j] = rnd.Rand8() & 1 ? mask_ : -mask_; input_extreme_block[j] = rnd.Rand8() & 1 ? mask_ : -mask_;
} }
if (i == 0) { if (i == 0) {
for (int j = 0; j < kNumCoeffs; ++j) for (int j = 0; j < kNumCoeffs; ++j) input_extreme_block[j] = mask_;
input_extreme_block[j] = mask_;
} else if (i == 1) { } else if (i == 1) {
for (int j = 0; j < kNumCoeffs; ++j) for (int j = 0; j < kNumCoeffs; ++j) input_extreme_block[j] = -mask_;
input_extreme_block[j] = -mask_;
} }
const int stride = 32; const int stride = 32;
@ -291,9 +283,8 @@ TEST_P(Trans32x32Test, InverseAccuracy) {
const int diff = dst[j] - src[j]; const int diff = dst[j] - src[j];
#endif #endif
const int error = diff * diff; const int error = diff * diff;
EXPECT_GE(1, error) EXPECT_GE(1, error) << "Error: 32x32 IDCT has error " << error
<< "Error: 32x32 IDCT has error " << error << " at index " << j;
<< " at index " << j;
} }
} }
} }
@ -365,18 +356,13 @@ using std::tr1::make_tuple;
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
C, Trans32x32Test, C, Trans32x32Test,
::testing::Values( ::testing::Values(
make_tuple(&vpx_highbd_fdct32x32_c, make_tuple(&vpx_highbd_fdct32x32_c, &idct32x32_10, 0, VPX_BITS_10),
&idct32x32_10, 0, VPX_BITS_10), make_tuple(&vpx_highbd_fdct32x32_rd_c, &idct32x32_10, 1, VPX_BITS_10),
make_tuple(&vpx_highbd_fdct32x32_rd_c, make_tuple(&vpx_highbd_fdct32x32_c, &idct32x32_12, 0, VPX_BITS_12),
&idct32x32_10, 1, VPX_BITS_10), make_tuple(&vpx_highbd_fdct32x32_rd_c, &idct32x32_12, 1, VPX_BITS_12),
make_tuple(&vpx_highbd_fdct32x32_c, make_tuple(&vpx_fdct32x32_c, &vpx_idct32x32_1024_add_c, 0, VPX_BITS_8),
&idct32x32_12, 0, VPX_BITS_12), make_tuple(&vpx_fdct32x32_rd_c, &vpx_idct32x32_1024_add_c, 1,
make_tuple(&vpx_highbd_fdct32x32_rd_c, VPX_BITS_8)));
&idct32x32_12, 1, VPX_BITS_12),
make_tuple(&vpx_fdct32x32_c,
&vpx_idct32x32_1024_add_c, 0, VPX_BITS_8),
make_tuple(&vpx_fdct32x32_rd_c,
&vpx_idct32x32_1024_add_c, 1, VPX_BITS_8)));
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
C, PartialTrans32x32Test, C, PartialTrans32x32Test,
::testing::Values(make_tuple(&vpx_highbd_fdct32x32_1_c, VPX_BITS_8), ::testing::Values(make_tuple(&vpx_highbd_fdct32x32_1_c, VPX_BITS_8),
@ -385,11 +371,10 @@ INSTANTIATE_TEST_CASE_P(
#else #else
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
C, Trans32x32Test, C, Trans32x32Test,
::testing::Values( ::testing::Values(make_tuple(&vpx_fdct32x32_c, &vpx_idct32x32_1024_add_c, 0,
make_tuple(&vpx_fdct32x32_c, VPX_BITS_8),
&vpx_idct32x32_1024_add_c, 0, VPX_BITS_8), make_tuple(&vpx_fdct32x32_rd_c, &vpx_idct32x32_1024_add_c,
make_tuple(&vpx_fdct32x32_rd_c, 1, VPX_BITS_8)));
&vpx_idct32x32_1024_add_c, 1, VPX_BITS_8)));
INSTANTIATE_TEST_CASE_P(C, PartialTrans32x32Test, INSTANTIATE_TEST_CASE_P(C, PartialTrans32x32Test,
::testing::Values(make_tuple(&vpx_fdct32x32_1_c, ::testing::Values(make_tuple(&vpx_fdct32x32_1_c,
VPX_BITS_8))); VPX_BITS_8)));
@ -398,21 +383,19 @@ INSTANTIATE_TEST_CASE_P(C, PartialTrans32x32Test,
#if HAVE_NEON && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE #if HAVE_NEON && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
NEON, Trans32x32Test, NEON, Trans32x32Test,
::testing::Values( ::testing::Values(make_tuple(&vpx_fdct32x32_c, &vpx_idct32x32_1024_add_neon,
make_tuple(&vpx_fdct32x32_c, 0, VPX_BITS_8),
&vpx_idct32x32_1024_add_neon, 0, VPX_BITS_8), make_tuple(&vpx_fdct32x32_rd_c,
make_tuple(&vpx_fdct32x32_rd_c, &vpx_idct32x32_1024_add_neon, 1, VPX_BITS_8)));
&vpx_idct32x32_1024_add_neon, 1, VPX_BITS_8)));
#endif // HAVE_NEON && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE #endif // HAVE_NEON && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
#if HAVE_SSE2 && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE #if HAVE_SSE2 && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
SSE2, Trans32x32Test, SSE2, Trans32x32Test,
::testing::Values( ::testing::Values(make_tuple(&vpx_fdct32x32_sse2,
make_tuple(&vpx_fdct32x32_sse2, &vpx_idct32x32_1024_add_sse2, 0, VPX_BITS_8),
&vpx_idct32x32_1024_add_sse2, 0, VPX_BITS_8), make_tuple(&vpx_fdct32x32_rd_sse2,
make_tuple(&vpx_fdct32x32_rd_sse2, &vpx_idct32x32_1024_add_sse2, 1, VPX_BITS_8)));
&vpx_idct32x32_1024_add_sse2, 1, VPX_BITS_8)));
INSTANTIATE_TEST_CASE_P(SSE2, PartialTrans32x32Test, INSTANTIATE_TEST_CASE_P(SSE2, PartialTrans32x32Test,
::testing::Values(make_tuple(&vpx_fdct32x32_1_sse2, ::testing::Values(make_tuple(&vpx_fdct32x32_1_sse2,
VPX_BITS_8))); VPX_BITS_8)));
@ -440,21 +423,19 @@ INSTANTIATE_TEST_CASE_P(SSE2, PartialTrans32x32Test,
#if HAVE_AVX2 && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE #if HAVE_AVX2 && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
AVX2, Trans32x32Test, AVX2, Trans32x32Test,
::testing::Values( ::testing::Values(make_tuple(&vpx_fdct32x32_avx2,
make_tuple(&vpx_fdct32x32_avx2, &vpx_idct32x32_1024_add_sse2, 0, VPX_BITS_8),
&vpx_idct32x32_1024_add_sse2, 0, VPX_BITS_8), make_tuple(&vpx_fdct32x32_rd_avx2,
make_tuple(&vpx_fdct32x32_rd_avx2, &vpx_idct32x32_1024_add_sse2, 1, VPX_BITS_8)));
&vpx_idct32x32_1024_add_sse2, 1, VPX_BITS_8)));
#endif // HAVE_AVX2 && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE #endif // HAVE_AVX2 && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
#if HAVE_MSA && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE #if HAVE_MSA && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
MSA, Trans32x32Test, MSA, Trans32x32Test,
::testing::Values( ::testing::Values(make_tuple(&vpx_fdct32x32_msa,
make_tuple(&vpx_fdct32x32_msa, &vpx_idct32x32_1024_add_msa, 0, VPX_BITS_8),
&vpx_idct32x32_1024_add_msa, 0, VPX_BITS_8), make_tuple(&vpx_fdct32x32_rd_msa,
make_tuple(&vpx_fdct32x32_rd_msa, &vpx_idct32x32_1024_add_msa, 1, VPX_BITS_8)));
&vpx_idct32x32_1024_add_msa, 1, VPX_BITS_8)));
INSTANTIATE_TEST_CASE_P(MSA, PartialTrans32x32Test, INSTANTIATE_TEST_CASE_P(MSA, PartialTrans32x32Test,
::testing::Values(make_tuple(&vpx_fdct32x32_1_msa, ::testing::Values(make_tuple(&vpx_fdct32x32_1_msa,
VPX_BITS_8))); VPX_BITS_8)));

31
test/decode_api_test.cc
View File

@ -28,7 +28,7 @@ TEST(DecodeAPI, InvalidParams) {
&vpx_codec_vp9_dx_algo, &vpx_codec_vp9_dx_algo,
#endif #endif
}; };
uint8_t buf[1] = {0}; uint8_t buf[1] = { 0 };
vpx_codec_ctx_t dec; vpx_codec_ctx_t dec;
EXPECT_EQ(VPX_CODEC_INVALID_PARAM, vpx_codec_dec_init(NULL, NULL, NULL, 0)); EXPECT_EQ(VPX_CODEC_INVALID_PARAM, vpx_codec_dec_init(NULL, NULL, NULL, 0));
@ -51,8 +51,7 @@ TEST(DecodeAPI, InvalidParams) {
vpx_codec_decode(&dec, buf, NELEMENTS(buf), NULL, 0)); vpx_codec_decode(&dec, buf, NELEMENTS(buf), NULL, 0));
EXPECT_EQ(VPX_CODEC_INVALID_PARAM, EXPECT_EQ(VPX_CODEC_INVALID_PARAM,
vpx_codec_decode(&dec, NULL, NELEMENTS(buf), NULL, 0)); vpx_codec_decode(&dec, NULL, NELEMENTS(buf), NULL, 0));
EXPECT_EQ(VPX_CODEC_INVALID_PARAM, EXPECT_EQ(VPX_CODEC_INVALID_PARAM, vpx_codec_decode(&dec, buf, 0, NULL, 0));
vpx_codec_decode(&dec, buf, 0, NULL, 0));
EXPECT_EQ(VPX_CODEC_OK, vpx_codec_destroy(&dec)); EXPECT_EQ(VPX_CODEC_OK, vpx_codec_destroy(&dec));
} }
@ -77,12 +76,9 @@ TEST(DecodeAPI, OptionalParams) {
// Test VP9 codec controls after a decode error to ensure the code doesn't // Test VP9 codec controls after a decode error to ensure the code doesn't
// misbehave. // misbehave.
void TestVp9Controls(vpx_codec_ctx_t *dec) { void TestVp9Controls(vpx_codec_ctx_t *dec) {
static const int kControls[] = { static const int kControls[] = { VP8D_GET_LAST_REF_UPDATES,
VP8D_GET_LAST_REF_UPDATES, VP8D_GET_FRAME_CORRUPTED,
VP8D_GET_FRAME_CORRUPTED, VP9D_GET_DISPLAY_SIZE, VP9D_GET_FRAME_SIZE };
VP9D_GET_DISPLAY_SIZE,
VP9D_GET_FRAME_SIZE
};
int val[2]; int val[2];
for (int i = 0; i < NELEMENTS(kControls); ++i) { for (int i = 0; i < NELEMENTS(kControls); ++i) {
@ -91,9 +87,7 @@ void TestVp9Controls(vpx_codec_ctx_t *dec) {
case VP8D_GET_FRAME_CORRUPTED: case VP8D_GET_FRAME_CORRUPTED:
EXPECT_EQ(VPX_CODEC_ERROR, res) << kControls[i]; EXPECT_EQ(VPX_CODEC_ERROR, res) << kControls[i];
break; break;
default: default: EXPECT_EQ(VPX_CODEC_OK, res) << kControls[i]; break;
EXPECT_EQ(VPX_CODEC_OK, res) << kControls[i];
break;
} }
EXPECT_EQ(VPX_CODEC_INVALID_PARAM, EXPECT_EQ(VPX_CODEC_INVALID_PARAM,
vpx_codec_control_(dec, kControls[i], NULL)); vpx_codec_control_(dec, kControls[i], NULL));
@ -150,10 +144,9 @@ TEST(DecodeAPI, Vp9PeekSI) {
// size 10, this should return VPX_CODEC_UNSUP_BITSTREAM and after that it // size 10, this should return VPX_CODEC_UNSUP_BITSTREAM and after that it
// should return VPX_CODEC_CORRUPT_FRAME. // should return VPX_CODEC_CORRUPT_FRAME.
const uint8_t data[32] = { const uint8_t data[32] = {
0x85, 0xa4, 0xc1, 0xa1, 0x38, 0x81, 0xa3, 0x49, 0x85, 0xa4, 0xc1, 0xa1, 0x38, 0x81, 0xa3, 0x49, 0x83, 0xff, 0xff,
0x83, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
}; };
for (uint32_t data_sz = 1; data_sz <= 32; ++data_sz) { for (uint32_t data_sz = 1; data_sz <= 32; ++data_sz) {
@ -162,9 +155,9 @@ TEST(DecodeAPI, Vp9PeekSI) {
if (data_sz >= 8) { if (data_sz >= 8) {
vpx_codec_ctx_t dec; vpx_codec_ctx_t dec;
EXPECT_EQ(VPX_CODEC_OK, vpx_codec_dec_init(&dec, codec, NULL, 0)); EXPECT_EQ(VPX_CODEC_OK, vpx_codec_dec_init(&dec, codec, NULL, 0));
EXPECT_EQ((data_sz < 10) ? EXPECT_EQ(
VPX_CODEC_UNSUP_BITSTREAM : VPX_CODEC_CORRUPT_FRAME, (data_sz < 10) ? VPX_CODEC_UNSUP_BITSTREAM : VPX_CODEC_CORRUPT_FRAME,
vpx_codec_decode(&dec, data, data_sz, NULL, 0)); vpx_codec_decode(&dec, data, data_sz, NULL, 0));
vpx_codec_iter_t iter = NULL; vpx_codec_iter_t iter = NULL;
EXPECT_EQ(NULL, vpx_codec_get_frame(&dec, &iter)); EXPECT_EQ(NULL, vpx_codec_get_frame(&dec, &iter));
EXPECT_EQ(VPX_CODEC_OK, vpx_codec_destroy(&dec)); EXPECT_EQ(VPX_CODEC_OK, vpx_codec_destroy(&dec));

39
test/decode_perf_test.cc
View File

@ -70,8 +70,7 @@ const DecodePerfParam kVP9DecodePerfVectors[] = {
power/temp/min max frame decode times/etc power/temp/min max frame decode times/etc
*/ */
class DecodePerfTest : public ::testing::TestWithParam<DecodePerfParam> { class DecodePerfTest : public ::testing::TestWithParam<DecodePerfParam> {};
};
TEST_P(DecodePerfTest, PerfTest) { TEST_P(DecodePerfTest, PerfTest) {
const char *const video_name = GET_PARAM(VIDEO_NAME); const char *const video_name = GET_PARAM(VIDEO_NAME);
@ -92,8 +91,7 @@ TEST_P(DecodePerfTest, PerfTest) {
} }
vpx_usec_timer_mark(&t); vpx_usec_timer_mark(&t);
const double elapsed_secs = double(vpx_usec_timer_elapsed(&t)) const double elapsed_secs = double(vpx_usec_timer_elapsed(&t)) / kUsecsInSec;
/ kUsecsInSec;
const unsigned frames = video.frame_number(); const unsigned frames = video.frame_number();
const double fps = double(frames) / elapsed_secs; const double fps = double(frames) / elapsed_secs;
@ -111,17 +109,13 @@ TEST_P(DecodePerfTest, PerfTest) {
INSTANTIATE_TEST_CASE_P(VP9, DecodePerfTest, INSTANTIATE_TEST_CASE_P(VP9, DecodePerfTest,
::testing::ValuesIn(kVP9DecodePerfVectors)); ::testing::ValuesIn(kVP9DecodePerfVectors));
class VP9NewEncodeDecodePerfTest : class VP9NewEncodeDecodePerfTest
public ::libvpx_test::EncoderTest, : public ::libvpx_test::EncoderTest,
public ::libvpx_test::CodecTestWithParam<libvpx_test::TestMode> { public ::libvpx_test::CodecTestWithParam<libvpx_test::TestMode> {
protected: protected:
VP9NewEncodeDecodePerfTest() VP9NewEncodeDecodePerfTest()
: EncoderTest(GET_PARAM(0)), : EncoderTest(GET_PARAM(0)), encoding_mode_(GET_PARAM(1)), speed_(0),
encoding_mode_(GET_PARAM(1)), outfile_(0), out_frames_(0) {}
speed_(0),
outfile_(0),
out_frames_(0) {
}
virtual ~VP9NewEncodeDecodePerfTest() {} virtual ~VP9NewEncodeDecodePerfTest() {}
@ -182,9 +176,7 @@ class VP9NewEncodeDecodePerfTest :
virtual bool DoDecode() { return false; } virtual bool DoDecode() { return false; }
void set_speed(unsigned int speed) { void set_speed(unsigned int speed) { speed_ = speed; }
speed_ = speed;
}
private: private:
libvpx_test::TestMode encoding_mode_; libvpx_test::TestMode encoding_mode_;
@ -196,10 +188,7 @@ class VP9NewEncodeDecodePerfTest :
struct EncodePerfTestVideo { struct EncodePerfTestVideo {
EncodePerfTestVideo(const char *name_, uint32_t width_, uint32_t height_, EncodePerfTestVideo(const char *name_, uint32_t width_, uint32_t height_,
uint32_t bitrate_, int frames_) uint32_t bitrate_, int frames_)
: name(name_), : name(name_), width(width_), height(height_), bitrate(bitrate_),
width(width_),
height(height_),
bitrate(bitrate_),
frames(frames_) {} frames(frames_) {}
const char *name; const char *name;
uint32_t width; uint32_t width;
@ -225,10 +214,8 @@ TEST_P(VP9NewEncodeDecodePerfTest, PerfTest) {
const char *video_name = kVP9EncodePerfTestVectors[i].name; const char *video_name = kVP9EncodePerfTestVectors[i].name;
libvpx_test::I420VideoSource video( libvpx_test::I420VideoSource video(
video_name, video_name, kVP9EncodePerfTestVectors[i].width,
kVP9EncodePerfTestVectors[i].width, kVP9EncodePerfTestVectors[i].height, timebase.den, timebase.num, 0,
kVP9EncodePerfTestVectors[i].height,
timebase.den, timebase.num, 0,
kVP9EncodePerfTestVectors[i].frames); kVP9EncodePerfTestVectors[i].frames);
set_speed(2); set_speed(2);
@ -268,6 +255,6 @@ TEST_P(VP9NewEncodeDecodePerfTest, PerfTest) {
printf("}\n"); printf("}\n");
} }
VP9_INSTANTIATE_TEST_CASE( VP9_INSTANTIATE_TEST_CASE(VP9NewEncodeDecodePerfTest,
VP9NewEncodeDecodePerfTest, ::testing::Values(::libvpx_test::kTwoPassGood)); ::testing::Values(::libvpx_test::kTwoPassGood));
} // namespace } // namespace

28
test/decode_test_driver.cc
View File

@ -21,9 +21,8 @@ const char kVP8Name[] = "WebM Project VP8";
vpx_codec_err_t Decoder::PeekStream(const uint8_t *cxdata, size_t size, vpx_codec_err_t Decoder::PeekStream(const uint8_t *cxdata, size_t size,
vpx_codec_stream_info_t *stream_info) { vpx_codec_stream_info_t *stream_info) {
return vpx_codec_peek_stream_info(CodecInterface(), return vpx_codec_peek_stream_info(
cxdata, static_cast<unsigned int>(size), CodecInterface(), cxdata, static_cast<unsigned int>(size), stream_info);
stream_info);
} }
vpx_codec_err_t Decoder::DecodeFrame(const uint8_t *cxdata, size_t size) { vpx_codec_err_t Decoder::DecodeFrame(const uint8_t *cxdata, size_t size) {
@ -35,9 +34,8 @@ vpx_codec_err_t Decoder::DecodeFrame(const uint8_t *cxdata, size_t size,
vpx_codec_err_t res_dec; vpx_codec_err_t res_dec;
InitOnce(); InitOnce();
API_REGISTER_STATE_CHECK( API_REGISTER_STATE_CHECK(
res_dec = vpx_codec_decode(&decoder_, res_dec = vpx_codec_decode(
cxdata, static_cast<unsigned int>(size), &decoder_, cxdata, static_cast<unsigned int>(size), user_priv, 0));
user_priv, 0));
return res_dec; return res_dec;
} }
@ -67,7 +65,7 @@ void DecoderTest::HandlePeekResult(Decoder *const decoder,
void DecoderTest::RunLoop(CompressedVideoSource *video, void DecoderTest::RunLoop(CompressedVideoSource *video,
const vpx_codec_dec_cfg_t &dec_cfg) { const vpx_codec_dec_cfg_t &dec_cfg) {
Decoder* const decoder = codec_->CreateDecoder(dec_cfg, flags_, 0); Decoder *const decoder = codec_->CreateDecoder(dec_cfg, flags_, 0);
ASSERT_TRUE(decoder != NULL); ASSERT_TRUE(decoder != NULL);
bool end_of_file = false; bool end_of_file = false;
@ -80,16 +78,14 @@ void DecoderTest::RunLoop(CompressedVideoSource *video,
stream_info.sz = sizeof(stream_info); stream_info.sz = sizeof(stream_info);
if (video->cxdata() != NULL) { if (video->cxdata() != NULL) {
const vpx_codec_err_t res_peek = decoder->PeekStream(video->cxdata(), const vpx_codec_err_t res_peek = decoder->PeekStream(
video->frame_size(), video->cxdata(), video->frame_size(), &stream_info);
&stream_info);
HandlePeekResult(decoder, video, res_peek); HandlePeekResult(decoder, video, res_peek);
ASSERT_FALSE(::testing::Test::HasFailure()); ASSERT_FALSE(::testing::Test::HasFailure());
vpx_codec_err_t res_dec = decoder->DecodeFrame(video->cxdata(), vpx_codec_err_t res_dec =
video->frame_size()); decoder->DecodeFrame(video->cxdata(), video->frame_size());
if (!HandleDecodeResult(res_dec, *video, decoder)) if (!HandleDecodeResult(res_dec, *video, decoder)) break;
break;
} else { } else {
// Signal end of the file to the decoder. // Signal end of the file to the decoder.
const vpx_codec_err_t res_dec = decoder->DecodeFrame(NULL, 0); const vpx_codec_err_t res_dec = decoder->DecodeFrame(NULL, 0);
@ -116,8 +112,6 @@ void DecoderTest::set_cfg(const vpx_codec_dec_cfg_t &dec_cfg) {
memcpy(&cfg_, &dec_cfg, sizeof(cfg_)); memcpy(&cfg_, &dec_cfg, sizeof(cfg_));
} }
void DecoderTest::set_flags(const vpx_codec_flags_t flags) { void DecoderTest::set_flags(const vpx_codec_flags_t flags) { flags_ = flags; }
flags_ = flags;
}
} // namespace libvpx_test } // namespace libvpx_test

72
test/decode_test_driver.h
View File

@ -26,13 +26,11 @@ class DxDataIterator {
explicit DxDataIterator(vpx_codec_ctx_t *decoder) explicit DxDataIterator(vpx_codec_ctx_t *decoder)
: decoder_(decoder), iter_(NULL) {} : decoder_(decoder), iter_(NULL) {}
const vpx_image_t *Next() { const vpx_image_t *Next() { return vpx_codec_get_frame(decoder_, &iter_); }
return vpx_codec_get_frame(decoder_, &iter_);
}
private: private:
vpx_codec_ctx_t *decoder_; vpx_codec_ctx_t *decoder_;
vpx_codec_iter_t iter_; vpx_codec_iter_t iter_;
}; };
// Provides a simplified interface to manage one video decoding. // Provides a simplified interface to manage one video decoding.
@ -47,13 +45,14 @@ class Decoder {
Decoder(vpx_codec_dec_cfg_t cfg, const vpx_codec_flags_t flag, Decoder(vpx_codec_dec_cfg_t cfg, const vpx_codec_flags_t flag,
unsigned long deadline) // NOLINT unsigned long deadline) // NOLINT
: cfg_(cfg), flags_(flag), deadline_(deadline), init_done_(false) { : cfg_(cfg),
flags_(flag),
deadline_(deadline),
init_done_(false) {
memset(&decoder_, 0, sizeof(decoder_)); memset(&decoder_, 0, sizeof(decoder_));
} }
virtual ~Decoder() { virtual ~Decoder() { vpx_codec_destroy(&decoder_); }
vpx_codec_destroy(&decoder_);
}
vpx_codec_err_t PeekStream(const uint8_t *cxdata, size_t size, vpx_codec_err_t PeekStream(const uint8_t *cxdata, size_t size,
vpx_codec_stream_info_t *stream_info); vpx_codec_stream_info_t *stream_info);
@ -63,17 +62,11 @@ class Decoder {
vpx_codec_err_t DecodeFrame(const uint8_t *cxdata, size_t size, vpx_codec_err_t DecodeFrame(const uint8_t *cxdata, size_t size,
void *user_priv); void *user_priv);
DxDataIterator GetDxData() { DxDataIterator GetDxData() { return DxDataIterator(&decoder_); }
return DxDataIterator(&decoder_);
}
void set_deadline(unsigned long deadline) { void set_deadline(unsigned long deadline) { deadline_ = deadline; }
deadline_ = deadline;
}
void Control(int ctrl_id, int arg) { void Control(int ctrl_id, int arg) { Control(ctrl_id, arg, VPX_CODEC_OK); }
Control(ctrl_id, arg, VPX_CODEC_OK);
}
void Control(int ctrl_id, const void *arg) { void Control(int ctrl_id, const void *arg) {
InitOnce(); InitOnce();
@ -87,7 +80,7 @@ class Decoder {
ASSERT_EQ(expected_value, res) << DecodeError(); ASSERT_EQ(expected_value, res) << DecodeError();
} }
const char* DecodeError() { const char *DecodeError() {
const char *detail = vpx_codec_error_detail(&decoder_); const char *detail = vpx_codec_error_detail(&decoder_);
return detail ? detail : vpx_codec_error(&decoder_); return detail ? detail : vpx_codec_error(&decoder_);
} }
@ -97,38 +90,35 @@ class Decoder {
vpx_get_frame_buffer_cb_fn_t cb_get, vpx_get_frame_buffer_cb_fn_t cb_get,
vpx_release_frame_buffer_cb_fn_t cb_release, void *user_priv) { vpx_release_frame_buffer_cb_fn_t cb_release, void *user_priv) {
InitOnce(); InitOnce();
return vpx_codec_set_frame_buffer_functions( return vpx_codec_set_frame_buffer_functions(&decoder_, cb_get, cb_release,
&decoder_, cb_get, cb_release, user_priv); user_priv);
} }
const char* GetDecoderName() const { const char *GetDecoderName() const {
return vpx_codec_iface_name(CodecInterface()); return vpx_codec_iface_name(CodecInterface());
} }
bool IsVP8() const; bool IsVP8() const;
vpx_codec_ctx_t * GetDecoder() { vpx_codec_ctx_t *GetDecoder() { return &decoder_; }
return &decoder_;
}
protected: protected:
virtual vpx_codec_iface_t* CodecInterface() const = 0; virtual vpx_codec_iface_t *CodecInterface() const = 0;
void InitOnce() { void InitOnce() {
if (!init_done_) { if (!init_done_) {
const vpx_codec_err_t res = vpx_codec_dec_init(&decoder_, const vpx_codec_err_t res =
CodecInterface(), vpx_codec_dec_init(&decoder_, CodecInterface(), &cfg_, flags_);
&cfg_, flags_);
ASSERT_EQ(VPX_CODEC_OK, res) << DecodeError(); ASSERT_EQ(VPX_CODEC_OK, res) << DecodeError();
init_done_ = true; init_done_ = true;
} }
} }
vpx_codec_ctx_t decoder_; vpx_codec_ctx_t decoder_;
vpx_codec_dec_cfg_t cfg_; vpx_codec_dec_cfg_t cfg_;
vpx_codec_flags_t flags_; vpx_codec_flags_t flags_;
unsigned int deadline_; unsigned int deadline_;
bool init_done_; bool init_done_;
}; };
// Common test functionality for all Decoder tests. // Common test functionality for all Decoder tests.
@ -143,37 +133,35 @@ class DecoderTest {
virtual void set_flags(const vpx_codec_flags_t flags); virtual void set_flags(const vpx_codec_flags_t flags);
// Hook to be called before decompressing every frame. // Hook to be called before decompressing every frame.
virtual void PreDecodeFrameHook(const CompressedVideoSource& /*video*/, virtual void PreDecodeFrameHook(const CompressedVideoSource & /*video*/,
Decoder* /*decoder*/) {} Decoder * /*decoder*/) {}
// Hook to be called to handle decode result. Return true to continue. // Hook to be called to handle decode result. Return true to continue.
virtual bool HandleDecodeResult(const vpx_codec_err_t res_dec, virtual bool HandleDecodeResult(const vpx_codec_err_t res_dec,
const CompressedVideoSource& /*video*/, const CompressedVideoSource & /*video*/,
Decoder *decoder) { Decoder *decoder) {
EXPECT_EQ(VPX_CODEC_OK, res_dec) << decoder->DecodeError(); EXPECT_EQ(VPX_CODEC_OK, res_dec) << decoder->DecodeError();
return VPX_CODEC_OK == res_dec; return VPX_CODEC_OK == res_dec;
} }
// Hook to be called on every decompressed frame. // Hook to be called on every decompressed frame.
virtual void DecompressedFrameHook(const vpx_image_t& /*img*/, virtual void DecompressedFrameHook(const vpx_image_t & /*img*/,
const unsigned int /*frame_number*/) {} const unsigned int /*frame_number*/) {}
// Hook to be called on peek result // Hook to be called on peek result
virtual void HandlePeekResult(Decoder* const decoder, virtual void HandlePeekResult(Decoder *const decoder,
CompressedVideoSource *video, CompressedVideoSource *video,
const vpx_codec_err_t res_peek); const vpx_codec_err_t res_peek);
protected: protected:
explicit DecoderTest(const CodecFactory *codec) explicit DecoderTest(const CodecFactory *codec)
: codec_(codec), : codec_(codec), cfg_(), flags_(0) {}
cfg_(),
flags_(0) {}
virtual ~DecoderTest() {} virtual ~DecoderTest() {}
const CodecFactory *codec_; const CodecFactory *codec_;
vpx_codec_dec_cfg_t cfg_; vpx_codec_dec_cfg_t cfg_;
vpx_codec_flags_t flags_; vpx_codec_flags_t flags_;
}; };
} // namespace libvpx_test } // namespace libvpx_test

2
test/encode_api_test.cc
View File

@ -27,7 +27,7 @@ TEST(EncodeAPI, InvalidParams) {
&vpx_codec_vp9_cx_algo, &vpx_codec_vp9_cx_algo,
#endif #endif
}; };
uint8_t buf[1] = {0}; uint8_t buf[1] = { 0 };
vpx_image_t img; vpx_image_t img;
vpx_codec_ctx_t enc; vpx_codec_ctx_t enc;
vpx_codec_enc_cfg_t cfg; vpx_codec_enc_cfg_t cfg;

41
test/encode_perf_test.cc
View File

@ -26,10 +26,7 @@ const double kUsecsInSec = 1000000.0;
struct EncodePerfTestVideo { struct EncodePerfTestVideo {
EncodePerfTestVideo(const char *name_, uint32_t width_, uint32_t height_, EncodePerfTestVideo(const char *name_, uint32_t width_, uint32_t height_,
uint32_t bitrate_, int frames_) uint32_t bitrate_, int frames_)
: name(name_), : name(name_), width(width_), height(height_), bitrate(bitrate_),
width(width_),
height(height_),
bitrate(bitrate_),
frames(frames_) {} frames(frames_) {}
const char *name; const char *name;
uint32_t width; uint32_t width;
@ -45,8 +42,8 @@ const EncodePerfTestVideo kVP9EncodePerfTestVectors[] = {
EncodePerfTestVideo("macmarcostationary_640_480_30.yuv", 640, 480, 200, 718), EncodePerfTestVideo("macmarcostationary_640_480_30.yuv", 640, 480, 200, 718),
EncodePerfTestVideo("niklas_640_480_30.yuv", 640, 480, 200, 471), EncodePerfTestVideo("niklas_640_480_30.yuv", 640, 480, 200, 471),
EncodePerfTestVideo("tacomanarrows_640_480_30.yuv", 640, 480, 200, 300), EncodePerfTestVideo("tacomanarrows_640_480_30.yuv", 640, 480, 200, 300),
EncodePerfTestVideo("tacomasmallcameramovement_640_480_30.yuv", EncodePerfTestVideo("tacomasmallcameramovement_640_480_30.yuv", 640, 480, 200,
640, 480, 200, 300), 300),
EncodePerfTestVideo("thaloundeskmtg_640_480_30.yuv", 640, 480, 200, 300), EncodePerfTestVideo("thaloundeskmtg_640_480_30.yuv", 640, 480, 200, 300),
EncodePerfTestVideo("niklas_1280_720_30.yuv", 1280, 720, 600, 470), EncodePerfTestVideo("niklas_1280_720_30.yuv", 1280, 720, 600, 470),
}; };
@ -61,12 +58,8 @@ class VP9EncodePerfTest
public ::libvpx_test::CodecTestWithParam<libvpx_test::TestMode> { public ::libvpx_test::CodecTestWithParam<libvpx_test::TestMode> {
protected: protected:
VP9EncodePerfTest() VP9EncodePerfTest()
: EncoderTest(GET_PARAM(0)), : EncoderTest(GET_PARAM(0)), min_psnr_(kMaxPsnr), nframes_(0),
min_psnr_(kMaxPsnr), encoding_mode_(GET_PARAM(1)), speed_(0), threads_(1) {}
nframes_(0),
encoding_mode_(GET_PARAM(1)),
speed_(0),
threads_(1) {}
virtual ~VP9EncodePerfTest() {} virtual ~VP9EncodePerfTest() {}
@ -107,24 +100,18 @@ class VP9EncodePerfTest
virtual void PSNRPktHook(const vpx_codec_cx_pkt_t *pkt) { virtual void PSNRPktHook(const vpx_codec_cx_pkt_t *pkt) {
if (pkt->data.psnr.psnr[0] < min_psnr_) { if (pkt->data.psnr.psnr[0] < min_psnr_) {
min_psnr_= pkt->data.psnr.psnr[0]; min_psnr_ = pkt->data.psnr.psnr[0];
} }
} }
// for performance reasons don't decode // for performance reasons don't decode
virtual bool DoDecode() { return 0; } virtual bool DoDecode() { return 0; }
double min_psnr() const { double min_psnr() const { return min_psnr_; }
return min_psnr_;
}
void set_speed(unsigned int speed) { void set_speed(unsigned int speed) { speed_ = speed; }
speed_ = speed;
}
void set_threads(unsigned int threads) { void set_threads(unsigned int threads) { threads_ = threads; }
threads_ = threads;
}
private: private:
double min_psnr_; double min_psnr_;
@ -157,10 +144,8 @@ TEST_P(VP9EncodePerfTest, PerfTest) {
const unsigned frames = kVP9EncodePerfTestVectors[i].frames; const unsigned frames = kVP9EncodePerfTestVectors[i].frames;
const char *video_name = kVP9EncodePerfTestVectors[i].name; const char *video_name = kVP9EncodePerfTestVectors[i].name;
libvpx_test::I420VideoSource video( libvpx_test::I420VideoSource video(
video_name, video_name, kVP9EncodePerfTestVectors[i].width,
kVP9EncodePerfTestVectors[i].width, kVP9EncodePerfTestVectors[i].height, timebase.den, timebase.num, 0,
kVP9EncodePerfTestVectors[i].height,
timebase.den, timebase.num, 0,
kVP9EncodePerfTestVectors[i].frames); kVP9EncodePerfTestVectors[i].frames);
set_speed(kEncodePerfTestSpeeds[j]); set_speed(kEncodePerfTestSpeeds[j]);
@ -197,6 +182,6 @@ TEST_P(VP9EncodePerfTest, PerfTest) {
} }
} }
VP9_INSTANTIATE_TEST_CASE( VP9_INSTANTIATE_TEST_CASE(VP9EncodePerfTest,
VP9EncodePerfTest, ::testing::Values(::libvpx_test::kRealTime)); ::testing::Values(::libvpx_test::kRealTime));
} // namespace } // namespace

83
test/encode_test_driver.cc
View File

@ -30,8 +30,7 @@ void Encoder::InitEncoder(VideoSource *video) {
cfg_.g_timebase = video->timebase(); cfg_.g_timebase = video->timebase();
cfg_.rc_twopass_stats_in = stats_->buf(); cfg_.rc_twopass_stats_in = stats_->buf();
res = vpx_codec_enc_init(&encoder_, CodecInterface(), &cfg_, res = vpx_codec_enc_init(&encoder_, CodecInterface(), &cfg_, init_flags_);
init_flags_);
ASSERT_EQ(VPX_CODEC_OK, res) << EncoderError(); ASSERT_EQ(VPX_CODEC_OK, res) << EncoderError();
#if CONFIG_VP9_ENCODER #if CONFIG_VP9_ENCODER
@ -62,8 +61,7 @@ void Encoder::EncodeFrame(VideoSource *video, const unsigned long frame_flags) {
CxDataIterator iter = GetCxData(); CxDataIterator iter = GetCxData();
while (const vpx_codec_cx_pkt_t *pkt = iter.Next()) { while (const vpx_codec_cx_pkt_t *pkt = iter.Next()) {
if (pkt->kind != VPX_CODEC_STATS_PKT) if (pkt->kind != VPX_CODEC_STATS_PKT) continue;
continue;
stats_->Append(*pkt); stats_->Append(*pkt);
} }
@ -83,15 +81,15 @@ void Encoder::EncodeFrameInternal(const VideoSource &video,
} }
// Encode the frame // Encode the frame
API_REGISTER_STATE_CHECK( API_REGISTER_STATE_CHECK(res = vpx_codec_encode(&encoder_, img, video.pts(),
res = vpx_codec_encode(&encoder_, img, video.pts(), video.duration(), video.duration(), frame_flags,
frame_flags, deadline_)); deadline_));
ASSERT_EQ(VPX_CODEC_OK, res) << EncoderError(); ASSERT_EQ(VPX_CODEC_OK, res) << EncoderError();
} }
void Encoder::Flush() { void Encoder::Flush() {
const vpx_codec_err_t res = vpx_codec_encode(&encoder_, NULL, 0, 0, 0, const vpx_codec_err_t res =
deadline_); vpx_codec_encode(&encoder_, NULL, 0, 0, 0, deadline_);
if (!encoder_.priv) if (!encoder_.priv)
ASSERT_EQ(VPX_CODEC_ERROR, res) << EncoderError(); ASSERT_EQ(VPX_CODEC_ERROR, res) << EncoderError();
else else
@ -106,22 +104,15 @@ void EncoderTest::InitializeConfig() {
void EncoderTest::SetMode(TestMode mode) { void EncoderTest::SetMode(TestMode mode) {
switch (mode) { switch (mode) {
case kRealTime: case kRealTime: deadline_ = VPX_DL_REALTIME; break;
deadline_ = VPX_DL_REALTIME;
break;
case kOnePassGood: case kOnePassGood:
case kTwoPassGood: case kTwoPassGood: deadline_ = VPX_DL_GOOD_QUALITY; break;
deadline_ = VPX_DL_GOOD_QUALITY;
break;
case kOnePassBest: case kOnePassBest:
case kTwoPassBest: case kTwoPassBest: deadline_ = VPX_DL_BEST_QUALITY; break;
deadline_ = VPX_DL_BEST_QUALITY;
break;
default: default: ASSERT_TRUE(false) << "Unexpected mode " << mode;
ASSERT_TRUE(false) << "Unexpected mode " << mode;
} }
if (mode == kTwoPassGood || mode == kTwoPassBest) if (mode == kTwoPassGood || mode == kTwoPassBest)
@ -131,35 +122,35 @@ void EncoderTest::SetMode(TestMode mode) {
} }
// The function should return "true" most of the time, therefore no early // The function should return "true" most of the time, therefore no early
// break-out is implemented within the match checking process. // break-out is implemented within the match checking process.
static bool compare_img(const vpx_image_t *img1, static bool compare_img(const vpx_image_t *img1, const vpx_image_t *img2) {
const vpx_image_t *img2) { bool match = (img1->fmt == img2->fmt) && (img1->cs == img2->cs) &&
bool match = (img1->fmt == img2->fmt) && (img1->d_w == img2->d_w) && (img1->d_h == img2->d_h);
(img1->cs == img2->cs) &&
(img1->d_w == img2->d_w) &&
(img1->d_h == img2->d_h);
const unsigned int width_y = img1->d_w; const unsigned int width_y = img1->d_w;
const unsigned int height_y = img1->d_h; const unsigned int height_y = img1->d_h;
unsigned int i; unsigned int i;
for (i = 0; i < height_y; ++i) for (i = 0; i < height_y; ++i)
match = (memcmp(img1->planes[VPX_PLANE_Y] + i * img1->stride[VPX_PLANE_Y], match = (memcmp(img1->planes[VPX_PLANE_Y] + i * img1->stride[VPX_PLANE_Y],
img2->planes[VPX_PLANE_Y] + i * img2->stride[VPX_PLANE_Y], img2->planes[VPX_PLANE_Y] + i * img2->stride[VPX_PLANE_Y],
width_y) == 0) && match; width_y) == 0) &&
const unsigned int width_uv = (img1->d_w + 1) >> 1; match;
const unsigned int width_uv = (img1->d_w + 1) >> 1;
const unsigned int height_uv = (img1->d_h + 1) >> 1; const unsigned int height_uv = (img1->d_h + 1) >> 1;
for (i = 0; i < height_uv; ++i) for (i = 0; i < height_uv; ++i)
match = (memcmp(img1->planes[VPX_PLANE_U] + i * img1->stride[VPX_PLANE_U], match = (memcmp(img1->planes[VPX_PLANE_U] + i * img1->stride[VPX_PLANE_U],
img2->planes[VPX_PLANE_U] + i * img2->stride[VPX_PLANE_U], img2->planes[VPX_PLANE_U] + i * img2->stride[VPX_PLANE_U],
width_uv) == 0) && match; width_uv) == 0) &&
match;
for (i = 0; i < height_uv; ++i) for (i = 0; i < height_uv; ++i)
match = (memcmp(img1->planes[VPX_PLANE_V] + i * img1->stride[VPX_PLANE_V], match = (memcmp(img1->planes[VPX_PLANE_V] + i * img1->stride[VPX_PLANE_V],
img2->planes[VPX_PLANE_V] + i * img2->stride[VPX_PLANE_V], img2->planes[VPX_PLANE_V] + i * img2->stride[VPX_PLANE_V],
width_uv) == 0) && match; width_uv) == 0) &&
match;
return match; return match;
} }
void EncoderTest::MismatchHook(const vpx_image_t* /*img1*/, void EncoderTest::MismatchHook(const vpx_image_t * /*img1*/,
const vpx_image_t* /*img2*/) { const vpx_image_t * /*img2*/) {
ASSERT_TRUE(0) << "Encode/Decode mismatch found"; ASSERT_TRUE(0) << "Encode/Decode mismatch found";
} }
@ -215,10 +206,9 @@ void EncoderTest::RunLoop(VideoSource *video) {
has_cxdata = true; has_cxdata = true;
if (decoder.get() != NULL && DoDecode()) { if (decoder.get() != NULL && DoDecode()) {
vpx_codec_err_t res_dec = decoder->DecodeFrame( vpx_codec_err_t res_dec = decoder->DecodeFrame(
(const uint8_t*)pkt->data.frame.buf, pkt->data.frame.sz); (const uint8_t *)pkt->data.frame.buf, pkt->data.frame.sz);
if (!HandleDecodeResult(res_dec, *video, decoder.get())) if (!HandleDecodeResult(res_dec, *video, decoder.get())) break;
break;
has_dxdata = true; has_dxdata = true;
} }
@ -227,20 +217,16 @@ void EncoderTest::RunLoop(VideoSource *video) {
FramePktHook(pkt); FramePktHook(pkt);
break; break;
case VPX_CODEC_PSNR_PKT: case VPX_CODEC_PSNR_PKT: PSNRPktHook(pkt); break;
PSNRPktHook(pkt);
break;
default: default: break;
break;
} }
} }
// Flush the decoder when there are no more fragments. // Flush the decoder when there are no more fragments.
if ((init_flags_ & VPX_CODEC_USE_OUTPUT_PARTITION) && has_dxdata) { if ((init_flags_ & VPX_CODEC_USE_OUTPUT_PARTITION) && has_dxdata) {
const vpx_codec_err_t res_dec = decoder->DecodeFrame(NULL, 0); const vpx_codec_err_t res_dec = decoder->DecodeFrame(NULL, 0);
if (!HandleDecodeResult(res_dec, *video, decoder.get())) if (!HandleDecodeResult(res_dec, *video, decoder.get())) break;
break;
} }
if (has_dxdata && has_cxdata) { if (has_dxdata && has_cxdata) {
@ -253,17 +239,14 @@ void EncoderTest::RunLoop(VideoSource *video) {
MismatchHook(img_enc, img_dec); MismatchHook(img_enc, img_dec);
} }
} }
if (img_dec) if (img_dec) DecompressedFrameHook(*img_dec, video->pts());
DecompressedFrameHook(*img_dec, video->pts());
} }
if (!Continue()) if (!Continue()) break;
break;
} }
EndPassHook(); EndPassHook();
if (!Continue()) if (!Continue()) break;
break;
} }
} }

96
test/encode_test_driver.h
View File

@ -33,19 +33,17 @@ enum TestMode {
kTwoPassGood, kTwoPassGood,
kTwoPassBest kTwoPassBest
}; };
#define ALL_TEST_MODES ::testing::Values(::libvpx_test::kRealTime, \ #define ALL_TEST_MODES \
::libvpx_test::kOnePassGood, \ ::testing::Values(::libvpx_test::kRealTime, ::libvpx_test::kOnePassGood, \
::libvpx_test::kOnePassBest, \ ::libvpx_test::kOnePassBest, ::libvpx_test::kTwoPassGood, \
::libvpx_test::kTwoPassGood, \ ::libvpx_test::kTwoPassBest)
::libvpx_test::kTwoPassBest)
#define ONE_PASS_TEST_MODES ::testing::Values(::libvpx_test::kRealTime, \ #define ONE_PASS_TEST_MODES \
::libvpx_test::kOnePassGood, \ ::testing::Values(::libvpx_test::kRealTime, ::libvpx_test::kOnePassGood, \
::libvpx_test::kOnePassBest) ::libvpx_test::kOnePassBest)
#define TWO_PASS_TEST_MODES ::testing::Values(::libvpx_test::kTwoPassGood, \
::libvpx_test::kTwoPassBest)
#define TWO_PASS_TEST_MODES \
::testing::Values(::libvpx_test::kTwoPassGood, ::libvpx_test::kTwoPassBest)
// Provides an object to handle the libvpx get_cx_data() iteration pattern // Provides an object to handle the libvpx get_cx_data() iteration pattern
class CxDataIterator { class CxDataIterator {
@ -58,8 +56,8 @@ class CxDataIterator {
} }
private: private:
vpx_codec_ctx_t *encoder_; vpx_codec_ctx_t *encoder_;
vpx_codec_iter_t iter_; vpx_codec_iter_t iter_;
}; };
// Implements an in-memory store for libvpx twopass statistics // Implements an in-memory store for libvpx twopass statistics
@ -75,15 +73,12 @@ class TwopassStatsStore {
return buf; return buf;
} }
void Reset() { void Reset() { buffer_.clear(); }
buffer_.clear();
}
protected: protected:
std::string buffer_; std::string buffer_;
}; };
// Provides a simplified interface to manage one video encoding pass, given // Provides a simplified interface to manage one video encoding pass, given
// a configuration and video source. // a configuration and video source.
// //
@ -97,13 +92,9 @@ class Encoder {
memset(&encoder_, 0, sizeof(encoder_)); memset(&encoder_, 0, sizeof(encoder_));
} }
virtual ~Encoder() { virtual ~Encoder() { vpx_codec_destroy(&encoder_); }
vpx_codec_destroy(&encoder_);
}
CxDataIterator GetCxData() { CxDataIterator GetCxData() { return CxDataIterator(&encoder_); }
return CxDataIterator(&encoder_);
}
void InitEncoder(VideoSource *video); void InitEncoder(VideoSource *video);
@ -115,9 +106,7 @@ class Encoder {
void EncodeFrame(VideoSource *video, const unsigned long frame_flags); void EncodeFrame(VideoSource *video, const unsigned long frame_flags);
// Convenience wrapper for EncodeFrame() // Convenience wrapper for EncodeFrame()
void EncodeFrame(VideoSource *video) { void EncodeFrame(VideoSource *video) { EncodeFrame(video, 0); }
EncodeFrame(video, 0);
}
void Control(int ctrl_id, int arg) { void Control(int ctrl_id, int arg) {
const vpx_codec_err_t res = vpx_codec_control_(&encoder_, ctrl_id, arg); const vpx_codec_err_t res = vpx_codec_control_(&encoder_, ctrl_id, arg);
@ -156,12 +145,10 @@ class Encoder {
cfg_ = *cfg; cfg_ = *cfg;
} }
void set_deadline(unsigned long deadline) { void set_deadline(unsigned long deadline) { deadline_ = deadline; }
deadline_ = deadline;
}
protected: protected:
virtual vpx_codec_iface_t* CodecInterface() const = 0; virtual vpx_codec_iface_t *CodecInterface() const = 0;
const char *EncoderError() { const char *EncoderError() {
const char *detail = vpx_codec_error_detail(&encoder_); const char *detail = vpx_codec_error_detail(&encoder_);
@ -175,11 +162,11 @@ class Encoder {
// Flush the encoder on EOS // Flush the encoder on EOS
void Flush(); void Flush();
vpx_codec_ctx_t encoder_; vpx_codec_ctx_t encoder_;
vpx_codec_enc_cfg_t cfg_; vpx_codec_enc_cfg_t cfg_;
unsigned long deadline_; unsigned long deadline_;
unsigned long init_flags_; unsigned long init_flags_;
TwopassStatsStore *stats_; TwopassStatsStore *stats_;
}; };
// Common test functionality for all Encoder tests. // Common test functionality for all Encoder tests.
@ -221,36 +208,35 @@ class EncoderTest {
virtual void EndPassHook() {} virtual void EndPassHook() {}
// Hook to be called before encoding a frame. // Hook to be called before encoding a frame.
virtual void PreEncodeFrameHook(VideoSource* /*video*/) {} virtual void PreEncodeFrameHook(VideoSource * /*video*/) {}
virtual void PreEncodeFrameHook(VideoSource* /*video*/, virtual void PreEncodeFrameHook(VideoSource * /*video*/,
Encoder* /*encoder*/) {} Encoder * /*encoder*/) {}
// Hook to be called on every compressed data packet. // Hook to be called on every compressed data packet.
virtual void FramePktHook(const vpx_codec_cx_pkt_t* /*pkt*/) {} virtual void FramePktHook(const vpx_codec_cx_pkt_t * /*pkt*/) {}
// Hook to be called on every PSNR packet. // Hook to be called on every PSNR packet.
virtual void PSNRPktHook(const vpx_codec_cx_pkt_t* /*pkt*/) {} virtual void PSNRPktHook(const vpx_codec_cx_pkt_t * /*pkt*/) {}
// Hook to determine whether the encode loop should continue. // Hook to determine whether the encode loop should continue.
virtual bool Continue() const { virtual bool Continue() const {
return !(::testing::Test::HasFatalFailure() || abort_); return !(::testing::Test::HasFatalFailure() || abort_);
} }
const CodecFactory *codec_; const CodecFactory *codec_;
// Hook to determine whether to decode frame after encoding // Hook to determine whether to decode frame after encoding
virtual bool DoDecode() const { return 1; } virtual bool DoDecode() const { return 1; }
// Hook to handle encode/decode mismatch // Hook to handle encode/decode mismatch
virtual void MismatchHook(const vpx_image_t *img1, virtual void MismatchHook(const vpx_image_t *img1, const vpx_image_t *img2);
const vpx_image_t *img2);
// Hook to be called on every decompressed frame. // Hook to be called on every decompressed frame.
virtual void DecompressedFrameHook(const vpx_image_t& /*img*/, virtual void DecompressedFrameHook(const vpx_image_t & /*img*/,
vpx_codec_pts_t /*pts*/) {} vpx_codec_pts_t /*pts*/) {}
// Hook to be called to handle decode result. Return true to continue. // Hook to be called to handle decode result. Return true to continue.
virtual bool HandleDecodeResult(const vpx_codec_err_t res_dec, virtual bool HandleDecodeResult(const vpx_codec_err_t res_dec,
const VideoSource& /*video*/, const VideoSource & /*video*/,
Decoder *decoder) { Decoder *decoder) {
EXPECT_EQ(VPX_CODEC_OK, res_dec) << decoder->DecodeError(); EXPECT_EQ(VPX_CODEC_OK, res_dec) << decoder->DecodeError();
return VPX_CODEC_OK == res_dec; return VPX_CODEC_OK == res_dec;
@ -262,15 +248,15 @@ class EncoderTest {
return pkt; return pkt;
} }
bool abort_; bool abort_;
vpx_codec_enc_cfg_t cfg_; vpx_codec_enc_cfg_t cfg_;
vpx_codec_dec_cfg_t dec_cfg_; vpx_codec_dec_cfg_t dec_cfg_;
unsigned int passes_; unsigned int passes_;
unsigned long deadline_; unsigned long deadline_;
TwopassStatsStore stats_; TwopassStatsStore stats_;
unsigned long init_flags_; unsigned long init_flags_;
unsigned long frame_flags_; unsigned long frame_flags_;
vpx_codec_pts_t last_pts_; vpx_codec_pts_t last_pts_;
}; };
} // namespace libvpx_test } // namespace libvpx_test

210
test/error_resilience_test.cc
View File

@ -19,16 +19,13 @@ namespace {
const int kMaxErrorFrames = 12; const int kMaxErrorFrames = 12;
const int kMaxDroppableFrames = 12; const int kMaxDroppableFrames = 12;
class ErrorResilienceTestLarge : public ::libvpx_test::EncoderTest, class ErrorResilienceTestLarge
public ::libvpx_test::CodecTestWith2Params<libvpx_test::TestMode, bool> { : public ::libvpx_test::EncoderTest,
public ::libvpx_test::CodecTestWith2Params<libvpx_test::TestMode, bool> {
protected: protected:
ErrorResilienceTestLarge() ErrorResilienceTestLarge()
: EncoderTest(GET_PARAM(0)), : EncoderTest(GET_PARAM(0)), svc_support_(GET_PARAM(2)), psnr_(0.0),
svc_support_(GET_PARAM(2)), nframes_(0), mismatch_psnr_(0.0), mismatch_nframes_(0),
psnr_(0.0),
nframes_(0),
mismatch_psnr_(0.0),
mismatch_nframes_(0),
encoding_mode_(GET_PARAM(1)) { encoding_mode_(GET_PARAM(1)) {
Reset(); Reset();
} }
@ -66,81 +63,70 @@ class ErrorResilienceTestLarge : public ::libvpx_test::EncoderTest,
// LAST is updated on base/layer 0, GOLDEN updated on layer 1. // LAST is updated on base/layer 0, GOLDEN updated on layer 1.
// Non-zero pattern_switch parameter means pattern will switch to // Non-zero pattern_switch parameter means pattern will switch to
// not using LAST for frame_num >= pattern_switch. // not using LAST for frame_num >= pattern_switch.
int SetFrameFlags(int frame_num, int SetFrameFlags(int frame_num, int num_temp_layers, int pattern_switch) {
int num_temp_layers,
int pattern_switch) {
int frame_flags = 0; int frame_flags = 0;
if (num_temp_layers == 2) { if (num_temp_layers == 2) {
if (frame_num % 2 == 0) { if (frame_num % 2 == 0) {
if (frame_num < pattern_switch || pattern_switch == 0) { if (frame_num < pattern_switch || pattern_switch == 0) {
// Layer 0: predict from LAST and ARF, update LAST. // Layer 0: predict from LAST and ARF, update LAST.
frame_flags = VP8_EFLAG_NO_REF_GF | frame_flags =
VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF;
VP8_EFLAG_NO_UPD_ARF;
} else {
// Layer 0: predict from GF and ARF, update GF.
frame_flags = VP8_EFLAG_NO_REF_LAST |
VP8_EFLAG_NO_UPD_LAST |
VP8_EFLAG_NO_UPD_ARF;
}
} else { } else {
if (frame_num < pattern_switch || pattern_switch == 0) { // Layer 0: predict from GF and ARF, update GF.
// Layer 1: predict from L, GF, and ARF, update GF. frame_flags = VP8_EFLAG_NO_REF_LAST | VP8_EFLAG_NO_UPD_LAST |
frame_flags = VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_ARF;
VP8_EFLAG_NO_UPD_LAST;
} else {
// Layer 1: predict from GF and ARF, update GF.
frame_flags = VP8_EFLAG_NO_REF_LAST |
VP8_EFLAG_NO_UPD_LAST |
VP8_EFLAG_NO_UPD_ARF;
}
} }
} else {
if (frame_num < pattern_switch || pattern_switch == 0) {
// Layer 1: predict from L, GF, and ARF, update GF.
frame_flags = VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST;
} else {
// Layer 1: predict from GF and ARF, update GF.
frame_flags = VP8_EFLAG_NO_REF_LAST | VP8_EFLAG_NO_UPD_LAST |
VP8_EFLAG_NO_UPD_ARF;
}
}
} }
return frame_flags; return frame_flags;
} }
virtual void PreEncodeFrameHook(libvpx_test::VideoSource *video, virtual void PreEncodeFrameHook(libvpx_test::VideoSource *video,
::libvpx_test::Encoder * /*encoder*/) { ::libvpx_test::Encoder * /*encoder*/) {
frame_flags_ &= ~(VP8_EFLAG_NO_UPD_LAST | frame_flags_ &=
VP8_EFLAG_NO_UPD_GF | ~(VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF);
VP8_EFLAG_NO_UPD_ARF);
// For temporal layer case. // For temporal layer case.
if (cfg_.ts_number_layers > 1) { if (cfg_.ts_number_layers > 1) {
frame_flags_ = SetFrameFlags(video->frame(), frame_flags_ =
cfg_.ts_number_layers, SetFrameFlags(video->frame(), cfg_.ts_number_layers, pattern_switch_);
pattern_switch_);
for (unsigned int i = 0; i < droppable_nframes_; ++i) { for (unsigned int i = 0; i < droppable_nframes_; ++i) {
if (droppable_frames_[i] == video->frame()) { if (droppable_frames_[i] == video->frame()) {
std::cout << "Encoding droppable frame: " std::cout << "Encoding droppable frame: " << droppable_frames_[i]
<< droppable_frames_[i] << "\n"; << "\n";
} }
} }
} else { } else {
if (droppable_nframes_ > 0 && if (droppable_nframes_ > 0 &&
(cfg_.g_pass == VPX_RC_LAST_PASS || cfg_.g_pass == VPX_RC_ONE_PASS)) { (cfg_.g_pass == VPX_RC_LAST_PASS || cfg_.g_pass == VPX_RC_ONE_PASS)) {
for (unsigned int i = 0; i < droppable_nframes_; ++i) { for (unsigned int i = 0; i < droppable_nframes_; ++i) {
if (droppable_frames_[i] == video->frame()) { if (droppable_frames_[i] == video->frame()) {
std::cout << "Encoding droppable frame: " std::cout << "Encoding droppable frame: " << droppable_frames_[i]
<< droppable_frames_[i] << "\n"; << "\n";
frame_flags_ |= (VP8_EFLAG_NO_UPD_LAST | frame_flags_ |= (VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF |
VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF);
VP8_EFLAG_NO_UPD_ARF); return;
return; }
} }
} }
}
} }
} }
double GetAveragePsnr() const { double GetAveragePsnr() const {
if (nframes_) if (nframes_) return psnr_ / nframes_;
return psnr_ / nframes_;
return 0.0; return 0.0;
} }
double GetAverageMismatchPsnr() const { double GetAverageMismatchPsnr() const {
if (mismatch_nframes_) if (mismatch_nframes_) return mismatch_psnr_ / mismatch_nframes_;
return mismatch_psnr_ / mismatch_nframes_;
return 0.0; return 0.0;
} }
@ -158,8 +144,7 @@ class ErrorResilienceTestLarge : public ::libvpx_test::EncoderTest,
return 1; return 1;
} }
virtual void MismatchHook(const vpx_image_t *img1, virtual void MismatchHook(const vpx_image_t *img1, const vpx_image_t *img2) {
const vpx_image_t *img2) {
double mismatch_psnr = compute_psnr(img1, img2); double mismatch_psnr = compute_psnr(img1, img2);
mismatch_psnr_ += mismatch_psnr; mismatch_psnr_ += mismatch_psnr;
++mismatch_nframes_; ++mismatch_nframes_;
@ -186,13 +171,9 @@ class ErrorResilienceTestLarge : public ::libvpx_test::EncoderTest,
droppable_frames_[i] = list[i]; droppable_frames_[i] = list[i];
} }
unsigned int GetMismatchFrames() { unsigned int GetMismatchFrames() { return mismatch_nframes_; }
return mismatch_nframes_;
}
void SetPatternSwitch(int frame_switch) { void SetPatternSwitch(int frame_switch) { pattern_switch_ = frame_switch; }
pattern_switch_ = frame_switch;
}
bool svc_support_; bool svc_support_;
@ -265,15 +246,14 @@ TEST_P(ErrorResilienceTestLarge, DropFramesWithoutRecovery) {
// In addition to isolated loss/drop, add a long consecutive series // In addition to isolated loss/drop, add a long consecutive series
// (of size 9) of dropped frames. // (of size 9) of dropped frames.
unsigned int num_droppable_frames = 11; unsigned int num_droppable_frames = 11;
unsigned int droppable_frame_list[] = {5, 16, 22, 23, 24, 25, 26, 27, 28, unsigned int droppable_frame_list[] = { 5, 16, 22, 23, 24, 25,
29, 30}; 26, 27, 28, 29, 30 };
SetDroppableFrames(num_droppable_frames, droppable_frame_list); SetDroppableFrames(num_droppable_frames, droppable_frame_list);
SetErrorFrames(num_droppable_frames, droppable_frame_list); SetErrorFrames(num_droppable_frames, droppable_frame_list);
ASSERT_NO_FATAL_FAILURE(RunLoop(&video)); ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
// Test that no mismatches have been found // Test that no mismatches have been found
std::cout << " Mismatch frames: " std::cout << " Mismatch frames: " << GetMismatchFrames() << "\n";
<< GetMismatchFrames() << "\n"; EXPECT_EQ(GetMismatchFrames(), (unsigned int)0);
EXPECT_EQ(GetMismatchFrames(), (unsigned int) 0);
// Reset previously set of error/droppable frames. // Reset previously set of error/droppable frames.
Reset(); Reset();
@ -306,8 +286,7 @@ TEST_P(ErrorResilienceTestLarge, DropFramesWithoutRecovery) {
// layer, so successful decoding is expected. // layer, so successful decoding is expected.
TEST_P(ErrorResilienceTestLarge, 2LayersDropEnhancement) { TEST_P(ErrorResilienceTestLarge, 2LayersDropEnhancement) {
// This test doesn't run if SVC is not supported. // This test doesn't run if SVC is not supported.
if (!svc_support_) if (!svc_support_) return;
return;
const vpx_rational timebase = { 33333333, 1000000000 }; const vpx_rational timebase = { 33333333, 1000000000 };
cfg_.g_timebase = timebase; cfg_.g_timebase = timebase;
@ -337,14 +316,13 @@ TEST_P(ErrorResilienceTestLarge, 2LayersDropEnhancement) {
// The odd frames are the enhancement layer for 2 layer pattern, so set // The odd frames are the enhancement layer for 2 layer pattern, so set
// those frames as droppable. Drop the last 7 frames. // those frames as droppable. Drop the last 7 frames.
unsigned int num_droppable_frames = 7; unsigned int num_droppable_frames = 7;
unsigned int droppable_frame_list[] = {27, 29, 31, 33, 35, 37, 39}; unsigned int droppable_frame_list[] = { 27, 29, 31, 33, 35, 37, 39 };
SetDroppableFrames(num_droppable_frames, droppable_frame_list); SetDroppableFrames(num_droppable_frames, droppable_frame_list);
SetErrorFrames(num_droppable_frames, droppable_frame_list); SetErrorFrames(num_droppable_frames, droppable_frame_list);
ASSERT_NO_FATAL_FAILURE(RunLoop(&video)); ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
// Test that no mismatches have been found // Test that no mismatches have been found
std::cout << " Mismatch frames: " std::cout << " Mismatch frames: " << GetMismatchFrames() << "\n";
<< GetMismatchFrames() << "\n"; EXPECT_EQ(GetMismatchFrames(), (unsigned int)0);
EXPECT_EQ(GetMismatchFrames(), (unsigned int) 0);
// Reset previously set of error/droppable frames. // Reset previously set of error/droppable frames.
Reset(); Reset();
@ -355,8 +333,7 @@ TEST_P(ErrorResilienceTestLarge, 2LayersDropEnhancement) {
// sequence, the LAST ref is not used anymore. // sequence, the LAST ref is not used anymore.
TEST_P(ErrorResilienceTestLarge, 2LayersNoRefLast) { TEST_P(ErrorResilienceTestLarge, 2LayersNoRefLast) {
// This test doesn't run if SVC is not supported. // This test doesn't run if SVC is not supported.
if (!svc_support_) if (!svc_support_) return;
return;
const vpx_rational timebase = { 33333333, 1000000000 }; const vpx_rational timebase = { 33333333, 1000000000 };
cfg_.g_timebase = timebase; cfg_.g_timebase = timebase;
@ -385,20 +362,19 @@ TEST_P(ErrorResilienceTestLarge, 2LayersNoRefLast) {
ASSERT_NO_FATAL_FAILURE(RunLoop(&video)); ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
// Test that no mismatches have been found // Test that no mismatches have been found
std::cout << " Mismatch frames: " std::cout << " Mismatch frames: " << GetMismatchFrames() << "\n";
<< GetMismatchFrames() << "\n"; EXPECT_EQ(GetMismatchFrames(), (unsigned int)0);
EXPECT_EQ(GetMismatchFrames(), (unsigned int) 0);
// Reset previously set of error/droppable frames. // Reset previously set of error/droppable frames.
Reset(); Reset();
} }
class ErrorResilienceTestLargeCodecControls : public ::libvpx_test::EncoderTest, class ErrorResilienceTestLargeCodecControls
public ::libvpx_test::CodecTestWithParam<libvpx_test::TestMode> { : public ::libvpx_test::EncoderTest,
public ::libvpx_test::CodecTestWithParam<libvpx_test::TestMode> {
protected: protected:
ErrorResilienceTestLargeCodecControls() ErrorResilienceTestLargeCodecControls()
: EncoderTest(GET_PARAM(0)), : EncoderTest(GET_PARAM(0)), encoding_mode_(GET_PARAM(1)) {
encoding_mode_(GET_PARAM(1)) {
Reset(); Reset();
} }
@ -437,8 +413,8 @@ class ErrorResilienceTestLargeCodecControls : public ::libvpx_test::EncoderTest,
if (num_temp_layers == 2) { if (num_temp_layers == 2) {
if (frame_num % 2 == 0) { if (frame_num % 2 == 0) {
// Layer 0: predict from L and ARF, update L. // Layer 0: predict from L and ARF, update L.
frame_flags = VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_UPD_GF | frame_flags =
VP8_EFLAG_NO_UPD_ARF; VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF;
} else { } else {
// Layer 1: predict from L, G and ARF, and update G. // Layer 1: predict from L, G and ARF, and update G.
frame_flags = VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST | frame_flags = VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST |
@ -451,9 +427,9 @@ class ErrorResilienceTestLargeCodecControls : public ::libvpx_test::EncoderTest,
VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF; VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF;
} else if ((frame_num - 2) % 4 == 0) { } else if ((frame_num - 2) % 4 == 0) {
// Layer 1: predict from L, G, update G. // Layer 1: predict from L, G, update G.
frame_flags = VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST | frame_flags =
VP8_EFLAG_NO_REF_ARF; VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_REF_ARF;
} else if ((frame_num - 1) % 2 == 0) { } else if ((frame_num - 1) % 2 == 0) {
// Layer 2: predict from L, G, ARF; update ARG. // Layer 2: predict from L, G, ARF; update ARG.
frame_flags = VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_LAST; frame_flags = VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_LAST;
} }
@ -467,7 +443,7 @@ class ErrorResilienceTestLargeCodecControls : public ::libvpx_test::EncoderTest,
if (frame_num % 2 == 0) { if (frame_num % 2 == 0) {
layer_id = 0; layer_id = 0;
} else { } else {
layer_id = 1; layer_id = 1;
} }
} else if (num_temp_layers == 3) { } else if (num_temp_layers == 3) {
if (frame_num % 4 == 0) { if (frame_num % 4 == 0) {
@ -484,16 +460,16 @@ class ErrorResilienceTestLargeCodecControls : public ::libvpx_test::EncoderTest,
virtual void PreEncodeFrameHook(libvpx_test::VideoSource *video, virtual void PreEncodeFrameHook(libvpx_test::VideoSource *video,
libvpx_test::Encoder *encoder) { libvpx_test::Encoder *encoder) {
if (cfg_.ts_number_layers > 1) { if (cfg_.ts_number_layers > 1) {
int layer_id = SetLayerId(video->frame(), cfg_.ts_number_layers); int layer_id = SetLayerId(video->frame(), cfg_.ts_number_layers);
int frame_flags = SetFrameFlags(video->frame(), cfg_.ts_number_layers); int frame_flags = SetFrameFlags(video->frame(), cfg_.ts_number_layers);
if (video->frame() > 0) { if (video->frame() > 0) {
encoder->Control(VP8E_SET_TEMPORAL_LAYER_ID, layer_id); encoder->Control(VP8E_SET_TEMPORAL_LAYER_ID, layer_id);
encoder->Control(VP8E_SET_FRAME_FLAGS, frame_flags); encoder->Control(VP8E_SET_FRAME_FLAGS, frame_flags);
} }
const vpx_rational_t tb = video->timebase(); const vpx_rational_t tb = video->timebase();
timebase_ = static_cast<double>(tb.num) / tb.den; timebase_ = static_cast<double>(tb.num) / tb.den;
duration_ = 0; duration_ = 0;
return; return;
} }
} }
@ -519,26 +495,28 @@ class ErrorResilienceTestLargeCodecControls : public ::libvpx_test::EncoderTest,
virtual void EndPassHook(void) { virtual void EndPassHook(void) {
duration_ = (last_pts_ + 1) * timebase_; duration_ = (last_pts_ + 1) * timebase_;
if (cfg_.ts_number_layers > 1) { if (cfg_.ts_number_layers > 1) {
for (int layer = 0; layer < static_cast<int>(cfg_.ts_number_layers); for (int layer = 0; layer < static_cast<int>(cfg_.ts_number_layers);
++layer) { ++layer) {
if (bits_total_[layer]) { if (bits_total_[layer]) {
// Effective file datarate: // Effective file datarate:
effective_datarate_[layer] = (bits_total_[layer] / 1000.0) / duration_; effective_datarate_[layer] =
(bits_total_[layer] / 1000.0) / duration_;
} }
} }
} }
} }
double effective_datarate_[3]; double effective_datarate_[3];
private:
libvpx_test::TestMode encoding_mode_; private:
vpx_codec_pts_t last_pts_; libvpx_test::TestMode encoding_mode_;
double timebase_; vpx_codec_pts_t last_pts_;
int64_t bits_total_[3]; double timebase_;
double duration_; int64_t bits_total_[3];
int tot_frame_number_; double duration_;
}; int tot_frame_number_;
};
// Check two codec controls used for: // Check two codec controls used for:
// (1) for setting temporal layer id, and (2) for settings encoder flags. // (1) for setting temporal layer id, and (2) for settings encoder flags.
@ -582,10 +560,12 @@ TEST_P(ErrorResilienceTestLargeCodecControls, CodecControl3TemporalLayers) {
for (int j = 0; j < static_cast<int>(cfg_.ts_number_layers); ++j) { for (int j = 0; j < static_cast<int>(cfg_.ts_number_layers); ++j) {
ASSERT_GE(effective_datarate_[j], cfg_.ts_target_bitrate[j] * 0.75) ASSERT_GE(effective_datarate_[j], cfg_.ts_target_bitrate[j] * 0.75)
<< " The datarate for the file is lower than target by too much, " << " The datarate for the file is lower than target by too much, "
"for layer: " << j; "for layer: "
<< j;
ASSERT_LE(effective_datarate_[j], cfg_.ts_target_bitrate[j] * 1.25) ASSERT_LE(effective_datarate_[j], cfg_.ts_target_bitrate[j] * 1.25)
<< " The datarate for the file is greater than target by too much, " << " The datarate for the file is greater than target by too much, "
"for layer: " << j; "for layer: "
<< j;
} }
} }
} }

109
test/external_frame_buffer_test.cc
View File

@ -34,21 +34,18 @@ struct ExternalFrameBuffer {
// Class to manipulate a list of external frame buffers. // Class to manipulate a list of external frame buffers.
class ExternalFrameBufferList { class ExternalFrameBufferList {
public: public:
ExternalFrameBufferList() ExternalFrameBufferList() : num_buffers_(0), ext_fb_list_(NULL) {}
: num_buffers_(0),
ext_fb_list_(NULL) {}
virtual ~ExternalFrameBufferList() { virtual ~ExternalFrameBufferList() {
for (int i = 0; i < num_buffers_; ++i) { for (int i = 0; i < num_buffers_; ++i) {
delete [] ext_fb_list_[i].data; delete[] ext_fb_list_[i].data;
} }
delete [] ext_fb_list_; delete[] ext_fb_list_;
} }
// Creates the list to hold the external buffers. Returns true on success. // Creates the list to hold the external buffers. Returns true on success.
bool CreateBufferList(int num_buffers) { bool CreateBufferList(int num_buffers) {
if (num_buffers < 0) if (num_buffers < 0) return false;
return false;
num_buffers_ = num_buffers; num_buffers_ = num_buffers;
ext_fb_list_ = new ExternalFrameBuffer[num_buffers_]; ext_fb_list_ = new ExternalFrameBuffer[num_buffers_];
@ -64,11 +61,10 @@ class ExternalFrameBufferList {
int GetFreeFrameBuffer(size_t min_size, vpx_codec_frame_buffer_t *fb) { int GetFreeFrameBuffer(size_t min_size, vpx_codec_frame_buffer_t *fb) {
EXPECT_TRUE(fb != NULL); EXPECT_TRUE(fb != NULL);
const int idx = FindFreeBufferIndex(); const int idx = FindFreeBufferIndex();
if (idx == num_buffers_) if (idx == num_buffers_) return -1;
return -1;
if (ext_fb_list_[idx].size < min_size) { if (ext_fb_list_[idx].size < min_size) {
delete [] ext_fb_list_[idx].data; delete[] ext_fb_list_[idx].data;
ext_fb_list_[idx].data = new uint8_t[min_size]; ext_fb_list_[idx].data = new uint8_t[min_size];
memset(ext_fb_list_[idx].data, 0, min_size); memset(ext_fb_list_[idx].data, 0, min_size);
ext_fb_list_[idx].size = min_size; ext_fb_list_[idx].size = min_size;
@ -83,11 +79,10 @@ class ExternalFrameBufferList {
int GetZeroFrameBuffer(size_t min_size, vpx_codec_frame_buffer_t *fb) { int GetZeroFrameBuffer(size_t min_size, vpx_codec_frame_buffer_t *fb) {
EXPECT_TRUE(fb != NULL); EXPECT_TRUE(fb != NULL);
const int idx = FindFreeBufferIndex(); const int idx = FindFreeBufferIndex();
if (idx == num_buffers_) if (idx == num_buffers_) return -1;
return -1;
if (ext_fb_list_[idx].size < min_size) { if (ext_fb_list_[idx].size < min_size) {
delete [] ext_fb_list_[idx].data; delete[] ext_fb_list_[idx].data;
ext_fb_list_[idx].data = NULL; ext_fb_list_[idx].data = NULL;
ext_fb_list_[idx].size = min_size; ext_fb_list_[idx].size = min_size;
} }
@ -104,7 +99,7 @@ class ExternalFrameBufferList {
return -1; return -1;
} }
ExternalFrameBuffer *const ext_fb = ExternalFrameBuffer *const ext_fb =
reinterpret_cast<ExternalFrameBuffer*>(fb->priv); reinterpret_cast<ExternalFrameBuffer *>(fb->priv);
if (ext_fb == NULL) { if (ext_fb == NULL) {
EXPECT_TRUE(ext_fb != NULL); EXPECT_TRUE(ext_fb != NULL);
return -1; return -1;
@ -119,7 +114,7 @@ class ExternalFrameBufferList {
void CheckXImageFrameBuffer(const vpx_image_t *img) { void CheckXImageFrameBuffer(const vpx_image_t *img) {
if (img->fb_priv != NULL) { if (img->fb_priv != NULL) {
const struct ExternalFrameBuffer *const ext_fb = const struct ExternalFrameBuffer *const ext_fb =
reinterpret_cast<ExternalFrameBuffer*>(img->fb_priv); reinterpret_cast<ExternalFrameBuffer *>(img->fb_priv);
ASSERT_TRUE(img->planes[0] >= ext_fb->data && ASSERT_TRUE(img->planes[0] >= ext_fb->data &&
img->planes[0] < (ext_fb->data + ext_fb->size)); img->planes[0] < (ext_fb->data + ext_fb->size));
@ -133,8 +128,7 @@ class ExternalFrameBufferList {
int i; int i;
// Find a free frame buffer. // Find a free frame buffer.
for (i = 0; i < num_buffers_; ++i) { for (i = 0; i < num_buffers_; ++i) {
if (!ext_fb_list_[i].in_use) if (!ext_fb_list_[i].in_use) break;
break;
} }
return i; return i;
} }
@ -161,16 +155,15 @@ class ExternalFrameBufferList {
int get_vp9_frame_buffer(void *user_priv, size_t min_size, int get_vp9_frame_buffer(void *user_priv, size_t min_size,
vpx_codec_frame_buffer_t *fb) { vpx_codec_frame_buffer_t *fb) {
ExternalFrameBufferList *const fb_list = ExternalFrameBufferList *const fb_list =
reinterpret_cast<ExternalFrameBufferList*>(user_priv); reinterpret_cast<ExternalFrameBufferList *>(user_priv);
return fb_list->GetFreeFrameBuffer(min_size, fb); return fb_list->GetFreeFrameBuffer(min_size, fb);
} }
// Callback used by libvpx to tell the application that |fb| is not needed // Callback used by libvpx to tell the application that |fb| is not needed
// anymore. // anymore.
int release_vp9_frame_buffer(void *user_priv, int release_vp9_frame_buffer(void *user_priv, vpx_codec_frame_buffer_t *fb) {
vpx_codec_frame_buffer_t *fb) {
ExternalFrameBufferList *const fb_list = ExternalFrameBufferList *const fb_list =
reinterpret_cast<ExternalFrameBufferList*>(user_priv); reinterpret_cast<ExternalFrameBufferList *>(user_priv);
return fb_list->ReturnFrameBuffer(fb); return fb_list->ReturnFrameBuffer(fb);
} }
@ -178,7 +171,7 @@ int release_vp9_frame_buffer(void *user_priv,
int get_vp9_zero_frame_buffer(void *user_priv, size_t min_size, int get_vp9_zero_frame_buffer(void *user_priv, size_t min_size,
vpx_codec_frame_buffer_t *fb) { vpx_codec_frame_buffer_t *fb) {
ExternalFrameBufferList *const fb_list = ExternalFrameBufferList *const fb_list =
reinterpret_cast<ExternalFrameBufferList*>(user_priv); reinterpret_cast<ExternalFrameBufferList *>(user_priv);
return fb_list->GetZeroFrameBuffer(min_size, fb); return fb_list->GetZeroFrameBuffer(min_size, fb);
} }
@ -186,7 +179,7 @@ int get_vp9_zero_frame_buffer(void *user_priv, size_t min_size,
int get_vp9_one_less_byte_frame_buffer(void *user_priv, size_t min_size, int get_vp9_one_less_byte_frame_buffer(void *user_priv, size_t min_size,
vpx_codec_frame_buffer_t *fb) { vpx_codec_frame_buffer_t *fb) {
ExternalFrameBufferList *const fb_list = ExternalFrameBufferList *const fb_list =
reinterpret_cast<ExternalFrameBufferList*>(user_priv); reinterpret_cast<ExternalFrameBufferList *>(user_priv);
return fb_list->GetFreeFrameBuffer(min_size - 1, fb); return fb_list->GetFreeFrameBuffer(min_size - 1, fb);
} }
@ -203,16 +196,14 @@ int do_not_release_vp9_frame_buffer(void *user_priv,
// Class for testing passing in external frame buffers to libvpx. // Class for testing passing in external frame buffers to libvpx.
class ExternalFrameBufferMD5Test class ExternalFrameBufferMD5Test
: public ::libvpx_test::DecoderTest, : public ::libvpx_test::DecoderTest,
public ::libvpx_test::CodecTestWithParam<const char*> { public ::libvpx_test::CodecTestWithParam<const char *> {
protected: protected:
ExternalFrameBufferMD5Test() ExternalFrameBufferMD5Test()
: DecoderTest(GET_PARAM(::libvpx_test::kCodecFactoryParam)), : DecoderTest(GET_PARAM(::libvpx_test::kCodecFactoryParam)),
md5_file_(NULL), md5_file_(NULL), num_buffers_(0) {}
num_buffers_(0) {}
virtual ~ExternalFrameBufferMD5Test() { virtual ~ExternalFrameBufferMD5Test() {
if (md5_file_ != NULL) if (md5_file_ != NULL) fclose(md5_file_);
fclose(md5_file_);
} }
virtual void PreDecodeFrameHook( virtual void PreDecodeFrameHook(
@ -222,15 +213,15 @@ class ExternalFrameBufferMD5Test
// Have libvpx use frame buffers we create. // Have libvpx use frame buffers we create.
ASSERT_TRUE(fb_list_.CreateBufferList(num_buffers_)); ASSERT_TRUE(fb_list_.CreateBufferList(num_buffers_));
ASSERT_EQ(VPX_CODEC_OK, ASSERT_EQ(VPX_CODEC_OK,
decoder->SetFrameBufferFunctions( decoder->SetFrameBufferFunctions(GetVP9FrameBuffer,
GetVP9FrameBuffer, ReleaseVP9FrameBuffer, this)); ReleaseVP9FrameBuffer, this));
} }
} }
void OpenMD5File(const std::string &md5_file_name_) { void OpenMD5File(const std::string &md5_file_name_) {
md5_file_ = libvpx_test::OpenTestDataFile(md5_file_name_); md5_file_ = libvpx_test::OpenTestDataFile(md5_file_name_);
ASSERT_TRUE(md5_file_ != NULL) << "Md5 file open failed. Filename: " ASSERT_TRUE(md5_file_ != NULL) << "Md5 file open failed. Filename: "
<< md5_file_name_; << md5_file_name_;
} }
virtual void DecompressedFrameHook(const vpx_image_t &img, virtual void DecompressedFrameHook(const vpx_image_t &img,
@ -258,7 +249,7 @@ class ExternalFrameBufferMD5Test
static int GetVP9FrameBuffer(void *user_priv, size_t min_size, static int GetVP9FrameBuffer(void *user_priv, size_t min_size,
vpx_codec_frame_buffer_t *fb) { vpx_codec_frame_buffer_t *fb) {
ExternalFrameBufferMD5Test *const md5Test = ExternalFrameBufferMD5Test *const md5Test =
reinterpret_cast<ExternalFrameBufferMD5Test*>(user_priv); reinterpret_cast<ExternalFrameBufferMD5Test *>(user_priv);
return md5Test->fb_list_.GetFreeFrameBuffer(min_size, fb); return md5Test->fb_list_.GetFreeFrameBuffer(min_size, fb);
} }
@ -267,7 +258,7 @@ class ExternalFrameBufferMD5Test
static int ReleaseVP9FrameBuffer(void *user_priv, static int ReleaseVP9FrameBuffer(void *user_priv,
vpx_codec_frame_buffer_t *fb) { vpx_codec_frame_buffer_t *fb) {
ExternalFrameBufferMD5Test *const md5Test = ExternalFrameBufferMD5Test *const md5Test =
reinterpret_cast<ExternalFrameBufferMD5Test*>(user_priv); reinterpret_cast<ExternalFrameBufferMD5Test *>(user_priv);
return md5Test->fb_list_.ReturnFrameBuffer(fb); return md5Test->fb_list_.ReturnFrameBuffer(fb);
} }
@ -286,10 +277,7 @@ const char kVP9TestFile[] = "vp90-2-02-size-lf-1920x1080.webm";
// Class for testing passing in external frame buffers to libvpx. // Class for testing passing in external frame buffers to libvpx.
class ExternalFrameBufferTest : public ::testing::Test { class ExternalFrameBufferTest : public ::testing::Test {
protected: protected:
ExternalFrameBufferTest() ExternalFrameBufferTest() : video_(NULL), decoder_(NULL), num_buffers_(0) {}
: video_(NULL),
decoder_(NULL),
num_buffers_(0) {}
virtual void SetUp() { virtual void SetUp() {
video_ = new libvpx_test::WebMVideoSource(kVP9TestFile); video_ = new libvpx_test::WebMVideoSource(kVP9TestFile);
@ -309,8 +297,7 @@ class ExternalFrameBufferTest : public ::testing::Test {
// Passes the external frame buffer information to libvpx. // Passes the external frame buffer information to libvpx.
vpx_codec_err_t SetFrameBufferFunctions( vpx_codec_err_t SetFrameBufferFunctions(
int num_buffers, int num_buffers, vpx_get_frame_buffer_cb_fn_t cb_get,
vpx_get_frame_buffer_cb_fn_t cb_get,
vpx_release_frame_buffer_cb_fn_t cb_release) { vpx_release_frame_buffer_cb_fn_t cb_release) {
if (num_buffers > 0) { if (num_buffers > 0) {
num_buffers_ = num_buffers; num_buffers_ = num_buffers;
@ -324,8 +311,7 @@ class ExternalFrameBufferTest : public ::testing::Test {
const vpx_codec_err_t res = const vpx_codec_err_t res =
decoder_->DecodeFrame(video_->cxdata(), video_->frame_size()); decoder_->DecodeFrame(video_->cxdata(), video_->frame_size());
CheckDecodedFrames(); CheckDecodedFrames();
if (res == VPX_CODEC_OK) if (res == VPX_CODEC_OK) video_->Next();
video_->Next();
return res; return res;
} }
@ -333,8 +319,7 @@ class ExternalFrameBufferTest : public ::testing::Test {
for (; video_->cxdata() != NULL; video_->Next()) { for (; video_->cxdata() != NULL; video_->Next()) {
const vpx_codec_err_t res = const vpx_codec_err_t res =
decoder_->DecodeFrame(video_->cxdata(), video_->frame_size()); decoder_->DecodeFrame(video_->cxdata(), video_->frame_size());
if (res != VPX_CODEC_OK) if (res != VPX_CODEC_OK) return res;
return res;
CheckDecodedFrames(); CheckDecodedFrames();
} }
return VPX_CODEC_OK; return VPX_CODEC_OK;
@ -409,8 +394,8 @@ TEST_F(ExternalFrameBufferTest, MinFrameBuffers) {
// #VP9_MAXIMUM_REF_BUFFERS + #VPX_MAXIMUM_WORK_BUFFERS. // #VP9_MAXIMUM_REF_BUFFERS + #VPX_MAXIMUM_WORK_BUFFERS.
const int num_buffers = VP9_MAXIMUM_REF_BUFFERS + VPX_MAXIMUM_WORK_BUFFERS; const int num_buffers = VP9_MAXIMUM_REF_BUFFERS + VPX_MAXIMUM_WORK_BUFFERS;
ASSERT_EQ(VPX_CODEC_OK, ASSERT_EQ(VPX_CODEC_OK,
SetFrameBufferFunctions( SetFrameBufferFunctions(num_buffers, get_vp9_frame_buffer,
num_buffers, get_vp9_frame_buffer, release_vp9_frame_buffer)); release_vp9_frame_buffer));
ASSERT_EQ(VPX_CODEC_OK, DecodeRemainingFrames()); ASSERT_EQ(VPX_CODEC_OK, DecodeRemainingFrames());
} }
@ -421,8 +406,8 @@ TEST_F(ExternalFrameBufferTest, EightJitterBuffers) {
const int num_buffers = const int num_buffers =
VP9_MAXIMUM_REF_BUFFERS + VPX_MAXIMUM_WORK_BUFFERS + jitter_buffers; VP9_MAXIMUM_REF_BUFFERS + VPX_MAXIMUM_WORK_BUFFERS + jitter_buffers;
ASSERT_EQ(VPX_CODEC_OK, ASSERT_EQ(VPX_CODEC_OK,
SetFrameBufferFunctions( SetFrameBufferFunctions(num_buffers, get_vp9_frame_buffer,
num_buffers, get_vp9_frame_buffer, release_vp9_frame_buffer)); release_vp9_frame_buffer));
ASSERT_EQ(VPX_CODEC_OK, DecodeRemainingFrames()); ASSERT_EQ(VPX_CODEC_OK, DecodeRemainingFrames());
} }
@ -432,8 +417,8 @@ TEST_F(ExternalFrameBufferTest, NotEnoughBuffers) {
// only use 5 frame buffers at one time. // only use 5 frame buffers at one time.
const int num_buffers = 2; const int num_buffers = 2;
ASSERT_EQ(VPX_CODEC_OK, ASSERT_EQ(VPX_CODEC_OK,
SetFrameBufferFunctions( SetFrameBufferFunctions(num_buffers, get_vp9_frame_buffer,
num_buffers, get_vp9_frame_buffer, release_vp9_frame_buffer)); release_vp9_frame_buffer));
ASSERT_EQ(VPX_CODEC_OK, DecodeOneFrame()); ASSERT_EQ(VPX_CODEC_OK, DecodeOneFrame());
ASSERT_EQ(VPX_CODEC_MEM_ERROR, DecodeRemainingFrames()); ASSERT_EQ(VPX_CODEC_MEM_ERROR, DecodeRemainingFrames());
} }
@ -457,18 +442,17 @@ TEST_F(ExternalFrameBufferTest, NullRealloc) {
TEST_F(ExternalFrameBufferTest, ReallocOneLessByte) { TEST_F(ExternalFrameBufferTest, ReallocOneLessByte) {
const int num_buffers = VP9_MAXIMUM_REF_BUFFERS + VPX_MAXIMUM_WORK_BUFFERS; const int num_buffers = VP9_MAXIMUM_REF_BUFFERS + VPX_MAXIMUM_WORK_BUFFERS;
ASSERT_EQ(VPX_CODEC_OK, ASSERT_EQ(VPX_CODEC_OK, SetFrameBufferFunctions(
SetFrameBufferFunctions( num_buffers, get_vp9_one_less_byte_frame_buffer,
num_buffers, get_vp9_one_less_byte_frame_buffer, release_vp9_frame_buffer));
release_vp9_frame_buffer));
ASSERT_EQ(VPX_CODEC_MEM_ERROR, DecodeOneFrame()); ASSERT_EQ(VPX_CODEC_MEM_ERROR, DecodeOneFrame());
} }
TEST_F(ExternalFrameBufferTest, NullGetFunction) { TEST_F(ExternalFrameBufferTest, NullGetFunction) {
const int num_buffers = VP9_MAXIMUM_REF_BUFFERS + VPX_MAXIMUM_WORK_BUFFERS; const int num_buffers = VP9_MAXIMUM_REF_BUFFERS + VPX_MAXIMUM_WORK_BUFFERS;
ASSERT_EQ(VPX_CODEC_INVALID_PARAM, ASSERT_EQ(
SetFrameBufferFunctions(num_buffers, NULL, VPX_CODEC_INVALID_PARAM,
release_vp9_frame_buffer)); SetFrameBufferFunctions(num_buffers, NULL, release_vp9_frame_buffer));
} }
TEST_F(ExternalFrameBufferTest, NullReleaseFunction) { TEST_F(ExternalFrameBufferTest, NullReleaseFunction) {
@ -481,13 +465,14 @@ TEST_F(ExternalFrameBufferTest, SetAfterDecode) {
const int num_buffers = VP9_MAXIMUM_REF_BUFFERS + VPX_MAXIMUM_WORK_BUFFERS; const int num_buffers = VP9_MAXIMUM_REF_BUFFERS + VPX_MAXIMUM_WORK_BUFFERS;
ASSERT_EQ(VPX_CODEC_OK, DecodeOneFrame()); ASSERT_EQ(VPX_CODEC_OK, DecodeOneFrame());
ASSERT_EQ(VPX_CODEC_ERROR, ASSERT_EQ(VPX_CODEC_ERROR,
SetFrameBufferFunctions( SetFrameBufferFunctions(num_buffers, get_vp9_frame_buffer,
num_buffers, get_vp9_frame_buffer, release_vp9_frame_buffer)); release_vp9_frame_buffer));
} }
#endif // CONFIG_WEBM_IO #endif // CONFIG_WEBM_IO
VP9_INSTANTIATE_TEST_CASE(ExternalFrameBufferMD5Test, VP9_INSTANTIATE_TEST_CASE(
::testing::ValuesIn(libvpx_test::kVP9TestVectors, ExternalFrameBufferMD5Test,
libvpx_test::kVP9TestVectors + ::testing::ValuesIn(libvpx_test::kVP9TestVectors,
libvpx_test::kNumVP9TestVectors)); libvpx_test::kVP9TestVectors +
libvpx_test::kNumVP9TestVectors));
} // namespace } // namespace

155
test/fdct4x4_test.cc
View File

@ -128,14 +128,14 @@ class Trans4x4TestBase {
} }
} }
ASM_REGISTER_STATE_CHECK(RunFwdTxfm(test_input_block, ASM_REGISTER_STATE_CHECK(
test_temp_block, pitch_)); RunFwdTxfm(test_input_block, test_temp_block, pitch_));
if (bit_depth_ == VPX_BITS_8) { if (bit_depth_ == VPX_BITS_8) {
ASM_REGISTER_STATE_CHECK(RunInvTxfm(test_temp_block, dst, pitch_)); ASM_REGISTER_STATE_CHECK(RunInvTxfm(test_temp_block, dst, pitch_));
#if CONFIG_VP9_HIGHBITDEPTH #if CONFIG_VP9_HIGHBITDEPTH
} else { } else {
ASM_REGISTER_STATE_CHECK(RunInvTxfm(test_temp_block, ASM_REGISTER_STATE_CHECK(
CONVERT_TO_BYTEPTR(dst16), pitch_)); RunInvTxfm(test_temp_block, CONVERT_TO_BYTEPTR(dst16), pitch_));
#endif #endif
} }
@ -148,15 +148,13 @@ class Trans4x4TestBase {
const int diff = dst[j] - src[j]; const int diff = dst[j] - src[j];
#endif #endif
const uint32_t error = diff * diff; const uint32_t error = diff * diff;
if (max_error < error) if (max_error < error) max_error = error;
max_error = error;
total_error += error; total_error += error;
} }
} }
EXPECT_GE(static_cast<uint32_t>(limit), max_error) EXPECT_GE(static_cast<uint32_t>(limit), max_error)
<< "Error: 4x4 FHT/IHT has an individual round trip error > " << "Error: 4x4 FHT/IHT has an individual round trip error > " << limit;
<< limit;
EXPECT_GE(count_test_block * limit, total_error) EXPECT_GE(count_test_block * limit, total_error)
<< "Error: 4x4 FHT/IHT has average round trip error > " << limit << "Error: 4x4 FHT/IHT has average round trip error > " << limit
@ -197,16 +195,14 @@ class Trans4x4TestBase {
input_extreme_block[j] = rnd.Rand8() % 2 ? mask_ : -mask_; input_extreme_block[j] = rnd.Rand8() % 2 ? mask_ : -mask_;
} }
if (i == 0) { if (i == 0) {
for (int j = 0; j < kNumCoeffs; ++j) for (int j = 0; j < kNumCoeffs; ++j) input_extreme_block[j] = mask_;
input_extreme_block[j] = mask_;
} else if (i == 1) { } else if (i == 1) {
for (int j = 0; j < kNumCoeffs; ++j) for (int j = 0; j < kNumCoeffs; ++j) input_extreme_block[j] = -mask_;
input_extreme_block[j] = -mask_;
} }
fwd_txfm_ref(input_extreme_block, output_ref_block, pitch_, tx_type_); fwd_txfm_ref(input_extreme_block, output_ref_block, pitch_, tx_type_);
ASM_REGISTER_STATE_CHECK(RunFwdTxfm(input_extreme_block, ASM_REGISTER_STATE_CHECK(
output_block, pitch_)); RunFwdTxfm(input_extreme_block, output_block, pitch_));
// The minimum quant value is 4. // The minimum quant value is 4.
for (int j = 0; j < kNumCoeffs; ++j) { for (int j = 0; j < kNumCoeffs; ++j) {
@ -251,8 +247,8 @@ class Trans4x4TestBase {
ASM_REGISTER_STATE_CHECK(RunInvTxfm(coeff, dst, pitch_)); ASM_REGISTER_STATE_CHECK(RunInvTxfm(coeff, dst, pitch_));
#if CONFIG_VP9_HIGHBITDEPTH #if CONFIG_VP9_HIGHBITDEPTH
} else { } else {
ASM_REGISTER_STATE_CHECK(RunInvTxfm(coeff, CONVERT_TO_BYTEPTR(dst16), ASM_REGISTER_STATE_CHECK(
pitch_)); RunInvTxfm(coeff, CONVERT_TO_BYTEPTR(dst16), pitch_));
#endif #endif
} }
@ -265,8 +261,7 @@ class Trans4x4TestBase {
#endif #endif
const uint32_t error = diff * diff; const uint32_t error = diff * diff;
EXPECT_GE(static_cast<uint32_t>(limit), error) EXPECT_GE(static_cast<uint32_t>(limit), error)
<< "Error: 4x4 IDCT has error " << error << "Error: 4x4 IDCT has error " << error << " at index " << j;
<< " at index " << j;
} }
} }
} }
@ -278,17 +273,16 @@ class Trans4x4TestBase {
int mask_; int mask_;
}; };
class Trans4x4DCT class Trans4x4DCT : public Trans4x4TestBase,
: public Trans4x4TestBase, public ::testing::TestWithParam<Dct4x4Param> {
public ::testing::TestWithParam<Dct4x4Param> {
public: public:
virtual ~Trans4x4DCT() {} virtual ~Trans4x4DCT() {}
virtual void SetUp() { virtual void SetUp() {
fwd_txfm_ = GET_PARAM(0); fwd_txfm_ = GET_PARAM(0);
inv_txfm_ = GET_PARAM(1); inv_txfm_ = GET_PARAM(1);
tx_type_ = GET_PARAM(2); tx_type_ = GET_PARAM(2);
pitch_ = 4; pitch_ = 4;
fwd_txfm_ref = fdct4x4_ref; fwd_txfm_ref = fdct4x4_ref;
bit_depth_ = GET_PARAM(3); bit_depth_ = GET_PARAM(3);
mask_ = (1 << bit_depth_) - 1; mask_ = (1 << bit_depth_) - 1;
@ -307,33 +301,24 @@ class Trans4x4DCT
IdctFunc inv_txfm_; IdctFunc inv_txfm_;
}; };
TEST_P(Trans4x4DCT, AccuracyCheck) { TEST_P(Trans4x4DCT, AccuracyCheck) { RunAccuracyCheck(1); }
RunAccuracyCheck(1);
}
TEST_P(Trans4x4DCT, CoeffCheck) { TEST_P(Trans4x4DCT, CoeffCheck) { RunCoeffCheck(); }
RunCoeffCheck();
}
TEST_P(Trans4x4DCT, MemCheck) { TEST_P(Trans4x4DCT, MemCheck) { RunMemCheck(); }
RunMemCheck();
}
TEST_P(Trans4x4DCT, InvAccuracyCheck) { TEST_P(Trans4x4DCT, InvAccuracyCheck) { RunInvAccuracyCheck(1); }
RunInvAccuracyCheck(1);
}
class Trans4x4HT class Trans4x4HT : public Trans4x4TestBase,
: public Trans4x4TestBase, public ::testing::TestWithParam<Ht4x4Param> {
public ::testing::TestWithParam<Ht4x4Param> {
public: public:
virtual ~Trans4x4HT() {} virtual ~Trans4x4HT() {}
virtual void SetUp() { virtual void SetUp() {
fwd_txfm_ = GET_PARAM(0); fwd_txfm_ = GET_PARAM(0);
inv_txfm_ = GET_PARAM(1); inv_txfm_ = GET_PARAM(1);
tx_type_ = GET_PARAM(2); tx_type_ = GET_PARAM(2);
pitch_ = 4; pitch_ = 4;
fwd_txfm_ref = fht4x4_ref; fwd_txfm_ref = fht4x4_ref;
bit_depth_ = GET_PARAM(3); bit_depth_ = GET_PARAM(3);
mask_ = (1 << bit_depth_) - 1; mask_ = (1 << bit_depth_) - 1;
@ -353,33 +338,24 @@ class Trans4x4HT
IhtFunc inv_txfm_; IhtFunc inv_txfm_;
}; };
TEST_P(Trans4x4HT, AccuracyCheck) { TEST_P(Trans4x4HT, AccuracyCheck) { RunAccuracyCheck(1); }
RunAccuracyCheck(1);
}
TEST_P(Trans4x4HT, CoeffCheck) { TEST_P(Trans4x4HT, CoeffCheck) { RunCoeffCheck(); }
RunCoeffCheck();
}
TEST_P(Trans4x4HT, MemCheck) { TEST_P(Trans4x4HT, MemCheck) { RunMemCheck(); }
RunMemCheck();
}
TEST_P(Trans4x4HT, InvAccuracyCheck) { TEST_P(Trans4x4HT, InvAccuracyCheck) { RunInvAccuracyCheck(1); }
RunInvAccuracyCheck(1);
}
class Trans4x4WHT class Trans4x4WHT : public Trans4x4TestBase,
: public Trans4x4TestBase, public ::testing::TestWithParam<Dct4x4Param> {
public ::testing::TestWithParam<Dct4x4Param> {
public: public:
virtual ~Trans4x4WHT() {} virtual ~Trans4x4WHT() {}
virtual void SetUp() { virtual void SetUp() {
fwd_txfm_ = GET_PARAM(0); fwd_txfm_ = GET_PARAM(0);
inv_txfm_ = GET_PARAM(1); inv_txfm_ = GET_PARAM(1);
tx_type_ = GET_PARAM(2); tx_type_ = GET_PARAM(2);
pitch_ = 4; pitch_ = 4;
fwd_txfm_ref = fwht4x4_ref; fwd_txfm_ref = fwht4x4_ref;
bit_depth_ = GET_PARAM(3); bit_depth_ = GET_PARAM(3);
mask_ = (1 << bit_depth_) - 1; mask_ = (1 << bit_depth_) - 1;
@ -398,21 +374,13 @@ class Trans4x4WHT
IdctFunc inv_txfm_; IdctFunc inv_txfm_;
}; };
TEST_P(Trans4x4WHT, AccuracyCheck) { TEST_P(Trans4x4WHT, AccuracyCheck) { RunAccuracyCheck(0); }
RunAccuracyCheck(0);
}
TEST_P(Trans4x4WHT, CoeffCheck) { TEST_P(Trans4x4WHT, CoeffCheck) { RunCoeffCheck(); }
RunCoeffCheck();
}
TEST_P(Trans4x4WHT, MemCheck) { TEST_P(Trans4x4WHT, MemCheck) { RunMemCheck(); }
RunMemCheck();
}
TEST_P(Trans4x4WHT, InvAccuracyCheck) { TEST_P(Trans4x4WHT, InvAccuracyCheck) { RunInvAccuracyCheck(0); }
RunInvAccuracyCheck(0);
}
using std::tr1::make_tuple; using std::tr1::make_tuple;
#if CONFIG_VP9_HIGHBITDEPTH #if CONFIG_VP9_HIGHBITDEPTH
@ -423,10 +391,10 @@ INSTANTIATE_TEST_CASE_P(
make_tuple(&vpx_highbd_fdct4x4_c, &idct4x4_12, 0, VPX_BITS_12), make_tuple(&vpx_highbd_fdct4x4_c, &idct4x4_12, 0, VPX_BITS_12),
make_tuple(&vpx_fdct4x4_c, &vpx_idct4x4_16_add_c, 0, VPX_BITS_8))); make_tuple(&vpx_fdct4x4_c, &vpx_idct4x4_16_add_c, 0, VPX_BITS_8)));
#else #else
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(C, Trans4x4DCT,
C, Trans4x4DCT, ::testing::Values(make_tuple(&vpx_fdct4x4_c,
::testing::Values( &vpx_idct4x4_16_add_c, 0,
make_tuple(&vpx_fdct4x4_c, &vpx_idct4x4_16_add_c, 0, VPX_BITS_8))); VPX_BITS_8)));
#endif // CONFIG_VP9_HIGHBITDEPTH #endif // CONFIG_VP9_HIGHBITDEPTH
#if CONFIG_VP9_HIGHBITDEPTH #if CONFIG_VP9_HIGHBITDEPTH
@ -463,18 +431,17 @@ INSTANTIATE_TEST_CASE_P(
make_tuple(&vp9_highbd_fwht4x4_c, &iwht4x4_12, 0, VPX_BITS_12), make_tuple(&vp9_highbd_fwht4x4_c, &iwht4x4_12, 0, VPX_BITS_12),
make_tuple(&vp9_fwht4x4_c, &vpx_iwht4x4_16_add_c, 0, VPX_BITS_8))); make_tuple(&vp9_fwht4x4_c, &vpx_iwht4x4_16_add_c, 0, VPX_BITS_8)));
#else #else
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(C, Trans4x4WHT,
C, Trans4x4WHT, ::testing::Values(make_tuple(&vp9_fwht4x4_c,
::testing::Values( &vpx_iwht4x4_16_add_c, 0,
make_tuple(&vp9_fwht4x4_c, &vpx_iwht4x4_16_add_c, 0, VPX_BITS_8))); VPX_BITS_8)));
#endif // CONFIG_VP9_HIGHBITDEPTH #endif // CONFIG_VP9_HIGHBITDEPTH
#if HAVE_NEON_ASM && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE #if HAVE_NEON_ASM && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(NEON, Trans4x4DCT,
NEON, Trans4x4DCT, ::testing::Values(make_tuple(&vpx_fdct4x4_c,
::testing::Values( &vpx_idct4x4_16_add_neon,
make_tuple(&vpx_fdct4x4_c, 0, VPX_BITS_8)));
&vpx_idct4x4_16_add_neon, 0, VPX_BITS_8)));
#endif // HAVE_NEON_ASM && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE #endif // HAVE_NEON_ASM && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
#if HAVE_NEON && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE #if HAVE_NEON && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
@ -496,11 +463,10 @@ INSTANTIATE_TEST_CASE_P(
#endif #endif
#if HAVE_SSE2 && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE #if HAVE_SSE2 && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(SSE2, Trans4x4DCT,
SSE2, Trans4x4DCT, ::testing::Values(make_tuple(&vpx_fdct4x4_sse2,
::testing::Values( &vpx_idct4x4_16_add_sse2,
make_tuple(&vpx_fdct4x4_sse2, 0, VPX_BITS_8)));
&vpx_idct4x4_16_add_sse2, 0, VPX_BITS_8)));
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
SSE2, Trans4x4HT, SSE2, Trans4x4HT,
::testing::Values( ::testing::Values(
@ -514,12 +480,11 @@ INSTANTIATE_TEST_CASE_P(
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
SSE2, Trans4x4DCT, SSE2, Trans4x4DCT,
::testing::Values( ::testing::Values(
make_tuple(&vpx_highbd_fdct4x4_c, &idct4x4_10_sse2, 0, VPX_BITS_10), make_tuple(&vpx_highbd_fdct4x4_c, &idct4x4_10_sse2, 0, VPX_BITS_10),
make_tuple(&vpx_highbd_fdct4x4_sse2, &idct4x4_10_sse2, 0, VPX_BITS_10), make_tuple(&vpx_highbd_fdct4x4_sse2, &idct4x4_10_sse2, 0, VPX_BITS_10),
make_tuple(&vpx_highbd_fdct4x4_c, &idct4x4_12_sse2, 0, VPX_BITS_12), make_tuple(&vpx_highbd_fdct4x4_c, &idct4x4_12_sse2, 0, VPX_BITS_12),
make_tuple(&vpx_highbd_fdct4x4_sse2, &idct4x4_12_sse2, 0, VPX_BITS_12), make_tuple(&vpx_highbd_fdct4x4_sse2, &idct4x4_12_sse2, 0, VPX_BITS_12),
make_tuple(&vpx_fdct4x4_sse2, &vpx_idct4x4_16_add_c, 0, make_tuple(&vpx_fdct4x4_sse2, &vpx_idct4x4_16_add_c, 0, VPX_BITS_8)));
VPX_BITS_8)));
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
SSE2, Trans4x4HT, SSE2, Trans4x4HT,
@ -531,10 +496,10 @@ INSTANTIATE_TEST_CASE_P(
#endif // HAVE_SSE2 && CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE #endif // HAVE_SSE2 && CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
#if HAVE_MSA && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE #if HAVE_MSA && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(MSA, Trans4x4DCT,
MSA, Trans4x4DCT, ::testing::Values(make_tuple(&vpx_fdct4x4_msa,
::testing::Values( &vpx_idct4x4_16_add_msa, 0,
make_tuple(&vpx_fdct4x4_msa, &vpx_idct4x4_16_add_msa, 0, VPX_BITS_8))); VPX_BITS_8)));
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
MSA, Trans4x4HT, MSA, Trans4x4HT,
::testing::Values( ::testing::Values(

227
test/fdct8x8_test.cc
View File

@ -53,8 +53,7 @@ void reference_8x8_dct_1d(const double in[8], double out[8]) {
out[k] = 0.0; out[k] = 0.0;
for (int n = 0; n < 8; n++) for (int n = 0; n < 8; n++)
out[k] += in[n] * cos(kPi * (2 * n + 1) * k / 16.0); out[k] += in[n] * cos(kPi * (2 * n + 1) * k / 16.0);
if (k == 0) if (k == 0) out[k] = out[k] * kInvSqrt2;
out[k] = out[k] * kInvSqrt2;
} }
} }
@ -63,25 +62,20 @@ void reference_8x8_dct_2d(const int16_t input[kNumCoeffs],
// First transform columns // First transform columns
for (int i = 0; i < 8; ++i) { for (int i = 0; i < 8; ++i) {
double temp_in[8], temp_out[8]; double temp_in[8], temp_out[8];
for (int j = 0; j < 8; ++j) for (int j = 0; j < 8; ++j) temp_in[j] = input[j * 8 + i];
temp_in[j] = input[j*8 + i];
reference_8x8_dct_1d(temp_in, temp_out); reference_8x8_dct_1d(temp_in, temp_out);
for (int j = 0; j < 8; ++j) for (int j = 0; j < 8; ++j) output[j * 8 + i] = temp_out[j];
output[j * 8 + i] = temp_out[j];
} }
// Then transform rows // Then transform rows
for (int i = 0; i < 8; ++i) { for (int i = 0; i < 8; ++i) {
double temp_in[8], temp_out[8]; double temp_in[8], temp_out[8];
for (int j = 0; j < 8; ++j) for (int j = 0; j < 8; ++j) temp_in[j] = output[j + i * 8];
temp_in[j] = output[j + i*8];
reference_8x8_dct_1d(temp_in, temp_out); reference_8x8_dct_1d(temp_in, temp_out);
// Scale by some magic number // Scale by some magic number
for (int j = 0; j < 8; ++j) for (int j = 0; j < 8; ++j) output[j + i * 8] = temp_out[j] * 2;
output[j + i * 8] = temp_out[j] * 2;
} }
} }
void fdct8x8_ref(const int16_t *in, tran_low_t *out, int stride, void fdct8x8_ref(const int16_t *in, tran_low_t *out, int stride,
int /*tx_type*/) { int /*tx_type*/) {
vpx_fdct8x8_c(in, out, stride); vpx_fdct8x8_c(in, out, stride);
@ -177,8 +171,7 @@ class FwdTrans8x8TestBase {
<< 1. * max_diff / count_test_block * 100 << "%" << 1. * max_diff / count_test_block * 100 << "%"
<< " for input range [-255, 255] at index " << j << " for input range [-255, 255] at index " << j
<< " count0: " << count_sign_block[j][0] << " count0: " << count_sign_block[j][0]
<< " count1: " << count_sign_block[j][1] << " count1: " << count_sign_block[j][1] << " diff: " << diff;
<< " diff: " << diff;
} }
memset(count_sign_block, 0, sizeof(count_sign_block)); memset(count_sign_block, 0, sizeof(count_sign_block));
@ -186,8 +179,8 @@ class FwdTrans8x8TestBase {
for (int i = 0; i < count_test_block; ++i) { for (int i = 0; i < count_test_block; ++i) {
// Initialize a test block with input range [-mask_ / 16, mask_ / 16]. // Initialize a test block with input range [-mask_ / 16, mask_ / 16].
for (int j = 0; j < 64; ++j) for (int j = 0; j < 64; ++j)
test_input_block[j] = ((rnd.Rand16() & mask_) >> 4) - test_input_block[j] =
((rnd.Rand16() & mask_) >> 4); ((rnd.Rand16() & mask_) >> 4) - ((rnd.Rand16() & mask_) >> 4);
ASM_REGISTER_STATE_CHECK( ASM_REGISTER_STATE_CHECK(
RunFwdTxfm(test_input_block, test_output_block, pitch_)); RunFwdTxfm(test_input_block, test_output_block, pitch_));
@ -207,8 +200,7 @@ class FwdTrans8x8TestBase {
<< 1. * max_diff / count_test_block * 100 << "%" << 1. * max_diff / count_test_block * 100 << "%"
<< " for input range [-15, 15] at index " << j << " for input range [-15, 15] at index " << j
<< " count0: " << count_sign_block[j][0] << " count0: " << count_sign_block[j][0]
<< " count1: " << count_sign_block[j][1] << " count1: " << count_sign_block[j][1] << " diff: " << diff;
<< " diff: " << diff;
} }
} }
@ -245,19 +237,18 @@ class FwdTrans8x8TestBase {
ASM_REGISTER_STATE_CHECK( ASM_REGISTER_STATE_CHECK(
RunFwdTxfm(test_input_block, test_temp_block, pitch_)); RunFwdTxfm(test_input_block, test_temp_block, pitch_));
for (int j = 0; j < 64; ++j) { for (int j = 0; j < 64; ++j) {
if (test_temp_block[j] > 0) { if (test_temp_block[j] > 0) {
test_temp_block[j] += 2; test_temp_block[j] += 2;
test_temp_block[j] /= 4; test_temp_block[j] /= 4;
test_temp_block[j] *= 4; test_temp_block[j] *= 4;
} else { } else {
test_temp_block[j] -= 2; test_temp_block[j] -= 2;
test_temp_block[j] /= 4; test_temp_block[j] /= 4;
test_temp_block[j] *= 4; test_temp_block[j] *= 4;
} }
} }
if (bit_depth_ == VPX_BITS_8) { if (bit_depth_ == VPX_BITS_8) {
ASM_REGISTER_STATE_CHECK( ASM_REGISTER_STATE_CHECK(RunInvTxfm(test_temp_block, dst, pitch_));
RunInvTxfm(test_temp_block, dst, pitch_));
#if CONFIG_VP9_HIGHBITDEPTH #if CONFIG_VP9_HIGHBITDEPTH
} else { } else {
ASM_REGISTER_STATE_CHECK( ASM_REGISTER_STATE_CHECK(
@ -273,19 +264,18 @@ class FwdTrans8x8TestBase {
const int diff = dst[j] - src[j]; const int diff = dst[j] - src[j];
#endif #endif
const int error = diff * diff; const int error = diff * diff;
if (max_error < error) if (max_error < error) max_error = error;
max_error = error;
total_error += error; total_error += error;
} }
} }
EXPECT_GE(1 << 2 * (bit_depth_ - 8), max_error) EXPECT_GE(1 << 2 * (bit_depth_ - 8), max_error)
<< "Error: 8x8 FDCT/IDCT or FHT/IHT has an individual" << "Error: 8x8 FDCT/IDCT or FHT/IHT has an individual"
<< " roundtrip error > 1"; << " roundtrip error > 1";
EXPECT_GE((count_test_block << 2 * (bit_depth_ - 8))/5, total_error) EXPECT_GE((count_test_block << 2 * (bit_depth_ - 8)) / 5, total_error)
<< "Error: 8x8 FDCT/IDCT or FHT/IHT has average roundtrip " << "Error: 8x8 FDCT/IDCT or FHT/IHT has average roundtrip "
<< "error > 1/5 per block"; << "error > 1/5 per block";
} }
void RunExtremalCheck() { void RunExtremalCheck() {
@ -341,8 +331,7 @@ class FwdTrans8x8TestBase {
ASM_REGISTER_STATE_CHECK( ASM_REGISTER_STATE_CHECK(
fwd_txfm_ref(test_input_block, ref_temp_block, pitch_, tx_type_)); fwd_txfm_ref(test_input_block, ref_temp_block, pitch_, tx_type_));
if (bit_depth_ == VPX_BITS_8) { if (bit_depth_ == VPX_BITS_8) {
ASM_REGISTER_STATE_CHECK( ASM_REGISTER_STATE_CHECK(RunInvTxfm(test_temp_block, dst, pitch_));
RunInvTxfm(test_temp_block, dst, pitch_));
#if CONFIG_VP9_HIGHBITDEPTH #if CONFIG_VP9_HIGHBITDEPTH
} else { } else {
ASM_REGISTER_STATE_CHECK( ASM_REGISTER_STATE_CHECK(
@ -358,8 +347,7 @@ class FwdTrans8x8TestBase {
const int diff = dst[j] - src[j]; const int diff = dst[j] - src[j];
#endif #endif
const int error = diff * diff; const int error = diff * diff;
if (max_error < error) if (max_error < error) max_error = error;
max_error = error;
total_error += error; total_error += error;
const int coeff_diff = test_temp_block[j] - ref_temp_block[j]; const int coeff_diff = test_temp_block[j] - ref_temp_block[j];
@ -370,7 +358,7 @@ class FwdTrans8x8TestBase {
<< "Error: Extremal 8x8 FDCT/IDCT or FHT/IHT has" << "Error: Extremal 8x8 FDCT/IDCT or FHT/IHT has"
<< "an individual roundtrip error > 1"; << "an individual roundtrip error > 1";
EXPECT_GE((count_test_block << 2 * (bit_depth_ - 8))/5, total_error) EXPECT_GE((count_test_block << 2 * (bit_depth_ - 8)) / 5, total_error)
<< "Error: Extremal 8x8 FDCT/IDCT or FHT/IHT has average" << "Error: Extremal 8x8 FDCT/IDCT or FHT/IHT has average"
<< " roundtrip error > 1/5 per block"; << " roundtrip error > 1/5 per block";
@ -418,8 +406,8 @@ class FwdTrans8x8TestBase {
ASM_REGISTER_STATE_CHECK(RunInvTxfm(coeff, dst, pitch_)); ASM_REGISTER_STATE_CHECK(RunInvTxfm(coeff, dst, pitch_));
#if CONFIG_VP9_HIGHBITDEPTH #if CONFIG_VP9_HIGHBITDEPTH
} else { } else {
ASM_REGISTER_STATE_CHECK(RunInvTxfm(coeff, CONVERT_TO_BYTEPTR(dst16), ASM_REGISTER_STATE_CHECK(
pitch_)); RunInvTxfm(coeff, CONVERT_TO_BYTEPTR(dst16), pitch_));
#endif #endif
} }
@ -432,8 +420,7 @@ class FwdTrans8x8TestBase {
#endif #endif
const uint32_t error = diff * diff; const uint32_t error = diff * diff;
EXPECT_GE(1u << 2 * (bit_depth_ - 8), error) EXPECT_GE(1u << 2 * (bit_depth_ - 8), error)
<< "Error: 8x8 IDCT has error " << error << "Error: 8x8 IDCT has error " << error << " at index " << j;
<< " at index " << j;
} }
} }
} }
@ -461,13 +448,12 @@ class FwdTrans8x8TestBase {
const int32_t diff = coeff[j] - coeff_r[j]; const int32_t diff = coeff[j] - coeff_r[j];
const uint32_t error = diff * diff; const uint32_t error = diff * diff;
EXPECT_GE(9u << 2 * (bit_depth_ - 8), error) EXPECT_GE(9u << 2 * (bit_depth_ - 8), error)
<< "Error: 8x8 DCT has error " << error << "Error: 8x8 DCT has error " << error << " at index " << j;
<< " at index " << j;
} }
} }
} }
void CompareInvReference(IdctFunc ref_txfm, int thresh) { void CompareInvReference(IdctFunc ref_txfm, int thresh) {
ACMRandom rnd(ACMRandom::DeterministicSeed()); ACMRandom rnd(ACMRandom::DeterministicSeed());
const int count_test_block = 10000; const int count_test_block = 10000;
const int eob = 12; const int eob = 12;
@ -484,7 +470,7 @@ void CompareInvReference(IdctFunc ref_txfm, int thresh) {
for (int j = 0; j < kNumCoeffs; ++j) { for (int j = 0; j < kNumCoeffs; ++j) {
if (j < eob) { if (j < eob) {
// Random values less than the threshold, either positive or negative // Random values less than the threshold, either positive or negative
coeff[scan[j]] = rnd(thresh) * (1-2*(i%2)); coeff[scan[j]] = rnd(thresh) * (1 - 2 * (i % 2));
} else { } else {
coeff[scan[j]] = 0; coeff[scan[j]] = 0;
} }
@ -504,8 +490,8 @@ void CompareInvReference(IdctFunc ref_txfm, int thresh) {
#if CONFIG_VP9_HIGHBITDEPTH #if CONFIG_VP9_HIGHBITDEPTH
} else { } else {
ref_txfm(coeff, CONVERT_TO_BYTEPTR(ref16), pitch_); ref_txfm(coeff, CONVERT_TO_BYTEPTR(ref16), pitch_);
ASM_REGISTER_STATE_CHECK(RunInvTxfm(coeff, CONVERT_TO_BYTEPTR(dst16), ASM_REGISTER_STATE_CHECK(
pitch_)); RunInvTxfm(coeff, CONVERT_TO_BYTEPTR(dst16), pitch_));
#endif #endif
} }
@ -517,9 +503,8 @@ void CompareInvReference(IdctFunc ref_txfm, int thresh) {
const int diff = dst[j] - ref[j]; const int diff = dst[j] - ref[j];
#endif #endif
const uint32_t error = diff * diff; const uint32_t error = diff * diff;
EXPECT_EQ(0u, error) EXPECT_EQ(0u, error) << "Error: 8x8 IDCT has error " << error
<< "Error: 8x8 IDCT has error " << error << " at index " << j;
<< " at index " << j;
} }
} }
} }
@ -530,17 +515,16 @@ void CompareInvReference(IdctFunc ref_txfm, int thresh) {
int mask_; int mask_;
}; };
class FwdTrans8x8DCT class FwdTrans8x8DCT : public FwdTrans8x8TestBase,
: public FwdTrans8x8TestBase, public ::testing::TestWithParam<Dct8x8Param> {
public ::testing::TestWithParam<Dct8x8Param> {
public: public:
virtual ~FwdTrans8x8DCT() {} virtual ~FwdTrans8x8DCT() {}
virtual void SetUp() { virtual void SetUp() {
fwd_txfm_ = GET_PARAM(0); fwd_txfm_ = GET_PARAM(0);
inv_txfm_ = GET_PARAM(1); inv_txfm_ = GET_PARAM(1);
tx_type_ = GET_PARAM(2); tx_type_ = GET_PARAM(2);
pitch_ = 8; pitch_ = 8;
fwd_txfm_ref = fdct8x8_ref; fwd_txfm_ref = fdct8x8_ref;
bit_depth_ = GET_PARAM(3); bit_depth_ = GET_PARAM(3);
mask_ = (1 << bit_depth_) - 1; mask_ = (1 << bit_depth_) - 1;
@ -560,37 +544,26 @@ class FwdTrans8x8DCT
IdctFunc inv_txfm_; IdctFunc inv_txfm_;
}; };
TEST_P(FwdTrans8x8DCT, SignBiasCheck) { TEST_P(FwdTrans8x8DCT, SignBiasCheck) { RunSignBiasCheck(); }
RunSignBiasCheck();
}
TEST_P(FwdTrans8x8DCT, RoundTripErrorCheck) { TEST_P(FwdTrans8x8DCT, RoundTripErrorCheck) { RunRoundTripErrorCheck(); }
RunRoundTripErrorCheck();
}
TEST_P(FwdTrans8x8DCT, ExtremalCheck) { TEST_P(FwdTrans8x8DCT, ExtremalCheck) { RunExtremalCheck(); }
RunExtremalCheck();
}
TEST_P(FwdTrans8x8DCT, FwdAccuracyCheck) { TEST_P(FwdTrans8x8DCT, FwdAccuracyCheck) { RunFwdAccuracyCheck(); }
RunFwdAccuracyCheck();
}
TEST_P(FwdTrans8x8DCT, InvAccuracyCheck) { TEST_P(FwdTrans8x8DCT, InvAccuracyCheck) { RunInvAccuracyCheck(); }
RunInvAccuracyCheck();
}
class FwdTrans8x8HT class FwdTrans8x8HT : public FwdTrans8x8TestBase,
: public FwdTrans8x8TestBase, public ::testing::TestWithParam<Ht8x8Param> {
public ::testing::TestWithParam<Ht8x8Param> {
public: public:
virtual ~FwdTrans8x8HT() {} virtual ~FwdTrans8x8HT() {}
virtual void SetUp() { virtual void SetUp() {
fwd_txfm_ = GET_PARAM(0); fwd_txfm_ = GET_PARAM(0);
inv_txfm_ = GET_PARAM(1); inv_txfm_ = GET_PARAM(1);
tx_type_ = GET_PARAM(2); tx_type_ = GET_PARAM(2);
pitch_ = 8; pitch_ = 8;
fwd_txfm_ref = fht8x8_ref; fwd_txfm_ref = fht8x8_ref;
bit_depth_ = GET_PARAM(3); bit_depth_ = GET_PARAM(3);
mask_ = (1 << bit_depth_) - 1; mask_ = (1 << bit_depth_) - 1;
@ -610,21 +583,14 @@ class FwdTrans8x8HT
IhtFunc inv_txfm_; IhtFunc inv_txfm_;
}; };
TEST_P(FwdTrans8x8HT, SignBiasCheck) { TEST_P(FwdTrans8x8HT, SignBiasCheck) { RunSignBiasCheck(); }
RunSignBiasCheck();
}
TEST_P(FwdTrans8x8HT, RoundTripErrorCheck) { TEST_P(FwdTrans8x8HT, RoundTripErrorCheck) { RunRoundTripErrorCheck(); }
RunRoundTripErrorCheck();
}
TEST_P(FwdTrans8x8HT, ExtremalCheck) { TEST_P(FwdTrans8x8HT, ExtremalCheck) { RunExtremalCheck(); }
RunExtremalCheck();
}
class InvTrans8x8DCT class InvTrans8x8DCT : public FwdTrans8x8TestBase,
: public FwdTrans8x8TestBase, public ::testing::TestWithParam<Idct8x8Param> {
public ::testing::TestWithParam<Idct8x8Param> {
public: public:
virtual ~InvTrans8x8DCT() {} virtual ~InvTrans8x8DCT() {}
@ -664,10 +630,10 @@ INSTANTIATE_TEST_CASE_P(
make_tuple(&vpx_highbd_fdct8x8_c, &idct8x8_10, 0, VPX_BITS_10), make_tuple(&vpx_highbd_fdct8x8_c, &idct8x8_10, 0, VPX_BITS_10),
make_tuple(&vpx_highbd_fdct8x8_c, &idct8x8_12, 0, VPX_BITS_12))); make_tuple(&vpx_highbd_fdct8x8_c, &idct8x8_12, 0, VPX_BITS_12)));
#else #else
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(C, FwdTrans8x8DCT,
C, FwdTrans8x8DCT, ::testing::Values(make_tuple(&vpx_fdct8x8_c,
::testing::Values( &vpx_idct8x8_64_add_c, 0,
make_tuple(&vpx_fdct8x8_c, &vpx_idct8x8_64_add_c, 0, VPX_BITS_8))); VPX_BITS_8)));
#endif // CONFIG_VP9_HIGHBITDEPTH #endif // CONFIG_VP9_HIGHBITDEPTH
#if CONFIG_VP9_HIGHBITDEPTH #if CONFIG_VP9_HIGHBITDEPTH
@ -697,11 +663,10 @@ INSTANTIATE_TEST_CASE_P(
#endif // CONFIG_VP9_HIGHBITDEPTH #endif // CONFIG_VP9_HIGHBITDEPTH
#if HAVE_NEON_ASM && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE #if HAVE_NEON_ASM && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(NEON, FwdTrans8x8DCT,
NEON, FwdTrans8x8DCT, ::testing::Values(make_tuple(&vpx_fdct8x8_neon,
::testing::Values( &vpx_idct8x8_64_add_neon,
make_tuple(&vpx_fdct8x8_neon, &vpx_idct8x8_64_add_neon, 0, 0, VPX_BITS_8)));
VPX_BITS_8)));
#endif // HAVE_NEON_ASM && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE #endif // HAVE_NEON_ASM && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
#if HAVE_NEON && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE #if HAVE_NEON && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
@ -715,11 +680,10 @@ INSTANTIATE_TEST_CASE_P(
#endif // HAVE_NEON && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE #endif // HAVE_NEON && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
#if HAVE_SSE2 && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE #if HAVE_SSE2 && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(SSE2, FwdTrans8x8DCT,
SSE2, FwdTrans8x8DCT, ::testing::Values(make_tuple(&vpx_fdct8x8_sse2,
::testing::Values( &vpx_idct8x8_64_add_sse2,
make_tuple(&vpx_fdct8x8_sse2, &vpx_idct8x8_64_add_sse2, 0, 0, VPX_BITS_8)));
VPX_BITS_8)));
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
SSE2, FwdTrans8x8HT, SSE2, FwdTrans8x8HT,
::testing::Values( ::testing::Values(
@ -732,16 +696,16 @@ INSTANTIATE_TEST_CASE_P(
#if HAVE_SSE2 && CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE #if HAVE_SSE2 && CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
SSE2, FwdTrans8x8DCT, SSE2, FwdTrans8x8DCT,
::testing::Values( ::testing::Values(make_tuple(&vpx_fdct8x8_sse2, &vpx_idct8x8_64_add_c, 0,
make_tuple(&vpx_fdct8x8_sse2, &vpx_idct8x8_64_add_c, 0, VPX_BITS_8), VPX_BITS_8),
make_tuple(&vpx_highbd_fdct8x8_c, make_tuple(&vpx_highbd_fdct8x8_c, &idct8x8_64_add_10_sse2,
&idct8x8_64_add_10_sse2, 12, VPX_BITS_10), 12, VPX_BITS_10),
make_tuple(&vpx_highbd_fdct8x8_sse2, make_tuple(&vpx_highbd_fdct8x8_sse2,
&idct8x8_64_add_10_sse2, 12, VPX_BITS_10), &idct8x8_64_add_10_sse2, 12, VPX_BITS_10),
make_tuple(&vpx_highbd_fdct8x8_c, make_tuple(&vpx_highbd_fdct8x8_c, &idct8x8_64_add_12_sse2,
&idct8x8_64_add_12_sse2, 12, VPX_BITS_12), 12, VPX_BITS_12),
make_tuple(&vpx_highbd_fdct8x8_sse2, make_tuple(&vpx_highbd_fdct8x8_sse2,
&idct8x8_64_add_12_sse2, 12, VPX_BITS_12))); &idct8x8_64_add_12_sse2, 12, VPX_BITS_12)));
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
SSE2, FwdTrans8x8HT, SSE2, FwdTrans8x8HT,
@ -756,30 +720,27 @@ INSTANTIATE_TEST_CASE_P(
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
SSE2, InvTrans8x8DCT, SSE2, InvTrans8x8DCT,
::testing::Values( ::testing::Values(
make_tuple(&idct8x8_10_add_10_c, make_tuple(&idct8x8_10_add_10_c, &idct8x8_10_add_10_sse2, 6225,
&idct8x8_10_add_10_sse2, 6225, VPX_BITS_10), VPX_BITS_10),
make_tuple(&idct8x8_10, make_tuple(&idct8x8_10, &idct8x8_64_add_10_sse2, 6225, VPX_BITS_10),
&idct8x8_64_add_10_sse2, 6225, VPX_BITS_10), make_tuple(&idct8x8_10_add_12_c, &idct8x8_10_add_12_sse2, 6225,
make_tuple(&idct8x8_10_add_12_c, VPX_BITS_12),
&idct8x8_10_add_12_sse2, 6225, VPX_BITS_12), make_tuple(&idct8x8_12, &idct8x8_64_add_12_sse2, 6225, VPX_BITS_12)));
make_tuple(&idct8x8_12,
&idct8x8_64_add_12_sse2, 6225, VPX_BITS_12)));
#endif // HAVE_SSE2 && CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE #endif // HAVE_SSE2 && CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
#if HAVE_SSSE3 && ARCH_X86_64 && \ #if HAVE_SSSE3 && ARCH_X86_64 && !CONFIG_VP9_HIGHBITDEPTH && \
!CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE !CONFIG_EMULATE_HARDWARE
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(SSSE3, FwdTrans8x8DCT,
SSSE3, FwdTrans8x8DCT, ::testing::Values(make_tuple(&vpx_fdct8x8_ssse3,
::testing::Values( &vpx_idct8x8_64_add_ssse3,
make_tuple(&vpx_fdct8x8_ssse3, &vpx_idct8x8_64_add_ssse3, 0, 0, VPX_BITS_8)));
VPX_BITS_8)));
#endif #endif
#if HAVE_MSA && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE #if HAVE_MSA && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(MSA, FwdTrans8x8DCT,
MSA, FwdTrans8x8DCT, ::testing::Values(make_tuple(&vpx_fdct8x8_msa,
::testing::Values( &vpx_idct8x8_64_add_msa, 0,
make_tuple(&vpx_fdct8x8_msa, &vpx_idct8x8_64_add_msa, 0, VPX_BITS_8))); VPX_BITS_8)));
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
MSA, FwdTrans8x8HT, MSA, FwdTrans8x8HT,
::testing::Values( ::testing::Values(

25
test/frame_size_tests.cc
View File

@ -13,12 +13,11 @@
namespace { namespace {
class VP9FrameSizeTestsLarge class VP9FrameSizeTestsLarge : public ::libvpx_test::EncoderTest,
: public ::libvpx_test::EncoderTest, public ::testing::Test {
public ::testing::Test {
protected: protected:
VP9FrameSizeTestsLarge() : EncoderTest(&::libvpx_test::kVP9), VP9FrameSizeTestsLarge()
expected_res_(VPX_CODEC_OK) {} : EncoderTest(&::libvpx_test::kVP9), expected_res_(VPX_CODEC_OK) {}
virtual ~VP9FrameSizeTestsLarge() {} virtual ~VP9FrameSizeTestsLarge() {}
virtual void SetUp() { virtual void SetUp() {
@ -27,7 +26,7 @@ class VP9FrameSizeTestsLarge
} }
virtual bool HandleDecodeResult(const vpx_codec_err_t res_dec, virtual bool HandleDecodeResult(const vpx_codec_err_t res_dec,
const libvpx_test::VideoSource& /*video*/, const libvpx_test::VideoSource & /*video*/,
libvpx_test::Decoder *decoder) { libvpx_test::Decoder *decoder) {
EXPECT_EQ(expected_res_, res_dec) << decoder->DecodeError(); EXPECT_EQ(expected_res_, res_dec) << decoder->DecodeError();
return !::testing::Test::HasFailure(); return !::testing::Test::HasFailure();
@ -67,13 +66,13 @@ TEST_F(VP9FrameSizeTestsLarge, ValidSizes) {
expected_res_ = VPX_CODEC_OK; expected_res_ = VPX_CODEC_OK;
ASSERT_NO_FATAL_FAILURE(RunLoop(&video)); ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
#else #else
// This test produces a pretty large single frame allocation, (roughly // This test produces a pretty large single frame allocation, (roughly
// 25 megabits). The encoder allocates a good number of these frames // 25 megabits). The encoder allocates a good number of these frames
// one for each lag in frames (for 2 pass), and then one for each possible // one for each lag in frames (for 2 pass), and then one for each possible
// reference buffer (8) - we can end up with up to 30 buffers of roughly this // reference buffer (8) - we can end up with up to 30 buffers of roughly this
// size or almost 1 gig of memory. // size or almost 1 gig of memory.
// In total the allocations will exceed 2GiB which may cause a failure with // In total the allocations will exceed 2GiB which may cause a failure with
// mingw + wine, use a smaller size in that case. // mingw + wine, use a smaller size in that case.
#if defined(_WIN32) && !defined(_WIN64) || defined(__OS2__) #if defined(_WIN32) && !defined(_WIN64) || defined(__OS2__)
video.SetSize(4096, 3072); video.SetSize(4096, 3072);
#else #else

4
test/hadamard_test.cc
View File

@ -80,8 +80,8 @@ void reference_hadamard16x16(const int16_t *a, int a_stride, int16_t *b) {
const int16_t b3 = (a2 - a3) >> 1; const int16_t b3 = (a2 - a3) >> 1;
/* Store a 16 bit value. */ /* Store a 16 bit value. */
b[ 0] = b0 + b2; b[0] = b0 + b2;
b[ 64] = b1 + b3; b[64] = b1 + b3;
b[128] = b0 - b2; b[128] = b0 - b2;
b[192] = b1 - b3; b[192] = b1 - b3;

11
test/i420_video_source.h
View File

@ -21,14 +21,11 @@ namespace libvpx_test {
// so that we can do actual file encodes. // so that we can do actual file encodes.
class I420VideoSource : public YUVVideoSource { class I420VideoSource : public YUVVideoSource {
public: public:
I420VideoSource(const std::string &file_name, I420VideoSource(const std::string &file_name, unsigned int width,
unsigned int width, unsigned int height, unsigned int height, int rate_numerator, int rate_denominator,
int rate_numerator, int rate_denominator,
unsigned int start, int limit) unsigned int start, int limit)
: YUVVideoSource(file_name, VPX_IMG_FMT_I420, : YUVVideoSource(file_name, VPX_IMG_FMT_I420, width, height,
width, height, rate_numerator, rate_denominator, start, limit) {}
rate_numerator, rate_denominator,
start, limit) {}
}; };
} // namespace libvpx_test } // namespace libvpx_test

28
test/idct8x8_test.cc
View File

@ -29,9 +29,8 @@ void reference_dct_1d(double input[8], double output[8]) {
for (int k = 0; k < 8; k++) { for (int k = 0; k < 8; k++) {
output[k] = 0.0; output[k] = 0.0;
for (int n = 0; n < 8; n++) for (int n = 0; n < 8; n++)
output[k] += input[n]*cos(kPi*(2*n+1)*k/16.0); output[k] += input[n] * cos(kPi * (2 * n + 1) * k / 16.0);
if (k == 0) if (k == 0) output[k] = output[k] * kInvSqrt2;
output[k] = output[k]*kInvSqrt2;
} }
} }
@ -39,24 +38,19 @@ void reference_dct_2d(int16_t input[64], double output[64]) {
// First transform columns // First transform columns
for (int i = 0; i < 8; ++i) { for (int i = 0; i < 8; ++i) {
double temp_in[8], temp_out[8]; double temp_in[8], temp_out[8];
for (int j = 0; j < 8; ++j) for (int j = 0; j < 8; ++j) temp_in[j] = input[j * 8 + i];
temp_in[j] = input[j*8 + i];
reference_dct_1d(temp_in, temp_out); reference_dct_1d(temp_in, temp_out);
for (int j = 0; j < 8; ++j) for (int j = 0; j < 8; ++j) output[j * 8 + i] = temp_out[j];
output[j*8 + i] = temp_out[j];
} }
// Then transform rows // Then transform rows
for (int i = 0; i < 8; ++i) { for (int i = 0; i < 8; ++i) {
double temp_in[8], temp_out[8]; double temp_in[8], temp_out[8];
for (int j = 0; j < 8; ++j) for (int j = 0; j < 8; ++j) temp_in[j] = output[j + i * 8];
temp_in[j] = output[j + i*8];
reference_dct_1d(temp_in, temp_out); reference_dct_1d(temp_in, temp_out);
for (int j = 0; j < 8; ++j) for (int j = 0; j < 8; ++j) output[j + i * 8] = temp_out[j];
output[j + i*8] = temp_out[j];
} }
// Scale by some magic number // Scale by some magic number
for (int i = 0; i < 64; ++i) for (int i = 0; i < 64; ++i) output[i] *= 2;
output[i] *= 2;
} }
TEST(VP9Idct8x8Test, AccuracyCheck) { TEST(VP9Idct8x8Test, AccuracyCheck) {
@ -73,8 +67,7 @@ TEST(VP9Idct8x8Test, AccuracyCheck) {
dst[j] = rnd.Rand8(); dst[j] = rnd.Rand8();
} }
// Initialize a test block with input range [-255, 255]. // Initialize a test block with input range [-255, 255].
for (int j = 0; j < 64; ++j) for (int j = 0; j < 64; ++j) input[j] = src[j] - dst[j];
input[j] = src[j] - dst[j];
reference_dct_2d(input, output_r); reference_dct_2d(input, output_r);
for (int j = 0; j < 64; ++j) for (int j = 0; j < 64; ++j)
@ -83,9 +76,8 @@ TEST(VP9Idct8x8Test, AccuracyCheck) {
for (int j = 0; j < 64; ++j) { for (int j = 0; j < 64; ++j) {
const int diff = dst[j] - src[j]; const int diff = dst[j] - src[j];
const int error = diff * diff; const int error = diff * diff;
EXPECT_GE(1, error) EXPECT_GE(1, error) << "Error: 8x8 FDCT/IDCT has error " << error
<< "Error: 8x8 FDCT/IDCT has error " << error << " at index " << j;
<< " at index " << j;
} }
} }
} }

67
test/invalid_file_test.cc
View File

@ -34,21 +34,19 @@ std::ostream &operator<<(std::ostream &os, const DecodeParam &dp) {
return os << "threads: " << dp.threads << " file: " << dp.filename; return os << "threads: " << dp.threads << " file: " << dp.filename;
} }
class InvalidFileTest class InvalidFileTest : public ::libvpx_test::DecoderTest,
: public ::libvpx_test::DecoderTest, public ::libvpx_test::CodecTestWithParam<DecodeParam> {
public ::libvpx_test::CodecTestWithParam<DecodeParam> {
protected: protected:
InvalidFileTest() : DecoderTest(GET_PARAM(0)), res_file_(NULL) {} InvalidFileTest() : DecoderTest(GET_PARAM(0)), res_file_(NULL) {}
virtual ~InvalidFileTest() { virtual ~InvalidFileTest() {
if (res_file_ != NULL) if (res_file_ != NULL) fclose(res_file_);
fclose(res_file_);
} }
void OpenResFile(const std::string &res_file_name_) { void OpenResFile(const std::string &res_file_name_) {
res_file_ = libvpx_test::OpenTestDataFile(res_file_name_); res_file_ = libvpx_test::OpenTestDataFile(res_file_name_);
ASSERT_TRUE(res_file_ != NULL) << "Result file open failed. Filename: " ASSERT_TRUE(res_file_ != NULL) << "Result file open failed. Filename: "
<< res_file_name_; << res_file_name_;
} }
virtual bool HandleDecodeResult( virtual bool HandleDecodeResult(
@ -72,8 +70,9 @@ class InvalidFileTest
EXPECT_TRUE(res_dec == expected_res_dec || EXPECT_TRUE(res_dec == expected_res_dec ||
res_dec == VPX_CODEC_CORRUPT_FRAME) res_dec == VPX_CODEC_CORRUPT_FRAME)
<< "Results don't match: frame number = " << video.frame_number() << "Results don't match: frame number = " << video.frame_number()
<< ". (" << decoder->DecodeError() << "). Expected: " << ". (" << decoder->DecodeError()
<< expected_res_dec << " or " << VPX_CODEC_CORRUPT_FRAME; << "). Expected: " << expected_res_dec << " or "
<< VPX_CODEC_CORRUPT_FRAME;
} else { } else {
EXPECT_EQ(expected_res_dec, res_dec) EXPECT_EQ(expected_res_dec, res_dec)
<< "Results don't match: frame number = " << video.frame_number() << "Results don't match: frame number = " << video.frame_number()
@ -119,25 +118,23 @@ class InvalidFileTest
FILE *res_file_; FILE *res_file_;
}; };
TEST_P(InvalidFileTest, ReturnCode) { TEST_P(InvalidFileTest, ReturnCode) { RunTest(); }
RunTest();
}
const DecodeParam kVP9InvalidFileTests[] = { const DecodeParam kVP9InvalidFileTests[] = {
{1, "invalid-vp90-02-v2.webm"}, { 1, "invalid-vp90-02-v2.webm" },
#if CONFIG_VP9_HIGHBITDEPTH #if CONFIG_VP9_HIGHBITDEPTH
{1, "invalid-vp90-2-00-quantizer-00.webm.ivf.s5861_r01-05_b6-.v2.ivf"}, { 1, "invalid-vp90-2-00-quantizer-00.webm.ivf.s5861_r01-05_b6-.v2.ivf" },
#endif #endif
{1, "invalid-vp90-03-v3.webm"}, { 1, "invalid-vp90-03-v3.webm" },
{1, "invalid-vp90-2-00-quantizer-11.webm.ivf.s52984_r01-05_b6-.ivf"}, { 1, "invalid-vp90-2-00-quantizer-11.webm.ivf.s52984_r01-05_b6-.ivf" },
{1, "invalid-vp90-2-00-quantizer-11.webm.ivf.s52984_r01-05_b6-z.ivf"}, { 1, "invalid-vp90-2-00-quantizer-11.webm.ivf.s52984_r01-05_b6-z.ivf" },
{1, "invalid-vp90-2-12-droppable_1.ivf.s3676_r01-05_b6-.ivf"}, { 1, "invalid-vp90-2-12-droppable_1.ivf.s3676_r01-05_b6-.ivf" },
{1, "invalid-vp90-2-05-resize.ivf.s59293_r01-05_b6-.ivf"}, { 1, "invalid-vp90-2-05-resize.ivf.s59293_r01-05_b6-.ivf" },
{1, "invalid-vp90-2-09-subpixel-00.ivf.s20492_r01-05_b6-.v2.ivf"}, { 1, "invalid-vp90-2-09-subpixel-00.ivf.s20492_r01-05_b6-.v2.ivf" },
{1, "invalid-vp91-2-mixedrefcsp-444to420.ivf"}, { 1, "invalid-vp91-2-mixedrefcsp-444to420.ivf" },
{1, "invalid-vp90-2-12-droppable_1.ivf.s73804_r01-05_b6-.ivf"}, { 1, "invalid-vp90-2-12-droppable_1.ivf.s73804_r01-05_b6-.ivf" },
{1, "invalid-vp90-2-03-size-224x196.webm.ivf.s44156_r01-05_b6-.ivf"}, { 1, "invalid-vp90-2-03-size-224x196.webm.ivf.s44156_r01-05_b6-.ivf" },
{1, "invalid-vp90-2-03-size-202x210.webm.ivf.s113306_r01-05_b6-.ivf"}, { 1, "invalid-vp90-2-03-size-202x210.webm.ivf.s113306_r01-05_b6-.ivf" },
}; };
VP9_INSTANTIATE_TEST_CASE(InvalidFileTest, VP9_INSTANTIATE_TEST_CASE(InvalidFileTest,
@ -149,34 +146,34 @@ class InvalidFileInvalidPeekTest : public InvalidFileTest {
protected: protected:
InvalidFileInvalidPeekTest() : InvalidFileTest() {} InvalidFileInvalidPeekTest() : InvalidFileTest() {}
virtual void HandlePeekResult(libvpx_test::Decoder *const /*decoder*/, virtual void HandlePeekResult(libvpx_test::Decoder *const /*decoder*/,
libvpx_test::CompressedVideoSource* /*video*/, libvpx_test::CompressedVideoSource * /*video*/,
const vpx_codec_err_t /*res_peek*/) {} const vpx_codec_err_t /*res_peek*/) {}
}; };
TEST_P(InvalidFileInvalidPeekTest, ReturnCode) { TEST_P(InvalidFileInvalidPeekTest, ReturnCode) { RunTest(); }
RunTest();
}
const DecodeParam kVP9InvalidFileInvalidPeekTests[] = { const DecodeParam kVP9InvalidFileInvalidPeekTests[] = {
{1, "invalid-vp90-01-v3.webm"}, { 1, "invalid-vp90-01-v3.webm" },
}; };
VP9_INSTANTIATE_TEST_CASE(InvalidFileInvalidPeekTest, VP9_INSTANTIATE_TEST_CASE(InvalidFileInvalidPeekTest,
::testing::ValuesIn(kVP9InvalidFileInvalidPeekTests)); ::testing::ValuesIn(kVP9InvalidFileInvalidPeekTests));
const DecodeParam kMultiThreadedVP9InvalidFileTests[] = { const DecodeParam kMultiThreadedVP9InvalidFileTests[] = {
{4, "invalid-vp90-2-08-tile_1x4_frame_parallel_all_key.webm"}, { 4, "invalid-vp90-2-08-tile_1x4_frame_parallel_all_key.webm" },
{4, "invalid-" { 4,
"vp90-2-08-tile_1x2_frame_parallel.webm.ivf.s47039_r01-05_b6-.ivf"}, "invalid-"
{4, "invalid-vp90-2-08-tile_1x8_frame_parallel.webm.ivf.s288_r01-05_b6-.ivf"}, "vp90-2-08-tile_1x2_frame_parallel.webm.ivf.s47039_r01-05_b6-.ivf" },
{2, "invalid-vp90-2-09-aq2.webm.ivf.s3984_r01-05_b6-.v2.ivf"}, { 4,
{4, "invalid-vp90-2-09-subpixel-00.ivf.s19552_r01-05_b6-.v2.ivf"}, "invalid-vp90-2-08-tile_1x8_frame_parallel.webm.ivf.s288_r01-05_b6-.ivf" },
{ 2, "invalid-vp90-2-09-aq2.webm.ivf.s3984_r01-05_b6-.v2.ivf" },
{ 4, "invalid-vp90-2-09-subpixel-00.ivf.s19552_r01-05_b6-.v2.ivf" },
}; };
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
VP9MultiThreaded, InvalidFileTest, VP9MultiThreaded, InvalidFileTest,
::testing::Combine( ::testing::Combine(
::testing::Values( ::testing::Values(
static_cast<const libvpx_test::CodecFactory*>(&libvpx_test::kVP9)), static_cast<const libvpx_test::CodecFactory *>(&libvpx_test::kVP9)),
::testing::ValuesIn(kMultiThreadedVP9InvalidFileTests))); ::testing::ValuesIn(kMultiThreadedVP9InvalidFileTests)));
} // namespace } // namespace

23
test/ivf_video_source.h
View File

@ -29,19 +29,13 @@ static unsigned int MemGetLe32(const uint8_t *mem) {
class IVFVideoSource : public CompressedVideoSource { class IVFVideoSource : public CompressedVideoSource {
public: public:
explicit IVFVideoSource(const std::string &file_name) explicit IVFVideoSource(const std::string &file_name)
: file_name_(file_name), : file_name_(file_name), input_file_(NULL), compressed_frame_buf_(NULL),
input_file_(NULL), frame_sz_(0), frame_(0), end_of_file_(false) {}
compressed_frame_buf_(NULL),
frame_sz_(0),
frame_(0),
end_of_file_(false) {
}
virtual ~IVFVideoSource() { virtual ~IVFVideoSource() {
delete[] compressed_frame_buf_; delete[] compressed_frame_buf_;
if (input_file_) if (input_file_) fclose(input_file_);
fclose(input_file_);
} }
virtual void Init() { virtual void Init() {
@ -54,15 +48,16 @@ class IVFVideoSource : public CompressedVideoSource {
virtual void Begin() { virtual void Begin() {
input_file_ = OpenTestDataFile(file_name_); input_file_ = OpenTestDataFile(file_name_);
ASSERT_TRUE(input_file_ != NULL) << "Input file open failed. Filename: " ASSERT_TRUE(input_file_ != NULL) << "Input file open failed. Filename: "
<< file_name_; << file_name_;
// Read file header // Read file header
uint8_t file_hdr[kIvfFileHdrSize]; uint8_t file_hdr[kIvfFileHdrSize];
ASSERT_EQ(kIvfFileHdrSize, fread(file_hdr, 1, kIvfFileHdrSize, input_file_)) ASSERT_EQ(kIvfFileHdrSize, fread(file_hdr, 1, kIvfFileHdrSize, input_file_))
<< "File header read failed."; << "File header read failed.";
// Check file header // Check file header
ASSERT_TRUE(file_hdr[0] == 'D' && file_hdr[1] == 'K' && file_hdr[2] == 'I' ASSERT_TRUE(file_hdr[0] == 'D' && file_hdr[1] == 'K' &&
&& file_hdr[3] == 'F') << "Input is not an IVF file."; file_hdr[2] == 'I' && file_hdr[3] == 'F')
<< "Input is not an IVF file.";
FillFrame(); FillFrame();
} }
@ -76,8 +71,8 @@ class IVFVideoSource : public CompressedVideoSource {
ASSERT_TRUE(input_file_ != NULL); ASSERT_TRUE(input_file_ != NULL);
uint8_t frame_hdr[kIvfFrameHdrSize]; uint8_t frame_hdr[kIvfFrameHdrSize];
// Check frame header and read a frame from input_file. // Check frame header and read a frame from input_file.
if (fread(frame_hdr, 1, kIvfFrameHdrSize, input_file_) if (fread(frame_hdr, 1, kIvfFrameHdrSize, input_file_) !=
!= kIvfFrameHdrSize) { kIvfFrameHdrSize) {
end_of_file_ = true; end_of_file_ = true;
} else { } else {
end_of_file_ = false; end_of_file_ = false;

13
test/keyframe_test.cc
View File

@ -17,8 +17,9 @@
namespace { namespace {
class KeyframeTest : public ::libvpx_test::EncoderTest, class KeyframeTest
public ::libvpx_test::CodecTestWithParam<libvpx_test::TestMode> { : public ::libvpx_test::EncoderTest,
public ::libvpx_test::CodecTestWithParam<libvpx_test::TestMode> {
protected: protected:
KeyframeTest() : EncoderTest(GET_PARAM(0)) {} KeyframeTest() : EncoderTest(GET_PARAM(0)) {}
virtual ~KeyframeTest() {} virtual ~KeyframeTest() {}
@ -65,8 +66,7 @@ TEST_P(KeyframeTest, TestRandomVideoSource) {
// In realtime mode - auto placed keyframes are exceedingly rare, don't // In realtime mode - auto placed keyframes are exceedingly rare, don't
// bother with this check if(GetParam() > 0) // bother with this check if(GetParam() > 0)
if (GET_PARAM(1) > 0) if (GET_PARAM(1) > 0) EXPECT_GT(kf_count_, 1);
EXPECT_GT(kf_count_, 1);
} }
TEST_P(KeyframeTest, TestDisableKeyframes) { TEST_P(KeyframeTest, TestDisableKeyframes) {
@ -114,8 +114,7 @@ TEST_P(KeyframeTest, TestAutoKeyframe) {
// may not produce a keyframe like we expect. This is necessary when running // may not produce a keyframe like we expect. This is necessary when running
// on very slow environments (like Valgrind). The step -11 was determined // on very slow environments (like Valgrind). The step -11 was determined
// experimentally as the fastest mode that still throws the keyframe. // experimentally as the fastest mode that still throws the keyframe.
if (deadline_ == VPX_DL_REALTIME) if (deadline_ == VPX_DL_REALTIME) set_cpu_used_ = -11;
set_cpu_used_ = -11;
// This clip has a cut scene every 30 frames -> Frame 0, 30, 60, 90, 120. // This clip has a cut scene every 30 frames -> Frame 0, 30, 60, 90, 120.
// I check only the first 40 frames to make sure there's a keyframe at frame // I check only the first 40 frames to make sure there's a keyframe at frame
@ -135,7 +134,7 @@ TEST_P(KeyframeTest, TestAutoKeyframe) {
iter != kf_pts_list_.end(); ++iter) { iter != kf_pts_list_.end(); ++iter) {
if (deadline_ == VPX_DL_REALTIME && *iter > 0) if (deadline_ == VPX_DL_REALTIME && *iter > 0)
EXPECT_EQ(0, (*iter - 1) % 30) << "Unexpected keyframe at frame " EXPECT_EQ(0, (*iter - 1) % 30) << "Unexpected keyframe at frame "
<< *iter; << *iter;
else else
EXPECT_EQ(0, *iter % 30) << "Unexpected keyframe at frame " << *iter; EXPECT_EQ(0, *iter % 30) << "Unexpected keyframe at frame " << *iter;
} }

9
test/level_test.cc
View File

@ -19,12 +19,9 @@ class LevelTest
public ::libvpx_test::CodecTestWith2Params<libvpx_test::TestMode, int> { public ::libvpx_test::CodecTestWith2Params<libvpx_test::TestMode, int> {
protected: protected:
LevelTest() LevelTest()
: EncoderTest(GET_PARAM(0)), : EncoderTest(GET_PARAM(0)), encoding_mode_(GET_PARAM(1)),
encoding_mode_(GET_PARAM(1)), cpu_used_(GET_PARAM(2)), min_gf_internal_(24), target_level_(0),
cpu_used_(GET_PARAM(2)), level_(0) {}
min_gf_internal_(24),
target_level_(0),
level_(0) {}
virtual ~LevelTest() {} virtual ~LevelTest() {}
virtual void SetUp() { virtual void SetUp() {

492
test/lpf_8_test.cc
View File

@ -36,8 +36,7 @@ const int number_of_iterations = 10000;
#if CONFIG_VP9_HIGHBITDEPTH #if CONFIG_VP9_HIGHBITDEPTH
typedef void (*loop_op_t)(uint16_t *s, int p, const uint8_t *blimit, typedef void (*loop_op_t)(uint16_t *s, int p, const uint8_t *blimit,
const uint8_t *limit, const uint8_t *thresh, const uint8_t *limit, const uint8_t *thresh, int bd);
int bd);
typedef void (*dual_loop_op_t)(uint16_t *s, int p, const uint8_t *blimit0, typedef void (*dual_loop_op_t)(uint16_t *s, int p, const uint8_t *blimit0,
const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *limit0, const uint8_t *thresh0,
const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *blimit1, const uint8_t *limit1,
@ -108,21 +107,18 @@ TEST_P(Loop8Test6Param, OperationCheck) {
for (int i = 0; i < count_test_block; ++i) { for (int i = 0; i < count_test_block; ++i) {
int err_count = 0; int err_count = 0;
uint8_t tmp = static_cast<uint8_t>(rnd(3 * MAX_LOOP_FILTER + 4)); uint8_t tmp = static_cast<uint8_t>(rnd(3 * MAX_LOOP_FILTER + 4));
DECLARE_ALIGNED(16, const uint8_t, blimit[16]) = { DECLARE_ALIGNED(16, const uint8_t,
tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp, blimit[16]) = { tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp };
};
tmp = static_cast<uint8_t>(rnd(MAX_LOOP_FILTER)); tmp = static_cast<uint8_t>(rnd(MAX_LOOP_FILTER));
DECLARE_ALIGNED(16, const uint8_t, limit[16]) = { DECLARE_ALIGNED(16, const uint8_t,
tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp, limit[16]) = { tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp };
};
tmp = rnd.Rand8(); tmp = rnd.Rand8();
DECLARE_ALIGNED(16, const uint8_t, thresh[16]) = { DECLARE_ALIGNED(16, const uint8_t,
tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp, thresh[16]) = { tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp };
}; int32_t p = kNumCoeffs / 32;
int32_t p = kNumCoeffs/32;
uint16_t tmp_s[kNumCoeffs]; uint16_t tmp_s[kNumCoeffs];
int j = 0; int j = 0;
@ -158,7 +154,7 @@ TEST_P(Loop8Test6Param, OperationCheck) {
ASM_REGISTER_STATE_CHECK( ASM_REGISTER_STATE_CHECK(
loopfilter_op_(s + 8 + p * 8, p, blimit, limit, thresh, bd)); loopfilter_op_(s + 8 + p * 8, p, blimit, limit, thresh, bd));
#else #else
ref_loopfilter_op_(ref_s+8+p*8, p, blimit, limit, thresh); ref_loopfilter_op_(ref_s + 8 + p * 8, p, blimit, limit, thresh);
ASM_REGISTER_STATE_CHECK( ASM_REGISTER_STATE_CHECK(
loopfilter_op_(s + 8 + p * 8, p, blimit, limit, thresh)); loopfilter_op_(s + 8 + p * 8, p, blimit, limit, thresh));
#endif // CONFIG_VP9_HIGHBITDEPTH #endif // CONFIG_VP9_HIGHBITDEPTH
@ -206,20 +202,17 @@ TEST_P(Loop8Test6Param, ValueCheck) {
for (int i = 0; i < count_test_block; ++i) { for (int i = 0; i < count_test_block; ++i) {
int err_count = 0; int err_count = 0;
uint8_t tmp = static_cast<uint8_t>(rnd(3 * MAX_LOOP_FILTER + 4)); uint8_t tmp = static_cast<uint8_t>(rnd(3 * MAX_LOOP_FILTER + 4));
DECLARE_ALIGNED(16, const uint8_t, blimit[16]) = { DECLARE_ALIGNED(16, const uint8_t,
tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp, blimit[16]) = { tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp };
};
tmp = static_cast<uint8_t>(rnd(MAX_LOOP_FILTER)); tmp = static_cast<uint8_t>(rnd(MAX_LOOP_FILTER));
DECLARE_ALIGNED(16, const uint8_t, limit[16]) = { DECLARE_ALIGNED(16, const uint8_t,
tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp, limit[16]) = { tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp };
};
tmp = rnd.Rand8(); tmp = rnd.Rand8();
DECLARE_ALIGNED(16, const uint8_t, thresh[16]) = { DECLARE_ALIGNED(16, const uint8_t,
tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp, thresh[16]) = { tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp };
};
int32_t p = kNumCoeffs / 32; int32_t p = kNumCoeffs / 32;
for (int j = 0; j < kNumCoeffs; ++j) { for (int j = 0; j < kNumCoeffs; ++j) {
s[j] = rnd.Rand16() & mask_; s[j] = rnd.Rand16() & mask_;
@ -230,7 +223,7 @@ TEST_P(Loop8Test6Param, ValueCheck) {
ASM_REGISTER_STATE_CHECK( ASM_REGISTER_STATE_CHECK(
loopfilter_op_(s + 8 + p * 8, p, blimit, limit, thresh, bd)); loopfilter_op_(s + 8 + p * 8, p, blimit, limit, thresh, bd));
#else #else
ref_loopfilter_op_(ref_s+8+p*8, p, blimit, limit, thresh); ref_loopfilter_op_(ref_s + 8 + p * 8, p, blimit, limit, thresh);
ASM_REGISTER_STATE_CHECK( ASM_REGISTER_STATE_CHECK(
loopfilter_op_(s + 8 + p * 8, p, blimit, limit, thresh)); loopfilter_op_(s + 8 + p * 8, p, blimit, limit, thresh));
#endif // CONFIG_VP9_HIGHBITDEPTH #endif // CONFIG_VP9_HIGHBITDEPTH
@ -256,43 +249,37 @@ TEST_P(Loop8Test9Param, OperationCheck) {
DECLARE_ALIGNED(16, uint16_t, s[kNumCoeffs]); DECLARE_ALIGNED(16, uint16_t, s[kNumCoeffs]);
DECLARE_ALIGNED(16, uint16_t, ref_s[kNumCoeffs]); DECLARE_ALIGNED(16, uint16_t, ref_s[kNumCoeffs]);
#else #else
DECLARE_ALIGNED(8, uint8_t, s[kNumCoeffs]); DECLARE_ALIGNED(8, uint8_t, s[kNumCoeffs]);
DECLARE_ALIGNED(8, uint8_t, ref_s[kNumCoeffs]); DECLARE_ALIGNED(8, uint8_t, ref_s[kNumCoeffs]);
#endif // CONFIG_VP9_HIGHBITDEPTH #endif // CONFIG_VP9_HIGHBITDEPTH
int err_count_total = 0; int err_count_total = 0;
int first_failure = -1; int first_failure = -1;
for (int i = 0; i < count_test_block; ++i) { for (int i = 0; i < count_test_block; ++i) {
int err_count = 0; int err_count = 0;
uint8_t tmp = static_cast<uint8_t>(rnd(3 * MAX_LOOP_FILTER + 4)); uint8_t tmp = static_cast<uint8_t>(rnd(3 * MAX_LOOP_FILTER + 4));
DECLARE_ALIGNED(16, const uint8_t, blimit0[16]) = { DECLARE_ALIGNED(16, const uint8_t,
tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp, blimit0[16]) = { tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp };
};
tmp = static_cast<uint8_t>(rnd(MAX_LOOP_FILTER)); tmp = static_cast<uint8_t>(rnd(MAX_LOOP_FILTER));
DECLARE_ALIGNED(16, const uint8_t, limit0[16]) = { DECLARE_ALIGNED(16, const uint8_t,
tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp, limit0[16]) = { tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp };
};
tmp = rnd.Rand8(); tmp = rnd.Rand8();
DECLARE_ALIGNED(16, const uint8_t, thresh0[16]) = { DECLARE_ALIGNED(16, const uint8_t,
tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp, thresh0[16]) = { tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp };
};
tmp = static_cast<uint8_t>(rnd(3 * MAX_LOOP_FILTER + 4)); tmp = static_cast<uint8_t>(rnd(3 * MAX_LOOP_FILTER + 4));
DECLARE_ALIGNED(16, const uint8_t, blimit1[16]) = { DECLARE_ALIGNED(16, const uint8_t,
tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp, blimit1[16]) = { tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp };
};
tmp = static_cast<uint8_t>(rnd(MAX_LOOP_FILTER)); tmp = static_cast<uint8_t>(rnd(MAX_LOOP_FILTER));
DECLARE_ALIGNED(16, const uint8_t, limit1[16]) = { DECLARE_ALIGNED(16, const uint8_t,
tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp, limit1[16]) = { tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp };
};
tmp = rnd.Rand8(); tmp = rnd.Rand8();
DECLARE_ALIGNED(16, const uint8_t, thresh1[16]) = { DECLARE_ALIGNED(16, const uint8_t,
tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp, thresh1[16]) = { tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp };
};
int32_t p = kNumCoeffs / 32; int32_t p = kNumCoeffs / 32;
uint16_t tmp_s[kNumCoeffs]; uint16_t tmp_s[kNumCoeffs];
int j = 0; int j = 0;
@ -325,17 +312,16 @@ TEST_P(Loop8Test9Param, OperationCheck) {
ref_s[j] = s[j]; ref_s[j] = s[j];
} }
#if CONFIG_VP9_HIGHBITDEPTH #if CONFIG_VP9_HIGHBITDEPTH
ref_loopfilter_op_(ref_s + 8 + p * 8, p, blimit0, limit0, thresh0, ref_loopfilter_op_(ref_s + 8 + p * 8, p, blimit0, limit0, thresh0, blimit1,
blimit1, limit1, thresh1, bd); limit1, thresh1, bd);
ASM_REGISTER_STATE_CHECK( ASM_REGISTER_STATE_CHECK(loopfilter_op_(s + 8 + p * 8, p, blimit0, limit0,
loopfilter_op_(s + 8 + p * 8, p, blimit0, limit0, thresh0, thresh0, blimit1, limit1, thresh1,
blimit1, limit1, thresh1, bd)); bd));
#else #else
ref_loopfilter_op_(ref_s + 8 + p * 8, p, blimit0, limit0, thresh0, ref_loopfilter_op_(ref_s + 8 + p * 8, p, blimit0, limit0, thresh0, blimit1,
blimit1, limit1, thresh1); limit1, thresh1);
ASM_REGISTER_STATE_CHECK( ASM_REGISTER_STATE_CHECK(loopfilter_op_(s + 8 + p * 8, p, blimit0, limit0,
loopfilter_op_(s + 8 + p * 8, p, blimit0, limit0, thresh0, thresh0, blimit1, limit1, thresh1));
blimit1, limit1, thresh1));
#endif // CONFIG_VP9_HIGHBITDEPTH #endif // CONFIG_VP9_HIGHBITDEPTH
for (int j = 0; j < kNumCoeffs; ++j) { for (int j = 0; j < kNumCoeffs; ++j) {
err_count += ref_s[j] != s[j]; err_count += ref_s[j] != s[j];
@ -358,43 +344,37 @@ TEST_P(Loop8Test9Param, ValueCheck) {
DECLARE_ALIGNED(16, uint16_t, s[kNumCoeffs]); DECLARE_ALIGNED(16, uint16_t, s[kNumCoeffs]);
DECLARE_ALIGNED(16, uint16_t, ref_s[kNumCoeffs]); DECLARE_ALIGNED(16, uint16_t, ref_s[kNumCoeffs]);
#else #else
DECLARE_ALIGNED(8, uint8_t, s[kNumCoeffs]); DECLARE_ALIGNED(8, uint8_t, s[kNumCoeffs]);
DECLARE_ALIGNED(8, uint8_t, ref_s[kNumCoeffs]); DECLARE_ALIGNED(8, uint8_t, ref_s[kNumCoeffs]);
#endif // CONFIG_VP9_HIGHBITDEPTH #endif // CONFIG_VP9_HIGHBITDEPTH
int err_count_total = 0; int err_count_total = 0;
int first_failure = -1; int first_failure = -1;
for (int i = 0; i < count_test_block; ++i) { for (int i = 0; i < count_test_block; ++i) {
int err_count = 0; int err_count = 0;
uint8_t tmp = static_cast<uint8_t>(rnd(3 * MAX_LOOP_FILTER + 4)); uint8_t tmp = static_cast<uint8_t>(rnd(3 * MAX_LOOP_FILTER + 4));
DECLARE_ALIGNED(16, const uint8_t, blimit0[16]) = { DECLARE_ALIGNED(16, const uint8_t,
tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp, blimit0[16]) = { tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp };
};
tmp = static_cast<uint8_t>(rnd(MAX_LOOP_FILTER)); tmp = static_cast<uint8_t>(rnd(MAX_LOOP_FILTER));
DECLARE_ALIGNED(16, const uint8_t, limit0[16]) = { DECLARE_ALIGNED(16, const uint8_t,
tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp, limit0[16]) = { tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp };
};
tmp = rnd.Rand8(); tmp = rnd.Rand8();
DECLARE_ALIGNED(16, const uint8_t, thresh0[16]) = { DECLARE_ALIGNED(16, const uint8_t,
tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp, thresh0[16]) = { tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp };
};
tmp = static_cast<uint8_t>(rnd(3 * MAX_LOOP_FILTER + 4)); tmp = static_cast<uint8_t>(rnd(3 * MAX_LOOP_FILTER + 4));
DECLARE_ALIGNED(16, const uint8_t, blimit1[16]) = { DECLARE_ALIGNED(16, const uint8_t,
tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp, blimit1[16]) = { tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp };
};
tmp = static_cast<uint8_t>(rnd(MAX_LOOP_FILTER)); tmp = static_cast<uint8_t>(rnd(MAX_LOOP_FILTER));
DECLARE_ALIGNED(16, const uint8_t, limit1[16]) = { DECLARE_ALIGNED(16, const uint8_t,
tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp, limit1[16]) = { tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp };
};
tmp = rnd.Rand8(); tmp = rnd.Rand8();
DECLARE_ALIGNED(16, const uint8_t, thresh1[16]) = { DECLARE_ALIGNED(16, const uint8_t,
tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp, thresh1[16]) = { tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp };
};
int32_t p = kNumCoeffs / 32; // TODO(pdlf) can we have non-square here? int32_t p = kNumCoeffs / 32; // TODO(pdlf) can we have non-square here?
for (int j = 0; j < kNumCoeffs; ++j) { for (int j = 0; j < kNumCoeffs; ++j) {
s[j] = rnd.Rand16() & mask_; s[j] = rnd.Rand16() & mask_;
@ -402,17 +382,16 @@ TEST_P(Loop8Test9Param, ValueCheck) {
} }
#if CONFIG_VP9_HIGHBITDEPTH #if CONFIG_VP9_HIGHBITDEPTH
const int32_t bd = bit_depth_; const int32_t bd = bit_depth_;
ref_loopfilter_op_(ref_s + 8 + p * 8, p, blimit0, limit0, thresh0, ref_loopfilter_op_(ref_s + 8 + p * 8, p, blimit0, limit0, thresh0, blimit1,
blimit1, limit1, thresh1, bd); limit1, thresh1, bd);
ASM_REGISTER_STATE_CHECK( ASM_REGISTER_STATE_CHECK(loopfilter_op_(s + 8 + p * 8, p, blimit0, limit0,
loopfilter_op_(s + 8 + p * 8, p, blimit0, limit0, thresh0, blimit1, limit1, thresh1,
thresh0, blimit1, limit1, thresh1, bd)); bd));
#else #else
ref_loopfilter_op_(ref_s + 8 + p * 8, p, blimit0, limit0, thresh0, ref_loopfilter_op_(ref_s + 8 + p * 8, p, blimit0, limit0, thresh0, blimit1,
blimit1, limit1, thresh1); limit1, thresh1);
ASM_REGISTER_STATE_CHECK( ASM_REGISTER_STATE_CHECK(loopfilter_op_(s + 8 + p * 8, p, blimit0, limit0,
loopfilter_op_(s + 8 + p * 8, p, blimit0, limit0, thresh0, thresh0, blimit1, limit1, thresh1));
blimit1, limit1, thresh1));
#endif // CONFIG_VP9_HIGHBITDEPTH #endif // CONFIG_VP9_HIGHBITDEPTH
for (int j = 0; j < kNumCoeffs; ++j) { for (int j = 0; j < kNumCoeffs; ++j) {
err_count += ref_s[j] != s[j]; err_count += ref_s[j] != s[j];
@ -434,129 +413,120 @@ using std::tr1::make_tuple;
#if CONFIG_VP9_HIGHBITDEPTH #if CONFIG_VP9_HIGHBITDEPTH
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
SSE2, Loop8Test6Param, SSE2, Loop8Test6Param,
::testing::Values( ::testing::Values(make_tuple(&vpx_highbd_lpf_horizontal_4_sse2,
make_tuple(&vpx_highbd_lpf_horizontal_4_sse2, &vpx_highbd_lpf_horizontal_4_c, 8),
&vpx_highbd_lpf_horizontal_4_c, 8), make_tuple(&vpx_highbd_lpf_vertical_4_sse2,
make_tuple(&vpx_highbd_lpf_vertical_4_sse2, &vpx_highbd_lpf_vertical_4_c, 8),
&vpx_highbd_lpf_vertical_4_c, 8), make_tuple(&vpx_highbd_lpf_horizontal_8_sse2,
make_tuple(&vpx_highbd_lpf_horizontal_8_sse2, &vpx_highbd_lpf_horizontal_8_c, 8),
&vpx_highbd_lpf_horizontal_8_c, 8), make_tuple(&vpx_highbd_lpf_horizontal_edge_8_sse2,
make_tuple(&vpx_highbd_lpf_horizontal_edge_8_sse2, &vpx_highbd_lpf_horizontal_edge_8_c, 8),
&vpx_highbd_lpf_horizontal_edge_8_c, 8), make_tuple(&vpx_highbd_lpf_horizontal_edge_16_sse2,
make_tuple(&vpx_highbd_lpf_horizontal_edge_16_sse2, &vpx_highbd_lpf_horizontal_edge_16_c, 8),
&vpx_highbd_lpf_horizontal_edge_16_c, 8), make_tuple(&vpx_highbd_lpf_vertical_8_sse2,
make_tuple(&vpx_highbd_lpf_vertical_8_sse2, &vpx_highbd_lpf_vertical_8_c, 8),
&vpx_highbd_lpf_vertical_8_c, 8), make_tuple(&vpx_highbd_lpf_vertical_16_sse2,
make_tuple(&vpx_highbd_lpf_vertical_16_sse2, &vpx_highbd_lpf_vertical_16_c, 8),
&vpx_highbd_lpf_vertical_16_c, 8), make_tuple(&vpx_highbd_lpf_horizontal_4_sse2,
make_tuple(&vpx_highbd_lpf_horizontal_4_sse2, &vpx_highbd_lpf_horizontal_4_c, 10),
&vpx_highbd_lpf_horizontal_4_c, 10), make_tuple(&vpx_highbd_lpf_vertical_4_sse2,
make_tuple(&vpx_highbd_lpf_vertical_4_sse2, &vpx_highbd_lpf_vertical_4_c, 10),
&vpx_highbd_lpf_vertical_4_c, 10), make_tuple(&vpx_highbd_lpf_horizontal_8_sse2,
make_tuple(&vpx_highbd_lpf_horizontal_8_sse2, &vpx_highbd_lpf_horizontal_8_c, 10),
&vpx_highbd_lpf_horizontal_8_c, 10), make_tuple(&vpx_highbd_lpf_horizontal_edge_8_sse2,
make_tuple(&vpx_highbd_lpf_horizontal_edge_8_sse2, &vpx_highbd_lpf_horizontal_edge_8_c, 10),
&vpx_highbd_lpf_horizontal_edge_8_c, 10), make_tuple(&vpx_highbd_lpf_horizontal_edge_16_sse2,
make_tuple(&vpx_highbd_lpf_horizontal_edge_16_sse2, &vpx_highbd_lpf_horizontal_edge_16_c, 10),
&vpx_highbd_lpf_horizontal_edge_16_c, 10), make_tuple(&vpx_highbd_lpf_vertical_8_sse2,
make_tuple(&vpx_highbd_lpf_vertical_8_sse2, &vpx_highbd_lpf_vertical_8_c, 10),
&vpx_highbd_lpf_vertical_8_c, 10), make_tuple(&vpx_highbd_lpf_vertical_16_sse2,
make_tuple(&vpx_highbd_lpf_vertical_16_sse2, &vpx_highbd_lpf_vertical_16_c, 10),
&vpx_highbd_lpf_vertical_16_c, 10), make_tuple(&vpx_highbd_lpf_horizontal_4_sse2,
make_tuple(&vpx_highbd_lpf_horizontal_4_sse2, &vpx_highbd_lpf_horizontal_4_c, 12),
&vpx_highbd_lpf_horizontal_4_c, 12), make_tuple(&vpx_highbd_lpf_vertical_4_sse2,
make_tuple(&vpx_highbd_lpf_vertical_4_sse2, &vpx_highbd_lpf_vertical_4_c, 12),
&vpx_highbd_lpf_vertical_4_c, 12), make_tuple(&vpx_highbd_lpf_horizontal_8_sse2,
make_tuple(&vpx_highbd_lpf_horizontal_8_sse2, &vpx_highbd_lpf_horizontal_8_c, 12),
&vpx_highbd_lpf_horizontal_8_c, 12), make_tuple(&vpx_highbd_lpf_horizontal_edge_8_sse2,
make_tuple(&vpx_highbd_lpf_horizontal_edge_8_sse2, &vpx_highbd_lpf_horizontal_edge_8_c, 12),
&vpx_highbd_lpf_horizontal_edge_8_c, 12), make_tuple(&vpx_highbd_lpf_horizontal_edge_16_sse2,
make_tuple(&vpx_highbd_lpf_horizontal_edge_16_sse2, &vpx_highbd_lpf_horizontal_edge_16_c, 12),
&vpx_highbd_lpf_horizontal_edge_16_c, 12), make_tuple(&vpx_highbd_lpf_vertical_8_sse2,
make_tuple(&vpx_highbd_lpf_vertical_8_sse2, &vpx_highbd_lpf_vertical_8_c, 12),
&vpx_highbd_lpf_vertical_8_c, 12), make_tuple(&vpx_highbd_lpf_vertical_16_sse2,
make_tuple(&vpx_highbd_lpf_vertical_16_sse2, &vpx_highbd_lpf_vertical_16_c, 12),
&vpx_highbd_lpf_vertical_16_c, 12), make_tuple(&vpx_highbd_lpf_vertical_16_dual_sse2,
make_tuple(&vpx_highbd_lpf_vertical_16_dual_sse2, &vpx_highbd_lpf_vertical_16_dual_c, 8),
&vpx_highbd_lpf_vertical_16_dual_c, 8), make_tuple(&vpx_highbd_lpf_vertical_16_dual_sse2,
make_tuple(&vpx_highbd_lpf_vertical_16_dual_sse2, &vpx_highbd_lpf_vertical_16_dual_c, 10),
&vpx_highbd_lpf_vertical_16_dual_c, 10), make_tuple(&vpx_highbd_lpf_vertical_16_dual_sse2,
make_tuple(&vpx_highbd_lpf_vertical_16_dual_sse2, &vpx_highbd_lpf_vertical_16_dual_c, 12)));
&vpx_highbd_lpf_vertical_16_dual_c, 12)));
#else #else
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
SSE2, Loop8Test6Param, SSE2, Loop8Test6Param,
::testing::Values( ::testing::Values(
make_tuple(&vpx_lpf_horizontal_4_sse2, make_tuple(&vpx_lpf_horizontal_4_sse2, &vpx_lpf_horizontal_4_c, 8),
&vpx_lpf_horizontal_4_c, 8), make_tuple(&vpx_lpf_horizontal_8_sse2, &vpx_lpf_horizontal_8_c, 8),
make_tuple(&vpx_lpf_horizontal_8_sse2,
&vpx_lpf_horizontal_8_c, 8),
make_tuple(&vpx_lpf_horizontal_edge_8_sse2, make_tuple(&vpx_lpf_horizontal_edge_8_sse2,
&vpx_lpf_horizontal_edge_8_c, 8), &vpx_lpf_horizontal_edge_8_c, 8),
make_tuple(&vpx_lpf_horizontal_edge_16_sse2, make_tuple(&vpx_lpf_horizontal_edge_16_sse2,
&vpx_lpf_horizontal_edge_16_c, 8), &vpx_lpf_horizontal_edge_16_c, 8),
make_tuple(&vpx_lpf_vertical_4_sse2, make_tuple(&vpx_lpf_vertical_4_sse2, &vpx_lpf_vertical_4_c, 8),
&vpx_lpf_vertical_4_c, 8), make_tuple(&vpx_lpf_vertical_8_sse2, &vpx_lpf_vertical_8_c, 8),
make_tuple(&vpx_lpf_vertical_8_sse2, make_tuple(&vpx_lpf_vertical_16_sse2, &vpx_lpf_vertical_16_c, 8),
&vpx_lpf_vertical_8_c, 8), make_tuple(&vpx_lpf_vertical_16_dual_sse2, &vpx_lpf_vertical_16_dual_c,
make_tuple(&vpx_lpf_vertical_16_sse2, 8)));
&vpx_lpf_vertical_16_c, 8),
make_tuple(&vpx_lpf_vertical_16_dual_sse2,
&vpx_lpf_vertical_16_dual_c, 8)));
#endif // CONFIG_VP9_HIGHBITDEPTH #endif // CONFIG_VP9_HIGHBITDEPTH
#endif #endif
#if HAVE_AVX2 && (!CONFIG_VP9_HIGHBITDEPTH) #if HAVE_AVX2 && (!CONFIG_VP9_HIGHBITDEPTH)
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
AVX2, Loop8Test6Param, AVX2, Loop8Test6Param,
::testing::Values( ::testing::Values(make_tuple(&vpx_lpf_horizontal_edge_8_avx2,
make_tuple(&vpx_lpf_horizontal_edge_8_avx2, &vpx_lpf_horizontal_edge_8_c, 8),
&vpx_lpf_horizontal_edge_8_c, 8), make_tuple(&vpx_lpf_horizontal_edge_16_avx2,
make_tuple(&vpx_lpf_horizontal_edge_16_avx2, &vpx_lpf_horizontal_edge_16_c, 8)));
&vpx_lpf_horizontal_edge_16_c, 8)));
#endif #endif
#if HAVE_SSE2 #if HAVE_SSE2
#if CONFIG_VP9_HIGHBITDEPTH #if CONFIG_VP9_HIGHBITDEPTH
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
SSE2, Loop8Test9Param, SSE2, Loop8Test9Param,
::testing::Values( ::testing::Values(make_tuple(&vpx_highbd_lpf_horizontal_4_dual_sse2,
make_tuple(&vpx_highbd_lpf_horizontal_4_dual_sse2, &vpx_highbd_lpf_horizontal_4_dual_c, 8),
&vpx_highbd_lpf_horizontal_4_dual_c, 8), make_tuple(&vpx_highbd_lpf_horizontal_8_dual_sse2,
make_tuple(&vpx_highbd_lpf_horizontal_8_dual_sse2, &vpx_highbd_lpf_horizontal_8_dual_c, 8),
&vpx_highbd_lpf_horizontal_8_dual_c, 8), make_tuple(&vpx_highbd_lpf_vertical_4_dual_sse2,
make_tuple(&vpx_highbd_lpf_vertical_4_dual_sse2, &vpx_highbd_lpf_vertical_4_dual_c, 8),
&vpx_highbd_lpf_vertical_4_dual_c, 8), make_tuple(&vpx_highbd_lpf_vertical_8_dual_sse2,
make_tuple(&vpx_highbd_lpf_vertical_8_dual_sse2, &vpx_highbd_lpf_vertical_8_dual_c, 8),
&vpx_highbd_lpf_vertical_8_dual_c, 8), make_tuple(&vpx_highbd_lpf_horizontal_4_dual_sse2,
make_tuple(&vpx_highbd_lpf_horizontal_4_dual_sse2, &vpx_highbd_lpf_horizontal_4_dual_c, 10),
&vpx_highbd_lpf_horizontal_4_dual_c, 10), make_tuple(&vpx_highbd_lpf_horizontal_8_dual_sse2,
make_tuple(&vpx_highbd_lpf_horizontal_8_dual_sse2, &vpx_highbd_lpf_horizontal_8_dual_c, 10),
&vpx_highbd_lpf_horizontal_8_dual_c, 10), make_tuple(&vpx_highbd_lpf_vertical_4_dual_sse2,
make_tuple(&vpx_highbd_lpf_vertical_4_dual_sse2, &vpx_highbd_lpf_vertical_4_dual_c, 10),
&vpx_highbd_lpf_vertical_4_dual_c, 10), make_tuple(&vpx_highbd_lpf_vertical_8_dual_sse2,
make_tuple(&vpx_highbd_lpf_vertical_8_dual_sse2, &vpx_highbd_lpf_vertical_8_dual_c, 10),
&vpx_highbd_lpf_vertical_8_dual_c, 10), make_tuple(&vpx_highbd_lpf_horizontal_4_dual_sse2,
make_tuple(&vpx_highbd_lpf_horizontal_4_dual_sse2, &vpx_highbd_lpf_horizontal_4_dual_c, 12),
&vpx_highbd_lpf_horizontal_4_dual_c, 12), make_tuple(&vpx_highbd_lpf_horizontal_8_dual_sse2,
make_tuple(&vpx_highbd_lpf_horizontal_8_dual_sse2, &vpx_highbd_lpf_horizontal_8_dual_c, 12),
&vpx_highbd_lpf_horizontal_8_dual_c, 12), make_tuple(&vpx_highbd_lpf_vertical_4_dual_sse2,
make_tuple(&vpx_highbd_lpf_vertical_4_dual_sse2, &vpx_highbd_lpf_vertical_4_dual_c, 12),
&vpx_highbd_lpf_vertical_4_dual_c, 12), make_tuple(&vpx_highbd_lpf_vertical_8_dual_sse2,
make_tuple(&vpx_highbd_lpf_vertical_8_dual_sse2, &vpx_highbd_lpf_vertical_8_dual_c, 12)));
&vpx_highbd_lpf_vertical_8_dual_c, 12)));
#else #else
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
SSE2, Loop8Test9Param, SSE2, Loop8Test9Param,
::testing::Values( ::testing::Values(make_tuple(&vpx_lpf_horizontal_4_dual_sse2,
make_tuple(&vpx_lpf_horizontal_4_dual_sse2, &vpx_lpf_horizontal_4_dual_c, 8),
&vpx_lpf_horizontal_4_dual_c, 8), make_tuple(&vpx_lpf_horizontal_8_dual_sse2,
make_tuple(&vpx_lpf_horizontal_8_dual_sse2, &vpx_lpf_horizontal_8_dual_c, 8),
&vpx_lpf_horizontal_8_dual_c, 8), make_tuple(&vpx_lpf_vertical_4_dual_sse2,
make_tuple(&vpx_lpf_vertical_4_dual_sse2, &vpx_lpf_vertical_4_dual_c, 8),
&vpx_lpf_vertical_4_dual_c, 8), make_tuple(&vpx_lpf_vertical_8_dual_sse2,
make_tuple(&vpx_lpf_vertical_8_dual_sse2, &vpx_lpf_vertical_8_dual_c, 8)));
&vpx_lpf_vertical_8_dual_c, 8)));
#endif // CONFIG_VP9_HIGHBITDEPTH #endif // CONFIG_VP9_HIGHBITDEPTH
#endif #endif
@ -567,39 +537,33 @@ INSTANTIATE_TEST_CASE_P(
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
NEON, Loop8Test6Param, NEON, Loop8Test6Param,
::testing::Values( ::testing::Values(
#if HAVE_NEON_ASM
// Using #if inside the macro is unsupported on MSVS but the tests are not // Using #if inside the macro is unsupported on MSVS but the tests are not
// currently built for MSVS with ARM and NEON. // currently built for MSVS with ARM and NEON.
#if HAVE_NEON_ASM
make_tuple(&vpx_lpf_horizontal_edge_8_neon, make_tuple(&vpx_lpf_horizontal_edge_8_neon,
&vpx_lpf_horizontal_edge_8_c, 8), &vpx_lpf_horizontal_edge_8_c, 8),
make_tuple(&vpx_lpf_horizontal_edge_16_neon, make_tuple(&vpx_lpf_horizontal_edge_16_neon,
&vpx_lpf_horizontal_edge_16_c, 8), &vpx_lpf_horizontal_edge_16_c, 8),
make_tuple(&vpx_lpf_vertical_16_neon, make_tuple(&vpx_lpf_vertical_16_neon, &vpx_lpf_vertical_16_c, 8),
&vpx_lpf_vertical_16_c, 8), make_tuple(&vpx_lpf_vertical_16_dual_neon, &vpx_lpf_vertical_16_dual_c,
make_tuple(&vpx_lpf_vertical_16_dual_neon, 8),
&vpx_lpf_vertical_16_dual_c, 8),
#endif // HAVE_NEON_ASM #endif // HAVE_NEON_ASM
make_tuple(&vpx_lpf_horizontal_8_neon, make_tuple(&vpx_lpf_horizontal_8_neon, &vpx_lpf_horizontal_8_c, 8),
&vpx_lpf_horizontal_8_c, 8), make_tuple(&vpx_lpf_vertical_8_neon, &vpx_lpf_vertical_8_c, 8),
make_tuple(&vpx_lpf_vertical_8_neon, make_tuple(&vpx_lpf_horizontal_4_neon, &vpx_lpf_horizontal_4_c, 8),
&vpx_lpf_vertical_8_c, 8), make_tuple(&vpx_lpf_vertical_4_neon, &vpx_lpf_vertical_4_c, 8)));
make_tuple(&vpx_lpf_horizontal_4_neon, INSTANTIATE_TEST_CASE_P(NEON, Loop8Test9Param,
&vpx_lpf_horizontal_4_c, 8), ::testing::Values(
make_tuple(&vpx_lpf_vertical_4_neon,
&vpx_lpf_vertical_4_c, 8)));
INSTANTIATE_TEST_CASE_P(
NEON, Loop8Test9Param,
::testing::Values(
#if HAVE_NEON_ASM #if HAVE_NEON_ASM
make_tuple(&vpx_lpf_horizontal_8_dual_neon, make_tuple(&vpx_lpf_horizontal_8_dual_neon,
&vpx_lpf_horizontal_8_dual_c, 8), &vpx_lpf_horizontal_8_dual_c, 8),
make_tuple(&vpx_lpf_vertical_8_dual_neon, make_tuple(&vpx_lpf_vertical_8_dual_neon,
&vpx_lpf_vertical_8_dual_c, 8), &vpx_lpf_vertical_8_dual_c, 8),
#endif // HAVE_NEON_ASM #endif // HAVE_NEON_ASM
make_tuple(&vpx_lpf_horizontal_4_dual_neon, make_tuple(&vpx_lpf_horizontal_4_dual_neon,
&vpx_lpf_horizontal_4_dual_c, 8), &vpx_lpf_horizontal_4_dual_c, 8),
make_tuple(&vpx_lpf_vertical_4_dual_neon, make_tuple(&vpx_lpf_vertical_4_dual_neon,
&vpx_lpf_vertical_4_dual_c, 8))); &vpx_lpf_vertical_4_dual_c, 8)));
#endif // CONFIG_VP9_HIGHBITDEPTH #endif // CONFIG_VP9_HIGHBITDEPTH
#endif // HAVE_NEON #endif // HAVE_NEON
@ -607,66 +571,52 @@ INSTANTIATE_TEST_CASE_P(
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
DSPR2, Loop8Test6Param, DSPR2, Loop8Test6Param,
::testing::Values( ::testing::Values(
make_tuple(&vpx_lpf_horizontal_4_dspr2, make_tuple(&vpx_lpf_horizontal_4_dspr2, &vpx_lpf_horizontal_4_c, 8),
&vpx_lpf_horizontal_4_c, 8), make_tuple(&vpx_lpf_horizontal_8_dspr2, &vpx_lpf_horizontal_8_c, 8),
make_tuple(&vpx_lpf_horizontal_8_dspr2, make_tuple(&vpx_lpf_horizontal_edge_8, &vpx_lpf_horizontal_edge_8, 8),
&vpx_lpf_horizontal_8_c, 8), make_tuple(&vpx_lpf_horizontal_edge_16, &vpx_lpf_horizontal_edge_16, 8),
make_tuple(&vpx_lpf_horizontal_edge_8, make_tuple(&vpx_lpf_vertical_4_dspr2, &vpx_lpf_vertical_4_c, 8),
&vpx_lpf_horizontal_edge_8, 8), make_tuple(&vpx_lpf_vertical_8_dspr2, &vpx_lpf_vertical_8_c, 8),
make_tuple(&vpx_lpf_horizontal_edge_16, make_tuple(&vpx_lpf_vertical_16_dspr2, &vpx_lpf_vertical_16_c, 8),
&vpx_lpf_horizontal_edge_16, 8), make_tuple(&vpx_lpf_vertical_16_dual_dspr2, &vpx_lpf_vertical_16_dual_c,
make_tuple(&vpx_lpf_vertical_4_dspr2, 8)));
&vpx_lpf_vertical_4_c, 8),
make_tuple(&vpx_lpf_vertical_8_dspr2,
&vpx_lpf_vertical_8_c, 8),
make_tuple(&vpx_lpf_vertical_16_dspr2,
&vpx_lpf_vertical_16_c, 8),
make_tuple(&vpx_lpf_vertical_16_dual_dspr2,
&vpx_lpf_vertical_16_dual_c, 8)));
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
DSPR2, Loop8Test9Param, DSPR2, Loop8Test9Param,
::testing::Values( ::testing::Values(make_tuple(&vpx_lpf_horizontal_4_dual_dspr2,
make_tuple(&vpx_lpf_horizontal_4_dual_dspr2, &vpx_lpf_horizontal_4_dual_c, 8),
&vpx_lpf_horizontal_4_dual_c, 8), make_tuple(&vpx_lpf_horizontal_8_dual_dspr2,
make_tuple(&vpx_lpf_horizontal_8_dual_dspr2, &vpx_lpf_horizontal_8_dual_c, 8),
&vpx_lpf_horizontal_8_dual_c, 8), make_tuple(&vpx_lpf_vertical_4_dual_dspr2,
make_tuple(&vpx_lpf_vertical_4_dual_dspr2, &vpx_lpf_vertical_4_dual_c, 8),
&vpx_lpf_vertical_4_dual_c, 8), make_tuple(&vpx_lpf_vertical_8_dual_dspr2,
make_tuple(&vpx_lpf_vertical_8_dual_dspr2, &vpx_lpf_vertical_8_dual_c, 8)));
&vpx_lpf_vertical_8_dual_c, 8)));
#endif // HAVE_DSPR2 && !CONFIG_VP9_HIGHBITDEPTH #endif // HAVE_DSPR2 && !CONFIG_VP9_HIGHBITDEPTH
#if HAVE_MSA && (!CONFIG_VP9_HIGHBITDEPTH) #if HAVE_MSA && (!CONFIG_VP9_HIGHBITDEPTH)
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
MSA, Loop8Test6Param, MSA, Loop8Test6Param,
::testing::Values( ::testing::Values(
make_tuple(&vpx_lpf_horizontal_4_msa, make_tuple(&vpx_lpf_horizontal_4_msa, &vpx_lpf_horizontal_4_c, 8),
&vpx_lpf_horizontal_4_c, 8), make_tuple(&vpx_lpf_horizontal_8_msa, &vpx_lpf_horizontal_8_c, 8),
make_tuple(&vpx_lpf_horizontal_8_msa, make_tuple(&vpx_lpf_horizontal_edge_8_msa, &vpx_lpf_horizontal_edge_8_c,
&vpx_lpf_horizontal_8_c, 8), 8),
make_tuple(&vpx_lpf_horizontal_edge_8_msa,
&vpx_lpf_horizontal_edge_8_c, 8),
make_tuple(&vpx_lpf_horizontal_edge_16_msa, make_tuple(&vpx_lpf_horizontal_edge_16_msa,
&vpx_lpf_horizontal_edge_16_c, 8), &vpx_lpf_horizontal_edge_16_c, 8),
make_tuple(&vpx_lpf_vertical_4_msa, make_tuple(&vpx_lpf_vertical_4_msa, &vpx_lpf_vertical_4_c, 8),
&vpx_lpf_vertical_4_c, 8), make_tuple(&vpx_lpf_vertical_8_msa, &vpx_lpf_vertical_8_c, 8),
make_tuple(&vpx_lpf_vertical_8_msa, make_tuple(&vpx_lpf_vertical_16_msa, &vpx_lpf_vertical_16_c, 8)));
&vpx_lpf_vertical_8_c, 8),
make_tuple(&vpx_lpf_vertical_16_msa,
&vpx_lpf_vertical_16_c, 8)));
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
MSA, Loop8Test9Param, MSA, Loop8Test9Param,
::testing::Values( ::testing::Values(make_tuple(&vpx_lpf_horizontal_4_dual_msa,
make_tuple(&vpx_lpf_horizontal_4_dual_msa, &vpx_lpf_horizontal_4_dual_c, 8),
&vpx_lpf_horizontal_4_dual_c, 8), make_tuple(&vpx_lpf_horizontal_8_dual_msa,
make_tuple(&vpx_lpf_horizontal_8_dual_msa, &vpx_lpf_horizontal_8_dual_c, 8),
&vpx_lpf_horizontal_8_dual_c, 8), make_tuple(&vpx_lpf_vertical_4_dual_msa,
make_tuple(&vpx_lpf_vertical_4_dual_msa, &vpx_lpf_vertical_4_dual_c, 8),
&vpx_lpf_vertical_4_dual_c, 8), make_tuple(&vpx_lpf_vertical_8_dual_msa,
make_tuple(&vpx_lpf_vertical_8_dual_msa, &vpx_lpf_vertical_8_dual_c, 8)));
&vpx_lpf_vertical_8_dual_c, 8)));
#endif // HAVE_MSA && (!CONFIG_VP9_HIGHBITDEPTH) #endif // HAVE_MSA && (!CONFIG_VP9_HIGHBITDEPTH)
} // namespace } // namespace

19
test/md5_helper.h
View File

@ -17,9 +17,7 @@
namespace libvpx_test { namespace libvpx_test {
class MD5 { class MD5 {
public: public:
MD5() { MD5() { MD5Init(&md5_); }
MD5Init(&md5_);
}
void Add(const vpx_image_t *img) { void Add(const vpx_image_t *img) {
for (int plane = 0; plane < 3; ++plane) { for (int plane = 0; plane < 3; ++plane) {
@ -30,10 +28,13 @@ class MD5 {
// This works only for chroma_shift of 0 and 1. // This works only for chroma_shift of 0 and 1.
const int bytes_per_sample = const int bytes_per_sample =
(img->fmt & VPX_IMG_FMT_HIGHBITDEPTH) ? 2 : 1; (img->fmt & VPX_IMG_FMT_HIGHBITDEPTH) ? 2 : 1;
const int h = plane ? (img->d_h + img->y_chroma_shift) >> const int h =
img->y_chroma_shift : img->d_h; plane ? (img->d_h + img->y_chroma_shift) >> img->y_chroma_shift
const int w = (plane ? (img->d_w + img->x_chroma_shift) >> : img->d_h;
img->x_chroma_shift : img->d_w) * bytes_per_sample; const int w =
(plane ? (img->d_w + img->x_chroma_shift) >> img->x_chroma_shift
: img->d_w) *
bytes_per_sample;
for (int y = 0; y < h; ++y) { for (int y = 0; y < h; ++y) {
MD5Update(&md5_, buf, w); MD5Update(&md5_, buf, w);
@ -56,8 +57,8 @@ class MD5 {
MD5Final(tmp, &ctx_tmp); MD5Final(tmp, &ctx_tmp);
for (int i = 0; i < 16; i++) { for (int i = 0; i < 16; i++) {
res_[i * 2 + 0] = hex[tmp[i] >> 4]; res_[i * 2 + 0] = hex[tmp[i] >> 4];
res_[i * 2 + 1] = hex[tmp[i] & 0xf]; res_[i * 2 + 1] = hex[tmp[i] & 0xf];
} }
res_[32] = 0; res_[32] = 0;

14
test/minmax_test.cc
View File

@ -23,9 +23,8 @@ namespace {
using ::libvpx_test::ACMRandom; using ::libvpx_test::ACMRandom;
typedef void (*MinMaxFunc)(const uint8_t *a, int a_stride, typedef void (*MinMaxFunc)(const uint8_t *a, int a_stride, const uint8_t *b,
const uint8_t *b, int b_stride, int b_stride, int *min, int *max);
int *min, int *max);
class MinMaxTest : public ::testing::TestWithParam<MinMaxFunc> { class MinMaxTest : public ::testing::TestWithParam<MinMaxFunc> {
public: public:
@ -39,9 +38,8 @@ class MinMaxTest : public ::testing::TestWithParam<MinMaxFunc> {
ACMRandom rnd_; ACMRandom rnd_;
}; };
void reference_minmax(const uint8_t *a, int a_stride, void reference_minmax(const uint8_t *a, int a_stride, const uint8_t *b,
const uint8_t *b, int b_stride, int b_stride, int *min_ret, int *max_ret) {
int *min_ret, int *max_ret) {
int min = 255; int min = 255;
int max = 0; int max = 0;
for (int i = 0; i < 8; i++) { for (int i = 0; i < 8; i++) {
@ -110,9 +108,9 @@ TEST_P(MinMaxTest, CompareReferenceAndVaryStride) {
reference_minmax(a, a_stride, b, b_stride, &min_ref, &max_ref); reference_minmax(a, a_stride, b, b_stride, &min_ref, &max_ref);
ASM_REGISTER_STATE_CHECK(mm_func_(a, a_stride, b, b_stride, &min, &max)); ASM_REGISTER_STATE_CHECK(mm_func_(a, a_stride, b, b_stride, &min, &max));
EXPECT_EQ(max_ref, max) << "when a_stride = " << a_stride EXPECT_EQ(max_ref, max) << "when a_stride = " << a_stride
<< " and b_stride = " << b_stride;; << " and b_stride = " << b_stride;
EXPECT_EQ(min_ref, min) << "when a_stride = " << a_stride EXPECT_EQ(min_ref, min) << "when a_stride = " << a_stride
<< " and b_stride = " << b_stride;; << " and b_stride = " << b_stride;
} }
} }
} }

241
test/partial_idct_test.cc
View File

@ -29,10 +29,8 @@ using libvpx_test::ACMRandom;
namespace { namespace {
typedef void (*FwdTxfmFunc)(const int16_t *in, tran_low_t *out, int stride); typedef void (*FwdTxfmFunc)(const int16_t *in, tran_low_t *out, int stride);
typedef void (*InvTxfmFunc)(const tran_low_t *in, uint8_t *out, int stride); typedef void (*InvTxfmFunc)(const tran_low_t *in, uint8_t *out, int stride);
typedef std::tr1::tuple<FwdTxfmFunc, typedef std::tr1::tuple<FwdTxfmFunc, InvTxfmFunc, InvTxfmFunc, TX_SIZE, int>
InvTxfmFunc, PartialInvTxfmParam;
InvTxfmFunc,
TX_SIZE, int> PartialInvTxfmParam;
const int kMaxNumCoeffs = 1024; const int kMaxNumCoeffs = 1024;
class PartialIDctTest : public ::testing::TestWithParam<PartialInvTxfmParam> { class PartialIDctTest : public ::testing::TestWithParam<PartialInvTxfmParam> {
public: public:
@ -41,7 +39,7 @@ class PartialIDctTest : public ::testing::TestWithParam<PartialInvTxfmParam> {
ftxfm_ = GET_PARAM(0); ftxfm_ = GET_PARAM(0);
full_itxfm_ = GET_PARAM(1); full_itxfm_ = GET_PARAM(1);
partial_itxfm_ = GET_PARAM(2); partial_itxfm_ = GET_PARAM(2);
tx_size_ = GET_PARAM(3); tx_size_ = GET_PARAM(3);
last_nonzero_ = GET_PARAM(4); last_nonzero_ = GET_PARAM(4);
} }
@ -59,21 +57,11 @@ TEST_P(PartialIDctTest, RunQuantCheck) {
ACMRandom rnd(ACMRandom::DeterministicSeed()); ACMRandom rnd(ACMRandom::DeterministicSeed());
int size; int size;
switch (tx_size_) { switch (tx_size_) {
case TX_4X4: case TX_4X4: size = 4; break;
size = 4; case TX_8X8: size = 8; break;
break; case TX_16X16: size = 16; break;
case TX_8X8: case TX_32X32: size = 32; break;
size = 8; default: FAIL() << "Wrong Size!"; break;
break;
case TX_16X16:
size = 16;
break;
case TX_32X32:
size = 32;
break;
default:
FAIL() << "Wrong Size!";
break;
} }
DECLARE_ALIGNED(16, tran_low_t, test_coef_block1[kMaxNumCoeffs]); DECLARE_ALIGNED(16, tran_low_t, test_coef_block1[kMaxNumCoeffs]);
DECLARE_ALIGNED(16, tran_low_t, test_coef_block2[kMaxNumCoeffs]); DECLARE_ALIGNED(16, tran_low_t, test_coef_block2[kMaxNumCoeffs]);
@ -99,11 +87,9 @@ TEST_P(PartialIDctTest, RunQuantCheck) {
for (int i = 0; i < count_test_block; ++i) { for (int i = 0; i < count_test_block; ++i) {
// Initialize a test block with input range [-255, 255]. // Initialize a test block with input range [-255, 255].
if (i == 0) { if (i == 0) {
for (int j = 0; j < block_size; ++j) for (int j = 0; j < block_size; ++j) input_extreme_block[j] = 255;
input_extreme_block[j] = 255;
} else if (i == 1) { } else if (i == 1) {
for (int j = 0; j < block_size; ++j) for (int j = 0; j < block_size; ++j) input_extreme_block[j] = -255;
input_extreme_block[j] = -255;
} else { } else {
for (int j = 0; j < block_size; ++j) { for (int j = 0; j < block_size; ++j) {
input_extreme_block[j] = rnd.Rand8() % 2 ? 255 : -255; input_extreme_block[j] = rnd.Rand8() % 2 ? 255 : -255;
@ -115,8 +101,8 @@ TEST_P(PartialIDctTest, RunQuantCheck) {
// quantization with maximum allowed step sizes // quantization with maximum allowed step sizes
test_coef_block1[0] = (output_ref_block[0] / 1336) * 1336; test_coef_block1[0] = (output_ref_block[0] / 1336) * 1336;
for (int j = 1; j < last_nonzero_; ++j) for (int j = 1; j < last_nonzero_; ++j)
test_coef_block1[vp9_default_scan_orders[tx_size_].scan[j]] test_coef_block1[vp9_default_scan_orders[tx_size_].scan[j]] =
= (output_ref_block[j] / 1828) * 1828; (output_ref_block[j] / 1828) * 1828;
} }
ASM_REGISTER_STATE_CHECK(full_itxfm_(test_coef_block1, dst1, size)); ASM_REGISTER_STATE_CHECK(full_itxfm_(test_coef_block1, dst1, size));
@ -125,8 +111,7 @@ TEST_P(PartialIDctTest, RunQuantCheck) {
for (int j = 0; j < block_size; ++j) { for (int j = 0; j < block_size; ++j) {
const int diff = dst1[j] - dst2[j]; const int diff = dst1[j] - dst2[j];
const int error = diff * diff; const int error = diff * diff;
if (max_error < error) if (max_error < error) max_error = error;
max_error = error;
} }
} }
@ -138,21 +123,11 @@ TEST_P(PartialIDctTest, ResultsMatch) {
ACMRandom rnd(ACMRandom::DeterministicSeed()); ACMRandom rnd(ACMRandom::DeterministicSeed());
int size; int size;
switch (tx_size_) { switch (tx_size_) {
case TX_4X4: case TX_4X4: size = 4; break;
size = 4; case TX_8X8: size = 8; break;
break; case TX_16X16: size = 16; break;
case TX_8X8: case TX_32X32: size = 32; break;
size = 8; default: FAIL() << "Wrong Size!"; break;
break;
case TX_16X16:
size = 16;
break;
case TX_32X32:
size = 32;
break;
default:
FAIL() << "Wrong Size!";
break;
} }
DECLARE_ALIGNED(16, tran_low_t, test_coef_block1[kMaxNumCoeffs]); DECLARE_ALIGNED(16, tran_low_t, test_coef_block1[kMaxNumCoeffs]);
DECLARE_ALIGNED(16, tran_low_t, test_coef_block2[kMaxNumCoeffs]); DECLARE_ALIGNED(16, tran_low_t, test_coef_block2[kMaxNumCoeffs]);
@ -189,8 +164,7 @@ TEST_P(PartialIDctTest, ResultsMatch) {
for (int j = 0; j < block_size; ++j) { for (int j = 0; j < block_size; ++j) {
const int diff = dst1[j] - dst2[j]; const int diff = dst1[j] - dst2[j];
const int error = diff * diff; const int error = diff * diff;
if (max_error < error) if (max_error < error) max_error = error;
max_error = error;
} }
} }
@ -201,143 +175,82 @@ using std::tr1::make_tuple;
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
C, PartialIDctTest, C, PartialIDctTest,
::testing::Values( ::testing::Values(make_tuple(&vpx_fdct32x32_c, &vpx_idct32x32_1024_add_c,
make_tuple(&vpx_fdct32x32_c, &vpx_idct32x32_34_add_c, TX_32X32, 34),
&vpx_idct32x32_1024_add_c, make_tuple(&vpx_fdct32x32_c, &vpx_idct32x32_1024_add_c,
&vpx_idct32x32_34_add_c, &vpx_idct32x32_1_add_c, TX_32X32, 1),
TX_32X32, 34), make_tuple(&vpx_fdct16x16_c, &vpx_idct16x16_256_add_c,
make_tuple(&vpx_fdct32x32_c, &vpx_idct16x16_10_add_c, TX_16X16, 10),
&vpx_idct32x32_1024_add_c, make_tuple(&vpx_fdct16x16_c, &vpx_idct16x16_256_add_c,
&vpx_idct32x32_1_add_c, &vpx_idct16x16_1_add_c, TX_16X16, 1),
TX_32X32, 1), make_tuple(&vpx_fdct8x8_c, &vpx_idct8x8_64_add_c,
make_tuple(&vpx_fdct16x16_c, &vpx_idct8x8_12_add_c, TX_8X8, 12),
&vpx_idct16x16_256_add_c, make_tuple(&vpx_fdct8x8_c, &vpx_idct8x8_64_add_c,
&vpx_idct16x16_10_add_c, &vpx_idct8x8_1_add_c, TX_8X8, 1),
TX_16X16, 10), make_tuple(&vpx_fdct4x4_c, &vpx_idct4x4_16_add_c,
make_tuple(&vpx_fdct16x16_c, &vpx_idct4x4_1_add_c, TX_4X4, 1)));
&vpx_idct16x16_256_add_c,
&vpx_idct16x16_1_add_c,
TX_16X16, 1),
make_tuple(&vpx_fdct8x8_c,
&vpx_idct8x8_64_add_c,
&vpx_idct8x8_12_add_c,
TX_8X8, 12),
make_tuple(&vpx_fdct8x8_c,
&vpx_idct8x8_64_add_c,
&vpx_idct8x8_1_add_c,
TX_8X8, 1),
make_tuple(&vpx_fdct4x4_c,
&vpx_idct4x4_16_add_c,
&vpx_idct4x4_1_add_c,
TX_4X4, 1)));
#if HAVE_NEON && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE #if HAVE_NEON && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
NEON, PartialIDctTest, NEON, PartialIDctTest,
::testing::Values( ::testing::Values(make_tuple(&vpx_fdct32x32_c, &vpx_idct32x32_1024_add_c,
make_tuple(&vpx_fdct32x32_c, &vpx_idct32x32_1_add_neon, TX_32X32, 1),
&vpx_idct32x32_1024_add_c, make_tuple(&vpx_fdct16x16_c, &vpx_idct16x16_256_add_c,
&vpx_idct32x32_1_add_neon, &vpx_idct16x16_10_add_neon, TX_16X16, 10),
TX_32X32, 1), make_tuple(&vpx_fdct16x16_c, &vpx_idct16x16_256_add_c,
make_tuple(&vpx_fdct16x16_c, &vpx_idct16x16_1_add_neon, TX_16X16, 1),
&vpx_idct16x16_256_add_c, make_tuple(&vpx_fdct8x8_c, &vpx_idct8x8_64_add_c,
&vpx_idct16x16_10_add_neon, &vpx_idct8x8_12_add_neon, TX_8X8, 12),
TX_16X16, 10), make_tuple(&vpx_fdct8x8_c, &vpx_idct8x8_64_add_c,
make_tuple(&vpx_fdct16x16_c, &vpx_idct8x8_1_add_neon, TX_8X8, 1),
&vpx_idct16x16_256_add_c, make_tuple(&vpx_fdct4x4_c, &vpx_idct4x4_16_add_c,
&vpx_idct16x16_1_add_neon, &vpx_idct4x4_1_add_neon, TX_4X4, 1)));
TX_16X16, 1),
make_tuple(&vpx_fdct8x8_c,
&vpx_idct8x8_64_add_c,
&vpx_idct8x8_12_add_neon,
TX_8X8, 12),
make_tuple(&vpx_fdct8x8_c,
&vpx_idct8x8_64_add_c,
&vpx_idct8x8_1_add_neon,
TX_8X8, 1),
make_tuple(&vpx_fdct4x4_c,
&vpx_idct4x4_16_add_c,
&vpx_idct4x4_1_add_neon,
TX_4X4, 1)));
#endif // HAVE_NEON && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE #endif // HAVE_NEON && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
#if HAVE_SSE2 && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE #if HAVE_SSE2 && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
SSE2, PartialIDctTest, SSE2, PartialIDctTest,
::testing::Values( ::testing::Values(make_tuple(&vpx_fdct32x32_c, &vpx_idct32x32_1024_add_c,
make_tuple(&vpx_fdct32x32_c, &vpx_idct32x32_34_add_sse2, TX_32X32, 34),
&vpx_idct32x32_1024_add_c, make_tuple(&vpx_fdct32x32_c, &vpx_idct32x32_1024_add_c,
&vpx_idct32x32_34_add_sse2, &vpx_idct32x32_1_add_sse2, TX_32X32, 1),
TX_32X32, 34), make_tuple(&vpx_fdct16x16_c, &vpx_idct16x16_256_add_c,
make_tuple(&vpx_fdct32x32_c, &vpx_idct16x16_10_add_sse2, TX_16X16, 10),
&vpx_idct32x32_1024_add_c, make_tuple(&vpx_fdct16x16_c, &vpx_idct16x16_256_add_c,
&vpx_idct32x32_1_add_sse2, &vpx_idct16x16_1_add_sse2, TX_16X16, 1),
TX_32X32, 1), make_tuple(&vpx_fdct8x8_c, &vpx_idct8x8_64_add_c,
make_tuple(&vpx_fdct16x16_c, &vpx_idct8x8_12_add_sse2, TX_8X8, 12),
&vpx_idct16x16_256_add_c, make_tuple(&vpx_fdct8x8_c, &vpx_idct8x8_64_add_c,
&vpx_idct16x16_10_add_sse2, &vpx_idct8x8_1_add_sse2, TX_8X8, 1),
TX_16X16, 10), make_tuple(&vpx_fdct4x4_c, &vpx_idct4x4_16_add_c,
make_tuple(&vpx_fdct16x16_c, &vpx_idct4x4_1_add_sse2, TX_4X4, 1)));
&vpx_idct16x16_256_add_c,
&vpx_idct16x16_1_add_sse2,
TX_16X16, 1),
make_tuple(&vpx_fdct8x8_c,
&vpx_idct8x8_64_add_c,
&vpx_idct8x8_12_add_sse2,
TX_8X8, 12),
make_tuple(&vpx_fdct8x8_c,
&vpx_idct8x8_64_add_c,
&vpx_idct8x8_1_add_sse2,
TX_8X8, 1),
make_tuple(&vpx_fdct4x4_c,
&vpx_idct4x4_16_add_c,
&vpx_idct4x4_1_add_sse2,
TX_4X4, 1)));
#endif #endif
#if HAVE_SSSE3 && ARCH_X86_64 && \ #if HAVE_SSSE3 && ARCH_X86_64 && !CONFIG_VP9_HIGHBITDEPTH && \
!CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE !CONFIG_EMULATE_HARDWARE
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
SSSE3_64, PartialIDctTest, SSSE3_64, PartialIDctTest,
::testing::Values( ::testing::Values(make_tuple(&vpx_fdct8x8_c, &vpx_idct8x8_64_add_c,
make_tuple(&vpx_fdct8x8_c, &vpx_idct8x8_12_add_ssse3, TX_8X8, 12)));
&vpx_idct8x8_64_add_c,
&vpx_idct8x8_12_add_ssse3,
TX_8X8, 12)));
#endif #endif
#if HAVE_MSA && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE #if HAVE_MSA && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
MSA, PartialIDctTest, MSA, PartialIDctTest,
::testing::Values( ::testing::Values(make_tuple(&vpx_fdct32x32_c, &vpx_idct32x32_1024_add_c,
make_tuple(&vpx_fdct32x32_c, &vpx_idct32x32_34_add_msa, TX_32X32, 34),
&vpx_idct32x32_1024_add_c, make_tuple(&vpx_fdct32x32_c, &vpx_idct32x32_1024_add_c,
&vpx_idct32x32_34_add_msa, &vpx_idct32x32_1_add_msa, TX_32X32, 1),
TX_32X32, 34), make_tuple(&vpx_fdct16x16_c, &vpx_idct16x16_256_add_c,
make_tuple(&vpx_fdct32x32_c, &vpx_idct16x16_10_add_msa, TX_16X16, 10),
&vpx_idct32x32_1024_add_c, make_tuple(&vpx_fdct16x16_c, &vpx_idct16x16_256_add_c,
&vpx_idct32x32_1_add_msa, &vpx_idct16x16_1_add_msa, TX_16X16, 1),
TX_32X32, 1), make_tuple(&vpx_fdct8x8_c, &vpx_idct8x8_64_add_c,
make_tuple(&vpx_fdct16x16_c, &vpx_idct8x8_12_add_msa, TX_8X8, 10),
&vpx_idct16x16_256_add_c, make_tuple(&vpx_fdct8x8_c, &vpx_idct8x8_64_add_c,
&vpx_idct16x16_10_add_msa, &vpx_idct8x8_1_add_msa, TX_8X8, 1),
TX_16X16, 10), make_tuple(&vpx_fdct4x4_c, &vpx_idct4x4_16_add_c,
make_tuple(&vpx_fdct16x16_c, &vpx_idct4x4_1_add_msa, TX_4X4, 1)));
&vpx_idct16x16_256_add_c,
&vpx_idct16x16_1_add_msa,
TX_16X16, 1),
make_tuple(&vpx_fdct8x8_c,
&vpx_idct8x8_64_add_c,
&vpx_idct8x8_12_add_msa,
TX_8X8, 10),
make_tuple(&vpx_fdct8x8_c,
&vpx_idct8x8_64_add_c,
&vpx_idct8x8_1_add_msa,
TX_8X8, 1),
make_tuple(&vpx_fdct4x4_c,
&vpx_idct4x4_16_add_c,
&vpx_idct4x4_1_add_msa,
TX_4X4, 1)));
#endif // HAVE_MSA && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE #endif // HAVE_MSA && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
} // namespace } // namespace

40
test/pp_filter_test.cc
View File

@ -15,22 +15,16 @@
#include "vpx/vpx_integer.h" #include "vpx/vpx_integer.h"
#include "vpx_mem/vpx_mem.h" #include "vpx_mem/vpx_mem.h"
typedef void (*PostProcFunc)(unsigned char *src_ptr, typedef void (*PostProcFunc)(unsigned char *src_ptr, unsigned char *dst_ptr,
unsigned char *dst_ptr, int src_pixels_per_line, int dst_pixels_per_line,
int src_pixels_per_line, int cols, unsigned char *flimit, int size);
int dst_pixels_per_line,
int cols,
unsigned char *flimit,
int size);
namespace { namespace {
class VPxPostProcessingFilterTest class VPxPostProcessingFilterTest
: public ::testing::TestWithParam<PostProcFunc> { : public ::testing::TestWithParam<PostProcFunc> {
public: public:
virtual void TearDown() { virtual void TearDown() { libvpx_test::ClearSystemState(); }
libvpx_test::ClearSystemState();
}
}; };
// Test routine for the VPx post-processing function // Test routine for the VPx post-processing function
@ -38,7 +32,7 @@ class VPxPostProcessingFilterTest
TEST_P(VPxPostProcessingFilterTest, FilterOutputCheck) { TEST_P(VPxPostProcessingFilterTest, FilterOutputCheck) {
// Size of the underlying data block that will be filtered. // Size of the underlying data block that will be filtered.
const int block_width = 16; const int block_width = 16;
const int block_height = 16; const int block_height = 16;
// 5-tap filter needs 2 padding rows above and below the block in the input. // 5-tap filter needs 2 padding rows above and below the block in the input.
@ -54,9 +48,9 @@ TEST_P(VPxPostProcessingFilterTest, FilterOutputCheck) {
const int output_size = output_width * output_height; const int output_size = output_width * output_height;
uint8_t *const src_image = uint8_t *const src_image =
reinterpret_cast<uint8_t*>(vpx_calloc(input_size, 1)); reinterpret_cast<uint8_t *>(vpx_calloc(input_size, 1));
uint8_t *const dst_image = uint8_t *const dst_image =
reinterpret_cast<uint8_t*>(vpx_calloc(output_size, 1)); reinterpret_cast<uint8_t *>(vpx_calloc(output_size, 1));
// Pointers to top-left pixel of block in the input and output images. // Pointers to top-left pixel of block in the input and output images.
uint8_t *const src_image_ptr = src_image + (input_stride << 1); uint8_t *const src_image_ptr = src_image + (input_stride << 1);
@ -80,13 +74,12 @@ TEST_P(VPxPostProcessingFilterTest, FilterOutputCheck) {
// Initialize pixels in the output to 99. // Initialize pixels in the output to 99.
(void)memset(dst_image, 99, output_size); (void)memset(dst_image, 99, output_size);
ASM_REGISTER_STATE_CHECK( ASM_REGISTER_STATE_CHECK(GetParam()(src_image_ptr, dst_image_ptr,
GetParam()(src_image_ptr, dst_image_ptr, input_stride, input_stride, output_stride, block_width,
output_stride, block_width, flimits, 16)); flimits, 16));
static const uint8_t expected_data[block_height] = { static const uint8_t expected_data[block_height] = { 4, 3, 1, 1, 1, 1, 1, 1,
4, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 4 1, 1, 1, 1, 1, 1, 3, 4 };
};
pixel_ptr = dst_image_ptr; pixel_ptr = dst_image_ptr;
for (int i = 0; i < block_height; ++i) { for (int i = 0; i < block_height; ++i) {
@ -102,16 +95,19 @@ TEST_P(VPxPostProcessingFilterTest, FilterOutputCheck) {
vpx_free(flimits); vpx_free(flimits);
}; };
INSTANTIATE_TEST_CASE_P(C, VPxPostProcessingFilterTest, INSTANTIATE_TEST_CASE_P(
C, VPxPostProcessingFilterTest,
::testing::Values(vpx_post_proc_down_and_across_mb_row_c)); ::testing::Values(vpx_post_proc_down_and_across_mb_row_c));
#if HAVE_SSE2 #if HAVE_SSE2
INSTANTIATE_TEST_CASE_P(SSE2, VPxPostProcessingFilterTest, INSTANTIATE_TEST_CASE_P(
SSE2, VPxPostProcessingFilterTest,
::testing::Values(vpx_post_proc_down_and_across_mb_row_sse2)); ::testing::Values(vpx_post_proc_down_and_across_mb_row_sse2));
#endif #endif
#if HAVE_MSA #if HAVE_MSA
INSTANTIATE_TEST_CASE_P(MSA, VPxPostProcessingFilterTest, INSTANTIATE_TEST_CASE_P(
MSA, VPxPostProcessingFilterTest,
::testing::Values(vpx_post_proc_down_and_across_mb_row_msa)); ::testing::Values(vpx_post_proc_down_and_across_mb_row_msa));
#endif #endif

3
test/realtime_test.cc
View File

@ -23,8 +23,7 @@ class RealtimeTest
: public ::libvpx_test::EncoderTest, : public ::libvpx_test::EncoderTest,
public ::libvpx_test::CodecTestWithParam<libvpx_test::TestMode> { public ::libvpx_test::CodecTestWithParam<libvpx_test::TestMode> {
protected: protected:
RealtimeTest() RealtimeTest() : EncoderTest(GET_PARAM(0)), frame_packets_(0) {}
: EncoderTest(GET_PARAM(0)), frame_packets_(0) {}
virtual ~RealtimeTest() {} virtual ~RealtimeTest() {}
virtual void SetUp() { virtual void SetUp() {

43
test/register_state_check.h
View File

@ -36,7 +36,7 @@
#include <windows.h> #include <windows.h>
#include <winnt.h> #include <winnt.h>
inline bool operator==(const M128A& lhs, const M128A& rhs) { inline bool operator==(const M128A &lhs, const M128A &rhs) {
return (lhs.Low == rhs.Low && lhs.High == rhs.High); return (lhs.Low == rhs.Low && lhs.High == rhs.High);
} }
@ -51,7 +51,7 @@ class RegisterStateCheck {
~RegisterStateCheck() { Check(); } ~RegisterStateCheck() { Check(); }
private: private:
static bool StoreRegisters(CONTEXT* const context) { static bool StoreRegisters(CONTEXT *const context) {
const HANDLE this_thread = GetCurrentThread(); const HANDLE this_thread = GetCurrentThread();
EXPECT_TRUE(this_thread != NULL); EXPECT_TRUE(this_thread != NULL);
context->ContextFlags = CONTEXT_FLOATING_POINT; context->ContextFlags = CONTEXT_FLOATING_POINT;
@ -66,8 +66,8 @@ class RegisterStateCheck {
CONTEXT post_context; CONTEXT post_context;
ASSERT_TRUE(StoreRegisters(&post_context)); ASSERT_TRUE(StoreRegisters(&post_context));
const M128A* xmm_pre = &pre_context_.Xmm6; const M128A *xmm_pre = &pre_context_.Xmm6;
const M128A* xmm_post = &post_context.Xmm6; const M128A *xmm_post = &post_context.Xmm6;
for (int i = 6; i <= 15; ++i) { for (int i = 6; i <= 15; ++i) {
EXPECT_EQ(*xmm_pre, *xmm_post) << "xmm" << i << " has been modified!"; EXPECT_EQ(*xmm_pre, *xmm_post) << "xmm" << i << " has been modified!";
++xmm_pre; ++xmm_pre;
@ -79,15 +79,16 @@ class RegisterStateCheck {
CONTEXT pre_context_; CONTEXT pre_context_;
}; };
#define ASM_REGISTER_STATE_CHECK(statement) do { \ #define ASM_REGISTER_STATE_CHECK(statement) \
libvpx_test::RegisterStateCheck reg_check; \ do { \
statement; \ libvpx_test::RegisterStateCheck reg_check; \
} while (false) statement; \
} while (false)
} // namespace libvpx_test } // namespace libvpx_test
#elif defined(CONFIG_SHARED) && defined(HAVE_NEON_ASM) && defined(CONFIG_VP9) \ #elif defined(CONFIG_SHARED) && defined(HAVE_NEON_ASM) && \
&& !CONFIG_SHARED && HAVE_NEON_ASM && CONFIG_VP9 defined(CONFIG_VP9) && !CONFIG_SHARED && HAVE_NEON_ASM && CONFIG_VP9
extern "C" { extern "C" {
// Save the d8-d15 registers into store. // Save the d8-d15 registers into store.
@ -110,18 +111,19 @@ class RegisterStateCheck {
int64_t post_store[8]; int64_t post_store[8];
vpx_push_neon(post_store); vpx_push_neon(post_store);
for (int i = 0; i < 8; ++i) { for (int i = 0; i < 8; ++i) {
EXPECT_EQ(pre_store_[i], post_store[i]) << "d" EXPECT_EQ(pre_store_[i], post_store[i]) << "d" << i + 8
<< i + 8 << " has been modified"; << " has been modified";
} }
} }
int64_t pre_store_[8]; int64_t pre_store_[8];
}; };
#define ASM_REGISTER_STATE_CHECK(statement) do { \ #define ASM_REGISTER_STATE_CHECK(statement) \
libvpx_test::RegisterStateCheck reg_check; \ do { \
statement; \ libvpx_test::RegisterStateCheck reg_check; \
} while (false) statement; \
} while (false)
} // namespace libvpx_test } // namespace libvpx_test
@ -165,10 +167,11 @@ class RegisterStateCheckMMX {
uint16_t pre_fpu_env_[14]; uint16_t pre_fpu_env_[14];
}; };
#define API_REGISTER_STATE_CHECK(statement) do { \ #define API_REGISTER_STATE_CHECK(statement) \
libvpx_test::RegisterStateCheckMMX reg_check; \ do { \
ASM_REGISTER_STATE_CHECK(statement); \ libvpx_test::RegisterStateCheckMMX reg_check; \
} while (false) ASM_REGISTER_STATE_CHECK(statement); \
} while (false)
} // namespace libvpx_test } // namespace libvpx_test

103
test/resize_test.cc
View File

@ -44,9 +44,9 @@ static void write_ivf_file_header(const vpx_codec_enc_cfg_t *const cfg,
header[1] = 'K'; header[1] = 'K';
header[2] = 'I'; header[2] = 'I';
header[3] = 'F'; header[3] = 'F';
mem_put_le16(header + 4, 0); /* version */ mem_put_le16(header + 4, 0); /* version */
mem_put_le16(header + 6, 32); /* headersize */ mem_put_le16(header + 6, 32); /* headersize */
mem_put_le32(header + 8, 0x30395056); /* fourcc (vp9) */ mem_put_le32(header + 8, 0x30395056); /* fourcc (vp9) */
mem_put_le16(header + 12, cfg->g_w); /* width */ mem_put_le16(header + 12, cfg->g_w); /* width */
mem_put_le16(header + 14, cfg->g_h); /* height */ mem_put_le16(header + 14, cfg->g_h); /* height */
mem_put_le32(header + 16, cfg->g_timebase.den); /* rate */ mem_put_le32(header + 16, cfg->g_timebase.den); /* rate */
@ -68,8 +68,7 @@ static void write_ivf_frame_header(const vpx_codec_cx_pkt_t *const pkt,
char header[12]; char header[12];
vpx_codec_pts_t pts; vpx_codec_pts_t pts;
if (pkt->kind != VPX_CODEC_CX_FRAME_PKT) if (pkt->kind != VPX_CODEC_CX_FRAME_PKT) return;
return;
pts = pkt->data.frame.pts; pts = pkt->data.frame.pts;
mem_put_le32(header, static_cast<unsigned int>(pkt->data.frame.sz)); mem_put_le32(header, static_cast<unsigned int>(pkt->data.frame.sz));
@ -92,12 +91,9 @@ struct FrameInfo {
unsigned int h; unsigned int h;
}; };
void ScaleForFrameNumber(unsigned int frame, void ScaleForFrameNumber(unsigned int frame, unsigned int initial_w,
unsigned int initial_w, unsigned int initial_h, unsigned int *w,
unsigned int initial_h, unsigned int *h, int flag_codec) {
unsigned int *w,
unsigned int *h,
int flag_codec) {
if (frame < 10) { if (frame < 10) {
*w = initial_w; *w = initial_w;
*h = initial_h; *h = initial_h;
@ -219,7 +215,7 @@ void ScaleForFrameNumber(unsigned int frame,
return; return;
} }
if (frame < 250) { if (frame < 250) {
*w = initial_w / 2; *w = initial_w / 2;
*h = initial_h / 2; *h = initial_h / 2;
return; return;
} }
@ -268,8 +264,9 @@ class ResizingVideoSource : public ::libvpx_test::DummyVideoSource {
} }
}; };
class ResizeTest : public ::libvpx_test::EncoderTest, class ResizeTest
public ::libvpx_test::CodecTestWithParam<libvpx_test::TestMode> { : public ::libvpx_test::EncoderTest,
public ::libvpx_test::CodecTestWithParam<libvpx_test::TestMode> {
protected: protected:
ResizeTest() : EncoderTest(GET_PARAM(0)) {} ResizeTest() : EncoderTest(GET_PARAM(0)) {}
@ -285,7 +282,7 @@ class ResizeTest : public ::libvpx_test::EncoderTest,
frame_info_list_.push_back(FrameInfo(pts, img.d_w, img.d_h)); frame_info_list_.push_back(FrameInfo(pts, img.d_w, img.d_h));
} }
std::vector< FrameInfo > frame_info_list_; std::vector<FrameInfo> frame_info_list_;
}; };
TEST_P(ResizeTest, TestExternalResizeWorks) { TEST_P(ResizeTest, TestExternalResizeWorks) {
@ -299,12 +296,12 @@ TEST_P(ResizeTest, TestExternalResizeWorks) {
const unsigned int frame = static_cast<unsigned>(info->pts); const unsigned int frame = static_cast<unsigned>(info->pts);
unsigned int expected_w; unsigned int expected_w;
unsigned int expected_h; unsigned int expected_h;
ScaleForFrameNumber(frame, kInitialWidth, kInitialHeight, ScaleForFrameNumber(frame, kInitialWidth, kInitialHeight, &expected_w,
&expected_w, &expected_h, 0); &expected_h, 0);
EXPECT_EQ(expected_w, info->w) EXPECT_EQ(expected_w, info->w) << "Frame " << frame
<< "Frame " << frame << " had unexpected width"; << " had unexpected width";
EXPECT_EQ(expected_h, info->h) EXPECT_EQ(expected_h, info->h) << "Frame " << frame
<< "Frame " << frame << " had unexpected height"; << " had unexpected height";
} }
} }
@ -315,10 +312,7 @@ class ResizeInternalTest : public ResizeTest {
protected: protected:
#if WRITE_COMPRESSED_STREAM #if WRITE_COMPRESSED_STREAM
ResizeInternalTest() ResizeInternalTest()
: ResizeTest(), : ResizeTest(), frame0_psnr_(0.0), outfile_(NULL), out_frames_(0) {}
frame0_psnr_(0.0),
outfile_(NULL),
out_frames_(0) {}
#else #else
ResizeInternalTest() : ResizeTest(), frame0_psnr_(0.0) {} ResizeInternalTest() : ResizeTest(), frame0_psnr_(0.0) {}
#endif #endif
@ -347,30 +341,29 @@ class ResizeInternalTest : public ResizeTest {
if (change_config_) { if (change_config_) {
int new_q = 60; int new_q = 60;
if (video->frame() == 0) { if (video->frame() == 0) {
struct vpx_scaling_mode mode = {VP8E_ONETWO, VP8E_ONETWO}; struct vpx_scaling_mode mode = { VP8E_ONETWO, VP8E_ONETWO };
encoder->Control(VP8E_SET_SCALEMODE, &mode); encoder->Control(VP8E_SET_SCALEMODE, &mode);
} }
if (video->frame() == 1) { if (video->frame() == 1) {
struct vpx_scaling_mode mode = {VP8E_NORMAL, VP8E_NORMAL}; struct vpx_scaling_mode mode = { VP8E_NORMAL, VP8E_NORMAL };
encoder->Control(VP8E_SET_SCALEMODE, &mode); encoder->Control(VP8E_SET_SCALEMODE, &mode);
cfg_.rc_min_quantizer = cfg_.rc_max_quantizer = new_q; cfg_.rc_min_quantizer = cfg_.rc_max_quantizer = new_q;
encoder->Config(&cfg_); encoder->Config(&cfg_);
} }
} else { } else {
if (video->frame() == kStepDownFrame) { if (video->frame() == kStepDownFrame) {
struct vpx_scaling_mode mode = {VP8E_FOURFIVE, VP8E_THREEFIVE}; struct vpx_scaling_mode mode = { VP8E_FOURFIVE, VP8E_THREEFIVE };
encoder->Control(VP8E_SET_SCALEMODE, &mode); encoder->Control(VP8E_SET_SCALEMODE, &mode);
} }
if (video->frame() == kStepUpFrame) { if (video->frame() == kStepUpFrame) {
struct vpx_scaling_mode mode = {VP8E_NORMAL, VP8E_NORMAL}; struct vpx_scaling_mode mode = { VP8E_NORMAL, VP8E_NORMAL };
encoder->Control(VP8E_SET_SCALEMODE, &mode); encoder->Control(VP8E_SET_SCALEMODE, &mode);
} }
} }
} }
virtual void PSNRPktHook(const vpx_codec_cx_pkt_t *pkt) { virtual void PSNRPktHook(const vpx_codec_cx_pkt_t *pkt) {
if (frame0_psnr_ == 0.) if (frame0_psnr_ == 0.) frame0_psnr_ = pkt->data.psnr.psnr[0];
frame0_psnr_ = pkt->data.psnr.psnr[0];
EXPECT_NEAR(pkt->data.psnr.psnr[0], frame0_psnr_, 2.0); EXPECT_NEAR(pkt->data.psnr.psnr[0], frame0_psnr_, 2.0);
} }
@ -379,8 +372,7 @@ class ResizeInternalTest : public ResizeTest {
++out_frames_; ++out_frames_;
// Write initial file header if first frame. // Write initial file header if first frame.
if (pkt->data.frame.pts == 0) if (pkt->data.frame.pts == 0) write_ivf_file_header(&cfg_, 0, outfile_);
write_ivf_file_header(&cfg_, 0, outfile_);
// Write frame header and data. // Write frame header and data.
write_ivf_frame_header(pkt, outfile_); write_ivf_frame_header(pkt, outfile_);
@ -434,8 +426,9 @@ TEST_P(ResizeInternalTest, TestInternalResizeChangeConfig) {
ASSERT_NO_FATAL_FAILURE(RunLoop(&video)); ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
} }
class ResizeRealtimeTest : public ::libvpx_test::EncoderTest, class ResizeRealtimeTest
public ::libvpx_test::CodecTestWith2Params<libvpx_test::TestMode, int> { : public ::libvpx_test::EncoderTest,
public ::libvpx_test::CodecTestWith2Params<libvpx_test::TestMode, int> {
protected: protected:
ResizeRealtimeTest() : EncoderTest(GET_PARAM(0)) {} ResizeRealtimeTest() : EncoderTest(GET_PARAM(0)) {}
virtual ~ResizeRealtimeTest() {} virtual ~ResizeRealtimeTest() {}
@ -465,16 +458,13 @@ class ResizeRealtimeTest : public ::libvpx_test::EncoderTest,
frame_info_list_.push_back(FrameInfo(pts, img.d_w, img.d_h)); frame_info_list_.push_back(FrameInfo(pts, img.d_w, img.d_h));
} }
virtual void MismatchHook(const vpx_image_t *img1, virtual void MismatchHook(const vpx_image_t *img1, const vpx_image_t *img2) {
const vpx_image_t *img2) {
double mismatch_psnr = compute_psnr(img1, img2); double mismatch_psnr = compute_psnr(img1, img2);
mismatch_psnr_ += mismatch_psnr; mismatch_psnr_ += mismatch_psnr;
++mismatch_nframes_; ++mismatch_nframes_;
} }
unsigned int GetMismatchFrames() { unsigned int GetMismatchFrames() { return mismatch_nframes_; }
return mismatch_nframes_;
}
void DefaultConfig() { void DefaultConfig() {
cfg_.rc_buf_initial_sz = 500; cfg_.rc_buf_initial_sz = 500;
@ -491,14 +481,14 @@ class ResizeRealtimeTest : public ::libvpx_test::EncoderTest,
// Enable dropped frames. // Enable dropped frames.
cfg_.rc_dropframe_thresh = 1; cfg_.rc_dropframe_thresh = 1;
// Enable error_resilience mode. // Enable error_resilience mode.
cfg_.g_error_resilient = 1; cfg_.g_error_resilient = 1;
// Enable dynamic resizing. // Enable dynamic resizing.
cfg_.rc_resize_allowed = 1; cfg_.rc_resize_allowed = 1;
// Run at low bitrate. // Run at low bitrate.
cfg_.rc_target_bitrate = 200; cfg_.rc_target_bitrate = 200;
} }
std::vector< FrameInfo > frame_info_list_; std::vector<FrameInfo> frame_info_list_;
int set_cpu_used_; int set_cpu_used_;
bool change_bitrate_; bool change_bitrate_;
double mismatch_psnr_; double mismatch_psnr_;
@ -521,12 +511,12 @@ TEST_P(ResizeRealtimeTest, TestExternalResizeWorks) {
const unsigned int frame = static_cast<unsigned>(info->pts); const unsigned int frame = static_cast<unsigned>(info->pts);
unsigned int expected_w; unsigned int expected_w;
unsigned int expected_h; unsigned int expected_h;
ScaleForFrameNumber(frame, kInitialWidth, kInitialHeight, ScaleForFrameNumber(frame, kInitialWidth, kInitialHeight, &expected_w,
&expected_w, &expected_h, 1); &expected_h, 1);
EXPECT_EQ(expected_w, info->w) EXPECT_EQ(expected_w, info->w) << "Frame " << frame
<< "Frame " << frame << " had unexpected width"; << " had unexpected width";
EXPECT_EQ(expected_h, info->h) EXPECT_EQ(expected_h, info->h) << "Frame " << frame
<< "Frame " << frame << " had unexpected height"; << " had unexpected height";
EXPECT_EQ(static_cast<unsigned int>(0), GetMismatchFrames()); EXPECT_EQ(static_cast<unsigned int>(0), GetMismatchFrames());
} }
} }
@ -618,10 +608,8 @@ TEST_P(ResizeRealtimeTest, TestInternalResizeDownUpChangeBitRate) {
} }
vpx_img_fmt_t CspForFrameNumber(int frame) { vpx_img_fmt_t CspForFrameNumber(int frame) {
if (frame < 10) if (frame < 10) return VPX_IMG_FMT_I420;
return VPX_IMG_FMT_I420; if (frame < 20) return VPX_IMG_FMT_I444;
if (frame < 20)
return VPX_IMG_FMT_I444;
return VPX_IMG_FMT_I420; return VPX_IMG_FMT_I420;
} }
@ -629,10 +617,7 @@ class ResizeCspTest : public ResizeTest {
protected: protected:
#if WRITE_COMPRESSED_STREAM #if WRITE_COMPRESSED_STREAM
ResizeCspTest() ResizeCspTest()
: ResizeTest(), : ResizeTest(), frame0_psnr_(0.0), outfile_(NULL), out_frames_(0) {}
frame0_psnr_(0.0),
outfile_(NULL),
out_frames_(0) {}
#else #else
ResizeCspTest() : ResizeTest(), frame0_psnr_(0.0) {} ResizeCspTest() : ResizeTest(), frame0_psnr_(0.0) {}
#endif #endif
@ -671,8 +656,7 @@ class ResizeCspTest : public ResizeTest {
} }
virtual void PSNRPktHook(const vpx_codec_cx_pkt_t *pkt) { virtual void PSNRPktHook(const vpx_codec_cx_pkt_t *pkt) {
if (frame0_psnr_ == 0.) if (frame0_psnr_ == 0.) frame0_psnr_ = pkt->data.psnr.psnr[0];
frame0_psnr_ = pkt->data.psnr.psnr[0];
EXPECT_NEAR(pkt->data.psnr.psnr[0], frame0_psnr_, 2.0); EXPECT_NEAR(pkt->data.psnr.psnr[0], frame0_psnr_, 2.0);
} }
@ -681,8 +665,7 @@ class ResizeCspTest : public ResizeTest {
++out_frames_; ++out_frames_;
// Write initial file header if first frame. // Write initial file header if first frame.
if (pkt->data.frame.pts == 0) if (pkt->data.frame.pts == 0) write_ivf_file_header(&cfg_, 0, outfile_);
write_ivf_file_header(&cfg_, 0, outfile_);
// Write frame header and data. // Write frame header and data.
write_ivf_frame_header(pkt, outfile_); write_ivf_frame_header(pkt, outfile_);

38
test/sad_test.cc
View File

@ -8,7 +8,6 @@
* be found in the AUTHORS file in the root of the source tree. * be found in the AUTHORS file in the root of the source tree.
*/ */
#include <string.h> #include <string.h>
#include <limits.h> #include <limits.h>
#include <stdio.h> #include <stdio.h>
@ -25,7 +24,7 @@
#include "vpx_mem/vpx_mem.h" #include "vpx_mem/vpx_mem.h"
#include "vpx_ports/mem.h" #include "vpx_ports/mem.h"
template<typename Function> template <typename Function>
struct TestParams { struct TestParams {
TestParams(int w, int h, Function f, int bd = -1) TestParams(int w, int h, Function f, int bd = -1)
: width(w), height(h), bit_depth(bd), func(f) {} : width(w), height(h), bit_depth(bd), func(f) {}
@ -50,24 +49,24 @@ typedef TestParams<SadMxNx4Func> SadMxNx4Param;
using libvpx_test::ACMRandom; using libvpx_test::ACMRandom;
namespace { namespace {
template<typename ParamType> template <typename ParamType>
class SADTestBase : public ::testing::TestWithParam<ParamType> { class SADTestBase : public ::testing::TestWithParam<ParamType> {
public: public:
explicit SADTestBase(const ParamType& params) : params_(params) {} explicit SADTestBase(const ParamType &params) : params_(params) {}
virtual void SetUp() { virtual void SetUp() {
source_data8_ = reinterpret_cast<uint8_t*>( source_data8_ = reinterpret_cast<uint8_t *>(
vpx_memalign(kDataAlignment, kDataBlockSize)); vpx_memalign(kDataAlignment, kDataBlockSize));
reference_data8_ = reinterpret_cast<uint8_t*>( reference_data8_ = reinterpret_cast<uint8_t *>(
vpx_memalign(kDataAlignment, kDataBufferSize)); vpx_memalign(kDataAlignment, kDataBufferSize));
second_pred8_ = reinterpret_cast<uint8_t*>( second_pred8_ =
vpx_memalign(kDataAlignment, 64*64)); reinterpret_cast<uint8_t *>(vpx_memalign(kDataAlignment, 64 * 64));
source_data16_ = reinterpret_cast<uint16_t*>( source_data16_ = reinterpret_cast<uint16_t *>(
vpx_memalign(kDataAlignment, kDataBlockSize*sizeof(uint16_t))); vpx_memalign(kDataAlignment, kDataBlockSize * sizeof(uint16_t)));
reference_data16_ = reinterpret_cast<uint16_t*>( reference_data16_ = reinterpret_cast<uint16_t *>(
vpx_memalign(kDataAlignment, kDataBufferSize*sizeof(uint16_t))); vpx_memalign(kDataAlignment, kDataBufferSize * sizeof(uint16_t)));
second_pred16_ = reinterpret_cast<uint16_t*>( second_pred16_ = reinterpret_cast<uint16_t *>(
vpx_memalign(kDataAlignment, 64*64*sizeof(uint16_t))); vpx_memalign(kDataAlignment, 64 * 64 * sizeof(uint16_t)));
if (params_.bit_depth == -1) { if (params_.bit_depth == -1) {
use_high_bit_depth_ = false; use_high_bit_depth_ = false;
@ -167,13 +166,13 @@ class SADTestBase : public ::testing::TestWithParam<ParamType> {
for (int w = 0; w < params_.width; ++w) { for (int w = 0; w < params_.width; ++w) {
if (!use_high_bit_depth_) { if (!use_high_bit_depth_) {
const int tmp = second_pred8[h * params_.width + w] + const int tmp = second_pred8[h * params_.width + w] +
reference8[h * reference_stride_ + w]; reference8[h * reference_stride_ + w];
const uint8_t comp_pred = ROUND_POWER_OF_TWO(tmp, 1); const uint8_t comp_pred = ROUND_POWER_OF_TWO(tmp, 1);
sad += abs(source8[h * source_stride_ + w] - comp_pred); sad += abs(source8[h * source_stride_ + w] - comp_pred);
#if CONFIG_VP9_HIGHBITDEPTH #if CONFIG_VP9_HIGHBITDEPTH
} else { } else {
const int tmp = second_pred16[h * params_.width + w] + const int tmp = second_pred16[h * params_.width + w] +
reference16[h * reference_stride_ + w]; reference16[h * reference_stride_ + w];
const uint16_t comp_pred = ROUND_POWER_OF_TWO(tmp, 1); const uint16_t comp_pred = ROUND_POWER_OF_TWO(tmp, 1);
sad += abs(source16[h * source_stride_ + w] - comp_pred); sad += abs(source16[h * source_stride_ + w] - comp_pred);
#endif // CONFIG_VP9_HIGHBITDEPTH #endif // CONFIG_VP9_HIGHBITDEPTH
@ -248,9 +247,8 @@ class SADx4Test : public SADTestBase<SadMxNx4Param> {
const uint8_t *references[] = { GetReference(0), GetReference(1), const uint8_t *references[] = { GetReference(0), GetReference(1),
GetReference(2), GetReference(3) }; GetReference(2), GetReference(3) };
ASM_REGISTER_STATE_CHECK(params_.func(source_data_, source_stride_, ASM_REGISTER_STATE_CHECK(params_.func(
references, reference_stride_, source_data_, source_stride_, references, reference_stride_, results));
results));
} }
void CheckSADs() const { void CheckSADs() const {
@ -453,7 +451,7 @@ TEST_P(SADx4Test, ShortSrc) {
} }
TEST_P(SADx4Test, SrcAlignedByWidth) { TEST_P(SADx4Test, SrcAlignedByWidth) {
uint8_t * tmp_source_data = source_data_; uint8_t *tmp_source_data = source_data_;
source_data_ += params_.width; source_data_ += params_.width;
FillRandom(source_data_, source_stride_); FillRandom(source_data_, source_stride_);
FillRandom(GetReference(0), reference_stride_); FillRandom(GetReference(0), reference_stride_);

96
test/set_roi.cc
View File

@ -8,7 +8,6 @@
* be found in the AUTHORS file in the root of the source tree. * be found in the AUTHORS file in the root of the source tree.
*/ */
#include <math.h> #include <math.h>
#include <stddef.h> #include <stddef.h>
#include <stdio.h> #include <stdio.h>
@ -33,14 +32,10 @@ TEST(VP8RoiMapTest, ParameterCheck) {
unsigned int threshold[MAX_MB_SEGMENTS] = { 0, 100, 200, 300 }; unsigned int threshold[MAX_MB_SEGMENTS] = { 0, 100, 200, 300 };
const int internalq_trans[] = { const int internalq_trans[] = {
0, 1, 2, 3, 4, 5, 7, 8, 0, 1, 2, 3, 4, 5, 7, 8, 9, 10, 12, 13, 15, 17, 18, 19,
9, 10, 12, 13, 15, 17, 18, 19, 20, 21, 23, 24, 25, 26, 27, 28, 29, 30, 31, 33, 35, 37, 39, 41,
20, 21, 23, 24, 25, 26, 27, 28, 43, 45, 47, 49, 51, 53, 55, 57, 59, 61, 64, 67, 70, 73, 76, 79,
29, 30, 31, 33, 35, 37, 39, 41, 82, 85, 88, 91, 94, 97, 100, 103, 106, 109, 112, 115, 118, 121, 124, 127,
43, 45, 47, 49, 51, 53, 55, 57,
59, 61, 64, 67, 70, 73, 76, 79,
82, 85, 88, 91, 94, 97, 100, 103,
106, 109, 112, 115, 118, 121, 124, 127,
}; };
// Initialize elements of cpi with valid defaults. // Initialize elements of cpi with valid defaults.
@ -60,17 +55,17 @@ TEST(VP8RoiMapTest, ParameterCheck) {
// Allocate memory for the source memory map. // Allocate memory for the source memory map.
unsigned char *roi_map = unsigned char *roi_map =
reinterpret_cast<unsigned char *>(vpx_calloc(mbs, 1)); reinterpret_cast<unsigned char *>(vpx_calloc(mbs, 1));
memset(&roi_map[mbs >> 2], 1, (mbs >> 2)); memset(&roi_map[mbs >> 2], 1, (mbs >> 2));
memset(&roi_map[mbs >> 1], 2, (mbs >> 2)); memset(&roi_map[mbs >> 1], 2, (mbs >> 2));
memset(&roi_map[mbs -(mbs >> 2)], 3, (mbs >> 2)); memset(&roi_map[mbs - (mbs >> 2)], 3, (mbs >> 2));
// Do a test call with valid parameters. // Do a test call with valid parameters.
int roi_retval = vp8_set_roimap(&cpi, roi_map, cpi.common.mb_rows, int roi_retval =
cpi.common.mb_cols, delta_q, delta_lf, vp8_set_roimap(&cpi, roi_map, cpi.common.mb_rows, cpi.common.mb_cols,
threshold); delta_q, delta_lf, threshold);
EXPECT_EQ(0, roi_retval) EXPECT_EQ(0, roi_retval)
<< "vp8_set_roimap roi failed with default test parameters"; << "vp8_set_roimap roi failed with default test parameters";
// Check that the values in the cpi structure get set as expected. // Check that the values in the cpi structure get set as expected.
if (roi_retval == 0) { if (roi_retval == 0) {
@ -83,9 +78,9 @@ TEST(VP8RoiMapTest, ParameterCheck) {
for (int i = 0; i < MAX_MB_SEGMENTS; ++i) { for (int i = 0; i < MAX_MB_SEGMENTS; ++i) {
const int transq = internalq_trans[abs(delta_q[i])]; const int transq = internalq_trans[abs(delta_q[i])];
if (abs(cpi.segment_feature_data[MB_LVL_ALT_Q][i]) != transq) { if (abs(cpi.segment_feature_data[MB_LVL_ALT_Q][i]) != transq) {
EXPECT_EQ(transq, cpi.segment_feature_data[MB_LVL_ALT_Q][i]) EXPECT_EQ(transq, cpi.segment_feature_data[MB_LVL_ALT_Q][i])
<< "segment delta_q error"; << "segment delta_q error";
break; break;
} }
} }
@ -93,7 +88,7 @@ TEST(VP8RoiMapTest, ParameterCheck) {
for (int i = 0; i < MAX_MB_SEGMENTS; ++i) { for (int i = 0; i < MAX_MB_SEGMENTS; ++i) {
if (cpi.segment_feature_data[MB_LVL_ALT_LF][i] != delta_lf[i]) { if (cpi.segment_feature_data[MB_LVL_ALT_LF][i] != delta_lf[i]) {
EXPECT_EQ(delta_lf[i], cpi.segment_feature_data[MB_LVL_ALT_LF][i]) EXPECT_EQ(delta_lf[i], cpi.segment_feature_data[MB_LVL_ALT_LF][i])
<< "segment delta_lf error"; << "segment delta_lf error";
break; break;
} }
} }
@ -101,23 +96,21 @@ TEST(VP8RoiMapTest, ParameterCheck) {
// Check the breakout thresholds // Check the breakout thresholds
for (int i = 0; i < MAX_MB_SEGMENTS; ++i) { for (int i = 0; i < MAX_MB_SEGMENTS; ++i) {
unsigned int breakout = unsigned int breakout =
static_cast<unsigned int>(cpi.segment_encode_breakout[i]); static_cast<unsigned int>(cpi.segment_encode_breakout[i]);
if (threshold[i] != breakout) { if (threshold[i] != breakout) {
EXPECT_EQ(threshold[i], breakout) EXPECT_EQ(threshold[i], breakout) << "breakout threshold error";
<< "breakout threshold error";
break; break;
} }
} }
// Segmentation, and segmentation update flages should be set. // Segmentation, and segmentation update flages should be set.
EXPECT_EQ(1, cpi.mb.e_mbd.segmentation_enabled) EXPECT_EQ(1, cpi.mb.e_mbd.segmentation_enabled)
<< "segmentation_enabled error"; << "segmentation_enabled error";
EXPECT_EQ(1, cpi.mb.e_mbd.update_mb_segmentation_map) EXPECT_EQ(1, cpi.mb.e_mbd.update_mb_segmentation_map)
<< "update_mb_segmentation_map error"; << "update_mb_segmentation_map error";
EXPECT_EQ(1, cpi.mb.e_mbd.update_mb_segmentation_data) EXPECT_EQ(1, cpi.mb.e_mbd.update_mb_segmentation_data)
<< "update_mb_segmentation_data error"; << "update_mb_segmentation_data error";
// Try a range of delta q and lf parameters (some legal, some not) // Try a range of delta q and lf parameters (some legal, some not)
for (int i = 0; i < 1000; ++i) { for (int i = 0; i < 1000; ++i) {
@ -128,57 +121,54 @@ TEST(VP8RoiMapTest, ParameterCheck) {
rand_deltas[2] = rnd(160) - 80; rand_deltas[2] = rnd(160) - 80;
rand_deltas[3] = rnd(160) - 80; rand_deltas[3] = rnd(160) - 80;
deltas_valid = ((abs(rand_deltas[0]) <= 63) && deltas_valid =
(abs(rand_deltas[1]) <= 63) && ((abs(rand_deltas[0]) <= 63) && (abs(rand_deltas[1]) <= 63) &&
(abs(rand_deltas[2]) <= 63) && (abs(rand_deltas[2]) <= 63) && (abs(rand_deltas[3]) <= 63))
(abs(rand_deltas[3]) <= 63)) ? 0 : -1; ? 0
: -1;
// Test with random delta q values. // Test with random delta q values.
roi_retval = vp8_set_roimap(&cpi, roi_map, cpi.common.mb_rows, roi_retval =
cpi.common.mb_cols, rand_deltas, vp8_set_roimap(&cpi, roi_map, cpi.common.mb_rows, cpi.common.mb_cols,
delta_lf, threshold); rand_deltas, delta_lf, threshold);
EXPECT_EQ(deltas_valid, roi_retval) << "dq range check error"; EXPECT_EQ(deltas_valid, roi_retval) << "dq range check error";
// One delta_q error shown at a time // One delta_q error shown at a time
if (deltas_valid != roi_retval) if (deltas_valid != roi_retval) break;
break;
// Test with random loop filter values. // Test with random loop filter values.
roi_retval = vp8_set_roimap(&cpi, roi_map, cpi.common.mb_rows, roi_retval =
cpi.common.mb_cols, delta_q, vp8_set_roimap(&cpi, roi_map, cpi.common.mb_rows, cpi.common.mb_cols,
rand_deltas, threshold); delta_q, rand_deltas, threshold);
EXPECT_EQ(deltas_valid, roi_retval) << "dlf range check error"; EXPECT_EQ(deltas_valid, roi_retval) << "dlf range check error";
// One delta loop filter error shown at a time // One delta loop filter error shown at a time
if (deltas_valid != roi_retval) if (deltas_valid != roi_retval) break;
break;
} }
// Test that we report and error if cyclic refresh is enabled. // Test that we report and error if cyclic refresh is enabled.
cpi.cyclic_refresh_mode_enabled = 1; cpi.cyclic_refresh_mode_enabled = 1;
roi_retval = vp8_set_roimap(&cpi, roi_map, cpi.common.mb_rows, roi_retval =
cpi.common.mb_cols, delta_q, vp8_set_roimap(&cpi, roi_map, cpi.common.mb_rows, cpi.common.mb_cols,
delta_lf, threshold); delta_q, delta_lf, threshold);
EXPECT_EQ(-1, roi_retval) << "cyclic refresh check error"; EXPECT_EQ(-1, roi_retval) << "cyclic refresh check error";
cpi.cyclic_refresh_mode_enabled = 0; cpi.cyclic_refresh_mode_enabled = 0;
// Test invalid number of rows or colums. // Test invalid number of rows or colums.
roi_retval = vp8_set_roimap(&cpi, roi_map, cpi.common.mb_rows + 1, roi_retval =
cpi.common.mb_cols, delta_q, vp8_set_roimap(&cpi, roi_map, cpi.common.mb_rows + 1,
delta_lf, threshold); cpi.common.mb_cols, delta_q, delta_lf, threshold);
EXPECT_EQ(-1, roi_retval) << "MB rows bounds check error"; EXPECT_EQ(-1, roi_retval) << "MB rows bounds check error";
roi_retval = vp8_set_roimap(&cpi, roi_map, cpi.common.mb_rows, roi_retval =
cpi.common.mb_cols - 1, delta_q, vp8_set_roimap(&cpi, roi_map, cpi.common.mb_rows,
delta_lf, threshold); cpi.common.mb_cols - 1, delta_q, delta_lf, threshold);
EXPECT_EQ(-1, roi_retval) << "MB cols bounds check error"; EXPECT_EQ(-1, roi_retval) << "MB cols bounds check error";
} }
// Free allocated memory // Free allocated memory
if (cpi.segmentation_map) if (cpi.segmentation_map) vpx_free(cpi.segmentation_map);
vpx_free(cpi.segmentation_map); if (roi_map) vpx_free(roi_map);
if (roi_map)
vpx_free(roi_map);
}; };
} // namespace } // namespace

198
test/sixtap_predict_test.cc
View File

@ -25,22 +25,19 @@
namespace { namespace {
typedef void (*SixtapPredictFunc)(uint8_t *src_ptr, typedef void (*SixtapPredictFunc)(uint8_t *src_ptr, int src_pixels_per_line,
int src_pixels_per_line, int xoffset, int yoffset, uint8_t *dst_ptr,
int xoffset,
int yoffset,
uint8_t *dst_ptr,
int dst_pitch); int dst_pitch);
typedef std::tr1::tuple<int, int, SixtapPredictFunc> SixtapPredictParam; typedef std::tr1::tuple<int, int, SixtapPredictFunc> SixtapPredictParam;
class SixtapPredictTest class SixtapPredictTest : public ::testing::TestWithParam<SixtapPredictParam> {
: public ::testing::TestWithParam<SixtapPredictParam> {
public: public:
static void SetUpTestCase() { static void SetUpTestCase() {
src_ = reinterpret_cast<uint8_t*>(vpx_memalign(kDataAlignment, kSrcSize)); src_ = reinterpret_cast<uint8_t *>(vpx_memalign(kDataAlignment, kSrcSize));
dst_ = reinterpret_cast<uint8_t*>(vpx_memalign(kDataAlignment, kDstSize)); dst_ = reinterpret_cast<uint8_t *>(vpx_memalign(kDataAlignment, kDstSize));
dst_c_ = reinterpret_cast<uint8_t*>(vpx_memalign(kDataAlignment, kDstSize)); dst_c_ =
reinterpret_cast<uint8_t *>(vpx_memalign(kDataAlignment, kDstSize));
} }
static void TearDownTestCase() { static void TearDownTestCase() {
@ -52,9 +49,7 @@ class SixtapPredictTest
dst_c_ = NULL; dst_c_ = NULL;
} }
virtual void TearDown() { virtual void TearDown() { libvpx_test::ClearSystemState(); }
libvpx_test::ClearSystemState();
}
protected: protected:
// Make test arrays big enough for 16x16 functions. Six-tap filters // Make test arrays big enough for 16x16 functions. Six-tap filters
@ -80,74 +75,76 @@ class SixtapPredictTest
// The src stores the macroblock we will filter on, and makes it 1 byte larger // The src stores the macroblock we will filter on, and makes it 1 byte larger
// in order to test unaligned access. The result is stored in dst and dst_c(c // in order to test unaligned access. The result is stored in dst and dst_c(c
// reference code result). // reference code result).
static uint8_t* src_; static uint8_t *src_;
static uint8_t* dst_; static uint8_t *dst_;
static uint8_t* dst_c_; static uint8_t *dst_c_;
}; };
uint8_t* SixtapPredictTest::src_ = NULL; uint8_t *SixtapPredictTest::src_ = NULL;
uint8_t* SixtapPredictTest::dst_ = NULL; uint8_t *SixtapPredictTest::dst_ = NULL;
uint8_t* SixtapPredictTest::dst_c_ = NULL; uint8_t *SixtapPredictTest::dst_c_ = NULL;
TEST_P(SixtapPredictTest, TestWithPresetData) { TEST_P(SixtapPredictTest, TestWithPresetData) {
// Test input // Test input
static const uint8_t test_data[kSrcSize] = { static const uint8_t test_data[kSrcSize] = {
216, 184, 4, 191, 82, 92, 41, 0, 1, 226, 236, 172, 20, 182, 42, 226, 177, 216, 184, 4, 191, 82, 92, 41, 0, 1, 226, 236, 172, 20, 182, 42,
79, 94, 77, 179, 203, 206, 198, 22, 192, 19, 75, 17, 192, 44, 233, 120, 226, 177, 79, 94, 77, 179, 203, 206, 198, 22, 192, 19, 75, 17, 192,
48, 168, 203, 141, 210, 203, 143, 180, 184, 59, 201, 110, 102, 171, 32, 44, 233, 120, 48, 168, 203, 141, 210, 203, 143, 180, 184, 59, 201, 110,
182, 10, 109, 105, 213, 60, 47, 236, 253, 67, 55, 14, 3, 99, 247, 124, 102, 171, 32, 182, 10, 109, 105, 213, 60, 47, 236, 253, 67, 55, 14,
148, 159, 71, 34, 114, 19, 177, 38, 203, 237, 239, 58, 83, 155, 91, 10, 3, 99, 247, 124, 148, 159, 71, 34, 114, 19, 177, 38, 203, 237, 239,
166, 201, 115, 124, 5, 163, 104, 2, 231, 160, 16, 234, 4, 8, 103, 153, 58, 83, 155, 91, 10, 166, 201, 115, 124, 5, 163, 104, 2, 231, 160,
167, 174, 187, 26, 193, 109, 64, 141, 90, 48, 200, 174, 204, 36, 184, 16, 234, 4, 8, 103, 153, 167, 174, 187, 26, 193, 109, 64, 141, 90,
114, 237, 43, 238, 242, 207, 86, 245, 182, 247, 6, 161, 251, 14, 8, 148, 48, 200, 174, 204, 36, 184, 114, 237, 43, 238, 242, 207, 86, 245, 182,
182, 182, 79, 208, 120, 188, 17, 6, 23, 65, 206, 197, 13, 242, 126, 128, 247, 6, 161, 251, 14, 8, 148, 182, 182, 79, 208, 120, 188, 17, 6,
224, 170, 110, 211, 121, 197, 200, 47, 188, 207, 208, 184, 221, 216, 76, 23, 65, 206, 197, 13, 242, 126, 128, 224, 170, 110, 211, 121, 197, 200,
148, 143, 156, 100, 8, 89, 117, 14, 112, 183, 221, 54, 197, 208, 180, 69, 47, 188, 207, 208, 184, 221, 216, 76, 148, 143, 156, 100, 8, 89, 117,
176, 94, 180, 131, 215, 121, 76, 7, 54, 28, 216, 238, 249, 176, 58, 142, 14, 112, 183, 221, 54, 197, 208, 180, 69, 176, 94, 180, 131, 215, 121,
64, 215, 242, 72, 49, 104, 87, 161, 32, 52, 216, 230, 4, 141, 44, 181, 76, 7, 54, 28, 216, 238, 249, 176, 58, 142, 64, 215, 242, 72, 49,
235, 224, 57, 195, 89, 134, 203, 144, 162, 163, 126, 156, 84, 185, 42, 104, 87, 161, 32, 52, 216, 230, 4, 141, 44, 181, 235, 224, 57, 195,
148, 145, 29, 221, 194, 134, 52, 100, 166, 105, 60, 140, 110, 201, 184, 89, 134, 203, 144, 162, 163, 126, 156, 84, 185, 42, 148, 145, 29, 221,
35, 181, 153, 93, 121, 243, 227, 68, 131, 134, 232, 2, 35, 60, 187, 77, 194, 134, 52, 100, 166, 105, 60, 140, 110, 201, 184, 35, 181, 153, 93,
209, 76, 106, 174, 15, 241, 227, 115, 151, 77, 175, 36, 187, 121, 221, 121, 243, 227, 68, 131, 134, 232, 2, 35, 60, 187, 77, 209, 76, 106,
223, 47, 118, 61, 168, 105, 32, 237, 236, 167, 213, 238, 202, 17, 170, 174, 15, 241, 227, 115, 151, 77, 175, 36, 187, 121, 221, 223, 47, 118,
24, 226, 247, 131, 145, 6, 116, 117, 121, 11, 194, 41, 48, 126, 162, 13, 61, 168, 105, 32, 237, 236, 167, 213, 238, 202, 17, 170, 24, 226, 247,
93, 209, 131, 154, 122, 237, 187, 103, 217, 99, 60, 200, 45, 78, 115, 69, 131, 145, 6, 116, 117, 121, 11, 194, 41, 48, 126, 162, 13, 93, 209,
49, 106, 200, 194, 112, 60, 56, 234, 72, 251, 19, 120, 121, 182, 134, 215, 131, 154, 122, 237, 187, 103, 217, 99, 60, 200, 45, 78, 115, 69, 49,
135, 10, 114, 2, 247, 46, 105, 209, 145, 165, 153, 191, 243, 12, 5, 36, 106, 200, 194, 112, 60, 56, 234, 72, 251, 19, 120, 121, 182, 134, 215,
119, 206, 231, 231, 11, 32, 209, 83, 27, 229, 204, 149, 155, 83, 109, 35, 135, 10, 114, 2, 247, 46, 105, 209, 145, 165, 153, 191, 243, 12, 5,
93, 223, 37, 84, 14, 142, 37, 160, 52, 191, 96, 40, 204, 101, 77, 67, 52, 36, 119, 206, 231, 231, 11, 32, 209, 83, 27, 229, 204, 149, 155, 83,
53, 43, 63, 85, 253, 147, 113, 226, 96, 6, 125, 179, 115, 161, 17, 83, 109, 35, 93, 223, 37, 84, 14, 142, 37, 160, 52, 191, 96, 40, 204,
198, 101, 98, 85, 139, 3, 137, 75, 99, 178, 23, 201, 255, 91, 253, 52, 101, 77, 67, 52, 53, 43, 63, 85, 253, 147, 113, 226, 96, 6, 125,
134, 60, 138, 131, 208, 251, 101, 48, 2, 227, 228, 118, 132, 245, 202, 179, 115, 161, 17, 83, 198, 101, 98, 85, 139, 3, 137, 75, 99, 178,
75, 91, 44, 160, 231, 47, 41, 50, 147, 220, 74, 92, 219, 165, 89, 16 23, 201, 255, 91, 253, 52, 134, 60, 138, 131, 208, 251, 101, 48, 2,
227, 228, 118, 132, 245, 202, 75, 91, 44, 160, 231, 47, 41, 50, 147,
220, 74, 92, 219, 165, 89, 16
}; };
// Expected result // Expected result
static const uint8_t expected_dst[kDstSize] = { static const uint8_t expected_dst[kDstSize] = {
117, 102, 74, 135, 42, 98, 175, 206, 70, 73, 222, 197, 50, 24, 39, 49, 38, 117, 102, 74, 135, 42, 98, 175, 206, 70, 73, 222, 197, 50, 24, 39,
105, 90, 47, 169, 40, 171, 215, 200, 73, 109, 141, 53, 85, 177, 164, 79, 49, 38, 105, 90, 47, 169, 40, 171, 215, 200, 73, 109, 141, 53, 85,
208, 124, 89, 212, 18, 81, 145, 151, 164, 217, 153, 91, 154, 102, 102, 177, 164, 79, 208, 124, 89, 212, 18, 81, 145, 151, 164, 217, 153, 91,
159, 75, 164, 152, 136, 51, 213, 219, 186, 116, 193, 224, 186, 36, 231, 154, 102, 102, 159, 75, 164, 152, 136, 51, 213, 219, 186, 116, 193, 224,
208, 84, 211, 155, 167, 35, 59, 42, 76, 216, 149, 73, 201, 78, 149, 184, 186, 36, 231, 208, 84, 211, 155, 167, 35, 59, 42, 76, 216, 149, 73,
100, 96, 196, 189, 198, 188, 235, 195, 117, 129, 120, 129, 49, 25, 133, 201, 78, 149, 184, 100, 96, 196, 189, 198, 188, 235, 195, 117, 129, 120,
113, 69, 221, 114, 70, 143, 99, 157, 108, 189, 140, 78, 6, 55, 65, 240, 129, 49, 25, 133, 113, 69, 221, 114, 70, 143, 99, 157, 108, 189, 140,
255, 245, 184, 72, 90, 100, 116, 131, 39, 60, 234, 167, 33, 160, 88, 185, 78, 6, 55, 65, 240, 255, 245, 184, 72, 90, 100, 116, 131, 39, 60,
200, 157, 159, 176, 127, 151, 138, 102, 168, 106, 170, 86, 82, 219, 189, 234, 167, 33, 160, 88, 185, 200, 157, 159, 176, 127, 151, 138, 102, 168,
76, 33, 115, 197, 106, 96, 198, 136, 97, 141, 237, 151, 98, 137, 191, 106, 170, 86, 82, 219, 189, 76, 33, 115, 197, 106, 96, 198, 136, 97,
185, 2, 57, 95, 142, 91, 255, 185, 97, 137, 76, 162, 94, 173, 131, 193, 141, 237, 151, 98, 137, 191, 185, 2, 57, 95, 142, 91, 255, 185, 97,
161, 81, 106, 72, 135, 222, 234, 137, 66, 137, 106, 243, 210, 147, 95, 137, 76, 162, 94, 173, 131, 193, 161, 81, 106, 72, 135, 222, 234, 137,
15, 137, 110, 85, 66, 16, 96, 167, 147, 150, 173, 203, 140, 118, 196, 66, 137, 106, 243, 210, 147, 95, 15, 137, 110, 85, 66, 16, 96, 167,
84, 147, 160, 19, 95, 101, 123, 74, 132, 202, 82, 166, 12, 131, 166, 147, 150, 173, 203, 140, 118, 196, 84, 147, 160, 19, 95, 101, 123, 74,
189, 170, 159, 85, 79, 66, 57, 152, 132, 203, 194, 0, 1, 56, 146, 180, 132, 202, 82, 166, 12, 131, 166, 189, 170, 159, 85, 79, 66, 57, 152,
224, 156, 28, 83, 181, 79, 76, 80, 46, 160, 175, 59, 106, 43, 87, 75, 132, 203, 194, 0, 1, 56, 146, 180, 224, 156, 28, 83, 181, 79, 76,
136, 85, 189, 46, 71, 200, 90 80, 46, 160, 175, 59, 106, 43, 87, 75, 136, 85, 189, 46, 71, 200,
90
}; };
uint8_t *src = const_cast<uint8_t*>(test_data); uint8_t *src = const_cast<uint8_t *>(test_data);
ASM_REGISTER_STATE_CHECK( ASM_REGISTER_STATE_CHECK(sixtap_predict_(&src[kSrcStride * 2 + 2 + 1],
sixtap_predict_(&src[kSrcStride * 2 + 2 + 1], kSrcStride, kSrcStride, 2, 2, dst_, kDstStride));
2, 2, dst_, kDstStride));
for (int i = 0; i < height_; ++i) for (int i = 0; i < height_; ++i)
for (int j = 0; j < width_; ++j) for (int j = 0; j < width_; ++j)
@ -159,8 +156,7 @@ using libvpx_test::ACMRandom;
TEST_P(SixtapPredictTest, TestWithRandomData) { TEST_P(SixtapPredictTest, TestWithRandomData) {
ACMRandom rnd(ACMRandom::DeterministicSeed()); ACMRandom rnd(ACMRandom::DeterministicSeed());
for (int i = 0; i < kSrcSize; ++i) for (int i = 0; i < kSrcSize; ++i) src_[i] = rnd.Rand8();
src_[i] = rnd.Rand8();
// Run tests for all possible offsets. // Run tests for all possible offsets.
for (int xoffset = 0; xoffset < 8; ++xoffset) { for (int xoffset = 0; xoffset < 8; ++xoffset) {
@ -172,9 +168,9 @@ TEST_P(SixtapPredictTest, TestWithRandomData) {
xoffset, yoffset, dst_c_, kDstStride); xoffset, yoffset, dst_c_, kDstStride);
// Run test. // Run test.
ASM_REGISTER_STATE_CHECK( ASM_REGISTER_STATE_CHECK(sixtap_predict_(&src_[kSrcStride * 2 + 2 + 1],
sixtap_predict_(&src_[kSrcStride * 2 + 2 + 1], kSrcStride, kSrcStride, xoffset, yoffset,
xoffset, yoffset, dst_, kDstStride)); dst_, kDstStride));
for (int i = 0; i < height_; ++i) for (int i = 0; i < height_; ++i)
for (int j = 0; j < width_; ++j) for (int j = 0; j < width_; ++j)
@ -187,47 +183,47 @@ TEST_P(SixtapPredictTest, TestWithRandomData) {
using std::tr1::make_tuple; using std::tr1::make_tuple;
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
C, SixtapPredictTest, ::testing::Values( C, SixtapPredictTest,
make_tuple(16, 16, &vp8_sixtap_predict16x16_c), ::testing::Values(make_tuple(16, 16, &vp8_sixtap_predict16x16_c),
make_tuple(8, 8, &vp8_sixtap_predict8x8_c), make_tuple(8, 8, &vp8_sixtap_predict8x8_c),
make_tuple(8, 4, &vp8_sixtap_predict8x4_c), make_tuple(8, 4, &vp8_sixtap_predict8x4_c),
make_tuple(4, 4, &vp8_sixtap_predict4x4_c))); make_tuple(4, 4, &vp8_sixtap_predict4x4_c)));
#if HAVE_NEON #if HAVE_NEON
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
NEON, SixtapPredictTest, ::testing::Values( NEON, SixtapPredictTest,
make_tuple(16, 16, &vp8_sixtap_predict16x16_neon), ::testing::Values(make_tuple(16, 16, &vp8_sixtap_predict16x16_neon),
make_tuple(8, 8, &vp8_sixtap_predict8x8_neon), make_tuple(8, 8, &vp8_sixtap_predict8x8_neon),
make_tuple(8, 4, &vp8_sixtap_predict8x4_neon))); make_tuple(8, 4, &vp8_sixtap_predict8x4_neon)));
#endif #endif
#if HAVE_MMX #if HAVE_MMX
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
MMX, SixtapPredictTest, ::testing::Values( MMX, SixtapPredictTest,
make_tuple(16, 16, &vp8_sixtap_predict16x16_mmx), ::testing::Values(make_tuple(16, 16, &vp8_sixtap_predict16x16_mmx),
make_tuple(8, 8, &vp8_sixtap_predict8x8_mmx), make_tuple(8, 8, &vp8_sixtap_predict8x8_mmx),
make_tuple(8, 4, &vp8_sixtap_predict8x4_mmx), make_tuple(8, 4, &vp8_sixtap_predict8x4_mmx),
make_tuple(4, 4, &vp8_sixtap_predict4x4_mmx))); make_tuple(4, 4, &vp8_sixtap_predict4x4_mmx)));
#endif #endif
#if HAVE_SSE2 #if HAVE_SSE2
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
SSE2, SixtapPredictTest, ::testing::Values( SSE2, SixtapPredictTest,
make_tuple(16, 16, &vp8_sixtap_predict16x16_sse2), ::testing::Values(make_tuple(16, 16, &vp8_sixtap_predict16x16_sse2),
make_tuple(8, 8, &vp8_sixtap_predict8x8_sse2), make_tuple(8, 8, &vp8_sixtap_predict8x8_sse2),
make_tuple(8, 4, &vp8_sixtap_predict8x4_sse2))); make_tuple(8, 4, &vp8_sixtap_predict8x4_sse2)));
#endif #endif
#if HAVE_SSSE3 #if HAVE_SSSE3
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
SSSE3, SixtapPredictTest, ::testing::Values( SSSE3, SixtapPredictTest,
make_tuple(16, 16, &vp8_sixtap_predict16x16_ssse3), ::testing::Values(make_tuple(16, 16, &vp8_sixtap_predict16x16_ssse3),
make_tuple(8, 8, &vp8_sixtap_predict8x8_ssse3), make_tuple(8, 8, &vp8_sixtap_predict8x8_ssse3),
make_tuple(8, 4, &vp8_sixtap_predict8x4_ssse3), make_tuple(8, 4, &vp8_sixtap_predict8x4_ssse3),
make_tuple(4, 4, &vp8_sixtap_predict4x4_ssse3))); make_tuple(4, 4, &vp8_sixtap_predict4x4_ssse3)));
#endif #endif
#if HAVE_MSA #if HAVE_MSA
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
MSA, SixtapPredictTest, ::testing::Values( MSA, SixtapPredictTest,
make_tuple(16, 16, &vp8_sixtap_predict16x16_msa), ::testing::Values(make_tuple(16, 16, &vp8_sixtap_predict16x16_msa),
make_tuple(8, 8, &vp8_sixtap_predict8x8_msa), make_tuple(8, 8, &vp8_sixtap_predict8x8_msa),
make_tuple(8, 4, &vp8_sixtap_predict8x4_msa), make_tuple(8, 4, &vp8_sixtap_predict8x4_msa),
make_tuple(4, 4, &vp8_sixtap_predict4x4_msa))); make_tuple(4, 4, &vp8_sixtap_predict4x4_msa)));
#endif #endif
} // namespace } // namespace

22
test/sum_squares_test.cc
View File

@ -52,9 +52,9 @@ TEST_P(SumSquaresTest, OperationCheck) {
const int limit = 1 << (msb + 1); const int limit = 1 << (msb + 1);
for (int k = 0; k < kNumIterations; k++) { for (int k = 0; k < kNumIterations; k++) {
const int size = 4 << rnd(6); // Up to 128x128 const int size = 4 << rnd(6); // Up to 128x128
int stride = 4 << rnd(7); // Up to 256 stride int stride = 4 << rnd(7); // Up to 256 stride
while (stride < size) { // Make sure it's valid while (stride < size) { // Make sure it's valid
stride = 4 << rnd(7); stride = 4 << rnd(7);
} }
@ -68,9 +68,8 @@ TEST_P(SumSquaresTest, OperationCheck) {
uint64_t res_tst; uint64_t res_tst;
ASM_REGISTER_STATE_CHECK(res_tst = tst_func_(src, stride, size)); ASM_REGISTER_STATE_CHECK(res_tst = tst_func_(src, stride, size));
ASSERT_EQ(res_ref, res_tst) ASSERT_EQ(res_ref, res_tst) << "Error: Sum Squares Test"
<< "Error: Sum Squares Test" << " C output does not match optimized output.";
<< " C output does not match optimized output.";
} }
} }
@ -81,9 +80,9 @@ TEST_P(SumSquaresTest, ExtremeValues) {
const int limit = 1 << (msb + 1); const int limit = 1 << (msb + 1);
for (int k = 0; k < kNumIterations; k++) { for (int k = 0; k < kNumIterations; k++) {
const int size = 4 << rnd(6); // Up to 128x128 const int size = 4 << rnd(6); // Up to 128x128
int stride = 4 << rnd(7); // Up to 256 stride int stride = 4 << rnd(7); // Up to 256 stride
while (stride < size) { // Make sure it's valid while (stride < size) { // Make sure it's valid
stride = 4 << rnd(7); stride = 4 << rnd(7);
} }
@ -98,9 +97,8 @@ TEST_P(SumSquaresTest, ExtremeValues) {
uint64_t res_tst; uint64_t res_tst;
ASM_REGISTER_STATE_CHECK(res_tst = tst_func_(src, stride, size)); ASM_REGISTER_STATE_CHECK(res_tst = tst_func_(src, stride, size));
ASSERT_EQ(res_ref, res_tst) ASSERT_EQ(res_ref, res_tst) << "Error: Sum Squares Test"
<< "Error: Sum Squares Test" << " C output does not match optimized output.";
<< " C output does not match optimized output.";
} }
} }

42
test/superframe_test.cc
View File

@ -18,13 +18,14 @@ namespace {
const int kTestMode = 0; const int kTestMode = 0;
typedef std::tr1::tuple<libvpx_test::TestMode,int> SuperframeTestParam; typedef std::tr1::tuple<libvpx_test::TestMode, int> SuperframeTestParam;
class SuperframeTest : public ::libvpx_test::EncoderTest, class SuperframeTest
public ::libvpx_test::CodecTestWithParam<SuperframeTestParam> { : public ::libvpx_test::EncoderTest,
public ::libvpx_test::CodecTestWithParam<SuperframeTestParam> {
protected: protected:
SuperframeTest() : EncoderTest(GET_PARAM(0)), modified_buf_(NULL), SuperframeTest()
last_sf_pts_(0) {} : EncoderTest(GET_PARAM(0)), modified_buf_(NULL), last_sf_pts_(0) {}
virtual ~SuperframeTest() {} virtual ~SuperframeTest() {}
virtual void SetUp() { virtual void SetUp() {
@ -36,9 +37,7 @@ class SuperframeTest : public ::libvpx_test::EncoderTest,
sf_count_max_ = INT_MAX; sf_count_max_ = INT_MAX;
} }
virtual void TearDown() { virtual void TearDown() { delete[] modified_buf_; }
delete[] modified_buf_;
}
virtual void PreEncodeFrameHook(libvpx_test::VideoSource *video, virtual void PreEncodeFrameHook(libvpx_test::VideoSource *video,
libvpx_test::Encoder *encoder) { libvpx_test::Encoder *encoder) {
@ -47,25 +46,21 @@ class SuperframeTest : public ::libvpx_test::EncoderTest,
} }
} }
virtual const vpx_codec_cx_pkt_t * MutateEncoderOutputHook( virtual const vpx_codec_cx_pkt_t *MutateEncoderOutputHook(
const vpx_codec_cx_pkt_t *pkt) { const vpx_codec_cx_pkt_t *pkt) {
if (pkt->kind != VPX_CODEC_CX_FRAME_PKT) if (pkt->kind != VPX_CODEC_CX_FRAME_PKT) return pkt;
return pkt;
const uint8_t *buffer = reinterpret_cast<uint8_t*>(pkt->data.frame.buf); const uint8_t *buffer = reinterpret_cast<uint8_t *>(pkt->data.frame.buf);
const uint8_t marker = buffer[pkt->data.frame.sz - 1]; const uint8_t marker = buffer[pkt->data.frame.sz - 1];
const int frames = (marker & 0x7) + 1; const int frames = (marker & 0x7) + 1;
const int mag = ((marker >> 3) & 3) + 1; const int mag = ((marker >> 3) & 3) + 1;
const unsigned int index_sz = 2 + mag * frames; const unsigned int index_sz = 2 + mag * frames;
if ((marker & 0xe0) == 0xc0 && if ((marker & 0xe0) == 0xc0 && pkt->data.frame.sz >= index_sz &&
pkt->data.frame.sz >= index_sz &&
buffer[pkt->data.frame.sz - index_sz] == marker) { buffer[pkt->data.frame.sz - index_sz] == marker) {
// frame is a superframe. strip off the index. // frame is a superframe. strip off the index.
if (modified_buf_) if (modified_buf_) delete[] modified_buf_;
delete[] modified_buf_;
modified_buf_ = new uint8_t[pkt->data.frame.sz - index_sz]; modified_buf_ = new uint8_t[pkt->data.frame.sz - index_sz];
memcpy(modified_buf_, pkt->data.frame.buf, memcpy(modified_buf_, pkt->data.frame.buf, pkt->data.frame.sz - index_sz);
pkt->data.frame.sz - index_sz);
modified_pkt_ = *pkt; modified_pkt_ = *pkt;
modified_pkt_.data.frame.buf = modified_buf_; modified_pkt_.data.frame.buf = modified_buf_;
modified_pkt_.data.frame.sz -= index_sz; modified_pkt_.data.frame.sz -= index_sz;
@ -76,8 +71,8 @@ class SuperframeTest : public ::libvpx_test::EncoderTest,
} }
// Make sure we do a few frames after the last SF // Make sure we do a few frames after the last SF
abort_ |= sf_count_ > sf_count_max_ && abort_ |=
pkt->data.frame.pts - last_sf_pts_ >= 5; sf_count_ > sf_count_max_ && pkt->data.frame.pts - last_sf_pts_ >= 5;
return pkt; return pkt;
} }
@ -98,7 +93,8 @@ TEST_P(SuperframeTest, TestSuperframeIndexIsOptional) {
EXPECT_EQ(sf_count_, 1); EXPECT_EQ(sf_count_, 1);
} }
VP9_INSTANTIATE_TEST_CASE(SuperframeTest, ::testing::Combine( VP9_INSTANTIATE_TEST_CASE(
::testing::Values(::libvpx_test::kTwoPassGood), SuperframeTest,
::testing::Values(0))); ::testing::Combine(::testing::Values(::libvpx_test::kTwoPassGood),
::testing::Values(0)));
} // namespace } // namespace

98
test/svc_test.cc
View File

@ -33,10 +33,8 @@ class SvcTest : public ::testing::Test {
static const uint32_t kHeight = 288; static const uint32_t kHeight = 288;
SvcTest() SvcTest()
: codec_iface_(0), : codec_iface_(0), test_file_name_("hantro_collage_w352h288.yuv"),
test_file_name_("hantro_collage_w352h288.yuv"), codec_initialized_(false), decoder_(0) {
codec_initialized_(false),
decoder_(0) {
memset(&svc_, 0, sizeof(svc_)); memset(&svc_, 0, sizeof(svc_));
memset(&codec_, 0, sizeof(codec_)); memset(&codec_, 0, sizeof(codec_));
memset(&codec_enc_, 0, sizeof(codec_enc_)); memset(&codec_enc_, 0, sizeof(codec_enc_));
@ -70,7 +68,7 @@ class SvcTest : public ::testing::Test {
virtual void TearDown() { virtual void TearDown() {
ReleaseEncoder(); ReleaseEncoder();
delete(decoder_); delete (decoder_);
} }
void InitializeEncoder() { void InitializeEncoder() {
@ -97,7 +95,7 @@ class SvcTest : public ::testing::Test {
if (cx_pkt->kind == VPX_CODEC_STATS_PKT) { if (cx_pkt->kind == VPX_CODEC_STATS_PKT) {
EXPECT_GT(cx_pkt->data.twopass_stats.sz, 0U); EXPECT_GT(cx_pkt->data.twopass_stats.sz, 0U);
ASSERT_TRUE(cx_pkt->data.twopass_stats.buf != NULL); ASSERT_TRUE(cx_pkt->data.twopass_stats.buf != NULL);
stats_buf->append(static_cast<char*>(cx_pkt->data.twopass_stats.buf), stats_buf->append(static_cast<char *>(cx_pkt->data.twopass_stats.buf),
cx_pkt->data.twopass_stats.sz); cx_pkt->data.twopass_stats.sz);
} }
} }
@ -113,10 +111,9 @@ class SvcTest : public ::testing::Test {
codec_enc_.g_pass = VPX_RC_FIRST_PASS; codec_enc_.g_pass = VPX_RC_FIRST_PASS;
InitializeEncoder(); InitializeEncoder();
libvpx_test::I420VideoSource video(test_file_name_, libvpx_test::I420VideoSource video(
codec_enc_.g_w, codec_enc_.g_h, test_file_name_, codec_enc_.g_w, codec_enc_.g_h,
codec_enc_.g_timebase.den, codec_enc_.g_timebase.den, codec_enc_.g_timebase.num, 0, 30);
codec_enc_.g_timebase.num, 0, 30);
video.Begin(); video.Begin();
for (int i = 0; i < n; ++i) { for (int i = 0; i < n; ++i) {
@ -128,8 +125,8 @@ class SvcTest : public ::testing::Test {
} }
// Flush encoder and test EOS packet. // Flush encoder and test EOS packet.
res = vpx_svc_encode(&svc_, &codec_, NULL, video.pts(), res = vpx_svc_encode(&svc_, &codec_, NULL, video.pts(), video.duration(),
video.duration(), VPX_DL_GOOD_QUALITY); VPX_DL_GOOD_QUALITY);
ASSERT_EQ(VPX_CODEC_OK, res); ASSERT_EQ(VPX_CODEC_OK, res);
GetStatsData(stats_buf); GetStatsData(stats_buf);
@ -163,8 +160,8 @@ class SvcTest : public ::testing::Test {
} }
} }
void Pass2EncodeNFrames(std::string *const stats_buf, void Pass2EncodeNFrames(std::string *const stats_buf, const int n,
const int n, const int layers, const int layers,
struct vpx_fixed_buf *const outputs) { struct vpx_fixed_buf *const outputs) {
vpx_codec_err_t res; vpx_codec_err_t res;
size_t frame_received = 0; size_t frame_received = 0;
@ -182,10 +179,9 @@ class SvcTest : public ::testing::Test {
} }
InitializeEncoder(); InitializeEncoder();
libvpx_test::I420VideoSource video(test_file_name_, libvpx_test::I420VideoSource video(
codec_enc_.g_w, codec_enc_.g_h, test_file_name_, codec_enc_.g_w, codec_enc_.g_h,
codec_enc_.g_timebase.den, codec_enc_.g_timebase.den, codec_enc_.g_timebase.num, 0, 30);
codec_enc_.g_timebase.num, 0, 30);
video.Begin(); video.Begin();
for (int i = 0; i < n; ++i) { for (int i = 0; i < n; ++i) {
@ -197,8 +193,8 @@ class SvcTest : public ::testing::Test {
} }
// Flush encoder. // Flush encoder.
res = vpx_svc_encode(&svc_, &codec_, NULL, 0, res = vpx_svc_encode(&svc_, &codec_, NULL, 0, video.duration(),
video.duration(), VPX_DL_GOOD_QUALITY); VPX_DL_GOOD_QUALITY);
EXPECT_EQ(VPX_CODEC_OK, res); EXPECT_EQ(VPX_CODEC_OK, res);
StoreFrames(n, outputs, &frame_received); StoreFrames(n, outputs, &frame_received);
@ -217,9 +213,8 @@ class SvcTest : public ::testing::Test {
for (int i = 0; i < n; ++i) { for (int i = 0; i < n; ++i) {
ASSERT_TRUE(inputs[i].buf != NULL); ASSERT_TRUE(inputs[i].buf != NULL);
ASSERT_GT(inputs[i].sz, 0U); ASSERT_GT(inputs[i].sz, 0U);
const vpx_codec_err_t res_dec = const vpx_codec_err_t res_dec = decoder_->DecodeFrame(
decoder_->DecodeFrame(static_cast<const uint8_t *>(inputs[i].buf), static_cast<const uint8_t *>(inputs[i].buf), inputs[i].sz);
inputs[i].sz);
ASSERT_EQ(VPX_CODEC_OK, res_dec) << decoder_->DecodeError(); ASSERT_EQ(VPX_CODEC_OK, res_dec) << decoder_->DecodeError();
++decoded_frames; ++decoded_frames;
@ -240,17 +235,16 @@ class SvcTest : public ::testing::Test {
ASSERT_GT(remained_spatial_layers, 0); ASSERT_GT(remained_spatial_layers, 0);
for (int i = 0; i < num_super_frames; ++i) { for (int i = 0; i < num_super_frames; ++i) {
uint32_t frame_sizes[8] = {0}; uint32_t frame_sizes[8] = { 0 };
int frame_count = 0; int frame_count = 0;
int frames_found = 0; int frames_found = 0;
int frame; int frame;
ASSERT_TRUE(inputs[i].buf != NULL); ASSERT_TRUE(inputs[i].buf != NULL);
ASSERT_GT(inputs[i].sz, 0U); ASSERT_GT(inputs[i].sz, 0U);
vpx_codec_err_t res = vpx_codec_err_t res = vp9_parse_superframe_index(
vp9_parse_superframe_index(static_cast<const uint8_t*>(inputs[i].buf), static_cast<const uint8_t *>(inputs[i].buf), inputs[i].sz,
inputs[i].sz, frame_sizes, &frame_count, frame_sizes, &frame_count, NULL, NULL);
NULL, NULL);
ASSERT_EQ(VPX_CODEC_OK, res); ASSERT_EQ(VPX_CODEC_OK, res);
if (frame_count == 0) { if (frame_count == 0) {
@ -258,28 +252,27 @@ class SvcTest : public ::testing::Test {
ASSERT_EQ(1, remained_spatial_layers); ASSERT_EQ(1, remained_spatial_layers);
} else { } else {
// Found a super frame. // Found a super frame.
uint8_t *frame_data = static_cast<uint8_t*>(inputs[i].buf); uint8_t *frame_data = static_cast<uint8_t *>(inputs[i].buf);
uint8_t *frame_start = frame_data; uint8_t *frame_start = frame_data;
for (frame = 0; frame < frame_count; ++frame) { for (frame = 0; frame < frame_count; ++frame) {
// Looking for a visible frame. // Looking for a visible frame.
if (frame_data[0] & 0x02) { if (frame_data[0] & 0x02) {
++frames_found; ++frames_found;
if (frames_found == remained_spatial_layers) if (frames_found == remained_spatial_layers) break;
break;
} }
frame_data += frame_sizes[frame]; frame_data += frame_sizes[frame];
} }
ASSERT_LT(frame, frame_count) << "Couldn't find a visible frame. " ASSERT_LT(frame, frame_count)
<< "Couldn't find a visible frame. "
<< "remained_spatial_layers: " << remained_spatial_layers << "remained_spatial_layers: " << remained_spatial_layers
<< " super_frame: " << i; << " super_frame: " << i;
if (frame == frame_count - 1) if (frame == frame_count - 1) continue;
continue;
frame_data += frame_sizes[frame]; frame_data += frame_sizes[frame];
// We need to add one more frame for multiple frame contexts. // We need to add one more frame for multiple frame contexts.
uint8_t marker = uint8_t marker =
static_cast<const uint8_t*>(inputs[i].buf)[inputs[i].sz - 1]; static_cast<const uint8_t *>(inputs[i].buf)[inputs[i].sz - 1];
const uint32_t mag = ((marker >> 3) & 0x3) + 1; const uint32_t mag = ((marker >> 3) & 0x3) + 1;
const size_t index_sz = 2 + mag * frame_count; const size_t index_sz = 2 + mag * frame_count;
const size_t new_index_sz = 2 + mag * (frame + 1); const size_t new_index_sz = 2 + mag * (frame + 1);
@ -445,7 +438,7 @@ TEST_F(SvcTest, SetAutoAltRefOption) {
// Test that decoder can handle an SVC frame as the first frame in a sequence. // Test that decoder can handle an SVC frame as the first frame in a sequence.
TEST_F(SvcTest, OnePassEncodeOneFrame) { TEST_F(SvcTest, OnePassEncodeOneFrame) {
codec_enc_.g_pass = VPX_RC_ONE_PASS; codec_enc_.g_pass = VPX_RC_ONE_PASS;
vpx_fixed_buf output = {0}; vpx_fixed_buf output = { 0 };
Pass2EncodeNFrames(NULL, 1, 2, &output); Pass2EncodeNFrames(NULL, 1, 2, &output);
DecodeNFrames(&output, 1); DecodeNFrames(&output, 1);
FreeBitstreamBuffers(&output, 1); FreeBitstreamBuffers(&output, 1);
@ -539,8 +532,7 @@ TEST_F(SvcTest, TwoPassEncode2SNRLayers) {
// Second pass encode // Second pass encode
codec_enc_.g_pass = VPX_RC_LAST_PASS; codec_enc_.g_pass = VPX_RC_LAST_PASS;
vpx_svc_set_options(&svc_, vpx_svc_set_options(&svc_, "auto-alt-refs=1,1 scale-factors=1/1,1/1");
"auto-alt-refs=1,1 scale-factors=1/1,1/1");
vpx_fixed_buf outputs[20]; vpx_fixed_buf outputs[20];
memset(&outputs[0], 0, sizeof(outputs)); memset(&outputs[0], 0, sizeof(outputs));
Pass2EncodeNFrames(&stats_buf, 20, 2, &outputs[0]); Pass2EncodeNFrames(&stats_buf, 20, 2, &outputs[0]);
@ -556,8 +548,7 @@ TEST_F(SvcTest, TwoPassEncode3SNRLayersDecode321Layers) {
// Second pass encode // Second pass encode
codec_enc_.g_pass = VPX_RC_LAST_PASS; codec_enc_.g_pass = VPX_RC_LAST_PASS;
vpx_svc_set_options(&svc_, vpx_svc_set_options(&svc_, "auto-alt-refs=1,1,1 scale-factors=1/1,1/1,1/1");
"auto-alt-refs=1,1,1 scale-factors=1/1,1/1,1/1");
vpx_fixed_buf outputs[20]; vpx_fixed_buf outputs[20];
memset(&outputs[0], 0, sizeof(outputs)); memset(&outputs[0], 0, sizeof(outputs));
Pass2EncodeNFrames(&stats_buf, 20, 3, &outputs[0]); Pass2EncodeNFrames(&stats_buf, 20, 3, &outputs[0]);
@ -572,8 +563,7 @@ TEST_F(SvcTest, TwoPassEncode3SNRLayersDecode321Layers) {
TEST_F(SvcTest, SetMultipleFrameContextsOption) { TEST_F(SvcTest, SetMultipleFrameContextsOption) {
svc_.spatial_layers = 5; svc_.spatial_layers = 5;
vpx_codec_err_t res = vpx_codec_err_t res = vpx_svc_set_options(&svc_, "multi-frame-contexts=1");
vpx_svc_set_options(&svc_, "multi-frame-contexts=1");
EXPECT_EQ(VPX_CODEC_OK, res); EXPECT_EQ(VPX_CODEC_OK, res);
res = vpx_svc_init(&svc_, &codec_, vpx_codec_vp9_cx(), &codec_enc_); res = vpx_svc_init(&svc_, &codec_, vpx_codec_vp9_cx(), &codec_enc_);
EXPECT_EQ(VPX_CODEC_INVALID_PARAM, res); EXPECT_EQ(VPX_CODEC_INVALID_PARAM, res);
@ -626,7 +616,8 @@ TEST_F(SvcTest, TwoPassEncode2SNRLayersWithMultipleFrameContexts) {
// Second pass encode // Second pass encode
codec_enc_.g_pass = VPX_RC_LAST_PASS; codec_enc_.g_pass = VPX_RC_LAST_PASS;
codec_enc_.g_error_resilient = 0; codec_enc_.g_error_resilient = 0;
vpx_svc_set_options(&svc_, "auto-alt-refs=1,1 scale-factors=1/1,1/1 " vpx_svc_set_options(&svc_,
"auto-alt-refs=1,1 scale-factors=1/1,1/1 "
"multi-frame-contexts=1"); "multi-frame-contexts=1");
vpx_fixed_buf outputs[10]; vpx_fixed_buf outputs[10];
memset(&outputs[0], 0, sizeof(outputs)); memset(&outputs[0], 0, sizeof(outputs));
@ -645,7 +636,8 @@ TEST_F(SvcTest,
// Second pass encode // Second pass encode
codec_enc_.g_pass = VPX_RC_LAST_PASS; codec_enc_.g_pass = VPX_RC_LAST_PASS;
codec_enc_.g_error_resilient = 0; codec_enc_.g_error_resilient = 0;
vpx_svc_set_options(&svc_, "auto-alt-refs=1,1,1 scale-factors=1/1,1/1,1/1 " vpx_svc_set_options(&svc_,
"auto-alt-refs=1,1,1 scale-factors=1/1,1/1,1/1 "
"multi-frame-contexts=1"); "multi-frame-contexts=1");
vpx_fixed_buf outputs[10]; vpx_fixed_buf outputs[10];
memset(&outputs[0], 0, sizeof(outputs)); memset(&outputs[0], 0, sizeof(outputs));
@ -689,7 +681,8 @@ TEST_F(SvcTest, TwoPassEncode2TemporalLayersWithMultipleFrameContexts) {
codec_enc_.g_pass = VPX_RC_LAST_PASS; codec_enc_.g_pass = VPX_RC_LAST_PASS;
svc_.temporal_layers = 2; svc_.temporal_layers = 2;
codec_enc_.g_error_resilient = 0; codec_enc_.g_error_resilient = 0;
vpx_svc_set_options(&svc_, "auto-alt-refs=1 scale-factors=1/1 " vpx_svc_set_options(&svc_,
"auto-alt-refs=1 scale-factors=1/1 "
"multi-frame-contexts=1"); "multi-frame-contexts=1");
vpx_fixed_buf outputs[10]; vpx_fixed_buf outputs[10];
memset(&outputs[0], 0, sizeof(outputs)); memset(&outputs[0], 0, sizeof(outputs));
@ -714,8 +707,7 @@ TEST_F(SvcTest, TwoPassEncode2TemporalLayersDecodeBaseLayer) {
Pass2EncodeNFrames(&stats_buf, 10, 1, &outputs[0]); Pass2EncodeNFrames(&stats_buf, 10, 1, &outputs[0]);
vpx_fixed_buf base_layer[5]; vpx_fixed_buf base_layer[5];
for (int i = 0; i < 5; ++i) for (int i = 0; i < 5; ++i) base_layer[i] = outputs[i * 2];
base_layer[i] = outputs[i * 2];
DecodeNFrames(&base_layer[0], 5); DecodeNFrames(&base_layer[0], 5);
FreeBitstreamBuffers(&outputs[0], 10); FreeBitstreamBuffers(&outputs[0], 10);
@ -733,15 +725,15 @@ TEST_F(SvcTest,
codec_enc_.g_pass = VPX_RC_LAST_PASS; codec_enc_.g_pass = VPX_RC_LAST_PASS;
svc_.temporal_layers = 2; svc_.temporal_layers = 2;
codec_enc_.g_error_resilient = 0; codec_enc_.g_error_resilient = 0;
vpx_svc_set_options(&svc_, "auto-alt-refs=1 scale-factors=1/1 " vpx_svc_set_options(&svc_,
"auto-alt-refs=1 scale-factors=1/1 "
"multi-frame-contexts=1"); "multi-frame-contexts=1");
vpx_fixed_buf outputs[10]; vpx_fixed_buf outputs[10];
memset(&outputs[0], 0, sizeof(outputs)); memset(&outputs[0], 0, sizeof(outputs));
Pass2EncodeNFrames(&stats_buf, 10, 1, &outputs[0]); Pass2EncodeNFrames(&stats_buf, 10, 1, &outputs[0]);
vpx_fixed_buf base_layer[5]; vpx_fixed_buf base_layer[5];
for (int i = 0; i < 5; ++i) for (int i = 0; i < 5; ++i) base_layer[i] = outputs[i * 2];
base_layer[i] = outputs[i * 2];
DecodeNFrames(&base_layer[0], 5); DecodeNFrames(&base_layer[0], 5);
FreeBitstreamBuffers(&outputs[0], 10); FreeBitstreamBuffers(&outputs[0], 10);
@ -769,8 +761,7 @@ TEST_F(SvcTest, TwoPassEncode2TemporalLayersWithTiles) {
FreeBitstreamBuffers(&outputs[0], 10); FreeBitstreamBuffers(&outputs[0], 10);
} }
TEST_F(SvcTest, TEST_F(SvcTest, TwoPassEncode2TemporalLayersWithMultipleFrameContextsAndTiles) {
TwoPassEncode2TemporalLayersWithMultipleFrameContextsAndTiles) {
// First pass encode // First pass encode
std::string stats_buf; std::string stats_buf;
vpx_svc_set_options(&svc_, "scale-factors=1/1"); vpx_svc_set_options(&svc_, "scale-factors=1/1");
@ -785,7 +776,8 @@ TEST_F(SvcTest,
codec_enc_.g_h = 144; codec_enc_.g_h = 144;
tile_columns_ = 1; tile_columns_ = 1;
tile_rows_ = 1; tile_rows_ = 1;
vpx_svc_set_options(&svc_, "auto-alt-refs=1 scale-factors=1/1 " vpx_svc_set_options(&svc_,
"auto-alt-refs=1 scale-factors=1/1 "
"multi-frame-contexts=1"); "multi-frame-contexts=1");
vpx_fixed_buf outputs[10]; vpx_fixed_buf outputs[10];
memset(&outputs[0], 0, sizeof(outputs)); memset(&outputs[0], 0, sizeof(outputs));

137
test/test_intra_pred_speed.cc
View File

@ -31,9 +31,9 @@ typedef void (*VpxPredFunc)(uint8_t *dst, ptrdiff_t y_stride,
const int kNumVp9IntraPredFuncs = 13; const int kNumVp9IntraPredFuncs = 13;
const char *kVp9IntraPredNames[kNumVp9IntraPredFuncs] = { const char *kVp9IntraPredNames[kNumVp9IntraPredFuncs] = {
"DC_PRED", "DC_LEFT_PRED", "DC_TOP_PRED", "DC_128_PRED", "V_PRED", "H_PRED", "DC_PRED", "DC_LEFT_PRED", "DC_TOP_PRED", "DC_128_PRED", "V_PRED",
"D45_PRED", "D135_PRED", "D117_PRED", "D153_PRED", "D207_PRED", "D63_PRED", "H_PRED", "D45_PRED", "D135_PRED", "D117_PRED", "D153_PRED",
"TM_PRED" "D207_PRED", "D63_PRED", "TM_PRED"
}; };
void TestIntraPred(const char name[], VpxPredFunc const *pred_funcs, void TestIntraPred(const char name[], VpxPredFunc const *pred_funcs,
@ -82,18 +82,12 @@ void TestIntraPred(const char name[], VpxPredFunc const *pred_funcs,
void TestIntraPred4(VpxPredFunc const *pred_funcs) { void TestIntraPred4(VpxPredFunc const *pred_funcs) {
static const int kNumVp9IntraFuncs = 13; static const int kNumVp9IntraFuncs = 13;
static const char *const kSignatures[kNumVp9IntraFuncs] = { static const char *const kSignatures[kNumVp9IntraFuncs] = {
"4334156168b34ab599d9b5b30f522fe9", "4334156168b34ab599d9b5b30f522fe9", "bc4649d5ba47c7ff178d92e475960fb0",
"bc4649d5ba47c7ff178d92e475960fb0", "8d316e5933326dcac24e1064794b5d12", "a27270fed024eafd762c95de85f4da51",
"8d316e5933326dcac24e1064794b5d12", "c33dff000d4256c2b8f3bf9e9bab14d2", "44d8cddc2ad8f79b8ed3306051722b4f",
"a27270fed024eafd762c95de85f4da51", "eb54839b2bad6699d8946f01ec041cd0", "ecb0d56ae5f677ea45127ce9d5c058e4",
"c33dff000d4256c2b8f3bf9e9bab14d2", "0b7936841f6813da818275944895b574", "9117972ef64f91a58ff73e1731c81db2",
"44d8cddc2ad8f79b8ed3306051722b4f", "c56d5e8c729e46825f46dd5d3b5d508a", "c0889e2039bcf7bcb5d2f33cdca69adc",
"eb54839b2bad6699d8946f01ec041cd0",
"ecb0d56ae5f677ea45127ce9d5c058e4",
"0b7936841f6813da818275944895b574",
"9117972ef64f91a58ff73e1731c81db2",
"c56d5e8c729e46825f46dd5d3b5d508a",
"c0889e2039bcf7bcb5d2f33cdca69adc",
"309a618577b27c648f9c5ee45252bc8f", "309a618577b27c648f9c5ee45252bc8f",
}; };
TestIntraPred("Intra4", pred_funcs, kVp9IntraPredNames, kNumVp9IntraFuncs, TestIntraPred("Intra4", pred_funcs, kVp9IntraPredNames, kNumVp9IntraFuncs,
@ -103,18 +97,12 @@ void TestIntraPred4(VpxPredFunc const *pred_funcs) {
void TestIntraPred8(VpxPredFunc const *pred_funcs) { void TestIntraPred8(VpxPredFunc const *pred_funcs) {
static const int kNumVp9IntraFuncs = 13; static const int kNumVp9IntraFuncs = 13;
static const char *const kSignatures[kNumVp9IntraFuncs] = { static const char *const kSignatures[kNumVp9IntraFuncs] = {
"7694ddeeefed887faf9d339d18850928", "7694ddeeefed887faf9d339d18850928", "7d726b1213591b99f736be6dec65065b",
"7d726b1213591b99f736be6dec65065b", "19c5711281357a485591aaf9c96c0a67", "ba6b66877a089e71cd938e3b8c40caac",
"19c5711281357a485591aaf9c96c0a67", "802440c93317e0f8ba93fab02ef74265", "9e09a47a15deb0b9d8372824f9805080",
"ba6b66877a089e71cd938e3b8c40caac", "b7c2d8c662268c0c427da412d7b0311d", "78339c1c60bb1d67d248ab8c4da08b7f",
"802440c93317e0f8ba93fab02ef74265", "5c97d70f7d47de1882a6cd86c165c8a9", "8182bf60688b42205acd95e59e967157",
"9e09a47a15deb0b9d8372824f9805080", "08323400005a297f16d7e57e7fe1eaac", "95f7bfc262329a5849eda66d8f7c68ce",
"b7c2d8c662268c0c427da412d7b0311d",
"78339c1c60bb1d67d248ab8c4da08b7f",
"5c97d70f7d47de1882a6cd86c165c8a9",
"8182bf60688b42205acd95e59e967157",
"08323400005a297f16d7e57e7fe1eaac",
"95f7bfc262329a5849eda66d8f7c68ce",
"815b75c8e0d91cc1ae766dc5d3e445a3", "815b75c8e0d91cc1ae766dc5d3e445a3",
}; };
TestIntraPred("Intra8", pred_funcs, kVp9IntraPredNames, kNumVp9IntraFuncs, TestIntraPred("Intra8", pred_funcs, kVp9IntraPredNames, kNumVp9IntraFuncs,
@ -124,18 +112,12 @@ void TestIntraPred8(VpxPredFunc const *pred_funcs) {
void TestIntraPred16(VpxPredFunc const *pred_funcs) { void TestIntraPred16(VpxPredFunc const *pred_funcs) {
static const int kNumVp9IntraFuncs = 13; static const int kNumVp9IntraFuncs = 13;
static const char *const kSignatures[kNumVp9IntraFuncs] = { static const char *const kSignatures[kNumVp9IntraFuncs] = {
"b40dbb555d5d16a043dc361e6694fe53", "b40dbb555d5d16a043dc361e6694fe53", "fb08118cee3b6405d64c1fd68be878c6",
"fb08118cee3b6405d64c1fd68be878c6", "6c190f341475c837cc38c2e566b64875", "db5c34ccbe2c7f595d9b08b0dc2c698c",
"6c190f341475c837cc38c2e566b64875", "a62cbfd153a1f0b9fed13e62b8408a7a", "143df5b4c89335e281103f610f5052e4",
"db5c34ccbe2c7f595d9b08b0dc2c698c", "d87feb124107cdf2cfb147655aa0bb3c", "7841fae7d4d47b519322e6a03eeed9dc",
"a62cbfd153a1f0b9fed13e62b8408a7a", "f6ebed3f71cbcf8d6d0516ce87e11093", "3cc480297dbfeed01a1c2d78dd03d0c5",
"143df5b4c89335e281103f610f5052e4", "b9f69fa6532b372c545397dcb78ef311", "a8fe1c70432f09d0c20c67bdb6432c4d",
"d87feb124107cdf2cfb147655aa0bb3c",
"7841fae7d4d47b519322e6a03eeed9dc",
"f6ebed3f71cbcf8d6d0516ce87e11093",
"3cc480297dbfeed01a1c2d78dd03d0c5",
"b9f69fa6532b372c545397dcb78ef311",
"a8fe1c70432f09d0c20c67bdb6432c4d",
"b8a41aa968ec108af447af4217cba91b", "b8a41aa968ec108af447af4217cba91b",
}; };
TestIntraPred("Intra16", pred_funcs, kVp9IntraPredNames, kNumVp9IntraFuncs, TestIntraPred("Intra16", pred_funcs, kVp9IntraPredNames, kNumVp9IntraFuncs,
@ -145,18 +127,12 @@ void TestIntraPred16(VpxPredFunc const *pred_funcs) {
void TestIntraPred32(VpxPredFunc const *pred_funcs) { void TestIntraPred32(VpxPredFunc const *pred_funcs) {
static const int kNumVp9IntraFuncs = 13; static const int kNumVp9IntraFuncs = 13;
static const char *const kSignatures[kNumVp9IntraFuncs] = { static const char *const kSignatures[kNumVp9IntraFuncs] = {
"558541656d84f9ae7896db655826febe", "558541656d84f9ae7896db655826febe", "b3587a1f9a01495fa38c8cd3c8e2a1bf",
"b3587a1f9a01495fa38c8cd3c8e2a1bf", "4c6501e64f25aacc55a2a16c7e8f0255", "b3b01379ba08916ef6b1b35f7d9ad51c",
"4c6501e64f25aacc55a2a16c7e8f0255", "0f1eb38b6cbddb3d496199ef9f329071", "911c06efb9ed1c3b4c104b232b55812f",
"b3b01379ba08916ef6b1b35f7d9ad51c", "9225beb0ddfa7a1d24eaa1be430a6654", "0a6d584a44f8db9aa7ade2e2fdb9fc9e",
"0f1eb38b6cbddb3d496199ef9f329071", "b01c9076525216925f3456f034fb6eee", "d267e20ad9e5cd2915d1a47254d3d149",
"911c06efb9ed1c3b4c104b232b55812f", "ed012a4a5da71f36c2393023184a0e59", "f162b51ed618d28b936974cff4391da5",
"9225beb0ddfa7a1d24eaa1be430a6654",
"0a6d584a44f8db9aa7ade2e2fdb9fc9e",
"b01c9076525216925f3456f034fb6eee",
"d267e20ad9e5cd2915d1a47254d3d149",
"ed012a4a5da71f36c2393023184a0e59",
"f162b51ed618d28b936974cff4391da5",
"9e1370c6d42e08d357d9612c93a71cfc", "9e1370c6d42e08d357d9612c93a71cfc",
}; };
TestIntraPred("Intra32", pred_funcs, kVp9IntraPredNames, kNumVp9IntraFuncs, TestIntraPred("Intra32", pred_funcs, kVp9IntraPredNames, kNumVp9IntraFuncs,
@ -167,13 +143,13 @@ void TestIntraPred32(VpxPredFunc const *pred_funcs) {
// Defines a test case for |arch| (e.g., C, SSE2, ...) passing the predictors // Defines a test case for |arch| (e.g., C, SSE2, ...) passing the predictors
// to |test_func|. The test name is 'arch.test_func', e.g., C.TestIntraPred4. // to |test_func|. The test name is 'arch.test_func', e.g., C.TestIntraPred4.
#define INTRA_PRED_TEST(arch, test_func, dc, dc_left, dc_top, dc_128, v, h, \ #define INTRA_PRED_TEST(arch, test_func, dc, dc_left, dc_top, dc_128, v, h, \
d45, d135, d117, d153, d207, d63, tm) \ d45, d135, d117, d153, d207, d63, tm) \
TEST(arch, test_func) { \ TEST(arch, test_func) { \
static const VpxPredFunc vpx_intra_pred[] = { \ static const VpxPredFunc vpx_intra_pred[] = { \
dc, dc_left, dc_top, dc_128, v, h, d45, \ dc, dc_left, dc_top, dc_128, v, h, d45, d135, d117, d153, d207, d63, tm \
d135, d117, d153, d207, d63, tm}; \ }; \
test_func(vpx_intra_pred); \ test_func(vpx_intra_pred); \
} }
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
@ -197,9 +173,8 @@ INTRA_PRED_TEST(SSE2, TestIntraPred4, vpx_dc_predictor_4x4_sse2,
#endif // HAVE_SSE2 #endif // HAVE_SSE2
#if HAVE_SSSE3 #if HAVE_SSSE3
INTRA_PRED_TEST(SSSE3, TestIntraPred4, NULL, NULL, NULL, NULL, NULL, INTRA_PRED_TEST(SSSE3, TestIntraPred4, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, vpx_d153_predictor_4x4_ssse3, NULL,
vpx_d153_predictor_4x4_ssse3, NULL,
vpx_d63_predictor_4x4_ssse3, NULL) vpx_d63_predictor_4x4_ssse3, NULL)
#endif // HAVE_SSSE3 #endif // HAVE_SSSE3
@ -222,8 +197,8 @@ INTRA_PRED_TEST(NEON, TestIntraPred4, vpx_dc_predictor_4x4_neon,
INTRA_PRED_TEST(MSA, TestIntraPred4, vpx_dc_predictor_4x4_msa, INTRA_PRED_TEST(MSA, TestIntraPred4, vpx_dc_predictor_4x4_msa,
vpx_dc_left_predictor_4x4_msa, vpx_dc_top_predictor_4x4_msa, vpx_dc_left_predictor_4x4_msa, vpx_dc_top_predictor_4x4_msa,
vpx_dc_128_predictor_4x4_msa, vpx_v_predictor_4x4_msa, vpx_dc_128_predictor_4x4_msa, vpx_v_predictor_4x4_msa,
vpx_h_predictor_4x4_msa, NULL, NULL, NULL, NULL, NULL, vpx_h_predictor_4x4_msa, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, vpx_tm_predictor_4x4_msa) vpx_tm_predictor_4x4_msa)
#endif // HAVE_MSA #endif // HAVE_MSA
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
@ -246,10 +221,9 @@ INTRA_PRED_TEST(SSE2, TestIntraPred8, vpx_dc_predictor_8x8_sse2,
#endif // HAVE_SSE2 #endif // HAVE_SSE2
#if HAVE_SSSE3 #if HAVE_SSSE3
INTRA_PRED_TEST(SSSE3, TestIntraPred8, NULL, NULL, NULL, NULL, NULL, INTRA_PRED_TEST(SSSE3, TestIntraPred8, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, vpx_d153_predictor_8x8_ssse3,
vpx_d153_predictor_8x8_ssse3, vpx_d207_predictor_8x8_ssse3, vpx_d207_predictor_8x8_ssse3, vpx_d63_predictor_8x8_ssse3, NULL)
vpx_d63_predictor_8x8_ssse3, NULL)
#endif // HAVE_SSSE3 #endif // HAVE_SSSE3
#if HAVE_DSPR2 #if HAVE_DSPR2
@ -271,8 +245,8 @@ INTRA_PRED_TEST(NEON, TestIntraPred8, vpx_dc_predictor_8x8_neon,
INTRA_PRED_TEST(MSA, TestIntraPred8, vpx_dc_predictor_8x8_msa, INTRA_PRED_TEST(MSA, TestIntraPred8, vpx_dc_predictor_8x8_msa,
vpx_dc_left_predictor_8x8_msa, vpx_dc_top_predictor_8x8_msa, vpx_dc_left_predictor_8x8_msa, vpx_dc_top_predictor_8x8_msa,
vpx_dc_128_predictor_8x8_msa, vpx_v_predictor_8x8_msa, vpx_dc_128_predictor_8x8_msa, vpx_v_predictor_8x8_msa,
vpx_h_predictor_8x8_msa, NULL, NULL, NULL, NULL, NULL, vpx_h_predictor_8x8_msa, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, vpx_tm_predictor_8x8_msa) vpx_tm_predictor_8x8_msa)
#endif // HAVE_MSA #endif // HAVE_MSA
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
@ -296,11 +270,10 @@ INTRA_PRED_TEST(SSE2, TestIntraPred16, vpx_dc_predictor_16x16_sse2,
#endif // HAVE_SSE2 #endif // HAVE_SSE2
#if HAVE_SSSE3 #if HAVE_SSSE3
INTRA_PRED_TEST(SSSE3, TestIntraPred16, NULL, NULL, NULL, NULL, NULL, INTRA_PRED_TEST(SSSE3, TestIntraPred16, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, vpx_d45_predictor_16x16_ssse3, vpx_d45_predictor_16x16_ssse3, NULL, NULL,
NULL, NULL, vpx_d153_predictor_16x16_ssse3, vpx_d153_predictor_16x16_ssse3, vpx_d207_predictor_16x16_ssse3,
vpx_d207_predictor_16x16_ssse3, vpx_d63_predictor_16x16_ssse3, vpx_d63_predictor_16x16_ssse3, NULL)
NULL)
#endif // HAVE_SSSE3 #endif // HAVE_SSSE3
#if HAVE_DSPR2 #if HAVE_DSPR2
@ -322,8 +295,8 @@ INTRA_PRED_TEST(NEON, TestIntraPred16, vpx_dc_predictor_16x16_neon,
INTRA_PRED_TEST(MSA, TestIntraPred16, vpx_dc_predictor_16x16_msa, INTRA_PRED_TEST(MSA, TestIntraPred16, vpx_dc_predictor_16x16_msa,
vpx_dc_left_predictor_16x16_msa, vpx_dc_top_predictor_16x16_msa, vpx_dc_left_predictor_16x16_msa, vpx_dc_top_predictor_16x16_msa,
vpx_dc_128_predictor_16x16_msa, vpx_v_predictor_16x16_msa, vpx_dc_128_predictor_16x16_msa, vpx_v_predictor_16x16_msa,
vpx_h_predictor_16x16_msa, NULL, NULL, NULL, NULL, NULL, vpx_h_predictor_16x16_msa, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, vpx_tm_predictor_16x16_msa) vpx_tm_predictor_16x16_msa)
#endif // HAVE_MSA #endif // HAVE_MSA
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
@ -342,13 +315,13 @@ INTRA_PRED_TEST(SSE2, TestIntraPred32, vpx_dc_predictor_32x32_sse2,
vpx_dc_left_predictor_32x32_sse2, vpx_dc_left_predictor_32x32_sse2,
vpx_dc_top_predictor_32x32_sse2, vpx_dc_top_predictor_32x32_sse2,
vpx_dc_128_predictor_32x32_sse2, vpx_v_predictor_32x32_sse2, vpx_dc_128_predictor_32x32_sse2, vpx_v_predictor_32x32_sse2,
vpx_h_predictor_32x32_sse2, NULL, NULL, NULL, NULL, NULL, vpx_h_predictor_32x32_sse2, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, vpx_tm_predictor_32x32_sse2) vpx_tm_predictor_32x32_sse2)
#endif // HAVE_SSE2 #endif // HAVE_SSE2
#if HAVE_SSSE3 #if HAVE_SSSE3
INTRA_PRED_TEST(SSSE3, TestIntraPred32, NULL, NULL, NULL, NULL, NULL, INTRA_PRED_TEST(SSSE3, TestIntraPred32, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, vpx_d45_predictor_32x32_ssse3, NULL, NULL, vpx_d45_predictor_32x32_ssse3, NULL, NULL,
vpx_d153_predictor_32x32_ssse3, vpx_d207_predictor_32x32_ssse3, vpx_d153_predictor_32x32_ssse3, vpx_d207_predictor_32x32_ssse3,
vpx_d63_predictor_32x32_ssse3, NULL) vpx_d63_predictor_32x32_ssse3, NULL)
#endif // HAVE_SSSE3 #endif // HAVE_SSSE3
@ -366,8 +339,8 @@ INTRA_PRED_TEST(NEON, TestIntraPred32, vpx_dc_predictor_32x32_neon,
INTRA_PRED_TEST(MSA, TestIntraPred32, vpx_dc_predictor_32x32_msa, INTRA_PRED_TEST(MSA, TestIntraPred32, vpx_dc_predictor_32x32_msa,
vpx_dc_left_predictor_32x32_msa, vpx_dc_top_predictor_32x32_msa, vpx_dc_left_predictor_32x32_msa, vpx_dc_top_predictor_32x32_msa,
vpx_dc_128_predictor_32x32_msa, vpx_v_predictor_32x32_msa, vpx_dc_128_predictor_32x32_msa, vpx_v_predictor_32x32_msa,
vpx_h_predictor_32x32_msa, NULL, NULL, NULL, NULL, NULL, vpx_h_predictor_32x32_msa, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, vpx_tm_predictor_32x32_msa) vpx_tm_predictor_32x32_msa)
#endif // HAVE_MSA #endif // HAVE_MSA
#include "test/test_libvpx.cc" #include "test/test_libvpx.cc"

18
test/test_libvpx.cc
View File

@ -41,22 +41,16 @@ int main(int argc, char **argv) {
#if ARCH_X86 || ARCH_X86_64 #if ARCH_X86 || ARCH_X86_64
const int simd_caps = x86_simd_caps(); const int simd_caps = x86_simd_caps();
if (!(simd_caps & HAS_MMX)) if (!(simd_caps & HAS_MMX)) append_negative_gtest_filter(":MMX.*:MMX/*");
append_negative_gtest_filter(":MMX.*:MMX/*"); if (!(simd_caps & HAS_SSE)) append_negative_gtest_filter(":SSE.*:SSE/*");
if (!(simd_caps & HAS_SSE)) if (!(simd_caps & HAS_SSE2)) append_negative_gtest_filter(":SSE2.*:SSE2/*");
append_negative_gtest_filter(":SSE.*:SSE/*"); if (!(simd_caps & HAS_SSE3)) append_negative_gtest_filter(":SSE3.*:SSE3/*");
if (!(simd_caps & HAS_SSE2))
append_negative_gtest_filter(":SSE2.*:SSE2/*");
if (!(simd_caps & HAS_SSE3))
append_negative_gtest_filter(":SSE3.*:SSE3/*");
if (!(simd_caps & HAS_SSSE3)) if (!(simd_caps & HAS_SSSE3))
append_negative_gtest_filter(":SSSE3.*:SSSE3/*"); append_negative_gtest_filter(":SSSE3.*:SSSE3/*");
if (!(simd_caps & HAS_SSE4_1)) if (!(simd_caps & HAS_SSE4_1))
append_negative_gtest_filter(":SSE4_1.*:SSE4_1/*"); append_negative_gtest_filter(":SSE4_1.*:SSE4_1/*");
if (!(simd_caps & HAS_AVX)) if (!(simd_caps & HAS_AVX)) append_negative_gtest_filter(":AVX.*:AVX/*");
append_negative_gtest_filter(":AVX.*:AVX/*"); if (!(simd_caps & HAS_AVX2)) append_negative_gtest_filter(":AVX2.*:AVX2/*");
if (!(simd_caps & HAS_AVX2))
append_negative_gtest_filter(":AVX2.*:AVX2/*");
#endif // ARCH_X86 || ARCH_X86_64 #endif // ARCH_X86 || ARCH_X86_64
#if !CONFIG_SHARED #if !CONFIG_SHARED

37
test/test_vector_test.cc
View File

@ -28,43 +28,36 @@
namespace { namespace {
enum DecodeMode { enum DecodeMode { kSerialMode, kFrameParallelMode };
kSerialMode,
kFrameParallelMode
};
const int kDecodeMode = 0; const int kDecodeMode = 0;
const int kThreads = 1; const int kThreads = 1;
const int kFileName = 2; const int kFileName = 2;
typedef std::tr1::tuple<int, int, const char*> DecodeParam; typedef std::tr1::tuple<int, int, const char *> DecodeParam;
class TestVectorTest : public ::libvpx_test::DecoderTest, class TestVectorTest : public ::libvpx_test::DecoderTest,
public ::libvpx_test::CodecTestWithParam<DecodeParam> { public ::libvpx_test::CodecTestWithParam<DecodeParam> {
protected: protected:
TestVectorTest() TestVectorTest() : DecoderTest(GET_PARAM(0)), md5_file_(NULL) {
: DecoderTest(GET_PARAM(0)),
md5_file_(NULL) {
#if CONFIG_VP9_DECODER #if CONFIG_VP9_DECODER
resize_clips_.insert( resize_clips_.insert(::libvpx_test::kVP9TestVectorsResize,
::libvpx_test::kVP9TestVectorsResize, ::libvpx_test::kVP9TestVectorsResize +
::libvpx_test::kVP9TestVectorsResize + ::libvpx_test::kNumVP9TestVectorsResize);
::libvpx_test::kNumVP9TestVectorsResize);
#endif #endif
} }
virtual ~TestVectorTest() { virtual ~TestVectorTest() {
if (md5_file_) if (md5_file_) fclose(md5_file_);
fclose(md5_file_);
} }
void OpenMD5File(const std::string& md5_file_name_) { void OpenMD5File(const std::string &md5_file_name_) {
md5_file_ = libvpx_test::OpenTestDataFile(md5_file_name_); md5_file_ = libvpx_test::OpenTestDataFile(md5_file_name_);
ASSERT_TRUE(md5_file_ != NULL) << "Md5 file open failed. Filename: " ASSERT_TRUE(md5_file_ != NULL) << "Md5 file open failed. Filename: "
<< md5_file_name_; << md5_file_name_;
} }
virtual void DecompressedFrameHook(const vpx_image_t& img, virtual void DecompressedFrameHook(const vpx_image_t &img,
const unsigned int frame_number) { const unsigned int frame_number) {
ASSERT_TRUE(md5_file_ != NULL); ASSERT_TRUE(md5_file_ != NULL);
char expected_md5[33]; char expected_md5[33];
@ -121,8 +114,8 @@ TEST_P(TestVectorTest, MD5Match) {
cfg.threads = threads; cfg.threads = threads;
snprintf(str, sizeof(str) / sizeof(str[0]) - 1, snprintf(str, sizeof(str) / sizeof(str[0]) - 1,
"file: %s mode: %s threads: %d", "file: %s mode: %s threads: %d", filename.c_str(),
filename.c_str(), mode == 0 ? "Serial" : "Parallel", threads); mode == 0 ? "Serial" : "Parallel", threads);
SCOPED_TRACE(str); SCOPED_TRACE(str);
// Open compressed video file. // Open compressed video file.
@ -183,8 +176,8 @@ INSTANTIATE_TEST_CASE_P(
::testing::Values( ::testing::Values(
static_cast<const libvpx_test::CodecFactory *>(&libvpx_test::kVP9)), static_cast<const libvpx_test::CodecFactory *>(&libvpx_test::kVP9)),
::testing::Combine( ::testing::Combine(
::testing::Values(1), // Frame Parallel mode. ::testing::Values(1), // Frame Parallel mode.
::testing::Range(2, 9), // With 2 ~ 8 threads. ::testing::Range(2, 9), // With 2 ~ 8 threads.
::testing::ValuesIn(libvpx_test::kVP9TestVectors, ::testing::ValuesIn(libvpx_test::kVP9TestVectors,
libvpx_test::kVP9TestVectors + libvpx_test::kVP9TestVectors +
libvpx_test::kNumVP9TestVectors)))); libvpx_test::kNumVP9TestVectors))));

515
test/test_vectors.cc
View File

@ -16,201 +16,324 @@ namespace libvpx_test {
#if CONFIG_VP8_DECODER #if CONFIG_VP8_DECODER
const char *const kVP8TestVectors[] = { const char *const kVP8TestVectors[] = {
"vp80-00-comprehensive-001.ivf", "vp80-00-comprehensive-001.ivf", "vp80-00-comprehensive-002.ivf",
"vp80-00-comprehensive-002.ivf", "vp80-00-comprehensive-003.ivf", "vp80-00-comprehensive-003.ivf", "vp80-00-comprehensive-004.ivf",
"vp80-00-comprehensive-004.ivf", "vp80-00-comprehensive-005.ivf", "vp80-00-comprehensive-005.ivf", "vp80-00-comprehensive-006.ivf",
"vp80-00-comprehensive-006.ivf", "vp80-00-comprehensive-007.ivf", "vp80-00-comprehensive-007.ivf", "vp80-00-comprehensive-008.ivf",
"vp80-00-comprehensive-008.ivf", "vp80-00-comprehensive-009.ivf", "vp80-00-comprehensive-009.ivf", "vp80-00-comprehensive-010.ivf",
"vp80-00-comprehensive-010.ivf", "vp80-00-comprehensive-011.ivf", "vp80-00-comprehensive-011.ivf", "vp80-00-comprehensive-012.ivf",
"vp80-00-comprehensive-012.ivf", "vp80-00-comprehensive-013.ivf", "vp80-00-comprehensive-013.ivf", "vp80-00-comprehensive-014.ivf",
"vp80-00-comprehensive-014.ivf", "vp80-00-comprehensive-015.ivf", "vp80-00-comprehensive-015.ivf", "vp80-00-comprehensive-016.ivf",
"vp80-00-comprehensive-016.ivf", "vp80-00-comprehensive-017.ivf", "vp80-00-comprehensive-017.ivf", "vp80-00-comprehensive-018.ivf",
"vp80-00-comprehensive-018.ivf", "vp80-01-intra-1400.ivf", "vp80-01-intra-1400.ivf", "vp80-01-intra-1411.ivf",
"vp80-01-intra-1411.ivf", "vp80-01-intra-1416.ivf", "vp80-01-intra-1416.ivf", "vp80-01-intra-1417.ivf",
"vp80-01-intra-1417.ivf", "vp80-02-inter-1402.ivf", "vp80-02-inter-1402.ivf", "vp80-02-inter-1412.ivf",
"vp80-02-inter-1412.ivf", "vp80-02-inter-1418.ivf", "vp80-02-inter-1418.ivf", "vp80-02-inter-1424.ivf",
"vp80-02-inter-1424.ivf", "vp80-03-segmentation-01.ivf", "vp80-03-segmentation-01.ivf", "vp80-03-segmentation-02.ivf",
"vp80-03-segmentation-02.ivf", "vp80-03-segmentation-03.ivf", "vp80-03-segmentation-03.ivf", "vp80-03-segmentation-04.ivf",
"vp80-03-segmentation-04.ivf", "vp80-03-segmentation-1401.ivf", "vp80-03-segmentation-1401.ivf", "vp80-03-segmentation-1403.ivf",
"vp80-03-segmentation-1403.ivf", "vp80-03-segmentation-1407.ivf", "vp80-03-segmentation-1407.ivf", "vp80-03-segmentation-1408.ivf",
"vp80-03-segmentation-1408.ivf", "vp80-03-segmentation-1409.ivf", "vp80-03-segmentation-1409.ivf", "vp80-03-segmentation-1410.ivf",
"vp80-03-segmentation-1410.ivf", "vp80-03-segmentation-1413.ivf", "vp80-03-segmentation-1413.ivf", "vp80-03-segmentation-1414.ivf",
"vp80-03-segmentation-1414.ivf", "vp80-03-segmentation-1415.ivf", "vp80-03-segmentation-1415.ivf", "vp80-03-segmentation-1425.ivf",
"vp80-03-segmentation-1425.ivf", "vp80-03-segmentation-1426.ivf", "vp80-03-segmentation-1426.ivf", "vp80-03-segmentation-1427.ivf",
"vp80-03-segmentation-1427.ivf", "vp80-03-segmentation-1432.ivf", "vp80-03-segmentation-1432.ivf", "vp80-03-segmentation-1435.ivf",
"vp80-03-segmentation-1435.ivf", "vp80-03-segmentation-1436.ivf", "vp80-03-segmentation-1436.ivf", "vp80-03-segmentation-1437.ivf",
"vp80-03-segmentation-1437.ivf", "vp80-03-segmentation-1441.ivf", "vp80-03-segmentation-1441.ivf", "vp80-03-segmentation-1442.ivf",
"vp80-03-segmentation-1442.ivf", "vp80-04-partitions-1404.ivf", "vp80-04-partitions-1404.ivf", "vp80-04-partitions-1405.ivf",
"vp80-04-partitions-1405.ivf", "vp80-04-partitions-1406.ivf", "vp80-04-partitions-1406.ivf", "vp80-05-sharpness-1428.ivf",
"vp80-05-sharpness-1428.ivf", "vp80-05-sharpness-1429.ivf", "vp80-05-sharpness-1429.ivf", "vp80-05-sharpness-1430.ivf",
"vp80-05-sharpness-1430.ivf", "vp80-05-sharpness-1431.ivf", "vp80-05-sharpness-1431.ivf", "vp80-05-sharpness-1433.ivf",
"vp80-05-sharpness-1433.ivf", "vp80-05-sharpness-1434.ivf", "vp80-05-sharpness-1434.ivf", "vp80-05-sharpness-1438.ivf",
"vp80-05-sharpness-1438.ivf", "vp80-05-sharpness-1439.ivf", "vp80-05-sharpness-1439.ivf", "vp80-05-sharpness-1440.ivf",
"vp80-05-sharpness-1440.ivf", "vp80-05-sharpness-1443.ivf", "vp80-05-sharpness-1443.ivf", "vp80-06-smallsize.ivf"
"vp80-06-smallsize.ivf"
}; };
const int kNumVP8TestVectors = NELEMENTS(kVP8TestVectors); const int kNumVP8TestVectors = NELEMENTS(kVP8TestVectors);
#endif // CONFIG_VP8_DECODER #endif // CONFIG_VP8_DECODER
#if CONFIG_VP9_DECODER #if CONFIG_VP9_DECODER
#define RESIZE_TEST_VECTORS "vp90-2-21-resize_inter_320x180_5_1-2.webm", \ #define RESIZE_TEST_VECTORS \
"vp90-2-21-resize_inter_320x180_5_3-4.webm", \ "vp90-2-21-resize_inter_320x180_5_1-2.webm", \
"vp90-2-21-resize_inter_320x180_7_1-2.webm", \ "vp90-2-21-resize_inter_320x180_5_3-4.webm", \
"vp90-2-21-resize_inter_320x180_7_3-4.webm", \ "vp90-2-21-resize_inter_320x180_7_1-2.webm", \
"vp90-2-21-resize_inter_320x240_5_1-2.webm", \ "vp90-2-21-resize_inter_320x180_7_3-4.webm", \
"vp90-2-21-resize_inter_320x240_5_3-4.webm", \ "vp90-2-21-resize_inter_320x240_5_1-2.webm", \
"vp90-2-21-resize_inter_320x240_7_1-2.webm", \ "vp90-2-21-resize_inter_320x240_5_3-4.webm", \
"vp90-2-21-resize_inter_320x240_7_3-4.webm", \ "vp90-2-21-resize_inter_320x240_7_1-2.webm", \
"vp90-2-21-resize_inter_640x360_5_1-2.webm", \ "vp90-2-21-resize_inter_320x240_7_3-4.webm", \
"vp90-2-21-resize_inter_640x360_5_3-4.webm", \ "vp90-2-21-resize_inter_640x360_5_1-2.webm", \
"vp90-2-21-resize_inter_640x360_7_1-2.webm", \ "vp90-2-21-resize_inter_640x360_5_3-4.webm", \
"vp90-2-21-resize_inter_640x360_7_3-4.webm", \ "vp90-2-21-resize_inter_640x360_7_1-2.webm", \
"vp90-2-21-resize_inter_640x480_5_1-2.webm", \ "vp90-2-21-resize_inter_640x360_7_3-4.webm", \
"vp90-2-21-resize_inter_640x480_5_3-4.webm", \ "vp90-2-21-resize_inter_640x480_5_1-2.webm", \
"vp90-2-21-resize_inter_640x480_7_1-2.webm", \ "vp90-2-21-resize_inter_640x480_5_3-4.webm", \
"vp90-2-21-resize_inter_640x480_7_3-4.webm", \ "vp90-2-21-resize_inter_640x480_7_1-2.webm", \
"vp90-2-21-resize_inter_1280x720_5_1-2.webm", \ "vp90-2-21-resize_inter_640x480_7_3-4.webm", \
"vp90-2-21-resize_inter_1280x720_5_3-4.webm", \ "vp90-2-21-resize_inter_1280x720_5_1-2.webm", \
"vp90-2-21-resize_inter_1280x720_7_1-2.webm", \ "vp90-2-21-resize_inter_1280x720_5_3-4.webm", \
"vp90-2-21-resize_inter_1280x720_7_3-4.webm", \ "vp90-2-21-resize_inter_1280x720_7_1-2.webm", \
"vp90-2-21-resize_inter_1920x1080_5_1-2.webm", \ "vp90-2-21-resize_inter_1280x720_7_3-4.webm", \
"vp90-2-21-resize_inter_1920x1080_5_3-4.webm", \ "vp90-2-21-resize_inter_1920x1080_5_1-2.webm", \
"vp90-2-21-resize_inter_1920x1080_7_1-2.webm", \ "vp90-2-21-resize_inter_1920x1080_5_3-4.webm", \
"vp90-2-21-resize_inter_1920x1080_7_3-4.webm", "vp90-2-21-resize_inter_1920x1080_7_1-2.webm", \
"vp90-2-21-resize_inter_1920x1080_7_3-4.webm",
const char *const kVP9TestVectors[] = { const char *const kVP9TestVectors[] = {
"vp90-2-00-quantizer-00.webm", "vp90-2-00-quantizer-01.webm", "vp90-2-00-quantizer-00.webm",
"vp90-2-00-quantizer-02.webm", "vp90-2-00-quantizer-03.webm", "vp90-2-00-quantizer-01.webm",
"vp90-2-00-quantizer-04.webm", "vp90-2-00-quantizer-05.webm", "vp90-2-00-quantizer-02.webm",
"vp90-2-00-quantizer-06.webm", "vp90-2-00-quantizer-07.webm", "vp90-2-00-quantizer-03.webm",
"vp90-2-00-quantizer-08.webm", "vp90-2-00-quantizer-09.webm", "vp90-2-00-quantizer-04.webm",
"vp90-2-00-quantizer-10.webm", "vp90-2-00-quantizer-11.webm", "vp90-2-00-quantizer-05.webm",
"vp90-2-00-quantizer-12.webm", "vp90-2-00-quantizer-13.webm", "vp90-2-00-quantizer-06.webm",
"vp90-2-00-quantizer-14.webm", "vp90-2-00-quantizer-15.webm", "vp90-2-00-quantizer-07.webm",
"vp90-2-00-quantizer-16.webm", "vp90-2-00-quantizer-17.webm", "vp90-2-00-quantizer-08.webm",
"vp90-2-00-quantizer-18.webm", "vp90-2-00-quantizer-19.webm", "vp90-2-00-quantizer-09.webm",
"vp90-2-00-quantizer-20.webm", "vp90-2-00-quantizer-21.webm", "vp90-2-00-quantizer-10.webm",
"vp90-2-00-quantizer-22.webm", "vp90-2-00-quantizer-23.webm", "vp90-2-00-quantizer-11.webm",
"vp90-2-00-quantizer-24.webm", "vp90-2-00-quantizer-25.webm", "vp90-2-00-quantizer-12.webm",
"vp90-2-00-quantizer-26.webm", "vp90-2-00-quantizer-27.webm", "vp90-2-00-quantizer-13.webm",
"vp90-2-00-quantizer-28.webm", "vp90-2-00-quantizer-29.webm", "vp90-2-00-quantizer-14.webm",
"vp90-2-00-quantizer-30.webm", "vp90-2-00-quantizer-31.webm", "vp90-2-00-quantizer-15.webm",
"vp90-2-00-quantizer-32.webm", "vp90-2-00-quantizer-33.webm", "vp90-2-00-quantizer-16.webm",
"vp90-2-00-quantizer-34.webm", "vp90-2-00-quantizer-35.webm", "vp90-2-00-quantizer-17.webm",
"vp90-2-00-quantizer-36.webm", "vp90-2-00-quantizer-37.webm", "vp90-2-00-quantizer-18.webm",
"vp90-2-00-quantizer-38.webm", "vp90-2-00-quantizer-39.webm", "vp90-2-00-quantizer-19.webm",
"vp90-2-00-quantizer-40.webm", "vp90-2-00-quantizer-41.webm", "vp90-2-00-quantizer-20.webm",
"vp90-2-00-quantizer-42.webm", "vp90-2-00-quantizer-43.webm", "vp90-2-00-quantizer-21.webm",
"vp90-2-00-quantizer-44.webm", "vp90-2-00-quantizer-45.webm", "vp90-2-00-quantizer-22.webm",
"vp90-2-00-quantizer-46.webm", "vp90-2-00-quantizer-47.webm", "vp90-2-00-quantizer-23.webm",
"vp90-2-00-quantizer-48.webm", "vp90-2-00-quantizer-49.webm", "vp90-2-00-quantizer-24.webm",
"vp90-2-00-quantizer-50.webm", "vp90-2-00-quantizer-51.webm", "vp90-2-00-quantizer-25.webm",
"vp90-2-00-quantizer-52.webm", "vp90-2-00-quantizer-53.webm", "vp90-2-00-quantizer-26.webm",
"vp90-2-00-quantizer-54.webm", "vp90-2-00-quantizer-55.webm", "vp90-2-00-quantizer-27.webm",
"vp90-2-00-quantizer-56.webm", "vp90-2-00-quantizer-57.webm", "vp90-2-00-quantizer-28.webm",
"vp90-2-00-quantizer-58.webm", "vp90-2-00-quantizer-59.webm", "vp90-2-00-quantizer-29.webm",
"vp90-2-00-quantizer-60.webm", "vp90-2-00-quantizer-61.webm", "vp90-2-00-quantizer-30.webm",
"vp90-2-00-quantizer-62.webm", "vp90-2-00-quantizer-63.webm", "vp90-2-00-quantizer-31.webm",
"vp90-2-01-sharpness-1.webm", "vp90-2-01-sharpness-2.webm", "vp90-2-00-quantizer-32.webm",
"vp90-2-01-sharpness-3.webm", "vp90-2-01-sharpness-4.webm", "vp90-2-00-quantizer-33.webm",
"vp90-2-01-sharpness-5.webm", "vp90-2-01-sharpness-6.webm", "vp90-2-00-quantizer-34.webm",
"vp90-2-01-sharpness-7.webm", "vp90-2-02-size-08x08.webm", "vp90-2-00-quantizer-35.webm",
"vp90-2-02-size-08x10.webm", "vp90-2-02-size-08x16.webm", "vp90-2-00-quantizer-36.webm",
"vp90-2-02-size-08x18.webm", "vp90-2-02-size-08x32.webm", "vp90-2-00-quantizer-37.webm",
"vp90-2-02-size-08x34.webm", "vp90-2-02-size-08x64.webm", "vp90-2-00-quantizer-38.webm",
"vp90-2-02-size-08x66.webm", "vp90-2-02-size-10x08.webm", "vp90-2-00-quantizer-39.webm",
"vp90-2-02-size-10x10.webm", "vp90-2-02-size-10x16.webm", "vp90-2-00-quantizer-40.webm",
"vp90-2-02-size-10x18.webm", "vp90-2-02-size-10x32.webm", "vp90-2-00-quantizer-41.webm",
"vp90-2-02-size-10x34.webm", "vp90-2-02-size-10x64.webm", "vp90-2-00-quantizer-42.webm",
"vp90-2-02-size-10x66.webm", "vp90-2-02-size-16x08.webm", "vp90-2-00-quantizer-43.webm",
"vp90-2-02-size-16x10.webm", "vp90-2-02-size-16x16.webm", "vp90-2-00-quantizer-44.webm",
"vp90-2-02-size-16x18.webm", "vp90-2-02-size-16x32.webm", "vp90-2-00-quantizer-45.webm",
"vp90-2-02-size-16x34.webm", "vp90-2-02-size-16x64.webm", "vp90-2-00-quantizer-46.webm",
"vp90-2-02-size-16x66.webm", "vp90-2-02-size-18x08.webm", "vp90-2-00-quantizer-47.webm",
"vp90-2-02-size-18x10.webm", "vp90-2-02-size-18x16.webm", "vp90-2-00-quantizer-48.webm",
"vp90-2-02-size-18x18.webm", "vp90-2-02-size-18x32.webm", "vp90-2-00-quantizer-49.webm",
"vp90-2-02-size-18x34.webm", "vp90-2-02-size-18x64.webm", "vp90-2-00-quantizer-50.webm",
"vp90-2-02-size-18x66.webm", "vp90-2-02-size-32x08.webm", "vp90-2-00-quantizer-51.webm",
"vp90-2-02-size-32x10.webm", "vp90-2-02-size-32x16.webm", "vp90-2-00-quantizer-52.webm",
"vp90-2-02-size-32x18.webm", "vp90-2-02-size-32x32.webm", "vp90-2-00-quantizer-53.webm",
"vp90-2-02-size-32x34.webm", "vp90-2-02-size-32x64.webm", "vp90-2-00-quantizer-54.webm",
"vp90-2-02-size-32x66.webm", "vp90-2-02-size-34x08.webm", "vp90-2-00-quantizer-55.webm",
"vp90-2-02-size-34x10.webm", "vp90-2-02-size-34x16.webm", "vp90-2-00-quantizer-56.webm",
"vp90-2-02-size-34x18.webm", "vp90-2-02-size-34x32.webm", "vp90-2-00-quantizer-57.webm",
"vp90-2-02-size-34x34.webm", "vp90-2-02-size-34x64.webm", "vp90-2-00-quantizer-58.webm",
"vp90-2-02-size-34x66.webm", "vp90-2-02-size-64x08.webm", "vp90-2-00-quantizer-59.webm",
"vp90-2-02-size-64x10.webm", "vp90-2-02-size-64x16.webm", "vp90-2-00-quantizer-60.webm",
"vp90-2-02-size-64x18.webm", "vp90-2-02-size-64x32.webm", "vp90-2-00-quantizer-61.webm",
"vp90-2-02-size-64x34.webm", "vp90-2-02-size-64x64.webm", "vp90-2-00-quantizer-62.webm",
"vp90-2-02-size-64x66.webm", "vp90-2-02-size-66x08.webm", "vp90-2-00-quantizer-63.webm",
"vp90-2-02-size-66x10.webm", "vp90-2-02-size-66x16.webm", "vp90-2-01-sharpness-1.webm",
"vp90-2-02-size-66x18.webm", "vp90-2-02-size-66x32.webm", "vp90-2-01-sharpness-2.webm",
"vp90-2-02-size-66x34.webm", "vp90-2-02-size-66x64.webm", "vp90-2-01-sharpness-3.webm",
"vp90-2-02-size-66x66.webm", "vp90-2-02-size-130x132.webm", "vp90-2-01-sharpness-4.webm",
"vp90-2-02-size-132x130.webm", "vp90-2-02-size-132x132.webm", "vp90-2-01-sharpness-5.webm",
"vp90-2-02-size-178x180.webm", "vp90-2-02-size-180x178.webm", "vp90-2-01-sharpness-6.webm",
"vp90-2-02-size-180x180.webm", "vp90-2-03-size-196x196.webm", "vp90-2-01-sharpness-7.webm",
"vp90-2-03-size-196x198.webm", "vp90-2-03-size-196x200.webm", "vp90-2-02-size-08x08.webm",
"vp90-2-03-size-196x202.webm", "vp90-2-03-size-196x208.webm", "vp90-2-02-size-08x10.webm",
"vp90-2-03-size-196x210.webm", "vp90-2-03-size-196x224.webm", "vp90-2-02-size-08x16.webm",
"vp90-2-03-size-196x226.webm", "vp90-2-03-size-198x196.webm", "vp90-2-02-size-08x18.webm",
"vp90-2-03-size-198x198.webm", "vp90-2-03-size-198x200.webm", "vp90-2-02-size-08x32.webm",
"vp90-2-03-size-198x202.webm", "vp90-2-03-size-198x208.webm", "vp90-2-02-size-08x34.webm",
"vp90-2-03-size-198x210.webm", "vp90-2-03-size-198x224.webm", "vp90-2-02-size-08x64.webm",
"vp90-2-03-size-198x226.webm", "vp90-2-03-size-200x196.webm", "vp90-2-02-size-08x66.webm",
"vp90-2-03-size-200x198.webm", "vp90-2-03-size-200x200.webm", "vp90-2-02-size-10x08.webm",
"vp90-2-03-size-200x202.webm", "vp90-2-03-size-200x208.webm", "vp90-2-02-size-10x10.webm",
"vp90-2-03-size-200x210.webm", "vp90-2-03-size-200x224.webm", "vp90-2-02-size-10x16.webm",
"vp90-2-03-size-200x226.webm", "vp90-2-03-size-202x196.webm", "vp90-2-02-size-10x18.webm",
"vp90-2-03-size-202x198.webm", "vp90-2-03-size-202x200.webm", "vp90-2-02-size-10x32.webm",
"vp90-2-03-size-202x202.webm", "vp90-2-03-size-202x208.webm", "vp90-2-02-size-10x34.webm",
"vp90-2-03-size-202x210.webm", "vp90-2-03-size-202x224.webm", "vp90-2-02-size-10x64.webm",
"vp90-2-03-size-202x226.webm", "vp90-2-03-size-208x196.webm", "vp90-2-02-size-10x66.webm",
"vp90-2-03-size-208x198.webm", "vp90-2-03-size-208x200.webm", "vp90-2-02-size-16x08.webm",
"vp90-2-03-size-208x202.webm", "vp90-2-03-size-208x208.webm", "vp90-2-02-size-16x10.webm",
"vp90-2-03-size-208x210.webm", "vp90-2-03-size-208x224.webm", "vp90-2-02-size-16x16.webm",
"vp90-2-03-size-208x226.webm", "vp90-2-03-size-210x196.webm", "vp90-2-02-size-16x18.webm",
"vp90-2-03-size-210x198.webm", "vp90-2-03-size-210x200.webm", "vp90-2-02-size-16x32.webm",
"vp90-2-03-size-210x202.webm", "vp90-2-03-size-210x208.webm", "vp90-2-02-size-16x34.webm",
"vp90-2-03-size-210x210.webm", "vp90-2-03-size-210x224.webm", "vp90-2-02-size-16x64.webm",
"vp90-2-03-size-210x226.webm", "vp90-2-03-size-224x196.webm", "vp90-2-02-size-16x66.webm",
"vp90-2-03-size-224x198.webm", "vp90-2-03-size-224x200.webm", "vp90-2-02-size-18x08.webm",
"vp90-2-03-size-224x202.webm", "vp90-2-03-size-224x208.webm", "vp90-2-02-size-18x10.webm",
"vp90-2-03-size-224x210.webm", "vp90-2-03-size-224x224.webm", "vp90-2-02-size-18x16.webm",
"vp90-2-03-size-224x226.webm", "vp90-2-03-size-226x196.webm", "vp90-2-02-size-18x18.webm",
"vp90-2-03-size-226x198.webm", "vp90-2-03-size-226x200.webm", "vp90-2-02-size-18x32.webm",
"vp90-2-03-size-226x202.webm", "vp90-2-03-size-226x208.webm", "vp90-2-02-size-18x34.webm",
"vp90-2-03-size-226x210.webm", "vp90-2-03-size-226x224.webm", "vp90-2-02-size-18x64.webm",
"vp90-2-03-size-226x226.webm", "vp90-2-03-size-352x288.webm", "vp90-2-02-size-18x66.webm",
"vp90-2-02-size-32x08.webm",
"vp90-2-02-size-32x10.webm",
"vp90-2-02-size-32x16.webm",
"vp90-2-02-size-32x18.webm",
"vp90-2-02-size-32x32.webm",
"vp90-2-02-size-32x34.webm",
"vp90-2-02-size-32x64.webm",
"vp90-2-02-size-32x66.webm",
"vp90-2-02-size-34x08.webm",
"vp90-2-02-size-34x10.webm",
"vp90-2-02-size-34x16.webm",
"vp90-2-02-size-34x18.webm",
"vp90-2-02-size-34x32.webm",
"vp90-2-02-size-34x34.webm",
"vp90-2-02-size-34x64.webm",
"vp90-2-02-size-34x66.webm",
"vp90-2-02-size-64x08.webm",
"vp90-2-02-size-64x10.webm",
"vp90-2-02-size-64x16.webm",
"vp90-2-02-size-64x18.webm",
"vp90-2-02-size-64x32.webm",
"vp90-2-02-size-64x34.webm",
"vp90-2-02-size-64x64.webm",
"vp90-2-02-size-64x66.webm",
"vp90-2-02-size-66x08.webm",
"vp90-2-02-size-66x10.webm",
"vp90-2-02-size-66x16.webm",
"vp90-2-02-size-66x18.webm",
"vp90-2-02-size-66x32.webm",
"vp90-2-02-size-66x34.webm",
"vp90-2-02-size-66x64.webm",
"vp90-2-02-size-66x66.webm",
"vp90-2-02-size-130x132.webm",
"vp90-2-02-size-132x130.webm",
"vp90-2-02-size-132x132.webm",
"vp90-2-02-size-178x180.webm",
"vp90-2-02-size-180x178.webm",
"vp90-2-02-size-180x180.webm",
"vp90-2-03-size-196x196.webm",
"vp90-2-03-size-196x198.webm",
"vp90-2-03-size-196x200.webm",
"vp90-2-03-size-196x202.webm",
"vp90-2-03-size-196x208.webm",
"vp90-2-03-size-196x210.webm",
"vp90-2-03-size-196x224.webm",
"vp90-2-03-size-196x226.webm",
"vp90-2-03-size-198x196.webm",
"vp90-2-03-size-198x198.webm",
"vp90-2-03-size-198x200.webm",
"vp90-2-03-size-198x202.webm",
"vp90-2-03-size-198x208.webm",
"vp90-2-03-size-198x210.webm",
"vp90-2-03-size-198x224.webm",
"vp90-2-03-size-198x226.webm",
"vp90-2-03-size-200x196.webm",
"vp90-2-03-size-200x198.webm",
"vp90-2-03-size-200x200.webm",
"vp90-2-03-size-200x202.webm",
"vp90-2-03-size-200x208.webm",
"vp90-2-03-size-200x210.webm",
"vp90-2-03-size-200x224.webm",
"vp90-2-03-size-200x226.webm",
"vp90-2-03-size-202x196.webm",
"vp90-2-03-size-202x198.webm",
"vp90-2-03-size-202x200.webm",
"vp90-2-03-size-202x202.webm",
"vp90-2-03-size-202x208.webm",
"vp90-2-03-size-202x210.webm",
"vp90-2-03-size-202x224.webm",
"vp90-2-03-size-202x226.webm",
"vp90-2-03-size-208x196.webm",
"vp90-2-03-size-208x198.webm",
"vp90-2-03-size-208x200.webm",
"vp90-2-03-size-208x202.webm",
"vp90-2-03-size-208x208.webm",
"vp90-2-03-size-208x210.webm",
"vp90-2-03-size-208x224.webm",
"vp90-2-03-size-208x226.webm",
"vp90-2-03-size-210x196.webm",
"vp90-2-03-size-210x198.webm",
"vp90-2-03-size-210x200.webm",
"vp90-2-03-size-210x202.webm",
"vp90-2-03-size-210x208.webm",
"vp90-2-03-size-210x210.webm",
"vp90-2-03-size-210x224.webm",
"vp90-2-03-size-210x226.webm",
"vp90-2-03-size-224x196.webm",
"vp90-2-03-size-224x198.webm",
"vp90-2-03-size-224x200.webm",
"vp90-2-03-size-224x202.webm",
"vp90-2-03-size-224x208.webm",
"vp90-2-03-size-224x210.webm",
"vp90-2-03-size-224x224.webm",
"vp90-2-03-size-224x226.webm",
"vp90-2-03-size-226x196.webm",
"vp90-2-03-size-226x198.webm",
"vp90-2-03-size-226x200.webm",
"vp90-2-03-size-226x202.webm",
"vp90-2-03-size-226x208.webm",
"vp90-2-03-size-226x210.webm",
"vp90-2-03-size-226x224.webm",
"vp90-2-03-size-226x226.webm",
"vp90-2-03-size-352x288.webm",
"vp90-2-03-deltaq.webm", "vp90-2-03-deltaq.webm",
"vp90-2-05-resize.ivf", "vp90-2-06-bilinear.webm", "vp90-2-05-resize.ivf",
"vp90-2-07-frame_parallel.webm", "vp90-2-08-tile_1x2_frame_parallel.webm", "vp90-2-06-bilinear.webm",
"vp90-2-08-tile_1x2.webm", "vp90-2-08-tile_1x4_frame_parallel.webm", "vp90-2-07-frame_parallel.webm",
"vp90-2-08-tile_1x4.webm", "vp90-2-08-tile_1x8_frame_parallel.webm", "vp90-2-08-tile_1x2_frame_parallel.webm",
"vp90-2-08-tile_1x8.webm", "vp90-2-08-tile-4x4.webm", "vp90-2-08-tile_1x2.webm",
"vp90-2-08-tile-4x1.webm", "vp90-2-09-subpixel-00.ivf", "vp90-2-08-tile_1x4_frame_parallel.webm",
"vp90-2-02-size-lf-1920x1080.webm", "vp90-2-09-aq2.webm", "vp90-2-08-tile_1x4.webm",
"vp90-2-09-lf_deltas.webm", "vp90-2-10-show-existing-frame.webm", "vp90-2-08-tile_1x8_frame_parallel.webm",
"vp90-2-08-tile_1x8.webm",
"vp90-2-08-tile-4x4.webm",
"vp90-2-08-tile-4x1.webm",
"vp90-2-09-subpixel-00.ivf",
"vp90-2-02-size-lf-1920x1080.webm",
"vp90-2-09-aq2.webm",
"vp90-2-09-lf_deltas.webm",
"vp90-2-10-show-existing-frame.webm",
"vp90-2-10-show-existing-frame2.webm", "vp90-2-10-show-existing-frame2.webm",
"vp90-2-11-size-351x287.webm", "vp90-2-11-size-351x288.webm", "vp90-2-11-size-351x287.webm",
"vp90-2-11-size-352x287.webm", "vp90-2-12-droppable_1.ivf", "vp90-2-11-size-351x288.webm",
"vp90-2-12-droppable_2.ivf", "vp90-2-12-droppable_3.ivf", "vp90-2-11-size-352x287.webm",
"vp90-2-12-droppable_1.ivf",
"vp90-2-12-droppable_2.ivf",
"vp90-2-12-droppable_3.ivf",
#if !CONFIG_SIZE_LIMIT || \ #if !CONFIG_SIZE_LIMIT || \
(DECODE_WIDTH_LIMIT >= 20400 && DECODE_HEIGHT_LIMIT >= 120) (DECODE_WIDTH_LIMIT >= 20400 && DECODE_HEIGHT_LIMIT >= 120)
"vp90-2-13-largescaling.webm", "vp90-2-13-largescaling.webm",
#endif #endif
"vp90-2-14-resize-fp-tiles-1-16.webm", "vp90-2-14-resize-fp-tiles-1-16.webm",
"vp90-2-14-resize-fp-tiles-1-2-4-8-16.webm", "vp90-2-14-resize-fp-tiles-1-2-4-8-16.webm",
"vp90-2-14-resize-fp-tiles-1-2.webm", "vp90-2-14-resize-fp-tiles-1-4.webm", "vp90-2-14-resize-fp-tiles-1-2.webm",
"vp90-2-14-resize-fp-tiles-16-1.webm", "vp90-2-14-resize-fp-tiles-16-2.webm", "vp90-2-14-resize-fp-tiles-1-4.webm",
"vp90-2-14-resize-fp-tiles-16-1.webm",
"vp90-2-14-resize-fp-tiles-16-2.webm",
"vp90-2-14-resize-fp-tiles-16-4.webm", "vp90-2-14-resize-fp-tiles-16-4.webm",
"vp90-2-14-resize-fp-tiles-16-8-4-2-1.webm", "vp90-2-14-resize-fp-tiles-16-8-4-2-1.webm",
"vp90-2-14-resize-fp-tiles-16-8.webm", "vp90-2-14-resize-fp-tiles-1-8.webm", "vp90-2-14-resize-fp-tiles-16-8.webm",
"vp90-2-14-resize-fp-tiles-2-16.webm", "vp90-2-14-resize-fp-tiles-2-1.webm", "vp90-2-14-resize-fp-tiles-1-8.webm",
"vp90-2-14-resize-fp-tiles-2-4.webm", "vp90-2-14-resize-fp-tiles-2-8.webm", "vp90-2-14-resize-fp-tiles-2-16.webm",
"vp90-2-14-resize-fp-tiles-4-16.webm", "vp90-2-14-resize-fp-tiles-4-1.webm", "vp90-2-14-resize-fp-tiles-2-1.webm",
"vp90-2-14-resize-fp-tiles-4-2.webm", "vp90-2-14-resize-fp-tiles-4-8.webm", "vp90-2-14-resize-fp-tiles-2-4.webm",
"vp90-2-14-resize-fp-tiles-8-16.webm", "vp90-2-14-resize-fp-tiles-8-1.webm", "vp90-2-14-resize-fp-tiles-2-8.webm",
"vp90-2-14-resize-fp-tiles-8-2.webm", "vp90-2-14-resize-fp-tiles-8-4.webm", "vp90-2-14-resize-fp-tiles-4-16.webm",
"vp90-2-14-resize-fp-tiles-4-1.webm",
"vp90-2-14-resize-fp-tiles-4-2.webm",
"vp90-2-14-resize-fp-tiles-4-8.webm",
"vp90-2-14-resize-fp-tiles-8-16.webm",
"vp90-2-14-resize-fp-tiles-8-1.webm",
"vp90-2-14-resize-fp-tiles-8-2.webm",
"vp90-2-14-resize-fp-tiles-8-4.webm",
"vp90-2-14-resize-10frames-fp-tiles-1-2-4-8.webm", "vp90-2-14-resize-10frames-fp-tiles-1-2-4-8.webm",
"vp90-2-14-resize-10frames-fp-tiles-1-2.webm", "vp90-2-14-resize-10frames-fp-tiles-1-2.webm",
"vp90-2-14-resize-10frames-fp-tiles-1-4.webm", "vp90-2-14-resize-10frames-fp-tiles-1-4.webm",
@ -225,25 +348,33 @@ const char *const kVP9TestVectors[] = {
"vp90-2-14-resize-10frames-fp-tiles-8-2.webm", "vp90-2-14-resize-10frames-fp-tiles-8-2.webm",
"vp90-2-14-resize-10frames-fp-tiles-8-4-2-1.webm", "vp90-2-14-resize-10frames-fp-tiles-8-4-2-1.webm",
"vp90-2-14-resize-10frames-fp-tiles-8-4.webm", "vp90-2-14-resize-10frames-fp-tiles-8-4.webm",
"vp90-2-15-segkey.webm", "vp90-2-15-segkey_adpq.webm", "vp90-2-15-segkey.webm",
"vp90-2-16-intra-only.webm", "vp90-2-17-show-existing-frame.webm", "vp90-2-15-segkey_adpq.webm",
"vp90-2-18-resize.ivf", "vp90-2-19-skip.webm", "vp90-2-16-intra-only.webm",
"vp90-2-19-skip-01.webm", "vp90-2-19-skip-02.webm", "vp90-2-17-show-existing-frame.webm",
"vp90-2-18-resize.ivf",
"vp90-2-19-skip.webm",
"vp90-2-19-skip-01.webm",
"vp90-2-19-skip-02.webm",
"vp91-2-04-yuv444.webm", "vp91-2-04-yuv444.webm",
"vp91-2-04-yuv422.webm", "vp91-2-04-yuv440.webm", "vp91-2-04-yuv422.webm",
"vp91-2-04-yuv440.webm",
#if CONFIG_VP9_HIGHBITDEPTH #if CONFIG_VP9_HIGHBITDEPTH
"vp92-2-20-10bit-yuv420.webm", "vp92-2-20-12bit-yuv420.webm", "vp92-2-20-10bit-yuv420.webm",
"vp93-2-20-10bit-yuv422.webm", "vp93-2-20-12bit-yuv422.webm", "vp92-2-20-12bit-yuv420.webm",
"vp93-2-20-10bit-yuv440.webm", "vp93-2-20-12bit-yuv440.webm", "vp93-2-20-10bit-yuv422.webm",
"vp93-2-20-10bit-yuv444.webm", "vp93-2-20-12bit-yuv444.webm", "vp93-2-20-12bit-yuv422.webm",
"vp93-2-20-10bit-yuv440.webm",
"vp93-2-20-12bit-yuv440.webm",
"vp93-2-20-10bit-yuv444.webm",
"vp93-2-20-12bit-yuv444.webm",
#endif // CONFIG_VP9_HIGHBITDEPTH #endif // CONFIG_VP9_HIGHBITDEPTH
"vp90-2-20-big_superframe-01.webm", "vp90-2-20-big_superframe-02.webm", "vp90-2-20-big_superframe-01.webm",
"vp90-2-20-big_superframe-02.webm",
RESIZE_TEST_VECTORS RESIZE_TEST_VECTORS
}; };
const int kNumVP9TestVectors = NELEMENTS(kVP9TestVectors); const int kNumVP9TestVectors = NELEMENTS(kVP9TestVectors);
const char *const kVP9TestVectorsResize[] = { const char *const kVP9TestVectorsResize[] = { RESIZE_TEST_VECTORS };
RESIZE_TEST_VECTORS
};
const int kNumVP9TestVectorsResize = NELEMENTS(kVP9TestVectorsResize); const int kNumVP9TestVectorsResize = NELEMENTS(kVP9TestVectorsResize);
#undef RESIZE_TEST_VECTORS #undef RESIZE_TEST_VECTORS
#endif // CONFIG_VP9_DECODER #endif // CONFIG_VP9_DECODER

6
test/tile_independence_test.cc
View File

@ -24,9 +24,7 @@ class TileIndependenceTest : public ::libvpx_test::EncoderTest,
public ::libvpx_test::CodecTestWithParam<int> { public ::libvpx_test::CodecTestWithParam<int> {
protected: protected:
TileIndependenceTest() TileIndependenceTest()
: EncoderTest(GET_PARAM(0)), : EncoderTest(GET_PARAM(0)), md5_fw_order_(), md5_inv_order_(),
md5_fw_order_(),
md5_inv_order_(),
n_tiles_(GET_PARAM(1)) { n_tiles_(GET_PARAM(1)) {
init_flags_ = VPX_CODEC_USE_PSNR; init_flags_ = VPX_CODEC_USE_PSNR;
vpx_codec_dec_cfg_t cfg = vpx_codec_dec_cfg_t(); vpx_codec_dec_cfg_t cfg = vpx_codec_dec_cfg_t();
@ -58,7 +56,7 @@ class TileIndependenceTest : public ::libvpx_test::EncoderTest,
void UpdateMD5(::libvpx_test::Decoder *dec, const vpx_codec_cx_pkt_t *pkt, void UpdateMD5(::libvpx_test::Decoder *dec, const vpx_codec_cx_pkt_t *pkt,
::libvpx_test::MD5 *md5) { ::libvpx_test::MD5 *md5) {
const vpx_codec_err_t res = dec->DecodeFrame( const vpx_codec_err_t res = dec->DecodeFrame(
reinterpret_cast<uint8_t*>(pkt->data.frame.buf), pkt->data.frame.sz); reinterpret_cast<uint8_t *>(pkt->data.frame.buf), pkt->data.frame.sz);
if (res != VPX_CODEC_OK) { if (res != VPX_CODEC_OK) {
abort_ = true; abort_ = true;
ASSERT_EQ(VPX_CODEC_OK, res); ASSERT_EQ(VPX_CODEC_OK, res);

4
test/user_priv_test.cc
View File

@ -34,8 +34,8 @@ using libvpx_test::ACMRandom;
void CheckUserPrivateData(void *user_priv, int *target) { void CheckUserPrivateData(void *user_priv, int *target) {
// actual pointer value should be the same as expected. // actual pointer value should be the same as expected.
EXPECT_EQ(reinterpret_cast<void *>(target), user_priv) << EXPECT_EQ(reinterpret_cast<void *>(target), user_priv)
"user_priv pointer value does not match."; << "user_priv pointer value does not match.";
} }
// Decodes |filename|. Passes in user_priv data when calling DecodeFrame and // Decodes |filename|. Passes in user_priv data when calling DecodeFrame and

7
test/util.h
View File

@ -17,14 +17,13 @@
#include "vpx/vpx_image.h" #include "vpx/vpx_image.h"
// Macros // Macros
#define GET_PARAM(k) std::tr1::get< k >(GetParam()) #define GET_PARAM(k) std::tr1::get<k>(GetParam())
inline double compute_psnr(const vpx_image_t *img1, const vpx_image_t *img2) { inline double compute_psnr(const vpx_image_t *img1, const vpx_image_t *img2) {
assert((img1->fmt == img2->fmt) && assert((img1->fmt == img2->fmt) && (img1->d_w == img2->d_w) &&
(img1->d_w == img2->d_w) &&
(img1->d_h == img2->d_h)); (img1->d_h == img2->d_h));
const unsigned int width_y = img1->d_w; const unsigned int width_y = img1->d_w;
const unsigned int height_y = img1->d_h; const unsigned int height_y = img1->d_h;
unsigned int i, j; unsigned int i, j;

276
test/variance_test.cc
View File

@ -57,8 +57,7 @@ static void RoundHighBitDepth(int bit_depth, int64_t *se, uint64_t *sse) {
*se = (*se + 2) >> 2; *se = (*se + 2) >> 2;
break; break;
case VPX_BITS_8: case VPX_BITS_8:
default: default: break;
break;
} }
} }
@ -74,10 +73,9 @@ static unsigned int mb_ss_ref(const int16_t *src) {
* Our codebase calculates the "diff" value in the variance algorithm by * Our codebase calculates the "diff" value in the variance algorithm by
* (src - ref). * (src - ref).
*/ */
static uint32_t variance_ref(const uint8_t *src, const uint8_t *ref, static uint32_t variance_ref(const uint8_t *src, const uint8_t *ref, int l2w,
int l2w, int l2h, int src_stride, int l2h, int src_stride, int ref_stride,
int ref_stride, uint32_t *sse_ptr, uint32_t *sse_ptr, bool use_high_bit_depth_,
bool use_high_bit_depth_,
vpx_bit_depth_t bit_depth) { vpx_bit_depth_t bit_depth) {
int64_t se = 0; int64_t se = 0;
uint64_t sse = 0; uint64_t sse = 0;
@ -87,8 +85,7 @@ static uint32_t variance_ref(const uint8_t *src, const uint8_t *ref,
for (int x = 0; x < w; x++) { for (int x = 0; x < w; x++) {
int diff; int diff;
if (!use_high_bit_depth_) { if (!use_high_bit_depth_) {
diff = src[y * src_stride + x] - diff = src[y * src_stride + x] - ref[y * ref_stride + x];
ref[y * ref_stride + x];
se += diff; se += diff;
sse += diff * diff; sse += diff * diff;
#if CONFIG_VP9_HIGHBITDEPTH #if CONFIG_VP9_HIGHBITDEPTH
@ -103,9 +100,8 @@ static uint32_t variance_ref(const uint8_t *src, const uint8_t *ref,
} }
RoundHighBitDepth(bit_depth, &se, &sse); RoundHighBitDepth(bit_depth, &se, &sse);
*sse_ptr = static_cast<uint32_t>(sse); *sse_ptr = static_cast<uint32_t>(sse);
return static_cast<uint32_t>(sse - return static_cast<uint32_t>(
((static_cast<int64_t>(se) * se) >> sse - ((static_cast<int64_t>(se) * se) >> (l2w + l2h)));
(l2w + l2h)));
} }
/* The subpel reference functions differ from the codec version in one aspect: /* The subpel reference functions differ from the codec version in one aspect:
@ -116,8 +112,7 @@ static uint32_t variance_ref(const uint8_t *src, const uint8_t *ref,
*/ */
static uint32_t subpel_variance_ref(const uint8_t *ref, const uint8_t *src, static uint32_t subpel_variance_ref(const uint8_t *ref, const uint8_t *src,
int l2w, int l2h, int xoff, int yoff, int l2w, int l2h, int xoff, int yoff,
uint32_t *sse_ptr, uint32_t *sse_ptr, bool use_high_bit_depth_,
bool use_high_bit_depth_,
vpx_bit_depth_t bit_depth) { vpx_bit_depth_t bit_depth) {
int64_t se = 0; int64_t se = 0;
uint64_t sse = 0; uint64_t sse = 0;
@ -161,16 +156,13 @@ static uint32_t subpel_variance_ref(const uint8_t *ref, const uint8_t *src,
} }
RoundHighBitDepth(bit_depth, &se, &sse); RoundHighBitDepth(bit_depth, &se, &sse);
*sse_ptr = static_cast<uint32_t>(sse); *sse_ptr = static_cast<uint32_t>(sse);
return static_cast<uint32_t>(sse - return static_cast<uint32_t>(
((static_cast<int64_t>(se) * se) >> sse - ((static_cast<int64_t>(se) * se) >> (l2w + l2h)));
(l2w + l2h)));
} }
static uint32_t subpel_avg_variance_ref(const uint8_t *ref, static uint32_t subpel_avg_variance_ref(const uint8_t *ref, const uint8_t *src,
const uint8_t *src, const uint8_t *second_pred, int l2w,
const uint8_t *second_pred, int l2h, int xoff, int yoff,
int l2w, int l2h,
int xoff, int yoff,
uint32_t *sse_ptr, uint32_t *sse_ptr,
bool use_high_bit_depth, bool use_high_bit_depth,
vpx_bit_depth_t bit_depth) { vpx_bit_depth_t bit_depth) {
@ -218,9 +210,8 @@ static uint32_t subpel_avg_variance_ref(const uint8_t *ref,
} }
RoundHighBitDepth(bit_depth, &se, &sse); RoundHighBitDepth(bit_depth, &se, &sse);
*sse_ptr = static_cast<uint32_t>(sse); *sse_ptr = static_cast<uint32_t>(sse);
return static_cast<uint32_t>(sse - return static_cast<uint32_t>(
((static_cast<int64_t>(se) * se) >> sse - ((static_cast<int64_t>(se) * se) >> (l2w + l2h)));
(l2w + l2h)));
} }
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
@ -229,9 +220,7 @@ class SumOfSquaresTest : public ::testing::TestWithParam<SumOfSquaresFunction> {
public: public:
SumOfSquaresTest() : func_(GetParam()) {} SumOfSquaresTest() : func_(GetParam()) {}
virtual ~SumOfSquaresTest() { virtual ~SumOfSquaresTest() { libvpx_test::ClearSystemState(); }
libvpx_test::ClearSystemState();
}
protected: protected:
void ConstTest(); void ConstTest();
@ -272,10 +261,10 @@ void SumOfSquaresTest::RefTest() {
// some testing context. // some testing context.
// Can be used for MSE, SSE, Variance, etc. // Can be used for MSE, SSE, Variance, etc.
template<typename Func> template <typename Func>
struct TestParams { struct TestParams {
TestParams(int log2w = 0, int log2h = 0, TestParams(int log2w = 0, int log2h = 0, Func function = NULL,
Func function = NULL, int bit_depth_value = 0) int bit_depth_value = 0)
: log2width(log2w), log2height(log2h), func(function) { : log2width(log2w), log2height(log2h), func(function) {
use_high_bit_depth = (bit_depth_value > 0); use_high_bit_depth = (bit_depth_value > 0);
if (use_high_bit_depth) { if (use_high_bit_depth) {
@ -298,17 +287,17 @@ struct TestParams {
uint32_t mask; uint32_t mask;
}; };
template<typename Func> template <typename Func>
std::ostream &operator<<(std::ostream &os, const TestParams<Func> &p) { std::ostream &operator<<(std::ostream &os, const TestParams<Func> &p) {
return os << "log2width/height:" << p.log2width << "/" << p.log2height return os << "log2width/height:" << p.log2width << "/" << p.log2height
<< " function:" << reinterpret_cast<const void*>(p.func) << " function:" << reinterpret_cast<const void *>(p.func)
<< " bit-depth:" << p.bit_depth; << " bit-depth:" << p.bit_depth;
} }
// Main class for testing a function type // Main class for testing a function type
template<typename FunctionType> template <typename FunctionType>
class MainTestClass : class MainTestClass
public ::testing::TestWithParam<TestParams<FunctionType> > { : public ::testing::TestWithParam<TestParams<FunctionType> > {
public: public:
virtual void SetUp() { virtual void SetUp() {
params_ = this->GetParam(); params_ = this->GetParam();
@ -316,7 +305,7 @@ class MainTestClass :
rnd_.Reset(ACMRandom::DeterministicSeed()); rnd_.Reset(ACMRandom::DeterministicSeed());
const size_t unit = const size_t unit =
use_high_bit_depth() ? sizeof(uint16_t) : sizeof(uint8_t); use_high_bit_depth() ? sizeof(uint16_t) : sizeof(uint8_t);
src_ = reinterpret_cast<uint8_t*>(vpx_memalign(16, block_size() * unit)); src_ = reinterpret_cast<uint8_t *>(vpx_memalign(16, block_size() * unit));
ref_ = new uint8_t[block_size() * unit]; ref_ = new uint8_t[block_size() * unit];
ASSERT_TRUE(src_ != NULL); ASSERT_TRUE(src_ != NULL);
ASSERT_TRUE(ref_ != NULL); ASSERT_TRUE(ref_ != NULL);
@ -333,8 +322,8 @@ class MainTestClass :
#if CONFIG_VP9_HIGHBITDEPTH #if CONFIG_VP9_HIGHBITDEPTH
if (use_high_bit_depth()) { if (use_high_bit_depth()) {
// TODO(skal): remove! // TODO(skal): remove!
src_ = reinterpret_cast<uint8_t*>(CONVERT_TO_SHORTPTR(src_)); src_ = reinterpret_cast<uint8_t *>(CONVERT_TO_SHORTPTR(src_));
ref_ = reinterpret_cast<uint8_t*>(CONVERT_TO_SHORTPTR(ref_)); ref_ = reinterpret_cast<uint8_t *>(CONVERT_TO_SHORTPTR(ref_));
} }
#endif #endif
@ -380,20 +369,20 @@ class MainTestClass :
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// Tests related to variance. // Tests related to variance.
template<typename VarianceFunctionType> template <typename VarianceFunctionType>
void MainTestClass<VarianceFunctionType>::ZeroTest() { void MainTestClass<VarianceFunctionType>::ZeroTest() {
for (int i = 0; i <= 255; ++i) { for (int i = 0; i <= 255; ++i) {
if (!use_high_bit_depth()) { if (!use_high_bit_depth()) {
memset(src_, i, block_size()); memset(src_, i, block_size());
} else { } else {
uint16_t* const src16 = CONVERT_TO_SHORTPTR(src_); uint16_t *const src16 = CONVERT_TO_SHORTPTR(src_);
for (int k = 0; k < block_size(); ++k) src16[k] = i << byte_shift(); for (int k = 0; k < block_size(); ++k) src16[k] = i << byte_shift();
} }
for (int j = 0; j <= 255; ++j) { for (int j = 0; j <= 255; ++j) {
if (!use_high_bit_depth()) { if (!use_high_bit_depth()) {
memset(ref_, j, block_size()); memset(ref_, j, block_size());
} else { } else {
uint16_t* const ref16 = CONVERT_TO_SHORTPTR(ref_); uint16_t *const ref16 = CONVERT_TO_SHORTPTR(ref_);
for (int k = 0; k < block_size(); ++k) ref16[k] = j << byte_shift(); for (int k = 0; k < block_size(); ++k) ref16[k] = j << byte_shift();
} }
unsigned int sse, var; unsigned int sse, var;
@ -404,7 +393,7 @@ void MainTestClass<VarianceFunctionType>::ZeroTest() {
} }
} }
template<typename VarianceFunctionType> template <typename VarianceFunctionType>
void MainTestClass<VarianceFunctionType>::RefTest() { void MainTestClass<VarianceFunctionType>::RefTest() {
for (int i = 0; i < 10; ++i) { for (int i = 0; i < 10; ++i) {
for (int j = 0; j < block_size(); j++) { for (int j = 0; j < block_size(); j++) {
@ -422,15 +411,15 @@ void MainTestClass<VarianceFunctionType>::RefTest() {
const int stride = width(); const int stride = width();
ASM_REGISTER_STATE_CHECK( ASM_REGISTER_STATE_CHECK(
var1 = params_.func(src_, stride, ref_, stride, &sse1)); var1 = params_.func(src_, stride, ref_, stride, &sse1));
var2 = variance_ref(src_, ref_, params_.log2width, params_.log2height, var2 =
stride, stride, &sse2, variance_ref(src_, ref_, params_.log2width, params_.log2height, stride,
use_high_bit_depth(), params_.bit_depth); stride, &sse2, use_high_bit_depth(), params_.bit_depth);
EXPECT_EQ(sse1, sse2) << "Error at test index: " << i; EXPECT_EQ(sse1, sse2) << "Error at test index: " << i;
EXPECT_EQ(var1, var2) << "Error at test index: " << i; EXPECT_EQ(var1, var2) << "Error at test index: " << i;
} }
} }
template<typename VarianceFunctionType> template <typename VarianceFunctionType>
void MainTestClass<VarianceFunctionType>::RefStrideTest() { void MainTestClass<VarianceFunctionType>::RefStrideTest() {
for (int i = 0; i < 10; ++i) { for (int i = 0; i < 10; ++i) {
const int ref_stride = (i & 1) * width(); const int ref_stride = (i & 1) * width();
@ -453,16 +442,15 @@ void MainTestClass<VarianceFunctionType>::RefStrideTest() {
ASM_REGISTER_STATE_CHECK( ASM_REGISTER_STATE_CHECK(
var1 = params_.func(src_, src_stride, ref_, ref_stride, &sse1)); var1 = params_.func(src_, src_stride, ref_, ref_stride, &sse1));
var2 = variance_ref(src_, ref_, var2 = variance_ref(src_, ref_, params_.log2width, params_.log2height,
params_.log2width, params_.log2height, src_stride, ref_stride, &sse2, use_high_bit_depth(),
src_stride, ref_stride, &sse2, params_.bit_depth);
use_high_bit_depth(), params_.bit_depth);
EXPECT_EQ(sse1, sse2) << "Error at test index: " << i; EXPECT_EQ(sse1, sse2) << "Error at test index: " << i;
EXPECT_EQ(var1, var2) << "Error at test index: " << i; EXPECT_EQ(var1, var2) << "Error at test index: " << i;
} }
} }
template<typename VarianceFunctionType> template <typename VarianceFunctionType>
void MainTestClass<VarianceFunctionType>::OneQuarterTest() { void MainTestClass<VarianceFunctionType>::OneQuarterTest() {
const int half = block_size() / 2; const int half = block_size() / 2;
if (!use_high_bit_depth()) { if (!use_high_bit_depth()) {
@ -486,7 +474,7 @@ void MainTestClass<VarianceFunctionType>::OneQuarterTest() {
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// Tests related to MSE / SSE. // Tests related to MSE / SSE.
template<typename FunctionType> template <typename FunctionType>
void MainTestClass<FunctionType>::RefTestMse() { void MainTestClass<FunctionType>::RefTestMse() {
for (int i = 0; i < 10; ++i) { for (int i = 0; i < 10; ++i) {
for (int j = 0; j < block_size(); ++j) { for (int j = 0; j < block_size(); ++j) {
@ -496,13 +484,13 @@ void MainTestClass<FunctionType>::RefTestMse() {
unsigned int sse1, sse2; unsigned int sse1, sse2;
const int stride = width(); const int stride = width();
ASM_REGISTER_STATE_CHECK(params_.func(src_, stride, ref_, stride, &sse1)); ASM_REGISTER_STATE_CHECK(params_.func(src_, stride, ref_, stride, &sse1));
variance_ref(src_, ref_, params_.log2width, params_.log2height, variance_ref(src_, ref_, params_.log2width, params_.log2height, stride,
stride, stride, &sse2, false, VPX_BITS_8); stride, &sse2, false, VPX_BITS_8);
EXPECT_EQ(sse1, sse2); EXPECT_EQ(sse1, sse2);
} }
} }
template<typename FunctionType> template <typename FunctionType>
void MainTestClass<FunctionType>::RefTestSse() { void MainTestClass<FunctionType>::RefTestSse() {
for (int i = 0; i < 10; ++i) { for (int i = 0; i < 10; ++i) {
for (int j = 0; j < block_size(); ++j) { for (int j = 0; j < block_size(); ++j) {
@ -513,13 +501,13 @@ void MainTestClass<FunctionType>::RefTestSse() {
unsigned int var1; unsigned int var1;
const int stride = width(); const int stride = width();
ASM_REGISTER_STATE_CHECK(var1 = params_.func(src_, stride, ref_, stride)); ASM_REGISTER_STATE_CHECK(var1 = params_.func(src_, stride, ref_, stride));
variance_ref(src_, ref_, params_.log2width, params_.log2height, variance_ref(src_, ref_, params_.log2width, params_.log2height, stride,
stride, stride, &sse2, false, VPX_BITS_8); stride, &sse2, false, VPX_BITS_8);
EXPECT_EQ(var1, sse2); EXPECT_EQ(var1, sse2);
} }
} }
template<typename FunctionType> template <typename FunctionType>
void MainTestClass<FunctionType>::MaxTestMse() { void MainTestClass<FunctionType>::MaxTestMse() {
memset(src_, 255, block_size()); memset(src_, 255, block_size());
memset(ref_, 0, block_size()); memset(ref_, 0, block_size());
@ -529,7 +517,7 @@ void MainTestClass<FunctionType>::MaxTestMse() {
EXPECT_EQ(expected, sse); EXPECT_EQ(expected, sse);
} }
template<typename FunctionType> template <typename FunctionType>
void MainTestClass<FunctionType>::MaxTestSse() { void MainTestClass<FunctionType>::MaxTestSse() {
memset(src_, 255, block_size()); memset(src_, 255, block_size());
memset(ref_, 0, block_size()); memset(ref_, 0, block_size());
@ -545,27 +533,27 @@ using ::std::tr1::get;
using ::std::tr1::make_tuple; using ::std::tr1::make_tuple;
using ::std::tr1::tuple; using ::std::tr1::tuple;
template<typename SubpelVarianceFunctionType> template <typename SubpelVarianceFunctionType>
class SubpelVarianceTest class SubpelVarianceTest
: public ::testing::TestWithParam<tuple<int, int, : public ::testing::TestWithParam<
SubpelVarianceFunctionType, int> > { tuple<int, int, SubpelVarianceFunctionType, int> > {
public: public:
virtual void SetUp() { virtual void SetUp() {
const tuple<int, int, SubpelVarianceFunctionType, int>& params = const tuple<int, int, SubpelVarianceFunctionType, int> &params =
this->GetParam(); this->GetParam();
log2width_ = get<0>(params); log2width_ = get<0>(params);
width_ = 1 << log2width_; width_ = 1 << log2width_;
log2height_ = get<1>(params); log2height_ = get<1>(params);
height_ = 1 << log2height_; height_ = 1 << log2height_;
subpel_variance_ = get<2>(params); subpel_variance_ = get<2>(params);
if (get<3>(params)) { if (get<3>(params)) {
bit_depth_ = (vpx_bit_depth_t) get<3>(params); bit_depth_ = (vpx_bit_depth_t)get<3>(params);
use_high_bit_depth_ = true; use_high_bit_depth_ = true;
} else { } else {
bit_depth_ = VPX_BITS_8; bit_depth_ = VPX_BITS_8;
use_high_bit_depth_ = false; use_high_bit_depth_ = false;
} }
mask_ = (1 << bit_depth_)-1; mask_ = (1 << bit_depth_) - 1;
rnd_.Reset(ACMRandom::DeterministicSeed()); rnd_.Reset(ACMRandom::DeterministicSeed());
block_size_ = width_ * height_; block_size_ = width_ * height_;
@ -575,14 +563,12 @@ class SubpelVarianceTest
ref_ = new uint8_t[block_size_ + width_ + height_ + 1]; ref_ = new uint8_t[block_size_ + width_ + height_ + 1];
#if CONFIG_VP9_HIGHBITDEPTH #if CONFIG_VP9_HIGHBITDEPTH
} else { } else {
src_ = CONVERT_TO_BYTEPTR( src_ = CONVERT_TO_BYTEPTR(reinterpret_cast<uint16_t *>(
reinterpret_cast<uint16_t *>( vpx_memalign(16, block_size_ * sizeof(uint16_t))));
vpx_memalign(16, block_size_*sizeof(uint16_t)))); sec_ = CONVERT_TO_BYTEPTR(reinterpret_cast<uint16_t *>(
sec_ = CONVERT_TO_BYTEPTR( vpx_memalign(16, block_size_ * sizeof(uint16_t))));
reinterpret_cast<uint16_t *>( ref_ =
vpx_memalign(16, block_size_*sizeof(uint16_t)))); CONVERT_TO_BYTEPTR(new uint16_t[block_size_ + width_ + height_ + 1]);
ref_ = CONVERT_TO_BYTEPTR(
new uint16_t[block_size_ + width_ + height_ + 1]);
#endif // CONFIG_VP9_HIGHBITDEPTH #endif // CONFIG_VP9_HIGHBITDEPTH
} }
ASSERT_TRUE(src_ != NULL); ASSERT_TRUE(src_ != NULL);
@ -617,11 +603,11 @@ class SubpelVarianceTest
vpx_bit_depth_t bit_depth_; vpx_bit_depth_t bit_depth_;
int width_, log2width_; int width_, log2width_;
int height_, log2height_; int height_, log2height_;
int block_size_, mask_; int block_size_, mask_;
SubpelVarianceFunctionType subpel_variance_; SubpelVarianceFunctionType subpel_variance_;
}; };
template<typename SubpelVarianceFunctionType> template <typename SubpelVarianceFunctionType>
void SubpelVarianceTest<SubpelVarianceFunctionType>::RefTest() { void SubpelVarianceTest<SubpelVarianceFunctionType>::RefTest() {
for (int x = 0; x < 8; ++x) { for (int x = 0; x < 8; ++x) {
for (int y = 0; y < 8; ++y) { for (int y = 0; y < 8; ++y) {
@ -644,20 +630,18 @@ void SubpelVarianceTest<SubpelVarianceFunctionType>::RefTest() {
} }
unsigned int sse1, sse2; unsigned int sse1, sse2;
unsigned int var1; unsigned int var1;
ASM_REGISTER_STATE_CHECK(var1 = subpel_variance_(ref_, width_ + 1, x, y, ASM_REGISTER_STATE_CHECK(
src_, width_, &sse1)); var1 = subpel_variance_(ref_, width_ + 1, x, y, src_, width_, &sse1));
const unsigned int var2 = subpel_variance_ref(ref_, src_, const unsigned int var2 =
log2width_, log2height_, subpel_variance_ref(ref_, src_, log2width_, log2height_, x, y, &sse2,
x, y, &sse2, use_high_bit_depth_, bit_depth_);
use_high_bit_depth_,
bit_depth_);
EXPECT_EQ(sse1, sse2) << "at position " << x << ", " << y; EXPECT_EQ(sse1, sse2) << "at position " << x << ", " << y;
EXPECT_EQ(var1, var2) << "at position " << x << ", " << y; EXPECT_EQ(var1, var2) << "at position " << x << ", " << y;
} }
} }
} }
template<typename SubpelVarianceFunctionType> template <typename SubpelVarianceFunctionType>
void SubpelVarianceTest<SubpelVarianceFunctionType>::ExtremeRefTest() { void SubpelVarianceTest<SubpelVarianceFunctionType>::ExtremeRefTest() {
// Compare against reference. // Compare against reference.
// Src: Set the first half of values to 0, the second half to the maximum. // Src: Set the first half of values to 0, the second half to the maximum.
@ -684,15 +668,15 @@ void SubpelVarianceTest<SubpelVarianceFunctionType>::ExtremeRefTest() {
ASM_REGISTER_STATE_CHECK( ASM_REGISTER_STATE_CHECK(
var1 = subpel_variance_(ref_, width_ + 1, x, y, src_, width_, &sse1)); var1 = subpel_variance_(ref_, width_ + 1, x, y, src_, width_, &sse1));
const unsigned int var2 = const unsigned int var2 =
subpel_variance_ref(ref_, src_, log2width_, log2height_, subpel_variance_ref(ref_, src_, log2width_, log2height_, x, y, &sse2,
x, y, &sse2, use_high_bit_depth_, bit_depth_); use_high_bit_depth_, bit_depth_);
EXPECT_EQ(sse1, sse2) << "for xoffset " << x << " and yoffset " << y; EXPECT_EQ(sse1, sse2) << "for xoffset " << x << " and yoffset " << y;
EXPECT_EQ(var1, var2) << "for xoffset " << x << " and yoffset " << y; EXPECT_EQ(var1, var2) << "for xoffset " << x << " and yoffset " << y;
} }
} }
} }
template<> template <>
void SubpelVarianceTest<SubpixAvgVarMxNFunc>::RefTest() { void SubpelVarianceTest<SubpixAvgVarMxNFunc>::RefTest() {
for (int x = 0; x < 8; ++x) { for (int x = 0; x < 8; ++x) {
for (int y = 0; y < 8; ++y) { for (int y = 0; y < 8; ++y) {
@ -717,13 +701,11 @@ void SubpelVarianceTest<SubpixAvgVarMxNFunc>::RefTest() {
} }
uint32_t sse1, sse2; uint32_t sse1, sse2;
uint32_t var1, var2; uint32_t var1, var2;
ASM_REGISTER_STATE_CHECK( ASM_REGISTER_STATE_CHECK(var1 =
var1 = subpel_variance_(ref_, width_ + 1, x, y, subpel_variance_(ref_, width_ + 1, x, y,
src_, width_, &sse1, sec_)); src_, width_, &sse1, sec_));
var2 = subpel_avg_variance_ref(ref_, src_, sec_, var2 = subpel_avg_variance_ref(ref_, src_, sec_, log2width_, log2height_,
log2width_, log2height_, x, y, &sse2, use_high_bit_depth_,
x, y, &sse2,
use_high_bit_depth_,
static_cast<vpx_bit_depth_t>(bit_depth_)); static_cast<vpx_bit_depth_t>(bit_depth_));
EXPECT_EQ(sse1, sse2) << "at position " << x << ", " << y; EXPECT_EQ(sse1, sse2) << "at position " << x << ", " << y;
EXPECT_EQ(var1, var2) << "at position " << x << ", " << y; EXPECT_EQ(var1, var2) << "at position " << x << ", " << y;
@ -756,14 +738,15 @@ INSTANTIATE_TEST_CASE_P(C, SumOfSquaresTest,
typedef TestParams<Get4x4SseFunc> SseParams; typedef TestParams<Get4x4SseFunc> SseParams;
INSTANTIATE_TEST_CASE_P(C, VpxSseTest, INSTANTIATE_TEST_CASE_P(C, VpxSseTest,
::testing::Values(SseParams(2, 2, &vpx_get4x4sse_cs_c))); ::testing::Values(SseParams(2, 2,
&vpx_get4x4sse_cs_c)));
typedef TestParams<VarianceMxNFunc> MseParams; typedef TestParams<VarianceMxNFunc> MseParams;
INSTANTIATE_TEST_CASE_P(C, VpxMseTest, INSTANTIATE_TEST_CASE_P(C, VpxMseTest,
::testing::Values(MseParams(4, 4, &vpx_mse16x16_c), ::testing::Values(MseParams(4, 4, &vpx_mse16x16_c),
MseParams(4, 3, &vpx_mse16x8_c), MseParams(4, 3, &vpx_mse16x8_c),
MseParams(3, 4, &vpx_mse8x16_c), MseParams(3, 4, &vpx_mse8x16_c),
MseParams(3, 3, &vpx_mse8x8_c))); MseParams(3, 3, &vpx_mse8x8_c)));
typedef TestParams<VarianceMxNFunc> VarianceParams; typedef TestParams<VarianceMxNFunc> VarianceParams;
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
@ -818,8 +801,7 @@ INSTANTIATE_TEST_CASE_P(
typedef MainTestClass<VarianceMxNFunc> VpxHBDMseTest; typedef MainTestClass<VarianceMxNFunc> VpxHBDMseTest;
typedef MainTestClass<VarianceMxNFunc> VpxHBDVarianceTest; typedef MainTestClass<VarianceMxNFunc> VpxHBDVarianceTest;
typedef SubpelVarianceTest<SubpixVarMxNFunc> VpxHBDSubpelVarianceTest; typedef SubpelVarianceTest<SubpixVarMxNFunc> VpxHBDSubpelVarianceTest;
typedef SubpelVarianceTest<SubpixAvgVarMxNFunc> typedef SubpelVarianceTest<SubpixAvgVarMxNFunc> VpxHBDSubpelAvgVarianceTest;
VpxHBDSubpelAvgVarianceTest;
TEST_P(VpxHBDMseTest, RefMse) { RefTestMse(); } TEST_P(VpxHBDMseTest, RefMse) { RefTestMse(); }
TEST_P(VpxHBDMseTest, MaxMse) { MaxTestMse(); } TEST_P(VpxHBDMseTest, MaxMse) { MaxTestMse(); }
@ -982,10 +964,10 @@ INSTANTIATE_TEST_CASE_P(SSE2, SumOfSquaresTest,
::testing::Values(vpx_get_mb_ss_sse2)); ::testing::Values(vpx_get_mb_ss_sse2));
INSTANTIATE_TEST_CASE_P(SSE2, VpxMseTest, INSTANTIATE_TEST_CASE_P(SSE2, VpxMseTest,
::testing::Values(MseParams(4, 4, &vpx_mse16x16_sse2), ::testing::Values(MseParams(4, 4, &vpx_mse16x16_sse2),
MseParams(4, 3, &vpx_mse16x8_sse2), MseParams(4, 3, &vpx_mse16x8_sse2),
MseParams(3, 4, &vpx_mse8x16_sse2), MseParams(3, 4, &vpx_mse8x16_sse2),
MseParams(3, 3, &vpx_mse8x8_sse2))); MseParams(3, 3, &vpx_mse8x8_sse2)));
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
SSE2, VpxVarianceTest, SSE2, VpxVarianceTest,
@ -1055,37 +1037,38 @@ INSTANTIATE_TEST_CASE_P(
*/ */
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
SSE2, VpxHBDVarianceTest, ::testing::Values( SSE2, VpxHBDVarianceTest,
VarianceParams(6, 6, &vpx_highbd_12_variance64x64_sse2, 12), ::testing::Values(
VarianceParams(6, 5, &vpx_highbd_12_variance64x32_sse2, 12), VarianceParams(6, 6, &vpx_highbd_12_variance64x64_sse2, 12),
VarianceParams(5, 6, &vpx_highbd_12_variance32x64_sse2, 12), VarianceParams(6, 5, &vpx_highbd_12_variance64x32_sse2, 12),
VarianceParams(5, 5, &vpx_highbd_12_variance32x32_sse2, 12), VarianceParams(5, 6, &vpx_highbd_12_variance32x64_sse2, 12),
VarianceParams(5, 4, &vpx_highbd_12_variance32x16_sse2, 12), VarianceParams(5, 5, &vpx_highbd_12_variance32x32_sse2, 12),
VarianceParams(4, 5, &vpx_highbd_12_variance16x32_sse2, 12), VarianceParams(5, 4, &vpx_highbd_12_variance32x16_sse2, 12),
VarianceParams(4, 4, &vpx_highbd_12_variance16x16_sse2, 12), VarianceParams(4, 5, &vpx_highbd_12_variance16x32_sse2, 12),
VarianceParams(4, 3, &vpx_highbd_12_variance16x8_sse2, 12), VarianceParams(4, 4, &vpx_highbd_12_variance16x16_sse2, 12),
VarianceParams(3, 4, &vpx_highbd_12_variance8x16_sse2, 12), VarianceParams(4, 3, &vpx_highbd_12_variance16x8_sse2, 12),
VarianceParams(3, 3, &vpx_highbd_12_variance8x8_sse2, 12), VarianceParams(3, 4, &vpx_highbd_12_variance8x16_sse2, 12),
VarianceParams(6, 6, &vpx_highbd_10_variance64x64_sse2, 10), VarianceParams(3, 3, &vpx_highbd_12_variance8x8_sse2, 12),
VarianceParams(6, 5, &vpx_highbd_10_variance64x32_sse2, 10), VarianceParams(6, 6, &vpx_highbd_10_variance64x64_sse2, 10),
VarianceParams(5, 6, &vpx_highbd_10_variance32x64_sse2, 10), VarianceParams(6, 5, &vpx_highbd_10_variance64x32_sse2, 10),
VarianceParams(5, 5, &vpx_highbd_10_variance32x32_sse2, 10), VarianceParams(5, 6, &vpx_highbd_10_variance32x64_sse2, 10),
VarianceParams(5, 4, &vpx_highbd_10_variance32x16_sse2, 10), VarianceParams(5, 5, &vpx_highbd_10_variance32x32_sse2, 10),
VarianceParams(4, 5, &vpx_highbd_10_variance16x32_sse2, 10), VarianceParams(5, 4, &vpx_highbd_10_variance32x16_sse2, 10),
VarianceParams(4, 4, &vpx_highbd_10_variance16x16_sse2, 10), VarianceParams(4, 5, &vpx_highbd_10_variance16x32_sse2, 10),
VarianceParams(4, 3, &vpx_highbd_10_variance16x8_sse2, 10), VarianceParams(4, 4, &vpx_highbd_10_variance16x16_sse2, 10),
VarianceParams(3, 4, &vpx_highbd_10_variance8x16_sse2, 10), VarianceParams(4, 3, &vpx_highbd_10_variance16x8_sse2, 10),
VarianceParams(3, 3, &vpx_highbd_10_variance8x8_sse2, 10), VarianceParams(3, 4, &vpx_highbd_10_variance8x16_sse2, 10),
VarianceParams(6, 6, &vpx_highbd_8_variance64x64_sse2, 8), VarianceParams(3, 3, &vpx_highbd_10_variance8x8_sse2, 10),
VarianceParams(6, 5, &vpx_highbd_8_variance64x32_sse2, 8), VarianceParams(6, 6, &vpx_highbd_8_variance64x64_sse2, 8),
VarianceParams(5, 6, &vpx_highbd_8_variance32x64_sse2, 8), VarianceParams(6, 5, &vpx_highbd_8_variance64x32_sse2, 8),
VarianceParams(5, 5, &vpx_highbd_8_variance32x32_sse2, 8), VarianceParams(5, 6, &vpx_highbd_8_variance32x64_sse2, 8),
VarianceParams(5, 4, &vpx_highbd_8_variance32x16_sse2, 8), VarianceParams(5, 5, &vpx_highbd_8_variance32x32_sse2, 8),
VarianceParams(4, 5, &vpx_highbd_8_variance16x32_sse2, 8), VarianceParams(5, 4, &vpx_highbd_8_variance32x16_sse2, 8),
VarianceParams(4, 4, &vpx_highbd_8_variance16x16_sse2, 8), VarianceParams(4, 5, &vpx_highbd_8_variance16x32_sse2, 8),
VarianceParams(4, 3, &vpx_highbd_8_variance16x8_sse2, 8), VarianceParams(4, 4, &vpx_highbd_8_variance16x16_sse2, 8),
VarianceParams(3, 4, &vpx_highbd_8_variance8x16_sse2, 8), VarianceParams(4, 3, &vpx_highbd_8_variance16x8_sse2, 8),
VarianceParams(3, 3, &vpx_highbd_8_variance8x8_sse2, 8))); VarianceParams(3, 4, &vpx_highbd_8_variance8x16_sse2, 8),
VarianceParams(3, 3, &vpx_highbd_8_variance8x8_sse2, 8)));
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
SSE2, VpxHBDSubpelVarianceTest, SSE2, VpxHBDSubpelVarianceTest,
@ -1200,7 +1183,7 @@ INSTANTIATE_TEST_CASE_P(
#if HAVE_AVX2 #if HAVE_AVX2
INSTANTIATE_TEST_CASE_P(AVX2, VpxMseTest, INSTANTIATE_TEST_CASE_P(AVX2, VpxMseTest,
::testing::Values(MseParams(4, 4, &vpx_mse16x16_avx2))); ::testing::Values(MseParams(4, 4, &vpx_mse16x16_avx2)));
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
AVX2, VpxVarianceTest, AVX2, VpxVarianceTest,
@ -1224,7 +1207,8 @@ INSTANTIATE_TEST_CASE_P(
#if HAVE_MEDIA #if HAVE_MEDIA
INSTANTIATE_TEST_CASE_P(MEDIA, VpxMseTest, INSTANTIATE_TEST_CASE_P(MEDIA, VpxMseTest,
::testing::Values(MseParams(4, 4, &vpx_mse16x16_media))); ::testing::Values(MseParams(4, 4,
&vpx_mse16x16_media)));
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
MEDIA, VpxVarianceTest, MEDIA, VpxVarianceTest,
@ -1239,10 +1223,11 @@ INSTANTIATE_TEST_CASE_P(
#if HAVE_NEON #if HAVE_NEON
INSTANTIATE_TEST_CASE_P(NEON, VpxSseTest, INSTANTIATE_TEST_CASE_P(NEON, VpxSseTest,
::testing::Values(SseParams(2, 2, &vpx_get4x4sse_cs_neon))); ::testing::Values(SseParams(2, 2,
&vpx_get4x4sse_cs_neon)));
INSTANTIATE_TEST_CASE_P(NEON, VpxMseTest, INSTANTIATE_TEST_CASE_P(NEON, VpxMseTest,
::testing::Values(MseParams(4, 4, &vpx_mse16x16_neon))); ::testing::Values(MseParams(4, 4, &vpx_mse16x16_neon)));
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
NEON, VpxVarianceTest, NEON, VpxVarianceTest,
@ -1268,13 +1253,14 @@ INSTANTIATE_TEST_CASE_P(MSA, SumOfSquaresTest,
::testing::Values(vpx_get_mb_ss_msa)); ::testing::Values(vpx_get_mb_ss_msa));
INSTANTIATE_TEST_CASE_P(MSA, VpxSseTest, INSTANTIATE_TEST_CASE_P(MSA, VpxSseTest,
::testing::Values(SseParams(2, 2, &vpx_get4x4sse_cs_msa))); ::testing::Values(SseParams(2, 2,
&vpx_get4x4sse_cs_msa)));
INSTANTIATE_TEST_CASE_P(MSA, VpxMseTest, INSTANTIATE_TEST_CASE_P(MSA, VpxMseTest,
::testing::Values(MseParams(4, 4, &vpx_mse16x16_msa), ::testing::Values(MseParams(4, 4, &vpx_mse16x16_msa),
MseParams(4, 3, &vpx_mse16x8_msa), MseParams(4, 3, &vpx_mse16x8_msa),
MseParams(3, 4, &vpx_mse8x16_msa), MseParams(3, 4, &vpx_mse8x16_msa),
MseParams(3, 3, &vpx_mse8x8_msa))); MseParams(3, 3, &vpx_mse8x8_msa)));
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
MSA, VpxVarianceTest, MSA, VpxVarianceTest,

43
test/video_source.h
View File

@ -51,7 +51,7 @@ static std::string GetDataPath() {
#undef TO_STRING #undef TO_STRING
#undef STRINGIFY #undef STRINGIFY
inline FILE *OpenTestDataFile(const std::string& file_name) { inline FILE *OpenTestDataFile(const std::string &file_name) {
const std::string path_to_source = GetDataPath() + "/" + file_name; const std::string path_to_source = GetDataPath() + "/" + file_name;
return fopen(path_to_source.c_str(), "rb"); return fopen(path_to_source.c_str(), "rb");
} }
@ -76,21 +76,15 @@ static FILE *GetTempOutFile(std::string *file_name) {
class TempOutFile { class TempOutFile {
public: public:
TempOutFile() { TempOutFile() { file_ = GetTempOutFile(&file_name_); }
file_ = GetTempOutFile(&file_name_);
}
~TempOutFile() { ~TempOutFile() {
CloseFile(); CloseFile();
if (!file_name_.empty()) { if (!file_name_.empty()) {
EXPECT_EQ(0, remove(file_name_.c_str())); EXPECT_EQ(0, remove(file_name_.c_str()));
} }
} }
FILE *file() { FILE *file() { return file_; }
return file_; const std::string &file_name() { return file_name_; }
}
const std::string& file_name() {
return file_name_;
}
protected: protected:
void CloseFile() { void CloseFile() {
@ -134,14 +128,10 @@ class VideoSource {
virtual unsigned int limit() const = 0; virtual unsigned int limit() const = 0;
}; };
class DummyVideoSource : public VideoSource { class DummyVideoSource : public VideoSource {
public: public:
DummyVideoSource() DummyVideoSource()
: img_(NULL), : img_(NULL), limit_(100), width_(80), height_(64),
limit_(100),
width_(80),
height_(64),
format_(VPX_IMG_FMT_I420) { format_(VPX_IMG_FMT_I420) {
ReallocImage(); ReallocImage();
} }
@ -158,9 +148,7 @@ class DummyVideoSource : public VideoSource {
FillFrame(); FillFrame();
} }
virtual vpx_image_t *img() const { virtual vpx_image_t *img() const { return (frame_ < limit_) ? img_ : NULL; }
return (frame_ < limit_) ? img_ : NULL;
}
// Models a stream where Timebase = 1/FPS, so pts == frame. // Models a stream where Timebase = 1/FPS, so pts == frame.
virtual vpx_codec_pts_t pts() const { return frame_; } virtual vpx_codec_pts_t pts() const { return frame_; }
@ -168,7 +156,7 @@ class DummyVideoSource : public VideoSource {
virtual unsigned long duration() const { return 1; } virtual unsigned long duration() const { return 1; }
virtual vpx_rational_t timebase() const { virtual vpx_rational_t timebase() const {
const vpx_rational_t t = {1, 30}; const vpx_rational_t t = { 1, 30 };
return t; return t;
} }
@ -176,9 +164,7 @@ class DummyVideoSource : public VideoSource {
virtual unsigned int limit() const { return limit_; } virtual unsigned int limit() const { return limit_; }
void set_limit(unsigned int limit) { void set_limit(unsigned int limit) { limit_ = limit; }
limit_ = limit;
}
void SetSize(unsigned int width, unsigned int height) { void SetSize(unsigned int width, unsigned int height) {
if (width != width_ || height != height_) { if (width != width_ || height != height_) {
@ -196,7 +182,9 @@ class DummyVideoSource : public VideoSource {
} }
protected: protected:
virtual void FillFrame() { if (img_) memset(img_->img_data, 0, raw_sz_); } virtual void FillFrame() {
if (img_) memset(img_->img_data, 0, raw_sz_);
}
void ReallocImage() { void ReallocImage() {
vpx_img_free(img_); vpx_img_free(img_);
@ -205,7 +193,7 @@ class DummyVideoSource : public VideoSource {
} }
vpx_image_t *img_; vpx_image_t *img_;
size_t raw_sz_; size_t raw_sz_;
unsigned int limit_; unsigned int limit_;
unsigned int frame_; unsigned int frame_;
unsigned int width_; unsigned int width_;
@ -213,12 +201,10 @@ class DummyVideoSource : public VideoSource {
vpx_img_fmt_t format_; vpx_img_fmt_t format_;
}; };
class RandomVideoSource : public DummyVideoSource { class RandomVideoSource : public DummyVideoSource {
public: public:
RandomVideoSource(int seed = ACMRandom::DeterministicSeed()) RandomVideoSource(int seed = ACMRandom::DeterministicSeed())
: rnd_(seed), : rnd_(seed), seed_(seed) {}
seed_(seed) { }
protected: protected:
// Reset the RNG to get a matching stream for the second pass // Reset the RNG to get a matching stream for the second pass
@ -233,8 +219,7 @@ class RandomVideoSource : public DummyVideoSource {
virtual void FillFrame() { virtual void FillFrame() {
if (img_) { if (img_) {
if (frame_ % 30 < 15) if (frame_ % 30 < 15)
for (size_t i = 0; i < raw_sz_; ++i) for (size_t i = 0; i < raw_sz_; ++i) img_->img_data[i] = rnd_.Rand8();
img_->img_data[i] = rnd_.Rand8();
else else
memset(img_->img_data, 0, raw_sz_); memset(img_->img_data, 0, raw_sz_);
} }

19
test/vp8_boolcoder_test.cc
View File

@ -8,7 +8,6 @@
* be found in the AUTHORS file in the root of the source tree. * be found in the AUTHORS file in the root of the source tree.
*/ */
#include <math.h> #include <math.h>
#include <stddef.h> #include <stddef.h>
#include <stdio.h> #include <stdio.h>
@ -41,9 +40,9 @@ void encrypt_buffer(uint8_t *buffer, size_t size) {
} }
} }
void test_decrypt_cb(void *decrypt_state, const uint8_t *input, void test_decrypt_cb(void *decrypt_state, const uint8_t *input, uint8_t *output,
uint8_t *output, int count) { int count) {
const size_t offset = input - reinterpret_cast<uint8_t*>(decrypt_state); const size_t offset = input - reinterpret_cast<uint8_t *>(decrypt_state);
for (int i = 0; i < count; i++) { for (int i = 0; i < count; i++) {
output[i] = input[i] ^ secret_key[(offset + i) & 15]; output[i] = input[i] ^ secret_key[(offset + i) & 15];
} }
@ -56,12 +55,13 @@ using libvpx_test::ACMRandom;
TEST(VP8, TestBitIO) { TEST(VP8, TestBitIO) {
ACMRandom rnd(ACMRandom::DeterministicSeed()); ACMRandom rnd(ACMRandom::DeterministicSeed());
for (int n = 0; n < num_tests; ++n) { for (int n = 0; n < num_tests; ++n) {
for (int method = 0; method <= 7; ++method) { // we generate various proba for (int method = 0; method <= 7; ++method) { // we generate various proba
const int kBitsToTest = 1000; const int kBitsToTest = 1000;
uint8_t probas[kBitsToTest]; uint8_t probas[kBitsToTest];
for (int i = 0; i < kBitsToTest; ++i) { for (int i = 0; i < kBitsToTest; ++i) {
const int parity = i & 1; const int parity = i & 1;
/* clang-format off */
probas[i] = probas[i] =
(method == 0) ? 0 : (method == 1) ? 255 : (method == 0) ? 0 : (method == 1) ? 255 :
(method == 2) ? 128 : (method == 2) ? 128 :
@ -72,6 +72,7 @@ TEST(VP8, TestBitIO) {
(method == 6) ? (method == 6) ?
(parity ? rnd(64) : 255 - rnd(64)) : (parity ? rnd(64) : 255 - rnd(64)) :
(parity ? rnd(32) : 255 - rnd(32)); (parity ? rnd(32) : 255 - rnd(32));
/* clang-format on */
} }
for (int bit_method = 0; bit_method <= 3; ++bit_method) { for (int bit_method = 0; bit_method <= 3; ++bit_method) {
const int random_seed = 6432; const int random_seed = 6432;
@ -95,8 +96,7 @@ TEST(VP8, TestBitIO) {
BOOL_DECODER br; BOOL_DECODER br;
encrypt_buffer(bw_buffer, kBufferSize); encrypt_buffer(bw_buffer, kBufferSize);
vp8dx_start_decode(&br, bw_buffer, kBufferSize, vp8dx_start_decode(&br, bw_buffer, kBufferSize, test_decrypt_cb,
test_decrypt_cb,
reinterpret_cast<void *>(bw_buffer)); reinterpret_cast<void *>(bw_buffer));
bit_rnd.Reset(random_seed); bit_rnd.Reset(random_seed);
for (int i = 0; i < kBitsToTest; ++i) { for (int i = 0; i < kBitsToTest; ++i) {
@ -106,9 +106,8 @@ TEST(VP8, TestBitIO) {
bit = bit_rnd(2); bit = bit_rnd(2);
} }
GTEST_ASSERT_EQ(vp8dx_decode_bool(&br, probas[i]), bit) GTEST_ASSERT_EQ(vp8dx_decode_bool(&br, probas[i]), bit)
<< "pos: "<< i << " / " << kBitsToTest << "pos: " << i << " / " << kBitsToTest
<< " bit_method: " << bit_method << " bit_method: " << bit_method << " method: " << method;
<< " method: " << method;
} }
} }
} }

10
test/vp8_decrypt_test.cc
View File

@ -21,10 +21,8 @@ namespace {
// with whatever internal state the decryptor uses. For testing we'll just // with whatever internal state the decryptor uses. For testing we'll just
// xor with a constant key, and decrypt_state will point to the start of // xor with a constant key, and decrypt_state will point to the start of
// the original buffer. // the original buffer.
const uint8_t test_key[16] = { const uint8_t test_key[16] = { 0x01, 0x12, 0x23, 0x34, 0x45, 0x56, 0x67, 0x78,
0x01, 0x12, 0x23, 0x34, 0x45, 0x56, 0x67, 0x78, 0x89, 0x9a, 0xab, 0xbc, 0xcd, 0xde, 0xef, 0xf0 };
0x89, 0x9a, 0xab, 0xbc, 0xcd, 0xde, 0xef, 0xf0
};
void encrypt_buffer(const uint8_t *src, uint8_t *dst, size_t size, void encrypt_buffer(const uint8_t *src, uint8_t *dst, size_t size,
ptrdiff_t offset) { ptrdiff_t offset) {
@ -33,8 +31,8 @@ void encrypt_buffer(const uint8_t *src, uint8_t *dst, size_t size,
} }
} }
void test_decrypt_cb(void *decrypt_state, const uint8_t *input, void test_decrypt_cb(void *decrypt_state, const uint8_t *input, uint8_t *output,
uint8_t *output, int count) { int count) {
encrypt_buffer(input, output, count, encrypt_buffer(input, output, count,
input - reinterpret_cast<uint8_t *>(decrypt_state)); input - reinterpret_cast<uint8_t *>(decrypt_state));
} }

8
test/vp8_denoiser_sse2_test.cc
View File

@ -32,9 +32,7 @@ class VP8DenoiserTest : public ::testing::TestWithParam<int> {
public: public:
virtual ~VP8DenoiserTest() {} virtual ~VP8DenoiserTest() {}
virtual void SetUp() { virtual void SetUp() { increase_denoising_ = GetParam(); }
increase_denoising_ = GetParam();
}
virtual void TearDown() { libvpx_test::ClearSystemState(); } virtual void TearDown() { libvpx_test::ClearSystemState(); }
@ -71,8 +69,8 @@ TEST_P(VP8DenoiserTest, BitexactCheck) {
sig_block_sse2[j] = sig_block_c[j] = rnd.Rand8(); sig_block_sse2[j] = sig_block_c[j] = rnd.Rand8();
// The pixels in mc_avg_block are generated by adding a random // The pixels in mc_avg_block are generated by adding a random
// number in range [-19, 19] to corresponding pixels in sig_block. // number in range [-19, 19] to corresponding pixels in sig_block.
temp = sig_block_c[j] + (rnd.Rand8() % 2 == 0 ? -1 : 1) * temp =
(rnd.Rand8() % 20); sig_block_c[j] + (rnd.Rand8() % 2 == 0 ? -1 : 1) * (rnd.Rand8() % 20);
// Clip. // Clip.
mc_avg_block[j] = (temp < 0) ? 0 : ((temp > 255) ? 255 : temp); mc_avg_block[j] = (temp < 0) ? 0 : ((temp > 255) ? 255 : temp);
} }

23
test/vp8_fdct4x4_test.cc
View File

@ -95,11 +95,12 @@ TEST(VP8FdctTest, SignBiasCheck) {
bool bias_acceptable = true; bool bias_acceptable = true;
for (int j = 0; j < 16; ++j) for (int j = 0; j < 16; ++j)
bias_acceptable = bias_acceptable && bias_acceptable =
(abs(count_sign_block[j][0] - count_sign_block[j][1]) < 10000); bias_acceptable &&
(abs(count_sign_block[j][0] - count_sign_block[j][1]) < 10000);
EXPECT_EQ(true, bias_acceptable) EXPECT_EQ(true, bias_acceptable)
<< "Error: 4x4 FDCT has a sign bias > 1% for input range [-255, 255]"; << "Error: 4x4 FDCT has a sign bias > 1% for input range [-255, 255]";
memset(count_sign_block, 0, sizeof(count_sign_block)); memset(count_sign_block, 0, sizeof(count_sign_block));
@ -120,11 +121,12 @@ TEST(VP8FdctTest, SignBiasCheck) {
bias_acceptable = true; bias_acceptable = true;
for (int j = 0; j < 16; ++j) for (int j = 0; j < 16; ++j)
bias_acceptable = bias_acceptable && bias_acceptable =
(abs(count_sign_block[j][0] - count_sign_block[j][1]) < 100000); bias_acceptable &&
(abs(count_sign_block[j][0] - count_sign_block[j][1]) < 100000);
EXPECT_EQ(true, bias_acceptable) EXPECT_EQ(true, bias_acceptable)
<< "Error: 4x4 FDCT has a sign bias > 10% for input range [-15, 15]"; << "Error: 4x4 FDCT has a sign bias > 10% for input range [-15, 15]";
}; };
TEST(VP8FdctTest, RoundTripErrorCheck) { TEST(VP8FdctTest, RoundTripErrorCheck) {
@ -148,17 +150,16 @@ TEST(VP8FdctTest, RoundTripErrorCheck) {
for (int j = 0; j < 16; ++j) { for (int j = 0; j < 16; ++j) {
const int diff = test_input_block[j] - test_output_block[j]; const int diff = test_input_block[j] - test_output_block[j];
const int error = diff * diff; const int error = diff * diff;
if (max_error < error) if (max_error < error) max_error = error;
max_error = error;
total_error += error; total_error += error;
} }
} }
EXPECT_GE(1, max_error ) EXPECT_GE(1, max_error)
<< "Error: FDCT/IDCT has an individual roundtrip error > 1"; << "Error: FDCT/IDCT has an individual roundtrip error > 1";
EXPECT_GE(count_test_block, total_error) EXPECT_GE(count_test_block, total_error)
<< "Error: FDCT/IDCT has average roundtrip error > 1 per block"; << "Error: FDCT/IDCT has average roundtrip error > 1 per block";
}; };
} // namespace } // namespace

5
test/vp8_fragments_test.cc
View File

@ -13,9 +13,8 @@
namespace { namespace {
class VP8FramgmentsTest class VP8FramgmentsTest : public ::libvpx_test::EncoderTest,
: public ::libvpx_test::EncoderTest, public ::testing::Test {
public ::testing::Test {
protected: protected:
VP8FramgmentsTest() : EncoderTest(&::libvpx_test::kVP8) {} VP8FramgmentsTest() : EncoderTest(&::libvpx_test::kVP8) {}
virtual ~VP8FramgmentsTest() {} virtual ~VP8FramgmentsTest() {}

78
test/vp9_arf_freq_test.cc
View File

@ -22,8 +22,8 @@ namespace {
const unsigned int kFrames = 100; const unsigned int kFrames = 100;
const int kBitrate = 500; const int kBitrate = 500;
#define ARF_NOT_SEEN 1000001 #define ARF_NOT_SEEN 1000001
#define ARF_SEEN_ONCE 1000000 #define ARF_SEEN_ONCE 1000000
typedef struct { typedef struct {
const char *filename; const char *filename;
@ -44,24 +44,20 @@ typedef struct {
const TestVideoParam kTestVectors[] = { const TestVideoParam kTestVectors[] = {
// artificially increase framerate to trigger default check // artificially increase framerate to trigger default check
{"hantro_collage_w352h288.yuv", 352, 288, 5000, 1, { "hantro_collage_w352h288.yuv", 352, 288, 5000, 1, 8, VPX_IMG_FMT_I420,
8, VPX_IMG_FMT_I420, VPX_BITS_8, 0}, VPX_BITS_8, 0 },
{"hantro_collage_w352h288.yuv", 352, 288, 30, 1, { "hantro_collage_w352h288.yuv", 352, 288, 30, 1, 8, VPX_IMG_FMT_I420,
8, VPX_IMG_FMT_I420, VPX_BITS_8, 0}, VPX_BITS_8, 0 },
{"rush_hour_444.y4m", 352, 288, 30, 1, { "rush_hour_444.y4m", 352, 288, 30, 1, 8, VPX_IMG_FMT_I444, VPX_BITS_8, 1 },
8, VPX_IMG_FMT_I444, VPX_BITS_8, 1},
#if CONFIG_VP9_HIGHBITDEPTH #if CONFIG_VP9_HIGHBITDEPTH
// Add list of profile 2/3 test videos here ... // Add list of profile 2/3 test videos here ...
#endif // CONFIG_VP9_HIGHBITDEPTH #endif // CONFIG_VP9_HIGHBITDEPTH
}; };
const TestEncodeParam kEncodeVectors[] = { const TestEncodeParam kEncodeVectors[] = {
{::libvpx_test::kOnePassGood, 2}, { ::libvpx_test::kOnePassGood, 2 }, { ::libvpx_test::kOnePassGood, 5 },
{::libvpx_test::kOnePassGood, 5}, { ::libvpx_test::kTwoPassGood, 1 }, { ::libvpx_test::kTwoPassGood, 2 },
{::libvpx_test::kTwoPassGood, 1}, { ::libvpx_test::kTwoPassGood, 5 }, { ::libvpx_test::kRealTime, 5 },
{::libvpx_test::kTwoPassGood, 2},
{::libvpx_test::kTwoPassGood, 5},
{::libvpx_test::kRealTime, 5},
}; };
const int kMinArfVectors[] = { const int kMinArfVectors[] = {
@ -80,15 +76,12 @@ int is_extension_y4m(const char *filename) {
class ArfFreqTest class ArfFreqTest
: public ::libvpx_test::EncoderTest, : public ::libvpx_test::EncoderTest,
public ::libvpx_test::CodecTestWith3Params<TestVideoParam, \ public ::libvpx_test::CodecTestWith3Params<TestVideoParam,
TestEncodeParam, int> { TestEncodeParam, int> {
protected: protected:
ArfFreqTest() ArfFreqTest()
: EncoderTest(GET_PARAM(0)), : EncoderTest(GET_PARAM(0)), test_video_param_(GET_PARAM(1)),
test_video_param_(GET_PARAM(1)), test_encode_param_(GET_PARAM(2)), min_arf_requested_(GET_PARAM(3)) {}
test_encode_param_(GET_PARAM(2)),
min_arf_requested_(GET_PARAM(3)) {
}
virtual ~ArfFreqTest() {} virtual ~ArfFreqTest() {}
@ -114,17 +107,16 @@ class ArfFreqTest
} }
int GetNumFramesInPkt(const vpx_codec_cx_pkt_t *pkt) { int GetNumFramesInPkt(const vpx_codec_cx_pkt_t *pkt) {
const uint8_t *buffer = reinterpret_cast<uint8_t*>(pkt->data.frame.buf); const uint8_t *buffer = reinterpret_cast<uint8_t *>(pkt->data.frame.buf);
const uint8_t marker = buffer[pkt->data.frame.sz - 1]; const uint8_t marker = buffer[pkt->data.frame.sz - 1];
const int mag = ((marker >> 3) & 3) + 1; const int mag = ((marker >> 3) & 3) + 1;
int frames = (marker & 0x7) + 1; int frames = (marker & 0x7) + 1;
const unsigned int index_sz = 2 + mag * frames; const unsigned int index_sz = 2 + mag * frames;
// Check for superframe or not. // Check for superframe or not.
// Assume superframe has only one visible frame, the rest being // Assume superframe has only one visible frame, the rest being
// invisible. If superframe index is not found, then there is only // invisible. If superframe index is not found, then there is only
// one frame. // one frame.
if (!((marker & 0xe0) == 0xc0 && if (!((marker & 0xe0) == 0xc0 && pkt->data.frame.sz >= index_sz &&
pkt->data.frame.sz >= index_sz &&
buffer[pkt->data.frame.sz - index_sz] == marker)) { buffer[pkt->data.frame.sz - index_sz] == marker)) {
frames = 1; frames = 1;
} }
@ -132,8 +124,7 @@ class ArfFreqTest
} }
virtual void FramePktHook(const vpx_codec_cx_pkt_t *pkt) { virtual void FramePktHook(const vpx_codec_cx_pkt_t *pkt) {
if (pkt->kind != VPX_CODEC_CX_FRAME_PKT) if (pkt->kind != VPX_CODEC_CX_FRAME_PKT) return;
return;
const int frames = GetNumFramesInPkt(pkt); const int frames = GetNumFramesInPkt(pkt);
if (frames == 1) { if (frames == 1) {
run_of_visible_frames_++; run_of_visible_frames_++;
@ -167,9 +158,7 @@ class ArfFreqTest
} }
} }
int GetMinVisibleRun() const { int GetMinVisibleRun() const { return min_run_; }
return min_run_;
}
int GetMinArfDistanceRequested() const { int GetMinArfDistanceRequested() const {
if (min_arf_requested_) if (min_arf_requested_)
@ -178,7 +167,7 @@ class ArfFreqTest
return vp9_rc_get_default_min_gf_interval( return vp9_rc_get_default_min_gf_interval(
test_video_param_.width, test_video_param_.height, test_video_param_.width, test_video_param_.height,
(double)test_video_param_.framerate_num / (double)test_video_param_.framerate_num /
test_video_param_.framerate_den); test_video_param_.framerate_den);
} }
TestVideoParam test_video_param_; TestVideoParam test_video_param_;
@ -197,21 +186,18 @@ TEST_P(ArfFreqTest, MinArfFreqTest) {
cfg_.g_input_bit_depth = test_video_param_.input_bit_depth; cfg_.g_input_bit_depth = test_video_param_.input_bit_depth;
cfg_.g_bit_depth = test_video_param_.bit_depth; cfg_.g_bit_depth = test_video_param_.bit_depth;
init_flags_ = VPX_CODEC_USE_PSNR; init_flags_ = VPX_CODEC_USE_PSNR;
if (cfg_.g_bit_depth > 8) if (cfg_.g_bit_depth > 8) init_flags_ |= VPX_CODEC_USE_HIGHBITDEPTH;
init_flags_ |= VPX_CODEC_USE_HIGHBITDEPTH;
testing::internal::scoped_ptr<libvpx_test::VideoSource> video; testing::internal::scoped_ptr<libvpx_test::VideoSource> video;
if (is_extension_y4m(test_video_param_.filename)) { if (is_extension_y4m(test_video_param_.filename)) {
video.reset(new libvpx_test::Y4mVideoSource(test_video_param_.filename, video.reset(new libvpx_test::Y4mVideoSource(test_video_param_.filename, 0,
0, kFrames)); kFrames));
} else { } else {
video.reset(new libvpx_test::YUVVideoSource(test_video_param_.filename, video.reset(new libvpx_test::YUVVideoSource(
test_video_param_.fmt, test_video_param_.filename, test_video_param_.fmt,
test_video_param_.width, test_video_param_.width, test_video_param_.height,
test_video_param_.height, test_video_param_.framerate_num, test_video_param_.framerate_den, 0,
test_video_param_.framerate_num, kFrames));
test_video_param_.framerate_den,
0, kFrames));
} }
ASSERT_NO_FATAL_FAILURE(RunLoop(video.get())); ASSERT_NO_FATAL_FAILURE(RunLoop(video.get()));
@ -223,9 +209,7 @@ TEST_P(ArfFreqTest, MinArfFreqTest) {
} }
} }
VP9_INSTANTIATE_TEST_CASE( VP9_INSTANTIATE_TEST_CASE(ArfFreqTest, ::testing::ValuesIn(kTestVectors),
ArfFreqTest, ::testing::ValuesIn(kEncodeVectors),
::testing::ValuesIn(kTestVectors), ::testing::ValuesIn(kMinArfVectors));
::testing::ValuesIn(kEncodeVectors),
::testing::ValuesIn(kMinArfVectors));
} // namespace } // namespace

7
test/vp9_boolcoder_test.cc
View File

@ -28,12 +28,13 @@ const int num_tests = 10;
TEST(VP9, TestBitIO) { TEST(VP9, TestBitIO) {
ACMRandom rnd(ACMRandom::DeterministicSeed()); ACMRandom rnd(ACMRandom::DeterministicSeed());
for (int n = 0; n < num_tests; ++n) { for (int n = 0; n < num_tests; ++n) {
for (int method = 0; method <= 7; ++method) { // we generate various proba for (int method = 0; method <= 7; ++method) { // we generate various proba
const int kBitsToTest = 1000; const int kBitsToTest = 1000;
uint8_t probas[kBitsToTest]; uint8_t probas[kBitsToTest];
for (int i = 0; i < kBitsToTest; ++i) { for (int i = 0; i < kBitsToTest; ++i) {
const int parity = i & 1; const int parity = i & 1;
/* clang-format off */
probas[i] = probas[i] =
(method == 0) ? 0 : (method == 1) ? 255 : (method == 0) ? 0 : (method == 1) ? 255 :
(method == 2) ? 128 : (method == 2) ? 128 :
@ -44,6 +45,7 @@ TEST(VP9, TestBitIO) {
(method == 6) ? (method == 6) ?
(parity ? rnd(64) : 255 - rnd(64)) : (parity ? rnd(64) : 255 - rnd(64)) :
(parity ? rnd(32) : 255 - rnd(32)); (parity ? rnd(32) : 255 - rnd(32));
/* clang-format on */
} }
for (int bit_method = 0; bit_method <= 3; ++bit_method) { for (int bit_method = 0; bit_method <= 3; ++bit_method) {
const int random_seed = 6432; const int random_seed = 6432;
@ -79,8 +81,7 @@ TEST(VP9, TestBitIO) {
} }
GTEST_ASSERT_EQ(vpx_read(&br, probas[i]), bit) GTEST_ASSERT_EQ(vpx_read(&br, probas[i]), bit)
<< "pos: " << i << " / " << kBitsToTest << "pos: " << i << " / " << kBitsToTest
<< " bit_method: " << bit_method << " bit_method: " << bit_method << " method: " << method;
<< " method: " << method;
} }
} }
} }

10
test/vp9_decrypt_test.cc
View File

@ -21,10 +21,8 @@ namespace {
// with whatever internal state the decryptor uses. For testing we'll just // with whatever internal state the decryptor uses. For testing we'll just
// xor with a constant key, and decrypt_state will point to the start of // xor with a constant key, and decrypt_state will point to the start of
// the original buffer. // the original buffer.
const uint8_t test_key[16] = { const uint8_t test_key[16] = { 0x01, 0x12, 0x23, 0x34, 0x45, 0x56, 0x67, 0x78,
0x01, 0x12, 0x23, 0x34, 0x45, 0x56, 0x67, 0x78, 0x89, 0x9a, 0xab, 0xbc, 0xcd, 0xde, 0xef, 0xf0 };
0x89, 0x9a, 0xab, 0xbc, 0xcd, 0xde, 0xef, 0xf0
};
void encrypt_buffer(const uint8_t *src, uint8_t *dst, size_t size, void encrypt_buffer(const uint8_t *src, uint8_t *dst, size_t size,
ptrdiff_t offset) { ptrdiff_t offset) {
@ -33,8 +31,8 @@ void encrypt_buffer(const uint8_t *src, uint8_t *dst, size_t size,
} }
} }
void test_decrypt_cb(void *decrypt_state, const uint8_t *input, void test_decrypt_cb(void *decrypt_state, const uint8_t *input, uint8_t *output,
uint8_t *output, int count) { int count) {
encrypt_buffer(input, output, count, encrypt_buffer(input, output, count,
input - reinterpret_cast<uint8_t *>(decrypt_state)); input - reinterpret_cast<uint8_t *>(decrypt_state));
} }

28
test/vp9_denoiser_sse2_test.cc
View File

@ -33,9 +33,7 @@ class VP9DenoiserTest : public ::testing::TestWithParam<BLOCK_SIZE> {
public: public:
virtual ~VP9DenoiserTest() {} virtual ~VP9DenoiserTest() {}
virtual void SetUp() { virtual void SetUp() { bs_ = GetParam(); }
bs_ = GetParam();
}
virtual void TearDown() { libvpx_test::ClearSystemState(); } virtual void TearDown() { libvpx_test::ClearSystemState(); }
@ -68,19 +66,19 @@ TEST_P(VP9DenoiserTest, BitexactCheck) {
sig_block[j] = rnd.Rand8(); sig_block[j] = rnd.Rand8();
// The pixels in mc_avg_block are generated by adding a random // The pixels in mc_avg_block are generated by adding a random
// number in range [-19, 19] to corresponding pixels in sig_block. // number in range [-19, 19] to corresponding pixels in sig_block.
temp = sig_block[j] + ((rnd.Rand8() % 2 == 0) ? -1 : 1) * temp =
(rnd.Rand8() % 20); sig_block[j] + ((rnd.Rand8() % 2 == 0) ? -1 : 1) * (rnd.Rand8() % 20);
// Clip. // Clip.
mc_avg_block[j] = (temp < 0) ? 0 : ((temp > 255) ? 255 : temp); mc_avg_block[j] = (temp < 0) ? 0 : ((temp > 255) ? 255 : temp);
} }
ASM_REGISTER_STATE_CHECK(vp9_denoiser_filter_c( ASM_REGISTER_STATE_CHECK(vp9_denoiser_filter_c(sig_block, 64, mc_avg_block,
sig_block, 64, mc_avg_block, 64, avg_block_c, 64, avg_block_c, 64, 0, bs_,
64, 0, bs_, motion_magnitude_random)); motion_magnitude_random));
ASM_REGISTER_STATE_CHECK(vp9_denoiser_filter_sse2( ASM_REGISTER_STATE_CHECK(vp9_denoiser_filter_sse2(
sig_block, 64, mc_avg_block, 64, avg_block_sse2, sig_block, 64, mc_avg_block, 64, avg_block_sse2, 64, 0, bs_,
64, 0, bs_, motion_magnitude_random)); motion_magnitude_random));
// Test bitexactness. // Test bitexactness.
for (int h = 0; h < (4 << b_height_log2_lookup[bs_]); ++h) { for (int h = 0; h < (4 << b_height_log2_lookup[bs_]); ++h) {
@ -92,9 +90,9 @@ TEST_P(VP9DenoiserTest, BitexactCheck) {
} }
// Test for all block size. // Test for all block size.
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(SSE2, VP9DenoiserTest,
SSE2, VP9DenoiserTest, ::testing::Values(BLOCK_8X8, BLOCK_8X16, BLOCK_16X8,
::testing::Values(BLOCK_8X8, BLOCK_8X16, BLOCK_16X8, BLOCK_16X16, BLOCK_16X16, BLOCK_16X32, BLOCK_32X16,
BLOCK_16X32, BLOCK_32X16, BLOCK_32X32, BLOCK_32X64, BLOCK_32X32, BLOCK_32X64, BLOCK_64X32,
BLOCK_64X32, BLOCK_64X64)); BLOCK_64X64));
} // namespace } // namespace

10
test/vp9_encoder_parms_get_to_decoder.cc
View File

@ -29,7 +29,7 @@ struct EncodePerfTestVideo {
}; };
const EncodePerfTestVideo kVP9EncodePerfTestVectors[] = { const EncodePerfTestVideo kVP9EncodePerfTestVectors[] = {
{"niklas_1280_720_30.y4m", 1280, 720, 600, 10}, { "niklas_1280_720_30.y4m", 1280, 720, 600, 10 },
}; };
struct EncodeParameters { struct EncodeParameters {
@ -45,10 +45,10 @@ struct EncodeParameters {
}; };
const EncodeParameters kVP9EncodeParameterSet[] = { const EncodeParameters kVP9EncodeParameterSet[] = {
{0, 0, 0, 1, 0, VPX_CR_STUDIO_RANGE, VPX_CS_BT_601, { 0, 0 }}, { 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, 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, 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 }}, { 0, 2, 0, 0, 1, VPX_CR_STUDIO_RANGE, VPX_CS_UNKNOWN, { 640, 480 } },
// TODO(JBB): Test profiles (requires more work). // TODO(JBB): Test profiles (requires more work).
}; };

81
test/vp9_end_to_end_test.cc
View File

@ -18,21 +18,17 @@
namespace { namespace {
const unsigned int kWidth = 160; const unsigned int kWidth = 160;
const unsigned int kHeight = 90; const unsigned int kHeight = 90;
const unsigned int kFramerate = 50; const unsigned int kFramerate = 50;
const unsigned int kFrames = 10; const unsigned int kFrames = 10;
const int kBitrate = 500; const int kBitrate = 500;
// List of psnr thresholds for speed settings 0-7 and 5 encoding modes // List of psnr thresholds for speed settings 0-7 and 5 encoding modes
const double kPsnrThreshold[][5] = { const double kPsnrThreshold[][5] = {
{ 36.0, 37.0, 37.0, 37.0, 37.0 }, { 36.0, 37.0, 37.0, 37.0, 37.0 }, { 35.0, 36.0, 36.0, 36.0, 36.0 },
{ 35.0, 36.0, 36.0, 36.0, 36.0 }, { 34.0, 35.0, 35.0, 35.0, 35.0 }, { 33.0, 34.0, 34.0, 34.0, 34.0 },
{ 34.0, 35.0, 35.0, 35.0, 35.0 }, { 32.0, 33.0, 33.0, 33.0, 33.0 }, { 31.0, 32.0, 32.0, 32.0, 32.0 },
{ 33.0, 34.0, 34.0, 34.0, 34.0 }, { 30.0, 31.0, 31.0, 31.0, 31.0 }, { 29.0, 30.0, 30.0, 30.0, 30.0 },
{ 32.0, 33.0, 33.0, 33.0, 33.0 },
{ 31.0, 32.0, 32.0, 32.0, 32.0 },
{ 30.0, 31.0, 31.0, 31.0, 31.0 },
{ 29.0, 30.0, 30.0, 30.0, 30.0 },
}; };
typedef struct { typedef struct {
@ -44,31 +40,30 @@ typedef struct {
} TestVideoParam; } TestVideoParam;
const TestVideoParam kTestVectors[] = { const TestVideoParam kTestVectors[] = {
{"park_joy_90p_8_420.y4m", 8, VPX_IMG_FMT_I420, VPX_BITS_8, 0}, { "park_joy_90p_8_420.y4m", 8, VPX_IMG_FMT_I420, VPX_BITS_8, 0 },
{"park_joy_90p_8_422.y4m", 8, VPX_IMG_FMT_I422, VPX_BITS_8, 1}, { "park_joy_90p_8_422.y4m", 8, VPX_IMG_FMT_I422, VPX_BITS_8, 1 },
{"park_joy_90p_8_444.y4m", 8, VPX_IMG_FMT_I444, VPX_BITS_8, 1}, { "park_joy_90p_8_444.y4m", 8, VPX_IMG_FMT_I444, VPX_BITS_8, 1 },
{"park_joy_90p_8_440.yuv", 8, VPX_IMG_FMT_I440, VPX_BITS_8, 1}, { "park_joy_90p_8_440.yuv", 8, VPX_IMG_FMT_I440, VPX_BITS_8, 1 },
#if CONFIG_VP9_HIGHBITDEPTH #if CONFIG_VP9_HIGHBITDEPTH
{"park_joy_90p_10_420.y4m", 10, VPX_IMG_FMT_I42016, VPX_BITS_10, 2}, { "park_joy_90p_10_420.y4m", 10, VPX_IMG_FMT_I42016, VPX_BITS_10, 2 },
{"park_joy_90p_10_422.y4m", 10, VPX_IMG_FMT_I42216, VPX_BITS_10, 3}, { "park_joy_90p_10_422.y4m", 10, VPX_IMG_FMT_I42216, VPX_BITS_10, 3 },
{"park_joy_90p_10_444.y4m", 10, VPX_IMG_FMT_I44416, VPX_BITS_10, 3}, { "park_joy_90p_10_444.y4m", 10, VPX_IMG_FMT_I44416, VPX_BITS_10, 3 },
{"park_joy_90p_10_440.yuv", 10, VPX_IMG_FMT_I44016, VPX_BITS_10, 3}, { "park_joy_90p_10_440.yuv", 10, VPX_IMG_FMT_I44016, VPX_BITS_10, 3 },
{"park_joy_90p_12_420.y4m", 12, VPX_IMG_FMT_I42016, VPX_BITS_12, 2}, { "park_joy_90p_12_420.y4m", 12, VPX_IMG_FMT_I42016, VPX_BITS_12, 2 },
{"park_joy_90p_12_422.y4m", 12, VPX_IMG_FMT_I42216, VPX_BITS_12, 3}, { "park_joy_90p_12_422.y4m", 12, VPX_IMG_FMT_I42216, VPX_BITS_12, 3 },
{"park_joy_90p_12_444.y4m", 12, VPX_IMG_FMT_I44416, VPX_BITS_12, 3}, { "park_joy_90p_12_444.y4m", 12, VPX_IMG_FMT_I44416, VPX_BITS_12, 3 },
{"park_joy_90p_12_440.yuv", 12, VPX_IMG_FMT_I44016, VPX_BITS_12, 3}, { "park_joy_90p_12_440.yuv", 12, VPX_IMG_FMT_I44016, VPX_BITS_12, 3 },
#endif // CONFIG_VP9_HIGHBITDEPTH #endif // CONFIG_VP9_HIGHBITDEPTH
}; };
// Encoding modes tested // Encoding modes tested
const libvpx_test::TestMode kEncodingModeVectors[] = { const libvpx_test::TestMode kEncodingModeVectors[] = {
::libvpx_test::kTwoPassGood, ::libvpx_test::kTwoPassGood, ::libvpx_test::kOnePassGood,
::libvpx_test::kOnePassGood,
::libvpx_test::kRealTime, ::libvpx_test::kRealTime,
}; };
// Speed settings tested // Speed settings tested
const int kCpuUsedVectors[] = {1, 2, 3, 5, 6}; const int kCpuUsedVectors[] = { 1, 2, 3, 5, 6 };
int is_extension_y4m(const char *filename) { int is_extension_y4m(const char *filename) {
const char *dot = strrchr(filename, '.'); const char *dot = strrchr(filename, '.');
@ -80,17 +75,13 @@ int is_extension_y4m(const char *filename) {
class EndToEndTestLarge class EndToEndTestLarge
: public ::libvpx_test::EncoderTest, : public ::libvpx_test::EncoderTest,
public ::libvpx_test::CodecTestWith3Params<libvpx_test::TestMode, \ public ::libvpx_test::CodecTestWith3Params<libvpx_test::TestMode,
TestVideoParam, int> { TestVideoParam, int> {
protected: protected:
EndToEndTestLarge() EndToEndTestLarge()
: EncoderTest(GET_PARAM(0)), : EncoderTest(GET_PARAM(0)), test_video_param_(GET_PARAM(2)),
test_video_param_(GET_PARAM(2)), cpu_used_(GET_PARAM(3)), psnr_(0.0), nframes_(0),
cpu_used_(GET_PARAM(3)), encoding_mode_(GET_PARAM(1)) {}
psnr_(0.0),
nframes_(0),
encoding_mode_(GET_PARAM(1)) {
}
virtual ~EndToEndTestLarge() {} virtual ~EndToEndTestLarge() {}
@ -136,8 +127,7 @@ class EndToEndTestLarge
} }
double GetAveragePsnr() const { double GetAveragePsnr() const {
if (nframes_) if (nframes_) return psnr_ / nframes_;
return psnr_ / nframes_;
return 0.0; return 0.0;
} }
@ -161,29 +151,26 @@ TEST_P(EndToEndTestLarge, EndtoEndPSNRTest) {
cfg_.g_input_bit_depth = test_video_param_.input_bit_depth; cfg_.g_input_bit_depth = test_video_param_.input_bit_depth;
cfg_.g_bit_depth = test_video_param_.bit_depth; cfg_.g_bit_depth = test_video_param_.bit_depth;
init_flags_ = VPX_CODEC_USE_PSNR; init_flags_ = VPX_CODEC_USE_PSNR;
if (cfg_.g_bit_depth > 8) if (cfg_.g_bit_depth > 8) init_flags_ |= VPX_CODEC_USE_HIGHBITDEPTH;
init_flags_ |= VPX_CODEC_USE_HIGHBITDEPTH;
libvpx_test::VideoSource *video; libvpx_test::VideoSource *video;
if (is_extension_y4m(test_video_param_.filename)) { if (is_extension_y4m(test_video_param_.filename)) {
video = new libvpx_test::Y4mVideoSource(test_video_param_.filename, video =
0, kFrames); new libvpx_test::Y4mVideoSource(test_video_param_.filename, 0, kFrames);
} else { } else {
video = new libvpx_test::YUVVideoSource(test_video_param_.filename, video = new libvpx_test::YUVVideoSource(test_video_param_.filename,
test_video_param_.fmt, test_video_param_.fmt, kWidth,
kWidth, kHeight, kHeight, kFramerate, 1, 0, kFrames);
kFramerate, 1, 0, kFrames);
} }
ASSERT_NO_FATAL_FAILURE(RunLoop(video)); ASSERT_NO_FATAL_FAILURE(RunLoop(video));
const double psnr = GetAveragePsnr(); const double psnr = GetAveragePsnr();
EXPECT_GT(psnr, GetPsnrThreshold()); EXPECT_GT(psnr, GetPsnrThreshold());
delete(video); delete (video);
} }
VP9_INSTANTIATE_TEST_CASE( VP9_INSTANTIATE_TEST_CASE(EndToEndTestLarge,
EndToEndTestLarge, ::testing::ValuesIn(kEncodingModeVectors),
::testing::ValuesIn(kEncodingModeVectors), ::testing::ValuesIn(kTestVectors),
::testing::ValuesIn(kTestVectors), ::testing::ValuesIn(kCpuUsedVectors));
::testing::ValuesIn(kCpuUsedVectors));
} // namespace } // namespace

54
test/vp9_error_block_test.cc
View File

@ -32,11 +32,10 @@ const int kNumIterations = 1000;
typedef int64_t (*ErrorBlockFunc)(const tran_low_t *coeff, typedef int64_t (*ErrorBlockFunc)(const tran_low_t *coeff,
const tran_low_t *dqcoeff, const tran_low_t *dqcoeff,
intptr_t block_size, intptr_t block_size, int64_t *ssz, int bps);
int64_t *ssz, int bps);
typedef std::tr1::tuple<ErrorBlockFunc, ErrorBlockFunc, vpx_bit_depth_t> typedef std::tr1::tuple<ErrorBlockFunc, ErrorBlockFunc, vpx_bit_depth_t>
ErrorBlockParam; ErrorBlockParam;
// wrapper for 8-bit block error functions without a 'bps' param. // wrapper for 8-bit block error functions without a 'bps' param.
typedef int64_t (*HighBdBlockError8bit)(const tran_low_t *coeff, typedef int64_t (*HighBdBlockError8bit)(const tran_low_t *coeff,
@ -51,14 +50,13 @@ int64_t HighBdBlockError8bitWrapper(const tran_low_t *coeff,
return fn(coeff, dqcoeff, block_size, ssz); return fn(coeff, dqcoeff, block_size, ssz);
} }
class ErrorBlockTest class ErrorBlockTest : public ::testing::TestWithParam<ErrorBlockParam> {
: public ::testing::TestWithParam<ErrorBlockParam> {
public: public:
virtual ~ErrorBlockTest() {} virtual ~ErrorBlockTest() {}
virtual void SetUp() { virtual void SetUp() {
error_block_op_ = GET_PARAM(0); error_block_op_ = GET_PARAM(0);
ref_error_block_op_ = GET_PARAM(1); ref_error_block_op_ = GET_PARAM(1);
bit_depth_ = GET_PARAM(2); bit_depth_ = GET_PARAM(2);
} }
virtual void TearDown() { libvpx_test::ClearSystemState(); } virtual void TearDown() { libvpx_test::ClearSystemState(); }
@ -89,18 +87,18 @@ TEST_P(ErrorBlockTest, OperationCheck) {
// can be used for optimization, so generate test input precisely. // can be used for optimization, so generate test input precisely.
if (rnd(2)) { if (rnd(2)) {
// Positive number // Positive number
coeff[j] = rnd(1 << msb); coeff[j] = rnd(1 << msb);
dqcoeff[j] = rnd(1 << msb); dqcoeff[j] = rnd(1 << msb);
} else { } else {
// Negative number // Negative number
coeff[j] = -rnd(1 << msb); coeff[j] = -rnd(1 << msb);
dqcoeff[j] = -rnd(1 << msb); dqcoeff[j] = -rnd(1 << msb);
} }
} }
ref_ret = ref_error_block_op_(coeff, dqcoeff, block_size, &ref_ssz, ref_ret =
bit_depth_); ref_error_block_op_(coeff, dqcoeff, block_size, &ref_ssz, bit_depth_);
ASM_REGISTER_STATE_CHECK(ret = error_block_op_(coeff, dqcoeff, block_size, ASM_REGISTER_STATE_CHECK(
&ssz, bit_depth_)); ret = error_block_op_(coeff, dqcoeff, block_size, &ssz, bit_depth_));
err_count += (ref_ret != ret) | (ref_ssz != ssz); err_count += (ref_ret != ret) | (ref_ssz != ssz);
if (err_count && !err_count_total) { if (err_count && !err_count_total) {
first_failure = i; first_failure = i;
@ -130,35 +128,35 @@ TEST_P(ErrorBlockTest, ExtremeValues) {
int k = (i / 9) % 9; int k = (i / 9) % 9;
// Change the maximum coeff value, to test different bit boundaries // Change the maximum coeff value, to test different bit boundaries
if ( k == 8 && (i % 9) == 0 ) { if (k == 8 && (i % 9) == 0) {
max_val >>= 1; max_val >>= 1;
} }
block_size = 16 << (i % 9); // All block sizes from 4x4, 8x4 ..64x64 block_size = 16 << (i % 9); // All block sizes from 4x4, 8x4 ..64x64
for (int j = 0; j < block_size; j++) { for (int j = 0; j < block_size; j++) {
if (k < 4) { if (k < 4) {
// Test at positive maximum values // Test at positive maximum values
coeff[j] = k % 2 ? max_val : 0; coeff[j] = k % 2 ? max_val : 0;
dqcoeff[j] = (k >> 1) % 2 ? max_val : 0; dqcoeff[j] = (k >> 1) % 2 ? max_val : 0;
} else if (k < 8) { } else if (k < 8) {
// Test at negative maximum values // Test at negative maximum values
coeff[j] = k % 2 ? -max_val : 0; coeff[j] = k % 2 ? -max_val : 0;
dqcoeff[j] = (k >> 1) % 2 ? -max_val : 0; dqcoeff[j] = (k >> 1) % 2 ? -max_val : 0;
} else { } else {
if (rnd(2)) { if (rnd(2)) {
// Positive number // Positive number
coeff[j] = rnd(1 << 14); coeff[j] = rnd(1 << 14);
dqcoeff[j] = rnd(1 << 14); dqcoeff[j] = rnd(1 << 14);
} else { } else {
// Negative number // Negative number
coeff[j] = -rnd(1 << 14); coeff[j] = -rnd(1 << 14);
dqcoeff[j] = -rnd(1 << 14); dqcoeff[j] = -rnd(1 << 14);
} }
} }
} }
ref_ret = ref_error_block_op_(coeff, dqcoeff, block_size, &ref_ssz, ref_ret =
bit_depth_); ref_error_block_op_(coeff, dqcoeff, block_size, &ref_ssz, bit_depth_);
ASM_REGISTER_STATE_CHECK(ret = error_block_op_(coeff, dqcoeff, block_size, ASM_REGISTER_STATE_CHECK(
&ssz, bit_depth_)); ret = error_block_op_(coeff, dqcoeff, block_size, &ssz, bit_depth_));
err_count += (ref_ret != ret) | (ref_ssz != ssz); err_count += (ref_ret != ret) | (ref_ssz != ssz);
if (err_count && !err_count_total) { if (err_count && !err_count_total) {
first_failure = i; first_failure = i;
@ -176,12 +174,12 @@ using std::tr1::make_tuple;
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
SSE2, ErrorBlockTest, SSE2, ErrorBlockTest,
::testing::Values( ::testing::Values(
make_tuple(&vp9_highbd_block_error_sse2, make_tuple(&vp9_highbd_block_error_sse2, &vp9_highbd_block_error_c,
&vp9_highbd_block_error_c, VPX_BITS_10), VPX_BITS_10),
make_tuple(&vp9_highbd_block_error_sse2, make_tuple(&vp9_highbd_block_error_sse2, &vp9_highbd_block_error_c,
&vp9_highbd_block_error_c, VPX_BITS_12), VPX_BITS_12),
make_tuple(&vp9_highbd_block_error_sse2, make_tuple(&vp9_highbd_block_error_sse2, &vp9_highbd_block_error_c,
&vp9_highbd_block_error_c, VPX_BITS_8), VPX_BITS_8),
make_tuple( make_tuple(
&HighBdBlockError8bitWrapper<vp9_highbd_block_error_8bit_sse2>, &HighBdBlockError8bitWrapper<vp9_highbd_block_error_8bit_sse2>,
&HighBdBlockError8bitWrapper<vp9_highbd_block_error_8bit_c>, &HighBdBlockError8bitWrapper<vp9_highbd_block_error_8bit_c>,

19
test/vp9_ethread_test.cc
View File

@ -23,11 +23,8 @@ class VPxEncoderThreadTest
public ::libvpx_test::CodecTestWith2Params<libvpx_test::TestMode, int> { public ::libvpx_test::CodecTestWith2Params<libvpx_test::TestMode, int> {
protected: protected:
VPxEncoderThreadTest() VPxEncoderThreadTest()
: EncoderTest(GET_PARAM(0)), : EncoderTest(GET_PARAM(0)), encoder_initialized_(false), tiles_(2),
encoder_initialized_(false), encoding_mode_(GET_PARAM(1)), set_cpu_used_(GET_PARAM(2)) {
tiles_(2),
encoding_mode_(GET_PARAM(1)),
set_cpu_used_(GET_PARAM(2)) {
init_flags_ = VPX_CODEC_USE_PSNR; init_flags_ = VPX_CODEC_USE_PSNR;
md5_.clear(); md5_.clear();
} }
@ -82,7 +79,7 @@ class VPxEncoderThreadTest
} }
virtual bool HandleDecodeResult(const vpx_codec_err_t res, virtual bool HandleDecodeResult(const vpx_codec_err_t res,
const libvpx_test::VideoSource& /*video*/, const libvpx_test::VideoSource & /*video*/,
libvpx_test::Decoder * /*decoder*/) { libvpx_test::Decoder * /*decoder*/) {
if (res != VPX_CODEC_OK) { if (res != VPX_CODEC_OK) {
EXPECT_EQ(VPX_CODEC_OK, res); EXPECT_EQ(VPX_CODEC_OK, res);
@ -123,9 +120,9 @@ TEST_P(VPxEncoderThreadTest, EncoderResultTest) {
ASSERT_EQ(single_thr_md5, multi_thr_md5); ASSERT_EQ(single_thr_md5, multi_thr_md5);
} }
VP9_INSTANTIATE_TEST_CASE( VP9_INSTANTIATE_TEST_CASE(VPxEncoderThreadTest,
VPxEncoderThreadTest, ::testing::Values(::libvpx_test::kTwoPassGood,
::testing::Values(::libvpx_test::kTwoPassGood, ::libvpx_test::kOnePassGood, ::libvpx_test::kOnePassGood,
::libvpx_test::kRealTime), ::libvpx_test::kRealTime),
::testing::Range(1, 9)); ::testing::Range(1, 9));
} // namespace } // namespace

31
test/vp9_frame_parallel_test.cc
View File

@ -46,7 +46,7 @@ string DecodeFileWithPause(const string &filename, int num_threads,
int in_frames = 0; int in_frames = 0;
int out_frames = 0; int out_frames = 0;
vpx_codec_dec_cfg_t cfg = {0}; vpx_codec_dec_cfg_t cfg = { 0 };
cfg.threads = num_threads; cfg.threads = num_threads;
vpx_codec_flags_t flags = 0; vpx_codec_flags_t flags = 0;
flags |= VPX_CODEC_USE_FRAME_THREADING; flags |= VPX_CODEC_USE_FRAME_THREADING;
@ -74,8 +74,7 @@ string DecodeFileWithPause(const string &filename, int num_threads,
} }
// Flush the decoder at the end of the video. // Flush the decoder at the end of the video.
if (!video.cxdata()) if (!video.cxdata()) decoder.DecodeFrame(NULL, 0);
decoder.DecodeFrame(NULL, 0);
libvpx_test::DxDataIterator dec_iter = decoder.GetDxData(); libvpx_test::DxDataIterator dec_iter = decoder.GetDxData();
const vpx_image_t *img; const vpx_image_t *img;
@ -87,8 +86,8 @@ string DecodeFileWithPause(const string &filename, int num_threads,
} }
} while (video.cxdata() != NULL); } while (video.cxdata() != NULL);
EXPECT_EQ(in_frames, out_frames) << EXPECT_EQ(in_frames, out_frames)
"Input frame count does not match output frame count"; << "Input frame count does not match output frame count";
return string(md5.Get()); return string(md5.Get());
} }
@ -108,12 +107,12 @@ TEST(VP9MultiThreadedFrameParallel, PauseSeekResume) {
// vp90-2-07-frame_parallel-1.webm is a 40 frame video file with // vp90-2-07-frame_parallel-1.webm is a 40 frame video file with
// one key frame for every ten frames. // one key frame for every ten frames.
static const PauseFileList files[] = { static const PauseFileList files[] = {
{ "vp90-2-07-frame_parallel-1.webm", { "vp90-2-07-frame_parallel-1.webm", "6ea7c3875d67252e7caf2bc6e75b36b1",
"6ea7c3875d67252e7caf2bc6e75b36b1", 6 }, 6 },
{ "vp90-2-07-frame_parallel-1.webm", { "vp90-2-07-frame_parallel-1.webm", "4bb634160c7356a8d7d4299b6dc83a45",
"4bb634160c7356a8d7d4299b6dc83a45", 12 }, 12 },
{ "vp90-2-07-frame_parallel-1.webm", { "vp90-2-07-frame_parallel-1.webm", "89772591e6ef461f9fa754f916c78ed8",
"89772591e6ef461f9fa754f916c78ed8", 26 }, 26 },
{ NULL, NULL, 0 }, { NULL, NULL, 0 },
}; };
DecodeFilesWithPause(files); DecodeFilesWithPause(files);
@ -155,8 +154,7 @@ string DecodeFile(const string &filename, int num_threads,
video.Next(); video.Next();
// Flush the decoder at the end of the video. // Flush the decoder at the end of the video.
if (!video.cxdata()) if (!video.cxdata()) decoder.DecodeFrame(NULL, 0);
decoder.DecodeFrame(NULL, 0);
libvpx_test::DxDataIterator dec_iter = decoder.GetDxData(); libvpx_test::DxDataIterator dec_iter = decoder.GetDxData();
const vpx_image_t *img; const vpx_image_t *img;
@ -168,8 +166,8 @@ string DecodeFile(const string &filename, int num_threads,
} }
} while (video.cxdata() != NULL); } while (video.cxdata() != NULL);
EXPECT_EQ(expected_frame_count, out_frames) << EXPECT_EQ(expected_frame_count, out_frames)
"Input frame count does not match expected output frame count"; << "Input frame count does not match expected output frame count";
return string(md5.Get()); return string(md5.Get());
} }
@ -209,8 +207,7 @@ TEST(VP9MultiThreadedFrameParallel, InvalidFileTest) {
TEST(VP9MultiThreadedFrameParallel, ValidFileTest) { TEST(VP9MultiThreadedFrameParallel, ValidFileTest) {
static const FileList files[] = { static const FileList files[] = {
#if CONFIG_VP9_HIGHBITDEPTH #if CONFIG_VP9_HIGHBITDEPTH
{ "vp92-2-20-10bit-yuv420.webm", { "vp92-2-20-10bit-yuv420.webm", "a16b99df180c584e8db2ffeda987d293", 10 },
"a16b99df180c584e8db2ffeda987d293", 10 },
#endif #endif
{ NULL, NULL, 0 }, { NULL, NULL, 0 },
}; };

181
test/vp9_intrapred_test.cc
View File

@ -28,15 +28,14 @@ using libvpx_test::ACMRandom;
const int count_test_block = 100000; const int count_test_block = 100000;
typedef void (*IntraPred)(uint16_t* dst, ptrdiff_t stride, typedef void (*IntraPred)(uint16_t *dst, ptrdiff_t stride,
const uint16_t* above, const uint16_t* left, const uint16_t *above, const uint16_t *left, int bps);
int bps);
struct IntraPredFunc { struct IntraPredFunc {
IntraPredFunc(IntraPred pred = NULL, IntraPred ref = NULL, IntraPredFunc(IntraPred pred = NULL, IntraPred ref = NULL,
int block_size_value = 0, int bit_depth_value = 0) int block_size_value = 0, int bit_depth_value = 0)
: pred_fn(pred), ref_fn(ref), : pred_fn(pred), ref_fn(ref), block_size(block_size_value),
block_size(block_size_value), bit_depth(bit_depth_value) {} bit_depth(bit_depth_value) {}
IntraPred pred_fn; IntraPred pred_fn;
IntraPred ref_fn; IntraPred ref_fn;
@ -46,8 +45,8 @@ struct IntraPredFunc {
class VP9IntraPredTest : public ::testing::TestWithParam<IntraPredFunc> { class VP9IntraPredTest : public ::testing::TestWithParam<IntraPredFunc> {
public: public:
void RunTest(uint16_t* left_col, uint16_t* above_data, void RunTest(uint16_t *left_col, uint16_t *above_data, uint16_t *dst,
uint16_t* dst, uint16_t* ref_dst) { uint16_t *ref_dst) {
ACMRandom rnd(ACMRandom::DeterministicSeed()); ACMRandom rnd(ACMRandom::DeterministicSeed());
const int block_size = params_.block_size; const int block_size = params_.block_size;
above_row_ = above_data + 16; above_row_ = above_data + 16;
@ -81,14 +80,14 @@ class VP9IntraPredTest : public ::testing::TestWithParam<IntraPredFunc> {
virtual void SetUp() { virtual void SetUp() {
params_ = GetParam(); params_ = GetParam();
stride_ = params_.block_size * 3; stride_ = params_.block_size * 3;
mask_ = (1 << params_.bit_depth) - 1; mask_ = (1 << params_.bit_depth) - 1;
} }
void Predict() { void Predict() {
const int bit_depth = params_.bit_depth; const int bit_depth = params_.bit_depth;
params_.ref_fn(ref_dst_, stride_, above_row_, left_col_, bit_depth); params_.ref_fn(ref_dst_, stride_, above_row_, left_col_, bit_depth);
ASM_REGISTER_STATE_CHECK(params_.pred_fn(dst_, stride_, ASM_REGISTER_STATE_CHECK(
above_row_, left_col_, bit_depth)); params_.pred_fn(dst_, stride_, above_row_, left_col_, bit_depth));
} }
void CheckPrediction(int test_case_number, int *error_count) const { void CheckPrediction(int test_case_number, int *error_count) const {
@ -99,7 +98,7 @@ class VP9IntraPredTest : public ::testing::TestWithParam<IntraPredFunc> {
*error_count += ref_dst_[x + y * stride_] != dst_[x + y * stride_]; *error_count += ref_dst_[x + y * stride_] != dst_[x + y * stride_];
if (*error_count == 1) { if (*error_count == 1) {
ASSERT_EQ(ref_dst_[x + y * stride_], dst_[x + y * stride_]) ASSERT_EQ(ref_dst_[x + y * stride_], dst_[x + y * stride_])
<< " Failed on Test Case Number "<< test_case_number; << " Failed on Test Case Number " << test_case_number;
} }
} }
} }
@ -117,8 +116,8 @@ class VP9IntraPredTest : public ::testing::TestWithParam<IntraPredFunc> {
TEST_P(VP9IntraPredTest, IntraPredTests) { TEST_P(VP9IntraPredTest, IntraPredTests) {
// max block size is 32 // max block size is 32
DECLARE_ALIGNED(16, uint16_t, left_col[2*32]); DECLARE_ALIGNED(16, uint16_t, left_col[2 * 32]);
DECLARE_ALIGNED(16, uint16_t, above_data[2*32+32]); DECLARE_ALIGNED(16, uint16_t, above_data[2 * 32 + 32]);
DECLARE_ALIGNED(16, uint16_t, dst[3 * 32 * 32]); DECLARE_ALIGNED(16, uint16_t, dst[3 * 32 * 32]);
DECLARE_ALIGNED(16, uint16_t, ref_dst[3 * 32 * 32]); DECLARE_ALIGNED(16, uint16_t, ref_dst[3 * 32 * 32]);
RunTest(left_col, above_data, dst, ref_dst); RunTest(left_col, above_data, dst, ref_dst);
@ -126,86 +125,86 @@ TEST_P(VP9IntraPredTest, IntraPredTests) {
#if HAVE_SSE2 #if HAVE_SSE2
#if CONFIG_VP9_HIGHBITDEPTH #if CONFIG_VP9_HIGHBITDEPTH
INSTANTIATE_TEST_CASE_P(SSE2_TO_C_8, VP9IntraPredTest, INSTANTIATE_TEST_CASE_P(
::testing::Values( SSE2_TO_C_8, VP9IntraPredTest,
IntraPredFunc(&vpx_highbd_dc_predictor_32x32_sse2, ::testing::Values(IntraPredFunc(&vpx_highbd_dc_predictor_32x32_sse2,
&vpx_highbd_dc_predictor_32x32_c, 32, 8), &vpx_highbd_dc_predictor_32x32_c, 32, 8),
IntraPredFunc(&vpx_highbd_tm_predictor_16x16_sse2, IntraPredFunc(&vpx_highbd_tm_predictor_16x16_sse2,
&vpx_highbd_tm_predictor_16x16_c, 16, 8), &vpx_highbd_tm_predictor_16x16_c, 16, 8),
IntraPredFunc(&vpx_highbd_tm_predictor_32x32_sse2, IntraPredFunc(&vpx_highbd_tm_predictor_32x32_sse2,
&vpx_highbd_tm_predictor_32x32_c, 32, 8), &vpx_highbd_tm_predictor_32x32_c, 32, 8),
IntraPredFunc(&vpx_highbd_dc_predictor_4x4_sse2, IntraPredFunc(&vpx_highbd_dc_predictor_4x4_sse2,
&vpx_highbd_dc_predictor_4x4_c, 4, 8), &vpx_highbd_dc_predictor_4x4_c, 4, 8),
IntraPredFunc(&vpx_highbd_dc_predictor_8x8_sse2, IntraPredFunc(&vpx_highbd_dc_predictor_8x8_sse2,
&vpx_highbd_dc_predictor_8x8_c, 8, 8), &vpx_highbd_dc_predictor_8x8_c, 8, 8),
IntraPredFunc(&vpx_highbd_dc_predictor_16x16_sse2, IntraPredFunc(&vpx_highbd_dc_predictor_16x16_sse2,
&vpx_highbd_dc_predictor_16x16_c, 16, 8), &vpx_highbd_dc_predictor_16x16_c, 16, 8),
IntraPredFunc(&vpx_highbd_v_predictor_4x4_sse2, IntraPredFunc(&vpx_highbd_v_predictor_4x4_sse2,
&vpx_highbd_v_predictor_4x4_c, 4, 8), &vpx_highbd_v_predictor_4x4_c, 4, 8),
IntraPredFunc(&vpx_highbd_v_predictor_8x8_sse2, IntraPredFunc(&vpx_highbd_v_predictor_8x8_sse2,
&vpx_highbd_v_predictor_8x8_c, 8, 8), &vpx_highbd_v_predictor_8x8_c, 8, 8),
IntraPredFunc(&vpx_highbd_v_predictor_16x16_sse2, IntraPredFunc(&vpx_highbd_v_predictor_16x16_sse2,
&vpx_highbd_v_predictor_16x16_c, 16, 8), &vpx_highbd_v_predictor_16x16_c, 16, 8),
IntraPredFunc(&vpx_highbd_v_predictor_32x32_sse2, IntraPredFunc(&vpx_highbd_v_predictor_32x32_sse2,
&vpx_highbd_v_predictor_32x32_c, 32, 8), &vpx_highbd_v_predictor_32x32_c, 32, 8),
IntraPredFunc(&vpx_highbd_tm_predictor_4x4_sse2, IntraPredFunc(&vpx_highbd_tm_predictor_4x4_sse2,
&vpx_highbd_tm_predictor_4x4_c, 4, 8), &vpx_highbd_tm_predictor_4x4_c, 4, 8),
IntraPredFunc(&vpx_highbd_tm_predictor_8x8_sse2, IntraPredFunc(&vpx_highbd_tm_predictor_8x8_sse2,
&vpx_highbd_tm_predictor_8x8_c, 8, 8))); &vpx_highbd_tm_predictor_8x8_c, 8, 8)));
INSTANTIATE_TEST_CASE_P(SSE2_TO_C_10, VP9IntraPredTest, INSTANTIATE_TEST_CASE_P(
::testing::Values( SSE2_TO_C_10, VP9IntraPredTest,
IntraPredFunc(&vpx_highbd_dc_predictor_32x32_sse2, ::testing::Values(IntraPredFunc(&vpx_highbd_dc_predictor_32x32_sse2,
&vpx_highbd_dc_predictor_32x32_c, 32, 10), &vpx_highbd_dc_predictor_32x32_c, 32, 10),
IntraPredFunc(&vpx_highbd_tm_predictor_16x16_sse2, IntraPredFunc(&vpx_highbd_tm_predictor_16x16_sse2,
&vpx_highbd_tm_predictor_16x16_c, 16, 10), &vpx_highbd_tm_predictor_16x16_c, 16, 10),
IntraPredFunc(&vpx_highbd_tm_predictor_32x32_sse2, IntraPredFunc(&vpx_highbd_tm_predictor_32x32_sse2,
&vpx_highbd_tm_predictor_32x32_c, 32, 10), &vpx_highbd_tm_predictor_32x32_c, 32, 10),
IntraPredFunc(&vpx_highbd_dc_predictor_4x4_sse2, IntraPredFunc(&vpx_highbd_dc_predictor_4x4_sse2,
&vpx_highbd_dc_predictor_4x4_c, 4, 10), &vpx_highbd_dc_predictor_4x4_c, 4, 10),
IntraPredFunc(&vpx_highbd_dc_predictor_8x8_sse2, IntraPredFunc(&vpx_highbd_dc_predictor_8x8_sse2,
&vpx_highbd_dc_predictor_8x8_c, 8, 10), &vpx_highbd_dc_predictor_8x8_c, 8, 10),
IntraPredFunc(&vpx_highbd_dc_predictor_16x16_sse2, IntraPredFunc(&vpx_highbd_dc_predictor_16x16_sse2,
&vpx_highbd_dc_predictor_16x16_c, 16, 10), &vpx_highbd_dc_predictor_16x16_c, 16, 10),
IntraPredFunc(&vpx_highbd_v_predictor_4x4_sse2, IntraPredFunc(&vpx_highbd_v_predictor_4x4_sse2,
&vpx_highbd_v_predictor_4x4_c, 4, 10), &vpx_highbd_v_predictor_4x4_c, 4, 10),
IntraPredFunc(&vpx_highbd_v_predictor_8x8_sse2, IntraPredFunc(&vpx_highbd_v_predictor_8x8_sse2,
&vpx_highbd_v_predictor_8x8_c, 8, 10), &vpx_highbd_v_predictor_8x8_c, 8, 10),
IntraPredFunc(&vpx_highbd_v_predictor_16x16_sse2, IntraPredFunc(&vpx_highbd_v_predictor_16x16_sse2,
&vpx_highbd_v_predictor_16x16_c, 16, 10), &vpx_highbd_v_predictor_16x16_c, 16, 10),
IntraPredFunc(&vpx_highbd_v_predictor_32x32_sse2, IntraPredFunc(&vpx_highbd_v_predictor_32x32_sse2,
&vpx_highbd_v_predictor_32x32_c, 32, 10), &vpx_highbd_v_predictor_32x32_c, 32, 10),
IntraPredFunc(&vpx_highbd_tm_predictor_4x4_sse2, IntraPredFunc(&vpx_highbd_tm_predictor_4x4_sse2,
&vpx_highbd_tm_predictor_4x4_c, 4, 10), &vpx_highbd_tm_predictor_4x4_c, 4, 10),
IntraPredFunc(&vpx_highbd_tm_predictor_8x8_sse2, IntraPredFunc(&vpx_highbd_tm_predictor_8x8_sse2,
&vpx_highbd_tm_predictor_8x8_c, 8, 10))); &vpx_highbd_tm_predictor_8x8_c, 8, 10)));
INSTANTIATE_TEST_CASE_P(SSE2_TO_C_12, VP9IntraPredTest, INSTANTIATE_TEST_CASE_P(
::testing::Values( SSE2_TO_C_12, VP9IntraPredTest,
IntraPredFunc(&vpx_highbd_dc_predictor_32x32_sse2, ::testing::Values(IntraPredFunc(&vpx_highbd_dc_predictor_32x32_sse2,
&vpx_highbd_dc_predictor_32x32_c, 32, 12), &vpx_highbd_dc_predictor_32x32_c, 32, 12),
IntraPredFunc(&vpx_highbd_tm_predictor_16x16_sse2, IntraPredFunc(&vpx_highbd_tm_predictor_16x16_sse2,
&vpx_highbd_tm_predictor_16x16_c, 16, 12), &vpx_highbd_tm_predictor_16x16_c, 16, 12),
IntraPredFunc(&vpx_highbd_tm_predictor_32x32_sse2, IntraPredFunc(&vpx_highbd_tm_predictor_32x32_sse2,
&vpx_highbd_tm_predictor_32x32_c, 32, 12), &vpx_highbd_tm_predictor_32x32_c, 32, 12),
IntraPredFunc(&vpx_highbd_dc_predictor_4x4_sse2, IntraPredFunc(&vpx_highbd_dc_predictor_4x4_sse2,
&vpx_highbd_dc_predictor_4x4_c, 4, 12), &vpx_highbd_dc_predictor_4x4_c, 4, 12),
IntraPredFunc(&vpx_highbd_dc_predictor_8x8_sse2, IntraPredFunc(&vpx_highbd_dc_predictor_8x8_sse2,
&vpx_highbd_dc_predictor_8x8_c, 8, 12), &vpx_highbd_dc_predictor_8x8_c, 8, 12),
IntraPredFunc(&vpx_highbd_dc_predictor_16x16_sse2, IntraPredFunc(&vpx_highbd_dc_predictor_16x16_sse2,
&vpx_highbd_dc_predictor_16x16_c, 16, 12), &vpx_highbd_dc_predictor_16x16_c, 16, 12),
IntraPredFunc(&vpx_highbd_v_predictor_4x4_sse2, IntraPredFunc(&vpx_highbd_v_predictor_4x4_sse2,
&vpx_highbd_v_predictor_4x4_c, 4, 12), &vpx_highbd_v_predictor_4x4_c, 4, 12),
IntraPredFunc(&vpx_highbd_v_predictor_8x8_sse2, IntraPredFunc(&vpx_highbd_v_predictor_8x8_sse2,
&vpx_highbd_v_predictor_8x8_c, 8, 12), &vpx_highbd_v_predictor_8x8_c, 8, 12),
IntraPredFunc(&vpx_highbd_v_predictor_16x16_sse2, IntraPredFunc(&vpx_highbd_v_predictor_16x16_sse2,
&vpx_highbd_v_predictor_16x16_c, 16, 12), &vpx_highbd_v_predictor_16x16_c, 16, 12),
IntraPredFunc(&vpx_highbd_v_predictor_32x32_sse2, IntraPredFunc(&vpx_highbd_v_predictor_32x32_sse2,
&vpx_highbd_v_predictor_32x32_c, 32, 12), &vpx_highbd_v_predictor_32x32_c, 32, 12),
IntraPredFunc(&vpx_highbd_tm_predictor_4x4_sse2, IntraPredFunc(&vpx_highbd_tm_predictor_4x4_sse2,
&vpx_highbd_tm_predictor_4x4_c, 4, 12), &vpx_highbd_tm_predictor_4x4_c, 4, 12),
IntraPredFunc(&vpx_highbd_tm_predictor_8x8_sse2, IntraPredFunc(&vpx_highbd_tm_predictor_8x8_sse2,
&vpx_highbd_tm_predictor_8x8_c, 8, 12))); &vpx_highbd_tm_predictor_8x8_c, 8, 12)));
#endif // CONFIG_VP9_HIGHBITDEPTH #endif // CONFIG_VP9_HIGHBITDEPTH
#endif // HAVE_SSE2 #endif // HAVE_SSE2

19
test/vp9_lossless_test.cc
View File

@ -21,15 +21,13 @@ namespace {
const int kMaxPsnr = 100; const int kMaxPsnr = 100;
class LosslessTest : public ::libvpx_test::EncoderTest, class LosslessTest
public ::libvpx_test::CodecTestWithParam<libvpx_test::TestMode> { : public ::libvpx_test::EncoderTest,
public ::libvpx_test::CodecTestWithParam<libvpx_test::TestMode> {
protected: protected:
LosslessTest() LosslessTest()
: EncoderTest(GET_PARAM(0)), : EncoderTest(GET_PARAM(0)), psnr_(kMaxPsnr), nframes_(0),
psnr_(kMaxPsnr), encoding_mode_(GET_PARAM(1)) {}
nframes_(0),
encoding_mode_(GET_PARAM(1)) {
}
virtual ~LosslessTest() {} virtual ~LosslessTest() {}
@ -55,13 +53,10 @@ class LosslessTest : public ::libvpx_test::EncoderTest,
} }
virtual void PSNRPktHook(const vpx_codec_cx_pkt_t *pkt) { virtual void PSNRPktHook(const vpx_codec_cx_pkt_t *pkt) {
if (pkt->data.psnr.psnr[0] < psnr_) if (pkt->data.psnr.psnr[0] < psnr_) psnr_ = pkt->data.psnr.psnr[0];
psnr_= pkt->data.psnr.psnr[0];
} }
double GetMinPsnr() const { double GetMinPsnr() const { return psnr_; }
return psnr_;
}
private: private:
double psnr_; double psnr_;

127
test/vp9_quantize_test.cc
View File

@ -34,9 +34,8 @@ const int number_of_iterations = 100;
typedef void (*QuantizeFunc)(const tran_low_t *coeff, intptr_t count, typedef void (*QuantizeFunc)(const tran_low_t *coeff, intptr_t count,
int skip_block, const int16_t *zbin, int skip_block, const int16_t *zbin,
const int16_t *round, const int16_t *quant, const int16_t *round, const int16_t *quant,
const int16_t *quant_shift, const int16_t *quant_shift, tran_low_t *qcoeff,
tran_low_t *qcoeff, tran_low_t *dqcoeff, tran_low_t *dqcoeff, const int16_t *dequant,
const int16_t *dequant,
uint16_t *eob, const int16_t *scan, uint16_t *eob, const int16_t *scan,
const int16_t *iscan); const int16_t *iscan);
typedef std::tr1::tuple<QuantizeFunc, QuantizeFunc, vpx_bit_depth_t> typedef std::tr1::tuple<QuantizeFunc, QuantizeFunc, vpx_bit_depth_t>
@ -46,9 +45,9 @@ class VP9QuantizeTest : public ::testing::TestWithParam<QuantizeParam> {
public: public:
virtual ~VP9QuantizeTest() {} virtual ~VP9QuantizeTest() {}
virtual void SetUp() { virtual void SetUp() {
quantize_op_ = GET_PARAM(0); quantize_op_ = GET_PARAM(0);
ref_quantize_op_ = GET_PARAM(1); ref_quantize_op_ = GET_PARAM(1);
bit_depth_ = GET_PARAM(2); bit_depth_ = GET_PARAM(2);
mask_ = (1 << bit_depth_) - 1; mask_ = (1 << bit_depth_) - 1;
} }
@ -65,9 +64,9 @@ class VP9Quantize32Test : public ::testing::TestWithParam<QuantizeParam> {
public: public:
virtual ~VP9Quantize32Test() {} virtual ~VP9Quantize32Test() {}
virtual void SetUp() { virtual void SetUp() {
quantize_op_ = GET_PARAM(0); quantize_op_ = GET_PARAM(0);
ref_quantize_op_ = GET_PARAM(1); ref_quantize_op_ = GET_PARAM(1);
bit_depth_ = GET_PARAM(2); bit_depth_ = GET_PARAM(2);
mask_ = (1 << bit_depth_) - 1; mask_ = (1 << bit_depth_) - 1;
} }
@ -106,10 +105,10 @@ TEST_P(VP9QuantizeTest, OperationCheck) {
*eob_ptr = rnd.Rand16(); *eob_ptr = rnd.Rand16();
*ref_eob_ptr = *eob_ptr; *ref_eob_ptr = *eob_ptr;
for (int j = 0; j < count; j++) { for (int j = 0; j < count; j++) {
coeff_ptr[j] = rnd.Rand16()&mask_; coeff_ptr[j] = rnd.Rand16() & mask_;
} }
for (int j = 0; j < 2; j++) { for (int j = 0; j < 2; j++) {
zbin_ptr[j] = rnd.Rand16()&mask_; zbin_ptr[j] = rnd.Rand16() & mask_;
round_ptr[j] = rnd.Rand16(); round_ptr[j] = rnd.Rand16();
quant_ptr[j] = rnd.Rand16(); quant_ptr[j] = rnd.Rand16();
quant_shift_ptr[j] = rnd.Rand16(); quant_shift_ptr[j] = rnd.Rand16();
@ -117,16 +116,15 @@ TEST_P(VP9QuantizeTest, OperationCheck) {
} }
ref_quantize_op_(coeff_ptr, count, skip_block, zbin_ptr, round_ptr, ref_quantize_op_(coeff_ptr, count, skip_block, zbin_ptr, round_ptr,
quant_ptr, quant_shift_ptr, ref_qcoeff_ptr, quant_ptr, quant_shift_ptr, ref_qcoeff_ptr,
ref_dqcoeff_ptr, dequant_ptr, ref_dqcoeff_ptr, dequant_ptr, ref_eob_ptr,
ref_eob_ptr, scan_order->scan, scan_order->iscan); scan_order->scan, scan_order->iscan);
ASM_REGISTER_STATE_CHECK(quantize_op_(coeff_ptr, count, skip_block, ASM_REGISTER_STATE_CHECK(quantize_op_(
zbin_ptr, round_ptr, quant_ptr, coeff_ptr, count, skip_block, zbin_ptr, round_ptr, quant_ptr,
quant_shift_ptr, qcoeff_ptr, quant_shift_ptr, qcoeff_ptr, dqcoeff_ptr, dequant_ptr, eob_ptr,
dqcoeff_ptr, dequant_ptr, eob_ptr, scan_order->scan, scan_order->iscan));
scan_order->scan, scan_order->iscan));
for (int j = 0; j < sz; ++j) { for (int j = 0; j < sz; ++j) {
err_count += (ref_qcoeff_ptr[j] != qcoeff_ptr[j]) | err_count += (ref_qcoeff_ptr[j] != qcoeff_ptr[j]) |
(ref_dqcoeff_ptr[j] != dqcoeff_ptr[j]); (ref_dqcoeff_ptr[j] != dqcoeff_ptr[j]);
} }
err_count += (*ref_eob_ptr != *eob_ptr); err_count += (*ref_eob_ptr != *eob_ptr);
if (err_count && !err_count_total) { if (err_count && !err_count_total) {
@ -165,10 +163,10 @@ TEST_P(VP9Quantize32Test, OperationCheck) {
*eob_ptr = rnd.Rand16(); *eob_ptr = rnd.Rand16();
*ref_eob_ptr = *eob_ptr; *ref_eob_ptr = *eob_ptr;
for (int j = 0; j < count; j++) { for (int j = 0; j < count; j++) {
coeff_ptr[j] = rnd.Rand16()&mask_; coeff_ptr[j] = rnd.Rand16() & mask_;
} }
for (int j = 0; j < 2; j++) { for (int j = 0; j < 2; j++) {
zbin_ptr[j] = rnd.Rand16()&mask_; zbin_ptr[j] = rnd.Rand16() & mask_;
round_ptr[j] = rnd.Rand16(); round_ptr[j] = rnd.Rand16();
quant_ptr[j] = rnd.Rand16(); quant_ptr[j] = rnd.Rand16();
quant_shift_ptr[j] = rnd.Rand16(); quant_shift_ptr[j] = rnd.Rand16();
@ -176,16 +174,15 @@ TEST_P(VP9Quantize32Test, OperationCheck) {
} }
ref_quantize_op_(coeff_ptr, count, skip_block, zbin_ptr, round_ptr, ref_quantize_op_(coeff_ptr, count, skip_block, zbin_ptr, round_ptr,
quant_ptr, quant_shift_ptr, ref_qcoeff_ptr, quant_ptr, quant_shift_ptr, ref_qcoeff_ptr,
ref_dqcoeff_ptr, dequant_ptr, ref_dqcoeff_ptr, dequant_ptr, ref_eob_ptr,
ref_eob_ptr, scan_order->scan, scan_order->iscan); scan_order->scan, scan_order->iscan);
ASM_REGISTER_STATE_CHECK(quantize_op_(coeff_ptr, count, skip_block, ASM_REGISTER_STATE_CHECK(quantize_op_(
zbin_ptr, round_ptr, quant_ptr, coeff_ptr, count, skip_block, zbin_ptr, round_ptr, quant_ptr,
quant_shift_ptr, qcoeff_ptr, quant_shift_ptr, qcoeff_ptr, dqcoeff_ptr, dequant_ptr, eob_ptr,
dqcoeff_ptr, dequant_ptr, eob_ptr, scan_order->scan, scan_order->iscan));
scan_order->scan, scan_order->iscan));
for (int j = 0; j < sz; ++j) { for (int j = 0; j < sz; ++j) {
err_count += (ref_qcoeff_ptr[j] != qcoeff_ptr[j]) | err_count += (ref_qcoeff_ptr[j] != qcoeff_ptr[j]) |
(ref_dqcoeff_ptr[j] != dqcoeff_ptr[j]); (ref_dqcoeff_ptr[j] != dqcoeff_ptr[j]);
} }
err_count += (*ref_eob_ptr != *eob_ptr); err_count += (*ref_eob_ptr != *eob_ptr);
if (err_count && !err_count_total) { if (err_count && !err_count_total) {
@ -227,10 +224,10 @@ TEST_P(VP9QuantizeTest, EOBCheck) {
for (int j = 0; j < count; j++) { for (int j = 0; j < count; j++) {
coeff_ptr[j] = 0; coeff_ptr[j] = 0;
} }
coeff_ptr[rnd(count)] = rnd.Rand16()&mask_; coeff_ptr[rnd(count)] = rnd.Rand16() & mask_;
coeff_ptr[rnd(count)] = rnd.Rand16()&mask_; coeff_ptr[rnd(count)] = rnd.Rand16() & mask_;
for (int j = 0; j < 2; j++) { for (int j = 0; j < 2; j++) {
zbin_ptr[j] = rnd.Rand16()&mask_; zbin_ptr[j] = rnd.Rand16() & mask_;
round_ptr[j] = rnd.Rand16(); round_ptr[j] = rnd.Rand16();
quant_ptr[j] = rnd.Rand16(); quant_ptr[j] = rnd.Rand16();
quant_shift_ptr[j] = rnd.Rand16(); quant_shift_ptr[j] = rnd.Rand16();
@ -239,17 +236,16 @@ TEST_P(VP9QuantizeTest, EOBCheck) {
ref_quantize_op_(coeff_ptr, count, skip_block, zbin_ptr, round_ptr, ref_quantize_op_(coeff_ptr, count, skip_block, zbin_ptr, round_ptr,
quant_ptr, quant_shift_ptr, ref_qcoeff_ptr, quant_ptr, quant_shift_ptr, ref_qcoeff_ptr,
ref_dqcoeff_ptr, dequant_ptr, ref_dqcoeff_ptr, dequant_ptr, ref_eob_ptr,
ref_eob_ptr, scan_order->scan, scan_order->iscan); scan_order->scan, scan_order->iscan);
ASM_REGISTER_STATE_CHECK(quantize_op_(coeff_ptr, count, skip_block, ASM_REGISTER_STATE_CHECK(quantize_op_(
zbin_ptr, round_ptr, quant_ptr, coeff_ptr, count, skip_block, zbin_ptr, round_ptr, quant_ptr,
quant_shift_ptr, qcoeff_ptr, quant_shift_ptr, qcoeff_ptr, dqcoeff_ptr, dequant_ptr, eob_ptr,
dqcoeff_ptr, dequant_ptr, eob_ptr, scan_order->scan, scan_order->iscan));
scan_order->scan, scan_order->iscan));
for (int j = 0; j < sz; ++j) { for (int j = 0; j < sz; ++j) {
err_count += (ref_qcoeff_ptr[j] != qcoeff_ptr[j]) | err_count += (ref_qcoeff_ptr[j] != qcoeff_ptr[j]) |
(ref_dqcoeff_ptr[j] != dqcoeff_ptr[j]); (ref_dqcoeff_ptr[j] != dqcoeff_ptr[j]);
} }
err_count += (*ref_eob_ptr != *eob_ptr); err_count += (*ref_eob_ptr != *eob_ptr);
if (err_count && !err_count_total) { if (err_count && !err_count_total) {
@ -291,10 +287,10 @@ TEST_P(VP9Quantize32Test, EOBCheck) {
coeff_ptr[j] = 0; coeff_ptr[j] = 0;
} }
// Two random entries // Two random entries
coeff_ptr[rnd(count)] = rnd.Rand16()&mask_; coeff_ptr[rnd(count)] = rnd.Rand16() & mask_;
coeff_ptr[rnd(count)] = rnd.Rand16()&mask_; coeff_ptr[rnd(count)] = rnd.Rand16() & mask_;
for (int j = 0; j < 2; j++) { for (int j = 0; j < 2; j++) {
zbin_ptr[j] = rnd.Rand16()&mask_; zbin_ptr[j] = rnd.Rand16() & mask_;
round_ptr[j] = rnd.Rand16(); round_ptr[j] = rnd.Rand16();
quant_ptr[j] = rnd.Rand16(); quant_ptr[j] = rnd.Rand16();
quant_shift_ptr[j] = rnd.Rand16(); quant_shift_ptr[j] = rnd.Rand16();
@ -303,17 +299,16 @@ TEST_P(VP9Quantize32Test, EOBCheck) {
ref_quantize_op_(coeff_ptr, count, skip_block, zbin_ptr, round_ptr, ref_quantize_op_(coeff_ptr, count, skip_block, zbin_ptr, round_ptr,
quant_ptr, quant_shift_ptr, ref_qcoeff_ptr, quant_ptr, quant_shift_ptr, ref_qcoeff_ptr,
ref_dqcoeff_ptr, dequant_ptr, ref_dqcoeff_ptr, dequant_ptr, ref_eob_ptr,
ref_eob_ptr, scan_order->scan, scan_order->iscan); scan_order->scan, scan_order->iscan);
ASM_REGISTER_STATE_CHECK(quantize_op_(coeff_ptr, count, skip_block, ASM_REGISTER_STATE_CHECK(quantize_op_(
zbin_ptr, round_ptr, quant_ptr, coeff_ptr, count, skip_block, zbin_ptr, round_ptr, quant_ptr,
quant_shift_ptr, qcoeff_ptr, quant_shift_ptr, qcoeff_ptr, dqcoeff_ptr, dequant_ptr, eob_ptr,
dqcoeff_ptr, dequant_ptr, eob_ptr, scan_order->scan, scan_order->iscan));
scan_order->scan, scan_order->iscan));
for (int j = 0; j < sz; ++j) { for (int j = 0; j < sz; ++j) {
err_count += (ref_qcoeff_ptr[j] != qcoeff_ptr[j]) | err_count += (ref_qcoeff_ptr[j] != qcoeff_ptr[j]) |
(ref_dqcoeff_ptr[j] != dqcoeff_ptr[j]); (ref_dqcoeff_ptr[j] != dqcoeff_ptr[j]);
} }
err_count += (*ref_eob_ptr != *eob_ptr); err_count += (*ref_eob_ptr != *eob_ptr);
if (err_count && !err_count_total) { if (err_count && !err_count_total) {
@ -330,22 +325,20 @@ using std::tr1::make_tuple;
#if HAVE_SSE2 #if HAVE_SSE2
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
SSE2, VP9QuantizeTest, SSE2, VP9QuantizeTest,
::testing::Values( ::testing::Values(make_tuple(&vpx_highbd_quantize_b_sse2,
make_tuple(&vpx_highbd_quantize_b_sse2, &vpx_highbd_quantize_b_c, VPX_BITS_8),
&vpx_highbd_quantize_b_c, VPX_BITS_8), make_tuple(&vpx_highbd_quantize_b_sse2,
make_tuple(&vpx_highbd_quantize_b_sse2, &vpx_highbd_quantize_b_c, VPX_BITS_10),
&vpx_highbd_quantize_b_c, VPX_BITS_10), make_tuple(&vpx_highbd_quantize_b_sse2,
make_tuple(&vpx_highbd_quantize_b_sse2, &vpx_highbd_quantize_b_c, VPX_BITS_12)));
&vpx_highbd_quantize_b_c, VPX_BITS_12)));
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
SSE2, VP9Quantize32Test, SSE2, VP9Quantize32Test,
::testing::Values( ::testing::Values(make_tuple(&vpx_highbd_quantize_b_32x32_sse2,
make_tuple(&vpx_highbd_quantize_b_32x32_sse2, &vpx_highbd_quantize_b_32x32_c, VPX_BITS_8),
&vpx_highbd_quantize_b_32x32_c, VPX_BITS_8), make_tuple(&vpx_highbd_quantize_b_32x32_sse2,
make_tuple(&vpx_highbd_quantize_b_32x32_sse2, &vpx_highbd_quantize_b_32x32_c, VPX_BITS_10),
&vpx_highbd_quantize_b_32x32_c, VPX_BITS_10), make_tuple(&vpx_highbd_quantize_b_32x32_sse2,
make_tuple(&vpx_highbd_quantize_b_32x32_sse2, &vpx_highbd_quantize_b_32x32_c, VPX_BITS_12)));
&vpx_highbd_quantize_b_32x32_c, VPX_BITS_12)));
#endif // HAVE_SSE2 #endif // HAVE_SSE2
#endif // CONFIG_VP9_HIGHBITDEPTH #endif // CONFIG_VP9_HIGHBITDEPTH
} // namespace } // namespace

16
test/vp9_skip_loopfilter_test.cc
View File

@ -24,14 +24,10 @@ const char kVp9Md5File[] = "vp90-2-08-tile_1x8_frame_parallel.webm.md5";
// Class for testing shutting off the loop filter. // Class for testing shutting off the loop filter.
class SkipLoopFilterTest { class SkipLoopFilterTest {
public: public:
SkipLoopFilterTest() SkipLoopFilterTest() : video_(NULL), decoder_(NULL), md5_file_(NULL) {}
: video_(NULL),
decoder_(NULL),
md5_file_(NULL) {}
~SkipLoopFilterTest() { ~SkipLoopFilterTest() {
if (md5_file_ != NULL) if (md5_file_ != NULL) fclose(md5_file_);
fclose(md5_file_);
delete decoder_; delete decoder_;
delete video_; delete video_;
} }
@ -46,8 +42,7 @@ class SkipLoopFilterTest {
video_->Begin(); video_->Begin();
vpx_codec_dec_cfg_t cfg = vpx_codec_dec_cfg_t(); vpx_codec_dec_cfg_t cfg = vpx_codec_dec_cfg_t();
if (num_threads > 0) if (num_threads > 0) cfg.threads = num_threads;
cfg.threads = num_threads;
decoder_ = new libvpx_test::VP9Decoder(cfg, 0); decoder_ = new libvpx_test::VP9Decoder(cfg, 0);
ASSERT_TRUE(decoder_ != NULL); ASSERT_TRUE(decoder_ != NULL);
@ -73,8 +68,7 @@ class SkipLoopFilterTest {
for (; video_->cxdata() != NULL; video_->Next()) { for (; video_->cxdata() != NULL; video_->Next()) {
const vpx_codec_err_t res = const vpx_codec_err_t res =
decoder_->DecodeFrame(video_->cxdata(), video_->frame_size()); decoder_->DecodeFrame(video_->cxdata(), video_->frame_size());
if (res != VPX_CODEC_OK) if (res != VPX_CODEC_OK) return res;
return res;
ReadMd5(); ReadMd5();
} }
return VPX_CODEC_OK; return VPX_CODEC_OK;
@ -92,7 +86,7 @@ class SkipLoopFilterTest {
void OpenMd5File(const std::string &md5_file_name) { void OpenMd5File(const std::string &md5_file_name) {
md5_file_ = libvpx_test::OpenTestDataFile(md5_file_name); md5_file_ = libvpx_test::OpenTestDataFile(md5_file_name);
ASSERT_TRUE(md5_file_ != NULL) << "MD5 file open failed. Filename: " ASSERT_TRUE(md5_file_ != NULL) << "MD5 file open failed. Filename: "
<< md5_file_name; << md5_file_name;
} }
// Reads the next line of the MD5 file. // Reads the next line of the MD5 file.

37
test/vp9_subtract_test.cc
View File

@ -19,18 +19,16 @@
#include "vp9/common/vp9_blockd.h" #include "vp9/common/vp9_blockd.h"
#include "vpx_mem/vpx_mem.h" #include "vpx_mem/vpx_mem.h"
typedef void (*SubtractFunc)(int rows, int cols, typedef void (*SubtractFunc)(int rows, int cols, int16_t *diff_ptr,
int16_t *diff_ptr, ptrdiff_t diff_stride, ptrdiff_t diff_stride, const uint8_t *src_ptr,
const uint8_t *src_ptr, ptrdiff_t src_stride, ptrdiff_t src_stride, const uint8_t *pred_ptr,
const uint8_t *pred_ptr, ptrdiff_t pred_stride); ptrdiff_t pred_stride);
namespace vp9 { namespace vp9 {
class VP9SubtractBlockTest : public ::testing::TestWithParam<SubtractFunc> { class VP9SubtractBlockTest : public ::testing::TestWithParam<SubtractFunc> {
public: public:
virtual void TearDown() { virtual void TearDown() { libvpx_test::ClearSystemState(); }
libvpx_test::ClearSystemState();
}
}; };
using libvpx_test::ACMRandom; using libvpx_test::ACMRandom;
@ -47,7 +45,7 @@ TEST_P(VP9SubtractBlockTest, SimpleSubtract) {
vpx_memalign(16, sizeof(*diff) * block_width * block_height * 2)); vpx_memalign(16, sizeof(*diff) * block_width * block_height * 2));
uint8_t *pred = reinterpret_cast<uint8_t *>( uint8_t *pred = reinterpret_cast<uint8_t *>(
vpx_memalign(16, block_width * block_height * 2)); vpx_memalign(16, block_width * block_height * 2));
uint8_t *src = reinterpret_cast<uint8_t *>( uint8_t *src = reinterpret_cast<uint8_t *>(
vpx_memalign(16, block_width * block_height * 2)); vpx_memalign(16, block_width * block_height * 2));
for (int n = 0; n < 100; n++) { for (int n = 0; n < 100; n++) {
@ -58,29 +56,26 @@ TEST_P(VP9SubtractBlockTest, SimpleSubtract) {
} }
} }
GetParam()(block_height, block_width, diff, block_width, GetParam()(block_height, block_width, diff, block_width, src, block_width,
src, block_width, pred, block_width); pred, block_width);
for (int r = 0; r < block_height; ++r) { for (int r = 0; r < block_height; ++r) {
for (int c = 0; c < block_width; ++c) { for (int c = 0; c < block_width; ++c) {
EXPECT_EQ(diff[r * block_width + c], EXPECT_EQ(diff[r * block_width + c],
(src[r * block_width + c] - (src[r * block_width + c] - pred[r * block_width + c]))
pred[r * block_width + c])) << "r = " << r << "r = " << r << ", c = " << c << ", bs = " << bsize;
<< ", c = " << c
<< ", bs = " << bsize;
} }
} }
GetParam()(block_height, block_width, diff, block_width * 2, GetParam()(block_height, block_width, diff, block_width * 2, src,
src, block_width * 2, pred, block_width * 2); block_width * 2, pred, block_width * 2);
for (int r = 0; r < block_height; ++r) { for (int r = 0; r < block_height; ++r) {
for (int c = 0; c < block_width; ++c) { for (int c = 0; c < block_width; ++c) {
EXPECT_EQ(diff[r * block_width * 2 + c], EXPECT_EQ(
(src[r * block_width * 2 + c] - diff[r * block_width * 2 + c],
pred[r * block_width * 2 + c])) << "r = " << r (src[r * block_width * 2 + c] - pred[r * block_width * 2 + c]))
<< ", c = " << c << "r = " << r << ", c = " << c << ", bs = " << bsize;
<< ", bs = " << bsize;
} }
} }
} }

38
test/vp9_thread_test.cc
View File

@ -27,15 +27,11 @@ using std::string;
class VPxWorkerThreadTest : public ::testing::TestWithParam<bool> { class VPxWorkerThreadTest : public ::testing::TestWithParam<bool> {
protected: protected:
virtual ~VPxWorkerThreadTest() {} virtual ~VPxWorkerThreadTest() {}
virtual void SetUp() { virtual void SetUp() { vpx_get_worker_interface()->init(&worker_); }
vpx_get_worker_interface()->init(&worker_);
}
virtual void TearDown() { virtual void TearDown() { vpx_get_worker_interface()->end(&worker_); }
vpx_get_worker_interface()->end(&worker_);
}
void Run(VPxWorker* worker) { void Run(VPxWorker *worker) {
const bool synchronous = GetParam(); const bool synchronous = GetParam();
if (synchronous) { if (synchronous) {
vpx_get_worker_interface()->execute(worker); vpx_get_worker_interface()->execute(worker);
@ -47,10 +43,10 @@ class VPxWorkerThreadTest : public ::testing::TestWithParam<bool> {
VPxWorker worker_; VPxWorker worker_;
}; };
int ThreadHook(void* data, void* return_value) { int ThreadHook(void *data, void *return_value) {
int* const hook_data = reinterpret_cast<int*>(data); int *const hook_data = reinterpret_cast<int *>(data);
*hook_data = 5; *hook_data = 5;
return *reinterpret_cast<int*>(return_value); return *reinterpret_cast<int *>(return_value);
} }
TEST_P(VPxWorkerThreadTest, HookSuccess) { TEST_P(VPxWorkerThreadTest, HookSuccess) {
@ -159,7 +155,7 @@ struct FileList {
}; };
// Decodes |filename| with |num_threads|. Returns the md5 of the decoded frames. // Decodes |filename| with |num_threads|. Returns the md5 of the decoded frames.
string DecodeFile(const string& filename, int num_threads) { string DecodeFile(const string &filename, int num_threads) {
libvpx_test::WebMVideoSource video(filename); libvpx_test::WebMVideoSource video(filename);
video.Init(); video.Init();
@ -191,8 +187,8 @@ void DecodeFiles(const FileList files[]) {
for (const FileList *iter = files; iter->name != NULL; ++iter) { for (const FileList *iter = files; iter->name != NULL; ++iter) {
SCOPED_TRACE(iter->name); SCOPED_TRACE(iter->name);
for (int t = 1; t <= 8; ++t) { for (int t = 1; t <= 8; ++t) {
EXPECT_EQ(iter->expected_md5, DecodeFile(iter->name, t)) EXPECT_EQ(iter->expected_md5, DecodeFile(iter->name, t)) << "threads = "
<< "threads = " << t; << t;
} }
} }
} }
@ -242,15 +238,13 @@ TEST(VP9DecodeMultiThreadedTest, NoTilesNonFrameParallel) {
} }
TEST(VP9DecodeMultiThreadedTest, FrameParallel) { TEST(VP9DecodeMultiThreadedTest, FrameParallel) {
static const FileList files[] = { static const FileList files[] = { { "vp90-2-08-tile_1x2_frame_parallel.webm",
{ "vp90-2-08-tile_1x2_frame_parallel.webm", "68ede6abd66bae0a2edf2eb9232241b6" },
"68ede6abd66bae0a2edf2eb9232241b6" }, { "vp90-2-08-tile_1x4_frame_parallel.webm",
{ "vp90-2-08-tile_1x4_frame_parallel.webm", "368ebc6ebf3a5e478d85b2c3149b2848" },
"368ebc6ebf3a5e478d85b2c3149b2848" }, { "vp90-2-08-tile_1x8_frame_parallel.webm",
{ "vp90-2-08-tile_1x8_frame_parallel.webm", "17e439da2388aff3a0f69cb22579c6c1" },
"17e439da2388aff3a0f69cb22579c6c1" }, { NULL, NULL } };
{ NULL, NULL }
};
DecodeFiles(files); DecodeFiles(files);
} }

59
test/vpx_scale_test.cc
View File

@ -25,9 +25,7 @@ typedef void (*CopyFrameFunc)(const YV12_BUFFER_CONFIG *src_ybf,
class VpxScaleBase { class VpxScaleBase {
public: public:
virtual ~VpxScaleBase() { virtual ~VpxScaleBase() { libvpx_test::ClearSystemState(); }
libvpx_test::ClearSystemState();
}
void ResetImage(int width, int height) { void ResetImage(int width, int height) {
width_ = width; width_ = width;
@ -105,28 +103,22 @@ class VpxScaleBase {
} }
uint8_t *bottom = left + (crop_height * stride); uint8_t *bottom = left + (crop_height * stride);
for (int y = 0; y < bottom_extend; ++y) { for (int y = 0; y < bottom_extend; ++y) {
memcpy(bottom, left + (crop_height - 1) * stride, extend_width); memcpy(bottom, left + (crop_height - 1) * stride, extend_width);
bottom += stride; bottom += stride;
} }
} }
void ReferenceExtendBorder() { void ReferenceExtendBorder() {
ExtendPlane(ref_img_.y_buffer, ExtendPlane(ref_img_.y_buffer, ref_img_.y_crop_width,
ref_img_.y_crop_width, ref_img_.y_crop_height, ref_img_.y_crop_height, ref_img_.y_width, ref_img_.y_height,
ref_img_.y_width, ref_img_.y_height, ref_img_.y_stride, ref_img_.border);
ref_img_.y_stride, ExtendPlane(ref_img_.u_buffer, ref_img_.uv_crop_width,
ref_img_.border); ref_img_.uv_crop_height, ref_img_.uv_width, ref_img_.uv_height,
ExtendPlane(ref_img_.u_buffer, ref_img_.uv_stride, ref_img_.border / 2);
ref_img_.uv_crop_width, ref_img_.uv_crop_height, ExtendPlane(ref_img_.v_buffer, ref_img_.uv_crop_width,
ref_img_.uv_width, ref_img_.uv_height, ref_img_.uv_crop_height, ref_img_.uv_width, ref_img_.uv_height,
ref_img_.uv_stride, ref_img_.uv_stride, ref_img_.border / 2);
ref_img_.border / 2);
ExtendPlane(ref_img_.v_buffer,
ref_img_.uv_crop_width, ref_img_.uv_crop_height,
ref_img_.uv_width, ref_img_.uv_height,
ref_img_.uv_stride,
ref_img_.border / 2);
} }
void ReferenceCopyFrame() { void ReferenceCopyFrame() {
@ -172,13 +164,9 @@ class ExtendBorderTest
virtual ~ExtendBorderTest() {} virtual ~ExtendBorderTest() {}
protected: protected:
virtual void SetUp() { virtual void SetUp() { extend_fn_ = GetParam(); }
extend_fn_ = GetParam();
}
void ExtendBorder() { void ExtendBorder() { ASM_REGISTER_STATE_CHECK(extend_fn_(&img_)); }
ASM_REGISTER_STATE_CHECK(extend_fn_(&img_));
}
void RunTest() { void RunTest() {
#if ARCH_ARM #if ARCH_ARM
@ -187,7 +175,7 @@ class ExtendBorderTest
#else #else
static const int kNumSizesToTest = 7; static const int kNumSizesToTest = 7;
#endif #endif
static const int kSizesToTest[] = {1, 15, 33, 145, 512, 1025, 16383}; static const int kSizesToTest[] = { 1, 15, 33, 145, 512, 1025, 16383 };
for (int h = 0; h < kNumSizesToTest; ++h) { for (int h = 0; h < kNumSizesToTest; ++h) {
for (int w = 0; w < kNumSizesToTest; ++w) { for (int w = 0; w < kNumSizesToTest; ++w) {
ResetImage(kSizesToTest[w], kSizesToTest[h]); ResetImage(kSizesToTest[w], kSizesToTest[h]);
@ -202,23 +190,18 @@ class ExtendBorderTest
ExtendFrameBorderFunc extend_fn_; ExtendFrameBorderFunc extend_fn_;
}; };
TEST_P(ExtendBorderTest, ExtendBorder) { TEST_P(ExtendBorderTest, ExtendBorder) { ASSERT_NO_FATAL_FAILURE(RunTest()); }
ASSERT_NO_FATAL_FAILURE(RunTest());
}
INSTANTIATE_TEST_CASE_P(C, ExtendBorderTest, INSTANTIATE_TEST_CASE_P(C, ExtendBorderTest,
::testing::Values(vp8_yv12_extend_frame_borders_c)); ::testing::Values(vp8_yv12_extend_frame_borders_c));
class CopyFrameTest class CopyFrameTest : public VpxScaleBase,
: public VpxScaleBase, public ::testing::TestWithParam<CopyFrameFunc> {
public ::testing::TestWithParam<CopyFrameFunc> {
public: public:
virtual ~CopyFrameTest() {} virtual ~CopyFrameTest() {}
protected: protected:
virtual void SetUp() { virtual void SetUp() { copy_frame_fn_ = GetParam(); }
copy_frame_fn_ = GetParam();
}
void CopyFrame() { void CopyFrame() {
ASM_REGISTER_STATE_CHECK(copy_frame_fn_(&img_, &cpy_img_)); ASM_REGISTER_STATE_CHECK(copy_frame_fn_(&img_, &cpy_img_));
@ -231,7 +214,7 @@ class CopyFrameTest
#else #else
static const int kNumSizesToTest = 7; static const int kNumSizesToTest = 7;
#endif #endif
static const int kSizesToTest[] = {1, 15, 33, 145, 512, 1025, 16383}; static const int kSizesToTest[] = { 1, 15, 33, 145, 512, 1025, 16383 };
for (int h = 0; h < kNumSizesToTest; ++h) { for (int h = 0; h < kNumSizesToTest; ++h) {
for (int w = 0; w < kNumSizesToTest; ++w) { for (int w = 0; w < kNumSizesToTest; ++w) {
ResetImage(kSizesToTest[w], kSizesToTest[h]); ResetImage(kSizesToTest[w], kSizesToTest[h]);
@ -246,9 +229,7 @@ class CopyFrameTest
CopyFrameFunc copy_frame_fn_; CopyFrameFunc copy_frame_fn_;
}; };
TEST_P(CopyFrameTest, CopyFrame) { TEST_P(CopyFrameTest, CopyFrame) { ASSERT_NO_FATAL_FAILURE(RunTest()); }
ASSERT_NO_FATAL_FAILURE(RunTest());
}
INSTANTIATE_TEST_CASE_P(C, CopyFrameTest, INSTANTIATE_TEST_CASE_P(C, CopyFrameTest,
::testing::Values(vp8_yv12_copy_frame_c)); ::testing::Values(vp8_yv12_copy_frame_c));

23
test/webm_video_source.h
View File

@ -25,30 +25,23 @@ namespace libvpx_test {
class WebMVideoSource : public CompressedVideoSource { class WebMVideoSource : public CompressedVideoSource {
public: public:
explicit WebMVideoSource(const std::string &file_name) explicit WebMVideoSource(const std::string &file_name)
: file_name_(file_name), : file_name_(file_name), vpx_ctx_(new VpxInputContext()),
vpx_ctx_(new VpxInputContext()), webm_ctx_(new WebmInputContext()), buf_(NULL), buf_sz_(0), frame_(0),
webm_ctx_(new WebmInputContext()), end_of_file_(false) {}
buf_(NULL),
buf_sz_(0),
frame_(0),
end_of_file_(false) {
}
virtual ~WebMVideoSource() { virtual ~WebMVideoSource() {
if (vpx_ctx_->file != NULL) if (vpx_ctx_->file != NULL) fclose(vpx_ctx_->file);
fclose(vpx_ctx_->file);
webm_free(webm_ctx_); webm_free(webm_ctx_);
delete vpx_ctx_; delete vpx_ctx_;
delete webm_ctx_; delete webm_ctx_;
} }
virtual void Init() { virtual void Init() {}
}
virtual void Begin() { virtual void Begin() {
vpx_ctx_->file = OpenTestDataFile(file_name_); vpx_ctx_->file = OpenTestDataFile(file_name_);
ASSERT_TRUE(vpx_ctx_->file != NULL) << "Input file open failed. Filename: " ASSERT_TRUE(vpx_ctx_->file != NULL) << "Input file open failed. Filename: "
<< file_name_; << file_name_;
ASSERT_EQ(file_is_webm(webm_ctx_, vpx_ctx_), 1) << "file is not WebM"; ASSERT_EQ(file_is_webm(webm_ctx_, vpx_ctx_), 1) << "file is not WebM";
@ -81,9 +74,7 @@ class WebMVideoSource : public CompressedVideoSource {
} while (!webm_ctx_->is_key_frame && !end_of_file_); } while (!webm_ctx_->is_key_frame && !end_of_file_);
} }
virtual const uint8_t *cxdata() const { virtual const uint8_t *cxdata() const { return end_of_file_ ? NULL : buf_; }
return end_of_file_ ? NULL : buf_;
}
virtual size_t frame_size() const { return buf_sz_; } virtual size_t frame_size() const { return buf_sz_; }
virtual unsigned int frame_number() const { return frame_; } virtual unsigned int frame_number() const { return frame_; }

70
test/y4m_test.cc
View File

@ -22,7 +22,7 @@ namespace {
using std::string; using std::string;
static const unsigned int kWidth = 160; static const unsigned int kWidth = 160;
static const unsigned int kHeight = 90; static const unsigned int kHeight = 90;
static const unsigned int kFrames = 10; static const unsigned int kFrames = 10;
@ -34,24 +34,24 @@ struct Y4mTestParam {
}; };
const Y4mTestParam kY4mTestVectors[] = { const Y4mTestParam kY4mTestVectors[] = {
{"park_joy_90p_8_420.y4m", 8, VPX_IMG_FMT_I420, { "park_joy_90p_8_420.y4m", 8, VPX_IMG_FMT_I420,
"e5406275b9fc6bb3436c31d4a05c1cab"}, "e5406275b9fc6bb3436c31d4a05c1cab" },
{"park_joy_90p_8_422.y4m", 8, VPX_IMG_FMT_I422, { "park_joy_90p_8_422.y4m", 8, VPX_IMG_FMT_I422,
"284a47a47133b12884ec3a14e959a0b6"}, "284a47a47133b12884ec3a14e959a0b6" },
{"park_joy_90p_8_444.y4m", 8, VPX_IMG_FMT_I444, { "park_joy_90p_8_444.y4m", 8, VPX_IMG_FMT_I444,
"90517ff33843d85de712fd4fe60dbed0"}, "90517ff33843d85de712fd4fe60dbed0" },
{"park_joy_90p_10_420.y4m", 10, VPX_IMG_FMT_I42016, { "park_joy_90p_10_420.y4m", 10, VPX_IMG_FMT_I42016,
"63f21f9f717d8b8631bd2288ee87137b"}, "63f21f9f717d8b8631bd2288ee87137b" },
{"park_joy_90p_10_422.y4m", 10, VPX_IMG_FMT_I42216, { "park_joy_90p_10_422.y4m", 10, VPX_IMG_FMT_I42216,
"48ab51fb540aed07f7ff5af130c9b605"}, "48ab51fb540aed07f7ff5af130c9b605" },
{"park_joy_90p_10_444.y4m", 10, VPX_IMG_FMT_I44416, { "park_joy_90p_10_444.y4m", 10, VPX_IMG_FMT_I44416,
"067bfd75aa85ff9bae91fa3e0edd1e3e"}, "067bfd75aa85ff9bae91fa3e0edd1e3e" },
{"park_joy_90p_12_420.y4m", 12, VPX_IMG_FMT_I42016, { "park_joy_90p_12_420.y4m", 12, VPX_IMG_FMT_I42016,
"9e6d8f6508c6e55625f6b697bc461cef"}, "9e6d8f6508c6e55625f6b697bc461cef" },
{"park_joy_90p_12_422.y4m", 12, VPX_IMG_FMT_I42216, { "park_joy_90p_12_422.y4m", 12, VPX_IMG_FMT_I42216,
"b239c6b301c0b835485be349ca83a7e3"}, "b239c6b301c0b835485be349ca83a7e3" },
{"park_joy_90p_12_444.y4m", 12, VPX_IMG_FMT_I44416, { "park_joy_90p_12_444.y4m", 12, VPX_IMG_FMT_I44416,
"5a6481a550821dab6d0192f5c63845e9"}, "5a6481a550821dab6d0192f5c63845e9" },
}; };
static void write_image_file(const vpx_image_t *img, FILE *file) { static void write_image_file(const vpx_image_t *img, FILE *file) {
@ -60,10 +60,12 @@ static void write_image_file(const vpx_image_t *img, FILE *file) {
const unsigned char *buf = img->planes[plane]; const unsigned char *buf = img->planes[plane];
const int stride = img->stride[plane]; const int stride = img->stride[plane];
const int bytes_per_sample = (img->fmt & VPX_IMG_FMT_HIGHBITDEPTH) ? 2 : 1; const int bytes_per_sample = (img->fmt & VPX_IMG_FMT_HIGHBITDEPTH) ? 2 : 1;
const int h = (plane ? (img->d_h + img->y_chroma_shift) >> const int h =
img->y_chroma_shift : img->d_h); (plane ? (img->d_h + img->y_chroma_shift) >> img->y_chroma_shift
const int w = (plane ? (img->d_w + img->x_chroma_shift) >> : img->d_h);
img->x_chroma_shift : img->d_w); const int w =
(plane ? (img->d_w + img->x_chroma_shift) >> img->x_chroma_shift
: img->d_w);
for (y = 0; y < h; ++y) { for (y = 0; y < h; ++y) {
fwrite(buf, bytes_per_sample, w, file); fwrite(buf, bytes_per_sample, w, file);
buf += stride; buf += stride;
@ -71,15 +73,12 @@ static void write_image_file(const vpx_image_t *img, FILE *file) {
} }
} }
class Y4mVideoSourceTest class Y4mVideoSourceTest : public ::testing::TestWithParam<Y4mTestParam>,
: public ::testing::TestWithParam<Y4mTestParam>, public ::libvpx_test::Y4mVideoSource {
public ::libvpx_test::Y4mVideoSource {
protected: protected:
Y4mVideoSourceTest() : Y4mVideoSource("", 0, 0) {} Y4mVideoSourceTest() : Y4mVideoSource("", 0, 0) {}
virtual ~Y4mVideoSourceTest() { virtual ~Y4mVideoSourceTest() { CloseSource(); }
CloseSource();
}
virtual void Init(const std::string &file_name, int limit) { virtual void Init(const std::string &file_name, int limit) {
file_name_ = file_name; file_name_ = file_name;
@ -137,8 +136,7 @@ TEST_P(Y4mVideoSourceTest, SourceTest) {
INSTANTIATE_TEST_CASE_P(C, Y4mVideoSourceTest, INSTANTIATE_TEST_CASE_P(C, Y4mVideoSourceTest,
::testing::ValuesIn(kY4mTestVectors)); ::testing::ValuesIn(kY4mTestVectors));
class Y4mVideoWriteTest class Y4mVideoWriteTest : public Y4mVideoSourceTest {
: public Y4mVideoSourceTest {
protected: protected:
Y4mVideoWriteTest() {} Y4mVideoWriteTest() {}
@ -158,14 +156,12 @@ class Y4mVideoWriteTest
// Writes out a y4m file and then reads it back // Writes out a y4m file and then reads it back
void WriteY4mAndReadBack() { void WriteY4mAndReadBack() {
ASSERT_TRUE(input_file_ != NULL); ASSERT_TRUE(input_file_ != NULL);
char buf[Y4M_BUFFER_SIZE] = {0}; char buf[Y4M_BUFFER_SIZE] = { 0 };
const struct VpxRational framerate = {y4m_.fps_n, y4m_.fps_d}; const struct VpxRational framerate = { y4m_.fps_n, y4m_.fps_d };
tmpfile_ = new libvpx_test::TempOutFile; tmpfile_ = new libvpx_test::TempOutFile;
ASSERT_TRUE(tmpfile_->file() != NULL); ASSERT_TRUE(tmpfile_->file() != NULL);
y4m_write_file_header(buf, sizeof(buf), y4m_write_file_header(buf, sizeof(buf), kWidth, kHeight, &framerate,
kWidth, kHeight, y4m_.vpx_fmt, y4m_.bit_depth);
&framerate, y4m_.vpx_fmt,
y4m_.bit_depth);
fputs(buf, tmpfile_->file()); fputs(buf, tmpfile_->file());
for (unsigned int i = start_; i < limit_; i++) { for (unsigned int i = start_; i < limit_; i++) {
y4m_write_frame_header(buf, sizeof(buf)); y4m_write_frame_header(buf, sizeof(buf));

16
test/y4m_video_source.h
View File

@ -21,18 +21,10 @@ namespace libvpx_test {
// so that we can do actual file encodes. // so that we can do actual file encodes.
class Y4mVideoSource : public VideoSource { class Y4mVideoSource : public VideoSource {
public: public:
Y4mVideoSource(const std::string &file_name, Y4mVideoSource(const std::string &file_name, unsigned int start, int limit)
unsigned int start, int limit) : file_name_(file_name), input_file_(NULL), img_(new vpx_image_t()),
: file_name_(file_name), start_(start), limit_(limit), frame_(0), framerate_numerator_(0),
input_file_(NULL), framerate_denominator_(0), y4m_() {}
img_(new vpx_image_t()),
start_(start),
limit_(limit),
frame_(0),
framerate_numerator_(0),
framerate_denominator_(0),
y4m_() {
}
virtual ~Y4mVideoSource() { virtual ~Y4mVideoSource() {
vpx_img_free(img_.get()); vpx_img_free(img_.get());

61
test/yuv_video_source.h
View File

@ -25,19 +25,11 @@ namespace libvpx_test {
class YUVVideoSource : public VideoSource { class YUVVideoSource : public VideoSource {
public: public:
YUVVideoSource(const std::string &file_name, vpx_img_fmt format, YUVVideoSource(const std::string &file_name, vpx_img_fmt format,
unsigned int width, unsigned int height, unsigned int width, unsigned int height, int rate_numerator,
int rate_numerator, int rate_denominator, int rate_denominator, unsigned int start, int limit)
unsigned int start, int limit) : file_name_(file_name), input_file_(NULL), img_(NULL), start_(start),
: file_name_(file_name), limit_(limit), frame_(0), width_(0), height_(0),
input_file_(NULL), format_(VPX_IMG_FMT_NONE), framerate_numerator_(rate_numerator),
img_(NULL),
start_(start),
limit_(limit),
frame_(0),
width_(0),
height_(0),
format_(VPX_IMG_FMT_NONE),
framerate_numerator_(rate_numerator),
framerate_denominator_(rate_denominator) { framerate_denominator_(rate_denominator) {
// This initializes format_, raw_size_, width_, height_ and allocates img. // This initializes format_, raw_size_, width_, height_ and allocates img.
SetSize(width, height, format); SetSize(width, height, format);
@ -45,13 +37,11 @@ class YUVVideoSource : public VideoSource {
virtual ~YUVVideoSource() { virtual ~YUVVideoSource() {
vpx_img_free(img_); vpx_img_free(img_);
if (input_file_) if (input_file_) fclose(input_file_);
fclose(input_file_);
} }
virtual void Begin() { virtual void Begin() {
if (input_file_) if (input_file_) fclose(input_file_);
fclose(input_file_);
input_file_ = OpenTestDataFile(file_name_); input_file_ = OpenTestDataFile(file_name_);
ASSERT_TRUE(input_file_ != NULL) << "Input file open failed. Filename: " ASSERT_TRUE(input_file_ != NULL) << "Input file open failed. Filename: "
<< file_name_; << file_name_;
@ -67,7 +57,7 @@ class YUVVideoSource : public VideoSource {
FillFrame(); FillFrame();
} }
virtual vpx_image_t *img() const { return (frame_ < limit_) ? img_ : NULL; } virtual vpx_image_t *img() const { return (frame_ < limit_) ? img_ : NULL; }
// Models a stream where Timebase = 1/FPS, so pts == frame. // Models a stream where Timebase = 1/FPS, so pts == frame.
virtual vpx_codec_pts_t pts() const { return frame_; } virtual vpx_codec_pts_t pts() const { return frame_; }
@ -93,32 +83,15 @@ class YUVVideoSource : public VideoSource {
height_ = height; height_ = height;
format_ = format; format_ = format;
switch (format) { switch (format) {
case VPX_IMG_FMT_I420: case VPX_IMG_FMT_I420: raw_size_ = width * height * 3 / 2; break;
raw_size_ = width * height * 3 / 2; case VPX_IMG_FMT_I422: raw_size_ = width * height * 2; break;
break; case VPX_IMG_FMT_I440: raw_size_ = width * height * 2; break;
case VPX_IMG_FMT_I422: case VPX_IMG_FMT_I444: raw_size_ = width * height * 3; break;
raw_size_ = width * height * 2; case VPX_IMG_FMT_I42016: raw_size_ = width * height * 3; break;
break; case VPX_IMG_FMT_I42216: raw_size_ = width * height * 4; break;
case VPX_IMG_FMT_I440: case VPX_IMG_FMT_I44016: raw_size_ = width * height * 4; break;
raw_size_ = width * height * 2; case VPX_IMG_FMT_I44416: raw_size_ = width * height * 6; break;
break; default: ASSERT_TRUE(0);
case VPX_IMG_FMT_I444:
raw_size_ = width * height * 3;
break;
case VPX_IMG_FMT_I42016:
raw_size_ = width * height * 3;
break;
case VPX_IMG_FMT_I42216:
raw_size_ = width * height * 4;
break;
case VPX_IMG_FMT_I44016:
raw_size_ = width * height * 4;
break;
case VPX_IMG_FMT_I44416:
raw_size_ = width * height * 6;
break;
default:
ASSERT_TRUE(0);
} }
} }
} }