// Copyright 2021 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifdef UNSAFE_BUFFERS_BUILD
// TODO(crbug.com/40285824): Remove this and spanify to fix the errors.
#pragma allow_unsafe_buffers
#endif

#include "media/gpu/v4l2/v4l2_utils.h"

#include <fcntl.h>
#include <sys/ioctl.h>

#include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <sstream>

#include "base/containers/contains.h"
#include "base/metrics/histogram_functions.h"
#include "base/numerics/safe_conversions.h"
#include "base/posix/eintr_wrapper.h"
#include "base/strings/stringprintf.h"
#include "build/build_config.h"
#include "media/base/media_switches.h"
#include "media/base/video_codecs.h"
#include "media/base/video_frame.h"
#include "media/base/video_types.h"
#include "media/gpu/chromeos/fourcc.h"
#include "media/gpu/macros.h"
#include "media/media_buildflags.h"
#include "ui/gfx/geometry/size.h"

// This has not been accepted upstream.
#ifndef V4L2_PIX_FMT_AV1
#define V4L2_PIX_FMT_AV1 v4l2_fourcc('A', 'V', '0', '1') /* AV1 */
#endif
// This has been upstreamed and backported for ChromeOS, but has not been
// picked up by the Chromium sysroots.
#ifndef V4L2_PIX_FMT_AV1_FRAME
#define V4L2_PIX_FMT_AV1_FRAME v4l2_fourcc('A', 'V', '1', 'F')
#endif

#define MAKE_V4L2_CODEC_PAIR(codec, suffix) \
  std::make_pair(codec##_##suffix, codec)

namespace {
int HandledIoctl(int fd, int request, void* arg) {
  return HANDLE_EINTR(ioctl(fd, request, arg));
}

std::string GetDriverName(const media::IoctlAsCallback& ioctl_cb) {
  struct v4l2_capability caps;
  memset(&caps, 0, sizeof(caps));
  if (ioctl_cb.Run(VIDIOC_QUERYCAP, &caps) != 0) {
    VPLOGF(1) << "ioctl() failed: VIDIOC_QUERYCAP" << ", caps check failed: 0x"
              << std::hex << caps.capabilities;
    return "";
  }

  return std::string(reinterpret_cast<const char*>(caps.driver));
}
}  // namespace
namespace media {

void RecordMediaIoctlUMA(MediaIoctlRequests function) {
  base::UmaHistogramEnumeration("Media.V4l2VideoDecoder.MediaIoctlError",
                                function);
}

void RecordVidiocIoctlErrorUMA(VidiocIoctlRequests function) {
  base::UmaHistogramEnumeration("Media.V4l2VideoDecoder.VidiocIoctlError",
                                function);
}

const char* V4L2MemoryToString(const v4l2_memory memory) {
  switch (memory) {
    case V4L2_MEMORY_MMAP:
      return "V4L2_MEMORY_MMAP";
    case V4L2_MEMORY_USERPTR:
      return "V4L2_MEMORY_USERPTR";
    case V4L2_MEMORY_DMABUF:
      return "V4L2_MEMORY_DMABUF";
    case V4L2_MEMORY_OVERLAY:
      return "V4L2_MEMORY_OVERLAY";
    default:
      return "UNKNOWN";
  }
}

std::string V4L2FormatToString(const struct v4l2_format& format) {
  std::ostringstream s;
  s << "v4l2_format type: " << format.type;
  if (format.type == V4L2_BUF_TYPE_VIDEO_CAPTURE ||
      format.type == V4L2_BUF_TYPE_VIDEO_OUTPUT) {
    //  single-planar
    const struct v4l2_pix_format& pix = format.fmt.pix;
    s << ", width_height: " << gfx::Size(pix.width, pix.height).ToString()
      << ", pixelformat: " << FourccToString(pix.pixelformat)
      << ", field: " << pix.field << ", bytesperline: " << pix.bytesperline
      << ", sizeimage: " << pix.sizeimage;
  } else if (V4L2_TYPE_IS_MULTIPLANAR(format.type)) {
    const struct v4l2_pix_format_mplane& pix_mp = format.fmt.pix_mp;
    // As long as num_planes's type is uint8_t, ostringstream treats it as a
    // char instead of an integer, which is not what we want. Casting
    // pix_mp.num_planes unsigned int solves the issue.
    s << ", width_height: " << gfx::Size(pix_mp.width, pix_mp.height).ToString()
      << ", pixelformat: " << FourccToString(pix_mp.pixelformat)
      << ", field: " << pix_mp.field
      << ", num_planes: " << static_cast<unsigned int>(pix_mp.num_planes);
    for (size_t i = 0; i < pix_mp.num_planes; ++i) {
      const struct v4l2_plane_pix_format& plane_fmt = pix_mp.plane_fmt[i];
      s << ", plane_fmt[" << i << "].sizeimage: " << plane_fmt.sizeimage
        << ", plane_fmt[" << i << "].bytesperline: " << plane_fmt.bytesperline;
    }
  } else {
    s << " unsupported yet.";
  }
  return s.str();
}

std::string V4L2BufferToString(const struct v4l2_buffer& buffer) {
  std::ostringstream s;
  s << "v4l2_buffer type: " << buffer.type << ", memory: " << buffer.memory
    << ", index: " << buffer.index << " bytesused: " << buffer.bytesused
    << ", length: " << buffer.length;
  if (buffer.type == V4L2_BUF_TYPE_VIDEO_CAPTURE ||
      buffer.type == V4L2_BUF_TYPE_VIDEO_OUTPUT) {
    //  single-planar
    if (buffer.memory == V4L2_MEMORY_MMAP) {
      s << ", m.offset: " << buffer.m.offset;
    } else if (buffer.memory == V4L2_MEMORY_USERPTR) {
      s << ", m.userptr: " << buffer.m.userptr;
    } else if (buffer.memory == V4L2_MEMORY_DMABUF) {
      s << ", m.fd: " << buffer.m.fd;
    }
  } else if (V4L2_TYPE_IS_MULTIPLANAR(buffer.type)) {
    for (size_t i = 0; i < buffer.length; ++i) {
      const struct v4l2_plane& plane = buffer.m.planes[i];
      s << ", m.planes[" << i << "](bytesused: " << plane.bytesused
        << ", length: " << plane.length
        << ", data_offset: " << plane.data_offset;
      if (buffer.memory == V4L2_MEMORY_MMAP) {
        s << ", m.mem_offset: " << plane.m.mem_offset;
      } else if (buffer.memory == V4L2_MEMORY_USERPTR) {
        s << ", m.userptr: " << plane.m.userptr;
      } else if (buffer.memory == V4L2_MEMORY_DMABUF) {
        s << ", m.fd: " << plane.m.fd;
      }
      s << ")";
    }
  } else {
    s << " unsupported yet.";
  }
  return s.str();
}

VideoCodecProfile V4L2ProfileToVideoCodecProfile(uint32_t v4l2_codec,
                                                 uint32_t v4l2_profile) {
  switch (v4l2_codec) {
    case V4L2_CID_MPEG_VIDEO_H264_PROFILE:
      switch (v4l2_profile) {
        // H264 Stereo amd Multiview High are not tested and the use is
        // minuscule, skip.
        case V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE:
        case V4L2_MPEG_VIDEO_H264_PROFILE_CONSTRAINED_BASELINE:
          return H264PROFILE_BASELINE;
        case V4L2_MPEG_VIDEO_H264_PROFILE_MAIN:
          return H264PROFILE_MAIN;
        case V4L2_MPEG_VIDEO_H264_PROFILE_EXTENDED:
          return H264PROFILE_EXTENDED;
        case V4L2_MPEG_VIDEO_H264_PROFILE_HIGH:
          return H264PROFILE_HIGH;
      }
      break;
    case V4L2_CID_MPEG_VIDEO_VP8_PROFILE:
      switch (v4l2_profile) {
        case V4L2_MPEG_VIDEO_VP8_PROFILE_0:
        case V4L2_MPEG_VIDEO_VP8_PROFILE_1:
        case V4L2_MPEG_VIDEO_VP8_PROFILE_2:
        case V4L2_MPEG_VIDEO_VP8_PROFILE_3:
          return VP8PROFILE_ANY;
      }
      break;
    case V4L2_CID_MPEG_VIDEO_VP9_PROFILE:
      switch (v4l2_profile) {
        // VP9 Profile 1 and 3 are not tested and the use is minuscule, skip.
        case V4L2_MPEG_VIDEO_VP9_PROFILE_0:
          return VP9PROFILE_PROFILE0;
        case V4L2_MPEG_VIDEO_VP9_PROFILE_2:
          return VP9PROFILE_PROFILE2;
      }
      break;
#if BUILDFLAG(ENABLE_HEVC_PARSER_AND_HW_DECODER)
    case V4L2_CID_MPEG_VIDEO_HEVC_PROFILE:
      switch (v4l2_profile) {
        case V4L2_MPEG_VIDEO_HEVC_PROFILE_MAIN:
          return HEVCPROFILE_MAIN;
        case V4L2_MPEG_VIDEO_HEVC_PROFILE_MAIN_STILL_PICTURE:
          return HEVCPROFILE_MAIN_STILL_PICTURE;
        case V4L2_MPEG_VIDEO_HEVC_PROFILE_MAIN_10:
          return HEVCPROFILE_MAIN10;
      }
      break;
#endif
#if BUILDFLAG(IS_CHROMEOS)
    case V4L2_CID_MPEG_VIDEO_AV1_PROFILE:
      switch (v4l2_profile) {
        case V4L2_MPEG_VIDEO_AV1_PROFILE_MAIN:
          return AV1PROFILE_PROFILE_MAIN;
        case V4L2_MPEG_VIDEO_AV1_PROFILE_HIGH:
          return AV1PROFILE_PROFILE_HIGH;
        case V4L2_MPEG_VIDEO_AV1_PROFILE_PROFESSIONAL:
          return AV1PROFILE_PROFILE_PRO;
      }
      break;
#endif
  }
  return VIDEO_CODEC_PROFILE_UNKNOWN;
}

size_t GetNumPlanesOfV4L2PixFmt(uint32_t pix_fmt) {
  std::optional<Fourcc> fourcc = Fourcc::FromV4L2PixFmt(pix_fmt);
  if (fourcc && fourcc->IsMultiPlanar()) {
    return VideoFrame::NumPlanes(fourcc->ToVideoPixelFormat());
  }
  return 1u;
}

std::optional<VideoFrameLayout> V4L2FormatToVideoFrameLayout(
    const struct v4l2_format& format) {
  if (!V4L2_TYPE_IS_MULTIPLANAR(format.type)) {
    VLOGF(1) << "v4l2_buf_type is not multiplanar: " << std::hex << "0x"
             << format.type;
    return std::nullopt;
  }
  const v4l2_pix_format_mplane& pix_mp = format.fmt.pix_mp;
  const uint32_t& pix_fmt = pix_mp.pixelformat;
  const auto video_fourcc = Fourcc::FromV4L2PixFmt(pix_fmt);
  if (!video_fourcc) {
    VLOGF(1) << "Failed to convert pixel format to VideoPixelFormat: "
             << FourccToString(pix_fmt);
    return std::nullopt;
  }
  const VideoPixelFormat video_format = video_fourcc->ToVideoPixelFormat();
  const size_t num_buffers = pix_mp.num_planes;
  const size_t num_color_planes = VideoFrame::NumPlanes(video_format);
  if (num_color_planes == 0) {
    VLOGF(1) << "Unsupported video format for NumPlanes(): "
             << VideoPixelFormatToString(video_format);
    return std::nullopt;
  }
  if (num_buffers > num_color_planes) {
    VLOGF(1) << "pix_mp.num_planes: " << num_buffers
             << " should not be larger than NumPlanes("
             << VideoPixelFormatToString(video_format)
             << "): " << num_color_planes;
    return std::nullopt;
  }
  // Reserve capacity in advance to prevent unnecessary vector reallocation.
  std::vector<ColorPlaneLayout> planes;
  planes.reserve(num_color_planes);
  for (size_t i = 0; i < num_buffers; ++i) {
    const v4l2_plane_pix_format& plane_format = pix_mp.plane_fmt[i];
    planes.emplace_back(static_cast<int32_t>(plane_format.bytesperline), 0u,
                        plane_format.sizeimage);
  }
  // For the case that #color planes > #buffers, it fills stride of color
  // plane which does not map to buffer.
  // Right now only some pixel formats are supported: NV12, YUV420, YVU420.
  if (num_color_planes > num_buffers) {
    const int32_t y_stride = planes[0].stride;
    // Note that y_stride is from v4l2 bytesperline and its type is uint32_t.
    // It is safe to cast to size_t.
    const size_t y_stride_abs = static_cast<size_t>(y_stride);
    switch (pix_fmt) {
      case V4L2_PIX_FMT_NV12:
        // The stride of UV is the same as Y in NV12.
        // The height is half of Y plane.
        planes.emplace_back(y_stride, y_stride_abs * pix_mp.height,
                            y_stride_abs * pix_mp.height / 2);
        DCHECK_EQ(2u, planes.size());
        break;
      case V4L2_PIX_FMT_YUV420:
      case V4L2_PIX_FMT_YVU420: {
        // The spec claims that two Cx rows (including padding) is exactly as
        // long as one Y row (including padding). So stride of Y must be even
        // number.
        if (y_stride % 2 != 0 || pix_mp.height % 2 != 0) {
          VLOGF(1) << "Plane-Y stride and height should be even; stride: "
                   << y_stride << ", height: " << pix_mp.height;
          return std::nullopt;
        }
        const int32_t half_stride = y_stride / 2;
        const size_t plane_0_area = y_stride_abs * pix_mp.height;
        const size_t plane_1_area = plane_0_area / 4;
        planes.emplace_back(half_stride, plane_0_area, plane_1_area);
        planes.emplace_back(half_stride, plane_0_area + plane_1_area,
                            plane_1_area);
        DCHECK_EQ(3u, planes.size());
        break;
      }
      default:
        VLOGF(1) << "Cannot derive stride for each plane for pixel format "
                 << FourccToString(pix_fmt);
        return std::nullopt;
    }
  }

  // Some V4L2 devices expect buffers to be page-aligned. We cannot detect
  // such devices individually, so set this as a video frame layout property.
  constexpr size_t buffer_alignment = 0x1000;
  if (num_buffers == 1) {
    return VideoFrameLayout::CreateWithPlanes(
        video_format, gfx::Size(pix_mp.width, pix_mp.height), std::move(planes),
        buffer_alignment);
  } else {
    return VideoFrameLayout::CreateMultiPlanar(
        video_format, gfx::Size(pix_mp.width, pix_mp.height), std::move(planes),
        buffer_alignment);
  }
}

namespace {
using v4l2_enum_type = decltype(V4L2_PIX_FMT_H264);
// Correspondence from V4L2 codec described as a pixel format to a Control ID.
static const std::map<v4l2_enum_type, v4l2_enum_type>
    kV4L2CodecPixFmtToProfileCID = {
        {V4L2_PIX_FMT_H264, V4L2_CID_MPEG_VIDEO_H264_PROFILE},
        {V4L2_PIX_FMT_H264_SLICE, V4L2_CID_MPEG_VIDEO_H264_PROFILE},
#if BUILDFLAG(ENABLE_HEVC_PARSER_AND_HW_DECODER)
        {V4L2_PIX_FMT_HEVC_SLICE, V4L2_CID_MPEG_VIDEO_HEVC_PROFILE},
#endif  // BUILDFLAG(ENABLE_HEVC_PARSER_AND_HW_DECODER)
        {V4L2_PIX_FMT_VP8, V4L2_CID_MPEG_VIDEO_VP8_PROFILE},
        {V4L2_PIX_FMT_VP8_FRAME, V4L2_CID_MPEG_VIDEO_VP8_PROFILE},
        {V4L2_PIX_FMT_VP9, V4L2_CID_MPEG_VIDEO_VP9_PROFILE},
        {V4L2_PIX_FMT_VP9_FRAME, V4L2_CID_MPEG_VIDEO_VP9_PROFILE},
#if BUILDFLAG(IS_CHROMEOS)
        {V4L2_PIX_FMT_AV1, V4L2_CID_MPEG_VIDEO_AV1_PROFILE},
        {V4L2_PIX_FMT_AV1_FRAME, V4L2_CID_MPEG_VIDEO_AV1_PROFILE},
#endif
};

// Default VideoCodecProfiles associated to a V4L2 Codec Control ID.
static const std::map<v4l2_enum_type, std::vector<VideoCodecProfile>>
    kDefaultVideoCodecProfilesForProfileCID = {
        {V4L2_CID_MPEG_VIDEO_H264_PROFILE,
         {
             H264PROFILE_BASELINE,
             H264PROFILE_MAIN,
             H264PROFILE_HIGH,
         }},
#if BUILDFLAG(ENABLE_HEVC_PARSER_AND_HW_DECODER)
        {V4L2_CID_MPEG_VIDEO_HEVC_PROFILE,
         {HEVCPROFILE_MAIN, HEVCPROFILE_MAIN10}},
#endif  // BUILDFLAG(ENABLE_HEVC_PARSER_AND_HW_DECODER)
        {V4L2_CID_MPEG_VIDEO_VP8_PROFILE, {VP8PROFILE_ANY}},
        {V4L2_CID_MPEG_VIDEO_VP9_PROFILE, {VP9PROFILE_PROFILE0}},
#if BUILDFLAG(IS_CHROMEOS)
        {V4L2_CID_MPEG_VIDEO_AV1_PROFILE, {AV1PROFILE_PROFILE_MAIN}},
#endif
};

// Correspondence from a VideoCodecProfiles to V4L2 codec described
// as a pixel format.
static const std::map<VideoCodecProfile,
                      std::pair<v4l2_enum_type, v4l2_enum_type>>
    kVideoCodecProfileToV4L2CodecPixFmt = {
        {H264PROFILE_BASELINE, MAKE_V4L2_CODEC_PAIR(V4L2_PIX_FMT_H264, SLICE)},
        {H264PROFILE_MAIN, MAKE_V4L2_CODEC_PAIR(V4L2_PIX_FMT_H264, SLICE)},
        {H264PROFILE_HIGH, MAKE_V4L2_CODEC_PAIR(V4L2_PIX_FMT_H264, SLICE)},
#if BUILDFLAG(ENABLE_HEVC_PARSER_AND_HW_DECODER)
        {HEVCPROFILE_MAIN, MAKE_V4L2_CODEC_PAIR(V4L2_PIX_FMT_HEVC, SLICE)},
        {HEVCPROFILE_MAIN10, MAKE_V4L2_CODEC_PAIR(V4L2_PIX_FMT_HEVC, SLICE)},
#endif  // BUILDFLAG(ENABLE_HEVC_PARSER_AND_HW_DECODER)
        {VP8PROFILE_ANY, MAKE_V4L2_CODEC_PAIR(V4L2_PIX_FMT_VP8, FRAME)},
        {VP9PROFILE_PROFILE0, MAKE_V4L2_CODEC_PAIR(V4L2_PIX_FMT_VP9, FRAME)},
        {VP9PROFILE_PROFILE2, MAKE_V4L2_CODEC_PAIR(V4L2_PIX_FMT_VP9, FRAME)},
#if BUILDFLAG(IS_CHROMEOS)
        {AV1PROFILE_PROFILE_MAIN,
         MAKE_V4L2_CODEC_PAIR(V4L2_PIX_FMT_AV1, FRAME)},
#endif
};

}  // namespace

std::vector<SVCScalabilityMode> GetSupportedScalabilityModesForV4L2Codec(
    const IoctlAsCallback& ioctl_cb,
    VideoCodecProfile media_profile) {
  std::vector<SVCScalabilityMode> scalability_modes;
  scalability_modes.push_back(SVCScalabilityMode::kL1T1);

  if (base::FeatureList::IsEnabled(kV4L2H264TemporalLayerHWEncoding) &&
      media_profile >= H264PROFILE_MIN && media_profile <= H264PROFILE_MAX) {
    struct v4l2_queryctrl query_ctrl;
    memset(&query_ctrl, 0, sizeof(query_ctrl));
    query_ctrl.id = V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING;
    if (ioctl_cb.Run(VIDIOC_QUERYCTRL, &query_ctrl) != kIoctlOk) {
      DPLOG(WARNING) << "h.264 hierarchical coding not supported.";
      return {};
    }

    memset(&query_ctrl, 0, sizeof(query_ctrl));
    query_ctrl.id = V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_TYPE;
    if (ioctl_cb.Run(VIDIOC_QUERYCTRL, &query_ctrl) != kIoctlOk) {
      DPLOG(WARNING) << "h.264 hierarchical coding type not supported.";
      return {};
    }

    struct v4l2_querymenu query_menu = {
        .id = query_ctrl.id, .index = static_cast<__u32>(query_ctrl.minimum)};
    for (; static_cast<int>(query_menu.index) <= query_ctrl.maximum;
         query_menu.index++) {
      if (ioctl_cb.Run(VIDIOC_QUERYMENU, &query_menu) != kIoctlOk) {
        continue;
      }

      if (query_menu.index == V4L2_MPEG_VIDEO_H264_HIERARCHICAL_CODING_P) {
        break;
      }
    }

    if (query_menu.index != V4L2_MPEG_VIDEO_H264_HIERARCHICAL_CODING_P) {
      DPLOG(WARNING) << "h.264 hierarchical P coding not supported.";
      return {};
    }

    memset(&query_ctrl, 0, sizeof(query_ctrl));
    query_ctrl.id = V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_LAYER;
    if (ioctl_cb.Run(VIDIOC_QUERYCTRL, &query_ctrl) != kIoctlOk) {
      DPLOG(WARNING) << "Unable to determine the number of layers supported.";
      return {};
    }

    if (query_ctrl.maximum >= 2) {
      DVLOGF(2) << "h.264 kL1T2 scalability mode supported.";
      scalability_modes.push_back(SVCScalabilityMode::kL1T2);
    }
  }

  return scalability_modes;
}

std::vector<VideoCodecProfile> EnumerateSupportedProfilesForV4L2Codec(
    const IoctlAsCallback& ioctl_cb,
    uint32_t codec_as_pix_fmt) {
  if (!base::Contains(kV4L2CodecPixFmtToProfileCID, codec_as_pix_fmt)) {
    // This is OK: there are many codecs that are not supported by Chrome.
    VLOGF(4) << "Unsupported codec: " << FourccToString(codec_as_pix_fmt);
    return {};
  }
  const auto profile_cid = kV4L2CodecPixFmtToProfileCID.at(codec_as_pix_fmt);

  v4l2_queryctrl query_ctrl = {.id = static_cast<__u32>(profile_cid)};
  if (ioctl_cb.Run(VIDIOC_QUERYCTRL, &query_ctrl) != kIoctlOk) {
    // This happens for example for VP8 on Hana MTK8173 at the time of writing.
    DVLOGF(4) << "Driver doesn't support enumerating "
              << FourccToString(codec_as_pix_fmt)
              << " profiles, using default ones.";
    DCHECK(
        base::Contains(kDefaultVideoCodecProfilesForProfileCID, profile_cid));
    return kDefaultVideoCodecProfilesForProfileCID.at(profile_cid);
  }

  std::vector<VideoCodecProfile> profiles;

  v4l2_querymenu query_menu = {.id = query_ctrl.id,
                               .index = static_cast<__u32>(query_ctrl.minimum)};
  for (; static_cast<int>(query_menu.index) <= query_ctrl.maximum;
       query_menu.index++) {
    if (ioctl_cb.Run(VIDIOC_QUERYMENU, &query_menu) != kIoctlOk) {
      continue;
    }
    const VideoCodecProfile profile =
        V4L2ProfileToVideoCodecProfile(profile_cid, query_menu.index);
    DVLOGF_IF(4, profile == VIDEO_CODEC_PROFILE_UNKNOWN)
        << "Profile: " << query_menu.name
        << " not supported by Chrome, skipping.";

    if (profile != VIDEO_CODEC_PROFILE_UNKNOWN) {
      profiles.push_back(profile);
      DVLOGF(4) << "Found supported profile: " << query_menu.name;
    }
  }

  // Erase duplicated profiles. This is needed because H264PROFILE_BASELINE maps
  // to both V4L2_MPEG_VIDEO_H264_PROFILE__BASELINE/CONSTRAINED_BASELINE
  std::ranges::sort(profiles);
  auto to_remove = std::ranges::unique(profiles);
  profiles.erase(to_remove.begin(), to_remove.end());
  return profiles;
}

std::vector<uint32_t> EnumerateSupportedPixFmts(const IoctlAsCallback& ioctl_cb,
                                                v4l2_buf_type buf_type) {
  DCHECK(buf_type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE ||
         buf_type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);

  std::vector<v4l2_enum_type> pix_fmts;
  v4l2_fmtdesc fmtdesc = {.type = buf_type};
  for (; ioctl_cb.Run(VIDIOC_ENUM_FMT, &fmtdesc) == kIoctlOk; ++fmtdesc.index) {
    DVLOGF(4) << "Enumerated "
              << (buf_type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
                      ? "codec: "
                      : "pixel format: ")
              << FourccToString(fmtdesc.pixelformat) << " ("
              << fmtdesc.description << ")";
    pix_fmts.push_back(fmtdesc.pixelformat);
  }

  return pix_fmts;
}

void GetSupportedResolution(const IoctlAsCallback& ioctl_cb,
                            uint32_t pixelformat,
                            gfx::Size* min_resolution,
                            gfx::Size* max_resolution) {
  constexpr gfx::Size kDefaultMaxCodedSize(1920, 1088);
  *max_resolution = kDefaultMaxCodedSize;
  constexpr gfx::Size kDefaultMinCodedSize(16, 16);
  *min_resolution = kDefaultMinCodedSize;

  v4l2_frmsizeenum frame_size;
  memset(&frame_size, 0, sizeof(frame_size));
  frame_size.pixel_format = pixelformat;
  if (ioctl_cb.Run(VIDIOC_ENUM_FRAMESIZES, &frame_size) == kIoctlOk) {
    if (frame_size.type == V4L2_FRMSIZE_TYPE_STEPWISE) {
      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);
    } else {
#if BUILDFLAG(IS_CHROMEOS)
      // All of Chrome-supported implementations support STEPWISE only.
      CHECK_EQ(frame_size.type, V4L2_FRMSIZE_TYPE_STEPWISE);
#endif
    }
  } else {
    DLOGF(INFO) << "VIDIOC_ENUM_FRAMESIZES failed, using default values";
  }
}

uint32_t VideoCodecProfileToV4L2PixFmt(VideoCodecProfile profile,
                                       bool slice_based) {
  CHECK(base::Contains(kVideoCodecProfileToV4L2CodecPixFmt, profile))
      << "Unsupported profile: " << GetProfileName(profile);

  const auto& v4l2_pix_fmt = kVideoCodecProfileToV4L2CodecPixFmt.at(profile);
  return slice_based ? v4l2_pix_fmt.first : v4l2_pix_fmt.second;
}

base::TimeDelta TimeValToTimeDelta(const struct timeval& timeval) {
  struct timespec ts;
  const struct timeval temp_timeval = timeval;
  TIMEVAL_TO_TIMESPEC(&temp_timeval, &ts);
  return base::TimeDelta::FromTimeSpec(ts);
}

struct timeval TimeDeltaToTimeVal(base::TimeDelta time_delta) {
  const int64_t time_delta_linear = time_delta.InMicroseconds();
  constexpr int64_t kMicrosecondsPerSecond = 1000 * 1000;
  return {.tv_sec = base::checked_cast<__time_t>(time_delta_linear /
                                                 kMicrosecondsPerSecond),
          .tv_usec = base::checked_cast<__suseconds_t>(time_delta_linear %
                                                       kMicrosecondsPerSecond)};
}

std::optional<SupportedVideoDecoderConfigs> GetSupportedV4L2DecoderConfigs() {
  SupportedVideoDecoderConfigs supported_media_configs;
  std::vector<std::string> candidate_paths;

#if BUILDFLAG(IS_CHROMEOS)
  constexpr char kVideoDevicePattern[] = "/dev/video-dec0";
  candidate_paths.push_back(kVideoDevicePattern);
#else
  constexpr char kVideoDevicePattern[] = "/dev/video";
  constexpr int kMaxDevices = 256;
  candidate_paths.reserve(kMaxDevices);
  for (int i = 0; i < kMaxDevices; ++i) {
    candidate_paths.push_back(
        base::StringPrintf("%s%d", kVideoDevicePattern, i));
  }
#endif

  for (const auto& path : candidate_paths) {
    base::ScopedFD device_fd(
        HANDLE_EINTR(open(path.c_str(), O_RDWR | O_NONBLOCK | O_CLOEXEC)));
    if (!device_fd.is_valid()) {
      PLOG(WARNING) << "Could not open " << path;
      continue;
    }

    std::vector<uint32_t> v4l2_codecs = EnumerateSupportedPixFmts(
        base::BindRepeating(&HandledIoctl, device_fd.get()),
        V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE);

    for (const uint32_t v4l2_codec : v4l2_codecs) {
      const std::vector<VideoCodecProfile> media_codec_profiles =
          EnumerateSupportedProfilesForV4L2Codec(
              base::BindRepeating(&HandledIoctl, device_fd.get()), v4l2_codec);

      gfx::Size min_coded_size;
      gfx::Size max_coded_size;
      GetSupportedResolution(
          base::BindRepeating(&HandledIoctl, device_fd.get()), v4l2_codec,
          &min_coded_size, &max_coded_size);

      for (const auto& profile : media_codec_profiles) {
        supported_media_configs.emplace_back(SupportedVideoDecoderConfig(
            profile, profile, min_coded_size, max_coded_size,
#if BUILDFLAG(USE_CHROMEOS_PROTECTED_MEDIA)
            /*allow_encrypted=*/true,
#else
            /*allow_encrypted=*/false,
#endif
            /*require_encrypted=*/false));
      }
    }
  }

#if DCHECK_IS_ON()
  for (const auto& config : supported_media_configs) {
    DVLOGF(3) << "Enumerated " << GetProfileName(config.profile_min) << " ("
              << config.coded_size_min.ToString() << "-"
              << config.coded_size_max.ToString() << ")";
  }
#endif

  return supported_media_configs;
}

bool IsV4L2DecoderStateful() {
  constexpr char kVideoDeviceDriverPath[] = "/dev/video-dec0";
  base::ScopedFD device_fd(HANDLE_EINTR(
      open(kVideoDeviceDriverPath, O_RDWR | O_NONBLOCK | O_CLOEXEC)));
  if (!device_fd.is_valid()) {
    return false;
  }

  std::vector<uint32_t> v4l2_codecs = EnumerateSupportedPixFmts(
      base::BindRepeating(&HandledIoctl, device_fd.get()),
      V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE);

  // V4L2 stateful formats (don't end up with _SLICE or _FRAME) supported.
  constexpr std::array<uint32_t, 4> kSupportedStatefulInputCodecs = {
      V4L2_PIX_FMT_H264,
      V4L2_PIX_FMT_VP8,
      V4L2_PIX_FMT_VP9,
  };

  return std::find_first_of(v4l2_codecs.begin(), v4l2_codecs.end(),
                            kSupportedStatefulInputCodecs.begin(),
                            kSupportedStatefulInputCodecs.end()) !=
         v4l2_codecs.end();
}

bool IsVislDriver() {
  constexpr char kVideoDeviceDriverPath[] = "/dev/video-dec0";
  base::ScopedFD device_fd(HANDLE_EINTR(
      open(kVideoDeviceDriverPath, O_RDWR | O_NONBLOCK | O_CLOEXEC)));
  if (!device_fd.is_valid()) {
    return false;
  }

  std::string v4l2_driver_name =
      GetDriverName(base::BindRepeating(&HandledIoctl, device_fd.get()));

  return v4l2_driver_name.compare("visl") == 0;
}

#ifndef NDEBUG
template <class T>
std::string ControlToString(const T& a, const std::string control) {
  std::ostringstream s;
  constexpr uint32_t kPadding = 40;
  const uint32_t len = kPadding - control.size();
  s << control << std::setw(len) << ": ";
  if (control.compare("flags") == 0) {
    s << "0x" << std::hex << +a << std::endl;
  } else {
    s << std::dec << +a << std::endl;
  }

  return s.str();
}

template <typename T, size_t N>
std::string ControlToString(const T (&arr)[N], const std::string control) {
  std::ostringstream s;
  const uint32_t pad = sizeof(arr[0]) * 2;
  s << control << "[" << N << "]:" << std::endl;
  for (const auto& x : arr) {
    s << std::setw(pad) << std::dec << +x << " ";
  }
  s << std::endl;
  return s.str();
}

template <typename T, size_t N, size_t M>
std::string ControlToString(const T (&arr)[N][M], const std::string control) {
  std::ostringstream s;
  const uint32_t pad = sizeof(arr[0][0]) * 2;
  s << control << "[" << N << "][" << M << "]:" << std::endl;
  for (const auto& inner : arr) {
    for (const auto& x : inner) {
      s << std::setw(pad) << std::dec << +x;
    }
    s << std::endl;
  }

  return s.str();
}

#define CONTROL(base, control)                     \
  do {                                             \
    s << ControlToString(base->control, #control); \
  } while (0)

static std::string PrintStatelessAV1Control(
    const struct v4l2_ext_control* ext_ctrls) {
  std::ostringstream s;
  s << "av1" << std::endl;
  switch (ext_ctrls->id) {
    case V4L2_CID_STATELESS_AV1_SEQUENCE: {
      s << "V4L2_CID_STATELESS_AV1_SEQUENCE" << std::endl;
      const struct v4l2_ctrl_av1_sequence* ctrl =
          static_cast<const struct v4l2_ctrl_av1_sequence*>(ext_ctrls->ptr);
      CONTROL(ctrl, flags);
      CONTROL(ctrl, seq_profile);
      CONTROL(ctrl, order_hint_bits);
      CONTROL(ctrl, bit_depth);
      CONTROL(ctrl, reserved);
      CONTROL(ctrl, max_frame_width_minus_1);
      CONTROL(ctrl, max_frame_height_minus_1);
    } break;
    case V4L2_CID_STATELESS_AV1_TILE_GROUP_ENTRY: {
      s << "V4L2_CID_STATELESS_AV1_TILE_GROUP_ENTRY" << std::endl;
      const struct v4l2_ctrl_av1_tile_group_entry* group_entry =
          static_cast<const struct v4l2_ctrl_av1_tile_group_entry*>(
              ext_ctrls->ptr);
      CONTROL(group_entry, tile_offset);
      CONTROL(group_entry, tile_size);
      CONTROL(group_entry, tile_row);
      CONTROL(group_entry, tile_col);
    } break;
    case V4L2_CID_STATELESS_AV1_FRAME: {
      s << "V4L2_CID_STATELESS_AV1_FRAME" << std::endl;
      const struct v4l2_ctrl_av1_frame* frame =
          static_cast<const struct v4l2_ctrl_av1_frame*>(ext_ctrls->ptr);

      const struct v4l2_av1_tile_info* tile_info =
          static_cast<const struct v4l2_av1_tile_info*>(&frame->tile_info);
      CONTROL(tile_info, flags);
      CONTROL(tile_info, context_update_tile_id);
      CONTROL(tile_info, tile_cols);
      CONTROL(tile_info, tile_rows);
      CONTROL(tile_info, mi_col_starts);
      CONTROL(tile_info, mi_row_starts);
      CONTROL(tile_info, width_in_sbs_minus_1);
      CONTROL(tile_info, height_in_sbs_minus_1);
      CONTROL(tile_info, tile_size_bytes);
      CONTROL(tile_info, reserved);

      const struct v4l2_av1_quantization* quantization =
          static_cast<const struct v4l2_av1_quantization*>(
              &frame->quantization);
      CONTROL(quantization, flags);
      CONTROL(quantization, base_q_idx);
      CONTROL(quantization, delta_q_y_dc);
      CONTROL(quantization, delta_q_u_dc);
      CONTROL(quantization, delta_q_u_ac);
      CONTROL(quantization, delta_q_v_dc);
      CONTROL(quantization, delta_q_v_ac);
      CONTROL(quantization, qm_y);
      CONTROL(quantization, qm_u);
      CONTROL(quantization, qm_v);
      CONTROL(quantization, delta_q_res);

      CONTROL(frame, superres_denom);

      const struct v4l2_av1_segmentation* segmentation =
          static_cast<const struct v4l2_av1_segmentation*>(
              &frame->segmentation);
      CONTROL(segmentation, flags);
      CONTROL(segmentation, last_active_seg_id);
      CONTROL(segmentation, feature_enabled);
      CONTROL(segmentation, feature_data);

      const struct v4l2_av1_loop_filter* loop_filter =
          static_cast<const struct v4l2_av1_loop_filter*>(&frame->loop_filter);
      CONTROL(loop_filter, flags);
      CONTROL(loop_filter, level);
      CONTROL(loop_filter, sharpness);
      CONTROL(loop_filter, ref_deltas);
      CONTROL(loop_filter, mode_deltas);
      CONTROL(loop_filter, delta_lf_res);

      const struct v4l2_av1_cdef* cdef =
          static_cast<const struct v4l2_av1_cdef*>(&frame->cdef);
      CONTROL(cdef, damping_minus_3);
      CONTROL(cdef, bits);
      CONTROL(cdef, y_pri_strength);
      CONTROL(cdef, y_sec_strength);
      CONTROL(cdef, uv_pri_strength);
      CONTROL(cdef, uv_sec_strength);

      CONTROL(frame, skip_mode_frame);
      CONTROL(frame, primary_ref_frame);

      const struct v4l2_av1_loop_restoration* loop_restoration =
          static_cast<const struct v4l2_av1_loop_restoration*>(
              &frame->loop_restoration);
      CONTROL(loop_restoration, flags);
      CONTROL(loop_restoration, lr_unit_shift);
      CONTROL(loop_restoration, lr_uv_shift);
      CONTROL(loop_restoration, reserved);
      CONTROL(loop_restoration, frame_restoration_type);
      CONTROL(loop_restoration, loop_restoration_size);

      const struct v4l2_av1_global_motion* global_motion =
          static_cast<const struct v4l2_av1_global_motion*>(
              &frame->global_motion);
      CONTROL(global_motion, flags);
      CONTROL(global_motion, type);
      CONTROL(global_motion, params);
      CONTROL(global_motion, invalid);
      CONTROL(global_motion, reserved);

      CONTROL(frame, flags);
      CONTROL(frame, frame_type);
      CONTROL(frame, order_hint);
      CONTROL(frame, upscaled_width);
      CONTROL(frame, interpolation_filter);
      CONTROL(frame, tx_mode);
      CONTROL(frame, frame_width_minus_1);
      CONTROL(frame, frame_height_minus_1);
      CONTROL(frame, render_width_minus_1);
      CONTROL(frame, render_height_minus_1);
      CONTROL(frame, current_frame_id);
      CONTROL(frame, buffer_removal_time);
      CONTROL(frame, reserved);
      CONTROL(frame, order_hints);
      CONTROL(frame, reference_frame_ts);
      CONTROL(frame, ref_frame_idx);
      CONTROL(frame, refresh_frame_flags);
    } break;
  }
  return s.str();
}

static std::string PrintStatelessVP8Control(
    const struct v4l2_ext_control* ext_ctrls) {
  DCHECK_EQ(ext_ctrls->id, static_cast<uint32_t>(V4L2_CID_STATELESS_VP8_FRAME));

  std::ostringstream s;
  s << "vp8" << std::endl;
  s << "V4L2_CID_STATELESS_VP8_FRAME" << std::endl;
  const struct v4l2_ctrl_vp8_frame* ctrl =
      static_cast<const struct v4l2_ctrl_vp8_frame*>(ext_ctrls->ptr);

  const struct v4l2_vp8_segment* segment =
      static_cast<const struct v4l2_vp8_segment*>(&ctrl->segment);
  CONTROL(segment, quant_update);
  CONTROL(segment, lf_update);
  CONTROL(segment, segment_probs);
  CONTROL(segment, padding);
  CONTROL(segment, flags);

  const struct v4l2_vp8_loop_filter* lf =
      static_cast<const struct v4l2_vp8_loop_filter*>(&ctrl->lf);
  CONTROL(lf, ref_frm_delta);
  CONTROL(lf, mb_mode_delta);
  CONTROL(lf, sharpness_level);
  CONTROL(lf, level);
  CONTROL(lf, padding);
  CONTROL(lf, flags);

  const struct v4l2_vp8_quantization* quant =
      static_cast<const struct v4l2_vp8_quantization*>(&ctrl->quant);
  CONTROL(quant, y_ac_qi);
  CONTROL(quant, y_dc_delta);
  CONTROL(quant, y2_dc_delta);
  CONTROL(quant, y2_ac_delta);
  CONTROL(quant, uv_dc_delta);
  CONTROL(quant, uv_ac_delta);
  CONTROL(quant, padding);

  const struct v4l2_vp8_entropy* entropy =
      static_cast<const struct v4l2_vp8_entropy*>(&ctrl->entropy);
  // TODO(frkoenig): how should this be displayed?
  // coeff_probs[4][8][3][11]
  CONTROL(entropy, y_mode_probs);
  CONTROL(entropy, uv_mode_probs);
  CONTROL(entropy, mv_probs);
  CONTROL(entropy, padding);

  const struct v4l2_vp8_entropy_coder_state* coder_state =
      static_cast<const struct v4l2_vp8_entropy_coder_state*>(
          &ctrl->coder_state);
  CONTROL(coder_state, range);
  CONTROL(coder_state, value);
  CONTROL(coder_state, bit_count);
  CONTROL(coder_state, padding);

  CONTROL(ctrl, width);
  CONTROL(ctrl, height);
  CONTROL(ctrl, horizontal_scale);
  CONTROL(ctrl, vertical_scale);
  CONTROL(ctrl, version);
  CONTROL(ctrl, prob_skip_false);
  CONTROL(ctrl, prob_intra);
  CONTROL(ctrl, prob_last);
  CONTROL(ctrl, prob_gf);
  CONTROL(ctrl, num_dct_parts);
  CONTROL(ctrl, first_part_size);
  CONTROL(ctrl, first_part_header_bits);
  CONTROL(ctrl, dct_part_sizes);
  CONTROL(ctrl, last_frame_ts);
  CONTROL(ctrl, golden_frame_ts);
  CONTROL(ctrl, alt_frame_ts);
  CONTROL(ctrl, flags);

  return s.str();
}

static std::string PrintStatelessVP9Control(
    const struct v4l2_ext_control* ext_ctrls) {
  DCHECK_EQ(ext_ctrls->id, static_cast<uint32_t>(V4L2_CID_STATELESS_VP9_FRAME));

  std::ostringstream s;
  s << "vp9" << std::endl;
  s << "V4L2_CID_STATELESS_VP9_FRAME" << std::endl;
  const struct v4l2_ctrl_vp9_frame* ctrl =
      static_cast<const struct v4l2_ctrl_vp9_frame*>(ext_ctrls->ptr);

  const struct v4l2_vp9_loop_filter* lf =
      static_cast<const struct v4l2_vp9_loop_filter*>(&ctrl->lf);
  CONTROL(lf, ref_deltas);
  CONTROL(lf, mode_deltas);
  CONTROL(lf, level);
  CONTROL(lf, sharpness);
  CONTROL(lf, flags);
  CONTROL(lf, reserved);

  const struct v4l2_vp9_quantization* quant =
      static_cast<const struct v4l2_vp9_quantization*>(&ctrl->quant);
  CONTROL(quant, base_q_idx);
  CONTROL(quant, delta_q_y_dc);
  CONTROL(quant, delta_q_uv_dc);
  CONTROL(quant, delta_q_uv_ac);
  CONTROL(quant, reserved);

  const struct v4l2_vp9_segmentation* seg =
      static_cast<const struct v4l2_vp9_segmentation*>(&ctrl->seg);
  CONTROL(seg, feature_data);
  CONTROL(seg, feature_enabled);
  CONTROL(seg, tree_probs);
  CONTROL(seg, pred_probs);
  CONTROL(seg, flags);
  CONTROL(seg, reserved);

  CONTROL(ctrl, flags);
  CONTROL(ctrl, compressed_header_size);
  CONTROL(ctrl, uncompressed_header_size);
  CONTROL(ctrl, frame_width_minus_1);
  CONTROL(ctrl, frame_height_minus_1);
  CONTROL(ctrl, render_width_minus_1);
  CONTROL(ctrl, render_height_minus_1);
  CONTROL(ctrl, last_frame_ts);
  CONTROL(ctrl, golden_frame_ts);
  CONTROL(ctrl, alt_frame_ts);
  CONTROL(ctrl, ref_frame_sign_bias);
  CONTROL(ctrl, reset_frame_context);
  CONTROL(ctrl, frame_context_idx);
  CONTROL(ctrl, profile);
  CONTROL(ctrl, bit_depth);
  CONTROL(ctrl, interpolation_filter);
  CONTROL(ctrl, tile_cols_log2);
  CONTROL(ctrl, tile_rows_log2);
  CONTROL(ctrl, reference_mode);
  CONTROL(ctrl, reserved);

  return s.str();
}

static std::string PrintStatelessH264Control(
    const struct v4l2_ext_control* ext_ctrls) {
  std::ostringstream s;
  s << "h.264" << std::endl;
  switch (ext_ctrls->id) {
    case V4L2_CID_STATELESS_H264_SPS: {
      s << "V4L2_CID_STATELESS_H264_SPS" << std::endl;
      const struct v4l2_ctrl_h264_sps* sps =
          static_cast<const struct v4l2_ctrl_h264_sps*>(ext_ctrls->ptr);
      CONTROL(sps, profile_idc);
      CONTROL(sps, constraint_set_flags);
      CONTROL(sps, level_idc);
      CONTROL(sps, seq_parameter_set_id);
      CONTROL(sps, chroma_format_idc);
      CONTROL(sps, bit_depth_luma_minus8);
      CONTROL(sps, bit_depth_chroma_minus8);
      CONTROL(sps, log2_max_frame_num_minus4);
      CONTROL(sps, pic_order_cnt_type);
      CONTROL(sps, log2_max_pic_order_cnt_lsb_minus4);
      CONTROL(sps, max_num_ref_frames);
      CONTROL(sps, num_ref_frames_in_pic_order_cnt_cycle);
      CONTROL(sps, offset_for_ref_frame);
      CONTROL(sps, offset_for_non_ref_pic);
      CONTROL(sps, offset_for_top_to_bottom_field);
      CONTROL(sps, pic_width_in_mbs_minus1);
      CONTROL(sps, pic_height_in_map_units_minus1);
      CONTROL(sps, flags);
    } break;
    case V4L2_CID_STATELESS_H264_PPS: {
      s << "V4L2_CID_STATELESS_H264_PPS" << std::endl;
      const struct v4l2_ctrl_h264_pps* pps =
          static_cast<const struct v4l2_ctrl_h264_pps*>(ext_ctrls->ptr);
      CONTROL(pps, pic_parameter_set_id);
      CONTROL(pps, seq_parameter_set_id);
      CONTROL(pps, num_slice_groups_minus1);
      CONTROL(pps, num_ref_idx_l0_default_active_minus1);
      CONTROL(pps, num_ref_idx_l1_default_active_minus1);
      CONTROL(pps, weighted_bipred_idc);
      CONTROL(pps, pic_init_qp_minus26);
      CONTROL(pps, pic_init_qs_minus26);
      CONTROL(pps, chroma_qp_index_offset);
      CONTROL(pps, second_chroma_qp_index_offset);
      CONTROL(pps, flags);
    } break;
    case V4L2_CID_STATELESS_H264_SCALING_MATRIX: {
      s << "V4L2_CID_STATELESS_H264_SCALING_MATRIX" << std::endl;
      const struct v4l2_ctrl_h264_scaling_matrix* sm =
          static_cast<const struct v4l2_ctrl_h264_scaling_matrix*>(
              ext_ctrls->ptr);
      CONTROL(sm, scaling_list_4x4);
      CONTROL(sm, scaling_list_8x8);
    } break;
    case V4L2_CID_STATELESS_H264_DECODE_PARAMS: {
      s << "V4L2_CID_STATELESS_H264_DECODE_PARAMS" << std::endl;
      const struct v4l2_ctrl_h264_decode_params* dp =
          static_cast<const struct v4l2_ctrl_h264_decode_params*>(
              ext_ctrls->ptr);
      for (uint32_t i = 0; i < 16; ++i) {
        s << "dbp entry " << +i << std::endl;
        const struct v4l2_h264_dpb_entry* dpb =
            static_cast<const struct v4l2_h264_dpb_entry*>(&dp->dpb[i]);
        CONTROL(dpb, reference_ts);
        CONTROL(dpb, pic_num);
        CONTROL(dpb, frame_num);
        CONTROL(dpb, fields);
        CONTROL(dpb, top_field_order_cnt);
        CONTROL(dpb, bottom_field_order_cnt);
        CONTROL(dpb, flags);
      }

      CONTROL(dp, nal_ref_idc);
      CONTROL(dp, frame_num);
      CONTROL(dp, top_field_order_cnt);
      CONTROL(dp, bottom_field_order_cnt);
      CONTROL(dp, idr_pic_id);
      CONTROL(dp, pic_order_cnt_lsb);
      CONTROL(dp, delta_pic_order_cnt_bottom);
      CONTROL(dp, delta_pic_order_cnt0);
      CONTROL(dp, delta_pic_order_cnt1);
      CONTROL(dp, dec_ref_pic_marking_bit_size);
      CONTROL(dp, pic_order_cnt_bit_size);
      CONTROL(dp, slice_group_change_cycle);
      CONTROL(dp, flags);
    } break;
    case V4L2_CID_STATELESS_H264_DECODE_MODE: {
      const enum v4l2_stateless_h264_decode_mode dm =
          static_cast<const enum v4l2_stateless_h264_decode_mode>(
              ext_ctrls->value);
      s << "V4L2_CID_STATELESS_H264_DECODE_MODE: "
        << (dm == V4L2_STATELESS_H264_DECODE_MODE_SLICE_BASED
                ? "V4L2_STATELESS_H264_DECODE_MODE_SLICE_BASED"
                : "V4L2_STATELESS_H264_DECODE_MODE_FRAME_BASED")
        << std::endl;
    } break;
  }

  return s.str();
}

static std::string PrintStatelessHEVCControl(
    const struct v4l2_ext_control* ext_ctrls) {
  std::ostringstream s;
  s << "hevc" << std::endl;
  switch (ext_ctrls->id) {
    case V4L2_CID_STATELESS_HEVC_SPS: {
      const struct v4l2_ctrl_hevc_sps* sps =
          static_cast<const struct v4l2_ctrl_hevc_sps*>(ext_ctrls->ptr);
      CONTROL(sps, video_parameter_set_id);
      CONTROL(sps, seq_parameter_set_id);
      CONTROL(sps, pic_width_in_luma_samples);
      CONTROL(sps, pic_height_in_luma_samples);
      CONTROL(sps, bit_depth_luma_minus8);
      CONTROL(sps, bit_depth_chroma_minus8);
      CONTROL(sps, log2_max_pic_order_cnt_lsb_minus4);
      CONTROL(sps, sps_max_dec_pic_buffering_minus1);
      CONTROL(sps, sps_max_num_reorder_pics);
      CONTROL(sps, sps_max_latency_increase_plus1);
      CONTROL(sps, log2_min_luma_coding_block_size_minus3);
      CONTROL(sps, log2_diff_max_min_luma_coding_block_size);
      CONTROL(sps, log2_min_luma_transform_block_size_minus2);
      CONTROL(sps, log2_diff_max_min_luma_transform_block_size);
      CONTROL(sps, max_transform_hierarchy_depth_inter);
      CONTROL(sps, max_transform_hierarchy_depth_intra);
      CONTROL(sps, pcm_sample_bit_depth_luma_minus1);
      CONTROL(sps, pcm_sample_bit_depth_chroma_minus1);
      CONTROL(sps, log2_min_pcm_luma_coding_block_size_minus3);
      CONTROL(sps, log2_diff_max_min_pcm_luma_coding_block_size);
      CONTROL(sps, num_short_term_ref_pic_sets);
      CONTROL(sps, num_long_term_ref_pics_sps);
      CONTROL(sps, chroma_format_idc);
      CONTROL(sps, sps_max_sub_layers_minus1);
      CONTROL(sps, flags);
    } break;
    case V4L2_CID_STATELESS_HEVC_PPS: {
      const struct v4l2_ctrl_hevc_pps* pps =
          static_cast<const struct v4l2_ctrl_hevc_pps*>(ext_ctrls->ptr);
      CONTROL(pps, pic_parameter_set_id);
      CONTROL(pps, num_extra_slice_header_bits);
      CONTROL(pps, num_ref_idx_l0_default_active_minus1);
      CONTROL(pps, num_ref_idx_l1_default_active_minus1);
      CONTROL(pps, init_qp_minus26);
      CONTROL(pps, diff_cu_qp_delta_depth);
      CONTROL(pps, pps_cb_qp_offset);
      CONTROL(pps, pps_cr_qp_offset);
      CONTROL(pps, num_tile_columns_minus1);
      CONTROL(pps, num_tile_rows_minus1);
      CONTROL(pps, column_width_minus1);
      CONTROL(pps, row_height_minus1);
      CONTROL(pps, pps_beta_offset_div2);
      CONTROL(pps, pps_tc_offset_div2);
      CONTROL(pps, log2_parallel_merge_level_minus2);
      CONTROL(pps, reserved);
      CONTROL(pps, flags);
    } break;
    case V4L2_CID_STATELESS_HEVC_SCALING_MATRIX: {
      const struct v4l2_ctrl_hevc_scaling_matrix* sm =
          static_cast<const struct v4l2_ctrl_hevc_scaling_matrix*>(
              ext_ctrls->ptr);
      CONTROL(sm, scaling_list_4x4);
      CONTROL(sm, scaling_list_8x8);
      CONTROL(sm, scaling_list_16x16);
      CONTROL(sm, scaling_list_32x32);
      CONTROL(sm, scaling_list_dc_coef_16x16);
      CONTROL(sm, scaling_list_dc_coef_32x32);
    } break;
    case V4L2_CID_STATELESS_HEVC_DECODE_PARAMS: {
      const struct v4l2_ctrl_hevc_decode_params* dp =
          static_cast<const struct v4l2_ctrl_hevc_decode_params*>(
              ext_ctrls->ptr);
      CONTROL(dp, pic_order_cnt_val);
      CONTROL(dp, short_term_ref_pic_set_size);
      CONTROL(dp, long_term_ref_pic_set_size);
      CONTROL(dp, num_active_dpb_entries);
      CONTROL(dp, num_poc_st_curr_before);
      CONTROL(dp, num_poc_st_curr_after);
      CONTROL(dp, num_poc_lt_curr);
      CONTROL(dp, poc_st_curr_before);
      CONTROL(dp, poc_st_curr_after);
      CONTROL(dp, poc_lt_curr);
      CONTROL(dp, num_delta_pocs_of_ref_rps_idx);
      for (uint32_t i = 0; i < V4L2_HEVC_DPB_ENTRIES_NUM_MAX; ++i) {
        s << "dbp entry " << +i << std::endl;
        const struct v4l2_hevc_dpb_entry* dpb =
            static_cast<const struct v4l2_hevc_dpb_entry*>(&dp->dpb[i]);
        CONTROL(dpb, timestamp);
        CONTROL(dpb, flags);
        CONTROL(dpb, field_pic);
        CONTROL(dpb, reserved);
        CONTROL(dpb, pic_order_cnt_val);
      }
      CONTROL(dp, flags);
    } break;
  }

  return s.str();
}

std::string V4L2ControlsToString(const struct v4l2_ext_controls* ctrls) {
  const struct v4l2_ext_control* ext_ctrls = ctrls->controls;
  std::ostringstream s;

  CONTROL(ctrls, which);
  CONTROL(ctrls, count);
  CONTROL(ctrls, error_idx);
  CONTROL(ctrls, request_fd);
  CONTROL(ctrls, reserved);

  for (uint32_t i = 0; i < ctrls->count; ++i) {
    switch (ext_ctrls->id) {
      case V4L2_CID_STATELESS_AV1_SEQUENCE:
      case V4L2_CID_STATELESS_AV1_TILE_GROUP_ENTRY:
      case V4L2_CID_STATELESS_AV1_FRAME:
        s << PrintStatelessAV1Control(ext_ctrls);
        break;
      case V4L2_CID_STATELESS_VP8_FRAME:
        s << PrintStatelessVP8Control(ext_ctrls);
        break;
      case V4L2_CID_STATELESS_VP9_FRAME:
        s << PrintStatelessVP9Control(ext_ctrls);
        break;
      case V4L2_CID_STATELESS_H264_SPS:
      case V4L2_CID_STATELESS_H264_PPS:
      case V4L2_CID_STATELESS_H264_SCALING_MATRIX:
      case V4L2_CID_STATELESS_H264_DECODE_PARAMS:
      case V4L2_CID_STATELESS_H264_DECODE_MODE:
        s << PrintStatelessH264Control(ext_ctrls);
        break;
      case V4L2_CID_STATELESS_HEVC_SPS:
      case V4L2_CID_STATELESS_HEVC_PPS:
      case V4L2_CID_STATELESS_HEVC_SCALING_MATRIX:
      case V4L2_CID_STATELESS_HEVC_DECODE_PARAMS:
        s << PrintStatelessHEVCControl(ext_ctrls);
        break;
      default:
        s << "Unknown Control: 0x" << std::hex << ext_ctrls->id << std::endl;
    }

    ext_ctrls++;
  }

  return s.str();
}
#else
std::string V4L2ControlsToString(const struct v4l2_ext_controls* ctrls) {
  return "Use a debug build to see controls.";
}
#endif
}  // namespace media