dom/media/CanvasCaptureMediaStream.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-*/
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
   4  * You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #include "CanvasCaptureMediaStream.h"
   7
   8 #include "DOMMediaStream.h"
   9 #include "ImageContainer.h"
  10 #include "MediaStreamGraph.h"
  11 #include "MediaStreamListener.h"
  12 #include "gfxPlatform.h"
  13 #include "mozilla/Atomics.h"
  14 #include "mozilla/dom/CanvasCaptureMediaStreamBinding.h"
  15 #include "mozilla/gfx/2D.h"
  16 #include "nsContentUtils.h"
  17
  18 using namespace mozilla::layers;
  19 using namespace mozilla::gfx;
  20
  21 namespace mozilla {
  22 namespace dom {
  23
  24 class OutputStreamDriver::StreamListener : public MediaStreamListener
  25 {
  26 public:
  27   explicit StreamListener(OutputStreamDriver* aDriver,
  28                           TrackID aTrackId,
  29                           PrincipalHandle aPrincipalHandle,
  30                           SourceMediaStream* aSourceStream)
  31     : mEnded(false)
  32     , mSourceStream(aSourceStream)
  33     , mTrackId(aTrackId)
  34     , mPrincipalHandle(aPrincipalHandle)
  35     , mMutex("CanvasCaptureMediaStream OutputStreamDriver::StreamListener")
  36   {
  37     MOZ_ASSERT(mSourceStream);
  38   }
  39
  40   void EndStream() {
  41     mEnded = true;
  42   }
  43
  44   void SetImage(const RefPtr<layers::Image>& aImage, const TimeStamp& aTime)
  45   {
  46     MutexAutoLock lock(mMutex);
  47     mImage = aImage;
  48     mImageTime = aTime;
  49   }
  50
  51   void NotifyPull(MediaStreamGraph* aGraph, StreamTime aDesiredTime) override
  52   {
  53     // Called on the MediaStreamGraph thread.
  54     MOZ_ASSERT(mSourceStream);
  55     StreamTime delta = aDesiredTime - mSourceStream->GetEndOfAppendedData(mTrackId);
  56     if (delta > 0) {
  57       MutexAutoLock lock(mMutex);
  58
  59       RefPtr<Image> image = mImage;
  60       IntSize size = image ? image->GetSize() : IntSize(0, 0);
  61       VideoSegment segment;
  62       segment.AppendFrame(image.forget(), delta, size, mPrincipalHandle, false,
  63                           mImageTime);
  64
  65       mSourceStream->AppendToTrack(mTrackId, &segment);
  66     }
  67
  68     if (mEnded) {
  69       mSourceStream->EndAllTrackAndFinish();
  70     }
  71   }
  72
  73   void NotifyEvent(MediaStreamGraph* aGraph, MediaStreamGraphEvent aEvent) override
  74   {
  75     if (aEvent == MediaStreamGraphEvent::EVENT_REMOVED) {
  76       EndStream();
  77       mSourceStream->EndAllTrackAndFinish();
  78
  79       MutexAutoLock lock(mMutex);
  80       mImage = nullptr;
  81     }
  82   }
  83
  84 protected:
  85   ~StreamListener() { }
  86
  87 private:
  88   Atomic<bool> mEnded;
  89   const RefPtr<SourceMediaStream> mSourceStream;
  90   const TrackID mTrackId;
  91   const PrincipalHandle mPrincipalHandle;
  92
  93   Mutex mMutex;
  94   // The below members are protected by mMutex.
  95   RefPtr<layers::Image> mImage;
  96   TimeStamp mImageTime;
  97 };
  98
  99 OutputStreamDriver::OutputStreamDriver(SourceMediaStream* aSourceStream,
 100                                        const TrackID& aTrackId,
 101                                        const PrincipalHandle& aPrincipalHandle)
 102   : FrameCaptureListener()
 103   , mSourceStream(aSourceStream)
 104   , mStreamListener(new StreamListener(this, aTrackId, aPrincipalHandle,
 105                                        aSourceStream))
 106 {
 107   MOZ_ASSERT(NS_IsMainThread());
 108   MOZ_ASSERT(mSourceStream);
 109   mSourceStream->AddListener(mStreamListener);
 110   mSourceStream->AddTrack(aTrackId, 0, new VideoSegment());
 111   mSourceStream->AdvanceKnownTracksTime(STREAM_TIME_MAX);
 112   mSourceStream->SetPullEnabled(true);
 113
 114   // All CanvasCaptureMediaStreams shall at least get one frame.
 115   mFrameCaptureRequested = true;
 116 }
 117
 118 OutputStreamDriver::~OutputStreamDriver()
 119 {
 120   MOZ_ASSERT(NS_IsMainThread());
 121   if (mStreamListener) {
 122     // MediaStreamGraph will keep the listener alive until it can finish the
 123     // stream on the next NotifyPull().
 124     mStreamListener->EndStream();
 125   }
 126 }
 127
 128 void
 129 OutputStreamDriver::SetImage(const RefPtr<layers::Image>& aImage,
 130                              const TimeStamp& aTime)
 131 {
 132   if (mStreamListener) {
 133     mStreamListener->SetImage(aImage, aTime);
 134   }
 135 }
 136
 137 // ----------------------------------------------------------------------
 138
 139 class TimerDriver : public OutputStreamDriver
 140 {
 141 public:
 142   explicit TimerDriver(SourceMediaStream* aSourceStream,
 143                        const double& aFPS,
 144                        const TrackID& aTrackId,
 145                        const PrincipalHandle& aPrincipalHandle)
 146     : OutputStreamDriver(aSourceStream, aTrackId, aPrincipalHandle)
 147     , mFPS(aFPS)
 148     , mTimer(nullptr)
 149   {
 150     if (mFPS == 0.0) {
 151       return;
 152     }
 153
 154     NS_NewTimerWithFuncCallback(getter_AddRefs(mTimer),
 155                                 &TimerTick,
 156                                 this,
 157                                 int(1000 / mFPS),
 158                                 nsITimer::TYPE_REPEATING_SLACK,
 159                                 "dom::TimerDriver::TimerDriver");
 160   }
 161
 162   static void TimerTick(nsITimer* aTimer, void* aClosure)
 163   {
 164     MOZ_ASSERT(aClosure);
 165     TimerDriver* driver = static_cast<TimerDriver*>(aClosure);
 166
 167     driver->RequestFrameCapture();
 168   }
 169
 170   void NewFrame(already_AddRefed<Image> aImage, const TimeStamp& aTime) override
 171   {
 172     RefPtr<Image> image = aImage;
 173
 174     if (!mFrameCaptureRequested) {
 175       return;
 176     }
 177
 178     mFrameCaptureRequested = false;
 179     SetImage(image.forget(), aTime);
 180   }
 181
 182   void Forget() override
 183   {
 184     if (mTimer) {
 185       mTimer->Cancel();
 186       mTimer = nullptr;
 187     }
 188   }
 189
 190 protected:
 191   virtual ~TimerDriver() {}
 192
 193 private:
 194   const double mFPS;
 195   nsCOMPtr<nsITimer> mTimer;
 196 };
 197
 198 // ----------------------------------------------------------------------
 199
 200 class AutoDriver : public OutputStreamDriver
 201 {
 202 public:
 203   explicit AutoDriver(SourceMediaStream* aSourceStream,
 204                       const TrackID& aTrackId,
 205                       const PrincipalHandle& aPrincipalHandle)
 206     : OutputStreamDriver(aSourceStream, aTrackId, aPrincipalHandle) {}
 207
 208   void NewFrame(already_AddRefed<Image> aImage, const TimeStamp& aTime) override
 209   {
 210     // Don't reset `mFrameCaptureRequested` since AutoDriver shall always have
 211     // `mFrameCaptureRequested` set to true.
 212     // This also means we should accept every frame as NewFrame is called only
 213     // after something changed.
 214
 215     RefPtr<Image> image = aImage;
 216     SetImage(image.forget(), aTime);
 217   }
 218
 219 protected:
 220   virtual ~AutoDriver() {}
 221 };
 222
 223 // ----------------------------------------------------------------------
 224
 225 NS_IMPL_CYCLE_COLLECTION_INHERITED(CanvasCaptureMediaStream, DOMMediaStream,
 226                                    mCanvas)
 227
 228 NS_IMPL_ADDREF_INHERITED(CanvasCaptureMediaStream, DOMMediaStream)
 229 NS_IMPL_RELEASE_INHERITED(CanvasCaptureMediaStream, DOMMediaStream)
 230
 231 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(CanvasCaptureMediaStream)
 232 NS_INTERFACE_MAP_END_INHERITING(DOMMediaStream)
 233
 234 CanvasCaptureMediaStream::CanvasCaptureMediaStream(nsPIDOMWindowInner* aWindow,
 235                                                    HTMLCanvasElement* aCanvas)
 236   : DOMMediaStream(aWindow, nullptr)
 237   , mCanvas(aCanvas)
 238   , mOutputStreamDriver(nullptr)
 239 {
 240 }
 241
 242 CanvasCaptureMediaStream::~CanvasCaptureMediaStream()
 243 {
 244   if (mOutputStreamDriver) {
 245     mOutputStreamDriver->Forget();
 246   }
 247 }
 248
 249 JSObject*
 250 CanvasCaptureMediaStream::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
 251 {
 252   return dom::CanvasCaptureMediaStreamBinding::Wrap(aCx, this, aGivenProto);
 253 }
 254
 255 void
 256 CanvasCaptureMediaStream::RequestFrame()
 257 {
 258   if (mOutputStreamDriver) {
 259     mOutputStreamDriver->RequestFrameCapture();
 260   }
 261 }
 262
 263 nsresult
 264 CanvasCaptureMediaStream::Init(const dom::Optional<double>& aFPS,
 265                                const TrackID& aTrackId,
 266                                nsIPrincipal* aPrincipal)
 267 {
 268   PrincipalHandle principalHandle = MakePrincipalHandle(aPrincipal);
 269
 270   if (!aFPS.WasPassed()) {
 271     mOutputStreamDriver =
 272       new AutoDriver(GetInputStream()->AsSourceStream(), aTrackId, principalHandle);
 273   } else if (aFPS.Value() < 0) {
 274     return NS_ERROR_ILLEGAL_VALUE;
 275   } else {
 276     // Cap frame rate to 60 FPS for sanity
 277     double fps = std::min(60.0, aFPS.Value());
 278     mOutputStreamDriver =
 279       new TimerDriver(GetInputStream()->AsSourceStream(), fps, aTrackId, principalHandle);
 280   }
 281   return NS_OK;
 282 }
 283
 284 already_AddRefed<CanvasCaptureMediaStream>
 285 CanvasCaptureMediaStream::CreateSourceStream(nsPIDOMWindowInner* aWindow,
 286                                              HTMLCanvasElement* aCanvas)
 287 {
 288   RefPtr<CanvasCaptureMediaStream> stream = new CanvasCaptureMediaStream(aWindow, aCanvas);
 289   MediaStreamGraph* graph =
 290     MediaStreamGraph::GetInstance(MediaStreamGraph::SYSTEM_THREAD_DRIVER, aWindow,
 291                                   MediaStreamGraph::REQUEST_DEFAULT_SAMPLE_RATE);
 292   stream->InitSourceStream(graph);
 293   return stream.forget();
 294 }
 295
 296 FrameCaptureListener*
 297 CanvasCaptureMediaStream::FrameCaptureListener()
 298 {
 299   return mOutputStreamDriver;
 300 }
 301
 302 void
 303 CanvasCaptureMediaStream::StopCapture()
 304 {
 305   if (!mOutputStreamDriver) {
 306     return;
 307   }
 308
 309   mOutputStreamDriver->Forget();
 310   mOutputStreamDriver = nullptr;
 311 }
 312
 313 } // namespace dom
 314 } // namespace mozilla
 315