diff --git a/driver/ConsecutivePoolAllocator.c b/driver/ConsecutivePoolAllocator.c index 35a710a..a2e7ad9 100644 --- a/driver/ConsecutivePoolAllocator.c +++ b/driver/ConsecutivePoolAllocator.c @@ -119,9 +119,20 @@ void consecutivePoolFree(ConsecutivePoolAllocator* pa, void* p, uint32_t numBloc return; } + int counter = 0; + //somewhere the linked list may point after the free block (or null), we need to correct this for(uint32_t* nextFreeBlockCandidate = pa->nextFreeBlock; nextFreeBlockCandidate; nextFreeBlockCandidate = (uint32_t*)*nextFreeBlockCandidate) { + //TODO infinite loop + counter++; + + if(counter > 100) + { + printf("--------------detected infinite loop nextFreeCandidate: %p, *nextfreecandidate: %p, p: %p\n", nextFreeBlockCandidate, *nextFreeBlockCandidate, p); + break; + } + if((void*)*nextFreeBlockCandidate > p || !*nextFreeBlockCandidate) { for(uint32_t c = 0; c < numBlocks - 1; ++c) diff --git a/driver/command.c b/driver/command.c index 909f9fd..3204d41 100644 --- a/driver/command.c +++ b/driver/command.c @@ -379,7 +379,7 @@ VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers( for(int c = 0; c < commandBufferCount; ++c) { - //if(cp->usePoolAllocator) + if(pCommandBuffers[c]) { consecutivePoolFree(&cp->cpa, &pCommandBuffers[c]->binCl, pCommandBuffers[c]->binCl.numBlocks); consecutivePoolFree(&cp->cpa, &pCommandBuffers[c]->handlesCl, pCommandBuffers[c]->handlesCl.numBlocks); @@ -402,11 +402,10 @@ VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool( const VkAllocationCallbacks* pAllocator) { assert(device); - assert(commandPool); _commandPool* cp = (_commandPool*)commandPool; - //if(cp->usePoolAllocator) + if(cp) { FREE(cp->pa.buf); FREE(cp->cpa.buf); diff --git a/driver/common.c b/driver/common.c index 586f069..a652f71 100644 --- a/driver/common.c +++ b/driver/common.c @@ -8,11 +8,112 @@ uint32_t getFormatBpp(VkFormat f) { switch(f) { + case VK_FORMAT_R64G64B64_UINT: //padded to 256 + case VK_FORMAT_R64G64B64_SINT: + case VK_FORMAT_R64G64B64_SFLOAT: + case VK_FORMAT_R64G64B64A64_UINT: + case VK_FORMAT_R64G64B64A64_SINT: + case VK_FORMAT_R64G64B64A64_SFLOAT: + return 256; + case VK_FORMAT_R32G32B32_UINT: //padded to 128 + case VK_FORMAT_R32G32B32_SINT: + case VK_FORMAT_R32G32B32_SFLOAT: + case VK_FORMAT_R32G32B32A32_UINT: + case VK_FORMAT_R32G32B32A32_SINT: + case VK_FORMAT_R32G32B32A32_SFLOAT: + case VK_FORMAT_R64G64_UINT: + case VK_FORMAT_R64G64_SINT: + case VK_FORMAT_R64G64_SFLOAT: + return 128; case VK_FORMAT_R16G16B16A16_SFLOAT: + case VK_FORMAT_R16G16B16_UNORM: //padded to 64 + case VK_FORMAT_R16G16B16_SNORM: //padded to 64 + case VK_FORMAT_R16G16B16_USCALED: //padded to 64 + case VK_FORMAT_R16G16B16_SSCALED: //padded to 64 + case VK_FORMAT_R16G16B16_UINT: //padded to 64 + case VK_FORMAT_R16G16B16_SINT: //padded to 64 + case VK_FORMAT_R16G16B16_SFLOAT: //padded to 64 + case VK_FORMAT_R16G16B16A16_UNORM: + case VK_FORMAT_R16G16B16A16_SNORM: + case VK_FORMAT_R16G16B16A16_USCALED: + case VK_FORMAT_R16G16B16A16_SSCALED: + case VK_FORMAT_R16G16B16A16_UINT: + case VK_FORMAT_R16G16B16A16_SINT: + case VK_FORMAT_R32G32_UINT: + case VK_FORMAT_R32G32_SINT: + case VK_FORMAT_R32G32_SFLOAT: + case VK_FORMAT_R64_UINT: + case VK_FORMAT_R64_SINT: + case VK_FORMAT_R64_SFLOAT: + case VK_FORMAT_D32_SFLOAT_S8_UINT: //padded to 64 + case VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16: + case VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16: return 64; case VK_FORMAT_R8G8B8_UNORM: //padded to 32 case VK_FORMAT_R8G8B8A8_UNORM: - return 32; + case VK_FORMAT_R32_UINT: + case VK_FORMAT_R8G8B8A8_UINT: + case VK_FORMAT_D32_SFLOAT: + case VK_FORMAT_R8G8B8_SNORM: //padded to 32 + case VK_FORMAT_R8G8B8_USCALED: //padded to 32 + case VK_FORMAT_R8G8B8_SSCALED: //padded to 32 + case VK_FORMAT_R8G8B8_UINT: //padded to 32 + case VK_FORMAT_R8G8B8_SINT: //padded to 32 + case VK_FORMAT_R8G8B8_SRGB: //padded to 32 + case VK_FORMAT_B8G8R8_UNORM: //padded to 32 + case VK_FORMAT_B8G8R8_SNORM: //padded to 32 + case VK_FORMAT_B8G8R8_USCALED: //padded to 32 + case VK_FORMAT_B8G8R8_SSCALED: //padded to 32 + case VK_FORMAT_B8G8R8_UINT: //padded to 32 + case VK_FORMAT_B8G8R8_SINT: //padded to 32 + case VK_FORMAT_B8G8R8_SRGB: //padded to 32 + case VK_FORMAT_R8G8B8A8_SNORM: + case VK_FORMAT_R8G8B8A8_USCALED: + case VK_FORMAT_R8G8B8A8_SSCALED: + case VK_FORMAT_R8G8B8A8_SINT: + case VK_FORMAT_R8G8B8A8_SRGB: + case VK_FORMAT_B8G8R8A8_UNORM: + case VK_FORMAT_B8G8R8A8_SNORM: + case VK_FORMAT_B8G8R8A8_USCALED: + case VK_FORMAT_B8G8R8A8_SSCALED: + case VK_FORMAT_B8G8R8A8_UINT: + case VK_FORMAT_B8G8R8A8_SINT: + case VK_FORMAT_B8G8R8A8_SRGB: + case VK_FORMAT_A8B8G8R8_UNORM_PACK32: + case VK_FORMAT_A8B8G8R8_SNORM_PACK32: + case VK_FORMAT_A8B8G8R8_USCALED_PACK32: + case VK_FORMAT_A8B8G8R8_SSCALED_PACK32: + case VK_FORMAT_A8B8G8R8_UINT_PACK32: + case VK_FORMAT_A8B8G8R8_SINT_PACK32: + case VK_FORMAT_A8B8G8R8_SRGB_PACK32: + case VK_FORMAT_A2R10G10B10_UNORM_PACK32: + case VK_FORMAT_A2R10G10B10_SNORM_PACK32: + case VK_FORMAT_A2R10G10B10_USCALED_PACK32: + case VK_FORMAT_A2R10G10B10_SSCALED_PACK32: + case VK_FORMAT_A2R10G10B10_UINT_PACK32: + case VK_FORMAT_A2R10G10B10_SINT_PACK32: + case VK_FORMAT_A2B10G10R10_UNORM_PACK32: + case VK_FORMAT_A2B10G10R10_SNORM_PACK32: + case VK_FORMAT_A2B10G10R10_USCALED_PACK32: + case VK_FORMAT_A2B10G10R10_SSCALED_PACK32: + case VK_FORMAT_A2B10G10R10_UINT_PACK32: + case VK_FORMAT_A2B10G10R10_SINT_PACK32: + case VK_FORMAT_R16G16_UNORM: + case VK_FORMAT_R16G16_SNORM: + case VK_FORMAT_R16G16_USCALED: + case VK_FORMAT_R16G16_SSCALED: + case VK_FORMAT_R16G16_UINT: + case VK_FORMAT_R16G16_SINT: + case VK_FORMAT_R16G16_SFLOAT: + case VK_FORMAT_R32_SINT: + case VK_FORMAT_R32_SFLOAT: + case VK_FORMAT_B10G11R11_UFLOAT_PACK32: + case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32: + case VK_FORMAT_X8_D24_UNORM_PACK32: + case VK_FORMAT_D16_UNORM_S8_UINT: //padded to 32 + case VK_FORMAT_D24_UNORM_S8_UINT: + case VK_FORMAT_R10X6G10X6_UNORM_2PACK16: + case VK_FORMAT_R12X4G12X4_UNORM_2PACK16: return 32; case VK_FORMAT_R5G5B5A1_UNORM_PACK16: case VK_FORMAT_R4G4B4A4_UNORM_PACK16: @@ -21,9 +122,34 @@ uint32_t getFormatBpp(VkFormat f) case VK_FORMAT_R16_SFLOAT: case VK_FORMAT_R16_SINT: case VK_FORMAT_D16_UNORM: + case VK_FORMAT_B4G4R4A4_UNORM_PACK16: + case VK_FORMAT_B5G6R5_UNORM_PACK16: + case VK_FORMAT_B5G5R5A1_UNORM_PACK16: + case VK_FORMAT_A1R5G5B5_UNORM_PACK16: + case VK_FORMAT_R8G8_SNORM: + case VK_FORMAT_R8G8_USCALED: + case VK_FORMAT_R8G8_SSCALED: + case VK_FORMAT_R8G8_UINT: + case VK_FORMAT_R8G8_SINT: + case VK_FORMAT_R8G8_SRGB: + case VK_FORMAT_R16_UNORM: + case VK_FORMAT_R16_SNORM: + case VK_FORMAT_R16_USCALED: + case VK_FORMAT_R16_SSCALED: + case VK_FORMAT_R16_UINT: + case VK_FORMAT_R10X6_UNORM_PACK16: + case VK_FORMAT_R12X4_UNORM_PACK16: return 16; case VK_FORMAT_R8_UNORM: case VK_FORMAT_R8_SINT: + case VK_FORMAT_S8_UINT: + case VK_FORMAT_R4G4_UNORM_PACK8: + case VK_FORMAT_R8_SNORM: + case VK_FORMAT_R8_USCALED: + case VK_FORMAT_R8_SSCALED: + case VK_FORMAT_R8_UINT: + case VK_FORMAT_R8_SRGB: + case VK_FORMAT_UNDEFINED: //TODO return 8; default:// printf("format %i\n", f); @@ -108,6 +234,18 @@ void getPaddedTextureDimensionsT(uint32_t width, uint32_t height, uint32_t bpp, switch(bpp) { + case 256: + { + tileW = 8; + tileH = 16; + break; + } + case 128: + { + tileW = 16; + tileH = 16; + break; + } case 64: { tileW = 16; @@ -576,6 +714,48 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties( VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) { + assert(physicalDevice); + assert(pImageFormatProperties); + + for(uint32_t c = 0; c < numUnsupportedFormats; ++c) + { + if(format == unsupportedFormats[c]) + { + return VK_ERROR_FORMAT_NOT_SUPPORTED; + } + } + + pImageFormatProperties->maxArrayLayers = _limits.maxImageArrayLayers; + + pImageFormatProperties->maxExtent.width = 1; + pImageFormatProperties->maxExtent.height = 1; + pImageFormatProperties->maxExtent.depth = 1; + + if(type == VK_IMAGE_TYPE_1D) + { + pImageFormatProperties->maxExtent.width = _limits.maxImageDimension1D; + pImageFormatProperties->maxMipLevels = ulog2(_limits.maxImageDimension1D); + } + else if(type == VK_IMAGE_TYPE_2D) + { + pImageFormatProperties->maxExtent.width = _limits.maxImageDimension2D; + pImageFormatProperties->maxExtent.height = _limits.maxImageDimension2D; + pImageFormatProperties->maxMipLevels = ulog2(_limits.maxImageDimension2D); + } + else + { + pImageFormatProperties->maxExtent.width = _limits.maxImageDimension3D; + pImageFormatProperties->maxExtent.height = _limits.maxImageDimension3D; + pImageFormatProperties->maxExtent.depth = _limits.maxImageDimension3D; + pImageFormatProperties->maxMipLevels = ulog2(_limits.maxImageDimension3D); + } + + //TODO real max size? + //2^31 + pImageFormatProperties->maxResourceSize = 0x7fffffff; + + pImageFormatProperties->sampleCounts = _limits.framebufferColorSampleCounts; + return VK_SUCCESS; } @@ -990,7 +1170,19 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2( const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties) { - return VK_SUCCESS; + assert(physicalDevice); + assert(pImageFormatProperties); + assert(pImageFormatInfo); + + //TODO + + return vkGetPhysicalDeviceImageFormatProperties(physicalDevice, + pImageFormatInfo->format, + pImageFormatInfo->type, + pImageFormatInfo->tiling, + pImageFormatInfo->usage, + pImageFormatInfo->flags, + &pImageFormatProperties->imageFormatProperties); } VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2( @@ -1093,7 +1285,11 @@ VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2( const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) { + assert(device); + assert(pInfo); + assert(pMemoryRequirements); + vkGetBufferMemoryRequirements(device, pInfo->buffer, &pMemoryRequirements->memoryRequirements); } VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2( diff --git a/driver/device.c b/driver/device.c index 5b5271c..f8d7b19 100644 --- a/driver/device.c +++ b/driver/device.c @@ -320,14 +320,16 @@ VKAPI_ATTR void VKAPI_CALL vkDestroyDevice( VkDevice device, const VkAllocationCallbacks* pAllocator) { - assert(device); - _device* dev = device; - for(int c = 0; c < numQueueFamilies; ++c) + + if(dev) { - for(int d = 0; d < dev->numQueues[c]; ++d) + for(int c = 0; c < numQueueFamilies; ++c) { - FREE(dev->queues[d]); + for(int d = 0; d < dev->numQueues[c]; ++d) + { + FREE(dev->queues[d]); + } } } diff --git a/driver/instance.c b/driver/instance.c index 94d5ec5..bddd31c 100644 --- a/driver/instance.c +++ b/driver/instance.c @@ -124,8 +124,6 @@ VKAPI_ATTR void VKAPI_CALL vkDestroyInstance( VkInstance instance, const VkAllocationCallbacks* pAllocator) { - assert(instance); - closeIoctl(); FREE(instance); diff --git a/driver/memory.c b/driver/memory.c index a57eb92..accfd26 100644 --- a/driver/memory.c +++ b/driver/memory.c @@ -39,7 +39,7 @@ void vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhys //all heaps share the same memory for(int c = 0; c < numMemoryHeaps; ++c) { - memoryHeaps[c].size = amount; + memoryHeaps[c].size = amount * 1000; //kB to B } } @@ -134,15 +134,20 @@ void vkUnmapMemory(VkDevice device, VkDeviceMemory memory) assert(memory); vc4_bo_unmap_unsynchronized(controlFd, ((_deviceMemory*)memory)->mappedPtr, ((_deviceMemory*)memory)->mappedSize); + ((_deviceMemory*)memory)->mappedPtr = 0; + ((_deviceMemory*)memory)->mappedSize = 0; + ((_deviceMemory*)memory)->mappedOffset = 0; } void vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator) { assert(device); - assert(memory); _deviceMemory* mem = memory; - vc4_bo_free(controlFd, mem->bo, mem->mappedPtr, mem->size); + if(mem) + { + vc4_bo_free(controlFd, mem->bo, mem->mappedPtr, mem->size); + } FREE(mem); } diff --git a/driver/pipeline.c b/driver/pipeline.c index 43108a9..3948f2c 100644 --- a/driver/pipeline.c +++ b/driver/pipeline.c @@ -177,20 +177,22 @@ VkResult vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCach void vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator) { assert(device); - assert(pipeline); _pipeline* pip = pipeline; - FREE(pip->dynamicStates); - FREE(pip->attachmentBlendStates); - FREE(pip->scissors); - FREE(pip->viewports); - FREE(pip->vertexBindingDescriptions); - FREE(pip->vertexAttributeDescriptions); - - for(int c = 0; c < 6; ++c) + if(pip) { - FREE(pip->names[c]); + FREE(pip->dynamicStates); + FREE(pip->attachmentBlendStates); + FREE(pip->scissors); + FREE(pip->viewports); + FREE(pip->vertexBindingDescriptions); + FREE(pip->vertexAttributeDescriptions); + + for(int c = 0; c < 6; ++c) + { + FREE(pip->names[c]); + } } FREE(pip); diff --git a/driver/renderpass.c b/driver/renderpass.c index 4e7fa65..08a126a 100644 --- a/driver/renderpass.c +++ b/driver/renderpass.c @@ -184,25 +184,27 @@ VkResult vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCrea void vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator) { assert(device); - assert(renderPass); _renderpass* rp = renderPass; - FREE(rp->subpassDependencies); - - for(int c = 0; c < rp->numSubpasses; ++c) + if(rp) { - FREE(rp->subpasses[c].pInputAttachments); - FREE(rp->subpasses[c].pColorAttachments); - FREE(rp->subpasses[c].pResolveAttachments); - FREE(rp->subpasses[c].pDepthStencilAttachment); - FREE(rp->subpasses[c].pPreserveAttachments); + FREE(rp->subpassDependencies); + + for(int c = 0; c < rp->numSubpasses; ++c) + { + FREE(rp->subpasses[c].pInputAttachments); + FREE(rp->subpasses[c].pColorAttachments); + FREE(rp->subpasses[c].pResolveAttachments); + FREE(rp->subpasses[c].pDepthStencilAttachment); + FREE(rp->subpasses[c].pPreserveAttachments); + } + + FREE(rp->subpasses); + + FREE(rp->attachments); } - FREE(rp->subpasses); - - FREE(rp->attachments); - FREE(rp); } @@ -251,10 +253,13 @@ VkResult vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCr void vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator) { assert(device); - assert(framebuffer); _framebuffer* fb = framebuffer; - FREE(fb->attachmentViews); + if(fb) + { + FREE(fb->attachmentViews); + } + FREE(fb); } diff --git a/driver/resource.c b/driver/resource.c index 5697a37..729058c 100644 --- a/driver/resource.c +++ b/driver/resource.c @@ -67,7 +67,7 @@ void vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryReq assert(pMemoryRequirements); pMemoryRequirements->alignment = ((_buffer*)buffer)->alignment; - pMemoryRequirements->size = ((_buffer*)buffer)->alignedSize; + pMemoryRequirements->size = getBOAlignedSize(((_buffer*)buffer)->size); pMemoryRequirements->memoryTypeBits = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT; //TODO } @@ -97,7 +97,6 @@ VkResult vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem void vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator) { assert(device); - assert(buffer); _buffer* buf = buffer; FREE(buf); @@ -106,7 +105,6 @@ void vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbac void vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator) { assert(device); - assert(imageView); _imageView* view = imageView; FREE(view); @@ -152,7 +150,6 @@ VKAPI_ATTR void VKAPI_CALL vkDestroyBufferView( const VkAllocationCallbacks* pAllocator) { assert(device); - assert(bufferView); _bufferView* bv = bufferView; FREE(bv); @@ -232,12 +229,16 @@ VKAPI_ATTR void VKAPI_CALL vkDestroyImage( const VkAllocationCallbacks* pAllocator) { assert(device); - assert(image); _image* i = image; - if(i->numQueueFamiliesWithAccess > 0); - FREE(i->queueFamiliesWithAccess); + if(i) + { + if(i->numQueueFamiliesWithAccess > 0) + { + FREE(i->queueFamiliesWithAccess); + } + } FREE(i); } diff --git a/driver/shader.c b/driver/shader.c index 8a5380f..7055a9a 100644 --- a/driver/shader.c +++ b/driver/shader.c @@ -48,15 +48,17 @@ VkResult vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* p void vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator) { assert(device); - assert(shaderModule); _shaderModule* shader = shaderModule; - for(int c = 0; c < VK_RPI_ASSEMBLY_TYPE_MAX; ++c) + if(shader) { - if(shader->bos[c]) + for(int c = 0; c < VK_RPI_ASSEMBLY_TYPE_MAX; ++c) { - vc4_bo_free(controlFd, shader->bos[c], 0, shader->sizes[c]); + if(shader->bos[c]) + { + vc4_bo_free(controlFd, shader->bos[c], 0, shader->sizes[c]); + } } } diff --git a/driver/sync.c b/driver/sync.c index 1fb54cc..418052f 100644 --- a/driver/sync.c +++ b/driver/sync.c @@ -276,9 +276,11 @@ VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore( const VkAllocationCallbacks* pAllocator) { assert(device); - assert(semaphore); - sem_destroy((sem_t*)semaphore); + if(semaphore) + { + sem_destroy((sem_t*)semaphore); + } FREE(semaphore); } @@ -320,7 +322,6 @@ VKAPI_ATTR void VKAPI_CALL vkDestroyFence( const VkAllocationCallbacks* pAllocator) { assert(device); - assert(fence); FREE(fence); } diff --git a/driver/vkCaps.h b/driver/vkCaps.h index 716afcf..f1bc5ca 100644 --- a/driver/vkCaps.h +++ b/driver/vkCaps.h @@ -284,4 +284,99 @@ static VkMemoryHeap memoryHeaps[] = }; #define numMemoryHeaps (sizeof(memoryHeaps) / sizeof(VkMemoryHeap)) +static VkFormat unsupportedFormats[] = +{ + VK_FORMAT_BC1_RGB_UNORM_BLOCK, //bc formats + VK_FORMAT_BC1_RGB_SRGB_BLOCK, + VK_FORMAT_BC1_RGBA_UNORM_BLOCK, + VK_FORMAT_BC1_RGBA_SRGB_BLOCK, + VK_FORMAT_BC2_UNORM_BLOCK, + VK_FORMAT_BC2_SRGB_BLOCK, + VK_FORMAT_BC3_UNORM_BLOCK, + VK_FORMAT_BC3_SRGB_BLOCK, + VK_FORMAT_BC4_UNORM_BLOCK, + VK_FORMAT_BC4_SNORM_BLOCK, + VK_FORMAT_BC5_UNORM_BLOCK, + VK_FORMAT_BC5_SNORM_BLOCK, + VK_FORMAT_BC6H_UFLOAT_BLOCK, + VK_FORMAT_BC6H_SFLOAT_BLOCK, + VK_FORMAT_BC7_UNORM_BLOCK, + VK_FORMAT_BC7_SRGB_BLOCK, + VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK, //etc2 formats + VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK, + VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK, + VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK, + VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK, + VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK, + VK_FORMAT_EAC_R11_UNORM_BLOCK, //eac formats + VK_FORMAT_EAC_R11_SNORM_BLOCK, + VK_FORMAT_EAC_R11G11_UNORM_BLOCK, + VK_FORMAT_EAC_R11G11_SNORM_BLOCK, + VK_FORMAT_ASTC_4x4_UNORM_BLOCK, //astc formats + VK_FORMAT_ASTC_4x4_SRGB_BLOCK, + VK_FORMAT_ASTC_5x4_UNORM_BLOCK, + VK_FORMAT_ASTC_5x4_SRGB_BLOCK, + VK_FORMAT_ASTC_5x5_UNORM_BLOCK, + VK_FORMAT_ASTC_5x5_SRGB_BLOCK, + VK_FORMAT_ASTC_6x5_UNORM_BLOCK, + VK_FORMAT_ASTC_6x5_SRGB_BLOCK, + VK_FORMAT_ASTC_6x6_UNORM_BLOCK, + VK_FORMAT_ASTC_6x6_SRGB_BLOCK, + VK_FORMAT_ASTC_8x5_UNORM_BLOCK, + VK_FORMAT_ASTC_8x5_SRGB_BLOCK, + VK_FORMAT_ASTC_8x6_UNORM_BLOCK, + VK_FORMAT_ASTC_8x6_SRGB_BLOCK, + VK_FORMAT_ASTC_8x8_UNORM_BLOCK, + VK_FORMAT_ASTC_8x8_SRGB_BLOCK, + VK_FORMAT_ASTC_10x5_UNORM_BLOCK, + VK_FORMAT_ASTC_10x5_SRGB_BLOCK, + VK_FORMAT_ASTC_10x6_UNORM_BLOCK, + VK_FORMAT_ASTC_10x6_SRGB_BLOCK, + VK_FORMAT_ASTC_10x8_UNORM_BLOCK, + VK_FORMAT_ASTC_10x8_SRGB_BLOCK, + VK_FORMAT_ASTC_10x10_UNORM_BLOCK, + VK_FORMAT_ASTC_10x10_SRGB_BLOCK, + VK_FORMAT_ASTC_12x10_UNORM_BLOCK, + VK_FORMAT_ASTC_12x10_SRGB_BLOCK, + VK_FORMAT_ASTC_12x12_UNORM_BLOCK, + VK_FORMAT_ASTC_12x12_SRGB_BLOCK, + VK_FORMAT_G8B8G8R8_422_UNORM, //TODO yuv formats??? + VK_FORMAT_B8G8R8G8_422_UNORM, + VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM, + VK_FORMAT_G8_B8R8_2PLANE_420_UNORM, + VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM, + VK_FORMAT_G8_B8R8_2PLANE_422_UNORM, + VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM, + VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16, + VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16, + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16, + VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16, + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16, + VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16, + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16, + VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16, + VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16, + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16, + VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16, + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16, + VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16, + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16, + VK_FORMAT_G16B16G16R16_422_UNORM, + VK_FORMAT_B16G16R16G16_422_UNORM, + VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, + VK_FORMAT_G16_B16R16_2PLANE_420_UNORM, + VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM, + VK_FORMAT_G16_B16R16_2PLANE_422_UNORM, + VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM, + VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG, //pvrtc formats + VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG, + VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG, + VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG, + VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG, + VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG, + VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG, + VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG +}; +#define numUnsupportedFormats (sizeof(unsupportedFormats)/sizeof(VkFormat)) + #define VK_DRIVER_VERSION VK_MAKE_VERSION(1, 1, 0) diff --git a/driver/wsi.c b/driver/wsi.c index 84c2878..c057914 100644 --- a/driver/wsi.c +++ b/driver/wsi.c @@ -35,11 +35,13 @@ VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR( const VkAllocationCallbacks* pAllocator) { assert(instance); - assert(surface); //TODO use allocator - modeset_destroy(controlFd, (modeset_dev*)surface); + if(surface) + { + modeset_destroy(controlFd, (modeset_dev*)surface); + } } /* @@ -397,19 +399,22 @@ VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR( const VkAllocationCallbacks* pAllocator) { assert(device); - assert(swapchain); //TODO flush all ops _swapchain* s = swapchain; - for(int c = 0; c < s->numImages; ++c) + if(s) { - vkFreeMemory(device, s->images[c].boundMem, 0); - modeset_destroy_fb(controlFd, &s->images[c]); + for(int c = 0; c < s->numImages; ++c) + { + vkFreeMemory(device, s->images[c].boundMem, 0); + modeset_destroy_fb(controlFd, &s->images[c]); + } + + FREE(s->images); } - FREE(s->images); FREE(s); }