test/frame_resize_test.cc - aom - Git at Google

 /*
  * Copyright (c) 2024, 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 "config/av1_rtcd.h"
 #include "test/acm_random.h"
 #include "test/util.h"
 #include "aom_ports/aom_timer.h"
 #include "aom_ports/bitops.h"
 #include "third_party/googletest/src/googletest/include/gtest/gtest.h"

 namespace {

 using ::testing::Combine;
 using ::testing::Values;
 using ::testing::ValuesIn;

 using std::make_tuple;
 using std::tuple;

 const int kIters = 1000;

 typedef tuple<int, int> FrameDimension;

 // Check that two 8-bit output buffers are identical.
 void AssertOutputBufferEq(const uint8_t *p1, const uint8_t *p2, int width,
                           int height) {
   ASSERT_TRUE(p1 != p2) << "Buffers must be at different memory locations";
   for (int j = 0; j < height; ++j) {
     if (memcmp(p1, p2, sizeof(*p1) * width) == 0) {
       p1 += width;
       p2 += width;
       continue;
     }
     for (int i = 0; i < width; ++i) {
       ASSERT_EQ(p1[i], p2[i])
           << width << "x" << height << " Pixel mismatch at (" << i << ", " << j
           << ")";
     }
   }
 }

 typedef bool (*LowBDResizeFunc)(uint8_t *intbuf, uint8_t *output,
                                 int out_stride, int height, int height2,
                                 int stride, int start_wd);
 // Test parameter list:
 //  <tst_fun, dims>
 typedef tuple<LowBDResizeFunc, FrameDimension> ResizeTestParams;

 class AV1ResizeYTest : public ::testing::TestWithParam<ResizeTestParams> {
  public:
   void SetUp() {
     test_fun_ = GET_PARAM(0);
     frame_dim_ = GET_PARAM(1);
     width_ = std::get<0>(frame_dim_);
     height_ = std::get<1>(frame_dim_);
     const int msb = get_msb(AOMMIN(width_, height_));
     n_levels_ = AOMMAX(msb - MIN_PYRAMID_SIZE_LOG2, 1);

     src_ = (uint8_t *)aom_malloc((width_ / 2) * height_ * sizeof(*src_));
     ref_dest_ =
         (uint8_t *)aom_calloc((width_ * height_) / 4, sizeof(*ref_dest_));
     test_dest_ =
         (uint8_t *)aom_calloc((width_ * height_) / 4, sizeof(*test_dest_));
   }

   void RunTest() {
     for (int i = 0; i < (width_ / 2) * height_; i++) src_[i] = rng_.Rand8();
     for (int level = 1; level < n_levels_; level++) {
       const int width2 = (width_ >> level);
       const int height2 = (height_ >> level);
       av1_resize_vert_dir_c(src_, ref_dest_, width2, height2 << 1, height2,
                             width2, 0);
       test_fun_(src_, test_dest_, width2, height2 << 1, height2, width2, 0);

       AssertOutputBufferEq(ref_dest_, test_dest_, width2, height2);
     }
   }

   void SpeedTest() {
     for (int i = 0; i < (width_ / 2) * height_; i++) src_[i] = rng_.Rand8();
     for (int level = 1; level < n_levels_; level++) {
       const int width2 = (width_ >> level);
       const int height2 = (height_ >> level);
       aom_usec_timer ref_timer;
       aom_usec_timer_start(&ref_timer);
       for (int j = 0; j < kIters; j++) {
         av1_resize_vert_dir_c(src_, ref_dest_, width2, height2 << 1, height2,
                               width2, 0);
       }
       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 (int j = 0; j < kIters; j++) {
         test_fun_(src_, test_dest_, width2, height2 << 1, height2, width2, 0);
       }
       aom_usec_timer_mark(&tst_timer);
       const int64_t tst_time = aom_usec_timer_elapsed(&tst_timer);

       std::cout << "level: " << level << " [" << width2 << " x " << height2
                 << "] C time = " << ref_time << " , SIMD time = " << tst_time
                 << " scaling=" << float(1.00) * ref_time / tst_time << "x \n";
     }
   }

   void TearDown() {
     aom_free(src_);
     aom_free(ref_dest_);
     aom_free(test_dest_);
   }

  private:
   LowBDResizeFunc test_fun_;
   FrameDimension frame_dim_;
   int width_;
   int height_;
   int n_levels_;
   uint8_t *src_;
   uint8_t *ref_dest_;
   uint8_t *test_dest_;
   libaom_test::ACMRandom rng_;
 };

 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(AV1ResizeYTest);

 TEST_P(AV1ResizeYTest, RunTest) { RunTest(); }

 TEST_P(AV1ResizeYTest, DISABLED_SpeedTest) { SpeedTest(); }

 #if HAVE_AVX2 || HAVE_SSE2
 // Resolutions (width x height) to be tested for resizing.
 const FrameDimension kFrameDim[] = {
   make_tuple(3840, 2160), make_tuple(2560, 1440), make_tuple(1920, 1080),
   make_tuple(1280, 720),  make_tuple(640, 480),   make_tuple(640, 360),
   make_tuple(256, 256),
 };
 #endif

 #if HAVE_AVX2
 INSTANTIATE_TEST_SUITE_P(
     AVX2, AV1ResizeYTest,
     ::testing::Combine(::testing::Values(av1_resize_vert_dir_avx2),
                        ::testing::ValuesIn(kFrameDim)));
 #endif

 #if HAVE_SSE2
 INSTANTIATE_TEST_SUITE_P(
     SSE2, AV1ResizeYTest,
     ::testing::Combine(::testing::Values(av1_resize_vert_dir_sse2),
                        ::testing::ValuesIn(kFrameDim)));
 #endif

 typedef void (*LowBDResize_x_Func)(const uint8_t *const input, int in_stride,
                                    uint8_t *intbuf, int height,
                                    int filteredlength, int width2);

 typedef tuple<LowBDResize_x_Func, FrameDimension> Resize_x_TestParams;

 class AV1ResizeXTest : public ::testing::TestWithParam<Resize_x_TestParams> {
  public:
   void SetUp() {
     test_fun_ = GET_PARAM(0);
     frame_dim_ = GET_PARAM(1);
     width_ = std::get<0>(frame_dim_);
     height_ = std::get<1>(frame_dim_);
     const int msb = get_msb(AOMMIN(width_, height_));
     n_levels_ = AOMMAX(msb - MIN_PYRAMID_SIZE_LOG2, 1);
     src_ = (uint8_t *)aom_malloc(width_ * height_ * sizeof(*src_));
     ref_dest_ =
         (uint8_t *)aom_calloc((width_ * height_) / 2, sizeof(*ref_dest_));
     test_dest_ =
         (uint8_t *)aom_calloc((width_ * height_) / 2, sizeof(*test_dest_));
   }

   void RunTest() {
     for (int i = 0; i < width_ * height_; ++i) src_[i] = rng_.Rand8();

     for (int level = 1; level < n_levels_; ++level) {
       const int width2 = (width_ >> level);
       av1_resize_horz_dir_c(src_, width_, ref_dest_, height_, width2 << 1,
                             width2);
       test_fun_(src_, width_, test_dest_, height_, width2 << 1, width2);
       AssertOutputBufferEq(ref_dest_, test_dest_, width2, height_);
     }
   }

   void SpeedTest() {
     for (int i = 0; i < width_ * height_; ++i) src_[i] = rng_.Rand8();

     for (int level = 1; level < n_levels_; ++level) {
       const int width2 = (width_ >> level);
       aom_usec_timer ref_timer;
       aom_usec_timer_start(&ref_timer);
       for (int j = 0; j < kIters; ++j) {
         av1_resize_horz_dir_c(src_, width_, ref_dest_, height_, width2 << 1,
                               width2);
       }
       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 (int j = 0; j < kIters; ++j) {
         test_fun_(src_, width_, test_dest_, height_, width2 << 1, width2);
       }
       aom_usec_timer_mark(&tst_timer);
       const int64_t tst_time = aom_usec_timer_elapsed(&tst_timer);

       std::cout << "level: " << level << " [" << width2 << " x " << height_
                 << "] C time = " << ref_time << " , SIMD time = " << tst_time
                 << " scaling=" << float(1.00) * ref_time / tst_time << "x \n";
     }
   }

   void TearDown() {
     aom_free(src_);
     aom_free(ref_dest_);
     aom_free(test_dest_);
   }

  private:
   LowBDResize_x_Func test_fun_;
   FrameDimension frame_dim_;
   int width_;
   int height_;
   int n_levels_;
   uint8_t *src_;
   uint8_t *ref_dest_;
   uint8_t *test_dest_;
   libaom_test::ACMRandom rng_;
 };

 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(AV1ResizeXTest);

 TEST_P(AV1ResizeXTest, RunTest) { RunTest(); }

 TEST_P(AV1ResizeXTest, DISABLED_SpeedTest) { SpeedTest(); }

 // TODO(https://crbug.com/aomedia/3575): Reenable this after test passes under
 // 32-bit valgrind.
 #if 0  // HAVE_SSE2
 INSTANTIATE_TEST_SUITE_P(
     SSE2, AV1ResizeXTest,
     ::testing::Combine(::testing::Values(av1_resize_horz_dir_sse2),
                        ::testing::ValuesIn(kFrameDim)));
 #endif

 #if HAVE_AVX2
 INSTANTIATE_TEST_SUITE_P(
     AVX2, AV1ResizeXTest,
     ::testing::Combine(::testing::Values(av1_resize_horz_dir_avx2),
                        ::testing::ValuesIn(kFrameDim)));
 #endif

 }  // namespace
	/*
	* Copyright (c) 2024, 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 "config/av1_rtcd.h"
	#include "test/acm_random.h"
	#include "test/util.h"
	#include "aom_ports/aom_timer.h"
	#include "aom_ports/bitops.h"
	#include "third_party/googletest/src/googletest/include/gtest/gtest.h"

	namespace {

	using ::testing::Combine;
	using ::testing::Values;
	using ::testing::ValuesIn;

	using std::make_tuple;
	using std::tuple;

	const int kIters = 1000;

	typedef tuple<int, int> FrameDimension;

	// Check that two 8-bit output buffers are identical.
	void AssertOutputBufferEq(const uint8_t p1, const uint8_t p2, int width,
	int height) {
	ASSERT_TRUE(p1 != p2) << "Buffers must be at different memory locations";
	for (int j = 0; j < height; ++j) {
	if (memcmp(p1, p2, sizeof(p1) width) == 0) {
	p1 += width;
	p2 += width;
	continue;
	}
	for (int i = 0; i < width; ++i) {
	ASSERT_EQ(p1[i], p2[i])
	<< width << "x" << height << " Pixel mismatch at (" << i << ", " << j
	<< ")";
	}
	}
	}

	typedef bool (LowBDResizeFunc)(uint8_t intbuf, uint8_t *output,
	int out_stride, int height, int height2,
	int stride, int start_wd);
	// Test parameter list:
	// <tst_fun, dims>
	typedef tuple<LowBDResizeFunc, FrameDimension> ResizeTestParams;

	class AV1ResizeYTest : public ::testing::TestWithParam<ResizeTestParams> {
	public:
	void SetUp() {
	test_fun_ = GET_PARAM(0);
	frame_dim_ = GET_PARAM(1);
	width_ = std::get<0>(frame_dim_);
	height_ = std::get<1>(frame_dim_);
	const int msb = get_msb(AOMMIN(width_, height_));
	n_levels_ = AOMMAX(msb - MIN_PYRAMID_SIZE_LOG2, 1);

	src_ = (uint8_t )aom_malloc((width_ / 2) height_ * sizeof(*src_));
	ref_dest_ =
	(uint8_t )aom_calloc((width_ height_) / 4, sizeof(*ref_dest_));
	test_dest_ =
	(uint8_t )aom_calloc((width_ height_) / 4, sizeof(*test_dest_));
	}

	void RunTest() {
	for (int i = 0; i < (width_ / 2) * height_; i++) src_[i] = rng_.Rand8();
	for (int level = 1; level < n_levels_; level++) {
	const int width2 = (width_ >> level);
	const int height2 = (height_ >> level);
	av1_resize_vert_dir_c(src_, ref_dest_, width2, height2 << 1, height2,
	width2, 0);
	test_fun_(src_, test_dest_, width2, height2 << 1, height2, width2, 0);

	AssertOutputBufferEq(ref_dest_, test_dest_, width2, height2);
	}
	}

	void SpeedTest() {
	for (int i = 0; i < (width_ / 2) * height_; i++) src_[i] = rng_.Rand8();
	for (int level = 1; level < n_levels_; level++) {
	const int width2 = (width_ >> level);
	const int height2 = (height_ >> level);
	aom_usec_timer ref_timer;
	aom_usec_timer_start(&ref_timer);
	for (int j = 0; j < kIters; j++) {
	av1_resize_vert_dir_c(src_, ref_dest_, width2, height2 << 1, height2,
	width2, 0);
	}
	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 (int j = 0; j < kIters; j++) {
	test_fun_(src_, test_dest_, width2, height2 << 1, height2, width2, 0);
	}
	aom_usec_timer_mark(&tst_timer);
	const int64_t tst_time = aom_usec_timer_elapsed(&tst_timer);

	std::cout << "level: " << level << " [" << width2 << " x " << height2
	<< "] C time = " << ref_time << " , SIMD time = " << tst_time
	<< " scaling=" << float(1.00) * ref_time / tst_time << "x \n";
	}
	}

	void TearDown() {
	aom_free(src_);
	aom_free(ref_dest_);
	aom_free(test_dest_);
	}

	private:
	LowBDResizeFunc test_fun_;
	FrameDimension frame_dim_;
	int width_;
	int height_;
	int n_levels_;
	uint8_t *src_;
	uint8_t *ref_dest_;
	uint8_t *test_dest_;
	libaom_test::ACMRandom rng_;
	};

	GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(AV1ResizeYTest);

	TEST_P(AV1ResizeYTest, RunTest) { RunTest(); }

	TEST_P(AV1ResizeYTest, DISABLED_SpeedTest) { SpeedTest(); }

	#if HAVE_AVX2 \|\| HAVE_SSE2
	// Resolutions (width x height) to be tested for resizing.
	const FrameDimension kFrameDim[] = {
	make_tuple(3840, 2160), make_tuple(2560, 1440), make_tuple(1920, 1080),
	make_tuple(1280, 720), make_tuple(640, 480), make_tuple(640, 360),
	make_tuple(256, 256),
	};
	#endif

	#if HAVE_AVX2
	INSTANTIATE_TEST_SUITE_P(
	AVX2, AV1ResizeYTest,
	::testing::Combine(::testing::Values(av1_resize_vert_dir_avx2),
	::testing::ValuesIn(kFrameDim)));
	#endif

	#if HAVE_SSE2
	INSTANTIATE_TEST_SUITE_P(
	SSE2, AV1ResizeYTest,
	::testing::Combine(::testing::Values(av1_resize_vert_dir_sse2),
	::testing::ValuesIn(kFrameDim)));
	#endif

	typedef void (LowBDResize_x_Func)(const uint8_t const input, int in_stride,
	uint8_t *intbuf, int height,
	int filteredlength, int width2);

	typedef tuple<LowBDResize_x_Func, FrameDimension> Resize_x_TestParams;

	class AV1ResizeXTest : public ::testing::TestWithParam<Resize_x_TestParams> {
	public:
	void SetUp() {
	test_fun_ = GET_PARAM(0);
	frame_dim_ = GET_PARAM(1);
	width_ = std::get<0>(frame_dim_);
	height_ = std::get<1>(frame_dim_);
	const int msb = get_msb(AOMMIN(width_, height_));
	n_levels_ = AOMMAX(msb - MIN_PYRAMID_SIZE_LOG2, 1);
	src_ = (uint8_t )aom_malloc(width_ height_ * sizeof(*src_));
	ref_dest_ =
	(uint8_t )aom_calloc((width_ height_) / 2, sizeof(*ref_dest_));
	test_dest_ =
	(uint8_t )aom_calloc((width_ height_) / 2, sizeof(*test_dest_));
	}

	void RunTest() {
	for (int i = 0; i < width_ * height_; ++i) src_[i] = rng_.Rand8();

	for (int level = 1; level < n_levels_; ++level) {
	const int width2 = (width_ >> level);
	av1_resize_horz_dir_c(src_, width_, ref_dest_, height_, width2 << 1,
	width2);
	test_fun_(src_, width_, test_dest_, height_, width2 << 1, width2);
	AssertOutputBufferEq(ref_dest_, test_dest_, width2, height_);
	}
	}

	void SpeedTest() {
	for (int i = 0; i < width_ * height_; ++i) src_[i] = rng_.Rand8();

	for (int level = 1; level < n_levels_; ++level) {
	const int width2 = (width_ >> level);
	aom_usec_timer ref_timer;
	aom_usec_timer_start(&ref_timer);
	for (int j = 0; j < kIters; ++j) {
	av1_resize_horz_dir_c(src_, width_, ref_dest_, height_, width2 << 1,
	width2);
	}
	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 (int j = 0; j < kIters; ++j) {
	test_fun_(src_, width_, test_dest_, height_, width2 << 1, width2);
	}
	aom_usec_timer_mark(&tst_timer);
	const int64_t tst_time = aom_usec_timer_elapsed(&tst_timer);

	std::cout << "level: " << level << " [" << width2 << " x " << height_
	<< "] C time = " << ref_time << " , SIMD time = " << tst_time
	<< " scaling=" << float(1.00) * ref_time / tst_time << "x \n";
	}
	}

	void TearDown() {
	aom_free(src_);
	aom_free(ref_dest_);
	aom_free(test_dest_);
	}

	private:
	LowBDResize_x_Func test_fun_;
	FrameDimension frame_dim_;
	int width_;
	int height_;
	int n_levels_;
	uint8_t *src_;
	uint8_t *ref_dest_;
	uint8_t *test_dest_;
	libaom_test::ACMRandom rng_;
	};

	GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(AV1ResizeXTest);

	TEST_P(AV1ResizeXTest, RunTest) { RunTest(); }

	TEST_P(AV1ResizeXTest, DISABLED_SpeedTest) { SpeedTest(); }

	// TODO(https://crbug.com/aomedia/3575): Reenable this after test passes under
	// 32-bit valgrind.
	#if 0 // HAVE_SSE2
	INSTANTIATE_TEST_SUITE_P(
	SSE2, AV1ResizeXTest,
	::testing::Combine(::testing::Values(av1_resize_horz_dir_sse2),
	::testing::ValuesIn(kFrameDim)));
	#endif

	#if HAVE_AVX2
	INSTANTIATE_TEST_SUITE_P(
	AVX2, AV1ResizeXTest,
	::testing::Combine(::testing::Values(av1_resize_horz_dir_avx2),
	::testing::ValuesIn(kFrameDim)));
	#endif

	} // namespace