// 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
Codebase Browser
chromium