blob: 5c6cab4abcd30a91f8096b617aab984c3826d39d [file] [log] [blame]
/*
* Copyright (c) 2016, Alliance for Open Media. All rights reserved
*
* This source code is subject to the terms of the BSD 2 Clause License and
* the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
* was not distributed with this source code in the LICENSE file, you can
* obtain it at www.aomedia.org/license/software. If the Alliance for Open
* Media Patent License 1.0 was not distributed with this source code in the
* PATENTS file, you can obtain it at www.aomedia.org/license/patent.
*/
#include "test/hiprec_convolve_test_util.h"
#include "av1/common/restoration.h"
using std::make_tuple;
using std::tuple;
namespace libaom_test {
// Generate a random pair of filter kernels, using the ranges
// of possible values from the loop-restoration experiment
static void generate_kernels(ACMRandom *rnd, InterpKernel hkernel,
InterpKernel vkernel, int kernel_type = 2) {
if (kernel_type == 0) {
// Low possible values for filter coefficients
hkernel[0] = hkernel[6] = vkernel[0] = vkernel[6] = WIENER_FILT_TAP0_MINV;
hkernel[1] = hkernel[5] = vkernel[1] = vkernel[5] = WIENER_FILT_TAP1_MINV;
hkernel[2] = hkernel[4] = vkernel[2] = vkernel[4] = WIENER_FILT_TAP2_MINV;
hkernel[3] = vkernel[3] = -2 * (hkernel[0] + hkernel[1] + hkernel[2]);
hkernel[7] = vkernel[7] = 0;
} else if (kernel_type == 1) {
// Max possible values for filter coefficients
hkernel[0] = hkernel[6] = vkernel[0] = vkernel[6] = WIENER_FILT_TAP0_MAXV;
hkernel[1] = hkernel[5] = vkernel[1] = vkernel[5] = WIENER_FILT_TAP1_MAXV;
hkernel[2] = hkernel[4] = vkernel[2] = vkernel[4] = WIENER_FILT_TAP2_MAXV;
hkernel[3] = vkernel[3] = -2 * (hkernel[0] + hkernel[1] + hkernel[2]);
hkernel[7] = vkernel[7] = 0;
} else {
// Randomly generated values for filter coefficients
hkernel[0] = hkernel[6] =
WIENER_FILT_TAP0_MINV +
rnd->PseudoUniform(WIENER_FILT_TAP0_MAXV + 1 - WIENER_FILT_TAP0_MINV);
hkernel[1] = hkernel[5] =
WIENER_FILT_TAP1_MINV +
rnd->PseudoUniform(WIENER_FILT_TAP1_MAXV + 1 - WIENER_FILT_TAP1_MINV);
hkernel[2] = hkernel[4] =
WIENER_FILT_TAP2_MINV +
rnd->PseudoUniform(WIENER_FILT_TAP2_MAXV + 1 - WIENER_FILT_TAP2_MINV);
hkernel[3] = -2 * (hkernel[0] + hkernel[1] + hkernel[2]);
hkernel[7] = 0;
vkernel[0] = vkernel[6] =
WIENER_FILT_TAP0_MINV +
rnd->PseudoUniform(WIENER_FILT_TAP0_MAXV + 2 - WIENER_FILT_TAP0_MINV);
vkernel[1] = vkernel[5] =
WIENER_FILT_TAP1_MINV +
rnd->PseudoUniform(WIENER_FILT_TAP1_MAXV + 2 - WIENER_FILT_TAP1_MINV);
vkernel[2] = vkernel[4] =
WIENER_FILT_TAP2_MINV +
rnd->PseudoUniform(WIENER_FILT_TAP2_MAXV + 2 - WIENER_FILT_TAP2_MINV);
vkernel[3] = -2 * (vkernel[0] + vkernel[1] + vkernel[2]);
vkernel[7] = 0;
}
}
namespace AV1HiprecConvolve {
::testing::internal::ParamGenerator<HiprecConvolveParam> BuildParams(
hiprec_convolve_func filter) {
const HiprecConvolveParam params[] = {
make_tuple(8, 8, 50000, filter), make_tuple(8, 4, 50000, filter),
make_tuple(64, 24, 1000, filter), make_tuple(64, 64, 1000, filter),
make_tuple(64, 56, 1000, filter), make_tuple(32, 8, 10000, filter),
make_tuple(32, 28, 10000, filter), make_tuple(32, 32, 10000, filter),
make_tuple(16, 34, 10000, filter), make_tuple(32, 34, 10000, filter),
make_tuple(64, 34, 1000, filter), make_tuple(8, 17, 10000, filter),
make_tuple(16, 17, 10000, filter), make_tuple(32, 17, 10000, filter)
};
return ::testing::ValuesIn(params);
}
AV1HiprecConvolveTest::~AV1HiprecConvolveTest() {}
void AV1HiprecConvolveTest::SetUp() {
rnd_.Reset(ACMRandom::DeterministicSeed());
}
void AV1HiprecConvolveTest::TearDown() { libaom_test::ClearSystemState(); }
void AV1HiprecConvolveTest::RunCheckOutput(hiprec_convolve_func test_impl) {
const int w = 128, h = 128;
const int out_w = GET_PARAM(0), out_h = GET_PARAM(1);
const int num_iters = GET_PARAM(2);
int i, j, k, m;
const ConvolveParams conv_params = get_conv_params_wiener(8);
uint8_t *input_ = new uint8_t[h * w];
uint8_t *input = input_;
// The AVX2 convolve functions always write rows with widths that are
// multiples of 16. So to avoid a buffer overflow, we may need to pad
// rows to a multiple of 16.
int output_n = ALIGN_POWER_OF_TWO(out_w, 4) * out_h;
uint8_t *output = new uint8_t[output_n];
uint8_t *output2 = new uint8_t[output_n];
// Generate random filter kernels
DECLARE_ALIGNED(16, InterpKernel, hkernel);
DECLARE_ALIGNED(16, InterpKernel, vkernel);
for (int kernel_type = 0; kernel_type < 3; kernel_type++) {
generate_kernels(&rnd_, hkernel, vkernel, kernel_type);
for (i = 0; i < num_iters; ++i) {
for (k = 0; k < h; ++k)
for (m = 0; m < w; ++m) input[k * w + m] = rnd_.Rand8();
// 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_wiener_convolve_add_src_c(input + offset_r * w + offset_c, w, output,
out_w, hkernel, 16, vkernel, 16, out_w,
out_h, &conv_params);
test_impl(input + offset_r * w + offset_c, w, output2, out_w, hkernel, 16,
vkernel, 16, out_w, out_h, &conv_params);
for (j = 0; j < out_w * out_h; ++j)
ASSERT_EQ(output[j], output2[j])
<< "Pixel mismatch at index " << j << " = (" << (j % out_w) << ", "
<< (j / out_w) << ") on iteration " << i;
}
}
delete[] input_;
delete[] output;
delete[] output2;
}
void AV1HiprecConvolveTest::RunSpeedTest(hiprec_convolve_func test_impl) {
const int w = 128, h = 128;
const int out_w = GET_PARAM(0), out_h = GET_PARAM(1);
const int num_iters = GET_PARAM(2) / 500;
int i, j, k;
const ConvolveParams conv_params = get_conv_params_wiener(8);
uint8_t *input_ = new uint8_t[h * w];
uint8_t *input = input_;
// The AVX2 convolve functions always write rows with widths that are
// multiples of 16. So to avoid a buffer overflow, we may need to pad
// rows to a multiple of 16.
int output_n = ALIGN_POWER_OF_TWO(out_w, 4) * out_h;
uint8_t *output = new uint8_t[output_n];
uint8_t *output2 = new uint8_t[output_n];
// Generate random filter kernels
DECLARE_ALIGNED(16, InterpKernel, hkernel);
DECLARE_ALIGNED(16, InterpKernel, vkernel);
generate_kernels(&rnd_, hkernel, vkernel);
for (i = 0; i < h; ++i)
for (j = 0; j < w; ++j) input[i * w + j] = rnd_.Rand8();
aom_usec_timer ref_timer;
aom_usec_timer_start(&ref_timer);
for (i = 0; i < num_iters; ++i) {
for (j = 3; j < h - out_h - 4; j++) {
for (k = 3; k < w - out_w - 4; k++) {
av1_wiener_convolve_add_src_c(input + j * w + k, w, output, out_w,
hkernel, 16, vkernel, 16, out_w, out_h,
&conv_params);
}
}
}
aom_usec_timer_mark(&ref_timer);
const int64_t ref_time = aom_usec_timer_elapsed(&ref_timer);
aom_usec_timer tst_timer;
aom_usec_timer_start(&tst_timer);
for (i = 0; i < num_iters; ++i) {
for (j = 3; j < h - out_h - 4; j++) {
for (k = 3; k < w - out_w - 4; k++) {
test_impl(input + j * w + k, w, output2, out_w, hkernel, 16, vkernel,
16, out_w, out_h, &conv_params);
}
}
}
aom_usec_timer_mark(&tst_timer);
const int64_t tst_time = aom_usec_timer_elapsed(&tst_timer);
std::cout << "[ ] C time = " << ref_time / 1000
<< " ms, SIMD time = " << tst_time / 1000 << " ms\n";
EXPECT_GT(ref_time, tst_time)
<< "Error: AV1HiprecConvolveTest.SpeedTest, SIMD slower than C.\n"
<< "C time: " << ref_time << " us\n"
<< "SIMD time: " << tst_time << " us\n";
delete[] input_;
delete[] output;
delete[] output2;
}
} // namespace AV1HiprecConvolve
namespace AV1HighbdHiprecConvolve {
::testing::internal::ParamGenerator<HighbdHiprecConvolveParam> BuildParams(
highbd_hiprec_convolve_func filter) {
const HighbdHiprecConvolveParam params[] = {
make_tuple(8, 8, 50000, 8, filter), make_tuple(64, 64, 1000, 8, filter),
make_tuple(32, 8, 10000, 8, filter), make_tuple(8, 8, 50000, 10, filter),
make_tuple(64, 64, 1000, 10, filter), make_tuple(32, 8, 10000, 10, filter),
make_tuple(8, 8, 50000, 12, filter), make_tuple(64, 64, 1000, 12, filter),
make_tuple(32, 8, 10000, 12, filter),
};
return ::testing::ValuesIn(params);
}
AV1HighbdHiprecConvolveTest::~AV1HighbdHiprecConvolveTest() {}
void AV1HighbdHiprecConvolveTest::SetUp() {
rnd_.Reset(ACMRandom::DeterministicSeed());
}
void AV1HighbdHiprecConvolveTest::TearDown() {
libaom_test::ClearSystemState();
}
void AV1HighbdHiprecConvolveTest::RunCheckOutput(
highbd_hiprec_convolve_func test_impl) {
const int w = 128, h = 128;
const int out_w = GET_PARAM(0), out_h = GET_PARAM(1);
const int num_iters = GET_PARAM(2);
const int bd = GET_PARAM(3);
int i, j;
const ConvolveParams conv_params = get_conv_params_wiener(bd);
uint16_t *input = new uint16_t[h * w];
// The AVX2 convolve functions always write rows with widths that are
// multiples of 16. So to avoid a buffer overflow, we may need to pad
// rows to a multiple of 16.
int output_n = ALIGN_POWER_OF_TWO(out_w, 4) * out_h;
uint16_t *output = new uint16_t[output_n];
uint16_t *output2 = new uint16_t[output_n];
// Generate random filter kernels
DECLARE_ALIGNED(16, InterpKernel, hkernel);
DECLARE_ALIGNED(16, InterpKernel, vkernel);
for (i = 0; i < h; ++i)
for (j = 0; j < w; ++j) input[i * w + j] = rnd_.Rand16() & ((1 << bd) - 1);
uint8_t *input_ptr = CONVERT_TO_BYTEPTR(input);
uint8_t *output_ptr = CONVERT_TO_BYTEPTR(output);
uint8_t *output2_ptr = CONVERT_TO_BYTEPTR(output2);
for (int kernel_type = 0; kernel_type < 3; kernel_type++) {
generate_kernels(&rnd_, hkernel, vkernel, kernel_type);
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_highbd_wiener_convolve_add_src_c(
input_ptr + offset_r * w + offset_c, w, output_ptr, out_w, hkernel,
16, vkernel, 16, out_w, out_h, &conv_params, bd);
test_impl(input_ptr + offset_r * w + offset_c, w, output2_ptr, out_w,
hkernel, 16, vkernel, 16, out_w, out_h, &conv_params, bd);
for (j = 0; j < out_w * out_h; ++j)
ASSERT_EQ(output[j], output2[j])
<< "Pixel mismatch at index " << j << " = (" << (j % out_w) << ", "
<< (j / out_w) << ") on iteration " << i;
}
}
delete[] input;
delete[] output;
delete[] output2;
}
void AV1HighbdHiprecConvolveTest::RunSpeedTest(
highbd_hiprec_convolve_func test_impl) {
const int w = 128, h = 128;
const int out_w = GET_PARAM(0), out_h = GET_PARAM(1);
const int num_iters = GET_PARAM(2) / 500;
const int bd = GET_PARAM(3);
int i, j, k;
const ConvolveParams conv_params = get_conv_params_wiener(bd);
uint16_t *input = new uint16_t[h * w];
// The AVX2 convolve functions always write rows with widths that are
// multiples of 16. So to avoid a buffer overflow, we may need to pad
// rows to a multiple of 16.
int output_n = ALIGN_POWER_OF_TWO(out_w, 4) * out_h;
uint16_t *output = new uint16_t[output_n];
uint16_t *output2 = new uint16_t[output_n];
// Generate random filter kernels
DECLARE_ALIGNED(16, InterpKernel, hkernel);
DECLARE_ALIGNED(16, InterpKernel, vkernel);
generate_kernels(&rnd_, hkernel, vkernel);
for (i = 0; i < h; ++i)
for (j = 0; j < w; ++j) input[i * w + j] = rnd_.Rand16() & ((1 << bd) - 1);
uint8_t *input_ptr = CONVERT_TO_BYTEPTR(input);
uint8_t *output_ptr = CONVERT_TO_BYTEPTR(output);
uint8_t *output2_ptr = CONVERT_TO_BYTEPTR(output2);
aom_usec_timer ref_timer;
aom_usec_timer_start(&ref_timer);
for (i = 0; i < num_iters; ++i) {
for (j = 3; j < h - out_h - 4; j++) {
for (k = 3; k < w - out_w - 4; k++) {
av1_highbd_wiener_convolve_add_src_c(
input_ptr + j * w + k, w, output_ptr, out_w, hkernel, 16, vkernel,
16, out_w, out_h, &conv_params, bd);
}
}
}
aom_usec_timer_mark(&ref_timer);
const int64_t ref_time = aom_usec_timer_elapsed(&ref_timer);
aom_usec_timer tst_timer;
aom_usec_timer_start(&tst_timer);
for (i = 0; i < num_iters; ++i) {
for (j = 3; j < h - out_h - 4; j++) {
for (k = 3; k < w - out_w - 4; k++) {
test_impl(input_ptr + j * w + k, w, output2_ptr, out_w, hkernel, 16,
vkernel, 16, out_w, out_h, &conv_params, bd);
}
}
}
aom_usec_timer_mark(&tst_timer);
const int64_t tst_time = aom_usec_timer_elapsed(&tst_timer);
std::cout << "[ ] C time = " << ref_time / 1000
<< " ms, SIMD time = " << tst_time / 1000 << " ms\n";
EXPECT_GT(ref_time, tst_time)
<< "Error: AV1HighbdHiprecConvolveTest.SpeedTest, SIMD slower than C.\n"
<< "C time: " << ref_time << " us\n"
<< "SIMD time: " << tst_time << " us\n";
delete[] input;
delete[] output;
delete[] output2;
}
} // namespace AV1HighbdHiprecConvolve
} // namespace libaom_test