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

media/gpu/v4l2_video_decode_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_decode_accelerator.h"
 
 #include <dlfcn.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <linux/videodev2.h>
@@ skipping 160 matching lines @@
       output_streamon_(false),
       output_buffer_queued_count_(0),
       output_dpb_size_(0),
       output_planes_count_(0),
       picture_clearing_count_(0),
       device_poll_thread_("V4L2DevicePollThread"),
       egl_display_(egl_display),
       get_gl_context_cb_(get_gl_context_cb),
       make_context_current_cb_(make_context_current_cb),
       video_profile_(VIDEO_CODEC_PROFILE_UNKNOWN),
+      input_format_fourcc_(0),
       output_format_fourcc_(0),
       egl_image_format_fourcc_(0),
       egl_image_planes_count_(0),
       weak_this_factory_(this) {
   weak_this_ = weak_this_factory_.GetWeakPtr();
 }
 
 V4L2VideoDecodeAccelerator::~V4L2VideoDecodeAccelerator() {
   DCHECK(!decoder_thread_.IsRunning());
   DCHECK(!device_poll_thread_.IsRunning());
 
   // These maps have members that should be manually destroyed, e.g. file
   // descriptors, mmap() segments, etc.
   DCHECK(input_buffer_map_.empty());
   DCHECK(output_buffer_map_.empty());
 }
 
 bool V4L2VideoDecodeAccelerator::Initialize(const Config& config,
                                             Client* client) {
   DVLOGF(3) << "profile: " << config.profile
             << ", output_mode=" << static_cast<int>(config.output_mode);
   DCHECK(child_task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(decoder_state_, kUninitialized);
 
-  if (!device_->SupportsDecodeProfileForV4L2PixelFormats(
-          config.profile, arraysize(supported_input_fourccs_),
-          supported_input_fourccs_)) {
-    DVLOGF(1) << "unsupported profile=" << config.profile;
-    return false;
-  }
-
   if (config.is_encrypted) {
     NOTREACHED() << "Encrypted streams are not supported for this VDA";
     return false;
   }
 
   if (config.output_mode != Config::OutputMode::ALLOCATE &&
       config.output_mode != Config::OutputMode::IMPORT) {
     NOTREACHED() << "Only ALLOCATE and IMPORT OutputModes are supported";
     return false;
   }
@@ skipping 27 matching lines @@
 #if defined(ARCH_CPU_ARMEL)
     if (!gl::g_driver_egl.ext.b_EGL_KHR_fence_sync) {
       LOGF(ERROR) << "context does not have EGL_KHR_fence_sync";
       return false;
     }
 #endif
   } else {
     DVLOGF(1) << "No GL callbacks provided, initializing without GL support";
   }
 
+  input_format_fourcc_ =
+      V4L2Device::VideoCodecProfileToV4L2PixFmt(video_profile_, false);
+
+  if (!device_->Open(V4L2Device::Type::kDecoder, input_format_fourcc_)) {
+    DVLOGF(1) << "Failed to open device for profile: " << config.profile
+              << " 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;
   const __u32 kCapsRequired = V4L2_CAP_VIDEO_M2M_MPLANE | V4L2_CAP_STREAMING;
   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_QUERYCAP, &caps);
   if ((caps.capabilities & kCapsRequired) != kCapsRequired) {
     LOGF(ERROR) << "ioctl() failed: VIDIOC_QUERYCAP"
                 << ", caps check failed: 0x" << std::hex << caps.capabilities;
     return false;
   }
 
@@ skipping 445 matching lines @@
     const scoped_refptr<base::SingleThreadTaskRunner>& decode_task_runner) {
   DVLOGF(2);
   decode_client_ = decode_client;
   decode_task_runner_ = decode_task_runner;
   return true;
 }
 
 // static
 VideoDecodeAccelerator::SupportedProfiles
 V4L2VideoDecodeAccelerator::GetSupportedProfiles() {
-  scoped_refptr<V4L2Device> device = V4L2Device::Create(V4L2Device::kDecoder);
+  scoped_refptr<V4L2Device> device = V4L2Device::Create();
   if (!device)
     return SupportedProfiles();
 
   return device->GetSupportedDecodeProfiles(arraysize(supported_input_fourccs_),
                                             supported_input_fourccs_);
 }
 
 void V4L2VideoDecodeAccelerator::DecodeTask(
     const BitstreamBuffer& bitstream_buffer) {
   DVLOGF(3) << "input_id=" << bitstream_buffer.id();
@@ skipping 1218 matching lines @@
 }
 
 bool V4L2VideoDecodeAccelerator::CreateBuffersForFormat(
     const struct v4l2_format& format,
     const gfx::Size& visible_size) {
   DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
   output_planes_count_ = format.fmt.pix_mp.num_planes;
   coded_size_.SetSize(format.fmt.pix_mp.width, format.fmt.pix_mp.height);
   visible_size_ = visible_size;
   if (image_processor_device_) {
-    V4L2ImageProcessor processor(image_processor_device_);
     egl_image_size_ = visible_size_;
     egl_image_planes_count_ = 0;
-    if (!processor.TryOutputFormat(egl_image_format_fourcc_, &egl_image_size_,
-                                   &egl_image_planes_count_)) {
+    if (!V4L2ImageProcessor::TryOutputFormat(
+            output_format_fourcc_, egl_image_format_fourcc_, &egl_image_size_,
+            &egl_image_planes_count_)) {
       LOGF(ERROR) << "Fail to get output size and plane count of processor";
       return false;
     }
   } else {
     egl_image_size_ = coded_size_;
     egl_image_planes_count_ = output_planes_count_;
   }
   DVLOGF(3) << "new resolution: " << coded_size_.ToString()
             << ", visible size: " << visible_size_.ToString()
             << ", decoder output planes count: " << output_planes_count_
@@ skipping 83 matching lines @@
   return true;
 }
 
 bool V4L2VideoDecodeAccelerator::SetupFormats() {
   // We always run this as we prepare to initialize.
   DCHECK(child_task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(decoder_state_, kUninitialized);
   DCHECK(!input_streamon_);
   DCHECK(!output_streamon_);
 
-  __u32 input_format_fourcc =
-      V4L2Device::VideoCodecProfileToV4L2PixFmt(video_profile_, false);
-  if (!input_format_fourcc) {
-    NOTREACHED();
-    return false;
-  }
-
   size_t input_size;
   gfx::Size max_resolution, min_resolution;
-  device_->GetSupportedResolution(input_format_fourcc, &min_resolution,
+  device_->GetSupportedResolution(input_format_fourcc_, &min_resolution,
                                   &max_resolution);
   if (max_resolution.width() > 1920 && max_resolution.height() > 1088)
     input_size = kInputBufferMaxSizeFor4k;
   else
     input_size = kInputBufferMaxSizeFor1080p;
 
   struct v4l2_fmtdesc fmtdesc;
   memset(&fmtdesc, 0, sizeof(fmtdesc));
   fmtdesc.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
   bool is_format_supported = false;
   while (device_->Ioctl(VIDIOC_ENUM_FMT, &fmtdesc) == 0) {
-    if (fmtdesc.pixelformat == input_format_fourcc) {
+    if (fmtdesc.pixelformat == input_format_fourcc_) {
       is_format_supported = true;
       break;
     }
     ++fmtdesc.index;
   }
 
   if (!is_format_supported) {
-    DVLOGF(1) << "Input fourcc " << input_format_fourcc
+    DVLOGF(1) << "Input fourcc " << input_format_fourcc_
               << " not supported by device.";
     return false;
   }
 
   struct v4l2_format format;
   memset(&format, 0, sizeof(format));
   format.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
-  format.fmt.pix_mp.pixelformat = input_format_fourcc;
+  format.fmt.pix_mp.pixelformat = input_format_fourcc_;
   format.fmt.pix_mp.plane_fmt[0].sizeimage = input_size;
   format.fmt.pix_mp.num_planes = 1;
   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_S_FMT, &format);
 
   // We have to set up the format for output, because the driver may not allow
   // changing it once we start streaming; whether it can support our chosen
   // output format or not may depend on the input format.
   memset(&fmtdesc, 0, sizeof(fmtdesc));
   fmtdesc.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
   while (device_->Ioctl(VIDIOC_ENUM_FMT, &fmtdesc) == 0) {
     if (device_->CanCreateEGLImageFrom(fmtdesc.pixelformat)) {
       output_format_fourcc_ = fmtdesc.pixelformat;
       break;
     }
     ++fmtdesc.index;
   }
 
   if (output_format_fourcc_ == 0) {
     DVLOGF(1) << "Could not find a usable output format. Try image processor";
-    image_processor_device_ = V4L2Device::Create(V4L2Device::kImageProcessor);
-    if (!image_processor_device_) {
-      DVLOGF(1) << "No image processor device.";
+    if (!V4L2ImageProcessor::IsSupported()) {
+      DVLOGF(1) << "Image processor not available";
       return false;
     }
     output_format_fourcc_ = FindImageProcessorInputFormat();
     if (output_format_fourcc_ == 0) {
       LOGF(ERROR) << "Can't find a usable input format from image processor";
       return false;
     }
     egl_image_format_fourcc_ = FindImageProcessorOutputFormat();
     if (egl_image_format_fourcc_ == 0) {
       LOGF(ERROR) << "Can't find a usable output format from image processor";
       return false;
     }
+    image_processor_device_ = V4L2Device::Create();
+    if (!image_processor_device_) {
+      DVLOGF(1) << "Could not create a V4L2Device for image processor";
+      return false;
+    }
     egl_image_device_ = image_processor_device_;
   } else {
     if (output_mode_ == Config::OutputMode::IMPORT) {
       LOGF(ERROR) << "Import mode without image processor is not implemented "
                   << "yet.";
       return false;
     }
+    image_processor_device_ = nullptr;

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

DCHECK(image_processor_device_ == nullptr) at line 2121 instead.

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

Done.

     egl_image_format_fourcc_ = output_format_fourcc_;
     egl_image_device_ = device_;
   }
   DVLOGF(2) << "Output format=" << output_format_fourcc_;
 
   // Just set the fourcc for output; resolution, etc., will come from the
   // driver once it extracts it from the stream.
   memset(&format, 0, sizeof(format));
   format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
   format.fmt.pix_mp.pixelformat = output_format_fourcc_;
   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_S_FMT, &format);
 
   return true;
 }
 
 uint32_t V4L2VideoDecodeAccelerator::FindImageProcessorInputFormat() {
-  V4L2ImageProcessor image_processor(image_processor_device_);
   std::vector<uint32_t> processor_input_formats =
-      image_processor.GetSupportedInputFormats();
+      V4L2ImageProcessor::GetSupportedInputFormats();
+
   struct v4l2_fmtdesc fmtdesc;
   memset(&fmtdesc, 0, sizeof(fmtdesc));
   fmtdesc.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
   while (device_->Ioctl(VIDIOC_ENUM_FMT, &fmtdesc) == 0) {
     if (std::find(processor_input_formats.begin(),
                   processor_input_formats.end(),
                   fmtdesc.pixelformat) != processor_input_formats.end()) {
-      DVLOGF(1) << "Image processor input format=" << fmtdesc.pixelformat;
+      DVLOGF(1) << "Image processor input format=" << fmtdesc.description;
       return fmtdesc.pixelformat;
     }
     ++fmtdesc.index;
   }
   return 0;
 }
 
 uint32_t V4L2VideoDecodeAccelerator::FindImageProcessorOutputFormat() {
   // Prefer YVU420 and NV12 because ArcGpuVideoDecodeAccelerator only supports
   // single physical plane. Prefer YVU420 over NV12 because chrome rendering
   // supports YV12 only.
   static const uint32_t kPreferredFormats[] = {V4L2_PIX_FMT_YVU420,
                                                V4L2_PIX_FMT_NV12};
   auto preferred_formats_first = [](uint32_t a, uint32_t b) -> bool {
     auto iter_a = std::find(std::begin(kPreferredFormats),
                             std::end(kPreferredFormats), a);
     auto iter_b = std::find(std::begin(kPreferredFormats),
                             std::end(kPreferredFormats), b);
     return iter_a < iter_b;
   };
 
-  V4L2ImageProcessor image_processor(image_processor_device_);
   std::vector<uint32_t> processor_output_formats =
-      image_processor.GetSupportedOutputFormats();
+      V4L2ImageProcessor::GetSupportedOutputFormats();
 
   // Move the preferred formats to the front.
   std::sort(processor_output_formats.begin(), processor_output_formats.end(),
             preferred_formats_first);
 
   for (uint32_t processor_output_format : processor_output_formats) {
     if (device_->CanCreateEGLImageFrom(processor_output_format)) {
       DVLOGF(1) << "Image processor output format=" << processor_output_format;
       return processor_output_format;
     }
@@ skipping 133 matching lines @@
   // done with this one. After we get the buffers, we'll go back into kIdle and
   // kick off further event processing, and eventually go back into kDecoding
   // once no more events are pending (if any).
   decoder_state_ = kAwaitingPictureBuffers;
 
   return true;
 }
 
 void V4L2VideoDecodeAccelerator::DestroyInputBuffers() {
   DVLOGF(3);
-  DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
+  DCHECK(!decoder_thread_.IsRunning() ||
+         decoder_thread_.task_runner()->BelongsToCurrentThread());
   DCHECK(!input_streamon_);
 
+  if (input_buffer_map_.empty())
+    return;
+
   for (size_t i = 0; i < input_buffer_map_.size(); ++i) {
     if (input_buffer_map_[i].address != NULL) {
       device_->Munmap(input_buffer_map_[i].address,
                       input_buffer_map_[i].length);
     }
   }
 
   struct v4l2_requestbuffers reqbufs;
   memset(&reqbufs, 0, sizeof(reqbufs));
   reqbufs.count = 0;
   reqbufs.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
   reqbufs.memory = V4L2_MEMORY_MMAP;
   IOCTL_OR_LOG_ERROR(VIDIOC_REQBUFS, &reqbufs);
 
   input_buffer_map_.clear();
   free_input_buffers_.clear();
 }
 
 bool V4L2VideoDecodeAccelerator::DestroyOutputBuffers() {
   DVLOGF(3);
-  DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
+  DCHECK(!decoder_thread_.IsRunning() ||
+         decoder_thread_.task_runner()->BelongsToCurrentThread());
   DCHECK(!output_streamon_);
   bool success = true;
 
+  if (output_buffer_map_.empty())
+    return true;
+
   for (size_t i = 0; i < output_buffer_map_.size(); ++i) {
     OutputRecord& output_record = output_buffer_map_[i];
 
     if (output_record.egl_image != EGL_NO_IMAGE_KHR) {
       child_task_runner_->PostTask(
           FROM_HERE,
           base::Bind(base::IgnoreResult(&V4L2Device::DestroyEGLImage), device_,
                      egl_display_, output_record.egl_image));
     }
 
@@ skipping 113 matching lines @@
       StartResolutionChange();
   }
 }
 
 void V4L2VideoDecodeAccelerator::ImageProcessorError() {
   LOGF(ERROR) << "Image processor error";
   NOTIFY_ERROR(PLATFORM_FAILURE);
 }
 
 }  // namespace media