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

media/gpu/v4l2_device.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 <libdrm/drm_fourcc.h>
 #include <linux/videodev2.h>
 #include <string.h>
 
 #include "base/numerics/safe_conversions.h"
 #include "build/build_config.h"
 #include "media/gpu/generic_v4l2_device.h"
 #if defined(ARCH_CPU_ARMEL)
 #include "media/gpu/tegra_v4l2_device.h"
 #endif
 
 namespace media {
 
-V4L2Device::V4L2Device(Type type) : type_(type) {}
+V4L2Device::V4L2Device() {}
 
 V4L2Device::~V4L2Device() {}
 
 // static
-scoped_refptr<V4L2Device> V4L2Device::Create(Type type) {
+scoped_refptr<V4L2Device> V4L2Device::Create() {
   DVLOG(3) << __PRETTY_FUNCTION__;
 
-  scoped_refptr<GenericV4L2Device> generic_device(new GenericV4L2Device(type));
-  if (generic_device->Initialize())
-    return generic_device;
-
 #if defined(ARCH_CPU_ARMEL)
-  scoped_refptr<TegraV4L2Device> tegra_device(new TegraV4L2Device(type));
+  scoped_refptr<TegraV4L2Device> tegra_device(new TegraV4L2Device());

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

Change it to scoped_refptr<V4L2Device> in order to make it possible to make
Initialize() private.

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

Done.

   if (tegra_device->Initialize())
     return tegra_device;
 #endif
 
-  DVLOG(1) << "Failed to create V4L2Device";
-  return scoped_refptr<V4L2Device>();
+  scoped_refptr<GenericV4L2Device> generic_device(new GenericV4L2Device());

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

Change it to scoped_refptr<V4L2Device> in order to make it possible to make
Initialize() private.

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

Done.

+  if (generic_device->Initialize())
+    return generic_device;
+
+  DVLOG(1) << "Failed to create a V4L2Device";
+  return nullptr;
 }
 
 // static
 VideoPixelFormat V4L2Device::V4L2PixFmtToVideoPixelFormat(uint32_t pix_fmt) {
   switch (pix_fmt) {
     case V4L2_PIX_FMT_NV12:
     case V4L2_PIX_FMT_NV12M:
       return PIXEL_FORMAT_NV12;
 
     case V4L2_PIX_FMT_MT21:
       return PIXEL_FORMAT_MT21;
 
     case V4L2_PIX_FMT_YUV420:
     case V4L2_PIX_FMT_YUV420M:
       return PIXEL_FORMAT_I420;
 
     case V4L2_PIX_FMT_YVU420:
       return PIXEL_FORMAT_YV12;
 
     case V4L2_PIX_FMT_RGB32:
       return PIXEL_FORMAT_ARGB;
 
     default:
-      LOG(FATAL) << "Add more cases as needed";
+      DVLOG(1) << "Add more cases as needed";

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

How about DLOG(FATAL) ? anyway, up to you.

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

Thinking more about this, we should probably log only on unrecognized V4L2 pixel
formats, because we may have a device with unsupported/unused by us format and
it's ok to skip it. On the other hand, if we go from Chrome format to V4L2
pixfmt, we are probably requesting to use it and need it, so this should
probably be fatal always. Changing with this in mind.

       return PIXEL_FORMAT_UNKNOWN;
   }
 }
 
 // static
 uint32_t V4L2Device::VideoPixelFormatToV4L2PixFmt(VideoPixelFormat format) {
   switch (format) {
     case PIXEL_FORMAT_NV12:
       return V4L2_PIX_FMT_NV12M;
 
     case PIXEL_FORMAT_MT21:
       return V4L2_PIX_FMT_MT21;
 
     case PIXEL_FORMAT_I420:
       return V4L2_PIX_FMT_YUV420M;
 
     case PIXEL_FORMAT_YV12:
       return V4L2_PIX_FMT_YVU420;
 
     default:
-      LOG(FATAL) << "Add more cases as needed";
+      DVLOG(1) << "Add more cases as needed";
       return 0;
   }
 }
 
 // static
 uint32_t V4L2Device::VideoCodecProfileToV4L2PixFmt(VideoCodecProfile profile,
                                                    bool slice_based) {
   if (profile >= H264PROFILE_MIN && profile <= H264PROFILE_MAX) {
     if (slice_based)
       return V4L2_PIX_FMT_H264_SLICE;
     else
       return V4L2_PIX_FMT_H264;
   } else if (profile >= VP8PROFILE_MIN && profile <= VP8PROFILE_MAX) {
     if (slice_based)
       return V4L2_PIX_FMT_VP8_FRAME;
     else
       return V4L2_PIX_FMT_VP8;
   } else if (profile >= VP9PROFILE_MIN && profile <= VP9PROFILE_MAX) {
     if (slice_based)
       return V4L2_PIX_FMT_VP9_FRAME;
     else
       return V4L2_PIX_FMT_VP9;
   } else {
-    LOG(FATAL) << "Add more cases as needed";
+    DVLOG(1) << "Add more cases as needed";
     return 0;
   }
 }
 
 // static
+std::vector<VideoCodecProfile> V4L2Device::V4L2PixFmtToVideoCodecProfiles(
+    uint32_t pix_fmt,
+    bool is_encoder) {
+  VideoCodecProfile min_profile, max_profile;
+  std::vector<VideoCodecProfile> profiles;
+
+  switch (pix_fmt) {
+    case V4L2_PIX_FMT_H264:
+    case V4L2_PIX_FMT_H264_SLICE:
+      if (is_encoder) {
+        // TODO(posciak): need to query the device for supported H.264 profiles,
+        // for now choose Main as a sensible default.
+        min_profile = H264PROFILE_MAIN;
+        max_profile = H264PROFILE_MAIN;
+      } else {
+        min_profile = H264PROFILE_MIN;
+        max_profile = H264PROFILE_MAX;
+      }
+      break;
+
+    case V4L2_PIX_FMT_VP8:
+    case V4L2_PIX_FMT_VP8_FRAME:
+      min_profile = VP8PROFILE_MIN;
+      max_profile = VP8PROFILE_MAX;
+      break;
+
+    case V4L2_PIX_FMT_VP9:
+    case V4L2_PIX_FMT_VP9_FRAME:
+      min_profile = VP9PROFILE_MIN;
+      max_profile = VP9PROFILE_MAX;
+      break;
+
+    default:
+      DVLOG(1) << "Unhandled pixelformat " << std::hex << "0x" << pix_fmt;

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

"0x" could be merged with previous string literal. Up to you, if you feel this
is more readable.

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

Yes, I felt this was more readable.

+      return profiles;
+  }
+
+  for (int profile = min_profile; profile <= max_profile; ++profile)
+    profiles.push_back(static_cast<VideoCodecProfile>(profile));
+
+  return profiles;
+}
+
+// static
 uint32_t V4L2Device::V4L2PixFmtToDrmFormat(uint32_t format) {
   switch (format) {
     case V4L2_PIX_FMT_NV12:
     case V4L2_PIX_FMT_NV12M:
       return DRM_FORMAT_NV12;
 
     case V4L2_PIX_FMT_YUV420:
     case V4L2_PIX_FMT_YUV420M:
       return DRM_FORMAT_YUV420;
 
     case V4L2_PIX_FMT_YVU420:
       return DRM_FORMAT_YVU420;
 
     case V4L2_PIX_FMT_RGB32:
       return DRM_FORMAT_ARGB8888;
 
+    case V4L2_PIX_FMT_MT21:
+      return DRM_FORMAT_MT21;
+
     default:
-      DVLOG(1) << "Add more cases as needed";
+      DVLOG(1) << "Unrecognized format " << std::hex << "0x" << format;
       return 0;
   }
 }
 
 // static
 gfx::Size V4L2Device::CodedSizeFromV4L2Format(struct v4l2_format format) {
   gfx::Size coded_size;
   gfx::Size visible_size;
   VideoPixelFormat frame_format = PIXEL_FORMAT_UNKNOWN;
   size_t bytesperline = 0;
@@ skipping 112 matching lines @@
                << ", fall back to " << max_resolution->ToString();
   }
   if (min_resolution->IsEmpty()) {
     min_resolution->SetSize(16, 16);
     LOG(ERROR) << "GetSupportedResolution failed to get minimum resolution for "
                << "fourcc " << std::hex << pixelformat
                << ", fall back to " << min_resolution->ToString();
   }
 }
 
-VideoDecodeAccelerator::SupportedProfiles
-V4L2Device::GetSupportedDecodeProfiles(const size_t num_formats,
-                                       const uint32_t pixelformats[]) {
-  DCHECK_EQ(type_, kDecoder);
-  VideoDecodeAccelerator::SupportedProfiles profiles;
-  VideoDecodeAccelerator::SupportedProfile profile;
+std::vector<uint32_t> V4L2Device::EnumerateSupportedPixelformats(
+    v4l2_buf_type buf_type) {
+  std::vector<uint32_t> pixelformats;
+
   v4l2_fmtdesc fmtdesc;
   memset(&fmtdesc, 0, sizeof(fmtdesc));
-  fmtdesc.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
+  fmtdesc.type = buf_type;
 
   for (; Ioctl(VIDIOC_ENUM_FMT, &fmtdesc) == 0; ++fmtdesc.index) {
-    if (std::find(pixelformats, pixelformats + num_formats,
-                  fmtdesc.pixelformat) == pixelformats + num_formats)
+    DVLOG(1) << "Found " << std::hex << fmtdesc.pixelformat << " "

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

0x

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

Done.

+             << fmtdesc.description;
+    pixelformats.push_back(fmtdesc.pixelformat);
+  }
+
+  return pixelformats;
+}
+
+VideoDecodeAccelerator::SupportedProfiles
+V4L2Device::EnumerateSupportedDecodeProfiles(const size_t num_formats,
+                                             const uint32_t pixelformats[]) {
+  VideoDecodeAccelerator::SupportedProfiles profiles;
+
+  const auto& supported_pixelformats =
+      EnumerateSupportedPixelformats(V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE);
+
+  for (uint32_t pixelformat : supported_pixelformats) {
+    if (std::find(pixelformats, pixelformats + num_formats, pixelformat) ==
+        pixelformats + num_formats)
       continue;
-    int min_profile, max_profile;
-    switch (fmtdesc.pixelformat) {
-      case V4L2_PIX_FMT_H264:
-      case V4L2_PIX_FMT_H264_SLICE:
-        min_profile = H264PROFILE_MIN;
-        max_profile = H264PROFILE_MAX;
-        break;
-      case V4L2_PIX_FMT_VP8:
-      case V4L2_PIX_FMT_VP8_FRAME:
-        min_profile = VP8PROFILE_MIN;
-        max_profile = VP8PROFILE_MAX;
-        break;
-      case V4L2_PIX_FMT_VP9:
-      case V4L2_PIX_FMT_VP9_FRAME:
-        min_profile = VP9PROFILE_MIN;
-        max_profile = VP9PROFILE_MAX;
-        break;
-      default:
-        NOTREACHED() << "Unhandled pixelformat " << std::hex
-                     << fmtdesc.pixelformat;
-        return profiles;
-    }
-    GetSupportedResolution(fmtdesc.pixelformat, &profile.min_resolution,
+
+    VideoDecodeAccelerator::SupportedProfile profile;
+    GetSupportedResolution(pixelformat, &profile.min_resolution,
                            &profile.max_resolution);
-    for (int media_profile = min_profile; media_profile <= max_profile;
-         ++media_profile) {
-      profile.profile = static_cast<VideoCodecProfile>(media_profile);
+
+    const auto video_codec_profiles =
+        V4L2PixFmtToVideoCodecProfiles(pixelformat, false);
+
+    for (const auto& video_codec_profile : video_codec_profiles) {
+      profile.profile = video_codec_profile;
       profiles.push_back(profile);
+
+      DVLOG(1) << "Found decoder profile " << GetProfileName(profile.profile)
+               << ", resolutions: " << profile.min_resolution.ToString() << " "
+               << profile.max_resolution.ToString();
     }
   }
+
   return profiles;
 }
 
-bool V4L2Device::SupportsDecodeProfileForV4L2PixelFormats(
-    VideoCodecProfile profile,
-    const size_t num_formats,
-    const uint32_t pixelformats[]) {
-  // Get all supported profiles by this device, taking into account only fourccs
-  // in pixelformats.
-  const auto supported_profiles =
-      GetSupportedDecodeProfiles(num_formats, pixelformats);
+VideoEncodeAccelerator::SupportedProfiles
+V4L2Device::EnumerateSupportedEncodeProfiles() {
+  VideoEncodeAccelerator::SupportedProfiles profiles;
 
-  // Try to find requested profile among the returned supported_profiles.
-  const auto iter = std::find_if(
-      supported_profiles.begin(), supported_profiles.end(),
-      [profile](const VideoDecodeAccelerator::SupportedProfile& p) {
-        return profile == p.profile;
-      });
+  const auto& supported_pixelformats =
+      EnumerateSupportedPixelformats(V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
 
-  return iter != supported_profiles.end();
+  for (const auto& pixelformat : supported_pixelformats) {
+    VideoEncodeAccelerator::SupportedProfile profile;
+    profile.max_framerate_numerator = 30;
+    profile.max_framerate_denominator = 1;
+    gfx::Size min_resolution;
+    GetSupportedResolution(pixelformat, &min_resolution,
+                           &profile.max_resolution);
+
+    const auto video_codec_profiles =
+        V4L2PixFmtToVideoCodecProfiles(pixelformat, true);
+
+    for (const auto& video_codec_profile : video_codec_profiles) {
+      profile.profile = video_codec_profile;
+      profiles.push_back(profile);
+
+      DVLOG(1) << "Found encoder profile " << GetProfileName(profile.profile)
+               << ", max resolution: " << profile.max_resolution.ToString();
+    }
+  }
+
+  return profiles;
 }
 
 }  //  namespace media