rooty/rpi-vk-driver
1
0
Fork 0
mirror of https://github.com/Yours3lf/rpi-vk-driver.git synced 2025-02-26 23:54:17 +01:00
Code Issues Releases Wiki Activity

loads of CTS fixeeees

Browse Source
This commit is contained in:
Unknown 2019-02-09 16:18:15 +00:00
parent 60d31572e4
commit 689eb72cff
13 changed files with 383 additions and 61 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
driver/ConsecutivePoolAllocator.c
View File

@ -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)

5
driver/command.c
View File

@ -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);

200
driver/common.c
View File

@ -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(

12
driver/device.c
View File

@ -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]);
}
}
}

2
driver/instance.c
View File

@ -124,8 +124,6 @@ VKAPI_ATTR void VKAPI_CALL vkDestroyInstance(
VkInstance instance,
const VkAllocationCallbacks* pAllocator)
{
assert(instance);
closeIoctl();
FREE(instance);

11
driver/memory.c
View File

@ -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);
}

22
driver/pipeline.c
View File

@ -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);

35
driver/renderpass.c
View File

@ -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);
}

15
driver/resource.c
View File

@ -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);
}

10
driver/shader.c
View File

@ -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]);
}
}
}

7
driver/sync.c
View File

@ -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);
}

95
driver/vkCaps.h
View File

@ -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)

19
driver/wsi.c
View File

@ -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);
}