/* This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ #include #include #include #include #include #include "ContainerParser.h" #include "MPEGAudioByteStream.h" #include "MPEGAudioByteStreamDemuxer.h" #include "MediaData.h" #include "SourceBufferResource.h" #include "mozilla/gtest/MozAssertions.h" #include "mozilla/gtest/WaitFor.h" #ifdef FUZZING_INTERFACES # include "FuzzingInterface.h" #endif using namespace mozilla; using namespace mozilla::mpeg_audio; using media::TimeUnit; namespace { // MPEG-1 Layer III, 128 kb/s, 44100 Hz, stereo. constexpr uint8_t kStereoHeader[] = {0xFF, 0xFB, 0x90, 0x00}; constexpr size_t kStereoFrameLength = 417; // MPEG-1 Layer III, 64 kb/s, 48000 Hz, mono. constexpr uint8_t kMonoHeader[] = {0xFF, 0xFB, 0x54, 0xC0}; constexpr size_t kMonoFrameLength = 192; // MPEG-2 Layer III, 64 kb/s, 22050 Hz, mono. constexpr uint8_t kMPEG2Header[] = {0xFF, 0xF3, 0x80, 0xC0}; constexpr size_t kMPEG2FrameLength = 208; // MPEG-1 Layer II, 160 kb/s, 44100 Hz, stereo. constexpr uint8_t kLayer2Header[] = {0xFF, 0xFD, 0x90, 0x00}; constexpr size_t kLayer2FrameLength = 522; // MPEG-1 Layer I, 288 kb/s, 44100 Hz, stereo. constexpr uint8_t kLayer1Header[] = {0xFF, 0xFF, 0x90, 0x00}; constexpr size_t kLayer1FrameLength = 312; // The reserved layer. constexpr uint8_t kInvalidHeader[] = {0xFF, 0xF9, 0x90, 0x00}; using Bytes = std::vector; Bytes Header(const uint8_t (&aHeader)[4]) { return Bytes(aHeader, aHeader + 4); } // A frame whose payload bytes all equal aFill. Bytes Frame(const uint8_t (&aHeader)[4], size_t aLength, uint8_t aFill = 0) { Bytes frame = Header(aHeader); frame.resize(aLength, aFill); return frame; } Bytes StereoFrame(uint8_t aFill = 0) { return Frame(kStereoHeader, kStereoFrameLength, aFill); } // A Xing or Info frame, which follows the 32 bytes of MPEG-1 stereo side // information. Bytes InfoFrame(const char* aTag) { Bytes frame = StereoFrame(); memcpy(frame.data() + 4 + 32, aTag, 4); return frame; } Bytes ID3v2(uint32_t aPayloadSize, bool aFooter = false) { Bytes tag = {'I', 'D', '3', 4, 0, uint8_t(aFooter ? 0x10 : 0), uint8_t((aPayloadSize >> 21) & 0x7F), uint8_t((aPayloadSize >> 14) & 0x7F), uint8_t((aPayloadSize >> 7) & 0x7F), uint8_t(aPayloadSize & 0x7F)}; tag.resize(tag.size() + aPayloadSize + (aFooter ? 10 : 0), 0); return tag; } Bytes Text(const char* aText) { return Bytes(aText, aText + strlen(aText)); } Bytes ID3v1() { Bytes tag = Text("TAG"); tag.resize(128, 'x'); return tag; } Bytes Garbage(size_t aLength) { return Bytes(aLength, 0x55); } Bytes Concat(std::initializer_list aParts) { Bytes bytes; for (const Bytes& part : aParts) { bytes.insert(bytes.end(), part.begin(), part.end()); } return bytes; } Span AsSpan(const Bytes& aBytes) { return Span(aBytes.data(), aBytes.size()); } Bytes Slice(const Bytes& aBytes, size_t aStart, size_t aEnd) { return Bytes(aBytes.begin() + aStart, aBytes.begin() + aEnd); } MediaSpan AsMediaSpan(Span aBytes) { RefPtr buffer = new MediaByteBuffer(); buffer->AppendElements(aBytes.Elements(), aBytes.Length()); return MediaSpan(buffer); } MediaSpan AsMediaSpan(const Bytes& aBytes) { return AsMediaSpan(AsSpan(aBytes)); } MediaByteRange MakeRange(size_t aStart, size_t aEnd) { return MediaByteRange(int64_t(aStart), int64_t(aEnd)); } UniquePtr CreateParser() { return ContainerParser::CreateForMIMEType( MediaContainerType(MEDIAMIMETYPE("audio/mpeg"))); } // As TrackBuffersManager::RecreateParser(true) does. UniquePtr CreateParserWithInitData( const uint8_t (&aHeader)[4]) { UniquePtr parser = CreateParser(); TimeUnit start, end; EXPECT_EQ(parser->ParseStartAndEndTimestamps(AsMediaSpan(Header(aHeader)), start, end), NS_ERROR_NOT_AVAILABLE); EXPECT_TRUE(parser->HasCompleteInitData()); return parser; } nsresult Parse(ContainerParser& aParser, const Bytes& aBytes) { TimeUnit start, end; return aParser.ParseStartAndEndTimestamps(AsMediaSpan(aBytes), start, end); } } // namespace TEST(MPEGAudioByteStream, FrameHeader) { Maybe frame = ParseFrameHeader(kStereoHeader); ASSERT_TRUE(frame); EXPECT_EQ(frame->mLayer, 3u); EXPECT_EQ(frame->mSampleRate, 44100u); EXPECT_EQ(frame->mChannels, 2u); EXPECT_EQ(frame->mSamplesPerFrame, 1152u); EXPECT_EQ(frame->mLength, kStereoFrameLength); EXPECT_TRUE(frame->mIsMPEG1); const uint8_t padded[] = {0xFF, 0xFB, 0x92, 0x00}; frame = ParseFrameHeader(padded); ASSERT_TRUE(frame); EXPECT_EQ(frame->mLength, kStereoFrameLength + 1); frame = ParseFrameHeader(kMonoHeader); ASSERT_TRUE(frame); EXPECT_EQ(frame->mSampleRate, 48000u); EXPECT_EQ(frame->mChannels, 1u); EXPECT_EQ(frame->mLength, kMonoFrameLength); frame = ParseFrameHeader(kMPEG2Header); ASSERT_TRUE(frame); EXPECT_EQ(frame->mSampleRate, 22050u); EXPECT_EQ(frame->mChannels, 1u); EXPECT_EQ(frame->mSamplesPerFrame, 576u); EXPECT_EQ(frame->mLength, kMPEG2FrameLength); EXPECT_FALSE(frame->mIsMPEG1); EXPECT_FALSE(frame->HasSameConfig(*ParseFrameHeader(kMonoHeader))); EXPECT_TRUE(ParseFrameHeader(kStereoHeader) ->HasSameConfig(*ParseFrameHeader(padded))); frame = ParseFrameHeader(kLayer2Header); ASSERT_TRUE(frame); EXPECT_EQ(frame->mLayer, 2u); EXPECT_EQ(frame->mSampleRate, 44100u); EXPECT_EQ(frame->mChannels, 2u); EXPECT_EQ(frame->mSamplesPerFrame, 1152u); EXPECT_EQ(frame->mLength, kLayer2FrameLength); EXPECT_FALSE(frame->HasSameConfig(*ParseFrameHeader(kStereoHeader))); // MPEG-2 Layer II, 64 kb/s, 22050 Hz. const uint8_t mpeg2Layer2[] = {0xFF, 0xF5, 0x80, 0xC0}; frame = ParseFrameHeader(mpeg2Layer2); ASSERT_TRUE(frame); EXPECT_EQ(frame->mSampleRate, 22050u); EXPECT_EQ(frame->mSamplesPerFrame, 1152u); EXPECT_EQ(frame->mLength, 417u); // MPEG-2.5 Layer II, 160 kb/s, 8000 Hz, padded. const uint8_t mpeg25Layer2[] = {0xFF, 0xE5, 0xEA, 0xC0}; frame = ParseFrameHeader(mpeg25Layer2); ASSERT_TRUE(frame); EXPECT_EQ(frame->mSampleRate, 8000u); EXPECT_EQ(frame->mLength, kMaxFrameLength); // Layer I frames are made of 4 byte slots, so their length is a multiple of // 4. frame = ParseFrameHeader(kLayer1Header); ASSERT_TRUE(frame); EXPECT_EQ(frame->mLayer, 1u); EXPECT_EQ(frame->mSamplesPerFrame, 384u); EXPECT_EQ(frame->mLength, kLayer1FrameLength); const uint8_t paddedLayer1[] = {0xFF, 0xFF, 0x92, 0x00}; frame = ParseFrameHeader(paddedLayer1); ASSERT_TRUE(frame); EXPECT_EQ(frame->mLength, kLayer1FrameLength + 4); // MPEG-2 Layer I, 256 kb/s, 16000 Hz. const uint8_t mpeg2Layer1[] = {0xFF, 0xF7, 0xE8, 0x00}; frame = ParseFrameHeader(mpeg2Layer1); ASSERT_TRUE(frame); EXPECT_EQ(frame->mSampleRate, 16000u); EXPECT_EQ(frame->mLength, 768u); const uint8_t invalid[][4] = { {0xFF, 0xF9, 0x90, 0x00}, // Reserved layer {0xFF, 0xEB, 0x90, 0x00}, // Reserved version {0xFF, 0xFB, 0x00, 0x00}, // Free format bitrate {0xFF, 0xFB, 0xF0, 0x00}, // Bad bitrate {0xFF, 0xFB, 0x9C, 0x00}, // Reserved sample rate {0xFE, 0xFB, 0x90, 0x00}, // No sync }; for (const auto& header : invalid) { EXPECT_FALSE(ParseFrameHeader(header)); } } TEST(MPEGAudioByteStream, Frames) { const Bytes frame = StereoFrame(); Unit unit = ParseUnit(AsSpan(frame), false); EXPECT_EQ(unit.mType, Unit::Type::Frame); EXPECT_EQ(unit.mLength, kStereoFrameLength); EXPECT_EQ(unit.mFrame.mSampleRate, 44100u); EXPECT_EQ(ParseUnit(AsSpan(frame).To(3), false).mType, Unit::Type::NeedMoreData); EXPECT_EQ(ParseUnit(AsSpan(frame).To(100), false).mType, Unit::Type::NeedMoreData); unit = ParseUnit(AsSpan(frame).To(4), false, /* aHeaderOnly = */ true); EXPECT_EQ(unit.mType, Unit::Type::Frame); EXPECT_EQ(unit.mLength, kStereoFrameLength); const Bytes invalid = Frame(kInvalidHeader, 100); EXPECT_EQ(ParseUnit(AsSpan(invalid), false).mType, Unit::Type::Error); for (const char* tag : {"Xing", "Info"}) { const Bytes info = InfoFrame(tag); unit = ParseUnit(AsSpan(info), false); EXPECT_EQ(unit.mType, Unit::Type::InfoFrame); EXPECT_EQ(unit.mLength, kStereoFrameLength); EXPECT_EQ(ParseUnit(AsSpan(info), false, true).mType, Unit::Type::Frame); } // Xing and Info tags are only defined for Layer III. Bytes layer2 = Frame(kLayer2Header, kLayer2FrameLength); memcpy(layer2.data() + 4 + 32, "Info", 4); unit = ParseUnit(AsSpan(layer2), false); EXPECT_EQ(unit.mType, Unit::Type::Frame); EXPECT_EQ(unit.mLength, kLayer2FrameLength); EXPECT_EQ(unit.mFrame.mLayer, 2u); } TEST(MPEGAudioByteStream, Metadata) { Bytes tag = ID3v2(257); Unit unit = ParseUnit(AsSpan(tag).To(10), false); EXPECT_EQ(unit.mType, Unit::Type::Metadata); EXPECT_EQ(unit.mLength, 267u); EXPECT_EQ(ParseUnit(AsSpan(tag).To(9), false).mType, Unit::Type::NeedMoreData); tag[8] = 0x80; EXPECT_EQ(ParseUnit(AsSpan(tag), false).mType, Unit::Type::Error); unit = ParseUnit(AsSpan(ID3v2(257, true)), false); EXPECT_EQ(unit.mType, Unit::Type::Metadata); EXPECT_EQ(unit.mLength, 277u); unit = ParseUnit(AsSpan(Text("TAG.")), false); EXPECT_EQ(unit.mType, Unit::Type::Metadata); EXPECT_EQ(unit.mLength, 128u); // "TAG+" starts an extended tag only when an ID3v1 tag follows it. // Otherwise it's an ID3v1 tag with a title that starts with "+". Bytes extended = Text("TAG+"); extended.resize(227, 'x'); EXPECT_EQ(ParseUnit(AsSpan(extended), false).mType, Unit::Type::NeedMoreData); unit = ParseUnit(AsSpan(Concat({extended, ID3v1()})), false); EXPECT_EQ(unit.mType, Unit::Type::Metadata); EXPECT_EQ(unit.mLength, 227u); Bytes plusTitle = Text("TAG+"); plusTitle.resize(128, 'x'); unit = ParseUnit(AsSpan(Concat({plusTitle, StereoFrame()})), false); EXPECT_EQ(unit.mType, Unit::Type::Metadata); EXPECT_EQ(unit.mLength, 128u); const Bytes icy = Text("ICY 200 OK\r\nicy-name: test\r\n\r\n"); unit = ParseUnit(AsSpan(icy), false); EXPECT_EQ(unit.mType, Unit::Type::Metadata); EXPECT_EQ(unit.mLength, icy.size()); EXPECT_EQ(ParseUnit(AsSpan(icy).To(icy.size() - 1), false).mType, Unit::Type::NeedMoreData); const Bytes longIcy = Concat({Text("ICY 200 OK\r\n"), Garbage(4096)}); EXPECT_EQ(ParseUnit(AsSpan(longIcy), false).mType, Unit::Type::Error); // "ICY" only starts an Icecast header when a space follows it. const Bytes notIcy = Text("ICY200 OK\r\nicy-name: test\r\n\r\n"); EXPECT_EQ(ParseUnit(AsSpan(notIcy), false).mType, Unit::Type::Garbage); } TEST(MPEGAudioByteStream, Garbage) { const Bytes frames = Concat({StereoFrame(), StereoFrame(), StereoFrame()}); const Bytes data = Concat({Garbage(100), frames, Garbage(1)}); Unit unit = ParseUnit(AsSpan(data), false); EXPECT_EQ(unit.mType, Unit::Type::Garbage); EXPECT_EQ(unit.mLength, 100u); unit = ParseUnit(AsSpan(data).From(100), true); EXPECT_EQ(unit.mType, Unit::Type::Frame); // Resynchronizing needs the third frame to end within the data. unit = ParseUnit(AsSpan(frames), true); EXPECT_EQ(unit.mType, Unit::Type::NeedMoreData); // Garbage is skipped up to a frame sync that may start the next frame. unit = ParseUnit(AsSpan(Concat({Garbage(10), frames})), false); EXPECT_EQ(unit.mType, Unit::Type::Garbage); EXPECT_EQ(unit.mLength, 10u); // A frame sync that isn't followed by more frames is garbage. const Bytes falseSync = Concat({Header(kStereoHeader), Garbage(1000)}); unit = ParseUnit(AsSpan(falseSync), true); EXPECT_EQ(unit.mType, Unit::Type::Garbage); EXPECT_EQ(unit.mLength, falseSync.size()); } TEST(MPEGAudioContainerParser, InitSegment) { UniquePtr parser = CreateParser(); EXPECT_TRUE(parser->HasImplicitInitSegment()); EXPECT_EQ(parser->GetRoundingError(), 0); const Bytes data = Concat({StereoFrame(), StereoFrame()}); EXPECT_EQ(parser->SkipIgnorableBytesAtStart(AsMediaSpan(data)), 0u); EXPECT_EQ(parser->IsInitSegmentPresent(AsMediaSpan(AsSpan(data).To(3))), NS_ERROR_NOT_AVAILABLE); EXPECT_EQ(parser->IsMediaSegmentPresent(AsMediaSpan(data)), NS_ERROR_NOT_AVAILABLE); EXPECT_NS_SUCCEEDED(parser->IsInitSegmentPresent(AsMediaSpan(data))); EXPECT_EQ(Parse(*parser, data), NS_ERROR_NOT_AVAILABLE); ASSERT_TRUE(parser->HasCompleteInitData()); ASSERT_EQ(parser->InitData()->Length(), 4u); EXPECT_EQ(memcmp(parser->InitData()->Elements(), kStereoHeader, 4), 0); // The frame header is also part of the media segment. EXPECT_TRUE(parser->InitSegmentRange().IsEmpty()); EXPECT_TRUE(parser->MediaSegmentRange().IsEmpty()); parser = CreateParser(); const Bytes invalid = Frame(kInvalidHeader, 100); MediaResult rv = parser->IsInitSegmentPresent(AsMediaSpan(invalid)); EXPECT_TRUE(NS_FAILED(rv) && rv != NS_ERROR_NOT_AVAILABLE); } TEST(MPEGAudioContainerParser, MediaSegments) { UniquePtr parser = CreateParserWithInitData(kStereoHeader); const Bytes frames = Concat({StereoFrame(), StereoFrame(), StereoFrame()}); const Bytes partial = Concat({frames, StereoFrame()}); // A frame header with the current configuration needs no new track. EXPECT_EQ(parser->IsInitSegmentPresent(AsMediaSpan(frames)), NS_ERROR_NOT_AVAILABLE); EXPECT_NS_SUCCEEDED(parser->IsMediaSegmentPresent(AsMediaSpan(frames))); // The media segment starts with the coded audio that follows the header. EXPECT_EQ(parser->IsMediaSegmentPresent( AsMediaSpan(Slice(frames, 0, kFrameHeaderSize))), NS_ERROR_NOT_AVAILABLE); EXPECT_NS_SUCCEEDED(parser->IsMediaSegmentPresent( AsMediaSpan(Slice(frames, 0, kFrameHeaderSize + 1)))); // The media segment ends after the last complete frame. const size_t split = frames.size() + 100; EXPECT_EQ(Parse(*parser, Slice(partial, 0, split)), NS_ERROR_NOT_AVAILABLE); EXPECT_EQ(parser->MediaSegmentRange(), MakeRange(4, 4 + 3 * kStereoFrameLength)); EXPECT_EQ(Parse(*parser, Slice(partial, split, partial.size())), NS_ERROR_NOT_AVAILABLE); EXPECT_EQ(parser->MediaSegmentRange(), MakeRange(4, 4 + 4 * kStereoFrameLength)); } TEST(MPEGAudioContainerParser, ConfigChange) { UniquePtr parser = CreateParserWithInitData(kStereoHeader); const Bytes mono = Frame(kMonoHeader, kMonoFrameLength); EXPECT_NS_SUCCEEDED(parser->IsInitSegmentPresent(AsMediaSpan(mono))); EXPECT_EQ(parser->IsMediaSegmentPresent(AsMediaSpan(mono)), NS_ERROR_NOT_AVAILABLE); // The media segment ends before the frame that needs a new init segment. EXPECT_EQ(Parse(*parser, Concat({StereoFrame(), StereoFrame(), mono})), NS_ERROR_NOT_AVAILABLE); EXPECT_EQ(parser->MediaSegmentRange(), MakeRange(4, 4 + 2 * kStereoFrameLength)); EXPECT_EQ(Parse(*parser, StereoFrame()), NS_ERROR_NOT_AVAILABLE); EXPECT_EQ(parser->MediaSegmentRange(), MakeRange(4, 4 + 2 * kStereoFrameLength)); // A frame of another layer also needs a new init segment. parser = CreateParserWithInitData(kStereoHeader); const Bytes layer2 = Frame(kLayer2Header, kLayer2FrameLength); EXPECT_NS_SUCCEEDED(parser->IsInitSegmentPresent(AsMediaSpan(layer2))); EXPECT_EQ(parser->IsMediaSegmentPresent(AsMediaSpan(layer2)), NS_ERROR_NOT_AVAILABLE); } TEST(MPEGAudioContainerParser, Metadata) { UniquePtr parser = CreateParser(); const Bytes tag = ID3v2(1000); const Bytes icy = Text("ICY 200 OK\r\n\r\n"); const Bytes frame = StereoFrame(); const Bytes data = Concat({tag, icy, ID3v1(), frame}); // Metadata frames are ignored, including the rest of one that is appended // later. EXPECT_EQ(parser->SkipIgnorableBytesAtStart(AsMediaSpan(Slice(data, 0, 5))), 0u); EXPECT_EQ(parser->SkipIgnorableBytesAtStart(AsMediaSpan(Slice(data, 0, 100))), 100u); EXPECT_EQ(parser->SkipIgnorableBytesAtStart( AsMediaSpan(Slice(data, 100, data.size()))), data.size() - 100 - frame.size()); EXPECT_EQ(parser->SkipIgnorableBytesAtStart(AsMediaSpan(frame)), 0u); EXPECT_NS_SUCCEEDED(parser->IsInitSegmentPresent(AsMediaSpan(frame))); // A media segment ends before a metadata frame. parser = CreateParserWithInitData(kStereoHeader); EXPECT_EQ(Parse(*parser, Concat({frame, frame, ID3v1(), frame})), NS_ERROR_NOT_AVAILABLE); EXPECT_EQ(parser->MediaSegmentRange(), MakeRange(4, 4 + 2 * kStereoFrameLength)); // An ID3v1 tag with a title that starts with "+" doesn't take the start of // the frame that follows it. Bytes plusTitle = Text("TAG+"); plusTitle.resize(128, 'x'); const Bytes rest = Concat({plusTitle, frame}); parser = CreateParserWithInitData(kStereoHeader); EXPECT_EQ(parser->SkipIgnorableBytesAtStart(AsMediaSpan(rest)), 128u); EXPECT_NS_SUCCEEDED(parser->IsMediaSegmentPresent(AsMediaSpan(frame))); } TEST(MPEGAudioContainerParser, Garbage) { UniquePtr parser = CreateParserWithInitData(kStereoHeader); const Bytes frames = Concat({StereoFrame(), StereoFrame(), StereoFrame()}); const Bytes data = Concat({Garbage(50), frames, Garbage(1)}); // Garbage is ignored, and a frame header that follows it only starts a // media segment once two more follow it. const Bytes start = Slice(data, 0, 50 + 2 * kStereoFrameLength); EXPECT_EQ(parser->SkipIgnorableBytesAtStart(AsMediaSpan(start)), 50u); const Bytes rest = Slice(data, 50, data.size()); EXPECT_EQ(parser->IsMediaSegmentPresent( AsMediaSpan(Slice(start, 50, start.size()))), NS_ERROR_NOT_AVAILABLE); EXPECT_EQ(parser->SkipIgnorableBytesAtStart(AsMediaSpan(rest)), 0u); EXPECT_NS_SUCCEEDED(parser->IsMediaSegmentPresent(AsMediaSpan(rest))); // A media segment ends before garbage. EXPECT_EQ(Parse(*parser, rest), NS_ERROR_NOT_AVAILABLE); EXPECT_EQ(parser->MediaSegmentRange(), MakeRange(4, 4 + 3 * kStereoFrameLength)); // A frame header that isn't followed by more frames is garbage. parser = CreateParserWithInitData(kStereoHeader); const Bytes falseSync = Concat({Garbage(10), Header(kStereoHeader), Garbage(1000), rest}); EXPECT_EQ(parser->SkipIgnorableBytesAtStart(AsMediaSpan(falseSync)), 1014u); parser = CreateParserWithInitData(kStereoHeader); const Bytes invalid = Frame(kInvalidHeader, 100); MediaResult rv = Parse(*parser, Concat({StereoFrame(), invalid})); EXPECT_TRUE(NS_FAILED(rv) && rv != NS_ERROR_NOT_AVAILABLE); } TEST(MPEGAudioByteStreamDemuxer, Samples) { RefPtr resource = new SourceBufferResource(); resource->AppendData(AsMediaSpan(Header(kStereoHeader))); RefPtr demuxer = new MPEGAudioByteStreamDemuxer(resource); EXPECT_EQ(WaitForResolve(demuxer->Init()), NS_OK); ASSERT_EQ(demuxer->GetNumberTracks(TrackInfo::kAudioTrack), 1u); EXPECT_EQ(demuxer->GetNumberTracks(TrackInfo::kVideoTrack), 0u); RefPtr track = demuxer->GetTrackDemuxer(TrackInfo::kAudioTrack, 0); ASSERT_TRUE(track); UniquePtr info = track->GetInfo(); ASSERT_TRUE(info->GetAsAudioInfo()); EXPECT_EQ(info->mMimeType, "audio/mpeg"_ns); EXPECT_EQ(info->GetAsAudioInfo()->mRate, 44100u); EXPECT_EQ(info->GetAsAudioInfo()->mChannels, 2u); // The byte stream format doesn't specify a duration. EXPECT_TRUE(info->mDuration.IsZero()); // The generated timestamps don't account for the decoder delay. ASSERT_TRUE( info->GetAsAudioInfo()->mCodecSpecificConfig.is()); EXPECT_EQ(info->GetAsAudioInfo() ->mCodecSpecificConfig.as() .mDecoderDelayFrames, 529u); // TrackBuffersManager evicts the initialization segment once the demuxer // is initialized. resource->EvictAll(); const Bytes data = Concat( {InfoFrame("Info"), StereoFrame(1), StereoFrame(2), StereoFrame(3)}); const size_t split = 2 * kStereoFrameLength + 200; resource->AppendData(AsMediaSpan(AsSpan(data).To(split))); // The Info frame carries no audio. auto samples = WaitFor(track->GetSamples(-1)); ASSERT_TRUE(samples.isOk()); { const auto& list = samples.inspect()->GetSamples(); ASSERT_EQ(list.Length(), 1u); EXPECT_EQ(list[0]->Size(), kStereoFrameLength); EXPECT_EQ(list[0]->Data()[4], 1); EXPECT_EQ(list[0]->mOffset, int64_t(4 + kStereoFrameLength)); EXPECT_EQ(list[0]->mTime, TimeUnit::Zero()); EXPECT_EQ(list[0]->mDuration, TimeUnit(1152, 44100)); EXPECT_TRUE(list[0]->mKeyframe); } auto waiting = WaitFor(track->GetSamples(-1)); ASSERT_TRUE(waiting.isErr()); EXPECT_EQ(waiting.inspectErr().Code(), NS_ERROR_DOM_MEDIA_WAITING_FOR_DATA); EXPECT_EQ(track->GetEvictionOffset(TimeUnit::Zero()), int64_t(4 + 2 * kStereoFrameLength)); resource->AppendData(AsMediaSpan(AsSpan(data).From(split))); auto moreSamples = WaitFor(track->GetSamples(-1)); ASSERT_TRUE(moreSamples.isOk()); { const auto& list = moreSamples.inspect()->GetSamples(); ASSERT_EQ(list.Length(), 2u); for (size_t i = 0; i < list.Length(); ++i) { EXPECT_EQ(list[i]->Data()[4], i + 2); EXPECT_EQ(list[i]->mTime, TimeUnit(1152 * (i + 1), 44100)); } } EXPECT_EQ(track->GetEvictionOffset(TimeUnit::Zero()), int64_t(4 + data.size())); } TEST(MPEGAudioByteStreamDemuxer, Layer1) { RefPtr resource = new SourceBufferResource(); resource->AppendData(AsMediaSpan(Header(kLayer1Header))); RefPtr demuxer = new MPEGAudioByteStreamDemuxer(resource); EXPECT_EQ(WaitForResolve(demuxer->Init()), NS_OK); RefPtr track = demuxer->GetTrackDemuxer(TrackInfo::kAudioTrack, 0); ASSERT_TRUE(track); UniquePtr info = track->GetInfo(); ASSERT_TRUE(info->GetAsAudioInfo()); ASSERT_TRUE( info->GetAsAudioInfo()->mCodecSpecificConfig.is()); EXPECT_EQ(info->GetAsAudioInfo() ->mCodecSpecificConfig.as() .mDecoderDelayFrames, 241u); resource->EvictAll(); const Bytes frame = Frame(kLayer1Header, kLayer1FrameLength); resource->AppendData(AsMediaSpan(Concat({frame, frame}))); auto samples = WaitFor(track->GetSamples(-1)); ASSERT_TRUE(samples.isOk()); const auto& list = samples.inspect()->GetSamples(); ASSERT_EQ(list.Length(), 2u); for (size_t i = 0; i < list.Length(); ++i) { EXPECT_EQ(list[i]->Size(), kLayer1FrameLength); EXPECT_EQ(list[i]->mTime, TimeUnit(384 * i, 44100)); EXPECT_EQ(list[i]->mDuration, TimeUnit(384, 44100)); } } namespace { // As TrackBuffersManager::RecreateParser(true) does, after an initialization // segment. UniquePtr CreateParserWithInitData( const MediaByteBuffer& aInitData) { UniquePtr parser = CreateParser(); Parse(*parser, Bytes(aInitData.begin(), aInitData.end())); return parser; } // Appends aData to MPEGAudioContainerParser in chunks, and demuxes each media // segment that it finds with MPEGAudioByteStreamDemuxer, as // TrackBuffersManager does. The first byte sets the chunk size. Returns false // if the demuxer disagrees with the parser about a media segment, which must // only hold complete frames with the current configuration. bool AppendAndDemux(Span aData) { if (aData.IsEmpty()) { return true; } const size_t chunkSize = 1 + aData[0] * 8; aData = aData.From(1); UniquePtr parser = CreateParser(); RefPtr initData; RefPtr resource; RefPtr track; // The end of the data appended to resource. int64_t appended = 0; Bytes input; // Whether input starts with a media segment, of which the first parsed // bytes have been passed to the parser. bool parsingMediaSegment = false; size_t parsed = 0; for (size_t offset = 0; offset < aData.Length(); offset += chunkSize) { const Span chunk = aData.Subspan(offset, std::min(chunkSize, aData.Length() - offset)); input.insert(input.end(), chunk.begin(), chunk.end()); while (!input.empty()) { if (!parsingMediaSegment) { if (size_t ignored = parser->SkipIgnorableBytesAtStart(AsMediaSpan(input))) { input.erase(input.begin(), input.begin() + ignored); continue; } MediaResult rv = parser->IsInitSegmentPresent(AsMediaSpan(input)); if (NS_SUCCEEDED(rv)) { parser = CreateParser(); if (Parse(*parser, input) != NS_ERROR_NOT_AVAILABLE || !parser->HasCompleteInitData()) { return false; } initData = parser->InitData(); resource = new SourceBufferResource(); resource->AppendData(initData); appended = int64_t(initData->Length()); RefPtr demuxer = new MPEGAudioByteStreamDemuxer(resource); // The demuxer crashes this if it rejects the initialization // segment. WaitForResolve(demuxer->Init()); track = demuxer->GetTrackDemuxer(TrackInfo::kAudioTrack, 0); resource->EvictAll(); parser = CreateParserWithInitData(*initData); continue; } if (rv != NS_ERROR_NOT_AVAILABLE) { // The append is rejected. return true; } rv = parser->IsMediaSegmentPresent(AsMediaSpan(input)); if (rv == NS_ERROR_NOT_AVAILABLE) { break; } if (NS_FAILED(rv)) { return true; } parsingMediaSegment = true; parsed = 0; } if (parsed < input.size()) { if (Parse(*parser, Slice(input, parsed, input.size())) != NS_ERROR_NOT_AVAILABLE) { return true; } parsed = input.size(); } const MediaByteRange range = parser->MediaSegmentRange(); if (range.IsEmpty()) { break; } // The parser's offsets count the initialization data it was created // with. if (range.mStart != int64_t(initData->Length()) || size_t(range.Length()) > input.size()) { return false; } const size_t length = size_t(range.Length()); resource->AppendData(AsMediaSpan(Slice(input, 0, length))); appended += int64_t(length); while (true) { auto samples = WaitFor(track->GetSamples(-1)); if (samples.isErr()) { if (samples.inspectErr().Code() != NS_ERROR_DOM_MEDIA_WAITING_FOR_DATA) { return false; } break; } } const int64_t demuxed = track->GetEvictionOffset(TimeUnit::Zero()); if (demuxed != appended) { return false; } resource->EvictBefore(demuxed); input.erase(input.begin(), input.begin() + length); parsingMediaSegment = false; parser = CreateParserWithInitData(*initData); } } return true; } } // namespace TEST(MPEGAudioByteStream, MutatedStreams) { const Bytes mono = Frame(kMonoHeader, kMonoFrameLength); const Bytes mpeg2 = Frame(kMPEG2Header, kMPEG2FrameLength); const Bytes layer2 = Frame(kLayer2Header, kLayer2FrameLength); const Bytes layer1 = Frame(kLayer1Header, kLayer1FrameLength); const std::vector streams = { Concat({ID3v2(300), InfoFrame("Info"), StereoFrame(1), StereoFrame(2), StereoFrame(3), ID3v1()}), Concat({Text("ICY 200 OK\r\n\r\n"), StereoFrame(), StereoFrame(), Garbage(50), StereoFrame(), StereoFrame(), StereoFrame(), mono, mono, mono, mpeg2, mpeg2, layer2, layer2, layer1, layer1}), }; for (const Bytes& stream : streams) { for (uint8_t chunkSize : {0, 3, 50, 255}) { Bytes input = Concat({{chunkSize}, stream}); EXPECT_TRUE(AppendAndDemux(AsSpan(input))); } } std::mt19937 random(1169485); for (int i = 0; i < 2000; ++i) { Bytes input = streams[random() % streams.size()]; for (uint32_t edits = 1 + random() % 8; edits; --edits) { const size_t at = random() % input.size(); switch (random() % 3) { case 0: input[at] = uint8_t(random()); break; case 1: input.insert(input.begin() + at, uint8_t(random())); break; default: input.erase(input.begin() + at); break; } } input.insert(input.begin(), uint8_t(random())); EXPECT_TRUE(AppendAndDemux(AsSpan(input))) << "mutation " << i; } } #ifdef FUZZING_INTERFACES static int FuzzingRunMediaSourceMPEGAudio(const uint8_t* aData, size_t aSize) { MOZ_RELEASE_ASSERT(AppendAndDemux(Span(aData, aSize))); return 0; } MOZ_FUZZING_INTERFACE_RAW(nullptr, FuzzingRunMediaSourceMPEGAudio, MediaSourceMPEGAudio); #endif