Add metadata to media::VideoFrame and plumb it through IPC/MediaStream.

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 58 matching lines @@
   // |callback| will however be released on the main render thread.
   void AddCallback(const MediaStreamVideoTrack* track,
                    const VideoCaptureDeliverFrameCB& callback);
 
   // Removes |callback| associated with |track| from receiving video frames if
   // |track| has been added. It is ok to call RemoveCallback even if the |track|
   // has not been added. The |callback| is released on the main render thread.
   void RemoveCallback(const MediaStreamVideoTrack* track);
 
   void DeliverFrame(const scoped_refptr<media::VideoFrame>& frame,
-                    const media::VideoCaptureFormat& format,
                     const base::TimeTicks& estimated_capture_time);
 
   // Returns true if all arguments match with the output of this adapter.
   bool ConstraintsMatch(const gfx::Size& max_size,
                         double min_aspect_ratio,
                         double max_aspect_ratio,
                         double max_frame_rate) const;
 
   bool IsEmpty() const;
 
  private:
   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,
                       float source_frame_rate);
 
   // Bound to the IO-thread.
   base::ThreadChecker io_thread_checker_;
 
@@ skipping 60 matching lines @@
 }
 
 VideoTrackAdapter::
 VideoFrameResolutionAdapter::~VideoFrameResolutionAdapter() {
   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, format.frame_rate))
+  double frame_rate;
+  if (!frame->metadata()->GetDouble(media::VideoFrameMetadata::FRAME_RATE,
+                                    &frame_rate)) {
+    frame_rate = MediaStreamVideoSource::kUnknownFrameRate;
+  }
+  if (MaybeDropFrame(frame, 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);
+    DoDeliverFrame(frame, estimated_capture_time);
     return;
   }
   scoped_refptr<media::VideoFrame> video_frame(frame);
   double input_ratio =
       static_cast<double>(frame->natural_size().width()) /
       frame->natural_size().height();
 
   // If |frame| has larger width or height than requested, or the aspect ratio
   // does not match the requested, we want to create a wrapped version of this
   // frame with a size that fulfills the constraints.
@@ skipping 41 matching lines @@
         region_in_frame,
         desired_size,
         base::Bind(&ReleaseOriginalFrame, frame));
 
     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);
+  DoDeliverFrame(video_frame, estimated_capture_time);
 }
 
 bool VideoTrackAdapter::VideoFrameResolutionAdapter::MaybeDropFrame(
     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 ||
@@ skipping 44 matching lines @@
     // Keep the frame.
     return false;
   }
   DVLOG(3) << "Drop frame. Input frame_rate_ " << frame_rate_ << ".";
   return true;
 }
 
 void VideoTrackAdapter::
 VideoFrameResolutionAdapter::DoDeliverFrame(
     const scoped_refptr<media::VideoFrame>& frame,
-    const media::VideoCaptureFormat& format,
     const base::TimeTicks& estimated_capture_time) {
   DCHECK(io_thread_checker_.CalledOnValidThread());
-  for (std::vector<VideoIdCallbackPair>::const_iterator it = callbacks_.begin();
-       it != callbacks_.end(); ++it) {
-    it->second.Run(frame, format, estimated_capture_time);
-  }
+  for (const auto& entry : callbacks_)
+    entry.second.Run(frame, estimated_capture_time);
 }
 
 void VideoTrackAdapter::VideoFrameResolutionAdapter::AddCallback(
     const MediaStreamVideoTrack* track,
     const VideoCaptureDeliverFrameCB& callback) {
   DCHECK(io_thread_checker_.CalledOnValidThread());
   callbacks_.push_back(std::make_pair(track, callback));
 }
 
 void VideoTrackAdapter::VideoFrameResolutionAdapter::RemoveCallback(
@@ skipping 156 matching lines @@
     (*it)->RemoveCallback(track);
     if ((*it)->IsEmpty()) {
       adapters_.erase(it);
       break;
     }
   }
 }
 
 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_;
-  for (FrameAdapters::iterator it = adapters_.begin();
-       it != adapters_.end(); ++it) {
-    (*it)->DeliverFrame(frame, format, estimated_capture_time);
-  }
+  for (const auto& adapter : adapters_)
+    adapter->DeliverFrame(frame, estimated_capture_time);
 }
 
 void VideoTrackAdapter::CheckFramesReceivedOnIO(
     const OnMutedCallback& set_muted_state_callback,
     uint64 old_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;
   }
 
   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