WaveDemuxer.h - mozsearch

Enable keyboard shortcuts

/* This Source Code Form is subject to the terms of the Mozilla Public

 * Licence, 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/. */

#ifndef WAV_DEMUXER_H_

#define WAV_DEMUXER_H_

#include "MediaDataDemuxer.h"

#include "MediaResource.h"

namespace mozilla {

class BufferReader;

static const uint32_t FRMT_CODE = 0x666d7420;

static const uint32_t DATA_CODE = 0x64617461;

static const uint32_t LIST_CODE = 0x4c495354;

static const uint32_t INFO_CODE = 0x494e464f;

static const uint8_t RIFF[4] = {'R', 'I', 'F', 'F'};

static const uint8_t WAVE[4] = {'W', 'A', 'V', 'E'};

static const uint16_t RIFF_CHUNK_SIZE = 12;

static const uint16_t CHUNK_HEAD_SIZE = 8;

static const uint16_t FMT_CHUNK_MIN_SIZE = 16;

static const uint16_t DATA_CHUNK_SIZE = 768;

class WAVTrackDemuxer;

DDLoggedTypeDeclNameAndBase(WAVDemuxer, MediaDataDemuxer);

DDLoggedTypeNameAndBase(WAVTrackDemuxer, MediaTrackDemuxer);

class WAVDemuxer : public MediaDataDemuxer,

                   public DecoderDoctorLifeLogger<WAVDemuxer> {

 public:

  // MediaDataDemuxer interface.

  explicit WAVDemuxer(MediaResource* aSource);

  RefPtr<InitPromise> Init() override;

  uint32_t GetNumberTracks(TrackInfo::TrackType aType) const override;

  already_AddRefed<MediaTrackDemuxer> GetTrackDemuxer(

      TrackInfo::TrackType aType, uint32_t aTrackNumber) override;

  bool IsSeekable() const override;

 private:

  // Synchronous Initialization.

  bool InitInternal();

  MediaResourceIndex mSource;

  RefPtr<WAVTrackDemuxer> mTrackDemuxer;

};

class RIFFParser {

 private:

  class RIFFHeader;

 public:

  const RIFFHeader& RiffHeader() const;

  Result<uint32_t, nsresult> Parse(BufferReader& aReader);

  void Reset();

 private:

  class RIFFHeader {

   public:

    RIFFHeader();

    void Reset();

    bool IsValid() const;

    bool IsValid(int aPos) const;

    bool ParseNext(uint8_t c);

   private:

    bool Update(uint8_t c);

    uint8_t mRaw[RIFF_CHUNK_SIZE] = {};

    int mPos = 0;

};

  RIFFHeader mRiffHeader;

};

class HeaderParser {

 private:

  class ChunkHeader;

 public:

  const ChunkHeader& GiveHeader() const;

  Result<uint32_t, nsresult> Parse(BufferReader& aReader);

  void Reset();

 private:

  class ChunkHeader {

   public:

    ChunkHeader();

    void Reset();

    bool IsValid() const;

    uint32_t ChunkName() const;

    uint32_t ChunkSize() const;

    bool ParseNext(uint8_t c);

   private:

    void Update(uint8_t c);

    uint8_t mRaw[CHUNK_HEAD_SIZE] = {};

    int mPos = 0;

};

  ChunkHeader mHeader;

};

class FormatChunk {

 public:

  FormatChunk() = default;

  void Init(nsTArray<uint8_t>&& aData);

  uint16_t WaveFormat() const;

  uint16_t Channels() const;

  uint32_t SampleRate() const;

  uint16_t ExtraFormatInfoSize() const;

  uint16_t SampleFormat() const;

  uint16_t AverageBytesPerSec() const;

  uint16_t BlockAlign() const;

  uint16_t ValidBitsPerSamples() const;

  AudioConfig::ChannelLayout::ChannelMap ChannelMap() const;

 private:

  nsTArray<uint8_t> mRaw;

};

class DataParser {

 private:

  class DataChunk;

 public:

  DataParser();

  const DataChunk& CurrentChunk() const;

  void Reset();

 private:

  class DataChunk {

   public:

    void Reset();

   private:

    int mPos = 0;  // To Check Alignment

};

  DataChunk mChunk;

};

class WAVTrackDemuxer : public MediaTrackDemuxer,

                        public DecoderDoctorLifeLogger<WAVTrackDemuxer> {

 public:

  explicit WAVTrackDemuxer(MediaResource* aSource);

  bool Init();

  int64_t StreamLength() const;

  media::TimeUnit Duration() const;

  media::TimeUnit Duration(int64_t aNumDataChunks) const;

  media::TimeUnit DurationFromBytes(uint32_t aNumBytes) const;

  media::TimeUnit SeekPosition() const;

  RefPtr<MediaRawData> DemuxSample();

  // MediaTrackDemuxer interface.

  UniquePtr<TrackInfo> GetInfo() const override;

  RefPtr<SeekPromise> Seek(const media::TimeUnit& aTime) override;

  RefPtr<SamplesPromise> GetSamples(int32_t aNumSamples) override;

  void Reset() override;

  RefPtr<SkipAccessPointPromise> SkipToNextRandomAccessPoint(

      const media::TimeUnit& aTimeThreshold) override;

  int64_t GetResourceOffset() const override;

  media::TimeIntervals GetBuffered() override;

 private:

  ~WAVTrackDemuxer() = default;

  media::TimeUnit FastSeek(const media::TimeUnit& aTime);

  media::TimeUnit ScanUntil(const media::TimeUnit& aTime);

  MediaByteRange FindNextChunk();

  MediaByteRange FindChunkHeader();

  MediaByteRange FindRIFFHeader();

  MediaByteRange FindFmtChunk();

  MediaByteRange FindListChunk();

  MediaByteRange FindInfoTag();

  bool RIFFParserInit();

  bool HeaderParserInit();

  bool FmtChunkParserInit();

  bool ListChunkParserInit(uint32_t aChunkSize);

  bool SkipNextChunk(const MediaByteRange& aRange);

  already_AddRefed<MediaRawData> GetNextChunk(const MediaByteRange& aRange);

  already_AddRefed<MediaRawData> GetFileHeader(const MediaByteRange& aRange);

  void UpdateState(const MediaByteRange& aRange);

  uint64_t OffsetFromChunkIndex(uint32_t aChunkIndex) const;

  uint64_t ChunkIndexFromTime(const media::TimeUnit& aTime) const;

  int64_t Read(uint8_t* aBuffer, int64_t aOffset, int64_t aSize);

  MediaResourceIndex mSource;

  DataParser mParser;

  RIFFParser mRIFFParser;

  HeaderParser mHeaderParser;

  FormatChunk mFmtChunk;

  // ListChunkParser mListChunkParser;

  uint64_t mOffset;

  uint64_t mFirstChunkOffset;

  uint32_t mNumParsedChunks;

  uint32_t mChunkIndex;

  uint32_t mDataLength;

  uint64_t mTotalChunkLen;

  uint32_t mSamplesPerChunk;

  uint32_t mSamplesPerSecond;

  uint32_t mChannels;

  uint32_t mSampleFormat;

  UniquePtr<AudioInfo> mInfo;

};

}  // namespace mozilla

#endif