1/*
2 * Copyright 2015 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include <hardware/hwvulkan.h>
18
19#include <inttypes.h>
20#include <stdlib.h>
21#include <string.h>
22#include <unistd.h>
23
24#include <algorithm>
25#include <array>
26
27#include <log/log.h>
28
29#include "null_driver_gen.h"
30
31using namespace null_driver;
32
33struct VkPhysicalDevice_T {
34    hwvulkan_dispatch_t dispatch;
35};
36
37struct VkInstance_T {
38    hwvulkan_dispatch_t dispatch;
39    VkAllocationCallbacks allocator;
40    VkPhysicalDevice_T physical_device;
41    uint64_t next_callback_handle;
42};
43
44struct VkQueue_T {
45    hwvulkan_dispatch_t dispatch;
46};
47
48struct VkCommandBuffer_T {
49    hwvulkan_dispatch_t dispatch;
50};
51
52namespace {
53// Handles for non-dispatchable objects are either pointers, or arbitrary
54// 64-bit non-zero values. We only use pointers when we need to keep state for
55// the object even in a null driver. For the rest, we form a handle as:
56//   [63:63] = 1 to distinguish from pointer handles*
57//   [62:56] = non-zero handle type enum value
58//   [55: 0] = per-handle-type incrementing counter
59// * This works because virtual addresses with the high bit set are reserved
60// for kernel data in all ABIs we run on.
61//
62// We never reclaim handles on vkDestroy*. It's not even necessary for us to
63// have distinct handles for live objects, and practically speaking we won't
64// ever create 2^56 objects of the same type from a single VkDevice in a null
65// driver.
66//
67// Using a namespace here instead of 'enum class' since we want scoped
68// constants but also want implicit conversions to integral types.
69namespace HandleType {
70enum Enum {
71    kBufferView,
72    kDebugReportCallbackEXT,
73    kDescriptorPool,
74    kDescriptorSet,
75    kDescriptorSetLayout,
76    kEvent,
77    kFence,
78    kFramebuffer,
79    kImageView,
80    kPipeline,
81    kPipelineCache,
82    kPipelineLayout,
83    kQueryPool,
84    kRenderPass,
85    kSampler,
86    kSemaphore,
87    kShaderModule,
88
89    kNumTypes
90};
91}  // namespace HandleType
92
93const VkDeviceSize kMaxDeviceMemory = 0x10000000;  // 256 MiB, arbitrary
94
95}  // anonymous namespace
96
97struct VkDevice_T {
98    hwvulkan_dispatch_t dispatch;
99    VkAllocationCallbacks allocator;
100    VkInstance_T* instance;
101    VkQueue_T queue;
102    std::array<uint64_t, HandleType::kNumTypes> next_handle;
103};
104
105// -----------------------------------------------------------------------------
106// Declare HAL_MODULE_INFO_SYM early so it can be referenced by nulldrv_device
107// later.
108
109namespace {
110int OpenDevice(const hw_module_t* module, const char* id, hw_device_t** device);
111hw_module_methods_t nulldrv_module_methods = {.open = OpenDevice};
112}  // namespace
113
114#pragma clang diagnostic push
115#pragma clang diagnostic ignored "-Wmissing-variable-declarations"
116__attribute__((visibility("default"))) hwvulkan_module_t HAL_MODULE_INFO_SYM = {
117    .common =
118        {
119            .tag = HARDWARE_MODULE_TAG,
120            .module_api_version = HWVULKAN_MODULE_API_VERSION_0_1,
121            .hal_api_version = HARDWARE_HAL_API_VERSION,
122            .id = HWVULKAN_HARDWARE_MODULE_ID,
123            .name = "Null Vulkan Driver",
124            .author = "The Android Open Source Project",
125            .methods = &nulldrv_module_methods,
126        },
127};
128#pragma clang diagnostic pop
129
130// -----------------------------------------------------------------------------
131
132namespace {
133
134int CloseDevice(struct hw_device_t* /*device*/) {
135    // nothing to do - opening a device doesn't allocate any resources
136    return 0;
137}
138
139hwvulkan_device_t nulldrv_device = {
140    .common =
141        {
142            .tag = HARDWARE_DEVICE_TAG,
143            .version = HWVULKAN_DEVICE_API_VERSION_0_1,
144            .module = &HAL_MODULE_INFO_SYM.common,
145            .close = CloseDevice,
146        },
147    .EnumerateInstanceExtensionProperties =
148        EnumerateInstanceExtensionProperties,
149    .CreateInstance = CreateInstance,
150    .GetInstanceProcAddr = GetInstanceProcAddr};
151
152int OpenDevice(const hw_module_t* /*module*/,
153               const char* id,
154               hw_device_t** device) {
155    if (strcmp(id, HWVULKAN_DEVICE_0) == 0) {
156        *device = &nulldrv_device.common;
157        return 0;
158    }
159    return -ENOENT;
160}
161
162VkInstance_T* GetInstanceFromPhysicalDevice(
163    VkPhysicalDevice_T* physical_device) {
164    return reinterpret_cast<VkInstance_T*>(
165        reinterpret_cast<uintptr_t>(physical_device) -
166        offsetof(VkInstance_T, physical_device));
167}
168
169uint64_t AllocHandle(uint64_t type, uint64_t* next_handle) {
170    const uint64_t kHandleMask = (UINT64_C(1) << 56) - 1;
171    ALOGE_IF(*next_handle == kHandleMask,
172             "non-dispatchable handles of type=%" PRIu64
173             " are about to overflow",
174             type);
175    return (UINT64_C(1) << 63) | ((type & 0x7) << 56) |
176           ((*next_handle)++ & kHandleMask);
177}
178
179template <class Handle>
180Handle AllocHandle(VkInstance instance, HandleType::Enum type) {
181    return reinterpret_cast<Handle>(
182        AllocHandle(type, &instance->next_callback_handle));
183}
184
185template <class Handle>
186Handle AllocHandle(VkDevice device, HandleType::Enum type) {
187    return reinterpret_cast<Handle>(
188        AllocHandle(type, &device->next_handle[type]));
189}
190
191VKAPI_ATTR void* DefaultAllocate(void*,
192                                 size_t size,
193                                 size_t alignment,
194                                 VkSystemAllocationScope) {
195    void* ptr = nullptr;
196    // Vulkan requires 'alignment' to be a power of two, but posix_memalign
197    // additionally requires that it be at least sizeof(void*).
198    int ret = posix_memalign(&ptr, std::max(alignment, sizeof(void*)), size);
199    return ret == 0 ? ptr : nullptr;
200}
201
202VKAPI_ATTR void* DefaultReallocate(void*,
203                                   void* ptr,
204                                   size_t size,
205                                   size_t alignment,
206                                   VkSystemAllocationScope) {
207    if (size == 0) {
208        free(ptr);
209        return nullptr;
210    }
211
212    // TODO(jessehall): Right now we never shrink allocations; if the new
213    // request is smaller than the existing chunk, we just continue using it.
214    // The null driver never reallocs, so this doesn't matter. If that changes,
215    // or if this code is copied into some other project, this should probably
216    // have a heuristic to allocate-copy-free when doing so will save "enough"
217    // space.
218    size_t old_size = ptr ? malloc_usable_size(ptr) : 0;
219    if (size <= old_size)
220        return ptr;
221
222    void* new_ptr = nullptr;
223    if (posix_memalign(&new_ptr, std::max(alignment, sizeof(void*)), size) != 0)
224        return nullptr;
225    if (ptr) {
226        memcpy(new_ptr, ptr, std::min(old_size, size));
227        free(ptr);
228    }
229    return new_ptr;
230}
231
232VKAPI_ATTR void DefaultFree(void*, void* ptr) {
233    free(ptr);
234}
235
236const VkAllocationCallbacks kDefaultAllocCallbacks = {
237    .pUserData = nullptr,
238    .pfnAllocation = DefaultAllocate,
239    .pfnReallocation = DefaultReallocate,
240    .pfnFree = DefaultFree,
241};
242
243}  // namespace
244
245namespace null_driver {
246
247#define DEFINE_OBJECT_HANDLE_CONVERSION(T)              \
248    T* Get##T##FromHandle(Vk##T h);                     \
249    T* Get##T##FromHandle(Vk##T h) {                    \
250        return reinterpret_cast<T*>(uintptr_t(h));      \
251    }                                                   \
252    Vk##T GetHandleTo##T(const T* obj);                 \
253    Vk##T GetHandleTo##T(const T* obj) {                \
254        return Vk##T(reinterpret_cast<uintptr_t>(obj)); \
255    }
256
257// -----------------------------------------------------------------------------
258// Global
259
260VKAPI_ATTR
261VkResult EnumerateInstanceExtensionProperties(
262    const char* layer_name,
263    uint32_t* count,
264    VkExtensionProperties* properties) {
265    if (layer_name) {
266        ALOGW(
267            "Driver vkEnumerateInstanceExtensionProperties shouldn't be called "
268            "with a layer name ('%s')",
269            layer_name);
270    }
271
272    const VkExtensionProperties kExtensions[] = {
273        {VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION}};
274    const uint32_t kExtensionsCount =
275        sizeof(kExtensions) / sizeof(kExtensions[0]);
276
277    if (!properties || *count > kExtensionsCount)
278        *count = kExtensionsCount;
279    if (properties)
280        std::copy(kExtensions, kExtensions + *count, properties);
281    return *count < kExtensionsCount ? VK_INCOMPLETE : VK_SUCCESS;
282}
283
284VKAPI_ATTR
285VkResult CreateInstance(const VkInstanceCreateInfo* create_info,
286                        const VkAllocationCallbacks* allocator,
287                        VkInstance* out_instance) {
288    if (!allocator)
289        allocator = &kDefaultAllocCallbacks;
290
291    VkInstance_T* instance =
292        static_cast<VkInstance_T*>(allocator->pfnAllocation(
293            allocator->pUserData, sizeof(VkInstance_T), alignof(VkInstance_T),
294            VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE));
295    if (!instance)
296        return VK_ERROR_OUT_OF_HOST_MEMORY;
297
298    instance->dispatch.magic = HWVULKAN_DISPATCH_MAGIC;
299    instance->allocator = *allocator;
300    instance->physical_device.dispatch.magic = HWVULKAN_DISPATCH_MAGIC;
301    instance->next_callback_handle = 0;
302
303    for (uint32_t i = 0; i < create_info->enabledExtensionCount; i++) {
304        if (strcmp(create_info->ppEnabledExtensionNames[i],
305                   VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME) == 0) {
306            ALOGV("instance extension '%s' requested",
307                  create_info->ppEnabledExtensionNames[i]);
308        } else if (strcmp(create_info->ppEnabledExtensionNames[i],
309                   VK_EXT_DEBUG_REPORT_EXTENSION_NAME) == 0) {
310            ALOGV("instance extension '%s' requested",
311                  create_info->ppEnabledExtensionNames[i]);
312        } else {
313            ALOGW("unsupported extension '%s' requested",
314                  create_info->ppEnabledExtensionNames[i]);
315        }
316    }
317
318    *out_instance = instance;
319    return VK_SUCCESS;
320}
321
322VKAPI_ATTR
323PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const char* name) {
324    return instance ? GetInstanceProcAddr(name) : GetGlobalProcAddr(name);
325}
326
327VKAPI_ATTR
328PFN_vkVoidFunction GetDeviceProcAddr(VkDevice, const char* name) {
329    return GetInstanceProcAddr(name);
330}
331
332// -----------------------------------------------------------------------------
333// Instance
334
335void DestroyInstance(VkInstance instance,
336                     const VkAllocationCallbacks* /*allocator*/) {
337    instance->allocator.pfnFree(instance->allocator.pUserData, instance);
338}
339
340// -----------------------------------------------------------------------------
341// PhysicalDevice
342
343VkResult EnumeratePhysicalDevices(VkInstance instance,
344                                  uint32_t* physical_device_count,
345                                  VkPhysicalDevice* physical_devices) {
346    if (physical_devices && *physical_device_count >= 1)
347        physical_devices[0] = &instance->physical_device;
348    *physical_device_count = 1;
349    return VK_SUCCESS;
350}
351
352VkResult EnumerateDeviceLayerProperties(VkPhysicalDevice /*gpu*/,
353                                        uint32_t* count,
354                                        VkLayerProperties* /*properties*/) {
355    ALOGW("Driver vkEnumerateDeviceLayerProperties shouldn't be called");
356    *count = 0;
357    return VK_SUCCESS;
358}
359
360VkResult EnumerateDeviceExtensionProperties(VkPhysicalDevice /*gpu*/,
361                                            const char* layer_name,
362                                            uint32_t* count,
363                                            VkExtensionProperties* properties) {
364    if (layer_name) {
365        ALOGW(
366            "Driver vkEnumerateDeviceExtensionProperties shouldn't be called "
367            "with a layer name ('%s')",
368            layer_name);
369        *count = 0;
370        return VK_SUCCESS;
371    }
372
373    const VkExtensionProperties kExtensions[] = {
374        {VK_ANDROID_NATIVE_BUFFER_EXTENSION_NAME,
375         VK_ANDROID_NATIVE_BUFFER_SPEC_VERSION}};
376    const uint32_t kExtensionsCount =
377        sizeof(kExtensions) / sizeof(kExtensions[0]);
378
379    if (!properties || *count > kExtensionsCount)
380        *count = kExtensionsCount;
381    if (properties)
382        std::copy(kExtensions, kExtensions + *count, properties);
383    return *count < kExtensionsCount ? VK_INCOMPLETE : VK_SUCCESS;
384}
385
386void GetPhysicalDeviceProperties(VkPhysicalDevice,
387                                 VkPhysicalDeviceProperties* properties) {
388    properties->apiVersion = VK_MAKE_VERSION(1, 0, VK_HEADER_VERSION);
389    properties->driverVersion = VK_MAKE_VERSION(0, 0, 1);
390    properties->vendorID = 0;
391    properties->deviceID = 0;
392    properties->deviceType = VK_PHYSICAL_DEVICE_TYPE_OTHER;
393    strcpy(properties->deviceName, "Android Vulkan Null Driver");
394    memset(properties->pipelineCacheUUID, 0,
395           sizeof(properties->pipelineCacheUUID));
396    properties->limits = VkPhysicalDeviceLimits{
397        4096,     // maxImageDimension1D
398        4096,     // maxImageDimension2D
399        256,      // maxImageDimension3D
400        4096,     // maxImageDimensionCube
401        256,      // maxImageArrayLayers
402        65536,    // maxTexelBufferElements
403        16384,    // maxUniformBufferRange
404        1 << 27,  // maxStorageBufferRange
405        128,      // maxPushConstantsSize
406        4096,     // maxMemoryAllocationCount
407        4000,     // maxSamplerAllocationCount
408        1,        // bufferImageGranularity
409        0,        // sparseAddressSpaceSize
410        4,        // maxBoundDescriptorSets
411        16,       // maxPerStageDescriptorSamplers
412        12,       // maxPerStageDescriptorUniformBuffers
413        4,        // maxPerStageDescriptorStorageBuffers
414        16,       // maxPerStageDescriptorSampledImages
415        4,        // maxPerStageDescriptorStorageImages
416        4,        // maxPerStageDescriptorInputAttachments
417        128,      // maxPerStageResources
418        96,       // maxDescriptorSetSamplers
419        72,       // maxDescriptorSetUniformBuffers
420        8,        // maxDescriptorSetUniformBuffersDynamic
421        24,       // maxDescriptorSetStorageBuffers
422        4,        // maxDescriptorSetStorageBuffersDynamic
423        96,       // maxDescriptorSetSampledImages
424        24,       // maxDescriptorSetStorageImages
425        4,        // maxDescriptorSetInputAttachments
426        16,       // maxVertexInputAttributes
427        16,       // maxVertexInputBindings
428        2047,     // maxVertexInputAttributeOffset
429        2048,     // maxVertexInputBindingStride
430        64,       // maxVertexOutputComponents
431        0,        // maxTessellationGenerationLevel
432        0,        // maxTessellationPatchSize
433        0,        // maxTessellationControlPerVertexInputComponents
434        0,        // maxTessellationControlPerVertexOutputComponents
435        0,        // maxTessellationControlPerPatchOutputComponents
436        0,        // maxTessellationControlTotalOutputComponents
437        0,        // maxTessellationEvaluationInputComponents
438        0,        // maxTessellationEvaluationOutputComponents
439        0,        // maxGeometryShaderInvocations
440        0,        // maxGeometryInputComponents
441        0,        // maxGeometryOutputComponents
442        0,        // maxGeometryOutputVertices
443        0,        // maxGeometryTotalOutputComponents
444        64,       // maxFragmentInputComponents
445        4,        // maxFragmentOutputAttachments
446        0,        // maxFragmentDualSrcAttachments
447        4,        // maxFragmentCombinedOutputResources
448        16384,    // maxComputeSharedMemorySize
449        {65536, 65536, 65536},  // maxComputeWorkGroupCount[3]
450        128,                    // maxComputeWorkGroupInvocations
451        {128, 128, 64},         // maxComputeWorkGroupSize[3]
452        4,                      // subPixelPrecisionBits
453        4,                      // subTexelPrecisionBits
454        4,                      // mipmapPrecisionBits
455        UINT32_MAX,             // maxDrawIndexedIndexValue
456        1,                      // maxDrawIndirectCount
457        2,                      // maxSamplerLodBias
458        1,                      // maxSamplerAnisotropy
459        1,                      // maxViewports
460        {4096, 4096},           // maxViewportDimensions[2]
461        {-8192.0f, 8191.0f},    // viewportBoundsRange[2]
462        0,                      // viewportSubPixelBits
463        64,                     // minMemoryMapAlignment
464        256,                    // minTexelBufferOffsetAlignment
465        256,                    // minUniformBufferOffsetAlignment
466        256,                    // minStorageBufferOffsetAlignment
467        -8,                     // minTexelOffset
468        7,                      // maxTexelOffset
469        0,                      // minTexelGatherOffset
470        0,                      // maxTexelGatherOffset
471        0.0f,                   // minInterpolationOffset
472        0.0f,                   // maxInterpolationOffset
473        0,                      // subPixelInterpolationOffsetBits
474        4096,                   // maxFramebufferWidth
475        4096,                   // maxFramebufferHeight
476        256,                    // maxFramebufferLayers
477        VK_SAMPLE_COUNT_1_BIT |
478            VK_SAMPLE_COUNT_4_BIT,  // framebufferColorSampleCounts
479        VK_SAMPLE_COUNT_1_BIT |
480            VK_SAMPLE_COUNT_4_BIT,  // framebufferDepthSampleCounts
481        VK_SAMPLE_COUNT_1_BIT |
482            VK_SAMPLE_COUNT_4_BIT,  // framebufferStencilSampleCounts
483        VK_SAMPLE_COUNT_1_BIT |
484            VK_SAMPLE_COUNT_4_BIT,  // framebufferNoAttachmentsSampleCounts
485        4,                          // maxColorAttachments
486        VK_SAMPLE_COUNT_1_BIT |
487            VK_SAMPLE_COUNT_4_BIT,  // sampledImageColorSampleCounts
488        VK_SAMPLE_COUNT_1_BIT,      // sampledImageIntegerSampleCounts
489        VK_SAMPLE_COUNT_1_BIT |
490            VK_SAMPLE_COUNT_4_BIT,  // sampledImageDepthSampleCounts
491        VK_SAMPLE_COUNT_1_BIT |
492            VK_SAMPLE_COUNT_4_BIT,  // sampledImageStencilSampleCounts
493        VK_SAMPLE_COUNT_1_BIT,      // storageImageSampleCounts
494        1,                          // maxSampleMaskWords
495        VK_TRUE,                    // timestampComputeAndGraphics
496        1,                          // timestampPeriod
497        0,                          // maxClipDistances
498        0,                          // maxCullDistances
499        0,                          // maxCombinedClipAndCullDistances
500        2,                          // discreteQueuePriorities
501        {1.0f, 1.0f},               // pointSizeRange[2]
502        {1.0f, 1.0f},               // lineWidthRange[2]
503        0.0f,                       // pointSizeGranularity
504        0.0f,                       // lineWidthGranularity
505        VK_TRUE,                    // strictLines
506        VK_TRUE,                    // standardSampleLocations
507        1,                          // optimalBufferCopyOffsetAlignment
508        1,                          // optimalBufferCopyRowPitchAlignment
509        64,                         // nonCoherentAtomSize
510    };
511}
512
513void GetPhysicalDeviceProperties2KHR(VkPhysicalDevice physical_device,
514                                  VkPhysicalDeviceProperties2KHR* properties) {
515    GetPhysicalDeviceProperties(physical_device, &properties->properties);
516
517    while (properties->pNext) {
518        properties = reinterpret_cast<VkPhysicalDeviceProperties2KHR *>(properties->pNext);
519
520#pragma clang diagnostic push
521#pragma clang diagnostic ignored "-Wold-style-cast"
522        switch ((VkFlags)properties->sType) {
523        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID: {
524            VkPhysicalDevicePresentationPropertiesANDROID *presentation_properties =
525                reinterpret_cast<VkPhysicalDevicePresentationPropertiesANDROID *>(properties);
526#pragma clang diagnostic pop
527
528                // Claim that we do all the right things for the loader to
529                // expose KHR_shared_presentable_image on our behalf.
530                presentation_properties->sharedImage = VK_TRUE;
531            } break;
532
533        default:
534            // Silently ignore other extension query structs
535            break;
536        }
537    }
538}
539
540void GetPhysicalDeviceQueueFamilyProperties(
541    VkPhysicalDevice,
542    uint32_t* count,
543    VkQueueFamilyProperties* properties) {
544    if (!properties || *count > 1)
545        *count = 1;
546    if (properties && *count == 1) {
547        properties->queueFlags = VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT |
548                                 VK_QUEUE_TRANSFER_BIT;
549        properties->queueCount = 1;
550        properties->timestampValidBits = 64;
551        properties->minImageTransferGranularity = VkExtent3D{1, 1, 1};
552    }
553}
554
555void GetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physical_device, uint32_t* count, VkQueueFamilyProperties2KHR* properties) {
556    // note: even though multiple structures, this is safe to forward in this
557    // case since we only expose one queue family.
558    GetPhysicalDeviceQueueFamilyProperties(physical_device, count, properties ? &properties->queueFamilyProperties : nullptr);
559}
560
561void GetPhysicalDeviceMemoryProperties(
562    VkPhysicalDevice,
563    VkPhysicalDeviceMemoryProperties* properties) {
564    properties->memoryTypeCount = 1;
565    properties->memoryTypes[0].propertyFlags =
566        VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT |
567        VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
568        VK_MEMORY_PROPERTY_HOST_COHERENT_BIT |
569        VK_MEMORY_PROPERTY_HOST_CACHED_BIT;
570    properties->memoryTypes[0].heapIndex = 0;
571    properties->memoryHeapCount = 1;
572    properties->memoryHeaps[0].size = kMaxDeviceMemory;
573    properties->memoryHeaps[0].flags = VK_MEMORY_HEAP_DEVICE_LOCAL_BIT;
574}
575
576void GetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physical_device, VkPhysicalDeviceMemoryProperties2KHR* properties) {
577    GetPhysicalDeviceMemoryProperties(physical_device, &properties->memoryProperties);
578}
579
580void GetPhysicalDeviceFeatures(VkPhysicalDevice /*gpu*/,
581                               VkPhysicalDeviceFeatures* features) {
582    *features = VkPhysicalDeviceFeatures{
583        VK_TRUE,   // robustBufferAccess
584        VK_FALSE,  // fullDrawIndexUint32
585        VK_FALSE,  // imageCubeArray
586        VK_FALSE,  // independentBlend
587        VK_FALSE,  // geometryShader
588        VK_FALSE,  // tessellationShader
589        VK_FALSE,  // sampleRateShading
590        VK_FALSE,  // dualSrcBlend
591        VK_FALSE,  // logicOp
592        VK_FALSE,  // multiDrawIndirect
593        VK_FALSE,  // drawIndirectFirstInstance
594        VK_FALSE,  // depthClamp
595        VK_FALSE,  // depthBiasClamp
596        VK_FALSE,  // fillModeNonSolid
597        VK_FALSE,  // depthBounds
598        VK_FALSE,  // wideLines
599        VK_FALSE,  // largePoints
600        VK_FALSE,  // alphaToOne
601        VK_FALSE,  // multiViewport
602        VK_FALSE,  // samplerAnisotropy
603        VK_FALSE,  // textureCompressionETC2
604        VK_FALSE,  // textureCompressionASTC_LDR
605        VK_FALSE,  // textureCompressionBC
606        VK_FALSE,  // occlusionQueryPrecise
607        VK_FALSE,  // pipelineStatisticsQuery
608        VK_FALSE,  // vertexPipelineStoresAndAtomics
609        VK_FALSE,  // fragmentStoresAndAtomics
610        VK_FALSE,  // shaderTessellationAndGeometryPointSize
611        VK_FALSE,  // shaderImageGatherExtended
612        VK_FALSE,  // shaderStorageImageExtendedFormats
613        VK_FALSE,  // shaderStorageImageMultisample
614        VK_FALSE,  // shaderStorageImageReadWithoutFormat
615        VK_FALSE,  // shaderStorageImageWriteWithoutFormat
616        VK_FALSE,  // shaderUniformBufferArrayDynamicIndexing
617        VK_FALSE,  // shaderSampledImageArrayDynamicIndexing
618        VK_FALSE,  // shaderStorageBufferArrayDynamicIndexing
619        VK_FALSE,  // shaderStorageImageArrayDynamicIndexing
620        VK_FALSE,  // shaderClipDistance
621        VK_FALSE,  // shaderCullDistance
622        VK_FALSE,  // shaderFloat64
623        VK_FALSE,  // shaderInt64
624        VK_FALSE,  // shaderInt16
625        VK_FALSE,  // shaderResourceResidency
626        VK_FALSE,  // shaderResourceMinLod
627        VK_FALSE,  // sparseBinding
628        VK_FALSE,  // sparseResidencyBuffer
629        VK_FALSE,  // sparseResidencyImage2D
630        VK_FALSE,  // sparseResidencyImage3D
631        VK_FALSE,  // sparseResidency2Samples
632        VK_FALSE,  // sparseResidency4Samples
633        VK_FALSE,  // sparseResidency8Samples
634        VK_FALSE,  // sparseResidency16Samples
635        VK_FALSE,  // sparseResidencyAliased
636        VK_FALSE,  // variableMultisampleRate
637        VK_FALSE,  // inheritedQueries
638    };
639}
640
641void GetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physical_device, VkPhysicalDeviceFeatures2KHR* features) {
642    GetPhysicalDeviceFeatures(physical_device, &features->features);
643}
644
645// -----------------------------------------------------------------------------
646// Device
647
648VkResult CreateDevice(VkPhysicalDevice physical_device,
649                      const VkDeviceCreateInfo* create_info,
650                      const VkAllocationCallbacks* allocator,
651                      VkDevice* out_device) {
652    VkInstance_T* instance = GetInstanceFromPhysicalDevice(physical_device);
653    if (!allocator)
654        allocator = &instance->allocator;
655    VkDevice_T* device = static_cast<VkDevice_T*>(allocator->pfnAllocation(
656        allocator->pUserData, sizeof(VkDevice_T), alignof(VkDevice_T),
657        VK_SYSTEM_ALLOCATION_SCOPE_DEVICE));
658    if (!device)
659        return VK_ERROR_OUT_OF_HOST_MEMORY;
660
661    device->dispatch.magic = HWVULKAN_DISPATCH_MAGIC;
662    device->allocator = *allocator;
663    device->instance = instance;
664    device->queue.dispatch.magic = HWVULKAN_DISPATCH_MAGIC;
665    std::fill(device->next_handle.begin(), device->next_handle.end(),
666              UINT64_C(0));
667
668    for (uint32_t i = 0; i < create_info->enabledExtensionCount; i++) {
669        if (strcmp(create_info->ppEnabledExtensionNames[i],
670                   VK_ANDROID_NATIVE_BUFFER_EXTENSION_NAME) == 0) {
671            ALOGV("Enabling " VK_ANDROID_NATIVE_BUFFER_EXTENSION_NAME);
672        }
673    }
674
675    *out_device = device;
676    return VK_SUCCESS;
677}
678
679void DestroyDevice(VkDevice device,
680                   const VkAllocationCallbacks* /*allocator*/) {
681    if (!device)
682        return;
683    device->allocator.pfnFree(device->allocator.pUserData, device);
684}
685
686void GetDeviceQueue(VkDevice device, uint32_t, uint32_t, VkQueue* queue) {
687    *queue = &device->queue;
688}
689
690// -----------------------------------------------------------------------------
691// CommandPool
692
693struct CommandPool {
694    typedef VkCommandPool HandleType;
695    VkAllocationCallbacks allocator;
696};
697DEFINE_OBJECT_HANDLE_CONVERSION(CommandPool)
698
699VkResult CreateCommandPool(VkDevice device,
700                           const VkCommandPoolCreateInfo* /*create_info*/,
701                           const VkAllocationCallbacks* allocator,
702                           VkCommandPool* cmd_pool) {
703    if (!allocator)
704        allocator = &device->allocator;
705    CommandPool* pool = static_cast<CommandPool*>(allocator->pfnAllocation(
706        allocator->pUserData, sizeof(CommandPool), alignof(CommandPool),
707        VK_SYSTEM_ALLOCATION_SCOPE_OBJECT));
708    if (!pool)
709        return VK_ERROR_OUT_OF_HOST_MEMORY;
710    pool->allocator = *allocator;
711    *cmd_pool = GetHandleToCommandPool(pool);
712    return VK_SUCCESS;
713}
714
715void DestroyCommandPool(VkDevice /*device*/,
716                        VkCommandPool cmd_pool,
717                        const VkAllocationCallbacks* /*allocator*/) {
718    CommandPool* pool = GetCommandPoolFromHandle(cmd_pool);
719    pool->allocator.pfnFree(pool->allocator.pUserData, pool);
720}
721
722// -----------------------------------------------------------------------------
723// CmdBuffer
724
725VkResult AllocateCommandBuffers(VkDevice /*device*/,
726                                const VkCommandBufferAllocateInfo* alloc_info,
727                                VkCommandBuffer* cmdbufs) {
728    VkResult result = VK_SUCCESS;
729    CommandPool& pool = *GetCommandPoolFromHandle(alloc_info->commandPool);
730    std::fill(cmdbufs, cmdbufs + alloc_info->commandBufferCount, nullptr);
731    for (uint32_t i = 0; i < alloc_info->commandBufferCount; i++) {
732        cmdbufs[i] =
733            static_cast<VkCommandBuffer_T*>(pool.allocator.pfnAllocation(
734                pool.allocator.pUserData, sizeof(VkCommandBuffer_T),
735                alignof(VkCommandBuffer_T), VK_SYSTEM_ALLOCATION_SCOPE_OBJECT));
736        if (!cmdbufs[i]) {
737            result = VK_ERROR_OUT_OF_HOST_MEMORY;
738            break;
739        }
740        cmdbufs[i]->dispatch.magic = HWVULKAN_DISPATCH_MAGIC;
741    }
742    if (result != VK_SUCCESS) {
743        for (uint32_t i = 0; i < alloc_info->commandBufferCount; i++) {
744            if (!cmdbufs[i])
745                break;
746            pool.allocator.pfnFree(pool.allocator.pUserData, cmdbufs[i]);
747        }
748    }
749    return result;
750}
751
752void FreeCommandBuffers(VkDevice /*device*/,
753                        VkCommandPool cmd_pool,
754                        uint32_t count,
755                        const VkCommandBuffer* cmdbufs) {
756    CommandPool& pool = *GetCommandPoolFromHandle(cmd_pool);
757    for (uint32_t i = 0; i < count; i++)
758        pool.allocator.pfnFree(pool.allocator.pUserData, cmdbufs[i]);
759}
760
761// -----------------------------------------------------------------------------
762// DeviceMemory
763
764struct DeviceMemory {
765    typedef VkDeviceMemory HandleType;
766    VkDeviceSize size;
767    alignas(16) uint8_t data[0];
768};
769DEFINE_OBJECT_HANDLE_CONVERSION(DeviceMemory)
770
771VkResult AllocateMemory(VkDevice device,
772                        const VkMemoryAllocateInfo* alloc_info,
773                        const VkAllocationCallbacks* allocator,
774                        VkDeviceMemory* mem_handle) {
775    if (SIZE_MAX - sizeof(DeviceMemory) <= alloc_info->allocationSize)
776        return VK_ERROR_OUT_OF_HOST_MEMORY;
777    if (!allocator)
778        allocator = &device->allocator;
779
780    size_t size = sizeof(DeviceMemory) + size_t(alloc_info->allocationSize);
781    DeviceMemory* mem = static_cast<DeviceMemory*>(allocator->pfnAllocation(
782        allocator->pUserData, size, alignof(DeviceMemory),
783        VK_SYSTEM_ALLOCATION_SCOPE_OBJECT));
784    if (!mem)
785        return VK_ERROR_OUT_OF_HOST_MEMORY;
786    mem->size = size;
787    *mem_handle = GetHandleToDeviceMemory(mem);
788    return VK_SUCCESS;
789}
790
791void FreeMemory(VkDevice device,
792                VkDeviceMemory mem_handle,
793                const VkAllocationCallbacks* allocator) {
794    if (!allocator)
795        allocator = &device->allocator;
796    DeviceMemory* mem = GetDeviceMemoryFromHandle(mem_handle);
797    allocator->pfnFree(allocator->pUserData, mem);
798}
799
800VkResult MapMemory(VkDevice,
801                   VkDeviceMemory mem_handle,
802                   VkDeviceSize offset,
803                   VkDeviceSize,
804                   VkMemoryMapFlags,
805                   void** out_ptr) {
806    DeviceMemory* mem = GetDeviceMemoryFromHandle(mem_handle);
807    *out_ptr = &mem->data[0] + offset;
808    return VK_SUCCESS;
809}
810
811// -----------------------------------------------------------------------------
812// Buffer
813
814struct Buffer {
815    typedef VkBuffer HandleType;
816    VkDeviceSize size;
817};
818DEFINE_OBJECT_HANDLE_CONVERSION(Buffer)
819
820VkResult CreateBuffer(VkDevice device,
821                      const VkBufferCreateInfo* create_info,
822                      const VkAllocationCallbacks* allocator,
823                      VkBuffer* buffer_handle) {
824    ALOGW_IF(create_info->size > kMaxDeviceMemory,
825             "CreateBuffer: requested size 0x%" PRIx64
826             " exceeds max device memory size 0x%" PRIx64,
827             create_info->size, kMaxDeviceMemory);
828    if (!allocator)
829        allocator = &device->allocator;
830    Buffer* buffer = static_cast<Buffer*>(allocator->pfnAllocation(
831        allocator->pUserData, sizeof(Buffer), alignof(Buffer),
832        VK_SYSTEM_ALLOCATION_SCOPE_OBJECT));
833    if (!buffer)
834        return VK_ERROR_OUT_OF_HOST_MEMORY;
835    buffer->size = create_info->size;
836    *buffer_handle = GetHandleToBuffer(buffer);
837    return VK_SUCCESS;
838}
839
840void GetBufferMemoryRequirements(VkDevice,
841                                 VkBuffer buffer_handle,
842                                 VkMemoryRequirements* requirements) {
843    Buffer* buffer = GetBufferFromHandle(buffer_handle);
844    requirements->size = buffer->size;
845    requirements->alignment = 16;  // allow fast Neon/SSE memcpy
846    requirements->memoryTypeBits = 0x1;
847}
848
849void DestroyBuffer(VkDevice device,
850                   VkBuffer buffer_handle,
851                   const VkAllocationCallbacks* allocator) {
852    if (!allocator)
853        allocator = &device->allocator;
854    Buffer* buffer = GetBufferFromHandle(buffer_handle);
855    allocator->pfnFree(allocator->pUserData, buffer);
856}
857
858// -----------------------------------------------------------------------------
859// Image
860
861struct Image {
862    typedef VkImage HandleType;
863    VkDeviceSize size;
864};
865DEFINE_OBJECT_HANDLE_CONVERSION(Image)
866
867VkResult CreateImage(VkDevice device,
868                     const VkImageCreateInfo* create_info,
869                     const VkAllocationCallbacks* allocator,
870                     VkImage* image_handle) {
871    if (create_info->imageType != VK_IMAGE_TYPE_2D ||
872        create_info->format != VK_FORMAT_R8G8B8A8_UNORM ||
873        create_info->mipLevels != 1) {
874        ALOGE("CreateImage: not yet implemented: type=%d format=%d mips=%u",
875              create_info->imageType, create_info->format,
876              create_info->mipLevels);
877        return VK_ERROR_OUT_OF_HOST_MEMORY;
878    }
879
880    VkDeviceSize size =
881        VkDeviceSize(create_info->extent.width * create_info->extent.height) *
882        create_info->arrayLayers * create_info->samples * 4u;
883    ALOGW_IF(size > kMaxDeviceMemory,
884             "CreateImage: image size 0x%" PRIx64
885             " exceeds max device memory size 0x%" PRIx64,
886             size, kMaxDeviceMemory);
887
888    if (!allocator)
889        allocator = &device->allocator;
890    Image* image = static_cast<Image*>(allocator->pfnAllocation(
891        allocator->pUserData, sizeof(Image), alignof(Image),
892        VK_SYSTEM_ALLOCATION_SCOPE_OBJECT));
893    if (!image)
894        return VK_ERROR_OUT_OF_HOST_MEMORY;
895    image->size = size;
896    *image_handle = GetHandleToImage(image);
897    return VK_SUCCESS;
898}
899
900void GetImageMemoryRequirements(VkDevice,
901                                VkImage image_handle,
902                                VkMemoryRequirements* requirements) {
903    Image* image = GetImageFromHandle(image_handle);
904    requirements->size = image->size;
905    requirements->alignment = 16;  // allow fast Neon/SSE memcpy
906    requirements->memoryTypeBits = 0x1;
907}
908
909void DestroyImage(VkDevice device,
910                  VkImage image_handle,
911                  const VkAllocationCallbacks* allocator) {
912    if (!allocator)
913        allocator = &device->allocator;
914    Image* image = GetImageFromHandle(image_handle);
915    allocator->pfnFree(allocator->pUserData, image);
916}
917
918VkResult GetSwapchainGrallocUsageANDROID(VkDevice,
919                                         VkFormat,
920                                         VkImageUsageFlags,
921                                         int* grallocUsage) {
922    // The null driver never reads or writes the gralloc buffer
923    *grallocUsage = 0;
924    return VK_SUCCESS;
925}
926
927VkResult GetSwapchainGrallocUsage2ANDROID(VkDevice,
928                                          VkFormat,
929                                          VkImageUsageFlags,
930                                          VkSwapchainImageUsageFlagsANDROID,
931                                          uint64_t* grallocConsumerUsage,
932                                          uint64_t* grallocProducerUsage) {
933    // The null driver never reads or writes the gralloc buffer
934    *grallocConsumerUsage = 0;
935    *grallocProducerUsage = 0;
936    return VK_SUCCESS;
937}
938
939VkResult AcquireImageANDROID(VkDevice,
940                             VkImage,
941                             int fence,
942                             VkSemaphore,
943                             VkFence) {
944    close(fence);
945    return VK_SUCCESS;
946}
947
948VkResult QueueSignalReleaseImageANDROID(VkQueue,
949                                        uint32_t,
950                                        const VkSemaphore*,
951                                        VkImage,
952                                        int* fence) {
953    *fence = -1;
954    return VK_SUCCESS;
955}
956
957// -----------------------------------------------------------------------------
958// No-op types
959
960VkResult CreateBufferView(VkDevice device,
961                          const VkBufferViewCreateInfo*,
962                          const VkAllocationCallbacks* /*allocator*/,
963                          VkBufferView* view) {
964    *view = AllocHandle<VkBufferView>(device, HandleType::kBufferView);
965    return VK_SUCCESS;
966}
967
968VkResult CreateDescriptorPool(VkDevice device,
969                              const VkDescriptorPoolCreateInfo*,
970                              const VkAllocationCallbacks* /*allocator*/,
971                              VkDescriptorPool* pool) {
972    *pool = AllocHandle<VkDescriptorPool>(device, HandleType::kDescriptorPool);
973    return VK_SUCCESS;
974}
975
976VkResult AllocateDescriptorSets(VkDevice device,
977                                const VkDescriptorSetAllocateInfo* alloc_info,
978                                VkDescriptorSet* descriptor_sets) {
979    for (uint32_t i = 0; i < alloc_info->descriptorSetCount; i++)
980        descriptor_sets[i] =
981            AllocHandle<VkDescriptorSet>(device, HandleType::kDescriptorSet);
982    return VK_SUCCESS;
983}
984
985VkResult CreateDescriptorSetLayout(VkDevice device,
986                                   const VkDescriptorSetLayoutCreateInfo*,
987                                   const VkAllocationCallbacks* /*allocator*/,
988                                   VkDescriptorSetLayout* layout) {
989    *layout = AllocHandle<VkDescriptorSetLayout>(
990        device, HandleType::kDescriptorSetLayout);
991    return VK_SUCCESS;
992}
993
994VkResult CreateEvent(VkDevice device,
995                     const VkEventCreateInfo*,
996                     const VkAllocationCallbacks* /*allocator*/,
997                     VkEvent* event) {
998    *event = AllocHandle<VkEvent>(device, HandleType::kEvent);
999    return VK_SUCCESS;
1000}
1001
1002VkResult CreateFence(VkDevice device,
1003                     const VkFenceCreateInfo*,
1004                     const VkAllocationCallbacks* /*allocator*/,
1005                     VkFence* fence) {
1006    *fence = AllocHandle<VkFence>(device, HandleType::kFence);
1007    return VK_SUCCESS;
1008}
1009
1010VkResult CreateFramebuffer(VkDevice device,
1011                           const VkFramebufferCreateInfo*,
1012                           const VkAllocationCallbacks* /*allocator*/,
1013                           VkFramebuffer* framebuffer) {
1014    *framebuffer = AllocHandle<VkFramebuffer>(device, HandleType::kFramebuffer);
1015    return VK_SUCCESS;
1016}
1017
1018VkResult CreateImageView(VkDevice device,
1019                         const VkImageViewCreateInfo*,
1020                         const VkAllocationCallbacks* /*allocator*/,
1021                         VkImageView* view) {
1022    *view = AllocHandle<VkImageView>(device, HandleType::kImageView);
1023    return VK_SUCCESS;
1024}
1025
1026VkResult CreateGraphicsPipelines(VkDevice device,
1027                                 VkPipelineCache,
1028                                 uint32_t count,
1029                                 const VkGraphicsPipelineCreateInfo*,
1030                                 const VkAllocationCallbacks* /*allocator*/,
1031                                 VkPipeline* pipelines) {
1032    for (uint32_t i = 0; i < count; i++)
1033        pipelines[i] = AllocHandle<VkPipeline>(device, HandleType::kPipeline);
1034    return VK_SUCCESS;
1035}
1036
1037VkResult CreateComputePipelines(VkDevice device,
1038                                VkPipelineCache,
1039                                uint32_t count,
1040                                const VkComputePipelineCreateInfo*,
1041                                const VkAllocationCallbacks* /*allocator*/,
1042                                VkPipeline* pipelines) {
1043    for (uint32_t i = 0; i < count; i++)
1044        pipelines[i] = AllocHandle<VkPipeline>(device, HandleType::kPipeline);
1045    return VK_SUCCESS;
1046}
1047
1048VkResult CreatePipelineCache(VkDevice device,
1049                             const VkPipelineCacheCreateInfo*,
1050                             const VkAllocationCallbacks* /*allocator*/,
1051                             VkPipelineCache* cache) {
1052    *cache = AllocHandle<VkPipelineCache>(device, HandleType::kPipelineCache);
1053    return VK_SUCCESS;
1054}
1055
1056VkResult CreatePipelineLayout(VkDevice device,
1057                              const VkPipelineLayoutCreateInfo*,
1058                              const VkAllocationCallbacks* /*allocator*/,
1059                              VkPipelineLayout* layout) {
1060    *layout =
1061        AllocHandle<VkPipelineLayout>(device, HandleType::kPipelineLayout);
1062    return VK_SUCCESS;
1063}
1064
1065VkResult CreateQueryPool(VkDevice device,
1066                         const VkQueryPoolCreateInfo*,
1067                         const VkAllocationCallbacks* /*allocator*/,
1068                         VkQueryPool* pool) {
1069    *pool = AllocHandle<VkQueryPool>(device, HandleType::kQueryPool);
1070    return VK_SUCCESS;
1071}
1072
1073VkResult CreateRenderPass(VkDevice device,
1074                          const VkRenderPassCreateInfo*,
1075                          const VkAllocationCallbacks* /*allocator*/,
1076                          VkRenderPass* renderpass) {
1077    *renderpass = AllocHandle<VkRenderPass>(device, HandleType::kRenderPass);
1078    return VK_SUCCESS;
1079}
1080
1081VkResult CreateSampler(VkDevice device,
1082                       const VkSamplerCreateInfo*,
1083                       const VkAllocationCallbacks* /*allocator*/,
1084                       VkSampler* sampler) {
1085    *sampler = AllocHandle<VkSampler>(device, HandleType::kSampler);
1086    return VK_SUCCESS;
1087}
1088
1089VkResult CreateSemaphore(VkDevice device,
1090                         const VkSemaphoreCreateInfo*,
1091                         const VkAllocationCallbacks* /*allocator*/,
1092                         VkSemaphore* semaphore) {
1093    *semaphore = AllocHandle<VkSemaphore>(device, HandleType::kSemaphore);
1094    return VK_SUCCESS;
1095}
1096
1097VkResult CreateShaderModule(VkDevice device,
1098                            const VkShaderModuleCreateInfo*,
1099                            const VkAllocationCallbacks* /*allocator*/,
1100                            VkShaderModule* module) {
1101    *module = AllocHandle<VkShaderModule>(device, HandleType::kShaderModule);
1102    return VK_SUCCESS;
1103}
1104
1105VkResult CreateDebugReportCallbackEXT(VkInstance instance,
1106                                      const VkDebugReportCallbackCreateInfoEXT*,
1107                                      const VkAllocationCallbacks*,
1108                                      VkDebugReportCallbackEXT* callback) {
1109    *callback = AllocHandle<VkDebugReportCallbackEXT>(
1110        instance, HandleType::kDebugReportCallbackEXT);
1111    return VK_SUCCESS;
1112}
1113
1114// -----------------------------------------------------------------------------
1115// No-op entrypoints
1116
1117// clang-format off
1118#pragma clang diagnostic push
1119#pragma clang diagnostic ignored "-Wunused-parameter"
1120
1121void GetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) {
1122    ALOGV("TODO: vk%s", __FUNCTION__);
1123}
1124
1125void GetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2KHR* pFormatProperties) {
1126    ALOGV("TODO: vk%s", __FUNCTION__);
1127}
1128
1129VkResult GetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) {
1130    ALOGV("TODO: vk%s", __FUNCTION__);
1131    return VK_SUCCESS;
1132}
1133
1134VkResult GetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice physicalDevice,
1135                                                    const VkPhysicalDeviceImageFormatInfo2KHR* pImageFormatInfo,
1136                                                    VkImageFormatProperties2KHR* pImageFormatProperties) {
1137    ALOGV("TODO: vk%s", __FUNCTION__);
1138    return VK_SUCCESS;
1139}
1140
1141VkResult EnumerateInstanceLayerProperties(uint32_t* pCount, VkLayerProperties* pProperties) {
1142    ALOGV("TODO: vk%s", __FUNCTION__);
1143    return VK_SUCCESS;
1144}
1145
1146VkResult QueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmitInfo, VkFence fence) {
1147    return VK_SUCCESS;
1148}
1149
1150VkResult QueueWaitIdle(VkQueue queue) {
1151    ALOGV("TODO: vk%s", __FUNCTION__);
1152    return VK_SUCCESS;
1153}
1154
1155VkResult DeviceWaitIdle(VkDevice device) {
1156    ALOGV("TODO: vk%s", __FUNCTION__);
1157    return VK_SUCCESS;
1158}
1159
1160void UnmapMemory(VkDevice device, VkDeviceMemory mem) {
1161}
1162
1163VkResult FlushMappedMemoryRanges(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges) {
1164    ALOGV("TODO: vk%s", __FUNCTION__);
1165    return VK_SUCCESS;
1166}
1167
1168VkResult InvalidateMappedMemoryRanges(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges) {
1169    ALOGV("TODO: vk%s", __FUNCTION__);
1170    return VK_SUCCESS;
1171}
1172
1173void GetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) {
1174    ALOGV("TODO: vk%s", __FUNCTION__);
1175}
1176
1177VkResult BindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memOffset) {
1178    return VK_SUCCESS;
1179}
1180
1181VkResult BindImageMemory(VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize memOffset) {
1182    return VK_SUCCESS;
1183}
1184
1185void GetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) {
1186    ALOGV("TODO: vk%s", __FUNCTION__);
1187}
1188
1189void GetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties) {
1190    ALOGV("TODO: vk%s", __FUNCTION__);
1191}
1192
1193void GetPhysicalDeviceSparseImageFormatProperties2KHR(VkPhysicalDevice physicalDevice,
1194                                                      VkPhysicalDeviceSparseImageFormatInfo2KHR const* pInfo,
1195                                                      unsigned int* pNumProperties,
1196                                                      VkSparseImageFormatProperties2KHR* pProperties) {
1197    ALOGV("TODO: vk%s", __FUNCTION__);
1198}
1199
1200
1201VkResult QueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence) {
1202    ALOGV("TODO: vk%s", __FUNCTION__);
1203    return VK_SUCCESS;
1204}
1205
1206void DestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* allocator) {
1207}
1208
1209VkResult ResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences) {
1210    return VK_SUCCESS;
1211}
1212
1213VkResult GetFenceStatus(VkDevice device, VkFence fence) {
1214    ALOGV("TODO: vk%s", __FUNCTION__);
1215    return VK_SUCCESS;
1216}
1217
1218VkResult WaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout) {
1219    return VK_SUCCESS;
1220}
1221
1222void DestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* allocator) {
1223}
1224
1225void DestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* allocator) {
1226}
1227
1228VkResult GetEventStatus(VkDevice device, VkEvent event) {
1229    ALOGV("TODO: vk%s", __FUNCTION__);
1230    return VK_SUCCESS;
1231}
1232
1233VkResult SetEvent(VkDevice device, VkEvent event) {
1234    ALOGV("TODO: vk%s", __FUNCTION__);
1235    return VK_SUCCESS;
1236}
1237
1238VkResult ResetEvent(VkDevice device, VkEvent event) {
1239    ALOGV("TODO: vk%s", __FUNCTION__);
1240    return VK_SUCCESS;
1241}
1242
1243void DestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* allocator) {
1244}
1245
1246VkResult GetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) {
1247    ALOGV("TODO: vk%s", __FUNCTION__);
1248    return VK_SUCCESS;
1249}
1250
1251void DestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* allocator) {
1252}
1253
1254void GetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) {
1255    ALOGV("TODO: vk%s", __FUNCTION__);
1256}
1257
1258void DestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* allocator) {
1259}
1260
1261void DestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* allocator) {
1262}
1263
1264void DestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* allocator) {
1265}
1266
1267VkResult GetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData) {
1268    ALOGV("TODO: vk%s", __FUNCTION__);
1269    return VK_SUCCESS;
1270}
1271
1272VkResult MergePipelineCaches(VkDevice device, VkPipelineCache destCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches) {
1273    ALOGV("TODO: vk%s", __FUNCTION__);
1274    return VK_SUCCESS;
1275}
1276
1277void DestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* allocator) {
1278}
1279
1280void DestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* allocator) {
1281}
1282
1283void DestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* allocator) {
1284}
1285
1286void DestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* allocator) {
1287}
1288
1289void DestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* allocator) {
1290}
1291
1292VkResult ResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) {
1293    ALOGV("TODO: vk%s", __FUNCTION__);
1294    return VK_SUCCESS;
1295}
1296
1297void UpdateDescriptorSets(VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies) {
1298    ALOGV("TODO: vk%s", __FUNCTION__);
1299}
1300
1301VkResult FreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets) {
1302    ALOGV("TODO: vk%s", __FUNCTION__);
1303    return VK_SUCCESS;
1304}
1305
1306void DestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* allocator) {
1307}
1308
1309void DestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* allocator) {
1310}
1311
1312void GetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) {
1313    ALOGV("TODO: vk%s", __FUNCTION__);
1314}
1315
1316VkResult ResetCommandPool(VkDevice device, VkCommandPool cmdPool, VkCommandPoolResetFlags flags) {
1317    ALOGV("TODO: vk%s", __FUNCTION__);
1318    return VK_SUCCESS;
1319}
1320
1321VkResult BeginCommandBuffer(VkCommandBuffer cmdBuffer, const VkCommandBufferBeginInfo* pBeginInfo) {
1322    return VK_SUCCESS;
1323}
1324
1325VkResult EndCommandBuffer(VkCommandBuffer cmdBuffer) {
1326    return VK_SUCCESS;
1327}
1328
1329VkResult ResetCommandBuffer(VkCommandBuffer cmdBuffer, VkCommandBufferResetFlags flags) {
1330    ALOGV("TODO: vk%s", __FUNCTION__);
1331    return VK_SUCCESS;
1332}
1333
1334void CmdBindPipeline(VkCommandBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) {
1335}
1336
1337void CmdSetViewport(VkCommandBuffer cmdBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports) {
1338}
1339
1340void CmdSetScissor(VkCommandBuffer cmdBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors) {
1341}
1342
1343void CmdSetLineWidth(VkCommandBuffer cmdBuffer, float lineWidth) {
1344}
1345
1346void CmdSetDepthBias(VkCommandBuffer cmdBuffer, float depthBias, float depthBiasClamp, float slopeScaledDepthBias) {
1347}
1348
1349void CmdSetBlendConstants(VkCommandBuffer cmdBuffer, const float blendConst[4]) {
1350}
1351
1352void CmdSetDepthBounds(VkCommandBuffer cmdBuffer, float minDepthBounds, float maxDepthBounds) {
1353}
1354
1355void CmdSetStencilCompareMask(VkCommandBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilCompareMask) {
1356}
1357
1358void CmdSetStencilWriteMask(VkCommandBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilWriteMask) {
1359}
1360
1361void CmdSetStencilReference(VkCommandBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilReference) {
1362}
1363
1364void CmdBindDescriptorSets(VkCommandBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) {
1365}
1366
1367void CmdBindIndexBuffer(VkCommandBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) {
1368}
1369
1370void CmdBindVertexBuffers(VkCommandBuffer cmdBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) {
1371}
1372
1373void CmdDraw(VkCommandBuffer cmdBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) {
1374}
1375
1376void CmdDrawIndexed(VkCommandBuffer cmdBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) {
1377}
1378
1379void CmdDrawIndirect(VkCommandBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride) {
1380}
1381
1382void CmdDrawIndexedIndirect(VkCommandBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride) {
1383}
1384
1385void CmdDispatch(VkCommandBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z) {
1386}
1387
1388void CmdDispatchIndirect(VkCommandBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset) {
1389}
1390
1391void CmdCopyBuffer(VkCommandBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) {
1392}
1393
1394void CmdCopyImage(VkCommandBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) {
1395}
1396
1397void CmdBlitImage(VkCommandBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) {
1398}
1399
1400void CmdCopyBufferToImage(VkCommandBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) {
1401}
1402
1403void CmdCopyImageToBuffer(VkCommandBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) {
1404}
1405
1406void CmdUpdateBuffer(VkCommandBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const void* pData) {
1407}
1408
1409void CmdFillBuffer(VkCommandBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, uint32_t data) {
1410}
1411
1412void CmdClearColorImage(VkCommandBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
1413}
1414
1415void CmdClearDepthStencilImage(VkCommandBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
1416}
1417
1418void CmdClearAttachments(VkCommandBuffer cmdBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) {
1419}
1420
1421void CmdResolveImage(VkCommandBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) {
1422}
1423
1424void CmdSetEvent(VkCommandBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
1425}
1426
1427void CmdResetEvent(VkCommandBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
1428}
1429
1430void CmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) {
1431}
1432
1433void CmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) {
1434}
1435
1436void CmdBeginQuery(VkCommandBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags) {
1437}
1438
1439void CmdEndQuery(VkCommandBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot) {
1440}
1441
1442void CmdResetQueryPool(VkCommandBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount) {
1443}
1444
1445void CmdWriteTimestamp(VkCommandBuffer cmdBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t slot) {
1446}
1447
1448void CmdCopyQueryPoolResults(VkCommandBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize destStride, VkQueryResultFlags flags) {
1449}
1450
1451void CmdPushConstants(VkCommandBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t start, uint32_t length, const void* values) {
1452}
1453
1454void CmdBeginRenderPass(VkCommandBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) {
1455}
1456
1457void CmdNextSubpass(VkCommandBuffer cmdBuffer, VkSubpassContents contents) {
1458}
1459
1460void CmdEndRenderPass(VkCommandBuffer cmdBuffer) {
1461}
1462
1463void CmdExecuteCommands(VkCommandBuffer cmdBuffer, uint32_t cmdBuffersCount, const VkCommandBuffer* pCmdBuffers) {
1464}
1465
1466void DestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator) {
1467}
1468
1469void DebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage) {
1470}
1471
1472#pragma clang diagnostic pop
1473// clang-format on
1474
1475}  // namespace null_driver
1476