VideoCaptureBufferPool: Refactor to allow support of non-ShMem backed buffers

content/browser/renderer_host/media/video_capture_device_client.cc

 // Copyright 2015 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/browser/renderer_host/media/video_capture_device_client.h"
 
 #include "base/bind.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/trace_event.h"
 #include "content/browser/renderer_host/media/video_capture_buffer_pool.h"
@@ skipping 87 matching lines @@
     rotation_mode = libyuv::kRotate270;
 
   const gfx::Size dimensions(destination_width, destination_height);
   if (!VideoFrame::IsValidConfig(VideoFrame::I420,
                                  dimensions,
                                  gfx::Rect(dimensions),
                                  dimensions)) {
     return;
   }
 
-  scoped_refptr<Buffer> buffer = ReserveOutputBuffer(VideoFrame::I420,
-                                                     dimensions);
+  const VideoCaptureFormat format(dimensions, 0.0, media::PIXEL_FORMAT_I420);
+  scoped_refptr<Buffer> buffer = ReserveOutputBuffer(format);
   if (!buffer.get())
     return;
 
   uint8* const yplane = reinterpret_cast<uint8*>(buffer->data());
   uint8* const uplane =
       yplane + VideoFrame::PlaneAllocationSize(VideoFrame::I420,
                                                VideoFrame::kYPlane, dimensions);
   uint8* const vplane =
       uplane + VideoFrame::PlaneAllocationSize(VideoFrame::I420,
                                                VideoFrame::kUPlane, dimensions);
@@ skipping 116 matching lines @@
     size_t y_stride,
     size_t u_stride,
     size_t v_stride,
     const VideoCaptureFormat& frame_format,
     int clockwise_rotation,
     const base::TimeTicks& timestamp) {
   TRACE_EVENT0("video", "VideoCaptureController::OnIncomingCapturedYuvData");
   DCHECK_EQ(frame_format.pixel_format, media::PIXEL_FORMAT_I420);
   DCHECK_EQ(clockwise_rotation, 0) << "Rotation not supported";
 
-  scoped_refptr<Buffer> buffer = ReserveOutputBuffer(VideoFrame::I420,
-                                                     frame_format.frame_size);
+  scoped_refptr<Buffer> buffer = ReserveOutputBuffer(frame_format);
   if (!buffer.get())
     return;
 
   // Blit (copy) here from y,u,v into buffer.data()). Needed so we can return
   // the parameter buffer synchronously to the driver.
   const size_t y_plane_size = VideoFrame::PlaneAllocationSize(VideoFrame::I420,
       VideoFrame::kYPlane, frame_format.frame_size);
   const size_t u_plane_size = VideoFrame::PlaneAllocationSize(
       VideoFrame::I420, VideoFrame::kUPlane, frame_format.frame_size);
   uint8* const dst_y = reinterpret_cast<uint8*>(buffer->data());
@@ skipping 36 matching lines @@
       FROM_HERE,
       base::Bind(
           &VideoCaptureController::DoIncomingCapturedVideoFrameOnIOThread,
           controller_,
           buffer,
           video_frame,
           timestamp));
 };
 
 scoped_refptr<media::VideoCaptureDevice::Client::Buffer>
-VideoCaptureDeviceClient::ReserveOutputBuffer(VideoFrame::Format format,
-                                              const gfx::Size& dimensions) {
-  const size_t frame_bytes = VideoFrame::AllocationSize(format, dimensions);
-  if (format == VideoFrame::NATIVE_TEXTURE) {
-    DCHECK_EQ(dimensions.width(), 0);
-    DCHECK_EQ(dimensions.height(), 0);
+VideoCaptureDeviceClient::ReserveOutputBuffer(
+    const media::VideoCaptureFormat& format) {
+  DCHECK(format.pixel_format == media::PIXEL_FORMAT_TEXTURE ||
+         format.pixel_format == media::PIXEL_FORMAT_I420);
+  if (format.pixel_format == media::PIXEL_FORMAT_TEXTURE) {

[miu, 2015/04/08 01:20:00]

IMO, you should just delete lines 307-313 and replace with:

DCHECK_GT(format.frame_size.width(), 0);
DCHECK_GT(format.frame_size.height(), 0);

...since VCBufferPool will need to know the frame size in order to reserve a
buffer, regardless of whether it's SharedMerory or a GPUMemoryBuffer.

[mcasas, 2015/04/08 22:07:06]

Done.

+    DCHECK_EQ(format.frame_size.width(), 0);
+    DCHECK_EQ(format.frame_size.height(), 0);
   } else {
-    DLOG_IF(ERROR, frame_bytes == 0) << "Error calculating allocation size";
+    DLOG_IF(ERROR, format.ImageAllocationSize() == 0)
+        << "Error calculating allocation size";
   }
 
   int buffer_id_to_drop = VideoCaptureBufferPool::kInvalidId;
-  const int buffer_id =
-      buffer_pool_->ReserveForProducer(frame_bytes, &buffer_id_to_drop);
+  const int buffer_id = buffer_pool_->ReserveForProducer(
+      format, &buffer_id_to_drop);
   if (buffer_id == VideoCaptureBufferPool::kInvalidId)
     return NULL;
   void* data;
   size_t size;
   buffer_pool_->GetBufferInfo(buffer_id, &data, &size);
 
   scoped_refptr<media::VideoCaptureDevice::Client::Buffer> output_buffer(
       new AutoReleaseBuffer(buffer_pool_, buffer_id, data, size));
 
   if (buffer_id_to_drop != VideoCaptureBufferPool::kInvalidId) {
@@ skipping 37 matching lines @@
 }
 
 void VideoCaptureDeviceClient::OnLog(
     const std::string& message) {
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                           base::Bind(&VideoCaptureController::DoLogOnIOThread,
                                      controller_, message));
 }
 
 }  // namespace content