Add m-esr52 at 52.6.0

1 files changed, 898 insertions, 0 deletions

diff --git a/dom/media/wave/WaveDemuxer.cpp b/dom/media/wave/WaveDemuxer.cpp
new file mode 100644
index 000000000..387a75675
--- /dev/null
+++ b/dom/media/wave/WaveDemuxer.cpp
@@ -0,0 +1,898 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et cindent: */
+/* 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 "WaveDemuxer.h"
+
+#include <inttypes.h>
+#include <algorithm>
+
+#include "mozilla/Assertions.h"
+#include "mozilla/EndianUtils.h"
+#include "nsAutoPtr.h"
+#include "VideoUtils.h"
+#include "TimeUnits.h"
+#include "prenv.h"
+
+using mozilla::media::TimeUnit;
+using mozilla::media::TimeIntervals;
+using mp4_demuxer::ByteReader;
+
+namespace mozilla {
+
+// WAVDemuxer
+
+WAVDemuxer::WAVDemuxer(MediaResource* aSource)
+  : mSource(aSource)
+{
+}
+
+bool
+WAVDemuxer::InitInternal()
+{
+  if (!mTrackDemuxer) {
+    mTrackDemuxer = new WAVTrackDemuxer(mSource);
+  }
+  return mTrackDemuxer->Init();
+}
+
+RefPtr<WAVDemuxer::InitPromise>
+WAVDemuxer::Init()
+{
+  if (!InitInternal()) {
+    return InitPromise::CreateAndReject(
+      NS_ERROR_DOM_MEDIA_METADATA_ERR, __func__);
+  }
+  return InitPromise::CreateAndResolve(NS_OK, __func__);
+}
+
+bool
+WAVDemuxer::HasTrackType(TrackInfo::TrackType aType) const
+{
+  return aType == TrackInfo::kAudioTrack;
+}
+
+uint32_t
+WAVDemuxer::GetNumberTracks(TrackInfo::TrackType aType) const
+{
+  return aType == TrackInfo::kAudioTrack ? 1u : 0u;
+}
+
+already_AddRefed<MediaTrackDemuxer>
+WAVDemuxer::GetTrackDemuxer(TrackInfo::TrackType aType, uint32_t aTrackNumber)
+{
+  if (!mTrackDemuxer) {
+    return nullptr;
+  }
+  return RefPtr<WAVTrackDemuxer>(mTrackDemuxer).forget();
+}
+
+bool
+WAVDemuxer::IsSeekable() const
+{
+  return true;
+}
+
+// WAVTrackDemuxer
+
+WAVTrackDemuxer::WAVTrackDemuxer(MediaResourceIndex aSource)
+  : mSource(aSource)
+  , mOffset(0)
+  , mFirstChunkOffset(0)
+  , mNumParsedChunks(0)
+  , mChunkIndex(0)
+  , mTotalChunkLen(0)
+  , mSamplesPerChunk(0)
+  , mSamplesPerSecond(0)
+  , mChannels(0)
+{
+  Reset();
+}
+
+bool
+WAVTrackDemuxer::Init()
+{
+  Reset();
+  FastSeek(TimeUnit());
+
+  if (!mInfo) {
+    mInfo = MakeUnique<AudioInfo>();
+  }
+
+  if (!RIFFParserInit()) {
+    return false;
+  }
+
+  while (true) {
+    if (!HeaderParserInit()) {
+      return false;
+    }
+
+    uint32_t aChunkName = mHeaderParser.GiveHeader().ChunkName();
+    uint32_t aChunkSize = mHeaderParser.GiveHeader().ChunkSize();
+
+    if (aChunkName == FRMT_CODE) {
+      if (!FmtChunkParserInit()) {
+        return false;
+      }
+    } else if (aChunkName == LIST_CODE) {
+      mHeaderParser.Reset();
+      uint64_t endOfListChunk = static_cast<uint64_t>(mOffset) + aChunkSize;
+      if (endOfListChunk > UINT32_MAX) {
+        return false;
+      }
+      if (!ListChunkParserInit(aChunkSize)) {
+        mOffset = endOfListChunk;
+      }
+    } else if (aChunkName == DATA_CODE) {
+      mDataLength = aChunkSize;
+      if (mFirstChunkOffset != mOffset) {
+        mFirstChunkOffset = mOffset;
+      }
+      break;
+    } else {
+      mOffset += aChunkSize; // Skip other irrelevant chunks.
+    }
+    if (mOffset & 1) {
+      // Wave files are 2-byte aligned so we need to round up
+      mOffset += 1;
+    }
+    mHeaderParser.Reset();
+  }
+
+  if (mDataLength > StreamLength() - mFirstChunkOffset) {
+    mDataLength = StreamLength() - mFirstChunkOffset;
+  }
+
+  mSamplesPerSecond = mFmtParser.FmtChunk().SampleRate();
+  mChannels = mFmtParser.FmtChunk().Channels();
+  mSampleFormat = mFmtParser.FmtChunk().SampleFormat();
+  if (!mSamplesPerSecond || !mChannels || !mSampleFormat) {
+    return false;
+  }
+  mSamplesPerChunk = DATA_CHUNK_SIZE * 8 / mChannels / mSampleFormat;
+
+  mInfo->mRate = mSamplesPerSecond;
+  mInfo->mChannels = mChannels;
+  mInfo->mBitDepth = mSampleFormat;
+  mInfo->mProfile = mFmtParser.FmtChunk().WaveFormat() & 0x00FF;
+  mInfo->mExtendedProfile = (mFmtParser.FmtChunk().WaveFormat() & 0xFF00) >> 8;
+  mInfo->mMimeType = "audio/wave; codecs=";
+  mInfo->mMimeType.AppendInt(mFmtParser.FmtChunk().WaveFormat());
+  mInfo->mDuration = Duration().ToMicroseconds();
+
+  return !!(mInfo->mDuration);
+}
+
+bool
+WAVTrackDemuxer::RIFFParserInit()
+{
+  RefPtr<MediaRawData> riffHeader = GetFileHeader(FindRIFFHeader());
+  if (!riffHeader) {
+    return false;
+  }
+  ByteReader RIFFReader(riffHeader->Data(), 12);
+  mRIFFParser.Parse(RIFFReader);
+  return mRIFFParser.RiffHeader().IsValid(11);
+}
+
+bool
+WAVTrackDemuxer::HeaderParserInit()
+{
+  RefPtr<MediaRawData> header = GetFileHeader(FindChunkHeader());
+  if (!header) {
+    return false;
+  }
+  ByteReader HeaderReader(header->Data(), 8);
+  mHeaderParser.Parse(HeaderReader);
+  return true;
+}
+
+bool
+WAVTrackDemuxer::FmtChunkParserInit()
+{
+  RefPtr<MediaRawData> fmtChunk = GetFileHeader(FindFmtChunk());
+  if (!fmtChunk) {
+    return false;
+  }
+  ByteReader fmtReader(fmtChunk->Data(), mHeaderParser.GiveHeader().ChunkSize());
+  mFmtParser.Parse(fmtReader);
+  return true;
+}
+
+bool
+WAVTrackDemuxer::ListChunkParserInit(uint32_t aChunkSize)
+{
+  uint32_t bytesRead = 0;
+
+  RefPtr<MediaRawData> infoTag = GetFileHeader(FindInfoTag());
+  if (!infoTag) {
+    return false;
+  }
+  ByteReader infoTagReader(infoTag->Data(), 4);
+  if (!infoTagReader.CanRead32() || infoTagReader.ReadU32() != INFO_CODE) {
+    return false;
+  }
+
+  bytesRead += 4;
+
+  while (bytesRead < aChunkSize) {
+    if (!HeaderParserInit()) {
+      return false;
+    }
+
+    bytesRead += 8;
+
+    uint32_t id = mHeaderParser.GiveHeader().ChunkName();
+    uint32_t length = mHeaderParser.GiveHeader().ChunkSize();
+
+    // SubChunk Length Cannot Exceed List Chunk length.
+    if (length > aChunkSize - bytesRead) {
+      length = aChunkSize - bytesRead;
+    }
+
+    MediaByteRange mRange = { mOffset, mOffset + length };
+    RefPtr<MediaRawData> mChunkData = GetFileHeader(mRange);
+    if (!mChunkData) {
+      return false;
+    }
+
+    const char* rawData = reinterpret_cast<const char*>(mChunkData->Data());
+
+    nsCString val(rawData, length);
+    if (length > 0 && val[length - 1] == '\0') {
+      val.SetLength(length - 1);
+    }
+
+    if (length % 2) {
+      mOffset += 1;
+      length += length % 2;
+    }
+
+    bytesRead += length;
+
+    if (!IsUTF8(val)) {
+      mHeaderParser.Reset();
+      continue;
+    }
+
+    switch (id) {
+      case 0x49415254:                // IART
+        mInfo->mTags.AppendElement(MetadataTag(NS_LITERAL_CSTRING("artist"), val));
+        break;
+      case 0x49434d54:                // ICMT
+        mInfo->mTags.AppendElement(MetadataTag(NS_LITERAL_CSTRING("comments"), val));
+        break;
+      case 0x49474e52:                // IGNR
+        mInfo->mTags.AppendElement(MetadataTag(NS_LITERAL_CSTRING("genre"), val));
+        break;
+      case 0x494e414d:                // INAM
+        mInfo->mTags.AppendElement(MetadataTag(NS_LITERAL_CSTRING("name"), val));
+        break;
+    }
+
+    mHeaderParser.Reset();
+  }
+  return true;
+}
+
+media::TimeUnit
+WAVTrackDemuxer::SeekPosition() const
+{
+  TimeUnit pos = Duration(mChunkIndex);
+  if (Duration() > TimeUnit()) {
+    pos = std::min(Duration(), pos);
+  }
+  return pos;
+}
+
+RefPtr<MediaRawData>
+WAVTrackDemuxer::DemuxSample()
+{
+  return GetNextChunk(FindNextChunk());
+}
+
+UniquePtr<TrackInfo>
+WAVTrackDemuxer::GetInfo() const
+{
+  return mInfo->Clone();
+}
+
+RefPtr<WAVTrackDemuxer::SeekPromise>
+WAVTrackDemuxer::Seek(TimeUnit aTime)
+{
+  FastSeek(aTime);
+  const TimeUnit seekTime = ScanUntil(aTime);
+  return SeekPromise::CreateAndResolve(seekTime, __func__);
+}
+
+TimeUnit
+WAVTrackDemuxer::FastSeek(const TimeUnit& aTime)
+{
+  if (aTime.ToMicroseconds()) {
+    mChunkIndex = ChunkIndexFromTime(aTime);
+  } else {
+    mChunkIndex = 0;
+  }
+
+  mOffset = OffsetFromChunkIndex(mChunkIndex);
+
+  if (mOffset > mFirstChunkOffset && StreamLength() > 0) {
+    mOffset = std::min(StreamLength() - 1, mOffset);
+  }
+
+  return Duration(mChunkIndex);
+}
+
+TimeUnit
+WAVTrackDemuxer::ScanUntil(const TimeUnit& aTime)
+{
+  if (!aTime.ToMicroseconds()) {
+    return FastSeek(aTime);
+  }
+
+  if (Duration(mChunkIndex) > aTime) {
+    FastSeek(aTime);
+  }
+
+  return SeekPosition();
+}
+
+RefPtr<WAVTrackDemuxer::SamplesPromise>
+WAVTrackDemuxer::GetSamples(int32_t aNumSamples)
+{
+  MOZ_ASSERT(aNumSamples);
+
+  RefPtr<SamplesHolder> datachunks = new SamplesHolder();
+
+  while (aNumSamples--) {
+    RefPtr<MediaRawData> datachunk = GetNextChunk(FindNextChunk());
+    if (!datachunk) {
+      break;
+    }
+    datachunks->mSamples.AppendElement(datachunk);
+  }
+
+  if (datachunks->mSamples.IsEmpty()) {
+    return SamplesPromise::CreateAndReject(
+        NS_ERROR_DOM_MEDIA_END_OF_STREAM, __func__);
+  }
+
+  return SamplesPromise::CreateAndResolve(datachunks, __func__);
+}
+
+void
+WAVTrackDemuxer::Reset()
+{
+  FastSeek(TimeUnit());
+  mParser.Reset();
+  mHeaderParser.Reset();
+  mRIFFParser.Reset();
+  mFmtParser.Reset();
+}
+
+RefPtr<WAVTrackDemuxer::SkipAccessPointPromise>
+WAVTrackDemuxer::SkipToNextRandomAccessPoint(TimeUnit aTimeThreshold)
+{
+  return SkipAccessPointPromise::CreateAndReject(
+    SkipFailureHolder(NS_ERROR_DOM_MEDIA_DEMUXER_ERR, 0), __func__);
+}
+
+int64_t
+WAVTrackDemuxer::GetResourceOffset() const
+{
+  return mOffset;
+}
+
+TimeIntervals
+WAVTrackDemuxer::GetBuffered()
+{
+  TimeUnit duration = Duration();
+
+  if (duration <= TimeUnit()) {
+    return TimeIntervals();
+  }
+
+  AutoPinned<MediaResource> stream(mSource.GetResource());
+  return GetEstimatedBufferedTimeRanges(stream, duration.ToMicroseconds());
+}
+
+int64_t
+WAVTrackDemuxer::StreamLength() const
+{
+  return mSource.GetLength();
+}
+
+TimeUnit
+WAVTrackDemuxer::Duration() const
+{
+  if (!mDataLength ||!mChannels || !mSampleFormat) {
+    return TimeUnit();
+  }
+
+  int64_t numSamples =
+    static_cast<int64_t>(mDataLength) * 8 / mChannels / mSampleFormat;
+
+  int64_t numUSeconds = USECS_PER_S * numSamples / mSamplesPerSecond;
+
+  if (USECS_PER_S * numSamples % mSamplesPerSecond > mSamplesPerSecond / 2) {
+    numUSeconds++;
+  }
+
+  return TimeUnit::FromMicroseconds(numUSeconds);
+}
+
+TimeUnit
+WAVTrackDemuxer::Duration(int64_t aNumDataChunks) const
+{
+  if (!mSamplesPerSecond || !mSamplesPerChunk) {
+    return TimeUnit();
+  }
+  const double usPerDataChunk = USECS_PER_S *
+                                static_cast<double>(mSamplesPerChunk) /
+                                mSamplesPerSecond;
+  return TimeUnit::FromMicroseconds(aNumDataChunks * usPerDataChunk);
+}
+
+TimeUnit
+WAVTrackDemuxer::DurationFromBytes(uint32_t aNumBytes) const
+{
+  if (!mSamplesPerSecond || !mChannels || !mSampleFormat) {
+    return TimeUnit();
+  }
+
+  int64_t numSamples = aNumBytes * 8 / mChannels / mSampleFormat;
+
+  int64_t numUSeconds = USECS_PER_S * numSamples / mSamplesPerSecond;
+
+  if (USECS_PER_S * numSamples % mSamplesPerSecond > mSamplesPerSecond / 2) {
+    numUSeconds++;
+  }
+
+  return TimeUnit::FromMicroseconds(numUSeconds);
+}
+
+MediaByteRange
+WAVTrackDemuxer::FindNextChunk()
+{
+  if (mOffset + DATA_CHUNK_SIZE < mFirstChunkOffset + mDataLength) {
+    return { mOffset, mOffset + DATA_CHUNK_SIZE };
+  } else {
+    return { mOffset, mFirstChunkOffset + mDataLength };
+  }
+}
+
+MediaByteRange
+WAVTrackDemuxer::FindChunkHeader()
+{
+  return { mOffset, mOffset + CHUNK_HEAD_SIZE };
+}
+
+MediaByteRange
+WAVTrackDemuxer::FindRIFFHeader()
+{
+  return { mOffset, mOffset + RIFF_CHUNK_SIZE };
+}
+
+MediaByteRange
+WAVTrackDemuxer::FindFmtChunk()
+{
+  return { mOffset, mOffset + mHeaderParser.GiveHeader().ChunkSize() };
+}
+
+MediaByteRange
+WAVTrackDemuxer::FindListChunk()
+{
+  return { mOffset, mOffset + mHeaderParser.GiveHeader().ChunkSize() };
+}
+
+MediaByteRange
+WAVTrackDemuxer::FindInfoTag()
+{
+  return { mOffset, mOffset + 4 };
+}
+
+bool
+WAVTrackDemuxer::SkipNextChunk(const MediaByteRange& aRange)
+{
+  UpdateState(aRange);
+  return true;
+}
+
+already_AddRefed<MediaRawData>
+WAVTrackDemuxer::GetNextChunk(const MediaByteRange& aRange)
+{
+  if (!aRange.Length()) {
+    return nullptr;
+  }
+
+  RefPtr<MediaRawData> datachunk = new MediaRawData();
+  datachunk->mOffset = aRange.mStart;
+
+  nsAutoPtr<MediaRawDataWriter> chunkWriter(datachunk->CreateWriter());
+  if (!chunkWriter->SetSize(aRange.Length())) {
+    return nullptr;
+  }
+
+  const uint32_t read = Read(chunkWriter->Data(),
+                             datachunk->mOffset,
+                             datachunk->Size());
+
+  if (read != aRange.Length()) {
+    return nullptr;
+  }
+
+  UpdateState(aRange);
+  ++mNumParsedChunks;
+  ++mChunkIndex;
+
+  datachunk->mTime = Duration(mChunkIndex - 1).ToMicroseconds();
+
+  if (static_cast<uint32_t>(mChunkIndex) * DATA_CHUNK_SIZE < mDataLength) {
+    datachunk->mDuration = Duration(1).ToMicroseconds();
+  } else {
+    uint32_t mBytesRemaining =
+      mDataLength - mChunkIndex * DATA_CHUNK_SIZE;
+    datachunk->mDuration = DurationFromBytes(mBytesRemaining).ToMicroseconds();
+  }
+  datachunk->mTimecode = datachunk->mTime;
+  datachunk->mKeyframe = true;
+
+  MOZ_ASSERT(datachunk->mTime >= 0);
+  MOZ_ASSERT(datachunk->mDuration >= 0);
+
+  return datachunk.forget();
+}
+
+already_AddRefed<MediaRawData>
+WAVTrackDemuxer::GetFileHeader(const MediaByteRange& aRange)
+{
+  if (!aRange.Length()) {
+    return nullptr;
+  }
+
+  RefPtr<MediaRawData> fileHeader = new MediaRawData();
+  fileHeader->mOffset = aRange.mStart;
+
+  nsAutoPtr<MediaRawDataWriter> headerWriter(fileHeader->CreateWriter());
+  if (!headerWriter->SetSize(aRange.Length())) {
+    return nullptr;
+  }
+
+  const uint32_t read = Read(headerWriter->Data(),
+                             fileHeader->mOffset,
+                             fileHeader->Size());
+
+  if (read != aRange.Length()) {
+    return nullptr;
+  }
+
+  UpdateState(aRange);
+
+  return fileHeader.forget();
+}
+
+int64_t
+WAVTrackDemuxer::OffsetFromChunkIndex(int64_t aChunkIndex) const
+{
+  return mFirstChunkOffset + aChunkIndex * DATA_CHUNK_SIZE;
+}
+
+int64_t
+WAVTrackDemuxer::ChunkIndexFromOffset(int64_t aOffset) const
+{
+  int64_t chunkIndex = (aOffset - mFirstChunkOffset) / DATA_CHUNK_SIZE;
+  return std::max<int64_t>(0, chunkIndex);
+}
+
+int64_t
+WAVTrackDemuxer::ChunkIndexFromTime(const media::TimeUnit& aTime) const
+{
+  if (!mSamplesPerChunk || !mSamplesPerSecond) {
+    return 0;
+  }
+  int64_t chunkIndex =
+    (aTime.ToSeconds() * mSamplesPerSecond / mSamplesPerChunk) - 1;
+  return chunkIndex;
+}
+
+void
+WAVTrackDemuxer::UpdateState(const MediaByteRange& aRange)
+{
+  // Full chunk parsed, move offset to its end.
+  mOffset = aRange.mEnd;
+  mTotalChunkLen += aRange.Length();
+}
+
+int32_t
+WAVTrackDemuxer::Read(uint8_t* aBuffer, int64_t aOffset, int32_t aSize)
+{
+  const int64_t streamLen = StreamLength();
+  if (mInfo && streamLen > 0) {
+    aSize = std::min<int64_t>(aSize, streamLen - aOffset);
+  }
+  uint32_t read = 0;
+  const nsresult rv = mSource.ReadAt(aOffset,
+                                     reinterpret_cast<char*>(aBuffer),
+                                     static_cast<uint32_t>(aSize),
+                                     &read);
+  NS_ENSURE_SUCCESS(rv, 0);
+  return static_cast<int32_t>(read);
+}
+
+// RIFFParser
+
+uint32_t
+RIFFParser::Parse(ByteReader& aReader)
+{
+  while (aReader.CanRead8() && !mRiffHeader.ParseNext(aReader.ReadU8())) { }
+
+  if (mRiffHeader.IsValid()) {
+    return RIFF_CHUNK_SIZE;
+  }
+
+  return 0;
+}
+
+void
+RIFFParser::Reset()
+{
+  mRiffHeader.Reset();
+}
+
+const RIFFParser::RIFFHeader&
+RIFFParser::RiffHeader() const
+{
+  return mRiffHeader;
+}
+
+// RIFFParser::RIFFHeader
+
+RIFFParser::RIFFHeader::RIFFHeader()
+{
+  Reset();
+}
+
+void
+RIFFParser::RIFFHeader::Reset()
+{
+  memset(mRaw, 0, sizeof(mRaw));
+  mPos = 0;
+}
+
+bool
+RIFFParser::RIFFHeader::ParseNext(uint8_t c)
+{
+  if (!Update(c)) {
+    Reset();
+    if (!Update(c)) {
+      Reset();
+    }
+  }
+  return IsValid();
+}
+
+bool
+RIFFParser::RIFFHeader::IsValid(int aPos) const
+{
+  if (aPos > -1 && aPos < 4) {
+    return RIFF[aPos] == mRaw[aPos];
+  } else if (aPos > 7 && aPos < 12) {
+    return WAVE[aPos - 8] == mRaw[aPos];
+  } else {
+    return true;
+  }
+}
+
+bool
+RIFFParser::RIFFHeader::IsValid() const
+{
+  return mPos >= RIFF_CHUNK_SIZE;
+}
+
+bool
+RIFFParser::RIFFHeader::Update(uint8_t c)
+{
+  if (mPos < RIFF_CHUNK_SIZE) {
+    mRaw[mPos] = c;
+  }
+  return IsValid(mPos++);
+}
+
+// HeaderParser
+
+uint32_t
+HeaderParser::Parse(ByteReader& aReader)
+{
+  while (aReader.CanRead8() && !mHeader.ParseNext(aReader.ReadU8())) { }
+
+  if (mHeader.IsValid()) {
+    return CHUNK_HEAD_SIZE;
+  }
+
+  return 0;
+}
+
+void
+HeaderParser::Reset()
+{
+  mHeader.Reset();
+}
+
+const HeaderParser::ChunkHeader&
+HeaderParser::GiveHeader() const
+{
+  return mHeader;
+}
+
+// HeaderParser::ChunkHeader
+
+HeaderParser::ChunkHeader::ChunkHeader()
+{
+  Reset();
+}
+
+void
+HeaderParser::ChunkHeader::Reset()
+{
+  memset(mRaw, 0, sizeof(mRaw));
+  mPos = 0;
+}
+
+bool
+HeaderParser::ChunkHeader::ParseNext(uint8_t c)
+{
+  Update(c);
+  return IsValid();
+}
+
+bool
+HeaderParser::ChunkHeader::IsValid() const
+{
+  return mPos >= CHUNK_HEAD_SIZE;
+}
+
+uint32_t
+HeaderParser::ChunkHeader::ChunkName() const
+{
+  return ((mRaw[0] << 24) | (mRaw[1] << 16) |
+          (mRaw[2] << 8 ) | (mRaw[3]));
+}
+
+uint32_t
+HeaderParser::ChunkHeader::ChunkSize() const
+{
+  return ((mRaw[7] << 24) | (mRaw[6] << 16) |
+          (mRaw[5] << 8 ) | (mRaw[4]));
+}
+
+void
+HeaderParser::ChunkHeader::Update(uint8_t c)
+{
+  if (mPos < CHUNK_HEAD_SIZE) {
+    mRaw[mPos++] = c;
+  }
+}
+
+// FormatParser
+
+uint32_t
+FormatParser::Parse(ByteReader& aReader)
+{
+  while (aReader.CanRead8() && !mFmtChunk.ParseNext(aReader.ReadU8())) { }
+
+  if (mFmtChunk.IsValid()) {
+    return FMT_CHUNK_MIN_SIZE;
+  }
+
+  return 0;
+}
+
+void
+FormatParser::Reset()
+{
+  mFmtChunk.Reset();
+}
+
+const FormatParser::FormatChunk&
+FormatParser::FmtChunk() const
+{
+  return mFmtChunk;
+}
+
+// FormatParser::FormatChunk
+
+FormatParser::FormatChunk::FormatChunk()
+{
+  Reset();
+}
+
+void
+FormatParser::FormatChunk::Reset()
+{
+  memset(mRaw, 0, sizeof(mRaw));
+  mPos = 0;
+}
+
+uint16_t
+FormatParser::FormatChunk::WaveFormat() const
+{
+  return (mRaw[1] << 8) | (mRaw[0]);
+}
+
+uint16_t
+FormatParser::FormatChunk::Channels() const
+{
+  return (mRaw[3] << 8) | (mRaw[2]);
+}
+
+uint32_t
+FormatParser::FormatChunk::SampleRate() const
+{
+  return (mRaw[7] << 24) | (mRaw[6] << 16) |
+         (mRaw[5] << 8 ) | (mRaw[4]);
+}
+
+uint16_t
+FormatParser::FormatChunk::FrameSize() const
+{
+  return (mRaw[13] << 8) | (mRaw[12]);
+}
+
+uint16_t
+FormatParser::FormatChunk::SampleFormat() const
+{
+  return (mRaw[15] << 8) | (mRaw[14]);
+}
+
+bool
+FormatParser::FormatChunk::ParseNext(uint8_t c)
+{
+  Update(c);
+  return IsValid();
+}
+
+bool
+FormatParser::FormatChunk::IsValid() const
+{
+  return (FrameSize() == SampleRate() * Channels() / 8) &&
+         (mPos >= FMT_CHUNK_MIN_SIZE);
+}
+
+void
+FormatParser::FormatChunk::Update(uint8_t c)
+{
+  if (mPos < FMT_CHUNK_MIN_SIZE) {
+    mRaw[mPos++] = c;
+  }
+}
+
+// DataParser
+
+DataParser::DataParser()
+{
+}
+
+void
+DataParser::Reset()
+{
+  mChunk.Reset();
+}
+
+const DataParser::DataChunk&
+DataParser::CurrentChunk() const
+{
+  return mChunk;
+}
+
+// DataParser::DataChunk
+
+void
+DataParser::DataChunk::Reset()
+{
+  mPos = 0;
+}
+
+} // namespace mozilla