dlls/winevulkan/vulkan_private.h

   1 /* Wine Vulkan ICD private data structures
   2  *
   3  * Copyright 2017 Roderick Colenbrander
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #ifndef __WINE_VULKAN_PRIVATE_H
  21 #define __WINE_VULKAN_PRIVATE_H
  22
  23 #define WINE_VK_HOST
  24 #define VK_NO_PROTOTYPES
  25
  26 #include <pthread.h>
  27
  28 #include "vulkan_loader.h"
  29 #include "vulkan_thunks.h"
  30
  31 /* Some extensions have callbacks for those we need to be able to
  32  * get the wine wrapper for a native handle
  33  */
  34 struct wine_vk_mapping
  35 {
  36     struct list link;
  37     uint64_t native_handle;
  38     uint64_t wine_wrapped_handle;
  39 };
  40
  41 struct wine_cmd_buffer
  42 {
  43     struct wine_device *device; /* parent */
  44
  45     VkCommandBuffer handle; /* client command buffer */
  46     VkCommandBuffer command_buffer; /* native command buffer */
  47
  48     struct wine_vk_mapping mapping;
  49 };
  50
  51 static inline struct wine_cmd_buffer *wine_cmd_buffer_from_handle(VkCommandBuffer handle)
  52 {
  53     return (struct wine_cmd_buffer *)(uintptr_t)handle->base.unix_handle;
  54 }
  55
  56 struct wine_device
  57 {
  58     struct vulkan_device_funcs funcs;
  59     struct wine_phys_dev *phys_dev; /* parent */
  60
  61     VkDevice handle; /* client device */
  62     VkDevice device; /* native device */
  63
  64     struct wine_queue *queues;
  65     uint32_t queue_count;
  66
  67     struct wine_vk_mapping mapping;
  68 };
  69
  70 static inline struct wine_device *wine_device_from_handle(VkDevice handle)
  71 {
  72     return (struct wine_device *)(uintptr_t)handle->base.unix_handle;
  73 }
  74
  75 struct wine_debug_utils_messenger;
  76
  77 struct wine_debug_report_callback
  78 {
  79     struct wine_instance *instance; /* parent */
  80     VkDebugReportCallbackEXT debug_callback; /* native callback object */
  81
  82     /* application callback + data */
  83     PFN_vkDebugReportCallbackEXT user_callback;
  84     void *user_data;
  85
  86     struct wine_vk_mapping mapping;
  87 };
  88
  89 struct wine_instance
  90 {
  91     struct vulkan_instance_funcs funcs;
  92
  93     VkInstance handle; /* client instance */
  94     VkInstance instance; /* native instance */
  95
  96     /* We cache devices as we need to wrap them as they are
  97      * dispatchable objects.
  98      */
  99     struct wine_phys_dev **phys_devs;
 100     uint32_t phys_dev_count;
 101
 102     VkBool32 enable_wrapper_list;
 103     struct list wrappers;
 104     pthread_rwlock_t wrapper_lock;
 105
 106     struct wine_debug_utils_messenger *utils_messengers;
 107     uint32_t utils_messenger_count;
 108
 109     struct wine_debug_report_callback default_callback;
 110
 111     unsigned int quirks;
 112
 113     struct wine_vk_mapping mapping;
 114 };
 115
 116 static inline struct wine_instance *wine_instance_from_handle(VkInstance handle)
 117 {
 118     return (struct wine_instance *)(uintptr_t)handle->base.unix_handle;
 119 }
 120
 121 struct wine_phys_dev
 122 {
 123     struct wine_instance *instance; /* parent */
 124
 125     VkPhysicalDevice handle; /* client physical device */
 126     VkPhysicalDevice phys_dev; /* native physical device */
 127
 128     VkPhysicalDeviceMemoryProperties memory_properties;
 129     VkExtensionProperties *extensions;
 130     uint32_t extension_count;
 131
 132     uint32_t external_memory_align;
 133
 134     struct wine_vk_mapping mapping;
 135 };
 136
 137 static inline struct wine_phys_dev *wine_phys_dev_from_handle(VkPhysicalDevice handle)
 138 {
 139     return (struct wine_phys_dev *)(uintptr_t)handle->base.unix_handle;
 140 }
 141
 142 struct wine_queue
 143 {
 144     struct wine_device *device; /* parent */
 145
 146     VkQueue handle; /* client queue */
 147     VkQueue queue; /* native queue */
 148
 149     uint32_t family_index;
 150     uint32_t queue_index;
 151     VkDeviceQueueCreateFlags flags;
 152
 153     struct wine_vk_mapping mapping;
 154 };
 155
 156 static inline struct wine_queue *wine_queue_from_handle(VkQueue handle)
 157 {
 158     return (struct wine_queue *)(uintptr_t)handle->base.unix_handle;
 159 }
 160
 161 struct wine_cmd_pool
 162 {
 163     VkCommandPool handle;
 164     VkCommandPool command_pool;
 165
 166     struct wine_vk_mapping mapping;
 167 };
 168
 169 static inline struct wine_cmd_pool *wine_cmd_pool_from_handle(VkCommandPool handle)
 170 {
 171     struct vk_command_pool *client_ptr = command_pool_from_handle(handle);
 172     return (struct wine_cmd_pool *)(uintptr_t)client_ptr->unix_handle;
 173 }
 174
 175 struct wine_device_memory
 176 {
 177     VkDeviceMemory memory;
 178     void *mapping;
 179 };
 180
 181 static inline struct wine_device_memory *wine_device_memory_from_handle(VkDeviceMemory handle)
 182 {
 183     return (struct wine_device_memory *)(uintptr_t)handle;
 184 }
 185
 186 struct wine_debug_utils_messenger
 187 {
 188     struct wine_instance *instance; /* parent */
 189     VkDebugUtilsMessengerEXT debug_messenger; /* native messenger */
 190
 191     /* application callback + data */
 192     PFN_vkDebugUtilsMessengerCallbackEXT user_callback;
 193     void *user_data;
 194
 195     struct wine_vk_mapping mapping;
 196 };
 197
 198 static inline struct wine_debug_utils_messenger *wine_debug_utils_messenger_from_handle(
 199         VkDebugUtilsMessengerEXT handle)
 200 {
 201     return (struct wine_debug_utils_messenger *)(uintptr_t)handle;
 202 }
 203
 204 static inline VkDebugUtilsMessengerEXT wine_debug_utils_messenger_to_handle(
 205         struct wine_debug_utils_messenger *debug_messenger)
 206 {
 207     return (VkDebugUtilsMessengerEXT)(uintptr_t)debug_messenger;
 208 }
 209
 210 static inline struct wine_debug_report_callback *wine_debug_report_callback_from_handle(
 211         VkDebugReportCallbackEXT handle)
 212 {
 213     return (struct wine_debug_report_callback *)(uintptr_t)handle;
 214 }
 215
 216 static inline VkDebugReportCallbackEXT wine_debug_report_callback_to_handle(
 217         struct wine_debug_report_callback *debug_messenger)
 218 {
 219     return (VkDebugReportCallbackEXT)(uintptr_t)debug_messenger;
 220 }
 221
 222 struct wine_surface
 223 {
 224     VkSurfaceKHR surface; /* native surface */
 225     VkSurfaceKHR driver_surface; /* wine driver surface */
 226
 227     struct wine_vk_mapping mapping;
 228 };
 229
 230 static inline struct wine_surface *wine_surface_from_handle(VkSurfaceKHR handle)
 231 {
 232     return (struct wine_surface *)(uintptr_t)handle;
 233 }
 234
 235 static inline VkSurfaceKHR wine_surface_to_handle(struct wine_surface *surface)
 236 {
 237     return (VkSurfaceKHR)(uintptr_t)surface;
 238 }
 239
 240 BOOL wine_vk_device_extension_supported(const char *name) DECLSPEC_HIDDEN;
 241 BOOL wine_vk_instance_extension_supported(const char *name) DECLSPEC_HIDDEN;
 242
 243 BOOL wine_vk_is_type_wrapped(VkObjectType type) DECLSPEC_HIDDEN;
 244
 245 NTSTATUS init_vulkan(void *args) DECLSPEC_HIDDEN;
 246
 247 NTSTATUS vk_is_available_instance_function(void *arg) DECLSPEC_HIDDEN;
 248 NTSTATUS vk_is_available_device_function(void *arg) DECLSPEC_HIDDEN;
 249 NTSTATUS vk_is_available_instance_function32(void *arg) DECLSPEC_HIDDEN;
 250 NTSTATUS vk_is_available_device_function32(void *arg) DECLSPEC_HIDDEN;
 251
 252 struct conversion_context
 253 {
 254     char buffer[2048];
 255     uint32_t used;
 256     struct list alloc_entries;
 257 };
 258
 259 static inline void init_conversion_context(struct conversion_context *pool)
 260 {
 261     pool->used = 0;
 262     list_init(&pool->alloc_entries);
 263 }
 264
 265 static inline void free_conversion_context(struct conversion_context *pool)
 266 {
 267     struct list *entry, *next;
 268     LIST_FOR_EACH_SAFE(entry, next, &pool->alloc_entries)
 269         free(entry);
 270 }
 271
 272 static inline void *conversion_context_alloc(struct conversion_context *pool, size_t size)
 273 {
 274     if (pool->used + size <= sizeof(pool->buffer))
 275     {
 276         void *ret = pool->buffer + pool->used;
 277         pool->used += (size + sizeof(UINT64) - 1) & ~(sizeof(UINT64) - 1);
 278         return ret;
 279     }
 280     else
 281     {
 282         struct list *entry;
 283         if (!(entry = malloc(sizeof(*entry) + size)))
 284             return NULL;
 285         list_add_tail(&pool->alloc_entries, entry);
 286         return entry + 1;
 287     }
 288 }
 289
 290 struct wine_deferred_operation
 291 {
 292     VkDeferredOperationKHR deferred_operation; /* native handle */
 293
 294     struct conversion_context ctx; /* to keep params alive. */
 295
 296     struct wine_vk_mapping mapping;
 297 };
 298
 299 static inline struct wine_deferred_operation *wine_deferred_operation_from_handle(
 300         VkDeferredOperationKHR handle)
 301 {
 302     return (struct wine_deferred_operation *)(uintptr_t)handle;
 303 }
 304
 305 static inline VkDeferredOperationKHR wine_deferred_operation_to_handle(
 306         struct wine_deferred_operation *deferred_operation)
 307 {
 308     return (VkDeferredOperationKHR)(uintptr_t)deferred_operation;
 309 }
 310
 311 typedef UINT32 PTR32;
 312
 313 typedef struct
 314 {
 315     VkStructureType sType;
 316     PTR32 pNext;
 317 } VkBaseInStructure32;
 318
 319 typedef struct
 320 {
 321     VkStructureType sType;
 322     PTR32 pNext;
 323 } VkBaseOutStructure32;
 324
 325 static inline void *find_next_struct32(void *s, VkStructureType t)
 326 {
 327     VkBaseOutStructure32 *header;
 328
 329     for (header = s; header; header = UlongToPtr(header->pNext))
 330     {
 331         if (header->sType == t)
 332             return header;
 333     }
 334
 335     return NULL;
 336 }
 337
 338 static inline void *find_next_struct(const void *s, VkStructureType t)
 339 {
 340     VkBaseOutStructure *header;
 341
 342     for (header = (VkBaseOutStructure *)s; header; header = header->pNext)
 343     {
 344         if (header->sType == t)
 345             return header;
 346     }
 347
 348     return NULL;
 349 }
 350
 351 #endif /* __WINE_VULKAN_PRIVATE_H */