Quelle  OggDemuxer.h   Sprache: C

/* -*- 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/. */
#if !defined(OggDemuxer_h_)
#  define OggDemuxer_h_

#  include "nsTArray.h"
#  include "MediaDataDemuxer.h"
#  include "OggCodecState.h"
#  include "OggCodecStore.h"
#  include "OggRLBoxTypes.h"
#  include "MediaMetadataManager.h"

#  include <memory>

namespace mozilla {

class OggTrackDemuxer;

DDLoggedTypeDeclNameAndBase(OggDemuxer, MediaDataDemuxer);
DDLoggedTypeNameAndBase(OggTrackDemuxer, MediaTrackDemuxer);

class OggDemuxer : public MediaDataDemuxer,
                   public DecoderDoctorLifeLogger<OggDemuxer> {
 public:
  explicit OggDemuxer(MediaResource* aResource);

  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;

  UniquePtr<EncryptionInfo> GetCrypto() override;

  // Set the events to notify when chaining is encountered.
  void SetChainingEvents(TimedMetadataEventProducer* aMetadataEvent,
                         MediaEventProducer<void>* aOnSeekableEvent);

 private:
  // helpers for friend OggTrackDemuxer
  UniquePtr<TrackInfo> GetTrackInfo(TrackInfo::TrackType aType,
                                    size_t aTrackNumber) const;

  struct nsAutoOggSyncState {
    explicit nsAutoOggSyncState(rlbox_sandbox_ogg* aSandbox);
    ~nsAutoOggSyncState();
    rlbox_sandbox_ogg* mSandbox;
    tainted_opaque_ogg<ogg_sync_state*> mState;
  };
  media::TimeIntervals GetBuffered(TrackInfo::TrackType aType);
  void FindStartTime(media::TimeUnit& aOutStartTime);
  void FindStartTime(TrackInfo::TrackType, media::TimeUnit& aOutStartTime);

  nsresult SeekInternal(TrackInfo::TrackType aType,
                        const media::TimeUnit& aTarget);

  // Seeks to the keyframe preceding the target time using available
  // keyframe indexes.
  enum IndexedSeekResult {
    SEEK_OK,          // Success.
    SEEK_INDEX_FAIL,  // Failure due to no index, or invalid index.
    SEEK_FATAL_ERROR  // Error returned by a stream operation.
  };
  IndexedSeekResult SeekToKeyframeUsingIndex(TrackInfo::TrackType aType,
                                             const media::TimeUnit& aTarget);

  // Rolls back a seek-using-index attempt, returning a failure error code.
  IndexedSeekResult RollbackIndexedSeek(TrackInfo::TrackType aType,
                                        int64_t aOffset);

  // Represents a section of contiguous media, with a start and end offset,
  // and the timestamps of the start and end of that range, that is cached.
  // Used to denote the extremities of a range in which we can seek quickly
  // (because it's cached).
  class SeekRange {
   public:
    SeekRange()
        : mOffsetStart(0),
          mOffsetEnd(0),
          mTimeStart(media::TimeUnit::Zero()),
          mTimeEnd(media::TimeUnit::Zero()) {}

    SeekRange(int64_t aOffsetStart, int64_t aOffsetEnd,
              const media::TimeUnit& aTimeStart,
              const media::TimeUnit& aTimeEnd)
        : mOffsetStart(aOffsetStart),
          mOffsetEnd(aOffsetEnd),
          mTimeStart(aTimeStart),
          mTimeEnd(aTimeEnd) {}

    bool IsNull() const {
      return mOffsetStart == 0 && mOffsetEnd == 0 && mTimeStart.IsZero() &&
             mTimeEnd.IsZero();
    }

    int64_t mOffsetStart, mOffsetEnd;  // in bytes.
    media::TimeUnit mTimeStart, mTimeEnd;
  };

  nsresult GetSeekRanges(TrackInfo::TrackType aType,
                         nsTArray<SeekRange>& aRanges);
  SeekRange SelectSeekRange(TrackInfo::TrackType aType,
                            const nsTArray<SeekRange>& ranges,
                            const media::TimeUnit& aTarget,
                            const media::TimeUnit& aStartTime,
                            const media::TimeUnit& aEndTime, bool aExact);

  // Seeks to aTarget usecs in the buffered range aRange using bisection search.
  // aAdjustedTarget is an adjusted version of the target used to account for
  // Opus pre-roll, if necessary. aStartTime must be the presentation time at
  // the start of media, and aEndTime the time at end of media. aRanges must be
  // the time/byte ranges buffered in the media cache as per GetSeekRanges().
  nsresult SeekInBufferedRange(TrackInfo::TrackType aType,
                               const media::TimeUnit& aTarget,
                               media::TimeUnit& aAdjustedTarget,
                               const media::TimeUnit& aStartTime,
                               const media::TimeUnit& aEndTime,
                               const nsTArray<SeekRange>& aRanges,
                               const SeekRange& aRange);

  // Seeks to before aTarget usecs in media using bisection search.
  // This will seek to the packet required to render the
  // media at aTarget. Will use aRanges in order to narrow the bisection
  // search space. aStartTime must be the presentation time at the start of
  // media, and aEndTime the time at end of media. aRanges must be the time/byte
  // ranges buffered in the media cache as per GetSeekRanges().
  nsresult SeekInUnbuffered(TrackInfo::TrackType aType,
                            const media::TimeUnit& aTarget,
                            const media::TimeUnit& aStartTime,
                            const media::TimeUnit& aEndTime,
                            const nsTArray<SeekRange>& aRanges);

  // Performs a seek bisection to move the media stream's read cursor to the
  // last ogg page boundary which has end time before aTarget usecs
  // on the Vorbis bitstreams. Limits its search to data inside aRange;
  // i.e. it will only read inside of the aRange's start and end offsets.
  // aFuzz is the number of usecs of leniency we'll allow; we'll terminate the
  // seek when we land in the range (aTime - aFuzz, aTime) usecs.
  nsresult SeekBisection(TrackInfo::TrackType aType,
                         const media::TimeUnit& aTarget,
                         const SeekRange& aRange, const media::TimeUnit& aFuzz);

  // Chunk size to read when reading Ogg files. Average Ogg page length
  // is about 4300 bytes, so we read the file in chunks larger than that.
  static const int PAGE_STEP = 8192;

  enum PageSyncResult {
    PAGE_SYNC_ERROR = 1,
    PAGE_SYNC_END_OF_RANGE = 2,
    PAGE_SYNC_OK = 3
  };
  static PageSyncResult PageSync(rlbox_sandbox_ogg* aSandbox,
                                 MediaResourceIndex* aResource,
                                 tainted_opaque_ogg<ogg_sync_state*> aState,
                                 bool aCachedDataOnly, int64_t aOffset,
                                 int64_t aEndOffset,
                                 tainted_ogg<ogg_page*> aPage,
                                 int& aSkippedBytes);

  // Demux next Ogg packet
  ogg_packet* GetNextPacket(TrackInfo::TrackType aType);

  nsresult Reset(TrackInfo::TrackType aType);

  static nsString GetKind(const nsCString& aRole);
  static void InitTrack(MessageField* aMsgInfo, TrackInfo* aInfo, bool aEnable);

  // Really private!
  ~OggDemuxer();

  // Read enough of the file to identify track information and header
  // packets necessary for decoding to begin.
  nsresult ReadMetadata();

  // Read a page of data from the Ogg file. Returns true if a page has been
  // read, false if the page read failed or end of file reached.
  bool ReadOggPage(TrackInfo::TrackType aType,
                   tainted_opaque_ogg<ogg_page*> aPage);

  // Send a page off to the individual streams it belongs to.
  // Reconstructed packets, if any are ready, will be available
  // on the individual OggCodecStates.
  nsresult DemuxOggPage(TrackInfo::TrackType aType,
                        tainted_opaque_ogg<ogg_page*> aPage);

  // Read data and demux until a packet is available on the given stream state
  void DemuxUntilPacketAvailable(TrackInfo::TrackType aType,
                                 OggCodecState* aState);

  // Reads and decodes header packets for aState, until either header decode
  // fails, or is complete. Initializes the codec state before returning.
  // Returns true if reading headers and initializtion of the stream
  // succeeds.
  bool ReadHeaders(TrackInfo::TrackType aType, OggCodecState* aState);

  // Reads the next link in the chain.
  bool ReadOggChain(const media::TimeUnit& aLastEndTime);

  // Set this media as being a chain and notifies the state machine that the
  // media is no longer seekable.
  void SetChained();

  // Fills aTracks with the serial numbers of each active stream, for use by
  // various SkeletonState functions.
  void BuildSerialList(nsTArray<uint32_t>& aTracks);

  // Setup target bitstreams for decoding.
  void SetupTarget(OggCodecState** aSavedState, OggCodecState* aNewState);
  void SetupTargetSkeleton();
  void SetupMediaTracksInfo(const nsTArray<uint32_t>& aSerials);
  void FillTags(TrackInfo* aInfo, UniquePtr<MetadataTags>&& aTags);

  // Compute an ogg page's checksum
  tainted_opaque_ogg<ogg_uint32_t> GetPageChecksum(
      tainted_opaque_ogg<ogg_page*> aPage);

  // Get the end time of aEndOffset. This is the playback position we'd reach
  // after playback finished at aEndOffset.
  media::TimeUnit RangeEndTime(TrackInfo::TrackType aType, int64_t aEndOffset);

  // Get the end time of aEndOffset, without reading before aStartOffset.
  // This is the playback position we'd reach after playback finished at
  // aEndOffset. If bool aCachedDataOnly is true, then we'll only read
  // from data which is cached in the media cached, otherwise we'll do
  // regular blocking reads from the media stream. If bool aCachedDataOnly
  // is true, this can safely be called on the main thread, otherwise it
  // must be called on the state machine thread.
  media::TimeUnit RangeEndTime(TrackInfo::TrackType aType, int64_t aStartOffset,
                               int64_t aEndOffset, bool aCachedDataOnly);

  // Get the start time of the range beginning at aOffset. This is the start
  // time of the first aType sample we'd be able to play if we
  // started playback at aOffset.
  media::TimeUnit RangeStartTime(TrackInfo::TrackType aType, int64_t aOffset);

  // All invocations of libogg functionality from the demuxer is sandboxed using
  // wasm library sandboxes on supported platforms. These functions that create
  // and destroy the sandbox instance.
  static rlbox_sandbox_ogg* CreateSandbox();
  struct SandboxDestroy {
    void operator()(rlbox_sandbox_ogg* sandbox);
  };

  // The sandbox instance used to sandbox libogg functionality in the demuxer.
  // This must be declared before other members so that constructors/destructors
  // run in the right order.
  std::unique_ptr<rlbox_sandbox_ogg, SandboxDestroy> mSandbox;

  MediaInfo mInfo;
  nsTArray<RefPtr<OggTrackDemuxer>> mDemuxers;

  // Map of codec-specific bitstream states.
  OggCodecStore mCodecStore;

  // Decode state of the Vorbis bitstream we're decoding, if we have audio.
  OggCodecState* mVorbisState;

  // Decode state of the Opus bitstream we're decoding, if we have one.
  OggCodecState* mOpusState;

  // Get the bitstream decode state for the given track type
  // Decode state of the Flac bitstream we're decoding, if we have one.
  OggCodecState* mFlacState;

  OggCodecState* GetTrackCodecState(TrackInfo::TrackType aType) const;
  TrackInfo::TrackType GetCodecStateType(OggCodecState* aState) const;

  // Represents the user pref media.opus.enabled at the time our
  // contructor was called. We can't check it dynamically because
  // we're not on the main thread;
  bool mOpusEnabled;

  // Decode state of the Skeleton bitstream.
  SkeletonState* mSkeletonState;

  // Ogg decoding state.
  struct OggStateContext {
    explicit OggStateContext(MediaResource* aResource,
                             rlbox_sandbox_ogg* aSandbox)
        : mOggState(aSandbox), mResource(aResource), mNeedKeyframe(true) {}
    nsAutoOggSyncState mOggState;
    MediaResourceIndex mResource;
    Maybe<media::TimeUnit> mStartTime;
    bool mNeedKeyframe;
  };

  OggStateContext& OggState(TrackInfo::TrackType aType);
  tainted_opaque_ogg<ogg_sync_state*> OggSyncState(TrackInfo::TrackType aType);
  MediaResourceIndex* Resource(TrackInfo::TrackType aType);
  MediaResourceIndex* CommonResource();
  OggStateContext mAudioOggState;

  Maybe<media::TimeUnit> mStartTime;

  // Booleans to indicate if we have audio and/or video data
  bool HasVideo() const;
  bool HasAudio() const;
  bool HasSkeleton() const {
    return mSkeletonState != nullptr && mSkeletonState->mActive;
  }
  bool HaveStartTime() const;
  bool HaveStartTime(TrackInfo::TrackType aType);
  media::TimeUnit StartTime() const;
  media::TimeUnit StartTime(TrackInfo::TrackType aType);

  // True if we are decoding a chained ogg.
  bool mIsChained;

  // Total audio duration played so far.
  media::TimeUnit mDecodedAudioDuration;

  // Events manager
  TimedMetadataEventProducer* mTimedMetadataEvent;
  MediaEventProducer<void>* mOnSeekableEvent;

  // This will be populated only if a content change occurs, otherwise it
  // will be left as null so the original metadata is used.
  // It is updated once a chained ogg is encountered.
  // As Ogg chaining is only supported for audio, we only need an audio track
  // info.
  RefPtr<TrackInfoSharedPtr> mSharedAudioTrackInfo;

  friend class OggTrackDemuxer;
};

class OggTrackDemuxer : public MediaTrackDemuxer,
                        public DecoderDoctorLifeLogger<OggTrackDemuxer> {
 public:
  OggTrackDemuxer(OggDemuxer* aParent, TrackInfo::TrackType aType,
                  uint32_t aTrackNumber);

  UniquePtr<TrackInfo> GetInfo() const override;

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

  RefPtr<SamplesPromise> GetSamples(int32_t aNumSamples = 1) override;

  void Reset() override;

  RefPtr<SkipAccessPointPromise> SkipToNextRandomAccessPoint(
      const media::TimeUnit& aTimeThreshold) override;

  media::TimeIntervals GetBuffered() override;

  void BreakCycles() override;

 private:
  ~OggTrackDemuxer();
  void SetNextKeyFrameTime();
  RefPtr<MediaRawData> NextSample();
  RefPtr<OggDemuxer> mParent;
  TrackInfo::TrackType mType;
  UniquePtr<TrackInfo> mInfo;

  // Queued sample extracted by the demuxer, but not yet returned.
  RefPtr<MediaRawData> mQueuedSample;
};
}  // namespace mozilla

#endif