content/browser/media/capture/desktop_capture_device.cc

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/browser/media/capture/desktop_capture_device.h"
   6
   7 #include "base/bind.h"
   8 #include "base/location.h"
   9 #include "base/logging.h"
  10 #include "base/sequenced_task_runner.h"
  11 #include "base/strings/string_number_conversions.h"
  12 #include "base/synchronization/lock.h"
  13 #include "base/threading/sequenced_worker_pool.h"
  14 #include "content/public/browser/browser_thread.h"
  15 #include "content/public/browser/desktop_media_id.h"
  16 #include "media/base/video_util.h"
  17 #include "third_party/libyuv/include/libyuv/scale_argb.h"
  18 #include "third_party/webrtc/modules/desktop_capture/desktop_and_cursor_composer.h"
  19 #include "third_party/webrtc/modules/desktop_capture/desktop_capture_options.h"
  20 #include "third_party/webrtc/modules/desktop_capture/desktop_capturer.h"
  21 #include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
  22 #include "third_party/webrtc/modules/desktop_capture/mouse_cursor_monitor.h"
  23 #include "third_party/webrtc/modules/desktop_capture/screen_capturer.h"
  24 #include "third_party/webrtc/modules/desktop_capture/window_capturer.h"
  25
  26 namespace content {
  27
  28 namespace {
  29
  30 // Maximum CPU time percentage of a single core that can be consumed for desktop
  31 // capturing. This means that on systems where screen scraping is slow we may
  32 // need to capture at frame rate lower than requested. This is necessary to keep
  33 // UI responsive.
  34 const int kMaximumCpuConsumptionPercentage = 50;
  35
  36 webrtc::DesktopRect ComputeLetterboxRect(
  37     const webrtc::DesktopSize& max_size,
  38     const webrtc::DesktopSize& source_size) {
  39   gfx::Rect result = media::ComputeLetterboxRegion(
  40       gfx::Rect(0, 0, max_size.width(), max_size.height()),
  41       gfx::Size(source_size.width(), source_size.height()));
  42   return webrtc::DesktopRect::MakeLTRB(
  43       result.x(), result.y(), result.right(), result.bottom());
  44 }
  45
  46 }  // namespace
  47
  48 class DesktopCaptureDevice::Core
  49     : public base::RefCountedThreadSafe<Core>,
  50       public webrtc::DesktopCapturer::Callback {
  51  public:
  52   Core(scoped_refptr<base::SequencedTaskRunner> task_runner,
  53        scoped_ptr<webrtc::DesktopCapturer> capturer);
  54
  55   // Implementation of VideoCaptureDevice methods.
  56   void AllocateAndStart(const media::VideoCaptureParams& params,
  57                         scoped_ptr<Client> client);
  58   void StopAndDeAllocate();
  59
  60   void SetNotificationWindowId(gfx::NativeViewId window_id);
  61
  62  private:
  63   friend class base::RefCountedThreadSafe<Core>;
  64   virtual ~Core();
  65
  66   // webrtc::DesktopCapturer::Callback interface
  67   virtual webrtc::SharedMemory* CreateSharedMemory(size_t size) OVERRIDE;
  68   virtual void OnCaptureCompleted(webrtc::DesktopFrame* frame) OVERRIDE;
  69
  70   // Helper methods that run on the |task_runner_|. Posted from the
  71   // corresponding public methods.
  72   void DoAllocateAndStart(const media::VideoCaptureParams& params,
  73                           scoped_ptr<Client> client);
  74   void DoStopAndDeAllocate();
  75
  76   // Chooses new output properties based on the supplied source size and the
  77   // properties requested to Allocate(), and dispatches OnFrameInfo[Changed]
  78   // notifications.
  79   void RefreshCaptureFormat(const webrtc::DesktopSize& frame_size);
  80
  81   // Method that is scheduled on |task_runner_| to be called on regular interval
  82   // to capture a frame.
  83   void OnCaptureTimer();
  84
  85   // Captures a frame and schedules timer for the next one.
  86   void CaptureFrameAndScheduleNext();
  87
  88   // Captures a single frame.
  89   void DoCapture();
  90
  91   void DoSetNotificationWindowId(gfx::NativeViewId window_id);
  92
  93   // Task runner used for capturing operations.
  94   scoped_refptr<base::SequencedTaskRunner> task_runner_;
  95
  96   // The underlying DesktopCapturer instance used to capture frames.
  97   scoped_ptr<webrtc::DesktopCapturer> desktop_capturer_;
  98
  99   // The device client which proxies device events to the controller. Accessed
 100   // on the task_runner_ thread.
 101   scoped_ptr<Client> client_;
 102
 103   // Requested video capture format (width, height, frame rate, etc).
 104   media::VideoCaptureParams requested_params_;
 105
 106   // Actual video capture format being generated.
 107   media::VideoCaptureFormat capture_format_;
 108
 109   // Size of frame most recently captured from the source.
 110   webrtc::DesktopSize previous_frame_size_;
 111
 112   // DesktopFrame into which captured frames are down-scaled and/or letterboxed,
 113   // depending upon the caller's requested capture capabilities. If frames can
 114   // be returned to the caller directly then this is NULL.
 115   scoped_ptr<webrtc::DesktopFrame> output_frame_;
 116
 117   // Sub-rectangle of |output_frame_| into which the source will be scaled
 118   // and/or letterboxed.
 119   webrtc::DesktopRect output_rect_;
 120
 121   // True when we have delayed OnCaptureTimer() task posted on
 122   // |task_runner_|.
 123   bool capture_task_posted_;
 124
 125   // True when waiting for |desktop_capturer_| to capture current frame.
 126   bool capture_in_progress_;
 127
 128   DISALLOW_COPY_AND_ASSIGN(Core);
 129 };
 130
 131 DesktopCaptureDevice::Core::Core(
 132     scoped_refptr<base::SequencedTaskRunner> task_runner,
 133     scoped_ptr<webrtc::DesktopCapturer> capturer)
 134     : task_runner_(task_runner),
 135       desktop_capturer_(capturer.Pass()),
 136       capture_task_posted_(false),
 137       capture_in_progress_(false) {}
 138
 139 DesktopCaptureDevice::Core::~Core() {
 140 }
 141
 142 void DesktopCaptureDevice::Core::AllocateAndStart(
 143     const media::VideoCaptureParams& params,
 144     scoped_ptr<Client> client) {
 145   DCHECK_GT(params.requested_format.frame_size.GetArea(), 0);
 146   DCHECK_GT(params.requested_format.frame_rate, 0);
 147
 148   task_runner_->PostTask(
 149       FROM_HERE,
 150       base::Bind(
 151           &Core::DoAllocateAndStart, this, params, base::Passed(&client)));
 152 }
 153
 154 void DesktopCaptureDevice::Core::StopAndDeAllocate() {
 155   task_runner_->PostTask(FROM_HERE,
 156                          base::Bind(&Core::DoStopAndDeAllocate, this));
 157 }
 158
 159 void DesktopCaptureDevice::Core::SetNotificationWindowId(
 160     gfx::NativeViewId window_id) {
 161   task_runner_->PostTask(
 162       FROM_HERE, base::Bind(&Core::DoSetNotificationWindowId, this, window_id));
 163 }
 164
 165 webrtc::SharedMemory*
 166 DesktopCaptureDevice::Core::CreateSharedMemory(size_t size) {
 167   return NULL;
 168 }
 169
 170 void DesktopCaptureDevice::Core::OnCaptureCompleted(
 171     webrtc::DesktopFrame* frame) {
 172   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 173   DCHECK(capture_in_progress_);
 174
 175   capture_in_progress_ = false;
 176
 177   if (!frame) {
 178     std::string log("Failed to capture a frame.");
 179     LOG(ERROR) << log;
 180     client_->OnError(log);
 181     return;
 182   }
 183
 184   if (!client_)
 185     return;
 186
 187   scoped_ptr<webrtc::DesktopFrame> owned_frame(frame);
 188
 189   // Handle initial frame size and size changes.
 190   RefreshCaptureFormat(frame->size());
 191
 192   webrtc::DesktopSize output_size(capture_format_.frame_size.width(),
 193                                   capture_format_.frame_size.height());
 194   size_t output_bytes = output_size.width() * output_size.height() *
 195       webrtc::DesktopFrame::kBytesPerPixel;
 196   const uint8_t* output_data = NULL;
 197   scoped_ptr<uint8_t[]> flipped_frame_buffer;
 198
 199   if (frame->size().equals(output_size)) {
 200     // If the captured frame matches the output size, we can return the pixel
 201     // data directly, without scaling.
 202     output_data = frame->data();
 203
 204     // If the |frame| generated by the screen capturer is inverted then we need
 205     // to flip |frame|.
 206     // This happens only on a specific platform. Refer to crbug.com/306876.
 207     if (frame->stride() < 0) {
 208       int height = frame->size().height();
 209       int bytes_per_row =
 210           frame->size().width() * webrtc::DesktopFrame::kBytesPerPixel;
 211       flipped_frame_buffer.reset(new uint8_t[output_bytes]);
 212       uint8_t* dest = flipped_frame_buffer.get();
 213       for (int row = 0; row < height; ++row) {
 214         memcpy(dest, output_data, bytes_per_row);
 215         dest += bytes_per_row;
 216         output_data += frame->stride();
 217       }
 218       output_data = flipped_frame_buffer.get();
 219     }
 220   } else {
 221     // Otherwise we need to down-scale and/or letterbox to the target format.
 222
 223     // Allocate a buffer of the correct size to scale the frame into.
 224     // |output_frame_| is cleared whenever |output_rect_| changes, so we don't
 225     // need to worry about clearing out stale pixel data in letterboxed areas.
 226     if (!output_frame_) {
 227       output_frame_.reset(new webrtc::BasicDesktopFrame(output_size));
 228       memset(output_frame_->data(), 0, output_bytes);
 229     }
 230     DCHECK(output_frame_->size().equals(output_size));
 231
 232     // TODO(wez): Optimize this to scale only changed portions of the output,
 233     // using ARGBScaleClip().
 234     uint8_t* output_rect_data = output_frame_->data() +
 235         output_frame_->stride() * output_rect_.top() +
 236         webrtc::DesktopFrame::kBytesPerPixel * output_rect_.left();
 237     libyuv::ARGBScale(frame->data(), frame->stride(),
 238                       frame->size().width(), frame->size().height(),
 239                       output_rect_data, output_frame_->stride(),
 240                       output_rect_.width(), output_rect_.height(),
 241                       libyuv::kFilterBilinear);
 242     output_data = output_frame_->data();
 243   }
 244
 245   client_->OnIncomingCapturedData(
 246       output_data, output_bytes, capture_format_, 0, base::TimeTicks::Now());
 247 }
 248
 249 void DesktopCaptureDevice::Core::DoAllocateAndStart(
 250     const media::VideoCaptureParams& params,
 251     scoped_ptr<Client> client) {
 252   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 253   DCHECK(desktop_capturer_);
 254   DCHECK(client.get());
 255   DCHECK(!client_.get());
 256
 257   client_ = client.Pass();
 258   requested_params_ = params;
 259
 260   capture_format_ = requested_params_.requested_format;
 261
 262   // This capturer always outputs ARGB, non-interlaced.
 263   capture_format_.pixel_format = media::PIXEL_FORMAT_ARGB;
 264
 265   desktop_capturer_->Start(this);
 266
 267   CaptureFrameAndScheduleNext();
 268 }
 269
 270 void DesktopCaptureDevice::Core::DoStopAndDeAllocate() {
 271   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 272   client_.reset();
 273   output_frame_.reset();
 274   previous_frame_size_.set(0, 0);
 275   desktop_capturer_.reset();
 276 }
 277
 278 void DesktopCaptureDevice::Core::RefreshCaptureFormat(
 279     const webrtc::DesktopSize& frame_size) {
 280   if (previous_frame_size_.equals(frame_size))
 281     return;
 282
 283   // Clear the output frame, if any, since it will either need resizing, or
 284   // clearing of stale data in letterbox areas, anyway.
 285   output_frame_.reset();
 286
 287   if (previous_frame_size_.is_empty() ||
 288       requested_params_.allow_resolution_change) {
 289     // If this is the first frame, or the receiver supports variable resolution
 290     // then determine the output size by treating the requested width & height
 291     // as maxima.
 292     if (frame_size.width() >
 293             requested_params_.requested_format.frame_size.width() ||
 294         frame_size.height() >
 295             requested_params_.requested_format.frame_size.height()) {
 296       output_rect_ = ComputeLetterboxRect(
 297           webrtc::DesktopSize(
 298               requested_params_.requested_format.frame_size.width(),
 299               requested_params_.requested_format.frame_size.height()),
 300           frame_size);
 301       output_rect_.Translate(-output_rect_.left(), -output_rect_.top());
 302     } else {
 303       output_rect_ = webrtc::DesktopRect::MakeSize(frame_size);
 304     }
 305     capture_format_.frame_size.SetSize(output_rect_.width(),
 306                                        output_rect_.height());
 307   } else {
 308     // Otherwise the output frame size cannot change, so just scale and
 309     // letterbox.
 310     output_rect_ = ComputeLetterboxRect(
 311         webrtc::DesktopSize(capture_format_.frame_size.width(),
 312                             capture_format_.frame_size.height()),
 313         frame_size);
 314   }
 315
 316   previous_frame_size_ = frame_size;
 317 }
 318
 319 void DesktopCaptureDevice::Core::OnCaptureTimer() {
 320   DCHECK(capture_task_posted_);
 321   capture_task_posted_ = false;
 322
 323   if (!client_)
 324     return;
 325
 326   CaptureFrameAndScheduleNext();
 327 }
 328
 329 void DesktopCaptureDevice::Core::CaptureFrameAndScheduleNext() {
 330   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 331   DCHECK(!capture_task_posted_);
 332
 333   base::TimeTicks started_time = base::TimeTicks::Now();
 334   DoCapture();
 335   base::TimeDelta last_capture_duration = base::TimeTicks::Now() - started_time;
 336
 337   // Limit frame-rate to reduce CPU consumption.
 338   base::TimeDelta capture_period = std::max(
 339     (last_capture_duration * 100) / kMaximumCpuConsumptionPercentage,
 340     base::TimeDelta::FromSeconds(1) / capture_format_.frame_rate);
 341
 342   // Schedule a task for the next frame.
 343   capture_task_posted_ = true;
 344   task_runner_->PostDelayedTask(
 345       FROM_HERE, base::Bind(&Core::OnCaptureTimer, this),
 346       capture_period - last_capture_duration);
 347 }
 348
 349 void DesktopCaptureDevice::Core::DoCapture() {
 350   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 351   DCHECK(!capture_in_progress_);
 352
 353   capture_in_progress_ = true;
 354   desktop_capturer_->Capture(webrtc::DesktopRegion());
 355
 356   // Currently only synchronous implementations of DesktopCapturer are
 357   // supported.
 358   DCHECK(!capture_in_progress_);
 359 }
 360
 361 void DesktopCaptureDevice::Core::DoSetNotificationWindowId(
 362     gfx::NativeViewId window_id) {
 363   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 364   DCHECK(window_id);
 365   desktop_capturer_->SetExcludedWindow(window_id);
 366 }
 367
 368 // static
 369 scoped_ptr<media::VideoCaptureDevice> DesktopCaptureDevice::Create(
 370     const DesktopMediaID& source) {
 371   scoped_refptr<base::SequencedWorkerPool> blocking_pool =
 372       BrowserThread::GetBlockingPool();
 373   scoped_refptr<base::SequencedTaskRunner> task_runner =
 374       blocking_pool->GetSequencedTaskRunner(
 375           blocking_pool->GetSequenceToken());
 376
 377   webrtc::DesktopCaptureOptions options =
 378       webrtc::DesktopCaptureOptions::CreateDefault();
 379   // Leave desktop effects enabled during WebRTC captures.
 380   options.set_disable_effects(false);
 381
 382   scoped_ptr<webrtc::DesktopCapturer> capturer;
 383
 384   switch (source.type) {
 385     case DesktopMediaID::TYPE_SCREEN: {
 386       scoped_ptr<webrtc::ScreenCapturer> screen_capturer;
 387       screen_capturer.reset(webrtc::ScreenCapturer::Create(options));
 388       if (screen_capturer && screen_capturer->SelectScreen(source.id)) {
 389         capturer.reset(new webrtc::DesktopAndCursorComposer(
 390             screen_capturer.release(),
 391             webrtc::MouseCursorMonitor::CreateForScreen(options, source.id)));
 392       }
 393       break;
 394     }
 395
 396     case DesktopMediaID::TYPE_WINDOW: {
 397       scoped_ptr<webrtc::WindowCapturer> window_capturer(
 398           webrtc::WindowCapturer::Create(options));
 399       if (window_capturer && window_capturer->SelectWindow(source.id)) {
 400         window_capturer->BringSelectedWindowToFront();
 401         capturer.reset(new webrtc::DesktopAndCursorComposer(
 402             window_capturer.release(),
 403             webrtc::MouseCursorMonitor::CreateForWindow(options, source.id)));
 404       }
 405       break;
 406     }
 407
 408     default: {
 409       NOTREACHED();
 410     }
 411   }
 412
 413   scoped_ptr<media::VideoCaptureDevice> result;
 414   if (capturer)
 415     result.reset(new DesktopCaptureDevice(task_runner, capturer.Pass()));
 416
 417   return result.Pass();
 418 }
 419
 420 DesktopCaptureDevice::DesktopCaptureDevice(
 421     scoped_refptr<base::SequencedTaskRunner> task_runner,
 422     scoped_ptr<webrtc::DesktopCapturer> capturer)
 423     : core_(new Core(task_runner, capturer.Pass())) {}
 424
 425 DesktopCaptureDevice::~DesktopCaptureDevice() {
 426   StopAndDeAllocate();
 427 }
 428
 429 void DesktopCaptureDevice::AllocateAndStart(
 430     const media::VideoCaptureParams& params,
 431     scoped_ptr<Client> client) {
 432   core_->AllocateAndStart(params, client.Pass());
 433 }
 434
 435 void DesktopCaptureDevice::StopAndDeAllocate() {
 436   core_->StopAndDeAllocate();
 437 }
 438
 439 void DesktopCaptureDevice::SetNotificationWindowId(
 440     gfx::NativeViewId window_id) {
 441   core_->SetNotificationWindowId(window_id);
 442 }
 443
 444 }  // namespace content