gstreamer/ext/vulkan/vkinstance.c
2016-02-17 01:13:43 +11:00

542 lines
17 KiB
C

/*
* GStreamer
* Copyright (C) 2015 Matthew Waters <matthew@centricular.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "vkinstance.h"
#include "vkutils_private.h"
#include <string.h>
#define APP_SHORT_NAME "GStreamer"
static const char *instance_validation_layers[] = {
"VK_LAYER_LUNARG_threading",
"VK_LAYER_LUNARG_mem_tracker",
"VK_LAYER_LUNARG_object_tracker",
"VK_LAYER_LUNARG_draw_state",
"VK_LAYER_LUNARG_param_checker",
"VK_LAYER_LUNARG_swapchain",
"VK_LAYER_LUNARG_device_limits",
"VK_LAYER_LUNARG_image",
};
#define GST_CAT_DEFAULT gst_vulkan_instance_debug
GST_DEBUG_CATEGORY (GST_CAT_DEFAULT);
GST_DEBUG_CATEGORY (GST_VULKAN_DEBUG_CAT);
GST_DEBUG_CATEGORY_STATIC (GST_CAT_CONTEXT);
enum
{
SIGNAL_0,
SIGNAL_CREATE_DEVICE,
LAST_SIGNAL
};
static guint gst_vulkan_instance_signals[LAST_SIGNAL] = { 0 };
#define gst_vulkan_instance_parent_class parent_class
G_DEFINE_TYPE_WITH_CODE (GstVulkanInstance, gst_vulkan_instance,
GST_TYPE_OBJECT, GST_DEBUG_CATEGORY_INIT (GST_CAT_DEFAULT,
"vulkaninstance", 0, "Vulkan Instance");
GST_DEBUG_CATEGORY_INIT (GST_VULKAN_DEBUG_CAT,
"vulkandebug", 0, "Vulkan Debug");
GST_DEBUG_CATEGORY_GET (GST_CAT_CONTEXT, "GST_CONTEXT"));
static void gst_vulkan_instance_finalize (GObject * object);
struct _GstVulkanInstancePrivate
{
gboolean opened;
};
GstVulkanInstance *
gst_vulkan_instance_new (void)
{
return g_object_new (GST_TYPE_VULKAN_INSTANCE, NULL);
}
static void
gst_vulkan_instance_init (GstVulkanInstance * instance)
{
instance->priv = G_TYPE_INSTANCE_GET_PRIVATE ((instance),
GST_TYPE_VULKAN_INSTANCE, GstVulkanInstancePrivate);
}
static void
gst_vulkan_instance_class_init (GstVulkanInstanceClass * klass)
{
gst_vulkan_memory_init_once ();
gst_vulkan_image_memory_init_once ();
gst_vulkan_buffer_memory_init_once ();
g_type_class_add_private (klass, sizeof (GstVulkanInstancePrivate));
/**
* GstVulkanInstance::create-device:
* @object: the #GstVulkanDisplay
*
* Overrides the #GstVulkanDevice creation mechanism.
* It can be called from any thread.
*
* Returns: the newly created #GstVulkanDevice.
*/
gst_vulkan_instance_signals[SIGNAL_CREATE_DEVICE] =
g_signal_new ("create-device", G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_generic,
GST_TYPE_VULKAN_DEVICE, 0);
G_OBJECT_CLASS (klass)->finalize = gst_vulkan_instance_finalize;
}
static void
gst_vulkan_instance_finalize (GObject * object)
{
GstVulkanInstance *instance = GST_VULKAN_INSTANCE (object);
if (instance->priv->opened) {
if (instance->dbgDestroyDebugReportCallback)
instance->dbgDestroyDebugReportCallback (instance->instance,
instance->msg_callback, NULL);
g_free (instance->physical_devices);
}
instance->priv->opened = FALSE;
if (instance->instance)
vkDestroyInstance (instance->instance, NULL);
instance->instance = NULL;
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static VkBool32
_gst_vk_debug_callback (VkDebugReportFlagsEXT msgFlags,
VkDebugReportObjectTypeEXT objType, uint64_t srcObject, size_t location,
int32_t msgCode, const char *pLayerPrefix, const char *pMsg,
void *pUserData)
{
if (msgFlags & VK_DEBUG_REPORT_ERROR_BIT_EXT) {
GST_CAT_ERROR (GST_VULKAN_DEBUG_CAT, "[%s] Code %d : %s", pLayerPrefix,
msgCode, pMsg);
} else if (msgFlags & VK_DEBUG_REPORT_WARNING_BIT_EXT) {
GST_CAT_WARNING (GST_VULKAN_DEBUG_CAT, "[%s] Code %d : %s", pLayerPrefix,
msgCode, pMsg);
} else if (msgFlags & VK_DEBUG_REPORT_INFORMATION_BIT_EXT) {
GST_CAT_LOG (GST_VULKAN_DEBUG_CAT, "[%s] Code %d : %s", pLayerPrefix,
msgCode, pMsg);
} else if (msgFlags & VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT) {
GST_CAT_FIXME (GST_VULKAN_DEBUG_CAT, "[%s] Code %d : %s", pLayerPrefix,
msgCode, pMsg);
} else if (msgFlags & VK_DEBUG_REPORT_DEBUG_BIT_EXT) {
GST_CAT_TRACE (GST_VULKAN_DEBUG_CAT, "[%s] Code %d : %s", pLayerPrefix,
msgCode, pMsg);
} else {
return FALSE;
}
/*
* false indicates that layer should not bail-out of an
* API call that had validation failures. This may mean that the
* app dies inside the driver due to invalid parameter(s).
* That's what would happen without validation layers, so we'll
* keep that behavior here.
*/
return FALSE;
}
gboolean
gst_vulkan_instance_open (GstVulkanInstance * instance, GError ** error)
{
VkExtensionProperties *instance_extensions;
char *extension_names[64]; /* FIXME: make dynamic */
VkLayerProperties *instance_layers;
uint32_t instance_extension_count = 0;
uint32_t enabled_extension_count = 0;
uint32_t instance_layer_count = 0;
uint32_t enabled_layer_count = 0;
gboolean validation_found;
VkResult err;
GST_OBJECT_LOCK (instance);
if (instance->priv->opened) {
GST_OBJECT_UNLOCK (instance);
return TRUE;
}
/* Look for validation layers */
err = vkEnumerateInstanceLayerProperties (&instance_layer_count, NULL);
if (gst_vulkan_error_to_g_error (err, error,
"vKEnumerateInstanceLayerProperties") < 0)
goto error;
instance_layers = g_new0 (VkLayerProperties, instance_layer_count);
err =
vkEnumerateInstanceLayerProperties (&instance_layer_count,
instance_layers);
if (gst_vulkan_error_to_g_error (err, error,
"vKEnumerateInstanceLayerProperties") < 0) {
g_free (instance_layers);
goto error;
}
/* TODO: allow outside selection */
validation_found =
_check_for_all_layers (G_N_ELEMENTS (instance_validation_layers),
instance_validation_layers, instance_layer_count, instance_layers);
if (!validation_found) {
g_error ("vkEnumerateInstanceLayerProperties failed to find"
"required validation layer.\n\n"
"Please look at the Getting Started guide for additional "
"information.\nvkCreateInstance Failure");
}
enabled_layer_count = G_N_ELEMENTS (instance_validation_layers);
err =
vkEnumerateInstanceExtensionProperties (NULL, &instance_extension_count,
NULL);
if (gst_vulkan_error_to_g_error (err, error,
"vkEnumerateInstanceExtensionProperties") < 0) {
g_free (instance_layers);
goto error;
}
GST_DEBUG_OBJECT (instance, "Found %u extensions", instance_extension_count);
memset (extension_names, 0, sizeof (extension_names));
instance_extensions =
g_new0 (VkExtensionProperties, instance_extension_count);
err =
vkEnumerateInstanceExtensionProperties (NULL, &instance_extension_count,
instance_extensions);
if (gst_vulkan_error_to_g_error (err, error,
"vkEnumerateInstanceExtensionProperties") < 0) {
g_free (instance_layers);
g_free (instance_extensions);
goto error;
}
{
GstVulkanDisplayType display_type;
gboolean swapchain_ext_found = FALSE;
gboolean winsys_ext_found = FALSE;
const gchar *winsys_ext_name;
display_type = gst_vulkan_display_choose_type (instance);
winsys_ext_name =
gst_vulkan_display_type_to_extension_string (display_type);
if (!winsys_ext_name) {
GST_WARNING_OBJECT (instance, "No window system extension enabled");
winsys_ext_found = TRUE; /* Don't error out completely */
}
/* TODO: allow outside selection */
for (uint32_t i = 0; i < instance_extension_count; i++) {
GST_TRACE_OBJECT (instance, "checking instance extension %s",
instance_extensions[i].extensionName);
if (!g_strcmp0 (VK_KHR_SURFACE_EXTENSION_NAME,
instance_extensions[i].extensionName)) {
swapchain_ext_found = TRUE;
extension_names[enabled_extension_count++] =
(gchar *) VK_KHR_SURFACE_EXTENSION_NAME;
}
if (!g_strcmp0 (VK_EXT_DEBUG_REPORT_EXTENSION_NAME,
instance_extensions[i].extensionName)) {
extension_names[enabled_extension_count++] =
(gchar *) VK_EXT_DEBUG_REPORT_EXTENSION_NAME;
}
if (!g_strcmp0 (winsys_ext_name, instance_extensions[i].extensionName)) {
winsys_ext_found = TRUE;
extension_names[enabled_extension_count++] = (gchar *) winsys_ext_name;
}
g_assert (enabled_extension_count < 64);
}
if (!swapchain_ext_found) {
g_set_error (error, GST_VULKAN_ERROR, VK_ERROR_INITIALIZATION_FAILED,
"vkEnumerateInstanceExtensionProperties failed to find the required "
"\"" VK_KHR_SURFACE_EXTENSION_NAME "\" extension");
g_free (instance_layers);
g_free (instance_extensions);
goto error;
}
if (!winsys_ext_found) {
g_set_error (error, GST_VULKAN_ERROR, VK_ERROR_INITIALIZATION_FAILED,
"vkEnumerateInstanceExtensionProperties failed to find the required "
"\"%s\" window system extension", winsys_ext_name);
g_free (instance_layers);
g_free (instance_extensions);
goto error;
}
}
{
VkApplicationInfo app = { 0, };
VkInstanceCreateInfo inst_info = { 0, };
app.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
app.pNext = NULL;
app.pApplicationName = APP_SHORT_NAME;
app.applicationVersion = 0;
app.pEngineName = APP_SHORT_NAME;
app.engineVersion = 0;
app.apiVersion = VK_API_VERSION;
inst_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
inst_info.pNext = NULL;
inst_info.pApplicationInfo = &app;
inst_info.enabledLayerCount = enabled_layer_count;
inst_info.ppEnabledLayerNames =
(const char *const *) instance_validation_layers;
inst_info.enabledExtensionCount = enabled_extension_count;
inst_info.ppEnabledExtensionNames = (const char *const *) extension_names;
err = vkCreateInstance (&inst_info, NULL, &instance->instance);
if (gst_vulkan_error_to_g_error (err, error, "vkCreateInstance") < 0) {
g_free (instance_layers);
g_free (instance_extensions);
goto error;
}
}
g_free (instance_layers);
g_free (instance_extensions);
err =
vkEnumeratePhysicalDevices (instance->instance,
&instance->n_physical_devices, NULL);
if (gst_vulkan_error_to_g_error (err, error,
"vkEnumeratePhysicalDevices") < 0)
goto error;
g_assert (instance->n_physical_devices > 0);
instance->physical_devices =
g_new0 (VkPhysicalDevice, instance->n_physical_devices);
err =
vkEnumeratePhysicalDevices (instance->instance,
&instance->n_physical_devices, instance->physical_devices);
if (gst_vulkan_error_to_g_error (err, error,
"vkEnumeratePhysicalDevices") < 0)
goto error;
instance->dbgCreateDebugReportCallback = (PFN_vkCreateDebugReportCallbackEXT)
gst_vulkan_instance_get_proc_address (instance,
"vkCreateDebugReportCallbackEXT");
if (!instance->dbgCreateDebugReportCallback) {
g_set_error (error, GST_VULKAN_ERROR, VK_ERROR_INITIALIZATION_FAILED,
"Failed to retreive vkCreateDebugReportCallback");
goto error;
}
instance->dbgDestroyDebugReportCallback =
(PFN_vkDestroyDebugReportCallbackEXT)
gst_vulkan_instance_get_proc_address (instance,
"vkDestroyDebugReportCallbackEXT");
if (!instance->dbgDestroyDebugReportCallback) {
g_set_error (error, GST_VULKAN_ERROR, VK_ERROR_INITIALIZATION_FAILED,
"Failed to retreive vkDestroyDebugReportCallback");
goto error;
}
instance->dbgReportMessage = (PFN_vkDebugReportMessageEXT)
gst_vulkan_instance_get_proc_address (instance,
"vkDebugReportMessageEXT");
if (!instance->dbgReportMessage) {
g_set_error (error, GST_VULKAN_ERROR, VK_ERROR_INITIALIZATION_FAILED,
"Failed to retreive vkDebugReportMessage");
goto error;
}
{
VkDebugReportCallbackCreateInfoEXT info = { 0, };
info.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT;
info.pNext = NULL;
info.flags =
VK_DEBUG_REPORT_ERROR_BIT_EXT | VK_DEBUG_REPORT_WARNING_BIT_EXT |
VK_DEBUG_REPORT_INFORMATION_BIT_EXT | VK_DEBUG_REPORT_DEBUG_BIT_EXT |
VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT;
info.pfnCallback = (PFN_vkDebugReportCallbackEXT) _gst_vk_debug_callback;
info.pUserData = NULL;
err =
instance->dbgCreateDebugReportCallback (instance->instance, &info, NULL,
&instance->msg_callback);
if (gst_vulkan_error_to_g_error (err, error,
"vkCreateDebugReportCallback") < 0)
goto error;
}
instance->priv->opened = TRUE;
GST_OBJECT_UNLOCK (instance);
return TRUE;
error:
{
GST_OBJECT_UNLOCK (instance);
return FALSE;
}
}
gpointer
gst_vulkan_instance_get_proc_address (GstVulkanInstance * instance,
const gchar * name)
{
g_return_val_if_fail (GST_IS_VULKAN_INSTANCE (instance), NULL);
g_return_val_if_fail (instance->instance != NULL, NULL);
g_return_val_if_fail (name != NULL, NULL);
GST_TRACE_OBJECT (instance, "%s", name);
return vkGetInstanceProcAddr (instance->instance, name);
}
GstVulkanDevice *
gst_vulkan_instance_create_device (GstVulkanInstance * instance,
GError ** error)
{
GstVulkanDevice *device;
g_return_val_if_fail (GST_IS_VULKAN_INSTANCE (instance), NULL);
g_signal_emit (instance, gst_vulkan_instance_signals[SIGNAL_CREATE_DEVICE], 0,
&device);
if (!device)
device = gst_vulkan_device_new (instance);
if (!gst_vulkan_device_open (device, error)) {
gst_object_unref (device);
device = NULL;
}
return device;
}
/**
* gst_context_set_vulkan_instance:
* @context: a #GstContext
* @instance: a #GstVulkanInstance
*
* Sets @instance on @context
*
* Since: 1.10
*/
void
gst_context_set_vulkan_instance (GstContext * context,
GstVulkanInstance * instance)
{
GstStructure *s;
g_return_if_fail (context != NULL);
g_return_if_fail (gst_context_is_writable (context));
if (instance)
GST_CAT_LOG (GST_CAT_CONTEXT,
"setting GstVulkanInstance(%" GST_PTR_FORMAT ") on context(%"
GST_PTR_FORMAT ")", instance, context);
s = gst_context_writable_structure (context);
gst_structure_set (s, GST_VULKAN_INSTANCE_CONTEXT_TYPE_STR,
GST_TYPE_VULKAN_INSTANCE, instance, NULL);
}
/**
* gst_context_get_vulkan_instance:
* @context: a #GstContext
* @instance: resulting #GstVulkanInstance
*
* Returns: Whether @instance was in @context
*
* Since: 1.10
*/
gboolean
gst_context_get_vulkan_instance (GstContext * context,
GstVulkanInstance ** instance)
{
const GstStructure *s;
gboolean ret;
g_return_val_if_fail (instance != NULL, FALSE);
g_return_val_if_fail (context != NULL, FALSE);
s = gst_context_get_structure (context);
ret = gst_structure_get (s, GST_VULKAN_INSTANCE_CONTEXT_TYPE_STR,
GST_TYPE_VULKAN_INSTANCE, instance, NULL);
GST_CAT_LOG (GST_CAT_CONTEXT, "got GstVulkanInstance(%" GST_PTR_FORMAT
") from context(%" GST_PTR_FORMAT ")", *instance, context);
return ret;
}
gboolean
gst_vulkan_instance_handle_context_query (GstElement * element,
GstQuery * query, GstVulkanInstance ** instance)
{
gboolean res = FALSE;
const gchar *context_type;
GstContext *context, *old_context;
g_return_val_if_fail (element != NULL, FALSE);
g_return_val_if_fail (query != NULL, FALSE);
g_return_val_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_CONTEXT, FALSE);
g_return_val_if_fail (instance != NULL, FALSE);
gst_query_parse_context_type (query, &context_type);
if (g_strcmp0 (context_type, GST_VULKAN_INSTANCE_CONTEXT_TYPE_STR) == 0) {
gst_query_parse_context (query, &old_context);
if (old_context)
context = gst_context_copy (old_context);
else
context = gst_context_new (GST_VULKAN_INSTANCE_CONTEXT_TYPE_STR, TRUE);
gst_context_set_vulkan_instance (context, *instance);
gst_query_set_context (query, context);
gst_context_unref (context);
res = *instance != NULL;
}
return res;
}
gboolean
gst_vulkan_instance_run_context_query (GstElement * element,
GstVulkanInstance ** instance)
{
g_return_val_if_fail (GST_IS_ELEMENT (element), FALSE);
g_return_val_if_fail (instance != NULL, FALSE);
if (*instance && GST_IS_VULKAN_INSTANCE (*instance))
return TRUE;
gst_vulkan_global_context_query (element,
GST_VULKAN_INSTANCE_CONTEXT_TYPE_STR);
GST_DEBUG_OBJECT (element, "found instance %p", *instance);
if (*instance)
return TRUE;
return FALSE;
}