tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

ReaderProxy.h (4307B)

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