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