Change VideoTrackAdapter to not drop frames if the source frame rate is known.

content/renderer/media/video_track_adapter.cc

 // Copyright 2014 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/renderer/media/video_track_adapter.h"
 
 #include <algorithm>
 #include <limits>
 #include <utility>
 
@@ skipping 71 matching lines @@
   virtual ~VideoFrameResolutionAdapter();
   friend class base::RefCountedThreadSafe<VideoFrameResolutionAdapter>;
 
   virtual void DoDeliverFrame(
       const scoped_refptr<media::VideoFrame>& frame,
       const media::VideoCaptureFormat& format,
       const base::TimeTicks& estimated_capture_time);
 
   // Returns |true| if the input frame rate is higher that the requested max
   // frame rate and |frame| should be dropped.
-  bool MaybeDropFrame(const scoped_refptr<media::VideoFrame>& frame);
+  bool MaybeDropFrame(const scoped_refptr<media::VideoFrame>& frame,
+                      float source_frame_rate);
 
   // Bound to the IO-thread.
   base::ThreadChecker io_thread_checker_;
 
   // The task runner where we will release VideoCaptureDeliverFrameCB
   // registered in AddCallback.
   scoped_refptr<base::SingleThreadTaskRunner> renderer_task_runner_;
 
   gfx::Size max_frame_size_;
   double min_aspect_ratio_;
@@ skipping 42 matching lines @@
   DCHECK(io_thread_checker_.CalledOnValidThread());
   DCHECK(callbacks_.empty());
 }
 
 void VideoTrackAdapter::VideoFrameResolutionAdapter::DeliverFrame(
     const scoped_refptr<media::VideoFrame>& frame,
     const media::VideoCaptureFormat& format,
     const base::TimeTicks& estimated_capture_time) {
   DCHECK(io_thread_checker_.CalledOnValidThread());
 
-  if (MaybeDropFrame(frame))
+  if (MaybeDropFrame(frame, format.frame_rate))
     return;
 
   // TODO(perkj): Allow cropping / scaling of textures once
   // http://crbug/362521 is fixed.
   if (frame->format() == media::VideoFrame::NATIVE_TEXTURE) {
     DoDeliverFrame(frame, format, estimated_capture_time);
     return;
   }
   scoped_refptr<media::VideoFrame> video_frame(frame);
   double input_ratio =
@@ skipping 51 matching lines @@
     DVLOG(3) << "desired size  " << desired_size.ToString()
              << " output natural size "
              << video_frame->natural_size().ToString()
              << " output visible rect  "
              << video_frame->visible_rect().ToString();
   }
   DoDeliverFrame(video_frame, format, estimated_capture_time);
 }
 
 bool VideoTrackAdapter::VideoFrameResolutionAdapter::MaybeDropFrame(
-    const scoped_refptr<media::VideoFrame>& frame) {
-  if (max_frame_rate_ == 0.0f)
+    const scoped_refptr<media::VideoFrame>& frame,
+    float source_frame_rate) {
+  DCHECK(io_thread_checker_.CalledOnValidThread());
+
+  // Do not drop frames if max frame rate hasn't been specified or the source
+  // frame rate is known and is lower than max.
+  if (max_frame_rate_ == 0.0f ||
+      (source_frame_rate > 0 &&
+          source_frame_rate <= max_frame_rate_))

[tommi (sloooow) - chröme, 2014/08/30 17:40:58]

nit: there should have been braces here.

     return false;
 
   base::TimeDelta delta = frame->timestamp() - last_time_stamp_;
   if (delta.InMilliseconds() < kMinTimeInMsBetweenFrames) {
     // We have seen video frames being delivered from camera devices back to
     // back. The simple AR filter for frame rate calculation is too short to
     // handle that. http://crbug/394315
     // TODO(perkj): Can we come up with a way to fix the times stamps and the
     // timing when frames are delivered so all frames can be used?
     // The time stamps are generated by Chrome and not the actual device.
     // Most likely the back to back problem is caused by software and not the
     // actual camera.
     DVLOG(3) << "Drop frame since delta time since previous frame is "
              << delta.InMilliseconds() << "ms.";
     return true;
   }
   last_time_stamp_ = frame->timestamp();
-  if (delta == last_time_stamp_) // First received frame.
+  if (delta == last_time_stamp_)  // First received frame.
     return false;
   // Calculate the frame rate using a simple AR filter.
   // Use a simple filter with 0.1 weight of the current sample.
   frame_rate_ = 100 / delta.InMillisecondsF() + 0.9 * frame_rate_;
 
   // Prefer to not drop frames.
   if (max_frame_rate_ + 0.5f > frame_rate_)
     return false;  // Keep this frame.
 
   // The input frame rate is higher than requested.
@@ skipping 196 matching lines @@
   // Rearm the monitoring while there are active Tracks, i.e. as long as the
   // owner MediaStreamSource is active.
   io_message_loop_->PostDelayedTask(FROM_HERE,
       base::Bind(&VideoTrackAdapter::CheckFramesReceivedOnIO, this,
           set_muted_state_callback, frame_counter_),
       base::TimeDelta::FromSecondsD(kNormalFrameTimeoutInFrameIntervals /
                                     source_frame_rate_));
 }
 
 }  // namespace content