Add support for multiple V4L2 video devices of the same type.

media/gpu/v4l2_image_processor.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 <errno.h>
 #include <fcntl.h>
 #include <linux/videodev2.h>
 #include <poll.h>
 #include <string.h>
 #include <sys/eventfd.h>
@@ skipping 117 matching lines @@
     return false;
   }
 
   input_memory_type_ = input_memory_type;
   output_memory_type_ = output_memory_type;
   input_visible_size_ = input_visible_size;
   input_allocated_size_ = input_allocated_size;
   output_visible_size_ = output_visible_size;
   output_allocated_size_ = output_allocated_size;
 
+  if (!device_->Open(V4L2Device::Type::kImageProcessor, input_format_fourcc_)) {
+    LOG(ERROR) << "Failed to open device for input format: "
+               << VideoPixelFormatToString(input_format)
+               << " fourcc: " << std::hex << input_format_fourcc_;

[kcwu, 2016/10/07 11:19:05]

0x

[Pawel Osciak, 2016/10/11 06:13:46]

Done.

+    return false;
+  }
+
   // Capabilities check.
   struct v4l2_capability caps;
   memset(&caps, 0, sizeof(caps));
   const __u32 kCapsRequired = V4L2_CAP_VIDEO_M2M_MPLANE | V4L2_CAP_STREAMING;
   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_QUERYCAP, &caps);
   if ((caps.capabilities & kCapsRequired) != kCapsRequired) {
     LOG(ERROR) << "Initialize(): ioctl() failed: VIDIOC_QUERYCAP: "
                << "caps check failed: 0x" << std::hex << caps.capabilities;
     return false;
   }
@@ skipping 26 matching lines @@
 
 std::vector<base::ScopedFD> V4L2ImageProcessor::GetDmabufsForOutputBuffer(
     int output_buffer_index) {
   DCHECK_GE(output_buffer_index, 0);
   DCHECK_LT(output_buffer_index, num_buffers_);
   return device_->GetDmabufsForV4L2Buffer(output_buffer_index,
                                           output_planes_count_,
                                           V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
 }
 
-std::vector<uint32_t> V4L2ImageProcessor::GetSupportedInputFormats() {
-  std::vector<uint32_t> input_formats;
-  v4l2_fmtdesc fmtdesc;
-  memset(&fmtdesc, 0, sizeof(fmtdesc));
-  fmtdesc.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
-  for (; device_->Ioctl(VIDIOC_ENUM_FMT, &fmtdesc) == 0; ++fmtdesc.index) {
-    input_formats.push_back(fmtdesc.pixelformat);
-  }
-  return input_formats;
+// static
+bool V4L2ImageProcessor::IsSupported() {
+  scoped_refptr<V4L2Device> device = V4L2Device::Create();
+  if (!device)
+    return false;
+
+  return device->IsImageProcessingSupported();
 }
 
-std::vector<uint32_t> V4L2ImageProcessor::GetSupportedOutputFormats() {
-  std::vector<uint32_t> output_formats;
-  v4l2_fmtdesc fmtdesc;
-  memset(&fmtdesc, 0, sizeof(fmtdesc));
-  fmtdesc.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
-  for (; device_->Ioctl(VIDIOC_ENUM_FMT, &fmtdesc) == 0; ++fmtdesc.index) {
-    output_formats.push_back(fmtdesc.pixelformat);
-  }
-  return output_formats;
+// static
+std::vector<uint32_t> V4L2ImageProcessor::GetSupportedInputFormats() {
+  scoped_refptr<V4L2Device> device = V4L2Device::Create();
+  if (!device)
+    return std::vector<uint32_t>();
+
+  return device->GetSupportedImageProcessorPixelformats(
+      V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE);
 }
 
-bool V4L2ImageProcessor::TryOutputFormat(uint32_t pixelformat,
+// static
+std::vector<uint32_t> V4L2ImageProcessor::GetSupportedOutputFormats() {
+  scoped_refptr<V4L2Device> device = V4L2Device::Create();
+  if (!device)
+    return std::vector<uint32_t>();
+
+  return device->GetSupportedImageProcessorPixelformats(
+      V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
+}
+
+// static
+bool V4L2ImageProcessor::TryOutputFormat(uint32_t input_pixelformat,
+                                         uint32_t output_pixelformat,
                                          gfx::Size* size,
                                          size_t* num_planes) {
   DVLOG(1) << __func__ << ": size=" << size->ToString();
+  scoped_refptr<V4L2Device> device = V4L2Device::Create();
+  if (!device ||
+      !device->Open(V4L2Device::Type::kImageProcessor, input_pixelformat))
+    return false;
+
   struct v4l2_format format;
   memset(&format, 0, sizeof(format));
   format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
   format.fmt.pix_mp.width = size->width();
   format.fmt.pix_mp.height = size->height();
-  format.fmt.pix_mp.pixelformat = pixelformat;
-  IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_TRY_FMT, &format);
+  format.fmt.pix_mp.pixelformat = output_pixelformat;
+  if (device->Ioctl(VIDIOC_TRY_FMT, &format) != 0)
+    return false;
 
   *num_planes = format.fmt.pix_mp.num_planes;
   *size = V4L2Device::CodedSizeFromV4L2Format(format);
   DVLOG(1) << __func__ << ": adjusted output coded size=" << size->ToString()
            << ", num_planes=" << *num_planes;
   return true;
 }
 
 bool V4L2ImageProcessor::Process(const scoped_refptr<VideoFrame>& frame,
                                  int output_buffer_index,
@@ skipping 528 matching lines @@
   output_buffer_queued_count_ = 0;
 }
 
 void V4L2ImageProcessor::FrameReady(const FrameReadyCB& cb,
                                     int output_buffer_index) {
   DCHECK(child_task_runner_->BelongsToCurrentThread());
   cb.Run(output_buffer_index);
 }
 
 }  // namespace media