mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2025-01-27 09:38:17 +00:00
Code Issues 1 Projects Releases Wiki Activity

vulkan: remove the private struct from the public struct

Browse source 
Remove any references to CamelTypePrivate from the public CamelType
struct.  They can be accessed as needed using
camel_type_get_instance_private().
This commit is contained in:
Matthew Waters 2019-11-07 02:41:10 +11:00 committed by GStreamer Merge Bot
parent 32b3387ae6
commit 670d0a8e88
25 changed files with 347 additions and 321 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
gst-libs/gst/vulkan/cocoa/gstvkwindow_cocoa.h
View file

@ -53,9 +53,7 @@ struct _GstVulkanWindowCocoa
PFN_vkCreateMacOSSurfaceMVK CreateMacOSSurface; PFN_vkCreateMacOSSurfaceMVK CreateMacOSSurface;
/*< private >*/ /*< private >*/
GstVulkanWindowCocoaPrivate *priv;
gpointer _reserved[GST_PADDING]; gpointer _reserved[GST_PADDING];
}; };

31
gst-libs/gst/vulkan/cocoa/gstvkwindow_cocoa.m
View file

@ -34,8 +34,7 @@
#include "gstvkcocoa_utils.h" #include "gstvkcocoa_utils.h"
#define GST_VULKAN_WINDOW_COCOA_GET_PRIVATE(o) \ #define GET_PRIV(o) gst_vulkan_window_cocoa_get_instance_private (o)
(G_TYPE_INSTANCE_GET_PRIVATE((o), GST_TYPE_VULKAN_WINDOW_COCOA, GstVulkanWindowCocoaPrivate))
#define GST_CAT_DEFAULT gst_vulkan_window_cocoa_debug #define GST_CAT_DEFAULT gst_vulkan_window_cocoa_debug
GST_DEBUG_CATEGORY_STATIC (GST_CAT_DEFAULT); GST_DEBUG_CATEGORY_STATIC (GST_CAT_DEFAULT);
@ -106,10 +105,10 @@ gst_vulkan_window_cocoa_class_init (GstVulkanWindowCocoaClass * klass)
static void static void
gst_vulkan_window_cocoa_init (GstVulkanWindowCocoa * window) gst_vulkan_window_cocoa_init (GstVulkanWindowCocoa * window)
{ {
window->priv = gst_vulkan_window_cocoa_get_instance_private (window); GstVulkanWindowCocoaPrivate *priv = GET_PRIV (window);
window->priv->preferred_width = 320; priv->preferred_width = 320;
window->priv->preferred_height = 240; priv->preferred_height = 240;
} }
/* Must be called in the gl thread */ /* Must be called in the gl thread */
@ -138,7 +137,7 @@ static void
_show_window (gpointer data) _show_window (gpointer data)
{ {
GstVulkanWindowCocoa *window_cocoa = GST_VULKAN_WINDOW_COCOA (data); GstVulkanWindowCocoa *window_cocoa = GST_VULKAN_WINDOW_COCOA (data);
GstVulkanWindowCocoaPrivate *priv = window_cocoa->priv; GstVulkanWindowCocoaPrivate *priv = GET_PRIV (window_cocoa);
GstVulkanNSWindow *internal_win_id = (__bridge GstVulkanNSWindow *)priv->internal_win_id; GstVulkanNSWindow *internal_win_id = (__bridge GstVulkanNSWindow *)priv->internal_win_id;
GST_DEBUG_OBJECT (window_cocoa, "showing"); GST_DEBUG_OBJECT (window_cocoa, "showing");
@ -153,7 +152,7 @@ static void
gst_vulkan_window_cocoa_show (GstVulkanWindow * window) gst_vulkan_window_cocoa_show (GstVulkanWindow * window)
{ {
GstVulkanWindowCocoa *window_cocoa = GST_VULKAN_WINDOW_COCOA (window); GstVulkanWindowCocoa *window_cocoa = GST_VULKAN_WINDOW_COCOA (window);
GstVulkanWindowCocoaPrivate *priv = window_cocoa->priv; GstVulkanWindowCocoaPrivate *priv = GET_PRIV (window_cocoa);
if (!priv->visible) if (!priv->visible)
_invoke_on_main ((GstVulkanWindowFunc) _show_window, gst_object_ref (window), _invoke_on_main ((GstVulkanWindowFunc) _show_window, gst_object_ref (window),
@ -171,7 +170,7 @@ gst_vulkan_window_cocoa_hide (GstVulkanWindow * window)
static void static void
_create_window (GstVulkanWindowCocoa * window_cocoa) _create_window (GstVulkanWindowCocoa * window_cocoa)
{ {
GstVulkanWindowCocoaPrivate *priv = window_cocoa->priv; GstVulkanWindowCocoaPrivate *priv = GET_PRIV (window_cocoa);
NSRect mainRect = [[NSScreen mainScreen] visibleFrame]; NSRect mainRect = [[NSScreen mainScreen] visibleFrame];
gint h = priv->preferred_height; gint h = priv->preferred_height;
gint y = mainRect.size.height > h ? (mainRect.size.height - h) * 0.5 : 0; gint y = mainRect.size.height > h ? (mainRect.size.height - h) * 0.5 : 0;
@ -210,6 +209,7 @@ static VkSurfaceKHR
gst_vulkan_window_cocoa_get_surface (GstVulkanWindow * window, GError ** error) gst_vulkan_window_cocoa_get_surface (GstVulkanWindow * window, GError ** error)
{ {
GstVulkanWindowCocoa *window_cocoa = GST_VULKAN_WINDOW_COCOA (window); GstVulkanWindowCocoa *window_cocoa = GST_VULKAN_WINDOW_COCOA (window);
GstVulkanWindowCocoaPrivate *priv = GET_PRIV (window_cocoa);
VkMacOSSurfaceCreateInfoMVK info = { 0, }; VkMacOSSurfaceCreateInfoMVK info = { 0, };
VkSurfaceKHR ret; VkSurfaceKHR ret;
VkResult err; VkResult err;
@ -217,7 +217,7 @@ gst_vulkan_window_cocoa_get_surface (GstVulkanWindow * window, GError ** error)
info.sType = VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK; info.sType = VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK;
info.pNext = NULL; info.pNext = NULL;
info.flags = 0; info.flags = 0;
info.pView = window_cocoa->priv->internal_view; info.pView = priv->internal_view;
if (!window_cocoa->CreateMacOSSurface) if (!window_cocoa->CreateMacOSSurface)
window_cocoa->CreateMacOSSurface = window_cocoa->CreateMacOSSurface =
@ -261,16 +261,17 @@ _close_window (gpointer * data)
{ {
GstVulkanWindowCocoa *window_cocoa = GST_VULKAN_WINDOW_COCOA (data); GstVulkanWindowCocoa *window_cocoa = GST_VULKAN_WINDOW_COCOA (data);
GstVulkanWindow *window = GST_VULKAN_WINDOW (window_cocoa); GstVulkanWindow *window = GST_VULKAN_WINDOW (window_cocoa);
GstVulkanWindowCocoaPrivate *priv = GET_PRIV (window_cocoa);
GstVulkanNSWindow *internal_win_id = GstVulkanNSWindow *internal_win_id =
(__bridge GstVulkanNSWindow *) window_cocoa->priv->internal_win_id; (__bridge GstVulkanNSWindow *) priv->internal_win_id;
gst_vulkan_window_cocoa_hide (window); gst_vulkan_window_cocoa_hide (window);
[[internal_win_id contentView] removeFromSuperview]; [[internal_win_id contentView] removeFromSuperview];
CFBridgingRelease (window_cocoa->priv->internal_win_id); CFBridgingRelease (priv->internal_win_id);
window_cocoa->priv->internal_win_id = NULL; priv->internal_win_id = NULL;
CFBridgingRelease (window_cocoa->priv->internal_view); CFBridgingRelease (priv->internal_view);
window_cocoa->priv->internal_view = NULL; priv->internal_view = NULL;
} }
static void static void
@ -325,7 +326,7 @@ gst_vulkan_window_cocoa_close (GstVulkanWindow * window)
- (BOOL) windowShouldClose:(id)sender { - (BOOL) windowShouldClose:(id)sender {
GstVulkanWindowCocoaPrivate *priv = window_cocoa->priv; GstVulkanWindowCocoaPrivate *priv = GET_PRIV (window_cocoa);
GstVulkanNSWindow *internal_win_id = (__bridge GstVulkanNSWindow *)priv->internal_win_id; GstVulkanNSWindow *internal_win_id = (__bridge GstVulkanNSWindow *)priv->internal_win_id;
GST_DEBUG ("user clicked the close button\n"); GST_DEBUG ("user clicked the close button\n");
[internal_win_id setClosed]; [internal_win_id setClosed];

9
gst-libs/gst/vulkan/gstvkbufferpool.c
View file

@ -52,6 +52,8 @@ static void gst_vulkan_buffer_pool_finalize (GObject * object);
GST_DEBUG_CATEGORY_STATIC (GST_CAT_VULKAN_BUFFER_POOL); GST_DEBUG_CATEGORY_STATIC (GST_CAT_VULKAN_BUFFER_POOL);
#define GST_CAT_DEFAULT GST_CAT_VULKAN_BUFFER_POOL #define GST_CAT_DEFAULT GST_CAT_VULKAN_BUFFER_POOL
#define GET_PRIV(pool) gst_vulkan_buffer_pool_get_instance_private (pool)
#define gst_vulkan_buffer_pool_parent_class parent_class #define gst_vulkan_buffer_pool_parent_class parent_class
G_DEFINE_TYPE_WITH_CODE (GstVulkanBufferPool, gst_vulkan_buffer_pool, G_DEFINE_TYPE_WITH_CODE (GstVulkanBufferPool, gst_vulkan_buffer_pool,
GST_TYPE_BUFFER_POOL, G_ADD_PRIVATE (GstVulkanBufferPool) GST_TYPE_BUFFER_POOL, G_ADD_PRIVATE (GstVulkanBufferPool)
@ -72,7 +74,7 @@ static gboolean
gst_vulkan_buffer_pool_set_config (GstBufferPool * pool, GstStructure * config) gst_vulkan_buffer_pool_set_config (GstBufferPool * pool, GstStructure * config)
{ {
GstVulkanBufferPool *vk_pool = GST_VULKAN_BUFFER_POOL_CAST (pool); GstVulkanBufferPool *vk_pool = GST_VULKAN_BUFFER_POOL_CAST (pool);
GstVulkanBufferPoolPrivate *priv = vk_pool->priv; GstVulkanBufferPoolPrivate *priv = GET_PRIV (vk_pool);
guint min_buffers, max_buffers; guint min_buffers, max_buffers;
GstCaps *caps = NULL; GstCaps *caps = NULL;
gboolean ret = TRUE; gboolean ret = TRUE;
@ -136,7 +138,7 @@ gst_vulkan_buffer_pool_alloc (GstBufferPool * pool, GstBuffer ** buffer,
GstBufferPoolAcquireParams * params) GstBufferPoolAcquireParams * params)
{ {
GstVulkanBufferPool *vk_pool = GST_VULKAN_BUFFER_POOL_CAST (pool); GstVulkanBufferPool *vk_pool = GST_VULKAN_BUFFER_POOL_CAST (pool);
GstVulkanBufferPoolPrivate *priv = vk_pool->priv; GstVulkanBufferPoolPrivate *priv = GET_PRIV (vk_pool);
GstBuffer *buf; GstBuffer *buf;
guint i; guint i;
@ -223,14 +225,13 @@ gst_vulkan_buffer_pool_class_init (GstVulkanBufferPoolClass * klass)
static void static void
gst_vulkan_buffer_pool_init (GstVulkanBufferPool * pool) gst_vulkan_buffer_pool_init (GstVulkanBufferPool * pool)
{ {
pool->priv = gst_vulkan_buffer_pool_get_instance_private (pool);
} }
static void static void
gst_vulkan_buffer_pool_finalize (GObject * object) gst_vulkan_buffer_pool_finalize (GObject * object)
{ {
GstVulkanBufferPool *pool = GST_VULKAN_BUFFER_POOL_CAST (object); GstVulkanBufferPool *pool = GST_VULKAN_BUFFER_POOL_CAST (object);
GstVulkanBufferPoolPrivate *priv = pool->priv; GstVulkanBufferPoolPrivate *priv = GET_PRIV (pool);
GST_LOG_OBJECT (pool, "finalize Vulkan buffer pool %p", pool); GST_LOG_OBJECT (pool, "finalize Vulkan buffer pool %p", pool);

2
gst-libs/gst/vulkan/gstvkbufferpool.h
View file

@ -46,8 +46,6 @@ struct _GstVulkanBufferPool
GstBufferPool bufferpool; GstBufferPool bufferpool;
GstVulkanDevice *device; GstVulkanDevice *device;
GstVulkanBufferPoolPrivate *priv;
}; };
/** /**

33
gst-libs/gst/vulkan/gstvkcommandpool.c
View file

@ -34,10 +34,7 @@
#define GST_VULKAN_COMMAND_POOL_LARGE_OUTSTANDING 1024 #define GST_VULKAN_COMMAND_POOL_LARGE_OUTSTANDING 1024
#define GET_PRIV(pool) G_TYPE_INSTANCE_GET_PRIVATE(pool, GST_TYPE_VULKAN_COMMAND_POOL, GstVulkanCommandPoolPrivate) #define GET_PRIV(pool) gst_vulkan_command_pool_get_instance_private (pool)
#define GST_VULKAN_COMMAND_POOL_LOCK(pool) (g_rec_mutex_lock(&GET_PRIV(pool)->rec_mutex))
#define GST_VULKAN_COMMAND_POOL_UNLOCK(pool) (g_rec_mutex_unlock(&GET_PRIV(pool)->rec_mutex))
#define GST_CAT_DEFAULT gst_vulkan_command_pool_debug #define GST_CAT_DEFAULT gst_vulkan_command_pool_debug
GST_DEBUG_CATEGORY (GST_CAT_DEFAULT); GST_DEBUG_CATEGORY (GST_CAT_DEFAULT);
@ -88,10 +85,10 @@ gst_vulkan_command_pool_finalize (GObject * object)
GstVulkanCommandPool *pool = GST_VULKAN_COMMAND_POOL (object); GstVulkanCommandPool *pool = GST_VULKAN_COMMAND_POOL (object);
GstVulkanCommandPoolPrivate *priv = GET_PRIV (pool); GstVulkanCommandPoolPrivate *priv = GET_PRIV (pool);
GST_VULKAN_COMMAND_POOL_LOCK (pool); gst_vulkan_command_pool_lock (pool);
g_queue_free_full (priv->available, (GDestroyNotify) do_free_buffer); g_queue_free_full (priv->available, (GDestroyNotify) do_free_buffer);
priv->available = NULL; priv->available = NULL;
GST_VULKAN_COMMAND_POOL_UNLOCK (pool); gst_vulkan_command_pool_unlock (pool);
if (priv->outstanding > 0) if (priv->outstanding > 0)
g_critical g_critical
@ -138,9 +135,9 @@ command_alloc (GstVulkanCommandPool * pool, GError ** error)
cmd_info.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; cmd_info.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
cmd_info.commandBufferCount = 1; cmd_info.commandBufferCount = 1;
GST_VULKAN_COMMAND_POOL_LOCK (pool); gst_vulkan_command_pool_lock (pool);
err = vkAllocateCommandBuffers (pool->queue->device->device, &cmd_info, &cmd); err = vkAllocateCommandBuffers (pool->queue->device->device, &cmd_info, &cmd);
GST_VULKAN_COMMAND_POOL_UNLOCK (pool); gst_vulkan_command_pool_unlock (pool);
if (gst_vulkan_error_to_g_error (err, error, "vkCreateCommandBuffer") < 0) if (gst_vulkan_error_to_g_error (err, error, "vkCreateCommandBuffer") < 0)
return NULL; return NULL;
@ -182,9 +179,9 @@ gst_vulkan_command_pool_create (GstVulkanCommandPool * pool, GError ** error)
priv = GET_PRIV (pool); priv = GET_PRIV (pool);
if (gst_vulkan_command_pool_can_reset (pool)) { if (gst_vulkan_command_pool_can_reset (pool)) {
GST_VULKAN_COMMAND_POOL_LOCK (pool); gst_vulkan_command_pool_lock (pool);
cmd = g_queue_pop_head (priv->available); cmd = g_queue_pop_head (priv->available);
GST_VULKAN_COMMAND_POOL_UNLOCK (pool); gst_vulkan_command_pool_unlock (pool);
} }
if (!cmd) if (!cmd)
cmd = command_alloc (pool, error); cmd = command_alloc (pool, error);
@ -193,13 +190,13 @@ gst_vulkan_command_pool_create (GstVulkanCommandPool * pool, GError ** error)
cmd->pool = gst_object_ref (pool); cmd->pool = gst_object_ref (pool);
GST_VULKAN_COMMAND_POOL_LOCK (pool); gst_vulkan_command_pool_lock (pool);
priv->outstanding++; priv->outstanding++;
if (priv->outstanding > GST_VULKAN_COMMAND_POOL_LARGE_OUTSTANDING) if (priv->outstanding > GST_VULKAN_COMMAND_POOL_LARGE_OUTSTANDING)
g_critical ("%s: There are a large number of command buffers outstanding! " g_critical ("%s: There are a large number of command buffers outstanding! "
"This usually means there is a reference counting issue somewhere.", "This usually means there is a reference counting issue somewhere.",
GST_OBJECT_NAME (pool)); GST_OBJECT_NAME (pool));
GST_VULKAN_COMMAND_POOL_UNLOCK (pool); gst_vulkan_command_pool_unlock (pool);
return cmd; return cmd;
} }
@ -217,7 +214,7 @@ gst_vulkan_command_pool_release_buffer (GstVulkanCommandPool * pool,
priv = GET_PRIV (pool); priv = GET_PRIV (pool);
can_reset = gst_vulkan_command_pool_can_reset (pool); can_reset = gst_vulkan_command_pool_can_reset (pool);
GST_VULKAN_COMMAND_POOL_LOCK (pool); gst_vulkan_command_pool_lock (pool);
if (can_reset) { if (can_reset) {
vkResetCommandBuffer (buffer->cmd, 0); vkResetCommandBuffer (buffer->cmd, 0);
g_queue_push_tail (priv->available, buffer); g_queue_push_tail (priv->available, buffer);
@ -226,7 +223,7 @@ gst_vulkan_command_pool_release_buffer (GstVulkanCommandPool * pool,
/* TODO: if this is a secondary command buffer, all primary command buffers /* TODO: if this is a secondary command buffer, all primary command buffers
* that reference this command buffer will be invalid */ * that reference this command buffer will be invalid */
priv->outstanding--; priv->outstanding--;
GST_VULKAN_COMMAND_POOL_UNLOCK (pool); gst_vulkan_command_pool_unlock (pool);
/* decrease the refcount that the buffer had to us */ /* decrease the refcount that the buffer had to us */
gst_clear_object (&buffer->pool); gst_clear_object (&buffer->pool);
@ -249,8 +246,10 @@ gst_vulkan_command_pool_release_buffer (GstVulkanCommandPool * pool,
void void
gst_vulkan_command_pool_lock (GstVulkanCommandPool * pool) gst_vulkan_command_pool_lock (GstVulkanCommandPool * pool)
{ {
GstVulkanCommandPoolPrivate *priv;
g_return_if_fail (GST_IS_VULKAN_COMMAND_POOL (pool)); g_return_if_fail (GST_IS_VULKAN_COMMAND_POOL (pool));
GST_VULKAN_COMMAND_POOL_LOCK (pool); priv = GET_PRIV (pool);
g_rec_mutex_lock (&priv->rec_mutex);
} }
/** /**
@ -263,6 +262,8 @@ gst_vulkan_command_pool_lock (GstVulkanCommandPool * pool)
void void
gst_vulkan_command_pool_unlock (GstVulkanCommandPool * pool) gst_vulkan_command_pool_unlock (GstVulkanCommandPool * pool)
{ {
GstVulkanCommandPoolPrivate *priv;
g_return_if_fail (GST_IS_VULKAN_COMMAND_POOL (pool)); g_return_if_fail (GST_IS_VULKAN_COMMAND_POOL (pool));
GST_VULKAN_COMMAND_POOL_UNLOCK (pool); priv = GET_PRIV (pool);
g_rec_mutex_unlock (&priv->rec_mutex);
} }

2
gst-libs/gst/vulkan/gstvkdescriptorcache.c
View file

@ -32,7 +32,7 @@
* @see_also: #GstVulkanDevice * @see_also: #GstVulkanDevice
*/ */
#define GET_PRIV(cache) G_TYPE_INSTANCE_GET_PRIVATE(cache, GST_TYPE_VULKAN_DESCRIPTOR_CACHE, GstVulkanDescriptorCachePrivate) #define GET_PRIV(cache) gst_vulkan_descriptor_cache_get_instance_private (cache)
#define GST_CAT_DEFAULT gst_vulkan_descriptor_cache_debug #define GST_CAT_DEFAULT gst_vulkan_descriptor_cache_debug
GST_DEBUG_CATEGORY (GST_CAT_DEFAULT); GST_DEBUG_CATEGORY (GST_CAT_DEFAULT);

4
gst-libs/gst/vulkan/gstvkdescriptorpool.c
View file

@ -31,7 +31,7 @@
* @see_also: #GstVulkanDevice * @see_also: #GstVulkanDevice
*/ */
#define GET_PRIV(pool) G_TYPE_INSTANCE_GET_PRIVATE(pool, GST_TYPE_VULKAN_DESCRIPTOR_POOL, GstVulkanDescriptorPoolPrivate) #define GET_PRIV(pool) gst_vulkan_descriptor_pool_get_instance_private (pool)
#define GST_CAT_DEFAULT gst_vulkan_descriptor_pool_debug #define GST_CAT_DEFAULT gst_vulkan_descriptor_pool_debug
GST_DEBUG_CATEGORY (GST_CAT_DEFAULT); GST_DEBUG_CATEGORY (GST_CAT_DEFAULT);
@ -68,9 +68,9 @@ static void
gst_vulkan_descriptor_pool_finalize (GObject * object) gst_vulkan_descriptor_pool_finalize (GObject * object)
{ {
GstVulkanDescriptorPool *pool = GST_VULKAN_DESCRIPTOR_POOL (object); GstVulkanDescriptorPool *pool = GST_VULKAN_DESCRIPTOR_POOL (object);
#if 0
GstVulkanDescriptorPoolPrivate *priv = GET_PRIV (pool); GstVulkanDescriptorPoolPrivate *priv = GET_PRIV (pool);
#if 0
/* FIXME: track these correctly */ /* FIXME: track these correctly */
if (priv->outstanding > 0) if (priv->outstanding > 0)
g_critical g_critical

44
gst-libs/gst/vulkan/gstvkdisplay.c
View file

@ -89,23 +89,27 @@ struct _GstVulkanDisplayPrivate
GCond thread_cond; GCond thread_cond;
}; };
#define GET_PRIV(display) gst_vulkan_display_get_instance_private (display)
G_DEFINE_TYPE_WITH_CODE (GstVulkanDisplay, gst_vulkan_display, GST_TYPE_OBJECT, G_DEFINE_TYPE_WITH_CODE (GstVulkanDisplay, gst_vulkan_display, GST_TYPE_OBJECT,
G_ADD_PRIVATE (GstVulkanDisplay) _init_debug ()); G_ADD_PRIVATE (GstVulkanDisplay) _init_debug ());
static gpointer static gpointer
_event_thread_main (GstVulkanDisplay * display) _event_thread_main (GstVulkanDisplay * display)
{ {
g_mutex_lock (&display->priv->thread_lock); GstVulkanDisplayPrivate *priv = GET_PRIV (display);
g_mutex_lock (&priv->thread_lock);
display->main_context = g_main_context_new (); display->main_context = g_main_context_new ();
display->main_loop = g_main_loop_new (display->main_context, FALSE); display->main_loop = g_main_loop_new (display->main_context, FALSE);
g_cond_broadcast (&display->priv->thread_cond); g_cond_broadcast (&priv->thread_cond);
g_mutex_unlock (&display->priv->thread_lock); g_mutex_unlock (&priv->thread_lock);
g_main_loop_run (display->main_loop); g_main_loop_run (display->main_loop);
g_mutex_lock (&display->priv->thread_lock); g_mutex_lock (&priv->thread_lock);
g_main_loop_unref (display->main_loop); g_main_loop_unref (display->main_loop);
g_main_context_unref (display->main_context); g_main_context_unref (display->main_context);
@ -113,8 +117,8 @@ _event_thread_main (GstVulkanDisplay * display)
display->main_loop = NULL; display->main_loop = NULL;
display->main_context = NULL; display->main_context = NULL;
g_cond_broadcast (&display->priv->thread_cond); g_cond_broadcast (&priv->thread_cond);
g_mutex_unlock (&display->priv->thread_lock); g_mutex_unlock (&priv->thread_lock);
return NULL; return NULL;
} }
@ -131,19 +135,20 @@ gst_vulkan_display_class_init (GstVulkanDisplayClass * klass)
static void static void
gst_vulkan_display_init (GstVulkanDisplay * display) gst_vulkan_display_init (GstVulkanDisplay * display)
{ {
display->priv = gst_vulkan_display_get_instance_private (display); GstVulkanDisplayPrivate *priv = GET_PRIV (display);
display->type = GST_VULKAN_DISPLAY_TYPE_ANY; display->type = GST_VULKAN_DISPLAY_TYPE_ANY;
g_mutex_init (&display->priv->thread_lock); g_mutex_init (&priv->thread_lock);
g_cond_init (&display->priv->thread_cond); g_cond_init (&priv->thread_cond);
display->priv->event_thread = g_thread_new ("vkdisplay-event", priv->event_thread = g_thread_new ("vkdisplay-event",
(GThreadFunc) _event_thread_main, display); (GThreadFunc) _event_thread_main, display);
g_mutex_lock (&display->priv->thread_lock); g_mutex_lock (&priv->thread_lock);
while (!display->main_loop) while (!display->main_loop)
g_cond_wait (&display->priv->thread_cond, &display->priv->thread_lock); g_cond_wait (&priv->thread_cond, &priv->thread_lock);
g_mutex_unlock (&display->priv->thread_lock); g_mutex_unlock (&priv->thread_lock);
} }
static void static void
@ -160,19 +165,20 @@ static void
gst_vulkan_display_finalize (GObject * object) gst_vulkan_display_finalize (GObject * object)
{ {
GstVulkanDisplay *display = GST_VULKAN_DISPLAY (object); GstVulkanDisplay *display = GST_VULKAN_DISPLAY (object);
GstVulkanDisplayPrivate *priv = GET_PRIV (display);
g_mutex_lock (&display->priv->thread_lock); g_mutex_lock (&priv->thread_lock);
if (display->main_loop) if (display->main_loop)
g_main_loop_quit (display->main_loop); g_main_loop_quit (display->main_loop);
while (display->main_loop) while (display->main_loop)
g_cond_wait (&display->priv->thread_cond, &display->priv->thread_lock); g_cond_wait (&priv->thread_cond, &priv->thread_lock);
if (display->priv->event_thread) if (priv->event_thread)
g_thread_unref (display->priv->event_thread); g_thread_unref (priv->event_thread);
display->priv->event_thread = NULL; priv->event_thread = NULL;
g_mutex_unlock (&display->priv->thread_lock); g_mutex_unlock (&priv->thread_lock);
if (display->event_source) { if (display->event_source) {
g_source_destroy (display->event_source); g_source_destroy (display->event_source);

3
gst-libs/gst/vulkan/gstvkdisplay.h
View file

@ -85,9 +85,6 @@ struct _GstVulkanDisplay
GMainContext *main_context; GMainContext *main_context;
GMainLoop *main_loop; GMainLoop *main_loop;
GSource *event_source; GSource *event_source;
/* <private> */
GstVulkanDisplayPrivate *priv;
}; };
struct _GstVulkanDisplayClass struct _GstVulkanDisplayClass

9
gst-libs/gst/vulkan/gstvkimagebufferpool.c
View file

@ -52,6 +52,8 @@ static void gst_vulkan_image_buffer_pool_finalize (GObject * object);
GST_DEBUG_CATEGORY_STATIC (GST_CAT_VULKAN_IMAGE_BUFFER_POOL); GST_DEBUG_CATEGORY_STATIC (GST_CAT_VULKAN_IMAGE_BUFFER_POOL);
#define GST_CAT_DEFAULT GST_CAT_VULKAN_IMAGE_BUFFER_POOL #define GST_CAT_DEFAULT GST_CAT_VULKAN_IMAGE_BUFFER_POOL
#define GET_PRIV(pool) gst_vulkan_image_buffer_pool_get_instance_private (pool)
#define gst_vulkan_image_buffer_pool_parent_class parent_class #define gst_vulkan_image_buffer_pool_parent_class parent_class
G_DEFINE_TYPE_WITH_CODE (GstVulkanImageBufferPool, gst_vulkan_image_buffer_pool, G_DEFINE_TYPE_WITH_CODE (GstVulkanImageBufferPool, gst_vulkan_image_buffer_pool,
GST_TYPE_BUFFER_POOL, G_ADD_PRIVATE (GstVulkanImageBufferPool) GST_TYPE_BUFFER_POOL, G_ADD_PRIVATE (GstVulkanImageBufferPool)
@ -73,7 +75,7 @@ gst_vulkan_image_buffer_pool_set_config (GstBufferPool * pool,
GstStructure * config) GstStructure * config)
{ {
GstVulkanImageBufferPool *vk_pool = GST_VULKAN_IMAGE_BUFFER_POOL_CAST (pool); GstVulkanImageBufferPool *vk_pool = GST_VULKAN_IMAGE_BUFFER_POOL_CAST (pool);
GstVulkanImageBufferPoolPrivate *priv = vk_pool->priv; GstVulkanImageBufferPoolPrivate *priv = GET_PRIV (vk_pool);
guint min_buffers, max_buffers; guint min_buffers, max_buffers;
GstCaps *caps = NULL; GstCaps *caps = NULL;
GstCapsFeatures *features; GstCapsFeatures *features;
@ -161,7 +163,7 @@ gst_vulkan_image_buffer_pool_alloc (GstBufferPool * pool, GstBuffer ** buffer,
GstBufferPoolAcquireParams * params) GstBufferPoolAcquireParams * params)
{ {
GstVulkanImageBufferPool *vk_pool = GST_VULKAN_IMAGE_BUFFER_POOL_CAST (pool); GstVulkanImageBufferPool *vk_pool = GST_VULKAN_IMAGE_BUFFER_POOL_CAST (pool);
GstVulkanImageBufferPoolPrivate *priv = vk_pool->priv; GstVulkanImageBufferPoolPrivate *priv = GET_PRIV (vk_pool);
GstBuffer *buf; GstBuffer *buf;
guint i; guint i;
@ -251,14 +253,13 @@ gst_vulkan_image_buffer_pool_class_init (GstVulkanImageBufferPoolClass * klass)
static void static void
gst_vulkan_image_buffer_pool_init (GstVulkanImageBufferPool * pool) gst_vulkan_image_buffer_pool_init (GstVulkanImageBufferPool * pool)
{ {
pool->priv = gst_vulkan_image_buffer_pool_get_instance_private (pool);
} }
static void static void
gst_vulkan_image_buffer_pool_finalize (GObject * object) gst_vulkan_image_buffer_pool_finalize (GObject * object)
{ {
GstVulkanImageBufferPool *pool = GST_VULKAN_IMAGE_BUFFER_POOL_CAST (object); GstVulkanImageBufferPool *pool = GST_VULKAN_IMAGE_BUFFER_POOL_CAST (object);
GstVulkanImageBufferPoolPrivate *priv = pool->priv; GstVulkanImageBufferPoolPrivate *priv = GET_PRIV (pool);
GST_LOG_OBJECT (pool, "finalize Vulkan buffer pool %p", pool); GST_LOG_OBJECT (pool, "finalize Vulkan buffer pool %p", pool);

2
gst-libs/gst/vulkan/gstvkimagebufferpool.h
View file

@ -46,8 +46,6 @@ struct _GstVulkanImageBufferPool
GstBufferPool bufferpool; GstBufferPool bufferpool;
GstVulkanDevice *device; GstVulkanDevice *device;
GstVulkanImageBufferPoolPrivate *priv;
}; };
/** /**

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

@ -74,6 +74,8 @@ _init_debug (void)
} }
} }
#define GET_PRIV(instance) gst_vulkan_instance_get_instance_private (instance)
#define gst_vulkan_instance_parent_class parent_class #define gst_vulkan_instance_parent_class parent_class
G_DEFINE_TYPE_WITH_CODE (GstVulkanInstance, gst_vulkan_instance, G_DEFINE_TYPE_WITH_CODE (GstVulkanInstance, gst_vulkan_instance,
GST_TYPE_OBJECT, G_ADD_PRIVATE (GstVulkanInstance) GST_TYPE_OBJECT, G_ADD_PRIVATE (GstVulkanInstance)
@ -93,7 +95,6 @@ gst_vulkan_instance_new (void)
static void static void
gst_vulkan_instance_init (GstVulkanInstance * instance) gst_vulkan_instance_init (GstVulkanInstance * instance)
{ {
instance->priv = gst_vulkan_instance_get_instance_private (instance);
} }
static void static void
@ -125,15 +126,16 @@ static void
gst_vulkan_instance_finalize (GObject * object) gst_vulkan_instance_finalize (GObject * object)
{ {
GstVulkanInstance *instance = GST_VULKAN_INSTANCE (object); GstVulkanInstance *instance = GST_VULKAN_INSTANCE (object);
GstVulkanInstancePrivate *priv = GET_PRIV (instance);
if (instance->priv->opened) { if (priv->opened) {
if (instance->dbgDestroyDebugReportCallback) if (instance->dbgDestroyDebugReportCallback)
instance->dbgDestroyDebugReportCallback (instance->instance, instance->dbgDestroyDebugReportCallback (instance->instance,
instance->msg_callback, NULL); instance->msg_callback, NULL);
g_free (instance->physical_devices); g_free (instance->physical_devices);
} }
instance->priv->opened = FALSE; priv->opened = FALSE;
if (instance->instance) if (instance->instance)
vkDestroyInstance (instance->instance, NULL); vkDestroyInstance (instance->instance, NULL);
@ -191,6 +193,7 @@ _gst_vk_debug_callback (VkDebugReportFlagsEXT msgFlags,
gboolean gboolean
gst_vulkan_instance_open (GstVulkanInstance * instance, GError ** error) gst_vulkan_instance_open (GstVulkanInstance * instance, GError ** error)
{ {
GstVulkanInstancePrivate *priv;
VkExtensionProperties *instance_extensions; VkExtensionProperties *instance_extensions;
char *extension_names[64]; /* FIXME: make dynamic */ char *extension_names[64]; /* FIXME: make dynamic */
VkLayerProperties *instance_layers; VkLayerProperties *instance_layers;
@ -202,8 +205,10 @@ gst_vulkan_instance_open (GstVulkanInstance * instance, GError ** error)
g_return_val_if_fail (GST_IS_VULKAN_INSTANCE (instance), FALSE); g_return_val_if_fail (GST_IS_VULKAN_INSTANCE (instance), FALSE);
priv = GET_PRIV (instance);
GST_OBJECT_LOCK (instance); GST_OBJECT_LOCK (instance);
if (instance->priv->opened) { if (priv->opened) {
GST_OBJECT_UNLOCK (instance); GST_OBJECT_UNLOCK (instance);
return TRUE; return TRUE;
} }
@ -400,7 +405,7 @@ gst_vulkan_instance_open (GstVulkanInstance * instance, GError ** error)
goto error; goto error;
} }
instance->priv->opened = TRUE; priv->opened = TRUE;
GST_OBJECT_UNLOCK (instance); GST_OBJECT_UNLOCK (instance);
return TRUE; return TRUE;

2
gst-libs/gst/vulkan/gstvkinstance.h
View file

@ -48,8 +48,6 @@ struct _GstVulkanInstance
PFN_vkCreateDebugReportCallbackEXT dbgCreateDebugReportCallback; PFN_vkCreateDebugReportCallbackEXT dbgCreateDebugReportCallback;
PFN_vkDestroyDebugReportCallbackEXT dbgDestroyDebugReportCallback; PFN_vkDestroyDebugReportCallbackEXT dbgDestroyDebugReportCallback;
PFN_vkDebugReportMessageEXT dbgReportMessage; PFN_vkDebugReportMessageEXT dbgReportMessage;
GstVulkanInstancePrivate *priv;
}; };
struct _GstVulkanInstanceClass struct _GstVulkanInstanceClass

2
gst-libs/gst/vulkan/gstvkphysicaldevice.c
View file

@ -67,6 +67,8 @@ _init_debug (void)
} }
} }
#define GET_PRIV(device) gst_vulkan_physical_device_get_instance_private (device)
#define gst_vulkan_physical_device_parent_class parent_class #define gst_vulkan_physical_device_parent_class parent_class
G_DEFINE_TYPE_WITH_CODE (GstVulkanPhysicalDevice, gst_vulkan_physical_device, G_DEFINE_TYPE_WITH_CODE (GstVulkanPhysicalDevice, gst_vulkan_physical_device,
GST_TYPE_OBJECT, G_ADD_PRIVATE (GstVulkanPhysicalDevice); GST_TYPE_OBJECT, G_ADD_PRIVATE (GstVulkanPhysicalDevice);

2
gst-libs/gst/vulkan/gstvkphysicaldevice.h
View file

@ -56,8 +56,6 @@ struct _GstVulkanPhysicalDevice
VkQueueFamilyProperties *queue_family_props; VkQueueFamilyProperties *queue_family_props;
guint32 n_queue_families; guint32 n_queue_families;
GstVulkanPhysicalDevicePrivate *priv;
}; };
struct _GstVulkanPhysicalDeviceClass struct _GstVulkanPhysicalDeviceClass

403
gst-libs/gst/vulkan/gstvkswapper.c
View file

@ -29,10 +29,6 @@
#define GST_CAT_DEFAULT gst_vulkan_swapper_debug #define GST_CAT_DEFAULT gst_vulkan_swapper_debug
GST_DEBUG_CATEGORY (GST_CAT_DEFAULT); GST_DEBUG_CATEGORY (GST_CAT_DEFAULT);
#define RENDER_GET_LOCK(o) &(GST_VULKAN_SWAPPER (o)->priv->render_lock)
#define RENDER_LOCK(o) g_mutex_lock (RENDER_GET_LOCK(o));
#define RENDER_UNLOCK(o) g_mutex_unlock (RENDER_GET_LOCK(o));
struct _GstVulkanSwapperPrivate struct _GstVulkanSwapperPrivate
{ {
VkSurfaceKHR surface; VkSurfaceKHR surface;
@ -99,6 +95,8 @@ enum
#define DEFAULT_PIXEL_ASPECT_RATIO_N 0 #define DEFAULT_PIXEL_ASPECT_RATIO_N 0
#define DEFAULT_PIXEL_ASPECT_RATIO_D 1 #define DEFAULT_PIXEL_ASPECT_RATIO_D 1
#define GET_PRIV(swapper) gst_vulkan_swapper_get_instance_private (swapper)
#define gst_vulkan_swapper_parent_class parent_class #define gst_vulkan_swapper_parent_class parent_class
G_DEFINE_TYPE_WITH_CODE (GstVulkanSwapper, gst_vulkan_swapper, G_DEFINE_TYPE_WITH_CODE (GstVulkanSwapper, gst_vulkan_swapper,
GST_TYPE_OBJECT, G_ADD_PRIVATE (GstVulkanSwapper) GST_TYPE_OBJECT, G_ADD_PRIVATE (GstVulkanSwapper)
@ -110,9 +108,20 @@ static void _on_window_draw (GstVulkanWindow * window,
static void _on_window_resize (GstVulkanWindow * window, static void _on_window_resize (GstVulkanWindow * window,
guint width, guint height, GstVulkanSwapper * swapper); guint width, guint height, GstVulkanSwapper * swapper);
static inline GMutex *
render_get_lock (gpointer swapper)
{
GstVulkanSwapperPrivate *priv = GET_PRIV (swapper);
return &priv->render_lock;
}
#define RENDER_LOCK(o) g_mutex_lock (render_get_lock(o));
#define RENDER_UNLOCK(o) g_mutex_unlock (render_get_lock(o));
static gboolean static gboolean
_get_function_table (GstVulkanSwapper * swapper) _get_function_table (GstVulkanSwapper * swapper)
{ {
GstVulkanSwapperPrivate *priv = GET_PRIV (swapper);
GstVulkanDevice *device = swapper->device; GstVulkanDevice *device = swapper->device;
GstVulkanInstance *instance = gst_vulkan_device_get_instance (device); GstVulkanInstance *instance = gst_vulkan_device_get_instance (device);
@ -120,30 +129,26 @@ _get_function_table (GstVulkanSwapper * swapper)
GST_ERROR_OBJECT (swapper, "Failed to get instance from the device"); GST_ERROR_OBJECT (swapper, "Failed to get instance from the device");
return FALSE; return FALSE;
} }
#define GET_PROC_ADDRESS_REQUIRED(obj, type, name) \ #define GET_PROC_ADDRESS_REQUIRED(type, name) \
G_STMT_START { \ G_STMT_START { \
obj->priv->G_PASTE (, name) = G_PASTE(G_PASTE(gst_vulkan_, type), _get_proc_address) (type, "vk" G_STRINGIFY(name)); \ priv->G_PASTE (, name) = G_PASTE(G_PASTE(gst_vulkan_, type), _get_proc_address) (type, "vk" G_STRINGIFY(name)); \
if (!obj->priv->G_PASTE(, name)) { \ if (!priv->G_PASTE(, name)) { \
GST_ERROR_OBJECT (obj, "Failed to find required function vk" G_STRINGIFY(name)); \ GST_ERROR_OBJECT (swapper, "Failed to find required function vk" G_STRINGIFY(name)); \
gst_object_unref (instance); \ gst_object_unref (instance); \
return FALSE; \ return FALSE; \
} \ } \
} G_STMT_END } G_STMT_END
GET_PROC_ADDRESS_REQUIRED (swapper, instance, GET_PROC_ADDRESS_REQUIRED (instance, GetPhysicalDeviceSurfaceSupportKHR);
GetPhysicalDeviceSurfaceSupportKHR); GET_PROC_ADDRESS_REQUIRED (instance, GetPhysicalDeviceSurfaceCapabilitiesKHR);
GET_PROC_ADDRESS_REQUIRED (swapper, instance, GET_PROC_ADDRESS_REQUIRED (instance, GetPhysicalDeviceSurfaceFormatsKHR);
GetPhysicalDeviceSurfaceCapabilitiesKHR); GET_PROC_ADDRESS_REQUIRED (instance, GetPhysicalDeviceSurfacePresentModesKHR);
GET_PROC_ADDRESS_REQUIRED (swapper, instance, GET_PROC_ADDRESS_REQUIRED (instance, DestroySurfaceKHR);
GetPhysicalDeviceSurfaceFormatsKHR); GET_PROC_ADDRESS_REQUIRED (device, CreateSwapchainKHR);
GET_PROC_ADDRESS_REQUIRED (swapper, instance, GET_PROC_ADDRESS_REQUIRED (device, DestroySwapchainKHR);
GetPhysicalDeviceSurfacePresentModesKHR); GET_PROC_ADDRESS_REQUIRED (device, GetSwapchainImagesKHR);
GET_PROC_ADDRESS_REQUIRED (swapper, instance, DestroySurfaceKHR); GET_PROC_ADDRESS_REQUIRED (device, AcquireNextImageKHR);
GET_PROC_ADDRESS_REQUIRED (swapper, device, CreateSwapchainKHR); GET_PROC_ADDRESS_REQUIRED (device, QueuePresentKHR);
GET_PROC_ADDRESS_REQUIRED (swapper, device, DestroySwapchainKHR);
GET_PROC_ADDRESS_REQUIRED (swapper, device, GetSwapchainImagesKHR);
GET_PROC_ADDRESS_REQUIRED (swapper, device, AcquireNextImageKHR);
GET_PROC_ADDRESS_REQUIRED (swapper, device, QueuePresentKHR);
gst_object_unref (instance); gst_object_unref (instance);
@ -200,8 +205,10 @@ _add_vk_format_to_list (GValue * list, VkFormat format)
static gboolean static gboolean
_vulkan_swapper_ensure_surface (GstVulkanSwapper * swapper, GError ** error) _vulkan_swapper_ensure_surface (GstVulkanSwapper * swapper, GError ** error)
{ {
if (!swapper->priv->surface) { GstVulkanSwapperPrivate *priv = GET_PRIV (swapper);
if (!(swapper->priv->surface =
if (!priv->surface) {
if (!(priv->surface =
gst_vulkan_window_get_surface (swapper->window, error))) { gst_vulkan_window_get_surface (swapper->window, error))) {
return FALSE; return FALSE;
} }
@ -221,6 +228,7 @@ static gboolean
_choose_queue (GstVulkanDevice * device, GstVulkanQueue * queue, _choose_queue (GstVulkanDevice * device, GstVulkanQueue * queue,
struct choose_data *data) struct choose_data *data)
{ {
GstVulkanSwapperPrivate *priv = GET_PRIV (data->swapper);
guint flags = guint flags =
device->physical_device->queue_family_props[queue->family].queueFlags; device->physical_device->queue_family_props[queue->family].queueFlags;
VkPhysicalDevice gpu; VkPhysicalDevice gpu;
@ -234,8 +242,8 @@ _choose_queue (GstVulkanDevice * device, GstVulkanQueue * queue,
VkBool32 physical_device_supported; VkBool32 physical_device_supported;
err = err =
data->swapper->priv->GetPhysicalDeviceSurfaceSupportKHR (gpu, priv->GetPhysicalDeviceSurfaceSupportKHR (gpu,
queue->index, data->swapper->priv->surface, &physical_device_supported); queue->index, priv->surface, &physical_device_supported);
if (gst_vulkan_error_to_g_error (err, &error, if (gst_vulkan_error_to_g_error (err, &error,
"GetPhysicalDeviceSurfaceSupport") < 0) { "GetPhysicalDeviceSurfaceSupport") < 0) {
GST_DEBUG_OBJECT (data->swapper, GST_DEBUG_OBJECT (data->swapper,
@ -334,42 +342,46 @@ gst_vulkan_swapper_choose_queue (GstVulkanSwapper * swapper,
static void static void
dump_surface_properties (GstVulkanSwapper * swapper) dump_surface_properties (GstVulkanSwapper * swapper)
{ {
GstVulkanSwapperPrivate *priv = GET_PRIV (swapper);
GST_TRACE_OBJECT (swapper, "surface %p, n images [%" G_GUINT32_FORMAT ", %" GST_TRACE_OBJECT (swapper, "surface %p, n images [%" G_GUINT32_FORMAT ", %"
G_GUINT32_FORMAT "], extent [%" GST_VULKAN_EXTENT2D_FORMAT ", %" G_GUINT32_FORMAT "], extent [%" GST_VULKAN_EXTENT2D_FORMAT ", %"
GST_VULKAN_EXTENT2D_FORMAT "], max layers %" G_GUINT32_FORMAT GST_VULKAN_EXTENT2D_FORMAT "], max layers %" G_GUINT32_FORMAT
" transforms supported 0x%x current transform 0x%x, alpha flags 0x%x, " " transforms supported 0x%x current transform 0x%x, alpha flags 0x%x, "
"supported image usage flags 0x%x", swapper->priv->surface, "supported image usage flags 0x%x", priv->surface,
swapper->priv->surf_props.minImageCount, priv->surf_props.minImageCount,
swapper->priv->surf_props.maxImageCount, priv->surf_props.maxImageCount,
GST_VULKAN_EXTENT2D_ARGS (swapper->priv->surf_props.minImageExtent), GST_VULKAN_EXTENT2D_ARGS (priv->surf_props.minImageExtent),
GST_VULKAN_EXTENT2D_ARGS (swapper->priv->surf_props.maxImageExtent), GST_VULKAN_EXTENT2D_ARGS (priv->surf_props.maxImageExtent),
swapper->priv->surf_props.maxImageArrayLayers, priv->surf_props.maxImageArrayLayers,
swapper->priv->surf_props.supportedTransforms, priv->surf_props.supportedTransforms,
swapper->priv->surf_props.currentTransform, priv->surf_props.currentTransform,
swapper->priv->surf_props.supportedCompositeAlpha, priv->surf_props.supportedCompositeAlpha,
swapper->priv->surf_props.supportedUsageFlags); priv->surf_props.supportedUsageFlags);
} }
static void static void
dump_surface_formats (GstVulkanSwapper * swapper) dump_surface_formats (GstVulkanSwapper * swapper)
{ {
GstVulkanSwapperPrivate *priv = GET_PRIV (swapper);
int i; int i;
for (i = 0; i < swapper->priv->n_surf_formats; i++) { for (i = 0; i < priv->n_surf_formats; i++) {
GST_DEBUG_OBJECT (swapper, "surface %p format 0x%x colorspace 0x%x", GST_DEBUG_OBJECT (swapper, "surface %p format 0x%x colorspace 0x%x",
swapper->priv->surface, swapper->priv->surf_formats[i].format, priv->surface, priv->surf_formats[i].format,
swapper->priv->surf_formats[i].colorSpace); priv->surf_formats[i].colorSpace);
} }
} }
static void static void
dump_surface_present_modes (GstVulkanSwapper * swapper) dump_surface_present_modes (GstVulkanSwapper * swapper)
{ {
GstVulkanSwapperPrivate *priv = GET_PRIV (swapper);
int i; int i;
for (i = 0; i < swapper->priv->n_surf_present_modes; i++) { for (i = 0; i < priv->n_surf_present_modes; i++) {
GST_DEBUG_OBJECT (swapper, "surface %p present modes 0x%x", GST_DEBUG_OBJECT (swapper, "surface %p present modes 0x%x",
swapper->priv->surface, swapper->priv->surf_present_modes[i]); priv->surface, priv->surf_present_modes[i]);
} }
} }
@ -377,10 +389,11 @@ static gboolean
_vulkan_swapper_retrieve_surface_properties (GstVulkanSwapper * swapper, _vulkan_swapper_retrieve_surface_properties (GstVulkanSwapper * swapper,
GError ** error) GError ** error)
{ {
GstVulkanSwapperPrivate *priv = GET_PRIV (swapper);
VkPhysicalDevice gpu; VkPhysicalDevice gpu;
VkResult err; VkResult err;
if (swapper->priv->surf_formats) if (priv->surf_formats)
return TRUE; return TRUE;
gpu = gst_vulkan_device_get_physical_device (swapper->device); gpu = gst_vulkan_device_get_physical_device (swapper->device);
@ -393,8 +406,8 @@ _vulkan_swapper_retrieve_surface_properties (GstVulkanSwapper * swapper,
return FALSE; return FALSE;
err = err =
swapper->priv->GetPhysicalDeviceSurfaceCapabilitiesKHR (gpu, priv->GetPhysicalDeviceSurfaceCapabilitiesKHR (gpu,
swapper->priv->surface, &swapper->priv->surf_props); priv->surface, &priv->surf_props);
if (gst_vulkan_error_to_g_error (err, error, if (gst_vulkan_error_to_g_error (err, error,
"GetPhysicalDeviceSurfaceCapabilitiesKHR") < 0) "GetPhysicalDeviceSurfaceCapabilitiesKHR") < 0)
return FALSE; return FALSE;
@ -402,18 +415,16 @@ _vulkan_swapper_retrieve_surface_properties (GstVulkanSwapper * swapper,
dump_surface_properties (swapper); dump_surface_properties (swapper);
err = err =
swapper->priv->GetPhysicalDeviceSurfaceFormatsKHR (gpu, priv->GetPhysicalDeviceSurfaceFormatsKHR (gpu,
swapper->priv->surface, &swapper->priv->n_surf_formats, NULL); priv->surface, &priv->n_surf_formats, NULL);
if (gst_vulkan_error_to_g_error (err, error, if (gst_vulkan_error_to_g_error (err, error,
"GetPhysicalDeviceSurfaceFormatsKHR") < 0) "GetPhysicalDeviceSurfaceFormatsKHR") < 0)
return FALSE; return FALSE;
swapper->priv->surf_formats = priv->surf_formats = g_new0 (VkSurfaceFormatKHR, priv->n_surf_formats);
g_new0 (VkSurfaceFormatKHR, swapper->priv->n_surf_formats);
err = err =
swapper->priv->GetPhysicalDeviceSurfaceFormatsKHR (gpu, priv->GetPhysicalDeviceSurfaceFormatsKHR (gpu,
swapper->priv->surface, &swapper->priv->n_surf_formats, priv->surface, &priv->n_surf_formats, priv->surf_formats);
swapper->priv->surf_formats);
if (gst_vulkan_error_to_g_error (err, error, if (gst_vulkan_error_to_g_error (err, error,
"GetPhysicalDeviceSurfaceFormatsKHR") < 0) "GetPhysicalDeviceSurfaceFormatsKHR") < 0)
return FALSE; return FALSE;
@ -421,18 +432,17 @@ _vulkan_swapper_retrieve_surface_properties (GstVulkanSwapper * swapper,
dump_surface_formats (swapper); dump_surface_formats (swapper);
err = err =
swapper->priv->GetPhysicalDeviceSurfacePresentModesKHR (gpu, priv->GetPhysicalDeviceSurfacePresentModesKHR (gpu,
swapper->priv->surface, &swapper->priv->n_surf_present_modes, NULL); priv->surface, &priv->n_surf_present_modes, NULL);
if (gst_vulkan_error_to_g_error (err, error, if (gst_vulkan_error_to_g_error (err, error,
"GetPhysicalDeviceSurfacePresentModesKHR") < 0) "GetPhysicalDeviceSurfacePresentModesKHR") < 0)
return FALSE; return FALSE;
swapper->priv->surf_present_modes = priv->surf_present_modes =
g_new0 (VkPresentModeKHR, swapper->priv->n_surf_present_modes); g_new0 (VkPresentModeKHR, priv->n_surf_present_modes);
err = err =
swapper->priv->GetPhysicalDeviceSurfacePresentModesKHR (gpu, priv->GetPhysicalDeviceSurfacePresentModesKHR (gpu,
swapper->priv->surface, &swapper->priv->n_surf_present_modes, priv->surface, &priv->n_surf_present_modes, priv->surf_present_modes);
swapper->priv->surf_present_modes);
if (gst_vulkan_error_to_g_error (err, error, if (gst_vulkan_error_to_g_error (err, error,
"GetPhysicalDeviceSurfacePresentModesKHR") < 0) "GetPhysicalDeviceSurfacePresentModesKHR") < 0)
return FALSE; return FALSE;
@ -445,7 +455,9 @@ _vulkan_swapper_retrieve_surface_properties (GstVulkanSwapper * swapper,
static gboolean static gboolean
_on_window_close (GstVulkanWindow * window, GstVulkanSwapper * swapper) _on_window_close (GstVulkanWindow * window, GstVulkanSwapper * swapper)
{ {
g_atomic_int_set (&swapper->priv->to_quit, 1); GstVulkanSwapperPrivate *priv = GET_PRIV (swapper);
g_atomic_int_set (&priv->to_quit, 1);
return TRUE; return TRUE;
} }
@ -455,14 +467,15 @@ gst_vulkan_swapper_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec) const GValue * value, GParamSpec * pspec)
{ {
GstVulkanSwapper *swapper = GST_VULKAN_SWAPPER (object); GstVulkanSwapper *swapper = GST_VULKAN_SWAPPER (object);
GstVulkanSwapperPrivate *priv = GET_PRIV (swapper);
switch (prop_id) { switch (prop_id) {
case PROP_FORCE_ASPECT_RATIO: case PROP_FORCE_ASPECT_RATIO:
swapper->priv->force_aspect_ratio = g_value_get_boolean (value); priv->force_aspect_ratio = g_value_get_boolean (value);
break; break;
case PROP_PIXEL_ASPECT_RATIO: case PROP_PIXEL_ASPECT_RATIO:
swapper->priv->par_n = gst_value_get_fraction_numerator (value); priv->par_n = gst_value_get_fraction_numerator (value);
swapper->priv->par_d = gst_value_get_fraction_denominator (value); priv->par_d = gst_value_get_fraction_denominator (value);
break; break;
default: default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@ -475,14 +488,14 @@ gst_vulkan_swapper_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec) GValue * value, GParamSpec * pspec)
{ {
GstVulkanSwapper *swapper = GST_VULKAN_SWAPPER (object); GstVulkanSwapper *swapper = GST_VULKAN_SWAPPER (object);
GstVulkanSwapperPrivate *priv = GET_PRIV (swapper);
switch (prop_id) { switch (prop_id) {
case PROP_FORCE_ASPECT_RATIO: case PROP_FORCE_ASPECT_RATIO:
g_value_set_boolean (value, swapper->priv->force_aspect_ratio); g_value_set_boolean (value, priv->force_aspect_ratio);
break; break;
case PROP_PIXEL_ASPECT_RATIO: case PROP_PIXEL_ASPECT_RATIO:
gst_value_set_fraction (value, swapper->priv->par_n, gst_value_set_fraction (value, priv->par_n, priv->par_d);
swapper->priv->par_d);
break; break;
default: default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@ -494,55 +507,54 @@ static void
gst_vulkan_swapper_finalize (GObject * object) gst_vulkan_swapper_finalize (GObject * object)
{ {
GstVulkanSwapper *swapper = GST_VULKAN_SWAPPER (object); GstVulkanSwapper *swapper = GST_VULKAN_SWAPPER (object);
GstVulkanSwapperPrivate *priv = GET_PRIV (swapper);
GstVulkanInstance *instance = GstVulkanInstance *instance =
gst_vulkan_device_get_instance (swapper->device); gst_vulkan_device_get_instance (swapper->device);
int i; int i;
g_signal_handler_disconnect (swapper->window, swapper->priv->draw_id); g_signal_handler_disconnect (swapper->window, priv->draw_id);
swapper->priv->draw_id = 0; priv->draw_id = 0;
g_signal_handler_disconnect (swapper->window, swapper->priv->close_id); g_signal_handler_disconnect (swapper->window, priv->close_id);
swapper->priv->close_id = 0; priv->close_id = 0;
g_signal_handler_disconnect (swapper->window, swapper->priv->resize_id); g_signal_handler_disconnect (swapper->window, priv->resize_id);
swapper->priv->resize_id = 0; priv->resize_id = 0;
if (!gst_vulkan_trash_list_wait (swapper->priv->trash_list, -1)) if (!gst_vulkan_trash_list_wait (priv->trash_list, -1))
GST_WARNING_OBJECT (swapper, "Failed to wait for all fences to complete " GST_WARNING_OBJECT (swapper, "Failed to wait for all fences to complete "
"before shutting down"); "before shutting down");
gst_object_unref (swapper->priv->trash_list); gst_object_unref (priv->trash_list);
swapper->priv->trash_list = NULL; priv->trash_list = NULL;
if (swapper->priv->swap_chain_images) { if (priv->swap_chain_images) {
for (i = 0; i < swapper->priv->n_swap_chain_images; i++) { for (i = 0; i < priv->n_swap_chain_images; i++) {
gst_memory_unref ((GstMemory *) swapper->priv->swap_chain_images[i]); gst_memory_unref ((GstMemory *) priv->swap_chain_images[i]);
swapper->priv->swap_chain_images[i] = NULL; priv->swap_chain_images[i] = NULL;
} }
g_free (swapper->priv->swap_chain_images); g_free (priv->swap_chain_images);
} }
swapper->priv->swap_chain_images = NULL; priv->swap_chain_images = NULL;
if (swapper->priv->swap_chain) if (priv->swap_chain)
swapper->priv->DestroySwapchainKHR (swapper->device->device, priv->DestroySwapchainKHR (swapper->device->device, priv->swap_chain, NULL);
swapper->priv->swap_chain, NULL); priv->swap_chain = VK_NULL_HANDLE;
swapper->priv->swap_chain = VK_NULL_HANDLE;
if (swapper->priv->surface) { if (priv->surface) {
swapper->priv->DestroySurfaceKHR (instance->instance, priv->DestroySurfaceKHR (instance->instance, priv->surface, NULL);
swapper->priv->surface, NULL);
} }
swapper->priv->surface = VK_NULL_HANDLE; priv->surface = VK_NULL_HANDLE;
g_free (swapper->priv->surf_present_modes); g_free (priv->surf_present_modes);
swapper->priv->surf_present_modes = NULL; priv->surf_present_modes = NULL;
g_free (swapper->priv->surf_formats); g_free (priv->surf_formats);
swapper->priv->surf_formats = NULL; priv->surf_formats = NULL;
gst_buffer_replace (&swapper->priv->current_buffer, NULL); gst_buffer_replace (&priv->current_buffer, NULL);
gst_caps_replace (&swapper->priv->caps, NULL); gst_caps_replace (&priv->caps, NULL);
g_mutex_clear (&swapper->priv->render_lock); g_mutex_clear (&priv->render_lock);
if (swapper->cmd_pool) if (swapper->cmd_pool)
gst_object_unref (swapper->cmd_pool); gst_object_unref (swapper->cmd_pool);
@ -568,15 +580,15 @@ gst_vulkan_swapper_finalize (GObject * object)
static void static void
gst_vulkan_swapper_init (GstVulkanSwapper * swapper) gst_vulkan_swapper_init (GstVulkanSwapper * swapper)
{ {
swapper->priv = gst_vulkan_swapper_get_instance_private (swapper); GstVulkanSwapperPrivate *priv = GET_PRIV (swapper);
g_mutex_init (&swapper->priv->render_lock); g_mutex_init (&priv->render_lock);
swapper->priv->force_aspect_ratio = DEFAULT_FORCE_ASPECT_RATIO; priv->force_aspect_ratio = DEFAULT_FORCE_ASPECT_RATIO;
swapper->priv->par_n = DEFAULT_PIXEL_ASPECT_RATIO_N; priv->par_n = DEFAULT_PIXEL_ASPECT_RATIO_N;
swapper->priv->par_d = DEFAULT_PIXEL_ASPECT_RATIO_D; priv->par_d = DEFAULT_PIXEL_ASPECT_RATIO_D;
swapper->priv->trash_list = gst_vulkan_trash_fence_list_new (); priv->trash_list = gst_vulkan_trash_fence_list_new ();
} }
static void static void
@ -604,6 +616,7 @@ GstVulkanSwapper *
gst_vulkan_swapper_new (GstVulkanDevice * device, GstVulkanWindow * window) gst_vulkan_swapper_new (GstVulkanDevice * device, GstVulkanWindow * window)
{ {
GstVulkanSwapper *swapper; GstVulkanSwapper *swapper;
GstVulkanSwapperPrivate *priv;
swapper = g_object_new (GST_TYPE_VULKAN_SWAPPER, NULL); swapper = g_object_new (GST_TYPE_VULKAN_SWAPPER, NULL);
gst_object_ref_sink (swapper); gst_object_ref_sink (swapper);
@ -614,12 +627,13 @@ gst_vulkan_swapper_new (GstVulkanDevice * device, GstVulkanWindow * window)
gst_object_unref (swapper); gst_object_unref (swapper);
return NULL; return NULL;
} }
priv = GET_PRIV (swapper);
swapper->priv->close_id = g_signal_connect (swapper->window, "close", priv->close_id = g_signal_connect (swapper->window, "close",
(GCallback) _on_window_close, swapper); (GCallback) _on_window_close, swapper);
swapper->priv->draw_id = g_signal_connect (swapper->window, "draw", priv->draw_id = g_signal_connect (swapper->window, "draw",
(GCallback) _on_window_draw, swapper); (GCallback) _on_window_draw, swapper);
swapper->priv->resize_id = g_signal_connect (swapper->window, "resize", priv->resize_id = g_signal_connect (swapper->window, "resize",
(GCallback) _on_window_resize, swapper); (GCallback) _on_window_resize, swapper);
return swapper; return swapper;
@ -629,6 +643,7 @@ GstCaps *
gst_vulkan_swapper_get_supported_caps (GstVulkanSwapper * swapper, gst_vulkan_swapper_get_supported_caps (GstVulkanSwapper * swapper,
GError ** error) GError ** error)
{ {
GstVulkanSwapperPrivate *priv = GET_PRIV (swapper);
GstStructure *s; GstStructure *s;
GstCaps *caps; GstCaps *caps;
@ -648,12 +663,12 @@ gst_vulkan_swapper_get_supported_caps (GstVulkanSwapper * swapper,
g_value_init (&list, GST_TYPE_LIST); g_value_init (&list, GST_TYPE_LIST);
if (swapper->priv->n_surf_formats if (priv->n_surf_formats
&& swapper->priv->surf_formats[0].format == VK_FORMAT_UNDEFINED) { && priv->surf_formats[0].format == VK_FORMAT_UNDEFINED) {
_add_vk_format_to_list (&list, VK_FORMAT_B8G8R8A8_UNORM); _add_vk_format_to_list (&list, VK_FORMAT_B8G8R8A8_UNORM);
} else { } else {
for (i = 0; i < swapper->priv->n_surf_formats; i++) { for (i = 0; i < priv->n_surf_formats; i++) {
_add_vk_format_to_list (&list, swapper->priv->surf_formats[i].format); _add_vk_format_to_list (&list, priv->surf_formats[i].format);
} }
} }
@ -680,6 +695,7 @@ static gboolean
_allocate_swapchain (GstVulkanSwapper * swapper, GstCaps * caps, _allocate_swapchain (GstVulkanSwapper * swapper, GstCaps * caps,
GError ** error) GError ** error)
{ {
GstVulkanSwapperPrivate *priv = GET_PRIV (swapper);
VkSurfaceTransformFlagsKHR preTransform; VkSurfaceTransformFlagsKHR preTransform;
VkCompositeAlphaFlagsKHR alpha_flags; VkCompositeAlphaFlagsKHR alpha_flags;
VkPresentModeKHR present_mode; VkPresentModeKHR present_mode;
@ -698,25 +714,25 @@ _allocate_swapchain (GstVulkanSwapper * swapper, GstCaps * caps,
gpu = gst_vulkan_device_get_physical_device (swapper->device); gpu = gst_vulkan_device_get_physical_device (swapper->device);
err = err =
swapper->priv->GetPhysicalDeviceSurfaceCapabilitiesKHR (gpu, priv->GetPhysicalDeviceSurfaceCapabilitiesKHR (gpu,
swapper->priv->surface, &swapper->priv->surf_props); priv->surface, &priv->surf_props);
if (gst_vulkan_error_to_g_error (err, error, if (gst_vulkan_error_to_g_error (err, error,
"GetPhysicalDeviceSurfaceCapabilitiesKHR") < 0) "GetPhysicalDeviceSurfaceCapabilitiesKHR") < 0)
return FALSE; return FALSE;
/* width and height are either both -1, or both not -1. */ /* width and height are either both -1, or both not -1. */
if (swapper->priv->surf_props.currentExtent.width == -1) { if (priv->surf_props.currentExtent.width == -1) {
/* If the surface size is undefined, the size is set to /* If the surface size is undefined, the size is set to
* the size of the images requested. */ * the size of the images requested. */
guint width, height; guint width, height;
gst_vulkan_window_get_surface_dimensions (swapper->window, &width, &height); gst_vulkan_window_get_surface_dimensions (swapper->window, &width, &height);
swapchain_dims.width = width; swapchain_dims.width = width;
swapchain_dims.height = height; swapchain_dims.height = height;
swapper->priv->any_current_extent = TRUE; priv->any_current_extent = TRUE;
} else { } else {
/* If the surface size is defined, the swap chain size must match */ /* If the surface size is defined, the swap chain size must match */
swapchain_dims = swapper->priv->surf_props.currentExtent; swapchain_dims = priv->surf_props.currentExtent;
swapper->priv->any_current_extent = FALSE; priv->any_current_extent = FALSE;
} }
/* If mailbox mode is available, use it, as is the lowest-latency non- /* If mailbox mode is available, use it, as is the lowest-latency non-
@ -724,14 +740,13 @@ _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 (i = 0; i < swapper->priv->n_surf_present_modes; i++) { for (i = 0; i < priv->n_surf_present_modes; i++) {
if (swapper->priv->surf_present_modes[i] == VK_PRESENT_MODE_MAILBOX_KHR) { if (priv->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;
} }
if ((present_mode != VK_PRESENT_MODE_MAILBOX_KHR) && if ((present_mode != VK_PRESENT_MODE_MAILBOX_KHR) &&
(swapper->priv->surf_present_modes[i] == (priv->surf_present_modes[i] == VK_PRESENT_MODE_IMMEDIATE_KHR)) {
VK_PRESENT_MODE_IMMEDIATE_KHR)) {
present_mode = VK_PRESENT_MODE_IMMEDIATE_KHR; present_mode = VK_PRESENT_MODE_IMMEDIATE_KHR;
} }
} }
@ -739,27 +754,27 @@ _allocate_swapchain (GstVulkanSwapper * swapper, GstCaps * caps,
/* Determine the number of VkImage's to use in the swap chain (we desire to /* Determine the number of VkImage's to use in the swap chain (we desire to
* own only 1 image at a time, besides the images being displayed and * own only 1 image at a time, besides the images being displayed and
* queued for display): */ * queued for display): */
n_images_wanted = swapper->priv->surf_props.minImageCount + 1; n_images_wanted = priv->surf_props.minImageCount + 1;
if ((swapper->priv->surf_props.maxImageCount > 0) && if ((priv->surf_props.maxImageCount > 0) &&
(n_images_wanted > swapper->priv->surf_props.maxImageCount)) { (n_images_wanted > priv->surf_props.maxImageCount)) {
/* Application must settle for fewer images than desired: */ /* Application must settle for fewer images than desired: */
n_images_wanted = swapper->priv->surf_props.maxImageCount; n_images_wanted = priv->surf_props.maxImageCount;
} }
if (swapper->priv->surf_props. if (priv->surf_props.
supportedTransforms & VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR) { supportedTransforms & VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR) {
preTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR; preTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
} else { } else {
preTransform = swapper->priv->surf_props.currentTransform; preTransform = priv->surf_props.currentTransform;
} }
format = gst_vulkan_format_from_video_info (&swapper->priv->v_info, 0); format = gst_vulkan_format_from_video_info (&priv->v_info, 0);
color_space = _vk_color_space_from_video_info (&swapper->priv->v_info); color_space = _vk_color_space_from_video_info (&priv->v_info);
if ((swapper->priv->surf_props.supportedCompositeAlpha & if ((priv->surf_props.supportedCompositeAlpha &
VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR) != 0) { VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR) != 0) {
alpha_flags = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR; alpha_flags = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
} else if ((swapper->priv->surf_props.supportedCompositeAlpha & } else if ((priv->surf_props.supportedCompositeAlpha &
VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR) != 0) { VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR) != 0) {
alpha_flags = VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR; alpha_flags = VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR;
} else { } else {
@ -769,7 +784,7 @@ _allocate_swapchain (GstVulkanSwapper * swapper, GstCaps * caps,
return FALSE; return FALSE;
} }
if ((swapper->priv->surf_props.supportedUsageFlags & if ((priv->surf_props.supportedUsageFlags &
VK_IMAGE_USAGE_TRANSFER_DST_BIT) != 0) { VK_IMAGE_USAGE_TRANSFER_DST_BIT) != 0) {
usage |= VK_IMAGE_USAGE_TRANSFER_DST_BIT; usage |= VK_IMAGE_USAGE_TRANSFER_DST_BIT;
} else { } else {
@ -778,7 +793,7 @@ _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->priv-> if ((priv->
surf_props.supportedUsageFlags & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT) surf_props.supportedUsageFlags & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT)
!= 0) { != 0) {
usage |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; usage |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
@ -793,13 +808,13 @@ _allocate_swapchain (GstVulkanSwapper * swapper, GstCaps * caps,
VkSwapchainCreateInfoKHR swap_chain_info = { 0, }; VkSwapchainCreateInfoKHR swap_chain_info = { 0, };
VkSwapchainKHR old_swap_chain; VkSwapchainKHR old_swap_chain;
old_swap_chain = swapper->priv->swap_chain; old_swap_chain = priv->swap_chain;
/* *INDENT-OFF* */ /* *INDENT-OFF* */
swap_chain_info = (VkSwapchainCreateInfoKHR) { swap_chain_info = (VkSwapchainCreateInfoKHR) {
.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR, .sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR,
.pNext = NULL, .pNext = NULL,
.surface = swapper->priv->surface, .surface = priv->surface,
.minImageCount = n_images_wanted, .minImageCount = n_images_wanted,
.imageFormat = format, .imageFormat = format,
.imageColorSpace = color_space, .imageColorSpace = color_space,
@ -818,46 +833,44 @@ _allocate_swapchain (GstVulkanSwapper * swapper, GstCaps * caps,
/* *INDENT-ON* */ /* *INDENT-ON* */
err = err =
swapper->priv->CreateSwapchainKHR (swapper->device->device, priv->CreateSwapchainKHR (swapper->device->device,
&swap_chain_info, NULL, &swapper->priv->swap_chain); &swap_chain_info, NULL, &priv->swap_chain);
if (gst_vulkan_error_to_g_error (err, error, "vkCreateSwapchainKHR") < 0) if (gst_vulkan_error_to_g_error (err, error, "vkCreateSwapchainKHR") < 0)
return FALSE; return FALSE;
if (old_swap_chain != VK_NULL_HANDLE) { if (old_swap_chain != VK_NULL_HANDLE) {
swapper->priv->DestroySwapchainKHR (swapper->device->device, priv->DestroySwapchainKHR (swapper->device->device, old_swap_chain, NULL);
old_swap_chain, NULL);
} }
} }
err = err =
swapper->priv->GetSwapchainImagesKHR (swapper->device->device, priv->GetSwapchainImagesKHR (swapper->device->device,
swapper->priv->swap_chain, &swapper->priv->n_swap_chain_images, NULL); priv->swap_chain, &priv->n_swap_chain_images, NULL);
if (gst_vulkan_error_to_g_error (err, error, "vkGetSwapchainImagesKHR") < 0) if (gst_vulkan_error_to_g_error (err, error, "vkGetSwapchainImagesKHR") < 0)
return FALSE; return FALSE;
swap_chain_images = g_new0 (VkImage, swapper->priv->n_swap_chain_images); swap_chain_images = g_new0 (VkImage, priv->n_swap_chain_images);
err = err =
swapper->priv->GetSwapchainImagesKHR (swapper->device->device, priv->GetSwapchainImagesKHR (swapper->device->device,
swapper->priv->swap_chain, &swapper->priv->n_swap_chain_images, priv->swap_chain, &priv->n_swap_chain_images, swap_chain_images);
swap_chain_images);
if (gst_vulkan_error_to_g_error (err, error, "vkGetSwapchainImagesKHR") < 0) { if (gst_vulkan_error_to_g_error (err, error, "vkGetSwapchainImagesKHR") < 0) {
g_free (swap_chain_images); g_free (swap_chain_images);
return FALSE; return FALSE;
} }
swapper->priv->swap_chain_images = priv->swap_chain_images =
g_new0 (GstVulkanImageMemory *, swapper->priv->n_swap_chain_images); g_new0 (GstVulkanImageMemory *, priv->n_swap_chain_images);
for (i = 0; i < swapper->priv->n_swap_chain_images; i++) { for (i = 0; i < priv->n_swap_chain_images; i++) {
swapper->priv->swap_chain_images[i] = (GstVulkanImageMemory *) priv->swap_chain_images[i] = (GstVulkanImageMemory *)
gst_vulkan_image_memory_wrapped (swapper->device, swap_chain_images[i], gst_vulkan_image_memory_wrapped (swapper->device, swap_chain_images[i],
format, swapchain_dims.width, swapchain_dims.height, format, swapchain_dims.width, swapchain_dims.height,
VK_IMAGE_TILING_OPTIMAL, usage, NULL, NULL); VK_IMAGE_TILING_OPTIMAL, usage, NULL, NULL);
swapper->priv->swap_chain_images[i]->barrier.parent.pipeline_stages = priv->swap_chain_images[i]->barrier.parent.pipeline_stages =
VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT; VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
swapper->priv->swap_chain_images[i]->barrier.parent.access_flags = priv->swap_chain_images[i]->barrier.parent.access_flags =
VK_ACCESS_MEMORY_READ_BIT; VK_ACCESS_MEMORY_READ_BIT;
swapper->priv->swap_chain_images[i]->barrier.image_layout = priv->swap_chain_images[i]->barrier.image_layout =
VK_IMAGE_LAYOUT_UNDEFINED; VK_IMAGE_LAYOUT_UNDEFINED;
} }
@ -868,6 +881,7 @@ _allocate_swapchain (GstVulkanSwapper * swapper, GstCaps * caps,
static gboolean static gboolean
_swapchain_resize (GstVulkanSwapper * swapper, GError ** error) _swapchain_resize (GstVulkanSwapper * swapper, GError ** error)
{ {
GstVulkanSwapperPrivate *priv = GET_PRIV (swapper);
int i; int i;
if (!swapper->queue) { if (!swapper->queue) {
@ -876,22 +890,23 @@ _swapchain_resize (GstVulkanSwapper * swapper, GError ** error)
} }
} }
if (swapper->priv->swap_chain_images) { if (priv->swap_chain_images) {
for (i = 0; i < swapper->priv->n_swap_chain_images; i++) { for (i = 0; i < priv->n_swap_chain_images; i++) {
if (swapper->priv->swap_chain_images[i]) if (priv->swap_chain_images[i])
gst_memory_unref ((GstMemory *) swapper->priv->swap_chain_images[i]); gst_memory_unref ((GstMemory *) priv->swap_chain_images[i]);
} }
g_free (swapper->priv->swap_chain_images); g_free (priv->swap_chain_images);
swapper->priv->swap_chain_images = NULL; priv->swap_chain_images = NULL;
} }
return _allocate_swapchain (swapper, swapper->priv->caps, error); return _allocate_swapchain (swapper, priv->caps, error);
} }
static gboolean static gboolean
configure_display_from_info (GstVulkanSwapper * swapper, GstVideoInfo * vinfo) configure_display_from_info (GstVulkanSwapper * swapper, GstVideoInfo * vinfo)
{ {
GstVulkanSwapperPrivate *priv = GET_PRIV (swapper);
gint width; gint width;
gint height; gint height;
gboolean ok; gboolean ok;
@ -909,9 +924,9 @@ configure_display_from_info (GstVulkanSwapper * swapper, GstVideoInfo * vinfo)
par_n = 1; par_n = 1;
/* get display's PAR */ /* get display's PAR */
if (swapper->priv->par_n != 0 && swapper->priv->par_d != 0) { if (priv->par_n != 0 && priv->par_d != 0) {
display_par_n = swapper->priv->par_n; display_par_n = priv->par_n;
display_par_d = swapper->priv->par_d; display_par_d = priv->par_d;
} else { } else {
display_par_n = 1; display_par_n = 1;
display_par_d = 1; display_par_d = 1;
@ -929,24 +944,24 @@ configure_display_from_info (GstVulkanSwapper * swapper, GstVideoInfo * vinfo)
if (height % display_ratio_den == 0) { if (height % display_ratio_den == 0) {
GST_DEBUG_OBJECT (swapper, "keeping video height"); GST_DEBUG_OBJECT (swapper, "keeping video height");
swapper->priv->dar_width = (guint) priv->dar_width = (guint)
gst_util_uint64_scale_int (height, display_ratio_num, gst_util_uint64_scale_int (height, display_ratio_num,
display_ratio_den); display_ratio_den);
swapper->priv->dar_height = height; priv->dar_height = height;
} else if (width % display_ratio_num == 0) { } else if (width % display_ratio_num == 0) {
GST_DEBUG_OBJECT (swapper, "keeping video width"); GST_DEBUG_OBJECT (swapper, "keeping video width");
swapper->priv->dar_width = width; priv->dar_width = width;
swapper->priv->dar_height = (guint) priv->dar_height = (guint)
gst_util_uint64_scale_int (width, display_ratio_den, display_ratio_num); gst_util_uint64_scale_int (width, display_ratio_den, display_ratio_num);
} else { } else {
GST_DEBUG_OBJECT (swapper, "approximating while keeping video height"); GST_DEBUG_OBJECT (swapper, "approximating while keeping video height");
swapper->priv->dar_width = (guint) priv->dar_width = (guint)
gst_util_uint64_scale_int (height, display_ratio_num, gst_util_uint64_scale_int (height, display_ratio_num,
display_ratio_den); display_ratio_den);
swapper->priv->dar_height = height; priv->dar_height = height;
} }
GST_DEBUG_OBJECT (swapper, "scaling to %dx%d", swapper->priv->dar_width, GST_DEBUG_OBJECT (swapper, "scaling to %dx%d", priv->dar_width,
swapper->priv->dar_height); priv->dar_height);
return TRUE; return TRUE;
} }
@ -955,19 +970,21 @@ gboolean
gst_vulkan_swapper_set_caps (GstVulkanSwapper * swapper, GstCaps * caps, gst_vulkan_swapper_set_caps (GstVulkanSwapper * swapper, GstCaps * caps,
GError ** error) GError ** error)
{ {
if (!gst_video_info_from_caps (&swapper->priv->v_info, caps)) { GstVulkanSwapperPrivate *priv = GET_PRIV (swapper);
if (!gst_video_info_from_caps (&priv->v_info, caps)) {
g_set_error (error, GST_VULKAN_ERROR, g_set_error (error, GST_VULKAN_ERROR,
VK_ERROR_INITIALIZATION_FAILED, "Failed to get GstVideoInfo from caps"); VK_ERROR_INITIALIZATION_FAILED, "Failed to get GstVideoInfo from caps");
return FALSE; return FALSE;
} }
if (!configure_display_from_info (swapper, &swapper->priv->v_info)) { if (!configure_display_from_info (swapper, &priv->v_info)) {
g_set_error (error, GST_VULKAN_ERROR, g_set_error (error, GST_VULKAN_ERROR,
VK_ERROR_INITIALIZATION_FAILED, "Failed to configure display sizes"); VK_ERROR_INITIALIZATION_FAILED, "Failed to configure display sizes");
return FALSE; return FALSE;
} }
gst_caps_replace (&swapper->priv->caps, caps); gst_caps_replace (&priv->caps, caps);
return _swapchain_resize (swapper, error); return _swapchain_resize (swapper, error);
} }
@ -976,14 +993,15 @@ static gboolean
_build_render_buffer_cmd (GstVulkanSwapper * swapper, guint32 swap_idx, _build_render_buffer_cmd (GstVulkanSwapper * swapper, guint32 swap_idx,
GstBuffer * buffer, GstVulkanCommandBuffer ** cmd_ret, GError ** error) GstBuffer * buffer, GstVulkanCommandBuffer ** cmd_ret, GError ** error)
{ {
GstVulkanSwapperPrivate *priv = GET_PRIV (swapper);
GstMemory *in_mem; GstMemory *in_mem;
GstVulkanImageMemory *swap_img; GstVulkanImageMemory *swap_img;
GstVulkanCommandBuffer *cmd_buf; GstVulkanCommandBuffer *cmd_buf;
GstVideoRectangle src, dst, rslt; GstVideoRectangle src, dst, rslt;
VkResult err; VkResult err;
g_return_val_if_fail (swap_idx < swapper->priv->n_swap_chain_images, FALSE); g_return_val_if_fail (swap_idx < priv->n_swap_chain_images, FALSE);
swap_img = swapper->priv->swap_chain_images[swap_idx]; swap_img = priv->swap_chain_images[swap_idx];
if (!(cmd_buf = gst_vulkan_command_pool_create (swapper->cmd_pool, error))) if (!(cmd_buf = gst_vulkan_command_pool_create (swapper->cmd_pool, error)))
return FALSE; return FALSE;
@ -1032,15 +1050,14 @@ _build_render_buffer_cmd (GstVulkanSwapper * swapper, guint32 swap_idx,
} }
src.x = src.y = 0; src.x = src.y = 0;
src.w = swapper->priv->dar_width; src.w = priv->dar_width;
src.h = swapper->priv->dar_height; src.h = priv->dar_height;
dst.x = dst.y = 0; dst.x = dst.y = 0;
dst.w = gst_vulkan_image_memory_get_width (swap_img); dst.w = gst_vulkan_image_memory_get_width (swap_img);
dst.h = gst_vulkan_image_memory_get_height (swap_img); dst.h = gst_vulkan_image_memory_get_height (swap_img);
gst_video_sink_center_rect (src, dst, &rslt, gst_video_sink_center_rect (src, dst, &rslt, priv->force_aspect_ratio);
swapper->priv->force_aspect_ratio);
GST_TRACE_OBJECT (swapper, "rendering into result rectangle %ux%u+%u,%u " GST_TRACE_OBJECT (swapper, "rendering into result rectangle %ux%u+%u,%u "
"src %ux%u dst %ux%u", rslt.w, rslt.h, rslt.x, rslt.y, src.w, src.h, "src %ux%u dst %ux%u", rslt.w, rslt.h, rslt.x, rslt.y, src.w, src.h,
@ -1059,7 +1076,7 @@ _build_render_buffer_cmd (GstVulkanSwapper * swapper, guint32 swap_idx,
}, },
.srcOffsets = { .srcOffsets = {
{0, 0, 0}, {0, 0, 0},
{GST_VIDEO_INFO_WIDTH (&swapper->priv->v_info), GST_VIDEO_INFO_HEIGHT (&swapper->priv->v_info), 1}, {GST_VIDEO_INFO_WIDTH (&priv->v_info), GST_VIDEO_INFO_HEIGHT (&priv->v_info), 1},
}, },
.dstSubresource = { .dstSubresource = {
.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
@ -1154,6 +1171,7 @@ static gboolean
_render_buffer_unlocked (GstVulkanSwapper * swapper, _render_buffer_unlocked (GstVulkanSwapper * swapper,
GstBuffer * buffer, GError ** error) GstBuffer * buffer, GError ** error)
{ {
GstVulkanSwapperPrivate *priv = GET_PRIV (swapper);
VkSemaphore acquire_semaphore = { 0, }; VkSemaphore acquire_semaphore = { 0, };
VkSemaphore present_semaphore = { 0, }; VkSemaphore present_semaphore = { 0, };
VkSemaphoreCreateInfo semaphore_info = { 0, }; VkSemaphoreCreateInfo semaphore_info = { 0, };
@ -1163,7 +1181,7 @@ _render_buffer_unlocked (GstVulkanSwapper * swapper,
guint32 swap_idx; guint32 swap_idx;
VkResult err, present_err = VK_SUCCESS; VkResult err, present_err = VK_SUCCESS;
gst_vulkan_trash_list_gc (swapper->priv->trash_list); gst_vulkan_trash_list_gc (priv->trash_list);
if (!buffer) { if (!buffer) {
g_set_error (error, GST_VULKAN_ERROR, g_set_error (error, GST_VULKAN_ERROR,
@ -1171,13 +1189,13 @@ _render_buffer_unlocked (GstVulkanSwapper * swapper,
goto error; goto error;
} }
if (g_atomic_int_get (&swapper->priv->to_quit)) { if (g_atomic_int_get (&priv->to_quit)) {
g_set_error (error, GST_VULKAN_ERROR, VK_ERROR_SURFACE_LOST_KHR, g_set_error (error, GST_VULKAN_ERROR, VK_ERROR_SURFACE_LOST_KHR,
"Output window was closed"); "Output window was closed");
goto error; goto error;
} }
gst_buffer_replace (&swapper->priv->current_buffer, buffer); gst_buffer_replace (&priv->current_buffer, buffer);
/* *INDENT-OFF* */ /* *INDENT-OFF* */
semaphore_info = (VkSemaphoreCreateInfo) { semaphore_info = (VkSemaphoreCreateInfo) {
@ -1194,9 +1212,8 @@ reacquire:
goto error; goto error;
err = err =
swapper->priv->AcquireNextImageKHR (swapper->device->device, priv->AcquireNextImageKHR (swapper->device->device,
swapper->priv->swap_chain, -1, acquire_semaphore, VK_NULL_HANDLE, priv->swap_chain, -1, acquire_semaphore, VK_NULL_HANDLE, &swap_idx);
&swap_idx);
/* TODO: Deal with the VK_SUBOPTIMAL_KHR and VK_ERROR_OUT_OF_DATE_KHR */ /* TODO: Deal with the VK_SUBOPTIMAL_KHR and VK_ERROR_OUT_OF_DATE_KHR */
if (err == VK_ERROR_OUT_OF_DATE_KHR) { if (err == VK_ERROR_OUT_OF_DATE_KHR) {
GST_DEBUG_OBJECT (swapper, "out of date frame acquired"); GST_DEBUG_OBJECT (swapper, "out of date frame acquired");
@ -1247,10 +1264,10 @@ reacquire:
if (gst_vulkan_error_to_g_error (err, error, "vkQueueSubmit") < 0) if (gst_vulkan_error_to_g_error (err, error, "vkQueueSubmit") < 0)
goto error; goto error;
gst_vulkan_trash_list_add (swapper->priv->trash_list, gst_vulkan_trash_list_add (priv->trash_list,
gst_vulkan_trash_new_mini_object_unref (gst_vulkan_fence_ref (fence), gst_vulkan_trash_new_mini_object_unref (gst_vulkan_fence_ref (fence),
GST_MINI_OBJECT_CAST (cmd_buf))); GST_MINI_OBJECT_CAST (cmd_buf)));
gst_vulkan_trash_list_add (swapper->priv->trash_list, gst_vulkan_trash_list_add (priv->trash_list,
gst_vulkan_trash_new_free_semaphore (fence, acquire_semaphore)); gst_vulkan_trash_new_free_semaphore (fence, acquire_semaphore));
acquire_semaphore = VK_NULL_HANDLE; acquire_semaphore = VK_NULL_HANDLE;
@ -1266,13 +1283,13 @@ reacquire:
.waitSemaphoreCount = 1, .waitSemaphoreCount = 1,
.pWaitSemaphores = &present_semaphore, .pWaitSemaphores = &present_semaphore,
.swapchainCount = 1, .swapchainCount = 1,
.pSwapchains = &swapper->priv->swap_chain, .pSwapchains = &priv->swap_chain,
.pImageIndices = &swap_idx, .pImageIndices = &swap_idx,
.pResults = &present_err, .pResults = &present_err,
}; };
/* *INDENT-ON* */ /* *INDENT-ON* */
err = swapper->priv->QueuePresentKHR (swapper->queue->queue, &present); err = priv->QueuePresentKHR (swapper->queue->queue, &present);
if (present_err == VK_ERROR_OUT_OF_DATE_KHR) { if (present_err == VK_ERROR_OUT_OF_DATE_KHR) {
GST_DEBUG_OBJECT (swapper, "out of date frame submitted"); GST_DEBUG_OBJECT (swapper, "out of date frame submitted");
@ -1304,7 +1321,7 @@ reacquire:
if (gst_vulkan_error_to_g_error (err, error, "vkQueueSubmit") < 0) if (gst_vulkan_error_to_g_error (err, error, "vkQueueSubmit") < 0)
goto error; goto error;
gst_vulkan_trash_list_add (swapper->priv->trash_list, gst_vulkan_trash_list_add (priv->trash_list,
gst_vulkan_trash_new_free_semaphore (fence, present_semaphore)); gst_vulkan_trash_new_free_semaphore (fence, present_semaphore));
fence = NULL; fence = NULL;
} }
@ -1354,19 +1371,20 @@ gst_vulkan_swapper_render_buffer (GstVulkanSwapper * swapper,
static void static void
_on_window_draw (GstVulkanWindow * window, GstVulkanSwapper * swapper) _on_window_draw (GstVulkanWindow * window, GstVulkanSwapper * swapper)
{ {
GstVulkanSwapperPrivate *priv = GET_PRIV (swapper);
GError *error = NULL; GError *error = NULL;
RENDER_LOCK (swapper); RENDER_LOCK (swapper);
if (!swapper->priv->current_buffer) { if (!priv->current_buffer) {
GST_DEBUG_OBJECT (swapper, "No buffer to render"); GST_DEBUG_OBJECT (swapper, "No buffer to render");
RENDER_UNLOCK (swapper); RENDER_UNLOCK (swapper);
return; return;
} }
/* TODO: perform some rate limiting of the number of redraw events */ /* TODO: perform some rate limiting of the number of redraw events */
if (!_render_buffer_unlocked (swapper, swapper->priv->current_buffer, &error)) if (!_render_buffer_unlocked (swapper, priv->current_buffer, &error))
GST_ERROR_OBJECT (swapper, "Failed to redraw buffer %p %s", GST_ERROR_OBJECT (swapper, "Failed to redraw buffer %p %s",
swapper->priv->current_buffer, error->message); priv->current_buffer, error->message);
g_clear_error (&error); g_clear_error (&error);
RENDER_UNLOCK (swapper); RENDER_UNLOCK (swapper);
} }
@ -1375,10 +1393,11 @@ static void
_on_window_resize (GstVulkanWindow * window, guint width, guint height, _on_window_resize (GstVulkanWindow * window, guint width, guint height,
GstVulkanSwapper * swapper) GstVulkanSwapper * swapper)
{ {
GstVulkanSwapperPrivate *priv = GET_PRIV (swapper);
GError *error = NULL; GError *error = NULL;
RENDER_LOCK (swapper); RENDER_LOCK (swapper);
if (swapper->priv->any_current_extent) { if (priv->any_current_extent) {
if (!_swapchain_resize (swapper, &error)) if (!_swapchain_resize (swapper, &error))
GST_ERROR_OBJECT (swapper, "Failed to resize swapchain: %s", GST_ERROR_OBJECT (swapper, "Failed to resize swapchain: %s",
error->message); error->message);

2
gst-libs/gst/vulkan/gstvkswapper.h
View file

@ -50,8 +50,6 @@ struct _GstVulkanSwapper
GstVulkanWindow *window; GstVulkanWindow *window;
GstVulkanQueue *queue; GstVulkanQueue *queue;
GstVulkanCommandPool *cmd_pool; GstVulkanCommandPool *cmd_pool;
GstVulkanSwapperPrivate *priv;
}; };
struct _GstVulkanSwapperClass struct _GstVulkanSwapperClass

19
gst-libs/gst/vulkan/gstvkwindow.c
View file

@ -62,6 +62,8 @@ struct _GstVulkanWindowPrivate
guint surface_height; guint surface_height;
}; };
#define GET_PRIV(window) gst_vulkan_window_get_instance_private (window)
#define gst_vulkan_window_parent_class parent_class #define gst_vulkan_window_parent_class parent_class
G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (GstVulkanWindow, gst_vulkan_window, G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (GstVulkanWindow, gst_vulkan_window,
GST_TYPE_OBJECT); GST_TYPE_OBJECT);
@ -175,7 +177,6 @@ gst_vulkan_window_get_property (GObject * object, guint prop_id,
static void static void
gst_vulkan_window_init (GstVulkanWindow * window) gst_vulkan_window_init (GstVulkanWindow * window)
{ {
window->priv = gst_vulkan_window_get_instance_private (window);
} }
static void static void
@ -395,10 +396,14 @@ gst_vulkan_window_close (GstVulkanWindow * window)
void void
gst_vulkan_window_resize (GstVulkanWindow * window, gint width, gint height) gst_vulkan_window_resize (GstVulkanWindow * window, gint width, gint height)
{ {
GstVulkanWindowPrivate *priv;
g_return_if_fail (GST_IS_VULKAN_WINDOW (window)); g_return_if_fail (GST_IS_VULKAN_WINDOW (window));
window->priv->surface_width = width; priv = GET_PRIV (window);
window->priv->surface_height = height;
priv->surface_width = width;
priv->surface_height = height;
g_signal_emit (window, gst_vulkan_window_signals[SIGNAL_RESIZE], 0, width, g_signal_emit (window, gst_vulkan_window_signals[SIGNAL_RESIZE], 0, width,
height); height);
@ -442,18 +447,20 @@ void
gst_vulkan_window_get_surface_dimensions (GstVulkanWindow * window, gst_vulkan_window_get_surface_dimensions (GstVulkanWindow * window,
guint * width, guint * height) guint * width, guint * height)
{ {
GstVulkanWindowPrivate *priv;
GstVulkanWindowClass *klass; GstVulkanWindowClass *klass;
g_return_if_fail (GST_IS_VULKAN_WINDOW (window)); g_return_if_fail (GST_IS_VULKAN_WINDOW (window));
klass = GST_VULKAN_WINDOW_GET_CLASS (window); klass = GST_VULKAN_WINDOW_GET_CLASS (window);
priv = GET_PRIV (window);
if (klass->get_surface_dimensions) { if (klass->get_surface_dimensions) {
klass->get_surface_dimensions (window, width, height); klass->get_surface_dimensions (window, width, height);
} else { } else {
GST_DEBUG_OBJECT (window, "Returning size %ix%i", GST_DEBUG_OBJECT (window, "Returning size %ix%i",
window->priv->surface_width, window->priv->surface_height); priv->surface_width, priv->surface_height);
*width = window->priv->surface_width; *width = priv->surface_width;
*height = window->priv->surface_height; *height = priv->surface_height;
} }
} }

2
gst-libs/gst/vulkan/gstvkwindow.h
View file

@ -65,8 +65,6 @@ struct _GstVulkanWindow {
GMutex lock; GMutex lock;
GstVulkanWindowPrivate *priv;
gpointer _reserved[GST_PADDING]; gpointer _reserved[GST_PADDING];
}; };

2
gst-libs/gst/vulkan/ios/gstvkwindow_ios.h
View file

@ -54,8 +54,6 @@ struct _GstVulkanWindowIos
PFN_vkCreateIOSSurfaceMVK CreateIOSSurface; PFN_vkCreateIOSSurfaceMVK CreateIOSSurface;
/*< private >*/ /*< private >*/
GstVulkanWindowIosPrivate *priv;
gpointer _reserved[GST_PADDING]; gpointer _reserved[GST_PADDING];
}; };

39
gst-libs/gst/vulkan/ios/gstvkwindow_ios.m
View file

@ -87,9 +87,10 @@ static void
gst_vulkan_window_ios_finalize (GObject * object) gst_vulkan_window_ios_finalize (GObject * object)
{ {
GstVulkanWindowIos *window_ios = GST_VULKAN_WINDOW_IOS (object); GstVulkanWindowIos *window_ios = GST_VULKAN_WINDOW_IOS (object);
GstVulkanWindowIosPrivate *priv = GET_PRIV (window_ios);
g_mutex_clear (&window_ios->priv->lock); g_mutex_clear (&priv->lock);
g_cond_clear (&window_ios->priv->cond); g_cond_clear (&priv->cond);
G_OBJECT_CLASS (parent_class)->finalize (object); G_OBJECT_CLASS (parent_class)->finalize (object);
} }
@ -114,13 +115,13 @@ gst_vulkan_window_ios_class_init (GstVulkanWindowIosClass * klass)
static void static void
gst_vulkan_window_ios_init (GstVulkanWindowIos * window) gst_vulkan_window_ios_init (GstVulkanWindowIos * window)
{ {
window->priv = gst_vulkan_window_ios_get_instance_private (window); GstVulkanWindowIosPrivate *priv = GET_PRIV (window_ios);
window->priv->preferred_width = 320; priv->preferred_width = 320;
window->priv->preferred_height = 240; priv->preferred_height = 240;
g_mutex_init (&window->priv->lock); g_mutex_init (&priv->lock);
g_cond_init (&window->priv->cond); g_cond_init (&priv->cond);
} }
/* Must be called in the gl thread */ /* Must be called in the gl thread */
@ -148,7 +149,7 @@ gst_vulkan_window_ios_new (GstVulkanDisplay * display)
static void static void
_create_window (GstVulkanWindowIos * window_ios) _create_window (GstVulkanWindowIos * window_ios)
{ {
GstVulkanWindowIosPrivate *priv = window_ios->priv; GstVulkanWindowIosPrivate *priv = GET_PRIV (window_ios);
UIView *external_view = (__bridge UIView *) priv->external_view; UIView *external_view = (__bridge UIView *) priv->external_view;
CGRect rect = CGRectMake (0, 0, external_view.frame.size.width, external_view.frame.size.height); CGRect rect = CGRectMake (0, 0, external_view.frame.size.width, external_view.frame.size.height);
GstVulkanUIView *view; GstVulkanUIView *view;
@ -171,7 +172,7 @@ _create_window (GstVulkanWindowIos * window_ios)
gboolean gboolean
gst_vulkan_window_ios_create_window (GstVulkanWindowIos * window_ios) gst_vulkan_window_ios_create_window (GstVulkanWindowIos * window_ios)
{ {
GstVulkanWindowIosPrivate *priv = window_ios->priv; GstVulkanWindowIosPrivate *priv = GET_PRIV (window_ios);
if (!priv->external_view) { if (!priv->external_view) {
GST_WARNING_OBJECT(window_ios, "No external UIView provided"); GST_WARNING_OBJECT(window_ios, "No external UIView provided");
@ -194,11 +195,12 @@ static VkSurfaceKHR
gst_vulkan_window_ios_get_surface (GstVulkanWindow * window, GError ** error) gst_vulkan_window_ios_get_surface (GstVulkanWindow * window, GError ** error)
{ {
GstVulkanWindowIos *window_ios = GST_VULKAN_WINDOW_IOS (window); GstVulkanWindowIos *window_ios = GST_VULKAN_WINDOW_IOS (window);
GstVulkanWindowIosPrivate *priv = GET_PRIV (window_ios);
VkIOSSurfaceCreateInfoMVK info = { 0, }; VkIOSSurfaceCreateInfoMVK info = { 0, };
VkSurfaceKHR ret; VkSurfaceKHR ret;
VkResult err; VkResult err;
if (!window_ios->priv->internal_layer) { if (!priv->internal_layer) {
g_set_error_literal (error, GST_VULKAN_ERROR, g_set_error_literal (error, GST_VULKAN_ERROR,
VK_ERROR_INITIALIZATION_FAILED, VK_ERROR_INITIALIZATION_FAILED,
"No layer to retrieve surface for. Has create_window() been called?"); "No layer to retrieve surface for. Has create_window() been called?");
@ -208,7 +210,7 @@ gst_vulkan_window_ios_get_surface (GstVulkanWindow * window, GError ** error)
info.sType = VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK; info.sType = VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK;
info.pNext = NULL; info.pNext = NULL;
info.flags = 0; info.flags = 0;
info.pView = window_ios->priv->internal_layer; info.pView = priv->internal_layer;
if (!window_ios->CreateIOSSurface) if (!window_ios->CreateIOSSurface)
window_ios->CreateIOSSurface = window_ios->CreateIOSSurface =
@ -251,13 +253,14 @@ static void
gst_vulkan_window_ios_close (GstVulkanWindow * window) gst_vulkan_window_ios_close (GstVulkanWindow * window)
{ {
GstVulkanWindowIos *window_ios = GST_VULKAN_WINDOW_IOS (window); GstVulkanWindowIos *window_ios = GST_VULKAN_WINDOW_IOS (window);
GstVulkanUIView *view = (__bridge GstVulkanUIView *) window_ios->priv->internal_view; GstVulkanWindowIosPrivate *priv = GET_PRIV (window_ios);
GstVulkanUIView *view = (__bridge GstVulkanUIView *) priv->internal_view;
[view setGstWindow:NULL]; [view setGstWindow:NULL];
CFBridgingRelease (window_ios->priv->internal_view); CFBridgingRelease (priv->internal_view);
window_ios->priv->internal_view = NULL; priv->internal_view = NULL;
CFBridgingRelease (window_ios->priv->internal_layer); CFBridgingRelease (priv->internal_layer);
window_ios->priv->internal_layer = NULL; priv->internal_layer = NULL;
GST_VULKAN_WINDOW_CLASS (parent_class)->close (window); GST_VULKAN_WINDOW_CLASS (parent_class)->close (window);
} }
@ -271,12 +274,12 @@ gst_vulkan_window_ios_set_window_handle (GstVulkanWindow * window,
g_return_if_fail (view != NULL); g_return_if_fail (view != NULL);
if (window_ios->priv->external_view && window_ios->priv->external_view != view) { if (priv->external_view && priv->external_view != view) {
GST_FIXME_OBJECT (window_ios, "View changes are not implemented"); GST_FIXME_OBJECT (window_ios, "View changes are not implemented");
return; return;
} }
window_ios->priv->external_view = view; priv->external_view = view;
} }
@implementation GstVulkanUIView { @implementation GstVulkanUIView {

24
gst-libs/gst/vulkan/win32/gstvkwindow_win32.c
View file

@ -53,6 +53,8 @@ GST_DEBUG_CATEGORY_STATIC (GST_CAT_DEFAULT);
G_DEFINE_TYPE_WITH_CODE (GstVulkanWindowWin32, gst_vulkan_window_win32, G_DEFINE_TYPE_WITH_CODE (GstVulkanWindowWin32, gst_vulkan_window_win32,
GST_TYPE_VULKAN_WINDOW, G_ADD_PRIVATE (GstVulkanWindowWin32) DEBUG_INIT); GST_TYPE_VULKAN_WINDOW, G_ADD_PRIVATE (GstVulkanWindowWin32) DEBUG_INIT);
#define GET_PRIV(window) gst_vulkan_window_win32_get_instance_private (window)
static void gst_vulkan_window_win32_set_window_handle (GstVulkanWindow * window, static void gst_vulkan_window_win32_set_window_handle (GstVulkanWindow * window,
guintptr handle); guintptr handle);
static VkSurfaceKHR static VkSurfaceKHR
@ -84,10 +86,10 @@ gst_vulkan_window_win32_class_init (GstVulkanWindowWin32Class * klass)
static void static void
gst_vulkan_window_win32_init (GstVulkanWindowWin32 * window) gst_vulkan_window_win32_init (GstVulkanWindowWin32 * window)
{ {
window->priv = gst_vulkan_window_win32_get_instance_private (window); GstVulkanWindowWin32Private *priv = GET_PRIV (window);
window->priv->preferred_width = 320; priv->preferred_width = 320;
window->priv->preferred_height = 240; priv->preferred_height = 240;
} }
GstVulkanWindowWin32 * GstVulkanWindowWin32 *
@ -148,6 +150,7 @@ static gboolean
gst_vulkan_window_win32_open (GstVulkanWindow * window, GError ** error) gst_vulkan_window_win32_open (GstVulkanWindow * window, GError ** error)
{ {
GstVulkanWindowWin32 *window_win32 = GST_VULKAN_WINDOW_WIN32 (window); GstVulkanWindowWin32 *window_win32 = GST_VULKAN_WINDOW_WIN32 (window);
GstVulkanWindowWin32Private *priv = GET_PRIV (window_win32);
GstVulkanDisplay *display; GstVulkanDisplay *display;
GMainContext *context; GMainContext *context;
CreateWindowData data = { 0, }; CreateWindowData data = { 0, };
@ -159,9 +162,8 @@ gst_vulkan_window_win32_open (GstVulkanWindow * window, GError ** error)
context = g_main_context_ref (display->main_context); context = g_main_context_ref (display->main_context);
gst_object_unref (display); gst_object_unref (display);
window_win32->priv->msg_io_channel = g_io_channel_win32_new_messages (0); priv->msg_io_channel = g_io_channel_win32_new_messages (0);
window_win32->msg_source = msg_source = g_io_create_watch (priv->msg_io_channel, G_IO_IN);
g_io_create_watch (window_win32->priv->msg_io_channel, G_IO_IN);
g_source_set_callback (window_win32->msg_source, (GSourceFunc) msg_cb, NULL, g_source_set_callback (window_win32->msg_source, (GSourceFunc) msg_cb, NULL,
NULL); NULL);
g_source_attach (window_win32->msg_source, context); g_source_attach (window_win32->msg_source, context);
@ -193,6 +195,7 @@ static void
gst_vulkan_window_win32_close (GstVulkanWindow * window) gst_vulkan_window_win32_close (GstVulkanWindow * window)
{ {
GstVulkanWindowWin32 *window_win32 = GST_VULKAN_WINDOW_WIN32 (window); GstVulkanWindowWin32 *window_win32 = GST_VULKAN_WINDOW_WIN32 (window);
GstVulkanWindowWin32Private *priv = GET_PRIV (window_win32);
release_parent_win_id (window_win32); release_parent_win_id (window_win32);
@ -209,8 +212,8 @@ gst_vulkan_window_win32_close (GstVulkanWindow * window)
g_source_destroy (window_win32->msg_source); g_source_destroy (window_win32->msg_source);
g_source_unref (window_win32->msg_source); g_source_unref (window_win32->msg_source);
window_win32->msg_source = NULL; window_win32->msg_source = NULL;
g_io_channel_unref (window_win32->priv->msg_io_channel); g_io_channel_unref (priv->msg_io_channel);
window_win32->priv->msg_io_channel = NULL; priv->msg_io_channel = NULL;
GST_VULKAN_WINDOW_CLASS (parent_class)->close (window); GST_VULKAN_WINDOW_CLASS (parent_class)->close (window);
} }
@ -455,8 +458,9 @@ gst_vulkan_window_win32_set_window_handle (GstVulkanWindow * window,
static void static void
gst_vulkan_window_win32_show (GstVulkanWindowWin32 * window) gst_vulkan_window_win32_show (GstVulkanWindowWin32 * window)
{ {
gint width = window->priv->preferred_width; GstVulkanWindowWin32Private *priv = GET_PRIV (window);
gint height = window->priv->preferred_height; gint width = priv->preferred_width;
gint height = priv->preferred_height;
if (!window->visible) { if (!window->visible) {
HWND parent_id = window->parent_win_id; HWND parent_id = window->parent_win_id;

2
gst-libs/gst/vulkan/win32/gstvkwindow_win32.h
View file

@ -58,8 +58,6 @@ struct _GstVulkanWindowWin32 {
GSource *msg_source; GSource *msg_source;
/*< private >*/ /*< private >*/
GstVulkanWindowWin32Private *priv;
gpointer _reserved[GST_PADDING]; gpointer _reserved[GST_PADDING];
}; };

9
gst-libs/gst/vulkan/xcb/gstvkwindow_xcb.c
View file

@ -28,8 +28,7 @@
#include "gstvkwindow_xcb.h" #include "gstvkwindow_xcb.h"
#include "gstvkdisplay_xcb.h" #include "gstvkdisplay_xcb.h"
#define GST_VULKAN_WINDOW_XCB_GET_PRIVATE(o) \ #define GET_PRIV(o) gst_vulkan_window_xcb_get_instance_private (o)
(G_TYPE_INSTANCE_GET_PRIVATE((o), GST_TYPE_VULKAN_WINDOW_XCB, GstVulkanWindowXCBPrivate))
#define GST_CAT_DEFAULT gst_vulkan_window_xcb_debug #define GST_CAT_DEFAULT gst_vulkan_window_xcb_debug
GST_DEBUG_CATEGORY_STATIC (GST_CAT_DEFAULT); GST_DEBUG_CATEGORY_STATIC (GST_CAT_DEFAULT);
@ -100,7 +99,6 @@ gst_vulkan_window_xcb_class_init (GstVulkanWindowXCBClass * klass)
static void static void
gst_vulkan_window_xcb_init (GstVulkanWindowXCB * window) gst_vulkan_window_xcb_init (GstVulkanWindowXCB * window)
{ {
window->priv = gst_vulkan_window_xcb_get_instance_private (window);
} }
/* Must be called in the gl thread */ /* Must be called in the gl thread */
@ -303,6 +301,7 @@ static void
gst_vulkan_window_xcb_close (GstVulkanWindow * window) gst_vulkan_window_xcb_close (GstVulkanWindow * window)
{ {
GstVulkanWindowXCB *window_xcb = GST_VULKAN_WINDOW_XCB (window); GstVulkanWindowXCB *window_xcb = GST_VULKAN_WINDOW_XCB (window);
GstVulkanWindowXCBPrivate *priv = GET_PRIV (window_xcb);
GstVulkanDisplayXCB *display_xcb = (GstVulkanDisplayXCB *) window->display; GstVulkanDisplayXCB *display_xcb = (GstVulkanDisplayXCB *) window->display;
xcb_connection_t *connection = xcb_connection_t *connection =
GST_VULKAN_DISPLAY_XCB_CONNECTION (display_xcb); GST_VULKAN_DISPLAY_XCB_CONNECTION (display_xcb);
@ -310,8 +309,8 @@ gst_vulkan_window_xcb_close (GstVulkanWindow * window)
if (connection) { if (connection) {
gst_vulkan_window_xcb_hide (window); gst_vulkan_window_xcb_hide (window);
g_free (window_xcb->priv->atom_wm_delete_window); g_free (priv->atom_wm_delete_window);
window_xcb->priv->atom_wm_delete_window = NULL; priv->atom_wm_delete_window = NULL;
GST_DEBUG ("display receiver closed"); GST_DEBUG ("display receiver closed");
} }

2
gst-libs/gst/vulkan/xcb/gstvkwindow_xcb.h
View file

@ -59,8 +59,6 @@ struct _GstVulkanWindowXCB
PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR GetPhysicalDeviceXcbPresentationSupport; PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR GetPhysicalDeviceXcbPresentationSupport;
/*< private >*/ /*< private >*/
GstVulkanWindowXCBPrivate *priv;
gpointer _reserved[GST_PADDING]; gpointer _reserved[GST_PADDING];
}; };