Remove kIgnoreResolutionLimitsForAcceleratedVideoDecode flag

content/common/gpu/media/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 "base/numerics/safe_conversions.h"
 #include "content/common/gpu/media/generic_v4l2_device.h"
 #if defined(ARCH_CPU_ARMEL)
 #include "content/common/gpu/media/tegra_v4l2_device.h"
 #endif
 
 namespace content {
 
+V4L2Device::V4L2Device(Type type) : type_(type) {
+}
+
 V4L2Device::~V4L2Device() {
 }
 
 // static
 scoped_refptr<V4L2Device> V4L2Device::Create(Type type) {
   DVLOG(3) << __PRETTY_FUNCTION__;
 
   scoped_refptr<GenericV4L2Device> generic_device(new GenericV4L2Device(type));
   if (generic_device->Initialize())
     return generic_device;
@@ skipping 164 matching lines @@
 
   // Sanity checks. Calculated coded size has to contain given visible size
   // and fulfill buffer byte size requirements.
   DCHECK(gfx::Rect(coded_size).Contains(gfx::Rect(visible_size)));
   DCHECK_LE(sizeimage,
             media::VideoFrame::AllocationSize(frame_format, coded_size));
 
   return coded_size;
 }
 
+gfx::Size V4L2Device::GetMaxSupportedResolution(uint32_t pixelformat) {
+  gfx::Size max_resolution;
+  v4l2_frmsizeenum frame_size;
+  memset(&frame_size, 0, sizeof(frame_size));
+  frame_size.pixel_format = pixelformat;
+  for (; Ioctl(VIDIOC_ENUM_FRAMESIZES, &frame_size) == 0; ++frame_size.index) {
+    if (frame_size.type == V4L2_FRMSIZE_TYPE_DISCRETE &&
+        frame_size.discrete.width >=
+            base::checked_cast<uint32_t>(max_resolution.width()) &&
+        frame_size.discrete.height >=
+            base::checked_cast<uint32_t>(max_resolution.height())) {
+      max_resolution.SetSize(frame_size.discrete.width,
+                             frame_size.discrete.height);
+    } else if (frame_size.type == V4L2_FRMSIZE_TYPE_STEPWISE ||
+               frame_size.type == V4L2_FRMSIZE_TYPE_CONTINUOUS) {
+      max_resolution.SetSize(frame_size.stepwise.max_width,
+                             frame_size.stepwise.max_height);
+      break;
+    }
+  }
+  if (max_resolution.IsEmpty()) {
+    LOG(ERROR) << "GetMaxSupportedResolution failed for fourcc " << std::hex
+               << pixelformat << ", fall back to 1920x1088.";
+    max_resolution.SetSize(1920, 1088);
+  }
+  return max_resolution;
+}
+
+media::VideoDecodeAccelerator::SupportedProfiles
+V4L2Device::GetSupportedDecodeProfiles(
+    const uint32_t num_formats, const uint32_t pixelformats[]) {
+  DCHECK_EQ(type_, kDecoder);
+  media::VideoDecodeAccelerator::SupportedProfiles profiles;
+  media::VideoDecodeAccelerator::SupportedProfile profile;
+  profile.min_resolution.SetSize(16, 16);

[Pawel Osciak, 2015/04/27 05:36:15]

Framesize API also supports minimum resolution, there is a min_width/height
member in v4l2_frmsizeenum.stepwise and we can figure out minimum values from
continuous as well. I think we should try to use that information.

[henryhsu, 2015/04/27 07:23:51]

Done.

+  v4l2_fmtdesc fmtdesc;
+  memset(&fmtdesc, 0, sizeof(fmtdesc));
+  fmtdesc.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
+
+  for (; Ioctl(VIDIOC_ENUM_FMT, &fmtdesc) == 0; ++fmtdesc.index) {
+    if (std::find(pixelformats, pixelformats + num_formats,
+                  fmtdesc.pixelformat) == pixelformats + num_formats)
+      continue;
+    profile.max_resolution = GetMaxSupportedResolution(fmtdesc.pixelformat);
+    uint32_t min_profile, max_profile;

[Pawel Osciak, 2015/04/27 05:36:15]

s/uint32_t/int/

[henryhsu, 2015/04/27 07:23:51]

Done.

+    switch (fmtdesc.pixelformat) {
+      case V4L2_PIX_FMT_H264:
+      case V4L2_PIX_FMT_H264_SLICE:
+        min_profile = media::H264PROFILE_MIN;
+        max_profile = media::H264PROFILE_MAX;
+        break;
+      case V4L2_PIX_FMT_VP8:
+      case V4L2_PIX_FMT_VP8_FRAME:
+        min_profile = media::VP8PROFILE_MIN;
+        max_profile = media::VP8PROFILE_MAX;
+        break;
+      case V4L2_PIX_FMT_VP9:
+        min_profile = media::VP9PROFILE_MIN;
+        max_profile = media::VP9PROFILE_MAX;
+        break;
+      default:
+        NOTREACHED() << "Unhandled pixelformat " << std::hex
+                     << fmtdesc.pixelformat;
+        break;

[Pawel Osciak, 2015/04/27 05:36:14]

NOTREACHED is not a fatal failure in Release, so you need to "return profiles;"
from here. Otherwise we'll iterate over uninitialized values in the for loop
below.

[henryhsu, 2015/04/27 07:23:51]

Done.

+    }
+    for (uint32_t media_profile = min_profile; media_profile <= max_profile;

[Pawel Osciak, 2015/04/27 05:36:14]

s/uint32_t/int/

[henryhsu, 2015/04/27 07:23:51]

Done.

+        ++media_profile) {
+      profile.profile =
+        static_cast<media::VideoCodecProfile>(media_profile);
+      profiles.push_back(profile);
+    }
+  }
+  return profiles;
+}
+
 }  //  namespace content