Use texture-backed VideoFrame pipeline for Aura desktop capturing.

content/browser/media/capture/desktop_capture_device_aura.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/media/capture/desktop_capture_device_aura.h"
 
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/timer/timer.h"
 #include "cc/output/copy_output_request.h"
@@ skipping 79 matching lines @@
 class DesktopVideoCaptureMachine
     : public VideoCaptureMachine,
       public aura::WindowObserver,
       public ui::CompositorObserver,
       public base::SupportsWeakPtr<DesktopVideoCaptureMachine> {
  public:
   DesktopVideoCaptureMachine(const DesktopMediaID& source);
   virtual ~DesktopVideoCaptureMachine();
 
   // VideoCaptureFrameSource overrides.
-  virtual bool Start(
-      const scoped_refptr<ThreadSafeCaptureOracle>& oracle_proxy) OVERRIDE;
+  virtual bool Start(const scoped_refptr<ThreadSafeCaptureOracle>& oracle_proxy,
+                     const media::VideoCaptureParams& params) OVERRIDE;
   virtual void Stop(const base::Closure& callback) OVERRIDE;
 
   // Implements aura::WindowObserver.
   virtual void OnWindowBoundsChanged(aura::Window* window,
                                      const gfx::Rect& old_bounds,
                                      const gfx::Rect& new_bounds) OVERRIDE;
   virtual void OnWindowDestroyed(aura::Window* window) OVERRIDE;
 
   // Implements ui::CompositorObserver.
   virtual void OnCompositingDidCommit(ui::Compositor* compositor) OVERRIDE {}
@@ skipping 43 matching lines @@
 
   // The timer that kicks off period captures.
   base::Timer timer_;
 
   // The id of the window being captured.
   DesktopMediaID window_id_;
 
   // Makes all the decisions about which frames to copy, and how.
   scoped_refptr<ThreadSafeCaptureOracle> oracle_proxy_;
 
+  // The capture parameters for this capture.
+  media::VideoCaptureParams capture_params_;
+
   // YUV readback pipeline.
   scoped_ptr<content::ReadbackYUVInterface> yuv_readback_pipeline_;
 
   // Cursor state.
   ui::Cursor last_cursor_;
   gfx::Point cursor_hot_point_;
   SkBitmap scaled_cursor_bitmap_;
 
   DISALLOW_COPY_AND_ASSIGN(DesktopVideoCaptureMachine);
 };
 
 DesktopVideoCaptureMachine::DesktopVideoCaptureMachine(
     const DesktopMediaID& source)
     : desktop_window_(NULL),
       desktop_layer_(NULL),
       timer_(true, true),
       window_id_(source) {}
 
 DesktopVideoCaptureMachine::~DesktopVideoCaptureMachine() {}
 
 bool DesktopVideoCaptureMachine::Start(
-    const scoped_refptr<ThreadSafeCaptureOracle>& oracle_proxy) {
+    const scoped_refptr<ThreadSafeCaptureOracle>& oracle_proxy,
+    const media::VideoCaptureParams& params) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   desktop_window_ = content::DesktopMediaID::GetAuraWindowById(window_id_);
   if (!desktop_window_)
     return false;
 
   // If the desktop layer is already destroyed then return failure.
   desktop_layer_ = desktop_window_->layer();
   if (!desktop_layer_)
     return false;
 
   DCHECK(oracle_proxy.get());
   oracle_proxy_ = oracle_proxy;
+  capture_params_ = params;
 
   // Update capture size.
   UpdateCaptureSize();
 
   // Start observing window events.
   desktop_window_->AddObserver(this);
 
   // Start observing compositor updates.
   ui::Compositor* compositor = desktop_layer_->GetCompositor();
   if (!compositor)
@@ skipping 77 matching lines @@
     base::TimeTicks start_time,
     const ThreadSafeCaptureOracle::CaptureFrameCallback& capture_frame_cb,
     const scoped_refptr<media::VideoFrame>& target,
     const SkBitmap& cursor_bitmap,
     const gfx::Point& cursor_position,
     scoped_ptr<cc::SingleReleaseCallback> release_callback,
     bool result) {
   if (!cursor_bitmap.isNull())
     RenderCursorOnVideoFrame(target, cursor_bitmap, cursor_position);
   release_callback->Run(0, false);
-  capture_frame_cb.Run(start_time, result);
+  capture_frame_cb.Run(target, start_time, result);
+}
+
+void RunSingleReleaseCallback(scoped_ptr<cc::SingleReleaseCallback> cb,
+                              const std::vector<uint32>& sync_points) {
+  // TODO(hshi): handle release of multiple sync points.
+  DCHECK_EQ(1u, sync_points.size());
+  cb->Run(sync_points[0], false);
 }
 
 void DesktopVideoCaptureMachine::DidCopyOutput(
     scoped_refptr<media::VideoFrame> video_frame,
     base::TimeTicks start_time,
     const ThreadSafeCaptureOracle::CaptureFrameCallback& capture_frame_cb,
     scoped_ptr<cc::CopyOutputResult> result) {
   static bool first_call = true;
 
   bool succeeded = ProcessCopyOutputResponse(
@@ skipping 19 matching lines @@
 }
 
 bool DesktopVideoCaptureMachine::ProcessCopyOutputResponse(
     scoped_refptr<media::VideoFrame> video_frame,
     base::TimeTicks start_time,
     const ThreadSafeCaptureOracle::CaptureFrameCallback& capture_frame_cb,
     scoped_ptr<cc::CopyOutputResult> result) {
   if (result->IsEmpty() || result->size().IsEmpty() || !desktop_layer_)
     return false;
 
+  if (capture_params_.requested_format.pixel_format ==
+      media::PIXEL_FORMAT_TEXTURE) {
+    DCHECK(!video_frame);
+    cc::TextureMailbox texture_mailbox;
+    scoped_ptr<cc::SingleReleaseCallback> release_callback;
+    result->TakeTexture(&texture_mailbox, &release_callback);
+    DCHECK(texture_mailbox.IsTexture());
+    if (!texture_mailbox.IsTexture())
+      return false;
+    video_frame = media::VideoFrame::WrapNativeTexture(
+        make_scoped_ptr(new gpu::MailboxHolder(texture_mailbox.mailbox(),
+                                               texture_mailbox.target(),
+                                               texture_mailbox.sync_point())),
+        base::Bind(&RunSingleReleaseCallback, base::Passed(&release_callback)),
+        result->size(),
+        gfx::Rect(result->size()),
+        result->size(),
+        base::TimeDelta(),
+        media::VideoFrame::ReadPixelsCB());
+    capture_frame_cb.Run(video_frame, start_time, true);
+    return true;
+  }
+
   // Compute the dest size we want after the letterboxing resize. Make the
   // coordinates and sizes even because we letterbox in YUV space
   // (see CopyRGBToVideoFrame). They need to be even for the UV samples to
   // line up correctly.
   // The video frame's coded_size() and the result's size() are both physical
   // pixels.
   gfx::Rect region_in_frame =
       media::ComputeLetterboxRegion(gfx::Rect(video_frame->coded_size()),
                                     result->size());
   region_in_frame = gfx::Rect(region_in_frame.x() & ~1,
@@ skipping 128 matching lines @@
   IncrementDesktopCaptureCounter(source.type == DesktopMediaID::TYPE_SCREEN
                                      ? SCREEN_CAPTURER_CREATED
                                      : WINDOW_CATPTURER_CREATED);
   return new DesktopCaptureDeviceAura(source);
 }
 
 void DesktopCaptureDeviceAura::AllocateAndStart(
     const media::VideoCaptureParams& params,
     scoped_ptr<Client> client) {
   DVLOG(1) << "Allocating " << params.requested_format.frame_size.ToString();
-  core_->AllocateAndStart(params, client.Pass());
+  media::VideoCaptureParams new_params = params;
+  // Desktop capture devices ignore the requested size and return the actual
+  // captured desktop size.
+  new_params.requested_format.frame_size.SetSize(0, 0);
+  core_->AllocateAndStart(new_params, client.Pass());
 }
 
 void DesktopCaptureDeviceAura::StopAndDeAllocate() {
   core_->StopAndDeAllocate();
 }
 
 }  // namespace content