null_driver.cpp revision 2077ce0c0d7ca716c408826449314ac799eda650
1#include <hardware/hwvulkan.h> 2 3#include <string.h> 4#include <algorithm> 5 6// #define LOG_NDEBUG 0 7#include <log/log.h> 8#include <utils/Errors.h> 9 10#include "null_driver.h" 11 12using namespace null_driver; 13 14struct VkPhysicalDevice_T { 15 hwvulkan_dispatch_t dispatch; 16}; 17 18struct VkInstance_T { 19 hwvulkan_dispatch_t dispatch; 20 const VkAllocCallbacks* alloc; 21 VkPhysicalDevice_T physical_device; 22}; 23 24struct VkQueue_T { 25 hwvulkan_dispatch_t dispatch; 26}; 27 28struct VkCmdBuffer_T { 29 hwvulkan_dispatch_t dispatch; 30}; 31 32struct VkDevice_T { 33 hwvulkan_dispatch_t dispatch; 34 VkInstance_T* instance; 35 VkQueue_T queue; 36}; 37 38// ----------------------------------------------------------------------------- 39// Declare HAL_MODULE_INFO_SYM early so it can be referenced by nulldrv_device 40// later. 41 42namespace { 43int OpenDevice(const hw_module_t* module, const char* id, hw_device_t** device); 44hw_module_methods_t nulldrv_module_methods = {.open = OpenDevice}; 45} // namespace 46 47#pragma clang diagnostic push 48#pragma clang diagnostic ignored "-Wmissing-variable-declarations" 49__attribute__((visibility("default"))) hwvulkan_module_t HAL_MODULE_INFO_SYM = { 50 .common = 51 { 52 .tag = HARDWARE_MODULE_TAG, 53 .module_api_version = HWVULKAN_MODULE_API_VERSION_0_1, 54 .hal_api_version = HARDWARE_HAL_API_VERSION, 55 .id = HWVULKAN_HARDWARE_MODULE_ID, 56 .name = "Null Vulkan Driver", 57 .author = "The Android Open Source Project", 58 .methods = &nulldrv_module_methods, 59 }, 60}; 61#pragma clang diagnostic pop 62 63// ----------------------------------------------------------------------------- 64 65namespace { 66 67VkResult CreateInstance(const VkInstanceCreateInfo* create_info, 68 VkInstance* out_instance) { 69 VkInstance_T* instance = 70 static_cast<VkInstance_T*>(create_info->pAllocCb->pfnAlloc( 71 create_info->pAllocCb->pUserData, sizeof(VkInstance_T), 72 alignof(VkInstance_T), VK_SYSTEM_ALLOC_TYPE_API_OBJECT)); 73 if (!instance) 74 return VK_ERROR_OUT_OF_HOST_MEMORY; 75 76 instance->dispatch.magic = HWVULKAN_DISPATCH_MAGIC; 77 instance->alloc = create_info->pAllocCb; 78 instance->physical_device.dispatch.magic = HWVULKAN_DISPATCH_MAGIC; 79 80 *out_instance = instance; 81 return VK_SUCCESS; 82} 83 84int CloseDevice(struct hw_device_t* /*device*/) { 85 // nothing to do - opening a device doesn't allocate any resources 86 return 0; 87} 88 89hwvulkan_device_t nulldrv_device = { 90 .common = 91 { 92 .tag = HARDWARE_DEVICE_TAG, 93 .version = HWVULKAN_DEVICE_API_VERSION_0_1, 94 .module = &HAL_MODULE_INFO_SYM.common, 95 .close = CloseDevice, 96 }, 97 .GetGlobalExtensionProperties = GetGlobalExtensionProperties, 98 .CreateInstance = CreateInstance, 99 .GetInstanceProcAddr = GetInstanceProcAddr}; 100 101int OpenDevice(const hw_module_t* /*module*/, 102 const char* id, 103 hw_device_t** device) { 104 if (strcmp(id, HWVULKAN_DEVICE_0) == 0) { 105 *device = &nulldrv_device.common; 106 return 0; 107 } 108 return -ENOENT; 109} 110 111VkInstance_T* GetInstanceFromPhysicalDevice( 112 VkPhysicalDevice_T* physical_device) { 113 return reinterpret_cast<VkInstance_T*>( 114 reinterpret_cast<uintptr_t>(physical_device) - 115 offsetof(VkInstance_T, physical_device)); 116} 117 118} // namespace 119 120namespace null_driver { 121 122template <typename HandleT> 123struct HandleTraits {}; 124 125template <typename HandleT> 126typename HandleTraits<HandleT>::PointerType GetObjectFromHandle( 127 const HandleT& h) { 128 return reinterpret_cast<typename HandleTraits<HandleT>::PointerType>( 129 uintptr_t(h.handle)); 130} 131 132template <typename T> 133typename T::HandleType GetHandleToObject(const T* obj) { 134 return typename T::HandleType(reinterpret_cast<uintptr_t>(obj)); 135} 136 137// ----------------------------------------------------------------------------- 138// Global 139 140VkResult GetGlobalExtensionProperties(const char*, 141 uint32_t* count, 142 VkExtensionProperties*) { 143 *count = 0; 144 return VK_SUCCESS; 145} 146 147PFN_vkVoidFunction GetInstanceProcAddr(VkInstance, const char* name) { 148 PFN_vkVoidFunction proc = LookupInstanceProcAddr(name); 149 if (!proc && strcmp(name, "vkGetDeviceProcAddr") == 0) 150 proc = reinterpret_cast<PFN_vkVoidFunction>(GetDeviceProcAddr); 151 return proc; 152} 153 154PFN_vkVoidFunction GetDeviceProcAddr(VkDevice, const char* name) { 155 return LookupDeviceProcAddr(name); 156} 157 158// ----------------------------------------------------------------------------- 159// Instance 160 161VkResult DestroyInstance(VkInstance instance) { 162 instance->alloc->pfnFree(instance->alloc->pUserData, instance); 163 return VK_SUCCESS; 164} 165 166// ----------------------------------------------------------------------------- 167// PhysicalDevice 168 169VkResult EnumeratePhysicalDevices(VkInstance instance, 170 uint32_t* physical_device_count, 171 VkPhysicalDevice* physical_devices) { 172 if (physical_devices && *physical_device_count >= 1) 173 physical_devices[0] = &instance->physical_device; 174 *physical_device_count = 1; 175 return VK_SUCCESS; 176} 177 178VkResult GetPhysicalDeviceProperties(VkPhysicalDevice, 179 VkPhysicalDeviceProperties* properties) { 180 properties->apiVersion = VK_API_VERSION; 181 properties->driverVersion = VK_MAKE_VERSION(0, 0, 1); 182 properties->vendorId = 0xC0DE; 183 properties->deviceId = 0xCAFE; 184 properties->deviceType = VK_PHYSICAL_DEVICE_TYPE_OTHER; 185 strcpy(properties->deviceName, "Android Vulkan Null Driver"); 186 memset(properties->pipelineCacheUUID, 0, 187 sizeof(properties->pipelineCacheUUID)); 188 return VK_SUCCESS; 189} 190 191VkResult GetPhysicalDeviceMemoryProperties( 192 VkPhysicalDevice, 193 VkPhysicalDeviceMemoryProperties* properties) { 194 properties->memoryTypeCount = 1; 195 properties->memoryTypes[0].propertyFlags = 196 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT; 197 properties->memoryTypes[0].heapIndex = 0; 198 properties->memoryHeapCount = 1; 199 properties->memoryHeaps[0].size = 200 INTPTR_MAX; // TODO: do something smarter? 201 properties->memoryHeaps[0].flags = VK_MEMORY_HEAP_HOST_LOCAL; 202 return VK_SUCCESS; 203} 204 205// ----------------------------------------------------------------------------- 206// Device 207 208VkResult CreateDevice(VkPhysicalDevice physical_device, 209 const VkDeviceCreateInfo*, 210 VkDevice* out_device) { 211 VkInstance_T* instance = GetInstanceFromPhysicalDevice(physical_device); 212 VkDevice_T* device = static_cast<VkDevice_T*>(instance->alloc->pfnAlloc( 213 instance->alloc->pUserData, sizeof(VkDevice_T), alignof(VkDevice_T), 214 VK_SYSTEM_ALLOC_TYPE_API_OBJECT)); 215 if (!device) 216 return VK_ERROR_OUT_OF_HOST_MEMORY; 217 218 device->dispatch.magic = HWVULKAN_DISPATCH_MAGIC; 219 device->instance = instance; 220 device->queue.dispatch.magic = HWVULKAN_DISPATCH_MAGIC; 221 222 *out_device = device; 223 return VK_SUCCESS; 224} 225 226VkResult DestroyDevice(VkDevice device) { 227 if (!device) 228 return VK_SUCCESS; 229 const VkAllocCallbacks* alloc = device->instance->alloc; 230 alloc->pfnFree(alloc->pUserData, device); 231 return VK_SUCCESS; 232} 233 234VkResult GetDeviceQueue(VkDevice device, uint32_t, uint32_t, VkQueue* queue) { 235 *queue = &device->queue; 236 return VK_SUCCESS; 237} 238 239// ----------------------------------------------------------------------------- 240// DeviceMemory 241 242struct DeviceMemory { 243 typedef VkDeviceMemory HandleType; 244 VkDeviceSize size; 245 alignas(16) uint8_t data[0]; 246}; 247template <> 248struct HandleTraits<VkDeviceMemory> { 249 typedef DeviceMemory* PointerType; 250}; 251 252VkResult AllocMemory(VkDevice device, 253 const VkMemoryAllocInfo* alloc_info, 254 VkDeviceMemory* mem_handle) { 255 if (SIZE_MAX - sizeof(DeviceMemory) <= alloc_info->allocationSize) 256 return VK_ERROR_OUT_OF_HOST_MEMORY; 257 258 const VkAllocCallbacks* alloc = device->instance->alloc; 259 size_t size = sizeof(DeviceMemory) + size_t(alloc_info->allocationSize); 260 DeviceMemory* mem = static_cast<DeviceMemory*>( 261 alloc->pfnAlloc(alloc->pUserData, size, alignof(DeviceMemory), 262 VK_SYSTEM_ALLOC_TYPE_API_OBJECT)); 263 if (!mem) 264 return VK_ERROR_OUT_OF_HOST_MEMORY; 265 mem->size = size; 266 *mem_handle = GetHandleToObject(mem); 267 return VK_SUCCESS; 268} 269 270VkResult FreeMemory(VkDevice device, VkDeviceMemory mem_handle) { 271 const VkAllocCallbacks* alloc = device->instance->alloc; 272 DeviceMemory* mem = GetObjectFromHandle(mem_handle); 273 alloc->pfnFree(alloc->pUserData, mem); 274 return VK_SUCCESS; 275} 276 277VkResult MapMemory(VkDevice, 278 VkDeviceMemory mem_handle, 279 VkDeviceSize offset, 280 VkDeviceSize, 281 VkMemoryMapFlags, 282 void** out_ptr) { 283 DeviceMemory* mem = GetObjectFromHandle(mem_handle); 284 *out_ptr = &mem->data[0] + offset; 285 return VK_SUCCESS; 286} 287 288// ----------------------------------------------------------------------------- 289// Buffer 290 291struct Buffer { 292 typedef VkBuffer HandleType; 293 VkDeviceSize size; 294}; 295template <> 296struct HandleTraits<VkBuffer> { 297 typedef Buffer* PointerType; 298}; 299 300VkResult CreateBuffer(VkDevice device, 301 const VkBufferCreateInfo* create_info, 302 VkBuffer* buffer_handle) { 303 const VkAllocCallbacks* alloc = device->instance->alloc; 304 Buffer* buffer = static_cast<Buffer*>( 305 alloc->pfnAlloc(alloc->pUserData, sizeof(Buffer), alignof(Buffer), 306 VK_SYSTEM_ALLOC_TYPE_API_OBJECT)); 307 if (!buffer) 308 return VK_ERROR_OUT_OF_HOST_MEMORY; 309 buffer->size = create_info->size; 310 *buffer_handle = GetHandleToObject(buffer); 311 return VK_SUCCESS; 312} 313 314VkResult GetBufferMemoryRequirements(VkDevice, 315 VkBuffer buffer_handle, 316 VkMemoryRequirements* requirements) { 317 Buffer* buffer = GetObjectFromHandle(buffer_handle); 318 requirements->size = buffer->size; 319 requirements->alignment = 16; // allow fast Neon/SSE memcpy 320 requirements->memoryTypeBits = 0x1; 321 return VK_SUCCESS; 322} 323 324VkResult DestroyBuffer(VkDevice device, VkBuffer buffer_handle) { 325 const VkAllocCallbacks* alloc = device->instance->alloc; 326 Buffer* buffer = GetObjectFromHandle(buffer_handle); 327 alloc->pfnFree(alloc->pUserData, buffer); 328 return VK_SUCCESS; 329} 330 331// ----------------------------------------------------------------------------- 332// No-op entrypoints 333 334// clang-format off 335#pragma clang diagnostic push 336#pragma clang diagnostic ignored "-Wunused-parameter" 337 338VkResult GetPhysicalDeviceQueueCount(VkPhysicalDevice physicalDevice, uint32_t* pCount) { 339 ALOGV("TODO: vk%s", __FUNCTION__); 340 return VK_SUCCESS; 341} 342 343VkResult GetPhysicalDeviceQueueProperties(VkPhysicalDevice physicalDevice, uint32_t count, VkPhysicalDeviceQueueProperties* pQueueProperties) { 344 ALOGV("TODO: vk%s", __FUNCTION__); 345 return VK_SUCCESS; 346} 347 348VkResult GetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) { 349 ALOGV("TODO: vk%s", __FUNCTION__); 350 return VK_SUCCESS; 351} 352 353VkResult GetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) { 354 ALOGV("TODO: vk%s", __FUNCTION__); 355 return VK_SUCCESS; 356} 357 358VkResult GetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageFormatProperties* pImageFormatProperties) { 359 ALOGV("TODO: vk%s", __FUNCTION__); 360 return VK_SUCCESS; 361} 362 363VkResult GetPhysicalDeviceLimits(VkPhysicalDevice physicalDevice, VkPhysicalDeviceLimits* pLimits) { 364 ALOGV("TODO: vk%s", __FUNCTION__); 365 return VK_SUCCESS; 366} 367 368VkResult GetGlobalLayerProperties(uint32_t* pCount, VkLayerProperties* pProperties) { 369 ALOGV("TODO: vk%s", __FUNCTION__); 370 return VK_SUCCESS; 371} 372 373VkResult GetPhysicalDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkLayerProperties* pProperties) { 374 ALOGV("TODO: vk%s", __FUNCTION__); 375 return VK_SUCCESS; 376} 377 378VkResult GetPhysicalDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties) { 379 ALOGV("TODO: vk%s", __FUNCTION__); 380 return VK_SUCCESS; 381} 382 383VkResult QueueSubmit(VkQueue queue, uint32_t cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence) { 384 ALOGV("TODO: vk%s", __FUNCTION__); 385 return VK_SUCCESS; 386} 387 388VkResult QueueWaitIdle(VkQueue queue) { 389 ALOGV("TODO: vk%s", __FUNCTION__); 390 return VK_SUCCESS; 391} 392 393VkResult DeviceWaitIdle(VkDevice device) { 394 ALOGV("TODO: vk%s", __FUNCTION__); 395 return VK_SUCCESS; 396} 397 398VkResult UnmapMemory(VkDevice device, VkDeviceMemory mem) { 399 return VK_SUCCESS; 400} 401 402VkResult FlushMappedMemoryRanges(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges) { 403 ALOGV("TODO: vk%s", __FUNCTION__); 404 return VK_SUCCESS; 405} 406 407VkResult InvalidateMappedMemoryRanges(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges) { 408 ALOGV("TODO: vk%s", __FUNCTION__); 409 return VK_SUCCESS; 410} 411 412VkResult GetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) { 413 ALOGV("TODO: vk%s", __FUNCTION__); 414 return VK_SUCCESS; 415} 416 417VkResult BindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memOffset) { 418 return VK_SUCCESS; 419} 420 421VkResult GetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) { 422 ALOGV("TODO: vk%s", __FUNCTION__); 423 return VK_SUCCESS; 424} 425 426VkResult BindImageMemory(VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize memOffset) { 427 ALOGV("TODO: vk%s", __FUNCTION__); 428 return VK_SUCCESS; 429} 430 431VkResult GetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) { 432 ALOGV("TODO: vk%s", __FUNCTION__); 433 return VK_SUCCESS; 434} 435 436VkResult GetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties) { 437 ALOGV("TODO: vk%s", __FUNCTION__); 438 return VK_SUCCESS; 439} 440 441VkResult QueueBindSparseBufferMemory(VkQueue queue, VkBuffer buffer, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo) { 442 ALOGV("TODO: vk%s", __FUNCTION__); 443 return VK_SUCCESS; 444} 445 446VkResult QueueBindSparseImageOpaqueMemory(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo) { 447 ALOGV("TODO: vk%s", __FUNCTION__); 448 return VK_SUCCESS; 449} 450 451VkResult QueueBindSparseImageMemory(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseImageMemoryBindInfo* pBindInfo) { 452 ALOGV("TODO: vk%s", __FUNCTION__); 453 return VK_SUCCESS; 454} 455 456VkResult CreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence) { 457 ALOGV("TODO: vk%s", __FUNCTION__); 458 return VK_SUCCESS; 459} 460 461VkResult DestroyFence(VkDevice device, VkFence fence) { 462 ALOGV("TODO: vk%s", __FUNCTION__); 463 return VK_SUCCESS; 464} 465 466VkResult ResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences) { 467 ALOGV("TODO: vk%s", __FUNCTION__); 468 return VK_SUCCESS; 469} 470 471VkResult GetFenceStatus(VkDevice device, VkFence fence) { 472 ALOGV("TODO: vk%s", __FUNCTION__); 473 return VK_SUCCESS; 474} 475 476VkResult WaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout) { 477 ALOGV("TODO: vk%s", __FUNCTION__); 478 return VK_SUCCESS; 479} 480 481VkResult CreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, VkSemaphore* pSemaphore) { 482 ALOGV("TODO: vk%s", __FUNCTION__); 483 return VK_SUCCESS; 484} 485 486VkResult DestroySemaphore(VkDevice device, VkSemaphore semaphore) { 487 ALOGV("TODO: vk%s", __FUNCTION__); 488 return VK_SUCCESS; 489} 490 491VkResult QueueSignalSemaphore(VkQueue queue, VkSemaphore semaphore) { 492 ALOGV("TODO: vk%s", __FUNCTION__); 493 return VK_SUCCESS; 494} 495 496VkResult QueueWaitSemaphore(VkQueue queue, VkSemaphore semaphore) { 497 ALOGV("TODO: vk%s", __FUNCTION__); 498 return VK_SUCCESS; 499} 500 501VkResult CreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, VkEvent* pEvent) { 502 ALOGV("TODO: vk%s", __FUNCTION__); 503 return VK_SUCCESS; 504} 505 506VkResult DestroyEvent(VkDevice device, VkEvent event) { 507 ALOGV("TODO: vk%s", __FUNCTION__); 508 return VK_SUCCESS; 509} 510 511VkResult GetEventStatus(VkDevice device, VkEvent event) { 512 ALOGV("TODO: vk%s", __FUNCTION__); 513 return VK_SUCCESS; 514} 515 516VkResult SetEvent(VkDevice device, VkEvent event) { 517 ALOGV("TODO: vk%s", __FUNCTION__); 518 return VK_SUCCESS; 519} 520 521VkResult ResetEvent(VkDevice device, VkEvent event) { 522 ALOGV("TODO: vk%s", __FUNCTION__); 523 return VK_SUCCESS; 524} 525 526VkResult CreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, VkQueryPool* pQueryPool) { 527 ALOGV("TODO: vk%s", __FUNCTION__); 528 return VK_SUCCESS; 529} 530 531VkResult DestroyQueryPool(VkDevice device, VkQueryPool queryPool) { 532 ALOGV("TODO: vk%s", __FUNCTION__); 533 return VK_SUCCESS; 534} 535 536VkResult GetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData, VkQueryResultFlags flags) { 537 ALOGV("TODO: vk%s", __FUNCTION__); 538 return VK_SUCCESS; 539} 540 541VkResult CreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView) { 542 ALOGV("TODO: vk%s", __FUNCTION__); 543 return VK_SUCCESS; 544} 545 546VkResult DestroyBufferView(VkDevice device, VkBufferView bufferView) { 547 ALOGV("TODO: vk%s", __FUNCTION__); 548 return VK_SUCCESS; 549} 550 551VkResult CreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage) { 552 ALOGV("TODO: vk%s", __FUNCTION__); 553 return VK_SUCCESS; 554} 555 556VkResult DestroyImage(VkDevice device, VkImage image) { 557 ALOGV("TODO: vk%s", __FUNCTION__); 558 return VK_SUCCESS; 559} 560 561VkResult GetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) { 562 ALOGV("TODO: vk%s", __FUNCTION__); 563 return VK_SUCCESS; 564} 565 566VkResult CreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView) { 567 ALOGV("TODO: vk%s", __FUNCTION__); 568 return VK_SUCCESS; 569} 570 571VkResult DestroyImageView(VkDevice device, VkImageView imageView) { 572 ALOGV("TODO: vk%s", __FUNCTION__); 573 return VK_SUCCESS; 574} 575 576VkResult CreateAttachmentView(VkDevice device, const VkAttachmentViewCreateInfo* pCreateInfo, VkAttachmentView* pView) { 577 ALOGV("TODO: vk%s", __FUNCTION__); 578 return VK_SUCCESS; 579} 580 581VkResult DestroyAttachmentView(VkDevice device, VkAttachmentView attachmentView) { 582 ALOGV("TODO: vk%s", __FUNCTION__); 583 return VK_SUCCESS; 584} 585 586VkResult CreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModule* pShaderModule) { 587 ALOGV("TODO: vk%s", __FUNCTION__); 588 return VK_SUCCESS; 589} 590 591VkResult DestroyShaderModule(VkDevice device, VkShaderModule shaderModule) { 592 ALOGV("TODO: vk%s", __FUNCTION__); 593 return VK_SUCCESS; 594} 595 596VkResult CreateShader(VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader) { 597 ALOGV("TODO: vk%s", __FUNCTION__); 598 return VK_SUCCESS; 599} 600 601VkResult DestroyShader(VkDevice device, VkShader shader) { 602 ALOGV("TODO: vk%s", __FUNCTION__); 603 return VK_SUCCESS; 604} 605 606VkResult CreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, VkPipelineCache* pPipelineCache) { 607 ALOGV("TODO: vk%s", __FUNCTION__); 608 return VK_SUCCESS; 609} 610 611VkResult DestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache) { 612 ALOGV("TODO: vk%s", __FUNCTION__); 613 return VK_SUCCESS; 614} 615 616size_t GetPipelineCacheSize(VkDevice device, VkPipelineCache pipelineCache) { 617 ALOGV("TODO: vk%s", __FUNCTION__); 618 return VK_SUCCESS; 619} 620 621VkResult GetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, void* pData) { 622 ALOGV("TODO: vk%s", __FUNCTION__); 623 return VK_SUCCESS; 624} 625 626VkResult MergePipelineCaches(VkDevice device, VkPipelineCache destCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches) { 627 ALOGV("TODO: vk%s", __FUNCTION__); 628 return VK_SUCCESS; 629} 630 631VkResult CreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkGraphicsPipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines) { 632 ALOGV("TODO: vk%s", __FUNCTION__); 633 return VK_SUCCESS; 634} 635 636VkResult CreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkComputePipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines) { 637 ALOGV("TODO: vk%s", __FUNCTION__); 638 return VK_SUCCESS; 639} 640 641VkResult DestroyPipeline(VkDevice device, VkPipeline pipeline) { 642 ALOGV("TODO: vk%s", __FUNCTION__); 643 return VK_SUCCESS; 644} 645 646VkResult CreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout) { 647 ALOGV("TODO: vk%s", __FUNCTION__); 648 return VK_SUCCESS; 649} 650 651VkResult DestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout) { 652 ALOGV("TODO: vk%s", __FUNCTION__); 653 return VK_SUCCESS; 654} 655 656VkResult CreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler) { 657 ALOGV("TODO: vk%s", __FUNCTION__); 658 return VK_SUCCESS; 659} 660 661VkResult DestroySampler(VkDevice device, VkSampler sampler) { 662 ALOGV("TODO: vk%s", __FUNCTION__); 663 return VK_SUCCESS; 664} 665 666VkResult CreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout) { 667 ALOGV("TODO: vk%s", __FUNCTION__); 668 return VK_SUCCESS; 669} 670 671VkResult DestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout) { 672 ALOGV("TODO: vk%s", __FUNCTION__); 673 return VK_SUCCESS; 674} 675 676VkResult CreateDescriptorPool(VkDevice device, VkDescriptorPoolUsage poolUsage, uint32_t maxSets, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool) { 677 ALOGV("TODO: vk%s", __FUNCTION__); 678 return VK_SUCCESS; 679} 680 681VkResult DestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool) { 682 ALOGV("TODO: vk%s", __FUNCTION__); 683 return VK_SUCCESS; 684} 685 686VkResult ResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool) { 687 ALOGV("TODO: vk%s", __FUNCTION__); 688 return VK_SUCCESS; 689} 690 691VkResult AllocDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, uint32_t count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets, uint32_t* pCount) { 692 ALOGV("TODO: vk%s", __FUNCTION__); 693 return VK_SUCCESS; 694} 695 696VkResult UpdateDescriptorSets(VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies) { 697 ALOGV("TODO: vk%s", __FUNCTION__); 698 return VK_SUCCESS; 699} 700 701VkResult FreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets) { 702 ALOGV("TODO: vk%s", __FUNCTION__); 703 return VK_SUCCESS; 704} 705 706VkResult CreateDynamicViewportState(VkDevice device, const VkDynamicViewportStateCreateInfo* pCreateInfo, VkDynamicViewportState* pState) { 707 ALOGV("TODO: vk%s", __FUNCTION__); 708 return VK_SUCCESS; 709} 710 711VkResult DestroyDynamicViewportState(VkDevice device, VkDynamicViewportState dynamicViewportState) { 712 ALOGV("TODO: vk%s", __FUNCTION__); 713 return VK_SUCCESS; 714} 715 716VkResult CreateDynamicRasterState(VkDevice device, const VkDynamicRasterStateCreateInfo* pCreateInfo, VkDynamicRasterState* pState) { 717 ALOGV("TODO: vk%s", __FUNCTION__); 718 return VK_SUCCESS; 719} 720 721VkResult DestroyDynamicRasterState(VkDevice device, VkDynamicRasterState dynamicRasterState) { 722 ALOGV("TODO: vk%s", __FUNCTION__); 723 return VK_SUCCESS; 724} 725 726VkResult CreateDynamicColorBlendState(VkDevice device, const VkDynamicColorBlendStateCreateInfo* pCreateInfo, VkDynamicColorBlendState* pState) { 727 ALOGV("TODO: vk%s", __FUNCTION__); 728 return VK_SUCCESS; 729} 730 731VkResult DestroyDynamicColorBlendState(VkDevice device, VkDynamicColorBlendState dynamicColorBlendState) { 732 ALOGV("TODO: vk%s", __FUNCTION__); 733 return VK_SUCCESS; 734} 735 736VkResult CreateDynamicDepthStencilState(VkDevice device, const VkDynamicDepthStencilStateCreateInfo* pCreateInfo, VkDynamicDepthStencilState* pState) { 737 ALOGV("TODO: vk%s", __FUNCTION__); 738 return VK_SUCCESS; 739} 740 741VkResult DestroyDynamicDepthStencilState(VkDevice device, VkDynamicDepthStencilState dynamicDepthStencilState) { 742 ALOGV("TODO: vk%s", __FUNCTION__); 743 return VK_SUCCESS; 744} 745 746VkResult CreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer) { 747 ALOGV("TODO: vk%s", __FUNCTION__); 748 return VK_SUCCESS; 749} 750 751VkResult DestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer) { 752 ALOGV("TODO: vk%s", __FUNCTION__); 753 return VK_SUCCESS; 754} 755 756VkResult CreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass) { 757 ALOGV("TODO: vk%s", __FUNCTION__); 758 return VK_SUCCESS; 759} 760 761VkResult DestroyRenderPass(VkDevice device, VkRenderPass renderPass) { 762 ALOGV("TODO: vk%s", __FUNCTION__); 763 return VK_SUCCESS; 764} 765 766VkResult GetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) { 767 ALOGV("TODO: vk%s", __FUNCTION__); 768 return VK_SUCCESS; 769} 770 771VkResult CreateCommandPool(VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, VkCmdPool* pCmdPool) { 772 ALOGV("TODO: vk%s", __FUNCTION__); 773 return VK_SUCCESS; 774} 775 776VkResult DestroyCommandPool(VkDevice device, VkCmdPool cmdPool) { 777 ALOGV("TODO: vk%s", __FUNCTION__); 778 return VK_SUCCESS; 779} 780 781VkResult ResetCommandPool(VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags) { 782 ALOGV("TODO: vk%s", __FUNCTION__); 783 return VK_SUCCESS; 784} 785 786VkResult CreateCommandBuffer(VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer) { 787 ALOGV("TODO: vk%s", __FUNCTION__); 788 return VK_SUCCESS; 789} 790 791VkResult DestroyCommandBuffer(VkDevice device, VkCmdBuffer commandBuffer) { 792 ALOGV("TODO: vk%s", __FUNCTION__); 793 return VK_SUCCESS; 794} 795 796VkResult BeginCommandBuffer(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo) { 797 ALOGV("TODO: vk%s", __FUNCTION__); 798 return VK_SUCCESS; 799} 800 801VkResult EndCommandBuffer(VkCmdBuffer cmdBuffer) { 802 ALOGV("TODO: vk%s", __FUNCTION__); 803 return VK_SUCCESS; 804} 805 806VkResult ResetCommandBuffer(VkCmdBuffer cmdBuffer, VkCmdBufferResetFlags flags) { 807 ALOGV("TODO: vk%s", __FUNCTION__); 808 return VK_SUCCESS; 809} 810 811void CmdBindPipeline(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) { 812} 813 814void CmdBindDynamicViewportState(VkCmdBuffer cmdBuffer, VkDynamicViewportState dynamicViewportState) { 815} 816 817void CmdBindDynamicRasterState(VkCmdBuffer cmdBuffer, VkDynamicRasterState dynamicRasterState) { 818} 819 820void CmdBindDynamicColorBlendState(VkCmdBuffer cmdBuffer, VkDynamicColorBlendState dynamicColorBlendState) { 821} 822 823void CmdBindDynamicDepthStencilState(VkCmdBuffer cmdBuffer, VkDynamicDepthStencilState dynamicDepthStencilState) { 824} 825 826void CmdBindDescriptorSets(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) { 827} 828 829void CmdBindIndexBuffer(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) { 830} 831 832void CmdBindVertexBuffers(VkCmdBuffer cmdBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) { 833} 834 835void CmdDraw(VkCmdBuffer cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount) { 836} 837 838void CmdDrawIndexed(VkCmdBuffer cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount) { 839} 840 841void CmdDrawIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride) { 842} 843 844void CmdDrawIndexedIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride) { 845} 846 847void CmdDispatch(VkCmdBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z) { 848} 849 850void CmdDispatchIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset) { 851} 852 853void CmdCopyBuffer(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) { 854} 855 856void CmdCopyImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) { 857} 858 859void CmdBlitImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkTexFilter filter) { 860} 861 862void CmdCopyBufferToImage(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) { 863} 864 865void CmdCopyImageToBuffer(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) { 866} 867 868void CmdUpdateBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const uint32_t* pData) { 869} 870 871void CmdFillBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, uint32_t data) { 872} 873 874void CmdClearColorImage(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) { 875} 876 877void CmdClearDepthStencilImage(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, float depth, uint32_t stencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) { 878} 879 880void CmdClearColorAttachment(VkCmdBuffer cmdBuffer, uint32_t colorAttachment, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rectCount, const VkRect3D* pRects) { 881} 882 883void CmdClearDepthStencilAttachment(VkCmdBuffer cmdBuffer, VkImageAspectFlags imageAspectMask, VkImageLayout imageLayout, float depth, uint32_t stencil, uint32_t rectCount, const VkRect3D* pRects) { 884} 885 886void CmdResolveImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) { 887} 888 889void CmdSetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask) { 890} 891 892void CmdResetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask) { 893} 894 895void CmdWaitEvents(VkCmdBuffer cmdBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, uint32_t memBarrierCount, const void* const* ppMemBarriers) { 896} 897 898void CmdPipelineBarrier(VkCmdBuffer cmdBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, VkBool32 byRegion, uint32_t memBarrierCount, const void* const* ppMemBarriers) { 899} 900 901void CmdBeginQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags) { 902} 903 904void CmdEndQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot) { 905} 906 907void CmdResetQueryPool(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount) { 908} 909 910void CmdWriteTimestamp(VkCmdBuffer cmdBuffer, VkTimestampType timestampType, VkBuffer destBuffer, VkDeviceSize destOffset) { 911} 912 913void CmdCopyQueryPoolResults(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize destStride, VkQueryResultFlags flags) { 914} 915 916void CmdPushConstants(VkCmdBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t start, uint32_t length, const void* values) { 917} 918 919void CmdBeginRenderPass(VkCmdBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents) { 920} 921 922void CmdNextSubpass(VkCmdBuffer cmdBuffer, VkRenderPassContents contents) { 923} 924 925void CmdEndRenderPass(VkCmdBuffer cmdBuffer) { 926} 927 928void CmdExecuteCommands(VkCmdBuffer cmdBuffer, uint32_t cmdBuffersCount, const VkCmdBuffer* pCmdBuffers) { 929} 930 931#pragma clang diagnostic pop 932// clang-format on 933 934} // namespace null_driver 935