Commit 4ce0f8cc authored by Cheng Chen's avatar Cheng Chen

Unit tests for convolve_2d copy and x, y functions

Copy and x, y only convolve functions should be identical to the
original 2d function.

Change-Id: I2b84a1eed775e8d7cba9bc3baa6352227a0326c8
parent 99ff0b00
...@@ -735,17 +735,15 @@ void av1_jnt_convolve_2d_copy_c(const uint8_t *src, int src_stride, ...@@ -735,17 +735,15 @@ void av1_jnt_convolve_2d_copy_c(const uint8_t *src, int src_stride,
for (int y = 0; y < h; ++y) { for (int y = 0; y < h; ++y) {
for (int x = 0; x < w; ++x) { for (int x = 0; x < w; ++x) {
CONV_BUF_TYPE res = (1 << bits) * src[y * src_stride + x]; CONV_BUF_TYPE res = src[y * src_stride + x] << bits;
if (conv_params->use_jnt_comp_avg) { if (conv_params->use_jnt_comp_avg) {
if (conv_params->do_average) { if (conv_params->do_average) {
dst[y * dst_stride + x] += dst[y * dst_stride + x] += res * conv_params->bck_offset;
(src[y * src_stride + x] * conv_params->bck_offset) << bits;
dst[y * dst_stride + x] = ROUND_POWER_OF_TWO(dst[y * dst_stride + x], dst[y * dst_stride + x] = ROUND_POWER_OF_TWO(dst[y * dst_stride + x],
DIST_PRECISION_BITS - 1); DIST_PRECISION_BITS - 1);
} else { } else {
dst[y * dst_stride + x] = dst[y * dst_stride + x] = res * conv_params->fwd_offset;
(src[y * src_stride + x] * conv_params->fwd_offset) << bits;
} }
} else { } else {
if (conv_params->do_average) if (conv_params->do_average)
......
...@@ -30,21 +30,54 @@ namespace { ...@@ -30,21 +30,54 @@ namespace {
TEST_P(AV1Convolve2DTest, CheckOutput) { RunCheckOutput(GET_PARAM(2)); } TEST_P(AV1Convolve2DTest, CheckOutput) { RunCheckOutput(GET_PARAM(2)); }
INSTANTIATE_TEST_CASE_P(
C_COPY, AV1Convolve2DTest,
libaom_test::AV1Convolve2D::BuildParams(av1_convolve_2d_copy_c, 0, 0, 1));
INSTANTIATE_TEST_CASE_P(SSE2_COPY, AV1Convolve2DTest,
libaom_test::AV1Convolve2D::BuildParams(
av1_convolve_2d_copy_sse2, 0, 0, 1));
INSTANTIATE_TEST_CASE_P(
C_X, AV1Convolve2DTest,
libaom_test::AV1Convolve2D::BuildParams(av1_convolve_x_c, 1, 0, 1));
INSTANTIATE_TEST_CASE_P(
SSE2_X, AV1Convolve2DTest,
libaom_test::AV1Convolve2D::BuildParams(av1_convolve_x_sse2, 1, 0, 1));
INSTANTIATE_TEST_CASE_P(
C_Y, AV1Convolve2DTest,
libaom_test::AV1Convolve2D::BuildParams(av1_convolve_y_c, 0, 1, 1));
INSTANTIATE_TEST_CASE_P(
SSE2_Y, AV1Convolve2DTest,
libaom_test::AV1Convolve2D::BuildParams(av1_convolve_y_sse2, 0, 1, 1));
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
SSE2, AV1Convolve2DTest, SSE2, AV1Convolve2DTest,
libaom_test::AV1Convolve2D::BuildParams(av1_convolve_2d_sse2)); libaom_test::AV1Convolve2D::BuildParams(av1_convolve_2d_sse2, 1, 1, 1));
#if HAVE_AVX2 #if HAVE_AVX2
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
AVX2, AV1Convolve2DTest, AVX2, AV1Convolve2DTest,
libaom_test::AV1Convolve2D::BuildParams(av1_convolve_2d_avx2)); libaom_test::AV1Convolve2D::BuildParams(av1_convolve_2d_avx2, 1, 1, 1));
#endif #endif
#if CONFIG_JNT_COMP && HAVE_SSE4_1 #if CONFIG_JNT_COMP && HAVE_SSE4_1
TEST_P(AV1JntConvolve2DTest, CheckOutput) { RunCheckOutput(GET_PARAM(2)); } TEST_P(AV1JntConvolve2DTest, CheckOutput) { RunCheckOutput(GET_PARAM(2)); }
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(C_COPY, AV1JntConvolve2DTest,
SSE4_1, AV1JntConvolve2DTest, libaom_test::AV1Convolve2D::BuildParams(
libaom_test::AV1Convolve2D::BuildParams(av1_jnt_convolve_2d_sse4_1)); av1_jnt_convolve_2d_copy_c, 0, 0, 1));
INSTANTIATE_TEST_CASE_P(SSE2_COPY, AV1JntConvolve2DTest,
libaom_test::AV1Convolve2D::BuildParams(
av1_jnt_convolve_2d_copy_sse2, 0, 0, 1));
INSTANTIATE_TEST_CASE_P(SSE4_1, AV1JntConvolve2DTest,
libaom_test::AV1Convolve2D::BuildParams(
av1_jnt_convolve_2d_sse4_1, 1, 1, 1));
#endif #endif
#if CONFIG_HIGHBITDEPTH && HAVE_SSSE3 #if CONFIG_HIGHBITDEPTH && HAVE_SSSE3
......
...@@ -22,11 +22,13 @@ namespace libaom_test { ...@@ -22,11 +22,13 @@ namespace libaom_test {
namespace AV1Convolve2D { namespace AV1Convolve2D {
::testing::internal::ParamGenerator<Convolve2DParam> BuildParams( ::testing::internal::ParamGenerator<Convolve2DParam> BuildParams(
convolve_2d_func filter) { convolve_2d_func filter, int has_subx, int has_suby, int is_compound) {
const Convolve2DParam params[] = { const Convolve2DParam params[] = {
make_tuple(4, 4, filter), make_tuple(8, 8, filter), make_tuple(4, 4, filter, has_subx, has_suby, is_compound),
make_tuple(64, 64, filter), make_tuple(4, 16, filter), make_tuple(8, 8, filter, has_subx, has_suby, is_compound),
make_tuple(32, 8, filter), make_tuple(64, 64, filter, has_subx, has_suby, is_compound),
make_tuple(4, 16, filter, has_subx, has_suby, is_compound),
make_tuple(32, 8, filter, has_subx, has_suby, is_compound),
}; };
return ::testing::ValuesIn(params); return ::testing::ValuesIn(params);
} }
...@@ -40,6 +42,10 @@ void AV1Convolve2DTest::RunCheckOutput(convolve_2d_func test_impl) { ...@@ -40,6 +42,10 @@ void AV1Convolve2DTest::RunCheckOutput(convolve_2d_func test_impl) {
const int w = 128, h = 128; const int w = 128, h = 128;
const int out_w = GET_PARAM(0), out_h = GET_PARAM(1); const int out_w = GET_PARAM(0), out_h = GET_PARAM(1);
int i, j, k; int i, j, k;
const int has_subx = GET_PARAM(3);
const int has_suby = GET_PARAM(4);
const int is_compound = GET_PARAM(5);
(void)is_compound;
uint8_t *input = new uint8_t[h * w]; uint8_t *input = new uint8_t[h * w];
...@@ -63,8 +69,10 @@ void AV1Convolve2DTest::RunCheckOutput(convolve_2d_func test_impl) { ...@@ -63,8 +69,10 @@ void AV1Convolve2DTest::RunCheckOutput(convolve_2d_func test_impl) {
ConvolveParams conv_params2 = ConvolveParams conv_params2 =
get_conv_params_no_round(0, do_average, 0, output2, MAX_SB_SIZE, 1); get_conv_params_no_round(0, do_average, 0, output2, MAX_SB_SIZE, 1);
for (subx = 0; subx < 16; ++subx) const int subx_range = has_subx ? 16 : 1;
for (suby = 0; suby < 16; ++suby) { const int suby_range = has_suby ? 16 : 1;
for (subx = 0; subx < subx_range; ++subx)
for (suby = 0; suby < suby_range; ++suby) {
// av1_convolve_2d is designed for accumulate two predicted blocks for // av1_convolve_2d is designed for accumulate two predicted blocks for
// compound mode, so we set num_iter to two here. // compound mode, so we set num_iter to two here.
// A larger number may introduce overflow // A larger number may introduce overflow
...@@ -111,6 +119,10 @@ void AV1JntConvolve2DTest::RunCheckOutput(convolve_2d_func test_impl) { ...@@ -111,6 +119,10 @@ void AV1JntConvolve2DTest::RunCheckOutput(convolve_2d_func test_impl) {
const int w = 128, h = 128; const int w = 128, h = 128;
const int out_w = GET_PARAM(0), out_h = GET_PARAM(1); const int out_w = GET_PARAM(0), out_h = GET_PARAM(1);
int i, j, k, l, m; int i, j, k, l, m;
const int has_subx = GET_PARAM(3);
const int has_suby = GET_PARAM(4);
const int is_compound = GET_PARAM(5);
(void)is_compound;
uint8_t *input = new uint8_t[h * w]; uint8_t *input = new uint8_t[h * w];
...@@ -138,8 +150,10 @@ void AV1JntConvolve2DTest::RunCheckOutput(convolve_2d_func test_impl) { ...@@ -138,8 +150,10 @@ void AV1JntConvolve2DTest::RunCheckOutput(convolve_2d_func test_impl) {
conv_params1.use_jnt_comp_avg = 0; conv_params1.use_jnt_comp_avg = 0;
conv_params2.use_jnt_comp_avg = 0; conv_params2.use_jnt_comp_avg = 0;
for (subx = 0; subx < 16; ++subx) const int subx_range = has_subx ? 16 : 1;
for (suby = 0; suby < 16; ++suby) { const int suby_range = has_suby ? 16 : 1;
for (subx = 0; subx < subx_range; ++subx)
for (suby = 0; suby < suby_range; ++suby) {
// av1_convolve_2d is designed for accumulate two predicted blocks // av1_convolve_2d is designed for accumulate two predicted blocks
// for compound mode, so we set num_iter to two here. // for compound mode, so we set num_iter to two here.
// A larger number may introduce overflow // A larger number may introduce overflow
...@@ -179,8 +193,8 @@ void AV1JntConvolve2DTest::RunCheckOutput(convolve_2d_func test_impl) { ...@@ -179,8 +193,8 @@ void AV1JntConvolve2DTest::RunCheckOutput(convolve_2d_func test_impl) {
conv_params2.fwd_offset = quant_dist_lookup_table[l][m][0]; conv_params2.fwd_offset = quant_dist_lookup_table[l][m][0];
conv_params2.bck_offset = quant_dist_lookup_table[l][m][1]; conv_params2.bck_offset = quant_dist_lookup_table[l][m][1];
for (subx = 0; subx < 16; ++subx) for (subx = 0; subx < subx_range; ++subx)
for (suby = 0; suby < 16; ++suby) { for (suby = 0; suby < suby_range; ++suby) {
// av1_convolve_2d is designed for accumulate two predicted blocks // av1_convolve_2d is designed for accumulate two predicted blocks
// for compound mode, so we set num_iter to two here. // for compound mode, so we set num_iter to two here.
// A larger number may introduce overflow // A larger number may introduce overflow
......
...@@ -31,10 +31,11 @@ typedef void (*convolve_2d_func)(const uint8_t *src, int src_stride, ...@@ -31,10 +31,11 @@ typedef void (*convolve_2d_func)(const uint8_t *src, int src_stride,
const int subpel_x_q4, const int subpel_y_q4, const int subpel_x_q4, const int subpel_y_q4,
ConvolveParams *conv_params); ConvolveParams *conv_params);
typedef std::tr1::tuple<int, int, convolve_2d_func> Convolve2DParam; typedef std::tr1::tuple<int, int, convolve_2d_func, int, int, int>
Convolve2DParam;
::testing::internal::ParamGenerator<Convolve2DParam> BuildParams( ::testing::internal::ParamGenerator<Convolve2DParam> BuildParams(
convolve_2d_func filter); convolve_2d_func filter, int subx_exist, int suby_exist, int is_compound);
class AV1Convolve2DTest : public ::testing::TestWithParam<Convolve2DParam> { class AV1Convolve2DTest : public ::testing::TestWithParam<Convolve2DParam> {
public: public:
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment