mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2025-06-06 07:28:53 +00:00
Code Issues 1 Projects Releases Wiki Activity

vulkan: use c99 designated initializers where possible

Browse source 
Makes the code much easier to read and allows removing our terrible
macros for structure initialization.
This commit is contained in:
Matthew Waters 2019-05-09 21:50:47 +10:00
parent b02493091b
commit d61e771c37
7 changed files with 305 additions and 307 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

233
ext/vulkan/vkswapper.c
View file

@ -527,19 +527,25 @@ _swapper_set_image_layout (GstVulkanSwapper * swapper,
VkCommandBufferInheritanceInfo buf_inh = { 0, }; VkCommandBufferInheritanceInfo buf_inh = { 0, };
VkCommandBufferBeginInfo cmd_buf_info = { 0, }; VkCommandBufferBeginInfo cmd_buf_info = { 0, };
buf_inh.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO; /* *INDENT-OFF* */
buf_inh.pNext = NULL; buf_inh = (VkCommandBufferInheritanceInfo) {
buf_inh.renderPass = VK_NULL_HANDLE; .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
buf_inh.subpass = 0; .pNext = NULL,
buf_inh.framebuffer = VK_NULL_HANDLE; .renderPass = VK_NULL_HANDLE,
buf_inh.occlusionQueryEnable = FALSE; .subpass = 0,
buf_inh.queryFlags = 0; .framebuffer = VK_NULL_HANDLE,
buf_inh.pipelineStatistics = 0; .occlusionQueryEnable = FALSE,
.queryFlags = 0,
.pipelineStatistics = 0
};
cmd_buf_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; cmd_buf_info = (VkCommandBufferBeginInfo) {
cmd_buf_info.pNext = NULL; .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
cmd_buf_info.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT; .pNext = NULL,
cmd_buf_info.pInheritanceInfo = &buf_inh; .flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
.pInheritanceInfo = &buf_inh
};
/* *INDENT-ON* */
err = vkBeginCommandBuffer (cmd, &cmd_buf_info); err = vkBeginCommandBuffer (cmd, &cmd_buf_info);
if (gst_vulkan_error_to_g_error (err, error, "vkBeginCommandBuffer") < 0) if (gst_vulkan_error_to_g_error (err, error, "vkBeginCommandBuffer") < 0)
@ -558,15 +564,19 @@ _swapper_set_image_layout (GstVulkanSwapper * swapper,
VkSubmitInfo submit_info = { 0, }; VkSubmitInfo submit_info = { 0, };
VkPipelineStageFlags stages = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT; VkPipelineStageFlags stages = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; /* *INDENT-OFF* */
submit_info.pNext = NULL; submit_info = (VkSubmitInfo) {
submit_info.waitSemaphoreCount = 0; .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
submit_info.pWaitSemaphores = NULL; .pNext = NULL,
submit_info.pWaitDstStageMask = &stages; .waitSemaphoreCount = 0,
submit_info.commandBufferCount = 1; .pWaitSemaphores = NULL,
submit_info.pCommandBuffers = &cmd; .pWaitDstStageMask = &stages,
submit_info.signalSemaphoreCount = 0; .commandBufferCount = 1,
submit_info.pSignalSemaphores = NULL; .pCommandBuffers = &cmd,
.signalSemaphoreCount = 0,
.pSignalSemaphores = NULL,
};
/* *INDENT-ON* */
err = err =
vkQueueSubmit (swapper->queue->queue, 1, &submit_info, vkQueueSubmit (swapper->queue->queue, 1, &submit_info,
@ -701,23 +711,27 @@ _allocate_swapchain (GstVulkanSwapper * swapper, GstCaps * caps,
old_swap_chain = swapper->swap_chain; old_swap_chain = swapper->swap_chain;
swap_chain_info.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR; /* *INDENT-OFF* */
swap_chain_info.pNext = NULL; swap_chain_info = (VkSwapchainCreateInfoKHR) {
swap_chain_info.surface = swapper->surface; .sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR,
swap_chain_info.minImageCount = n_images_wanted; .pNext = NULL,
swap_chain_info.imageFormat = format; .surface = swapper->surface,
swap_chain_info.imageColorSpace = color_space; .minImageCount = n_images_wanted,
swap_chain_info.imageExtent = swapchain_dims; .imageFormat = format,
swap_chain_info.imageArrayLayers = 1; .imageColorSpace = color_space,
swap_chain_info.imageUsage = usage; .imageExtent = swapchain_dims,
swap_chain_info.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE; .imageArrayLayers = 1,
swap_chain_info.queueFamilyIndexCount = 0; .imageUsage = usage,
swap_chain_info.pQueueFamilyIndices = NULL; .imageSharingMode = VK_SHARING_MODE_EXCLUSIVE,
swap_chain_info.preTransform = preTransform; .queueFamilyIndexCount = 0,
swap_chain_info.presentMode = present_mode; .pQueueFamilyIndices = NULL,
swap_chain_info.compositeAlpha = alpha_flags; .preTransform = preTransform,
swap_chain_info.clipped = TRUE; .presentMode = present_mode,
swap_chain_info.oldSwapchain = swapper->swap_chain; .compositeAlpha = alpha_flags,
.clipped = TRUE,
.oldSwapchain = old_swap_chain
};
/* *INDENT-ON* */
err = err =
swapper->CreateSwapchainKHR (swapper->device->device, &swap_chain_info, swapper->CreateSwapchainKHR (swapper->device->device, &swap_chain_info,
@ -823,19 +837,25 @@ _build_render_buffer_cmd (GstVulkanSwapper * swapper, guint32 swap_idx,
VkCommandBufferInheritanceInfo buf_inh = { 0, }; VkCommandBufferInheritanceInfo buf_inh = { 0, };
VkCommandBufferBeginInfo cmd_buf_info = { 0, }; VkCommandBufferBeginInfo cmd_buf_info = { 0, };
buf_inh.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO; /* *INDENT-OFF* */
buf_inh.pNext = NULL; buf_inh = (VkCommandBufferInheritanceInfo) {
buf_inh.renderPass = VK_NULL_HANDLE; .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
buf_inh.subpass = 0; .pNext = NULL,
buf_inh.framebuffer = VK_NULL_HANDLE; .renderPass = VK_NULL_HANDLE,
buf_inh.occlusionQueryEnable = FALSE; .subpass = 0,
buf_inh.queryFlags = 0; .framebuffer = VK_NULL_HANDLE,
buf_inh.pipelineStatistics = 0; .occlusionQueryEnable = FALSE,
.queryFlags = 0,
.pipelineStatistics = 0
};
cmd_buf_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; cmd_buf_info = (VkCommandBufferBeginInfo) {
cmd_buf_info.pNext = NULL; .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
cmd_buf_info.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT; .pNext = NULL,
cmd_buf_info.pInheritanceInfo = &buf_inh; .flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
.pInheritanceInfo = &buf_inh
};
/* *INDENT-ON* */
err = vkBeginCommandBuffer (cmd, &cmd_buf_info); err = vkBeginCommandBuffer (cmd, &cmd_buf_info);
if (gst_vulkan_error_to_g_error (err, error, "vkBeginCommandBuffer") < 0) if (gst_vulkan_error_to_g_error (err, error, "vkBeginCommandBuffer") < 0)
@ -866,10 +886,25 @@ _build_render_buffer_cmd (GstVulkanSwapper * swapper, guint32 swap_idx,
GstVulkanBufferMemory *buf_mem = (GstVulkanBufferMemory *) in_mem; GstVulkanBufferMemory *buf_mem = (GstVulkanBufferMemory *) in_mem;
VkBufferImageCopy region = { 0, }; VkBufferImageCopy region = { 0, };
GST_VK_BUFFER_IMAGE_COPY (region, 0, src.w, src.h, /* *INDENT-OFF* */
GST_VK_IMAGE_SUBRESOURCE_LAYERS_INIT (VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, region = (VkBufferImageCopy) {
1), GST_VK_OFFSET3D_INIT (rslt.x, rslt.y, 0), .bufferOffset = 0,
GST_VK_EXTENT3D_INIT (rslt.w, rslt.h, 1)); .bufferRowLength = src.w,
.bufferImageHeight = src.h,
.imageSubresource = {
.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
.mipLevel = 0,
.baseArrayLayer = 0,
.layerCount = 1,
},
.imageOffset = { .x = rslt.x, .y = rslt.y, .z = 0, },
.imageExtent = {
.width = rslt.w,
.height = rslt.h,
.depth = 1,
}
};
/* *INDENT-ON* */
vkCmdCopyBufferToImage (cmd, buf_mem->buffer, swap_mem->image, vkCmdCopyBufferToImage (cmd, buf_mem->buffer, swap_mem->image,
swap_mem->image_layout, 1, &region); swap_mem->image_layout, 1, &region);
@ -878,12 +913,25 @@ _build_render_buffer_cmd (GstVulkanSwapper * swapper, guint32 swap_idx,
VkImageCopy region = { 0, }; VkImageCopy region = { 0, };
/* FIXME: should really be a blit to resize to the output dimensions */ /* FIXME: should really be a blit to resize to the output dimensions */
GST_VK_IMAGE_COPY (region, /* *INDENT-OFF* */
GST_VK_IMAGE_SUBRESOURCE_LAYERS_INIT (VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, region = (VkImageCopy) {
1), GST_VK_OFFSET3D_INIT (src.x, src.y, 0), .srcSubresource = {
GST_VK_IMAGE_SUBRESOURCE_LAYERS_INIT (VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
1), GST_VK_OFFSET3D_INIT (rslt.x, rslt.y, 0), .mipLevel = 0,
GST_VK_EXTENT3D_INIT (rslt.w, rslt.h, 1)); .baseArrayLayer = 0,
.layerCount = 1,
},
.srcOffset = { src.x, src.y, 0 },
.dstSubresource = {
.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
.mipLevel = 0,
.baseArrayLayer = 0,
.layerCount = 1,
},
.dstOffset = { rslt.x, rslt.y, 0 },
.extent = { rslt.w, rslt.h, 1 }
};
/* *INDENT-ON* */
if (!_swapper_set_image_layout_with_cmd (swapper, cmd, img_mem, if (!_swapper_set_image_layout_with_cmd (swapper, cmd, img_mem,
VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, error)) { VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, error)) {
@ -924,10 +972,6 @@ _render_buffer_unlocked (GstVulkanSwapper * swapper,
swapper->priv->trash_list = swapper->priv->trash_list =
gst_vulkan_trash_list_gc (swapper->priv->trash_list); gst_vulkan_trash_list_gc (swapper->priv->trash_list);
semaphore_info.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
semaphore_info.pNext = NULL;
semaphore_info.flags = 0;
if (!buffer) { if (!buffer) {
g_set_error (error, GST_VULKAN_ERROR, g_set_error (error, GST_VULKAN_ERROR,
VK_ERROR_INITIALIZATION_FAILED, "Invalid buffer"); VK_ERROR_INITIALIZATION_FAILED, "Invalid buffer");
@ -942,6 +986,14 @@ _render_buffer_unlocked (GstVulkanSwapper * swapper,
gst_buffer_replace (&swapper->current_buffer, buffer); gst_buffer_replace (&swapper->current_buffer, buffer);
/* *INDENT-OFF* */
semaphore_info = (VkSemaphoreCreateInfo) {
.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
.pNext = NULL,
.flags = 0,
};
/* *INDENT-ON* */
reacquire: reacquire:
err = vkCreateSemaphore (swapper->device->device, &semaphore_info, err = vkCreateSemaphore (swapper->device->device, &semaphore_info,
NULL, &acquire_semaphore); NULL, &acquire_semaphore);
@ -973,18 +1025,22 @@ reacquire:
goto error; goto error;
{ {
VkSubmitInfo submit_info = { 0, };
VkPipelineStageFlags stages = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT; VkPipelineStageFlags stages = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
VkSubmitInfo submit_info = { 0, };
submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; /* *INDENT-OFF* */
submit_info.pNext = NULL; submit_info = (VkSubmitInfo) {
submit_info.waitSemaphoreCount = 1; .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
submit_info.pWaitSemaphores = &acquire_semaphore; .pNext = NULL,
submit_info.pWaitDstStageMask = &stages; .waitSemaphoreCount = 1,
submit_info.commandBufferCount = 1; .pWaitSemaphores = &acquire_semaphore,
submit_info.pCommandBuffers = &cmd; .pWaitDstStageMask = &stages,
submit_info.signalSemaphoreCount = 1; .commandBufferCount = 1,
submit_info.pSignalSemaphores = &present_semaphore; .pCommandBuffers = &cmd,
.signalSemaphoreCount = 1,
.pSignalSemaphores = &present_semaphore,
};
/* *INDENT-ON* */
fence = gst_vulkan_fence_new (swapper->device, 0, error); fence = gst_vulkan_fence_new (swapper->device, 0, error);
if (!fence) if (!fence)
@ -1006,14 +1062,18 @@ reacquire:
fence = NULL; fence = NULL;
} }
present.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR; /* *INDENT-OFF* */
present.pNext = NULL; present = (VkPresentInfoKHR) {
present.waitSemaphoreCount = 1; .sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
present.pWaitSemaphores = &present_semaphore; .pNext = NULL,
present.swapchainCount = 1; .waitSemaphoreCount = 1,
present.pSwapchains = &swapper->swap_chain; .pWaitSemaphores = &present_semaphore,
present.pImageIndices = &swap_idx; .swapchainCount = 1,
present.pResults = &present_err; .pSwapchains = &swapper->swap_chain,
.pImageIndices = &swap_idx,
.pResults = &present_err,
};
/* *INDENT-ON* */
err = swapper->QueuePresentKHR (swapper->queue->queue, &present); err = swapper->QueuePresentKHR (swapper->queue->queue, &present);
if (gst_vulkan_error_to_g_error (err, error, "vkQueuePresentKHR") < 0) if (gst_vulkan_error_to_g_error (err, error, "vkQueuePresentKHR") < 0)
@ -1031,8 +1091,13 @@ reacquire:
VkSubmitInfo submit_info = { 0, }; VkSubmitInfo submit_info = { 0, };
VkPipelineStageFlags stages = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT; VkPipelineStageFlags stages = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; /* *INDENT-OFF* */
submit_info.pWaitDstStageMask = &stages; submit_info = (VkSubmitInfo) {
.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
.pWaitDstStageMask = &stages,
0,
};
/* *INDENT-ON* */
fence = gst_vulkan_fence_new (swapper->device, 0, error); fence = gst_vulkan_fence_new (swapper->device, 0, error);
if (!fence) if (!fence)

80
ext/vulkan/vkupload.c
View file

@ -479,19 +479,25 @@ _buffer_to_image_perform (gpointer impl, GstBuffer * inbuf, GstBuffer ** outbuf)
VkCommandBufferInheritanceInfo buf_inh = { 0, }; VkCommandBufferInheritanceInfo buf_inh = { 0, };
VkCommandBufferBeginInfo cmd_buf_info = { 0, }; VkCommandBufferBeginInfo cmd_buf_info = { 0, };
buf_inh.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO; /* *INDENT-OFF* */
buf_inh.pNext = NULL; buf_inh = (VkCommandBufferInheritanceInfo) {
buf_inh.renderPass = VK_NULL_HANDLE; .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
buf_inh.subpass = 0; .pNext = NULL,
buf_inh.framebuffer = VK_NULL_HANDLE; .renderPass = VK_NULL_HANDLE,
buf_inh.occlusionQueryEnable = FALSE; .subpass = 0,
buf_inh.queryFlags = 0; .framebuffer = VK_NULL_HANDLE,
buf_inh.pipelineStatistics = 0; .occlusionQueryEnable = FALSE,
.queryFlags = 0,
.pipelineStatistics = 0
};
cmd_buf_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; cmd_buf_info = (VkCommandBufferBeginInfo) {
cmd_buf_info.pNext = NULL; .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
cmd_buf_info.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT; .pNext = NULL,
cmd_buf_info.pInheritanceInfo = &buf_inh; .flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
.pInheritanceInfo = &buf_inh
};
/* *INDENT-ON* */
err = vkBeginCommandBuffer (cmd, &cmd_buf_info); err = vkBeginCommandBuffer (cmd, &cmd_buf_info);
if (gst_vulkan_error_to_g_error (err, &error, "vkBeginCommandBuffer") < 0) if (gst_vulkan_error_to_g_error (err, &error, "vkBeginCommandBuffer") < 0)
@ -499,7 +505,7 @@ _buffer_to_image_perform (gpointer impl, GstBuffer * inbuf, GstBuffer ** outbuf)
} }
for (i = 0; i < GST_VIDEO_INFO_N_PLANES (&raw->out_info); i++) { for (i = 0; i < GST_VIDEO_INFO_N_PLANES (&raw->out_info); i++) {
VkBufferImageCopy region = { 0, }; VkBufferImageCopy region;
GstMemory *in_mem, *out_mem; GstMemory *in_mem, *out_mem;
GstVulkanBufferMemory *buf_mem; GstVulkanBufferMemory *buf_mem;
GstVulkanImageMemory *img_mem; GstVulkanImageMemory *img_mem;
@ -519,13 +525,25 @@ _buffer_to_image_perform (gpointer impl, GstBuffer * inbuf, GstBuffer ** outbuf)
} }
img_mem = (GstVulkanImageMemory *) out_mem; img_mem = (GstVulkanImageMemory *) out_mem;
GST_VK_BUFFER_IMAGE_COPY (region, 0, /* *INDENT-OFF* */
GST_VIDEO_INFO_COMP_WIDTH (&raw->in_info, i), region = (VkBufferImageCopy) {
GST_VIDEO_INFO_COMP_HEIGHT (&raw->in_info, i), .bufferOffset = 0,
GST_VK_IMAGE_SUBRESOURCE_LAYERS_INIT (VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, .bufferRowLength = GST_VIDEO_INFO_COMP_WIDTH (&raw->in_info, i),
1), GST_VK_OFFSET3D_INIT (0, 0, 0), .bufferImageHeight = GST_VIDEO_INFO_COMP_HEIGHT (&raw->in_info, i),
GST_VK_EXTENT3D_INIT (GST_VIDEO_INFO_COMP_WIDTH (&raw->out_info, i), .imageSubresource = {
GST_VIDEO_INFO_COMP_HEIGHT (&raw->out_info, i), 1)); .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
.mipLevel = 0,
.baseArrayLayer = 0,
.layerCount = 1,
},
.imageOffset = { .x = 0, .y = 0, .z = 0, },
.imageExtent = {
.width = GST_VIDEO_INFO_COMP_WIDTH (&raw->out_info, i),
.height = GST_VIDEO_INFO_COMP_HEIGHT (&raw->out_info, i),
.depth = 1,
}
};
/* *INDENT-ON* */
gst_vulkan_image_memory_set_layout (img_mem, gst_vulkan_image_memory_set_layout (img_mem,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &image_memory_barrier); VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &image_memory_barrier);
@ -547,15 +565,19 @@ _buffer_to_image_perform (gpointer impl, GstBuffer * inbuf, GstBuffer ** outbuf)
VkPipelineStageFlags stages = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT; VkPipelineStageFlags stages = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
GstVulkanFence *fence; GstVulkanFence *fence;
submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; /* *INDENT-OFF* */
submit_info.pNext = NULL; submit_info = (VkSubmitInfo) {
submit_info.waitSemaphoreCount = 0; .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
submit_info.pWaitSemaphores = NULL; .pNext = NULL,
submit_info.pWaitDstStageMask = &stages; .waitSemaphoreCount = 0,
submit_info.commandBufferCount = 1; .pWaitSemaphores = NULL,
submit_info.pCommandBuffers = &cmd; .pWaitDstStageMask = &stages,
submit_info.signalSemaphoreCount = 0; .commandBufferCount = 1,
submit_info.pSignalSemaphores = NULL; .pCommandBuffers = &cmd,
.signalSemaphoreCount = 0,
.pSignalSemaphores = NULL
};
/* *INDENT-ON* */
fence = gst_vulkan_fence_new (raw->upload->device, 0, &error); fence = gst_vulkan_fence_new (raw->upload->device, 0, &error);
if (!fence) if (!fence)

41
gst-libs/gst/vulkan/gstvkbuffermemory.c
View file

@ -39,31 +39,27 @@ GST_DEBUG_CATEGORY_STATIC (GST_CAT_DEFUALT);
static GstAllocator *_vulkan_buffer_memory_allocator; static GstAllocator *_vulkan_buffer_memory_allocator;
#define GST_VK_BUFFER_CREATE_INFO_INIT GST_VK_STRUCT_8
#define GST_VK_BUFFER_CREATE_INFO(info, pNext, flags, size, usage, sharingMode, queueFamilyIndexCount, pQueueFamilyIndices ) \
G_STMT_START { \
VkBufferCreateInfo tmp = GST_VK_BUFFER_CREATE_INFO_INIT (VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, pNext, flags, size, usage, sharingMode, queueFamilyIndexCount, pQueueFamilyIndices); \
(info) = tmp; \
} G_STMT_END
static gboolean static gboolean
_create_info_from_args (VkBufferCreateInfo * info, gsize size, _create_info_from_args (VkBufferCreateInfo * info, gsize size,
VkBufferUsageFlags usage) VkBufferUsageFlags usage)
{ {
/* FIXME: validate these */ /* FIXME: validate these */
GST_VK_BUFFER_CREATE_INFO (*info, NULL, 0, size, usage, /* *INDENT-OFF* */
VK_SHARING_MODE_EXCLUSIVE, 0, NULL); *info = (VkBufferCreateInfo) {
.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
.pNext = NULL,
.flags = 0,
.size = size,
.usage = usage,
.sharingMode = VK_SHARING_MODE_EXCLUSIVE,
.queueFamilyIndexCount = 0,
.pQueueFamilyIndices = NULL,
};
/* *INDENT-ON* */
return TRUE; return TRUE;
} }
#define GST_VK_BUFFER_VIEW_CREATE_INFO_INIT GST_VK_STRUCT_7
#define GST_VK_BUFFER_VIEW_CREATE_INFO(info, pNext, flags, buffer, format, offset, range) \
G_STMT_START { \
VkBufferViewCreateInfo tmp = GST_VK_BUFFER_VIEW_CREATE_INFO_INIT (VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO, pNext, flags, buffer, format, offset, range); \
(info) = tmp; \
} G_STMT_END
static gboolean static gboolean
_create_view_from_args (VkBufferViewCreateInfo * info, VkBuffer buffer, _create_view_from_args (VkBufferViewCreateInfo * info, VkBuffer buffer,
VkFormat format, gsize offset, gsize range) VkFormat format, gsize offset, gsize range)
@ -71,8 +67,17 @@ _create_view_from_args (VkBufferViewCreateInfo * info, VkBuffer buffer,
/* FIXME: validate these */ /* FIXME: validate these */
g_assert (format != VK_FORMAT_UNDEFINED); g_assert (format != VK_FORMAT_UNDEFINED);
GST_VK_BUFFER_VIEW_CREATE_INFO (*info, NULL, 0, buffer, format, offset, /* *INDENT-OFF* */
range); *info = (VkBufferViewCreateInfo) {
.sType = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO,
.pNext = NULL,
.flags = 0,
.buffer = buffer,
.format = format,
.offset = offset,
.range = range,
};
/* *INDENT-ON* */
return TRUE; return TRUE;
} }

99
gst-libs/gst/vulkan/gstvkimagememory.c
View file

@ -114,17 +114,29 @@ gst_vulkan_format_from_video_format (GstVideoFormat v_format, guint plane)
static void static void
_view_create_info (VkImage image, VkFormat format, VkImageViewCreateInfo * info) _view_create_info (VkImage image, VkFormat format, VkImageViewCreateInfo * info)
{ {
info->sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO; /* *INDENT-OFF* */
info->pNext = NULL; *info = (VkImageViewCreateInfo) {
info->image = image; .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
info->format = format; .pNext = NULL,
info->viewType = VK_IMAGE_VIEW_TYPE_2D; .image = image,
info->flags = 0; .format = format,
.viewType = VK_IMAGE_VIEW_TYPE_2D,
GST_VK_COMPONENT_MAPPING (info->components, VK_COMPONENT_SWIZZLE_R, .flags = 0,
VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_A); .components = (VkComponentMapping) {
GST_VK_IMAGE_SUBRESOURCE_RANGE (info->subresourceRange, VK_COMPONENT_SWIZZLE_R,
VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1); VK_COMPONENT_SWIZZLE_G,
VK_COMPONENT_SWIZZLE_B,
VK_COMPONENT_SWIZZLE_A
},
.subresourceRange = (VkImageSubresourceRange) {
.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
.baseMipLevel = 0,
.levelCount = 1,
.baseArrayLayer = 0,
.layerCount = 1,
}
};
/* *INDENT-ON* */
} }
static gboolean static gboolean
@ -133,21 +145,25 @@ _create_info_from_args (VkImageCreateInfo * info, VkFormat format, gsize width,
{ {
/* FIXME: validate these */ /* FIXME: validate these */
info->sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO; /* *INDENT-OFF* */
info->pNext = NULL; *info = (VkImageCreateInfo) {
info->flags = 0; .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
info->imageType = VK_IMAGE_TYPE_2D; .pNext = NULL,
info->format = format; .flags = 0,
GST_VK_EXTENT3D (info->extent, width, height, 1); .imageType = VK_IMAGE_TYPE_2D,
info->mipLevels = 1; .format = format,
info->arrayLayers = 1; .extent = (VkExtent3D) { width, height, 1 },
info->samples = VK_SAMPLE_COUNT_1_BIT; .mipLevels = 1,
info->tiling = tiling; .arrayLayers = 1,
info->usage = usage; .samples = VK_SAMPLE_COUNT_1_BIT,
info->sharingMode = VK_SHARING_MODE_EXCLUSIVE; .tiling = tiling,
info->queueFamilyIndexCount = 0; .usage = usage,
info->pQueueFamilyIndices = NULL; .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
info->initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; .queueFamilyIndexCount = 0,
.pQueueFamilyIndices = NULL,
.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED,
};
/* *INDENT-ON* */
return TRUE; return TRUE;
} }
@ -462,17 +478,26 @@ gst_vulkan_image_memory_set_layout (GstVulkanImageMemory * vk_mem,
{ {
/* validate vk_mem->usage with image_layout */ /* validate vk_mem->usage with image_layout */
barrier->sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER; /* *INDENT-OFF* */
barrier->pNext = NULL; *barrier = (VkImageMemoryBarrier) {
barrier->dstAccessMask = _access_flags_from_layout (image_layout); .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
barrier->srcAccessMask = _access_flags_from_layout (vk_mem->image_layout); .pNext = NULL,
barrier->oldLayout = vk_mem->image_layout; .dstAccessMask = _access_flags_from_layout (image_layout),
barrier->newLayout = image_layout; .srcAccessMask = _access_flags_from_layout (vk_mem->image_layout),
barrier->srcQueueFamilyIndex = 0; .oldLayout = vk_mem->image_layout,
barrier->dstQueueFamilyIndex = 0; .newLayout = image_layout,
barrier->image = vk_mem->image; .srcQueueFamilyIndex = 0,
GST_VK_IMAGE_SUBRESOURCE_RANGE (barrier->subresourceRange, .dstQueueFamilyIndex = 0,
VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1); .image = vk_mem->image,
.subresourceRange = (VkImageSubresourceRange) {
.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
.baseMipLevel = 0,
.levelCount = 1,
.baseArrayLayer = 0,
.layerCount = 1
}
};
/* *INDENT-ON* */
/* FIXME: what if the barrier is never submitted or is submitted out of order? */ /* FIXME: what if the barrier is never submitted or is submitted out of order? */
vk_mem->image_layout = image_layout; vk_mem->image_layout = image_layout;

34
gst-libs/gst/vulkan/gstvkinstance.c
View file

@ -294,21 +294,27 @@ gst_vulkan_instance_open (GstVulkanInstance * instance, GError ** error)
VkApplicationInfo app = { 0, }; VkApplicationInfo app = { 0, };
VkInstanceCreateInfo inst_info = { 0, }; VkInstanceCreateInfo inst_info = { 0, };
app.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO; /* *INDENT-OFF* */
app.pNext = NULL; app = (VkApplicationInfo) {
app.pApplicationName = APP_SHORT_NAME; .sType = VK_STRUCTURE_TYPE_APPLICATION_INFO,
app.applicationVersion = 0; .pNext = NULL,
app.pEngineName = APP_SHORT_NAME; .pApplicationName = APP_SHORT_NAME,
app.engineVersion = 0; .applicationVersion = 0,
app.apiVersion = VK_API_VERSION_1_0; .pEngineName = APP_SHORT_NAME,
.engineVersion = 0,
.apiVersion = VK_API_VERSION_1_0
};
inst_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; inst_info = (VkInstanceCreateInfo) {
inst_info.pNext = NULL; .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
inst_info.pApplicationInfo = &app; .pNext = NULL,
inst_info.enabledLayerCount = 0; .pApplicationInfo = &app,
inst_info.ppEnabledLayerNames = NULL; .enabledLayerCount = 0,
inst_info.enabledExtensionCount = enabled_extension_count; .ppEnabledLayerNames = NULL,
inst_info.ppEnabledExtensionNames = (const char *const *) extension_names; .enabledExtensionCount = enabled_extension_count,
.ppEnabledExtensionNames = (const char *const *) extension_names
};
/* *INDENT-ON* */
err = vkCreateInstance (&inst_info, NULL, &instance->instance); err = vkCreateInstance (&inst_info, NULL, &instance->instance);
if (gst_vulkan_error_to_g_error (err, error, "vkCreateInstance") < 0) { if (gst_vulkan_error_to_g_error (err, error, "vkCreateInstance") < 0) {

124
gst-libs/gst/vulkan/gstvkmacros.h
View file

@ -1,124 +0,0 @@
/*
* GStreamer
* Copyright (C) 2015 Matthew Waters <matthew@centricular.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#ifndef __GST_VULKAN_MACROS_H__
#define __GST_VULKAN_MACROS_H__
#include <gst/gst.h>
#include <gst/vulkan/vulkan.h>
G_BEGIN_DECLS
#define GST_VK_STRUCT_1(a) \
{ a }
#define GST_VK_STRUCT_2(a, b) \
{ a, b }
#define GST_VK_STRUCT_3(a, b, c) \
{ a, b, c }
#define GST_VK_STRUCT_4(a, b, c, d) \
{ a, b, c, d }
#define GST_VK_STRUCT_5(a, b, c, d, e) \
{ a, b, c, d, e }
#define GST_VK_STRUCT_6(a, b, c, d, e, f) \
{ a, b, c, d, e, f }
#define GST_VK_STRUCT_7(a, b, c, d, e, f, g) \
{ a, b, c, d, e, f, g }
#define GST_VK_STRUCT_8(a, b, c, d, e, f, g, h) \
{ a, b, c, d, e, f, g, h }
#define GST_VK_BUFFER_IMAGE_COPY_INIT GST_VK_STRUCT_6
#define GST_VK_BUFFER_IMAGE_COPY(info,bufferOffset_,bufferRowLength_,bufferImageHeight_,imageSubresourceLayers_,imageOffset_,imageExtent_) \
G_STMT_START { \
VkImageSubresourceLayers sub = imageSubresourceLayers_; \
VkOffset3D offset = imageOffset_; \
VkExtent3D extent = imageExtent_; \
VkBufferImageCopy tmp = GST_VK_BUFFER_IMAGE_COPY_INIT(bufferOffset_,bufferRowLength_,bufferImageHeight_,sub,offset,extent); \
(region) = tmp; \
} G_STMT_END
#define GST_VK_COMPONENT_MAPPING_INIT GST_VK_STRUCT_4
#define GST_VK_COMPONENT_MAPPING(component, r_, g_, b_, a_) \
G_STMT_START { \
VkComponentMapping tmp = GST_VK_COMPONENT_MAPPING_INIT(r_, g_, b_, a_); \
(component) = tmp; \
} G_STMT_END
#define GST_VK_EXTENT3D_INIT GST_VK_STRUCT_3
#define GST_VK_EXTENT3D(extent,w,h,d) \
G_STMT_START { \
VkExtent3D tmp = GST_VK_EXTENT3D_INIT(w,h,d); \
(extent) = tmp; \
} G_STMT_END
#define GST_VK_IMAGE_COPY_INIT GST_VK_STRUCT_5
#define GST_VK_IMAGE_COPY(copy,srcSubresource_,srcOffset_,dstSubresource_,dstOffset_,extent_) \
G_STMT_START { \
VkImageSubresourceLayers src_res = srcSubresource_; \
VkOffset3D src_offset = srcOffset_; \
VkImageSubresourceLayers dst_res = dstSubresource_; \
VkOffset3D dst_offset = dstOffset_; \
VkExtent3D ext = extent_; \
VkImageCopy tmp = GST_VK_IMAGE_COPY_INIT(src_res,src_offset,dst_res,dst_offset,ext); \
(copy) = tmp; \
} G_STMT_END
#define GST_VK_IMAGE_BLIT_INIT GST_VK_STRUCT_6
#define GST_VK_IMAGE_BLIT(blit,srcSubresource_,srcOffset_,srcExtent_,dstSubresource_,dstOffset_,dstExtent_) \
G_STMT_START { \
VkImageSubresourceLayers src_res = srcSubresource_; \
VkOffset3D src_offset = srcOffset; \
VkExtent3D src_ext = srcExtent_; \
VkImageSubresourceLayers dst_res = dstSubresource_; \
VkOffset3D dst_offset = dstSubresource_; \
VkExtent3D dst_ext = dstExtent_; \
VkImageBlit tmp = GST_VK_IMAGE_BLIT_INIT(src_res, src_offset, src_ext, dst_res, dst_offset, dst_ext); \
(blit) = tmp; \
} G_STMT_END
#define GST_VK_IMAGE_SUBRESOURCE_INIT GST_VK_STRUCT_3
#define GST_VK_IMAGE_SUBRESOURCE(subresource,aspectMast,mipLevel,arrayLayer) \
G_STMT_START { \
VkImageSubresource tmp = GST_VK_IMAGE_SUBRESOURCE_INIT(aspectMast,mipLevel,arrayLayer); \
(subresource) = tmp; \
} G_STMT_END
#define GST_VK_IMAGE_SUBRESOURCE_LAYERS_INIT GST_VK_STRUCT_4
#define GST_VK_IMAGE_SUBRESOURCE_LAYERS(res,aspect_,mip,base_layer,layer_count) \
G_STMT_START { \
VkImageSubresourceLayers tmp = GST_VK_IMAGE_SUBRESOURCE_LAYERS_INIT(aspect_,mip,base_layer,layer_count); \
(res) = tmp; \
} G_STMT_END
#define GST_VK_IMAGE_SUBRESOURCE_RANGE_INIT GST_VK_STRUCT_5
#define GST_VK_IMAGE_SUBRESOURCE_RANGE(range, aspect, mip_lvl, mip_lvl_count, array, layer_count) \
G_STMT_START { \
VkImageSubresourceRange tmp = GST_VK_IMAGE_SUBRESOURCE_RANGE_INIT(aspect,mip_lvl,mip_lvl_count,array,layer_count); \
(range) = tmp; \
} G_STMT_END
#define GST_VK_OFFSET3D_INIT GST_VK_STRUCT_3
#define GST_VK_OFFSET3D(offset,x_,y_,z_) \
G_STMT_START { \
VkOffset3D tmp = GST_VK_OFFSET3D_INIT (x_,y_,z_); \
(offset) = tmp; \
} G_STMT_END
G_END_DECLS
#endif /*__GST_VULKAN_MACROS_H__ */

1
gst-libs/gst/vulkan/vulkan.h
View file

@ -24,7 +24,6 @@
#include <gst/gst.h> #include <gst/gst.h>
#include <gst/vulkan/gstvkapi.h> #include <gst/vulkan/gstvkapi.h>
#include <gst/vulkan/gstvkmacros.h>
#include <gst/vulkan/gstvkerror.h> #include <gst/vulkan/gstvkerror.h>
#include <gst/vulkan/gstvkinstance.h> #include <gst/vulkan/gstvkinstance.h>