JNT_COMP: Add unit tests for low bit-depth
Unit tests for jnt_comp low bit-depth added.
Change-Id: Ib070a67c125c5fa9a034e2b368aa109f9a256a45
diff --git a/test/av1_convolve_2d_test_util.cc b/test/av1_convolve_2d_test_util.cc
index 3b61f6b..a173a53 100644
--- a/test/av1_convolve_2d_test_util.cc
+++ b/test/av1_convolve_2d_test_util.cc
@@ -12,6 +12,7 @@
#include "test/av1_convolve_2d_test_util.h"
#include "av1/common/convolve.h"
+#include "av1/common/common_data.h"
using std::tr1::tuple;
using std::tr1::make_tuple;
@@ -20,6 +21,17 @@
namespace AV1Convolve2D {
+#if CONFIG_JNT_COMP
+::testing::internal::ParamGenerator<Convolve2DParam> BuildParams(
+ convolve_2d_func filter, convolve_2d_func filter2) {
+ const Convolve2DParam params[] = {
+ make_tuple(4, 4, filter, filter2), make_tuple(8, 8, filter, filter2),
+ make_tuple(64, 64, filter, filter2), make_tuple(4, 16, filter, filter2),
+ make_tuple(32, 8, filter, filter2),
+ };
+ return ::testing::ValuesIn(params);
+}
+#else
::testing::internal::ParamGenerator<Convolve2DParam> BuildParams(
convolve_2d_func filter) {
const Convolve2DParam params[] = {
@@ -29,6 +41,7 @@
};
return ::testing::ValuesIn(params);
}
+#endif // CONFIG_JNT_COMP
AV1Convolve2DTest::~AV1Convolve2DTest() {}
void AV1Convolve2DTest::SetUp() { rnd_.Reset(ACMRandom::DeterministicSeed()); }
@@ -97,6 +110,120 @@
delete[] output;
delete[] output2;
}
+
+#if CONFIG_JNT_COMP
+void AV1Convolve2DTest::RunCheckOutput2(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;
+
+ uint8_t *input = new uint8_t[h * w];
+
+ int output_n = out_h * MAX_SB_SIZE;
+ CONV_BUF_TYPE *output = new CONV_BUF_TYPE[output_n];
+ CONV_BUF_TYPE *output2 = new CONV_BUF_TYPE[output_n];
+
+ for (i = 0; i < h; ++i)
+ for (j = 0; j < w; ++j) input[i * w + j] = rnd_.Rand8();
+
+ int hfilter, vfilter, subx, suby;
+ for (hfilter = EIGHTTAP_REGULAR; hfilter < INTERP_FILTERS_ALL; ++hfilter) {
+ for (vfilter = EIGHTTAP_REGULAR; vfilter < INTERP_FILTERS_ALL; ++vfilter) {
+ InterpFilterParams filter_params_x =
+ av1_get_interp_filter_params((InterpFilter)hfilter);
+ InterpFilterParams filter_params_y =
+ av1_get_interp_filter_params((InterpFilter)vfilter);
+ const int do_average = rnd_.Rand8() & 1;
+ ConvolveParams conv_params1 =
+ get_conv_params_no_round(0, do_average, 0, output, MAX_SB_SIZE);
+ ConvolveParams conv_params2 =
+ get_conv_params_no_round(0, do_average, 0, output2, MAX_SB_SIZE);
+
+ // Test special case where fwd and bck offsets are -1
+ conv_params1.fwd_offset = -1;
+ conv_params1.bck_offset = -1;
+ conv_params2.fwd_offset = -1;
+ conv_params2.bck_offset = -1;
+
+ for (subx = 0; subx < 16; ++subx)
+ for (suby = 0; suby < 16; ++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
+ const int num_iters = 2;
+ memset(output, 0, output_n * sizeof(*output));
+ memset(output2, 0, output_n * sizeof(*output2));
+ for (i = 0; i < num_iters; ++i) {
+ // Choose random locations within the source block
+ int offset_r = 3 + rnd_.PseudoUniform(h - out_h - 7);
+ int offset_c = 3 + rnd_.PseudoUniform(w - out_w - 7);
+ av1_jnt_convolve_2d_c(input + offset_r * w + offset_c, w, output,
+ MAX_SB_SIZE, out_w, out_h, &filter_params_x,
+ &filter_params_y, subx, suby, &conv_params1);
+ test_impl(input + offset_r * w + offset_c, w, output2, MAX_SB_SIZE,
+ out_w, out_h, &filter_params_x, &filter_params_y, subx,
+ suby, &conv_params2);
+
+ for (j = 0; j < out_h; ++j)
+ for (k = 0; k < out_w; ++k) {
+ int idx = j * MAX_SB_SIZE + k;
+ ASSERT_EQ(output[idx], output2[idx])
+ << "Mismatch at unit tests for av1_jnt_convolve_2d\n"
+ << "Pixel mismatch at index " << idx << " = (" << j << ", "
+ << k << "), sub pixel offset = (" << suby << ", " << subx
+ << ")";
+ }
+ }
+ }
+
+ // Test different combination of fwd and bck offset weights
+ for (l = 0; l < 2; ++l) {
+ for (m = 0; m < 4; ++m) {
+ conv_params1.fwd_offset = quant_dist_lookup_table[l][m][0];
+ conv_params1.bck_offset = quant_dist_lookup_table[l][m][1];
+ 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) {
+ // 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
+ const int num_iters = 2;
+ memset(output, 0, output_n * sizeof(*output));
+ memset(output2, 0, output_n * sizeof(*output2));
+ for (i = 0; i < num_iters; ++i) {
+ // Choose random locations within the source block
+ int offset_r = 3 + rnd_.PseudoUniform(h - out_h - 7);
+ int offset_c = 3 + rnd_.PseudoUniform(w - out_w - 7);
+ av1_jnt_convolve_2d_c(input + offset_r * w + offset_c, w,
+ output, MAX_SB_SIZE, out_w, out_h,
+ &filter_params_x, &filter_params_y, subx,
+ suby, &conv_params1);
+ test_impl(input + offset_r * w + offset_c, w, output2,
+ MAX_SB_SIZE, out_w, out_h, &filter_params_x,
+ &filter_params_y, subx, suby, &conv_params2);
+
+ for (j = 0; j < out_h; ++j)
+ for (k = 0; k < out_w; ++k) {
+ int idx = j * MAX_SB_SIZE + k;
+ ASSERT_EQ(output[idx], output2[idx])
+ << "Mismatch at unit tests for av1_jnt_convolve_2d\n"
+ << "Pixel mismatch at index " << idx << " = (" << j
+ << ", " << k << "), sub pixel offset = (" << suby
+ << ", " << subx << ")";
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ delete[] input;
+ delete[] output;
+ delete[] output2;
+}
+#endif // CONFIG_JNT_COMP
} // namespace AV1Convolve2D
#if CONFIG_HIGHBITDEPTH
