src/dsp/motion_field_projection_test.cc - platform/external/libgav1 - Git at Google

 // Copyright 2021 The libgav1 Authors
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //      http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 #include "src/dsp/motion_field_projection.h"

 #include <algorithm>
 #include <array>
 #include <cassert>
 #include <cmath>
 #include <cstdint>
 #include <string>

 #include "absl/strings/match.h"
 #include "absl/strings/str_format.h"
 #include "absl/time/clock.h"
 #include "absl/time/time.h"
 #include "gtest/gtest.h"
 #include "src/dsp/dsp.h"
 #include "src/utils/array_2d.h"
 #include "src/utils/common.h"
 #include "src/utils/constants.h"
 #include "src/utils/cpu.h"
 #include "src/utils/reference_info.h"
 #include "src/utils/types.h"
 #include "tests/third_party/libvpx/acm_random.h"
 #include "tests/utils.h"

 namespace libgav1 {
 namespace dsp {
 namespace {

 constexpr int kMotionFieldWidth = 160;
 constexpr int kMotionFieldHight = 120;

 // The 'int' parameter is unused but required to allow for instantiations of C,
 // NEON, etc.
 class MotionFieldProjectionTest : public testing::TestWithParam<int> {
  public:
   MotionFieldProjectionTest() = default;
   MotionFieldProjectionTest(const MotionFieldProjectionTest&) = delete;
   MotionFieldProjectionTest& operator=(const MotionFieldProjectionTest&) =
       delete;
   ~MotionFieldProjectionTest() override = default;

   void SetUp() override {
     test_utils::ResetDspTable(8);
     MotionFieldProjectionInit_C();
     const testing::TestInfo* const test_info =
         testing::UnitTest::GetInstance()->current_test_info();
     const char* const test_case = test_info->test_suite_name();
     if (absl::StartsWith(test_case, "C/")) {
     } else if (absl::StartsWith(test_case, "NEON/")) {
       MotionFieldProjectionInit_NEON();
     } else if (absl::StartsWith(test_case, "SSE41/")) {
       if ((GetCpuInfo() & kSSE4_1) != 0) {
         MotionFieldProjectionInit_SSE4_1();
       }
     } else {
       FAIL() << "Unrecognized architecture prefix in test case name: "
              << test_case;
     }
     const Dsp* const dsp = GetDspTable(8);
     ASSERT_NE(dsp, nullptr);
     target_motion_field_projection_kernel_func_ =
         dsp->motion_field_projection_kernel;
   }

   void SetInputData(int motion_field_width, libvpx_test::ACMRandom* rnd);
   void TestRandomValues(bool speed);

  private:
   MotionFieldProjectionKernelFunc target_motion_field_projection_kernel_func_;
   ReferenceInfo reference_info_;
   TemporalMotionField motion_field_;
 };

 void MotionFieldProjectionTest::SetInputData(
     const int motion_field_width, libvpx_test::ACMRandom* const rnd) {
   ASSERT_TRUE(reference_info_.Reset(kMotionFieldHight, motion_field_width));
   ASSERT_TRUE(motion_field_.mv.Reset(kMotionFieldHight, motion_field_width,
                                      /*zero_initialize=*/false));
   ASSERT_TRUE(motion_field_.reference_offset.Reset(kMotionFieldHight,
                                                    motion_field_width,
                                                    /*zero_initialize=*/false));
   constexpr int order_hint_bits = 6;
   unsigned int order_hint_shift_bits = Mod32(32 - order_hint_bits);
   const unsigned int current_frame_order_hint =
       rnd->Rand8() & ((1 << order_hint_bits) - 1);  // [0, 63]
   uint8_t reference_frame_order_hint = 0;
   reference_info_.relative_distance_to[0] = 0;
   reference_info_.skip_references[kReferenceFrameIntra] = true;
   reference_info_.projection_divisions[kReferenceFrameIntra] = 0;
   for (int i = kReferenceFrameLast; i < kNumReferenceFrameTypes; ++i) {
     reference_frame_order_hint =
         rnd->Rand8() & ((1 << order_hint_bits) - 1);  // [0, 63]
     const int relative_distance_to =
         GetRelativeDistance(current_frame_order_hint,
                             reference_frame_order_hint, order_hint_shift_bits);
     reference_info_.relative_distance_to[i] = relative_distance_to;
     reference_info_.skip_references[i] =
         relative_distance_to > kMaxFrameDistance || relative_distance_to <= 0;
     reference_info_.projection_divisions[i] =
         reference_info_.skip_references[i]
             ? 0
             : kProjectionMvDivisionLookup[relative_distance_to];
   }
   for (int y = 0; y < kMotionFieldHight; ++y) {
     for (int x = 0; x < motion_field_width; ++x) {
       reference_info_.motion_field_reference_frame[y][x] =
           static_cast<ReferenceFrameType>(rnd->Rand16() &
                                           kReferenceFrameAlternate);
       reference_info_.motion_field_mv[y][x].mv[0] = rnd->Rand16Signed() / 512;
       reference_info_.motion_field_mv[y][x].mv[1] = rnd->Rand16Signed() / 512;
     }
   }
   MotionVector invalid_mv;
   invalid_mv.mv[0] = kInvalidMvValue;
   invalid_mv.mv[1] = kInvalidMvValue;
   MotionVector* const motion_field_mv = &motion_field_.mv[0][0];
   int8_t* const motion_field_reference_offset =
       &motion_field_.reference_offset[0][0];
   std::fill(motion_field_mv, motion_field_mv + motion_field_.mv.size(),
             invalid_mv);
   std::fill(
       motion_field_reference_offset,
       motion_field_reference_offset + motion_field_.reference_offset.size(),
       -128);
 }

 void MotionFieldProjectionTest::TestRandomValues(bool speed) {
   static const char* const kDigestMv[8] = {
       "87c2a74538f5c015809492ac2e521075", "ba7b4a5d82c6083b13a5b02eb7655ab7",
       "8c37d96bf1744d5553860bf44a4f60a3", "720aa644f85e48995db9785e87cd02e3",
       "9289c0c66524bb77a605870d78285f35", "f0326509885c2b2c89feeac53698cd47",
       "6b9ad1d672dec825cb1803063d35badc", "dfe06c57cc9c70d27246df7fd0afa0b2"};
   static const char* const kDigestReferenceOffset[8] = {
       "d8d1384268d7cf5c4514b39c329f94fb", "7f30e79ceb064befbad64a20d206a540",
       "61e2eb5644edbd3a91b939403edc891e", "7a018f1bf88193e86934241af445dc36",
       "2d6166bf8bbe1db77baf687ecf71d028", "95fee61f0219e06076d6f0e1073b1a4e",
       "64d0a63751267bdc573cab761f1fe685", "906a99e0e791dbcb9183c9b68ecc4ea3"};
   const int num_tests = speed ? 2000 : 1;
   if (target_motion_field_projection_kernel_func_ == nullptr) return;
   libvpx_test::ACMRandom rnd(libvpx_test::ACMRandom::DeterministicSeed());
   for (int width_idx = 0; width_idx < 8; ++width_idx) {
     const int motion_field_width = kMotionFieldWidth + width_idx;
     SetInputData(motion_field_width, &rnd);
     const int dst_sign = ((rnd.Rand16() & 1) != 0) ? 0 : -1;
     const int reference_to_current_with_sign =
         rnd.PseudoUniform(2 * kMaxFrameDistance + 1) - kMaxFrameDistance;
     assert(std::abs(reference_to_current_with_sign) <= kMaxFrameDistance);
     // Step of y8 and x8 is at least 16 except the last hop.
     for (int step = 16; step <= 80; step += 16) {
       const absl::Time start = absl::Now();
       for (int k = 0; k < num_tests; ++k) {
         for (int y8 = 0; y8 < kMotionFieldHight; y8 += step) {
           const int y8_end = std::min(y8 + step, kMotionFieldHight);
           for (int x8 = 0; x8 < motion_field_width; x8 += step) {
             const int x8_end = std::min(x8 + step, motion_field_width);
             target_motion_field_projection_kernel_func_(
                 reference_info_, reference_to_current_with_sign, dst_sign, y8,
                 y8_end, x8, x8_end, &motion_field_);
           }
         }
       }
       const absl::Duration elapsed_time = absl::Now() - start;
       test_utils::CheckMd5Digest(
           "MotionFieldProjectionKernel",
           absl::StrFormat("(mv) width %d  step %d", motion_field_width, step)
               .c_str(),
           kDigestMv[width_idx], motion_field_.mv[0],
           sizeof(motion_field_.mv[0][0]) * motion_field_.mv.size(),
           elapsed_time);
       test_utils::CheckMd5Digest(
           "MotionFieldProjectionKernel",
           absl::StrFormat("(ref offset) width %d  step %d", motion_field_width,
                           step)
               .c_str(),
           kDigestReferenceOffset[width_idx], motion_field_.reference_offset[0],
           sizeof(motion_field_.reference_offset[0][0]) *
               motion_field_.reference_offset.size(),
           elapsed_time);
     }
   }
 }

 TEST_P(MotionFieldProjectionTest, Correctness) { TestRandomValues(false); }

 TEST_P(MotionFieldProjectionTest, DISABLED_Speed) { TestRandomValues(true); }

 INSTANTIATE_TEST_SUITE_P(C, MotionFieldProjectionTest, testing::Values(0));

 #if LIBGAV1_ENABLE_NEON
 INSTANTIATE_TEST_SUITE_P(NEON, MotionFieldProjectionTest, testing::Values(0));
 #endif

 #if LIBGAV1_ENABLE_SSE4_1
 INSTANTIATE_TEST_SUITE_P(SSE41, MotionFieldProjectionTest, testing::Values(0));
 #endif

 }  // namespace
 }  // namespace dsp
 }  // namespace libgav1
	// Copyright 2021 The libgav1 Authors
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	#include "src/dsp/motion_field_projection.h"

	#include <algorithm>
	#include <array>
	#include <cassert>
	#include <cmath>
	#include <cstdint>
	#include <string>

	#include "absl/strings/match.h"
	#include "absl/strings/str_format.h"
	#include "absl/time/clock.h"
	#include "absl/time/time.h"
	#include "gtest/gtest.h"
	#include "src/dsp/dsp.h"
	#include "src/utils/array_2d.h"
	#include "src/utils/common.h"
	#include "src/utils/constants.h"
	#include "src/utils/cpu.h"
	#include "src/utils/reference_info.h"
	#include "src/utils/types.h"
	#include "tests/third_party/libvpx/acm_random.h"
	#include "tests/utils.h"

	namespace libgav1 {
	namespace dsp {
	namespace {

	constexpr int kMotionFieldWidth = 160;
	constexpr int kMotionFieldHight = 120;

	// The 'int' parameter is unused but required to allow for instantiations of C,
	// NEON, etc.
	class MotionFieldProjectionTest : public testing::TestWithParam<int> {
	public:
	MotionFieldProjectionTest() = default;
	MotionFieldProjectionTest(const MotionFieldProjectionTest&) = delete;
	MotionFieldProjectionTest& operator=(const MotionFieldProjectionTest&) =
	delete;
	~MotionFieldProjectionTest() override = default;

	void SetUp() override {
	test_utils::ResetDspTable(8);
	MotionFieldProjectionInit_C();
	const testing::TestInfo* const test_info =
	testing::UnitTest::GetInstance()->current_test_info();
	const char* const test_case = test_info->test_suite_name();
	if (absl::StartsWith(test_case, "C/")) {
	} else if (absl::StartsWith(test_case, "NEON/")) {
	MotionFieldProjectionInit_NEON();
	} else if (absl::StartsWith(test_case, "SSE41/")) {
	if ((GetCpuInfo() & kSSE4_1) != 0) {
	MotionFieldProjectionInit_SSE4_1();
	}
	} else {
	FAIL() << "Unrecognized architecture prefix in test case name: "
	<< test_case;
	}
	const Dsp* const dsp = GetDspTable(8);
	ASSERT_NE(dsp, nullptr);
	target_motion_field_projection_kernel_func_ =
	dsp->motion_field_projection_kernel;
	}

	void SetInputData(int motion_field_width, libvpx_test::ACMRandom* rnd);
	void TestRandomValues(bool speed);

	private:
	MotionFieldProjectionKernelFunc target_motion_field_projection_kernel_func_;
	ReferenceInfo reference_info_;
	TemporalMotionField motion_field_;
	};

	void MotionFieldProjectionTest::SetInputData(
	const int motion_field_width, libvpx_test::ACMRandom* const rnd) {
	ASSERT_TRUE(reference_info_.Reset(kMotionFieldHight, motion_field_width));
	ASSERT_TRUE(motion_field_.mv.Reset(kMotionFieldHight, motion_field_width,
	/zero_initialize=/false));
	ASSERT_TRUE(motion_field_.reference_offset.Reset(kMotionFieldHight,
	motion_field_width,
	/zero_initialize=/false));
	constexpr int order_hint_bits = 6;
	unsigned int order_hint_shift_bits = Mod32(32 - order_hint_bits);
	const unsigned int current_frame_order_hint =
	rnd->Rand8() & ((1 << order_hint_bits) - 1); // [0, 63]
	uint8_t reference_frame_order_hint = 0;
	reference_info_.relative_distance_to[0] = 0;
	reference_info_.skip_references[kReferenceFrameIntra] = true;
	reference_info_.projection_divisions[kReferenceFrameIntra] = 0;
	for (int i = kReferenceFrameLast; i < kNumReferenceFrameTypes; ++i) {
	reference_frame_order_hint =
	rnd->Rand8() & ((1 << order_hint_bits) - 1); // [0, 63]
	const int relative_distance_to =
	GetRelativeDistance(current_frame_order_hint,
	reference_frame_order_hint, order_hint_shift_bits);
	reference_info_.relative_distance_to[i] = relative_distance_to;
	reference_info_.skip_references[i] =
	relative_distance_to > kMaxFrameDistance \|\| relative_distance_to <= 0;
	reference_info_.projection_divisions[i] =
	reference_info_.skip_references[i]
	? 0
	: kProjectionMvDivisionLookup[relative_distance_to];
	}
	for (int y = 0; y < kMotionFieldHight; ++y) {
	for (int x = 0; x < motion_field_width; ++x) {
	reference_info_.motion_field_reference_frame[y][x] =
	static_cast<ReferenceFrameType>(rnd->Rand16() &
	kReferenceFrameAlternate);
	reference_info_.motion_field_mv[y][x].mv[0] = rnd->Rand16Signed() / 512;
	reference_info_.motion_field_mv[y][x].mv[1] = rnd->Rand16Signed() / 512;
	}
	}
	MotionVector invalid_mv;
	invalid_mv.mv[0] = kInvalidMvValue;
	invalid_mv.mv[1] = kInvalidMvValue;
	MotionVector* const motion_field_mv = &motion_field_.mv[0][0];
	int8_t* const motion_field_reference_offset =
	&motion_field_.reference_offset[0][0];
	std::fill(motion_field_mv, motion_field_mv + motion_field_.mv.size(),
	invalid_mv);
	std::fill(
	motion_field_reference_offset,
	motion_field_reference_offset + motion_field_.reference_offset.size(),
	-128);
	}

	void MotionFieldProjectionTest::TestRandomValues(bool speed) {
	static const char* const kDigestMv[8] = {
	"87c2a74538f5c015809492ac2e521075", "ba7b4a5d82c6083b13a5b02eb7655ab7",
	"8c37d96bf1744d5553860bf44a4f60a3", "720aa644f85e48995db9785e87cd02e3",
	"9289c0c66524bb77a605870d78285f35", "f0326509885c2b2c89feeac53698cd47",
	"6b9ad1d672dec825cb1803063d35badc", "dfe06c57cc9c70d27246df7fd0afa0b2"};
	static const char* const kDigestReferenceOffset[8] = {
	"d8d1384268d7cf5c4514b39c329f94fb", "7f30e79ceb064befbad64a20d206a540",
	"61e2eb5644edbd3a91b939403edc891e", "7a018f1bf88193e86934241af445dc36",
	"2d6166bf8bbe1db77baf687ecf71d028", "95fee61f0219e06076d6f0e1073b1a4e",
	"64d0a63751267bdc573cab761f1fe685", "906a99e0e791dbcb9183c9b68ecc4ea3"};
	const int num_tests = speed ? 2000 : 1;
	if (target_motion_field_projection_kernel_func_ == nullptr) return;
	libvpx_test::ACMRandom rnd(libvpx_test::ACMRandom::DeterministicSeed());
	for (int width_idx = 0; width_idx < 8; ++width_idx) {
	const int motion_field_width = kMotionFieldWidth + width_idx;
	SetInputData(motion_field_width, &rnd);
	const int dst_sign = ((rnd.Rand16() & 1) != 0) ? 0 : -1;
	const int reference_to_current_with_sign =
	rnd.PseudoUniform(2 * kMaxFrameDistance + 1) - kMaxFrameDistance;
	assert(std::abs(reference_to_current_with_sign) <= kMaxFrameDistance);
	// Step of y8 and x8 is at least 16 except the last hop.
	for (int step = 16; step <= 80; step += 16) {
	const absl::Time start = absl::Now();
	for (int k = 0; k < num_tests; ++k) {
	for (int y8 = 0; y8 < kMotionFieldHight; y8 += step) {
	const int y8_end = std::min(y8 + step, kMotionFieldHight);
	for (int x8 = 0; x8 < motion_field_width; x8 += step) {
	const int x8_end = std::min(x8 + step, motion_field_width);
	target_motion_field_projection_kernel_func_(
	reference_info_, reference_to_current_with_sign, dst_sign, y8,
	y8_end, x8, x8_end, &motion_field_);
	}
	}
	}
	const absl::Duration elapsed_time = absl::Now() - start;
	test_utils::CheckMd5Digest(
	"MotionFieldProjectionKernel",
	absl::StrFormat("(mv) width %d step %d", motion_field_width, step)
	.c_str(),
	kDigestMv[width_idx], motion_field_.mv[0],
	sizeof(motion_field_.mv[0][0]) * motion_field_.mv.size(),
	elapsed_time);
	test_utils::CheckMd5Digest(
	"MotionFieldProjectionKernel",
	absl::StrFormat("(ref offset) width %d step %d", motion_field_width,
	step)
	.c_str(),
	kDigestReferenceOffset[width_idx], motion_field_.reference_offset[0],
	sizeof(motion_field_.reference_offset[0][0]) *
	motion_field_.reference_offset.size(),
	elapsed_time);
	}
	}
	}

	TEST_P(MotionFieldProjectionTest, Correctness) { TestRandomValues(false); }

	TEST_P(MotionFieldProjectionTest, DISABLED_Speed) { TestRandomValues(true); }

	INSTANTIATE_TEST_SUITE_P(C, MotionFieldProjectionTest, testing::Values(0));

	#if LIBGAV1_ENABLE_NEON
	INSTANTIATE_TEST_SUITE_P(NEON, MotionFieldProjectionTest, testing::Values(0));
	#endif

	#if LIBGAV1_ENABLE_SSE4_1
	INSTANTIATE_TEST_SUITE_P(SSE41, MotionFieldProjectionTest, testing::Values(0));
	#endif

	} // namespace
	} // namespace dsp
	} // namespace libgav1