dom/media/wave/WaveDemuxer.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim:set ts=2 sw=2 sts=2 et cindent: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "WaveDemuxer.h"
   8
   9 #include <inttypes.h>
  10 #include <algorithm>
  11
  12 #include "mozilla/Assertions.h"
  13 #include "mozilla/EndianUtils.h"
  14 #include "mozilla/Utf8.h"
  15 #include "BufferReader.h"
  16 #include "VideoUtils.h"
  17 #include "TimeUnits.h"
  18
  19 using mozilla::media::TimeIntervals;
  20 using mozilla::media::TimeUnit;
  21
  22 namespace mozilla {
  23
  24 // WAVDemuxer
  25
  26 WAVDemuxer::WAVDemuxer(MediaResource* aSource) : mSource(aSource) {
  27   DDLINKCHILD("source", aSource);
  28 }
  29
  30 bool WAVDemuxer::InitInternal() {
  31   if (!mTrackDemuxer) {
  32     mTrackDemuxer = new WAVTrackDemuxer(mSource.GetResource());
  33     DDLINKCHILD("track demuxer", mTrackDemuxer.get());
  34   }
  35   return mTrackDemuxer->Init();
  36 }
  37
  38 RefPtr<WAVDemuxer::InitPromise> WAVDemuxer::Init() {
  39   if (!InitInternal()) {
  40     return InitPromise::CreateAndReject(NS_ERROR_DOM_MEDIA_METADATA_ERR,
  41                                         __func__);
  42   }
  43   return InitPromise::CreateAndResolve(NS_OK, __func__);
  44 }
  45
  46 uint32_t WAVDemuxer::GetNumberTracks(TrackInfo::TrackType aType) const {
  47   return aType == TrackInfo::kAudioTrack ? 1u : 0u;
  48 }
  49
  50 already_AddRefed<MediaTrackDemuxer> WAVDemuxer::GetTrackDemuxer(
  51     TrackInfo::TrackType aType, uint32_t aTrackNumber) {
  52   if (!mTrackDemuxer) {
  53     return nullptr;
  54   }
  55   return RefPtr<WAVTrackDemuxer>(mTrackDemuxer).forget();
  56 }
  57
  58 bool WAVDemuxer::IsSeekable() const { return true; }
  59
  60 // WAVTrackDemuxer
  61
  62 WAVTrackDemuxer::WAVTrackDemuxer(MediaResource* aSource)
  63     : mSource(aSource),
  64       mOffset(0),
  65       mFirstChunkOffset(0),
  66       mNumParsedChunks(0),
  67       mChunkIndex(0),
  68       mDataLength(0),
  69       mTotalChunkLen(0),
  70       mSamplesPerChunk(0),
  71       mSamplesPerSecond(0),
  72       mChannels(0),
  73       mSampleFormat(0) {
  74   DDLINKCHILD("source", aSource);
  75   Reset();
  76 }
  77
  78 bool WAVTrackDemuxer::Init() {
  79   Reset();
  80   FastSeek(TimeUnit());
  81
  82   if (!mInfo) {
  83     mInfo = MakeUnique<AudioInfo>();
  84     mInfo->mCodecSpecificConfig =
  85         AudioCodecSpecificVariant{WaveCodecSpecificData{}};
  86   }
  87
  88   if (!RIFFParserInit()) {
  89     return false;
  90   }
  91
  92   bool hasValidFmt = false;
  93
  94   while (true) {
  95     if (!HeaderParserInit()) {
  96       return false;
  97     }
  98
  99     uint32_t chunkName = mHeaderParser.GiveHeader().ChunkName();
 100     uint32_t chunkSize = mHeaderParser.GiveHeader().ChunkSize();
 101
 102     if (chunkName == FRMT_CODE) {
 103       hasValidFmt = FmtChunkParserInit();
 104     } else if (chunkName == LIST_CODE) {
 105       mHeaderParser.Reset();
 106       uint64_t endOfListChunk = static_cast<uint64_t>(mOffset) + chunkSize;
 107       if (endOfListChunk > UINT32_MAX) {
 108         return false;
 109       }
 110       if (!ListChunkParserInit(chunkSize)) {
 111         mOffset = endOfListChunk;
 112       }
 113     } else if (chunkName == DATA_CODE) {
 114       mDataLength = chunkSize;
 115       if (mFirstChunkOffset != mOffset) {
 116         mFirstChunkOffset = mOffset;
 117       }
 118       break;
 119     } else {
 120       mOffset += chunkSize;  // Skip other irrelevant chunks.
 121     }
 122     if (mOffset & 1) {
 123       // Wave files are 2-byte aligned so we need to round up
 124       mOffset += 1;
 125     }
 126     mHeaderParser.Reset();
 127   }
 128
 129   if (!hasValidFmt) {
 130     return false;
 131   }
 132
 133   int64_t streamLength = StreamLength();
 134   // If the chunk length and the resource length are not equal, use the
 135   // resource length as the "real" data chunk length, if it's longer than the
 136   // chunk size.
 137   if (streamLength != -1) {
 138     uint64_t streamLengthPositive = static_cast<uint64_t>(streamLength);
 139     if (streamLengthPositive > mFirstChunkOffset &&
 140         mDataLength > streamLengthPositive - mFirstChunkOffset) {
 141       mDataLength = streamLengthPositive - mFirstChunkOffset;
 142     }
 143   }
 144
 145   mSamplesPerSecond = mFmtChunk.SampleRate();
 146   mChannels = mFmtChunk.Channels();
 147   if (!mSamplesPerSecond || !mChannels || !mFmtChunk.ValidBitsPerSamples()) {
 148     return false;
 149   }
 150   mSamplesPerChunk =
 151       DATA_CHUNK_SIZE * 8 / mChannels / mFmtChunk.ValidBitsPerSamples();
 152   mSampleFormat = mFmtChunk.ValidBitsPerSamples();
 153
 154   mInfo->mRate = mSamplesPerSecond;
 155   mInfo->mChannels = mChannels;
 156   mInfo->mBitDepth = mFmtChunk.ValidBitsPerSamples();
 157   mInfo->mProfile = AssertedCast<uint8_t>(mFmtChunk.WaveFormat() & 0x00FF);
 158   mInfo->mExtendedProfile =
 159       AssertedCast<uint8_t>(mFmtChunk.WaveFormat() & 0xFF00 >> 8);
 160   mInfo->mMimeType = "audio/wave; codecs=";
 161   mInfo->mMimeType.AppendInt(mFmtChunk.WaveFormat());
 162   mInfo->mDuration = Duration();
 163   mInfo->mChannelMap = mFmtChunk.ChannelMap();
 164
 165   return mInfo->mDuration.IsPositive();
 166 }
 167
 168 bool WAVTrackDemuxer::RIFFParserInit() {
 169   RefPtr<MediaRawData> riffHeader = GetFileHeader(FindRIFFHeader());
 170   if (!riffHeader) {
 171     return false;
 172   }
 173   BufferReader RIFFReader(riffHeader->Data(), 12);
 174   Unused << mRIFFParser.Parse(RIFFReader);
 175   return mRIFFParser.RiffHeader().IsValid(11);
 176 }
 177
 178 bool WAVTrackDemuxer::HeaderParserInit() {
 179   RefPtr<MediaRawData> header = GetFileHeader(FindChunkHeader());
 180   if (!header) {
 181     return false;
 182   }
 183   BufferReader headerReader(header->Data(), 8);
 184   Unused << mHeaderParser.Parse(headerReader);
 185   return true;
 186 }
 187
 188 bool WAVTrackDemuxer::FmtChunkParserInit() {
 189   RefPtr<MediaRawData> fmtChunk = GetFileHeader(FindFmtChunk());
 190   if (!fmtChunk || fmtChunk->Size() < 16) {
 191     return false;
 192   }
 193   nsTArray<uint8_t> fmtChunkData(fmtChunk->Data(), fmtChunk->Size());
 194   mFmtChunk.Init(std::move(fmtChunkData));
 195   return true;
 196 }
 197
 198 bool WAVTrackDemuxer::ListChunkParserInit(uint32_t aChunkSize) {
 199   uint32_t bytesRead = 0;
 200
 201   RefPtr<MediaRawData> infoTag = GetFileHeader(FindInfoTag());
 202   if (!infoTag) {
 203     return false;
 204   }
 205
 206   BufferReader infoTagReader(infoTag->Data(), 4);
 207   auto res = infoTagReader.ReadU32();
 208   if (res.isErr() || (res.isOk() && res.unwrap() != INFO_CODE)) {
 209     return false;
 210   }
 211
 212   bytesRead += 4;
 213
 214   while (bytesRead < aChunkSize) {
 215     if (!HeaderParserInit()) {
 216       return false;
 217     }
 218
 219     bytesRead += 8;
 220
 221     uint32_t id = mHeaderParser.GiveHeader().ChunkName();
 222     uint32_t length = mHeaderParser.GiveHeader().ChunkSize();
 223
 224     // SubChunk Length Cannot Exceed List Chunk length.
 225     if (length > aChunkSize - bytesRead) {
 226       length = aChunkSize - bytesRead;
 227     }
 228
 229     MediaByteRange mRange = {mOffset, mOffset + length};
 230     RefPtr<MediaRawData> mChunkData = GetFileHeader(mRange);
 231     if (!mChunkData) {
 232       return false;
 233     }
 234
 235     const char* rawData = reinterpret_cast<const char*>(mChunkData->Data());
 236
 237     nsCString val(rawData, length);
 238     if (length > 0 && val[length - 1] == '\0') {
 239       val.SetLength(length - 1);
 240     }
 241
 242     if (length % 2) {
 243       mOffset += 1;
 244       length += length % 2;
 245     }
 246
 247     bytesRead += length;
 248
 249     if (!IsUtf8(val)) {
 250       mHeaderParser.Reset();
 251       continue;
 252     }
 253
 254     switch (id) {
 255       case 0x49415254:  // IART
 256         mInfo->mTags.AppendElement(MetadataTag("artist"_ns, val));
 257         break;
 258       case 0x49434d54:  // ICMT
 259         mInfo->mTags.AppendElement(MetadataTag("comments"_ns, val));
 260         break;
 261       case 0x49474e52:  // IGNR
 262         mInfo->mTags.AppendElement(MetadataTag("genre"_ns, val));
 263         break;
 264       case 0x494e414d:  // INAM
 265         mInfo->mTags.AppendElement(MetadataTag("name"_ns, val));
 266         break;
 267     }
 268
 269     mHeaderParser.Reset();
 270   }
 271   return true;
 272 }
 273
 274 media::TimeUnit WAVTrackDemuxer::SeekPosition() const {
 275   TimeUnit pos = Duration(mChunkIndex);
 276   if (Duration() > TimeUnit()) {
 277     pos = std::min(Duration(), pos);
 278   }
 279   return pos;
 280 }
 281
 282 RefPtr<MediaRawData> WAVTrackDemuxer::DemuxSample() {
 283   return GetNextChunk(FindNextChunk());
 284 }
 285
 286 UniquePtr<TrackInfo> WAVTrackDemuxer::GetInfo() const { return mInfo->Clone(); }
 287
 288 RefPtr<WAVTrackDemuxer::SeekPromise> WAVTrackDemuxer::Seek(
 289     const TimeUnit& aTime) {
 290   FastSeek(aTime);
 291   const TimeUnit seekTime = ScanUntil(aTime);
 292   return SeekPromise::CreateAndResolve(seekTime, __func__);
 293 }
 294
 295 TimeUnit WAVTrackDemuxer::FastSeek(const TimeUnit& aTime) {
 296   if (aTime.ToMicroseconds()) {
 297     mChunkIndex = ChunkIndexFromTime(aTime);
 298   } else {
 299     mChunkIndex = 0;
 300   }
 301
 302   mOffset = OffsetFromChunkIndex(mChunkIndex);
 303
 304   if (mOffset > mFirstChunkOffset && StreamLength() > 0) {
 305     mOffset = std::min(static_cast<uint64_t>(StreamLength() - 1), mOffset);
 306   }
 307
 308   return Duration(mChunkIndex);
 309 }
 310
 311 TimeUnit WAVTrackDemuxer::ScanUntil(const TimeUnit& aTime) {
 312   if (!aTime.ToMicroseconds()) {
 313     return FastSeek(aTime);
 314   }
 315
 316   if (Duration(mChunkIndex) > aTime) {
 317     FastSeek(aTime);
 318   }
 319
 320   return SeekPosition();
 321 }
 322
 323 RefPtr<WAVTrackDemuxer::SamplesPromise> WAVTrackDemuxer::GetSamples(
 324     int32_t aNumSamples) {
 325   MOZ_ASSERT(aNumSamples);
 326
 327   RefPtr<SamplesHolder> datachunks = new SamplesHolder();
 328
 329   while (aNumSamples--) {
 330     RefPtr<MediaRawData> datachunk = GetNextChunk(FindNextChunk());
 331     if (!datachunk) {
 332       break;
 333     }
 334     if (!datachunk->HasValidTime()) {
 335       return SamplesPromise::CreateAndReject(NS_ERROR_DOM_MEDIA_DEMUXER_ERR,
 336                                              __func__);
 337     }
 338     datachunks->AppendSample(datachunk);
 339   }
 340
 341   if (datachunks->GetSamples().IsEmpty()) {
 342     return SamplesPromise::CreateAndReject(NS_ERROR_DOM_MEDIA_END_OF_STREAM,
 343                                            __func__);
 344   }
 345
 346   return SamplesPromise::CreateAndResolve(datachunks, __func__);
 347 }
 348
 349 void WAVTrackDemuxer::Reset() {
 350   FastSeek(TimeUnit());
 351   mParser.Reset();
 352   mHeaderParser.Reset();
 353   mRIFFParser.Reset();
 354 }
 355
 356 RefPtr<WAVTrackDemuxer::SkipAccessPointPromise>
 357 WAVTrackDemuxer::SkipToNextRandomAccessPoint(const TimeUnit& aTimeThreshold) {
 358   return SkipAccessPointPromise::CreateAndReject(
 359       SkipFailureHolder(NS_ERROR_DOM_MEDIA_DEMUXER_ERR, 0), __func__);
 360 }
 361
 362 int64_t WAVTrackDemuxer::GetResourceOffset() const {
 363   return AssertedCast<int64_t>(mOffset);
 364 }
 365
 366 TimeIntervals WAVTrackDemuxer::GetBuffered() {
 367   TimeUnit duration = Duration();
 368
 369   if (duration <= TimeUnit()) {
 370     return TimeIntervals();
 371   }
 372
 373   AutoPinned<MediaResource> stream(mSource.GetResource());
 374   return GetEstimatedBufferedTimeRanges(stream, duration.ToMicroseconds());
 375 }
 376
 377 int64_t WAVTrackDemuxer::StreamLength() const { return mSource.GetLength(); }
 378
 379 TimeUnit WAVTrackDemuxer::Duration() const {
 380   if (!mDataLength || !mChannels || !mSampleFormat) {
 381     return TimeUnit();
 382   }
 383
 384   int64_t numSamples =
 385       static_cast<int64_t>(mDataLength) * 8 / mChannels / mSampleFormat;
 386
 387   int64_t numUSeconds = USECS_PER_S * numSamples / mSamplesPerSecond;
 388
 389   if (USECS_PER_S * numSamples % mSamplesPerSecond > mSamplesPerSecond / 2) {
 390     numUSeconds++;
 391   }
 392
 393   return TimeUnit::FromMicroseconds(numUSeconds);
 394 }
 395
 396 TimeUnit WAVTrackDemuxer::Duration(int64_t aNumDataChunks) const {
 397   if (!mSamplesPerSecond || !mSamplesPerChunk) {
 398     return TimeUnit();
 399   }
 400   const int64_t frames = mSamplesPerChunk * aNumDataChunks;
 401   return TimeUnit(frames, mSamplesPerSecond);
 402 }
 403
 404 TimeUnit WAVTrackDemuxer::DurationFromBytes(uint32_t aNumBytes) const {
 405   if (!mSamplesPerSecond || !mChannels || !mSampleFormat) {
 406     return TimeUnit();
 407   }
 408
 409   uint64_t numSamples = aNumBytes * 8 / mChannels / mSampleFormat;
 410
 411   return TimeUnit(numSamples, mSamplesPerSecond);
 412 }
 413
 414 MediaByteRange WAVTrackDemuxer::FindNextChunk() {
 415   if (mOffset + DATA_CHUNK_SIZE < mFirstChunkOffset + mDataLength) {
 416     return {mOffset, mOffset + DATA_CHUNK_SIZE};
 417   }
 418   return {mOffset, mFirstChunkOffset + mDataLength};
 419 }
 420
 421 MediaByteRange WAVTrackDemuxer::FindChunkHeader() {
 422   return {mOffset, mOffset + CHUNK_HEAD_SIZE};
 423 }
 424
 425 MediaByteRange WAVTrackDemuxer::FindRIFFHeader() {
 426   return {mOffset, mOffset + RIFF_CHUNK_SIZE};
 427 }
 428
 429 MediaByteRange WAVTrackDemuxer::FindFmtChunk() {
 430   return {mOffset, mOffset + mHeaderParser.GiveHeader().ChunkSize()};
 431 }
 432
 433 MediaByteRange WAVTrackDemuxer::FindListChunk() {
 434   return {mOffset, mOffset + mHeaderParser.GiveHeader().ChunkSize()};
 435 }
 436
 437 MediaByteRange WAVTrackDemuxer::FindInfoTag() { return {mOffset, mOffset + 4}; }
 438
 439 bool WAVTrackDemuxer::SkipNextChunk(const MediaByteRange& aRange) {
 440   UpdateState(aRange);
 441   return true;
 442 }
 443
 444 already_AddRefed<MediaRawData> WAVTrackDemuxer::GetNextChunk(
 445     const MediaByteRange& aRange) {
 446   if (!aRange.Length()) {
 447     return nullptr;
 448   }
 449
 450   RefPtr<MediaRawData> datachunk = new MediaRawData();
 451   datachunk->mOffset = aRange.mStart;
 452
 453   UniquePtr<MediaRawDataWriter> chunkWriter(datachunk->CreateWriter());
 454   if (!chunkWriter->SetSize(static_cast<uint32_t>(aRange.Length()))) {
 455     return nullptr;
 456   }
 457
 458   const uint32_t read = Read(chunkWriter->Data(), datachunk->mOffset,
 459                              AssertedCast<int64_t>(datachunk->Size()));
 460
 461   if (read != aRange.Length()) {
 462     return nullptr;
 463   }
 464
 465   UpdateState(aRange);
 466   ++mNumParsedChunks;
 467   ++mChunkIndex;
 468
 469   datachunk->mTime = Duration(mChunkIndex - 1);
 470
 471   if (static_cast<uint32_t>(mChunkIndex) * DATA_CHUNK_SIZE < mDataLength) {
 472     datachunk->mDuration = Duration(1);
 473   } else {
 474     uint32_t mBytesRemaining = mDataLength - mChunkIndex * DATA_CHUNK_SIZE;
 475     datachunk->mDuration = DurationFromBytes(mBytesRemaining);
 476   }
 477   datachunk->mTimecode = datachunk->mTime;
 478   datachunk->mKeyframe = true;
 479
 480   MOZ_ASSERT(!datachunk->mTime.IsNegative());
 481   MOZ_ASSERT(!datachunk->mDuration.IsNegative());
 482
 483   return datachunk.forget();
 484 }
 485
 486 already_AddRefed<MediaRawData> WAVTrackDemuxer::GetFileHeader(
 487     const MediaByteRange& aRange) {
 488   if (!aRange.Length()) {
 489     return nullptr;
 490   }
 491
 492   RefPtr<MediaRawData> fileHeader = new MediaRawData();
 493   fileHeader->mOffset = aRange.mStart;
 494
 495   UniquePtr<MediaRawDataWriter> headerWriter(fileHeader->CreateWriter());
 496   if (!headerWriter->SetSize(static_cast<uint32_t>(aRange.Length()))) {
 497     return nullptr;
 498   }
 499
 500   const uint32_t read = Read(headerWriter->Data(), fileHeader->mOffset,
 501                              AssertedCast<int64_t>(fileHeader->Size()));
 502
 503   if (read != aRange.Length()) {
 504     return nullptr;
 505   }
 506
 507   UpdateState(aRange);
 508
 509   return fileHeader.forget();
 510 }
 511
 512 uint64_t WAVTrackDemuxer::OffsetFromChunkIndex(uint32_t aChunkIndex) const {
 513   return mFirstChunkOffset + aChunkIndex * DATA_CHUNK_SIZE;
 514 }
 515
 516 uint64_t WAVTrackDemuxer::ChunkIndexFromTime(
 517     const media::TimeUnit& aTime) const {
 518   if (!mSamplesPerChunk || !mSamplesPerSecond) {
 519     return 0;
 520   }
 521   double chunkDurationS =
 522       mSamplesPerChunk / static_cast<double>(mSamplesPerSecond);
 523   int64_t chunkIndex = std::floor(aTime.ToSeconds() / chunkDurationS);
 524   return chunkIndex;
 525 }
 526
 527 void WAVTrackDemuxer::UpdateState(const MediaByteRange& aRange) {
 528   // Full chunk parsed, move offset to its end.
 529   mOffset = static_cast<uint32_t>(aRange.mEnd);
 530   mTotalChunkLen += static_cast<uint64_t>(aRange.Length());
 531 }
 532
 533 int64_t WAVTrackDemuxer::Read(uint8_t* aBuffer, int64_t aOffset,
 534                               int64_t aSize) {
 535   const int64_t streamLen = StreamLength();
 536   if (mInfo && streamLen > 0) {
 537     int64_t max = streamLen > aOffset ? streamLen - aOffset : 0;
 538     aSize = std::min(aSize, max);
 539   }
 540   uint32_t read = 0;
 541   const nsresult rv = mSource.ReadAt(aOffset, reinterpret_cast<char*>(aBuffer),
 542                                      static_cast<uint32_t>(aSize), &read);
 543   NS_ENSURE_SUCCESS(rv, 0);
 544   return read;
 545 }
 546
 547 // RIFFParser
 548
 549 Result<uint32_t, nsresult> RIFFParser::Parse(BufferReader& aReader) {
 550   for (auto res = aReader.ReadU8();
 551        res.isOk() && !mRiffHeader.ParseNext(res.unwrap());
 552        res = aReader.ReadU8()) {
 553   }
 554
 555   if (mRiffHeader.IsValid()) {
 556     return RIFF_CHUNK_SIZE;
 557   }
 558
 559   return 0;
 560 }
 561
 562 void RIFFParser::Reset() { mRiffHeader.Reset(); }
 563
 564 const RIFFParser::RIFFHeader& RIFFParser::RiffHeader() const {
 565   return mRiffHeader;
 566 }
 567
 568 // RIFFParser::RIFFHeader
 569
 570 RIFFParser::RIFFHeader::RIFFHeader() { Reset(); }
 571
 572 void RIFFParser::RIFFHeader::Reset() {
 573   memset(mRaw, 0, sizeof(mRaw));
 574   mPos = 0;
 575 }
 576
 577 bool RIFFParser::RIFFHeader::ParseNext(uint8_t c) {
 578   if (!Update(c)) {
 579     Reset();
 580     if (!Update(c)) {
 581       Reset();
 582     }
 583   }
 584   return IsValid();
 585 }
 586
 587 bool RIFFParser::RIFFHeader::IsValid(int aPos) const {
 588   if (aPos > -1 && aPos < 4) {
 589     return RIFF[aPos] == mRaw[aPos];
 590   }
 591   if (aPos > 7 && aPos < 12) {
 592     return WAVE[aPos - 8] == mRaw[aPos];
 593   }
 594   return true;
 595 }
 596
 597 bool RIFFParser::RIFFHeader::IsValid() const { return mPos >= RIFF_CHUNK_SIZE; }
 598
 599 bool RIFFParser::RIFFHeader::Update(uint8_t c) {
 600   if (mPos < RIFF_CHUNK_SIZE) {
 601     mRaw[mPos] = c;
 602   }
 603   return IsValid(mPos++);
 604 }
 605
 606 // HeaderParser
 607
 608 Result<uint32_t, nsresult> HeaderParser::Parse(BufferReader& aReader) {
 609   for (auto res = aReader.ReadU8();
 610        res.isOk() && !mHeader.ParseNext(res.unwrap()); res = aReader.ReadU8()) {
 611   }
 612
 613   if (mHeader.IsValid()) {
 614     return CHUNK_HEAD_SIZE;
 615   }
 616
 617   return 0;
 618 }
 619
 620 void HeaderParser::Reset() { mHeader.Reset(); }
 621
 622 const HeaderParser::ChunkHeader& HeaderParser::GiveHeader() const {
 623   return mHeader;
 624 }
 625
 626 // HeaderParser::ChunkHeader
 627
 628 HeaderParser::ChunkHeader::ChunkHeader() { Reset(); }
 629
 630 void HeaderParser::ChunkHeader::Reset() {
 631   memset(mRaw, 0, sizeof(mRaw));
 632   mPos = 0;
 633 }
 634
 635 bool HeaderParser::ChunkHeader::ParseNext(uint8_t c) {
 636   Update(c);
 637   return IsValid();
 638 }
 639
 640 bool HeaderParser::ChunkHeader::IsValid() const {
 641   return mPos >= CHUNK_HEAD_SIZE;
 642 }
 643
 644 uint32_t HeaderParser::ChunkHeader::ChunkName() const {
 645   return static_cast<uint32_t>(
 646       ((mRaw[0] << 24) | (mRaw[1] << 16) | (mRaw[2] << 8) | (mRaw[3])));
 647 }
 648
 649 uint32_t HeaderParser::ChunkHeader::ChunkSize() const {
 650   return static_cast<uint32_t>(
 651       ((mRaw[7] << 24) | (mRaw[6] << 16) | (mRaw[5] << 8) | (mRaw[4])));
 652 }
 653
 654 void HeaderParser::ChunkHeader::Update(uint8_t c) {
 655   if (mPos < CHUNK_HEAD_SIZE) {
 656     mRaw[mPos++] = c;
 657   }
 658 }
 659
 660 // FormatChunk
 661
 662 void FormatChunk::Init(nsTArray<uint8_t>&& aData) { mRaw = std::move(aData); }
 663
 664 uint16_t FormatChunk::WaveFormat() const { return (mRaw[1] << 8) | (mRaw[0]); }
 665
 666 uint16_t FormatChunk::Channels() const { return (mRaw[3] << 8) | (mRaw[2]); }
 667
 668 uint32_t FormatChunk::SampleRate() const {
 669   return static_cast<uint32_t>((mRaw[7] << 24) | (mRaw[6] << 16) |
 670                                (mRaw[5] << 8) | (mRaw[4]));
 671 }
 672
 673 uint16_t FormatChunk::AverageBytesPerSec() const {
 674   return static_cast<uint16_t>((mRaw[11] << 24) | (mRaw[10] << 16) |
 675                                (mRaw[9] << 8) | (mRaw[8]));
 676 }
 677
 678 uint16_t FormatChunk::BlockAlign() const {
 679   return static_cast<uint16_t>(mRaw[13] << 8) | (mRaw[12]);
 680 }
 681
 682 uint16_t FormatChunk::ValidBitsPerSamples() const {
 683   return (mRaw[15] << 8) | (mRaw[14]);
 684 }
 685
 686 uint16_t FormatChunk::ExtraFormatInfoSize() const {
 687   uint16_t value = static_cast<uint16_t>(mRaw[17] << 8) | (mRaw[16]);
 688   if (WaveFormat() != 0xFFFE && value != 0) {
 689     NS_WARNING(
 690         "Found non-zero extra format info length and the wave format"
 691         " isn't WAVEFORMATEXTENSIBLE.");
 692     return 0;
 693   }
 694   if (WaveFormat() == 0xFFFE && value < 22) {
 695     NS_WARNING(
 696         "Wave format is WAVEFORMATEXTENSIBLE and extra data size isn't at"
 697         " least 22 bytes");
 698     return 0;
 699   }
 700   return value;
 701 }
 702
 703 AudioConfig::ChannelLayout::ChannelMap FormatChunk::ChannelMap() const {
 704   // Regular mapping if file doesn't have channel mapping info. Alternatively,
 705   // if the chunk size doesn't have the field for the size of the extension
 706   // data, return a regular mapping.
 707   if (WaveFormat() != 0xFFFE || mRaw.Length() < 18) {
 708     return AudioConfig::ChannelLayout(Channels()).Map();
 709   }
 710   // The length of this chunk is at least 18, check if it's long enough to
 711   // hold the WAVE_FORMAT_EXTENSIBLE struct, that is 22 bytes. If not, fall
 712   // back to a common mapping. The channel mapping is four bytes, starting at
 713   // offset 18.
 714   if (ExtraFormatInfoSize() < 22 || mRaw.Length() < 22) {
 715     return AudioConfig::ChannelLayout(Channels()).Map();
 716   }
 717   // ChannelLayout::ChannelMap is by design bit-per-bit compatible with
 718   // WAVEFORMATEXTENSIBLE's dwChannelMask attribute, we can just cast here.
 719   auto channelMap = static_cast<AudioConfig::ChannelLayout::ChannelMap>(
 720       mRaw[21] | mRaw[20] | mRaw[19] | mRaw[18]);
 721   return channelMap;
 722 }
 723
 724 // DataParser
 725
 726 DataParser::DataParser() = default;
 727
 728 void DataParser::Reset() { mChunk.Reset(); }
 729
 730 const DataParser::DataChunk& DataParser::CurrentChunk() const { return mChunk; }
 731
 732 // DataParser::DataChunk
 733
 734 void DataParser::DataChunk::Reset() { mPos = 0; }
 735
 736 }  // namespace mozilla