Remove V4L2CaptureDelegate{Single,Multi}Plane, VCD::Client::OnIncomingCapturedYuvData()

media/capture/video/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/capture/video/linux/video_capture_device_factory_linux.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <stdint.h>
 #include <sys/ioctl.h>
@@ skipping 10 matching lines @@
 #endif
 
 #if defined(OS_CHROMEOS)
 #include "media/capture/video/linux/video_capture_device_chromeos.h"
 #endif
 #include "media/capture/video/linux/video_capture_device_linux.h"
 
 namespace media {
 
 static bool HasUsableFormats(int fd, uint32_t capabilities) {
+  if (!(capabilities & V4L2_CAP_VIDEO_CAPTURE))
+    return false;
+
   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;
-      }
+  v4l2_fmtdesc fmtdesc = {};
+  fmtdesc.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+  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_t fourcc,
                                          uint32_t width,
                                          uint32_t height) {
   std::list<float> frame_rates;
 
@@ skipping 19 matching lines @@
   }
   // Some devices, e.g. Kinect, do not enumerate any frame rates, see
   // http://crbug.com/412284. Set their frame_rate to zero.
   if (frame_rates.empty())
     frame_rates.push_back(0);
   return frame_rates;
 }
 
 static void GetSupportedFormatsForV4L2BufferType(
     int fd,
-    v4l2_buf_type buf_type,
     media::VideoCaptureFormats* supported_formats) {
   v4l2_fmtdesc v4l2_format = {};
-  v4l2_format.type = buf_type;
+  v4l2_format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
   for (; HANDLE_EINTR(ioctl(fd, VIDIOC_ENUM_FMT, &v4l2_format)) == 0;
        ++v4l2_format.index) {
     VideoCaptureFormat supported_format;
     supported_format.pixel_format =
         VideoCaptureDeviceLinux::V4l2FourCcToChromiumPixelFormat(
             v4l2_format.pixelformat);
 
     if (supported_format.pixel_format == PIXEL_FORMAT_UNKNOWN)
       continue;
 
@@ skipping 69 matching lines @@
     if (!fd.is_valid()) {
       DLOG(ERROR) << "Couldn't open " << info.GetName().value();
       continue;
     }
     // Test if this is a V4L2 capture device and if it has at least one
     // 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)) &&
+        (cap.capabilities & V4L2_CAP_VIDEO_CAPTURE &&
+         !(cap.capabilities & V4L2_CAP_VIDEO_OUTPUT)) &&
         HasUsableFormats(fd.get(), cap.capabilities)) {
       device_names->push_back(VideoCaptureDevice::Name(
           reinterpret_cast<char*>(cap.card), unique_id,
-          (cap.capabilities & V4L2_CAP_VIDEO_CAPTURE_MPLANE)
-              ? VideoCaptureDevice::Name::V4L2_MULTI_PLANE
-              : VideoCaptureDevice::Name::V4L2_SINGLE_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();
 
   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;
+  GetSupportedFormatsForV4L2BufferType(fd.get(), supported_formats);
 }
 
 // static
 VideoCaptureDeviceFactory*
 VideoCaptureDeviceFactory::CreateVideoCaptureDeviceFactory(
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner) {
   return new VideoCaptureDeviceFactoryLinux(ui_task_runner);
 }
 
 }  // namespace media