| /* |
| * 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 |
