mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-22 06:15:58 +00:00
* fix(venus): lower the guest's SPIR-V to 1.3 for the phone's shader compiler * fix(venus): lower SPIR-V to 1.3 for Mali drivers * fix(venus): keep the SPIR-V cap valid and scoped to active layers Cap inline compute pipeline code too, leave the shader hooks off when the layer is turned off, strip clip and cull distances only where they are emulated, and leave modules alone whose capabilities, decorations or OpSelect results need a newer version or an undeclared extension. * fix(venus): keep application pipeline chains read-only and check non-semantic imports Inline stage code is handed to the driver through a copy of the stage's pNext chain instead of being written into the application's create info, pipeline hooks return VK_ERROR_OUT_OF_HOST_MEMORY when their allocations fail, and a NonSemantic import is only lowered to SPIR-V 1.3 when the module declares SPV_KHR_non_semantic_info. * fix(venus): preserve valid pipeline and shader behavior * fix(venus): lower compatible read-only shader parameters * fix(venus): install SPIR-V 1.3 lowering hooks on Vulkan 1.2+ devices or emulated gaps
830 lines
34 KiB
C
830 lines
34 KiB
C
#define _GNU_SOURCE
|
|
#include "mali_compat.h"
|
|
|
|
#include <errno.h>
|
|
#include <stdarg.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#define LAYER_NAME "VK_LAYER_DROIDDECK_mali_compat"
|
|
|
|
static pthread_mutex_t global_lock = PTHREAD_MUTEX_INITIALIZER;
|
|
static struct instance *instances;
|
|
static struct device *devices;
|
|
|
|
void layer_log(const char *format, ...)
|
|
{
|
|
char line[512];
|
|
va_list args;
|
|
va_start(args, format);
|
|
vsnprintf(line, sizeof(line), format, args);
|
|
va_end(args);
|
|
fprintf(stderr, "droiddeck-mali-compat: %s\n", line);
|
|
}
|
|
|
|
/* The loader's dispatch table pointer: shared by an instance and its physical devices, and by a
|
|
* device and its queues and command buffers. */
|
|
static void *dispatch_key(const void *dispatchable)
|
|
{
|
|
return *(void *const *)dispatchable;
|
|
}
|
|
|
|
struct instance *instance_from_handle(const void *dispatchable)
|
|
{
|
|
void *key = dispatch_key(dispatchable);
|
|
pthread_mutex_lock(&global_lock);
|
|
struct instance *inst = instances;
|
|
while (inst && inst->key != key)
|
|
inst = inst->next;
|
|
pthread_mutex_unlock(&global_lock);
|
|
return inst;
|
|
}
|
|
|
|
struct device *device_from_handle(const void *dispatchable)
|
|
{
|
|
void *key = dispatch_key(dispatchable);
|
|
pthread_mutex_lock(&global_lock);
|
|
struct device *dev = devices;
|
|
while (dev && dev->key != key)
|
|
dev = dev->next;
|
|
pthread_mutex_unlock(&global_lock);
|
|
return dev;
|
|
}
|
|
|
|
static uint64_t hash(uint64_t key)
|
|
{
|
|
key ^= key >> 33;
|
|
key *= 0xff51afd7ed558ccdull;
|
|
key ^= key >> 33;
|
|
return key;
|
|
}
|
|
|
|
void *map_get(const struct handle_map *map, uint64_t key)
|
|
{
|
|
if (!map->capacity)
|
|
return NULL;
|
|
for (uint32_t i = hash(key) & (map->capacity - 1);; i = (i + 1) & (map->capacity - 1)) {
|
|
if (map->keys[i] == key)
|
|
return map->values[i];
|
|
if (!map->keys[i])
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
static void map_grow(struct handle_map *map)
|
|
{
|
|
struct handle_map bigger = {
|
|
.capacity = map->capacity ? map->capacity * 2 : 64,
|
|
};
|
|
bigger.keys = calloc(bigger.capacity, sizeof(*bigger.keys));
|
|
bigger.values = calloc(bigger.capacity, sizeof(*bigger.values));
|
|
for (uint32_t i = 0; i < map->capacity; i++) {
|
|
if (map->keys[i])
|
|
map_put(&bigger, map->keys[i], map->values[i]);
|
|
}
|
|
free(map->keys);
|
|
free(map->values);
|
|
*map = bigger;
|
|
}
|
|
|
|
void map_put(struct handle_map *map, uint64_t key, void *value)
|
|
{
|
|
if ((map->count + 1) * 4 > map->capacity * 3)
|
|
map_grow(map);
|
|
uint32_t i = hash(key) & (map->capacity - 1);
|
|
while (map->keys[i] && map->keys[i] != key)
|
|
i = (i + 1) & (map->capacity - 1);
|
|
if (!map->keys[i])
|
|
map->count++;
|
|
map->keys[i] = key;
|
|
map->values[i] = value;
|
|
}
|
|
|
|
void *map_remove(struct handle_map *map, uint64_t key)
|
|
{
|
|
if (!map->capacity)
|
|
return NULL;
|
|
uint32_t mask = map->capacity - 1;
|
|
uint32_t i = hash(key) & mask;
|
|
while (map->keys[i] != key) {
|
|
if (!map->keys[i])
|
|
return NULL;
|
|
i = (i + 1) & mask;
|
|
}
|
|
void *value = map->values[i];
|
|
map->count--;
|
|
/* Backward-shift deletion keeps every remaining key reachable from its home slot. */
|
|
for (uint32_t j = (i + 1) & mask; map->keys[j]; j = (j + 1) & mask) {
|
|
uint32_t home = hash(map->keys[j]) & mask;
|
|
if (((j - home) & mask) >= ((j - i) & mask)) {
|
|
map->keys[i] = map->keys[j];
|
|
map->values[i] = map->values[j];
|
|
i = j;
|
|
}
|
|
}
|
|
map->keys[i] = 0;
|
|
map->values[i] = NULL;
|
|
return value;
|
|
}
|
|
|
|
void map_free(struct handle_map *map)
|
|
{
|
|
free(map->keys);
|
|
free(map->values);
|
|
*map = (struct handle_map){0};
|
|
}
|
|
|
|
/* Wine processes by default. DROIDDECK_MALI_COMPAT=1 (the app's Venus route) turns it on everywhere
|
|
* but gamescope, so Zink in the Steam client and Xwayland gets robustness2's nullDescriptor, which it
|
|
* requires; gamescope runs fine on the driver's own features. =all includes gamescope too. */
|
|
static bool wanted(void)
|
|
{
|
|
const char *setting = getenv("DROIDDECK_MALI_COMPAT");
|
|
if (setting) {
|
|
if (strcmp(setting, "0") == 0)
|
|
return false;
|
|
if (strcmp(setting, "all") == 0)
|
|
return true;
|
|
return strcmp(program_invocation_short_name, "gamescope") != 0;
|
|
}
|
|
return getenv("WINEPREFIX") != NULL;
|
|
}
|
|
|
|
/* DROIDDECK_MALI_COMPAT_TRACE=1: what an application asks before it creates a device (Zink on a
|
|
* Mali-G615 through Venus gave up before vkCreateDevice without a word). */
|
|
static bool tracing(void)
|
|
{
|
|
static int on = -1;
|
|
if (on < 0) {
|
|
const char *v = getenv("DROIDDECK_MALI_COMPAT_TRACE");
|
|
on = v && *v && strcmp(v, "0") != 0;
|
|
}
|
|
return on;
|
|
}
|
|
|
|
static bool has_extension(struct instance *inst, VkPhysicalDevice physical_device, const char *name)
|
|
{
|
|
uint32_t count = 0;
|
|
inst->EnumerateDeviceExtensionProperties(physical_device, NULL, &count, NULL);
|
|
VkExtensionProperties *extensions = calloc(count, sizeof(*extensions));
|
|
inst->EnumerateDeviceExtensionProperties(physical_device, NULL, &count, extensions);
|
|
bool found = false;
|
|
for (uint32_t i = 0; i < count && !found; i++)
|
|
found = strcmp(extensions[i].extensionName, name) == 0;
|
|
free(extensions);
|
|
return found;
|
|
}
|
|
|
|
uint32_t physical_device_gaps(struct instance *inst, VkPhysicalDevice physical_device)
|
|
{
|
|
pthread_mutex_lock(&inst->lock);
|
|
for (uint32_t i = 0; i < inst->physical_device_count; i++) {
|
|
if (inst->physical_devices[i].handle == physical_device) {
|
|
uint32_t gaps = inst->physical_devices[i].gaps;
|
|
pthread_mutex_unlock(&inst->lock);
|
|
return gaps;
|
|
}
|
|
}
|
|
pthread_mutex_unlock(&inst->lock);
|
|
|
|
bool robustness2 = has_extension(inst, physical_device, "VK_EXT_robustness2");
|
|
VkPhysicalDeviceRobustness2FeaturesEXT robust = {
|
|
.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT,
|
|
};
|
|
VkPhysicalDeviceFeatures2 features = {
|
|
.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2,
|
|
.pNext = robustness2 ? &robust : NULL,
|
|
};
|
|
inst->GetPhysicalDeviceFeatures2(physical_device, &features);
|
|
uint32_t gaps = 0;
|
|
if (!features.features.fillModeNonSolid)
|
|
gaps |= GAP_FILL_MODE;
|
|
if (!features.features.multiViewport)
|
|
gaps |= GAP_MULTI_VIEWPORT;
|
|
if (!features.features.shaderClipDistance)
|
|
gaps |= GAP_CLIP_DISTANCE;
|
|
if (!features.features.shaderCullDistance)
|
|
gaps |= GAP_CULL_DISTANCE;
|
|
if (!features.features.textureCompressionBC)
|
|
gaps |= GAP_BC;
|
|
if (robustness2 && !robust.robustBufferAccess2)
|
|
gaps |= GAP_ROBUSTNESS2;
|
|
if (!features.features.multiDrawIndirect)
|
|
gaps |= GAP_MULTI_DRAW;
|
|
if (!features.features.dualSrcBlend)
|
|
gaps |= GAP_DUAL_SRC_BLEND;
|
|
if (!has_extension(inst, physical_device, VK_EXT_DEPTH_CLIP_ENABLE_EXTENSION_NAME))
|
|
gaps |= GAP_DEPTH_CLIP;
|
|
/* No robustness2 at all: the extension is offered with robustBufferAccess2 (as robustBufferAccess)
|
|
* and nullDescriptor (stand-ins, draw.c). */
|
|
if (!robustness2)
|
|
gaps |= GAP_ROBUSTNESS2 | GAP_NULL_DESCRIPTOR;
|
|
|
|
pthread_mutex_lock(&inst->lock);
|
|
if (inst->physical_device_count < sizeof(inst->physical_devices) / sizeof(inst->physical_devices[0])) {
|
|
inst->physical_devices[inst->physical_device_count++] =
|
|
(struct physical_device){.handle = physical_device, .gaps = gaps};
|
|
}
|
|
pthread_mutex_unlock(&inst->lock);
|
|
return gaps;
|
|
}
|
|
|
|
/* Structures of extensions the driver does not have are taken out of a chain for the call down and
|
|
* put back after it: the driver (and Venus) must not see them. */
|
|
struct unlinked {
|
|
VkBaseOutStructure *prev, *node;
|
|
};
|
|
|
|
static uint32_t unlink_types(void *head, const VkStructureType *types, uint32_t type_count,
|
|
struct unlinked *out, uint32_t max)
|
|
{
|
|
uint32_t n = 0;
|
|
VkBaseOutStructure *prev = head;
|
|
while (prev && prev->pNext && n < max) {
|
|
VkBaseOutStructure *s = prev->pNext;
|
|
bool drop = false;
|
|
for (uint32_t i = 0; i < type_count; i++)
|
|
drop |= s->sType == types[i];
|
|
if (drop) {
|
|
out[n++] = (struct unlinked){prev, s};
|
|
prev->pNext = s->pNext;
|
|
} else {
|
|
prev = s;
|
|
}
|
|
}
|
|
return n;
|
|
}
|
|
|
|
static void relink(struct unlinked *list, uint32_t n)
|
|
{
|
|
while (n--)
|
|
list[n].prev->pNext = list[n].node;
|
|
}
|
|
|
|
static uint32_t foreign_types(uint32_t gaps, VkStructureType *types)
|
|
{
|
|
uint32_t n = 0;
|
|
if (gaps & GAP_DEPTH_CLIP)
|
|
types[n++] = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT;
|
|
if (gaps & GAP_NULL_DESCRIPTOR)
|
|
types[n++] = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT;
|
|
return n;
|
|
}
|
|
|
|
static void report_features(VkPhysicalDeviceFeatures *features, uint32_t gaps)
|
|
{
|
|
if (gaps & GAP_FILL_MODE)
|
|
features->fillModeNonSolid = VK_TRUE;
|
|
if (gaps & GAP_MULTI_VIEWPORT)
|
|
features->multiViewport = VK_TRUE;
|
|
if (gaps & GAP_CLIP_DISTANCE)
|
|
features->shaderClipDistance = VK_TRUE;
|
|
if (gaps & GAP_CULL_DISTANCE)
|
|
features->shaderCullDistance = VK_TRUE;
|
|
if (gaps & GAP_BC)
|
|
features->textureCompressionBC = VK_TRUE;
|
|
if (gaps & GAP_MULTI_DRAW)
|
|
features->multiDrawIndirect = VK_TRUE;
|
|
if (gaps & GAP_DUAL_SRC_BLEND)
|
|
features->dualSrcBlend = VK_TRUE;
|
|
}
|
|
|
|
/* Which made-up features the application asked for, and off with them before the driver sees them. */
|
|
static uint32_t take_features(VkPhysicalDeviceFeatures *features, uint32_t gaps)
|
|
{
|
|
uint32_t requested = 0;
|
|
if ((gaps & GAP_FILL_MODE) && features->fillModeNonSolid) {
|
|
requested |= GAP_FILL_MODE;
|
|
features->fillModeNonSolid = VK_FALSE;
|
|
}
|
|
if ((gaps & GAP_MULTI_VIEWPORT) && features->multiViewport) {
|
|
requested |= GAP_MULTI_VIEWPORT;
|
|
features->multiViewport = VK_FALSE;
|
|
}
|
|
if ((gaps & GAP_CLIP_DISTANCE) && features->shaderClipDistance) {
|
|
requested |= GAP_CLIP_DISTANCE;
|
|
features->shaderClipDistance = VK_FALSE;
|
|
}
|
|
if ((gaps & GAP_CULL_DISTANCE) && features->shaderCullDistance) {
|
|
requested |= GAP_CULL_DISTANCE;
|
|
features->shaderCullDistance = VK_FALSE;
|
|
}
|
|
if ((gaps & GAP_BC) && features->textureCompressionBC) {
|
|
requested |= GAP_BC;
|
|
features->textureCompressionBC = VK_FALSE;
|
|
}
|
|
if ((gaps & GAP_MULTI_DRAW) && features->multiDrawIndirect) {
|
|
requested |= GAP_MULTI_DRAW;
|
|
features->multiDrawIndirect = VK_FALSE;
|
|
}
|
|
if ((gaps & GAP_DUAL_SRC_BLEND) && features->dualSrcBlend) {
|
|
requested |= GAP_DUAL_SRC_BLEND;
|
|
features->dualSrcBlend = VK_FALSE;
|
|
}
|
|
return requested;
|
|
}
|
|
|
|
static void report_limits(VkPhysicalDeviceLimits *limits, uint32_t gaps)
|
|
{
|
|
if (gaps & GAP_MULTI_VIEWPORT)
|
|
limits->maxViewports = 16;
|
|
if ((gaps & GAP_MULTI_DRAW) && limits->maxDrawIndirectCount < (1u << 30))
|
|
limits->maxDrawIndirectCount = 1u << 30;
|
|
if ((gaps & GAP_DUAL_SRC_BLEND) && !limits->maxFragmentDualSrcAttachments)
|
|
limits->maxFragmentDualSrcAttachments = 1;
|
|
if (gaps & GAPS_SHADER) {
|
|
limits->maxClipDistances = 8;
|
|
limits->maxCullDistances = 8;
|
|
limits->maxCombinedClipAndCullDistances = 8;
|
|
}
|
|
}
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures(VkPhysicalDevice physical_device,
|
|
VkPhysicalDeviceFeatures *features)
|
|
{
|
|
struct instance *inst = instance_from_handle(physical_device);
|
|
inst->GetPhysicalDeviceFeatures(physical_device, features);
|
|
report_features(features, physical_device_gaps(inst, physical_device));
|
|
}
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures2(VkPhysicalDevice physical_device,
|
|
VkPhysicalDeviceFeatures2 *features)
|
|
{
|
|
struct instance *inst = instance_from_handle(physical_device);
|
|
uint32_t gaps = physical_device_gaps(inst, physical_device);
|
|
VkStructureType types[4];
|
|
struct unlinked dropped[8];
|
|
uint32_t dropped_count = unlink_types(features, types, foreign_types(gaps, types), dropped, 8);
|
|
inst->GetPhysicalDeviceFeatures2(physical_device, features);
|
|
relink(dropped, dropped_count);
|
|
report_features(&features->features, gaps);
|
|
if (tracing()) {
|
|
char chain[512] = "";
|
|
size_t used = 0;
|
|
for (VkBaseOutStructure *s = features->pNext; s && used + 16 < sizeof(chain); s = s->pNext)
|
|
used += (size_t)snprintf(chain + used, sizeof(chain) - used, " %d", (int)s->sType);
|
|
layer_log("trace: vkGetPhysicalDeviceFeatures2 (gaps 0x%x, %u structures held back), chain:%s", gaps, dropped_count, chain);
|
|
}
|
|
for (VkBaseOutStructure *s = features->pNext; s; s = s->pNext) {
|
|
if (s->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT && (gaps & GAP_ROBUSTNESS2)) {
|
|
((VkPhysicalDeviceRobustness2FeaturesEXT *)s)->robustBufferAccess2 = VK_TRUE;
|
|
if (gaps & GAP_NULL_DESCRIPTOR)
|
|
((VkPhysicalDeviceRobustness2FeaturesEXT *)s)->nullDescriptor = VK_TRUE;
|
|
}
|
|
if (s->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT && (gaps & GAP_DEPTH_CLIP))
|
|
((VkPhysicalDeviceDepthClipEnableFeaturesEXT *)s)->depthClipEnable = VK_TRUE;
|
|
}
|
|
}
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties(VkPhysicalDevice physical_device,
|
|
VkPhysicalDeviceProperties *properties)
|
|
{
|
|
struct instance *inst = instance_from_handle(physical_device);
|
|
inst->GetPhysicalDeviceProperties(physical_device, properties);
|
|
report_limits(&properties->limits, physical_device_gaps(inst, physical_device));
|
|
}
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties2(VkPhysicalDevice physical_device,
|
|
VkPhysicalDeviceProperties2 *properties)
|
|
{
|
|
struct instance *inst = instance_from_handle(physical_device);
|
|
inst->GetPhysicalDeviceProperties2(physical_device, properties);
|
|
report_limits(&properties->properties.limits, physical_device_gaps(inst, physical_device));
|
|
if (tracing())
|
|
layer_log("trace: vkGetPhysicalDeviceProperties2: %s, Vulkan %u.%u.%u, type %d", properties->properties.deviceName,
|
|
VK_API_VERSION_MAJOR(properties->properties.apiVersion), VK_API_VERSION_MINOR(properties->properties.apiVersion),
|
|
VK_API_VERSION_PATCH(properties->properties.apiVersion), (int)properties->properties.deviceType);
|
|
}
|
|
|
|
/* The extensions the layer stands in for, added to the driver's list. */
|
|
static VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceExtensionProperties(VkPhysicalDevice physical_device,
|
|
const char *layer_name, uint32_t *count,
|
|
VkExtensionProperties *properties)
|
|
{
|
|
struct instance *inst = instance_from_handle(physical_device);
|
|
if (layer_name)
|
|
return inst->EnumerateDeviceExtensionProperties(physical_device, layer_name, count, properties);
|
|
uint32_t gaps = physical_device_gaps(inst, physical_device);
|
|
VkExtensionProperties extra[2];
|
|
uint32_t extra_count = 0;
|
|
if (gaps & GAP_DEPTH_CLIP)
|
|
extra[extra_count++] = (VkExtensionProperties){VK_EXT_DEPTH_CLIP_ENABLE_EXTENSION_NAME, 1};
|
|
if (gaps & GAP_NULL_DESCRIPTOR)
|
|
extra[extra_count++] = (VkExtensionProperties){VK_EXT_ROBUSTNESS_2_EXTENSION_NAME, 1};
|
|
uint32_t own = 0;
|
|
VkResult result = inst->EnumerateDeviceExtensionProperties(physical_device, NULL, &own, NULL);
|
|
if (result != VK_SUCCESS)
|
|
return result;
|
|
if (!properties) {
|
|
*count = own + extra_count;
|
|
return VK_SUCCESS;
|
|
}
|
|
VkExtensionProperties *all = calloc(own + extra_count, sizeof(*all));
|
|
inst->EnumerateDeviceExtensionProperties(physical_device, NULL, &own, all);
|
|
memcpy(all + own, extra, extra_count * sizeof(*extra));
|
|
uint32_t total = own + extra_count;
|
|
if (tracing()) {
|
|
layer_log("trace: vkEnumerateDeviceExtensionProperties: %u from the driver, %u added by the layer", own, extra_count);
|
|
trace_extension_names(all, total);
|
|
}
|
|
uint32_t n = *count < total ? *count : total;
|
|
memcpy(properties, all, n * sizeof(*all));
|
|
free(all);
|
|
*count = n;
|
|
return n < total ? VK_INCOMPLETE : VK_SUCCESS;
|
|
}
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateInstance(const VkInstanceCreateInfo *info,
|
|
const VkAllocationCallbacks *allocator, VkInstance *instance)
|
|
{
|
|
VkLayerInstanceCreateInfo *link = (VkLayerInstanceCreateInfo *)info->pNext;
|
|
while (link && !(link->sType == VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO && link->function == VK_LAYER_LINK_INFO))
|
|
link = (VkLayerInstanceCreateInfo *)link->pNext;
|
|
if (!link)
|
|
return VK_ERROR_INITIALIZATION_FAILED;
|
|
PFN_vkGetInstanceProcAddr gipa = link->u.pLayerInfo->pfnNextGetInstanceProcAddr;
|
|
link->u.pLayerInfo = link->u.pLayerInfo->pNext;
|
|
|
|
PFN_vkCreateInstance create = (PFN_vkCreateInstance)gipa(VK_NULL_HANDLE, "vkCreateInstance");
|
|
VkResult result = create(info, allocator, instance);
|
|
if (tracing())
|
|
layer_log("trace: vkCreateInstance for %s (API %u.%u): %d, layer %s", info->pApplicationInfo && info->pApplicationInfo->pApplicationName ?
|
|
info->pApplicationInfo->pApplicationName : "?", info->pApplicationInfo ? VK_API_VERSION_MAJOR(info->pApplicationInfo->apiVersion) : 0,
|
|
info->pApplicationInfo ? VK_API_VERSION_MINOR(info->pApplicationInfo->apiVersion) : 0, (int)result, wanted() ? "active" : "idle");
|
|
if (result != VK_SUCCESS)
|
|
return result;
|
|
|
|
struct instance *inst = calloc(1, sizeof(*inst));
|
|
inst->key = dispatch_key(*instance);
|
|
inst->handle = *instance;
|
|
inst->active = wanted();
|
|
inst->gipa = gipa;
|
|
pthread_mutex_init(&inst->lock, NULL);
|
|
#define LOAD(name) inst->name = (PFN_vk##name)gipa(*instance, "vk" #name);
|
|
#define LOAD_KHR(name) \
|
|
if (!inst->name) \
|
|
inst->name = (PFN_vk##name)gipa(*instance, "vk" #name "KHR");
|
|
LOAD(DestroyInstance)
|
|
LOAD(EnumerateDeviceExtensionProperties)
|
|
LOAD(GetPhysicalDeviceFeatures)
|
|
LOAD(GetPhysicalDeviceFeatures2)
|
|
LOAD_KHR(GetPhysicalDeviceFeatures2)
|
|
LOAD(GetPhysicalDeviceProperties)
|
|
LOAD(GetPhysicalDeviceProperties2)
|
|
LOAD_KHR(GetPhysicalDeviceProperties2)
|
|
LOAD(GetPhysicalDeviceMemoryProperties)
|
|
LOAD(GetPhysicalDeviceFormatProperties)
|
|
LOAD(GetPhysicalDeviceFormatProperties2)
|
|
LOAD_KHR(GetPhysicalDeviceFormatProperties2)
|
|
LOAD(GetPhysicalDeviceImageFormatProperties)
|
|
LOAD(GetPhysicalDeviceImageFormatProperties2)
|
|
LOAD_KHR(GetPhysicalDeviceImageFormatProperties2)
|
|
#undef LOAD
|
|
#undef LOAD_KHR
|
|
if (tracing())
|
|
trace_load(inst);
|
|
/* Without the Vulkan 1.1 queries there is no way to answer the chained ones. */
|
|
if (!inst->GetPhysicalDeviceFeatures2 || !inst->GetPhysicalDeviceProperties2 ||
|
|
!inst->GetPhysicalDeviceFormatProperties2 || !inst->GetPhysicalDeviceImageFormatProperties2)
|
|
inst->active = false;
|
|
|
|
pthread_mutex_lock(&global_lock);
|
|
inst->next = instances;
|
|
instances = inst;
|
|
pthread_mutex_unlock(&global_lock);
|
|
return VK_SUCCESS;
|
|
}
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL DestroyInstance(VkInstance instance, const VkAllocationCallbacks *allocator)
|
|
{
|
|
void *key = dispatch_key(instance);
|
|
pthread_mutex_lock(&global_lock);
|
|
struct instance **link = &instances;
|
|
while (*link && (*link)->key != key)
|
|
link = &(*link)->next;
|
|
struct instance *inst = *link;
|
|
if (inst)
|
|
*link = inst->next;
|
|
pthread_mutex_unlock(&global_lock);
|
|
if (!inst)
|
|
return;
|
|
inst->DestroyInstance(instance, allocator);
|
|
pthread_mutex_destroy(&inst->lock);
|
|
free(inst);
|
|
}
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateDevice(VkPhysicalDevice physical_device, const VkDeviceCreateInfo *info,
|
|
const VkAllocationCallbacks *allocator, VkDevice *device)
|
|
{
|
|
VkLayerDeviceCreateInfo *link = (VkLayerDeviceCreateInfo *)info->pNext;
|
|
while (link && !(link->sType == VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO && link->function == VK_LAYER_LINK_INFO))
|
|
link = (VkLayerDeviceCreateInfo *)link->pNext;
|
|
if (!link)
|
|
return VK_ERROR_INITIALIZATION_FAILED;
|
|
PFN_vkGetInstanceProcAddr gipa = link->u.pLayerInfo->pfnNextGetInstanceProcAddr;
|
|
PFN_vkGetDeviceProcAddr gdpa = link->u.pLayerInfo->pfnNextGetDeviceProcAddr;
|
|
link->u.pLayerInfo = link->u.pLayerInfo->pNext;
|
|
|
|
struct instance *inst = instance_from_handle(physical_device);
|
|
PFN_vkCreateDevice create = (PFN_vkCreateDevice)gipa(inst->handle, "vkCreateDevice");
|
|
uint32_t gaps = inst->active ? physical_device_gaps(inst, physical_device) : 0;
|
|
|
|
/* The application's own structures are put back after the call: DXVK reads its enabled
|
|
* features again later, and must keep seeing what it asked for. */
|
|
VkDeviceCreateInfo copy = *info;
|
|
VkPhysicalDeviceFeatures features;
|
|
VkPhysicalDeviceFeatures2 *features2 = NULL;
|
|
VkPhysicalDeviceRobustness2FeaturesEXT *robust = NULL;
|
|
for (VkBaseOutStructure *s = (VkBaseOutStructure *)info->pNext; s; s = s->pNext) {
|
|
if (s->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2)
|
|
features2 = (VkPhysicalDeviceFeatures2 *)s;
|
|
else if (s->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT)
|
|
robust = (VkPhysicalDeviceRobustness2FeaturesEXT *)s;
|
|
}
|
|
VkPhysicalDeviceFeatures *enabled = NULL;
|
|
VkPhysicalDeviceFeatures saved_features = {0};
|
|
if (info->pEnabledFeatures) {
|
|
features = *info->pEnabledFeatures;
|
|
copy.pEnabledFeatures = &features;
|
|
enabled = &features;
|
|
} else if (features2) {
|
|
saved_features = features2->features;
|
|
enabled = &features2->features;
|
|
}
|
|
uint32_t requested = enabled ? take_features(enabled, gaps) : 0;
|
|
VkBool32 saved_robust = robust ? robust->robustBufferAccess2 : VK_FALSE;
|
|
if (robust && (gaps & GAP_ROBUSTNESS2) && robust->robustBufferAccess2) {
|
|
requested |= GAP_ROBUSTNESS2;
|
|
robust->robustBufferAccess2 = VK_FALSE;
|
|
/* The first version of robust buffer access is the nearest the driver has. */
|
|
if (enabled)
|
|
enabled->robustBufferAccess = VK_TRUE;
|
|
}
|
|
|
|
/* The extensions the layer stands in for leave the list, and their structures the chain. */
|
|
const char **names = NULL;
|
|
if (gaps & (GAP_DEPTH_CLIP | GAP_NULL_DESCRIPTOR)) {
|
|
names = malloc((info->enabledExtensionCount ? info->enabledExtensionCount : 1) * sizeof(*names));
|
|
copy.enabledExtensionCount = 0;
|
|
for (uint32_t i = 0; i < info->enabledExtensionCount; i++) {
|
|
const char *name = info->ppEnabledExtensionNames[i];
|
|
if ((gaps & GAP_DEPTH_CLIP) && !strcmp(name, VK_EXT_DEPTH_CLIP_ENABLE_EXTENSION_NAME)) {
|
|
requested |= GAP_DEPTH_CLIP;
|
|
continue;
|
|
}
|
|
if ((gaps & GAP_NULL_DESCRIPTOR) && !strcmp(name, VK_EXT_ROBUSTNESS_2_EXTENSION_NAME)) {
|
|
requested |= GAP_NULL_DESCRIPTOR;
|
|
if (enabled)
|
|
enabled->robustBufferAccess = VK_TRUE;
|
|
continue;
|
|
}
|
|
names[copy.enabledExtensionCount++] = name;
|
|
}
|
|
copy.ppEnabledExtensionNames = names;
|
|
}
|
|
VkStructureType foreign[4];
|
|
struct unlinked dropped[8];
|
|
uint32_t dropped_count = unlink_types(©, foreign, foreign_types(gaps, foreign), dropped, 8);
|
|
|
|
VkResult result = create(physical_device, ©, allocator, device);
|
|
|
|
relink(dropped, dropped_count);
|
|
free(names);
|
|
if (features2 && !info->pEnabledFeatures)
|
|
features2->features = saved_features;
|
|
if (robust)
|
|
robust->robustBufferAccess2 = saved_robust;
|
|
if (result != VK_SUCCESS)
|
|
return result;
|
|
|
|
struct device *dev = calloc(1, sizeof(*dev));
|
|
dev->key = dispatch_key(*device);
|
|
dev->handle = *device;
|
|
dev->gdpa = gdpa;
|
|
dev->emulated = requested;
|
|
pthread_mutex_init(&dev->lock, NULL);
|
|
#define LOAD(name) \
|
|
dev->name = (PFN_vk##name)gdpa(*device, "vk" #name); \
|
|
if (!dev->name) \
|
|
dev->name = (PFN_vk##name)gdpa(*device, "vk" #name "KHR"); \
|
|
if (!dev->name) \
|
|
dev->name = (PFN_vk##name)gdpa(*device, "vk" #name "EXT");
|
|
DEVICE_FUNCTIONS(LOAD)
|
|
#undef LOAD
|
|
inst->GetPhysicalDeviceMemoryProperties(physical_device, &dev->memory_properties);
|
|
VkPhysicalDeviceProperties properties;
|
|
inst->GetPhysicalDeviceProperties(physical_device, &properties);
|
|
dev->active = inst->active && (requested != 0 || properties.apiVersion >= VK_API_VERSION_1_2);
|
|
uint32_t components = properties.limits.maxVertexOutputComponents;
|
|
if (properties.limits.maxFragmentInputComponents < components)
|
|
components = properties.limits.maxFragmentInputComponents;
|
|
dev->max_varying_locations = components / 4;
|
|
|
|
pthread_mutex_lock(&global_lock);
|
|
dev->next = devices;
|
|
devices = dev;
|
|
pthread_mutex_unlock(&global_lock);
|
|
|
|
if (requested) {
|
|
layer_log("emulating%s%s%s%s%s%s%s%s%s%s for %s", (requested & GAP_FILL_MODE) ? " fillModeNonSolid" : "",
|
|
(requested & GAP_MULTI_VIEWPORT) ? " multiViewport" : "",
|
|
(requested & GAP_CLIP_DISTANCE) ? " shaderClipDistance" : "",
|
|
(requested & GAP_CULL_DISTANCE) ? " shaderCullDistance" : "",
|
|
(requested & GAP_ROBUSTNESS2) ? " robustBufferAccess2" : "",
|
|
(requested & GAP_BC) ? " textureCompressionBC" : "",
|
|
(requested & GAP_MULTI_DRAW) ? " multiDrawIndirect" : "",
|
|
(requested & GAP_DEPTH_CLIP) ? " depthClipEnable" : "",
|
|
(requested & GAP_NULL_DESCRIPTOR) ? " nullDescriptor" : "",
|
|
(requested & GAP_DUAL_SRC_BLEND) ? " dualSrcBlend" : "", properties.deviceName);
|
|
}
|
|
return VK_SUCCESS;
|
|
}
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL DestroyDevice(VkDevice device, const VkAllocationCallbacks *allocator)
|
|
{
|
|
void *key = dispatch_key(device);
|
|
pthread_mutex_lock(&global_lock);
|
|
struct device **link = &devices;
|
|
while (*link && (*link)->key != key)
|
|
link = &(*link)->next;
|
|
struct device *dev = *link;
|
|
if (dev)
|
|
*link = dev->next;
|
|
pthread_mutex_unlock(&global_lock);
|
|
if (!dev)
|
|
return;
|
|
bc_destroy_device(dev);
|
|
null_resources_destroy(dev);
|
|
dev->DestroyDevice(device, allocator);
|
|
for (uint32_t i = 0; i < dev->shader_modules.capacity; i++) {
|
|
struct spirv_code *code = dev->shader_modules.values[i];
|
|
if (code) {
|
|
free(code->words);
|
|
free(code);
|
|
}
|
|
}
|
|
map_free(&dev->shader_modules);
|
|
pthread_mutex_destroy(&dev->lock);
|
|
free(dev);
|
|
}
|
|
|
|
struct hook {
|
|
const char *name;
|
|
PFN_vkVoidFunction function;
|
|
uint32_t gaps;
|
|
bool always;
|
|
};
|
|
|
|
#define HOOK(name, gaps) {"vk" #name, (PFN_vkVoidFunction)name, gaps, false}
|
|
#define HOOK_ALIAS(name, alias, gaps) {"vk" #alias, (PFN_vkVoidFunction)name, gaps, false}
|
|
#define HOOK_ALWAYS(name) {"vk" #name, (PFN_vkVoidFunction)name, 0, true}
|
|
|
|
static const struct hook device_hooks[] = {
|
|
HOOK_ALWAYS(CreateShaderModule),
|
|
HOOK_ALWAYS(DestroyShaderModule),
|
|
HOOK_ALWAYS(CreateGraphicsPipelines),
|
|
HOOK_ALWAYS(CreateComputePipelines),
|
|
HOOK(CmdSetViewport, GAP_MULTI_VIEWPORT),
|
|
HOOK(CmdSetScissor, GAP_MULTI_VIEWPORT),
|
|
HOOK(CmdSetViewportWithCount, GAP_MULTI_VIEWPORT),
|
|
HOOK_ALIAS(CmdSetViewportWithCount, CmdSetViewportWithCountEXT, GAP_MULTI_VIEWPORT),
|
|
HOOK(CmdSetScissorWithCount, GAP_MULTI_VIEWPORT),
|
|
HOOK_ALIAS(CmdSetScissorWithCount, CmdSetScissorWithCountEXT, GAP_MULTI_VIEWPORT),
|
|
HOOK(CmdSetColorBlendEquationEXT, GAP_DUAL_SRC_BLEND),
|
|
HOOK(CreateImage, GAP_BC),
|
|
HOOK(DestroyImage, GAP_BC),
|
|
HOOK(CreateImageView, GAP_BC),
|
|
HOOK(GetDeviceImageMemoryRequirements, GAP_BC),
|
|
HOOK_ALIAS(GetDeviceImageMemoryRequirements, GetDeviceImageMemoryRequirementsKHR, GAP_BC),
|
|
HOOK(GetDeviceImageSparseMemoryRequirements, GAP_BC),
|
|
HOOK_ALIAS(GetDeviceImageSparseMemoryRequirements, GetDeviceImageSparseMemoryRequirementsKHR, GAP_BC),
|
|
HOOK(GetDeviceImageSubresourceLayout, GAP_BC),
|
|
HOOK_ALIAS(GetDeviceImageSubresourceLayout, GetDeviceImageSubresourceLayoutKHR, GAP_BC),
|
|
HOOK(CmdCopyBufferToImage, GAP_BC),
|
|
HOOK(CmdCopyBufferToImage2, GAP_BC),
|
|
HOOK_ALIAS(CmdCopyBufferToImage2, CmdCopyBufferToImage2KHR, GAP_BC),
|
|
HOOK(CmdCopyImageToBuffer, GAP_BC),
|
|
HOOK(CmdCopyImageToBuffer2, GAP_BC),
|
|
HOOK_ALIAS(CmdCopyImageToBuffer2, CmdCopyImageToBuffer2KHR, GAP_BC),
|
|
HOOK(CmdCopyImage, GAP_BC),
|
|
HOOK(CmdCopyImage2, GAP_BC),
|
|
HOOK_ALIAS(CmdCopyImage2, CmdCopyImage2KHR, GAP_BC),
|
|
HOOK(BindBufferMemory, GAP_BC),
|
|
HOOK(BindBufferMemory2, GAP_BC),
|
|
HOOK_ALIAS(BindBufferMemory2, BindBufferMemory2KHR, GAP_BC),
|
|
HOOK(DestroyBuffer, GAP_BC),
|
|
HOOK(FreeMemory, GAP_BC),
|
|
HOOK(MapMemory, GAP_BC),
|
|
HOOK(MapMemory2, GAP_BC),
|
|
HOOK_ALIAS(MapMemory2, MapMemory2KHR, GAP_BC),
|
|
HOOK(UnmapMemory, GAP_BC),
|
|
HOOK(UnmapMemory2, GAP_BC),
|
|
HOOK_ALIAS(UnmapMemory2, UnmapMemory2KHR, GAP_BC),
|
|
HOOK(AllocateCommandBuffers, GAP_BC),
|
|
HOOK(FreeCommandBuffers, GAP_BC),
|
|
HOOK(BeginCommandBuffer, GAP_BC),
|
|
HOOK(ResetCommandBuffer, GAP_BC),
|
|
HOOK(ResetCommandPool, GAP_BC),
|
|
HOOK(DestroyCommandPool, GAP_BC),
|
|
HOOK(CmdDrawIndirect, GAP_MULTI_DRAW),
|
|
HOOK(CmdDrawIndexedIndirect, GAP_MULTI_DRAW),
|
|
HOOK(UpdateDescriptorSets, GAP_NULL_DESCRIPTOR),
|
|
HOOK(CmdPushDescriptorSet, GAP_NULL_DESCRIPTOR),
|
|
HOOK_ALIAS(CmdPushDescriptorSet, CmdPushDescriptorSetKHR, GAP_NULL_DESCRIPTOR),
|
|
HOOK(CreateDescriptorUpdateTemplate, GAP_NULL_DESCRIPTOR),
|
|
HOOK_ALIAS(CreateDescriptorUpdateTemplate, CreateDescriptorUpdateTemplateKHR, GAP_NULL_DESCRIPTOR),
|
|
HOOK(DestroyDescriptorUpdateTemplate, GAP_NULL_DESCRIPTOR),
|
|
HOOK_ALIAS(DestroyDescriptorUpdateTemplate, DestroyDescriptorUpdateTemplateKHR, GAP_NULL_DESCRIPTOR),
|
|
HOOK(UpdateDescriptorSetWithTemplate, GAP_NULL_DESCRIPTOR),
|
|
HOOK_ALIAS(UpdateDescriptorSetWithTemplate, UpdateDescriptorSetWithTemplateKHR, GAP_NULL_DESCRIPTOR),
|
|
HOOK(CmdPushDescriptorSetWithTemplate, GAP_NULL_DESCRIPTOR),
|
|
HOOK_ALIAS(CmdPushDescriptorSetWithTemplate, CmdPushDescriptorSetWithTemplateKHR, GAP_NULL_DESCRIPTOR),
|
|
HOOK(CmdBindVertexBuffers, GAP_NULL_DESCRIPTOR),
|
|
HOOK(CmdBindVertexBuffers2, GAP_NULL_DESCRIPTOR),
|
|
HOOK_ALIAS(CmdBindVertexBuffers2, CmdBindVertexBuffers2EXT, GAP_NULL_DESCRIPTOR),
|
|
};
|
|
|
|
static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr(VkDevice device, const char *name);
|
|
|
|
static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr(VkDevice device, const char *name)
|
|
{
|
|
if (!strcmp(name, "vkGetDeviceProcAddr"))
|
|
return (PFN_vkVoidFunction)GetDeviceProcAddr;
|
|
struct device *dev = device_from_handle(device);
|
|
if (!dev)
|
|
return NULL;
|
|
if (!strcmp(name, "vkDestroyDevice"))
|
|
return (PFN_vkVoidFunction)DestroyDevice;
|
|
PFN_vkVoidFunction next = dev->gdpa(device, name);
|
|
if (!next)
|
|
return NULL;
|
|
for (size_t i = 0; i < sizeof(device_hooks) / sizeof(device_hooks[0]); i++) {
|
|
bool installed = device_hooks[i].always ? dev->active : (dev->emulated & device_hooks[i].gaps) != 0;
|
|
if (installed && !strcmp(name, device_hooks[i].name))
|
|
return device_hooks[i].function;
|
|
}
|
|
return next;
|
|
}
|
|
|
|
static const struct hook physical_device_hooks[] = {
|
|
HOOK(EnumerateDeviceExtensionProperties, 0),
|
|
HOOK(GetPhysicalDeviceFeatures, 0),
|
|
HOOK(GetPhysicalDeviceFeatures2, 0),
|
|
HOOK_ALIAS(GetPhysicalDeviceFeatures2, GetPhysicalDeviceFeatures2KHR, 0),
|
|
HOOK(GetPhysicalDeviceProperties, 0),
|
|
HOOK(GetPhysicalDeviceProperties2, 0),
|
|
HOOK_ALIAS(GetPhysicalDeviceProperties2, GetPhysicalDeviceProperties2KHR, 0),
|
|
HOOK(GetPhysicalDeviceFormatProperties, 0),
|
|
HOOK(GetPhysicalDeviceFormatProperties2, 0),
|
|
HOOK_ALIAS(GetPhysicalDeviceFormatProperties2, GetPhysicalDeviceFormatProperties2KHR, 0),
|
|
HOOK(GetPhysicalDeviceImageFormatProperties, 0),
|
|
HOOK(GetPhysicalDeviceImageFormatProperties2, 0),
|
|
HOOK_ALIAS(GetPhysicalDeviceImageFormatProperties2, GetPhysicalDeviceImageFormatProperties2KHR, 0),
|
|
};
|
|
|
|
static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetInstanceProcAddr(VkInstance instance, const char *name)
|
|
{
|
|
if (!strcmp(name, "vkGetInstanceProcAddr"))
|
|
return (PFN_vkVoidFunction)GetInstanceProcAddr;
|
|
if (!strcmp(name, "vkCreateInstance"))
|
|
return (PFN_vkVoidFunction)CreateInstance;
|
|
if (!strcmp(name, "vkGetDeviceProcAddr"))
|
|
return (PFN_vkVoidFunction)GetDeviceProcAddr;
|
|
if (!instance)
|
|
return NULL;
|
|
struct instance *inst = instance_from_handle(instance);
|
|
if (!inst)
|
|
return NULL;
|
|
if (!strcmp(name, "vkDestroyInstance"))
|
|
return (PFN_vkVoidFunction)DestroyInstance;
|
|
/* Always ours, even when inactive: each layer moves the device chain one link on. */
|
|
if (!strcmp(name, "vkCreateDevice"))
|
|
return (PFN_vkVoidFunction)CreateDevice;
|
|
PFN_vkVoidFunction next = inst->gipa(instance, name);
|
|
if (next && tracing()) {
|
|
PFN_vkVoidFunction traced = trace_hook(inst, name);
|
|
if (traced)
|
|
return traced;
|
|
}
|
|
if (!next || !inst->active)
|
|
return next;
|
|
for (size_t i = 0; i < sizeof(physical_device_hooks) / sizeof(physical_device_hooks[0]); i++) {
|
|
if (!strcmp(name, physical_device_hooks[i].name))
|
|
return physical_device_hooks[i].function;
|
|
}
|
|
return next;
|
|
}
|
|
|
|
__attribute__((visibility("default"))) VKAPI_ATTR VkResult VKAPI_CALL
|
|
vkNegotiateLoaderLayerInterfaceVersion(VkNegotiateLayerInterface *interface)
|
|
{
|
|
if (interface->loaderLayerInterfaceVersion < 2)
|
|
return VK_ERROR_INITIALIZATION_FAILED;
|
|
interface->loaderLayerInterfaceVersion = 2;
|
|
interface->pfnGetInstanceProcAddr = GetInstanceProcAddr;
|
|
interface->pfnGetDeviceProcAddr = GetDeviceProcAddr;
|
|
interface->pfnGetPhysicalDeviceProcAddr = NULL;
|
|
return VK_SUCCESS;
|
|
}
|