Tab capture: do 200 rendundant captures of static content.

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 consumer's
@@ skipping 85 matching lines @@
 
 namespace content {
 
 namespace {
 
 const int kMinFrameWidth = 2;
 const int kMinFrameHeight = 2;
 const int kMaxFramesInFlight = 2;
 const int kMaxSnapshotsInFlight = 1;
 
+// This value controls how many redundant, timer-base captures occur when the
+// content is static. Redundantly capturing the same frame allows iterative
+// quality enhancement, and also allows the buffer to fill in "buffered mode".
+//
+// TODO(nick): Controlling this here is a hack and a layering violation, since
+// it's a strategy specific to the WebRTC consumer, and probably just papers
+// over some frame dropping and quality bugs. It should either be controlled at
+// a higher level, or else redundant frame generation should be pushed down
+// further into the WebRTC encoding stack.
+const int kNumRedundantCapturesOfStaticContent = 200;
+
 // TODO(nick): Remove this once frame subscription is supported on Aura and
 // Linux.
 #if (defined(OS_WIN) || defined(OS_MACOSX)) && !defined(USE_AURA)
 const bool kAcceleratedSubscriberIsSupported = true;
 #else
 const bool kAcceleratedSubscriberIsSupported = false;
 #endif
 
 typedef base::Callback<void(base::Time, bool)> DeliverFrameCallback;
 
@@ skipping 296 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(VideoFrameDeliveryLog);
 };
 
 CaptureOracle::CaptureOracle(media::VideoCaptureDevice::EventHandler* consumer,
                              base::TimeDelta capture_period)
     : capture_period_(capture_period),
       consumer_(consumer),
       frame_number_(0),
       is_started_(false),
-      sampler_(capture_period_, kAcceleratedSubscriberIsSupported) {}
+      sampler_(capture_period_, kAcceleratedSubscriberIsSupported,
+               kNumRedundantCapturesOfStaticContent) {}
 
 bool CaptureOracle::ObserveEventAndDecideCapture(
       Event event,
       scoped_refptr<media::VideoFrame>* storage,
       RenderWidgetHostViewFrameSubscriber::DeliverFrameCallback* callback) {
   base::AutoLock guard(lock_);
 
   if (!consumer_ || !is_started_)
     return false;  // Capture is stopped.
 
@@ skipping 813 matching lines @@
 void WebContentsVideoCaptureDevice::DeAllocate() {
   impl_->DeAllocate();
 }
 
 const media::VideoCaptureDevice::Name&
 WebContentsVideoCaptureDevice::device_name() {
   return device_name_;
 }
 
 SmoothEventSampler::SmoothEventSampler(base::TimeDelta capture_period,
-                                       bool events_are_reliable)
+                                       bool events_are_reliable,
+                                       int redundant_capture_goal)
     :  events_are_reliable_(events_are_reliable),
-       capture_period_(capture_period) {}
+       capture_period_(capture_period),
+       redundant_capture_goal_(redundant_capture_goal),
+       last_sample_count_(0) {}
 
 bool SmoothEventSampler::AddEventAndConsiderSampling(base::Time now) {
   current_event_ = now;
 
   // If we've never sampled, then the choice is obvious.
-  if (last_sample_.is_null())
+  if (last_sample_count_ == 0)
     return true;
 
   // TODO(nick): Actually track the effective frame rate here, and use an
   // uncertainty window based on that (half seems like a reasonable choice). E.g
   // if content is updating every 16.6ms, and we're hoping to sampling every
   // 100ms, then we might consider sampling events no sooner than (100ms -
   // 8.3ms) from the last sample.
   base::TimeDelta uncertainty_window = capture_period_ / 10;
 
   base::TimeDelta interval = current_event_ - last_sample_;
   return interval >= (capture_period_ - uncertainty_window);
 }
 
 void SmoothEventSampler::RecordSample() {
-  if (!current_event_.is_null())
+  if (!current_event_.is_null()) {
+    last_sample_count_ = 0;
     last_sample_ = current_event_;
+  }
+  last_sample_count_++;
   current_event_ = base::Time();
 }
 
 bool SmoothEventSampler::IsOverdueForSamplingAt(base::Time now) const {
-  if (last_sample_.is_null())
+  if (last_sample_count_ == 0)
     return true;  // Definitely old and dirty.
 
   // If we don't get events on compositor updates on this platform, then we
   // don't reliably know whether we're dirty.
   if (events_are_reliable_) {
-    if (current_event_.is_null())
+    if (current_event_.is_null() &&
+        last_sample_count_ >= redundant_capture_goal_) {
       return false;  // Not dirty.
+    }
   }
 
   // If we're dirty but not yet old, then we've recently gotten updates, so we
   // won't request a sample just yet.
   base::TimeDelta dirty_interval = now - last_sample_;
   if (dirty_interval < capture_period_ * 2)
     return false;
   else
     return true;
 }
 
 base::Time SmoothEventSampler::GetLastSampledEvent() {
   return last_sample_;
 }
 
 }  // namespace content