test/hiprec_convolve_test_util.cc - aom - Git at Google

 /*
  * 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 <memory>
 #include <new>

 #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() {}

 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);

   std::unique_ptr<uint8_t[]> input_(new (std::nothrow) uint8_t[h * w]);
   ASSERT_NE(input_, nullptr);
   uint8_t *input = input_.get();

   // 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;
   std::unique_ptr<uint8_t[]> output(new (std::nothrow) uint8_t[output_n]);
   ASSERT_NE(output, nullptr);
   std::unique_ptr<uint8_t[]> output2(new (std::nothrow) uint8_t[output_n]);
   ASSERT_NE(output2, nullptr);

   // 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.get(), out_w, hkernel, 16, vkernel,
                                     16, out_w, out_h, &conv_params);
       test_impl(input + offset_r * w + offset_c, w, output2.get(), 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;
     }
   }
 }

 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);

   std::unique_ptr<uint8_t[]> input_(new (std::nothrow) uint8_t[h * w]);
   ASSERT_NE(input_, nullptr);
   uint8_t *input = input_.get();

   // 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;
   std::unique_ptr<uint8_t[]> output(new (std::nothrow) uint8_t[output_n]);
   ASSERT_NE(output, nullptr);
   std::unique_ptr<uint8_t[]> output2(new (std::nothrow) uint8_t[output_n]);
   ASSERT_NE(output2, nullptr);

   // 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.get(), 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.get(), 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";
 }
 }  // namespace AV1HiprecConvolve

 #if CONFIG_AV1_HIGHBITDEPTH
 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() {}

 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);

   std::unique_ptr<uint16_t[]> input(new (std::nothrow) uint16_t[h * w]);
   ASSERT_NE(input, nullptr);

   // 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;
   std::unique_ptr<uint16_t[]> output(new (std::nothrow) uint16_t[output_n]);
   ASSERT_NE(output, nullptr);
   std::unique_ptr<uint16_t[]> output2(new (std::nothrow) uint16_t[output_n]);
   ASSERT_NE(output2, nullptr);

   // 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.get());
   uint8_t *output_ptr = CONVERT_TO_BYTEPTR(output.get());
   uint8_t *output2_ptr = CONVERT_TO_BYTEPTR(output2.get());
   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;
     }
   }
 }

 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);

   std::unique_ptr<uint16_t[]> input(new (std::nothrow) uint16_t[h * w]);
   ASSERT_NE(input, nullptr);

   // 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;
   std::unique_ptr<uint16_t[]> output(new (std::nothrow) uint16_t[output_n]);
   ASSERT_NE(output, nullptr);
   std::unique_ptr<uint16_t[]> output2(new (std::nothrow) uint16_t[output_n]);
   ASSERT_NE(output2, nullptr);

   // 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.get());
   uint8_t *output_ptr = CONVERT_TO_BYTEPTR(output.get());
   uint8_t *output2_ptr = CONVERT_TO_BYTEPTR(output2.get());

   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";
 }
 }  // namespace AV1HighbdHiprecConvolve
 #endif  // CONFIG_AV1_HIGHBITDEPTH
 }  // namespace libaom_test
	/*
	* 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 <memory>
	#include <new>

	#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() {}

	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);

	std::unique_ptr<uint8_t[]> input_(new (std::nothrow) uint8_t[h * w]);
	ASSERT_NE(input_, nullptr);
	uint8_t *input = input_.get();

	// 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;
	std::unique_ptr<uint8_t[]> output(new (std::nothrow) uint8_t[output_n]);
	ASSERT_NE(output, nullptr);
	std::unique_ptr<uint8_t[]> output2(new (std::nothrow) uint8_t[output_n]);
	ASSERT_NE(output2, nullptr);

	// 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.get(), out_w, hkernel, 16, vkernel,
	16, out_w, out_h, &conv_params);
	test_impl(input + offset_r * w + offset_c, w, output2.get(), 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;
	}
	}
	}

	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);

	std::unique_ptr<uint8_t[]> input_(new (std::nothrow) uint8_t[h * w]);
	ASSERT_NE(input_, nullptr);
	uint8_t *input = input_.get();

	// 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;
	std::unique_ptr<uint8_t[]> output(new (std::nothrow) uint8_t[output_n]);
	ASSERT_NE(output, nullptr);
	std::unique_ptr<uint8_t[]> output2(new (std::nothrow) uint8_t[output_n]);
	ASSERT_NE(output2, nullptr);

	// 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.get(), 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.get(), 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";
	}
	} // namespace AV1HiprecConvolve

	#if CONFIG_AV1_HIGHBITDEPTH
	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() {}

	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);

	std::unique_ptr<uint16_t[]> input(new (std::nothrow) uint16_t[h * w]);
	ASSERT_NE(input, nullptr);

	// 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;
	std::unique_ptr<uint16_t[]> output(new (std::nothrow) uint16_t[output_n]);
	ASSERT_NE(output, nullptr);
	std::unique_ptr<uint16_t[]> output2(new (std::nothrow) uint16_t[output_n]);
	ASSERT_NE(output2, nullptr);

	// 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.get());
	uint8_t *output_ptr = CONVERT_TO_BYTEPTR(output.get());
	uint8_t *output2_ptr = CONVERT_TO_BYTEPTR(output2.get());
	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;
	}
	}
	}

	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);

	std::unique_ptr<uint16_t[]> input(new (std::nothrow) uint16_t[h * w]);
	ASSERT_NE(input, nullptr);

	// 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;
	std::unique_ptr<uint16_t[]> output(new (std::nothrow) uint16_t[output_n]);
	ASSERT_NE(output, nullptr);
	std::unique_ptr<uint16_t[]> output2(new (std::nothrow) uint16_t[output_n]);
	ASSERT_NE(output2, nullptr);

	// 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.get());
	uint8_t *output_ptr = CONVERT_TO_BYTEPTR(output.get());
	uint8_t *output2_ptr = CONVERT_TO_BYTEPTR(output2.get());

	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";
	}
	} // namespace AV1HighbdHiprecConvolve
	#endif // CONFIG_AV1_HIGHBITDEPTH
	} // namespace libaom_test