mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-11-08 18:39:54 +00:00
640a65bf96
volatile is not sufficient to provide atomic guarantees and real atomics should be used instead. GCC 11 has started warning about using volatile with atomic operations. https://gitlab.gnome.org/GNOME/glib/-/merge_requests/1719 Discovered in https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/issues/868 Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-bad/-/merge_requests/2098>
1086 lines
46 KiB
C
1086 lines
46 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 "gstvkphysicaldevice.h"
|
|
|
|
#include "gstvkdebug.h"
|
|
|
|
#include <string.h>
|
|
|
|
/**
|
|
* SECTION:vkphysicaldevice
|
|
* @title: GstVulkanPhysicalDevice
|
|
* @short_description: Vulkan physical device
|
|
* @see_also: #GstVulkanInstance, #GstVulkanDevice
|
|
*
|
|
* A #GstVulkanPhysicalDevice encapsulates a VkPhysicalDevice
|
|
*/
|
|
|
|
#define GST_CAT_DEFAULT gst_vulkan_physical_device_debug
|
|
GST_DEBUG_CATEGORY (GST_CAT_DEFAULT);
|
|
|
|
enum
|
|
{
|
|
PROP_0,
|
|
PROP_INSTANCE,
|
|
PROP_DEVICE_ID,
|
|
PROP_NAME,
|
|
};
|
|
|
|
static void gst_vulkan_physical_device_finalize (GObject * object);
|
|
|
|
struct _GstVulkanPhysicalDevicePrivate
|
|
{
|
|
guint32 n_available_layers;
|
|
VkLayerProperties *available_layers;
|
|
|
|
guint32 n_available_extensions;
|
|
VkExtensionProperties *available_extensions;
|
|
|
|
#if defined (VK_API_VERSION_1_2)
|
|
VkPhysicalDeviceFeatures2 features10;
|
|
VkPhysicalDeviceProperties2 properties10;
|
|
VkPhysicalDeviceVulkan11Features features11;
|
|
VkPhysicalDeviceVulkan11Properties properties11;
|
|
VkPhysicalDeviceVulkan12Features features12;
|
|
VkPhysicalDeviceVulkan12Properties properties12;
|
|
#endif
|
|
};
|
|
|
|
static void
|
|
_init_debug (void)
|
|
{
|
|
static gsize init;
|
|
|
|
if (g_once_init_enter (&init)) {
|
|
GST_DEBUG_CATEGORY_INIT (GST_CAT_DEFAULT, "vulkandevice", 0,
|
|
"Vulkan Device");
|
|
g_once_init_leave (&init, 1);
|
|
}
|
|
}
|
|
|
|
#define GET_PRIV(device) gst_vulkan_physical_device_get_instance_private (device)
|
|
|
|
#define gst_vulkan_physical_device_parent_class parent_class
|
|
G_DEFINE_TYPE_WITH_CODE (GstVulkanPhysicalDevice, gst_vulkan_physical_device,
|
|
GST_TYPE_OBJECT, G_ADD_PRIVATE (GstVulkanPhysicalDevice);
|
|
_init_debug ());
|
|
|
|
static gboolean gst_vulkan_physical_device_fill_info (GstVulkanPhysicalDevice *
|
|
device, GError ** error);
|
|
|
|
/**
|
|
* gst_vulkan_physical_device_new:
|
|
* @instance: the parent #GstVulkanInstance
|
|
*
|
|
* Returns: (transfer full): a new #GstVulkanPhysicalDevice
|
|
*
|
|
* Since: 1.18
|
|
*/
|
|
GstVulkanPhysicalDevice *
|
|
gst_vulkan_physical_device_new (GstVulkanInstance * instance,
|
|
guint device_index)
|
|
{
|
|
GstVulkanPhysicalDevice *device;
|
|
|
|
g_return_val_if_fail (GST_IS_VULKAN_INSTANCE (instance), NULL);
|
|
|
|
device = g_object_new (GST_TYPE_VULKAN_PHYSICAL_DEVICE, "instance", instance,
|
|
"device-index", device_index, NULL);
|
|
gst_object_ref_sink (device);
|
|
|
|
return device;
|
|
}
|
|
|
|
static void
|
|
gst_vulkan_physical_device_set_property (GObject * object, guint prop_id,
|
|
const GValue * value, GParamSpec * pspec)
|
|
{
|
|
GstVulkanPhysicalDevice *device = GST_VULKAN_PHYSICAL_DEVICE (object);
|
|
|
|
switch (prop_id) {
|
|
case PROP_INSTANCE:
|
|
device->instance = g_value_dup_object (value);
|
|
break;
|
|
case PROP_DEVICE_ID:{
|
|
guint device_id = g_value_get_uint (value);
|
|
if (device->instance == VK_NULL_HANDLE
|
|
|| device_id >= device->instance->n_physical_devices) {
|
|
g_critical ("%s: Cannot set device-index larger than the "
|
|
"number of physical devices", GST_OBJECT_NAME (device));
|
|
} else {
|
|
device->device_index = device_id;
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void
|
|
gst_vulkan_physical_device_get_property (GObject * object, guint prop_id,
|
|
GValue * value, GParamSpec * pspec)
|
|
{
|
|
GstVulkanPhysicalDevice *device = GST_VULKAN_PHYSICAL_DEVICE (object);
|
|
|
|
switch (prop_id) {
|
|
case PROP_INSTANCE:
|
|
g_value_set_object (value, device->instance);
|
|
break;
|
|
case PROP_DEVICE_ID:
|
|
g_value_set_uint (value, device->device_index);
|
|
break;
|
|
case PROP_NAME:
|
|
g_value_set_string (value, device->properties.deviceName);
|
|
break;
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void
|
|
gst_vulkan_physical_device_init (GstVulkanPhysicalDevice * device)
|
|
{
|
|
GstVulkanPhysicalDevicePrivate *priv = GET_PRIV (device);
|
|
|
|
priv->n_available_layers = 0;
|
|
priv->n_available_extensions = 0;
|
|
|
|
#if defined (VK_API_VERSION_1_2)
|
|
priv->properties10.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
|
|
priv->properties11.sType =
|
|
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES;
|
|
priv->properties12.sType =
|
|
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES;
|
|
priv->properties10.pNext = &priv->properties11;
|
|
priv->properties11.pNext = &priv->properties12;
|
|
|
|
priv->features10.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
|
|
priv->features11.sType =
|
|
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES;
|
|
priv->features12.sType =
|
|
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES;
|
|
priv->features10.pNext = &priv->features11;
|
|
priv->features11.pNext = &priv->features12;
|
|
#endif
|
|
}
|
|
|
|
static void
|
|
gst_vulkan_physical_device_constructed (GObject * object)
|
|
{
|
|
GstVulkanPhysicalDevice *device = GST_VULKAN_PHYSICAL_DEVICE (object);
|
|
GError *error = NULL;
|
|
|
|
if (device->instance == VK_NULL_HANDLE) {
|
|
GST_ERROR_OBJECT (object, "Constructed without any instance set");
|
|
return;
|
|
}
|
|
|
|
device->device = device->instance->physical_devices[device->device_index];
|
|
|
|
if (!gst_vulkan_physical_device_fill_info (device, &error)) {
|
|
GST_ERROR_OBJECT (object, "%s", error->message);
|
|
g_clear_error (&error);
|
|
}
|
|
}
|
|
|
|
static void
|
|
gst_vulkan_physical_device_class_init (GstVulkanPhysicalDeviceClass *
|
|
device_class)
|
|
{
|
|
GObjectClass *gobject_class = (GObjectClass *) device_class;
|
|
|
|
gobject_class->set_property = gst_vulkan_physical_device_set_property;
|
|
gobject_class->get_property = gst_vulkan_physical_device_get_property;
|
|
gobject_class->finalize = gst_vulkan_physical_device_finalize;
|
|
gobject_class->constructed = gst_vulkan_physical_device_constructed;
|
|
|
|
g_object_class_install_property (gobject_class, PROP_INSTANCE,
|
|
g_param_spec_object ("instance", "Instance",
|
|
"Associated Vulkan Instance",
|
|
GST_TYPE_VULKAN_INSTANCE,
|
|
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));
|
|
|
|
g_object_class_install_property (gobject_class, PROP_DEVICE_ID,
|
|
g_param_spec_uint ("device-index", "Device Index", "Device Index", 0,
|
|
G_MAXUINT32, 0,
|
|
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));
|
|
|
|
g_object_class_install_property (gobject_class, PROP_NAME,
|
|
g_param_spec_string ("name", "Name", "Device Name", NULL,
|
|
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
|
|
}
|
|
|
|
static void
|
|
gst_vulkan_physical_device_finalize (GObject * object)
|
|
{
|
|
GstVulkanPhysicalDevice *device = GST_VULKAN_PHYSICAL_DEVICE (object);
|
|
GstVulkanPhysicalDevicePrivate *priv = GET_PRIV (device);
|
|
|
|
g_free (priv->available_layers);
|
|
priv->available_layers = NULL;
|
|
|
|
g_free (priv->available_extensions);
|
|
priv->available_extensions = NULL;
|
|
|
|
g_free (device->queue_family_props);
|
|
device->queue_family_props = NULL;
|
|
|
|
if (device->instance)
|
|
gst_object_unref (device->instance);
|
|
device->instance = VK_NULL_HANDLE;
|
|
|
|
G_OBJECT_CLASS (parent_class)->finalize (object);
|
|
}
|
|
|
|
#define DEBUG_BOOL(prefix, name, value) \
|
|
GST_DEBUG_OBJECT (device, prefix " " G_STRINGIFY(name) ": %s", \
|
|
value ? "YES" : "NO")
|
|
#define DEBUG_1(prefix, s, name, format, type) \
|
|
GST_DEBUG_OBJECT (device, prefix " " G_STRINGIFY(name) ": %" format, \
|
|
(type) (s)->name)
|
|
#define DEBUG_2(prefix, s, name, format, type) \
|
|
GST_DEBUG_OBJECT (device, prefix " " G_STRINGIFY(name) \
|
|
": %" format ", %" format, \
|
|
(type) (s)->name[0], \
|
|
(type) (s)->name[1])
|
|
#define DEBUG_3(prefix, s, name, format, type) \
|
|
GST_DEBUG_OBJECT (device, prefix " " G_STRINGIFY(limit) \
|
|
": %" format ", %" format ", %" format, \
|
|
(type) (s)->name[0], \
|
|
(type) (s)->name[1], \
|
|
(type) (s)->name[2])
|
|
|
|
#define DEBUG_UINT32(prefix, s, var) DEBUG_1(prefix, s, var, G_GUINT32_FORMAT, guint32)
|
|
#define DEBUG_UINT32_2(prefix, s, var) DEBUG_2(prefix, s, var, G_GUINT32_FORMAT, guint32)
|
|
#define DEBUG_UINT32_3(prefix, s, var) DEBUG_3(prefix, s, var, G_GUINT32_FORMAT, guint32)
|
|
|
|
#define DEBUG_UINT64(prefix, s, var) DEBUG_1(prefix, s, var, G_GUINT64_FORMAT, guint64)
|
|
|
|
#define DEBUG_INT32(prefix, s, var) DEBUG_1(prefix, s, var, G_GINT32_FORMAT, gint32)
|
|
|
|
#define DEBUG_FLOAT(prefix, s, var) DEBUG_1(prefix, s, var, "f", gfloat)
|
|
#define DEBUG_FLOAT_2(prefix, s, var) DEBUG_2(prefix, s, var, "f", gfloat)
|
|
|
|
#define DEBUG_SIZE(prefix, s, var) DEBUG_1(prefix, s, var, G_GSIZE_FORMAT, gsize)
|
|
#define DEBUG_FLAGS(prefix, s, limit, under_name_type) \
|
|
G_STMT_START { \
|
|
gchar *str = G_PASTE(G_PASTE(gst_vulkan_,under_name_type),_flags_to_string) ((s)->limit); \
|
|
GST_DEBUG_OBJECT (device, prefix " " G_STRINGIFY(limit) ": (0x%x) %s", \
|
|
(s)->limit, str); \
|
|
g_free (str); \
|
|
} G_STMT_END
|
|
|
|
#define DEBUG_BOOL_STRUCT(prefix, s, name) DEBUG_BOOL(prefix, name, (s)->name)
|
|
|
|
#define DEBUG_STRING(prefix, s, str) DEBUG_1(prefix, s, str, "s", gchar *);
|
|
|
|
static void
|
|
dump_features10 (GstVulkanPhysicalDevice * device,
|
|
VkPhysicalDeviceFeatures * features)
|
|
{
|
|
/* *INDENT-OFF* */
|
|
DEBUG_BOOL_STRUCT ("support for", features, robustBufferAccess);
|
|
DEBUG_BOOL_STRUCT ("support for", features, fullDrawIndexUint32);
|
|
DEBUG_BOOL_STRUCT ("support for", features, imageCubeArray);
|
|
DEBUG_BOOL_STRUCT ("support for", features, independentBlend);
|
|
DEBUG_BOOL_STRUCT ("support for", features, geometryShader);
|
|
DEBUG_BOOL_STRUCT ("support for", features, tessellationShader);
|
|
DEBUG_BOOL_STRUCT ("support for", features, sampleRateShading);
|
|
DEBUG_BOOL_STRUCT ("support for", features, sampleRateShading);
|
|
DEBUG_BOOL_STRUCT ("support for", features, dualSrcBlend);
|
|
DEBUG_BOOL_STRUCT ("support for", features, logicOp);
|
|
DEBUG_BOOL_STRUCT ("support for", features, multiDrawIndirect);
|
|
DEBUG_BOOL_STRUCT ("support for", features, drawIndirectFirstInstance);
|
|
DEBUG_BOOL_STRUCT ("support for", features, depthClamp);
|
|
DEBUG_BOOL_STRUCT ("support for", features, depthBiasClamp);
|
|
DEBUG_BOOL_STRUCT ("support for", features, fillModeNonSolid);
|
|
DEBUG_BOOL_STRUCT ("support for", features, depthBounds);
|
|
DEBUG_BOOL_STRUCT ("support for", features, wideLines);
|
|
DEBUG_BOOL_STRUCT ("support for", features, largePoints);
|
|
DEBUG_BOOL_STRUCT ("support for", features, alphaToOne);
|
|
DEBUG_BOOL_STRUCT ("support for", features, multiViewport);
|
|
DEBUG_BOOL_STRUCT ("support for", features, samplerAnisotropy);
|
|
DEBUG_BOOL_STRUCT ("support for", features, textureCompressionETC2);
|
|
DEBUG_BOOL_STRUCT ("support for", features, textureCompressionASTC_LDR);
|
|
DEBUG_BOOL_STRUCT ("support for", features, textureCompressionBC);
|
|
DEBUG_BOOL_STRUCT ("support for", features, occlusionQueryPrecise);
|
|
DEBUG_BOOL_STRUCT ("support for", features, pipelineStatisticsQuery);
|
|
DEBUG_BOOL_STRUCT ("support for", features, vertexPipelineStoresAndAtomics);
|
|
DEBUG_BOOL_STRUCT ("support for", features, fragmentStoresAndAtomics);
|
|
DEBUG_BOOL_STRUCT ("support for", features, shaderTessellationAndGeometryPointSize);
|
|
DEBUG_BOOL_STRUCT ("support for", features, shaderImageGatherExtended);
|
|
DEBUG_BOOL_STRUCT ("support for", features, shaderStorageImageExtendedFormats);
|
|
DEBUG_BOOL_STRUCT ("support for", features, shaderStorageImageMultisample);
|
|
DEBUG_BOOL_STRUCT ("support for", features, shaderStorageImageReadWithoutFormat);
|
|
DEBUG_BOOL_STRUCT ("support for", features, shaderStorageImageWriteWithoutFormat);
|
|
DEBUG_BOOL_STRUCT ("support for", features, shaderUniformBufferArrayDynamicIndexing);
|
|
DEBUG_BOOL_STRUCT ("support for", features, shaderSampledImageArrayDynamicIndexing);
|
|
DEBUG_BOOL_STRUCT ("support for", features, shaderStorageBufferArrayDynamicIndexing);
|
|
DEBUG_BOOL_STRUCT ("support for", features, shaderStorageImageArrayDynamicIndexing);
|
|
DEBUG_BOOL_STRUCT ("support for", features, shaderClipDistance);
|
|
DEBUG_BOOL_STRUCT ("support for", features, shaderCullDistance);
|
|
DEBUG_BOOL_STRUCT ("support for", features, shaderFloat64);
|
|
DEBUG_BOOL_STRUCT ("support for", features, shaderInt64);
|
|
DEBUG_BOOL_STRUCT ("support for", features, shaderInt16);
|
|
DEBUG_BOOL_STRUCT ("support for", features, shaderResourceResidency);
|
|
DEBUG_BOOL_STRUCT ("support for", features, shaderResourceMinLod);
|
|
DEBUG_BOOL_STRUCT ("support for", features, sparseBinding);
|
|
DEBUG_BOOL_STRUCT ("support for", features, sparseResidencyBuffer);
|
|
DEBUG_BOOL_STRUCT ("support for", features, sparseResidencyImage2D);
|
|
DEBUG_BOOL_STRUCT ("support for", features, sparseResidencyImage3D);
|
|
DEBUG_BOOL_STRUCT ("support for", features, sparseResidency2Samples);
|
|
DEBUG_BOOL_STRUCT ("support for", features, sparseResidency4Samples);
|
|
DEBUG_BOOL_STRUCT ("support for", features, sparseResidency8Samples);
|
|
DEBUG_BOOL_STRUCT ("support for", features, sparseResidency16Samples);
|
|
DEBUG_BOOL_STRUCT ("support for", features, sparseResidencyAliased);
|
|
DEBUG_BOOL_STRUCT ("support for", features, variableMultisampleRate);
|
|
DEBUG_BOOL_STRUCT ("support for", features, inheritedQueries);
|
|
/* *INDENT-ON* */
|
|
}
|
|
|
|
#if defined (VK_API_VERSION_1_2)
|
|
static void
|
|
dump_features11 (GstVulkanPhysicalDevice * device,
|
|
VkPhysicalDeviceVulkan11Features * features)
|
|
{
|
|
/* *INDENT-OFF* */
|
|
DEBUG_BOOL_STRUCT ("support for (1.1)", features, storageBuffer16BitAccess);
|
|
DEBUG_BOOL_STRUCT ("support for (1.1)", features, uniformAndStorageBuffer16BitAccess);
|
|
DEBUG_BOOL_STRUCT ("support for (1.1)", features, storagePushConstant16);
|
|
DEBUG_BOOL_STRUCT ("support for (1.1)", features, storageInputOutput16);
|
|
DEBUG_BOOL_STRUCT ("support for (1.1)", features, multiview);
|
|
DEBUG_BOOL_STRUCT ("support for (1.1)", features, multiviewGeometryShader);
|
|
DEBUG_BOOL_STRUCT ("support for (1.1)", features, multiviewTessellationShader);
|
|
DEBUG_BOOL_STRUCT ("support for (1.1)", features, variablePointersStorageBuffer);
|
|
DEBUG_BOOL_STRUCT ("support for (1.1)", features, variablePointers);
|
|
DEBUG_BOOL_STRUCT ("support for (1.1)", features, protectedMemory);
|
|
DEBUG_BOOL_STRUCT ("support for (1.1)", features, samplerYcbcrConversion);
|
|
DEBUG_BOOL_STRUCT ("support for (1.1)", features, shaderDrawParameters);
|
|
/* *INDENT-ON* */
|
|
}
|
|
|
|
static void
|
|
dump_features12 (GstVulkanPhysicalDevice * device,
|
|
VkPhysicalDeviceVulkan12Features * features)
|
|
{
|
|
/* *INDENT-OFF* */
|
|
DEBUG_BOOL_STRUCT ("support for (1.2)", features, samplerMirrorClampToEdge);
|
|
DEBUG_BOOL_STRUCT ("support for (1.2)", features, drawIndirectCount);
|
|
DEBUG_BOOL_STRUCT ("support for (1.2)", features, storageBuffer8BitAccess);
|
|
DEBUG_BOOL_STRUCT ("support for (1.2)", features, uniformAndStorageBuffer8BitAccess);
|
|
DEBUG_BOOL_STRUCT ("support for (1.2)", features, shaderBufferInt64Atomics);
|
|
DEBUG_BOOL_STRUCT ("support for (1.2)", features, shaderSharedInt64Atomics);
|
|
DEBUG_BOOL_STRUCT ("support for (1.2)", features, shaderFloat16);
|
|
DEBUG_BOOL_STRUCT ("support for (1.2)", features, shaderInt8);
|
|
DEBUG_BOOL_STRUCT ("support for (1.2)", features, descriptorIndexing);
|
|
DEBUG_BOOL_STRUCT ("support for (1.2)", features, shaderInputAttachmentArrayDynamicIndexing);
|
|
DEBUG_BOOL_STRUCT ("support for (1.2)", features, shaderUniformTexelBufferArrayDynamicIndexing);
|
|
DEBUG_BOOL_STRUCT ("support for (1.2)", features, shaderStorageTexelBufferArrayDynamicIndexing);
|
|
DEBUG_BOOL_STRUCT ("support for (1.2)", features, shaderUniformBufferArrayNonUniformIndexing);
|
|
DEBUG_BOOL_STRUCT ("support for (1.2)", features, shaderSampledImageArrayNonUniformIndexing);
|
|
DEBUG_BOOL_STRUCT ("support for (1.2)", features, shaderStorageBufferArrayNonUniformIndexing);
|
|
DEBUG_BOOL_STRUCT ("support for (1.2)", features, shaderStorageImageArrayNonUniformIndexing);
|
|
DEBUG_BOOL_STRUCT ("support for (1.2)", features, shaderInputAttachmentArrayNonUniformIndexing);
|
|
DEBUG_BOOL_STRUCT ("support for (1.2)", features, shaderUniformTexelBufferArrayNonUniformIndexing);
|
|
DEBUG_BOOL_STRUCT ("support for (1.2)", features, descriptorBindingUniformBufferUpdateAfterBind);
|
|
DEBUG_BOOL_STRUCT ("support for (1.2)", features, descriptorBindingSampledImageUpdateAfterBind);
|
|
DEBUG_BOOL_STRUCT ("support for (1.2)", features, descriptorBindingStorageImageUpdateAfterBind);
|
|
DEBUG_BOOL_STRUCT ("support for (1.2)", features, descriptorBindingStorageBufferUpdateAfterBind);
|
|
DEBUG_BOOL_STRUCT ("support for (1.2)", features, descriptorBindingUniformTexelBufferUpdateAfterBind);
|
|
DEBUG_BOOL_STRUCT ("support for (1.2)", features, descriptorBindingStorageTexelBufferUpdateAfterBind);
|
|
DEBUG_BOOL_STRUCT ("support for (1.2)", features, descriptorBindingUpdateUnusedWhilePending);
|
|
DEBUG_BOOL_STRUCT ("support for (1.2)", features, descriptorBindingPartiallyBound);
|
|
DEBUG_BOOL_STRUCT ("support for (1.2)", features, descriptorBindingVariableDescriptorCount);
|
|
DEBUG_BOOL_STRUCT ("support for (1.2)", features, runtimeDescriptorArray);
|
|
DEBUG_BOOL_STRUCT ("support for (1.2)", features, samplerFilterMinmax);
|
|
DEBUG_BOOL_STRUCT ("support for (1.2)", features, scalarBlockLayout);
|
|
DEBUG_BOOL_STRUCT ("support for (1.2)", features, imagelessFramebuffer);
|
|
DEBUG_BOOL_STRUCT ("support for (1.2)", features, uniformBufferStandardLayout);
|
|
DEBUG_BOOL_STRUCT ("support for (1.2)", features, shaderSubgroupExtendedTypes);
|
|
DEBUG_BOOL_STRUCT ("support for (1.2)", features, separateDepthStencilLayouts);
|
|
DEBUG_BOOL_STRUCT ("support for (1.2)", features, hostQueryReset);
|
|
DEBUG_BOOL_STRUCT ("support for (1.2)", features, timelineSemaphore);
|
|
DEBUG_BOOL_STRUCT ("support for (1.2)", features, bufferDeviceAddress);
|
|
DEBUG_BOOL_STRUCT ("support for (1.2)", features, bufferDeviceAddressCaptureReplay);
|
|
DEBUG_BOOL_STRUCT ("support for (1.2)", features, bufferDeviceAddressMultiDevice);
|
|
DEBUG_BOOL_STRUCT ("support for (1.2)", features, vulkanMemoryModel);
|
|
DEBUG_BOOL_STRUCT ("support for (1.2)", features, vulkanMemoryModelDeviceScope);
|
|
DEBUG_BOOL_STRUCT ("support for (1.2)", features, vulkanMemoryModelAvailabilityVisibilityChains);
|
|
DEBUG_BOOL_STRUCT ("support for (1.2)", features, shaderOutputViewportIndex);
|
|
DEBUG_BOOL_STRUCT ("support for (1.2)", features, shaderOutputLayer);
|
|
DEBUG_BOOL_STRUCT ("support for (1.2)", features, subgroupBroadcastDynamicId);
|
|
/* *INDENT-ON* */
|
|
}
|
|
#endif
|
|
static gboolean
|
|
dump_features (GstVulkanPhysicalDevice * device, GError ** error)
|
|
{
|
|
#if defined (VK_API_VERSION_1_2)
|
|
GstVulkanPhysicalDevicePrivate *priv = GET_PRIV (device);
|
|
VkBaseOutStructure *iter;
|
|
|
|
if (gst_vulkan_instance_check_version (device->instance, 1, 2, 0)) {
|
|
for (iter = (VkBaseOutStructure *) & priv->features10; iter;
|
|
iter = iter->pNext) {
|
|
if (iter->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2)
|
|
dump_features10 (device,
|
|
&((VkPhysicalDeviceFeatures2 *) iter)->features);
|
|
else if (iter->sType ==
|
|
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES)
|
|
dump_features11 (device, (VkPhysicalDeviceVulkan11Features *) iter);
|
|
else if (iter->sType ==
|
|
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES)
|
|
dump_features12 (device, (VkPhysicalDeviceVulkan12Features *) iter);
|
|
}
|
|
} else
|
|
#endif
|
|
{
|
|
dump_features10 (device, &device->features);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
dump_memory_properties (GstVulkanPhysicalDevice * device, GError ** error)
|
|
{
|
|
int i;
|
|
|
|
GST_DEBUG_OBJECT (device, "found %" G_GUINT32_FORMAT " memory heaps",
|
|
device->memory_properties.memoryHeapCount);
|
|
for (i = 0; i < device->memory_properties.memoryHeapCount; i++) {
|
|
gchar *prop_flags_str =
|
|
gst_vulkan_memory_heap_flags_to_string (device->
|
|
memory_properties.memoryHeaps[i].flags);
|
|
GST_LOG_OBJECT (device,
|
|
"memory heap at index %i has size %" G_GUINT64_FORMAT
|
|
" and flags (0x%x) \'%s\'", i,
|
|
(guint64) device->memory_properties.memoryHeaps[i].size,
|
|
device->memory_properties.memoryHeaps[i].flags, prop_flags_str);
|
|
g_free (prop_flags_str);
|
|
}
|
|
GST_DEBUG_OBJECT (device, "found %" G_GUINT32_FORMAT " memory types",
|
|
device->memory_properties.memoryTypeCount);
|
|
for (i = 0; i < device->memory_properties.memoryTypeCount; i++) {
|
|
gchar *prop_flags_str =
|
|
gst_vulkan_memory_property_flags_to_string (device->memory_properties.
|
|
memoryTypes[i].propertyFlags);
|
|
GST_LOG_OBJECT (device,
|
|
"memory type at index %i is allocatable from "
|
|
"heap %i with flags (0x%x) \'%s\'", i,
|
|
device->memory_properties.memoryTypes[i].heapIndex,
|
|
device->memory_properties.memoryTypes[i].propertyFlags, prop_flags_str);
|
|
g_free (prop_flags_str);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
dump_queue_properties (GstVulkanPhysicalDevice * device, GError ** error)
|
|
{
|
|
int i;
|
|
|
|
GST_DEBUG_OBJECT (device, "found %" G_GUINT32_FORMAT " queue families",
|
|
device->n_queue_families);
|
|
for (i = 0; i < device->n_queue_families; i++) {
|
|
gchar *queue_flags_str =
|
|
gst_vulkan_queue_flags_to_string (device->
|
|
queue_family_props[i].queueFlags);
|
|
GST_LOG_OBJECT (device,
|
|
"queue family at index %i supports %i queues "
|
|
"with flags (0x%x) \'%s\', %" G_GUINT32_FORMAT " timestamp bits and "
|
|
"a minimum image transfer granuality of %" GST_VULKAN_EXTENT3D_FORMAT,
|
|
i, device->queue_family_props[i].queueCount,
|
|
device->queue_family_props[i].queueFlags, queue_flags_str,
|
|
device->queue_family_props[i].timestampValidBits,
|
|
GST_VULKAN_EXTENT3D_ARGS (device->
|
|
queue_family_props[i].minImageTransferGranularity));
|
|
g_free (queue_flags_str);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
dump_limits (GstVulkanPhysicalDevice * device, GError ** error)
|
|
{
|
|
VkPhysicalDeviceLimits *limits = &device->properties.limits;
|
|
|
|
/* *INDENT-OFF* */
|
|
DEBUG_UINT32 ("limit", limits, maxImageDimension1D);
|
|
DEBUG_UINT32 ("limit", limits, maxImageDimension2D);
|
|
DEBUG_UINT32 ("limit", limits, maxImageDimension3D);
|
|
DEBUG_UINT32 ("limit", limits, maxImageDimensionCube);
|
|
DEBUG_UINT32 ("limit", limits, maxImageArrayLayers);
|
|
DEBUG_UINT32 ("limit", limits, maxTexelBufferElements);
|
|
DEBUG_UINT32 ("limit", limits, maxUniformBufferRange);
|
|
DEBUG_UINT32 ("limit", limits, maxStorageBufferRange);
|
|
DEBUG_UINT32 ("limit", limits, maxPushConstantsSize);
|
|
DEBUG_UINT32 ("limit", limits, maxMemoryAllocationCount);
|
|
DEBUG_UINT32 ("limit", limits, maxSamplerAllocationCount);
|
|
DEBUG_UINT64 ("limit", limits, bufferImageGranularity);
|
|
DEBUG_UINT64 ("limit", limits, sparseAddressSpaceSize);
|
|
DEBUG_UINT32 ("limit", limits, maxBoundDescriptorSets);
|
|
DEBUG_UINT32 ("limit", limits, maxPerStageDescriptorSamplers);
|
|
DEBUG_UINT32 ("limit", limits, maxPerStageDescriptorUniformBuffers);
|
|
DEBUG_UINT32 ("limit", limits, maxPerStageDescriptorStorageBuffers);
|
|
DEBUG_UINT32 ("limit", limits, maxPerStageDescriptorSampledImages);
|
|
DEBUG_UINT32 ("limit", limits, maxPerStageDescriptorStorageImages);
|
|
DEBUG_UINT32 ("limit", limits, maxPerStageDescriptorInputAttachments);
|
|
DEBUG_UINT32 ("limit", limits, maxPerStageResources);
|
|
DEBUG_UINT32 ("limit", limits, maxDescriptorSetSamplers);
|
|
DEBUG_UINT32 ("limit", limits, maxDescriptorSetUniformBuffers);
|
|
DEBUG_UINT32 ("limit", limits, maxDescriptorSetUniformBuffersDynamic);
|
|
DEBUG_UINT32 ("limit", limits, maxDescriptorSetStorageBuffers);
|
|
DEBUG_UINT32 ("limit", limits, maxDescriptorSetStorageBuffersDynamic);
|
|
DEBUG_UINT32 ("limit", limits, maxDescriptorSetSampledImages);
|
|
DEBUG_UINT32 ("limit", limits, maxDescriptorSetStorageImages);
|
|
DEBUG_UINT32 ("limit", limits, maxDescriptorSetInputAttachments);
|
|
DEBUG_UINT32 ("limit", limits, maxVertexInputAttributes);
|
|
DEBUG_UINT32 ("limit", limits, maxVertexInputBindings);
|
|
DEBUG_UINT32 ("limit", limits, maxVertexInputBindings);
|
|
DEBUG_UINT32 ("limit", limits, maxVertexInputAttributeOffset);
|
|
DEBUG_UINT32 ("limit", limits, maxVertexInputBindingStride);
|
|
DEBUG_UINT32 ("limit", limits, maxVertexOutputComponents);
|
|
DEBUG_UINT32 ("limit", limits, maxTessellationGenerationLevel);
|
|
DEBUG_UINT32 ("limit", limits, maxTessellationPatchSize);
|
|
DEBUG_UINT32 ("limit", limits, maxTessellationControlPerVertexInputComponents);
|
|
DEBUG_UINT32 ("limit", limits, maxTessellationControlPerVertexOutputComponents);
|
|
DEBUG_UINT32 ("limit", limits, maxTessellationControlPerPatchOutputComponents);
|
|
DEBUG_UINT32 ("limit", limits, maxTessellationControlTotalOutputComponents);
|
|
DEBUG_UINT32 ("limit", limits, maxTessellationControlTotalOutputComponents);
|
|
DEBUG_UINT32 ("limit", limits, maxTessellationEvaluationInputComponents);
|
|
DEBUG_UINT32 ("limit", limits, maxTessellationEvaluationOutputComponents);
|
|
DEBUG_UINT32 ("limit", limits, maxGeometryShaderInvocations);
|
|
DEBUG_UINT32 ("limit", limits, maxGeometryInputComponents);
|
|
DEBUG_UINT32 ("limit", limits, maxGeometryOutputComponents);
|
|
DEBUG_UINT32 ("limit", limits, maxGeometryOutputVertices);
|
|
DEBUG_UINT32 ("limit", limits, maxGeometryTotalOutputComponents);
|
|
DEBUG_UINT32 ("limit", limits, maxFragmentInputComponents);
|
|
DEBUG_UINT32 ("limit", limits, maxFragmentOutputAttachments);
|
|
DEBUG_UINT32 ("limit", limits, maxFragmentDualSrcAttachments);
|
|
DEBUG_UINT32 ("limit", limits, maxFragmentCombinedOutputResources);
|
|
DEBUG_UINT32 ("limit", limits, maxComputeSharedMemorySize);
|
|
DEBUG_UINT32_3 ("limit", limits, maxComputeWorkGroupCount);
|
|
DEBUG_UINT32 ("limit", limits, maxComputeWorkGroupInvocations);
|
|
DEBUG_UINT32_3 ("limit", limits, maxComputeWorkGroupSize);
|
|
DEBUG_UINT32 ("limit", limits, subPixelPrecisionBits);
|
|
DEBUG_UINT32 ("limit", limits, subTexelPrecisionBits);
|
|
DEBUG_UINT32 ("limit", limits, mipmapPrecisionBits);
|
|
DEBUG_UINT32 ("limit", limits, maxDrawIndexedIndexValue);
|
|
DEBUG_UINT32 ("limit", limits, maxDrawIndirectCount);
|
|
DEBUG_FLOAT ("limit", limits, maxSamplerLodBias);
|
|
DEBUG_FLOAT ("limit", limits, maxSamplerAnisotropy);
|
|
DEBUG_UINT32 ("limit", limits, maxViewports);
|
|
DEBUG_UINT32_2 ("limit", limits, maxViewportDimensions);
|
|
DEBUG_FLOAT_2 ("limit", limits, viewportBoundsRange);
|
|
DEBUG_UINT32 ("limit", limits, viewportSubPixelBits);
|
|
DEBUG_SIZE ("limit", limits, minMemoryMapAlignment);
|
|
DEBUG_UINT64 ("limit", limits, minTexelBufferOffsetAlignment);
|
|
DEBUG_UINT64 ("limit", limits, minUniformBufferOffsetAlignment);
|
|
DEBUG_UINT64 ("limit", limits, minStorageBufferOffsetAlignment);
|
|
DEBUG_INT32 ("limit", limits, minTexelOffset);
|
|
DEBUG_UINT32 ("limit", limits, maxTexelOffset);
|
|
DEBUG_INT32 ("limit", limits, minTexelGatherOffset);
|
|
DEBUG_UINT32 ("limit", limits, maxTexelGatherOffset);
|
|
DEBUG_FLOAT ("limit", limits, minInterpolationOffset);
|
|
DEBUG_FLOAT ("limit", limits, maxInterpolationOffset);
|
|
DEBUG_UINT32 ("limit", limits, subPixelInterpolationOffsetBits);
|
|
DEBUG_UINT32 ("limit", limits, maxFramebufferWidth);
|
|
DEBUG_UINT32 ("limit", limits, maxFramebufferHeight);
|
|
DEBUG_UINT32 ("limit", limits, maxFramebufferLayers);
|
|
DEBUG_FLAGS ("limit", limits, framebufferColorSampleCounts, sample_count);
|
|
DEBUG_FLAGS ("limit", limits, framebufferDepthSampleCounts, sample_count);
|
|
DEBUG_FLAGS ("limit", limits, framebufferStencilSampleCounts, sample_count);
|
|
DEBUG_FLAGS ("limit", limits, framebufferNoAttachmentsSampleCounts, sample_count);
|
|
DEBUG_UINT32 ("limit", limits, maxColorAttachments);
|
|
DEBUG_FLAGS ("limit", limits, sampledImageColorSampleCounts, sample_count);
|
|
DEBUG_FLAGS ("limit", limits, sampledImageIntegerSampleCounts, sample_count);
|
|
DEBUG_FLAGS ("limit", limits, sampledImageDepthSampleCounts, sample_count);
|
|
DEBUG_FLAGS ("limit", limits, sampledImageStencilSampleCounts, sample_count);
|
|
DEBUG_FLAGS ("limit", limits, storageImageSampleCounts, sample_count);
|
|
DEBUG_BOOL_STRUCT ("limit", limits, timestampComputeAndGraphics);
|
|
DEBUG_FLOAT ("limit", limits, timestampPeriod);
|
|
DEBUG_UINT32 ("limit", limits, maxClipDistances);
|
|
DEBUG_UINT32 ("limit", limits, maxCullDistances);
|
|
DEBUG_UINT32 ("limit", limits, maxCombinedClipAndCullDistances);
|
|
DEBUG_UINT32 ("limit", limits, discreteQueuePriorities);
|
|
DEBUG_FLOAT_2 ("limit", limits, pointSizeRange);
|
|
DEBUG_FLOAT_2 ("limit", limits, lineWidthRange);
|
|
DEBUG_FLOAT ("limit", limits, pointSizeGranularity);
|
|
DEBUG_FLOAT ("limit", limits, lineWidthGranularity);
|
|
DEBUG_BOOL_STRUCT ("limit", limits, strictLines);
|
|
DEBUG_BOOL_STRUCT ("limit", limits, standardSampleLocations);
|
|
DEBUG_UINT64 ("limit", limits, optimalBufferCopyOffsetAlignment);
|
|
DEBUG_UINT64 ("limit", limits, optimalBufferCopyRowPitchAlignment);
|
|
DEBUG_UINT64 ("limit", limits, nonCoherentAtomSize);
|
|
/* *INDENT-ON* */
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
dump_sparse_properties (GstVulkanPhysicalDevice * device, GError ** error)
|
|
{
|
|
VkPhysicalDeviceSparseProperties *props =
|
|
&device->properties.sparseProperties;
|
|
|
|
/* *INDENT-OFF* */
|
|
DEBUG_BOOL_STRUCT ("sparse property", props, residencyStandard2DBlockShape);
|
|
DEBUG_BOOL_STRUCT ("sparse property", props, residencyStandard2DMultisampleBlockShape);
|
|
DEBUG_BOOL_STRUCT ("sparse property", props, residencyStandard3DBlockShape);
|
|
DEBUG_BOOL_STRUCT ("sparse property", props, residencyAlignedMipSize);
|
|
DEBUG_BOOL_STRUCT ("sparse property", props, residencyNonResidentStrict);
|
|
/* *INDENT-ON* */
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
#if defined (VK_API_VERSION_1_2)
|
|
static void
|
|
dump_properties11 (GstVulkanPhysicalDevice * device,
|
|
VkPhysicalDeviceVulkan11Properties * properties)
|
|
{
|
|
/* *INDENT-OFF* */
|
|
/* uint8_t deviceUUID[VK_UUID_SIZE];
|
|
uint8_t driverUUID[VK_UUID_SIZE];
|
|
uint8_t deviceLUID[VK_LUID_SIZE];*/
|
|
DEBUG_UINT32 ("properties (1.1)", properties, deviceNodeMask);
|
|
/* VkBool32 deviceLUIDValid;*/
|
|
DEBUG_UINT32 ("properties (1.1)", properties, subgroupSize);
|
|
/* VkShaderStageFlags subgroupSupportedStages;
|
|
VkSubgroupFeatureFlags subgroupSupportedOperations;*/
|
|
DEBUG_BOOL_STRUCT ("properties (1.1)", properties, subgroupQuadOperationsInAllStages);
|
|
/* VkPointClippingBehavior pointClippingBehavior;*/
|
|
DEBUG_UINT32 ("properties (1.1)", properties, maxMultiviewViewCount);
|
|
DEBUG_UINT32 ("properties (1.1)", properties, maxMultiviewInstanceIndex);
|
|
DEBUG_BOOL_STRUCT ("properties (1.1)", properties, protectedNoFault);
|
|
DEBUG_UINT32 ("properties (1.1)", properties, maxPerSetDescriptors);
|
|
DEBUG_SIZE ("properties (1.1)", properties, maxMemoryAllocationSize);
|
|
/* *INDENT-ON* */
|
|
}
|
|
|
|
static void
|
|
dump_properties12 (GstVulkanPhysicalDevice * device,
|
|
VkPhysicalDeviceVulkan12Properties * properties)
|
|
{
|
|
/* *INDENT-OFF* */
|
|
/* VkDriverId driverID;*/
|
|
DEBUG_STRING ("properties (1.2)", properties, driverName);
|
|
DEBUG_STRING ("properties (1.2)", properties, driverInfo);
|
|
/* VkConformanceVersion conformanceVersion;
|
|
VkShaderFloatControlsIndependence denormBehaviorIndependence;
|
|
VkShaderFloatControlsIndependence roundingModeIndependence;*/
|
|
DEBUG_BOOL_STRUCT ("properties (1.2)", properties, shaderSignedZeroInfNanPreserveFloat16);
|
|
DEBUG_BOOL_STRUCT ("properties (1.2)", properties, shaderSignedZeroInfNanPreserveFloat32);
|
|
DEBUG_BOOL_STRUCT ("properties (1.2)", properties, shaderSignedZeroInfNanPreserveFloat64);
|
|
DEBUG_BOOL_STRUCT ("properties (1.2)", properties, shaderDenormPreserveFloat16);
|
|
DEBUG_BOOL_STRUCT ("properties (1.2)", properties, shaderDenormPreserveFloat32);
|
|
DEBUG_BOOL_STRUCT ("properties (1.2)", properties, shaderDenormPreserveFloat64);
|
|
DEBUG_BOOL_STRUCT ("properties (1.2)", properties, shaderDenormFlushToZeroFloat16);
|
|
DEBUG_BOOL_STRUCT ("properties (1.2)", properties, shaderDenormFlushToZeroFloat16);
|
|
DEBUG_BOOL_STRUCT ("properties (1.2)", properties, shaderDenormFlushToZeroFloat32);
|
|
DEBUG_BOOL_STRUCT ("properties (1.2)", properties, shaderRoundingModeRTEFloat16);
|
|
DEBUG_BOOL_STRUCT ("properties (1.2)", properties, shaderRoundingModeRTEFloat32);
|
|
DEBUG_BOOL_STRUCT ("properties (1.2)", properties, shaderRoundingModeRTEFloat64);
|
|
DEBUG_BOOL_STRUCT ("properties (1.2)", properties, shaderRoundingModeRTZFloat16);
|
|
DEBUG_BOOL_STRUCT ("properties (1.2)", properties, shaderRoundingModeRTZFloat32);
|
|
DEBUG_BOOL_STRUCT ("properties (1.2)", properties, shaderRoundingModeRTZFloat64);
|
|
DEBUG_UINT32 ("properties (1.2)", properties, maxUpdateAfterBindDescriptorsInAllPools);
|
|
DEBUG_BOOL_STRUCT ("properties (1.2)", properties, shaderUniformBufferArrayNonUniformIndexingNative);
|
|
DEBUG_BOOL_STRUCT ("properties (1.2)", properties, shaderSampledImageArrayNonUniformIndexingNative);
|
|
DEBUG_BOOL_STRUCT ("properties (1.2)", properties, shaderSampledImageArrayNonUniformIndexingNative);
|
|
DEBUG_BOOL_STRUCT ("properties (1.2)", properties, shaderStorageBufferArrayNonUniformIndexingNative);
|
|
DEBUG_BOOL_STRUCT ("properties (1.2)", properties, shaderStorageImageArrayNonUniformIndexingNative);
|
|
DEBUG_BOOL_STRUCT ("properties (1.2)", properties, shaderInputAttachmentArrayNonUniformIndexingNative);
|
|
DEBUG_BOOL_STRUCT ("properties (1.2)", properties, robustBufferAccessUpdateAfterBind);
|
|
DEBUG_BOOL_STRUCT ("properties (1.2)", properties, quadDivergentImplicitLod);
|
|
DEBUG_UINT32 ("properties (1.2)", properties, maxPerStageDescriptorUpdateAfterBindSamplers);
|
|
DEBUG_UINT32 ("properties (1.2)", properties, maxPerStageDescriptorUpdateAfterBindUniformBuffers);
|
|
DEBUG_UINT32 ("properties (1.2)", properties, maxPerStageDescriptorUpdateAfterBindStorageBuffers);
|
|
DEBUG_UINT32 ("properties (1.2)", properties, maxPerStageDescriptorUpdateAfterBindSampledImages);
|
|
DEBUG_UINT32 ("properties (1.2)", properties, maxPerStageDescriptorUpdateAfterBindStorageImages);
|
|
DEBUG_UINT32 ("properties (1.2)", properties, maxPerStageDescriptorUpdateAfterBindInputAttachments);
|
|
DEBUG_UINT32 ("properties (1.2)", properties, maxPerStageUpdateAfterBindResources);
|
|
DEBUG_UINT32 ("properties (1.2)", properties, maxDescriptorSetUpdateAfterBindSamplers);
|
|
DEBUG_UINT32 ("properties (1.2)", properties, maxDescriptorSetUpdateAfterBindUniformBuffers);
|
|
DEBUG_UINT32 ("properties (1.2)", properties, maxDescriptorSetUpdateAfterBindUniformBuffersDynamic);
|
|
DEBUG_UINT32 ("properties (1.2)", properties, maxDescriptorSetUpdateAfterBindStorageBuffers);
|
|
DEBUG_UINT32 ("properties (1.2)", properties, maxDescriptorSetUpdateAfterBindStorageBuffersDynamic);
|
|
DEBUG_UINT32 ("properties (1.2)", properties, maxDescriptorSetUpdateAfterBindSampledImages);
|
|
DEBUG_UINT32 ("properties (1.2)", properties, maxDescriptorSetUpdateAfterBindStorageImages);
|
|
DEBUG_UINT32 ("properties (1.2)", properties, maxDescriptorSetUpdateAfterBindInputAttachments);
|
|
/* VkResolveModeFlags supportedDepthResolveModes;
|
|
VkResolveModeFlags supportedStencilResolveModes;*/
|
|
DEBUG_BOOL_STRUCT ("properties (1.2)", properties, independentResolveNone);
|
|
DEBUG_BOOL_STRUCT ("properties (1.2)", properties, independentResolve);
|
|
DEBUG_BOOL_STRUCT ("properties (1.2)", properties, filterMinmaxSingleComponentFormats);
|
|
DEBUG_BOOL_STRUCT ("properties (1.2)", properties, filterMinmaxImageComponentMapping);
|
|
DEBUG_UINT64 ("properties (1.2)", properties, maxTimelineSemaphoreValueDifference);
|
|
DEBUG_FLAGS ("properties (1.2)", properties, framebufferIntegerColorSampleCounts, sample_count);
|
|
/* *INDENT-ON* */
|
|
}
|
|
#endif
|
|
|
|
static gboolean
|
|
physical_device_info (GstVulkanPhysicalDevice * device, GError ** error)
|
|
{
|
|
#if defined (VK_API_VERSION_1_2)
|
|
GstVulkanPhysicalDevicePrivate *priv = GET_PRIV (device);
|
|
VkBaseOutStructure *iter;
|
|
#endif
|
|
|
|
GST_INFO_OBJECT (device, "physical device %i name \'%s\' type \'%s\' "
|
|
"api version %u.%u.%u, driver version %u.%u.%u vendor ID 0x%x, "
|
|
"device ID 0x%x", device->device_index, device->properties.deviceName,
|
|
gst_vulkan_physical_device_type_to_string (device->properties.deviceType),
|
|
VK_VERSION_MAJOR (device->properties.apiVersion),
|
|
VK_VERSION_MINOR (device->properties.apiVersion),
|
|
VK_VERSION_PATCH (device->properties.apiVersion),
|
|
VK_VERSION_MAJOR (device->properties.driverVersion),
|
|
VK_VERSION_MINOR (device->properties.driverVersion),
|
|
VK_VERSION_PATCH (device->properties.driverVersion),
|
|
device->properties.vendorID, device->properties.deviceID);
|
|
|
|
if (!dump_queue_properties (device, error))
|
|
return FALSE;
|
|
if (!dump_memory_properties (device, error))
|
|
return FALSE;
|
|
if (!dump_features (device, error))
|
|
return FALSE;
|
|
if (!dump_limits (device, error))
|
|
return FALSE;
|
|
if (!dump_sparse_properties (device, error))
|
|
return FALSE;
|
|
|
|
#if defined (VK_API_VERSION_1_2)
|
|
if (gst_vulkan_instance_check_version (device->instance, 1, 2, 0)) {
|
|
for (iter = (VkBaseOutStructure *) & priv->properties10; iter;
|
|
iter = iter->pNext) {
|
|
if (iter->sType ==
|
|
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES)
|
|
dump_properties11 (device, (VkPhysicalDeviceVulkan11Properties *) iter);
|
|
else if (iter->sType ==
|
|
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES)
|
|
dump_properties12 (device, (VkPhysicalDeviceVulkan12Properties *) iter);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
gst_vulkan_physical_device_fill_info (GstVulkanPhysicalDevice * device,
|
|
GError ** error)
|
|
{
|
|
GstVulkanPhysicalDevicePrivate *priv = GET_PRIV (device);
|
|
VkResult err;
|
|
guint i;
|
|
|
|
device->device = gst_vulkan_physical_device_get_handle (device);
|
|
if (!device->device) {
|
|
g_set_error (error, GST_VULKAN_ERROR, VK_ERROR_INITIALIZATION_FAILED,
|
|
"Failed to retrieve physical device");
|
|
goto error;
|
|
}
|
|
|
|
err =
|
|
vkEnumerateDeviceLayerProperties (device->device,
|
|
&priv->n_available_layers, NULL);
|
|
if (gst_vulkan_error_to_g_error (err, error,
|
|
"vkEnumerateDeviceLayerProperties") < 0)
|
|
goto error;
|
|
|
|
priv->available_layers = g_new0 (VkLayerProperties, priv->n_available_layers);
|
|
err =
|
|
vkEnumerateDeviceLayerProperties (device->device,
|
|
&priv->n_available_layers, priv->available_layers);
|
|
if (gst_vulkan_error_to_g_error (err, error,
|
|
"vkEnumerateDeviceLayerProperties") < 0) {
|
|
goto error;
|
|
}
|
|
|
|
err =
|
|
vkEnumerateDeviceExtensionProperties (device->device, NULL,
|
|
&priv->n_available_extensions, NULL);
|
|
if (gst_vulkan_error_to_g_error (err, error,
|
|
"vkEnumerateDeviceExtensionProperties") < 0) {
|
|
goto error;
|
|
}
|
|
|
|
priv->available_extensions =
|
|
g_new0 (VkExtensionProperties, priv->n_available_extensions);
|
|
err =
|
|
vkEnumerateDeviceExtensionProperties (device->device, NULL,
|
|
&priv->n_available_extensions, priv->available_extensions);
|
|
if (gst_vulkan_error_to_g_error (err, error,
|
|
"vkEnumerateDeviceExtensionProperties") < 0) {
|
|
goto error;
|
|
}
|
|
|
|
GST_INFO_OBJECT (device, "found %u layers and %u extensions",
|
|
priv->n_available_layers, priv->n_available_extensions);
|
|
|
|
for (i = 0; i < priv->n_available_layers; i++)
|
|
GST_DEBUG_OBJECT (device, "available layer %u: %s", i,
|
|
priv->available_layers[i].layerName);
|
|
for (i = 0; i < priv->n_available_extensions; i++)
|
|
GST_DEBUG_OBJECT (device, "available extension %u: %s", i,
|
|
priv->available_extensions[i].extensionName);
|
|
|
|
vkGetPhysicalDeviceProperties (device->device, &device->properties);
|
|
#if defined (VK_API_VERSION_1_2)
|
|
if (gst_vulkan_instance_check_version (device->instance, 1, 2, 0)) {
|
|
PFN_vkGetPhysicalDeviceProperties2 get_props2;
|
|
PFN_vkGetPhysicalDeviceMemoryProperties2 get_mem_props2;
|
|
PFN_vkGetPhysicalDeviceFeatures2 get_features2;
|
|
PFN_vkGetPhysicalDeviceQueueFamilyProperties2 get_queue_props2;
|
|
VkPhysicalDeviceMemoryProperties2 mem_properties10;
|
|
|
|
/* *INDENT-OFF* */
|
|
mem_properties10 = (VkPhysicalDeviceMemoryProperties2) {
|
|
.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2,
|
|
.pNext = NULL,
|
|
};
|
|
/* *INDENT-ON* */
|
|
|
|
get_props2 = (PFN_vkGetPhysicalDeviceProperties2)
|
|
gst_vulkan_instance_get_proc_address (device->instance,
|
|
"vkGetPhysicalDeviceProperties2");
|
|
get_props2 (device->device, &priv->properties10);
|
|
|
|
get_mem_props2 = (PFN_vkGetPhysicalDeviceMemoryProperties2)
|
|
gst_vulkan_instance_get_proc_address (device->instance,
|
|
"vkGetPhysicalDeviceMemoryProperties2");
|
|
get_mem_props2 (device->device, &mem_properties10);
|
|
memcpy (&device->memory_properties, &mem_properties10.memoryProperties,
|
|
sizeof (device->memory_properties));
|
|
|
|
get_features2 = (PFN_vkGetPhysicalDeviceFeatures2)
|
|
gst_vulkan_instance_get_proc_address (device->instance,
|
|
"vkGetPhysicalDeviceFeatures2");
|
|
get_features2 (device->device, &priv->features10);
|
|
memcpy (&device->features, &priv->features10.features,
|
|
sizeof (device->features));
|
|
|
|
get_queue_props2 = (PFN_vkGetPhysicalDeviceQueueFamilyProperties2)
|
|
gst_vulkan_instance_get_proc_address (device->instance,
|
|
"vkGetPhysicalDeviceQueueFamilyProperties2");
|
|
get_queue_props2 (device->device, &device->n_queue_families, NULL);
|
|
if (device->n_queue_families > 0) {
|
|
VkQueueFamilyProperties2 *props;
|
|
int i;
|
|
|
|
props = g_new0 (VkQueueFamilyProperties2, device->n_queue_families);
|
|
for (i = 0; i < device->n_queue_families; i++) {
|
|
props[i].sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2;
|
|
props[i].pNext = NULL;
|
|
}
|
|
|
|
get_queue_props2 (device->device, &device->n_queue_families, props);
|
|
|
|
device->queue_family_props =
|
|
g_new0 (VkQueueFamilyProperties, device->n_queue_families);
|
|
for (i = 0; i < device->n_queue_families; i++) {
|
|
memcpy (&device->queue_family_props[i], &props[i].queueFamilyProperties,
|
|
sizeof (device->queue_family_props[i]));
|
|
}
|
|
g_free (props);
|
|
}
|
|
} else
|
|
#endif
|
|
{
|
|
vkGetPhysicalDeviceMemoryProperties (device->device,
|
|
&device->memory_properties);
|
|
vkGetPhysicalDeviceFeatures (device->device, &device->features);
|
|
vkGetPhysicalDeviceQueueFamilyProperties (device->device,
|
|
&device->n_queue_families, NULL);
|
|
if (device->n_queue_families > 0) {
|
|
device->queue_family_props =
|
|
g_new0 (VkQueueFamilyProperties, device->n_queue_families);
|
|
vkGetPhysicalDeviceQueueFamilyProperties (device->device,
|
|
&device->n_queue_families, device->queue_family_props);
|
|
}
|
|
}
|
|
|
|
if (!physical_device_info (device, error))
|
|
goto error;
|
|
|
|
return TRUE;
|
|
|
|
error:
|
|
return FALSE;
|
|
}
|
|
|
|
/**
|
|
* gst_vulkan_physical_device_get_handle: (skip)
|
|
* @device: a #GstVulkanPhysicalDevice
|
|
*
|
|
* Returns: The associated `VkPhysicalDevice` handle
|
|
*
|
|
* Since: 1.18
|
|
*/
|
|
VkPhysicalDevice
|
|
gst_vulkan_physical_device_get_handle (GstVulkanPhysicalDevice * device)
|
|
{
|
|
g_return_val_if_fail (GST_IS_VULKAN_PHYSICAL_DEVICE (device), NULL);
|
|
|
|
return device->device;
|
|
}
|
|
|
|
/**
|
|
* gst_vulkan_physical_device_get_instance:
|
|
* @device: a #GstVulkanPhysicalDevice
|
|
*
|
|
* Returns: (transfer full): The #GstVulkanInstance associated with this physical device
|
|
*
|
|
* Since: 1.18
|
|
*/
|
|
GstVulkanInstance *
|
|
gst_vulkan_physical_device_get_instance (GstVulkanPhysicalDevice * device)
|
|
{
|
|
g_return_val_if_fail (GST_IS_VULKAN_PHYSICAL_DEVICE (device), NULL);
|
|
|
|
return device->instance ? gst_object_ref (device->instance) : NULL;
|
|
}
|
|
|
|
static gboolean
|
|
gst_vulkan_physical_device_get_layer_info_unlocked (GstVulkanPhysicalDevice *
|
|
device, const gchar * name, gchar ** description, guint32 * spec_version,
|
|
guint32 * implementation_version)
|
|
{
|
|
GstVulkanPhysicalDevicePrivate *priv;
|
|
int i;
|
|
|
|
priv = GET_PRIV (device);
|
|
|
|
for (i = 0; i < priv->n_available_layers; i++) {
|
|
if (g_strcmp0 (name, priv->available_layers[i].layerName) == 0) {
|
|
if (description)
|
|
*description = g_strdup (priv->available_layers[i].description);
|
|
if (spec_version)
|
|
*spec_version = priv->available_layers[i].specVersion;
|
|
if (implementation_version)
|
|
*spec_version = priv->available_layers[i].implementationVersion;
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
/**
|
|
* gst_vulkan_physical_device_get_layer_info:
|
|
* @device: a #GstVulkanPhysicalDevice
|
|
* @name: the layer name to look for
|
|
* @description: (out) (nullable): return value for the layer description or %NULL
|
|
* @spec_version: (out) (nullable): return value for the layer specification version
|
|
* @implementation_version: (out) (nullable): return value for the layer implementation version
|
|
*
|
|
* Retrieves information about a layer.
|
|
*
|
|
* Will not find any layers before gst_vulkan_instance_fill_info() has been
|
|
* called.
|
|
*
|
|
* Returns: whether layer @name is available
|
|
*
|
|
* Since: 1.18
|
|
*/
|
|
gboolean
|
|
gst_vulkan_physical_device_get_layer_info (GstVulkanPhysicalDevice * device,
|
|
const gchar * name, gchar ** description, guint32 * spec_version,
|
|
guint32 * implementation_version)
|
|
{
|
|
gboolean ret;
|
|
|
|
g_return_val_if_fail (GST_IS_VULKAN_PHYSICAL_DEVICE (device), FALSE);
|
|
g_return_val_if_fail (name != NULL, FALSE);
|
|
|
|
GST_OBJECT_LOCK (device);
|
|
ret =
|
|
gst_vulkan_physical_device_get_layer_info_unlocked (device, name,
|
|
description, spec_version, implementation_version);
|
|
GST_OBJECT_UNLOCK (device);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static gboolean
|
|
gst_vulkan_physical_device_get_extension_info_unlocked (GstVulkanPhysicalDevice
|
|
* device, const gchar * name, guint32 * spec_version)
|
|
{
|
|
GstVulkanPhysicalDevicePrivate *priv;
|
|
int i;
|
|
|
|
priv = GET_PRIV (device);
|
|
|
|
for (i = 0; i < priv->n_available_extensions; i++) {
|
|
if (g_strcmp0 (name, priv->available_extensions[i].extensionName) == 0) {
|
|
if (spec_version)
|
|
*spec_version = priv->available_extensions[i].specVersion;
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
/**
|
|
* gst_vulkan_physical_device_get_extension_info:
|
|
* @device: a #GstVulkanPhysicalDevice
|
|
* @name: the extension name to look for
|
|
* @spec_version: (out) (nullable): return value for the exteion specification version
|
|
*
|
|
* Retrieves information about a device extension.
|
|
*
|
|
* Will not find any extensions before gst_vulkan_instance_fill_info() has been
|
|
* called.
|
|
*
|
|
* Returns: whether extension @name is available
|
|
*
|
|
* Since: 1.18
|
|
*/
|
|
gboolean
|
|
gst_vulkan_physical_device_get_extension_info (GstVulkanPhysicalDevice * device,
|
|
const gchar * name, guint32 * spec_version)
|
|
{
|
|
gboolean ret;
|
|
|
|
g_return_val_if_fail (GST_IS_VULKAN_PHYSICAL_DEVICE (device), FALSE);
|
|
g_return_val_if_fail (name != NULL, FALSE);
|
|
|
|
GST_OBJECT_LOCK (device);
|
|
ret =
|
|
gst_vulkan_physical_device_get_extension_info_unlocked (device, name,
|
|
spec_version);
|
|
GST_OBJECT_UNLOCK (device);
|
|
|
|
return ret;
|
|
}
|