media/gpu/v4l2_device.cc - chromium/src - Git at Google

 // 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() {}

 V4L2Device::~V4L2Device() {}

 // static
 scoped_refptr<V4L2Device> V4L2Device::Create() {
   DVLOG(3) << __PRETTY_FUNCTION__;

   scoped_refptr<V4L2Device> device;

 #if defined(ARCH_CPU_ARMEL)
   device = new TegraV4L2Device();
   if (device->Initialize())
     return device;
 #endif

   device = new GenericV4L2Device();
   if (device->Initialize())
     return 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_YUV422M:
       return PIXEL_FORMAT_I422;

     case V4L2_PIX_FMT_RGB32:
       return PIXEL_FORMAT_ARGB;

     default:
       DVLOG(1) << "Add more cases as needed";
       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";
       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";
     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;
       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) << "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;
   // Total bytes in the frame.
   size_t sizeimage = 0;

   if (V4L2_TYPE_IS_MULTIPLANAR(format.type)) {
     DCHECK_GT(format.fmt.pix_mp.num_planes, 0);
     bytesperline =
         base::checked_cast<int>(format.fmt.pix_mp.plane_fmt[0].bytesperline);
     for (size_t i = 0; i < format.fmt.pix_mp.num_planes; ++i) {
       sizeimage +=
           base::checked_cast<int>(format.fmt.pix_mp.plane_fmt[i].sizeimage);
     }
     visible_size.SetSize(base::checked_cast<int>(format.fmt.pix_mp.width),
                          base::checked_cast<int>(format.fmt.pix_mp.height));
     frame_format =
         V4L2Device::V4L2PixFmtToVideoPixelFormat(format.fmt.pix_mp.pixelformat);
   } else {
     bytesperline = base::checked_cast<int>(format.fmt.pix.bytesperline);
     sizeimage = base::checked_cast<int>(format.fmt.pix.sizeimage);
     visible_size.SetSize(base::checked_cast<int>(format.fmt.pix.width),
                          base::checked_cast<int>(format.fmt.pix.height));
     frame_format =
         V4L2Device::V4L2PixFmtToVideoPixelFormat(format.fmt.pix.pixelformat);
   }

   // V4L2 does not provide per-plane bytesperline (bpl) when different
   // components are sharing one physical plane buffer. In this case, it only
   // provides bpl for the first component in the plane. So we can't depend on it
   // for calculating height, because bpl may vary within one physical plane
   // buffer. For example, YUV420 contains 3 components in one physical plane,
   // with Y at 8 bits per pixel, and Cb/Cr at 4 bits per pixel per component,
   // but we only get 8 pits per pixel from bytesperline in physical plane 0.
   // So we need to get total frame bpp from elsewhere to calculate coded height.

   // We need bits per pixel for one component only to calculate
   // coded_width from bytesperline.
   int plane_horiz_bits_per_pixel =
       VideoFrame::PlaneHorizontalBitsPerPixel(frame_format, 0);

   // Adding up bpp for each component will give us total bpp for all components.
   int total_bpp = 0;
   for (size_t i = 0; i < VideoFrame::NumPlanes(frame_format); ++i)
     total_bpp += VideoFrame::PlaneBitsPerPixel(frame_format, i);

   if (sizeimage == 0 || bytesperline == 0 || plane_horiz_bits_per_pixel == 0 ||
       total_bpp == 0 || (bytesperline * 8) % plane_horiz_bits_per_pixel != 0) {
     LOG(ERROR) << "Invalid format provided";
     return coded_size;
   }

   // Coded width can be calculated by taking the first component's bytesperline,
   // which in V4L2 always applies to the first component in physical plane
   // buffer.
   int coded_width = bytesperline * 8 / plane_horiz_bits_per_pixel;
   // Sizeimage is coded_width * coded_height * total_bpp.
   int coded_height = sizeimage * 8 / coded_width / total_bpp;

   coded_size.SetSize(coded_width, coded_height);
   // It's possible the driver gave us a slightly larger sizeimage than what
   // would be calculated from coded size. This is technically not allowed, but
   // some drivers (Exynos) like to have some additional alignment that is not a
   // multiple of bytesperline. The best thing we can do is to compensate by
   // aligning to next full row.
   if (sizeimage > VideoFrame::AllocationSize(frame_format, coded_size))
     coded_size.SetSize(coded_width, coded_height + 1);
   DVLOG(3) << "coded_size=" << coded_size.ToString();

   // 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, VideoFrame::AllocationSize(frame_format, coded_size));

   return coded_size;
 }

 void V4L2Device::GetSupportedResolution(uint32_t pixelformat,
                                         gfx::Size* min_resolution,
                                         gfx::Size* max_resolution) {
   max_resolution->SetSize(0, 0);
   min_resolution->SetSize(0, 0);
   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) {
       if (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);
       }
       if (min_resolution->IsEmpty() ||
           (frame_size.discrete.width <=
                base::checked_cast<uint32_t>(min_resolution->width()) &&
            frame_size.discrete.height <=
                base::checked_cast<uint32_t>(min_resolution->height()))) {
         min_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);
       min_resolution->SetSize(frame_size.stepwise.min_width,
                               frame_size.stepwise.min_height);
       break;
     }
   }
   if (max_resolution->IsEmpty()) {
     max_resolution->SetSize(1920, 1088);
     LOG(ERROR) << "GetSupportedResolution failed to get maximum resolution for "
                << "fourcc " << std::hex << pixelformat
                << ", 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();
   }
 }

 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 = buf_type;

   for (; Ioctl(VIDIOC_ENUM_FMT, &fmtdesc) == 0; ++fmtdesc.index) {
     DVLOG(1) << "Found " << fmtdesc.description << std::hex << " (0x"
              << fmtdesc.pixelformat << ")";
     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;

     VideoDecodeAccelerator::SupportedProfile profile;
     GetSupportedResolution(pixelformat, &profile.min_resolution,
                            &profile.max_resolution);

     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;
 }

 VideoEncodeAccelerator::SupportedProfiles
 V4L2Device::EnumerateSupportedEncodeProfiles() {
   VideoEncodeAccelerator::SupportedProfiles profiles;

   const auto& supported_pixelformats =
       EnumerateSupportedPixelformats(V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);

   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
	// 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() {}

	V4L2Device::~V4L2Device() {}

	// static
	scoped_refptr<V4L2Device> V4L2Device::Create() {
	DVLOG(3) << __PRETTY_FUNCTION__;

	scoped_refptr<V4L2Device> device;

	#if defined(ARCH_CPU_ARMEL)
	device = new TegraV4L2Device();
	if (device->Initialize())
	return device;
	#endif

	device = new GenericV4L2Device();
	if (device->Initialize())
	return 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_YUV422M:
	return PIXEL_FORMAT_I422;

	case V4L2_PIX_FMT_RGB32:
	return PIXEL_FORMAT_ARGB;

	default:
	DVLOG(1) << "Add more cases as needed";
	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";
	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";
	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;
	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) << "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;
	// Total bytes in the frame.
	size_t sizeimage = 0;

	if (V4L2_TYPE_IS_MULTIPLANAR(format.type)) {
	DCHECK_GT(format.fmt.pix_mp.num_planes, 0);
	bytesperline =
	base::checked_cast<int>(format.fmt.pix_mp.plane_fmt[0].bytesperline);
	for (size_t i = 0; i < format.fmt.pix_mp.num_planes; ++i) {
	sizeimage +=
	base::checked_cast<int>(format.fmt.pix_mp.plane_fmt[i].sizeimage);
	}
	visible_size.SetSize(base::checked_cast<int>(format.fmt.pix_mp.width),
	base::checked_cast<int>(format.fmt.pix_mp.height));
	frame_format =
	V4L2Device::V4L2PixFmtToVideoPixelFormat(format.fmt.pix_mp.pixelformat);
	} else {
	bytesperline = base::checked_cast<int>(format.fmt.pix.bytesperline);
	sizeimage = base::checked_cast<int>(format.fmt.pix.sizeimage);
	visible_size.SetSize(base::checked_cast<int>(format.fmt.pix.width),
	base::checked_cast<int>(format.fmt.pix.height));
	frame_format =
	V4L2Device::V4L2PixFmtToVideoPixelFormat(format.fmt.pix.pixelformat);
	}

	// V4L2 does not provide per-plane bytesperline (bpl) when different
	// components are sharing one physical plane buffer. In this case, it only
	// provides bpl for the first component in the plane. So we can't depend on it
	// for calculating height, because bpl may vary within one physical plane
	// buffer. For example, YUV420 contains 3 components in one physical plane,
	// with Y at 8 bits per pixel, and Cb/Cr at 4 bits per pixel per component,
	// but we only get 8 pits per pixel from bytesperline in physical plane 0.
	// So we need to get total frame bpp from elsewhere to calculate coded height.

	// We need bits per pixel for one component only to calculate
	// coded_width from bytesperline.
	int plane_horiz_bits_per_pixel =
	VideoFrame::PlaneHorizontalBitsPerPixel(frame_format, 0);

	// Adding up bpp for each component will give us total bpp for all components.
	int total_bpp = 0;
	for (size_t i = 0; i < VideoFrame::NumPlanes(frame_format); ++i)
	total_bpp += VideoFrame::PlaneBitsPerPixel(frame_format, i);

	if (sizeimage == 0 \|\| bytesperline == 0 \|\| plane_horiz_bits_per_pixel == 0 \|\|
	total_bpp == 0 \|\| (bytesperline * 8) % plane_horiz_bits_per_pixel != 0) {
	LOG(ERROR) << "Invalid format provided";
	return coded_size;
	}

	// Coded width can be calculated by taking the first component's bytesperline,
	// which in V4L2 always applies to the first component in physical plane
	// buffer.
	int coded_width = bytesperline * 8 / plane_horiz_bits_per_pixel;
	// Sizeimage is coded_width * coded_height * total_bpp.
	int coded_height = sizeimage * 8 / coded_width / total_bpp;

	coded_size.SetSize(coded_width, coded_height);
	// It's possible the driver gave us a slightly larger sizeimage than what
	// would be calculated from coded size. This is technically not allowed, but
	// some drivers (Exynos) like to have some additional alignment that is not a
	// multiple of bytesperline. The best thing we can do is to compensate by
	// aligning to next full row.
	if (sizeimage > VideoFrame::AllocationSize(frame_format, coded_size))
	coded_size.SetSize(coded_width, coded_height + 1);
	DVLOG(3) << "coded_size=" << coded_size.ToString();

	// 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, VideoFrame::AllocationSize(frame_format, coded_size));

	return coded_size;
	}

	void V4L2Device::GetSupportedResolution(uint32_t pixelformat,
	gfx::Size* min_resolution,
	gfx::Size* max_resolution) {
	max_resolution->SetSize(0, 0);
	min_resolution->SetSize(0, 0);
	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) {
	if (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);
	}
	if (min_resolution->IsEmpty() \|\|
	(frame_size.discrete.width <=
	base::checked_cast<uint32_t>(min_resolution->width()) &&
	frame_size.discrete.height <=
	base::checked_cast<uint32_t>(min_resolution->height()))) {
	min_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);
	min_resolution->SetSize(frame_size.stepwise.min_width,
	frame_size.stepwise.min_height);
	break;
	}
	}
	if (max_resolution->IsEmpty()) {
	max_resolution->SetSize(1920, 1088);
	LOG(ERROR) << "GetSupportedResolution failed to get maximum resolution for "
	<< "fourcc " << std::hex << pixelformat
	<< ", 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();
	}
	}

	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 = buf_type;

	for (; Ioctl(VIDIOC_ENUM_FMT, &fmtdesc) == 0; ++fmtdesc.index) {
	DVLOG(1) << "Found " << fmtdesc.description << std::hex << " (0x"
	<< fmtdesc.pixelformat << ")";
	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;

	VideoDecodeAccelerator::SupportedProfile profile;
	GetSupportedResolution(pixelformat, &profile.min_resolution,
	&profile.max_resolution);

	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;
	}

	VideoEncodeAccelerator::SupportedProfiles
	V4L2Device::EnumerateSupportedEncodeProfiles() {
	VideoEncodeAccelerator::SupportedProfiles profiles;

	const auto& supported_pixelformats =
	EnumerateSupportedPixelformats(V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);

	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