Linux Video Capture: Add V4L2VideoCaptureDelegate{Single,Multi}Plane.

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 <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"
 #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<int>& usable_fourccs =
+  const std::list<uint32_t>& usable_fourccs =
       VideoCaptureDeviceLinux::GetListOfUsableFourCCs(false);
 
   static const struct {
     int capability;
     v4l2_buf_type buf_type;
   } kCapabilityAndBufferTypes[] = {
     {V4L2_CAP_VIDEO_CAPTURE, V4L2_BUF_TYPE_VIDEO_CAPTURE},
     {V4L2_CAP_VIDEO_CAPTURE_MPLANE, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE}
   };
 
   for (const auto& capability_and_buffer_type : kCapabilityAndBufferTypes) {
     v4l2_fmtdesc fmtdesc = {};
     if (capabilities & capability_and_buffer_type.capability) {
       fmtdesc.type = capability_and_buffer_type.buf_type;
       for (; HANDLE_EINTR(ioctl(fd, VIDIOC_ENUM_FMT, &fmtdesc)) == 0;
            ++fmtdesc.index) {
         if (std::find(usable_fourccs.begin(), usable_fourccs.end(),
                       fmtdesc.pixelformat) != usable_fourccs.end())
           return true;
       }
     }
   }
+  DLOG(ERROR) << "No usable formats found";
   return false;
 }
 
 static std::list<float> GetFrameRateList(int fd,
                                          uint32 fourcc,
                                          uint32 width,
                                          uint32 height) {
   std::list<float> frame_rates;
 
   v4l2_frmivalenum frame_interval = {};
@@ skipping 114 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)) {
-      VideoCaptureDevice::Name device_name(base::StringPrintf("%s", cap.card),
-                                           unique_id);
-      device_names->push_back(device_name);
+      device_names->push_back(VideoCaptureDevice::Name(
+          base::StringPrintf("%s", cap.card), unique_id,
+          (cap.capabilities & V4L2_CAP_VIDEO_CAPTURE_MPLANE)
+              ? VideoCaptureDevice::Name::V4L2_MULTI_PLANE
+              : VideoCaptureDevice::Name::V4L2_SINGLE_PLANE));
     }
   }
 }
 
 void VideoCaptureDeviceFactoryLinux::GetDeviceSupportedFormats(
     const VideoCaptureDevice::Name& device,
     VideoCaptureFormats* supported_formats) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (device.id().empty())
     return;
   base::ScopedFD fd(HANDLE_EINTR(open(device.id().c_str(), O_RDONLY)));
   if (!fd.is_valid())  // Failed to open this device.
     return;
   supported_formats->clear();
 
-  const v4l2_buf_type kCaptureTypes[] = {V4L2_BUF_TYPE_VIDEO_CAPTURE,
-                                         V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE};
-  for (const auto& buf_type : kCaptureTypes)
-    GetSupportedFormatsForV4L2BufferType(fd.get(), buf_type, supported_formats);
+  DCHECK_NE(device.capture_api_type(),
+            VideoCaptureDevice::Name::API_TYPE_UNKNOWN);
+  const v4l2_buf_type buf_type =
+      (device.capture_api_type() == VideoCaptureDevice::Name::V4L2_MULTI_PLANE)
+          ? V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
+          : V4L2_BUF_TYPE_VIDEO_CAPTURE;
+  GetSupportedFormatsForV4L2BufferType(fd.get(), buf_type, supported_formats);
+
   return;
 }
 
 // static
 VideoCaptureDeviceFactory*
 VideoCaptureDeviceFactory::CreateVideoCaptureDeviceFactory(
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner) {
   return new VideoCaptureDeviceFactoryLinux(ui_task_runner);
 }
 
 }  // namespace media