From Video Capture, abolish OnFrameInfo and enable resolution changes

content/browser/renderer_host/media/web_contents_video_capture_device.cc

 // Copyright (c) 2012 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.
 //
 // Implementation notes: This needs to work on a variety of hardware
 // configurations where the speed of the CPU and GPU greatly affect overall
 // performance. Spanning several threads, the process of capturing has been
 // split up into four conceptual stages:
 //
 //   1. Reserve Buffer: Before a frame can be captured, a slot in the client's
@@ skipping 121 matching lines @@
 }
 
 // Thread-safe, refcounted proxy to the VideoCaptureOracle.  This proxy wraps
 // the VideoCaptureOracle, which decides which frames to capture, and a
 // VideoCaptureDevice::Client, which allocates and receives the captured
 // frames, in a lock to synchronize state between the two.
 class ThreadSafeCaptureOracle
     : public base::RefCountedThreadSafe<ThreadSafeCaptureOracle> {
  public:
   ThreadSafeCaptureOracle(scoped_ptr<media::VideoCaptureDevice::Client> client,
-                          scoped_ptr<VideoCaptureOracle> oracle);
+                          scoped_ptr<VideoCaptureOracle> oracle,
+                          const gfx::Size& capture_size);
 
   bool ObserveEventAndDecideCapture(
       VideoCaptureOracle::Event event,
       base::Time event_time,
       scoped_refptr<media::VideoFrame>* storage,
       RenderWidgetHostViewFrameSubscriber::DeliverFrameCallback* callback);
 
   base::TimeDelta capture_period() const {
     return oracle_->capture_period();
   }
@@ skipping 14 matching lines @@
                        base::Time timestamp,
                        bool success);
   // Protects everything below it.
   base::Lock lock_;
 
   // Recipient of our capture activity.
   scoped_ptr<media::VideoCaptureDevice::Client> client_;
 
   // Makes the decision to capture a frame.
   const scoped_ptr<VideoCaptureOracle> oracle_;
+
+  // The resolution at which we're capturing.
+  const gfx::Size capture_size_;
 };
 
 // FrameSubscriber is a proxy to the ThreadSafeCaptureOracle that's compatible
 // with RenderWidgetHostViewFrameSubscriber. We create one per event type.
 class FrameSubscriber : public RenderWidgetHostViewFrameSubscriber {
  public:
   FrameSubscriber(VideoCaptureOracle::Event event_type,
                   const scoped_refptr<ThreadSafeCaptureOracle>& oracle)
       : event_type_(event_type),
         oracle_proxy_(oracle) {}
@@ skipping 202 matching lines @@
   // verbose logging is turned on.
   base::Time last_frame_rate_log_time_;
   int count_frames_rendered_;
   int last_frame_number_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoFrameDeliveryLog);
 };
 
 ThreadSafeCaptureOracle::ThreadSafeCaptureOracle(
     scoped_ptr<media::VideoCaptureDevice::Client> client,
-    scoped_ptr<VideoCaptureOracle> oracle)
-    : client_(client.Pass()), oracle_(oracle.Pass()) {}
+    scoped_ptr<VideoCaptureOracle> oracle,
+    const gfx::Size& capture_size)
+    : client_(client.Pass()),
+      oracle_(oracle.Pass()),
+      capture_size_(capture_size) {
+}
 
 bool ThreadSafeCaptureOracle::ObserveEventAndDecideCapture(
     VideoCaptureOracle::Event event,
     base::Time event_time,
     scoped_refptr<media::VideoFrame>* storage,
     RenderWidgetHostViewFrameSubscriber::DeliverFrameCallback* callback) {
   base::AutoLock guard(lock_);
 
   if (!client_)
     return false;  // Capture is stopped.
 
   scoped_refptr<media::VideoFrame> output_buffer =
-      client_->ReserveOutputBuffer();
+      client_->ReserveOutputBuffer(capture_size_);
   const bool should_capture =
       oracle_->ObserveEventAndDecideCapture(event, event_time);
   const bool content_is_dirty =
       (event == VideoCaptureOracle::kCompositorUpdate ||
        event == VideoCaptureOracle::kSoftwarePaint);
   const char* event_name =
       (event == VideoCaptureOracle::kTimerPoll ? "poll" :
        (event == VideoCaptureOracle::kCompositorUpdate ? "gpu" :
        "paint"));
 
@@ skipping 597 matching lines @@
   // wants (or will convert to) YUV420.
   width = MakeEven(width);
   height = MakeEven(height);
   if (width < kMinFrameWidth || height < kMinFrameHeight) {
     DVLOG(1) << "invalid width (" << width << ") and/or height ("
              << height << ")";
     client->OnError();
     return;
   }
 
-  // Initialize capture settings which will be consistent for the
-  // duration of the capture.
+  // Need to call OnFrameInfo just to set the frame rate.

[Ami GONE FROM CHROMIUM, 2013/10/04 00:24:15]

Time for a special-purpose setter?

[ncarter (slow), 2013/10/16 02:08:40]

I'm not quite sure what to do about frame_rate. It kind of stands alone. In
practice, only flash seems to depend on it (it doesn't seem to be hooked up to
the webrtc consumer).

Options are: 
 1. Special purpose setter, as you suggest.
 2. Pass as argument (similar to timestamp) to frame delivery /
OnIncomingCapturedVideoFrame.
 3. Keep using OnFrameInfo just for this.

I was leaning toward (3) -- though that's probably a bias towards not having
this CL introduce yet another tweak to the video_capture_device / client
interface.

[Ami GONE FROM CHROMIUM, 2013/10/17 20:31:45]

I like #1 best, but I agree fixing this doesn't need to be part of this CL. 
File a bug, point to it with a TODO here, and call it a day?

[ncarter (slow), 2013/10/22 01:06:20]

Done.

+  // The other parameters of this struct are ignored.
   media::VideoCaptureCapability settings;
-
-  settings.width = width;
-  settings.height = height;
   settings.frame_rate = frame_rate;
-  // Note: the value of |settings.color| doesn't matter if we use only the
-  // VideoFrame based methods on |client|.
-  settings.color = media::PIXEL_FORMAT_I420;
-  settings.expected_capture_delay = 0;
-  settings.interlaced = false;
+  client->OnFrameInfo(settings);
 
   base::TimeDelta capture_period = base::TimeDelta::FromMicroseconds(
-      1000000.0 / settings.frame_rate + 0.5);
+      1000000.0 / frame_rate + 0.5);
 
-  client->OnFrameInfo(settings);
   scoped_ptr<VideoCaptureOracle> oracle(
       new VideoCaptureOracle(capture_period,
                              kAcceleratedSubscriberIsSupported));
-  oracle_proxy_ = new ThreadSafeCaptureOracle(client.Pass(), oracle.Pass());
+  oracle_proxy_ = new ThreadSafeCaptureOracle(
+      client.Pass(), oracle.Pass(), gfx::Size(width, height));
 
   // Allocates the CaptureMachine. The CaptureMachine will be tracking render
   // view swapping over its lifetime, and we don't want to lose our reference to
   // the current render view by starting over with the stale
   // |initial_render_view_id_|.
   DCHECK(!capture_machine_.get());
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&CaptureMachine::Create,
                  initial_render_process_id_,
@@ skipping 117 matching lines @@
                           capture_format.height,
                           capture_format.frame_rate,
                           client.Pass());
 }
 
 void WebContentsVideoCaptureDevice::StopAndDeAllocate() {
   impl_->StopAndDeAllocate();
 }
 
 }  // namespace content