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 and the underlying platform support
+// Dma-Buf and both have the appropriate format
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,8,0)
+bool IsDmaBufCaptureSupported(const std::string& device_fd,

[Pawel Osciak, 2015/06/15 10:34:54]

static
s/device_fd/device_name/

[mcasas, 2015/06/17 01:30:53]

Done.

+                              VideoCaptureDevice::Client* client,
+                              v4l2_buf_type buf_type) {
+  const base::ScopedFD fd(HANDLE_EINTR(open(device_fd.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)

[Pawel Osciak, 2015/06/15 10:34:55]

Unfortunately, we check if the V4L2 capturer supports dmabufs, but we don't
check whether the HW encoder does. Also, we don't know (and we can't know here)
if a HW encoder will be used at all (we wouldn't want to use dmabufs either
then).

When we have dmabuf support in uvcvideo driver (and it's actually already there
in new upstream Linux kernels), we'll get dmabuf support in the V4L2 camera
capturer on all CrOS platforms (and, well, all Linux systems with sufficiently
new kernels). But some of them won't support dmabuf in HW encoder, and some
won't have a HW encoder at all.

Please also see the comment at l.84.

[mcasas, 2015/06/17 01:30:52]

This is true, and I think just landing this code "as-is" would
break current ToT, so in parallel I'm adding a command line
flag [1] to force Dmabuf usage. This flag boils down to a
bool in VideoCaptureParams passed on OnAllocateAndStart(). 
I think this flag will allow us to land all necessary code,
and then we can, if deemed necessary, use a Finch
experiment, as a step before having the decision
fully automatised like you say in l.84.

[1] https://codereview.chromium.org/1191443003/

+    return false;
+
+  // Check if the platform supports Dma-Buf capture.
+  scoped_ptr<VideoCaptureDevice::Client::Buffer> capture_buffer =
+      client->ReserveOutputBuffer(media::PIXEL_FORMAT_GPUMEMORYBUFFER,

[Pawel Osciak, 2015/06/15 10:34:55]

This is not really a detail of V4L2 capture, so I would prefer not having this
here. I understand this is a work in progress and some
workarounds/simplifications like this could be acceptable, but in general, the
decision about the whole pipeline can't be made in the V4L2 capturer, because it
has insufficient information about the platform. This should be queried in the
client based on the information from all the devices/platform.

So with this and for the reasons in l.79 above, I'd suggest the model should be:
- we should have a common property on each type of device (capturer, GPU
renderer, HW encoder) called SUPPORTS_NATIVE_BUFFERS, or something like that;
- the above for V4L2 capturer should ideally be in VideoCaptureDeviceInfo I
think. Then the client could query it very early.
- it should be the client to query each device for this; if all support it, it
just passes a bool or enum to each device, telling it to use native buffers;

Of course, within reasonable detail, I'm ok having some shortcuts and not a
full-blown detection for all possible cases/platforms in the client, but as long
as we eliminate false positives.

[mcasas, 2015/06/17 01:30:53]

That sounds reasonable. As you can see, at the level of
this particular file, CreateV4L2CaptureDelegate() is
instructed to use DmaBufs or not. The decision is taken
somewhere else, in a more intelligent part of Chromium.
So this function is reduced to just checking if V4L2
supports DmaBuf Capture.

+                                  gfx::Size(0, 0));
+  if (capture_buffer->GetType() != gfx::OZONE_NATIVE_BUFFER)
+    return false;
+
+  // TODO(mcasas): Check |capture_buffer|'s underlying supported formats and
+  // correlate with those we support. For the time being, just continue.
+
+  // TODO(mcasas): Query VCM to see if we have failed in the past to
+  // initialize
+  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,
     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,
+#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 8, 0)
+          false
+#else
+          IsDmaBufCaptureSupported(device_name.id(), client,
+                                   V4L2_BUF_TYPE_VIDEO_CAPTURE)
+#endif
+          ));
     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 52 matching lines @@
     PLOG_IF(ERROR, result < 0) << "Error munmap()ing V4L2 buffer";
   }
 }
 
 void V4L2CaptureDelegate::BufferTracker::AddMmapedPlane(uint8_t* const start,
                                                         size_t length) {
   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.start = nullptr;

[Pawel Osciak, 2015/06/15 10:34:55]

Zero-initialization could be done in Plane::Plane().

[mcasas, 2015/06/17 01:30:52]

Done.

+  plane.length = 0u;
+  plane.payload_size = 0;
+  plane.fd = fd;
+  planes_.push_back(plane);
+}
+
 V4L2CaptureDelegate::V4L2CaptureDelegate(
     const VideoCaptureDevice::Name& device_name,
     const scoped_refptr<base::SingleThreadTaskRunner>& v4l2_task_runner,
     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),
@@ skipping 110 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;
+  FinishFillingV4L2RequestBuffers(&r_buffer);

[Pawel Osciak, 2015/06/15 10:34:55]

I'd suggest just r_buffer.memory = memory(); if we do the getter.

[mcasas, 2015/06/17 01:30:53]

Done.

   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;
+  FinishFillingV4L2RequestBuffers(&r_buffer);
   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);
+  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