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