Add MediaStreamSource frame rate calculation to the tracker.

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 11 matching lines @@
 // Amount of frame intervals to wait before considering the source as muted, for
 // the first frame and under normal conditions, respectively. First frame might
 // take longer to arrive due to source startup.
 const float kFirstFrameTimeoutInFrameIntervals = 100.0f;
 const float kNormalFrameTimeoutInFrameIntervals = 25.0f;
 
 // Min delta time between two frames allowed without being dropped if a max
 // frame rate is specified.
 const int kMinTimeInMsBetweenFrames = 5;
 
+const int kNumberOfFramesInFrameRateCalculation = 20;
+
 // Empty method used for keeping a reference to the original media::VideoFrame
 // in VideoFrameResolutionAdapter::DeliverFrame if cropping is needed.
 // The reference to |frame| is kept in the closure that calls this method.
 void ReleaseOriginalFrame(
     const scoped_refptr<media::VideoFrame>& frame) {
 }
 
 void ResetCallbackOnMainRenderThread(
     scoped_ptr<VideoCaptureDeliverFrameCB> callback) {
   // |callback| will be deleted when this exits.
@@ skipping 56 matching lines @@
 
   // 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_;
   double max_aspect_ratio_;
 
   double frame_rate_;
+  int number_of_dropped_frames_;
   base::TimeDelta last_time_stamp_;
   double max_frame_rate_;
   double keep_frame_counter_;
 
   typedef std::pair<const void*, VideoCaptureDeliverFrameCB>
       VideoIdCallbackPair;
   std::vector<VideoIdCallbackPair> callbacks_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoFrameResolutionAdapter);
 };
@@ skipping 212 matching lines @@
 bool VideoTrackAdapter::VideoFrameResolutionAdapter::IsEmpty() const {
   DCHECK(io_thread_checker_.CalledOnValidThread());
   return callbacks_.empty();
 }
 
 VideoTrackAdapter::VideoTrackAdapter(
     const scoped_refptr<base::MessageLoopProxy>& io_message_loop)
     : io_message_loop_(io_message_loop),
       renderer_task_runner_(base::MessageLoopProxy::current()),
       monitoring_frame_rate_(false),
-      muted_state_(false),
       frame_counter_(0),
-      source_frame_rate_(0.0f) {
+      source_frame_rate_(0.0f),
+      dropped_frames_counter_(0) {
   DCHECK(io_message_loop_.get());
 }
 
 VideoTrackAdapter::~VideoTrackAdapter() {
   DCHECK(adapters_.empty());
 }
 
 void VideoTrackAdapter::AddTrack(
     const MediaStreamVideoTrack* track,
     VideoCaptureDeliverFrameCB frame_callback,
@@ skipping 42 matching lines @@
 
 void VideoTrackAdapter::RemoveTrack(const MediaStreamVideoTrack* track) {
   DCHECK(thread_checker_.CalledOnValidThread());
   io_message_loop_->PostTask(
       FROM_HERE,
       base::Bind(&VideoTrackAdapter::RemoveTrackOnIO, this, track));
 }
 
 void VideoTrackAdapter::StartFrameMonitoring(
     double source_frame_rate,
-    const OnMutedCallback& on_muted_callback) {
+    const OnFrameRateCallback& on_muted_callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  VideoTrackAdapter::OnMutedCallback bound_on_muted_callback =
+  VideoTrackAdapter::OnFrameRateCallback bound_on_muted_callback =
       media::BindToCurrentLoop(on_muted_callback);
 
+  media::BindToCurrentLoop(on_muted_callback);
+
   io_message_loop_->PostTask(
       FROM_HERE,
       base::Bind(&VideoTrackAdapter::StartFrameMonitoringOnIO,
                  this, bound_on_muted_callback, source_frame_rate));
 }
 
 void VideoTrackAdapter::StartFrameMonitoringOnIO(
-    const OnMutedCallback& on_muted_callback,
+    const OnFrameRateCallback& on_muted_callback,
     double source_frame_rate) {
   DCHECK(io_message_loop_->BelongsToCurrentThread());
   DCHECK(!monitoring_frame_rate_);
 
   monitoring_frame_rate_ = true;
 
   // If the source does not know the frame rate, set one by default.
   if (source_frame_rate == 0.0f)
     source_frame_rate = MediaStreamVideoSource::kDefaultFrameRate;
+
   source_frame_rate_ = source_frame_rate;
   DVLOG(1) << "Monitoring frame creation, first (large) delay: "
       << (kFirstFrameTimeoutInFrameIntervals / source_frame_rate_) << "s";
   io_message_loop_->PostDelayedTask(FROM_HERE,
        base::Bind(&VideoTrackAdapter::CheckFramesReceivedOnIO, this,
-                  on_muted_callback, frame_counter_),
+                  on_muted_callback, frame_counter_, dropped_frames_counter_),
        base::TimeDelta::FromSecondsD(kFirstFrameTimeoutInFrameIntervals /
                                      source_frame_rate_));
 }
 
 void VideoTrackAdapter::StopFrameMonitoring() {
   DCHECK(thread_checker_.CalledOnValidThread());
   io_message_loop_->PostTask(
       FROM_HERE,
       base::Bind(&VideoTrackAdapter::StopFrameMonitoringOnIO, this));
 }
@@ skipping 15 matching lines @@
   }
 }
 
 void VideoTrackAdapter::DeliverFrameOnIO(
     const scoped_refptr<media::VideoFrame>& frame,
     const media::VideoCaptureFormat& format,
     const base::TimeTicks& estimated_capture_time) {
   DCHECK(io_message_loop_->BelongsToCurrentThread());
   TRACE_EVENT0("video", "VideoTrackAdapter::DeliverFrameOnIO");
   ++frame_counter_;
+  UpdateFrameRateOnIO(frame->timestamp());;
+  dropped_frames_counter_ = format.number_of_dropped_frames;
+
   for (FrameAdapters::iterator it = adapters_.begin();
        it != adapters_.end(); ++it) {
     (*it)->DeliverFrame(frame, format, estimated_capture_time);
   }
 }
 
+void VideoTrackAdapter::UpdateFrameRateOnIO(base::TimeDelta timestamp) {
+  DCHECK(io_message_loop_->BelongsToCurrentThread());
+
+  frame_timestamps_.push(timestamp);
+  if (frame_timestamps_.size() > kNumberOfFramesInFrameRateCalculation)
+    frame_timestamps_.pop();
+}
+
+float VideoTrackAdapter::GetFrameRateOnIO() {
+  if (frame_timestamps_.size() < 2)
+    return 0;
+  return frame_timestamps_.size() /
+      (frame_timestamps_.back() - frame_timestamps_.front()).InSecondsF();
+}
+
 void VideoTrackAdapter::CheckFramesReceivedOnIO(
-    const OnMutedCallback& set_muted_state_callback,
-    uint64 old_frame_counter_snapshot) {
+    const OnFrameRateCallback& set_muted_state_callback,
+    uint64 old_frame_counter_snapshot,
+    int old_dropped_frame_counter_snapshot) {
   DCHECK(io_message_loop_->BelongsToCurrentThread());
 
   if (!monitoring_frame_rate_)
     return;
 
   DVLOG_IF(1, old_frame_counter_snapshot == frame_counter_)
       << "No frames have passed, setting source as Muted.";
 
   bool muted_state = old_frame_counter_snapshot == frame_counter_;
-  if (muted_state_ != muted_state) {
-    set_muted_state_callback.Run(muted_state);
-    muted_state_ = muted_state;
+  if (muted_state) {
+    frame_timestamps_ = std::queue<base::TimeDelta>();
   }
+  set_muted_state_callback.Run(
+      GetFrameRateOnIO(),
+      dropped_frames_counter_ - old_dropped_frame_counter_snapshot);
 
   io_message_loop_->PostDelayedTask(FROM_HERE,
       base::Bind(&VideoTrackAdapter::CheckFramesReceivedOnIO, this,
-          set_muted_state_callback, frame_counter_),
+          set_muted_state_callback, frame_counter_, dropped_frames_counter_),
       base::TimeDelta::FromSecondsD(kNormalFrameTimeoutInFrameIntervals /
                                     source_frame_rate_));
 }
 
 }  // namespace content