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

media/gpu/v4l2_jpeg_decode_accelerator.cc

 // Copyright 2015 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_jpeg_decode_accelerator.h"
 
 #include <errno.h>
 #include <linux/videodev2.h>
 #include <string.h>
 #include <sys/mman.h>
@@ skipping 169 matching lines @@
 void V4L2JpegDecodeAccelerator::PostNotifyError(int32_t bitstream_buffer_id,
                                                 Error error) {
   child_task_runner_->PostTask(
       FROM_HERE, base::Bind(&V4L2JpegDecodeAccelerator::NotifyError, weak_ptr_,
                             bitstream_buffer_id, error));
 }
 
 bool V4L2JpegDecodeAccelerator::Initialize(Client* client) {
   DCHECK(child_task_runner_->BelongsToCurrentThread());
 
+  if (!device_->Open(V4L2Device::Type::kJpegDecoder, V4L2_PIX_FMT_JPEG)) {
+    LOG(ERROR) << "Failed to open device";
+    return false;
+  }
+
   // Capabilities check.
   struct v4l2_capability caps;
   const __u32 kCapsRequired = V4L2_CAP_STREAMING | V4L2_CAP_VIDEO_M2M;
   memset(&caps, 0, sizeof(caps));
   if (device_->Ioctl(VIDIOC_QUERYCAP, &caps) != 0) {
     PLOG(ERROR) << __func__ << ": ioctl() failed: VIDIOC_QUERYCAP";
     return false;
   }
   if ((caps.capabilities & kCapsRequired) != kCapsRequired) {
     LOG(ERROR) << __func__ << ": VIDIOC_QUERYCAP, caps check failed: 0x"
@@ skipping 46 matching lines @@
   }
 
   std::unique_ptr<JobRecord> job_record(
       new JobRecord(bitstream_buffer, video_frame));
 
   decoder_task_runner_->PostTask(
       FROM_HERE, base::Bind(&V4L2JpegDecodeAccelerator::DecodeTask,
                             base::Unretained(this), base::Passed(&job_record)));
 }
 
+// static
 bool V4L2JpegDecodeAccelerator::IsSupported() {
-  v4l2_fmtdesc fmtdesc;
-  memset(&fmtdesc, 0, sizeof(fmtdesc));
-  fmtdesc.type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
+  scoped_refptr<V4L2Device> device = V4L2Device::Create();
+  if (!device)
+    return false;
 
-  for (; device_->Ioctl(VIDIOC_ENUM_FMT, &fmtdesc) == 0; ++fmtdesc.index) {
-    if (fmtdesc.pixelformat == V4L2_PIX_FMT_JPEG)
-      return true;
-  }
-  return false;
+  return device->IsJpegDecodingSupported();
 }
 
 void V4L2JpegDecodeAccelerator::DecodeTask(
     std::unique_ptr<JobRecord> job_record) {
   DCHECK(decoder_task_runner_->BelongsToCurrentThread());
   if (!job_record->shm.Map()) {
     PLOG(ERROR) << __func__ << ": could not map bitstream_buffer";
     PostNotifyError(job_record->bitstream_buffer_id, UNREADABLE_INPUT);
     return;
   }
@@ skipping 164 matching lines @@
     }
     output_buffer_map_[i].address = address;
     output_buffer_map_[i].length = buffer.length;
   }
 
   return true;
 }
 
 void V4L2JpegDecodeAccelerator::DestroyInputBuffers() {
   DCHECK(decoder_task_runner_->BelongsToCurrentThread());
   DCHECK(!input_streamon_);

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

I found this check is contradiction to line 459.

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

My guess is that the intention here could have been that normally streamoff
should have been called, but this method is intended to clean up no matter what,
so in debug builds it will check to give a chance to fix the code, in Release
just try to do this anyway just in case.
But if there is an issue, we should rather try to fix it, than do this, but out
of scope of this CL though I'd say.

 
+  free_input_buffers_.clear();
+
+  if (input_buffer_map_.empty())
+    return;
+
   if (input_streamon_) {
     __u32 type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
     IOCTL_OR_ERROR_RETURN(VIDIOC_STREAMOFF, &type);
     input_streamon_ = false;
   }
 
   for (size_t i = 0; i < input_buffer_map_.size(); ++i) {
     BufferRecord& input_record = input_buffer_map_[i];
     device_->Munmap(input_record.address, input_record.length);
   }
 
   struct v4l2_requestbuffers reqbufs;
   memset(&reqbufs, 0, sizeof(reqbufs));
   reqbufs.count = 0;
   reqbufs.type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
   reqbufs.memory = V4L2_MEMORY_MMAP;
   IOCTL_OR_LOG_ERROR(VIDIOC_REQBUFS, &reqbufs);
 
   input_buffer_map_.clear();
-  free_input_buffers_.clear();
 }
 
 void V4L2JpegDecodeAccelerator::DestroyOutputBuffers() {
   DCHECK(decoder_task_runner_->BelongsToCurrentThread());
   DCHECK(!output_streamon_);

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

I found this check is contradiction to line 489.

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

Please see above.

 
+  free_output_buffers_.clear();
+
+  if (output_buffer_map_.empty())
+    return;
+
   if (output_streamon_) {
     __u32 type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     IOCTL_OR_ERROR_RETURN(VIDIOC_STREAMOFF, &type);
     output_streamon_ = false;
   }
 
   for (size_t i = 0; i < output_buffer_map_.size(); ++i) {
     BufferRecord& output_record = output_buffer_map_[i];
     device_->Munmap(output_record.address, output_record.length);
   }
 
   struct v4l2_requestbuffers reqbufs;
   memset(&reqbufs, 0, sizeof(reqbufs));
   reqbufs.count = 0;
   reqbufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
   reqbufs.memory = V4L2_MEMORY_MMAP;
   IOCTL_OR_LOG_ERROR(VIDIOC_REQBUFS, &reqbufs);
 
   output_buffer_map_.clear();
-  free_output_buffers_.clear();
 }
 
 void V4L2JpegDecodeAccelerator::DevicePollTask() {
   DCHECK(device_poll_task_runner_->BelongsToCurrentThread());
 
   bool event_pending;
   if (!device_->Poll(true, &event_pending)) {
     PLOG(ERROR) << __func__ << ": Poll device error.";
     PostNotifyError(kInvalidBitstreamBufferId, PLATFORM_FAILURE);
     return;
@@ skipping 382 matching lines @@
   device_poll_thread_.Stop();
 
   // Clear the interrupt now, to be sure.
   if (!device_->ClearDevicePollInterrupt())
     return false;
 
   return true;
 }
 
 }  // namespace media