VideoCaptureDeviceLinux: Add support for SPLANE+DMABUF V4L2 type capture

media/video/capture/linux/video_capture_device_factory_linux.cc

 // Copyright 2014 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/video_capture_device_factory_linux.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #if defined(OS_OPENBSD)
 #include <sys/videoio.h>
 #else
 #include <linux/videodev2.h>
 #endif
+#include <linux/version.h>
 #include <sys/ioctl.h>
 
 #include "base/files/file_enumerator.h"
 #include "base/files/scoped_file.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/strings/stringprintf.h"
+//#include "content/common/gpu/gpu_memory_buffer_factory.h"

[emircan, 2015/05/06 03:06:26]

Can be erased.

[mcasas, 2015/05/06 21:44:42]

Done.

 #if defined(OS_CHROMEOS)
 #include "media/video/capture/linux/video_capture_device_chromeos.h"
 #endif
 #include "media/video/capture/linux/video_capture_device_linux.h"
 
 namespace media {
 
 static bool HasUsableFormats(int fd, uint32 capabilities) {
   const std::list<uint32_t>& usable_fourccs =
       VideoCaptureDeviceLinux::GetListOfUsableFourCCs(false);
@@ skipping 146 matching lines @@
     // supported capture format. Devices that have capture and output
     // capabilities at the same time are memory-to-memory and are skipped, see
     // http://crbug.com/139356.
     v4l2_capability cap;
     if ((HANDLE_EINTR(ioctl(fd.get(), VIDIOC_QUERYCAP, &cap)) == 0) &&
         ((cap.capabilities & V4L2_CAP_VIDEO_CAPTURE ||
          cap.capabilities & V4L2_CAP_VIDEO_CAPTURE_MPLANE) &&
          !(cap.capabilities & V4L2_CAP_VIDEO_OUTPUT) &&
          !(cap.capabilities & V4L2_CAP_VIDEO_OUTPUT_MPLANE)) &&
         HasUsableFormats(fd.get(), cap.capabilities)) {
-      device_names->push_back(VideoCaptureDevice::Name(
-          base::StringPrintf("%s", cap.card), unique_id,
+      VideoCaptureDevice::Name::CaptureApiType api_type =
           (cap.capabilities & V4L2_CAP_VIDEO_CAPTURE_MPLANE)
               ? VideoCaptureDevice::Name::V4L2_MULTI_PLANE
-              : VideoCaptureDevice::Name::V4L2_SINGLE_PLANE));
+              : VideoCaptureDevice::Name::V4L2_SINGLE_PLANE;
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,8,0)
+      // For SPLANE API, check if we support Dma-Buf based capture.
+      if (api_type == VideoCaptureDevice::Name::V4L2_SINGLE_PLANE) {
+        v4l2_requestbuffers r_buffer = {};
+        r_buffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+        r_buffer.memory = V4L2_MEMORY_DMABUF;
+        r_buffer.count = 1u;
+        if (HANDLE_EINTR(ioctl(fd.get(), VIDIOC_REQBUFS, &r_buffer)) >= 0)
+          api_type = VideoCaptureDevice::Name::V4L2_SINGLE_PLANE_DMABUF;
+      }

[emircan, 2015/05/06 03:06:26]

I think, we should also check if the usable "fourcc formats" returned by the
device, corresponds to the configurations supported by Gpu Memory Buffer
abstraction. 
https://code.google.com/p/chromium/codesearch#chromium/src/content/common/gpu...

[mcasas, 2015/05/06 21:44:42]

We still need to figure out indeed where to check
that the platform (not the V4L2) provides what we 
need, but my gut feeling is that it should go into 
the V4L2CaptureDelegate factory; here is all about
listing abstract capabilities.

+#endif
+      device_names->push_back(VideoCaptureDevice::Name(
+          base::StringPrintf("%s", cap.card), unique_id, api_type));
     }
   }
 }
 
 void VideoCaptureDeviceFactoryLinux::GetDeviceSupportedFormats(
     const VideoCaptureDevice::Name& device,
     VideoCaptureFormats* supported_formats) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (device.id().empty())
     return;
@@ skipping 14 matching lines @@
 }
 
 // static
 VideoCaptureDeviceFactory*
 VideoCaptureDeviceFactory::CreateVideoCaptureDeviceFactory(
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner) {
   return new VideoCaptureDeviceFactoryLinux(ui_task_runner);
 }
 
 }  // namespace media