detect_resolution.c

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

#if defined(USE_V4L2_CODEC)
#include <linux/videodev2.h>
#endif  // defined(USE_V4L2_CODEC)

#if defined(USE_VAAPI)
#include <va/va.h>
#endif  // defined(USE_VAAPI)

#include "label_detect.h"

#if defined(USE_V4L2_CODEC)
// TODO(b/255770680): Remove this once V4L2 header is updated.
#ifndef V4L2_PIX_FMT_AV1
#define V4L2_PIX_FMT_AV1 v4l2_fourcc('A', 'V', '0', '1') /* AV1 */
#endif
#ifndef V4L2_PIX_FMT_AV1_FRAME
#define V4L2_PIX_FMT_AV1_FRAME \
  v4l2_fourcc('A', 'V', '1', 'F') /* AV1 parsed frame */
#endif
// TODO(b/278157861): Remove this once ChromeOS V4L2 header is updated
#ifndef V4L2_PIX_FMT_HEVC_SLICE
#define V4L2_PIX_FMT_HEVC_SLICE \
  v4l2_fourcc('S', '2', '6', '5') /* HEVC parsed slices */
#endif
#endif  // defined(USE_V4L2_CODEC)

#if defined(USE_VAAPI) || defined(USE_V4L2_CODEC)
static const int32_t width_4k = 3840;
static const int32_t height_4k = 2160;
#endif
#if defined(USE_VAAPI)
static const int32_t width_8k = 7680;
static const int32_t height_8k = 4320;
#endif

#if defined(USE_VAAPI)
#if VA_CHECK_VERSION(0, 35, 0)

static const char kDRMDevicePattern[] = "/dev/dri/renderD*";

static const VAProfile va_profiles_h264[] = {
    VAProfileH264Baseline, VAProfileH264Main, VAProfileH264High,
    VAProfileH264ConstrainedBaseline, VAProfileNone};

static const VAProfile va_profiles_vp8[] = {VAProfileVP8Version0_3,
                                            VAProfileNone};

static const VAProfile va_profiles_vp9[] = {VAProfileVP9Profile0,
                                            VAProfileNone};

static const VAProfile va_profiles_av1[] = {VAProfileAV1Profile0,
                                            VAProfileNone};

static const VAProfile va_profiles_hevc[] = {VAProfileHEVCMain, VAProfileNone};

static const VAProfile va_profiles_hevc_10bpp[] = {VAProfileHEVCMain10,
                                                   VAProfileNone};

/* Determines if a VAAPI device associated with given |fd| supports
 * |va_profiles| for |va_entrypoint|, and its maximum resolution is larger
 * than or equal to |min_width|x|min_height|.
 */
static bool query_support_for(int fd,
                              const VAProfile* va_profiles,
                              VAEntrypoint va_entrypoint,
                              bool is_10bpp,
                              int32_t min_width,
                              int32_t min_height) {
  int32_t resolution_width = 0;
  int32_t resolution_height = 0;
  const unsigned int va_format =
      is_10bpp ? VA_RT_FORMAT_YUV420_10 : VA_RT_FORMAT_YUV420;

  return is_vaapi_support_formats(fd, va_profiles, va_entrypoint, va_format) &&
         get_vaapi_max_resolution(fd, va_profiles, va_entrypoint, va_format,
                                  &resolution_width, &resolution_height) &&
         resolution_width >= min_width && resolution_height >= min_height;
}

static bool query_support_for_dec_h264(int fd,
                                       int32_t min_width,
                                       int32_t min_height) {
  return query_support_for(fd, va_profiles_h264, VAEntrypointVLD, false,
                           min_width, min_height);
}

static bool query_support_for_enc_h264(int fd,
                                       int32_t min_width,
                                       int32_t min_height) {
  return query_support_for(fd, va_profiles_h264, VAEntrypointEncSlice, false,
                           min_width, min_height) ||
         query_support_for(fd, va_profiles_h264, VAEntrypointEncSliceLP, false,
                           min_width, min_height);
}

static bool query_support_for_dec_vp8(int fd,
                                      int32_t min_width,
                                      int32_t min_height) {
  return query_support_for(fd, va_profiles_vp8, VAEntrypointVLD, false,
                           min_width, min_height);
}

static bool query_support_for_enc_vp8(int fd,
                                      int32_t min_width,
                                      int32_t min_height) {
  return query_support_for(fd, va_profiles_vp8, VAEntrypointEncSlice, false,
                           min_width, min_height) ||
         query_support_for(fd, va_profiles_vp8, VAEntrypointEncSliceLP, false,
                           min_width, min_height);
}

static bool query_support_for_dec_vp9(int fd,
                                      int32_t min_width,
                                      int32_t min_height) {
  return query_support_for(fd, va_profiles_vp9, VAEntrypointVLD, false,
                           min_width, min_height);
}

static bool query_support_for_enc_vp9(int fd,
                                      int32_t min_width,
                                      int32_t min_height) {
  return query_support_for(fd, va_profiles_vp9, VAEntrypointEncSlice, false,
                           min_width, min_height) ||
         query_support_for(fd, va_profiles_vp9, VAEntrypointEncSliceLP, false,
                           min_width, min_height);
}

static bool query_support_for_enc_av1(int fd,
                                      int32_t min_width,
                                      int32_t min_height) {
  return query_support_for(fd, va_profiles_av1, VAEntrypointEncSliceLP, false,
                           min_width, min_height) ||
         query_support_for(fd, va_profiles_av1, VAEntrypointEncSlice, false,
                           min_width, min_height);
}

static bool query_support_for_dec_av1(int fd,
                                      int32_t min_width,
                                      int32_t min_height) {
  return query_support_for(fd, va_profiles_av1, VAEntrypointVLD, false,
                           min_width, min_height);
}

static bool query_support_for_dec_av1_10bpp(int fd,
                                            int32_t min_width,
                                            int32_t min_height) {
  return query_support_for(fd, va_profiles_av1, VAEntrypointVLD, true,
                           min_width, min_height);
}

static bool query_support_for_dec_hevc(int fd,
                                       int32_t min_width,
                                       int32_t min_height) {
  return query_support_for(fd, va_profiles_hevc, VAEntrypointVLD, false,
                           min_width, min_height);
}

static bool query_support_for_dec_hevc_10bpp(int fd,
                                             int32_t min_width,
                                             int32_t min_height) {
  return query_support_for(fd, va_profiles_hevc_10bpp, VAEntrypointVLD, true,
                           min_width, min_height);
}

#endif  // VA_CHECK_VERSION(0, 38, 1)
#endif  // defined(USE_VAAPI)

#if defined(USE_V4L2_CODEC)

static const char kVideoDevicePattern[] = "/dev/video*";

/* Determined if a V4L2 device associated with given |fd| supports |pix_fmt|
 * for |buf_type|, and its maximum resolution is larger than 3840x2160.
 */
static bool is_v4l2_4k_device(int fd,
                              enum v4l2_buf_type buf_type,
                              uint32_t pix_fmt) {
  int32_t resolution_width;
  int32_t resolution_height;
  if (!is_hw_video_acc_device(fd)) {
    return false;
  }
  if (is_v4l2_support_format(fd, buf_type, pix_fmt)) {
    if (get_v4l2_max_resolution(fd, pix_fmt, &resolution_width,
                                &resolution_height)) {
      return resolution_width >= width_4k && resolution_height >= height_4k;
    }
  }
  return false;
}

// Determines if is_v4l2_4k_device() for H264 decoding.
static bool is_v4l2_4k_device_dec_h264(int fd) {
  return is_v4l2_4k_device(fd, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
                           V4L2_PIX_FMT_H264) ||
         is_v4l2_4k_device(fd, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
                           V4L2_PIX_FMT_H264_SLICE);
}

// Determines if is_v4l2_4k_device() for H264 encoding.
static bool is_v4l2_4k_device_enc_h264(int fd) {
  return is_v4l2_4k_device(fd, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE,
                           V4L2_PIX_FMT_H264);
}

// Determines if is_v4l2_4k_device() for VP8 decoding.
static bool is_v4l2_4k_device_dec_vp8(int fd) {
  return is_v4l2_4k_device(fd, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
                           V4L2_PIX_FMT_VP8) ||
         is_v4l2_4k_device(fd, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
                           V4L2_PIX_FMT_VP8_FRAME);
}

// Determines if is_v4l2_4k_device() for VP8 encoding.
static bool is_v4l2_4k_device_enc_vp8(int fd) {
  return is_v4l2_4k_device(fd, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE,
                           V4L2_PIX_FMT_VP8);
}

// Determines if is_v4l2_4k_device() for VP9 decoding.
static bool is_v4l2_4k_device_dec_vp9(int fd) {
  return is_v4l2_4k_device(fd, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
                           V4L2_PIX_FMT_VP9) ||
         is_v4l2_4k_device(fd, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
                           V4L2_PIX_FMT_VP9_FRAME);
}

// Determines if is_v4l2_4k_device() for VP9 encoding.
static bool is_v4l2_4k_device_enc_vp9(int fd) {
  return is_v4l2_4k_device(fd, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE,
                           V4L2_PIX_FMT_VP9);
}

// Determines if is_v4l2_4k_device() for HEVC decoding.
static bool is_v4l2_4k_device_dec_hevc(int fd) {
  return is_v4l2_4k_device(fd, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
                           V4L2_PIX_FMT_HEVC) ||
         is_v4l2_4k_device(fd, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
                           V4L2_PIX_FMT_HEVC_SLICE);
}

// Determines if is_v4l2_4k_device() for AV1 decoding.
static bool is_v4l2_4k_device_dec_av1(int fd) {
  return is_v4l2_4k_device(fd, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
                           V4L2_PIX_FMT_AV1) ||
         is_v4l2_4k_device(fd, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
                           V4L2_PIX_FMT_AV1_FRAME);
}

#endif  // defined(USE_V4L2_CODEC)

/* Determines "4k_video_h264". Return true, if either the VAAPI device
 * supports 4k resolution H264 decoding, has decoding entry point,
 * and input YUV420 formats. Or there is a
 * /dev/video* device supporting 4k resolution H264 decoding.
 */
bool detect_4k_device_h264(void) {
#if defined(USE_VAAPI)
  return does_any_device_support_resolution(
      kDRMDevicePattern, query_support_for_dec_h264, width_4k, height_4k);
#endif  // defined(USE_VAAPI)

#if defined(USE_V4L2_CODEC)
  if (is_any_device(kVideoDevicePattern, is_v4l2_4k_device_dec_h264))
    return true;
#endif  // defined(USE_V4L2_CODEC)

  return false;
}

/* Determines "4k_video_vp8". Return true, if either the VAAPI device
 * supports 4k resolution VP8 decoding, has decoding entry point,
 * and input YUV420 formats. Or there is a
 * /dev/video* device supporting 4k resolution VP8 decoding.
 */
bool detect_4k_device_vp8(void) {
#if defined(USE_VAAPI)
  return does_any_device_support_resolution(
      kDRMDevicePattern, query_support_for_dec_vp8, width_4k, height_4k);
#endif  // defined(USE_VAAPI)

#if defined(USE_V4L2_CODEC)
  if (is_any_device(kVideoDevicePattern, is_v4l2_4k_device_dec_vp8))
    return true;
#endif  // defined(USE_V4L2_CODEC)

  return false;
}

/* Determines "4k_video_vp9". Return true, if either the VAAPI device
 * supports 4k resolution VP9 decoding, has decoding entry point,
 * and input YUV420 formats. Or there is a
 * /dev/video* device supporting 4k resolution VP9 decoding.
 */
bool detect_4k_device_vp9(void) {
#if defined(USE_VAAPI)
  return does_any_device_support_resolution(
      kDRMDevicePattern, query_support_for_dec_vp9, width_4k, height_4k);
#endif  // defined(USE_VAAPI)

#if defined(USE_V4L2_CODEC)
  if (is_any_device(kVideoDevicePattern, is_v4l2_4k_device_dec_vp9))
    return true;
#endif  // defined(USE_V4L2_CODEC)

  return false;
}

/* Determines "4k_video_av1". Return true, if either the VAAPI device
 * supports 4k resolution AV1 decoding, has decoding entry point,
 * and input YUV420 formats.
 */
bool detect_4k_device_av1(void) {
#if defined(USE_VAAPI)
  return does_any_device_support_resolution(
      kDRMDevicePattern, query_support_for_dec_av1, width_4k, height_4k);
#endif  // defined(USE_VAAPI)

#if defined(USE_V4L2_CODEC)
  if (is_any_device(kVideoDevicePattern, is_v4l2_4k_device_dec_av1))
    return true;
#endif  // defined(USE_V4L2_CODEC)

  return false;
}

/* Determines "4k_video_av1_10bpp". Return true, if either the VAAPI device
 * supports 4k resolution AV1 10BPP decoding, has decoding entry point,
 * and input YUV420 formats.
 */
bool detect_4k_device_av1_10bpp(void) {
#if defined(USE_VAAPI)
  return does_any_device_support_resolution(
      kDRMDevicePattern, query_support_for_dec_av1_10bpp, width_4k, height_4k);
#endif  // defined(USE_VAAPI)

  return false;
}

/* Determines "4k_video_hevc". Return true, if the VAAPI device supports 4k
 * resolution HEVC main decoding, has decoding entry point, and outputs YUV420
 * format.
 */
bool detect_4k_device_hevc(void) {
#if defined(USE_VAAPI)
  return does_any_device_support_resolution(
      kDRMDevicePattern, query_support_for_dec_hevc, width_4k, height_4k);
#endif  // defined(USE_VAAPI)

#if defined(USE_V4L2_CODEC)
  if (is_any_device(kVideoDevicePattern, is_v4l2_4k_device_dec_hevc))
    return true;
#endif  // defined(USE_V4L2_CODEC)

  return false;
}

/* Determines "4k_video_hevc_10bpp". Return true, if the VAAPI device supports
 * 4k resolution HEVC main10 10BPP decoding, has decoding entry point, and
 * outputs YUV420 format.
 */
bool detect_4k_device_hevc_10bpp(void) {
#if defined(USE_VAAPI)
  return does_any_device_support_resolution(
      kDRMDevicePattern, query_support_for_dec_hevc_10bpp, width_4k, height_4k);
#endif  // defined(USE_VAAPI)

  return false;
}

bool detect_8k_device_h264(void) {
#if defined(USE_VAAPI)
  return does_any_device_support_resolution(
      kDRMDevicePattern, query_support_for_dec_h264, width_8k, height_8k);
#endif  // defined(USE_VAAPI)

  return false;
}

bool detect_8k_device_vp9(void) {
#if defined(USE_VAAPI)
  return does_any_device_support_resolution(
      kDRMDevicePattern, query_support_for_dec_vp9, width_8k, height_8k);
#endif  // defined(USE_VAAPI)

  return false;
}

bool detect_8k_device_av1(void) {
#if defined(USE_VAAPI)
  return does_any_device_support_resolution(
      kDRMDevicePattern, query_support_for_dec_av1, width_8k, height_8k);
#endif  // defined(USE_VAAPI)

  return false;
}

bool detect_8k_device_av1_10bpp(void) {
#if defined(USE_VAAPI)
  return does_any_device_support_resolution(
      kDRMDevicePattern, query_support_for_dec_av1_10bpp, width_8k, height_8k);
#endif  // defined(USE_VAAPI)

  return false;
}

bool detect_8k_device_hevc(void) {
#if defined(USE_VAAPI)
  return does_any_device_support_resolution(
      kDRMDevicePattern, query_support_for_dec_hevc, width_8k, height_8k);
#endif  // defined(USE_VAAPI)

  return false;
}

bool detect_8k_device_hevc_10bpp(void) {
#if defined(USE_VAAPI)
  return does_any_device_support_resolution(
      kDRMDevicePattern, query_support_for_dec_hevc_10bpp, width_8k, height_8k);
#endif  // defined(USE_VAAPI)

  return false;
}

/* Determines "4k_video_enc_h264". Return true, if either the VAAPI device
 * supports 4k resolution H264 encoding, has encoding entry point,
 * and input YUV420 formats. Or there is a
 * /dev/video* device supporting 4k resolution H264 encoding.
 */
bool detect_4k_device_enc_h264(void) {
#if defined(USE_VAAPI)
  return does_any_device_support_resolution(
      kDRMDevicePattern, query_support_for_enc_h264, width_4k, height_4k);
#endif  // defined(USE_VAAPI)

#if defined(USE_V4L2_CODEC)
  if (is_any_device(kVideoDevicePattern, is_v4l2_4k_device_enc_h264))
    return true;
#endif  // defined(USE_V4L2_CODEC)

  return false;
}

/* Determines "4k_video_enc_vp8". Return true, if either the VAAPI device
 * supports 4k resolution VP8 encoding, has encoding entry point,
 * and input YUV420 formats. Or there is a
 * /dev/video* device supporting 4k resolution VP8 encoding.
 */
bool detect_4k_device_enc_vp8(void) {
#if defined(USE_VAAPI)
  return does_any_device_support_resolution(
      kDRMDevicePattern, query_support_for_enc_vp8, width_4k, height_4k);
#endif  // defined(USE_VAAPI)

#if defined(USE_V4L2_CODEC)
  if (is_any_device(kVideoDevicePattern, is_v4l2_4k_device_enc_vp8))
    return true;
#endif  // defined(USE_V4L2_CODEC)

  return false;
}

/* Determines "4k_video_enc_vp9". Return true, if either the VAAPI device
 * supports 4k resolution VP9 encoding, has encoding entry point,
 * and input YUV420 formats. Or there is a
 * /dev/video* device supporting 4k resolution VP9 encoding.
 */
bool detect_4k_device_enc_vp9(void) {
#if defined(USE_VAAPI)
  return does_any_device_support_resolution(
      kDRMDevicePattern, query_support_for_enc_vp9, width_4k, height_4k);
#endif  // defined(USE_VAAPI)

#if defined(USE_V4L2_CODEC)
  if (is_any_device(kVideoDevicePattern, is_v4l2_4k_device_enc_vp9))
    return true;
#endif  // defined(USE_V4L2_CODEC)

  return false;
}

/* Determines "4k_video_enc_av1". Return true, if the VAAPI device
 * supports 4k resolution AV1 encoding, has encoding entry point,
 * and input YUV420 formats.
 */
bool detect_4k_device_enc_av1(void) {
#if defined(USE_VAAPI)
  return does_any_device_support_resolution(
      kDRMDevicePattern, query_support_for_enc_av1, width_4k, height_4k);
#endif  // defined(USE_VAAPI)

  return false;
}