Add and apply .clang-format.
--- /dev/null
+BasedOnStyle: LLVM
+AlwaysBreakAfterReturnType: TopLevel
+BinPackParameters: false
+BraceWrapping:
+ AfterControlStatement: false
+ AfterEnum: true
+ AfterFunction: true
+ AfterStruct: true
+ BeforeElse: false
+ SplitEmptyFunction: true
+BreakBeforeBraces: Custom
+ColumnLimit: 78
+ContinuationIndentWidth: 3
+Cpp11BracedListStyle: false
+IncludeBlocks: Regroup
+IncludeCategories:
+ - Regex: '^"tu_private.h"$'
+ Priority: 0
+ - Regex: '^"(drm/|tu_)'
+ Priority: 4
+ - Regex: '^"(c11/|compiler/|main/|nir/|spirv/|util/|vk_)'
+ Priority: 3
+ - Regex: '^<(vulkan/)'
+ Priority: 2
+ - Regex: '.*'
+ Priority: 1
+IndentWidth: 3
+PenaltyBreakBeforeFirstCallParameter: 1
+PenaltyExcessCharacter: 100
+SpaceAfterCStyleCast: true
+SpaceBeforeCpp11BracedList: true
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
*/
+#include "tu_private.h"
+
#include <hardware/gralloc.h>
#include <hardware/hardware.h>
#include <hardware/hwvulkan.h>
#include <libsync.h>
+
#include <vulkan/vk_android_native_buffer.h>
#include <vulkan/vk_icd.h>
-#include "tu_private.h"
-
static int
tu_hal_open(const struct hw_module_t *mod,
const char *id,
VkResult result;
result = tu_image_create(
- device_h,
- &(struct tu_image_create_info){
- .vk_info = base_info, .scanout = true, .no_metadata_planes = true },
- alloc,
- &image_h);
+ device_h,
+ &(struct tu_image_create_info) {
+ .vk_info = base_info, .scanout = true, .no_metadata_planes = true },
+ alloc, &image_h);
if (result != VK_SUCCESS)
return result;
if (gralloc_info->handle->numFds != 1) {
- return vk_errorf(device->instance,
- VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR,
+ return vk_errorf(device->instance, VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR,
"VkNativeBufferANDROID::handle::numFds is %d, "
"expected 1",
gralloc_info->handle->numFds);
/* Find the first VRAM memory type, or GART for PRIME images. */
int memory_type_index = -1;
for (int i = 0;
- i < device->physical_device->memory_properties.memoryTypeCount;
- ++i) {
+ i < device->physical_device->memory_properties.memoryTypeCount; ++i) {
bool is_local =
- !!(device->physical_device->memory_properties.memoryTypes[i]
- .propertyFlags &
- VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
+ !!(device->physical_device->memory_properties.memoryTypes[i]
+ .propertyFlags &
+ VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
if (is_local) {
memory_type_index = i;
break;
memory_type_index = 0;
result =
- tu_AllocateMemory(device_h,
- &(VkMemoryAllocateInfo){
- .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
- .pNext = &import_info,
- .allocationSize = image->size,
- .memoryTypeIndex = memory_type_index,
+ tu_AllocateMemory(device_h,
+ &(VkMemoryAllocateInfo) {
+ .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
+ .pNext = &import_info,
+ .allocationSize = image->size,
+ .memoryTypeIndex = memory_type_index,
},
- alloc,
- &memory_h);
+ alloc, &memory_h);
if (result != VK_SUCCESS)
goto fail_create_image;
/* Check that requested format and usage are supported. */
result = tu_GetPhysicalDeviceImageFormatProperties2(
- phys_dev_h, &image_format_info, &image_format_props);
+ phys_dev_h, &image_format_info, &image_format_props);
if (result != VK_SUCCESS) {
- return vk_errorf(device->instance,
- result,
+ return vk_errorf(device->instance, result,
"tu_GetPhysicalDeviceImageFormatProperties2 failed "
"inside %s",
__func__);
}
- if (unmask32(&imageUsage,
- VK_IMAGE_USAGE_TRANSFER_DST_BIT |
- VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT))
+ if (unmask32(&imageUsage, VK_IMAGE_USAGE_TRANSFER_DST_BIT |
+ VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT))
*grallocUsage |= GRALLOC_USAGE_HW_RENDER;
- if (unmask32(&imageUsage,
- VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_SAMPLED_BIT |
- VK_IMAGE_USAGE_STORAGE_BIT |
- VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT))
+ if (unmask32(&imageUsage, VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
+ VK_IMAGE_USAGE_SAMPLED_BIT |
+ VK_IMAGE_USAGE_STORAGE_BIT |
+ VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT))
*grallocUsage |= GRALLOC_USAGE_HW_TEXTURE;
/* All VkImageUsageFlags not explicitly checked here are unsupported for
* gralloc swapchains.
*/
if (imageUsage != 0) {
- return vk_errorf(device->instance,
- VK_ERROR_FORMAT_NOT_SUPPORTED,
+ return vk_errorf(device->instance, VK_ERROR_FORMAT_NOT_SUPPORTED,
"unsupported VkImageUsageFlags(0x%x) for gralloc "
"swapchain",
imageUsage);
}
/*
- * FINISHME: Advertise all display-supported formats. Mostly
- * DRM_FORMAT_ARGB2101010 and DRM_FORMAT_ABGR2101010, but need to check
- * what we need for 30-bit colors.
- */
+ * FINISHME: Advertise all display-supported formats. Mostly
+ * DRM_FORMAT_ARGB2101010 and DRM_FORMAT_ABGR2101010, but need to check
+ * what we need for 30-bit colors.
+ */
if (format == VK_FORMAT_B8G8R8A8_UNORM ||
format == VK_FORMAT_B5G6R5_UNORM_PACK16) {
*grallocUsage |= GRALLOC_USAGE_HW_FB | GRALLOC_USAGE_HW_COMPOSER |
if (semaphore != VK_NULL_HANDLE) {
int semaphore_fd =
- nativeFenceFd >= 0 ? dup(nativeFenceFd) : nativeFenceFd;
+ nativeFenceFd >= 0 ? dup(nativeFenceFd) : nativeFenceFd;
semaphore_result = tu_ImportSemaphoreFdKHR(
- device,
- &(VkImportSemaphoreFdInfoKHR){
- .sType = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR,
- .flags = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR,
- .fd = semaphore_fd,
- .semaphore = semaphore,
- });
+ device, &(VkImportSemaphoreFdInfoKHR) {
+ .sType = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR,
+ .flags = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR,
+ .fd = semaphore_fd,
+ .semaphore = semaphore,
+ });
}
if (fence != VK_NULL_HANDLE) {
int fence_fd = nativeFenceFd >= 0 ? dup(nativeFenceFd) : nativeFenceFd;
fence_result = tu_ImportFenceFdKHR(
- device,
- &(VkImportFenceFdInfoKHR){
- .sType = VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR,
- .flags = VK_FENCE_IMPORT_TEMPORARY_BIT_KHR,
- .fd = fence_fd,
- .fence = fence,
- });
+ device, &(VkImportFenceFdInfoKHR) {
+ .sType = VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR,
+ .flags = VK_FENCE_IMPORT_TEMPORARY_BIT_KHR,
+ .fd = fence_fd,
+ .fence = fence,
+ });
}
close(nativeFenceFd);
for (uint32_t i = 0; i < waitSemaphoreCount; ++i) {
int tmp_fd;
result = tu_GetSemaphoreFdKHR(
- tu_device_to_handle(queue->device),
- &(VkSemaphoreGetFdInfoKHR){
- .sType = VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR,
- .handleType = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR,
- .semaphore = pWaitSemaphores[i],
- },
- &tmp_fd);
+ tu_device_to_handle(queue->device),
+ &(VkSemaphoreGetFdInfoKHR) {
+ .sType = VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR,
+ .handleType = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR,
+ .semaphore = pWaitSemaphores[i],
+ },
+ &tmp_fd);
if (result != VK_SUCCESS) {
if (fd >= 0)
close(fd);
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
*/
#include "tu_private.h"
+
#include "vk_format.h"
const struct tu_dynamic_state default_dynamic_state = {
dest->discard_rectangle.count = src->discard_rectangle.count;
if (copy_mask & TU_DYNAMIC_VIEWPORT) {
- if (memcmp(&dest->viewport.viewports,
- &src->viewport.viewports,
+ if (memcmp(&dest->viewport.viewports, &src->viewport.viewports,
src->viewport.count * sizeof(VkViewport))) {
- typed_memcpy(dest->viewport.viewports,
- src->viewport.viewports,
+ typed_memcpy(dest->viewport.viewports, src->viewport.viewports,
src->viewport.count);
dest_mask |= TU_DYNAMIC_VIEWPORT;
}
}
if (copy_mask & TU_DYNAMIC_SCISSOR) {
- if (memcmp(&dest->scissor.scissors,
- &src->scissor.scissors,
+ if (memcmp(&dest->scissor.scissors, &src->scissor.scissors,
src->scissor.count * sizeof(VkRect2D))) {
- typed_memcpy(
- dest->scissor.scissors, src->scissor.scissors, src->scissor.count);
+ typed_memcpy(dest->scissor.scissors, src->scissor.scissors,
+ src->scissor.count);
dest_mask |= TU_DYNAMIC_SCISSOR;
}
}
}
if (copy_mask & TU_DYNAMIC_DEPTH_BIAS) {
- if (memcmp(
- &dest->depth_bias, &src->depth_bias, sizeof(src->depth_bias))) {
+ if (memcmp(&dest->depth_bias, &src->depth_bias,
+ sizeof(src->depth_bias))) {
dest->depth_bias = src->depth_bias;
dest_mask |= TU_DYNAMIC_DEPTH_BIAS;
}
}
if (copy_mask & TU_DYNAMIC_BLEND_CONSTANTS) {
- if (memcmp(&dest->blend_constants,
- &src->blend_constants,
+ if (memcmp(&dest->blend_constants, &src->blend_constants,
sizeof(src->blend_constants))) {
typed_memcpy(dest->blend_constants, src->blend_constants, 4);
dest_mask |= TU_DYNAMIC_BLEND_CONSTANTS;
}
if (copy_mask & TU_DYNAMIC_DEPTH_BOUNDS) {
- if (memcmp(&dest->depth_bounds,
- &src->depth_bounds,
+ if (memcmp(&dest->depth_bounds, &src->depth_bounds,
sizeof(src->depth_bounds))) {
dest->depth_bounds = src->depth_bounds;
dest_mask |= TU_DYNAMIC_DEPTH_BOUNDS;
}
if (copy_mask & TU_DYNAMIC_STENCIL_COMPARE_MASK) {
- if (memcmp(&dest->stencil_compare_mask,
- &src->stencil_compare_mask,
+ if (memcmp(&dest->stencil_compare_mask, &src->stencil_compare_mask,
sizeof(src->stencil_compare_mask))) {
dest->stencil_compare_mask = src->stencil_compare_mask;
dest_mask |= TU_DYNAMIC_STENCIL_COMPARE_MASK;
}
if (copy_mask & TU_DYNAMIC_STENCIL_WRITE_MASK) {
- if (memcmp(&dest->stencil_write_mask,
- &src->stencil_write_mask,
+ if (memcmp(&dest->stencil_write_mask, &src->stencil_write_mask,
sizeof(src->stencil_write_mask))) {
dest->stencil_write_mask = src->stencil_write_mask;
dest_mask |= TU_DYNAMIC_STENCIL_WRITE_MASK;
}
if (copy_mask & TU_DYNAMIC_STENCIL_REFERENCE) {
- if (memcmp(&dest->stencil_reference,
- &src->stencil_reference,
+ if (memcmp(&dest->stencil_reference, &src->stencil_reference,
sizeof(src->stencil_reference))) {
dest->stencil_reference = src->stencil_reference;
dest_mask |= TU_DYNAMIC_STENCIL_REFERENCE;
VkCommandBuffer *pCommandBuffer)
{
struct tu_cmd_buffer *cmd_buffer;
- cmd_buffer = vk_zalloc(
- &pool->alloc, sizeof(*cmd_buffer), 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
+ cmd_buffer = vk_zalloc(&pool->alloc, sizeof(*cmd_buffer), 8,
+ VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (cmd_buffer == NULL)
return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
if (!list_empty(&pool->free_cmd_buffers)) {
struct tu_cmd_buffer *cmd_buffer = list_first_entry(
- &pool->free_cmd_buffers, struct tu_cmd_buffer, pool_link);
+ &pool->free_cmd_buffers, struct tu_cmd_buffer, pool_link);
list_del(&cmd_buffer->pool_link);
list_addtail(&cmd_buffer->pool_link, &pool->cmd_buffers);
pCommandBuffers[i] = tu_cmd_buffer_to_handle(cmd_buffer);
} else {
- result = tu_create_cmd_buffer(
- device, pool, pAllocateInfo->level, &pCommandBuffers[i]);
+ result = tu_create_cmd_buffer(device, pool, pAllocateInfo->level,
+ &pCommandBuffers[i]);
}
if (result != VK_SUCCESS)
break;
}
if (result != VK_SUCCESS) {
- tu_FreeCommandBuffers(
- _device, pAllocateInfo->commandPool, i, pCommandBuffers);
+ tu_FreeCommandBuffers(_device, pAllocateInfo->commandPool, i,
+ pCommandBuffers);
/* From the Vulkan 1.0.66 spec:
*
* command, set all entries of the pCommandBuffers array to
* NULL and return the error."
*/
- memset(pCommandBuffers,
- 0,
+ memset(pCommandBuffers, 0,
sizeof(*pCommandBuffers) * pAllocateInfo->commandBufferCount);
}
/* setup initial configuration into command buffer */
if (cmd_buffer->level == VK_COMMAND_BUFFER_LEVEL_PRIMARY) {
switch (cmd_buffer->queue_family_index) {
- case TU_QUEUE_GENERAL:
- /* init */
- break;
- default:
- break;
+ case TU_QUEUE_GENERAL:
+ /* init */
+ break;
+ default:
+ break;
}
}
TU_FROM_HANDLE(tu_device, device, _device);
struct tu_cmd_pool *pool;
- pool = vk_alloc2(&device->alloc,
- pAllocator,
- sizeof(*pool),
- 8,
+ pool = vk_alloc2(&device->alloc, pAllocator, sizeof(*pool), 8,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (pool == NULL)
return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
if (!pool)
return;
- list_for_each_entry_safe(
- struct tu_cmd_buffer, cmd_buffer, &pool->cmd_buffers, pool_link)
+ list_for_each_entry_safe(struct tu_cmd_buffer, cmd_buffer,
+ &pool->cmd_buffers, pool_link)
{
tu_cmd_buffer_destroy(cmd_buffer);
}
- list_for_each_entry_safe(
- struct tu_cmd_buffer, cmd_buffer, &pool->free_cmd_buffers, pool_link)
+ list_for_each_entry_safe(struct tu_cmd_buffer, cmd_buffer,
+ &pool->free_cmd_buffers, pool_link)
{
tu_cmd_buffer_destroy(cmd_buffer);
}
TU_FROM_HANDLE(tu_cmd_pool, pool, commandPool);
VkResult result;
- list_for_each_entry(
- struct tu_cmd_buffer, cmd_buffer, &pool->cmd_buffers, pool_link)
+ list_for_each_entry(struct tu_cmd_buffer, cmd_buffer, &pool->cmd_buffers,
+ pool_link)
{
result = tu_reset_cmd_buffer(cmd_buffer);
if (result != VK_SUCCESS)
if (!pool)
return;
- list_for_each_entry_safe(
- struct tu_cmd_buffer, cmd_buffer, &pool->free_cmd_buffers, pool_link)
+ list_for_each_entry_safe(struct tu_cmd_buffer, cmd_buffer,
+ &pool->free_cmd_buffers, pool_link)
{
tu_cmd_buffer_destroy(cmd_buffer);
}
const VkRenderPassBeginInfo *pRenderPassBeginInfo,
const VkSubpassBeginInfoKHR *pSubpassBeginInfo)
{
- tu_CmdBeginRenderPass(
- commandBuffer, pRenderPassBeginInfo, pSubpassBeginInfo->contents);
+ tu_CmdBeginRenderPass(commandBuffer, pRenderPassBeginInfo,
+ pSubpassBeginInfo->contents);
}
void
info.pEvents = NULL;
info.srcStageMask = srcStageMask;
- tu_barrier(cmd_buffer,
- memoryBarrierCount,
- pMemoryBarriers,
- bufferMemoryBarrierCount,
- pBufferMemoryBarriers,
- imageMemoryBarrierCount,
- pImageMemoryBarriers,
- &info);
+ tu_barrier(cmd_buffer, memoryBarrierCount, pMemoryBarriers,
+ bufferMemoryBarrierCount, pBufferMemoryBarriers,
+ imageMemoryBarrierCount, pImageMemoryBarriers, &info);
}
static void
info.pEvents = pEvents;
info.srcStageMask = 0;
- tu_barrier(cmd_buffer,
- memoryBarrierCount,
- pMemoryBarriers,
- bufferMemoryBarrierCount,
- pBufferMemoryBarriers,
- imageMemoryBarrierCount,
- pImageMemoryBarriers,
- &info);
+ tu_barrier(cmd_buffer, memoryBarrierCount, pMemoryBarriers,
+ bufferMemoryBarrierCount, pBufferMemoryBarriers,
+ imageMemoryBarrierCount, pImageMemoryBarriers, &info);
}
void
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
*/
+#include "tu_private.h"
+
#include <assert.h>
#include <fcntl.h>
#include <stdbool.h>
#include <string.h>
#include <unistd.h>
-#include "tu_private.h"
#include "util/mesa-sha1.h"
#include "vk_util.h"
binding_compare(const void *av, const void *bv)
{
const VkDescriptorSetLayoutBinding *a =
- (const VkDescriptorSetLayoutBinding *)av;
+ (const VkDescriptorSetLayoutBinding *) av;
const VkDescriptorSetLayoutBinding *b =
- (const VkDescriptorSetLayoutBinding *)bv;
+ (const VkDescriptorSetLayoutBinding *) bv;
return (a->binding < b->binding) ? -1 : (a->binding > b->binding) ? 1 : 0;
}
unsigned count)
{
VkDescriptorSetLayoutBinding *sorted_bindings =
- malloc(count * sizeof(VkDescriptorSetLayoutBinding));
+ malloc(count * sizeof(VkDescriptorSetLayoutBinding));
if (!sorted_bindings)
return NULL;
- memcpy(
- sorted_bindings, bindings, count * sizeof(VkDescriptorSetLayoutBinding));
+ memcpy(sorted_bindings, bindings,
+ count * sizeof(VkDescriptorSetLayoutBinding));
- qsort(sorted_bindings,
- count,
- sizeof(VkDescriptorSetLayoutBinding),
+ qsort(sorted_bindings, count, sizeof(VkDescriptorSetLayoutBinding),
binding_compare);
return sorted_bindings;
assert(pCreateInfo->sType ==
VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO);
const VkDescriptorSetLayoutBindingFlagsCreateInfoEXT *variable_flags =
- vk_find_struct_const(pCreateInfo->pNext,
- DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT);
+ vk_find_struct_const(
+ pCreateInfo->pNext,
+ DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT);
uint32_t max_binding = 0;
uint32_t immutable_sampler_count = 0;
}
uint32_t samplers_offset =
- sizeof(struct tu_descriptor_set_layout) +
- (max_binding + 1) * sizeof(set_layout->binding[0]);
+ sizeof(struct tu_descriptor_set_layout) +
+ (max_binding + 1) * sizeof(set_layout->binding[0]);
size_t size =
- samplers_offset + immutable_sampler_count * 4 * sizeof(uint32_t);
+ samplers_offset + immutable_sampler_count * 4 * sizeof(uint32_t);
- set_layout = vk_alloc2(
- &device->alloc, pAllocator, size, 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
+ set_layout = vk_alloc2(&device->alloc, pAllocator, size, 8,
+ VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (!set_layout)
return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
set_layout->flags = pCreateInfo->flags;
/* We just allocate all the samplers at the end of the struct */
- uint32_t *samplers = (uint32_t *)&set_layout->binding[max_binding + 1];
+ uint32_t *samplers = (uint32_t *) &set_layout->binding[max_binding + 1];
(void) samplers; /* TODO: Use me */
- VkDescriptorSetLayoutBinding *bindings =
- create_sorted_bindings(pCreateInfo->pBindings, pCreateInfo->bindingCount);
+ VkDescriptorSetLayoutBinding *bindings = create_sorted_bindings(
+ pCreateInfo->pBindings, pCreateInfo->bindingCount);
if (!bindings) {
vk_free2(&device->alloc, pAllocator, set_layout);
return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
set_layout->has_immutable_samplers = false;
set_layout->size = 0;
- memset(
- set_layout->binding, 0, size - sizeof(struct tu_descriptor_set_layout));
+ memset(set_layout->binding, 0,
+ size - sizeof(struct tu_descriptor_set_layout));
uint32_t buffer_count = 0;
uint32_t dynamic_offset_count = 0;
unsigned binding_buffer_count = 0;
switch (binding->descriptorType) {
- case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
- case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
- assert(!(pCreateInfo->flags &
- VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR));
- set_layout->binding[b].dynamic_offset_count = 1;
- set_layout->dynamic_shader_stages |= binding->stageFlags;
- set_layout->binding[b].size = 0;
- binding_buffer_count = 1;
- alignment = 1;
- break;
- case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
- case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
- case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
- case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
- set_layout->binding[b].size = 16;
- binding_buffer_count = 1;
- alignment = 16;
- break;
- case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
- case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
- case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
- /* main descriptor + fmask descriptor */
- set_layout->binding[b].size = 64;
- binding_buffer_count = 1;
- alignment = 32;
- break;
- case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
- /* main descriptor + fmask descriptor + sampler */
- set_layout->binding[b].size = 96;
- binding_buffer_count = 1;
- alignment = 32;
- break;
- case VK_DESCRIPTOR_TYPE_SAMPLER:
- set_layout->binding[b].size = 16;
- alignment = 16;
- break;
- default:
- unreachable("unknown descriptor type\n");
- break;
+ case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+ case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
+ assert(!(pCreateInfo->flags &
+ VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR));
+ set_layout->binding[b].dynamic_offset_count = 1;
+ set_layout->dynamic_shader_stages |= binding->stageFlags;
+ set_layout->binding[b].size = 0;
+ binding_buffer_count = 1;
+ alignment = 1;
+ break;
+ case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+ case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
+ case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
+ case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
+ set_layout->binding[b].size = 16;
+ binding_buffer_count = 1;
+ alignment = 16;
+ break;
+ case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
+ case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
+ case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
+ /* main descriptor + fmask descriptor */
+ set_layout->binding[b].size = 64;
+ binding_buffer_count = 1;
+ alignment = 32;
+ break;
+ case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
+ /* main descriptor + fmask descriptor + sampler */
+ set_layout->binding[b].size = 96;
+ binding_buffer_count = 1;
+ alignment = 32;
+ break;
+ case VK_DESCRIPTOR_TYPE_SAMPLER:
+ set_layout->binding[b].size = 16;
+ alignment = 16;
+ break;
+ default:
+ unreachable("unknown descriptor type\n");
+ break;
}
set_layout->size = align(set_layout->size, alignment);
if (variable_flags && binding->binding < variable_flags->bindingCount &&
(variable_flags->pBindingFlags[binding->binding] &
VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT)) {
- assert(!binding->pImmutableSamplers); /* Terribly ill defined how many
- samplers are valid */
+ assert(!binding->pImmutableSamplers); /* Terribly ill defined how
+ many samplers are valid */
assert(binding->binding == max_binding);
set_layout->has_variable_descriptors = true;
}
set_layout->size +=
- binding->descriptorCount * set_layout->binding[b].size;
+ binding->descriptorCount * set_layout->binding[b].size;
buffer_count += binding->descriptorCount * binding_buffer_count;
- dynamic_offset_count +=
- binding->descriptorCount * set_layout->binding[b].dynamic_offset_count;
+ dynamic_offset_count += binding->descriptorCount *
+ set_layout->binding[b].dynamic_offset_count;
set_layout->shader_stages |= binding->stageFlags;
}
const VkDescriptorSetLayoutCreateInfo *pCreateInfo,
VkDescriptorSetLayoutSupport *pSupport)
{
- VkDescriptorSetLayoutBinding *bindings =
- create_sorted_bindings(pCreateInfo->pBindings, pCreateInfo->bindingCount);
+ VkDescriptorSetLayoutBinding *bindings = create_sorted_bindings(
+ pCreateInfo->pBindings, pCreateInfo->bindingCount);
if (!bindings) {
pSupport->supported = false;
return;
}
const VkDescriptorSetLayoutBindingFlagsCreateInfoEXT *variable_flags =
- vk_find_struct_const(pCreateInfo->pNext,
- DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT);
+ vk_find_struct_const(
+ pCreateInfo->pNext,
+ DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT);
VkDescriptorSetVariableDescriptorCountLayoutSupportEXT *variable_count =
- vk_find_struct(
- (void *)pCreateInfo->pNext,
- DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT);
+ vk_find_struct(
+ (void *) pCreateInfo->pNext,
+ DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT);
if (variable_count) {
variable_count->maxVariableDescriptorCount = 0;
}
uint64_t descriptor_size = 0;
uint64_t descriptor_alignment = 1;
switch (binding->descriptorType) {
- case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
- case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
- break;
- case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
- case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
- case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
- case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
- descriptor_size = 16;
- descriptor_alignment = 16;
- break;
- case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
- case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
- case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
- descriptor_size = 64;
- descriptor_alignment = 32;
- break;
- case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
- descriptor_size = 96;
- descriptor_alignment = 32;
- break;
- case VK_DESCRIPTOR_TYPE_SAMPLER:
- descriptor_size = 16;
- descriptor_alignment = 16;
- break;
- default:
- unreachable("unknown descriptor type\n");
- break;
+ case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+ case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
+ break;
+ case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+ case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
+ case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
+ case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
+ descriptor_size = 16;
+ descriptor_alignment = 16;
+ break;
+ case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
+ case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
+ case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
+ descriptor_size = 64;
+ descriptor_alignment = 32;
+ break;
+ case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
+ descriptor_size = 96;
+ descriptor_alignment = 32;
+ break;
+ case VK_DESCRIPTOR_TYPE_SAMPLER:
+ descriptor_size = 16;
+ descriptor_alignment = 16;
+ break;
+ default:
+ unreachable("unknown descriptor type\n");
+ break;
}
if (size && !align_u64(size, descriptor_alignment)) {
(variable_flags->pBindingFlags[binding->binding] &
VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT)) {
variable_count->maxVariableDescriptorCount =
- MIN2(UINT32_MAX, max_count);
+ MIN2(UINT32_MAX, max_count);
}
size += binding->descriptorCount * descriptor_size;
}
struct tu_pipeline_layout *layout;
struct mesa_sha1 ctx;
- assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO);
+ assert(pCreateInfo->sType ==
+ VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO);
- layout = vk_alloc2(&device->alloc,
- pAllocator,
- sizeof(*layout),
- 8,
+ layout = vk_alloc2(&device->alloc, pAllocator, sizeof(*layout), 8,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (layout == NULL)
return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
_mesa_sha1_init(&ctx);
for (uint32_t set = 0; set < pCreateInfo->setLayoutCount; set++) {
- TU_FROM_HANDLE(
- tu_descriptor_set_layout, set_layout, pCreateInfo->pSetLayouts[set]);
+ TU_FROM_HANDLE(tu_descriptor_set_layout, set_layout,
+ pCreateInfo->pSetLayouts[set]);
layout->set[set].layout = set_layout;
layout->set[set].dynamic_offset_start = dynamic_offset_count;
set_layout->binding[b].dynamic_offset_count;
if (set_layout->binding[b].immutable_samplers_offset)
_mesa_sha1_update(
- &ctx,
- tu_immutable_samplers(set_layout, set_layout->binding + b),
- set_layout->binding[b].array_size * 4 * sizeof(uint32_t));
+ &ctx,
+ tu_immutable_samplers(set_layout, set_layout->binding + b),
+ set_layout->binding[b].array_size * 4 * sizeof(uint32_t));
}
- _mesa_sha1_update(&ctx,
- set_layout->binding,
- sizeof(set_layout->binding[0]) *
- set_layout->binding_count);
+ _mesa_sha1_update(
+ &ctx, set_layout->binding,
+ sizeof(set_layout->binding[0]) * set_layout->binding_count);
}
layout->dynamic_offset_count = dynamic_offset_count;
for (unsigned i = 0; i < pCreateInfo->pushConstantRangeCount; ++i) {
const VkPushConstantRange *range = pCreateInfo->pPushConstantRanges + i;
layout->push_constant_size =
- MAX2(layout->push_constant_size, range->offset + range->size);
+ MAX2(layout->push_constant_size, range->offset + range->size);
}
layout->push_constant_size = align(layout->push_constant_size, 16);
- _mesa_sha1_update(
- &ctx, &layout->push_constant_size, sizeof(layout->push_constant_size));
+ _mesa_sha1_update(&ctx, &layout->push_constant_size,
+ sizeof(layout->push_constant_size));
_mesa_sha1_final(&ctx, layout->sha1);
*pPipelineLayout = tu_pipeline_layout_to_handle(layout);
{
TU_FROM_HANDLE(tu_device, device, _device);
- tu_update_descriptor_sets(device,
- NULL,
- VK_NULL_HANDLE,
- descriptorWriteCount,
- pDescriptorWrites,
- descriptorCopyCount,
- pDescriptorCopies);
+ tu_update_descriptor_sets(device, NULL, VK_NULL_HANDLE,
+ descriptorWriteCount, pDescriptorWrites,
+ descriptorCopyCount, pDescriptorCopies);
}
VkResult
VkDescriptorUpdateTemplateKHR *pDescriptorUpdateTemplate)
{
TU_FROM_HANDLE(tu_device, device, _device);
- TU_FROM_HANDLE(
- tu_descriptor_set_layout, set_layout, pCreateInfo->descriptorSetLayout);
+ TU_FROM_HANDLE(tu_descriptor_set_layout, set_layout,
+ pCreateInfo->descriptorSetLayout);
const uint32_t entry_count = pCreateInfo->descriptorUpdateEntryCount;
const size_t size =
- sizeof(struct tu_descriptor_update_template) +
- sizeof(struct tu_descriptor_update_template_entry) * entry_count;
+ sizeof(struct tu_descriptor_update_template) +
+ sizeof(struct tu_descriptor_update_template_entry) * entry_count;
struct tu_descriptor_update_template *templ;
- templ = vk_alloc2(
- &device->alloc, pAllocator, size, 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
+ templ = vk_alloc2(&device->alloc, pAllocator, size, 8,
+ VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (!templ)
return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
- *pDescriptorUpdateTemplate = tu_descriptor_update_template_to_handle(templ);
+ *pDescriptorUpdateTemplate =
+ tu_descriptor_update_template_to_handle(templ);
tu_use_args(set_layout);
tu_stub();
const VkAllocationCallbacks *pAllocator)
{
TU_FROM_HANDLE(tu_device, device, _device);
- TU_FROM_HANDLE(
- tu_descriptor_update_template, templ, descriptorUpdateTemplate);
+ TU_FROM_HANDLE(tu_descriptor_update_template, templ,
+ descriptorUpdateTemplate);
if (!templ)
return;
VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate,
const void *pData)
{
- TU_FROM_HANDLE(
- tu_descriptor_update_template, templ, descriptorUpdateTemplate);
+ TU_FROM_HANDLE(tu_descriptor_update_template, templ,
+ descriptorUpdateTemplate);
tu_use_args(templ);
}
TU_FROM_HANDLE(tu_device, device, _device);
TU_FROM_HANDLE(tu_descriptor_set, set, descriptorSet);
- tu_update_descriptor_set_with_template(
- device, NULL, set, descriptorUpdateTemplate, pData);
+ tu_update_descriptor_set_with_template(device, NULL, set,
+ descriptorUpdateTemplate, pData);
}
VkResult
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
*/
#ifndef TU_DESCRIPTOR_SET_H
tu_immutable_samplers(const struct tu_descriptor_set_layout *set,
const struct tu_descriptor_set_binding_layout *binding)
{
- return (const uint32_t *)((const char *)set +
- binding->immutable_samplers_offset);
+ return (const uint32_t *) ((const char *) set +
+ binding->immutable_samplers_offset);
}
#endif /* TU_DESCRIPTOR_SET_H */
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
*/
#include "tu_private.h"
-#include "util/debug.h"
-#include "util/disk_cache.h"
-#include "util/strtod.h"
-#include "vk_format.h"
-#include "vk_util.h"
+
#include <fcntl.h>
+#include <msm_drm.h>
#include <stdbool.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/sysinfo.h>
#include <unistd.h>
#include <xf86drm.h>
-#include <msm_drm.h>
+
+#include "util/debug.h"
+#include "util/disk_cache.h"
+#include "util/strtod.h"
+#include "vk_format.h"
+#include "vk_util.h"
static int
tu_device_get_cache_uuid(uint16_t family, void *uuid)
return -1;
memcpy(uuid, &mesa_timestamp, 4);
- memcpy((char *)uuid + 4, &f, 2);
- snprintf((char *)uuid + 6, VK_UUID_SIZE - 10, "tu");
+ memcpy((char *) uuid + 4, &f, 2);
+ snprintf((char *) uuid + 6, VK_UUID_SIZE - 10, "tu");
return 0;
}
return VK_SUCCESS;
fail_info:
- tu_gem_close(dev, bo->gem_handle);
+ tu_gem_close(dev, bo->gem_handle);
fail_new:
- return vk_error(dev->instance, VK_ERROR_OUT_OF_DEVICE_MEMORY);
+ return vk_error(dev->instance, VK_ERROR_OUT_OF_DEVICE_MEMORY);
}
VkResult
result = vk_errorf(instance, VK_ERROR_INCOMPATIBLE_DRIVER,
"kernel driver for device %s has version %d.%d, "
"but Vulkan requires version >= %d.%d",
- path,
- version->version_major, version->version_minor,
+ path, version->version_major, version->version_minor,
min_version_major, min_version_minor);
drmFreeVersion(version);
close(fd);
strncpy(device->path, path, ARRAY_SIZE(device->path));
if (instance->enabled_extensions.KHR_display) {
- master_fd = open(drm_device->nodes[DRM_NODE_PRIMARY], O_RDWR | O_CLOEXEC);
+ master_fd =
+ open(drm_device->nodes[DRM_NODE_PRIMARY], O_RDWR | O_CLOEXEC);
if (master_fd >= 0) {
/* TODO: free master_fd is accel is not working? */
}
if (!device->drm_device) {
if (instance->debug_flags & TU_DEBUG_STARTUP)
tu_logi("Could not create the libdrm device");
- result = vk_errorf(
- instance, VK_ERROR_INITIALIZATION_FAILED, "could not create the libdrm device");
- goto fail;
+ result = vk_errorf(instance, VK_ERROR_INITIALIZATION_FAILED,
+ "could not create the libdrm device");
+ goto fail;
}
if (tu_drm_query_param(device, MSM_PARAM_GPU_ID, &val)) {
if (instance->debug_flags & TU_DEBUG_STARTUP)
tu_logi("Could not query the GPU ID");
- result = vk_errorf(
- instance, VK_ERROR_INITIALIZATION_FAILED, "could not get GPU ID");
+ result = vk_errorf(instance, VK_ERROR_INITIALIZATION_FAILED,
+ "could not get GPU ID");
goto fail;
}
device->gpu_id = val;
if (tu_drm_query_param(device, MSM_PARAM_GMEM_SIZE, &val)) {
if (instance->debug_flags & TU_DEBUG_STARTUP)
tu_logi("Could not query the GMEM size");
- result = vk_errorf(
- instance, VK_ERROR_INITIALIZATION_FAILED, "could not get GMEM size");
+ result = vk_errorf(instance, VK_ERROR_INITIALIZATION_FAILED,
+ "could not get GMEM size");
goto fail;
}
device->gmem_size = val;
memset(device->name, 0, sizeof(device->name));
sprintf(device->name, "FD%d", device->gpu_id);
- switch(device->gpu_id) {
+ switch (device->gpu_id) {
case 530:
case 630:
break;
goto fail;
}
if (tu_device_get_cache_uuid(device->gpu_id, device->cache_uuid)) {
- result = vk_errorf(
- instance, VK_ERROR_INITIALIZATION_FAILED, "cannot generate UUID");
+ result = vk_errorf(instance, VK_ERROR_INITIALIZATION_FAILED,
+ "cannot generate UUID");
goto fail;
}
disk_cache_format_hex_id(buf, device->cache_uuid, VK_UUID_SIZE * 2);
device->disk_cache = disk_cache_create(device->name, buf, 0);
- fprintf(stderr,
- "WARNING: tu is not a conformant vulkan implementation, "
- "testing use only.\n");
+ fprintf(stderr, "WARNING: tu is not a conformant vulkan implementation, "
+ "testing use only.\n");
tu_get_driver_uuid(&device->device_uuid);
tu_get_device_uuid(&device->device_uuid);
.pfnFree = default_free_func,
};
-static const struct debug_control tu_debug_options[] = { { "startup",
- TU_DEBUG_STARTUP },
- { NULL, 0 } };
+static const struct debug_control tu_debug_options[] = {
+ { "startup", TU_DEBUG_STARTUP }, { NULL, 0 }
+};
const char *
tu_get_debug_option_name(int id)
tu_EnumerateInstanceVersion(&client_version);
}
- instance = vk_zalloc2(&default_alloc,
- pAllocator,
- sizeof(*instance),
- 8,
+ instance = vk_zalloc2(&default_alloc, pAllocator, sizeof(*instance), 8,
VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
if (!instance)
return vk_error(NULL, VK_ERROR_OUT_OF_HOST_MEMORY);
instance->physical_device_count = -1;
instance->debug_flags =
- parse_debug_string(getenv("TU_DEBUG"), tu_debug_options);
+ parse_debug_string(getenv("TU_DEBUG"), tu_debug_options);
if (instance->debug_flags & TU_DEBUG_STARTUP)
tu_logi("Created an instance");
if (max_devices < 1)
return vk_error(instance, VK_ERROR_INCOMPATIBLE_DRIVER);
- for (unsigned i = 0; i < (unsigned)max_devices; i++) {
+ for (unsigned i = 0; i < (unsigned) max_devices; i++) {
if (devices[i]->available_nodes & 1 << DRM_NODE_RENDER &&
devices[i]->bustype == DRM_BUS_PLATFORM) {
- result = tu_physical_device_init(instance->physical_devices +
- instance->physical_device_count,
- instance,
- devices[i]);
+ result = tu_physical_device_init(
+ instance->physical_devices + instance->physical_device_count,
+ instance, devices[i]);
if (result == VK_SUCCESS)
++instance->physical_device_count;
else if (result != VK_ERROR_INCOMPATIBLE_DRIVER)
}
for (uint32_t i = 0; i < instance->physical_device_count; ++i) {
- vk_outarray_append(&out, p) {
+ vk_outarray_append(&out, p)
+ {
*p = tu_physical_device_to_handle(instance->physical_devices + i);
}
-
}
return vk_outarray_status(&out);
VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties)
{
TU_FROM_HANDLE(tu_instance, instance, _instance);
- VK_OUTARRAY_MAKE(out, pPhysicalDeviceGroupProperties, pPhysicalDeviceGroupCount);
+ VK_OUTARRAY_MAKE(out, pPhysicalDeviceGroupProperties,
+ pPhysicalDeviceGroupCount);
VkResult result;
if (instance->physical_device_count < 0) {
}
for (uint32_t i = 0; i < instance->physical_device_count; ++i) {
- vk_outarray_append(&out, p) {
+ vk_outarray_append(&out, p)
+ {
p->physicalDeviceCount = 1;
p->physicalDevices[0] =
- tu_physical_device_to_handle(instance->physical_devices + i);
+ tu_physical_device_to_handle(instance->physical_devices + i);
p->subsetAllocation = false;
}
}
{
memset(pFeatures, 0, sizeof(*pFeatures));
- *pFeatures = (VkPhysicalDeviceFeatures){
+ *pFeatures = (VkPhysicalDeviceFeatures) {
.robustBufferAccess = false,
.fullDrawIndexUint32 = false,
.imageCubeArray = false,
vk_foreach_struct(ext, pFeatures->pNext)
{
switch (ext->sType) {
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR: {
- VkPhysicalDeviceVariablePointerFeaturesKHR *features = (void *)ext;
- features->variablePointersStorageBuffer = false;
- features->variablePointers = false;
- break;
- }
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR: {
- VkPhysicalDeviceMultiviewFeaturesKHR *features =
- (VkPhysicalDeviceMultiviewFeaturesKHR *)ext;
- features->multiview = false;
- features->multiviewGeometryShader = false;
- features->multiviewTessellationShader = false;
- break;
- }
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES: {
- VkPhysicalDeviceShaderDrawParameterFeatures *features =
- (VkPhysicalDeviceShaderDrawParameterFeatures *)ext;
- features->shaderDrawParameters = false;
- break;
- }
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: {
- VkPhysicalDeviceProtectedMemoryFeatures *features =
- (VkPhysicalDeviceProtectedMemoryFeatures *)ext;
- features->protectedMemory = false;
- break;
- }
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: {
- VkPhysicalDevice16BitStorageFeatures *features =
- (VkPhysicalDevice16BitStorageFeatures *)ext;
- features->storageBuffer16BitAccess = false;
- features->uniformAndStorageBuffer16BitAccess = false;
- features->storagePushConstant16 = false;
- features->storageInputOutput16 = false;
- break;
- }
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: {
- VkPhysicalDeviceSamplerYcbcrConversionFeatures *features =
- (VkPhysicalDeviceSamplerYcbcrConversionFeatures *)ext;
- features->samplerYcbcrConversion = false;
- break;
- }
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT: {
- VkPhysicalDeviceDescriptorIndexingFeaturesEXT *features =
- (VkPhysicalDeviceDescriptorIndexingFeaturesEXT *)ext;
- features->shaderInputAttachmentArrayDynamicIndexing = false;
- features->shaderUniformTexelBufferArrayDynamicIndexing = false;
- features->shaderStorageTexelBufferArrayDynamicIndexing = false;
- features->shaderUniformBufferArrayNonUniformIndexing = false;
- features->shaderSampledImageArrayNonUniformIndexing = false;
- features->shaderStorageBufferArrayNonUniformIndexing = false;
- features->shaderStorageImageArrayNonUniformIndexing = false;
- features->shaderInputAttachmentArrayNonUniformIndexing = false;
- features->shaderUniformTexelBufferArrayNonUniformIndexing = false;
- features->shaderStorageTexelBufferArrayNonUniformIndexing = false;
- features->descriptorBindingUniformBufferUpdateAfterBind = false;
- features->descriptorBindingSampledImageUpdateAfterBind = false;
- features->descriptorBindingStorageImageUpdateAfterBind = false;
- features->descriptorBindingStorageBufferUpdateAfterBind = false;
- features->descriptorBindingUniformTexelBufferUpdateAfterBind = false;
- features->descriptorBindingStorageTexelBufferUpdateAfterBind = false;
- features->descriptorBindingUpdateUnusedWhilePending = false;
- features->descriptorBindingPartiallyBound = false;
- features->descriptorBindingVariableDescriptorCount = false;
- features->runtimeDescriptorArray = false;
- break;
- }
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: {
- VkPhysicalDeviceConditionalRenderingFeaturesEXT *features =
- (VkPhysicalDeviceConditionalRenderingFeaturesEXT *)ext;
- features->conditionalRendering = false;
- features->inheritedConditionalRendering = false;
- break;
- }
- default:
- break;
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR: {
+ VkPhysicalDeviceVariablePointerFeaturesKHR *features = (void *) ext;
+ features->variablePointersStorageBuffer = false;
+ features->variablePointers = false;
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR: {
+ VkPhysicalDeviceMultiviewFeaturesKHR *features =
+ (VkPhysicalDeviceMultiviewFeaturesKHR *) ext;
+ features->multiview = false;
+ features->multiviewGeometryShader = false;
+ features->multiviewTessellationShader = false;
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES: {
+ VkPhysicalDeviceShaderDrawParameterFeatures *features =
+ (VkPhysicalDeviceShaderDrawParameterFeatures *) ext;
+ features->shaderDrawParameters = false;
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: {
+ VkPhysicalDeviceProtectedMemoryFeatures *features =
+ (VkPhysicalDeviceProtectedMemoryFeatures *) ext;
+ features->protectedMemory = false;
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: {
+ VkPhysicalDevice16BitStorageFeatures *features =
+ (VkPhysicalDevice16BitStorageFeatures *) ext;
+ features->storageBuffer16BitAccess = false;
+ features->uniformAndStorageBuffer16BitAccess = false;
+ features->storagePushConstant16 = false;
+ features->storageInputOutput16 = false;
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: {
+ VkPhysicalDeviceSamplerYcbcrConversionFeatures *features =
+ (VkPhysicalDeviceSamplerYcbcrConversionFeatures *) ext;
+ features->samplerYcbcrConversion = false;
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT: {
+ VkPhysicalDeviceDescriptorIndexingFeaturesEXT *features =
+ (VkPhysicalDeviceDescriptorIndexingFeaturesEXT *) ext;
+ features->shaderInputAttachmentArrayDynamicIndexing = false;
+ features->shaderUniformTexelBufferArrayDynamicIndexing = false;
+ features->shaderStorageTexelBufferArrayDynamicIndexing = false;
+ features->shaderUniformBufferArrayNonUniformIndexing = false;
+ features->shaderSampledImageArrayNonUniformIndexing = false;
+ features->shaderStorageBufferArrayNonUniformIndexing = false;
+ features->shaderStorageImageArrayNonUniformIndexing = false;
+ features->shaderInputAttachmentArrayNonUniformIndexing = false;
+ features->shaderUniformTexelBufferArrayNonUniformIndexing = false;
+ features->shaderStorageTexelBufferArrayNonUniformIndexing = false;
+ features->descriptorBindingUniformBufferUpdateAfterBind = false;
+ features->descriptorBindingSampledImageUpdateAfterBind = false;
+ features->descriptorBindingStorageImageUpdateAfterBind = false;
+ features->descriptorBindingStorageBufferUpdateAfterBind = false;
+ features->descriptorBindingUniformTexelBufferUpdateAfterBind = false;
+ features->descriptorBindingStorageTexelBufferUpdateAfterBind = false;
+ features->descriptorBindingUpdateUnusedWhilePending = false;
+ features->descriptorBindingPartiallyBound = false;
+ features->descriptorBindingVariableDescriptorCount = false;
+ features->runtimeDescriptorArray = false;
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: {
+ VkPhysicalDeviceConditionalRenderingFeaturesEXT *features =
+ (VkPhysicalDeviceConditionalRenderingFeaturesEXT *) ext;
+ features->conditionalRendering = false;
+ features->inheritedConditionalRendering = false;
+ break;
+ }
+ default:
+ break;
}
}
return tu_GetPhysicalDeviceFeatures(physicalDevice, &pFeatures->features);
* there is no set limit, so we just set a pipeline limit. I don't think
* any app is going to hit this soon. */
size_t max_descriptor_set_size =
- ((1ull << 31) - 16 * MAX_DYNAMIC_BUFFERS) /
- (32 /* uniform buffer, 32 due to potential space wasted on alignment */ +
- 32 /* storage buffer, 32 due to potential space wasted on alignment */ +
- 32 /* sampler, largest when combined with image */ +
- 64 /* sampled image */ + 64 /* storage image */);
+ ((1ull << 31) - 16 * MAX_DYNAMIC_BUFFERS) /
+ (32 /* uniform buffer, 32 due to potential space wasted on alignment */ +
+ 32 /* storage buffer, 32 due to potential space wasted on alignment */ +
+ 32 /* sampler, largest when combined with image */ +
+ 64 /* sampled image */ + 64 /* storage image */);
VkPhysicalDeviceLimits limits = {
.maxImageDimension1D = (1 << 14),
.nonCoherentAtomSize = 64,
};
- *pProperties = (VkPhysicalDeviceProperties){
+ *pProperties = (VkPhysicalDeviceProperties) {
.apiVersion = tu_physical_device_api_version(pdevice),
.driverVersion = vk_get_driver_version(),
.vendorID = 0, /* TODO */
vk_foreach_struct(ext, pProperties->pNext)
{
switch (ext->sType) {
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR: {
- VkPhysicalDevicePushDescriptorPropertiesKHR *properties =
- (VkPhysicalDevicePushDescriptorPropertiesKHR *)ext;
- properties->maxPushDescriptors = MAX_PUSH_DESCRIPTORS;
- break;
- }
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR: {
- VkPhysicalDeviceIDPropertiesKHR *properties =
- (VkPhysicalDeviceIDPropertiesKHR *)ext;
- memcpy(properties->driverUUID, pdevice->driver_uuid, VK_UUID_SIZE);
- memcpy(properties->deviceUUID, pdevice->device_uuid, VK_UUID_SIZE);
- properties->deviceLUIDValid = false;
- break;
- }
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR: {
- VkPhysicalDeviceMultiviewPropertiesKHR *properties =
- (VkPhysicalDeviceMultiviewPropertiesKHR *)ext;
- properties->maxMultiviewViewCount = MAX_VIEWS;
- properties->maxMultiviewInstanceIndex = INT_MAX;
- break;
- }
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR: {
- VkPhysicalDevicePointClippingPropertiesKHR *properties =
- (VkPhysicalDevicePointClippingPropertiesKHR *)ext;
- properties->pointClippingBehavior =
- VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR;
- break;
- }
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: {
- VkPhysicalDeviceMaintenance3Properties *properties =
- (VkPhysicalDeviceMaintenance3Properties *)ext;
- /* Make sure everything is addressable by a signed 32-bit int, and
- * our largest descriptors are 96 bytes. */
- properties->maxPerSetDescriptors = (1ull << 31) / 96;
- /* Our buffer size fields allow only this much */
- properties->maxMemoryAllocationSize = 0xFFFFFFFFull;
- break;
- }
- default:
- break;
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR: {
+ VkPhysicalDevicePushDescriptorPropertiesKHR *properties =
+ (VkPhysicalDevicePushDescriptorPropertiesKHR *) ext;
+ properties->maxPushDescriptors = MAX_PUSH_DESCRIPTORS;
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR: {
+ VkPhysicalDeviceIDPropertiesKHR *properties =
+ (VkPhysicalDeviceIDPropertiesKHR *) ext;
+ memcpy(properties->driverUUID, pdevice->driver_uuid, VK_UUID_SIZE);
+ memcpy(properties->deviceUUID, pdevice->device_uuid, VK_UUID_SIZE);
+ properties->deviceLUIDValid = false;
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR: {
+ VkPhysicalDeviceMultiviewPropertiesKHR *properties =
+ (VkPhysicalDeviceMultiviewPropertiesKHR *) ext;
+ properties->maxMultiviewViewCount = MAX_VIEWS;
+ properties->maxMultiviewInstanceIndex = INT_MAX;
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR: {
+ VkPhysicalDevicePointClippingPropertiesKHR *properties =
+ (VkPhysicalDevicePointClippingPropertiesKHR *) ext;
+ properties->pointClippingBehavior =
+ VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR;
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: {
+ VkPhysicalDeviceMaintenance3Properties *properties =
+ (VkPhysicalDeviceMaintenance3Properties *) ext;
+ /* Make sure everything is addressable by a signed 32-bit int, and
+ * our largest descriptors are 96 bytes. */
+ properties->maxPerSetDescriptors = (1ull << 31) / 96;
+ /* Our buffer size fields allow only this much */
+ properties->maxMemoryAllocationSize = 0xFFFFFFFFull;
+ break;
+ }
+ default:
+ break;
}
}
}
-static const VkQueueFamilyProperties
-tu_queue_family_properties = {
- .queueFlags = VK_QUEUE_GRAPHICS_BIT |
- VK_QUEUE_COMPUTE_BIT |
- VK_QUEUE_TRANSFER_BIT,
+static const VkQueueFamilyProperties tu_queue_family_properties = {
+ .queueFlags =
+ VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT | VK_QUEUE_TRANSFER_BIT,
.queueCount = 1,
.timestampValidBits = 64,
.minImageTransferGranularity = (VkExtent3D) { 1, 1, 1 },
{
VK_OUTARRAY_MAKE(out, pQueueFamilyProperties, pQueueFamilyPropertyCount);
- vk_outarray_append(&out, p) {
- *p = tu_queue_family_properties;
- }
+ vk_outarray_append(&out, p) { *p = tu_queue_family_properties; }
}
void
{
VK_OUTARRAY_MAKE(out, pQueueFamilyProperties, pQueueFamilyPropertyCount);
- vk_outarray_append(&out, p) {
+ vk_outarray_append(&out, p)
+ {
p->queueFamilyProperties = tu_queue_family_properties;
}
}
struct sysinfo info;
sysinfo(&info);
- uint64_t total_ram = (uint64_t)info.totalram * (uint64_t)info.mem_unit;
+ uint64_t total_ram = (uint64_t) info.totalram * (uint64_t) info.mem_unit;
/* We don't want to burn too much ram with the GPU. If the user has 4GiB
* or less, we use at most half. If they have more than 4GiB, we use 3/4.
pMemoryProperties->memoryHeaps[0].flags = VK_MEMORY_HEAP_DEVICE_LOCAL_BIT;
pMemoryProperties->memoryTypeCount = 1;
- pMemoryProperties->memoryTypes[0].propertyFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT |
- VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
- VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
+ pMemoryProperties->memoryTypes[0].propertyFlags =
+ VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT |
+ VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
+ VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
pMemoryProperties->memoryTypes[0].heapIndex = 0;
}
VkPhysicalDeviceMemoryProperties2KHR *pMemoryProperties)
{
return tu_GetPhysicalDeviceMemoryProperties(
- physicalDevice, &pMemoryProperties->memoryProperties);
+ physicalDevice, &pMemoryProperties->memoryProperties);
}
static int
if (pCreateInfo->pEnabledFeatures) {
VkPhysicalDeviceFeatures supported_features;
tu_GetPhysicalDeviceFeatures(physicalDevice, &supported_features);
- VkBool32 *supported_feature = (VkBool32 *)&supported_features;
- VkBool32 *enabled_feature = (VkBool32 *)pCreateInfo->pEnabledFeatures;
+ VkBool32 *supported_feature = (VkBool32 *) &supported_features;
+ VkBool32 *enabled_feature = (VkBool32 *) pCreateInfo->pEnabledFeatures;
unsigned num_features =
- sizeof(VkPhysicalDeviceFeatures) / sizeof(VkBool32);
+ sizeof(VkPhysicalDeviceFeatures) / sizeof(VkBool32);
for (uint32_t i = 0; i < num_features; i++) {
if (enabled_feature[i] && !supported_feature[i])
return vk_error(physical_device->instance,
}
}
- device = vk_zalloc2(&physical_device->instance->alloc,
- pAllocator,
- sizeof(*device),
- 8,
- VK_SYSTEM_ALLOCATION_SCOPE_DEVICE);
+ device = vk_zalloc2(&physical_device->instance->alloc, pAllocator,
+ sizeof(*device), 8, VK_SYSTEM_ALLOCATION_SCOPE_DEVICE);
if (!device)
return vk_error(physical_device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
for (unsigned i = 0; i < pCreateInfo->queueCreateInfoCount; i++) {
const VkDeviceQueueCreateInfo *queue_create =
- &pCreateInfo->pQueueCreateInfos[i];
+ &pCreateInfo->pQueueCreateInfos[i];
uint32_t qfi = queue_create->queueFamilyIndex;
- device->queues[qfi] =
- vk_alloc(&device->alloc,
- queue_create->queueCount * sizeof(struct tu_queue),
- 8,
- VK_SYSTEM_ALLOCATION_SCOPE_DEVICE);
+ device->queues[qfi] = vk_alloc(
+ &device->alloc, queue_create->queueCount * sizeof(struct tu_queue),
+ 8, VK_SYSTEM_ALLOCATION_SCOPE_DEVICE);
if (!device->queues[qfi]) {
result = VK_ERROR_OUT_OF_HOST_MEMORY;
goto fail;
}
- memset(device->queues[qfi],
- 0,
+ memset(device->queues[qfi], 0,
queue_create->queueCount * sizeof(struct tu_queue));
device->queue_count[qfi] = queue_create->queueCount;
for (unsigned q = 0; q < queue_create->queueCount; q++) {
- result = tu_queue_init(
- device, &device->queues[qfi][q], qfi, q, queue_create->flags);
+ result = tu_queue_init(device, &device->queues[qfi][q], qfi, q,
+ queue_create->flags);
if (result != VK_SUCCESS)
goto fail;
}
ci.initialDataSize = 0;
VkPipelineCache pc;
result =
- tu_CreatePipelineCache(tu_device_to_handle(device), &ci, NULL, &pc);
+ tu_CreatePipelineCache(tu_device_to_handle(device), &ci, NULL, &pc);
if (result != VK_SUCCESS)
goto fail;
struct tu_queue *queue;
queue =
- &device->queues[pQueueInfo->queueFamilyIndex][pQueueInfo->queueIndex];
+ &device->queues[pQueueInfo->queueFamilyIndex][pQueueInfo->queueIndex];
if (pQueueInfo->flags != queue->flags) {
/* From the Vulkan 1.1.70 spec:
*
VkQueue *pQueue)
{
const VkDeviceQueueInfo2 info =
- (VkDeviceQueueInfo2){.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2,
- .queueFamilyIndex = queueFamilyIndex,
- .queueIndex = queueIndex };
+ (VkDeviceQueueInfo2) { .sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2,
+ .queueFamilyIndex = queueFamilyIndex,
+ .queueIndex = queueIndex };
tu_GetDeviceQueue2(_device, &info, pQueue);
}
{
TU_FROM_HANDLE(tu_instance, instance, _instance);
- return tu_lookup_entrypoint_checked(pName,
- instance ? instance->api_version : 0,
- instance ? &instance->enabled_extensions
- : NULL,
- NULL);
+ return tu_lookup_entrypoint_checked(
+ pName, instance ? instance->api_version : 0,
+ instance ? &instance->enabled_extensions : NULL, NULL);
}
/* The loader wants us to expose a second GetInstanceProcAddr function
{
TU_FROM_HANDLE(tu_device, device, _device);
- return tu_lookup_entrypoint_checked(pName,
- device->instance->api_version,
- &device->instance->enabled_extensions,
- &device->enabled_extensions);
+ return tu_lookup_entrypoint_checked(pName, device->instance->api_version,
+ &device->instance->enabled_extensions,
+ &device->enabled_extensions);
}
static VkResult
return VK_SUCCESS;
}
- mem = vk_alloc2(&device->alloc,
- pAllocator,
- sizeof(*mem),
- 8,
+ mem = vk_alloc2(&device->alloc, pAllocator, sizeof(*mem), 8,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (mem == NULL)
return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
if (mem->user_ptr) {
*ppData = mem->user_ptr;
- } else if (!mem->map){
+ } else if (!mem->map) {
result = tu_bo_map(device, &mem->bo);
if (result != VK_SUCCESS)
return result;
pMemoryRequirements->memoryTypeBits = 1;
pMemoryRequirements->alignment = 16;
pMemoryRequirements->size =
- align64(buffer->size, pMemoryRequirements->alignment);
+ align64(buffer->size, pMemoryRequirements->alignment);
}
void
const VkBufferMemoryRequirementsInfo2KHR *pInfo,
VkMemoryRequirements2KHR *pMemoryRequirements)
{
- tu_GetBufferMemoryRequirements(
- device, pInfo->buffer, &pMemoryRequirements->memoryRequirements);
+ tu_GetBufferMemoryRequirements(device, pInfo->buffer,
+ &pMemoryRequirements->memoryRequirements);
}
void
const VkImageMemoryRequirementsInfo2KHR *pInfo,
VkMemoryRequirements2KHR *pMemoryRequirements)
{
- tu_GetImageMemoryRequirements(
- device, pInfo->image, &pMemoryRequirements->memoryRequirements);
+ tu_GetImageMemoryRequirements(device, pInfo->image,
+ &pMemoryRequirements->memoryRequirements);
}
void
{
TU_FROM_HANDLE(tu_device, device, _device);
- struct tu_fence *fence = vk_alloc2(&device->alloc,
- pAllocator,
- sizeof(*fence),
- 8,
- VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
+ struct tu_fence *fence =
+ vk_alloc2(&device->alloc, pAllocator, sizeof(*fence), 8,
+ VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (!fence)
return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
{
TU_FROM_HANDLE(tu_device, device, _device);
- struct tu_semaphore *sem = vk_alloc2(&device->alloc,
- pAllocator,
- sizeof(*sem),
- 8,
- VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
+ struct tu_semaphore *sem =
+ vk_alloc2(&device->alloc, pAllocator, sizeof(*sem), 8,
+ VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (!sem)
return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
VkEvent *pEvent)
{
TU_FROM_HANDLE(tu_device, device, _device);
- struct tu_event *event = vk_alloc2(&device->alloc,
- pAllocator,
- sizeof(*event),
- 8,
- VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
+ struct tu_event *event =
+ vk_alloc2(&device->alloc, pAllocator, sizeof(*event), 8,
+ VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (!event)
return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO);
- buffer = vk_alloc2(&device->alloc,
- pAllocator,
- sizeof(*buffer),
- 8,
+ buffer = vk_alloc2(&device->alloc, pAllocator, sizeof(*buffer), 8,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (buffer == NULL)
return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
tu_surface_max_layer_count(struct tu_image_view *iview)
{
return iview->type == VK_IMAGE_VIEW_TYPE_3D
- ? iview->extent.depth
- : (iview->base_layer + iview->layer_count);
+ ? iview->extent.depth
+ : (iview->base_layer + iview->layer_count);
}
VkResult
assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO);
- size_t size =
- sizeof(*framebuffer) +
- sizeof(struct tu_attachment_info) * pCreateInfo->attachmentCount;
- framebuffer = vk_alloc2(
- &device->alloc, pAllocator, size, 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
+ size_t size = sizeof(*framebuffer) + sizeof(struct tu_attachment_info) *
+ pCreateInfo->attachmentCount;
+ framebuffer = vk_alloc2(&device->alloc, pAllocator, size, 8,
+ VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (framebuffer == NULL)
return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
framebuffer->width = MIN2(framebuffer->width, iview->extent.width);
framebuffer->height = MIN2(framebuffer->height, iview->extent.height);
framebuffer->layers =
- MIN2(framebuffer->layers, tu_surface_max_layer_count(iview));
+ MIN2(framebuffer->layers, tu_surface_max_layer_count(iview));
}
*pFramebuffer = tu_framebuffer_to_handle(framebuffer);
assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO);
- sampler = vk_alloc2(&device->alloc,
- pAllocator,
- sizeof(*sampler),
- 8,
+ sampler = vk_alloc2(&device->alloc, pAllocator, sizeof(*sampler), 8,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (!sampler)
return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
vk_icdNegotiateLoaderICDInterfaceVersion(uint32_t *pSupportedVersion)
{
/* For the full details on loader interface versioning, see
- * <https://github.com/KhronosGroup/Vulkan-LoaderAndValidationLayers/blob/master/loader/LoaderAndLayerInterface.md>.
- * What follows is a condensed summary, to help you navigate the large and
- * confusing official doc.
- *
- * - Loader interface v0 is incompatible with later versions. We don't
- * support it.
- *
- * - In loader interface v1:
- * - The first ICD entrypoint called by the loader is
- * vk_icdGetInstanceProcAddr(). The ICD must statically expose this
- * entrypoint.
- * - The ICD must statically expose no other Vulkan symbol unless it is
- * linked with -Bsymbolic.
- * - Each dispatchable Vulkan handle created by the ICD must be
- * a pointer to a struct whose first member is VK_LOADER_DATA. The
- * ICD must initialize VK_LOADER_DATA.loadMagic to ICD_LOADER_MAGIC.
- * - The loader implements vkCreate{PLATFORM}SurfaceKHR() and
- * vkDestroySurfaceKHR(). The ICD must be capable of working with
- * such loader-managed surfaces.
- *
- * - Loader interface v2 differs from v1 in:
- * - The first ICD entrypoint called by the loader is
- * vk_icdNegotiateLoaderICDInterfaceVersion(). The ICD must
- * statically expose this entrypoint.
- *
- * - Loader interface v3 differs from v2 in:
- * - The ICD must implement vkCreate{PLATFORM}SurfaceKHR(),
- * vkDestroySurfaceKHR(), and other API which uses VKSurfaceKHR,
- * because the loader no longer does so.
- */
+ * <https://github.com/KhronosGroup/Vulkan-LoaderAndValidationLayers/blob/master/loader/LoaderAndLayerInterface.md>.
+ * What follows is a condensed summary, to help you navigate the large and
+ * confusing official doc.
+ *
+ * - Loader interface v0 is incompatible with later versions. We don't
+ * support it.
+ *
+ * - In loader interface v1:
+ * - The first ICD entrypoint called by the loader is
+ * vk_icdGetInstanceProcAddr(). The ICD must statically expose this
+ * entrypoint.
+ * - The ICD must statically expose no other Vulkan symbol unless it
+ * is linked with -Bsymbolic.
+ * - Each dispatchable Vulkan handle created by the ICD must be
+ * a pointer to a struct whose first member is VK_LOADER_DATA. The
+ * ICD must initialize VK_LOADER_DATA.loadMagic to
+ * ICD_LOADER_MAGIC.
+ * - The loader implements vkCreate{PLATFORM}SurfaceKHR() and
+ * vkDestroySurfaceKHR(). The ICD must be capable of working with
+ * such loader-managed surfaces.
+ *
+ * - Loader interface v2 differs from v1 in:
+ * - The first ICD entrypoint called by the loader is
+ * vk_icdNegotiateLoaderICDInterfaceVersion(). The ICD must
+ * statically expose this entrypoint.
+ *
+ * - Loader interface v3 differs from v2 in:
+ * - The ICD must implement vkCreate{PLATFORM}SurfaceKHR(),
+ * vkDestroySurfaceKHR(), and other API which uses VKSurfaceKHR,
+ * because the loader no longer does so.
+ */
*pSupportedVersion = MIN2(*pSupportedVersion, 3u);
return VK_SUCCESS;
}
{
TU_FROM_HANDLE(tu_instance, instance, _instance);
return vk_create_debug_report_callback(&instance->debug_report_callbacks,
- pCreateInfo,
- pAllocator,
- &instance->alloc,
- pCallback);
+ pCreateInfo, pAllocator,
+ &instance->alloc, pCallback);
}
void
{
TU_FROM_HANDLE(tu_instance, instance, _instance);
vk_destroy_debug_report_callback(&instance->debug_report_callbacks,
- _callback,
- pAllocator,
- &instance->alloc);
+ _callback, pAllocator, &instance->alloc);
}
void
const char *pMessage)
{
TU_FROM_HANDLE(tu_instance, instance, _instance);
- vk_debug_report(&instance->debug_report_callbacks,
- flags,
- objectType,
- object,
- location,
- messageCode,
- pLayerPrefix,
- pMessage);
+ vk_debug_report(&instance->debug_report_callbacks, flags, objectType,
+ object, location, messageCode, pLayerPrefix, pMessage);
}
void
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
*/
-#include <stdint.h>
-#include <sys/ioctl.h>
-#include <errno.h>
-
-#include <msm_drm.h>
-
#include "tu_private.h"
#include "xf86drm.h"
+#include <errno.h>
+#include <msm_drm.h>
+#include <stdint.h>
+#include <sys/ioctl.h>
/**
* Return gem handle on success. Return 0 on failure.
.flags = flags,
};
-
- int ret = drmCommandWriteRead(dev->physical_device->local_fd, DRM_MSM_GEM_NEW,
- &req, sizeof(req));
+ int ret = drmCommandWriteRead(dev->physical_device->local_fd,
+ DRM_MSM_GEM_NEW, &req, sizeof(req));
if (ret)
return 0;
.flags = flags,
};
- int ret = drmCommandWriteRead(dev->physical_device->local_fd, DRM_MSM_GEM_INFO,
- &req, sizeof(req));
+ int ret = drmCommandWriteRead(dev->physical_device->local_fd,
+ DRM_MSM_GEM_INFO, &req, sizeof(req));
if (ret == -1)
return UINT64_MAX;
return tu_gem_info(dev, gem_handle, MSM_INFO_IOVA);
}
-
int
-tu_drm_query_param(struct tu_physical_device *dev, uint32_t param, uint64_t *value)
+tu_drm_query_param(struct tu_physical_device *dev,
+ uint32_t param,
+ uint64_t *value)
{
- /* Technically this requires a pipe, but the kernel only supports one pipe anyway
- * at the time of writing and most of these are clearly pipe independent. */
+ /* Technically this requires a pipe, but the kernel only supports one pipe
+ * anyway at the time of writing and most of these are clearly pipe
+ * independent. */
struct drm_msm_param req = {
.pipe = MSM_PIPE_3D0,
.param = param,
};
- int ret = drmCommandWriteRead(dev->local_fd, DRM_MSM_GET_PARAM,
- &req, sizeof(req));
+ int ret = drmCommandWriteRead(dev->local_fd, DRM_MSM_GET_PARAM, &req,
+ sizeof(req));
if (ret)
return ret;
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
*/
#include "tu_private.h"
-#include "vk_format.h"
-
-#include "vk_util.h"
-
#include "util/format_r11g11b10f.h"
#include "util/format_srgb.h"
#include "util/u_half.h"
+#include "vk_format.h"
+#include "vk_util.h"
static void
tu_physical_device_get_format_properties(
{
TU_FROM_HANDLE(tu_physical_device, physical_device, physicalDevice);
- tu_physical_device_get_format_properties(
- physical_device, format, pFormatProperties);
+ tu_physical_device_get_format_properties(physical_device, format,
+ pFormatProperties);
}
void
TU_FROM_HANDLE(tu_physical_device, physical_device, physicalDevice);
tu_physical_device_get_format_properties(
- physical_device, format, &pFormatProperties->formatProperties);
+ physical_device, format, &pFormatProperties->formatProperties);
}
static VkResult
-tu_get_image_format_properties(struct tu_physical_device *physical_device,
- const VkPhysicalDeviceImageFormatInfo2KHR *info,
- VkImageFormatProperties *pImageFormatProperties)
+tu_get_image_format_properties(
+ struct tu_physical_device *physical_device,
+ const VkPhysicalDeviceImageFormatInfo2KHR *info,
+ VkImageFormatProperties *pImageFormatProperties)
{
VkFormatProperties format_props;
uint32_t maxArraySize;
VkSampleCountFlags sampleCounts = VK_SAMPLE_COUNT_1_BIT;
- tu_physical_device_get_format_properties(
- physical_device, info->format, &format_props);
+ tu_physical_device_get_format_properties(physical_device, info->format,
+ &format_props);
if (info->tiling == VK_IMAGE_TILING_LINEAR) {
format_feature_flags = format_props.linearTilingFeatures;
} else if (info->tiling == VK_IMAGE_TILING_OPTIMAL) {
goto unsupported;
switch (info->type) {
- default:
- unreachable("bad vkimage type\n");
- case VK_IMAGE_TYPE_1D:
- maxExtent.width = 16384;
- maxExtent.height = 1;
- maxExtent.depth = 1;
- maxMipLevels = 15; /* log2(maxWidth) + 1 */
- maxArraySize = 2048;
- break;
- case VK_IMAGE_TYPE_2D:
- maxExtent.width = 16384;
- maxExtent.height = 16384;
- maxExtent.depth = 1;
- maxMipLevels = 15; /* log2(maxWidth) + 1 */
- maxArraySize = 2048;
- break;
- case VK_IMAGE_TYPE_3D:
- maxExtent.width = 2048;
- maxExtent.height = 2048;
- maxExtent.depth = 2048;
- maxMipLevels = 12; /* log2(maxWidth) + 1 */
- maxArraySize = 1;
- break;
+ default:
+ unreachable("bad vkimage type\n");
+ case VK_IMAGE_TYPE_1D:
+ maxExtent.width = 16384;
+ maxExtent.height = 1;
+ maxExtent.depth = 1;
+ maxMipLevels = 15; /* log2(maxWidth) + 1 */
+ maxArraySize = 2048;
+ break;
+ case VK_IMAGE_TYPE_2D:
+ maxExtent.width = 16384;
+ maxExtent.height = 16384;
+ maxExtent.depth = 1;
+ maxMipLevels = 15; /* log2(maxWidth) + 1 */
+ maxArraySize = 2048;
+ break;
+ case VK_IMAGE_TYPE_3D:
+ maxExtent.width = 2048;
+ maxExtent.height = 2048;
+ maxExtent.depth = 2048;
+ maxMipLevels = 12; /* log2(maxWidth) + 1 */
+ maxArraySize = 1;
+ break;
}
if (info->tiling == VK_IMAGE_TILING_OPTIMAL &&
VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT)) &&
!(info->flags & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT) &&
!(info->usage & VK_IMAGE_USAGE_STORAGE_BIT)) {
- sampleCounts |=
- VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT | VK_SAMPLE_COUNT_8_BIT;
+ sampleCounts |= VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT |
+ VK_SAMPLE_COUNT_8_BIT;
}
if (info->usage & VK_IMAGE_USAGE_SAMPLED_BIT) {
}
}
- *pImageFormatProperties = (VkImageFormatProperties){
+ *pImageFormatProperties = (VkImageFormatProperties) {
.maxExtent = maxExtent,
.maxMipLevels = maxMipLevels,
.maxArrayLayers = maxArraySize,
return VK_SUCCESS;
unsupported:
- *pImageFormatProperties = (VkImageFormatProperties){
+ *pImageFormatProperties = (VkImageFormatProperties) {
.maxExtent = { 0, 0, 0 },
.maxMipLevels = 0,
.maxArrayLayers = 0,
.flags = createFlags,
};
- return tu_get_image_format_properties(
- physical_device, &info, pImageFormatProperties);
+ return tu_get_image_format_properties(physical_device, &info,
+ pImageFormatProperties);
}
static void
get_external_image_format_properties(
- const VkPhysicalDeviceImageFormatInfo2KHR *pImageFormatInfo,
- VkExternalMemoryHandleTypeFlagBitsKHR handleType,
- VkExternalMemoryPropertiesKHR *external_properties)
+ const VkPhysicalDeviceImageFormatInfo2KHR *pImageFormatInfo,
+ VkExternalMemoryHandleTypeFlagBitsKHR handleType,
+ VkExternalMemoryPropertiesKHR *external_properties)
{
VkExternalMemoryFeatureFlagBitsKHR flags = 0;
VkExternalMemoryHandleTypeFlagsKHR export_flags = 0;
VkExternalMemoryHandleTypeFlagsKHR compat_flags = 0;
switch (handleType) {
- case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR:
- case VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT:
- switch (pImageFormatInfo->type) {
- case VK_IMAGE_TYPE_2D:
- flags = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR |
- VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR |
- VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR;
- compat_flags = export_flags =
- VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR |
- VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT;
- break;
- default:
- break;
- }
- break;
- case VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT:
- flags = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR;
- compat_flags = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT;
+ case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR:
+ case VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT:
+ switch (pImageFormatInfo->type) {
+ case VK_IMAGE_TYPE_2D:
+ flags = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR |
+ VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR |
+ VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR;
+ compat_flags = export_flags =
+ VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR |
+ VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT;
break;
default:
break;
+ }
+ break;
+ case VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT:
+ flags = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR;
+ compat_flags = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT;
+ break;
+ default:
+ break;
}
- *external_properties = (VkExternalMemoryPropertiesKHR){
+ *external_properties = (VkExternalMemoryPropertiesKHR) {
.externalMemoryFeatures = flags,
.exportFromImportedHandleTypes = export_flags,
.compatibleHandleTypes = compat_flags,
VkResult result;
result = tu_get_image_format_properties(
- physical_device, base_info, &base_props->imageFormatProperties);
+ physical_device, base_info, &base_props->imageFormatProperties);
if (result != VK_SUCCESS)
return result;
vk_foreach_struct_const(s, base_info->pNext)
{
switch (s->sType) {
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR:
- external_info = (const void *)s;
- break;
- default:
- break;
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR:
+ external_info = (const void *) s;
+ break;
+ default:
+ break;
}
}
vk_foreach_struct(s, base_props->pNext)
{
switch (s->sType) {
- case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR:
- external_props = (void *)s;
- break;
- default:
- break;
+ case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR:
+ external_props = (void *) s;
+ break;
+ default:
+ break;
}
}
*/
if (external_info && external_info->handleType != 0) {
switch (external_info->handleType) {
- case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR:
- case VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT:
- case VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT:
- get_external_image_format_properties(
- base_info,
- external_info->handleType,
- &external_props->externalMemoryProperties);
- break;
- default:
- /* From the Vulkan 1.0.42 spec:
- *
- * If handleType is not compatible with the [parameters]
- * specified
- * in VkPhysicalDeviceImageFormatInfo2KHR, then
- * vkGetPhysicalDeviceImageFormatProperties2KHR returns
- * VK_ERROR_FORMAT_NOT_SUPPORTED.
- */
- result =
- vk_errorf(physical_device->instance,
- VK_ERROR_FORMAT_NOT_SUPPORTED,
- "unsupported VkExternalMemoryTypeFlagBitsKHR 0x%x",
- external_info->handleType);
- goto fail;
+ case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR:
+ case VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT:
+ case VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT:
+ get_external_image_format_properties(
+ base_info, external_info->handleType,
+ &external_props->externalMemoryProperties);
+ break;
+ default:
+ /* From the Vulkan 1.0.42 spec:
+ *
+ * If handleType is not compatible with the [parameters]
+ * specified
+ * in VkPhysicalDeviceImageFormatInfo2KHR, then
+ * vkGetPhysicalDeviceImageFormatProperties2KHR returns
+ * VK_ERROR_FORMAT_NOT_SUPPORTED.
+ */
+ result = vk_errorf(
+ physical_device->instance, VK_ERROR_FORMAT_NOT_SUPPORTED,
+ "unsupported VkExternalMemoryTypeFlagBitsKHR 0x%x",
+ external_info->handleType);
+ goto fail;
}
}
* the implementation for use in vkCreateImage, then all members of
* imageFormatProperties will be filled with zero.
*/
- base_props->imageFormatProperties = (VkImageFormatProperties){ 0 };
+ base_props->imageFormatProperties = (VkImageFormatProperties) { 0 };
}
return result;
VkExternalMemoryHandleTypeFlagsKHR export_flags = 0;
VkExternalMemoryHandleTypeFlagsKHR compat_flags = 0;
switch (pExternalBufferInfo->handleType) {
- case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR:
- case VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT:
- flags = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR |
- VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR;
- compat_flags = export_flags =
- VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR |
- VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT;
- break;
- case VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT:
- flags = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR;
- compat_flags = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT;
- break;
- default:
- break;
+ case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR:
+ case VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT:
+ flags = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR |
+ VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR;
+ compat_flags = export_flags =
+ VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR |
+ VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT;
+ break;
+ case VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT:
+ flags = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR;
+ compat_flags = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT;
+ break;
+ default:
+ break;
}
pExternalBufferProperties->externalMemoryProperties =
- (VkExternalMemoryPropertiesKHR){
- .externalMemoryFeatures = flags,
- .exportFromImportedHandleTypes = export_flags,
- .compatibleHandleTypes = compat_flags,
- };
+ (VkExternalMemoryPropertiesKHR) {
+ .externalMemoryFeatures = flags,
+ .exportFromImportedHandleTypes = export_flags,
+ .compatibleHandleTypes = compat_flags,
+ };
}
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
*/
#include "tu_private.h"
+
#include "util/debug.h"
#include "util/u_atomic.h"
#include "vk_format.h"
#include "vk_util.h"
-
static inline bool
image_level_linear(struct tu_image *image, int level)
{
}
/* indexed by cpp: */
-static const struct {
+static const struct
+{
unsigned pitchalign;
unsigned heightalign;
} tile_alignment[] = {
- [1] = { 128, 32 },
- [2] = { 128, 16 },
- [3] = { 128, 16 },
- [4] = { 64, 16 },
- [8] = { 64, 16 },
- [12] = { 64, 16 },
- [16] = { 64, 16 },
+ [1] = { 128, 32 }, [2] = { 128, 16 }, [3] = { 128, 16 }, [4] = { 64, 16 },
+ [8] = { 64, 16 }, [12] = { 64, 16 }, [16] = { 64, 16 },
};
static void
setup_slices(struct tu_image *image, const VkImageCreateInfo *pCreateInfo)
{
- enum vk_format_layout layout = vk_format_description(pCreateInfo->format)->layout;
+ enum vk_format_layout layout =
+ vk_format_description(pCreateInfo->format)->layout;
uint32_t layer_size = 0;
uint32_t width = pCreateInfo->extent.width;
uint32_t height = pCreateInfo->extent.height;
}
if (layout == VK_FORMAT_LAYOUT_ASTC)
- slice->pitch =
- util_align_npot(width, pitchalign * vk_format_get_blockwidth(pCreateInfo->format));
+ slice->pitch = util_align_npot(
+ width,
+ pitchalign * vk_format_get_blockwidth(pCreateInfo->format));
else
slice->pitch = align(width, pitchalign);
slice->offset = layer_size;
- blocks = vk_format_get_block_count(pCreateInfo->format, slice->pitch, aligned_height);
+ blocks = vk_format_get_block_count(pCreateInfo->format, slice->pitch,
+ aligned_height);
/* 1d array and 2d array textures must all have the same layer size
* for each miplevel on a3xx. 3d textures can have different layer
* different than what this code does), so as soon as the layer size
* range gets into range, we stop reducing it.
*/
- if (pCreateInfo->imageType == VK_IMAGE_TYPE_3D && (
- level == 1 ||
- (level > 1 && image->levels[level - 1].size > 0xf000)))
+ if (pCreateInfo->imageType == VK_IMAGE_TYPE_3D &&
+ (level == 1 ||
+ (level > 1 && image->levels[level - 1].size > 0xf000)))
slice->size = align(blocks * cpp, alignment);
else if (level == 0 || layer_first || alignment == 1)
slice->size = align(blocks * cpp, alignment);
image->layer_size = layer_size;
}
-
VkResult
tu_image_create(VkDevice _device,
const struct tu_image_create_info *create_info,
tu_assert(pCreateInfo->extent.height > 0);
tu_assert(pCreateInfo->extent.depth > 0);
- image = vk_zalloc2(&device->alloc,
- alloc,
- sizeof(*image),
- 8,
+ image = vk_zalloc2(&device->alloc, alloc, sizeof(*image), 8,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (!image)
return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
VK_QUEUE_FAMILY_EXTERNAL_KHR)
image->queue_family_mask |= (1u << TU_MAX_QUEUE_FAMILIES) - 1u;
else
- image->queue_family_mask |= 1u
- << pCreateInfo->pQueueFamilyIndices[i];
+ image->queue_family_mask |=
+ 1u << pCreateInfo->pQueueFamilyIndices[i];
}
image->shareable =
- vk_find_struct_const(pCreateInfo->pNext,
- EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR) != NULL;
+ vk_find_struct_const(pCreateInfo->pNext,
+ EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR) != NULL;
image->tile_mode = pCreateInfo->tiling == VK_IMAGE_TILING_OPTIMAL ? 3 : 0;
setup_slices(image, pCreateInfo);
{
#ifdef ANDROID
const VkNativeBufferANDROID *gralloc_info =
- vk_find_struct_const(pCreateInfo->pNext, NATIVE_BUFFER_ANDROID);
+ vk_find_struct_const(pCreateInfo->pNext, NATIVE_BUFFER_ANDROID);
if (gralloc_info)
- return tu_image_from_gralloc(
- device, pCreateInfo, gralloc_info, pAllocator, pImage);
+ return tu_image_from_gralloc(device, pCreateInfo, gralloc_info,
+ pAllocator, pImage);
#endif
return tu_image_create(device,
- &(struct tu_image_create_info) {
+ &(struct tu_image_create_info) {
.vk_info = pCreateInfo,
.scanout = false,
- },
- pAllocator,
- pImage);
+ },
+ pAllocator, pImage);
}
void
TU_FROM_HANDLE(tu_device, device, _device);
struct tu_image_view *view;
- view = vk_alloc2(&device->alloc,
- pAllocator,
- sizeof(*view),
- 8,
+ view = vk_alloc2(&device->alloc, pAllocator, sizeof(*view), 8,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (view == NULL)
return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
TU_FROM_HANDLE(tu_buffer, buffer, pCreateInfo->buffer);
view->range = pCreateInfo->range == VK_WHOLE_SIZE
- ? buffer->size - pCreateInfo->offset
- : pCreateInfo->range;
+ ? buffer->size - pCreateInfo->offset
+ : pCreateInfo->range;
view->vk_format = pCreateInfo->format;
}
TU_FROM_HANDLE(tu_device, device, _device);
struct tu_buffer_view *view;
- view = vk_alloc2(&device->alloc,
- pAllocator,
- sizeof(*view),
- 8,
+ view = vk_alloc2(&device->alloc, pAllocator, sizeof(*view), 8,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (!view)
return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
*/
#include "tu_private.h"
+
#include "nir/nir_builder.h"
void
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
*/
#include "tu_private.h"
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
*/
#include "tu_private.h"
TU_FROM_HANDLE(tu_image, dest_image, destImage);
TU_FROM_HANDLE(tu_buffer, src_buffer, srcBuffer);
- meta_copy_buffer_to_image(cmd_buffer,
- src_buffer,
- dest_image,
- destImageLayout,
- regionCount,
- pRegions);
+ meta_copy_buffer_to_image(cmd_buffer, src_buffer, dest_image,
+ destImageLayout, regionCount, pRegions);
}
static void
TU_FROM_HANDLE(tu_image, src_image, srcImage);
TU_FROM_HANDLE(tu_buffer, dst_buffer, destBuffer);
- meta_copy_image_to_buffer(
- cmd_buffer, dst_buffer, src_image, srcImageLayout, regionCount, pRegions);
+ meta_copy_image_to_buffer(cmd_buffer, dst_buffer, src_image,
+ srcImageLayout, regionCount, pRegions);
}
static void
TU_FROM_HANDLE(tu_image, src_image, srcImage);
TU_FROM_HANDLE(tu_image, dest_image, destImage);
- meta_copy_image(cmd_buffer,
- src_image,
- srcImageLayout,
- dest_image,
- destImageLayout,
- regionCount,
- pRegions);
+ meta_copy_image(cmd_buffer, src_image, srcImageLayout, dest_image,
+ destImageLayout, regionCount, pRegions);
}
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
*/
+#include "tu_private.h"
+
#include <assert.h>
#include <stdbool.h>
-#include "tu_private.h"
#include "nir/nir_builder.h"
#include "vk_format.h"
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
*/
#include "tu_private.h"
attachments_offset = size;
size += pCreateInfo->attachmentCount * sizeof(pass->attachments[0]);
- pass = vk_alloc2(
- &device->alloc, pAllocator, size, 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
+ pass = vk_alloc2(&device->alloc, pAllocator, size, 8,
+ VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (pass == NULL)
return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
memset(pass, 0, size);
pass->attachment_count = pCreateInfo->attachmentCount;
pass->subpass_count = pCreateInfo->subpassCount;
- pass->attachments = (void *)pass + attachments_offset;
+ pass->attachments = (void *) pass + attachments_offset;
vk_foreach_struct(ext, pCreateInfo->pNext)
{
switch (ext->sType) {
- case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR:
- multiview_info = (VkRenderPassMultiviewCreateInfoKHR *)ext;
- break;
- default:
- break;
+ case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR:
+ multiview_info = (VkRenderPassMultiviewCreateInfoKHR *) ext;
+ break;
+ default:
+ break;
}
}
const VkSubpassDescription *desc = &pCreateInfo->pSubpasses[i];
subpass_attachment_count +=
- desc->inputAttachmentCount + desc->colorAttachmentCount +
- (desc->pResolveAttachments ? desc->colorAttachmentCount : 0) +
- (desc->pDepthStencilAttachment != NULL);
+ desc->inputAttachmentCount + desc->colorAttachmentCount +
+ (desc->pResolveAttachments ? desc->colorAttachmentCount : 0) +
+ (desc->pDepthStencilAttachment != NULL);
}
if (subpass_attachment_count) {
pass->subpass_attachments = vk_alloc2(
- &device->alloc,
- pAllocator,
- subpass_attachment_count * sizeof(struct tu_subpass_attachment),
- 8,
- VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
+ &device->alloc, pAllocator,
+ subpass_attachment_count * sizeof(struct tu_subpass_attachment), 8,
+ VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (pass->subpass_attachments == NULL) {
vk_free2(&device->alloc, pAllocator, pass);
return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
p += desc->inputAttachmentCount;
for (uint32_t j = 0; j < desc->inputAttachmentCount; j++) {
- subpass->input_attachments[j] = (struct tu_subpass_attachment){
+ subpass->input_attachments[j] = (struct tu_subpass_attachment) {
.attachment = desc->pInputAttachments[j].attachment,
.layout = desc->pInputAttachments[j].layout,
};
if (desc->pInputAttachments[j].attachment != VK_ATTACHMENT_UNUSED)
pass->attachments[desc->pInputAttachments[j].attachment]
- .view_mask |= subpass->view_mask;
+ .view_mask |= subpass->view_mask;
}
}
p += desc->colorAttachmentCount;
for (uint32_t j = 0; j < desc->colorAttachmentCount; j++) {
- subpass->color_attachments[j] = (struct tu_subpass_attachment){
+ subpass->color_attachments[j] = (struct tu_subpass_attachment) {
.attachment = desc->pColorAttachments[j].attachment,
.layout = desc->pColorAttachments[j].layout,
};
- if (desc->pColorAttachments[j].attachment != VK_ATTACHMENT_UNUSED) {
+ if (desc->pColorAttachments[j].attachment !=
+ VK_ATTACHMENT_UNUSED) {
pass->attachments[desc->pColorAttachments[j].attachment]
- .view_mask |= subpass->view_mask;
+ .view_mask |= subpass->view_mask;
color_sample_count =
- pCreateInfo
- ->pAttachments[desc->pColorAttachments[j].attachment]
- .samples;
+ pCreateInfo
+ ->pAttachments[desc->pColorAttachments[j].attachment]
+ .samples;
}
}
}
for (uint32_t j = 0; j < desc->colorAttachmentCount; j++) {
uint32_t a = desc->pResolveAttachments[j].attachment;
- subpass->resolve_attachments[j] = (struct tu_subpass_attachment){
+ subpass->resolve_attachments[j] = (struct tu_subpass_attachment) {
.attachment = desc->pResolveAttachments[j].attachment,
.layout = desc->pResolveAttachments[j].layout,
};
if (a != VK_ATTACHMENT_UNUSED) {
subpass->has_resolve = true;
pass->attachments[desc->pResolveAttachments[j].attachment]
- .view_mask |= subpass->view_mask;
+ .view_mask |= subpass->view_mask;
}
}
}
if (desc->pDepthStencilAttachment) {
- subpass->depth_stencil_attachment = (struct tu_subpass_attachment){
+ subpass->depth_stencil_attachment = (struct tu_subpass_attachment) {
.attachment = desc->pDepthStencilAttachment->attachment,
.layout = desc->pDepthStencilAttachment->layout,
};
if (desc->pDepthStencilAttachment->attachment !=
VK_ATTACHMENT_UNUSED) {
pass->attachments[desc->pDepthStencilAttachment->attachment]
- .view_mask |= subpass->view_mask;
+ .view_mask |= subpass->view_mask;
depth_sample_count =
- pCreateInfo
- ->pAttachments[desc->pDepthStencilAttachment->attachment]
- .samples;
+ pCreateInfo
+ ->pAttachments[desc->pDepthStencilAttachment->attachment]
+ .samples;
}
} else {
subpass->depth_stencil_attachment.attachment = VK_ATTACHMENT_UNUSED;
}
- subpass->max_sample_count = MAX2(color_sample_count, depth_sample_count);
+ subpass->max_sample_count =
+ MAX2(color_sample_count, depth_sample_count);
}
for (unsigned i = 0; i < pCreateInfo->dependencyCount; ++i) {
uint32_t dst = pCreateInfo->pDependencies[i].dstSubpass;
if (dst == VK_SUBPASS_EXTERNAL) {
pass->end_barrier.src_stage_mask =
- pCreateInfo->pDependencies[i].srcStageMask;
+ pCreateInfo->pDependencies[i].srcStageMask;
pass->end_barrier.src_access_mask =
- pCreateInfo->pDependencies[i].srcAccessMask;
+ pCreateInfo->pDependencies[i].srcAccessMask;
pass->end_barrier.dst_access_mask =
- pCreateInfo->pDependencies[i].dstAccessMask;
+ pCreateInfo->pDependencies[i].dstAccessMask;
} else {
pass->subpasses[dst].start_barrier.src_stage_mask =
- pCreateInfo->pDependencies[i].srcStageMask;
+ pCreateInfo->pDependencies[i].srcStageMask;
pass->subpasses[dst].start_barrier.src_access_mask =
- pCreateInfo->pDependencies[i].srcAccessMask;
+ pCreateInfo->pDependencies[i].srcAccessMask;
pass->subpasses[dst].start_barrier.dst_access_mask =
- pCreateInfo->pDependencies[i].dstAccessMask;
+ pCreateInfo->pDependencies[i].dstAccessMask;
}
}
attachments_offset = size;
size += pCreateInfo->attachmentCount * sizeof(pass->attachments[0]);
- pass = vk_alloc2(
- &device->alloc, pAllocator, size, 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
+ pass = vk_alloc2(&device->alloc, pAllocator, size, 8,
+ VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (pass == NULL)
return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
memset(pass, 0, size);
pass->attachment_count = pCreateInfo->attachmentCount;
pass->subpass_count = pCreateInfo->subpassCount;
- pass->attachments = (void *)pass + attachments_offset;
+ pass->attachments = (void *) pass + attachments_offset;
for (uint32_t i = 0; i < pCreateInfo->attachmentCount; i++) {
struct tu_render_pass_attachment *att = &pass->attachments[i];
const VkSubpassDescription2KHR *desc = &pCreateInfo->pSubpasses[i];
subpass_attachment_count +=
- desc->inputAttachmentCount + desc->colorAttachmentCount +
- (desc->pResolveAttachments ? desc->colorAttachmentCount : 0) +
- (desc->pDepthStencilAttachment != NULL);
+ desc->inputAttachmentCount + desc->colorAttachmentCount +
+ (desc->pResolveAttachments ? desc->colorAttachmentCount : 0) +
+ (desc->pDepthStencilAttachment != NULL);
}
if (subpass_attachment_count) {
pass->subpass_attachments = vk_alloc2(
- &device->alloc,
- pAllocator,
- subpass_attachment_count * sizeof(struct tu_subpass_attachment),
- 8,
- VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
+ &device->alloc, pAllocator,
+ subpass_attachment_count * sizeof(struct tu_subpass_attachment), 8,
+ VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (pass->subpass_attachments == NULL) {
vk_free2(&device->alloc, pAllocator, pass);
return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
p += desc->inputAttachmentCount;
for (uint32_t j = 0; j < desc->inputAttachmentCount; j++) {
- subpass->input_attachments[j] = (struct tu_subpass_attachment){
+ subpass->input_attachments[j] = (struct tu_subpass_attachment) {
.attachment = desc->pInputAttachments[j].attachment,
.layout = desc->pInputAttachments[j].layout,
};
if (desc->pInputAttachments[j].attachment != VK_ATTACHMENT_UNUSED)
pass->attachments[desc->pInputAttachments[j].attachment]
- .view_mask |= subpass->view_mask;
+ .view_mask |= subpass->view_mask;
}
}
p += desc->colorAttachmentCount;
for (uint32_t j = 0; j < desc->colorAttachmentCount; j++) {
- subpass->color_attachments[j] = (struct tu_subpass_attachment){
+ subpass->color_attachments[j] = (struct tu_subpass_attachment) {
.attachment = desc->pColorAttachments[j].attachment,
.layout = desc->pColorAttachments[j].layout,
};
- if (desc->pColorAttachments[j].attachment != VK_ATTACHMENT_UNUSED) {
+ if (desc->pColorAttachments[j].attachment !=
+ VK_ATTACHMENT_UNUSED) {
pass->attachments[desc->pColorAttachments[j].attachment]
- .view_mask |= subpass->view_mask;
+ .view_mask |= subpass->view_mask;
color_sample_count =
- pCreateInfo
- ->pAttachments[desc->pColorAttachments[j].attachment]
- .samples;
+ pCreateInfo
+ ->pAttachments[desc->pColorAttachments[j].attachment]
+ .samples;
}
}
}
for (uint32_t j = 0; j < desc->colorAttachmentCount; j++) {
uint32_t a = desc->pResolveAttachments[j].attachment;
- subpass->resolve_attachments[j] = (struct tu_subpass_attachment){
+ subpass->resolve_attachments[j] = (struct tu_subpass_attachment) {
.attachment = desc->pResolveAttachments[j].attachment,
.layout = desc->pResolveAttachments[j].layout,
};
if (a != VK_ATTACHMENT_UNUSED) {
subpass->has_resolve = true;
pass->attachments[desc->pResolveAttachments[j].attachment]
- .view_mask |= subpass->view_mask;
+ .view_mask |= subpass->view_mask;
}
}
}
if (desc->pDepthStencilAttachment) {
- subpass->depth_stencil_attachment = (struct tu_subpass_attachment){
+ subpass->depth_stencil_attachment = (struct tu_subpass_attachment) {
.attachment = desc->pDepthStencilAttachment->attachment,
.layout = desc->pDepthStencilAttachment->layout,
};
if (desc->pDepthStencilAttachment->attachment !=
VK_ATTACHMENT_UNUSED) {
pass->attachments[desc->pDepthStencilAttachment->attachment]
- .view_mask |= subpass->view_mask;
+ .view_mask |= subpass->view_mask;
depth_sample_count =
- pCreateInfo
- ->pAttachments[desc->pDepthStencilAttachment->attachment]
- .samples;
+ pCreateInfo
+ ->pAttachments[desc->pDepthStencilAttachment->attachment]
+ .samples;
}
} else {
subpass->depth_stencil_attachment.attachment = VK_ATTACHMENT_UNUSED;
}
- subpass->max_sample_count = MAX2(color_sample_count, depth_sample_count);
+ subpass->max_sample_count =
+ MAX2(color_sample_count, depth_sample_count);
}
for (unsigned i = 0; i < pCreateInfo->dependencyCount; ++i) {
uint32_t dst = pCreateInfo->pDependencies[i].dstSubpass;
if (dst == VK_SUBPASS_EXTERNAL) {
pass->end_barrier.src_stage_mask =
- pCreateInfo->pDependencies[i].srcStageMask;
+ pCreateInfo->pDependencies[i].srcStageMask;
pass->end_barrier.src_access_mask =
- pCreateInfo->pDependencies[i].srcAccessMask;
+ pCreateInfo->pDependencies[i].srcAccessMask;
pass->end_barrier.dst_access_mask =
- pCreateInfo->pDependencies[i].dstAccessMask;
+ pCreateInfo->pDependencies[i].dstAccessMask;
} else {
pass->subpasses[dst].start_barrier.src_stage_mask =
- pCreateInfo->pDependencies[i].srcStageMask;
+ pCreateInfo->pDependencies[i].srcStageMask;
pass->subpasses[dst].start_barrier.src_access_mask =
- pCreateInfo->pDependencies[i].srcAccessMask;
+ pCreateInfo->pDependencies[i].srcAccessMask;
pass->subpasses[dst].start_barrier.dst_access_mask =
- pCreateInfo->pDependencies[i].dstAccessMask;
+ pCreateInfo->pDependencies[i].dstAccessMask;
}
}
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
*/
#include "tu_private.h"
+
+#include "main/menums.h"
#include "nir/nir.h"
#include "nir/nir_builder.h"
#include "spirv/nir_spirv.h"
+#include "util/debug.h"
#include "util/mesa-sha1.h"
#include "util/u_atomic.h"
-#include "vk_util.h"
-
-#include "main/menums.h"
-#include "util/debug.h"
#include "vk_format.h"
+#include "vk_util.h"
VkResult
tu_graphics_pipeline_create(
for (; i < count; i++) {
VkResult r;
- r = tu_graphics_pipeline_create(_device,
- pipelineCache,
- &pCreateInfos[i],
- NULL,
- pAllocator,
- &pPipelines[i]);
+ r =
+ tu_graphics_pipeline_create(_device, pipelineCache, &pCreateInfos[i],
+ NULL, pAllocator, &pPipelines[i]);
if (r != VK_SUCCESS) {
result = r;
pPipelines[i] = VK_NULL_HANDLE;
unsigned i = 0;
for (; i < count; i++) {
VkResult r;
- r = tu_compute_pipeline_create(
- _device, pipelineCache, &pCreateInfos[i], pAllocator, &pPipelines[i]);
+ r = tu_compute_pipeline_create(_device, pipelineCache, &pCreateInfos[i],
+ pAllocator, &pPipelines[i]);
if (r != VK_SUCCESS) {
result = r;
pPipelines[i] = VK_NULL_HANDLE;
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
*/
#include "tu_private.h"
+
#include "util/debug.h"
#include "util/disk_cache.h"
#include "util/mesa-sha1.h"
struct cache_entry
{
- union
- {
+ union {
unsigned char sha1[20];
uint32_t sha1_dw[5];
};
size_t ret = sizeof(*entry);
for (int i = 0; i < MESA_SHADER_STAGES; ++i)
if (entry->code_sizes[i])
- ret += sizeof(struct cache_entry_variant_info) + entry->code_sizes[i];
+ ret +=
+ sizeof(struct cache_entry_variant_info) + entry->code_sizes[i];
return ret;
}
for (int i = 0; i < MESA_SHADER_STAGES; ++i) {
if (stages[i]) {
TU_FROM_HANDLE(tu_shader_module, module, stages[i]->module);
- const VkSpecializationInfo *spec_info = stages[i]->pSpecializationInfo;
+ const VkSpecializationInfo *spec_info =
+ stages[i]->pSpecializationInfo;
_mesa_sha1_update(&ctx, module->sha1, sizeof(module->sha1));
_mesa_sha1_update(&ctx, stages[i]->pName, strlen(stages[i]->pName));
if (spec_info) {
- _mesa_sha1_update(&ctx,
- spec_info->pMapEntries,
- spec_info->mapEntryCount *
- sizeof spec_info->pMapEntries[0]);
+ _mesa_sha1_update(
+ &ctx, spec_info->pMapEntries,
+ spec_info->mapEntryCount * sizeof spec_info->pMapEntries[0]);
_mesa_sha1_update(&ctx, spec_info->pData, spec_info->dataSize);
}
}
const unsigned char *sha1)
{
const uint32_t mask = cache->table_size - 1;
- const uint32_t start = (*(uint32_t *)sha1);
+ const uint32_t start = (*(uint32_t *) sha1);
if (cache->table_size == 0)
return NULL;
return;
if (header.device_id != 0 /* TODO */)
return;
- if (memcmp(header.uuid, device->physical_device->cache_uuid, VK_UUID_SIZE) !=
- 0)
+ if (memcmp(header.uuid, device->physical_device->cache_uuid,
+ VK_UUID_SIZE) != 0)
return;
- char *end = (void *)data + size;
- char *p = (void *)data + header.header_size;
+ char *end = (void *) data + size;
+ char *p = (void *) data + header.header_size;
while (end - p >= sizeof(struct cache_entry)) {
- struct cache_entry *entry = (struct cache_entry *)p;
+ struct cache_entry *entry = (struct cache_entry *) p;
struct cache_entry *dest_entry;
size_t size = entry_size(entry);
if (end - p < size)
break;
dest_entry =
- vk_alloc(&cache->alloc, size, 8, VK_SYSTEM_ALLOCATION_SCOPE_CACHE);
+ vk_alloc(&cache->alloc, size, 8, VK_SYSTEM_ALLOCATION_SCOPE_CACHE);
if (dest_entry) {
memcpy(dest_entry, entry, size);
for (int i = 0; i < MESA_SHADER_STAGES; ++i)
assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO);
assert(pCreateInfo->flags == 0);
- cache = vk_alloc2(&device->alloc,
- pAllocator,
- sizeof(*cache),
- 8,
+ cache = vk_alloc2(&device->alloc, pAllocator, sizeof(*cache), 8,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (cache == NULL)
return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
tu_pipeline_cache_init(cache, device);
if (pCreateInfo->initialDataSize > 0) {
- tu_pipeline_cache_load(
- cache, pCreateInfo->pInitialData, pCreateInfo->initialDataSize);
+ tu_pipeline_cache_load(cache, pCreateInfo->pInitialData,
+ pCreateInfo->initialDataSize);
}
*pPipelineCache = tu_pipeline_cache_to_handle(cache);
memcpy(p, entry, size);
for (int j = 0; j < MESA_SHADER_STAGES; ++j)
- ((struct cache_entry *)p)->variants[j] = NULL;
+ ((struct cache_entry *) p)->variants[j] = NULL;
p += size;
}
*pDataSize = p - pData;
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
*/
#ifndef TU_PRIVATE_H
#include <vulkan/vulkan_intel.h>
#include "drm/freedreno_ringbuffer.h"
-
#include "tu_entrypoints.h"
#define MAX_VBS 32
#define MAX_PUSH_DESCRIPTORS 32
#define MAX_DYNAMIC_UNIFORM_BUFFERS 16
#define MAX_DYNAMIC_STORAGE_BUFFERS 8
-#define MAX_DYNAMIC_BUFFERS \
+#define MAX_DYNAMIC_BUFFERS \
(MAX_DYNAMIC_UNIFORM_BUFFERS + MAX_DYNAMIC_STORAGE_BUFFERS)
#define MAX_SAMPLES_LOG2 4
#define NUM_META_FS_KEYS 13
}
}
-#define for_each_bit(b, dword) \
- for (uint32_t __dword = (dword); (b) = __builtin_ffs(__dword) - 1, __dword; \
- __dword &= ~(1 << (b)))
+#define for_each_bit(b, dword) \
+ for (uint32_t __dword = (dword); \
+ (b) = __builtin_ffs(__dword) - 1, __dword; __dword &= ~(1 << (b)))
-#define typed_memcpy(dest, src, count) \
- ({ \
- STATIC_ASSERT(sizeof(*src) == sizeof(*dest)); \
- memcpy((dest), (src), (count) * sizeof(*(src))); \
+#define typed_memcpy(dest, src, count) \
+ ({ \
+ STATIC_ASSERT(sizeof(*src) == sizeof(*dest)); \
+ memcpy((dest), (src), (count) * sizeof(*(src))); \
})
/* Whenever we generate an error, pass it through this function. Useful for
const char *format,
...);
-#define vk_error(instance, error) \
+#define vk_error(instance, error) \
__vk_errorf(instance, error, __FILE__, __LINE__, NULL);
-#define vk_errorf(instance, error, format, ...) \
+#define vk_errorf(instance, error, format, ...) \
__vk_errorf(instance, error, __FILE__, __LINE__, format, ##__VA_ARGS__);
void
__tu_finishme(const char *file, int line, const char *format, ...)
- tu_printflike(3, 4);
+ tu_printflike(3, 4);
void
tu_loge(const char *format, ...) tu_printflike(1, 2);
void
/**
* Print a FINISHME message, including its source location.
*/
-#define tu_finishme(format, ...) \
- do { \
- static bool reported = false; \
- if (!reported) { \
- __tu_finishme(__FILE__, __LINE__, format, ##__VA_ARGS__); \
- reported = true; \
- } \
+#define tu_finishme(format, ...) \
+ do { \
+ static bool reported = false; \
+ if (!reported) { \
+ __tu_finishme(__FILE__, __LINE__, format, ##__VA_ARGS__); \
+ reported = true; \
+ } \
} while (0)
/* A non-fatal assert. Useful for debugging. */
#ifdef DEBUG
-#define tu_assert(x) \
- ({ \
- if (unlikely(!(x))) \
- fprintf(stderr, "%s:%d ASSERT: %s\n", __FILE__, __LINE__, #x); \
+#define tu_assert(x) \
+ ({ \
+ if (unlikely(!(x))) \
+ fprintf(stderr, "%s:%d ASSERT: %s\n", __FILE__, __LINE__, #x); \
})
#else
#define tu_assert(x)
/* Suppress -Wunused in stub functions */
#define tu_use_args(...) __tu_use_args(0, ##__VA_ARGS__)
-static inline void __tu_use_args(int ignore, ...) {}
+static inline void
+__tu_use_args(int ignore, ...)
+{
+}
-#define tu_stub() \
- do { \
- tu_finishme("stub %s", __func__); \
+#define tu_stub() \
+ do { \
+ tu_finishme("stub %s", __func__); \
} while (0)
void *
#define TU_STAGE_MASK ((1 << MESA_SHADER_STAGES) - 1)
-#define tu_foreach_stage(stage, stage_bits) \
- for (gl_shader_stage stage, \
- __tmp = (gl_shader_stage)((stage_bits)&TU_STAGE_MASK); \
- stage = __builtin_ffs(__tmp) - 1, __tmp; \
- __tmp &= ~(1 << (stage)))
+#define tu_foreach_stage(stage, stage_bits) \
+ for (gl_shader_stage stage, \
+ __tmp = (gl_shader_stage)((stage_bits) &TU_STAGE_MASK); \
+ stage = __builtin_ffs(__tmp) - 1, __tmp; __tmp &= ~(1 << (stage)))
struct tu_shader_module
{
bool
tu_dcc_formats_compatible(VkFormat format1, VkFormat format2);
-
-struct tu_image_level {
- VkDeviceSize offset;
- VkDeviceSize size;
- uint32_t pitch;
+struct tu_image_level
+{
+ VkDeviceSize offset;
+ VkDeviceSize size;
+ uint32_t pitch;
};
struct tu_image
const struct VkExtent3D imageExtent)
{
switch (imageType) {
- case VK_IMAGE_TYPE_1D:
- return (VkExtent3D){ imageExtent.width, 1, 1 };
- case VK_IMAGE_TYPE_2D:
- return (VkExtent3D){ imageExtent.width, imageExtent.height, 1 };
- case VK_IMAGE_TYPE_3D:
- return imageExtent;
- default:
- unreachable("invalid image type");
+ case VK_IMAGE_TYPE_1D:
+ return (VkExtent3D) { imageExtent.width, 1, 1 };
+ case VK_IMAGE_TYPE_2D:
+ return (VkExtent3D) { imageExtent.width, imageExtent.height, 1 };
+ case VK_IMAGE_TYPE_3D:
+ return imageExtent;
+ default:
+ unreachable("invalid image type");
}
}
const struct VkOffset3D imageOffset)
{
switch (imageType) {
- case VK_IMAGE_TYPE_1D:
- return (VkOffset3D){ imageOffset.x, 0, 0 };
- case VK_IMAGE_TYPE_2D:
- return (VkOffset3D){ imageOffset.x, imageOffset.y, 0 };
- case VK_IMAGE_TYPE_3D:
- return imageOffset;
- default:
- unreachable("invalid image type");
+ case VK_IMAGE_TYPE_1D:
+ return (VkOffset3D) { imageOffset.x, 0, 0 };
+ case VK_IMAGE_TYPE_2D:
+ return (VkOffset3D) { imageOffset.x, imageOffset.y, 0 };
+ case VK_IMAGE_TYPE_3D:
+ return imageOffset;
+ default:
+ unreachable("invalid image type");
}
}
uint64_t
tu_gem_info_iova(struct tu_device *dev, uint32_t gem_handle);
int
-tu_drm_query_param(struct tu_physical_device *dev, uint32_t param, uint64_t *value);
+tu_drm_query_param(struct tu_physical_device *dev,
+ uint32_t param,
+ uint64_t *value);
#define TU_DEFINE_HANDLE_CASTS(__tu_type, __VkType) \
- \
+ \
static inline struct __tu_type *__tu_type##_from_handle(__VkType _handle) \
- { \
- return (struct __tu_type *)_handle; \
- } \
- \
+ { \
+ return (struct __tu_type *) _handle; \
+ } \
+ \
static inline __VkType __tu_type##_to_handle(struct __tu_type *_obj) \
- { \
- return (__VkType)_obj; \
+ { \
+ return (__VkType) _obj; \
}
#define TU_DEFINE_NONDISP_HANDLE_CASTS(__tu_type, __VkType) \
- \
+ \
static inline struct __tu_type *__tu_type##_from_handle(__VkType _handle) \
- { \
- return (struct __tu_type *)(uintptr_t)_handle; \
- } \
- \
+ { \
+ return (struct __tu_type *) (uintptr_t) _handle; \
+ } \
+ \
static inline __VkType __tu_type##_to_handle(struct __tu_type *_obj) \
- { \
- return (__VkType)(uintptr_t)_obj; \
+ { \
+ return (__VkType)(uintptr_t) _obj; \
}
#define TU_FROM_HANDLE(__tu_type, __name, __handle) \
TU_DEFINE_NONDISP_HANDLE_CASTS(tu_descriptor_pool, VkDescriptorPool)
TU_DEFINE_NONDISP_HANDLE_CASTS(tu_descriptor_set, VkDescriptorSet)
TU_DEFINE_NONDISP_HANDLE_CASTS(tu_descriptor_set_layout,
- VkDescriptorSetLayout)
+ VkDescriptorSetLayout)
TU_DEFINE_NONDISP_HANDLE_CASTS(tu_descriptor_update_template,
- VkDescriptorUpdateTemplateKHR)
+ VkDescriptorUpdateTemplateKHR)
TU_DEFINE_NONDISP_HANDLE_CASTS(tu_device_memory, VkDeviceMemory)
TU_DEFINE_NONDISP_HANDLE_CASTS(tu_fence, VkFence)
TU_DEFINE_NONDISP_HANDLE_CASTS(tu_event, VkEvent)
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
*/
+#include "tu_private.h"
+
#include <assert.h>
#include <fcntl.h>
#include <stdbool.h>
#include <string.h>
#include <unistd.h>
-#include "tu_private.h"
#include "nir/nir_builder.h"
VkResult
VkQueryPool *pQueryPool)
{
TU_FROM_HANDLE(tu_device, device, _device);
- struct tu_query_pool *pool = vk_alloc2(&device->alloc,
- pAllocator,
- sizeof(*pool),
- 8,
- VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
+ struct tu_query_pool *pool =
+ vk_alloc2(&device->alloc, pAllocator, sizeof(*pool), 8,
+ VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (!pool)
return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
*/
+#include "tu_private.h"
+
#include <assert.h>
#include <errno.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
-#include "tu_private.h"
-#include "vk_enum_to_str.h"
-
#include "util/u_math.h"
+#include "vk_enum_to_str.h"
/* TODO: Add Android support to tu_log funcs */
}
void tu_printflike(3, 4)
- __tu_finishme(const char *file, int line, const char *format, ...)
+ __tu_finishme(const char *file, int line, const char *format, ...)
{
va_list ap;
char buffer[256];
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
*/
#ifndef VK_FORMAT_H
#include <assert.h>
#include <util/macros.h>
+
#include <vulkan/vulkan.h>
enum vk_format_layout
vk_format_get_block_count_height(format, height);
}
-
/**
* Return the index of the first non-void channel
* -1 if no non-void channels
vk_format_aspects(VkFormat format)
{
switch (format) {
- case VK_FORMAT_UNDEFINED:
- return 0;
+ case VK_FORMAT_UNDEFINED:
+ return 0;
- case VK_FORMAT_S8_UINT:
- return VK_IMAGE_ASPECT_STENCIL_BIT;
+ case VK_FORMAT_S8_UINT:
+ return VK_IMAGE_ASPECT_STENCIL_BIT;
- case VK_FORMAT_D16_UNORM_S8_UINT:
- case VK_FORMAT_D24_UNORM_S8_UINT:
- case VK_FORMAT_D32_SFLOAT_S8_UINT:
- return VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
+ case VK_FORMAT_D16_UNORM_S8_UINT:
+ case VK_FORMAT_D24_UNORM_S8_UINT:
+ case VK_FORMAT_D32_SFLOAT_S8_UINT:
+ return VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
- case VK_FORMAT_D16_UNORM:
- case VK_FORMAT_X8_D24_UNORM_PACK32:
- case VK_FORMAT_D32_SFLOAT:
- return VK_IMAGE_ASPECT_DEPTH_BIT;
+ case VK_FORMAT_D16_UNORM:
+ case VK_FORMAT_X8_D24_UNORM_PACK32:
+ case VK_FORMAT_D32_SFLOAT:
+ return VK_IMAGE_ASPECT_DEPTH_BIT;
- default:
- return VK_IMAGE_ASPECT_COLOR_BIT;
+ default:
+ return VK_IMAGE_ASPECT_COLOR_BIT;
}
}
if (vk_swiz == VK_COMPONENT_SWIZZLE_IDENTITY)
vk_swiz = component;
switch (vk_swiz) {
- case VK_COMPONENT_SWIZZLE_ZERO:
- return VK_SWIZZLE_0;
- case VK_COMPONENT_SWIZZLE_ONE:
- return VK_SWIZZLE_1;
- case VK_COMPONENT_SWIZZLE_R:
- for (x = 0; x < 4; x++)
- if (chan[x] == 0)
- return x;
- return VK_SWIZZLE_0;
- case VK_COMPONENT_SWIZZLE_G:
- for (x = 0; x < 4; x++)
- if (chan[x] == 1)
- return x;
- return VK_SWIZZLE_0;
- case VK_COMPONENT_SWIZZLE_B:
- for (x = 0; x < 4; x++)
- if (chan[x] == 2)
- return x;
- return VK_SWIZZLE_0;
- case VK_COMPONENT_SWIZZLE_A:
- for (x = 0; x < 4; x++)
- if (chan[x] == 3)
- return x;
- return VK_SWIZZLE_1;
- default:
- unreachable("Illegal swizzle");
+ case VK_COMPONENT_SWIZZLE_ZERO:
+ return VK_SWIZZLE_0;
+ case VK_COMPONENT_SWIZZLE_ONE:
+ return VK_SWIZZLE_1;
+ case VK_COMPONENT_SWIZZLE_R:
+ for (x = 0; x < 4; x++)
+ if (chan[x] == 0)
+ return x;
+ return VK_SWIZZLE_0;
+ case VK_COMPONENT_SWIZZLE_G:
+ for (x = 0; x < 4; x++)
+ if (chan[x] == 1)
+ return x;
+ return VK_SWIZZLE_0;
+ case VK_COMPONENT_SWIZZLE_B:
+ for (x = 0; x < 4; x++)
+ if (chan[x] == 2)
+ return x;
+ return VK_SWIZZLE_0;
+ case VK_COMPONENT_SWIZZLE_A:
+ for (x = 0; x < 4; x++)
+ if (chan[x] == 3)
+ return x;
+ return VK_SWIZZLE_1;
+ default:
+ unreachable("Illegal swizzle");
}
}
}
switch (desc->layout) {
- case VK_FORMAT_LAYOUT_S3TC:
- case VK_FORMAT_LAYOUT_RGTC:
- case VK_FORMAT_LAYOUT_ETC:
- case VK_FORMAT_LAYOUT_BPTC:
- case VK_FORMAT_LAYOUT_ASTC:
- /* XXX add other formats in the future */
- return true;
- default:
- return false;
+ case VK_FORMAT_LAYOUT_S3TC:
+ case VK_FORMAT_LAYOUT_RGTC:
+ case VK_FORMAT_LAYOUT_ETC:
+ case VK_FORMAT_LAYOUT_BPTC:
+ case VK_FORMAT_LAYOUT_ASTC:
+ /* XXX add other formats in the future */
+ return true;
+ default:
+ return false;
}
}
vk_format_depth_only(VkFormat format)
{
switch (format) {
- case VK_FORMAT_D16_UNORM_S8_UINT:
- return VK_FORMAT_D16_UNORM;
- case VK_FORMAT_D24_UNORM_S8_UINT:
- return VK_FORMAT_X8_D24_UNORM_PACK32;
- case VK_FORMAT_D32_SFLOAT_S8_UINT:
- return VK_FORMAT_D32_SFLOAT;
- default:
- return format;
+ case VK_FORMAT_D16_UNORM_S8_UINT:
+ return VK_FORMAT_D16_UNORM;
+ case VK_FORMAT_D24_UNORM_S8_UINT:
+ return VK_FORMAT_X8_D24_UNORM_PACK32;
+ case VK_FORMAT_D32_SFLOAT_S8_UINT:
+ return VK_FORMAT_D32_SFLOAT;
+ default:
+ return format;
}
}
vk_format_no_srgb(VkFormat format)
{
switch (format) {
- case VK_FORMAT_R8_SRGB:
- return VK_FORMAT_R8_UNORM;
- case VK_FORMAT_R8G8_SRGB:
- return VK_FORMAT_R8G8_UNORM;
- case VK_FORMAT_R8G8B8_SRGB:
- return VK_FORMAT_R8G8B8_UNORM;
- case VK_FORMAT_B8G8R8_SRGB:
- return VK_FORMAT_B8G8R8_UNORM;
- case VK_FORMAT_R8G8B8A8_SRGB:
- return VK_FORMAT_R8G8B8A8_UNORM;
- case VK_FORMAT_B8G8R8A8_SRGB:
- return VK_FORMAT_B8G8R8A8_UNORM;
- case VK_FORMAT_A8B8G8R8_SRGB_PACK32:
- return VK_FORMAT_A8B8G8R8_UNORM_PACK32;
- case VK_FORMAT_BC1_RGB_SRGB_BLOCK:
- return VK_FORMAT_BC1_RGB_UNORM_BLOCK;
- case VK_FORMAT_BC1_RGBA_SRGB_BLOCK:
- return VK_FORMAT_BC1_RGBA_UNORM_BLOCK;
- case VK_FORMAT_BC2_SRGB_BLOCK:
- return VK_FORMAT_BC2_UNORM_BLOCK;
- case VK_FORMAT_BC3_SRGB_BLOCK:
- return VK_FORMAT_BC3_UNORM_BLOCK;
- case VK_FORMAT_BC7_SRGB_BLOCK:
- return VK_FORMAT_BC7_UNORM_BLOCK;
- case VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK:
- return VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK;
- case VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK:
- return VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK;
- case VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK:
- return VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK;
- default:
- assert(!vk_format_is_srgb(format));
- return format;
+ case VK_FORMAT_R8_SRGB:
+ return VK_FORMAT_R8_UNORM;
+ case VK_FORMAT_R8G8_SRGB:
+ return VK_FORMAT_R8G8_UNORM;
+ case VK_FORMAT_R8G8B8_SRGB:
+ return VK_FORMAT_R8G8B8_UNORM;
+ case VK_FORMAT_B8G8R8_SRGB:
+ return VK_FORMAT_B8G8R8_UNORM;
+ case VK_FORMAT_R8G8B8A8_SRGB:
+ return VK_FORMAT_R8G8B8A8_UNORM;
+ case VK_FORMAT_B8G8R8A8_SRGB:
+ return VK_FORMAT_B8G8R8A8_UNORM;
+ case VK_FORMAT_A8B8G8R8_SRGB_PACK32:
+ return VK_FORMAT_A8B8G8R8_UNORM_PACK32;
+ case VK_FORMAT_BC1_RGB_SRGB_BLOCK:
+ return VK_FORMAT_BC1_RGB_UNORM_BLOCK;
+ case VK_FORMAT_BC1_RGBA_SRGB_BLOCK:
+ return VK_FORMAT_BC1_RGBA_UNORM_BLOCK;
+ case VK_FORMAT_BC2_SRGB_BLOCK:
+ return VK_FORMAT_BC2_UNORM_BLOCK;
+ case VK_FORMAT_BC3_SRGB_BLOCK:
+ return VK_FORMAT_BC3_UNORM_BLOCK;
+ case VK_FORMAT_BC7_SRGB_BLOCK:
+ return VK_FORMAT_BC7_UNORM_BLOCK;
+ case VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK:
+ return VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK;
+ case VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK:
+ return VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK;
+ case VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK:
+ return VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK;
+ default:
+ assert(!vk_format_is_srgb(format));
+ return format;
}
}
}
switch (desc->swizzle[component]) {
- case VK_SWIZZLE_X:
- return desc->channel[0].size;
- case VK_SWIZZLE_Y:
- return desc->channel[1].size;
- case VK_SWIZZLE_Z:
- return desc->channel[2].size;
- case VK_SWIZZLE_W:
- return desc->channel[3].size;
- default:
- return 0;
+ case VK_SWIZZLE_X:
+ return desc->channel[0].size;
+ case VK_SWIZZLE_Y:
+ return desc->channel[1].size;
+ case VK_SWIZZLE_Z:
+ return desc->channel[2].size;
+ case VK_SWIZZLE_W:
+ return desc->channel[3].size;
+ default:
+ return 0;
}
}
vk_to_non_srgb_format(VkFormat format)
{
switch (format) {
- case VK_FORMAT_R8_SRGB:
- return VK_FORMAT_R8_UNORM;
- case VK_FORMAT_R8G8_SRGB:
- return VK_FORMAT_R8G8_UNORM;
- case VK_FORMAT_R8G8B8_SRGB:
- return VK_FORMAT_R8G8B8_UNORM;
- case VK_FORMAT_B8G8R8_SRGB:
- return VK_FORMAT_B8G8R8_UNORM;
- case VK_FORMAT_R8G8B8A8_SRGB:
- return VK_FORMAT_R8G8B8A8_UNORM;
- case VK_FORMAT_B8G8R8A8_SRGB:
- return VK_FORMAT_B8G8R8A8_UNORM;
- case VK_FORMAT_A8B8G8R8_SRGB_PACK32:
- return VK_FORMAT_A8B8G8R8_UNORM_PACK32;
- default:
- return format;
+ case VK_FORMAT_R8_SRGB:
+ return VK_FORMAT_R8_UNORM;
+ case VK_FORMAT_R8G8_SRGB:
+ return VK_FORMAT_R8G8_UNORM;
+ case VK_FORMAT_R8G8B8_SRGB:
+ return VK_FORMAT_R8G8B8_UNORM;
+ case VK_FORMAT_B8G8R8_SRGB:
+ return VK_FORMAT_B8G8R8_UNORM;
+ case VK_FORMAT_R8G8B8A8_SRGB:
+ return VK_FORMAT_R8G8B8A8_UNORM;
+ case VK_FORMAT_B8G8R8A8_SRGB:
+ return VK_FORMAT_B8G8R8A8_UNORM;
+ case VK_FORMAT_A8B8G8R8_SRGB_PACK32:
+ return VK_FORMAT_A8B8G8R8_UNORM_PACK32;
+ default:
+ return format;
}
}
projects / mesa.git / commitdiff