VideoCaptureDeviceLinux: Add support for SPLANE+DMABUF V4L2 type capture

media/video/capture/linux/v4l2_capture_delegate.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.h"
 
+#include <linux/version.h>
 #include <poll.h>
 #include <sys/fcntl.h>
 #include <sys/ioctl.h>
 #include <sys/mman.h>
 
 #include "base/bind.h"
 #include "base/files/file_enumerator.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/strings/stringprintf.h"
 #include "media/base/bind_to_current_loop.h"
@@ skipping 36 matching lines @@
   // MJPEG is usually sitting fairly low since we don't want to have to decode.
   // However, is needed for large resolutions due to USB bandwidth limitations,
   // so GetListOfUsableFourCcs() can duplicate it on top, see that method.
   {V4L2_PIX_FMT_MJPEG, PIXEL_FORMAT_MJPEG, 1},
   // JPEG works as MJPEG on some gspca webcams from field reports, see
   // https://code.google.com/p/webrtc/issues/detail?id=529, put it as the least
   // preferred format.
   {V4L2_PIX_FMT_JPEG, PIXEL_FORMAT_MJPEG, 1},
 };
 
+// This function investigates if the driver supports Dma-Buf. Such capacity is
+// not present in non-Ozone platforms nor for certain kernel versions.
+static bool IsDmaBufCaptureSupported(const std::string& device_name,
+                                     v4l2_buf_type buf_type) {
+#if LINUX_VERSION_CODE < KERNEL_VERSION(3,8,0) || !defined(USE_OZONE)
+  return false;
+#else
+  const base::ScopedFD fd(HANDLE_EINTR(open(device_name.c_str(), O_RDONLY)));
+  if (!fd.is_valid()) {
+    return false;
+  }
+  // Check if the V4L2 device supports Dma Buf capture.
+  v4l2_requestbuffers r_buffer = {};
+  r_buffer.type = buf_type;
+  r_buffer.memory = V4L2_MEMORY_DMABUF;
+  r_buffer.count = 1u;
+  if (HANDLE_EINTR(ioctl(fd.get(), VIDIOC_REQBUFS, &r_buffer)) < 0)
+    return false;
+  return true;
+#endif
+}
+
 // static
 scoped_refptr<V4L2CaptureDelegate>
 V4L2CaptureDelegate::CreateV4L2CaptureDelegate(
     const VideoCaptureDevice::Name& device_name,
     const scoped_refptr<base::SingleThreadTaskRunner>& v4l2_task_runner,
+    VideoCaptureDevice::Client* client,
+    bool allow_using_dma_bufs,
     int power_line_frequency) {
   switch (device_name.capture_api_type()) {
     case VideoCaptureDevice::Name::V4L2_SINGLE_PLANE:
       return make_scoped_refptr(new V4L2CaptureDelegateSinglePlane(
-          device_name, v4l2_task_runner, power_line_frequency));
+          device_name, v4l2_task_runner,
+          power_line_frequency,
+          allow_using_dma_bufs &&
+              IsDmaBufCaptureSupported(device_name.id(),
+                                       V4L2_BUF_TYPE_VIDEO_CAPTURE)));
     case VideoCaptureDevice::Name::V4L2_MULTI_PLANE:
 #if !defined(OS_OPENBSD)
       return make_scoped_refptr(new V4L2CaptureDelegateMultiPlane(
           device_name, v4l2_task_runner, power_line_frequency));
     default:
 #endif
       NOTIMPLEMENTED() << "Unknown V4L2 capture API type";
       return scoped_refptr<V4L2CaptureDelegate>();
   }
 }
@@ skipping 48 matching lines @@
   for (const auto& plane : planes_) {
     if (plane.start == nullptr)
       continue;
     const int result = munmap(plane.start, plane.length);
     PLOG_IF(ERROR, result < 0) << "Error munmap()ing V4L2 buffer";
   }
 }
 
 void V4L2CaptureDelegate::BufferTracker::AddMmapedPlane(uint8_t* const start,
                                                         size_t length) {
-  Plane plane;
+  Plane plane = {};
   plane.start = start;
   plane.length = length;
   plane.payload_size = 0;
+  plane.fd = -1;
+  planes_.push_back(plane);
+}
+
+void V4L2CaptureDelegate::BufferTracker::AddNonMmapedPlane(int fd) {
+  Plane plane = {};
+  plane.fd = fd;
   planes_.push_back(plane);
 }
 
 V4L2CaptureDelegate::V4L2CaptureDelegate(
     const VideoCaptureDevice::Name& device_name,
     const scoped_refptr<base::SingleThreadTaskRunner>& v4l2_task_runner,
+    v4l2_memory memory_type,
     int power_line_frequency)
     : capture_type_((device_name.capture_api_type() ==
                      VideoCaptureDevice::Name::V4L2_SINGLE_PLANE)
                         ? V4L2_BUF_TYPE_VIDEO_CAPTURE
                         : V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE),
       v4l2_task_runner_(v4l2_task_runner),
       device_name_(device_name),
       power_line_frequency_(power_line_frequency),
+      memory_type_(memory_type),
       is_capturing_(false),
       timeout_count_(0),
       rotation_(0) {
 }
 
 V4L2CaptureDelegate::~V4L2CaptureDelegate() {
 }
 
 void V4L2CaptureDelegate::AllocateAndStart(
     int width,
@@ skipping 99 matching lines @@
       DVLOG(1) << "Error setting power line frequency removal";
   }
 
   capture_format_.frame_size.SetSize(video_fmt_.fmt.pix.width,
                                      video_fmt_.fmt.pix.height);
   capture_format_.frame_rate = frame_rate;
   capture_format_.pixel_format = pixel_format;
 
   v4l2_requestbuffers r_buffer = {};
   r_buffer.type = capture_type_;
-  r_buffer.memory = V4L2_MEMORY_MMAP;
   r_buffer.count = kNumVideoBuffers;
+  r_buffer.memory = memory_type();
   if (HANDLE_EINTR(ioctl(device_fd_.get(), VIDIOC_REQBUFS, &r_buffer)) < 0) {
-    SetErrorState("Error requesting MMAP buffers from V4L2");
+    SetErrorState("Error requesting buffers from V4L2");
     return;
   }
   for (unsigned int i = 0; i < r_buffer.count; ++i) {
     if (!MapAndQueueBuffer(i)) {
       SetErrorState("Allocate buffer failed");
       return;
     }
   }
 
   if (HANDLE_EINTR(ioctl(device_fd_.get(), VIDIOC_STREAMON, &capture_type_))
@@ skipping 15 matching lines @@
   if (HANDLE_EINTR(ioctl(device_fd_.get(), VIDIOC_STREAMOFF, &capture_type_))
       < 0) {
     SetErrorState("VIDIOC_STREAMOFF failed");
     return;
   }
 
   buffer_tracker_pool_.clear();
 
   v4l2_requestbuffers r_buffer = {};
   r_buffer.type = capture_type_;
-  r_buffer.memory = V4L2_MEMORY_MMAP;
   r_buffer.count = 0;
+  r_buffer.memory = memory_type();
   if (HANDLE_EINTR(ioctl(device_fd_.get(), VIDIOC_REQBUFS, &r_buffer)) < 0)
     SetErrorState("Failed to VIDIOC_REQBUFS with count = 0");
 
   // At this point we can close the device.
   // This is also needed for correctly changing settings later via VIDIOC_S_FMT.
   device_fd_.reset();
   is_capturing_ = false;
   client_.reset();
 }
 
 void V4L2CaptureDelegate::SetRotation(int rotation) {
   DCHECK(v4l2_task_runner_->BelongsToCurrentThread());
   DCHECK(rotation >= 0 && rotation < 360 && rotation % 90 == 0);
   rotation_ = rotation;
 }
 
 bool V4L2CaptureDelegate::MapAndQueueBuffer(int index) {
   v4l2_buffer buffer;
-  FillV4L2Buffer(&buffer, index);
+  FillV4L2Buffer(&buffer, index, true  /* for_enqueue */);
 
   if (HANDLE_EINTR(ioctl(device_fd_.get(), VIDIOC_QUERYBUF, &buffer)) < 0) {
     DLOG(ERROR) << "Error querying status of a MMAP V4L2 buffer";
     return false;
   }
 
   const scoped_refptr<BufferTracker>& buffer_tracker = CreateBufferTracker();
   if (!buffer_tracker->Init(device_fd_.get(), buffer)) {
     DLOG(ERROR) << "Error creating BufferTracker";
     return false;
   }
   buffer_tracker_pool_.push_back(buffer_tracker);
 
   // Enqueue the buffer in the drivers incoming queue.
   if (HANDLE_EINTR(ioctl(device_fd_.get(), VIDIOC_QBUF, &buffer)) < 0) {
     DLOG(ERROR) << "Error enqueuing a V4L2 buffer back into the driver";
     return false;
   }
   return true;
 }
 
 void V4L2CaptureDelegate::FillV4L2Buffer(v4l2_buffer* buffer,
-                                         int i) const {
+                                         int i,
+                                         bool for_enqueue) const {
   memset(buffer, 0, sizeof(*buffer));
-  buffer->memory = V4L2_MEMORY_MMAP;
   buffer->index = i;
-  FinishFillingV4L2Buffer(buffer);
+  buffer->memory = memory_type();
+  FinishFillingV4L2Buffer(buffer, for_enqueue);
 }
 
 void V4L2CaptureDelegate::DoCapture() {
   DCHECK(v4l2_task_runner_->BelongsToCurrentThread());
   if (!is_capturing_)
     return;
 
   pollfd device_pfd = {};
   device_pfd.fd = device_fd_.get();
   device_pfd.events = POLLIN;
@@ skipping 11 matching lines @@
       timeout_count_ = 0;
       return;
     }
   } else {
     timeout_count_ = 0;
   }
 
   // Deenqueue, send and reenqueue a buffer if the driver has filled one in.
   if (device_pfd.revents & POLLIN) {
     v4l2_buffer buffer;
-    FillV4L2Buffer(&buffer, 0);
+    FillV4L2Buffer(&buffer, 0, false  /* for_enqueue */);
 
     if (HANDLE_EINTR(ioctl(device_fd_.get(), VIDIOC_DQBUF, &buffer)) < 0) {
       SetErrorState("Failed to dequeue capture buffer");
       return;
     }
 
     SetPayloadSize(buffer_tracker_pool_[buffer.index], buffer);
     SendBuffer(buffer_tracker_pool_[buffer.index], video_fmt_);
 
     if (HANDLE_EINTR(ioctl(device_fd_.get(), VIDIOC_QBUF, &buffer)) < 0) {
       SetErrorState("Failed to enqueue capture buffer");
       return;
     }
   }
 
   v4l2_task_runner_->PostTask(
       FROM_HERE, base::Bind(&V4L2CaptureDelegate::DoCapture, this));
 }
 
 void V4L2CaptureDelegate::SetErrorState(const std::string& reason) {
   DCHECK(v4l2_task_runner_->BelongsToCurrentThread());
   is_capturing_ = false;
   client_->OnError(reason);
 }
 
 }  // namespace media