1005 lines
44 KiB
C
1005 lines
44 KiB
C
/*
|
|
Copyright (C) 1997-2024 Sam Lantinga <slouken@libsdl.org>
|
|
|
|
This software is provided 'as-is', without any express or implied
|
|
warranty. In no event will the authors be held liable for any damages
|
|
arising from the use of this software.
|
|
|
|
Permission is granted to anyone to use this software for any purpose,
|
|
including commercial applications, and to alter it and redistribute it
|
|
freely.
|
|
*/
|
|
#include <SDL3/SDL.h>
|
|
#include <SDL3/SDL_vulkan.h>
|
|
|
|
#include "testffmpeg_vulkan.h"
|
|
|
|
#ifdef FFMPEG_VULKAN_SUPPORT
|
|
|
|
#define VULKAN_FUNCTIONS() \
|
|
VULKAN_GLOBAL_FUNCTION(vkCreateInstance) \
|
|
VULKAN_GLOBAL_FUNCTION(vkEnumerateInstanceExtensionProperties) \
|
|
VULKAN_GLOBAL_FUNCTION(vkEnumerateInstanceLayerProperties) \
|
|
VULKAN_INSTANCE_FUNCTION(vkCreateDevice) \
|
|
VULKAN_INSTANCE_FUNCTION(vkDestroyInstance) \
|
|
VULKAN_INSTANCE_FUNCTION(vkDestroySurfaceKHR) \
|
|
VULKAN_INSTANCE_FUNCTION(vkEnumerateDeviceExtensionProperties) \
|
|
VULKAN_INSTANCE_FUNCTION(vkEnumeratePhysicalDevices) \
|
|
VULKAN_INSTANCE_FUNCTION(vkGetDeviceProcAddr) \
|
|
VULKAN_INSTANCE_FUNCTION(vkGetPhysicalDeviceFeatures2) \
|
|
VULKAN_INSTANCE_FUNCTION(vkGetPhysicalDeviceQueueFamilyProperties) \
|
|
VULKAN_INSTANCE_FUNCTION(vkGetPhysicalDeviceSurfaceSupportKHR) \
|
|
VULKAN_INSTANCE_FUNCTION(vkQueueWaitIdle) \
|
|
VULKAN_DEVICE_FUNCTION(vkAllocateCommandBuffers) \
|
|
VULKAN_DEVICE_FUNCTION(vkBeginCommandBuffer) \
|
|
VULKAN_DEVICE_FUNCTION(vkCmdPipelineBarrier2) \
|
|
VULKAN_DEVICE_FUNCTION(vkCreateCommandPool) \
|
|
VULKAN_DEVICE_FUNCTION(vkCreateSemaphore) \
|
|
VULKAN_DEVICE_FUNCTION(vkDestroyCommandPool) \
|
|
VULKAN_DEVICE_FUNCTION(vkDestroyDevice) \
|
|
VULKAN_DEVICE_FUNCTION(vkDestroySemaphore) \
|
|
VULKAN_DEVICE_FUNCTION(vkDeviceWaitIdle) \
|
|
VULKAN_DEVICE_FUNCTION(vkEndCommandBuffer) \
|
|
VULKAN_DEVICE_FUNCTION(vkFreeCommandBuffers) \
|
|
VULKAN_DEVICE_FUNCTION(vkGetDeviceQueue) \
|
|
VULKAN_DEVICE_FUNCTION(vkQueueSubmit) \
|
|
\
|
|
VULKAN_INSTANCE_FUNCTION(vkGetPhysicalDeviceVideoFormatPropertiesKHR) \
|
|
|
|
typedef struct
|
|
{
|
|
VkPhysicalDeviceFeatures2 device_features;
|
|
VkPhysicalDeviceVulkan11Features device_features_1_1;
|
|
VkPhysicalDeviceVulkan12Features device_features_1_2;
|
|
VkPhysicalDeviceVulkan13Features device_features_1_3;
|
|
VkPhysicalDeviceDescriptorBufferFeaturesEXT desc_buf_features;
|
|
VkPhysicalDeviceShaderAtomicFloatFeaturesEXT atomic_float_features;
|
|
VkPhysicalDeviceCooperativeMatrixFeaturesKHR coop_matrix_features;
|
|
} VulkanDeviceFeatures;
|
|
|
|
struct VulkanVideoContext
|
|
{
|
|
VkInstance instance;
|
|
VkSurfaceKHR surface;
|
|
VkPhysicalDevice physicalDevice;
|
|
int presentQueueFamilyIndex;
|
|
int presentQueueCount;
|
|
int graphicsQueueFamilyIndex;
|
|
int graphicsQueueCount;
|
|
int transferQueueFamilyIndex;
|
|
int transferQueueCount;
|
|
int computeQueueFamilyIndex;
|
|
int computeQueueCount;
|
|
int decodeQueueFamilyIndex;
|
|
int decodeQueueCount;
|
|
VkDevice device;
|
|
VkQueue graphicsQueue;
|
|
VkCommandPool commandPool;
|
|
VkCommandBuffer *commandBuffers;
|
|
uint32_t commandBufferCount;
|
|
uint32_t commandBufferIndex;
|
|
VkSemaphore *waitSemaphores;
|
|
uint32_t waitSemaphoreCount;
|
|
VkSemaphore *signalSemaphores;
|
|
uint32_t signalSemaphoreCount;
|
|
|
|
const char **instanceExtensions;
|
|
int instanceExtensionsCount;
|
|
|
|
const char **deviceExtensions;
|
|
int deviceExtensionsCount;
|
|
|
|
VulkanDeviceFeatures features;
|
|
|
|
PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr;
|
|
#define VULKAN_GLOBAL_FUNCTION(name) PFN_##name name;
|
|
#define VULKAN_INSTANCE_FUNCTION(name) PFN_##name name;
|
|
#define VULKAN_DEVICE_FUNCTION(name) PFN_##name name;
|
|
VULKAN_FUNCTIONS()
|
|
#undef VULKAN_GLOBAL_FUNCTION
|
|
#undef VULKAN_INSTANCE_FUNCTION
|
|
#undef VULKAN_DEVICE_FUNCTION
|
|
};
|
|
|
|
|
|
static int loadGlobalFunctions(VulkanVideoContext *context)
|
|
{
|
|
context->vkGetInstanceProcAddr = (PFN_vkGetInstanceProcAddr)SDL_Vulkan_GetVkGetInstanceProcAddr();
|
|
if (!context->vkGetInstanceProcAddr) {
|
|
return -1;
|
|
}
|
|
|
|
#define VULKAN_GLOBAL_FUNCTION(name) \
|
|
context->name = (PFN_##name)context->vkGetInstanceProcAddr(VK_NULL_HANDLE, #name); \
|
|
if (!context->name) { \
|
|
return SDL_SetError("vkGetInstanceProcAddr(VK_NULL_HANDLE, \"" #name "\") failed"); \
|
|
}
|
|
#define VULKAN_INSTANCE_FUNCTION(name)
|
|
#define VULKAN_DEVICE_FUNCTION(name)
|
|
VULKAN_FUNCTIONS()
|
|
#undef VULKAN_GLOBAL_FUNCTION
|
|
#undef VULKAN_INSTANCE_FUNCTION
|
|
#undef VULKAN_DEVICE_FUNCTION
|
|
return 0;
|
|
}
|
|
|
|
static int loadInstanceFunctions(VulkanVideoContext *context)
|
|
{
|
|
#define VULKAN_GLOBAL_FUNCTION(name)
|
|
#define VULKAN_INSTANCE_FUNCTION(name) \
|
|
context->name = (PFN_##name)context->vkGetInstanceProcAddr(context->instance, #name); \
|
|
if (!context->name) { \
|
|
return SDL_SetError("vkGetInstanceProcAddr(instance, \"" #name "\") failed"); \
|
|
}
|
|
#define VULKAN_DEVICE_FUNCTION(name)
|
|
VULKAN_FUNCTIONS()
|
|
#undef VULKAN_GLOBAL_FUNCTION
|
|
#undef VULKAN_INSTANCE_FUNCTION
|
|
#undef VULKAN_DEVICE_FUNCTION
|
|
return 0;
|
|
}
|
|
|
|
static int loadDeviceFunctions(VulkanVideoContext *context)
|
|
{
|
|
#define VULKAN_GLOBAL_FUNCTION(name)
|
|
#define VULKAN_INSTANCE_FUNCTION(name)
|
|
#define VULKAN_DEVICE_FUNCTION(name) \
|
|
context->name = (PFN_##name)context->vkGetDeviceProcAddr(context->device, #name); \
|
|
if (!context->name) { \
|
|
return SDL_SetError("vkGetDeviceProcAddr(device, \"" #name "\") failed\n"); \
|
|
}
|
|
VULKAN_FUNCTIONS()
|
|
#undef VULKAN_GLOBAL_FUNCTION
|
|
#undef VULKAN_INSTANCE_FUNCTION
|
|
#undef VULKAN_DEVICE_FUNCTION
|
|
return 0;
|
|
}
|
|
|
|
#undef VULKAN_FUNCTIONS
|
|
|
|
static const char *getVulkanResultString(VkResult result)
|
|
{
|
|
switch ((int)result) {
|
|
#define RESULT_CASE(x) \
|
|
case x: \
|
|
return #x
|
|
RESULT_CASE(VK_SUCCESS);
|
|
RESULT_CASE(VK_NOT_READY);
|
|
RESULT_CASE(VK_TIMEOUT);
|
|
RESULT_CASE(VK_EVENT_SET);
|
|
RESULT_CASE(VK_EVENT_RESET);
|
|
RESULT_CASE(VK_INCOMPLETE);
|
|
RESULT_CASE(VK_ERROR_OUT_OF_HOST_MEMORY);
|
|
RESULT_CASE(VK_ERROR_OUT_OF_DEVICE_MEMORY);
|
|
RESULT_CASE(VK_ERROR_INITIALIZATION_FAILED);
|
|
RESULT_CASE(VK_ERROR_DEVICE_LOST);
|
|
RESULT_CASE(VK_ERROR_MEMORY_MAP_FAILED);
|
|
RESULT_CASE(VK_ERROR_LAYER_NOT_PRESENT);
|
|
RESULT_CASE(VK_ERROR_EXTENSION_NOT_PRESENT);
|
|
RESULT_CASE(VK_ERROR_FEATURE_NOT_PRESENT);
|
|
RESULT_CASE(VK_ERROR_INCOMPATIBLE_DRIVER);
|
|
RESULT_CASE(VK_ERROR_TOO_MANY_OBJECTS);
|
|
RESULT_CASE(VK_ERROR_FORMAT_NOT_SUPPORTED);
|
|
RESULT_CASE(VK_ERROR_FRAGMENTED_POOL);
|
|
RESULT_CASE(VK_ERROR_SURFACE_LOST_KHR);
|
|
RESULT_CASE(VK_ERROR_NATIVE_WINDOW_IN_USE_KHR);
|
|
RESULT_CASE(VK_SUBOPTIMAL_KHR);
|
|
RESULT_CASE(VK_ERROR_OUT_OF_DATE_KHR);
|
|
RESULT_CASE(VK_ERROR_INCOMPATIBLE_DISPLAY_KHR);
|
|
RESULT_CASE(VK_ERROR_VALIDATION_FAILED_EXT);
|
|
RESULT_CASE(VK_ERROR_OUT_OF_POOL_MEMORY_KHR);
|
|
RESULT_CASE(VK_ERROR_INVALID_SHADER_NV);
|
|
#undef RESULT_CASE
|
|
default:
|
|
break;
|
|
}
|
|
return (result < 0) ? "VK_ERROR_<Unknown>" : "VK_<Unknown>";
|
|
}
|
|
|
|
static int createInstance(VulkanVideoContext *context)
|
|
{
|
|
static const char *optional_extensions[] = {
|
|
VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME,
|
|
VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME
|
|
};
|
|
VkApplicationInfo appInfo = { 0 };
|
|
VkInstanceCreateInfo instanceCreateInfo = { 0 };
|
|
VkResult result;
|
|
char const *const *instanceExtensions = SDL_Vulkan_GetInstanceExtensions(&instanceCreateInfo.enabledExtensionCount);
|
|
|
|
appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
|
|
appInfo.apiVersion = VK_API_VERSION_1_3;
|
|
instanceCreateInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
|
|
instanceCreateInfo.pApplicationInfo = &appInfo;
|
|
|
|
const char **instanceExtensionsCopy = SDL_calloc(instanceCreateInfo.enabledExtensionCount + SDL_arraysize(optional_extensions), sizeof(const char *));
|
|
for (uint32_t i = 0; i < instanceCreateInfo.enabledExtensionCount; i++) {
|
|
instanceExtensionsCopy[i] = instanceExtensions[i];
|
|
}
|
|
|
|
// Get the rest of the optional extensions
|
|
{
|
|
uint32_t extensionCount;
|
|
if (context->vkEnumerateInstanceExtensionProperties(NULL, &extensionCount, NULL) == VK_SUCCESS && extensionCount > 0) {
|
|
VkExtensionProperties *extensionProperties = SDL_calloc(sizeof(VkExtensionProperties), extensionCount);
|
|
if (context->vkEnumerateInstanceExtensionProperties(NULL, &extensionCount, extensionProperties) == VK_SUCCESS) {
|
|
for (uint32_t i = 0; i < SDL_arraysize(optional_extensions); ++i) {
|
|
for (uint32_t j = 0; j < extensionCount; ++j) {
|
|
if (SDL_strcmp(extensionProperties[j].extensionName, optional_extensions[i]) == 0) {
|
|
instanceExtensionsCopy[instanceCreateInfo.enabledExtensionCount++] = optional_extensions[i];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
SDL_free(extensionProperties);
|
|
}
|
|
}
|
|
instanceCreateInfo.ppEnabledExtensionNames = instanceExtensionsCopy;
|
|
|
|
context->instanceExtensions = instanceExtensionsCopy;
|
|
context->instanceExtensionsCount = instanceCreateInfo.enabledExtensionCount;
|
|
|
|
result = context->vkCreateInstance(&instanceCreateInfo, NULL, &context->instance);
|
|
if (result != VK_SUCCESS) {
|
|
context->instance = VK_NULL_HANDLE;
|
|
return SDL_SetError("vkCreateInstance(): %s\n", getVulkanResultString(result));
|
|
}
|
|
if (loadInstanceFunctions(context) < 0) {
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int createSurface(VulkanVideoContext *context, SDL_Window *window)
|
|
{
|
|
if (!SDL_Vulkan_CreateSurface(window,
|
|
context->instance,
|
|
NULL,
|
|
&context->surface)) {
|
|
context->surface = VK_NULL_HANDLE;
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// Use the same queue scoring algorithm as ffmpeg to make sure we get the same device configuration
|
|
static int selectQueueFamily(VkQueueFamilyProperties *queueFamiliesProperties, uint32_t queueFamiliesCount, VkQueueFlagBits flags, int *queueCount)
|
|
{
|
|
uint32_t queueFamilyIndex;
|
|
uint32_t selectedQueueFamilyIndex = queueFamiliesCount;
|
|
uint32_t min_score = ~0u;
|
|
|
|
for (queueFamilyIndex = 0; queueFamilyIndex < queueFamiliesCount; ++queueFamilyIndex) {
|
|
VkQueueFlagBits current_flags = queueFamiliesProperties[queueFamilyIndex].queueFlags;
|
|
if (current_flags & flags) {
|
|
uint32_t score = av_popcount(current_flags) + queueFamiliesProperties[queueFamilyIndex].timestampValidBits;
|
|
if (score < min_score) {
|
|
selectedQueueFamilyIndex = queueFamilyIndex;
|
|
min_score = score;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (selectedQueueFamilyIndex != queueFamiliesCount) {
|
|
VkQueueFamilyProperties *selectedQueueFamily = &queueFamiliesProperties[selectedQueueFamilyIndex];
|
|
*queueCount = (int)selectedQueueFamily->queueCount;
|
|
++selectedQueueFamily->timestampValidBits;
|
|
return (int)selectedQueueFamilyIndex;
|
|
} else {
|
|
*queueCount = 0;
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
static int findPhysicalDevice(VulkanVideoContext *context)
|
|
{
|
|
uint32_t physicalDeviceCount = 0;
|
|
VkPhysicalDevice *physicalDevices;
|
|
VkQueueFamilyProperties *queueFamiliesProperties = NULL;
|
|
uint32_t queueFamiliesPropertiesAllocatedSize = 0;
|
|
VkExtensionProperties *deviceExtensions = NULL;
|
|
uint32_t deviceExtensionsAllocatedSize = 0;
|
|
uint32_t physicalDeviceIndex;
|
|
VkResult result;
|
|
|
|
result = context->vkEnumeratePhysicalDevices(context->instance, &physicalDeviceCount, NULL);
|
|
if (result != VK_SUCCESS) {
|
|
return SDL_SetError("vkEnumeratePhysicalDevices(): %s", getVulkanResultString(result));
|
|
}
|
|
if (physicalDeviceCount == 0) {
|
|
return SDL_SetError("vkEnumeratePhysicalDevices(): no physical devices");
|
|
}
|
|
physicalDevices = (VkPhysicalDevice *)SDL_malloc(sizeof(VkPhysicalDevice) * physicalDeviceCount);
|
|
if (!physicalDevices) {
|
|
return -1;
|
|
}
|
|
result = context->vkEnumeratePhysicalDevices(context->instance, &physicalDeviceCount, physicalDevices);
|
|
if (result != VK_SUCCESS) {
|
|
SDL_free(physicalDevices);
|
|
return SDL_SetError("vkEnumeratePhysicalDevices(): %s", getVulkanResultString(result));
|
|
}
|
|
context->physicalDevice = NULL;
|
|
for (physicalDeviceIndex = 0; physicalDeviceIndex < physicalDeviceCount; physicalDeviceIndex++) {
|
|
uint32_t queueFamiliesCount = 0;
|
|
uint32_t queueFamilyIndex;
|
|
uint32_t deviceExtensionCount = 0;
|
|
SDL_bool hasSwapchainExtension = SDL_FALSE;
|
|
uint32_t i;
|
|
|
|
VkPhysicalDevice physicalDevice = physicalDevices[physicalDeviceIndex];
|
|
context->vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueFamiliesCount, NULL);
|
|
if (queueFamiliesCount == 0) {
|
|
continue;
|
|
}
|
|
if (queueFamiliesPropertiesAllocatedSize < queueFamiliesCount) {
|
|
SDL_free(queueFamiliesProperties);
|
|
queueFamiliesPropertiesAllocatedSize = queueFamiliesCount;
|
|
queueFamiliesProperties = (VkQueueFamilyProperties *)SDL_malloc(sizeof(VkQueueFamilyProperties) * queueFamiliesPropertiesAllocatedSize);
|
|
if (!queueFamiliesProperties) {
|
|
SDL_free(physicalDevices);
|
|
SDL_free(deviceExtensions);
|
|
return -1;
|
|
}
|
|
}
|
|
context->vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueFamiliesCount, queueFamiliesProperties);
|
|
|
|
// Initialize timestampValidBits for scoring in selectQueueFamily
|
|
for (queueFamilyIndex = 0; queueFamilyIndex < queueFamiliesCount; queueFamilyIndex++) {
|
|
queueFamiliesProperties[queueFamilyIndex].timestampValidBits = 0;
|
|
}
|
|
context->presentQueueFamilyIndex = -1;
|
|
context->graphicsQueueFamilyIndex = -1;
|
|
for (queueFamilyIndex = 0; queueFamilyIndex < queueFamiliesCount; queueFamilyIndex++) {
|
|
VkBool32 supported = 0;
|
|
|
|
if (queueFamiliesProperties[queueFamilyIndex].queueCount == 0) {
|
|
continue;
|
|
}
|
|
|
|
if (queueFamiliesProperties[queueFamilyIndex].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
|
|
context->graphicsQueueFamilyIndex = queueFamilyIndex;
|
|
}
|
|
|
|
result = context->vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, context->surface, &supported);
|
|
if (result == VK_SUCCESS) {
|
|
if (supported) {
|
|
context->presentQueueFamilyIndex = queueFamilyIndex;
|
|
if (queueFamiliesProperties[queueFamilyIndex].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
|
|
break; // use this queue because it can present and do graphics
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (context->presentQueueFamilyIndex < 0 || context->graphicsQueueFamilyIndex < 0) {
|
|
// We can't render and present on this device
|
|
continue;
|
|
}
|
|
|
|
context->presentQueueCount = queueFamiliesProperties[context->presentQueueFamilyIndex].queueCount;
|
|
++queueFamiliesProperties[context->presentQueueFamilyIndex].timestampValidBits;
|
|
context->graphicsQueueCount = queueFamiliesProperties[context->graphicsQueueFamilyIndex].queueCount;
|
|
++queueFamiliesProperties[context->graphicsQueueFamilyIndex].timestampValidBits;
|
|
|
|
context->transferQueueFamilyIndex = selectQueueFamily(queueFamiliesProperties, queueFamiliesCount, VK_QUEUE_TRANSFER_BIT, &context->transferQueueCount);
|
|
context->computeQueueFamilyIndex = selectQueueFamily(queueFamiliesProperties, queueFamiliesCount, VK_QUEUE_COMPUTE_BIT, &context->computeQueueCount);
|
|
context->decodeQueueFamilyIndex = selectQueueFamily(queueFamiliesProperties, queueFamiliesCount, VK_QUEUE_VIDEO_DECODE_BIT_KHR, &context->decodeQueueCount);
|
|
if (context->transferQueueFamilyIndex < 0) {
|
|
// ffmpeg can fall back to the compute or graphics queues for this
|
|
context->transferQueueFamilyIndex = selectQueueFamily(queueFamiliesProperties, queueFamiliesCount, VK_QUEUE_COMPUTE_BIT, &context->transferQueueCount);
|
|
if (context->transferQueueFamilyIndex < 0) {
|
|
context->transferQueueFamilyIndex = selectQueueFamily(queueFamiliesProperties, queueFamiliesCount, VK_QUEUE_GRAPHICS_BIT, &context->transferQueueCount);
|
|
}
|
|
}
|
|
|
|
if (context->transferQueueFamilyIndex < 0 ||
|
|
context->computeQueueFamilyIndex < 0) {
|
|
// This device doesn't have the queues we need for video decoding
|
|
continue;
|
|
}
|
|
|
|
result = context->vkEnumerateDeviceExtensionProperties(physicalDevice, NULL, &deviceExtensionCount, NULL);
|
|
if (result != VK_SUCCESS) {
|
|
SDL_free(physicalDevices);
|
|
SDL_free(queueFamiliesProperties);
|
|
SDL_free(deviceExtensions);
|
|
return SDL_SetError("vkEnumerateDeviceExtensionProperties(): %s", getVulkanResultString(result));
|
|
}
|
|
if (deviceExtensionCount == 0) {
|
|
continue;
|
|
}
|
|
if (deviceExtensionsAllocatedSize < deviceExtensionCount) {
|
|
SDL_free(deviceExtensions);
|
|
deviceExtensionsAllocatedSize = deviceExtensionCount;
|
|
deviceExtensions = SDL_malloc(sizeof(VkExtensionProperties) * deviceExtensionsAllocatedSize);
|
|
if (!deviceExtensions) {
|
|
SDL_free(physicalDevices);
|
|
SDL_free(queueFamiliesProperties);
|
|
return -1;
|
|
}
|
|
}
|
|
result = context->vkEnumerateDeviceExtensionProperties(physicalDevice, NULL, &deviceExtensionCount, deviceExtensions);
|
|
if (result != VK_SUCCESS) {
|
|
SDL_free(physicalDevices);
|
|
SDL_free(queueFamiliesProperties);
|
|
SDL_free(deviceExtensions);
|
|
return SDL_SetError("vkEnumerateDeviceExtensionProperties(): %s", getVulkanResultString(result));
|
|
}
|
|
for (i = 0; i < deviceExtensionCount; i++) {
|
|
if (SDL_strcmp(deviceExtensions[i].extensionName, VK_KHR_SWAPCHAIN_EXTENSION_NAME) == 0) {
|
|
hasSwapchainExtension = SDL_TRUE;
|
|
break;
|
|
}
|
|
}
|
|
if (!hasSwapchainExtension) {
|
|
continue;
|
|
}
|
|
context->physicalDevice = physicalDevice;
|
|
break;
|
|
}
|
|
SDL_free(physicalDevices);
|
|
SDL_free(queueFamiliesProperties);
|
|
SDL_free(deviceExtensions);
|
|
if (!context->physicalDevice) {
|
|
return SDL_SetError("Vulkan: no viable physical devices found");
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static void initDeviceFeatures(VulkanDeviceFeatures *features)
|
|
{
|
|
features->device_features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
|
|
features->device_features.pNext = &features->device_features_1_1;
|
|
features->device_features_1_1.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES;
|
|
features->device_features_1_1.pNext = &features->device_features_1_2;
|
|
features->device_features_1_2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES;
|
|
features->device_features_1_2.pNext = &features->device_features_1_3;
|
|
features->device_features_1_3.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES;
|
|
features->device_features_1_3.pNext = &features->desc_buf_features;
|
|
features->desc_buf_features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT;
|
|
features->desc_buf_features.pNext = &features->atomic_float_features;
|
|
features->atomic_float_features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT;
|
|
features->atomic_float_features.pNext = &features->coop_matrix_features;
|
|
features->coop_matrix_features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR;
|
|
features->coop_matrix_features.pNext = NULL;
|
|
}
|
|
|
|
static void copyDeviceFeatures(VulkanDeviceFeatures *supported_features, VulkanDeviceFeatures *requested_features)
|
|
{
|
|
#define COPY_OPTIONAL_FEATURE(X) requested_features->X = supported_features->X
|
|
COPY_OPTIONAL_FEATURE(device_features.features.shaderImageGatherExtended);
|
|
COPY_OPTIONAL_FEATURE(device_features.features.shaderStorageImageReadWithoutFormat);
|
|
COPY_OPTIONAL_FEATURE(device_features.features.shaderStorageImageWriteWithoutFormat);
|
|
COPY_OPTIONAL_FEATURE(device_features.features.fragmentStoresAndAtomics);
|
|
COPY_OPTIONAL_FEATURE(device_features.features.vertexPipelineStoresAndAtomics);
|
|
COPY_OPTIONAL_FEATURE(device_features.features.shaderInt64);
|
|
COPY_OPTIONAL_FEATURE(device_features.features.shaderInt16);
|
|
COPY_OPTIONAL_FEATURE(device_features.features.shaderFloat64);
|
|
COPY_OPTIONAL_FEATURE(device_features_1_1.samplerYcbcrConversion);
|
|
COPY_OPTIONAL_FEATURE(device_features_1_1.storagePushConstant16);
|
|
COPY_OPTIONAL_FEATURE(device_features_1_2.bufferDeviceAddress);
|
|
COPY_OPTIONAL_FEATURE(device_features_1_2.hostQueryReset);
|
|
COPY_OPTIONAL_FEATURE(device_features_1_2.storagePushConstant8);
|
|
COPY_OPTIONAL_FEATURE(device_features_1_2.shaderInt8);
|
|
COPY_OPTIONAL_FEATURE(device_features_1_2.storageBuffer8BitAccess);
|
|
COPY_OPTIONAL_FEATURE(device_features_1_2.uniformAndStorageBuffer8BitAccess);
|
|
COPY_OPTIONAL_FEATURE(device_features_1_2.shaderFloat16);
|
|
COPY_OPTIONAL_FEATURE(device_features_1_2.shaderSharedInt64Atomics);
|
|
COPY_OPTIONAL_FEATURE(device_features_1_2.vulkanMemoryModel);
|
|
COPY_OPTIONAL_FEATURE(device_features_1_2.vulkanMemoryModelDeviceScope);
|
|
COPY_OPTIONAL_FEATURE(device_features_1_2.hostQueryReset);
|
|
COPY_OPTIONAL_FEATURE(device_features_1_3.dynamicRendering);
|
|
COPY_OPTIONAL_FEATURE(device_features_1_3.maintenance4);
|
|
COPY_OPTIONAL_FEATURE(device_features_1_3.synchronization2);
|
|
COPY_OPTIONAL_FEATURE(device_features_1_3.computeFullSubgroups);
|
|
COPY_OPTIONAL_FEATURE(device_features_1_3.shaderZeroInitializeWorkgroupMemory);
|
|
COPY_OPTIONAL_FEATURE(desc_buf_features.descriptorBuffer);
|
|
COPY_OPTIONAL_FEATURE(desc_buf_features.descriptorBufferPushDescriptors);
|
|
COPY_OPTIONAL_FEATURE(atomic_float_features.shaderBufferFloat32Atomics);
|
|
COPY_OPTIONAL_FEATURE(atomic_float_features.shaderBufferFloat32AtomicAdd);
|
|
COPY_OPTIONAL_FEATURE(coop_matrix_features.cooperativeMatrix);
|
|
#undef COPY_OPTIONAL_FEATURE
|
|
|
|
// timeline semaphores is required by ffmpeg
|
|
requested_features->device_features_1_2.timelineSemaphore = 1;
|
|
}
|
|
|
|
static int addQueueFamily(VkDeviceQueueCreateInfo **pQueueCreateInfos, uint32_t *pQueueCreateInfoCount, uint32_t queueFamilyIndex, uint32_t queueCount)
|
|
{
|
|
VkDeviceQueueCreateInfo *queueCreateInfo;
|
|
VkDeviceQueueCreateInfo *queueCreateInfos = *pQueueCreateInfos;
|
|
uint32_t queueCreateInfoCount = *pQueueCreateInfoCount;
|
|
float *queuePriorities;
|
|
|
|
if (queueCount == 0) {
|
|
return 0;
|
|
}
|
|
|
|
for (uint32_t i = 0; i < queueCreateInfoCount; ++i) {
|
|
if (queueCreateInfos[i].queueFamilyIndex == queueFamilyIndex) {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
queueCreateInfos = (VkDeviceQueueCreateInfo *)SDL_realloc(queueCreateInfos, (queueCreateInfoCount + 1) * sizeof(*queueCreateInfos));
|
|
if (!queueCreateInfos) {
|
|
return -1;
|
|
}
|
|
|
|
queuePriorities = (float *)SDL_malloc(queueCount * sizeof(*queuePriorities));
|
|
if (!queuePriorities) {
|
|
return -1;
|
|
}
|
|
|
|
for (uint32_t i = 0; i < queueCount; ++i) {
|
|
queuePriorities[i] = 1.0f / queueCount;
|
|
}
|
|
|
|
queueCreateInfo = &queueCreateInfos[queueCreateInfoCount++];
|
|
SDL_zerop(queueCreateInfo);
|
|
queueCreateInfo->sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
|
|
queueCreateInfo->queueFamilyIndex = queueFamilyIndex;
|
|
queueCreateInfo->queueCount = queueCount;
|
|
queueCreateInfo->pQueuePriorities = queuePriorities;
|
|
|
|
*pQueueCreateInfos = queueCreateInfos;
|
|
*pQueueCreateInfoCount = queueCreateInfoCount;
|
|
return 0;
|
|
}
|
|
|
|
static int createDevice(VulkanVideoContext *context)
|
|
{
|
|
static const char *const deviceExtensionNames[] = {
|
|
VK_KHR_SWAPCHAIN_EXTENSION_NAME,
|
|
VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME,
|
|
VK_KHR_MAINTENANCE1_EXTENSION_NAME,
|
|
VK_KHR_BIND_MEMORY_2_EXTENSION_NAME,
|
|
VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME,
|
|
};
|
|
static const char *optional_extensions[] = {
|
|
VK_KHR_VIDEO_QUEUE_EXTENSION_NAME,
|
|
VK_KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME,
|
|
VK_KHR_VIDEO_DECODE_H264_EXTENSION_NAME,
|
|
VK_KHR_VIDEO_DECODE_H265_EXTENSION_NAME,
|
|
"VK_MESA_video_decode_av1"
|
|
};
|
|
VkDeviceCreateInfo deviceCreateInfo = { 0 };
|
|
VkDeviceQueueCreateInfo *queueCreateInfos = NULL;
|
|
uint32_t queueCreateInfoCount = 0;
|
|
VulkanDeviceFeatures supported_features;
|
|
VkResult result = VK_ERROR_UNKNOWN;
|
|
|
|
if (addQueueFamily(&queueCreateInfos, &queueCreateInfoCount, context->presentQueueFamilyIndex, context->presentQueueCount) < 0 ||
|
|
addQueueFamily(&queueCreateInfos, &queueCreateInfoCount, context->graphicsQueueFamilyIndex, context->graphicsQueueCount) < 0 ||
|
|
addQueueFamily(&queueCreateInfos, &queueCreateInfoCount, context->transferQueueFamilyIndex, context->transferQueueCount) < 0 ||
|
|
addQueueFamily(&queueCreateInfos, &queueCreateInfoCount, context->computeQueueFamilyIndex, context->computeQueueCount) < 0 ||
|
|
addQueueFamily(&queueCreateInfos, &queueCreateInfoCount, context->decodeQueueFamilyIndex, context->decodeQueueCount) < 0) {
|
|
goto done;
|
|
}
|
|
|
|
initDeviceFeatures(&supported_features);
|
|
initDeviceFeatures(&context->features);
|
|
context->vkGetPhysicalDeviceFeatures2(context->physicalDevice, &supported_features.device_features);
|
|
copyDeviceFeatures(&supported_features, &context->features);
|
|
|
|
deviceCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
|
|
deviceCreateInfo.queueCreateInfoCount = queueCreateInfoCount;
|
|
deviceCreateInfo.pQueueCreateInfos = queueCreateInfos;
|
|
deviceCreateInfo.pEnabledFeatures = NULL;
|
|
deviceCreateInfo.enabledExtensionCount = SDL_arraysize(deviceExtensionNames);
|
|
deviceCreateInfo.pNext = &context->features.device_features;
|
|
|
|
const char **deviceExtensionsCopy = SDL_calloc(deviceCreateInfo.enabledExtensionCount + SDL_arraysize(optional_extensions), sizeof(const char *));
|
|
for (uint32_t i = 0; i < deviceCreateInfo.enabledExtensionCount; i++) {
|
|
deviceExtensionsCopy[i] = deviceExtensionNames[i];
|
|
}
|
|
|
|
// Get the rest of the optional extensions
|
|
{
|
|
uint32_t extensionCount;
|
|
if (context->vkEnumerateDeviceExtensionProperties(context->physicalDevice, NULL, &extensionCount, NULL) == VK_SUCCESS && extensionCount > 0) {
|
|
VkExtensionProperties *extensionProperties = SDL_calloc(sizeof(VkExtensionProperties), extensionCount);
|
|
if (context->vkEnumerateDeviceExtensionProperties(context->physicalDevice, NULL, &extensionCount, extensionProperties) == VK_SUCCESS) {
|
|
for (uint32_t i = 0; i < SDL_arraysize(optional_extensions); ++i) {
|
|
for (uint32_t j = 0; j < extensionCount; ++j) {
|
|
if (SDL_strcmp(extensionProperties[j].extensionName, optional_extensions[i]) == 0) {
|
|
deviceExtensionsCopy[deviceCreateInfo.enabledExtensionCount++] = optional_extensions[i];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
SDL_free(extensionProperties);
|
|
}
|
|
}
|
|
deviceCreateInfo.ppEnabledExtensionNames = deviceExtensionsCopy;
|
|
|
|
context->deviceExtensions = deviceExtensionsCopy;
|
|
context->deviceExtensionsCount = deviceCreateInfo.enabledExtensionCount;
|
|
|
|
result = context->vkCreateDevice(context->physicalDevice, &deviceCreateInfo, NULL, &context->device);
|
|
if (result != VK_SUCCESS) {
|
|
SDL_SetError("vkCreateDevice(): %s", getVulkanResultString(result));
|
|
goto done;
|
|
}
|
|
|
|
if (loadDeviceFunctions(context) < 0) {
|
|
result = VK_ERROR_UNKNOWN;
|
|
context->device = VK_NULL_HANDLE;
|
|
goto done;
|
|
}
|
|
|
|
// Get the graphics queue that SDL will use
|
|
context->vkGetDeviceQueue(context->device, context->graphicsQueueFamilyIndex, 0, &context->graphicsQueue);
|
|
|
|
// Create a command pool
|
|
VkCommandPoolCreateInfo commandPoolCreateInfo = { 0 };
|
|
commandPoolCreateInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
|
|
commandPoolCreateInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
|
|
commandPoolCreateInfo.queueFamilyIndex = context->graphicsQueueFamilyIndex;
|
|
result = context->vkCreateCommandPool(context->device, &commandPoolCreateInfo, NULL, &context->commandPool);
|
|
if (result != VK_SUCCESS) {
|
|
SDL_SetError("vkCreateCommandPool(): %s", getVulkanResultString(result));
|
|
goto done;
|
|
}
|
|
|
|
done:
|
|
for (uint32_t i = 0; i < queueCreateInfoCount; ++i) {
|
|
SDL_free((void *)queueCreateInfos[i].pQueuePriorities);
|
|
}
|
|
SDL_free(queueCreateInfos);
|
|
|
|
if (result != VK_SUCCESS) {
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
VulkanVideoContext *CreateVulkanVideoContext(SDL_Window *window)
|
|
{
|
|
VulkanVideoContext *context = SDL_calloc(1, sizeof(*context));
|
|
if (!context) {
|
|
return NULL;
|
|
}
|
|
if (loadGlobalFunctions(context) < 0 ||
|
|
createInstance(context) < 0 ||
|
|
createSurface(context, window) < 0 ||
|
|
findPhysicalDevice(context) < 0 ||
|
|
createDevice(context) < 0) {
|
|
DestroyVulkanVideoContext(context);
|
|
return NULL;
|
|
}
|
|
return context;
|
|
}
|
|
|
|
void SetupVulkanRenderProperties(VulkanVideoContext *context, SDL_PropertiesID props)
|
|
{
|
|
SDL_SetProperty(props, SDL_PROP_RENDERER_CREATE_VULKAN_INSTANCE_POINTER, context->instance);
|
|
SDL_SetNumberProperty(props, SDL_PROP_RENDERER_CREATE_VULKAN_SURFACE_NUMBER, (Sint64)context->surface);
|
|
SDL_SetProperty(props, SDL_PROP_RENDERER_CREATE_VULKAN_PHYSICAL_DEVICE_POINTER, context->physicalDevice);
|
|
SDL_SetProperty(props, SDL_PROP_RENDERER_CREATE_VULKAN_DEVICE_POINTER, context->device);
|
|
SDL_SetNumberProperty(props, SDL_PROP_RENDERER_CREATE_VULKAN_PRESENT_QUEUE_FAMILY_INDEX_NUMBER, context->presentQueueFamilyIndex);
|
|
SDL_SetNumberProperty(props, SDL_PROP_RENDERER_CREATE_VULKAN_GRAPHICS_QUEUE_FAMILY_INDEX_NUMBER, context->graphicsQueueFamilyIndex);
|
|
}
|
|
|
|
void SetupVulkanDeviceContextData(VulkanVideoContext *context, AVVulkanDeviceContext *ctx)
|
|
{
|
|
ctx->get_proc_addr = context->vkGetInstanceProcAddr;
|
|
ctx->inst = context->instance;
|
|
ctx->phys_dev = context->physicalDevice;
|
|
ctx->act_dev = context->device;
|
|
ctx->device_features = context->features.device_features;
|
|
ctx->enabled_inst_extensions = context->instanceExtensions;
|
|
ctx->nb_enabled_inst_extensions = context->instanceExtensionsCount;
|
|
ctx->enabled_dev_extensions = context->deviceExtensions;
|
|
ctx->nb_enabled_dev_extensions = context->deviceExtensionsCount;
|
|
ctx->queue_family_index = context->graphicsQueueFamilyIndex;
|
|
ctx->nb_graphics_queues = context->graphicsQueueCount;
|
|
ctx->queue_family_tx_index = context->transferQueueFamilyIndex;
|
|
ctx->nb_tx_queues = context->transferQueueCount;
|
|
ctx->queue_family_comp_index = context->computeQueueFamilyIndex;
|
|
ctx->nb_comp_queues = context->computeQueueCount;
|
|
ctx->queue_family_encode_index = -1;
|
|
ctx->nb_encode_queues = 0;
|
|
ctx->queue_family_decode_index = context->decodeQueueFamilyIndex;
|
|
ctx->nb_decode_queues = context->decodeQueueCount;
|
|
}
|
|
|
|
static int CreateCommandBuffers(VulkanVideoContext *context, SDL_Renderer *renderer)
|
|
{
|
|
uint32_t commandBufferCount = (uint32_t)SDL_GetNumberProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_VULKAN_SWAPCHAIN_IMAGE_COUNT_NUMBER, 1);
|
|
|
|
if (commandBufferCount > context->waitSemaphoreCount) {
|
|
VkSemaphore *semaphores = (VkSemaphore *)SDL_realloc(context->waitSemaphores, commandBufferCount * sizeof(*semaphores));
|
|
if (!semaphores) {
|
|
return -1;
|
|
}
|
|
context->waitSemaphores = semaphores;
|
|
|
|
VkSemaphoreCreateInfo semaphoreCreateInfo = { 0 };
|
|
semaphoreCreateInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
|
|
while (context->waitSemaphoreCount < commandBufferCount) {
|
|
VkResult result = context->vkCreateSemaphore(context->device, &semaphoreCreateInfo, NULL, &context->waitSemaphores[context->waitSemaphoreCount]);
|
|
if (result != VK_SUCCESS) {
|
|
SDL_SetError("vkCreateSemaphore(): %s", getVulkanResultString(result));
|
|
return -1;
|
|
}
|
|
++context->waitSemaphoreCount;
|
|
}
|
|
}
|
|
|
|
if (commandBufferCount > context->signalSemaphoreCount) {
|
|
VkSemaphore *semaphores = (VkSemaphore *)SDL_realloc(context->signalSemaphores, commandBufferCount * sizeof(*semaphores));
|
|
if (!semaphores) {
|
|
return -1;
|
|
}
|
|
context->signalSemaphores = semaphores;
|
|
|
|
VkSemaphoreCreateInfo semaphoreCreateInfo = { 0 };
|
|
semaphoreCreateInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
|
|
while (context->signalSemaphoreCount < commandBufferCount) {
|
|
VkResult result = context->vkCreateSemaphore(context->device, &semaphoreCreateInfo, NULL, &context->signalSemaphores[context->signalSemaphoreCount]);
|
|
if (result != VK_SUCCESS) {
|
|
SDL_SetError("vkCreateSemaphore(): %s", getVulkanResultString(result));
|
|
return -1;
|
|
}
|
|
++context->signalSemaphoreCount;
|
|
}
|
|
}
|
|
|
|
if (commandBufferCount > context->commandBufferCount) {
|
|
uint32_t needed = (commandBufferCount - context->commandBufferCount);
|
|
VkCommandBuffer *commandBuffers = (VkCommandBuffer *)SDL_realloc(context->commandBuffers, commandBufferCount * sizeof(*commandBuffers));
|
|
if (!commandBuffers) {
|
|
return -1;
|
|
}
|
|
context->commandBuffers = commandBuffers;
|
|
|
|
VkCommandBufferAllocateInfo commandBufferAllocateInfo = { 0 };
|
|
commandBufferAllocateInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
|
|
commandBufferAllocateInfo.commandPool = context->commandPool;
|
|
commandBufferAllocateInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
|
|
commandBufferAllocateInfo.commandBufferCount = needed;
|
|
VkResult result = context->vkAllocateCommandBuffers(context->device, &commandBufferAllocateInfo, &context->commandBuffers[context->commandBufferCount]);
|
|
if (result != VK_SUCCESS) {
|
|
SDL_SetError("vkAllocateCommandBuffers(): %s", getVulkanResultString(result));
|
|
return -1;
|
|
}
|
|
|
|
context->commandBufferCount = commandBufferCount;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int BeginVulkanFrameRendering(VulkanVideoContext *context, AVFrame *frame, SDL_Renderer *renderer)
|
|
{
|
|
AVHWFramesContext *frames = (AVHWFramesContext *)(frame->hw_frames_ctx->data);
|
|
AVVulkanFramesContext *vk = (AVVulkanFramesContext *)(frames->hwctx);
|
|
AVVkFrame *pVkFrame = (AVVkFrame *)frame->data[0];
|
|
|
|
if (CreateCommandBuffers(context, renderer) < 0) {
|
|
return -1;
|
|
}
|
|
|
|
vk->lock_frame(frames, pVkFrame);
|
|
|
|
VkTimelineSemaphoreSubmitInfo timeline = { 0 };
|
|
timeline.sType = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO;
|
|
timeline.waitSemaphoreValueCount = 1;
|
|
timeline.pWaitSemaphoreValues = pVkFrame->sem_value;
|
|
|
|
VkPipelineStageFlags pipelineStageMask = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
|
|
VkSubmitInfo submitInfo = { 0 };
|
|
submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
|
|
submitInfo.waitSemaphoreCount = 1;
|
|
submitInfo.pWaitSemaphores = pVkFrame->sem;
|
|
submitInfo.pWaitDstStageMask = &pipelineStageMask;
|
|
submitInfo.signalSemaphoreCount = 1;
|
|
submitInfo.pSignalSemaphores = &context->waitSemaphores[context->commandBufferIndex];
|
|
submitInfo.pNext = &timeline;
|
|
|
|
if (pVkFrame->layout[0] != VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL) {
|
|
VkCommandBuffer commandBuffer = context->commandBuffers[context->commandBufferIndex];
|
|
|
|
VkCommandBufferBeginInfo beginInfo = { 0 };
|
|
beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
|
|
beginInfo.flags = 0;
|
|
context->vkBeginCommandBuffer(commandBuffer, &beginInfo);
|
|
|
|
VkImageMemoryBarrier2 barrier = { 0 };
|
|
barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2;
|
|
barrier.srcAccessMask = VK_ACCESS_2_NONE;
|
|
barrier.dstAccessMask = VK_ACCESS_2_SHADER_SAMPLED_READ_BIT;
|
|
barrier.oldLayout = pVkFrame->layout[0];
|
|
barrier.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
|
|
barrier.image = pVkFrame->img[0];
|
|
barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
barrier.subresourceRange.levelCount = 1;
|
|
barrier.subresourceRange.layerCount = 1;
|
|
barrier.srcQueueFamilyIndex = pVkFrame->queue_family[0];
|
|
barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
|
|
barrier.srcStageMask = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
|
|
barrier.dstStageMask = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
|
|
|
|
VkDependencyInfo dep = { 0 };
|
|
dep.sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO;
|
|
dep.dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT;
|
|
dep.imageMemoryBarrierCount = 1;
|
|
dep.pImageMemoryBarriers = &barrier;
|
|
context->vkCmdPipelineBarrier2(commandBuffer, &dep);
|
|
|
|
context->vkEndCommandBuffer(commandBuffer);
|
|
|
|
// Add the image barrier to the submit info
|
|
submitInfo.commandBufferCount = 1;
|
|
submitInfo.pCommandBuffers = &context->commandBuffers[context->commandBufferIndex];
|
|
|
|
pVkFrame->layout[0] = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
|
|
pVkFrame->queue_family[0] = VK_QUEUE_FAMILY_IGNORED;
|
|
}
|
|
|
|
VkResult result = context->vkQueueSubmit(context->graphicsQueue, 1, &submitInfo, 0);
|
|
if (result != VK_SUCCESS) {
|
|
// Don't return an error here, we need to complete the frame operation
|
|
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION , "vkQueueSubmit(): %s", getVulkanResultString(result));
|
|
}
|
|
|
|
SDL_AddVulkanRenderSemaphores(renderer, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, (Sint64)context->waitSemaphores[context->commandBufferIndex], (Sint64)context->signalSemaphores[context->commandBufferIndex]);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int FinishVulkanFrameRendering(VulkanVideoContext *context, AVFrame *frame, SDL_Renderer *renderer)
|
|
{
|
|
AVHWFramesContext *frames = (AVHWFramesContext *)(frame->hw_frames_ctx->data);
|
|
AVVulkanFramesContext *vk = (AVVulkanFramesContext *)(frames->hwctx);
|
|
AVVkFrame *pVkFrame = (AVVkFrame *)frame->data[0];
|
|
|
|
// Transition the frame back to ffmpeg
|
|
++pVkFrame->sem_value[0];
|
|
|
|
VkTimelineSemaphoreSubmitInfo timeline = { 0 };
|
|
timeline.sType = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO;
|
|
timeline.signalSemaphoreValueCount = 1;
|
|
timeline.pSignalSemaphoreValues = pVkFrame->sem_value;
|
|
|
|
VkPipelineStageFlags pipelineStageMask = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
|
|
VkSubmitInfo submitInfo = { 0 };
|
|
submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
|
|
submitInfo.waitSemaphoreCount = 1;
|
|
submitInfo.pWaitSemaphores = &context->signalSemaphores[context->commandBufferIndex];
|
|
submitInfo.pWaitDstStageMask = &pipelineStageMask;
|
|
submitInfo.signalSemaphoreCount = 1;
|
|
submitInfo.pSignalSemaphores = pVkFrame->sem;
|
|
submitInfo.pNext = &timeline;
|
|
|
|
VkResult result = context->vkQueueSubmit(context->graphicsQueue, 1, &submitInfo, 0);
|
|
if (result != VK_SUCCESS) {
|
|
// Don't return an error here, we need to complete the frame operation
|
|
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "vkQueueSubmit(): %s", getVulkanResultString(result));
|
|
}
|
|
|
|
vk->unlock_frame(frames, pVkFrame);
|
|
|
|
context->commandBufferIndex = (context->commandBufferIndex + 1) % context->commandBufferCount;
|
|
|
|
return 0;
|
|
}
|
|
|
|
SDL_Texture *CreateVulkanVideoTexture(VulkanVideoContext *context, AVFrame *frame, SDL_Renderer *renderer, SDL_PropertiesID props)
|
|
{
|
|
AVHWFramesContext *frames = (AVHWFramesContext *)(frame->hw_frames_ctx->data);
|
|
AVVulkanFramesContext *vk = (AVVulkanFramesContext *)(frames->hwctx);
|
|
AVVkFrame *pVkFrame = (AVVkFrame *)frame->data[0];
|
|
Uint32 format;
|
|
|
|
switch (vk->format[0]) {
|
|
case VK_FORMAT_G8B8G8R8_422_UNORM:
|
|
format = SDL_PIXELFORMAT_YUY2;
|
|
break;
|
|
case VK_FORMAT_B8G8R8G8_422_UNORM:
|
|
format = SDL_PIXELFORMAT_UYVY;
|
|
break;
|
|
case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
|
|
format = SDL_PIXELFORMAT_IYUV;
|
|
break;
|
|
case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
|
|
format = SDL_PIXELFORMAT_NV12;
|
|
break;
|
|
case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16:
|
|
format = SDL_PIXELFORMAT_P010;
|
|
break;
|
|
default:
|
|
format = SDL_PIXELFORMAT_UNKNOWN;
|
|
break;
|
|
}
|
|
SDL_SetNumberProperty(props, SDL_PROP_TEXTURE_CREATE_FORMAT_NUMBER, format);
|
|
SDL_SetNumberProperty(props, SDL_PROP_TEXTURE_CREATE_VULKAN_TEXTURE_NUMBER, (Sint64)pVkFrame->img[0]);
|
|
return SDL_CreateTextureWithProperties(renderer, props);
|
|
}
|
|
|
|
void DestroyVulkanVideoContext(VulkanVideoContext *context)
|
|
{
|
|
if (context) {
|
|
if (context->device) {
|
|
context->vkDeviceWaitIdle(context->device);
|
|
}
|
|
if (context->instanceExtensions) {
|
|
SDL_free(context->instanceExtensions);
|
|
}
|
|
if (context->deviceExtensions) {
|
|
SDL_free(context->deviceExtensions);
|
|
}
|
|
if (context->waitSemaphores) {
|
|
for (uint32_t i = 0; i < context->waitSemaphoreCount; ++i) {
|
|
context->vkDestroySemaphore(context->device, context->waitSemaphores[i], NULL);
|
|
}
|
|
SDL_free(context->waitSemaphores);
|
|
context->waitSemaphores = NULL;
|
|
}
|
|
if (context->signalSemaphores) {
|
|
for (uint32_t i = 0; i < context->signalSemaphoreCount; ++i) {
|
|
context->vkDestroySemaphore(context->device, context->signalSemaphores[i], NULL);
|
|
}
|
|
SDL_free(context->signalSemaphores);
|
|
context->signalSemaphores = NULL;
|
|
}
|
|
if (context->commandBuffers) {
|
|
context->vkFreeCommandBuffers(context->device, context->commandPool, context->commandBufferCount, context->commandBuffers);
|
|
SDL_free(context->commandBuffers);
|
|
context->commandBuffers = NULL;
|
|
}
|
|
if (context->commandPool) {
|
|
context->vkDestroyCommandPool(context->device, context->commandPool, NULL);
|
|
context->commandPool = VK_NULL_HANDLE;
|
|
}
|
|
if (context->device) {
|
|
context->vkDestroyDevice(context->device, NULL);
|
|
}
|
|
if (context->surface) {
|
|
context->vkDestroySurfaceKHR(context->instance, context->surface, NULL);
|
|
}
|
|
if (context->instance) {
|
|
context->vkDestroyInstance(context->instance, NULL);
|
|
}
|
|
SDL_free(context);
|
|
}
|
|
}
|
|
|
|
#else
|
|
|
|
VulkanVideoContext *CreateVulkanVideoContext(SDL_Window *window)
|
|
{
|
|
SDL_SetError("testffmpeg not built with Vulkan support");
|
|
return NULL;
|
|
}
|
|
|
|
void SetupVulkanRenderProperties(VulkanVideoContext *context, SDL_PropertiesID props)
|
|
{
|
|
}
|
|
|
|
void SetupVulkanDeviceContextData(VulkanVideoContext *context, AVVulkanDeviceContext *ctx)
|
|
{
|
|
}
|
|
|
|
SDL_Texture *CreateVulkanVideoTexture(VulkanVideoContext *context, AVFrame *frame, SDL_Renderer *renderer, SDL_PropertiesID props)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
int BeginVulkanFrameRendering(VulkanVideoContext *context, AVFrame *frame, SDL_Renderer *renderer)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
int FinishVulkanFrameRendering(VulkanVideoContext *context, AVFrame *frame, SDL_Renderer *renderer)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
void DestroyVulkanVideoContext(VulkanVideoContext *context)
|
|
{
|
|
}
|
|
|
|
#endif // FFMPEG_VULKAN_SUPPORT
|