mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2025-02-02 20:42:30 +00:00
Code Issues 1 Projects Releases Wiki Activity

vulkan: de-C99 struct declarations

Browse source
This commit is contained in:
Matthew Waters 2015-12-02 17:10:39 +11:00
parent a4476fa24b
commit 074cb047ef
3 changed files with 111 additions and 111 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

61
ext/vulkan/vkdevice.c
View file

@ -269,35 +269,37 @@ gst_vulkan_device_open (GstVulkanDevice * device, GError ** error)
device->n_queues = 1; device->n_queues = 1;
{ {
const VkDeviceQueueCreateInfo queue_info = { VkDeviceQueueCreateInfo queue_info = { 0, };
.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, VkDeviceCreateInfo device_info = { 0, };
.pNext = NULL,
.queueFamilyIndex = device->queue_family_id, queue_info.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
.queueCount = device->n_queues, queue_info.pNext = NULL;
}; queue_info.queueFamilyIndex = device->queue_family_id;
VkDeviceCreateInfo device_info = { queue_info.queueCount = device->n_queues;
.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
.pNext = NULL, device_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
.queueRecordCount = 1, device_info.pNext = NULL;
.pRequestedQueues = &queue_info, device_info.queueRecordCount = 1;
.layerCount = enabled_layer_count, device_info.pRequestedQueues = &queue_info;
.ppEnabledLayerNames = (const char *const *) device_validation_layers, device_info.layerCount = enabled_layer_count;
.extensionCount = enabled_extension_count, device_info.ppEnabledLayerNames =
.ppEnabledExtensionNames = (const char *const *) extension_names, (const char *const *) device_validation_layers;
.pEnabledFeatures = NULL, // If specific features are required, pass them in here device_info.extensionCount = enabled_extension_count;
}; device_info.ppEnabledExtensionNames = (const char *const *) extension_names;
device_info.pEnabledFeatures = NULL;
err = vkCreateDevice (gpu, &device_info, &device->device); err = vkCreateDevice (gpu, &device_info, &device->device);
if (gst_vulkan_error_to_g_error (err, error, "vkCreateDevice") < 0) if (gst_vulkan_error_to_g_error (err, error, "vkCreateDevice") < 0)
return FALSE; return FALSE;
} }
{ {
const VkCmdPoolCreateInfo cmd_pool_info = { VkCmdPoolCreateInfo cmd_pool_info = { 0, };
.sType = VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO,
.pNext = NULL, cmd_pool_info.sType = VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO;
.queueFamilyIndex = device->queue_family_id, cmd_pool_info.pNext = NULL;
.flags = 0, cmd_pool_info.queueFamilyIndex = device->queue_family_id;
}; cmd_pool_info.flags = 0;
err = err =
vkCreateCommandPool (device->device, &cmd_pool_info, &device->cmd_pool); vkCreateCommandPool (device->device, &cmd_pool_info, &device->cmd_pool);
if (gst_vulkan_error_to_g_error (err, error, "vkCreateCommandPool") < 0) if (gst_vulkan_error_to_g_error (err, error, "vkCreateCommandPool") < 0)
@ -373,14 +375,13 @@ gst_vulkan_device_create_cmd_buffer (GstVulkanDevice * device,
VkCmdBuffer * cmd, GError ** error) VkCmdBuffer * cmd, GError ** error)
{ {
VkResult err; VkResult err;
VkCmdBufferCreateInfo cmd_info = { 0, };
const VkCmdBufferCreateInfo cmd_info = { cmd_info.sType = VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO;
.sType = VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO, cmd_info.pNext = NULL;
.pNext = NULL, cmd_info.cmdPool = device->cmd_pool;
.cmdPool = device->cmd_pool, cmd_info.level = VK_CMD_BUFFER_LEVEL_PRIMARY;
.level = VK_CMD_BUFFER_LEVEL_PRIMARY, cmd_info.flags = 0;
.flags = 0,
};
err = vkCreateCommandBuffer (device->device, &cmd_info, cmd); err = vkCreateCommandBuffer (device->device, &cmd_info, cmd);
if (gst_vulkan_error_to_g_error (err, error, "vkCreateCommandBuffer") < 0) if (gst_vulkan_error_to_g_error (err, error, "vkCreateCommandBuffer") < 0)

41
ext/vulkan/vkinstance.c
View file

@ -30,8 +30,6 @@
#define APP_SHORT_NAME "GStreamer" #define APP_SHORT_NAME "GStreamer"
static const char *instance_validation_layers[] = { static const char *instance_validation_layers[] = {
/* FIXME: until the loader stops segfaulting/hanging we don't have any
* validation layers for the instance */
"Threading", "Threading",
"MemTracker", "MemTracker",
"ObjectTracker", "ObjectTracker",
@ -207,25 +205,26 @@ gst_vulkan_instance_open (GstVulkanInstance * instance, GError ** error)
} }
{ {
const VkApplicationInfo app = { VkApplicationInfo app = { 0, };
.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO, VkInstanceCreateInfo inst_info = { 0, };
.pNext = NULL,
.pAppName = APP_SHORT_NAME, app.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
.appVersion = 0, app.pNext = NULL;
.pEngineName = APP_SHORT_NAME, app.pAppName = APP_SHORT_NAME;
.engineVersion = 0, app.appVersion = 0;
.apiVersion = VK_API_VERSION, app.pEngineName = APP_SHORT_NAME;
}; app.engineVersion = 0;
VkInstanceCreateInfo inst_info = { app.apiVersion = VK_API_VERSION;
.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
.pNext = NULL, inst_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
.pAppInfo = &app, inst_info.pNext = NULL;
.pAllocCb = NULL, inst_info.pAppInfo = &app;
.layerCount = enabled_layer_count, inst_info.pAllocCb = NULL;
.ppEnabledLayerNames = (const char *const *) instance_validation_layers, inst_info.layerCount = enabled_layer_count;
.extensionCount = enabled_extension_count, inst_info.ppEnabledLayerNames =
.ppEnabledExtensionNames = (const char *const *) extension_names, (const char *const *) instance_validation_layers;
}; inst_info.extensionCount = enabled_extension_count;
inst_info.ppEnabledExtensionNames = (const char *const *) extension_names;
err = vkCreateInstance (&inst_info, &instance->instance); err = vkCreateInstance (&inst_info, &instance->instance);
if (gst_vulkan_error_to_g_error (err, error, "vkCreateInstance") < 0) { if (gst_vulkan_error_to_g_error (err, error, "vkCreateInstance") < 0) {

120
ext/vulkan/vkswapper.c
View file

@ -222,8 +222,8 @@ _vulkan_swapper_retrieve_surface_properties (GstVulkanSwapper * swapper,
swapper->GetPhysicalDeviceSurfaceSupportKHR (gpu, i, swapper->GetPhysicalDeviceSurfaceSupportKHR (gpu, i,
(VkSurfaceDescriptionKHR *) & surface_desc, &supports_present); (VkSurfaceDescriptionKHR *) & surface_desc, &supports_present);
if ((swapper->device-> if ((swapper->device->queue_family_props[i].
queue_family_props[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) != 0) { queueFlags & VK_QUEUE_GRAPHICS_BIT) != 0) {
if (supports_present) { if (supports_present) {
/* found one that supports both */ /* found one that supports both */
graphics_queue = present_queue = i; graphics_queue = present_queue = i;
@ -486,17 +486,16 @@ _swapper_set_image_layout (GstVulkanSwapper * swapper,
return FALSE; return FALSE;
{ {
VkCmdBufferBeginInfo cmd_buf_info = { VkCmdBufferBeginInfo cmd_buf_info = { 0, };
.sType = VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO,
.pNext = NULL, cmd_buf_info.sType = VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO;
.flags = VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT | cmd_buf_info.pNext = NULL;
VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT, cmd_buf_info.flags = VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT |
.renderPass = {VK_NULL_HANDLE} VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT;
, cmd_buf_info.renderPass.handle = VK_NULL_HANDLE;
.subpass = 0, cmd_buf_info.subpass = 0;
.framebuffer = {VK_NULL_HANDLE} cmd_buf_info.framebuffer.handle = VK_NULL_HANDLE;
,
};
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)
return FALSE; return FALSE;
@ -569,7 +568,7 @@ _allocate_swapchain (GstVulkanSwapper * swapper, GstCaps * caps,
* and is fastest (though it tears). If not, fall back to FIFO which is * and is fastest (though it tears). If not, fall back to FIFO which is
* always available. */ * always available. */
present_mode = VK_PRESENT_MODE_FIFO_KHR; present_mode = VK_PRESENT_MODE_FIFO_KHR;
for (size_t i = 0; i < swapper->n_surf_present_modes; i++) { for (gsize i = 0; i < swapper->n_surf_present_modes; i++) {
if (swapper->surf_present_modes[i] == VK_PRESENT_MODE_MAILBOX_KHR) { if (swapper->surf_present_modes[i] == VK_PRESENT_MODE_MAILBOX_KHR) {
present_mode = VK_PRESENT_MODE_MAILBOX_KHR; present_mode = VK_PRESENT_MODE_MAILBOX_KHR;
break; break;
@ -590,8 +589,8 @@ _allocate_swapchain (GstVulkanSwapper * swapper, GstCaps * caps,
n_images_wanted = swapper->surf_props.maxImageCount; n_images_wanted = swapper->surf_props.maxImageCount;
} }
if (swapper->surf_props. if (swapper->
supportedTransforms & VK_SURFACE_TRANSFORM_NONE_BIT_KHR) { surf_props.supportedTransforms & VK_SURFACE_TRANSFORM_NONE_BIT_KHR) {
preTransform = VK_SURFACE_TRANSFORM_NONE_KHR; preTransform = VK_SURFACE_TRANSFORM_NONE_KHR;
} else { } else {
preTransform = swapper->surf_props.currentTransform; preTransform = swapper->surf_props.currentTransform;
@ -610,8 +609,8 @@ _allocate_swapchain (GstVulkanSwapper * swapper, GstCaps * caps,
"Incorrect usage flags available for the swap images"); "Incorrect usage flags available for the swap images");
return FALSE; return FALSE;
} }
if ((swapper-> if ((swapper->surf_props.
surf_props.supportedUsageFlags & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT) supportedUsageFlags & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT)
!= 0) { != 0) {
usage |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; usage |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
} else { } else {
@ -622,27 +621,25 @@ _allocate_swapchain (GstVulkanSwapper * swapper, GstCaps * caps,
} }
{ {
const VkSwapchainCreateInfoKHR swap_chain_info = { VkSwapchainCreateInfoKHR swap_chain_info = { 0, };
.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR,
.pNext = NULL, swap_chain_info.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
.pSurfaceDescription = (const VkSurfaceDescriptionKHR *) &surface_desc, swap_chain_info.pNext = NULL;
.minImageCount = n_images_wanted, swap_chain_info.pSurfaceDescription =
.imageFormat = format, (const VkSurfaceDescriptionKHR *) &surface_desc;
.imageColorSpace = color_space, swap_chain_info.minImageCount = n_images_wanted;
.imageExtent = { swap_chain_info.imageFormat = format;
.width = swapchain_dims.width, swap_chain_info.imageColorSpace = color_space;
.height = swapchain_dims.height, swap_chain_info.imageExtent = swapchain_dims;
}, swap_chain_info.imageUsageFlags = usage;
.imageUsageFlags = usage, swap_chain_info.preTransform = preTransform;
.preTransform = preTransform, swap_chain_info.imageArraySize = 1;
.imageArraySize = 1, swap_chain_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
.sharingMode = VK_SHARING_MODE_EXCLUSIVE, swap_chain_info.queueFamilyCount = 0;
.queueFamilyCount = 0, swap_chain_info.pQueueFamilyIndices = NULL;
.pQueueFamilyIndices = NULL, swap_chain_info.presentMode = present_mode;
.presentMode = present_mode, swap_chain_info.oldSwapchain = swapper->swap_chain;
.oldSwapchain = swapper->swap_chain, swap_chain_info.clipped = TRUE;
.clipped = TRUE,
};
err = err =
swapper->CreateSwapchainKHR (swapper->device->device, &swap_chain_info, swapper->CreateSwapchainKHR (swapper->device->device, &swap_chain_info,
@ -735,11 +732,13 @@ static gboolean
_build_render_buffer_cmd (GstVulkanSwapper * swapper, guint32 swap_idx, _build_render_buffer_cmd (GstVulkanSwapper * swapper, guint32 swap_idx,
GstBuffer * buffer, struct cmd_data *cmd_data, GError ** error) GstBuffer * buffer, struct cmd_data *cmd_data, GError ** error)
{ {
const VkImageSubresource subres = { #define IMAGE_SUBRESOURCE(sub,a,m,l) \
.aspect = VK_IMAGE_ASPECT_COLOR, G_STMT_START { \
.mipLevel = 0, sub.aspect = a; \
.arrayLayer = 0, sub.mipLevel = m; \
}; sub.arrayLayer = l; \
} G_STMT_END
VkImageSubresource subres = { 0, };
GstVulkanImageMemory *swap_mem, *staging; GstVulkanImageMemory *swap_mem, *staging;
GstMapInfo staging_map_info; GstMapInfo staging_map_info;
VkSubresourceLayout layout; VkSubresourceLayout layout;
@ -750,6 +749,8 @@ _build_render_buffer_cmd (GstVulkanSwapper * swapper, guint32 swap_idx,
VkResult err; VkResult err;
gsize h; gsize h;
IMAGE_SUBRESOURCE (subres, VK_IMAGE_ASPECT_COLOR, 0, 0);
g_return_val_if_fail (swap_idx < swapper->n_swap_chain_images, FALSE); g_return_val_if_fail (swap_idx < swapper->n_swap_chain_images, FALSE);
swap_mem = swapper->swap_chain_images[swap_idx]; swap_mem = swapper->swap_chain_images[swap_idx];
@ -808,17 +809,16 @@ _build_render_buffer_cmd (GstVulkanSwapper * swapper, guint32 swap_idx,
gst_memory_unmap ((GstMemory *) staging, &staging_map_info); gst_memory_unmap ((GstMemory *) staging, &staging_map_info);
{ {
VkCmdBufferBeginInfo cmd_buf_info = { VkCmdBufferBeginInfo cmd_buf_info = { 0, };
.sType = VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO,
.pNext = NULL, cmd_buf_info.sType = VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO;
.flags = VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT | cmd_buf_info.pNext = NULL;
VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT, cmd_buf_info.flags = VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT |
.renderPass = {VK_NULL_HANDLE} VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT;
, cmd_buf_info.renderPass.handle = VK_NULL_HANDLE;
.subpass = 0, cmd_buf_info.subpass = 0;
.framebuffer = {VK_NULL_HANDLE} cmd_buf_info.framebuffer.handle = VK_NULL_HANDLE;
,
};
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)
return FALSE; return FALSE;
@ -932,16 +932,16 @@ _render_buffer_unlocked (GstVulkanSwapper * swapper,
GstBuffer * buffer, GError ** error) GstBuffer * buffer, GError ** error)
{ {
VkSemaphore semaphore = { 0, }; VkSemaphore semaphore = { 0, };
VkSemaphoreCreateInfo semaphore_info = { VkSemaphoreCreateInfo semaphore_info = { 0, };
.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
.pNext = NULL,
.flags = VK_FENCE_CREATE_SIGNALED_BIT,
};
VkPresentInfoKHR present; VkPresentInfoKHR present;
struct cmd_data cmd_data = { 0, }; struct cmd_data cmd_data = { 0, };
guint32 swap_idx; guint32 swap_idx;
VkResult err; VkResult err;
semaphore_info.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
semaphore_info.pNext = NULL;
semaphore_info.flags = VK_FENCE_CREATE_SIGNALED_BIT;
if (!buffer) { if (!buffer) {
g_set_error (error, GST_VULKAN_ERROR, g_set_error (error, GST_VULKAN_ERROR,
GST_VULKAN_ERROR_INITIALIZATION_FAILED, "Invalid buffer"); GST_VULKAN_ERROR_INITIALIZATION_FAILED, "Invalid buffer");