VideoCaptureDeviceLinux: Add support for SPLANE+DMABUF V4L2 type capture

media/video/capture/linux/v4l2_capture_delegate_single_plane.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/video/capture/linux/v4l2_capture_delegate_single_plane.h"
 
+#include <linux/version.h>
 #include <sys/mman.h>
 
 namespace media {
 
+V4L2CaptureDelegateSinglePlane::V4L2CaptureDelegateSinglePlane(
+    const VideoCaptureDevice::Name& device_name,
+    const scoped_refptr<base::SingleThreadTaskRunner>& v4l2_task_runner,
+    int power_line_frequency,
+    bool allow_using_dma_bufs)
+    : V4L2CaptureDelegate(
+          device_name,
+          v4l2_task_runner,
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 8, 0)
+          allow_using_dma_bufs ? V4L2_MEMORY_DMABUF : V4L2_MEMORY_MMAP,
+#else
+          V4L2_MEMORY_MMAP,
+#endif
+          power_line_frequency) {
+}
+
+V4L2CaptureDelegateSinglePlane::~V4L2CaptureDelegateSinglePlane() {
+}
+
 scoped_refptr<V4L2CaptureDelegate::BufferTracker>
 V4L2CaptureDelegateSinglePlane::CreateBufferTracker() const {
   return make_scoped_refptr(new BufferTrackerSPlane());
 }
 
 bool V4L2CaptureDelegateSinglePlane::FillV4L2Format(
     v4l2_format* format,
     uint32_t width,
     uint32_t height,
     uint32_t pixelformat_fourcc) const {
   format->fmt.pix.width = width;
   format->fmt.pix.height = height;
   format->fmt.pix.pixelformat = pixelformat_fourcc;
   return true;
 }
 
 void V4L2CaptureDelegateSinglePlane::FinishFillingV4L2Buffer(
-    v4l2_buffer* buffer) const {
+    v4l2_buffer* buffer,
+    bool for_enqueue) const {
   buffer->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 8, 0)
+  if (memory_type() == V4L2_MEMORY_MMAP)
+    return;
+
+  if (!for_enqueue) {
+    DCHECK_NE(buffer->m.fd, -1);  // API should have filled |fd| in for dequeue.
+    return;
+  }
+  // For enqueueing, need to reserve an output buffer, keep it locally and pass
+  // its |fd| into the V4L2 API.
+  scoped_ptr<VideoCaptureDevice::Client::Buffer> capture_buffer =
+      client()->ReserveOutputBuffer(media::PIXEL_FORMAT_GPUMEMORYBUFFER,
+                                    capture_format().frame_size);
+  if (!capture_buffer)
+    return;
+
+  DCHECK_EQ(capture_buffer->GetType(), gfx::OZONE_NATIVE_BUFFER);
+  buffer->m.fd = capture_buffer->AsPlatformFile();
+
+  allocated_buffers_.push_back(capture_buffer.release());
+  DVLOG(1) << "Sizeof allocated_buffers_ " << allocated_buffers_.size();
+#endif
 }
 
 void V4L2CaptureDelegateSinglePlane::SetPayloadSize(
     const scoped_refptr<BufferTracker>& buffer_tracker,
     const v4l2_buffer& buffer) const {
   buffer_tracker->SetPlanePayloadSize(0, buffer.bytesused);
 }
 
 void V4L2CaptureDelegateSinglePlane::SendBuffer(
     const scoped_refptr<BufferTracker>& buffer_tracker,
     const v4l2_format& format) const {
-  client()->OnIncomingCapturedData(
-      buffer_tracker->GetPlaneStart(0),
-      buffer_tracker->GetPlanePayloadSize(0),
-      capture_format(),
-      rotation(),
-      base::TimeTicks::Now());
+  DVLOG(1) << __FUNCTION__;
+
+  if (memory_type() == V4L2_MEMORY_MMAP) {
+    const size_t data_length = format.fmt.pix.sizeimage;
+    DCHECK_GE(data_length, capture_format().ImageAllocationSize());
+    client()->OnIncomingCapturedData(
+        buffer_tracker->GetPlaneStart(0),
+        buffer_tracker->GetPlanePayloadSize(0),
+        capture_format(),
+        rotation(),
+        base::TimeTicks::Now());
+    return;
+  }
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 8, 0)
+  // Search for the |fd| used for capture in |allocated_buffers_| and send it
+  // to client().
+  const int incoming_fd = buffer_tracker->GetPlaneFd(0);
+  ScopedVector<VideoCaptureDevice::Client::Buffer>::iterator used_buffer =
+      std::find_if(allocated_buffers_.begin(), allocated_buffers_.end(),
+                   [incoming_fd](VideoCaptureDevice::Client::Buffer* b) {
+                     return incoming_fd == b->AsPlatformFile();
+                   });
+  CHECK(used_buffer != allocated_buffers_.end())
+      << "Uh oh, captured |fd| is not found in the list :?";
+  client()->OnIncomingCapturedBuffer(make_scoped_ptr(*used_buffer),
+                                     capture_format(), base::TimeTicks::Now());
+  allocated_buffers_.weak_erase(used_buffer);
+#endif
 }
 
 bool V4L2CaptureDelegateSinglePlane::BufferTrackerSPlane::Init(
     int fd,
     const v4l2_buffer& buffer) {
+  DVLOG(1) << __FUNCTION__;
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 8, 0)
+  if (buffer.memory == V4L2_MEMORY_DMABUF) {
+    AddNonMmapedPlane(buffer.m.fd);
+    return true;
+  }
+#endif
+
   // Some devices require mmap() to be called with both READ and WRITE.
   // See http://crbug.com/178582.
   void* const start = mmap(NULL, buffer.length, PROT_READ | PROT_WRITE,
                            MAP_SHARED, fd, buffer.m.offset);
   if (start == MAP_FAILED) {
     DLOG(ERROR) << "Error mmap()ing a V4L2 buffer into userspace";
     return false;
   }
   AddMmapedPlane(static_cast<uint8_t*>(start), buffer.length);
   return true;
 }
 
 }  // namespace media