dom/media/ReaderProxy.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   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 #ifndef ReaderProxy_h_
   8 #define ReaderProxy_h_
   9
  10 #include "mozilla/AbstractThread.h"
  11 #include "mozilla/RefPtr.h"
  12 #include "nsISupportsImpl.h"
  13
  14 #include "MediaEventSource.h"
  15 #include "MediaFormatReader.h"
  16 #include "MediaPromiseDefs.h"
  17
  18 namespace mozilla {
  19
  20 /**
  21  * A wrapper around MediaFormatReader to offset the timestamps of Audio/Video
  22  * samples by the start time to ensure MDSM can always assume zero start time.
  23  * It also adjusts the seek target passed to Seek() to ensure correct seek time
  24  * is passed to the underlying reader.
  25  */
  26 class ReaderProxy {
  27   using MetadataPromise = MediaFormatReader::MetadataPromise;
  28   using AudioDataPromise = MediaFormatReader::AudioDataPromise;
  29   using VideoDataPromise = MediaFormatReader::VideoDataPromise;
  30   using SeekPromise = MediaFormatReader::SeekPromise;
  31   using WaitForDataPromise = MediaFormatReader::WaitForDataPromise;
  32   using TrackSet = MediaFormatReader::TrackSet;
  33   NS_INLINE_DECL_THREADSAFE_REFCOUNTING(ReaderProxy);
  34
  35  public:
  36   ReaderProxy(AbstractThread* aOwnerThread, MediaFormatReader* aReader);
  37
  38   media::TimeUnit StartTime() const;
  39   RefPtr<MetadataPromise> ReadMetadata();
  40
  41   RefPtr<AudioDataPromise> RequestAudioData();
  42
  43   RefPtr<VideoDataPromise> RequestVideoData(
  44       const media::TimeUnit& aTimeThreshold, bool aRequestNextVideoKeyFrame);
  45
  46   RefPtr<WaitForDataPromise> WaitForData(MediaData::Type aType);
  47
  48   RefPtr<SeekPromise> Seek(const SeekTarget& aTarget);
  49   RefPtr<ShutdownPromise> Shutdown();
  50
  51   void ReleaseResources();
  52   void ResetDecode(TrackSet aTracks);
  53
  54   nsresult Init() { return mReader->Init(); }
  55   bool UseBufferingHeuristics() const {
  56     return mReader->UseBufferingHeuristics();
  57   }
  58
  59   bool VideoIsHardwareAccelerated() const {
  60     return mReader->VideoIsHardwareAccelerated();
  61   }
  62   TimedMetadataEventSource& TimedMetadataEvent() {
  63     return mReader->TimedMetadataEvent();
  64   }
  65   MediaEventSource<void>& OnMediaNotSeekable() {
  66     return mReader->OnMediaNotSeekable();
  67   }
  68   MediaEventProducer<VideoInfo, AudioInfo>& OnTrackInfoUpdatedEvent() {
  69     return mReader->OnTrackInfoUpdatedEvent();
  70   }
  71   size_t SizeOfAudioQueueInFrames() const {
  72     return mReader->SizeOfAudioQueueInFrames();
  73   }
  74   size_t SizeOfVideoQueueInFrames() const {
  75     return mReader->SizeOfVideoQueueInFrames();
  76   }
  77   void ReadUpdatedMetadata(MediaInfo* aInfo) {
  78     mReader->ReadUpdatedMetadata(aInfo);
  79   }
  80   AbstractCanonical<media::TimeIntervals>* CanonicalBuffered() {
  81     return mReader->CanonicalBuffered();
  82   }
  83
  84   RefPtr<SetCDMPromise> SetCDMProxy(CDMProxy* aProxy);
  85
  86   void SetVideoBlankDecode(bool aIsBlankDecode);
  87
  88   void SetCanonicalDuration(
  89       AbstractCanonical<media::NullableTimeUnit>* aCanonical);
  90
  91   void UpdateMediaEngineId(uint64_t aMediaEngineId);
  92
  93  private:
  94   ~ReaderProxy();
  95   RefPtr<MetadataPromise> OnMetadataRead(MetadataHolder&& aMetadata);
  96   RefPtr<MetadataPromise> OnMetadataNotRead(const MediaResult& aError);
  97   void UpdateDuration();
  98   RefPtr<SeekPromise> SeekInternal(const SeekTarget& aTarget);
  99
 100   RefPtr<ReaderProxy::AudioDataPromise> OnAudioDataRequestCompleted(
 101       RefPtr<AudioData> aAudio);
 102   RefPtr<ReaderProxy::AudioDataPromise> OnAudioDataRequestFailed(
 103       const MediaResult& aError);
 104
 105   const RefPtr<AbstractThread> mOwnerThread;
 106   const RefPtr<MediaFormatReader> mReader;
 107
 108   bool mShutdown = false;
 109   Maybe<media::TimeUnit> mStartTime;
 110
 111   // State-watching manager.
 112   WatchManager<ReaderProxy> mWatchManager;
 113
 114   // Duration, mirrored from the state machine task queue.
 115   Mirror<media::NullableTimeUnit> mDuration;
 116 };
 117
 118 }  // namespace mozilla
 119
 120 #endif  // ReaderProxy_h_