modules/video_coding/codecs/av1/libaom_av1_unittest.cc - src - Git at Google

 /*
  *  Copyright (c) 2020 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */

 #include <stddef.h>
 #include <stdint.h>

 #include <memory>
 #include <vector>

 #include "absl/types/optional.h"
 #include "api/test/create_frame_generator.h"
 #include "api/test/frame_generator_interface.h"
 #include "api/video_codecs/video_codec.h"
 #include "api/video_codecs/video_encoder.h"
 #include "modules/video_coding/codecs/av1/libaom_av1_decoder.h"
 #include "modules/video_coding/codecs/av1/libaom_av1_encoder.h"
 #include "modules/video_coding/codecs/av1/scalable_video_controller.h"
 #include "modules/video_coding/codecs/av1/scalable_video_controller_no_layering.h"
 #include "modules/video_coding/include/video_codec_interface.h"
 #include "modules/video_coding/include/video_error_codes.h"
 #include "test/gmock.h"
 #include "test/gtest.h"

 namespace webrtc {
 namespace {

 using ::testing::ContainerEq;
 using ::testing::Each;
 using ::testing::ElementsAreArray;
 using ::testing::Ge;
 using ::testing::IsEmpty;
 using ::testing::Not;
 using ::testing::NotNull;
 using ::testing::SizeIs;
 using ::testing::Truly;
 using ::testing::Values;

 // Use small resolution for this test to make it faster.
 constexpr int kWidth = 320;
 constexpr int kHeight = 180;
 constexpr int kFramerate = 30;
 constexpr int kRtpTicksPerSecond = 90000;

 class TestAv1Encoder {
  public:
   struct Encoded {
     EncodedImage encoded_image;
     CodecSpecificInfo codec_specific_info;
   };

   TestAv1Encoder() : encoder_(CreateLibaomAv1Encoder()) { InitEncoder(); }
   explicit TestAv1Encoder(
       std::unique_ptr<ScalableVideoController> svc_controller)
       : encoder_(CreateLibaomAv1Encoder(std::move(svc_controller))) {
     InitEncoder();
   }
   // This class requires pointer stability and thus not copyable nor movable.
   TestAv1Encoder(const TestAv1Encoder&) = delete;
   TestAv1Encoder& operator=(const TestAv1Encoder&) = delete;

   void EncodeAndAppend(const VideoFrame& frame, std::vector<Encoded>* encoded) {
     callback_.SetEncodeStorage(encoded);
     std::vector<VideoFrameType> frame_types = {
         VideoFrameType::kVideoFrameDelta};
     EXPECT_EQ(encoder_->Encode(frame, &frame_types), WEBRTC_VIDEO_CODEC_OK);
     // Prefer to crash checking nullptr rather than writing to random memory.
     callback_.SetEncodeStorage(nullptr);
   }

  private:
   class EncoderCallback : public EncodedImageCallback {
    public:
     void SetEncodeStorage(std::vector<Encoded>* storage) { storage_ = storage; }

    private:
     Result OnEncodedImage(
         const EncodedImage& encoded_image,
         const CodecSpecificInfo* codec_specific_info,
         const RTPFragmentationHeader* /*fragmentation*/) override {
       RTC_CHECK(storage_);
       storage_->push_back({encoded_image, *codec_specific_info});
       return Result(Result::Error::OK);
     }

     std::vector<Encoded>* storage_ = nullptr;
   };

   void InitEncoder() {
     RTC_CHECK(encoder_);
     VideoCodec codec_settings;
     codec_settings.width = kWidth;
     codec_settings.height = kHeight;
     codec_settings.maxFramerate = kFramerate;
     VideoEncoder::Settings encoder_settings(
         VideoEncoder::Capabilities(/*loss_notification=*/false),
         /*number_of_cores=*/1, /*max_payload_size=*/1200);
     EXPECT_EQ(encoder_->InitEncode(&codec_settings, encoder_settings),
               WEBRTC_VIDEO_CODEC_OK);
     EXPECT_EQ(encoder_->RegisterEncodeCompleteCallback(&callback_),
               WEBRTC_VIDEO_CODEC_OK);
   }

   EncoderCallback callback_;
   std::unique_ptr<VideoEncoder> encoder_;
 };

 class TestAv1Decoder {
  public:
   explicit TestAv1Decoder(int decoder_id)
       : decoder_id_(decoder_id), decoder_(CreateLibaomAv1Decoder()) {
     if (decoder_ == nullptr) {
       ADD_FAILURE() << "Failed to create a decoder#" << decoder_id_;
       return;
     }
     EXPECT_EQ(decoder_->InitDecode(/*codec_settings=*/nullptr,
                                    /*number_of_cores=*/1),
               WEBRTC_VIDEO_CODEC_OK);
     EXPECT_EQ(decoder_->RegisterDecodeCompleteCallback(&callback_),
               WEBRTC_VIDEO_CODEC_OK);
   }
   // This class requires pointer stability and thus not copyable nor movable.
   TestAv1Decoder(const TestAv1Decoder&) = delete;
   TestAv1Decoder& operator=(const TestAv1Decoder&) = delete;

   void Decode(int64_t frame_id, const EncodedImage& image) {
     ASSERT_THAT(decoder_, NotNull());
     int32_t error = decoder_->Decode(image, /*missing_frames=*/false,
                                      /*render_time_ms=*/image.capture_time_ms_);
     if (error != WEBRTC_VIDEO_CODEC_OK) {
       ADD_FAILURE() << "Failed to decode frame id " << frame_id
                     << " with error code " << error << " by decoder#"
                     << decoder_id_;
       return;
     }
     decoded_ids_.push_back(frame_id);
   }

   const std::vector<int64_t>& decoded_frame_ids() const { return decoded_ids_; }
   size_t num_output_frames() const { return callback_.num_called(); }

  private:
   // Decoder callback that only counts how many times it was called.
   // While it is tempting to replace it with a simple mock, that one requires
   // to set expectation on number of calls in advance. Tests below unsure about
   // expected number of calls until after calls are done.
   class DecoderCallback : public DecodedImageCallback {
    public:
     size_t num_called() const { return num_called_; }

    private:
     int32_t Decoded(VideoFrame& /*decoded_image*/) override {
       ++num_called_;
       return 0;
     }
     void Decoded(VideoFrame& /*decoded_image*/,
                  absl::optional<int32_t> /*decode_time_ms*/,
                  absl::optional<uint8_t> /*qp*/) override {
       ++num_called_;
     }

     int num_called_ = 0;
   };

   const int decoder_id_;
   std::vector<int64_t> decoded_ids_;
   DecoderCallback callback_;
   const std::unique_ptr<VideoDecoder> decoder_;
 };

 class VideoFrameGenerator {
  public:
   VideoFrame NextFrame() {
     return VideoFrame::Builder()
         .set_video_frame_buffer(frame_buffer_generator_->NextFrame().buffer)
         .set_timestamp_rtp(timestamp_ += kRtpTicksPerSecond / kFramerate)
         .build();
   }

  private:
   uint32_t timestamp_ = 1000;
   std::unique_ptr<test::FrameGeneratorInterface> frame_buffer_generator_ =
       test::CreateSquareFrameGenerator(
           kWidth,
           kHeight,
           test::FrameGeneratorInterface::OutputType::kI420,
           absl::nullopt);
 };

 TEST(LibaomAv1Test, EncodeDecode) {
   TestAv1Decoder decoder(0);
   TestAv1Encoder encoder;
   VideoFrameGenerator generator;

   std::vector<TestAv1Encoder::Encoded> encoded_frames;
   for (size_t i = 0; i < 4; ++i) {
     encoder.EncodeAndAppend(generator.NextFrame(), &encoded_frames);
   }
   for (size_t frame_id = 0; frame_id < encoded_frames.size(); ++frame_id) {
     decoder.Decode(static_cast<int64_t>(frame_id),
                    encoded_frames[frame_id].encoded_image);
   }

   // Check encoder produced some frames for decoder to decode.
   ASSERT_THAT(encoded_frames, Not(IsEmpty()));
   // Check decoder found all of them valid.
   EXPECT_THAT(decoder.decoded_frame_ids(), SizeIs(encoded_frames.size()));
   // Check each of them produced an output frame.
   EXPECT_EQ(decoder.num_output_frames(), decoder.decoded_frame_ids().size());
 }

 struct SvcTestParam {
   std::function<std::unique_ptr<ScalableVideoController>()> svc_factory;
   int num_frames_to_generate;
 };

 class LibaomAv1SvcTest : public ::testing::TestWithParam<SvcTestParam> {};

 TEST_P(LibaomAv1SvcTest, EncodeAndDecodeAllDecodeTargets) {
   std::unique_ptr<ScalableVideoController> svc_controller =
       GetParam().svc_factory();
   size_t num_decode_targets =
       svc_controller->DependencyStructure().num_decode_targets;

   std::vector<TestAv1Encoder::Encoded> encoded_frames;
   TestAv1Encoder encoder(std::move(svc_controller));
   VideoFrameGenerator generator;
   for (int temporal_unit = 0; temporal_unit < GetParam().num_frames_to_generate;
        ++temporal_unit) {
     encoder.EncodeAndAppend(generator.NextFrame(), &encoded_frames);
   }

   ASSERT_THAT(
       encoded_frames, Each(Truly([&](const TestAv1Encoder::Encoded& frame) {
         return frame.codec_specific_info.generic_frame_info &&
                frame.codec_specific_info.generic_frame_info
                        ->decode_target_indications.size() == num_decode_targets;
       })));

   for (size_t dt = 0; dt < num_decode_targets; ++dt) {
     TestAv1Decoder decoder(dt);
     std::vector<int64_t> requested_ids;
     for (int64_t frame_id = 0;
          frame_id < static_cast<int64_t>(encoded_frames.size()); ++frame_id) {
       const TestAv1Encoder::Encoded& frame = encoded_frames[frame_id];
       if (frame.codec_specific_info.generic_frame_info
               ->decode_target_indications[dt] !=
           DecodeTargetIndication::kNotPresent) {
         requested_ids.push_back(frame_id);
         decoder.Decode(frame_id, frame.encoded_image);
       }
     }

     ASSERT_THAT(requested_ids, SizeIs(Ge(2u)));
     // Check decoder found all of them valid.
     EXPECT_THAT(decoder.decoded_frame_ids(), ContainerEq(requested_ids))
         << "Decoder#" << dt;
     // Check each of them produced an output frame.
     EXPECT_EQ(decoder.num_output_frames(), decoder.decoded_frame_ids().size())
         << "Decoder#" << dt;
   }
 }

 INSTANTIATE_TEST_SUITE_P(
     Svc,
     LibaomAv1SvcTest,
     Values(SvcTestParam{std::make_unique<ScalableVideoControllerNoLayering>,
                         /*num_frames_to_generate=*/4}));

 }  // namespace
 }  // namespace webrtc
	/*
	* Copyright (c) 2020 The WebRTC project authors. All Rights Reserved.
	*
	* Use of this source code is governed by a BSD-style license
	* that can be found in the LICENSE file in the root of the source
	* tree. An additional intellectual property rights grant can be found
	* in the file PATENTS. All contributing project authors may
	* be found in the AUTHORS file in the root of the source tree.
	*/

	#include <stddef.h>
	#include <stdint.h>

	#include <memory>
	#include <vector>

	#include "absl/types/optional.h"
	#include "api/test/create_frame_generator.h"
	#include "api/test/frame_generator_interface.h"
	#include "api/video_codecs/video_codec.h"
	#include "api/video_codecs/video_encoder.h"
	#include "modules/video_coding/codecs/av1/libaom_av1_decoder.h"
	#include "modules/video_coding/codecs/av1/libaom_av1_encoder.h"
	#include "modules/video_coding/codecs/av1/scalable_video_controller.h"
	#include "modules/video_coding/codecs/av1/scalable_video_controller_no_layering.h"
	#include "modules/video_coding/include/video_codec_interface.h"
	#include "modules/video_coding/include/video_error_codes.h"
	#include "test/gmock.h"
	#include "test/gtest.h"

	namespace webrtc {
	namespace {

	using ::testing::ContainerEq;
	using ::testing::Each;
	using ::testing::ElementsAreArray;
	using ::testing::Ge;
	using ::testing::IsEmpty;
	using ::testing::Not;
	using ::testing::NotNull;
	using ::testing::SizeIs;
	using ::testing::Truly;
	using ::testing::Values;

	// Use small resolution for this test to make it faster.
	constexpr int kWidth = 320;
	constexpr int kHeight = 180;
	constexpr int kFramerate = 30;
	constexpr int kRtpTicksPerSecond = 90000;

	class TestAv1Encoder {
	public:
	struct Encoded {
	EncodedImage encoded_image;
	CodecSpecificInfo codec_specific_info;
	};

	TestAv1Encoder() : encoder_(CreateLibaomAv1Encoder()) { InitEncoder(); }
	explicit TestAv1Encoder(
	std::unique_ptr<ScalableVideoController> svc_controller)
	: encoder_(CreateLibaomAv1Encoder(std::move(svc_controller))) {
	InitEncoder();
	}
	// This class requires pointer stability and thus not copyable nor movable.
	TestAv1Encoder(const TestAv1Encoder&) = delete;
	TestAv1Encoder& operator=(const TestAv1Encoder&) = delete;

	void EncodeAndAppend(const VideoFrame& frame, std::vector<Encoded>* encoded) {
	callback_.SetEncodeStorage(encoded);
	std::vector<VideoFrameType> frame_types = {
	VideoFrameType::kVideoFrameDelta};
	EXPECT_EQ(encoder_->Encode(frame, &frame_types), WEBRTC_VIDEO_CODEC_OK);
	// Prefer to crash checking nullptr rather than writing to random memory.
	callback_.SetEncodeStorage(nullptr);
	}

	private:
	class EncoderCallback : public EncodedImageCallback {
	public:
	void SetEncodeStorage(std::vector<Encoded>* storage) { storage_ = storage; }

	private:
	Result OnEncodedImage(
	const EncodedImage& encoded_image,
	const CodecSpecificInfo* codec_specific_info,
	const RTPFragmentationHeader* /fragmentation/) override {
	RTC_CHECK(storage_);
	storage_->push_back({encoded_image, *codec_specific_info});
	return Result(Result::Error::OK);
	}

	std::vector<Encoded>* storage_ = nullptr;
	};

	void InitEncoder() {
	RTC_CHECK(encoder_);
	VideoCodec codec_settings;
	codec_settings.width = kWidth;
	codec_settings.height = kHeight;
	codec_settings.maxFramerate = kFramerate;
	VideoEncoder::Settings encoder_settings(
	VideoEncoder::Capabilities(/loss_notification=/false),
	/number_of_cores=/1, /max_payload_size=/1200);
	EXPECT_EQ(encoder_->InitEncode(&codec_settings, encoder_settings),
	WEBRTC_VIDEO_CODEC_OK);
	EXPECT_EQ(encoder_->RegisterEncodeCompleteCallback(&callback_),
	WEBRTC_VIDEO_CODEC_OK);
	}

	EncoderCallback callback_;
	std::unique_ptr<VideoEncoder> encoder_;
	};

	class TestAv1Decoder {
	public:
	explicit TestAv1Decoder(int decoder_id)
	: decoder_id_(decoder_id), decoder_(CreateLibaomAv1Decoder()) {
	if (decoder_ == nullptr) {
	ADD_FAILURE() << "Failed to create a decoder#" << decoder_id_;
	return;
	}
	EXPECT_EQ(decoder_->InitDecode(/codec_settings=/nullptr,
	/number_of_cores=/1),
	WEBRTC_VIDEO_CODEC_OK);
	EXPECT_EQ(decoder_->RegisterDecodeCompleteCallback(&callback_),
	WEBRTC_VIDEO_CODEC_OK);
	}
	// This class requires pointer stability and thus not copyable nor movable.
	TestAv1Decoder(const TestAv1Decoder&) = delete;
	TestAv1Decoder& operator=(const TestAv1Decoder&) = delete;

	void Decode(int64_t frame_id, const EncodedImage& image) {
	ASSERT_THAT(decoder_, NotNull());
	int32_t error = decoder_->Decode(image, /missing_frames=/false,
	/render_time_ms=/image.capture_time_ms_);
	if (error != WEBRTC_VIDEO_CODEC_OK) {
	ADD_FAILURE() << "Failed to decode frame id " << frame_id
	<< " with error code " << error << " by decoder#"
	<< decoder_id_;
	return;
	}
	decoded_ids_.push_back(frame_id);
	}

	const std::vector<int64_t>& decoded_frame_ids() const { return decoded_ids_; }
	size_t num_output_frames() const { return callback_.num_called(); }

	private:
	// Decoder callback that only counts how many times it was called.
	// While it is tempting to replace it with a simple mock, that one requires
	// to set expectation on number of calls in advance. Tests below unsure about
	// expected number of calls until after calls are done.
	class DecoderCallback : public DecodedImageCallback {
	public:
	size_t num_called() const { return num_called_; }

	private:
	int32_t Decoded(VideoFrame& /decoded_image/) override {
	++num_called_;
	return 0;
	}
	void Decoded(VideoFrame& /decoded_image/,
	absl::optional<int32_t> /decode_time_ms/,
	absl::optional<uint8_t> /qp/) override {
	++num_called_;
	}

	int num_called_ = 0;
	};

	const int decoder_id_;
	std::vector<int64_t> decoded_ids_;
	DecoderCallback callback_;
	const std::unique_ptr<VideoDecoder> decoder_;
	};

	class VideoFrameGenerator {
	public:
	VideoFrame NextFrame() {
	return VideoFrame::Builder()
	.set_video_frame_buffer(frame_buffer_generator_->NextFrame().buffer)
	.set_timestamp_rtp(timestamp_ += kRtpTicksPerSecond / kFramerate)
	.build();
	}

	private:
	uint32_t timestamp_ = 1000;
	std::unique_ptr<test::FrameGeneratorInterface> frame_buffer_generator_ =
	test::CreateSquareFrameGenerator(
	kWidth,
	kHeight,
	test::FrameGeneratorInterface::OutputType::kI420,
	absl::nullopt);
	};

	TEST(LibaomAv1Test, EncodeDecode) {
	TestAv1Decoder decoder(0);
	TestAv1Encoder encoder;
	VideoFrameGenerator generator;

	std::vector<TestAv1Encoder::Encoded> encoded_frames;
	for (size_t i = 0; i < 4; ++i) {
	encoder.EncodeAndAppend(generator.NextFrame(), &encoded_frames);
	}
	for (size_t frame_id = 0; frame_id < encoded_frames.size(); ++frame_id) {
	decoder.Decode(static_cast<int64_t>(frame_id),
	encoded_frames[frame_id].encoded_image);
	}

	// Check encoder produced some frames for decoder to decode.
	ASSERT_THAT(encoded_frames, Not(IsEmpty()));
	// Check decoder found all of them valid.
	EXPECT_THAT(decoder.decoded_frame_ids(), SizeIs(encoded_frames.size()));
	// Check each of them produced an output frame.
	EXPECT_EQ(decoder.num_output_frames(), decoder.decoded_frame_ids().size());
	}

	struct SvcTestParam {
	std::function<std::unique_ptr<ScalableVideoController>()> svc_factory;
	int num_frames_to_generate;
	};

	class LibaomAv1SvcTest : public ::testing::TestWithParam<SvcTestParam> {};

	TEST_P(LibaomAv1SvcTest, EncodeAndDecodeAllDecodeTargets) {
	std::unique_ptr<ScalableVideoController> svc_controller =
	GetParam().svc_factory();
	size_t num_decode_targets =
	svc_controller->DependencyStructure().num_decode_targets;

	std::vector<TestAv1Encoder::Encoded> encoded_frames;
	TestAv1Encoder encoder(std::move(svc_controller));
	VideoFrameGenerator generator;
	for (int temporal_unit = 0; temporal_unit < GetParam().num_frames_to_generate;
	++temporal_unit) {
	encoder.EncodeAndAppend(generator.NextFrame(), &encoded_frames);
	}

	ASSERT_THAT(
	encoded_frames, Each(Truly([&](const TestAv1Encoder::Encoded& frame) {
	return frame.codec_specific_info.generic_frame_info &&
	frame.codec_specific_info.generic_frame_info
	->decode_target_indications.size() == num_decode_targets;
	})));

	for (size_t dt = 0; dt < num_decode_targets; ++dt) {
	TestAv1Decoder decoder(dt);
	std::vector<int64_t> requested_ids;
	for (int64_t frame_id = 0;
	frame_id < static_cast<int64_t>(encoded_frames.size()); ++frame_id) {
	const TestAv1Encoder::Encoded& frame = encoded_frames[frame_id];
	if (frame.codec_specific_info.generic_frame_info
	->decode_target_indications[dt] !=
	DecodeTargetIndication::kNotPresent) {
	requested_ids.push_back(frame_id);
	decoder.Decode(frame_id, frame.encoded_image);
	}
	}

	ASSERT_THAT(requested_ids, SizeIs(Ge(2u)));
	// Check decoder found all of them valid.
	EXPECT_THAT(decoder.decoded_frame_ids(), ContainerEq(requested_ids))
	<< "Decoder#" << dt;
	// Check each of them produced an output frame.
	EXPECT_EQ(decoder.num_output_frames(), decoder.decoded_frame_ids().size())
	<< "Decoder#" << dt;
	}
	}

	INSTANTIATE_TEST_SUITE_P(
	Svc,
	LibaomAv1SvcTest,
	Values(SvcTestParam{std::make_unique<ScalableVideoControllerNoLayering>,
	/num_frames_to_generate=/4}));

	} // namespace
	} // namespace webrtc