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

media/gpu/v4l2_video_encode_accelerator.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/gpu/v4l2_video_encode_accelerator.h"
 
 #include <fcntl.h>
 #include <linux/videodev2.h>
 #include <poll.h>
 #include <string.h>
@@ skipping 135 matching lines @@
            << ", initial_bitrate=" << initial_bitrate;
 
   visible_size_ = input_visible_size;
 
   client_ptr_factory_.reset(new base::WeakPtrFactory<Client>(client));
   client_ = client_ptr_factory_->GetWeakPtr();
 
   DCHECK(child_task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(encoder_state_, kUninitialized);
 
+  output_format_fourcc_ =
+      V4L2Device::VideoCodecProfileToV4L2PixFmt(output_profile, false);
+  if (!output_format_fourcc_) {
+    LOG(ERROR) << "Initialize(): invalid output_profile="
+               << GetProfileName(output_profile);
+    return false;
+  }
+
+  if (!device_->Open(V4L2Device::Type::kEncoder, output_format_fourcc_)) {
+    DVLOG(1) << "Failed to open device for profile="
+             << GetProfileName(output_profile) << ", fourcc=0x" << std::hex
+             << output_format_fourcc_;
+    return false;
+  }
+
   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;
   }
 
   if (!SetFormats(input_format, output_profile)) {
     DLOG(ERROR) << "Failed setting up formats";
     return false;
   }
 
   if (input_format != device_input_format_) {
-    DVLOG(1) << "Input format not supported by the HW, will convert to "
+    DVLOG(1) << "Input format not supported by the HW, will try to convert to "
              << VideoPixelFormatToString(device_input_format_);
 
-    scoped_refptr<V4L2Device> device =
-        V4L2Device::Create(V4L2Device::kImageProcessor);
+    if (!V4L2ImageProcessor::IsSupported()) {
+      DVLOG(1) << "Image processor not available";
+      return false;
+    }
+
+    scoped_refptr<V4L2Device> device = V4L2Device::Create();
     image_processor_.reset(new V4L2ImageProcessor(device));
 
     // Convert from input_format to device_input_format_, keeping the size
     // at visible_size_ and requiring the output buffers to be of at least
     // input_allocated_size_. Unretained is safe because |this| owns image
     // processor and there will be no callbacks after processor destroys.
     if (!image_processor_->Initialize(
             input_format, device_input_format_, V4L2_MEMORY_USERPTR,
             V4L2_MEMORY_MMAP, visible_size_, visible_size_, visible_size_,
             input_allocated_size_, kImageProcBufferCount,
@@ skipping 155 matching lines @@
   }
 
   // Set to kError state just in case.
   encoder_state_ = kError;
 
   delete this;
 }
 
 VideoEncodeAccelerator::SupportedProfiles
 V4L2VideoEncodeAccelerator::GetSupportedProfiles() {
-  SupportedProfiles profiles;
-  SupportedProfile profile;
-  profile.max_framerate_numerator = 30;
-  profile.max_framerate_denominator = 1;
+  scoped_refptr<V4L2Device> device = V4L2Device::Create();
+  if (!device)
+    return SupportedProfiles();
 
-  gfx::Size min_resolution;
-  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) {
-    device_->GetSupportedResolution(fmtdesc.pixelformat, &min_resolution,
-                                    &profile.max_resolution);
-    switch (fmtdesc.pixelformat) {
-      case V4L2_PIX_FMT_H264:
-        profile.profile = H264PROFILE_MAIN;
-        profiles.push_back(profile);
-        break;
-      case V4L2_PIX_FMT_VP8:
-        profile.profile = VP8PROFILE_ANY;
-        profiles.push_back(profile);
-        break;
-      case V4L2_PIX_FMT_VP9:
-        profile.profile = VP9PROFILE_PROFILE0;
-        profiles.push_back(profile);
-        profile.profile = VP9PROFILE_PROFILE1;
-        profiles.push_back(profile);
-        profile.profile = VP9PROFILE_PROFILE2;
-        profiles.push_back(profile);
-        profile.profile = VP9PROFILE_PROFILE3;
-        profiles.push_back(profile);
-        break;
-    }
-  }
-
-  return profiles;
+  return device->GetSupportedEncodeProfiles();
 }
 
 void V4L2VideoEncodeAccelerator::FrameProcessed(bool force_keyframe,
                                                 base::TimeDelta timestamp,
                                                 int output_buffer_index) {
   DCHECK(child_task_runner_->BelongsToCurrentThread());
   DVLOG(3) << "FrameProcessed(): force_keyframe=" << force_keyframe
            << ", output_buffer_index=" << output_buffer_index;
   DCHECK_GE(output_buffer_index, 0);
   DCHECK_LT(static_cast<size_t>(output_buffer_index),
@@ skipping 587 matching lines @@
   parms.parm.output.timeperframe.denominator = framerate;
   IOCTL_OR_ERROR_RETURN(VIDIOC_S_PARM, &parms);
 }
 
 bool V4L2VideoEncodeAccelerator::SetOutputFormat(
     VideoCodecProfile output_profile) {
   DCHECK(child_task_runner_->BelongsToCurrentThread());
   DCHECK(!input_streamon_);
   DCHECK(!output_streamon_);
 
-  output_format_fourcc_ =
-      V4L2Device::VideoCodecProfileToV4L2PixFmt(output_profile, false);
-  if (!output_format_fourcc_) {
-    LOG(ERROR) << "Initialize(): invalid output_profile=" << output_profile;
-    return false;
-  }
-
   output_buffer_byte_size_ = kOutputBufferSize;
 
   struct v4l2_format format;
   memset(&format, 0, sizeof(format));
   format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
   format.fmt.pix_mp.width = visible_size_.width();
   format.fmt.pix_mp.height = visible_size_.height();
   format.fmt.pix_mp.pixelformat = output_format_fourcc_;
   format.fmt.pix_mp.plane_fmt[0].sizeimage =
       base::checked_cast<__u32>(output_buffer_byte_size_);
@@ skipping 31 matching lines @@
   // First see if we the device can use the provided input_format directly.
   struct v4l2_format format;
   memset(&format, 0, sizeof(format));
   format.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
   format.fmt.pix_mp.width = visible_size_.width();
   format.fmt.pix_mp.height = visible_size_.height();
   format.fmt.pix_mp.pixelformat = input_format_fourcc;
   format.fmt.pix_mp.num_planes = input_planes_count;
   if (device_->Ioctl(VIDIOC_S_FMT, &format) != 0) {
     // Error or format unsupported by device, try to negotiate a fallback.
-    input_format_fourcc = device_->PreferredInputFormat();
+    input_format_fourcc =
+        device_->PreferredInputFormat(V4L2Device::Type::kEncoder);
     input_format =
         V4L2Device::V4L2PixFmtToVideoPixelFormat(input_format_fourcc);
     if (input_format == PIXEL_FORMAT_UNKNOWN) {
       LOG(ERROR) << "Unsupported input format" << input_format_fourcc;
       return false;
     }
 
     input_planes_count = VideoFrame::NumPlanes(input_format);
     DCHECK_LE(input_planes_count, static_cast<size_t>(VIDEO_MAX_PLANES));
 
@@ skipping 245 matching lines @@
   }
 
   return true;
 }
 
 void V4L2VideoEncodeAccelerator::DestroyInputBuffers() {
   DVLOG(3) << "DestroyInputBuffers()";
   DCHECK(child_task_runner_->BelongsToCurrentThread());
   DCHECK(!input_streamon_);
 
+  free_input_buffers_.clear();
+
+  if (input_buffer_map_.empty())
+    return;
+
   struct v4l2_requestbuffers reqbufs;
   memset(&reqbufs, 0, sizeof(reqbufs));
   reqbufs.count = 0;
   reqbufs.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
   reqbufs.memory = input_memory_type_;
   IOCTL_OR_LOG_ERROR(VIDIOC_REQBUFS, &reqbufs);
 
   input_buffer_map_.clear();
-  free_input_buffers_.clear();
 }
 
 void V4L2VideoEncodeAccelerator::DestroyOutputBuffers() {
   DVLOG(3) << "DestroyOutputBuffers()";
   DCHECK(child_task_runner_->BelongsToCurrentThread());
   DCHECK(!output_streamon_);
 
+  free_output_buffers_.clear();
+
+  if (output_buffer_map_.empty())
+    return;
+
   for (size_t i = 0; i < output_buffer_map_.size(); ++i) {
     if (output_buffer_map_[i].address != NULL)
       device_->Munmap(output_buffer_map_[i].address,
                       output_buffer_map_[i].length);
   }
 
   struct v4l2_requestbuffers reqbufs;
   memset(&reqbufs, 0, sizeof(reqbufs));
   reqbufs.count = 0;
   reqbufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
   reqbufs.memory = V4L2_MEMORY_MMAP;
   IOCTL_OR_LOG_ERROR(VIDIOC_REQBUFS, &reqbufs);
 
   output_buffer_map_.clear();
-  free_output_buffers_.clear();
 }
 
 }  // namespace media