avtest_label_detect/detect_resolution.c

// Copyright 2017 The Chromium OS Authors. All rights reserved.
// 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_VAAPI) || defined(USE_V4L2_CODEC)
static const int32_t width_4k = 3840;
static const int32_t height_4k = 2160;
#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 3840x2160.
 */
static bool is_vaapi_4k_device(int fd,
                               const VAProfile* va_profiles,
                               VAEntrypoint va_entrypoint,
                               bool is_10bpp) {
  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;

  if (is_vaapi_support_formats(fd, va_profiles, va_entrypoint, va_format)) {
    if (get_vaapi_max_resolution(fd, va_profiles, va_entrypoint, va_format,
                                 &resolution_width, &resolution_height)) {
      return resolution_width >= width_4k && resolution_height >= height_4k;
    }
  }
  return false;
}

// Determines if is_vaapi_4k_device() for H264 decoding.
static bool is_vaapi_4k_device_dec_h264(int fd) {
  return is_vaapi_4k_device(fd, va_profiles_h264, VAEntrypointVLD, false);
}

// Determines if is_vaapi_4k_device() for H264 encoding.
static bool is_vaapi_4k_device_enc_h264(int fd) {
  return (
      is_vaapi_4k_device(fd, va_profiles_h264, VAEntrypointEncSlice, false) ||
      is_vaapi_4k_device(fd, va_profiles_h264, VAEntrypointEncSliceLP, false));
}

// Determines if is_vaapi_4k_device() for VP8 decoding.
static bool is_vaapi_4k_device_dec_vp8(int fd) {
  return is_vaapi_4k_device(fd, va_profiles_vp8, VAEntrypointVLD, false);
}

// Determines if is_vaapi_4k_device() for VP8 encoding.
static bool is_vaapi_4k_device_enc_vp8(int fd) {
  return (
      is_vaapi_4k_device(fd, va_profiles_vp8, VAEntrypointEncSlice, false) ||
      is_vaapi_4k_device(fd, va_profiles_vp8, VAEntrypointEncSliceLP, false));
}

// Determines if is_vaapi_4k_device() for VP9 decoding.
static bool is_vaapi_4k_device_dec_vp9(int fd) {
  return is_vaapi_4k_device(fd, va_profiles_vp9, VAEntrypointVLD, false);
}

// Determines if is_vaapi_4k_device() for VP9 encoding.
static bool is_vaapi_4k_device_enc_vp9(int fd) {
  return (
      is_vaapi_4k_device(fd, va_profiles_vp9, VAEntrypointEncSlice, false) ||
      is_vaapi_4k_device(fd, va_profiles_vp9, VAEntrypointEncSliceLP, false));
}

// Determines if is_vaapi_4k_device() for AV1 decoding.
static bool is_vaapi_4k_device_dec_av1(int fd) {
  return is_vaapi_4k_device(fd, va_profiles_av1, VAEntrypointVLD, false);
}

// Determines if is_vaapi_4k_device() for AV1 decoding 10BPP.
static bool is_vaapi_4k_device_dec_av1_10bpp(int fd) {
  return is_vaapi_4k_device(fd, va_profiles_av1, VAEntrypointVLD, true);
}

// Determines if is_vaapi_4k_device() for HEVC decoding.
static bool is_vaapi_4k_device_dec_hevc(int fd) {
  return is_vaapi_4k_device(fd, va_profiles_hevc, VAEntrypointVLD, false);
}

// Determines if is_vaapi_4k_device() for HEVC decoding 10BPP.
static bool is_vaapi_4k_device_dec_hevc_10bpp(int fd) {
  return is_vaapi_4k_device(fd, va_profiles_hevc_10bpp, VAEntrypointVLD, true);
}
#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);
}
#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)
  if (is_any_device(kDRMDevicePattern, is_vaapi_4k_device_dec_h264))
    return true;
#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)
  if (is_any_device(kDRMDevicePattern, is_vaapi_4k_device_dec_vp8))
    return true;
#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)
  if (is_any_device(kDRMDevicePattern, is_vaapi_4k_device_dec_vp9))
    return true;
#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)
  if (is_any_device(kDRMDevicePattern, is_vaapi_4k_device_dec_av1))
    return true;
#endif  // defined(USE_VAAPI)

  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)
  if (is_any_device(kDRMDevicePattern, is_vaapi_4k_device_dec_av1_10bpp))
    return true;
#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)
  if (is_any_device(kDRMDevicePattern, is_vaapi_4k_device_dec_hevc))
    return true;
#endif  // defined(USE_VAAPI)

  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)
  if (is_any_device(kDRMDevicePattern, is_vaapi_4k_device_dec_hevc_10bpp))
    return true;
#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)
  if (is_any_device(kDRMDevicePattern, is_vaapi_4k_device_enc_h264))
    return true;
#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)
  if (is_any_device(kDRMDevicePattern, is_vaapi_4k_device_enc_vp8))
    return true;
#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)
  if (is_any_device(kDRMDevicePattern, is_vaapi_4k_device_enc_vp9))
    return true;
#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;
}