Cleanup of video capture into GpuMemoryBuffer

media/capture/video/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 "media/capture/video/video_capture_device_client.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "media/base/bind_to_current_loop.h"
-#include "media/base/media_switches.h"
 #include "media/base/video_capture_types.h"
 #include "media/base/video_frame.h"
 #include "media/capture/video/video_capture_buffer_handle.h"
 #include "media/capture/video/video_capture_buffer_pool.h"
 #include "media/capture/video/video_capture_jpeg_decoder.h"
 #include "media/capture/video/video_frame_receiver.h"
 #include "third_party/libyuv/include/libyuv.h"
 
 using media::VideoCaptureFormat;
 using media::VideoFrame;
@@ skipping 34 matching lines @@
 };
 
 VideoCaptureDeviceClient::VideoCaptureDeviceClient(
     std::unique_ptr<VideoFrameReceiver> receiver,
     const scoped_refptr<VideoCaptureBufferPool>& buffer_pool,
     const VideoCaptureJpegDecoderFactoryCB& jpeg_decoder_factory)
     : receiver_(std::move(receiver)),
       jpeg_decoder_factory_callback_(jpeg_decoder_factory),
       external_jpeg_decoder_initialized_(false),
       buffer_pool_(buffer_pool),
-      use_gpu_memory_buffers_(base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kUseGpuMemoryBuffersForCapture)),
       last_captured_pixel_format_(media::PIXEL_FORMAT_UNKNOWN) {}
 
 VideoCaptureDeviceClient::~VideoCaptureDeviceClient() {
   // This should be on the platform auxiliary thread since
   // |external_jpeg_decoder_| need to be destructed on the same thread as
   // OnIncomingCapturedData.
 }
 
 void VideoCaptureDeviceClient::OnIncomingCapturedData(
     const uint8_t* data,
@@ skipping 37 matching lines @@
                               << rotation;
   libyuv::RotationMode rotation_mode = libyuv::kRotate0;
   if (rotation == 90)
     rotation_mode = libyuv::kRotate90;
   else if (rotation == 180)
     rotation_mode = libyuv::kRotate180;
   else if (rotation == 270)
     rotation_mode = libyuv::kRotate270;
 
   const gfx::Size dimensions(destination_width, destination_height);
-  const media::VideoPixelStorage output_pixel_storage =
-      use_gpu_memory_buffers_ ? media::PIXEL_STORAGE_GPUMEMORYBUFFER
-                              : media::PIXEL_STORAGE_CPU;
   uint8_t *y_plane_data, *u_plane_data, *v_plane_data;
   std::unique_ptr<Buffer> buffer(
-      ReserveI420OutputBuffer(dimensions, output_pixel_storage, &y_plane_data,
-                              &u_plane_data, &v_plane_data));
+      ReserveI420OutputBuffer(dimensions, media::PIXEL_STORAGE_CPU,
+                              &y_plane_data, &u_plane_data, &v_plane_data));
 #if DCHECK_IS_ON()
   dropped_frame_counter_ = buffer.get() ? 0 : dropped_frame_counter_ + 1;
   if (dropped_frame_counter_ >= kMaxDroppedFrames)
     OnError(FROM_HERE, "Too many frames dropped");
 #endif
   // Failed to reserve I420 output buffer, so drop the frame.
   if (!buffer.get())
     return;
 
   const int yplane_stride = dimensions.width();
@@ skipping 92 matching lines @@
                             (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::VideoPixelFormatToString(frame_format.pixel_format);
     return;
   }
 
   const VideoCaptureFormat output_format =
       VideoCaptureFormat(dimensions, frame_format.frame_rate,
-                         media::PIXEL_FORMAT_I420, output_pixel_storage);
+                         media::PIXEL_FORMAT_I420, media::PIXEL_STORAGE_CPU);
   OnIncomingCapturedBuffer(std::move(buffer), output_format, reference_time,
                            timestamp);
 }
 
 std::unique_ptr<media::VideoCaptureDevice::Client::Buffer>
 VideoCaptureDeviceClient::ReserveOutputBuffer(
     const gfx::Size& frame_size,
     media::VideoPixelFormat pixel_format,
     media::VideoPixelStorage pixel_storage) {
   DCHECK_GT(frame_size.width(), 0);
@@ skipping 14 matching lines @@
       new AutoReleaseBuffer(buffer_pool_, buffer_id));
 }
 
 void VideoCaptureDeviceClient::OnIncomingCapturedBuffer(
     std::unique_ptr<Buffer> buffer,
     const VideoCaptureFormat& frame_format,
     base::TimeTicks reference_time,
     base::TimeDelta timestamp) {
   // Currently, only I420 pixel format is supported.
   DCHECK_EQ(media::PIXEL_FORMAT_I420, frame_format.pixel_format);
+  DCHECK_EQ(media::PIXEL_STORAGE_CPU, frame_format.pixel_storage);
 
-  scoped_refptr<VideoFrame> frame;
-  switch (frame_format.pixel_storage) {
-    case media::PIXEL_STORAGE_GPUMEMORYBUFFER: {
-      // Create a VideoFrame to set the correct storage_type and pixel_format.
-      gfx::GpuMemoryBufferHandle handle;
-      frame = VideoFrame::WrapExternalYuvGpuMemoryBuffers(
-          media::PIXEL_FORMAT_I420, frame_format.frame_size,
-          gfx::Rect(frame_format.frame_size), frame_format.frame_size, 0, 0, 0,
-          reinterpret_cast<uint8_t*>(buffer->data(media::VideoFrame::kYPlane)),
-          reinterpret_cast<uint8_t*>(buffer->data(media::VideoFrame::kUPlane)),
-          reinterpret_cast<uint8_t*>(buffer->data(media::VideoFrame::kVPlane)),
-          handle, handle, handle, timestamp);
-      break;
-    }
-    case media::PIXEL_STORAGE_CPU:
-      frame = VideoFrame::WrapExternalSharedMemory(
-          media::PIXEL_FORMAT_I420, frame_format.frame_size,
-          gfx::Rect(frame_format.frame_size), frame_format.frame_size,
-          reinterpret_cast<uint8_t*>(buffer->data()),
-          VideoFrame::AllocationSize(media::PIXEL_FORMAT_I420,
-                                     frame_format.frame_size),
-          base::SharedMemory::NULLHandle(), 0u, timestamp);
-      break;
-  }
+  scoped_refptr<VideoFrame> frame = VideoFrame::WrapExternalSharedMemory(
+      media::PIXEL_FORMAT_I420, frame_format.frame_size,
+      gfx::Rect(frame_format.frame_size), frame_format.frame_size,
+      reinterpret_cast<uint8_t*>(buffer->data()),
+      VideoFrame::AllocationSize(media::PIXEL_FORMAT_I420,
+                                 frame_format.frame_size),
+      base::SharedMemory::NULLHandle(), 0u, timestamp);
   if (!frame)
     return;
   frame->metadata()->SetDouble(media::VideoFrameMetadata::FRAME_RATE,
                                frame_format.frame_rate);
   frame->metadata()->SetTimeTicks(media::VideoFrameMetadata::REFERENCE_TIME,
                                   reference_time);
   OnIncomingCapturedVideoFrame(std::move(buffer), frame);
 }
 
 void VideoCaptureDeviceClient::OnIncomingCapturedVideoFrame(
@@ skipping 36 matching lines @@
   return buffer_pool_->GetBufferPoolUtilization();
 }
 
 std::unique_ptr<media::VideoCaptureDevice::Client::Buffer>
 VideoCaptureDeviceClient::ReserveI420OutputBuffer(
     const gfx::Size& dimensions,
     media::VideoPixelStorage storage,
     uint8_t** y_plane_data,
     uint8_t** u_plane_data,
     uint8_t** v_plane_data) {
-  DCHECK(storage == media::PIXEL_STORAGE_GPUMEMORYBUFFER ||
-         storage == media::PIXEL_STORAGE_CPU);
+  DCHECK(storage == media::PIXEL_STORAGE_CPU);
   DCHECK(dimensions.height());
   DCHECK(dimensions.width());
 
   const media::VideoPixelFormat format = media::PIXEL_FORMAT_I420;
   std::unique_ptr<Buffer> buffer(
       ReserveOutputBuffer(dimensions, media::PIXEL_FORMAT_I420, storage));
   if (!buffer)
     return std::unique_ptr<Buffer>();
-
-  switch (storage) {
-    case media::PIXEL_STORAGE_CPU:
-      // TODO(emircan): See http://crbug.com/521068, move this pointer
-      // arithmetic inside Buffer::data() when this bug is resolved.
-      *y_plane_data = reinterpret_cast<uint8_t*>(buffer->data());
-      *u_plane_data =
-          *y_plane_data +
-          VideoFrame::PlaneSize(format, VideoFrame::kYPlane, dimensions)
-              .GetArea();
-      *v_plane_data =
-          *u_plane_data +
-          VideoFrame::PlaneSize(format, VideoFrame::kUPlane, dimensions)
-              .GetArea();
-      return buffer;
-    case media::PIXEL_STORAGE_GPUMEMORYBUFFER:
-      *y_plane_data =
-          reinterpret_cast<uint8_t*>(buffer->data(VideoFrame::kYPlane));
-      *u_plane_data =
-          reinterpret_cast<uint8_t*>(buffer->data(VideoFrame::kUPlane));
-      *v_plane_data =
-          reinterpret_cast<uint8_t*>(buffer->data(VideoFrame::kVPlane));
-      return buffer;
-  }
-  NOTREACHED();
-  return std::unique_ptr<Buffer>();
+  // TODO(emircan): See http://crbug.com/521068, move this pointer
+  // arithmetic inside Buffer::data() when this bug is resolved.
+  *y_plane_data = reinterpret_cast<uint8_t*>(buffer->data());
+  *u_plane_data =
+      *y_plane_data +
+      VideoFrame::PlaneSize(format, VideoFrame::kYPlane, dimensions).GetArea();
+  *v_plane_data =
+      *u_plane_data +
+      VideoFrame::PlaneSize(format, VideoFrame::kUPlane, dimensions).GetArea();
+  return buffer;
 }
 
 }  // namespace media