| // Copyright 2014 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. |
| #include <alloca.h> |
| #include <errno.h> |
| #include <fcntl.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <unistd.h> |
| |
| #include <va/va.h> |
| #include <va/va_drm.h> |
| |
| #include "label_detect.h" |
| |
| static bool is_blacklisted_driver(const char* vendor_string, |
| VAProfile profile, |
| VAEntrypoint entrypoint) { |
| // No blacklisted driver today. |
| return false; |
| } |
| |
| /* Returns true if given VA profile |va_profile| has |entrypoint| and the entry |
| * point supports given raw |format|. |
| */ |
| static bool has_vaapi_entrypoint(VADisplay va_display, |
| VAProfile va_profile, |
| VAEntrypoint entrypoint, |
| unsigned int format) { |
| VAStatus va_res; |
| VAConfigAttrib attrib = {VAConfigAttribRTFormat, 0}; |
| va_res = |
| vaGetConfigAttributes(va_display, va_profile, entrypoint, &attrib, 1); |
| if (va_res != VA_STATUS_SUCCESS) { |
| TRACE("vaGetConfigAttributes failed (%d)\n", va_res); |
| return false; |
| } |
| |
| return attrib.value & format; |
| } |
| |
| /* Returns true if the current platform supports at least one of the |
| * |required_profiles| and |entrypoint| for that profile supports given raw |
| * |format|. |
| */ |
| static bool match_vaapi_capabilities(VADisplay va_display, |
| const VAProfile* required_profiles, |
| VAEntrypoint entrypoint, |
| unsigned int format) { |
| int i; |
| bool found = false; |
| int num_supported_profiles; |
| VAStatus va_res; |
| VAProfile* profiles; |
| int max_profiles = vaMaxNumProfiles(va_display); |
| /* If no profiles are supported do not proceed further */ |
| if (max_profiles <= 0) { |
| TRACE("vaMaxNumProfiles returns %d \n ", max_profiles); |
| return false; |
| } |
| |
| profiles = (VAProfile*)alloca(sizeof(VAProfile) * max_profiles); |
| if (!profiles) { |
| TRACE("alloca failed\n"); |
| return false; |
| } |
| va_res = vaQueryConfigProfiles(va_display, profiles, &num_supported_profiles); |
| if (va_res != VA_STATUS_SUCCESS) { |
| TRACE("vaQueryConfigProfiles failed (%d)\n", va_res); |
| return false; |
| } |
| const char* vendor_string = vaQueryVendorString(va_display); |
| for (i = 0; i < num_supported_profiles; i++) { |
| int j; |
| VAProfile profile = profiles[i]; |
| TRACE("supported profile: %d\n", profile); |
| if (is_blacklisted_driver(vendor_string, profile, entrypoint)) { |
| continue; |
| } |
| for (j = 0; required_profiles[j] != VAProfileNone; j++) { |
| if (required_profiles[j] == profile && |
| has_vaapi_entrypoint(va_display, profile, entrypoint, format)) { |
| found = true; |
| /* continue the loop in order to output all supported profiles */ |
| } |
| } |
| } |
| return found; |
| } |
| |
| /* Returns true if libva supports any given profiles. And that profile has said |
| * entrypoint with format. |
| */ |
| bool is_vaapi_support_formats(int fd, |
| const VAProfile* profiles, |
| VAEntrypoint entrypoint, |
| unsigned int format) { |
| bool found = false; |
| VAStatus va_res; |
| VADisplay va_display; |
| int major_version, minor_version; |
| |
| va_display = vaGetDisplayDRM(fd); |
| if (!vaDisplayIsValid(va_display)) { |
| TRACE("vaGetDisplay returns invalid display\n"); |
| return false; |
| } |
| |
| va_res = vaInitialize(va_display, &major_version, &minor_version); |
| if (va_res != VA_STATUS_SUCCESS) { |
| TRACE("vaInitialize failed\n"); |
| return false; |
| } |
| |
| if (match_vaapi_capabilities(va_display, profiles, entrypoint, format)) |
| found = true; |
| |
| vaTerminate(va_display); |
| |
| return found; |
| } |
| |
| /* Returns true if |entrypoint| is supported. */ |
| static bool is_entrypoint_supported(VADisplay va_display, |
| VAProfile va_profile, |
| VAEntrypoint entrypoint) { |
| bool result = false; |
| int max_entrypoints = vaMaxNumEntrypoints(va_display); |
| VAEntrypoint* supported_entrypoints = |
| malloc(max_entrypoints * sizeof(VAEntrypoint)); |
| int num_supported_entrypoints; |
| VAStatus va_res = |
| vaQueryConfigEntrypoints(va_display, va_profile, supported_entrypoints, |
| &num_supported_entrypoints); |
| |
| if (va_res != VA_STATUS_SUCCESS) { |
| TRACE("vaQueryConfigEntrypoints failed (%d)\n", va_res); |
| goto finish; |
| } |
| if (num_supported_entrypoints < 0 || |
| num_supported_entrypoints > max_entrypoints) { |
| TRACE("vaQueryConfigEntrypoints returned: %d\n", num_supported_entrypoints); |
| goto finish; |
| } |
| |
| for (int i = 0; i < num_supported_entrypoints; i++) { |
| if (supported_entrypoints[i] == entrypoint) { |
| result = true; |
| break; |
| } |
| } |
| |
| finish: |
| free(supported_entrypoints); |
| return result; |
| } |
| |
| /* Returns true if |required_attribs| are supported. */ |
| static bool are_attribs_supported(VADisplay va_display, |
| VAProfile va_profile, |
| VAEntrypoint entrypoint, |
| VAConfigAttrib* required_attribs, |
| int num_required_attribs) { |
| bool result = false; |
| VAConfigAttrib* attribs = |
| malloc(sizeof(VAConfigAttrib) * num_required_attribs); |
| memcpy(attribs, required_attribs, sizeof(*attribs) * num_required_attribs); |
| for (int i = 0; i < num_required_attribs; i++) { |
| attribs[i].value = 0; |
| } |
| |
| VAStatus va_res = vaGetConfigAttributes(va_display, va_profile, entrypoint, |
| attribs, num_required_attribs); |
| if (va_res != VA_STATUS_SUCCESS) { |
| TRACE("vaGetConfigAttributes failed (%d)\n", va_res); |
| goto finish; |
| } |
| |
| for (int i = 0; i < num_required_attribs; i++) { |
| if (attribs[i].type != required_attribs[i].type || |
| (attribs[i].value & required_attribs[i].value) != |
| required_attribs[i].value) { |
| // Unsupported value. |
| goto finish; |
| } |
| } |
| result = true; |
| |
| finish: |
| free(attribs); |
| return result; |
| } |
| |
| /* Returns success or failure of getting resolution. The maximum resolution |
| * of a passed profile is returned through arguments. */ |
| static bool get_max_resolution(VADisplay va_display, |
| VAProfile va_profile, |
| VAEntrypoint entrypoint, |
| VAConfigAttrib* required_attribs, |
| int num_required_attribs, |
| int32_t* width, |
| int32_t* height) { |
| VAStatus va_res; |
| VAConfigID va_config_id; |
| VASurfaceAttrib* attrib_list; |
| unsigned int num_attribs = 0; |
| *width = 0; |
| *height = 0; |
| |
| va_res = vaCreateConfig(va_display, va_profile, entrypoint, required_attribs, |
| num_attribs, &va_config_id); |
| if (va_res != VA_STATUS_SUCCESS) { |
| TRACE("vaQueryConfigProfiles failed (%d)\n", va_res); |
| return false; |
| } |
| // Calls vaQuerySurfaceAttributes twice. The first time is to get the number |
| // of attributes to prepare the space and the second time is to get all |
| // attributes. |
| va_res = |
| vaQuerySurfaceAttributes(va_display, va_config_id, NULL, &num_attribs); |
| if (va_res != VA_STATUS_SUCCESS) { |
| TRACE("vaQuerySurfaceAttributes failed (%d)\n", va_res); |
| return false; |
| } |
| if (!num_attribs) { |
| return false; |
| } |
| |
| attrib_list = malloc(num_attribs * sizeof(VASurfaceAttrib)); |
| va_res = vaQuerySurfaceAttributes(va_display, va_config_id, attrib_list, |
| &num_attribs); |
| if (va_res != VA_STATUS_SUCCESS) { |
| TRACE("vaQuerySurfaceAttributes failed (%d)\n", va_res); |
| free(attrib_list); |
| return false; |
| } |
| for (unsigned int j = 0; j < num_attribs; j++) { |
| VASurfaceAttrib attrib = attrib_list[j]; |
| if (attrib.type == VASurfaceAttribMaxWidth) { |
| *width = attrib.value.value.i; |
| } else if (attrib.type == VASurfaceAttribMaxHeight) { |
| *height = attrib.value.value.i; |
| } |
| } |
| free(attrib_list); |
| return *width > 0 && *height > 0; |
| } |
| |
| /* Returns success or failure of getting resolution. The maximum resolution |
| * among passed profiles is returned through arguments. */ |
| bool get_vaapi_max_resolution(int fd, |
| const VAProfile* profiles, |
| VAEntrypoint entrypoint, |
| int32_t* const resolution_width, |
| int32_t* const resolution_height) { |
| *resolution_width = 0; |
| *resolution_height = 0; |
| |
| VAConfigAttrib required_attribs = {VAConfigAttribRTFormat, |
| VA_RT_FORMAT_YUV420}; |
| VAStatus va_res; |
| VADisplay va_display = vaGetDisplayDRM(fd); |
| int major_version, minor_version; |
| if (!vaDisplayIsValid(va_display)) { |
| TRACE("vaGetDisplay returns invalid display\n"); |
| return false; |
| } |
| va_res = vaInitialize(va_display, &major_version, &minor_version); |
| if (va_res != VA_STATUS_SUCCESS) { |
| TRACE("vaInitialize failed\n"); |
| return false; |
| } |
| |
| for (size_t i = 0; profiles[i] != VAProfileNone; i++) { |
| VAProfile va_profile = profiles[i]; |
| int32_t width = 0; |
| int32_t height = 0; |
| if (!is_entrypoint_supported(va_display, va_profile, entrypoint)) { |
| continue; |
| } |
| |
| if (!are_attribs_supported(va_display, va_profile, entrypoint, |
| &required_attribs, 1)) { |
| continue; |
| } |
| |
| if (!get_max_resolution(va_display, va_profile, entrypoint, |
| &required_attribs, 1, &width, &height)) { |
| TRACE("GetMaxResolution failed for va_profile %d and entrypoint %u\n", |
| va_profile, entrypoint); |
| continue; |
| } |
| |
| if (*resolution_width <= width && *resolution_height <= height) { |
| *resolution_width = width; |
| *resolution_height = height; |
| } |
| } |
| vaTerminate(va_display); |
| return *resolution_width > 0 && *resolution_height > 0; |
| } |
