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,
for (int y = 0; y < h; ++y) {
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->do_average) {
dst[y * dst_stride + x] +=
(src[y * src_stride + x] * conv_params->bck_offset) << bits;
dst[y * dst_stride + x] += res * conv_params->bck_offset;
dst[y * dst_stride + x] = ROUND_POWER_OF_TWO(dst[y * dst_stride + x],
DIST_PRECISION_BITS - 1);
} else {
dst[y * dst_stride + x] =
(src[y * src_stride + x] * conv_params->fwd_offset) << bits;
dst[y * dst_stride + x] = res * conv_params->fwd_offset;
}
} else {
if (conv_params->do_average)
......
......@@ -30,21 +30,54 @@ namespace {
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(
SSE2, AV1Convolve2DTest,
libaom_test::AV1Convolve2D::BuildParams(av1_convolve_2d_sse2));
libaom_test::AV1Convolve2D::BuildParams(av1_convolve_2d_sse2, 1, 1, 1));
#if HAVE_AVX2
INSTANTIATE_TEST_CASE_P(
AVX2, AV1Convolve2DTest,
libaom_test::AV1Convolve2D::BuildParams(av1_convolve_2d_avx2));
libaom_test::AV1Convolve2D::BuildParams(av1_convolve_2d_avx2, 1, 1, 1));
#endif
#if CONFIG_JNT_COMP && HAVE_SSE4_1
TEST_P(AV1JntConvolve2DTest, CheckOutput) { RunCheckOutput(GET_PARAM(2)); }
INSTANTIATE_TEST_CASE_P(
SSE4_1, AV1JntConvolve2DTest,
libaom_test::AV1Convolve2D::BuildParams(av1_jnt_convolve_2d_sse4_1));
INSTANTIATE_TEST_CASE_P(C_COPY, AV1JntConvolve2DTest,
libaom_test::AV1Convolve2D::BuildParams(
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
#if CONFIG_HIGHBITDEPTH && HAVE_SSSE3
......
......@@ -22,11 +22,13 @@ namespace libaom_test {
namespace AV1Convolve2D {
::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[] = {
make_tuple(4, 4, filter), make_tuple(8, 8, filter),
make_tuple(64, 64, filter), make_tuple(4, 16, filter),
make_tuple(32, 8, filter),
make_tuple(4, 4, filter, has_subx, has_suby, is_compound),
make_tuple(8, 8, filter, has_subx, has_suby, is_compound),
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);
}
......@@ -40,6 +42,10 @@ void AV1Convolve2DTest::RunCheckOutput(convolve_2d_func test_impl) {
const int w = 128, h = 128;
const int out_w = GET_PARAM(0), out_h = GET_PARAM(1);
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];
......@@ -63,8 +69,10 @@ void AV1Convolve2DTest::RunCheckOutput(convolve_2d_func test_impl) {
ConvolveParams conv_params2 =
get_conv_params_no_round(0, do_average, 0, output2, MAX_SB_SIZE, 1);
for (subx = 0; subx < 16; ++subx)
for (suby = 0; suby < 16; ++suby) {
const int subx_range = has_subx ? 16 : 1;
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
// compound mode, so we set num_iter to two here.
// A larger number may introduce overflow
......@@ -111,6 +119,10 @@ void AV1JntConvolve2DTest::RunCheckOutput(convolve_2d_func test_impl) {
const int w = 128, h = 128;
const int out_w = GET_PARAM(0), out_h = GET_PARAM(1);
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];
......@@ -138,8 +150,10 @@ void AV1JntConvolve2DTest::RunCheckOutput(convolve_2d_func test_impl) {
conv_params1.use_jnt_comp_avg = 0;
conv_params2.use_jnt_comp_avg = 0;
for (subx = 0; subx < 16; ++subx)
for (suby = 0; suby < 16; ++suby) {
const int subx_range = has_subx ? 16 : 1;
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 compound mode, so we set num_iter to two here.
// A larger number may introduce overflow
......@@ -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.bck_offset = quant_dist_lookup_table[l][m][1];
for (subx = 0; subx < 16; ++subx)
for (suby = 0; suby < 16; ++suby) {
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 compound mode, so we set num_iter to two here.
// A larger number may introduce overflow
......
......@@ -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,
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(
convolve_2d_func filter);
convolve_2d_func filter, int subx_exist, int suby_exist, int is_compound);
class AV1Convolve2DTest : public ::testing::TestWithParam<Convolve2DParam> {
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