Replace media::VideoCapture::VideoFrameBuffer with media::VideoFrame.

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/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"
@@ skipping 111 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(PP_ERROR_FAILED));
 }
 
 void PepperVideoCaptureHost::OnRemoved(media::VideoCapture* capture) {
 }
 
-void PepperVideoCaptureHost::OnBufferReady(
+void PepperVideoCaptureHost::OnFrameReady(
     media::VideoCapture* capture,
-    scoped_refptr<media::VideoCapture::VideoFrameBuffer> buffer) {
-  DCHECK(buffer.get());
+    const scoped_refptr<media::VideoFrame>& frame) {
+  DCHECK(frame.get());
   for (uint32_t i = 0; i < buffers_.size(); ++i) {
     if (!buffers_[i].in_use) {
-      // TODO(ihf): Switch to a size calculation based on stride.
-      // Stride is filled out now but not more meaningful than size
-      // until wjia unifies VideoFrameBuffer and media::VideoFrame.
-      size_t size = std::min(static_cast<size_t>(buffers_[i].buffer->size()),
-          buffer->buffer_size);
-      memcpy(buffers_[i].data, buffer->memory_pointer, size);
+      DCHECK_EQ(frame->format(), media::VideoFrame::I420);
+      if (static_cast<size_t>(buffers_[i].buffer->size() <

[miu, 2013/09/12 03:01:58]

Need to place the closing parenthesis of the static_cast expression before the
"<" operator.  However, if the compiler didn't complain about this code as it
is, maybe you don't need the static_cast at all?

[sheu, 2013/09/12 18:47:43]

Done.

+                              media::VideoFrame::AllocationSize(
+                                  frame->format(), frame->coded_size()))) {
+        // TODO(ihf): handle size mismatches gracefully here.
+        return;
+      }
+      uint8* dst = reinterpret_cast<uint8*>(buffers_[i].data);
+      for (size_t j = 0; j < media::VideoFrame::NumPlanes(frame->format());
+           ++j) {

[ncarter (slow), 2013/09/11 18:04:56]

This loop is correct, but it kind of opaquely relies on the fact that the enum
ordering in media::VideoFrame::Format is Y/U/V (if those values were declared in
a different order, you could wind up with YV12 instead of I420 here). Would it
be overly paranoid to add a compile time assert here?

[sheu, 2013/09/11 19:28:10]

I DCHECKED for I420 above, so this is safe for now.  I'd like to clean up the
plane copies in/out of media::VideoFrame, but that's another changelist.

[ncarter (slow), 2013/09/11 19:56:08]

The I420 DCHECK is on the source. The thing that's fragile is that the dest also
wants I420 (e.g. if the source were YV12, this code would produce an I420
destination).

[ilja, 2013/09/12 01:31:43]

It is not specified anywhere, but right now Flash expects I420 and nothing else.

[sheu, 2013/09/12 18:47:43]

Done.

+        const uint8* src = frame->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;
-      platform_video_capture_->FeedBuffer(buffer);
       host()->SendUnsolicitedReply(pp_resource(),
           PpapiPluginMsg_VideoCapture_OnBufferReady(i));
       return;
     }
   }
-
-  // No free slot, just discard the frame and tell the media layer it can
-  // re-use the buffer.
-  platform_video_capture_->FeedBuffer(buffer);
 }
 
 void PepperVideoCaptureHost::OnDeviceInfoReceived(
     media::VideoCapture* capture,
     const media::VideoCaptureParams& device_info) {
   PP_VideoCaptureDeviceInfo_Dev info = {
     static_cast<uint32_t>(device_info.width),
     static_cast<uint32_t>(device_info.height),
     static_cast<uint32_t>(device_info.frame_rate)
   };
   ReleaseBuffers();
 
-  // YUV 4:2:0
-  int uv_width = info.width / 2;
-  int uv_height = info.height / 2;
-  size_t size = info.width * info.height + 2 * uv_width * uv_height;
+  const size_t size = media::VideoFrame::AllocationSize(
+      media::VideoFrame::I420, gfx::Size(info.width, info.height));
 
   ppapi::proxy::ResourceMessageReplyParams params(pp_resource(), 0);
 
   // Allocate buffers. We keep a reference to them, that is released in
   // ReleaseBuffers. In the mean time, we prepare the resource and handle here
   // for sending below.
   std::vector<HostResource> buffer_host_resources;
   buffers_.reserve(buffer_count_hint_);
   ppapi::ResourceTracker* tracker =
       HostGlobals::Get()->GetResourceTracker();
@@ skipping 233 matching lines @@
 PepperVideoCaptureHost::BufferInfo::BufferInfo()
     : in_use(false),
       data(NULL),
       buffer() {
 }
 
 PepperVideoCaptureHost::BufferInfo::~BufferInfo() {
 }
 
 }  // namespace content