Reland: Video Capture: extract storage info from pixel format in VideoCaptureFormat.

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 <algorithm>
 
 #include "base/bind.h"
 #include "base/strings/stringprintf.h"
@@ skipping 198 matching lines @@
 
 VideoCaptureDeviceClient::~VideoCaptureDeviceClient() {}
 
 void VideoCaptureDeviceClient::OnIncomingCapturedData(
     const uint8* data,
     int length,
     const VideoCaptureFormat& frame_format,
     int rotation,
     const base::TimeTicks& timestamp) {
   TRACE_EVENT0("video", "VideoCaptureDeviceClient::OnIncomingCapturedData");
+  DCHECK_EQ(frame_format.pixel_storage, media::PIXEL_STORAGE_CPU);

[mcasas, 2015/06/24 21:23:23]

dcheng@: Same comment: this should be DCHECK_EQ(actual, expected)

Done.

 
   if (last_captured_pixel_format_ != frame_format.pixel_format) {
-    OnLog("Pixel format: " + media::VideoCaptureFormat::PixelFormatToString(
-                                 frame_format.pixel_format));
+    OnLog("Pixel format: " +
+          VideoCaptureFormat::PixelFormatToString(frame_format.pixel_format));
     last_captured_pixel_format_ = frame_format.pixel_format;
   }
 
   if (!frame_format.IsValid())
     return;
 
   // |chopped_{width,height} and |new_unrotated_{width,height}| are the lowest
   // bit decomposition of {width, height}, grabbing the odd and even parts.
   const int chopped_width = frame_format.frame_size.width() & 1;
   const int chopped_height = frame_format.frame_size.height() & 1;
@@ skipping 17 matching lines @@
 
   const gfx::Size dimensions(destination_width, destination_height);
   if (!VideoFrame::IsValidConfig(VideoFrame::I420,
                                  VideoFrame::STORAGE_UNKNOWN,
                                  dimensions,
                                  gfx::Rect(dimensions),
                                  dimensions)) {
     return;
   }
 
-  scoped_ptr<Buffer> buffer(
-      ReserveOutputBuffer(media::PIXEL_FORMAT_I420, dimensions));
+  scoped_ptr<Buffer> buffer(ReserveOutputBuffer(
+      dimensions, media::PIXEL_FORMAT_I420, media::PIXEL_STORAGE_CPU));
   if (!buffer.get())
     return;
 
   const size_t y_plane_size = VideoFrame::PlaneSize(
       VideoFrame::I420, VideoFrame::kYPlane, dimensions).GetArea();
   const size_t u_plane_size = VideoFrame::PlaneSize(
       VideoFrame::I420, VideoFrame::kUPlane, dimensions).GetArea();
   uint8* const yplane = reinterpret_cast<uint8*>(buffer->data());
   uint8* const uplane = yplane + y_plane_size;
   uint8* const vplane = uplane + u_plane_size;
@@ skipping 71 matching lines @@
                             uv_plane_stride,
                             crop_x,
                             crop_y,
                             frame_format.frame_size.width(),
                             (flip ? -1 : 1) * frame_format.frame_size.height(),
                             new_unrotated_width,
                             new_unrotated_height,
                             rotation_mode,
                             origin_colorspace) != 0) {
     DLOG(WARNING) << "Failed to convert buffer's pixel format to I420 from "
-                  << media::VideoCaptureFormat::PixelFormatToString(
+                  << VideoCaptureFormat::PixelFormatToString(
                          frame_format.pixel_format);
     return;
   }
 
-  OnIncomingCapturedBuffer(buffer.Pass(),
-                           media::VideoCaptureFormat(dimensions,
-                                                     frame_format.frame_rate,
-                                                     media::PIXEL_FORMAT_I420),
-                           timestamp);
+  const VideoCaptureFormat output_format =
+      VideoCaptureFormat(dimensions, frame_format.frame_rate,
+                         media::PIXEL_FORMAT_I420, media::PIXEL_STORAGE_CPU);
+  OnIncomingCapturedBuffer(buffer.Pass(), output_format, timestamp);
 }
 
 void
 VideoCaptureDeviceClient::OnIncomingCapturedYuvData(
     const uint8* y_data,
     const uint8* u_data,
     const uint8* v_data,
     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", "VideoCaptureDeviceClient::OnIncomingCapturedYuvData");
   DCHECK_EQ(frame_format.pixel_format, media::PIXEL_FORMAT_I420);
+  DCHECK_EQ(frame_format.pixel_storage, media::PIXEL_STORAGE_CPU);
   DCHECK_EQ(clockwise_rotation, 0) << "Rotation not supported";
 
-  scoped_ptr<Buffer> buffer(
-      ReserveOutputBuffer(frame_format.pixel_format, frame_format.frame_size));
+  scoped_ptr<Buffer> buffer(ReserveOutputBuffer(frame_format.frame_size,
+                                                frame_format.pixel_format,
+                                                frame_format.pixel_storage));
   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::PlaneSize(
       VideoFrame::I420, VideoFrame::kYPlane, frame_format.frame_size).GetArea();
   const size_t u_plane_size = VideoFrame::PlaneSize(
       VideoFrame::I420, VideoFrame::kUPlane, frame_format.frame_size).GetArea();
   uint8* const dst_y = reinterpret_cast<uint8*>(buffer->data());
@@ skipping 19 matching lines @@
                        frame_format.frame_size.width(),
                        frame_format.frame_size.height())) {
     DLOG(WARNING) << "Failed to copy buffer";
     return;
   }
 
   OnIncomingCapturedBuffer(buffer.Pass(), frame_format, timestamp);
 };
 
 scoped_ptr<media::VideoCaptureDevice::Client::Buffer>
-VideoCaptureDeviceClient::ReserveOutputBuffer(media::VideoPixelFormat format,
-                                              const gfx::Size& dimensions) {
-  DCHECK(format == media::PIXEL_FORMAT_I420 ||
-         format == media::PIXEL_FORMAT_TEXTURE ||
-         format == media::PIXEL_FORMAT_GPUMEMORYBUFFER);
-  DCHECK_GT(dimensions.width(), 0);
-  DCHECK_GT(dimensions.height(), 0);
+VideoCaptureDeviceClient::ReserveOutputBuffer(
+    const gfx::Size& frame_size,
+    media::VideoPixelFormat pixel_format,
+    media::VideoPixelStorage pixel_storage) {
+  DCHECK(pixel_format == media::PIXEL_FORMAT_I420 ||
+         pixel_format == media::PIXEL_FORMAT_ARGB);
+  DCHECK_GT(frame_size.width(), 0);
+  DCHECK_GT(frame_size.height(), 0);
 
-  if (format == media::PIXEL_FORMAT_GPUMEMORYBUFFER && !texture_wrap_helper_) {
+  if (pixel_storage == media::PIXEL_STORAGE_GPUMEMORYBUFFER &&
+      !texture_wrap_helper_) {
     texture_wrap_helper_ =
         new TextureWrapHelper(controller_, capture_task_runner_);
   }
 
+  // TODO(mcasas): For PIXEL_STORAGE_GPUMEMORYBUFFER, find a way to indicate if
+  // it's a ShMem GMB or a DmaBuf GMB.
   int buffer_id_to_drop = VideoCaptureBufferPool::kInvalidId;
-  const int buffer_id =
-      buffer_pool_->ReserveForProducer(format, dimensions, &buffer_id_to_drop);
+  const int buffer_id = buffer_pool_->ReserveForProducer(
+      pixel_format, pixel_storage, frame_size, &buffer_id_to_drop);
   if (buffer_id == VideoCaptureBufferPool::kInvalidId)
     return NULL;
 
   scoped_ptr<media::VideoCaptureDevice::Client::Buffer> output_buffer(
       new AutoReleaseBuffer(buffer_pool_, buffer_id));
 
   if (buffer_id_to_drop != VideoCaptureBufferPool::kInvalidId) {
     BrowserThread::PostTask(BrowserThread::IO,
         FROM_HERE,
         base::Bind(&VideoCaptureController::DoBufferDestroyedOnIOThread,
                    controller_, buffer_id_to_drop));
   }
 
   return output_buffer.Pass();
 }
 
 void VideoCaptureDeviceClient::OnIncomingCapturedBuffer(
     scoped_ptr<Buffer> buffer,
-    const media::VideoCaptureFormat& frame_format,
+    const VideoCaptureFormat& frame_format,
     const base::TimeTicks& timestamp) {
-  if (frame_format.pixel_format == media::PIXEL_FORMAT_GPUMEMORYBUFFER) {
+  if (frame_format.pixel_storage == media::PIXEL_STORAGE_GPUMEMORYBUFFER) {
     capture_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&TextureWrapHelper::OnIncomingCapturedGpuMemoryBuffer,
                    texture_wrap_helper_,
                    base::Passed(&buffer),
                    frame_format,
                    timestamp));
   } else {
-    DCHECK_EQ(frame_format.pixel_format, media::PIXEL_FORMAT_I420);
+    DCHECK(frame_format.pixel_format == media::PIXEL_FORMAT_I420 ||
+           frame_format.pixel_format == media::PIXEL_FORMAT_ARGB);
     scoped_refptr<VideoFrame> video_frame =
         VideoFrame::WrapExternalData(
             VideoFrame::I420,
             frame_format.frame_size,
             gfx::Rect(frame_format.frame_size),
             frame_format.frame_size,
             reinterpret_cast<uint8*>(buffer->data()),
             VideoFrame::AllocationSize(VideoFrame::I420,
                                        frame_format.frame_size),
             base::TimeDelta());
@@ skipping 53 matching lines @@
   capture_task_runner_->PostTask(FROM_HERE,
       base::Bind(&TextureWrapHelper::Init, this));
 }
 
 void
 VideoCaptureDeviceClient::TextureWrapHelper::OnIncomingCapturedGpuMemoryBuffer(
         scoped_ptr<media::VideoCaptureDevice::Client::Buffer> buffer,
         const media::VideoCaptureFormat& frame_format,
         const base::TimeTicks& timestamp) {
   DCHECK(capture_task_runner_->BelongsToCurrentThread());
-  DCHECK_EQ(frame_format.pixel_format, media::PIXEL_FORMAT_GPUMEMORYBUFFER);
+  DCHECK_EQ(frame_format.pixel_format, media::PIXEL_FORMAT_ARGB);
+  DCHECK_EQ(frame_format.pixel_storage, media::PIXEL_STORAGE_GPUMEMORYBUFFER);
   if (!gl_helper_) {
     // |gl_helper_| might not exist due to asynchronous initialization not
     // finished or due to termination in process after a context loss.
     DVLOG(1) << " Skipping ingress frame, no GL context.";
     return;
   }
 
   gpu::gles2::GLES2Interface* gl = capture_thread_context_->ContextGL();
   GLuint image_id = gl->CreateImageCHROMIUM(buffer->AsClientBuffer(),
                                             frame_format.frame_size.width(),
@@ skipping 134 matching lines @@
 void VideoCaptureDeviceClient::TextureWrapHelper::OnError(
     const std::string& message) {
   DCHECK(capture_task_runner_->BelongsToCurrentThread());
   DLOG(ERROR) << message;
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&VideoCaptureController::DoErrorOnIOThread, controller_));
 }
 
 }  // namespace content