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

content/renderer/pepper/pepper_video_capture_host.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.
 
 #include "content/renderer/pepper/pepper_video_capture_host.h"
 
+#include "content/renderer/media/media_stream_video_source.h"
 #include "content/renderer/pepper/host_globals.h"
 #include "content/renderer/pepper/pepper_media_device_manager.h"
 #include "content/renderer/pepper/pepper_platform_video_capture.h"
 #include "content/renderer/pepper/pepper_plugin_instance_impl.h"
 #include "content/renderer/pepper/renderer_ppapi_host_impl.h"
 #include "content/renderer/render_frame_impl.h"
 #include "media/base/limits.h"
 #include "media/base/video_frame.h"
 #include "ppapi/host/dispatch_host_message.h"
 #include "ppapi/host/ppapi_host.h"
@@ skipping 96 matching lines @@
   // conflicting "master" resolution), or because the browser failed to start
   // the capture.
   SetStatus(PP_VIDEO_CAPTURE_STATUS_STOPPED, true);
   host()->SendUnsolicitedReply(
       pp_resource(),
       PpapiPluginMsg_VideoCapture_OnError(
           static_cast<uint32_t>(PP_ERROR_FAILED)));
 }
 
 void PepperVideoCaptureHost::OnFrameReady(
-    const scoped_refptr<media::VideoFrame>& frame,
-    media::VideoCaptureFormat format) {
+    const scoped_refptr<media::VideoFrame>& frame) {
   DCHECK(frame.get());
 
-  if (alloc_size_ != frame->coded_size() || buffers_.empty()) {
-    AllocBuffers(frame->coded_size(), format.frame_rate);
-    alloc_size_ = frame->coded_size();
+  if (alloc_size_ != frame->visible_rect().size() || buffers_.empty()) {
+    alloc_size_ = frame->visible_rect().size();
+    double frame_rate;
+    int rounded_frame_rate;
+    if (frame->metadata()->GetDouble(media::VideoFrameMetadata::FRAME_RATE,
+                                     &frame_rate))
+      rounded_frame_rate = static_cast<int>(frame_rate + 0.5 /* round */);
+    else
+      rounded_frame_rate = MediaStreamVideoSource::kUnknownFrameRate;
+    AllocBuffers(alloc_size_, rounded_frame_rate);
   }
 
   for (uint32_t i = 0; i < buffers_.size(); ++i) {
     if (!buffers_[i].in_use) {
       DCHECK_EQ(frame->format(), media::VideoFrame::I420);
       if (buffers_[i].buffer->size() <
-          media::VideoFrame::AllocationSize(frame->format(),
-                                            frame->coded_size())) {
+          media::VideoFrame::AllocationSize(frame->format(), alloc_size_)) {
         // TODO(ihf): handle size mismatches gracefully here.
         return;
       }
       uint8* dst = reinterpret_cast<uint8*>(buffers_[i].data);
       static_assert(media::VideoFrame::kYPlane == 0, "y plane should be 0");
       static_assert(media::VideoFrame::kUPlane == 1, "u plane should be 1");
       static_assert(media::VideoFrame::kVPlane == 2, "v plane should be 2");
       for (size_t j = 0; j < media::VideoFrame::NumPlanes(frame->format());
            ++j) {
-        const uint8* src = frame->data(j);
+        const uint8* src = frame->visible_data(j);
         const size_t row_bytes = frame->row_bytes(j);
         const size_t src_stride = frame->stride(j);
         for (int k = 0; k < frame->rows(j); ++k) {
           memcpy(dst, src, row_bytes);
           dst += row_bytes;
           src += src_stride;
         }
       }
       buffers_[i].in_use = true;
       host()->SendUnsolicitedReply(
@@ skipping 256 matching lines @@
 }
 
 PepperVideoCaptureHost::BufferInfo::BufferInfo()
     : in_use(false), data(NULL), buffer() {
 }
 
 PepperVideoCaptureHost::BufferInfo::~BufferInfo() {
 }
 
 }  // namespace content