Merge "Clean up FunctionEquivalenceTest." into nextgenv2
This commit is contained in:
Pascal Massimino
Gerrit Code Review
Коммит
6de0e97d97
|
|
@ -23,14 +23,11 @@
|
|||
|
||||
#include "./vp10_rtcd.h"
|
||||
|
||||
#include "test/acm_random.h"
|
||||
#include "vp10/common/enums.h"
|
||||
|
||||
#include "vpx_dsp/blend.h"
|
||||
|
||||
using libvpx_test::ACMRandom;
|
||||
using libvpx_test::FunctionEquivalenceTest;
|
||||
using std::tr1::make_tuple;
|
||||
|
||||
namespace {
|
||||
|
||||
|
|
@ -44,29 +41,27 @@ class BlendA64Mask1DTest : public FunctionEquivalenceTest<F> {
|
|||
static const int kMaxMaskWidth = 2 * MAX_SB_SIZE;
|
||||
static const int kMaxMaskSize = kMaxMaskWidth;
|
||||
|
||||
BlendA64Mask1DTest() : rng_(ACMRandom::DeterministicSeed()) {}
|
||||
|
||||
virtual ~BlendA64Mask1DTest() {}
|
||||
|
||||
virtual void Execute(T *p_src0, T *p_src1) = 0;
|
||||
virtual void Execute(const T *p_src0, const T *p_src1) = 0;
|
||||
|
||||
void Common() {
|
||||
w_ = 1 << rng_(MAX_SB_SIZE_LOG2 + 1);
|
||||
h_ = 1 << rng_(MAX_SB_SIZE_LOG2 + 1);
|
||||
w_ = 1 << this->rng_(MAX_SB_SIZE_LOG2 + 1);
|
||||
h_ = 1 << this->rng_(MAX_SB_SIZE_LOG2 + 1);
|
||||
|
||||
dst_offset_ = rng_(33);
|
||||
dst_stride_ = rng_(kMaxWidth + 1 - w_) + w_;
|
||||
dst_offset_ = this->rng_(33);
|
||||
dst_stride_ = this->rng_(kMaxWidth + 1 - w_) + w_;
|
||||
|
||||
src0_offset_ = rng_(33);
|
||||
src0_stride_ = rng_(kMaxWidth + 1 - w_) + w_;
|
||||
src0_offset_ = this->rng_(33);
|
||||
src0_stride_ = this->rng_(kMaxWidth + 1 - w_) + w_;
|
||||
|
||||
src1_offset_ = rng_(33);
|
||||
src1_stride_ = rng_(kMaxWidth + 1 - w_) + w_;
|
||||
src1_offset_ = this->rng_(33);
|
||||
src1_stride_ = this->rng_(kMaxWidth + 1 - w_) + w_;
|
||||
|
||||
T *p_src0;
|
||||
T *p_src1;
|
||||
|
||||
switch (rng_(3)) {
|
||||
switch (this->rng_(3)) {
|
||||
case 0: // Separate sources
|
||||
p_src0 = src0_;
|
||||
p_src1 = src1_;
|
||||
|
|
@ -97,8 +92,6 @@ class BlendA64Mask1DTest : public FunctionEquivalenceTest<F> {
|
|||
}
|
||||
}
|
||||
|
||||
ACMRandom rng_;
|
||||
|
||||
T dst_ref_[kBufSize];
|
||||
T dst_tst_[kBufSize];
|
||||
size_t dst_stride_;
|
||||
|
|
@ -126,19 +119,18 @@ typedef void (*F8B)(uint8_t *dst, uint32_t dst_stride,
|
|||
const uint8_t *src0, uint32_t src0_stride,
|
||||
const uint8_t *src1, uint32_t src1_stride,
|
||||
const uint8_t *mask, int h, int w);
|
||||
typedef libvpx_test::FuncParam<F8B> TestFuncs;
|
||||
|
||||
class BlendA64Mask1DTest8B : public BlendA64Mask1DTest<F8B, uint8_t> {
|
||||
protected:
|
||||
void Execute(uint8_t *p_src0, uint8_t *p_src1) {
|
||||
ref_func_(dst_ref_ + dst_offset_, dst_stride_,
|
||||
p_src0 + src0_offset_, src0_stride_,
|
||||
p_src1 + src1_offset_, src1_stride_,
|
||||
mask_, h_, w_);
|
||||
|
||||
tst_func_(dst_tst_ + dst_offset_, dst_stride_,
|
||||
p_src0 + src0_offset_, src0_stride_,
|
||||
p_src1 + src1_offset_, src1_stride_,
|
||||
mask_, h_, w_);
|
||||
void Execute(const uint8_t *p_src0, const uint8_t *p_src1) {
|
||||
params_.ref_func(dst_ref_ + dst_offset_, dst_stride_,
|
||||
p_src0 + src0_offset_, src0_stride_,
|
||||
p_src1 + src1_offset_, src1_stride_, mask_, h_, w_);
|
||||
ASM_REGISTER_STATE_CHECK(
|
||||
params_.tst_func(dst_tst_ + dst_offset_, dst_stride_,
|
||||
p_src0 + src0_offset_, src0_stride_,
|
||||
p_src1 + src1_offset_, src1_stride_, mask_, h_, w_));
|
||||
}
|
||||
};
|
||||
|
||||
|
|
@ -215,16 +207,15 @@ static void blend_a64_vmask_ref(
|
|||
|
||||
INSTANTIATE_TEST_CASE_P(
|
||||
C, BlendA64Mask1DTest8B,
|
||||
::testing::Values(
|
||||
make_tuple(blend_a64_hmask_ref, vpx_blend_a64_hmask_c),
|
||||
make_tuple(blend_a64_vmask_ref, vpx_blend_a64_vmask_c)));
|
||||
::testing::Values(TestFuncs(blend_a64_hmask_ref, vpx_blend_a64_hmask_c),
|
||||
TestFuncs(blend_a64_vmask_ref, vpx_blend_a64_vmask_c)));
|
||||
|
||||
#if HAVE_SSE4_1
|
||||
INSTANTIATE_TEST_CASE_P(
|
||||
SSE4_1, BlendA64Mask1DTest8B,
|
||||
::testing::Values(
|
||||
make_tuple(blend_a64_hmask_ref, vpx_blend_a64_hmask_sse4_1),
|
||||
make_tuple(blend_a64_vmask_ref, vpx_blend_a64_vmask_sse4_1)));
|
||||
TestFuncs(blend_a64_hmask_ref, vpx_blend_a64_hmask_sse4_1),
|
||||
TestFuncs(blend_a64_vmask_ref, vpx_blend_a64_vmask_sse4_1)));
|
||||
#endif // HAVE_SSE4_1
|
||||
|
||||
#if CONFIG_VP9_HIGHBITDEPTH
|
||||
|
|
@ -236,20 +227,20 @@ typedef void (*FHBD)(uint8_t *dst, uint32_t dst_stride,
|
|||
const uint8_t *src0, uint32_t src0_stride,
|
||||
const uint8_t *src1, uint32_t src1_stride,
|
||||
const uint8_t *mask, int h, int w, int bd);
|
||||
typedef libvpx_test::FuncParam<FHBD> TestFuncsHBD;
|
||||
|
||||
class BlendA64Mask1DTestHBD : public BlendA64Mask1DTest<FHBD, uint16_t> {
|
||||
protected:
|
||||
void Execute(uint16_t *p_src0, uint16_t *p_src1) {
|
||||
ref_func_(CONVERT_TO_BYTEPTR(dst_ref_ + dst_offset_), dst_stride_,
|
||||
CONVERT_TO_BYTEPTR(p_src0 + src0_offset_), src0_stride_,
|
||||
CONVERT_TO_BYTEPTR(p_src1 + src1_offset_), src1_stride_,
|
||||
mask_, h_, w_, bit_depth_);
|
||||
|
||||
ASM_REGISTER_STATE_CHECK(
|
||||
tst_func_(CONVERT_TO_BYTEPTR(dst_tst_ + dst_offset_), dst_stride_,
|
||||
CONVERT_TO_BYTEPTR(p_src0 + src0_offset_), src0_stride_,
|
||||
CONVERT_TO_BYTEPTR(p_src1 + src1_offset_), src1_stride_,
|
||||
mask_, h_, w_, bit_depth_));
|
||||
void Execute(const uint16_t *p_src0, const uint16_t *p_src1) {
|
||||
params_.ref_func(CONVERT_TO_BYTEPTR(dst_ref_ + dst_offset_), dst_stride_,
|
||||
CONVERT_TO_BYTEPTR(p_src0 + src0_offset_), src0_stride_,
|
||||
CONVERT_TO_BYTEPTR(p_src1 + src1_offset_), src1_stride_,
|
||||
mask_, h_, w_, bit_depth_);
|
||||
ASM_REGISTER_STATE_CHECK(params_.tst_func(
|
||||
CONVERT_TO_BYTEPTR(dst_tst_ + dst_offset_), dst_stride_,
|
||||
CONVERT_TO_BYTEPTR(p_src0 + src0_offset_), src0_stride_,
|
||||
CONVERT_TO_BYTEPTR(p_src1 + src1_offset_), src1_stride_,
|
||||
mask_, h_, w_, bit_depth_));
|
||||
}
|
||||
|
||||
int bit_depth_;
|
||||
|
|
@ -359,15 +350,17 @@ static void highbd_blend_a64_vmask_ref(
|
|||
INSTANTIATE_TEST_CASE_P(
|
||||
C, BlendA64Mask1DTestHBD,
|
||||
::testing::Values(
|
||||
make_tuple(highbd_blend_a64_hmask_ref, vpx_highbd_blend_a64_hmask_c),
|
||||
make_tuple(highbd_blend_a64_vmask_ref, vpx_highbd_blend_a64_vmask_c)));
|
||||
TestFuncsHBD(highbd_blend_a64_hmask_ref, vpx_highbd_blend_a64_hmask_c),
|
||||
TestFuncsHBD(highbd_blend_a64_vmask_ref, vpx_highbd_blend_a64_vmask_c)));
|
||||
|
||||
#if HAVE_SSE4_1
|
||||
INSTANTIATE_TEST_CASE_P(
|
||||
SSE4_1, BlendA64Mask1DTestHBD,
|
||||
::testing::Values(
|
||||
make_tuple(highbd_blend_a64_hmask_ref, vpx_highbd_blend_a64_hmask_sse4_1),
|
||||
make_tuple(highbd_blend_a64_vmask_ref, vpx_highbd_blend_a64_vmask_sse4_1)));
|
||||
TestFuncsHBD(highbd_blend_a64_hmask_ref,
|
||||
vpx_highbd_blend_a64_hmask_sse4_1),
|
||||
TestFuncsHBD(highbd_blend_a64_vmask_ref,
|
||||
vpx_highbd_blend_a64_vmask_sse4_1)));
|
||||
#endif // HAVE_SSE4_1
|
||||
|
||||
#endif // CONFIG_VP9_HIGHBITDEPTH
|
||||
|
|
|
|||
|
|
@ -23,14 +23,11 @@
|
|||
|
||||
#include "./vp10_rtcd.h"
|
||||
|
||||
#include "test/acm_random.h"
|
||||
#include "vp10/common/enums.h"
|
||||
|
||||
#include "vpx_dsp/blend.h"
|
||||
|
||||
using libvpx_test::ACMRandom;
|
||||
using libvpx_test::FunctionEquivalenceTest;
|
||||
using std::tr1::make_tuple;
|
||||
|
||||
namespace {
|
||||
|
||||
|
|
@ -44,35 +41,33 @@ class BlendA64MaskTest : public FunctionEquivalenceTest<F> {
|
|||
static const int kMaxMaskWidth = 2 * MAX_SB_SIZE;
|
||||
static const int kMaxMaskSize = kMaxMaskWidth * kMaxMaskWidth;
|
||||
|
||||
BlendA64MaskTest() : rng_(ACMRandom::DeterministicSeed()) {}
|
||||
|
||||
virtual ~BlendA64MaskTest() {}
|
||||
|
||||
virtual void Execute(const T *p_src0, const T *p_src1) = 0;
|
||||
|
||||
void Common() {
|
||||
w_ = 1 << rng_(MAX_SB_SIZE_LOG2 + 1);
|
||||
h_ = 1 << rng_(MAX_SB_SIZE_LOG2 + 1);
|
||||
w_ = 1 << this->rng_(MAX_SB_SIZE_LOG2 + 1);
|
||||
h_ = 1 << this->rng_(MAX_SB_SIZE_LOG2 + 1);
|
||||
|
||||
subx_ = rng_(2);
|
||||
suby_ = rng_(2);
|
||||
subx_ = this->rng_(2);
|
||||
suby_ = this->rng_(2);
|
||||
|
||||
dst_offset_ = rng_(33);
|
||||
dst_stride_ = rng_(kMaxWidth + 1 - w_) + w_;
|
||||
dst_offset_ = this->rng_(33);
|
||||
dst_stride_ = this->rng_(kMaxWidth + 1 - w_) + w_;
|
||||
|
||||
src0_offset_ = rng_(33);
|
||||
src0_stride_ = rng_(kMaxWidth + 1 - w_) + w_;
|
||||
src0_offset_ = this->rng_(33);
|
||||
src0_stride_ = this->rng_(kMaxWidth + 1 - w_) + w_;
|
||||
|
||||
src1_offset_ = rng_(33);
|
||||
src1_stride_ = rng_(kMaxWidth + 1 - w_) + w_;
|
||||
src1_offset_ = this->rng_(33);
|
||||
src1_stride_ = this->rng_(kMaxWidth + 1 - w_) + w_;
|
||||
|
||||
mask_stride_ = rng_(kMaxWidth + 1 - w_ * (subx_ ? 2 : 1))
|
||||
+ w_ * (subx_ ? 2 : 1);
|
||||
mask_stride_ = this->rng_(kMaxWidth + 1 - w_ * (subx_ ? 2 : 1)) +
|
||||
w_ * (subx_ ? 2 : 1);
|
||||
|
||||
T *p_src0;
|
||||
T *p_src1;
|
||||
|
||||
switch (rng_(3)) {
|
||||
switch (this->rng_(3)) {
|
||||
case 0: // Separate sources
|
||||
p_src0 = src0_;
|
||||
p_src1 = src1_;
|
||||
|
|
@ -103,8 +98,6 @@ class BlendA64MaskTest : public FunctionEquivalenceTest<F> {
|
|||
}
|
||||
}
|
||||
|
||||
ACMRandom rng_;
|
||||
|
||||
T dst_ref_[kBufSize];
|
||||
T dst_tst_[kBufSize];
|
||||
size_t dst_stride_;
|
||||
|
|
@ -137,21 +130,20 @@ typedef void (*F8B)(uint8_t *dst, uint32_t dst_stride,
|
|||
const uint8_t *src1, uint32_t src1_stride,
|
||||
const uint8_t *mask, uint32_t mask_stride,
|
||||
int h, int w, int suby, int subx);
|
||||
typedef libvpx_test::FuncParam<F8B> TestFuncs;
|
||||
|
||||
class BlendA64MaskTest8B : public BlendA64MaskTest<F8B, uint8_t> {
|
||||
protected:
|
||||
void Execute(const uint8_t *p_src0, const uint8_t *p_src1) {
|
||||
ref_func_(dst_ref_ + dst_offset_, dst_stride_,
|
||||
p_src0 + src0_offset_, src0_stride_,
|
||||
p_src1 + src1_offset_, src1_stride_,
|
||||
mask_, kMaxMaskWidth,
|
||||
h_, w_, suby_, subx_);
|
||||
|
||||
tst_func_(dst_tst_ + dst_offset_, dst_stride_,
|
||||
p_src0 + src0_offset_, src0_stride_,
|
||||
p_src1 + src1_offset_, src1_stride_,
|
||||
mask_, kMaxMaskWidth,
|
||||
h_, w_, suby_, subx_);
|
||||
params_.ref_func(dst_ref_ + dst_offset_, dst_stride_,
|
||||
p_src0 + src0_offset_, src0_stride_,
|
||||
p_src1 + src1_offset_, src1_stride_,
|
||||
mask_, kMaxMaskWidth, h_, w_, suby_, subx_);
|
||||
ASM_REGISTER_STATE_CHECK(
|
||||
params_.tst_func(dst_tst_ + dst_offset_, dst_stride_,
|
||||
p_src0 + src0_offset_, src0_stride_,
|
||||
p_src1 + src1_offset_, src1_stride_,
|
||||
mask_, kMaxMaskWidth, h_, w_, suby_, subx_));
|
||||
}
|
||||
};
|
||||
|
||||
|
|
@ -191,8 +183,8 @@ TEST_P(BlendA64MaskTest8B, ExtremeValues) {
|
|||
#if HAVE_SSE4_1
|
||||
INSTANTIATE_TEST_CASE_P(
|
||||
SSE4_1_C_COMPARE, BlendA64MaskTest8B,
|
||||
::testing::Values(make_tuple(vpx_blend_a64_mask_c,
|
||||
vpx_blend_a64_mask_sse4_1)));
|
||||
::testing::Values(
|
||||
TestFuncs(vpx_blend_a64_mask_c, vpx_blend_a64_mask_sse4_1)));
|
||||
#endif // HAVE_SSE4_1
|
||||
|
||||
#if CONFIG_VP9_HIGHBITDEPTH
|
||||
|
|
@ -205,22 +197,20 @@ typedef void (*FHBD)(uint8_t *dst, uint32_t dst_stride,
|
|||
const uint8_t *src1, uint32_t src1_stride,
|
||||
const uint8_t *mask, uint32_t mask_stride,
|
||||
int h, int w, int suby, int subx, int bd);
|
||||
typedef libvpx_test::FuncParam<FHBD> TestFuncsHBD;
|
||||
|
||||
class BlendA64MaskTestHBD : public BlendA64MaskTest<FHBD, uint16_t> {
|
||||
protected:
|
||||
void Execute(const uint16_t *p_src0, const uint16_t *p_src1) {
|
||||
ref_func_(CONVERT_TO_BYTEPTR(dst_ref_ + dst_offset_), dst_stride_,
|
||||
CONVERT_TO_BYTEPTR(p_src0 + src0_offset_), src0_stride_,
|
||||
CONVERT_TO_BYTEPTR(p_src1 + src1_offset_), src1_stride_,
|
||||
mask_, kMaxMaskWidth,
|
||||
h_, w_, suby_, subx_, bit_depth_);
|
||||
|
||||
ASM_REGISTER_STATE_CHECK(
|
||||
tst_func_(CONVERT_TO_BYTEPTR(dst_tst_ + dst_offset_), dst_stride_,
|
||||
CONVERT_TO_BYTEPTR(p_src0 + src0_offset_), src0_stride_,
|
||||
CONVERT_TO_BYTEPTR(p_src1 + src1_offset_), src1_stride_,
|
||||
mask_, kMaxMaskWidth,
|
||||
h_, w_, suby_, subx_, bit_depth_));
|
||||
params_.ref_func(CONVERT_TO_BYTEPTR(dst_ref_ + dst_offset_), dst_stride_,
|
||||
CONVERT_TO_BYTEPTR(p_src0 + src0_offset_), src0_stride_,
|
||||
CONVERT_TO_BYTEPTR(p_src1 + src1_offset_), src1_stride_,
|
||||
mask_, kMaxMaskWidth, h_, w_, suby_, subx_, bit_depth_);
|
||||
ASM_REGISTER_STATE_CHECK(params_.tst_func(
|
||||
CONVERT_TO_BYTEPTR(dst_tst_ + dst_offset_), dst_stride_,
|
||||
CONVERT_TO_BYTEPTR(p_src0 + src0_offset_), src0_stride_,
|
||||
CONVERT_TO_BYTEPTR(p_src1 + src1_offset_), src1_stride_,
|
||||
mask_, kMaxMaskWidth, h_, w_, suby_, subx_, bit_depth_));
|
||||
}
|
||||
|
||||
int bit_depth_;
|
||||
|
|
@ -290,8 +280,9 @@ TEST_P(BlendA64MaskTestHBD, ExtremeValues) {
|
|||
#if HAVE_SSE4_1
|
||||
INSTANTIATE_TEST_CASE_P(
|
||||
SSE4_1_C_COMPARE, BlendA64MaskTestHBD,
|
||||
::testing::Values(make_tuple(vpx_highbd_blend_a64_mask_c,
|
||||
vpx_highbd_blend_a64_mask_sse4_1)));
|
||||
::testing::Values(
|
||||
TestFuncsHBD(vpx_highbd_blend_a64_mask_c,
|
||||
vpx_highbd_blend_a64_mask_sse4_1)));
|
||||
#endif // HAVE_SSE4_1
|
||||
#endif // CONFIG_VP9_HIGHBITDEPTH
|
||||
} // namespace
|
||||
|
|
|
|||
|
|
@ -12,19 +12,44 @@
|
|||
#define TEST_FUNCTION_EQUIVALENCE_TEST_H_
|
||||
|
||||
#include "third_party/googletest/src/include/gtest/gtest.h"
|
||||
#include "test/acm_random.h"
|
||||
#include "test/clear_system_state.h"
|
||||
#include "test/util.h"
|
||||
|
||||
using libvpx_test::ACMRandom;
|
||||
|
||||
namespace libvpx_test {
|
||||
// Base class for tests that compare 2 implementations of the same function
|
||||
// for equivalence. The template parameter should be pointer to a function
|
||||
// that is being tested.
|
||||
//
|
||||
// The test takes a 3-parameters encapsulating struct 'FuncParam', containing:
|
||||
// - Pointer to reference function
|
||||
// - Pointer to tested function
|
||||
// - Integer bit depth (default to 0).
|
||||
//
|
||||
// These values are then accessible in the tests as member of params_:
|
||||
// params_.ref_func, params_.tst_func, and params_.bit_depth.
|
||||
//
|
||||
|
||||
template <typename T>
|
||||
class FunctionEquivalenceTest :
|
||||
public ::testing::TestWithParam< std::tr1::tuple< T, T > > {
|
||||
struct FuncParam {
|
||||
FuncParam(T ref = NULL, T tst = NULL, int bit_depth = 0)
|
||||
: ref_func(ref), tst_func(tst), bit_depth(bit_depth) {}
|
||||
T ref_func;
|
||||
T tst_func;
|
||||
int bit_depth;
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
class FunctionEquivalenceTest : public ::testing::TestWithParam<FuncParam<T> > {
|
||||
public:
|
||||
FunctionEquivalenceTest() : rng_(ACMRandom::DeterministicSeed()) {}
|
||||
|
||||
virtual ~FunctionEquivalenceTest() {}
|
||||
|
||||
virtual void SetUp() {
|
||||
ref_func_ = std::tr1::get<0>(this->GetParam());
|
||||
tst_func_ = std::tr1::get<1>(this->GetParam());
|
||||
params_ = this->GetParam();
|
||||
}
|
||||
|
||||
virtual void TearDown() {
|
||||
|
|
@ -32,8 +57,8 @@ class FunctionEquivalenceTest :
|
|||
}
|
||||
|
||||
protected:
|
||||
T ref_func_;
|
||||
T tst_func_;
|
||||
ACMRandom rng_;
|
||||
FuncParam<T> params_;
|
||||
};
|
||||
|
||||
} // namespace libvpx_test
|
||||
|
|
|
|||
|
|
@ -9,9 +9,9 @@
|
|||
*/
|
||||
|
||||
#include "third_party/googletest/src/include/gtest/gtest.h"
|
||||
#include "test/acm_random.h"
|
||||
|
||||
#include "test/function_equivalence_test.h"
|
||||
#include "test/register_state_check.h"
|
||||
|
||||
#include "./vpx_config.h"
|
||||
#include "./vpx_dsp_rtcd.h"
|
||||
|
|
@ -19,9 +19,6 @@
|
|||
|
||||
#define MAX_SB_SQUARE (MAX_SB_SIZE * MAX_SB_SIZE)
|
||||
|
||||
using std::tr1::make_tuple;
|
||||
|
||||
using libvpx_test::ACMRandom;
|
||||
using libvpx_test::FunctionEquivalenceTest;
|
||||
|
||||
namespace {
|
||||
|
|
@ -31,18 +28,13 @@ static const int kMaskMax = 64;
|
|||
|
||||
typedef unsigned int (*ObmcSadF)(const uint8_t *pre, int pre_stride,
|
||||
const int32_t *wsrc, const int32_t *mask);
|
||||
typedef libvpx_test::FuncParam<ObmcSadF> TestFuncs;
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// 8 bit
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
class ObmcSadTest : public FunctionEquivalenceTest<ObmcSadF> {
|
||||
public:
|
||||
ObmcSadTest() : rng_(ACMRandom::DeterministicSeed()) {}
|
||||
|
||||
protected:
|
||||
ACMRandom rng_;
|
||||
};
|
||||
class ObmcSadTest : public FunctionEquivalenceTest<ObmcSadF> {};
|
||||
|
||||
TEST_P(ObmcSadTest, RandomValues) {
|
||||
DECLARE_ALIGNED(32, uint8_t, pre[MAX_SB_SQUARE]);
|
||||
|
|
@ -58,8 +50,10 @@ TEST_P(ObmcSadTest, RandomValues) {
|
|||
mask[i] = rng_(kMaskMax * kMaskMax + 1);
|
||||
}
|
||||
|
||||
const unsigned int ref_res = ref_func_(pre, pre_stride, wsrc, mask);
|
||||
const unsigned int tst_res = tst_func_(pre, pre_stride, wsrc, mask);
|
||||
const unsigned int ref_res = params_.ref_func(pre, pre_stride, wsrc, mask);
|
||||
unsigned int tst_res;
|
||||
ASM_REGISTER_STATE_CHECK(tst_res =
|
||||
params_.tst_func(pre, pre_stride, wsrc, mask));
|
||||
|
||||
ASSERT_EQ(ref_res, tst_res);
|
||||
}
|
||||
|
|
@ -79,8 +73,10 @@ TEST_P(ObmcSadTest, ExtremeValues) {
|
|||
mask[i] = kMaskMax * kMaskMax;
|
||||
}
|
||||
|
||||
const unsigned int ref_res = ref_func_(pre, pre_stride, wsrc, mask);
|
||||
const unsigned int tst_res = tst_func_(pre, pre_stride, wsrc, mask);
|
||||
const unsigned int ref_res = params_.ref_func(pre, pre_stride, wsrc, mask);
|
||||
unsigned int tst_res;
|
||||
ASM_REGISTER_STATE_CHECK(tst_res =
|
||||
params_.tst_func(pre, pre_stride, wsrc, mask));
|
||||
|
||||
ASSERT_EQ(ref_res, tst_res);
|
||||
}
|
||||
|
|
@ -89,23 +85,23 @@ TEST_P(ObmcSadTest, ExtremeValues) {
|
|||
#if HAVE_SSE4_1
|
||||
const ObmcSadTest::ParamType sse4_functions[] = {
|
||||
#if CONFIG_EXT_PARTITION
|
||||
make_tuple(vpx_obmc_sad128x128_c, vpx_obmc_sad128x128_sse4_1),
|
||||
make_tuple(vpx_obmc_sad128x64_c, vpx_obmc_sad128x64_sse4_1),
|
||||
make_tuple(vpx_obmc_sad64x128_c, vpx_obmc_sad64x128_sse4_1),
|
||||
TestFuncs(vpx_obmc_sad128x128_c, vpx_obmc_sad128x128_sse4_1),
|
||||
TestFuncs(vpx_obmc_sad128x64_c, vpx_obmc_sad128x64_sse4_1),
|
||||
TestFuncs(vpx_obmc_sad64x128_c, vpx_obmc_sad64x128_sse4_1),
|
||||
#endif // CONFIG_EXT_PARTITION
|
||||
make_tuple(vpx_obmc_sad64x64_c, vpx_obmc_sad64x64_sse4_1),
|
||||
make_tuple(vpx_obmc_sad64x32_c, vpx_obmc_sad64x32_sse4_1),
|
||||
make_tuple(vpx_obmc_sad32x64_c, vpx_obmc_sad32x64_sse4_1),
|
||||
make_tuple(vpx_obmc_sad32x32_c, vpx_obmc_sad32x32_sse4_1),
|
||||
make_tuple(vpx_obmc_sad32x16_c, vpx_obmc_sad32x16_sse4_1),
|
||||
make_tuple(vpx_obmc_sad16x32_c, vpx_obmc_sad16x32_sse4_1),
|
||||
make_tuple(vpx_obmc_sad16x16_c, vpx_obmc_sad16x16_sse4_1),
|
||||
make_tuple(vpx_obmc_sad16x8_c, vpx_obmc_sad16x8_sse4_1),
|
||||
make_tuple(vpx_obmc_sad8x16_c, vpx_obmc_sad8x16_sse4_1),
|
||||
make_tuple(vpx_obmc_sad8x8_c, vpx_obmc_sad8x8_sse4_1),
|
||||
make_tuple(vpx_obmc_sad8x4_c, vpx_obmc_sad8x4_sse4_1),
|
||||
make_tuple(vpx_obmc_sad4x8_c, vpx_obmc_sad4x8_sse4_1),
|
||||
make_tuple(vpx_obmc_sad4x4_c, vpx_obmc_sad4x4_sse4_1)
|
||||
TestFuncs(vpx_obmc_sad64x64_c, vpx_obmc_sad64x64_sse4_1),
|
||||
TestFuncs(vpx_obmc_sad64x32_c, vpx_obmc_sad64x32_sse4_1),
|
||||
TestFuncs(vpx_obmc_sad32x64_c, vpx_obmc_sad32x64_sse4_1),
|
||||
TestFuncs(vpx_obmc_sad32x32_c, vpx_obmc_sad32x32_sse4_1),
|
||||
TestFuncs(vpx_obmc_sad32x16_c, vpx_obmc_sad32x16_sse4_1),
|
||||
TestFuncs(vpx_obmc_sad16x32_c, vpx_obmc_sad16x32_sse4_1),
|
||||
TestFuncs(vpx_obmc_sad16x16_c, vpx_obmc_sad16x16_sse4_1),
|
||||
TestFuncs(vpx_obmc_sad16x8_c, vpx_obmc_sad16x8_sse4_1),
|
||||
TestFuncs(vpx_obmc_sad8x16_c, vpx_obmc_sad8x16_sse4_1),
|
||||
TestFuncs(vpx_obmc_sad8x8_c, vpx_obmc_sad8x8_sse4_1),
|
||||
TestFuncs(vpx_obmc_sad8x4_c, vpx_obmc_sad8x4_sse4_1),
|
||||
TestFuncs(vpx_obmc_sad4x8_c, vpx_obmc_sad4x8_sse4_1),
|
||||
TestFuncs(vpx_obmc_sad4x4_c, vpx_obmc_sad4x4_sse4_1)
|
||||
};
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(SSE4_1_C_COMPARE, ObmcSadTest,
|
||||
|
|
@ -117,13 +113,7 @@ INSTANTIATE_TEST_CASE_P(SSE4_1_C_COMPARE, ObmcSadTest,
|
|||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#if CONFIG_VP9_HIGHBITDEPTH
|
||||
class ObmcSadHBDTest : public FunctionEquivalenceTest<ObmcSadF> {
|
||||
public:
|
||||
ObmcSadHBDTest() : rng_(ACMRandom::DeterministicSeed()) {}
|
||||
|
||||
protected:
|
||||
ACMRandom rng_;
|
||||
};
|
||||
class ObmcSadHBDTest : public FunctionEquivalenceTest<ObmcSadF> {};
|
||||
|
||||
TEST_P(ObmcSadHBDTest, RandomValues) {
|
||||
DECLARE_ALIGNED(32, uint16_t, pre[MAX_SB_SQUARE]);
|
||||
|
|
@ -139,10 +129,11 @@ TEST_P(ObmcSadHBDTest, RandomValues) {
|
|||
mask[i] = rng_(kMaskMax * kMaskMax + 1);
|
||||
}
|
||||
|
||||
const unsigned int ref_res = ref_func_(CONVERT_TO_BYTEPTR(pre), pre_stride,
|
||||
wsrc, mask);
|
||||
const unsigned int tst_res = tst_func_(CONVERT_TO_BYTEPTR(pre), pre_stride,
|
||||
wsrc, mask);
|
||||
const unsigned int ref_res =
|
||||
params_.ref_func(CONVERT_TO_BYTEPTR(pre), pre_stride, wsrc, mask);
|
||||
unsigned int tst_res;
|
||||
ASM_REGISTER_STATE_CHECK(tst_res =
|
||||
params_.tst_func(CONVERT_TO_BYTEPTR(pre), pre_stride, wsrc, mask));
|
||||
|
||||
ASSERT_EQ(ref_res, tst_res);
|
||||
}
|
||||
|
|
@ -162,10 +153,11 @@ TEST_P(ObmcSadHBDTest, ExtremeValues) {
|
|||
mask[i] = kMaskMax * kMaskMax;
|
||||
}
|
||||
|
||||
const unsigned int ref_res = ref_func_(CONVERT_TO_BYTEPTR(pre), pre_stride,
|
||||
wsrc, mask);
|
||||
const unsigned int tst_res = tst_func_(CONVERT_TO_BYTEPTR(pre), pre_stride,
|
||||
wsrc, mask);
|
||||
const unsigned int ref_res =
|
||||
params_.ref_func(CONVERT_TO_BYTEPTR(pre), pre_stride, wsrc, mask);
|
||||
unsigned int tst_res;
|
||||
ASM_REGISTER_STATE_CHECK(tst_res =
|
||||
params_.tst_func(CONVERT_TO_BYTEPTR(pre), pre_stride, wsrc, mask));
|
||||
|
||||
ASSERT_EQ(ref_res, tst_res);
|
||||
}
|
||||
|
|
@ -174,23 +166,23 @@ TEST_P(ObmcSadHBDTest, ExtremeValues) {
|
|||
#if HAVE_SSE4_1
|
||||
ObmcSadHBDTest::ParamType sse4_functions_hbd[] = {
|
||||
#if CONFIG_EXT_PARTITION
|
||||
make_tuple(vpx_highbd_obmc_sad128x128_c, vpx_highbd_obmc_sad128x128_sse4_1),
|
||||
make_tuple(vpx_highbd_obmc_sad128x64_c, vpx_highbd_obmc_sad128x64_sse4_1),
|
||||
make_tuple(vpx_highbd_obmc_sad64x128_c, vpx_highbd_obmc_sad64x128_sse4_1),
|
||||
TestFuncs(vpx_highbd_obmc_sad128x128_c, vpx_highbd_obmc_sad128x128_sse4_1),
|
||||
TestFuncs(vpx_highbd_obmc_sad128x64_c, vpx_highbd_obmc_sad128x64_sse4_1),
|
||||
TestFuncs(vpx_highbd_obmc_sad64x128_c, vpx_highbd_obmc_sad64x128_sse4_1),
|
||||
#endif // CONFIG_EXT_PARTITION
|
||||
make_tuple(vpx_highbd_obmc_sad64x64_c, vpx_highbd_obmc_sad64x64_sse4_1),
|
||||
make_tuple(vpx_highbd_obmc_sad64x32_c, vpx_highbd_obmc_sad64x32_sse4_1),
|
||||
make_tuple(vpx_highbd_obmc_sad32x64_c, vpx_highbd_obmc_sad32x64_sse4_1),
|
||||
make_tuple(vpx_highbd_obmc_sad32x32_c, vpx_highbd_obmc_sad32x32_sse4_1),
|
||||
make_tuple(vpx_highbd_obmc_sad32x16_c, vpx_highbd_obmc_sad32x16_sse4_1),
|
||||
make_tuple(vpx_highbd_obmc_sad16x32_c, vpx_highbd_obmc_sad16x32_sse4_1),
|
||||
make_tuple(vpx_highbd_obmc_sad16x16_c, vpx_highbd_obmc_sad16x16_sse4_1),
|
||||
make_tuple(vpx_highbd_obmc_sad16x8_c, vpx_highbd_obmc_sad16x8_sse4_1),
|
||||
make_tuple(vpx_highbd_obmc_sad8x16_c, vpx_highbd_obmc_sad8x16_sse4_1),
|
||||
make_tuple(vpx_highbd_obmc_sad8x8_c, vpx_highbd_obmc_sad8x8_sse4_1),
|
||||
make_tuple(vpx_highbd_obmc_sad8x4_c, vpx_highbd_obmc_sad8x4_sse4_1),
|
||||
make_tuple(vpx_highbd_obmc_sad4x8_c, vpx_highbd_obmc_sad4x8_sse4_1),
|
||||
make_tuple(vpx_highbd_obmc_sad4x4_c, vpx_highbd_obmc_sad4x4_sse4_1)
|
||||
TestFuncs(vpx_highbd_obmc_sad64x64_c, vpx_highbd_obmc_sad64x64_sse4_1),
|
||||
TestFuncs(vpx_highbd_obmc_sad64x32_c, vpx_highbd_obmc_sad64x32_sse4_1),
|
||||
TestFuncs(vpx_highbd_obmc_sad32x64_c, vpx_highbd_obmc_sad32x64_sse4_1),
|
||||
TestFuncs(vpx_highbd_obmc_sad32x32_c, vpx_highbd_obmc_sad32x32_sse4_1),
|
||||
TestFuncs(vpx_highbd_obmc_sad32x16_c, vpx_highbd_obmc_sad32x16_sse4_1),
|
||||
TestFuncs(vpx_highbd_obmc_sad16x32_c, vpx_highbd_obmc_sad16x32_sse4_1),
|
||||
TestFuncs(vpx_highbd_obmc_sad16x16_c, vpx_highbd_obmc_sad16x16_sse4_1),
|
||||
TestFuncs(vpx_highbd_obmc_sad16x8_c, vpx_highbd_obmc_sad16x8_sse4_1),
|
||||
TestFuncs(vpx_highbd_obmc_sad8x16_c, vpx_highbd_obmc_sad8x16_sse4_1),
|
||||
TestFuncs(vpx_highbd_obmc_sad8x8_c, vpx_highbd_obmc_sad8x8_sse4_1),
|
||||
TestFuncs(vpx_highbd_obmc_sad8x4_c, vpx_highbd_obmc_sad8x4_sse4_1),
|
||||
TestFuncs(vpx_highbd_obmc_sad4x8_c, vpx_highbd_obmc_sad4x8_sse4_1),
|
||||
TestFuncs(vpx_highbd_obmc_sad4x4_c, vpx_highbd_obmc_sad4x4_sse4_1)
|
||||
};
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(SSE4_1_C_COMPARE, ObmcSadHBDTest,
|
||||
|
|
|
|||
|
|
@ -31,25 +31,21 @@ const int kNumIterations = 10000;
|
|||
|
||||
static const int16_t kInt13Max = (1 << 12) - 1;
|
||||
|
||||
typedef uint64_t (*SSI16Func)(const int16_t *src,
|
||||
int stride ,
|
||||
int size);
|
||||
typedef uint64_t (*SSI16Func)(const int16_t *src, int stride, int size);
|
||||
typedef libvpx_test::FuncParam<SSI16Func> TestFuncs;
|
||||
|
||||
typedef std::tr1::tuple<SSI16Func, SSI16Func> SumSquaresParam;
|
||||
|
||||
class SumSquaresTest : public ::testing::TestWithParam<SumSquaresParam> {
|
||||
class SumSquaresTest :
|
||||
public ::testing::TestWithParam<TestFuncs> {
|
||||
public:
|
||||
virtual ~SumSquaresTest() {}
|
||||
virtual void SetUp() {
|
||||
ref_func_ = GET_PARAM(0);
|
||||
tst_func_ = GET_PARAM(1);
|
||||
params_ = this->GetParam();
|
||||
}
|
||||
|
||||
virtual void TearDown() { libvpx_test::ClearSystemState(); }
|
||||
|
||||
protected:
|
||||
SSI16Func ref_func_;
|
||||
SSI16Func tst_func_;
|
||||
TestFuncs params_;
|
||||
};
|
||||
|
||||
TEST_P(SumSquaresTest, OperationCheck) {
|
||||
|
|
@ -74,9 +70,9 @@ TEST_P(SumSquaresTest, OperationCheck) {
|
|||
}
|
||||
}
|
||||
|
||||
uint64_t res_ref = ref_func_(src, stride, size);
|
||||
const uint64_t res_ref = params_.ref_func(src, stride, size);
|
||||
uint64_t res_tst;
|
||||
ASM_REGISTER_STATE_CHECK(res_tst = tst_func_(src, stride, size));
|
||||
ASM_REGISTER_STATE_CHECK(res_tst = params_.tst_func(src, stride, size));
|
||||
|
||||
if (!failed) {
|
||||
failed = res_ref != res_tst;
|
||||
|
|
@ -110,9 +106,9 @@ TEST_P(SumSquaresTest, ExtremeValues) {
|
|||
}
|
||||
}
|
||||
|
||||
uint64_t res_ref = ref_func_(src, stride, size);
|
||||
const uint64_t res_ref = params_.ref_func(src, stride, size);
|
||||
uint64_t res_tst;
|
||||
ASM_REGISTER_STATE_CHECK(res_tst = tst_func_(src, stride, size));
|
||||
ASM_REGISTER_STATE_CHECK(res_tst = params_.tst_func(src, stride, size));
|
||||
|
||||
if (!failed) {
|
||||
failed = res_ref != res_tst;
|
||||
|
|
@ -122,16 +118,14 @@ TEST_P(SumSquaresTest, ExtremeValues) {
|
|||
}
|
||||
}
|
||||
}
|
||||
using std::tr1::make_tuple;
|
||||
|
||||
#if HAVE_SSE2
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(
|
||||
SSE2, SumSquaresTest,
|
||||
::testing::Values(
|
||||
make_tuple(&vpx_sum_squares_2d_i16_c, &vpx_sum_squares_2d_i16_sse2)
|
||||
)
|
||||
);
|
||||
TestFuncs(&vpx_sum_squares_2d_i16_c, &vpx_sum_squares_2d_i16_sse2)));
|
||||
|
||||
#endif // HAVE_SSE2
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
|
@ -139,15 +133,12 @@ INSTANTIATE_TEST_CASE_P(
|
|||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
typedef uint64_t (*F1D)(const int16_t *src, uint32_t N);
|
||||
typedef libvpx_test::FuncParam<F1D> TestFuncs1D;
|
||||
|
||||
class SumSquares1DTest : public FunctionEquivalenceTest<F1D> {
|
||||
protected:
|
||||
SumSquares1DTest() : rng_(ACMRandom::DeterministicSeed()) {}
|
||||
|
||||
static const int kIterations = 1000;
|
||||
static const int kMaxSize = 256;
|
||||
|
||||
ACMRandom rng_;
|
||||
};
|
||||
|
||||
TEST_P(SumSquares1DTest, RandomValues) {
|
||||
|
|
@ -160,8 +151,9 @@ TEST_P(SumSquares1DTest, RandomValues) {
|
|||
const int N = rng_(2) ? rng_(kMaxSize * kMaxSize + 1 - kMaxSize) + kMaxSize
|
||||
: rng_(kMaxSize) + 1;
|
||||
|
||||
const uint64_t ref_res = ref_func_(src, N);
|
||||
const uint64_t tst_res = tst_func_(src, N);
|
||||
const uint64_t ref_res = params_.ref_func(src, N);
|
||||
uint64_t tst_res;
|
||||
ASM_REGISTER_STATE_CHECK(tst_res = params_.tst_func(src, N));
|
||||
|
||||
ASSERT_EQ(ref_res, tst_res);
|
||||
}
|
||||
|
|
@ -182,21 +174,19 @@ TEST_P(SumSquares1DTest, ExtremeValues) {
|
|||
const int N = rng_(2) ? rng_(kMaxSize * kMaxSize + 1 - kMaxSize) + kMaxSize
|
||||
: rng_(kMaxSize) + 1;
|
||||
|
||||
const uint64_t ref_res = ref_func_(src, N);
|
||||
const uint64_t tst_res = tst_func_(src, N);
|
||||
const uint64_t ref_res = params_.ref_func(src, N);
|
||||
uint64_t tst_res;
|
||||
ASM_REGISTER_STATE_CHECK(tst_res = params_.tst_func(src, N));
|
||||
|
||||
ASSERT_EQ(ref_res, tst_res);
|
||||
}
|
||||
}
|
||||
|
||||
using std::tr1::make_tuple;
|
||||
|
||||
#if HAVE_SSE2
|
||||
INSTANTIATE_TEST_CASE_P(
|
||||
SSE2, SumSquares1DTest,
|
||||
::testing::Values(
|
||||
make_tuple(&vpx_sum_squares_i16_c, &vpx_sum_squares_i16_sse2)
|
||||
)
|
||||
);
|
||||
TestFuncs1D(vpx_sum_squares_i16_c, vpx_sum_squares_i16_sse2)));
|
||||
|
||||
#endif // HAVE_SSE2
|
||||
} // namespace
|
||||
|
|
|
|||
|
|
@ -21,11 +21,11 @@
|
|||
|
||||
#include "test/acm_random.h"
|
||||
#include "test/function_equivalence_test.h"
|
||||
#include "test/register_state_check.h"
|
||||
|
||||
#define WEDGE_WEIGHT_BITS 6
|
||||
#define MAX_MASK_VALUE (1 << (WEDGE_WEIGHT_BITS))
|
||||
|
||||
using std::tr1::make_tuple;
|
||||
using libvpx_test::ACMRandom;
|
||||
using libvpx_test::FunctionEquivalenceTest;
|
||||
|
||||
|
|
@ -154,8 +154,8 @@ TEST_F(WedgeUtilsSSEFuncTest, ResidualBlendingMethod) {
|
|||
for (int i = 0 ; i < N ; i++)
|
||||
r0[i] = r1[i] + d[i];
|
||||
|
||||
uint64_t ref_res = sse_from_residuals(r0, r1, m, N);
|
||||
uint64_t tst_res = vp10_wedge_sse_from_residuals(r1, d, m, N);
|
||||
const uint64_t ref_res = sse_from_residuals(r0, r1, m, N);
|
||||
const uint64_t tst_res = vp10_wedge_sse_from_residuals(r1, d, m, N);
|
||||
|
||||
ASSERT_EQ(ref_res, tst_res);
|
||||
}
|
||||
|
|
@ -169,14 +169,11 @@ typedef uint64_t (*FSSE)(const int16_t *r1,
|
|||
const int16_t *d,
|
||||
const uint8_t *m,
|
||||
int N);
|
||||
typedef libvpx_test::FuncParam<FSSE> TestFuncsFSSE;
|
||||
|
||||
class WedgeUtilsSSEOptTest : public FunctionEquivalenceTest<FSSE> {
|
||||
protected:
|
||||
WedgeUtilsSSEOptTest() : rng_(ACMRandom::DeterministicSeed()) {}
|
||||
|
||||
static const int kIterations = 10000;
|
||||
|
||||
ACMRandom rng_;
|
||||
};
|
||||
|
||||
TEST_P(WedgeUtilsSSEOptTest, RandomValues) {
|
||||
|
|
@ -193,8 +190,9 @@ TEST_P(WedgeUtilsSSEOptTest, RandomValues) {
|
|||
|
||||
const int N = 64 * (rng_(MAX_SB_SQUARE/64) + 1);
|
||||
|
||||
const uint64_t ref_res = ref_func_(r1, d, m, N);
|
||||
const uint64_t tst_res = tst_func_(r1, d, m, N);
|
||||
const uint64_t ref_res = params_.ref_func(r1, d, m, N);
|
||||
uint64_t tst_res;
|
||||
ASM_REGISTER_STATE_CHECK(tst_res = params_.tst_func(r1, d, m, N));
|
||||
|
||||
ASSERT_EQ(ref_res, tst_res);
|
||||
}
|
||||
|
|
@ -227,8 +225,9 @@ TEST_P(WedgeUtilsSSEOptTest, ExtremeValues) {
|
|||
|
||||
const int N = 64 * (rng_(MAX_SB_SQUARE/64) + 1);
|
||||
|
||||
const uint64_t ref_res = ref_func_(r1, d, m, N);
|
||||
const uint64_t tst_res = tst_func_(r1, d, m, N);
|
||||
const uint64_t ref_res = params_.ref_func(r1, d, m, N);
|
||||
uint64_t tst_res;
|
||||
ASM_REGISTER_STATE_CHECK(tst_res = params_.tst_func(r1, d, m, N));
|
||||
|
||||
ASSERT_EQ(ref_res, tst_res);
|
||||
}
|
||||
|
|
@ -238,10 +237,9 @@ TEST_P(WedgeUtilsSSEOptTest, ExtremeValues) {
|
|||
INSTANTIATE_TEST_CASE_P(
|
||||
SSE2, WedgeUtilsSSEOptTest,
|
||||
::testing::Values(
|
||||
make_tuple(&vp10_wedge_sse_from_residuals_c,
|
||||
&vp10_wedge_sse_from_residuals_sse2)
|
||||
)
|
||||
);
|
||||
TestFuncsFSSE(vp10_wedge_sse_from_residuals_c,
|
||||
vp10_wedge_sse_from_residuals_sse2)));
|
||||
|
||||
#endif // HAVE_SSE2
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
|
@ -252,15 +250,12 @@ typedef int (*FSign)(const int16_t *ds,
|
|||
const uint8_t *m,
|
||||
int N,
|
||||
int64_t limit);
|
||||
typedef libvpx_test::FuncParam<FSign> TestFuncsFSign;
|
||||
|
||||
class WedgeUtilsSignOptTest : public FunctionEquivalenceTest<FSign> {
|
||||
protected:
|
||||
WedgeUtilsSignOptTest() : rng_(ACMRandom::DeterministicSeed()) {}
|
||||
|
||||
static const int kIterations = 10000;
|
||||
static const int kMaxSize = 8196; // Size limited by SIMD implementation.
|
||||
|
||||
ACMRandom rng_;
|
||||
};
|
||||
|
||||
TEST_P(WedgeUtilsSignOptTest, RandomValues) {
|
||||
|
|
@ -287,8 +282,9 @@ TEST_P(WedgeUtilsSignOptTest, RandomValues) {
|
|||
for (int i = 0 ; i < N ; i++)
|
||||
ds[i] = clamp(r0[i]*r0[i] - r1[i]*r1[i], INT16_MIN, INT16_MAX);
|
||||
|
||||
const int ref_res = ref_func_(ds, m, N, limit);
|
||||
const int tst_res = tst_func_(ds, m, N, limit);
|
||||
const int ref_res = params_.ref_func(ds, m, N, limit);
|
||||
int tst_res;
|
||||
ASM_REGISTER_STATE_CHECK(tst_res = params_.tst_func(ds, m, N, limit));
|
||||
|
||||
ASSERT_EQ(ref_res, tst_res);
|
||||
}
|
||||
|
|
@ -342,21 +338,22 @@ TEST_P(WedgeUtilsSignOptTest, ExtremeValues) {
|
|||
for (int i = 0 ; i < N ; i++)
|
||||
ds[i] = clamp(r0[i]*r0[i] - r1[i]*r1[i], INT16_MIN, INT16_MAX);
|
||||
|
||||
const int ref_res = ref_func_(ds, m, N, limit);
|
||||
const int tst_res = tst_func_(ds, m, N, limit);
|
||||
const int ref_res = params_.ref_func(ds, m, N, limit);
|
||||
int tst_res;
|
||||
ASM_REGISTER_STATE_CHECK(tst_res = params_.tst_func(ds, m, N, limit));
|
||||
|
||||
ASSERT_EQ(ref_res, tst_res);
|
||||
}
|
||||
}
|
||||
|
||||
#if HAVE_SSE2
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(
|
||||
SSE2, WedgeUtilsSignOptTest,
|
||||
::testing::Values(
|
||||
make_tuple(&vp10_wedge_sign_from_residuals_c,
|
||||
&vp10_wedge_sign_from_residuals_sse2)
|
||||
)
|
||||
);
|
||||
TestFuncsFSign(vp10_wedge_sign_from_residuals_c,
|
||||
vp10_wedge_sign_from_residuals_sse2)));
|
||||
|
||||
#endif // HAVE_SSE2
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
|
@ -367,14 +364,11 @@ typedef void (*FDS)(int16_t *d,
|
|||
const int16_t *a,
|
||||
const int16_t *b,
|
||||
int N);
|
||||
typedef libvpx_test::FuncParam<FDS> TestFuncsFDS;
|
||||
|
||||
class WedgeUtilsDeltaSquaresOptTest : public FunctionEquivalenceTest<FDS> {
|
||||
protected:
|
||||
WedgeUtilsDeltaSquaresOptTest() : rng_(ACMRandom::DeterministicSeed()) {}
|
||||
|
||||
static const int kIterations = 10000;
|
||||
|
||||
ACMRandom rng_;
|
||||
};
|
||||
|
||||
TEST_P(WedgeUtilsDeltaSquaresOptTest, RandomValues) {
|
||||
|
|
@ -394,8 +388,8 @@ TEST_P(WedgeUtilsDeltaSquaresOptTest, RandomValues) {
|
|||
memset(&d_ref, INT16_MAX, sizeof(d_ref));
|
||||
memset(&d_tst, INT16_MAX, sizeof(d_tst));
|
||||
|
||||
ref_func_(d_ref, a, b, N);
|
||||
tst_func_(d_tst, a, b, N);
|
||||
params_.ref_func(d_ref, a, b, N);
|
||||
ASM_REGISTER_STATE_CHECK(params_.tst_func(d_tst, a, b, N));
|
||||
|
||||
for (int i = 0 ; i < MAX_SB_SQUARE ; ++i)
|
||||
ASSERT_EQ(d_ref[i], d_tst[i]);
|
||||
|
|
@ -403,13 +397,13 @@ TEST_P(WedgeUtilsDeltaSquaresOptTest, RandomValues) {
|
|||
}
|
||||
|
||||
#if HAVE_SSE2
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(
|
||||
SSE2, WedgeUtilsDeltaSquaresOptTest,
|
||||
::testing::Values(
|
||||
make_tuple(&vp10_wedge_compute_delta_squares_c,
|
||||
&vp10_wedge_compute_delta_squares_sse2)
|
||||
)
|
||||
);
|
||||
TestFuncsFDS(vp10_wedge_compute_delta_squares_c,
|
||||
vp10_wedge_compute_delta_squares_sse2)));
|
||||
|
||||
#endif // HAVE_SSE2
|
||||
|
||||
} // namespace
|
||||
|
|
|
|||
Загрузка…
Ссылка в новой задаче