Line data    Source code

       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 DecodedStream_h_
       8             : #define DecodedStream_h_
       9             : 
      10             : #include "MediaEventSource.h"
      11             : #include "MediaInfo.h"
      12             : #include "MediaSink.h"
      13             : 
      14             : #include "mozilla/AbstractThread.h"
      15             : #include "mozilla/Maybe.h"
      16             : #include "mozilla/MozPromise.h"
      17             : #include "mozilla/RefPtr.h"
      18             : #include "mozilla/UniquePtr.h"
      19             : 
      20             : namespace mozilla {
      21             : 
      22             : class DecodedStreamData;
      23             : class AudioData;
      24             : class VideoData;
      25             : class MediaStream;
      26             : class OutputStreamManager;
      27             : struct PlaybackInfoInit;
      28             : class ProcessedMediaStream;
      29             : class TimeStamp;
      30             : 
      31             : template <class T> class MediaQueue;
      32             : 
      33             : class DecodedStream : public media::MediaSink {
      34             :   using media::MediaSink::PlaybackParams;
      35             : 
      36             : public:
      37             :   DecodedStream(AbstractThread* aOwnerThread,
      38             :                 AbstractThread* aMainThread,
      39             :                 MediaQueue<AudioData>& aAudioQueue,
      40             :                 MediaQueue<VideoData>& aVideoQueue,
      41             :                 OutputStreamManager* aOutputStreamManager,
      42             :                 const bool& aSameOrigin,
      43             :                 const PrincipalHandle& aPrincipalHandle);
      44             : 
      45             :   // MediaSink functions.
      46             :   const PlaybackParams& GetPlaybackParams() const override;
      47             :   void SetPlaybackParams(const PlaybackParams& aParams) override;
      48             : 
      49             :   RefPtr<GenericPromise> OnEnded(TrackType aType) override;
      50             :   media::TimeUnit GetEndTime(TrackType aType) const override;
      51             :   media::TimeUnit GetPosition(TimeStamp* aTimeStamp = nullptr) const override;
      52           0 :   bool HasUnplayedFrames(TrackType aType) const override
      53             :   {
      54             :     // TODO: implement this.
      55           0 :     return false;
      56             :   }
      57             : 
      58             :   void SetVolume(double aVolume) override;
      59             :   void SetPlaybackRate(double aPlaybackRate) override;
      60             :   void SetPreservesPitch(bool aPreservesPitch) override;
      61             :   void SetPlaying(bool aPlaying) override;
      62             : 
      63             :   void Start(const media::TimeUnit& aStartTime, const MediaInfo& aInfo) override;
      64             :   void Stop() override;
      65             :   bool IsStarted() const override;
      66             :   bool IsPlaying() const override;
      67             : 
      68             :   nsCString GetDebugInfo() override;
      69             : 
      70             : protected:
      71             :   virtual ~DecodedStream();
      72             : 
      73             : private:
      74           0 :   media::TimeUnit FromMicroseconds(int64_t aTime)
      75             :   {
      76           0 :     return media::TimeUnit::FromMicroseconds(aTime);
      77             :   }
      78             :   void DestroyData(UniquePtr<DecodedStreamData> aData);
      79             :   void AdvanceTracks();
      80             :   void SendAudio(double aVolume, bool aIsSameOrigin, const PrincipalHandle& aPrincipalHandle);
      81             :   void SendVideo(bool aIsSameOrigin, const PrincipalHandle& aPrincipalHandle);
      82             :   void SendData();
      83             :   void NotifyOutput(int64_t aTime);
      84             : 
      85           0 :   void AssertOwnerThread() const {
      86           0 :     MOZ_ASSERT(mOwnerThread->IsCurrentThreadIn());
      87           0 :   }
      88             : 
      89             :   void ConnectListener();
      90             :   void DisconnectListener();
      91             : 
      92             :   const RefPtr<AbstractThread> mOwnerThread;
      93             : 
      94             :   const RefPtr<AbstractThread> mAbstractMainThread;
      95             : 
      96             :   /*
      97             :    * Main thread only members.
      98             :    */
      99             :   // Data about MediaStreams that are being fed by the decoder.
     100             :   const RefPtr<OutputStreamManager> mOutputStreamManager;
     101             : 
     102             :   /*
     103             :    * Worker thread only members.
     104             :    */
     105             :   UniquePtr<DecodedStreamData> mData;
     106             :   RefPtr<GenericPromise> mFinishPromise;
     107             : 
     108             :   bool mPlaying;
     109             :   const bool& mSameOrigin; // valid until Shutdown() is called.
     110             :   const PrincipalHandle& mPrincipalHandle; // valid until Shutdown() is called.
     111             : 
     112             :   PlaybackParams mParams;
     113             : 
     114             :   media::NullableTimeUnit mStartTime;
     115             :   media::TimeUnit mLastOutputTime;
     116             :   MediaInfo mInfo;
     117             : 
     118             :   MediaQueue<AudioData>& mAudioQueue;
     119             :   MediaQueue<VideoData>& mVideoQueue;
     120             : 
     121             :   MediaEventListener mAudioPushListener;
     122             :   MediaEventListener mVideoPushListener;
     123             :   MediaEventListener mAudioFinishListener;
     124             :   MediaEventListener mVideoFinishListener;
     125             :   MediaEventListener mOutputListener;
     126             : };
     127             : 
     128             : } // namespace mozilla
     129             : 
     130             : #endif // DecodedStream_h_