diff options
Diffstat (limited to 'third_party/aom/test/av1_convolve_test.cc')
| -rw-r--r-- | third_party/aom/test/av1_convolve_test.cc | 514 |
1 files changed, 0 insertions, 514 deletions
diff --git a/third_party/aom/test/av1_convolve_test.cc b/third_party/aom/test/av1_convolve_test.cc deleted file mode 100644 index aaef7cfe0..000000000 --- a/third_party/aom/test/av1_convolve_test.cc +++ /dev/null @@ -1,514 +0,0 @@ -/* - * 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 <algorithm> -#include <vector> - -#include "third_party/googletest/src/googletest/include/gtest/gtest.h" - -#include "./av1_rtcd.h" -#include "./aom_dsp_rtcd.h" -#include "aom_dsp/aom_dsp_common.h" -#include "aom_ports/mem.h" -#include "av1/common/filter.h" -#include "av1/common/convolve.h" -#include "test/acm_random.h" -#include "test/util.h" - -using libaom_test::ACMRandom; - -namespace { -using std::tr1::tuple; -static void filter_block1d_horiz_c(const uint8_t *src_ptr, int src_stride, - const int16_t *filter, int tap, - uint8_t *dst_ptr, int dst_stride, int w, - int h) { - src_ptr -= tap / 2 - 1; - for (int r = 0; r < h; ++r) { - for (int c = 0; c < w; ++c) { - int sum = 0; - for (int i = 0; i < tap; ++i) { - sum += src_ptr[c + i] * filter[i]; - } - dst_ptr[c] = clip_pixel(ROUND_POWER_OF_TWO(sum, FILTER_BITS)); - } - src_ptr += src_stride; - dst_ptr += dst_stride; - } -} - -static void filter_block1d_vert_c(const uint8_t *src_ptr, int src_stride, - const int16_t *filter, int tap, - uint8_t *dst_ptr, int dst_stride, int w, - int h) { - src_ptr -= (tap / 2 - 1) * src_stride; - for (int r = 0; r < h; ++r) { - for (int c = 0; c < w; ++c) { - int sum = 0; - for (int i = 0; i < tap; ++i) { - sum += src_ptr[c + i * src_stride] * filter[i]; - } - dst_ptr[c] = clip_pixel(ROUND_POWER_OF_TWO(sum, FILTER_BITS)); - } - src_ptr += src_stride; - dst_ptr += dst_stride; - } -} - -static int match(const uint8_t *out, int out_stride, const uint8_t *ref_out, - int ref_out_stride, int w, int h) { - for (int r = 0; r < h; ++r) { - for (int c = 0; c < w; ++c) { - if (out[r * out_stride + c] != ref_out[r * ref_out_stride + c]) return 0; - } - } - return 1; -} - -typedef void (*ConvolveFunc)(const uint8_t *src, int src_stride, uint8_t *dst, - int dst_stride, int w, int h, - const InterpFilterParams filter_params, - const int subpel_q4, int step_q4, - ConvolveParams *conv_params); - -struct ConvolveFunctions { - ConvolveFunctions(ConvolveFunc hf, ConvolveFunc vf) : hf_(hf), vf_(vf) {} - ConvolveFunc hf_; - ConvolveFunc vf_; -}; - -typedef tuple<ConvolveFunctions *, InterpFilter /*filter_x*/, - InterpFilter /*filter_y*/> - ConvolveParam; - -class Av1ConvolveTest : public ::testing::TestWithParam<ConvolveParam> { - public: - virtual void SetUp() { - rnd_(ACMRandom::DeterministicSeed()); - cfs_ = GET_PARAM(0); - interp_filter_ls_[0] = GET_PARAM(2); - interp_filter_ls_[2] = interp_filter_ls_[0]; - interp_filter_ls_[1] = GET_PARAM(1); - interp_filter_ls_[3] = interp_filter_ls_[1]; - } - virtual void TearDown() { - while (buf_ls_.size() > 0) { - uint8_t *buf = buf_ls_.back(); - aom_free(buf); - buf_ls_.pop_back(); - } - } - virtual uint8_t *add_input(int w, int h, int *stride) { - uint8_t *buf = - reinterpret_cast<uint8_t *>(aom_memalign(kDataAlignment, kBufferSize)); - buf_ls_.push_back(buf); - *stride = w + MAX_FILTER_TAP - 1; - int offset = MAX_FILTER_TAP / 2 - 1; - for (int r = 0; r < h + MAX_FILTER_TAP - 1; ++r) { - for (int c = 0; c < w + MAX_FILTER_TAP - 1; ++c) { - buf[r * (*stride) + c] = rnd_.Rand8(); - } - } - return buf + offset * (*stride) + offset; - } - virtual uint8_t *add_output(int w, int /*h*/, int *stride) { - uint8_t *buf = - reinterpret_cast<uint8_t *>(aom_memalign(kDataAlignment, kBufferSize)); - buf_ls_.push_back(buf); - *stride = w; - return buf; - } - virtual void random_init_buf(uint8_t *buf, int w, int h, int stride) { - for (int r = 0; r < h; ++r) { - for (int c = 0; c < w; ++c) { - buf[r * stride + c] = rnd_.Rand8(); - } - } - } - - protected: - static const int kDataAlignment = 16; - static const int kOuterBlockSize = MAX_SB_SIZE + MAX_FILTER_TAP - 1; - static const int kBufferSize = kOuterBlockSize * kOuterBlockSize; - std::vector<uint8_t *> buf_ls_; - InterpFilter interp_filter_ls_[4]; - ConvolveFunctions *cfs_; - ACMRandom rnd_; -}; - -int bsize_ls[] = { 1, 2, 4, 8, 16, 32, 64, 3, 7, 15, 31, 63 }; -int bsize_num = NELEMENTS(bsize_ls); - -TEST_P(Av1ConvolveTest, av1_convolve_vert) { - const int y_step_q4 = 16; - ConvolveParams conv_params = get_conv_params(0, 0, 0); - - int in_stride, out_stride, ref_out_stride, avg_out_stride, ref_avg_out_stride; - uint8_t *in = add_input(MAX_SB_SIZE, MAX_SB_SIZE, &in_stride); - uint8_t *out = add_output(MAX_SB_SIZE, MAX_SB_SIZE, &out_stride); - uint8_t *ref_out = add_output(MAX_SB_SIZE, MAX_SB_SIZE, &ref_out_stride); - uint8_t *avg_out = add_output(MAX_SB_SIZE, MAX_SB_SIZE, &avg_out_stride); - uint8_t *ref_avg_out = - add_output(MAX_SB_SIZE, MAX_SB_SIZE, &ref_avg_out_stride); - for (int hb_idx = 0; hb_idx < bsize_num; ++hb_idx) { - for (int vb_idx = 0; vb_idx < bsize_num; ++vb_idx) { - int w = bsize_ls[hb_idx]; - int h = bsize_ls[vb_idx]; - for (int subpel_y_q4 = 0; subpel_y_q4 < SUBPEL_SHIFTS; ++subpel_y_q4) { - InterpFilter filter_y = interp_filter_ls_[0]; - InterpFilterParams param_vert = av1_get_interp_filter_params(filter_y); - const int16_t *filter_vert = - av1_get_interp_filter_subpel_kernel(param_vert, subpel_y_q4); - - filter_block1d_vert_c(in, in_stride, filter_vert, param_vert.taps, - ref_out, ref_out_stride, w, h); - - conv_params.ref = 0; - conv_params.do_average = 0; - cfs_->vf_(in, in_stride, out, out_stride, w, h, param_vert, subpel_y_q4, - y_step_q4, &conv_params); - EXPECT_EQ(match(out, out_stride, ref_out, ref_out_stride, w, h), 1) - << " hb_idx " << hb_idx << " vb_idx " << vb_idx << " filter_y " - << filter_y << " subpel_y_q4 " << subpel_y_q4; - - random_init_buf(avg_out, w, h, avg_out_stride); - for (int r = 0; r < h; ++r) { - for (int c = 0; c < w; ++c) { - ref_avg_out[r * ref_avg_out_stride + c] = ROUND_POWER_OF_TWO( - avg_out[r * avg_out_stride + c] + out[r * out_stride + c], 1); - } - } - conv_params.ref = 1; - conv_params.do_average = 1; - cfs_->vf_(in, in_stride, avg_out, avg_out_stride, w, h, param_vert, - subpel_y_q4, y_step_q4, &conv_params); - EXPECT_EQ(match(avg_out, avg_out_stride, ref_avg_out, - ref_avg_out_stride, w, h), - 1) - << " hb_idx " << hb_idx << " vb_idx " << vb_idx << " filter_y " - << filter_y << " subpel_y_q4 " << subpel_y_q4; - } - } - } -}; - -TEST_P(Av1ConvolveTest, av1_convolve_horiz) { - const int x_step_q4 = 16; - ConvolveParams conv_params = get_conv_params(0, 0, 0); - - int in_stride, out_stride, ref_out_stride, avg_out_stride, ref_avg_out_stride; - uint8_t *in = add_input(MAX_SB_SIZE, MAX_SB_SIZE, &in_stride); - uint8_t *out = add_output(MAX_SB_SIZE, MAX_SB_SIZE, &out_stride); - uint8_t *ref_out = add_output(MAX_SB_SIZE, MAX_SB_SIZE, &ref_out_stride); - uint8_t *avg_out = add_output(MAX_SB_SIZE, MAX_SB_SIZE, &avg_out_stride); - uint8_t *ref_avg_out = - add_output(MAX_SB_SIZE, MAX_SB_SIZE, &ref_avg_out_stride); - for (int hb_idx = 0; hb_idx < bsize_num; ++hb_idx) { - for (int vb_idx = 0; vb_idx < bsize_num; ++vb_idx) { - int w = bsize_ls[hb_idx]; - int h = bsize_ls[vb_idx]; - for (int subpel_x_q4 = 0; subpel_x_q4 < SUBPEL_SHIFTS; ++subpel_x_q4) { - InterpFilter filter_x = interp_filter_ls_[1]; - InterpFilterParams param_horiz = av1_get_interp_filter_params(filter_x); - const int16_t *filter_horiz = - av1_get_interp_filter_subpel_kernel(param_horiz, subpel_x_q4); - - filter_block1d_horiz_c(in, in_stride, filter_horiz, param_horiz.taps, - ref_out, ref_out_stride, w, h); - - conv_params.ref = 0; - conv_params.do_average = 0; - cfs_->hf_(in, in_stride, out, out_stride, w, h, param_horiz, - subpel_x_q4, x_step_q4, &conv_params); - EXPECT_EQ(match(out, out_stride, ref_out, ref_out_stride, w, h), 1) - << " hb_idx " << hb_idx << " vb_idx " << vb_idx << " filter_x " - << filter_x << " subpel_x_q4 " << subpel_x_q4; - - random_init_buf(avg_out, w, h, avg_out_stride); - for (int r = 0; r < h; ++r) { - for (int c = 0; c < w; ++c) { - ref_avg_out[r * ref_avg_out_stride + c] = ROUND_POWER_OF_TWO( - avg_out[r * avg_out_stride + c] + out[r * out_stride + c], 1); - } - } - conv_params.ref = 1; - conv_params.do_average = 1; - cfs_->hf_(in, in_stride, avg_out, avg_out_stride, w, h, param_horiz, - subpel_x_q4, x_step_q4, &conv_params); - EXPECT_EQ(match(avg_out, avg_out_stride, ref_avg_out, - ref_avg_out_stride, w, h), - 1) - << "hb_idx " << hb_idx << "vb_idx" << vb_idx << " filter_x " - << filter_x << "subpel_x_q4 " << subpel_x_q4; - } - } - } -}; - -ConvolveFunctions convolve_functions_c(av1_convolve_horiz_c, - av1_convolve_vert_c); - -InterpFilter filter_ls[] = { EIGHTTAP_REGULAR, EIGHTTAP_SMOOTH, - MULTITAP_SHARP }; - -INSTANTIATE_TEST_CASE_P( - C, Av1ConvolveTest, - ::testing::Combine(::testing::Values(&convolve_functions_c), - ::testing::ValuesIn(filter_ls), - ::testing::ValuesIn(filter_ls))); - -#if CONFIG_HIGHBITDEPTH -#ifndef __clang_analyzer__ -TEST(AV1ConvolveTest, av1_highbd_convolve) { - ACMRandom rnd(ACMRandom::DeterministicSeed()); - InterpFilters interp_filters = av1_broadcast_interp_filter(EIGHTTAP_REGULAR); - InterpFilterParams filter_params = - av1_get_interp_filter_params(EIGHTTAP_REGULAR); - int filter_size = filter_params.taps; - int filter_center = filter_size / 2 - 1; - uint16_t src[12 * 12]; - int src_stride = filter_size; - uint16_t dst[1] = { 0 }; - int dst_stride = 1; - int x_step_q4 = 16; - int y_step_q4 = 16; - int avg = 0; - int bd = 10; - int w = 1; - int h = 1; - - int subpel_x_q4; - int subpel_y_q4; - - for (int i = 0; i < filter_size * filter_size; i++) { - src[i] = rnd.Rand16() % (1 << bd); - } - - for (subpel_x_q4 = 0; subpel_x_q4 < SUBPEL_SHIFTS; subpel_x_q4++) { - for (subpel_y_q4 = 0; subpel_y_q4 < SUBPEL_SHIFTS; subpel_y_q4++) { - av1_highbd_convolve( - CONVERT_TO_BYTEPTR(src + src_stride * filter_center + filter_center), - src_stride, CONVERT_TO_BYTEPTR(dst), dst_stride, w, h, interp_filters, - subpel_x_q4, x_step_q4, subpel_y_q4, y_step_q4, avg, bd); - - const int16_t *x_filter = - av1_get_interp_filter_subpel_kernel(filter_params, subpel_x_q4); - const int16_t *y_filter = - av1_get_interp_filter_subpel_kernel(filter_params, subpel_y_q4); - - int temp[12]; - int dst_ref = 0; - for (int r = 0; r < filter_size; r++) { - temp[r] = 0; - for (int c = 0; c < filter_size; c++) { - temp[r] += x_filter[c] * src[r * filter_size + c]; - } - temp[r] = - clip_pixel_highbd(ROUND_POWER_OF_TWO(temp[r], FILTER_BITS), bd); - dst_ref += temp[r] * y_filter[r]; - } - dst_ref = clip_pixel_highbd(ROUND_POWER_OF_TWO(dst_ref, FILTER_BITS), bd); - EXPECT_EQ(dst[0], dst_ref); - } - } -} -#endif - -TEST(AV1ConvolveTest, av1_highbd_convolve_avg) { - ACMRandom rnd(ACMRandom::DeterministicSeed()); - InterpFilters interp_filters = av1_broadcast_interp_filter(EIGHTTAP_REGULAR); - InterpFilterParams filter_params = - av1_get_interp_filter_params(EIGHTTAP_REGULAR); - int filter_size = filter_params.taps; - int filter_center = filter_size / 2 - 1; - uint16_t src0[12 * 12]; - uint16_t src1[12 * 12]; - int src_stride = filter_size; - uint16_t dst0[1] = { 0 }; - uint16_t dst1[1] = { 0 }; - uint16_t dst[1] = { 0 }; - int dst_stride = 1; - int x_step_q4 = 16; - int y_step_q4 = 16; - int avg = 0; - int bd = 10; - - int w = 1; - int h = 1; - - int subpel_x_q4; - int subpel_y_q4; - - for (int i = 0; i < filter_size * filter_size; i++) { - src0[i] = rnd.Rand16() % (1 << bd); - src1[i] = rnd.Rand16() % (1 << bd); - } - - for (subpel_x_q4 = 0; subpel_x_q4 < SUBPEL_SHIFTS; subpel_x_q4++) { - for (subpel_y_q4 = 0; subpel_y_q4 < SUBPEL_SHIFTS; subpel_y_q4++) { - int offset = filter_size * filter_center + filter_center; - - avg = 0; - av1_highbd_convolve(CONVERT_TO_BYTEPTR(src0 + offset), src_stride, - CONVERT_TO_BYTEPTR(dst0), dst_stride, w, h, - interp_filters, subpel_x_q4, x_step_q4, subpel_y_q4, - y_step_q4, avg, bd); - avg = 0; - av1_highbd_convolve(CONVERT_TO_BYTEPTR(src1 + offset), src_stride, - CONVERT_TO_BYTEPTR(dst1), dst_stride, w, h, - interp_filters, subpel_x_q4, x_step_q4, subpel_y_q4, - y_step_q4, avg, bd); - - avg = 0; - av1_highbd_convolve(CONVERT_TO_BYTEPTR(src0 + offset), src_stride, - CONVERT_TO_BYTEPTR(dst), dst_stride, w, h, - interp_filters, subpel_x_q4, x_step_q4, subpel_y_q4, - y_step_q4, avg, bd); - avg = 1; - av1_highbd_convolve(CONVERT_TO_BYTEPTR(src1 + offset), src_stride, - CONVERT_TO_BYTEPTR(dst), dst_stride, w, h, - interp_filters, subpel_x_q4, x_step_q4, subpel_y_q4, - y_step_q4, avg, bd); - - EXPECT_EQ(dst[0], ROUND_POWER_OF_TWO(dst0[0] + dst1[0], 1)); - } - } -} -#endif // CONFIG_HIGHBITDEPTH - -#define CONVOLVE_SPEED_TEST 0 -#if CONVOLVE_SPEED_TEST -#define highbd_convolve_speed(func, block_size, frame_size) \ - TEST(AV1ConvolveTest, func##_speed_##block_size##_##frame_size) { \ - ACMRandom rnd(ACMRandom::DeterministicSeed()); \ - InterpFilter interp_filter = EIGHTTAP; \ - InterpFilterParams filter_params = \ - av1_get_interp_filter_params(interp_filter); \ - int filter_size = filter_params.tap; \ - int filter_center = filter_size / 2 - 1; \ - DECLARE_ALIGNED(16, uint16_t, \ - src[(frame_size + 7) * (frame_size + 7)]) = { 0 }; \ - int src_stride = frame_size + 7; \ - DECLARE_ALIGNED(16, uint16_t, dst[frame_size * frame_size]) = { 0 }; \ - int dst_stride = frame_size; \ - int x_step_q4 = 16; \ - int y_step_q4 = 16; \ - int subpel_x_q4 = 8; \ - int subpel_y_q4 = 6; \ - int bd = 10; \ - \ - int w = block_size; \ - int h = block_size; \ - \ - const int16_t *filter_x = \ - av1_get_interp_filter_kernel(filter_params, subpel_x_q4); \ - const int16_t *filter_y = \ - av1_get_interp_filter_kernel(filter_params, subpel_y_q4); \ - \ - for (int i = 0; i < src_stride * src_stride; i++) { \ - src[i] = rnd.Rand16() % (1 << bd); \ - } \ - \ - int offset = filter_center * src_stride + filter_center; \ - int row_offset = 0; \ - int col_offset = 0; \ - for (int i = 0; i < 100000; i++) { \ - int src_total_offset = offset + col_offset * src_stride + row_offset; \ - int dst_total_offset = col_offset * dst_stride + row_offset; \ - func(CONVERT_TO_BYTEPTR(src + src_total_offset), src_stride, \ - CONVERT_TO_BYTEPTR(dst + dst_total_offset), dst_stride, filter_x, \ - x_step_q4, filter_y, y_step_q4, w, h, bd); \ - if (offset + w + w < frame_size) { \ - row_offset += w; \ - } else { \ - row_offset = 0; \ - col_offset += h; \ - } \ - if (col_offset + h >= frame_size) { \ - col_offset = 0; \ - } \ - } \ - } - -#define lowbd_convolve_speed(func, block_size, frame_size) \ - TEST(AV1ConvolveTest, func##_speed_l_##block_size##_##frame_size) { \ - ACMRandom rnd(ACMRandom::DeterministicSeed()); \ - InterpFilter interp_filter = EIGHTTAP; \ - InterpFilterParams filter_params = \ - av1_get_interp_filter_params(interp_filter); \ - int filter_size = filter_params.tap; \ - int filter_center = filter_size / 2 - 1; \ - DECLARE_ALIGNED(16, uint8_t, src[(frame_size + 7) * (frame_size + 7)]); \ - int src_stride = frame_size + 7; \ - DECLARE_ALIGNED(16, uint8_t, dst[frame_size * frame_size]); \ - int dst_stride = frame_size; \ - int x_step_q4 = 16; \ - int y_step_q4 = 16; \ - int subpel_x_q4 = 8; \ - int subpel_y_q4 = 6; \ - int bd = 8; \ - \ - int w = block_size; \ - int h = block_size; \ - \ - const int16_t *filter_x = \ - av1_get_interp_filter_kernel(filter_params, subpel_x_q4); \ - const int16_t *filter_y = \ - av1_get_interp_filter_kernel(filter_params, subpel_y_q4); \ - \ - for (int i = 0; i < src_stride * src_stride; i++) { \ - src[i] = rnd.Rand16() % (1 << bd); \ - } \ - \ - int offset = filter_center * src_stride + filter_center; \ - int row_offset = 0; \ - int col_offset = 0; \ - for (int i = 0; i < 100000; i++) { \ - func(src + offset, src_stride, dst, dst_stride, filter_x, x_step_q4, \ - filter_y, y_step_q4, w, h); \ - if (offset + w + w < frame_size) { \ - row_offset += w; \ - } else { \ - row_offset = 0; \ - col_offset += h; \ - } \ - if (col_offset + h >= frame_size) { \ - col_offset = 0; \ - } \ - } \ - } - -// This experiment shows that when frame size is 64x64 -// aom_highbd_convolve8_sse2 and aom_convolve8_sse2's speed are similar. -// However when frame size becomes 1024x1024 -// aom_highbd_convolve8_sse2 is around 50% slower than aom_convolve8_sse2 -// we think the bottleneck is from memory IO -highbd_convolve_speed(aom_highbd_convolve8_sse2, 8, 64); -highbd_convolve_speed(aom_highbd_convolve8_sse2, 16, 64); -highbd_convolve_speed(aom_highbd_convolve8_sse2, 32, 64); -highbd_convolve_speed(aom_highbd_convolve8_sse2, 64, 64); - -lowbd_convolve_speed(aom_convolve8_sse2, 8, 64); -lowbd_convolve_speed(aom_convolve8_sse2, 16, 64); -lowbd_convolve_speed(aom_convolve8_sse2, 32, 64); -lowbd_convolve_speed(aom_convolve8_sse2, 64, 64); - -highbd_convolve_speed(aom_highbd_convolve8_sse2, 8, 1024); -highbd_convolve_speed(aom_highbd_convolve8_sse2, 16, 1024); -highbd_convolve_speed(aom_highbd_convolve8_sse2, 32, 1024); -highbd_convolve_speed(aom_highbd_convolve8_sse2, 64, 1024); - -lowbd_convolve_speed(aom_convolve8_sse2, 8, 1024); -lowbd_convolve_speed(aom_convolve8_sse2, 16, 1024); -lowbd_convolve_speed(aom_convolve8_sse2, 32, 1024); -lowbd_convolve_speed(aom_convolve8_sse2, 64, 1024); -#endif // CONVOLVE_SPEED_TEST -} // namespace |