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