media/parsers/h266_nalu_parser_unittest.cc - chromium/src - Git at Google

 // Copyright 2023 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include <memory>
 #include <string>

 #include "base/files/file_path.h"
 #include "base/files/memory_mapped_file.h"
 #include "base/logging.h"
 #include "media/base/subsample_entry.h"
 #include "media/base/test_data_util.h"
 #include "media/parsers/h266_nalu_parser.h"
 #include "testing/gtest/include/gtest/gtest.h"

 namespace media {

 namespace {
 struct VvcTestData {
   std::string file_name;
   // Number of NALUs in the test stream to be parsed.
   int num_nalus;
 };

 }  // namespace

 class H266NaluParserTest : public ::testing::Test {
  protected:
   void LoadParserFile(std::string file_name) {
     parser_.Reset();
     base::FilePath file_path = GetTestDataFilePath(file_name);
     stream_ = std::make_unique<base::MemoryMappedFile>();
     ASSERT_TRUE(stream_->Initialize(file_path))
         << "Couldn't open stream file: " << file_path.MaybeAsASCII();
     parser_.SetStream(stream_->data(), stream_->length());
   }
   bool ParseNalusUntilNut(H266NALU* target_nalu, H266NALU::Type nalu_type) {
     while (true) {
       H266NaluParser::Result res = parser_.AdvanceToNextNALU(target_nalu);
       if (res == H266NaluParser::kEndOfStream) {
         return false;
       }
       EXPECT_EQ(res, H266NaluParser::kOk);
       if (target_nalu->nal_unit_type == nalu_type) {
         return true;
       }
     }
   }
   H266NaluParser parser_;
   std::unique_ptr<base::MemoryMappedFile> stream_;
 };

 TEST_F(H266NaluParserTest, RawVvcStreamFileParsingShouldSucceed) {
   VvcTestData test_data[] = {
       {"bear_180p.vvc", 54},
       {"bbb_360p.vvc", 87},
   };
   for (const auto& data : test_data) {
     LoadParserFile(data.file_name);
     // Parse until the end of stream/unsupported stream/error in stream is
     // found.
     int num_parsed_nalus = 0;
     while (true) {
       H266NALU nalu;
       H266NaluParser::Result res = parser_.AdvanceToNextNALU(&nalu);
       if (res == H266NaluParser::kEndOfStream) {
         DVLOG(1) << "Number of successfully parsed NALUs before EOS: "
                  << num_parsed_nalus;
         EXPECT_EQ(data.num_nalus, num_parsed_nalus);
         break;
       }
       EXPECT_EQ(res, H266NaluParser::kOk);
       ++num_parsed_nalus;
       DVLOG(4) << "Found NALU " << nalu.nal_unit_type;
       EXPECT_EQ(res, H266NaluParser::kOk);
     }
   }
 }

 // Verify that GetCurrentSubsamples works.
 TEST_F(H266NaluParserTest, GetCurrentSubsamplesNormalShouldSucceed) {
   constexpr uint8_t kStream[] = {
       // First NALU.
       // Clear bytes = 5.
       0x00,
       0x00,
       0x01,  // start code.
       0x00,
       0x41,  // Nalu type = 8, IDR_N_LP picture
       // Below is bogus data.
       // Encrypted bytes = 15.
       0x00,
       0x01,
       0x02,
       0x03,
       0x04,
       0x05,
       0x06,
       0x07,
       0x00,
       0x01,
       0x02,
       0x03,
       0x04,
       0x05,
       0x06,
       // Clear bytes = 5.
       0x07,
       0x00,
       0x01,
       0x02,
       0x03,
       // Encrypted until next NALU. Encrypted bytes = 20.
       0x04,
       0x05,
       0x06,
       0x07,
       0x00,
       0x01,
       0x02,
       0x03,
       0x04,
       0x05,
       0x06,
       0x07,
       // Note that this is still in the encrypted region but looks like a start
       // code.
       0x00,
       0x00,
       0x01,
       0x03,
       0x04,
       0x05,
       0x06,
       0x07,
       // Second NALU. Completely clear.
       // Clear bytes = 11.
       0x00,
       0x00,
       0x01,  // start code.
       0x00,
       0x79,  // nalu type = 15, SPS.
       // Bogus data.
       0xff,
       0xfe,
       0xfd,
       0xee,
       0x12,
       0x33,
   };
   std::vector<SubsampleEntry> subsamples;
   subsamples.emplace_back(5u, 15u);
   subsamples.emplace_back(5u, 20u);
   subsamples.emplace_back(11u, 0u);
   H266NaluParser parser;
   parser.SetEncryptedStream(kStream, std::size(kStream), subsamples);
   H266NALU nalu;
   EXPECT_EQ(H266NaluParser::kOk, parser.AdvanceToNextNALU(&nalu));
   EXPECT_EQ(H266NALU::kIDRNoLeadingPicture, nalu.nal_unit_type);
   auto nalu_subsamples = parser.GetCurrentSubsamples();
   EXPECT_EQ(2u, nalu_subsamples.size());
   // Note that nalu->data starts from the NALU header, i.e. does not include
   // the start code.
   EXPECT_EQ(2u, nalu_subsamples[0].clear_bytes);
   EXPECT_EQ(15u, nalu_subsamples[0].cypher_bytes);
   EXPECT_EQ(5u, nalu_subsamples[1].clear_bytes);
   EXPECT_EQ(20u, nalu_subsamples[1].cypher_bytes);
   // Make sure that it reached the next NALU.
   EXPECT_EQ(H266NaluParser::kOk, parser.AdvanceToNextNALU(&nalu));
   EXPECT_EQ(H266NALU::kSPS, nalu.nal_unit_type);
   nalu_subsamples = parser.GetCurrentSubsamples();
   EXPECT_EQ(1u, nalu_subsamples.size());
   EXPECT_EQ(8u, nalu_subsamples[0].clear_bytes);
   EXPECT_EQ(0u, nalu_subsamples[0].cypher_bytes);
 }

 // Verify that subsamples starting at non-NALU boundary also works.
 TEST_F(H266NaluParserTest,
        GetCurrentSubsamplesSubsampleNotStartingAtNaluBoundaryShouldSucceed) {
   constexpr uint8_t kStream[] = {
       // First NALU.
       // Clear bytes = 5.
       0x00,
       0x00,
       0x01,  // start code.
       0x00,
       0x41,  // Nalu type = 8, IDR_N_LP slice.
       // Below is bogus data.
       // Encrypted bytes = 24.
       0x00,
       0x01,
       0x02,
       0x03,
       0x04,
       0x05,
       0x06,
       0x07,
       0x00,
       0x01,
       0x02,
       0x03,
       0x04,
       0x05,
       0x06,
       0x07,
       0x00,
       0x01,
       0x02,
       0x03,
       0x04,
       0x05,
       0x06,
       0x07,
       // Clear bytes = 19. The rest is in the clear. Note that this is not at
       // a NALU boundary and a NALU starts below.
       0xaa,
       0x01,
       0x02,
       0x03,
       0x04,
       0x05,
       0x06,
       0x07,
       // Second NALU. Completely clear.
       0x00,
       0x00,
       0x01,  // start code.
       0x00,
       0x79,  // nalu type = 15, SPS.
       // Bogus data.
       0xff,
       0xfe,
       0xfd,
       0xee,
       0x12,
       0x33,
   };
   std::vector<SubsampleEntry> subsamples;
   subsamples.emplace_back(5u, 24u);
   subsamples.emplace_back(19u, 0u);
   H266NaluParser parser;
   parser.SetEncryptedStream(kStream, std::size(kStream), subsamples);
   H266NALU nalu;
   EXPECT_EQ(H266NaluParser::kOk, parser.AdvanceToNextNALU(&nalu));
   EXPECT_EQ(H266NALU::kIDRNoLeadingPicture, nalu.nal_unit_type);
   auto nalu_subsamples = parser.GetCurrentSubsamples();
   EXPECT_EQ(2u, nalu_subsamples.size());
   // Note that nalu->data starts from the NALU header, i.e. does not include
   // the start code.
   EXPECT_EQ(2u, nalu_subsamples[0].clear_bytes);
   EXPECT_EQ(24u, nalu_subsamples[0].cypher_bytes);
   // The nalu ends with 8 more clear bytes. The last 10 bytes should be
   // associated with the next nalu.
   EXPECT_EQ(8u, nalu_subsamples[1].clear_bytes);
   EXPECT_EQ(0u, nalu_subsamples[1].cypher_bytes);
   EXPECT_EQ(H266NaluParser::kOk, parser.AdvanceToNextNALU(&nalu));
   EXPECT_EQ(H266NALU::kSPS, nalu.nal_unit_type);
   nalu_subsamples = parser.GetCurrentSubsamples();
   EXPECT_EQ(1u, nalu_subsamples.size());
   // Although the input had 10 more bytes, since nalu->data starts from the nalu
   // header, there's only 7 more bytes left.
   EXPECT_EQ(8u, nalu_subsamples[0].clear_bytes);
   EXPECT_EQ(0u, nalu_subsamples[0].cypher_bytes);
 }

 // Verify that nalus with invalid nuh_layer_id should be ignored.
 TEST_F(H266NaluParserTest, NaluWithOutOfRangeNuhLayerIdShouldBeIgnored) {
   constexpr uint8_t kStream[] = {0x00, 0x00,
                                  0x01,  // start code.
                                  0x56,
                                  0x41,  // Nalu type = 8, IDR_N_LP slice.
                                  // Below is bogus data.
                                  0x00, 0x01, 0x02, 0x03, 0x04};
   H266NaluParser parser;
   parser.SetStream(kStream, std::size(kStream));
   H266NALU nalu;
   EXPECT_EQ(H266NaluParser::kIgnored, parser.AdvanceToNextNALU(&nalu));
 }

 // Verify that nalus with invalid nuh_temproal_id_plus1 should not be allowed.
 TEST_F(H266NaluParserTest, ParseNaluWithInvalidTemporalIdShouldFail) {
   constexpr uint8_t kStream[] = {
       0x00, 0x00,
       0x01,  // start code.
       0x00,
       0x00,  // Nalu type = 0, TRAIL_NUT slice, but nuh_temporal_id_plus1 is 0
       // Below is bogus data.
       0x50, 0x01, 0x02, 0x03, 0x04,
       // Second Nalu.
       0x00, 0x00,
       0x01,  // start code.
       0x00,
       0x42,  // Nalu type = 8, IDR_N_LP slice, but nuh_temporal_id_plus1 is 2
       // Below is bogus data.
       0x00, 0x01, 0x02, 0x03, 0x04};
   H266NaluParser parser;
   parser.SetStream(kStream, std::size(kStream));
   H266NALU nalu;
   // First Nalu with nuh_temporal_id_plus1 of 0 is not allowed.
   EXPECT_EQ(H266NaluParser::kInvalidStream, parser.AdvanceToNextNALU(&nalu));
   // IRAP picture should be with nuh_temporal_id_plus1 of 1.
   EXPECT_EQ(H266NaluParser::kInvalidStream, parser.AdvanceToNextNALU(&nalu));
 }

 // Verify that non-IRAP pictures with nuh_temporal_id_plus1 not equal to 1
 // should succeed.
 TEST_F(H266NaluParserTest, ParseNonIrapNaluWithNonZeroTemporalIdShouldSucceed) {
   constexpr uint8_t kStream[] = {
       0x00, 0x00,
       0x01,  // start code.
       0x00,
       0x0e,  // Nalu type = 0, TRAIL_NUT slice, and nuh_temporal_id_plus1 is 6
       // Below is bogus data.
       0x94, 0x55, 0x48, 0x03, 0x04};
   H266NaluParser parser;
   parser.SetStream(kStream, std::size(kStream));
   H266NALU nalu;
   EXPECT_EQ(H266NaluParser::kOk, parser.AdvanceToNextNALU(&nalu));
 }

 }  // namespace media
	// Copyright 2023 The Chromium Authors
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include <memory>
	#include <string>

	#include "base/files/file_path.h"
	#include "base/files/memory_mapped_file.h"
	#include "base/logging.h"
	#include "media/base/subsample_entry.h"
	#include "media/base/test_data_util.h"
	#include "media/parsers/h266_nalu_parser.h"
	#include "testing/gtest/include/gtest/gtest.h"

	namespace media {

	namespace {
	struct VvcTestData {
	std::string file_name;
	// Number of NALUs in the test stream to be parsed.
	int num_nalus;
	};

	} // namespace

	class H266NaluParserTest : public ::testing::Test {
	protected:
	void LoadParserFile(std::string file_name) {
	parser_.Reset();
	base::FilePath file_path = GetTestDataFilePath(file_name);
	stream_ = std::make_unique<base::MemoryMappedFile>();
	ASSERT_TRUE(stream_->Initialize(file_path))
	<< "Couldn't open stream file: " << file_path.MaybeAsASCII();
	parser_.SetStream(stream_->data(), stream_->length());
	}
	bool ParseNalusUntilNut(H266NALU* target_nalu, H266NALU::Type nalu_type) {
	while (true) {
	H266NaluParser::Result res = parser_.AdvanceToNextNALU(target_nalu);
	if (res == H266NaluParser::kEndOfStream) {
	return false;
	}
	EXPECT_EQ(res, H266NaluParser::kOk);
	if (target_nalu->nal_unit_type == nalu_type) {
	return true;
	}
	}
	}
	H266NaluParser parser_;
	std::unique_ptr<base::MemoryMappedFile> stream_;
	};

	TEST_F(H266NaluParserTest, RawVvcStreamFileParsingShouldSucceed) {
	VvcTestData test_data[] = {
	{"bear_180p.vvc", 54},
	{"bbb_360p.vvc", 87},
	};
	for (const auto& data : test_data) {
	LoadParserFile(data.file_name);
	// Parse until the end of stream/unsupported stream/error in stream is
	// found.
	int num_parsed_nalus = 0;
	while (true) {
	H266NALU nalu;
	H266NaluParser::Result res = parser_.AdvanceToNextNALU(&nalu);
	if (res == H266NaluParser::kEndOfStream) {
	DVLOG(1) << "Number of successfully parsed NALUs before EOS: "
	<< num_parsed_nalus;
	EXPECT_EQ(data.num_nalus, num_parsed_nalus);
	break;
	}
	EXPECT_EQ(res, H266NaluParser::kOk);
	++num_parsed_nalus;
	DVLOG(4) << "Found NALU " << nalu.nal_unit_type;
	EXPECT_EQ(res, H266NaluParser::kOk);
	}
	}
	}

	// Verify that GetCurrentSubsamples works.
	TEST_F(H266NaluParserTest, GetCurrentSubsamplesNormalShouldSucceed) {
	constexpr uint8_t kStream[] = {
	// First NALU.
	// Clear bytes = 5.
	0x00,
	0x00,
	0x01, // start code.
	0x00,
	0x41, // Nalu type = 8, IDR_N_LP picture
	// Below is bogus data.
	// Encrypted bytes = 15.
	0x00,
	0x01,
	0x02,
	0x03,
	0x04,
	0x05,
	0x06,
	0x07,
	0x00,
	0x01,
	0x02,
	0x03,
	0x04,
	0x05,
	0x06,
	// Clear bytes = 5.
	0x07,
	0x00,
	0x01,
	0x02,
	0x03,
	// Encrypted until next NALU. Encrypted bytes = 20.
	0x04,
	0x05,
	0x06,
	0x07,
	0x00,
	0x01,
	0x02,
	0x03,
	0x04,
	0x05,
	0x06,
	0x07,
	// Note that this is still in the encrypted region but looks like a start
	// code.
	0x00,
	0x00,
	0x01,
	0x03,
	0x04,
	0x05,
	0x06,
	0x07,
	// Second NALU. Completely clear.
	// Clear bytes = 11.
	0x00,
	0x00,
	0x01, // start code.
	0x00,
	0x79, // nalu type = 15, SPS.
	// Bogus data.
	0xff,
	0xfe,
	0xfd,
	0xee,
	0x12,
	0x33,
	};
	std::vector<SubsampleEntry> subsamples;
	subsamples.emplace_back(5u, 15u);
	subsamples.emplace_back(5u, 20u);
	subsamples.emplace_back(11u, 0u);
	H266NaluParser parser;
	parser.SetEncryptedStream(kStream, std::size(kStream), subsamples);
	H266NALU nalu;
	EXPECT_EQ(H266NaluParser::kOk, parser.AdvanceToNextNALU(&nalu));
	EXPECT_EQ(H266NALU::kIDRNoLeadingPicture, nalu.nal_unit_type);
	auto nalu_subsamples = parser.GetCurrentSubsamples();
	EXPECT_EQ(2u, nalu_subsamples.size());
	// Note that nalu->data starts from the NALU header, i.e. does not include
	// the start code.
	EXPECT_EQ(2u, nalu_subsamples[0].clear_bytes);
	EXPECT_EQ(15u, nalu_subsamples[0].cypher_bytes);
	EXPECT_EQ(5u, nalu_subsamples[1].clear_bytes);
	EXPECT_EQ(20u, nalu_subsamples[1].cypher_bytes);
	// Make sure that it reached the next NALU.
	EXPECT_EQ(H266NaluParser::kOk, parser.AdvanceToNextNALU(&nalu));
	EXPECT_EQ(H266NALU::kSPS, nalu.nal_unit_type);
	nalu_subsamples = parser.GetCurrentSubsamples();
	EXPECT_EQ(1u, nalu_subsamples.size());
	EXPECT_EQ(8u, nalu_subsamples[0].clear_bytes);
	EXPECT_EQ(0u, nalu_subsamples[0].cypher_bytes);
	}

	// Verify that subsamples starting at non-NALU boundary also works.
	TEST_F(H266NaluParserTest,
	GetCurrentSubsamplesSubsampleNotStartingAtNaluBoundaryShouldSucceed) {
	constexpr uint8_t kStream[] = {
	// First NALU.
	// Clear bytes = 5.
	0x00,
	0x00,
	0x01, // start code.
	0x00,
	0x41, // Nalu type = 8, IDR_N_LP slice.
	// Below is bogus data.
	// Encrypted bytes = 24.
	0x00,
	0x01,
	0x02,
	0x03,
	0x04,
	0x05,
	0x06,
	0x07,
	0x00,
	0x01,
	0x02,
	0x03,
	0x04,
	0x05,
	0x06,
	0x07,
	0x00,
	0x01,
	0x02,
	0x03,
	0x04,
	0x05,
	0x06,
	0x07,
	// Clear bytes = 19. The rest is in the clear. Note that this is not at
	// a NALU boundary and a NALU starts below.
	0xaa,
	0x01,
	0x02,
	0x03,
	0x04,
	0x05,
	0x06,
	0x07,
	// Second NALU. Completely clear.
	0x00,
	0x00,
	0x01, // start code.
	0x00,
	0x79, // nalu type = 15, SPS.
	// Bogus data.
	0xff,
	0xfe,
	0xfd,
	0xee,
	0x12,
	0x33,
	};
	std::vector<SubsampleEntry> subsamples;
	subsamples.emplace_back(5u, 24u);
	subsamples.emplace_back(19u, 0u);
	H266NaluParser parser;
	parser.SetEncryptedStream(kStream, std::size(kStream), subsamples);
	H266NALU nalu;
	EXPECT_EQ(H266NaluParser::kOk, parser.AdvanceToNextNALU(&nalu));
	EXPECT_EQ(H266NALU::kIDRNoLeadingPicture, nalu.nal_unit_type);
	auto nalu_subsamples = parser.GetCurrentSubsamples();
	EXPECT_EQ(2u, nalu_subsamples.size());
	// Note that nalu->data starts from the NALU header, i.e. does not include
	// the start code.
	EXPECT_EQ(2u, nalu_subsamples[0].clear_bytes);
	EXPECT_EQ(24u, nalu_subsamples[0].cypher_bytes);
	// The nalu ends with 8 more clear bytes. The last 10 bytes should be
	// associated with the next nalu.
	EXPECT_EQ(8u, nalu_subsamples[1].clear_bytes);
	EXPECT_EQ(0u, nalu_subsamples[1].cypher_bytes);
	EXPECT_EQ(H266NaluParser::kOk, parser.AdvanceToNextNALU(&nalu));
	EXPECT_EQ(H266NALU::kSPS, nalu.nal_unit_type);
	nalu_subsamples = parser.GetCurrentSubsamples();
	EXPECT_EQ(1u, nalu_subsamples.size());
	// Although the input had 10 more bytes, since nalu->data starts from the nalu
	// header, there's only 7 more bytes left.
	EXPECT_EQ(8u, nalu_subsamples[0].clear_bytes);
	EXPECT_EQ(0u, nalu_subsamples[0].cypher_bytes);
	}

	// Verify that nalus with invalid nuh_layer_id should be ignored.
	TEST_F(H266NaluParserTest, NaluWithOutOfRangeNuhLayerIdShouldBeIgnored) {
	constexpr uint8_t kStream[] = {0x00, 0x00,
	0x01, // start code.
	0x56,
	0x41, // Nalu type = 8, IDR_N_LP slice.
	// Below is bogus data.
	0x00, 0x01, 0x02, 0x03, 0x04};
	H266NaluParser parser;
	parser.SetStream(kStream, std::size(kStream));
	H266NALU nalu;
	EXPECT_EQ(H266NaluParser::kIgnored, parser.AdvanceToNextNALU(&nalu));
	}

	// Verify that nalus with invalid nuh_temproal_id_plus1 should not be allowed.
	TEST_F(H266NaluParserTest, ParseNaluWithInvalidTemporalIdShouldFail) {
	constexpr uint8_t kStream[] = {
	0x00, 0x00,
	0x01, // start code.
	0x00,
	0x00, // Nalu type = 0, TRAIL_NUT slice, but nuh_temporal_id_plus1 is 0
	// Below is bogus data.
	0x50, 0x01, 0x02, 0x03, 0x04,
	// Second Nalu.
	0x00, 0x00,
	0x01, // start code.
	0x00,
	0x42, // Nalu type = 8, IDR_N_LP slice, but nuh_temporal_id_plus1 is 2
	// Below is bogus data.
	0x00, 0x01, 0x02, 0x03, 0x04};
	H266NaluParser parser;
	parser.SetStream(kStream, std::size(kStream));
	H266NALU nalu;
	// First Nalu with nuh_temporal_id_plus1 of 0 is not allowed.
	EXPECT_EQ(H266NaluParser::kInvalidStream, parser.AdvanceToNextNALU(&nalu));
	// IRAP picture should be with nuh_temporal_id_plus1 of 1.
	EXPECT_EQ(H266NaluParser::kInvalidStream, parser.AdvanceToNextNALU(&nalu));
	}

	// Verify that non-IRAP pictures with nuh_temporal_id_plus1 not equal to 1
	// should succeed.
	TEST_F(H266NaluParserTest, ParseNonIrapNaluWithNonZeroTemporalIdShouldSucceed) {
	constexpr uint8_t kStream[] = {
	0x00, 0x00,
	0x01, // start code.
	0x00,
	0x0e, // Nalu type = 0, TRAIL_NUT slice, and nuh_temporal_id_plus1 is 6
	// Below is bogus data.
	0x94, 0x55, 0x48, 0x03, 0x04};
	H266NaluParser parser;
	parser.SetStream(kStream, std::size(kStream));
	H266NALU nalu;
	EXPECT_EQ(H266NaluParser::kOk, parser.AdvanceToNextNALU(&nalu));
	}

	} // namespace media