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 "MediaTrackGraph.h"
  11 #include "Tracing.h"
  12 #include "VideoSegment.h"
  13 #include "gfxPlatform.h"
  14 #include "mozilla/Atomics.h"
  15 #include "mozilla/dom/CanvasCaptureMediaStreamBinding.h"
  16 #include "mozilla/gfx/2D.h"
  17 #include "nsContentUtils.h"
  18
  19 using namespace mozilla::layers;
  20 using namespace mozilla::gfx;
  21
  22 namespace mozilla::dom {
  23
  24 OutputStreamDriver::OutputStreamDriver(SourceMediaTrack* aSourceStream,
  25                                        const PrincipalHandle& aPrincipalHandle)
  26     : mSourceStream(aSourceStream), mPrincipalHandle(aPrincipalHandle) {
  27   MOZ_ASSERT(NS_IsMainThread());
  28   MOZ_ASSERT(mSourceStream);
  29 }
  30
  31 OutputStreamDriver::~OutputStreamDriver() {
  32   MOZ_ASSERT(NS_IsMainThread());
  33   EndTrack();
  34 }
  35
  36 void OutputStreamDriver::EndTrack() {
  37   MOZ_ASSERT(NS_IsMainThread());
  38   if (!mSourceStream->IsDestroyed()) {
  39     mSourceStream->Destroy();
  40   }
  41 }
  42
  43 void OutputStreamDriver::SetImage(RefPtr<layers::Image>&& aImage,
  44                                   const TimeStamp& aTime) {
  45   MOZ_ASSERT(NS_IsMainThread());
  46
  47   VideoSegment segment;
  48   const auto size = aImage->GetSize();
  49   segment.AppendFrame(aImage.forget(), size, mPrincipalHandle, false, aTime);
  50   mSourceStream->AppendData(&segment);
  51 }
  52
  53 // ----------------------------------------------------------------------
  54
  55 class TimerDriver : public OutputStreamDriver {
  56  public:
  57   explicit TimerDriver(SourceMediaTrack* aSourceStream, const double& aFPS,
  58                        const PrincipalHandle& aPrincipalHandle)
  59       : OutputStreamDriver(aSourceStream, aPrincipalHandle),
  60         mFrameInterval(aFPS == 0.0 ? TimeDuration::Forever()
  61                                    : TimeDuration::FromSeconds(1.0 / aFPS)) {}
  62
  63   void RequestFrameCapture() override { mExplicitCaptureRequested = true; }
  64
  65   bool FrameCaptureRequested(const TimeStamp& aTime) const override {
  66     if (mLastFrameTime.IsNull()) {
  67       // All CanvasCaptureMediaStreams shall at least get one frame.
  68       return true;
  69     }
  70
  71     if (mExplicitCaptureRequested) {
  72       return true;
  73     }
  74
  75     if ((aTime - mLastFrameTime) >= mFrameInterval) {
  76       return true;
  77     }
  78
  79     return false;
  80   }
  81
  82   void NewFrame(already_AddRefed<Image> aImage,
  83                 const TimeStamp& aTime) override {
  84     nsCString str;
  85     if (profiler_thread_is_being_profiled_for_markers()) {
  86       TimeDuration sinceLast =
  87           aTime - (mLastFrameTime.IsNull() ? aTime : mLastFrameTime);
  88       str.AppendPrintf(
  89           "TimerDriver %staking frame (%sexplicitly requested; after %.2fms; "
  90           "interval cap %.2fms)",
  91           sinceLast >= mFrameInterval ? "" : "NOT ",
  92           mExplicitCaptureRequested ? "" : "NOT ", sinceLast.ToMilliseconds(),
  93           mFrameInterval.ToMilliseconds());
  94     }
  95     AUTO_PROFILER_MARKER_TEXT("Canvas CaptureStream", MEDIA_RT, {}, str);
  96
  97     RefPtr<Image> image = aImage;
  98
  99     if (!FrameCaptureRequested(aTime)) {
 100       return;
 101     }
 102
 103     mLastFrameTime = aTime;
 104     mExplicitCaptureRequested = false;
 105     SetImage(std::move(image), aTime);
 106   }
 107
 108  protected:
 109   virtual ~TimerDriver() = default;
 110
 111  private:
 112   const TimeDuration mFrameInterval;
 113   bool mExplicitCaptureRequested = false;
 114   TimeStamp mLastFrameTime;
 115 };
 116
 117 // ----------------------------------------------------------------------
 118
 119 class AutoDriver : public OutputStreamDriver {
 120  public:
 121   explicit AutoDriver(SourceMediaTrack* aSourceStream,
 122                       const PrincipalHandle& aPrincipalHandle)
 123       : OutputStreamDriver(aSourceStream, aPrincipalHandle) {}
 124
 125   void RequestFrameCapture() override {}
 126
 127   bool FrameCaptureRequested(const TimeStamp& aTime) const override {
 128     return true;
 129   }
 130
 131   void NewFrame(already_AddRefed<Image> aImage,
 132                 const TimeStamp& aTime) override {
 133     AUTO_PROFILER_MARKER_TEXT("Canvas CaptureStream", MEDIA_RT, {},
 134                               "AutoDriver taking frame"_ns);
 135
 136     RefPtr<Image> image = aImage;
 137     SetImage(std::move(image), aTime);
 138   }
 139
 140  protected:
 141   virtual ~AutoDriver() = default;
 142 };
 143
 144 // ----------------------------------------------------------------------
 145
 146 NS_IMPL_CYCLE_COLLECTION_INHERITED(CanvasCaptureMediaStream, DOMMediaStream,
 147                                    mCanvas)
 148
 149 NS_IMPL_ADDREF_INHERITED(CanvasCaptureMediaStream, DOMMediaStream)
 150 NS_IMPL_RELEASE_INHERITED(CanvasCaptureMediaStream, DOMMediaStream)
 151
 152 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(CanvasCaptureMediaStream)
 153 NS_INTERFACE_MAP_END_INHERITING(DOMMediaStream)
 154
 155 CanvasCaptureMediaStream::CanvasCaptureMediaStream(nsPIDOMWindowInner* aWindow,
 156                                                    HTMLCanvasElement* aCanvas)
 157     : DOMMediaStream(aWindow), mCanvas(aCanvas) {}
 158
 159 CanvasCaptureMediaStream::~CanvasCaptureMediaStream() = default;
 160
 161 JSObject* CanvasCaptureMediaStream::WrapObject(
 162     JSContext* aCx, JS::Handle<JSObject*> aGivenProto) {
 163   return dom::CanvasCaptureMediaStream_Binding::Wrap(aCx, this, aGivenProto);
 164 }
 165
 166 void CanvasCaptureMediaStream::RequestFrame() {
 167   if (mOutputStreamDriver) {
 168     mOutputStreamDriver->RequestFrameCapture();
 169   }
 170 }
 171
 172 nsresult CanvasCaptureMediaStream::Init(const dom::Optional<double>& aFPS,
 173                                         nsIPrincipal* aPrincipal) {
 174   MediaTrackGraph* graph = MediaTrackGraph::GetInstance(
 175       MediaTrackGraph::SYSTEM_THREAD_DRIVER, GetOwner(),
 176       MediaTrackGraph::REQUEST_DEFAULT_SAMPLE_RATE,
 177       MediaTrackGraph::DEFAULT_OUTPUT_DEVICE);
 178   SourceMediaTrack* source = graph->CreateSourceTrack(MediaSegment::VIDEO);
 179   PrincipalHandle principalHandle = MakePrincipalHandle(aPrincipal);
 180   if (!aFPS.WasPassed()) {
 181     mOutputStreamDriver = new AutoDriver(source, principalHandle);
 182   } else if (aFPS.Value() < 0) {
 183     return NS_ERROR_ILLEGAL_VALUE;
 184   } else {
 185     // Cap frame rate to 60 FPS for sanity
 186     double fps = std::min(60.0, aFPS.Value());
 187     mOutputStreamDriver = new TimerDriver(source, fps, principalHandle);
 188   }
 189   return NS_OK;
 190 }
 191
 192 FrameCaptureListener* CanvasCaptureMediaStream::FrameCaptureListener() {
 193   return mOutputStreamDriver;
 194 }
 195
 196 void CanvasCaptureMediaStream::StopCapture() {
 197   if (!mOutputStreamDriver) {
 198     return;
 199   }
 200
 201   mOutputStreamDriver->EndTrack();
 202   mOutputStreamDriver = nullptr;
 203 }
 204
 205 SourceMediaTrack* CanvasCaptureMediaStream::GetSourceStream() const {
 206   if (!mOutputStreamDriver) {
 207     return nullptr;
 208   }
 209   return mOutputStreamDriver->mSourceStream;
 210 }
 211
 212 }  // namespace mozilla::dom