mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-12-13 20:06:35 +00:00
Code Issues 1 Projects Releases Wiki Activity
gstreamer/subprojects/gst-plugins-bad/gst-libs/gst/vulkan/gstvkdecoder-private.c

1401 lines
42 KiB
C
Raw Blame History

/*
* GStreamer
* Copyright (C) 2023 Igalia, S.L.
*
* 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 "gstvkdecoder-private.h"
#include "gstvkoperation.h"
#include "gstvkphysicaldevice-private.h"
#include "gstvkvideo-private.h"
/**
* SECTION:vkdecoder
* @title: GstVulkanDecoder
* @short_description: Abstract Vulkan Video Decoder
* @see_also: #GstVulkanOperation
*
* #GstVulkanOperation abstracts a video decoding operation.
*
* Since: 1.24
*/
typedef struct _GstVulkanDecoderPrivate GstVulkanDecoderPrivate;
struct _GstVulkanDecoderPrivate
{
GstVulkanHandle *empty_params;
GstVulkanHandle *session_params;
GstVulkanHandle *sampler;
GstCaps *profile_caps;
GstBufferPool *dpb_pool;
GstVulkanOperation *exec;
GstVulkanVideoSession session;
GstVulkanVideoCapabilities caps;
VkVideoFormatPropertiesKHR format;
gboolean vk_populated;
GstVulkanVideoFunctions vk;
gboolean started;
};
#define GST_CAT_DEFAULT gst_vulkan_decoder_debug
GST_DEBUG_CATEGORY (GST_CAT_DEFAULT);
#define gst_vulkan_decoder_parent_class parent_class
G_DEFINE_TYPE_WITH_CODE (GstVulkanDecoder, gst_vulkan_decoder,
GST_TYPE_OBJECT, G_ADD_PRIVATE (GstVulkanDecoder)
GST_DEBUG_CATEGORY_INIT (gst_vulkan_decoder_debug,
"vulkandecoder", 0, "Vulkan device decoder"));
static GstVulkanHandle *gst_vulkan_decoder_new_video_session_parameters
(GstVulkanDecoder * self, GstVulkanDecoderParameters * params,
GError ** error);
static gboolean
_populate_function_table (GstVulkanDecoder * self)
{
GstVulkanDecoderPrivate *priv =
gst_vulkan_decoder_get_instance_private (self);
GstVulkanInstance *instance;
if (priv->vk_populated)
return TRUE;
instance = gst_vulkan_device_get_instance (self->queue->device);
if (!instance) {
GST_ERROR_OBJECT (self, "Failed to get instance from the device");
return FALSE;
}
priv->vk_populated = gst_vulkan_video_get_vk_functions (instance, &priv->vk);
gst_object_unref (instance);
return priv->vk_populated;
}
static void
gst_vulkan_decoder_finalize (GObject * object)
{
GstVulkanDecoder *self = GST_VULKAN_DECODER (object);
gst_clear_object (&self->queue);
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
gst_vulkan_decoder_init (GstVulkanDecoder * self)
{
}
static void
gst_vulkan_decoder_class_init (GstVulkanDecoderClass * klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
gobject_class->finalize = gst_vulkan_decoder_finalize;
}
/**
* gst_vulkan_decoder_start:
* @self: a #GstVulkanDecoder
* @profile: a #GstVulkanVideoProfile
* @error: a #GError
*
* It creates a Vulkan video session for the given @profile. If an error occurs,
* @error is filled.
*
* Returns: whether the video decoder has started correctly.
*/
gboolean
gst_vulkan_decoder_start (GstVulkanDecoder * self,
GstVulkanVideoProfile * profile, GError ** error)
{
GstVulkanDecoderPrivate *priv;
VkPhysicalDevice gpu;
VkResult res;
VkVideoDecodeCapabilitiesKHR dec_caps;
VkVideoFormatPropertiesKHR *fmts = NULL;
VkVideoProfileListInfoKHR profile_list = {
.sType = VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR,
.profileCount = 1,
};
VkPhysicalDeviceVideoFormatInfoKHR fmt_info = {
.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR,
.pNext = &profile_list,
};
VkVideoSessionCreateInfoKHR session_create;
GstVulkanDecoderParameters empty_params;
guint i, maxlevel, n_fmts, codec_idx;
GstVideoFormat format = GST_VIDEO_FORMAT_UNKNOWN;
VkFormat vk_format = VK_FORMAT_UNDEFINED;
GstVulkanCommandPool *cmd_pool;
GError *query_err = NULL;
g_return_val_if_fail (GST_IS_VULKAN_DECODER (self), FALSE);
priv = gst_vulkan_decoder_get_instance_private (self);
if (priv->started)
return TRUE;
g_assert (self->codec == profile->profile.videoCodecOperation);
if (!_populate_function_table (self)) {
g_set_error (error, GST_VULKAN_ERROR, VK_ERROR_INITIALIZATION_FAILED,
"Couldn't load Vulkan Video functions");
return FALSE;
}
switch (self->codec) {
case VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR:
case VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR:
if (!gst_vulkan_video_profile_is_valid (profile, self->codec)) {
g_set_error (error, GST_VULKAN_ERROR, VK_ERROR_INITIALIZATION_FAILED,
"Invalid profile");
return FALSE;
}
break;
default:
g_set_error (error, GST_VULKAN_ERROR, VK_ERROR_INITIALIZATION_FAILED,
"Invalid codec");
return FALSE;
}
self->profile = *profile;
self->profile.profile.pNext = &self->profile.usage.decode;
self->profile.usage.decode.pNext = &self->profile.codec;
switch (self->codec) {
case VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR:
/* *INDENT-OFF* */
priv->caps.codec.h264dec = (VkVideoDecodeH264CapabilitiesKHR) {
.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR,
};
/* *INDENT-ON* */
codec_idx = GST_VK_VIDEO_EXTENSION_DECODE_H264;
break;
case VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR:
/* *INDENT-OFF* */
priv->caps.codec.h265dec = (VkVideoDecodeH265CapabilitiesKHR) {
.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR,
};
/* *INDENT-ON* */
codec_idx = GST_VK_VIDEO_EXTENSION_DECODE_H265;
break;
default:
g_assert_not_reached ();
}
/* *INDENT-OFF* */
dec_caps = (VkVideoDecodeCapabilitiesKHR) {
.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR,
.pNext = &priv->caps.codec,
};
priv->caps.caps = (VkVideoCapabilitiesKHR) {
.sType = VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR,
.pNext = &dec_caps,
};
/* *INDENT-ON* */
gpu = gst_vulkan_device_get_physical_device (self->queue->device);
res = priv->vk.GetPhysicalDeviceVideoCapabilities (gpu,
&self->profile.profile, &priv->caps.caps);
if (gst_vulkan_error_to_g_error (res, error,
"vkGetPhysicalDeviceVideoCapabilitiesKHR") != VK_SUCCESS)
return FALSE;
switch (self->codec) {
case VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR:
maxlevel = priv->caps.codec.h264dec.maxLevelIdc;
break;
case VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR:
maxlevel = priv->caps.codec.h265dec.maxLevelIdc;
break;
default:
maxlevel = 0;
}
priv->profile_caps = gst_vulkan_video_profile_to_caps (&self->profile);
GST_LOG_OBJECT (self, "Capabilities for %" GST_PTR_FORMAT ":\n"
" Maximum level: %d\n"
" Width from %i to %i\n"
" Height from %i to %i\n"
" Width alignment: %i\n"
" Height alignment: %i\n"
" Buffer offset alignment: %" G_GUINT64_FORMAT "\n"
" Buffer size alignment %" G_GUINT64_FORMAT "\n"
" Maximum references: %u\n"
" Maximum active references: %u\n"
" Capabilities flags: %s%s%s\n"
" Codec header version: %s [%i.%i.%i] (driver) [%i.%i.%i] (compiled) \n"
" Decode modes:%s%s%s",
priv->profile_caps,
maxlevel,
priv->caps.caps.minCodedExtent.width,
priv->caps.caps.maxCodedExtent.width,
priv->caps.caps.minCodedExtent.height,
priv->caps.caps.maxCodedExtent.height,
priv->caps.caps.pictureAccessGranularity.width,
priv->caps.caps.pictureAccessGranularity.height,
priv->caps.caps.minBitstreamBufferOffsetAlignment,
priv->caps.caps.minBitstreamBufferSizeAlignment,
priv->caps.caps.maxDpbSlots, priv->caps.caps.maxActiveReferencePictures,
priv->caps.caps.flags ? "" : " none",
priv->caps.caps.flags &
VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR ?
" protected" : "",
priv->caps.caps.flags &
VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR ?
" separate_references" : "",
GST_STR_NULL (priv->caps.caps.stdHeaderVersion.extensionName),
VK_CODEC_VERSION (priv->caps.caps.stdHeaderVersion.specVersion),
VK_CODEC_VERSION (_vk_codec_extensions[codec_idx].specVersion),
dec_caps.flags ? "" : " invalid",
dec_caps.flags &
VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR ?
" reuse_output_DPB" : "",
dec_caps.flags &
VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR ?
" dedicated_DPB" : "");
/* VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR - reports the
* implementation supports using the same Video Picture Resource for decode
* DPB and decode output.
*
* VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR - reports the
* implementation supports using distinct Video Picture Resources for decode
* DPB and decode output. */
self->dedicated_dpb = ((dec_caps.flags &
VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR) == 0);
/* The DPB or Reconstructed Video Picture Resources for the video session may
* be created as a separate VkImage for each DPB picture. If not supported,
* the DPB must be created as single multi-layered image where each layer
* represents one of the DPB Video Picture Resources. */
self->layered_dpb = ((priv->caps.caps.flags &
VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR) == 0);
priv->caps.caps.pNext = NULL;
/* Get output format */
profile_list.pProfiles = &self->profile.profile;
fmt_info.imageUsage = VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR
| VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;
if (!self->dedicated_dpb)
fmt_info.imageUsage |= VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR;
res = priv->vk.GetPhysicalDeviceVideoFormatProperties (gpu, &fmt_info,
&n_fmts, NULL);
if (gst_vulkan_error_to_g_error (res, error,
"vkGetPhysicalDeviceVideoFormatPropertiesKHR") != VK_SUCCESS)
goto failed;
if (n_fmts == 0) {
g_set_error (error, GST_VULKAN_ERROR, VK_ERROR_INITIALIZATION_FAILED,
"Profile doesn't have an output format");
goto failed;
}
fmts = g_new0 (VkVideoFormatPropertiesKHR, n_fmts);
for (i = 0; i < n_fmts; i++)
fmts[i].sType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR;
res = priv->vk.GetPhysicalDeviceVideoFormatProperties (gpu, &fmt_info,
&n_fmts, fmts);
if (gst_vulkan_error_to_g_error (res, error,
"vkGetPhysicalDeviceVideoFormatPropertiesKHR") != VK_SUCCESS) {
goto failed;
}
if (n_fmts == 0) {
g_free (fmts);
g_set_error (error, GST_VULKAN_ERROR, VK_ERROR_INITIALIZATION_FAILED,
"Profile doesn't have an output format");
goto failed;
}
/* find the best output format */
for (i = 0; i < n_fmts; i++) {
format = gst_vulkan_format_to_video_format (fmts[i].format);
if (format == GST_VIDEO_FORMAT_UNKNOWN) {
GST_WARNING_OBJECT (self, "Unknown Vulkan format %i", fmts[i].format);
continue;
} else {
vk_format = fmts[i].format;
priv->format = fmts[i];
priv->format.pNext = NULL;
break;
}
}
g_clear_pointer (&fmts, g_free);
if (vk_format == VK_FORMAT_UNDEFINED) {
g_set_error (error, GST_VULKAN_ERROR, VK_ERROR_INITIALIZATION_FAILED,
"No valid output format found");
goto failed;
}
GST_INFO_OBJECT (self, "Using output format %s",
gst_video_format_to_string (format));
/* *INDENT-OFF* */
session_create = (VkVideoSessionCreateInfoKHR) {
.sType = VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR,
.queueFamilyIndex = self->queue->family,
.pVideoProfile = &profile->profile,
.pictureFormat = vk_format,
.maxCodedExtent = priv->caps.caps.maxCodedExtent,
.referencePictureFormat = vk_format,
.maxDpbSlots = priv->caps.caps.maxDpbSlots,
.maxActiveReferencePictures = priv->caps.caps.maxActiveReferencePictures,
.pStdHeaderVersion = &_vk_codec_extensions[codec_idx],
};
/* *INDENT-ON* */
/* create video session */
if (!gst_vulkan_video_session_create (&priv->session, self->queue->device,
&priv->vk, &session_create, error))
goto failed;
/* create empty codec params */
switch (self->profile.profile.videoCodecOperation) {
case VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR:
/* *INDENT-OFF* */
empty_params.h264 = (VkVideoDecodeH264SessionParametersCreateInfoKHR) {
.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR,
};
/* *INDENT-ON* */
break;
case VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR:
/* *INDENT-OFF* */
empty_params.h265 = (VkVideoDecodeH265SessionParametersCreateInfoKHR) {
.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR,
};
/* *INDENT-ON* */
break;
default:
g_assert_not_reached ();
}
priv->empty_params = gst_vulkan_decoder_new_video_session_parameters (self,
&empty_params, error);
if (!priv->empty_params)
goto failed;
cmd_pool = gst_vulkan_queue_create_command_pool (self->queue, error);
if (!cmd_pool)
goto failed;
priv->exec = gst_vulkan_operation_new (cmd_pool);
gst_object_unref (cmd_pool);
if (!gst_vulkan_operation_enable_query (priv->exec,
VK_QUERY_TYPE_RESULT_STATUS_ONLY_KHR, 1, &profile->profile,
&query_err)) {
if (query_err->code != VK_ERROR_FEATURE_NOT_PRESENT) {
g_propagate_error (error, query_err);
goto failed;
}
g_clear_error (&query_err);
}
if (!gst_vulkan_decoder_flush (self, error))
goto failed;
priv->started = TRUE;
return TRUE;
failed:
{
g_free (fmts);
gst_clear_caps (&priv->profile_caps);
if (priv->session.session)
gst_vulkan_video_session_destroy (&priv->session);
gst_clear_vulkan_handle (&priv->empty_params);
gst_clear_object (&priv->exec);
return FALSE;
}
}
/**
* gst_vulkan_decoder_stop:
* @self: a #GstVulkanDecoder
*
* Destroys the video session created at gst_vulkan_decoder_start() and clean up
* the internal objects.
*
* Returns: whether the decoder stopped correctly.
*/
gboolean
gst_vulkan_decoder_stop (GstVulkanDecoder * self)
{
GstVulkanDecoderPrivate *priv;
g_return_val_if_fail (GST_IS_VULKAN_DECODER (self), FALSE);
priv = gst_vulkan_decoder_get_instance_private (self);
if (!priv->started)
return TRUE;
gst_vulkan_decoder_wait (self);
gst_clear_buffer (&self->input_buffer);
gst_clear_buffer (&self->layered_buffer);
gst_clear_object (&priv->dpb_pool);
gst_vulkan_video_session_destroy (&priv->session);
gst_clear_caps (&priv->profile_caps);
gst_clear_vulkan_handle (&priv->empty_params);
gst_clear_vulkan_handle (&priv->session_params);
gst_clear_vulkan_handle (&priv->sampler);
gst_clear_object (&priv->exec);
priv->started = FALSE;
return TRUE;
}
/**
* gst_vulkan_decoder_flush:
* @self: a #GstVulkanDecoder
* @error: a #GError
*
* Initializes the decoder at driver level and set its DPB slots to the inactive
* state.
*
* Returns: whether flush was successful
*/
gboolean
gst_vulkan_decoder_flush (GstVulkanDecoder * self, GError ** error)
{
GstVulkanDecoderPrivate *priv;
VkVideoBeginCodingInfoKHR decode_start;
VkVideoCodingControlInfoKHR decode_ctrl = {
.sType = VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR,
.flags = VK_VIDEO_CODING_CONTROL_RESET_BIT_KHR,
};
VkVideoEndCodingInfoKHR decode_end = {
.sType = VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR,
};
gboolean ret;
g_return_val_if_fail (GST_IS_VULKAN_DECODER (self), FALSE);
priv = gst_vulkan_decoder_get_instance_private (self);
if (!(priv->empty_params && priv->exec))
return FALSE;
/* *INDENT-OFF* */
decode_start = (VkVideoBeginCodingInfoKHR) {
.sType = VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR,
.videoSession = priv->session.session->handle,
.videoSessionParameters = priv->empty_params->handle,
};
/* *INDENT-ON* */
if (!gst_vulkan_operation_begin (priv->exec, error))
return FALSE;
priv->vk.CmdBeginVideoCoding (priv->exec->cmd_buf->cmd, &decode_start);
priv->vk.CmdControlVideoCoding (priv->exec->cmd_buf->cmd, &decode_ctrl);
priv->vk.CmdEndVideoCoding (priv->exec->cmd_buf->cmd, &decode_end);
ret = gst_vulkan_operation_end (priv->exec, error);
return ret;
}
/**
* gst_vulkan_decoder_create_dpb_pool:
* @self: a #GstVulkanDecoder
* @caps: the #GstCaps of the DP
*
* Instantiates an internal Vulkan image pool for driver decoders whose output
* buffers cannot be used as DPB buffers.
*
* Returns: whether the pool was created.
*/
gboolean
gst_vulkan_decoder_create_dpb_pool (GstVulkanDecoder * self, GstCaps * caps)
{
GstVulkanDecoderPrivate *priv;
VkImageUsageFlags usage = VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR;
GstStructure *config;
guint min_buffers, max_buffers;
GstFlowReturn ret;
g_return_val_if_fail (GST_IS_VULKAN_DECODER (self), FALSE);
g_return_val_if_fail (GST_IS_CAPS (caps), FALSE);
priv = gst_vulkan_decoder_get_instance_private (self);
if (!priv->started)
return FALSE;
if (!self->dedicated_dpb)
return TRUE;
if (self->layered_dpb) {
min_buffers = max_buffers = 1;
} else {
min_buffers = priv->caps.caps.maxDpbSlots;
max_buffers = 0;
}
priv->dpb_pool = gst_vulkan_image_buffer_pool_new (self->queue->device);
config = gst_buffer_pool_get_config (priv->dpb_pool);
gst_buffer_pool_config_set_params (config, caps, 1024, min_buffers,
max_buffers);
gst_vulkan_image_buffer_pool_config_set_allocation_params (config, usage,
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR,
VK_ACCESS_TRANSFER_READ_BIT | VK_ACCESS_TRANSFER_WRITE_BIT);
if (self->layered_dpb) {
gst_structure_set (config, "num-layers", G_TYPE_UINT,
priv->caps.caps.maxDpbSlots, NULL);
}
gst_vulkan_image_buffer_pool_config_set_decode_caps (config,
priv->profile_caps);
if (!gst_buffer_pool_set_config (priv->dpb_pool, config))
goto bail;
if (!gst_buffer_pool_set_active (priv->dpb_pool, TRUE))
goto bail;
if (self->layered_dpb) {
ret = gst_buffer_pool_acquire_buffer (priv->dpb_pool, &self->layered_buffer,
NULL);
if (ret != GST_FLOW_OK)
goto bail;
}
return TRUE;
bail:
g_clear_object (&priv->dpb_pool);
return FALSE;
}
/**
* gst_vulkan_decoder_decode:
* @self: a #GstVulkanDecoder
* @pic: a #GstVulkanDecoderPicture
* @error: a #GError
*
* Decodes @pic.
*
* Return: whether @pic was decoded correctly. It might fill @error.
*/
gboolean
gst_vulkan_decoder_decode (GstVulkanDecoder * self,
GstVulkanDecoderPicture * pic, GError ** error)
{
GstVulkanDecoderPrivate *priv;
VkVideoBeginCodingInfoKHR decode_start;
VkVideoEndCodingInfoKHR decode_end = {
.sType = VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR,
};
GArray *barriers;
VkImageLayout new_layout;
GstVulkanCommandBuffer *cmd_buf;
gboolean ret;
VkVideoReferenceSlotInfoKHR *cur_slot;
gint32 i;
GstMemory *mem;
guint32 slices_size;
g_return_val_if_fail (GST_IS_VULKAN_DECODER (self), FALSE);
g_return_val_if_fail (pic, FALSE);
priv = gst_vulkan_decoder_get_instance_private (self);
/* *INDENT-OFF* */
decode_start = (VkVideoBeginCodingInfoKHR) {
.sType = VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR,
.videoSession = priv->session.session->handle,
.videoSessionParameters = priv->session_params->handle,
.referenceSlotCount = pic->decode_info.referenceSlotCount,
.pReferenceSlots = pic->decode_info.pReferenceSlots,
};
/* *INDENT-ON* */
if (!(priv->started && priv->session_params)) {
g_set_error (error, GST_VULKAN_ERROR, VK_ERROR_INITIALIZATION_FAILED,
"Vulkan Decoder has not started or no session parameters are set");
return FALSE;
}
/* The current decoding reference has to be bound as an inactive reference */
cur_slot = (VkVideoReferenceSlotInfoKHR *)
& decode_start.pReferenceSlots[decode_start.referenceSlotCount];
*cur_slot = pic->slot;
cur_slot->slotIndex = -1;
decode_start.referenceSlotCount++;
/* set the input buffer */
mem = gst_buffer_peek_memory (self->input_buffer, 0);
slices_size = g_array_index (pic->slice_offs, guint32,
pic->slice_offs->len - 1);
pic->decode_info.srcBuffer = ((GstVulkanBufferMemory *) mem)->buffer;
pic->decode_info.srcBufferRange = GST_ROUND_UP_N (slices_size,
priv->caps.caps.minBitstreamBufferSizeAlignment);
if (!gst_vulkan_operation_begin (priv->exec, error))
return FALSE;
cmd_buf = priv->exec->cmd_buf;
if (!gst_vulkan_operation_add_dependency_frame (priv->exec, pic->out,
VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR,
VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR)) {
return FALSE;
}
new_layout = ((self->layered_dpb && self->dedicated_dpb) || pic->dpb) ?
VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR :
VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR;
gst_vulkan_operation_add_frame_barrier (priv->exec, pic->out,
VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR,
VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR,
VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR, new_layout, NULL);
/* Reference for the current image, if existing and not layered */
if (pic->dpb) {
if (!gst_vulkan_operation_add_dependency_frame (priv->exec, pic->dpb,
VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR,
VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR)) {
return FALSE;
}
}
if (!self->layered_buffer) {
/* All references (apart from the current) for non-layered refs */
for (i = 0; i < pic->decode_info.referenceSlotCount; i++) {
GstVulkanDecoderPicture *ref_pic = pic->refs[i];
GstBuffer *ref_buf = ref_pic->dpb ? ref_pic->dpb : ref_pic->out;
if (!gst_vulkan_operation_add_dependency_frame (priv->exec, ref_buf,
VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR,
VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR)) {
return FALSE;
}
if (!ref_pic->dpb) {
guint i, n = gst_buffer_n_memory (ref_buf);
GArray *barriers =
gst_vulkan_operation_new_extra_image_barriers (priv->exec);
for (i = 0; i < n; i++) {
GstVulkanImageMemory *vkmem =
(GstVulkanImageMemory *) gst_buffer_peek_memory (ref_buf, i);
VkImageMemoryBarrier2KHR barrier = {
.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2_KHR,
.pNext = NULL,
.srcStageMask = VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR,
.dstStageMask = VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR,
.srcAccessMask = VK_ACCESS_2_NONE,
.dstAccessMask = VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR
| VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR,
.oldLayout = vkmem->barrier.image_layout,
.newLayout = VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR,
.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.image = vkmem->image,
.subresourceRange = vkmem->barrier.subresource_range,
};
g_array_append_val (barriers, barrier);
}
gst_vulkan_operation_add_extra_image_barriers (priv->exec, barriers);
g_array_unref (barriers);
gst_vulkan_operation_update_frame (priv->exec, ref_buf,
VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR,
VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR
| VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR,
VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR, NULL);
}
}
} else if (pic->decode_info.referenceSlotCount > 1
|| pic->img_view_out != pic->img_view_ref) {
/* Single barrier for a single layered ref */
if (!gst_vulkan_operation_add_dependency_frame (priv->exec,
self->layered_buffer, VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR,
VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR)) {
return FALSE;
}
}
/* change image layout */
barriers = gst_vulkan_operation_retrieve_image_barriers (priv->exec);
/* *INDENT-OFF* */
vkCmdPipelineBarrier2 (cmd_buf->cmd, &(VkDependencyInfo) {
.sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
.dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT,
.pImageMemoryBarriers = (VkImageMemoryBarrier2 *) barriers->data,
.imageMemoryBarrierCount = barriers->len,
});
/* *INDENT-ON* */
g_array_unref (barriers);
priv->vk.CmdBeginVideoCoding (cmd_buf->cmd, &decode_start);
gst_vulkan_operation_begin_query (priv->exec, 0);
priv->vk.CmdDecodeVideo (cmd_buf->cmd, &pic->decode_info);
gst_vulkan_operation_end_query (priv->exec, 0);
priv->vk.CmdEndVideoCoding (cmd_buf->cmd, &decode_end);
ret = gst_vulkan_operation_end (priv->exec, error);
return ret;
}
/**
* gst_vulkan_decoder_is_started:
* @self: a #GstVulkanDecoder
*
* Returns: whether gst_vulkan_decoder_start() was called correctly previously.
*/
gboolean
gst_vulkan_decoder_is_started (GstVulkanDecoder * self)
{
GstVulkanDecoderPrivate *priv;
g_return_val_if_fail (GST_IS_VULKAN_DECODER (self), FALSE);
priv = gst_vulkan_decoder_get_instance_private (self);
return priv->started;
}
/**
* gst_vulkan_decoder_caps:
* @self: a #GstVulkanDecoder
* @caps: (out): a #GstVulkanVideoCapabilities
*
* Gets the Vulkan decoding capabilities of the current video session.
*
* Returns: whether the capabilities were fetched correctly.
*/
gboolean
gst_vulkan_decoder_caps (GstVulkanDecoder * self,
GstVulkanVideoCapabilities * caps)
{
GstVulkanDecoderPrivate *priv;
g_return_val_if_fail (GST_IS_VULKAN_DECODER (self), FALSE);
priv = gst_vulkan_decoder_get_instance_private (self);
if (!priv->started)
return FALSE;
if (caps) {
*caps = priv->caps;
caps->caps.pNext = &caps->codec;
}
return TRUE;
}
/**
* gst_vulkan_decoder_out_format: (skip)
* @self: a #GstVulkanDecoder
* @format: (out): the Vulkan output format properties
*
* Gets the Vulkan format properties of the output frames.
*
* Returns: whether the @format was fetched.
*/
gboolean
gst_vulkan_decoder_out_format (GstVulkanDecoder * self,
VkVideoFormatPropertiesKHR * format)
{
GstVulkanDecoderPrivate *priv;
g_return_val_if_fail (GST_IS_VULKAN_DECODER (self), FALSE);
priv = gst_vulkan_decoder_get_instance_private (self);
if (!priv->started)
return FALSE;
if (format)
*format = priv->format;
return TRUE;
}
/**
* gst_vulkan_decoder_profile_caps:
* @self: a #GstVulkanDecoder
*
* Returns: (transfer full): the #GstCaps of the profile defined at
* gst_vulkan_decoder_start().
*/
GstCaps *
gst_vulkan_decoder_profile_caps (GstVulkanDecoder * self)
{
GstVulkanDecoderPrivate *priv;
g_return_val_if_fail (GST_IS_VULKAN_DECODER (self), NULL);
priv = gst_vulkan_decoder_get_instance_private (self);
if (!priv->started)
return NULL;
return gst_caps_ref (priv->profile_caps);
}
static void
gst_vulkan_handle_free_video_session_parameters (GstVulkanHandle * handle,
gpointer data)
{
PFN_vkDestroyVideoSessionParametersKHR vkDestroyVideoSessionParameters;
g_return_if_fail (handle != NULL);
g_return_if_fail (handle->handle != VK_NULL_HANDLE);
g_return_if_fail (handle->type ==
GST_VULKAN_HANDLE_TYPE_VIDEO_SESSION_PARAMETERS);
g_return_if_fail (handle->user_data);
vkDestroyVideoSessionParameters = handle->user_data;
vkDestroyVideoSessionParameters (handle->device->device,
(VkVideoSessionKHR) handle->handle, NULL);
}
static GstVulkanHandle *
gst_vulkan_decoder_new_video_session_parameters (GstVulkanDecoder * self,
GstVulkanDecoderParameters * params, GError ** error)
{
GstVulkanDecoderPrivate *priv;
VkVideoSessionParametersCreateInfoKHR session_params_info;
VkResult res;
VkVideoSessionParametersKHR session_params;
priv = gst_vulkan_decoder_get_instance_private (self);
if (!priv->session.session)
return NULL;
/* *INDENT-OFF* */
session_params_info = (VkVideoSessionParametersCreateInfoKHR) {
.sType = VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR,
.pNext = params,
.videoSession = priv->session.session->handle,
};
/* *INDENT-ON* */
res = priv->vk.CreateVideoSessionParameters (self->queue->device->device,
&session_params_info, NULL, &session_params);
if (gst_vulkan_error_to_g_error (res, error,
"vkCreateVideoSessionParametersKHR") != VK_SUCCESS)
return NULL;
return gst_vulkan_handle_new_wrapped (self->queue->device,
GST_VULKAN_HANDLE_TYPE_VIDEO_SESSION_PARAMETERS,
(GstVulkanHandleTypedef) session_params,
gst_vulkan_handle_free_video_session_parameters,
priv->vk.DestroyVideoSessionParameters);
}
/**
* gst_vulkan_decoder_update_video_session_parameters:
* @self: a #GstVulkanDecoder
* @params: a GstVulkanDecoderParameters union
* @error: a #GError
*
* Update the internal codec parameters for the current video session.
*
* Returns: whether the @params were updated internally. It might fill @error.
*/
gboolean
gst_vulkan_decoder_update_video_session_parameters (GstVulkanDecoder * self,
GstVulkanDecoderParameters * params, GError ** error)
{
GstVulkanDecoderPrivate *priv;
GstVulkanHandle *handle;
g_return_val_if_fail (GST_IS_VULKAN_DECODER (self), FALSE);
g_return_val_if_fail (params, FALSE);
handle =
gst_vulkan_decoder_new_video_session_parameters (self, params, error);
if (!handle)
return FALSE;
priv = gst_vulkan_decoder_get_instance_private (self);
gst_clear_vulkan_handle (&priv->session_params);
priv->session_params = handle;
return TRUE;
}
static void
gst_vulkan_handle_free_sampler_ycbcr_conversion (GstVulkanHandle * handle,
gpointer data)
{
g_return_if_fail (handle != NULL);
g_return_if_fail (handle->handle != VK_NULL_HANDLE);
g_return_if_fail (handle->type ==
GST_VULKAN_HANDLE_TYPE_SAMPLER_YCBCR_CONVERSION);
vkDestroySamplerYcbcrConversion (handle->device->device,
(VkSamplerYcbcrConversion) handle->handle, NULL);
}
/**
* gst_vulkan_decoder_update_ycbcr_sampler:
* @self: a #GstVulkanDecoder
* @range: whether color components are encoded using the full range of
* numerical values or whether values are reserved for headroom and foot
* room.
* @xloc: x location of downsampled chroma component samples relative to the luma
* samples.
* @yloc: y location of downsampled chroma component samples relative to the luma
* samples.
*
* Update the internal Ycbcr sampler for the output images.
*
* Returns: whether the sampler was updated.
*/
gboolean
gst_vulkan_decoder_update_ycbcr_sampler (GstVulkanDecoder * self,
VkSamplerYcbcrRange range, VkChromaLocation xloc,
VkChromaLocation yloc, GError ** error)
{
const VkPhysicalDeviceFeatures2 *features;
const VkBaseOutStructure *iter;
GstVulkanDevice *device;
GstVulkanDecoderPrivate *priv;
GstVulkanHandle *handle;
VkSamplerYcbcrConversionCreateInfo create_info;
VkSamplerYcbcrConversion ycbr_conversion;
VkResult res;
gboolean found = FALSE;
g_return_val_if_fail (GST_IS_VULKAN_DECODER (self), FALSE);
device = self->queue->device;
if (!gst_vulkan_instance_check_version (device->instance, 1, 2, 0)) {
g_set_error (error, GST_VULKAN_ERROR, VK_ERROR_INITIALIZATION_FAILED,
"Sampler Ycbcr conversion not available in API");
return FALSE;
}
features = gst_vulkan_physical_device_get_features (device->physical_device);
for (iter = (const VkBaseOutStructure *) features; iter; iter = iter->pNext) {
if (iter->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES) {
const VkPhysicalDeviceVulkan11Features *features11 =
(const VkPhysicalDeviceVulkan11Features *) iter;
if (!features11->samplerYcbcrConversion)
return FALSE;
found = TRUE;
break;
}
}
if (!found) {
g_set_error (error, GST_VULKAN_ERROR, VK_ERROR_INITIALIZATION_FAILED,
"Sampler Ycbcr conversion not available in driver");
return FALSE;
}
priv = gst_vulkan_decoder_get_instance_private (self);
/* *INDENT-OFF* */
create_info = (VkSamplerYcbcrConversionCreateInfo) {
.sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO,
.components = _vk_identity_component_map,
.ycbcrModel = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY,
.ycbcrRange = range,
.xChromaOffset = xloc,
.yChromaOffset = yloc,
.format = priv->format.format,
};
/* *INDENT-ON* */
res = vkCreateSamplerYcbcrConversion (device->device, &create_info, NULL,
&ycbr_conversion);
if (gst_vulkan_error_to_g_error (res, error,
"vkCreateSamplerYcbcrConversion") != VK_SUCCESS)
return FALSE;
handle = gst_vulkan_handle_new_wrapped (device,
GST_VULKAN_HANDLE_TYPE_SAMPLER_YCBCR_CONVERSION,
(GstVulkanHandleTypedef) ycbr_conversion,
gst_vulkan_handle_free_sampler_ycbcr_conversion, NULL);
gst_clear_vulkan_handle (&priv->sampler);
priv->sampler = handle;
return TRUE;
}
/**
* gst_vulkan_decoder_picture_create_view:
* @self: a #GstVulkanDecoder
* @buf: a #GstBuffer
* @is_out: if @buf is for output or for DPB
*
* Creates a #GstVulkanImageView for @buf for decoding, with the internal Ycbcr
* sampler, if available.
*
* Returns: (transfer full) (nullable): the #GstVulkanImageView.
*/
GstVulkanImageView *
gst_vulkan_decoder_picture_create_view (GstVulkanDecoder * self,
GstBuffer * buf, gboolean is_out)
{
GstVulkanDecoderPrivate *priv;
VkSamplerYcbcrConversionInfo yuv_sampler_info;
VkImageViewCreateInfo view_create_info;
GstVulkanImageMemory *vkmem;
GstMemory *mem;
gpointer pnext;
guint n_mems;
g_return_val_if_fail (GST_IS_VULKAN_DECODER (self) && GST_IS_BUFFER (buf),
NULL);
n_mems = gst_buffer_n_memory (buf);
if (n_mems != 1)
return NULL;
mem = gst_buffer_peek_memory (buf, 0);
if (!gst_is_vulkan_image_memory (mem))
return NULL;
priv = gst_vulkan_decoder_get_instance_private (self);
pnext = NULL;
if (priv->sampler) {
/* *INDENT-OFF* */
yuv_sampler_info = (VkSamplerYcbcrConversionInfo) {
.sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO,
.conversion = priv->sampler->handle,
};
/* *INDENT-ON* */
pnext = &yuv_sampler_info;
}
vkmem = (GstVulkanImageMemory *) mem;
/* *INDENT-OFF* */
view_create_info = (VkImageViewCreateInfo) {
.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
.pNext = pnext,
.viewType = self->layered_dpb && !is_out ?
VK_IMAGE_VIEW_TYPE_2D_ARRAY: VK_IMAGE_VIEW_TYPE_2D,
.format = vkmem->create_info.format,
.image = vkmem->image,
.components = _vk_identity_component_map,
.subresourceRange = (VkImageSubresourceRange) {
.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
.baseArrayLayer = 0,
.layerCount = self->layered_dpb && !is_out ?
VK_REMAINING_ARRAY_LAYERS : 1,
.levelCount = 1,
},
};
/* *INDENT-ON* */
return gst_vulkan_get_or_create_image_view_with_info (vkmem,
&view_create_info);
}
/**
* gst_vulkan_decoder_picture_init:
* @self: a #GstVulkanDecoder
* @pic: a #GstVulkanDecoderPicture
* @out: the #GstBuffer to use as output
*
* Initializes @pic with @out as output buffer.
*
* Returns: whether @pic was initialized.
*/
gboolean
gst_vulkan_decoder_picture_init (GstVulkanDecoder * self,
GstVulkanDecoderPicture * pic, GstBuffer * out)
{
GstVulkanDecoderPrivate *priv;
GstFlowReturn ret;
g_return_val_if_fail (GST_IS_VULKAN_DECODER (self), FALSE);
g_return_val_if_fail (pic, FALSE);
g_return_val_if_fail (GST_IS_BUFFER (out), FALSE);
priv = gst_vulkan_decoder_get_instance_private (self);
if (self->layered_dpb && self->dedicated_dpb)
g_return_val_if_fail (GST_IS_BUFFER (self->layered_buffer), FALSE);
else if (self->dedicated_dpb)
g_return_val_if_fail (GST_IS_BUFFER_POOL (priv->dpb_pool), FALSE);
pic->out = gst_buffer_ref (out);
pic->img_view_out =
gst_vulkan_decoder_picture_create_view (self, pic->out, TRUE);
g_assert (pic->img_view_out);
pic->dpb = NULL;
pic->img_view_ref = NULL;
if (self->layered_dpb && self->dedicated_dpb) {
pic->img_view_ref =
gst_vulkan_decoder_picture_create_view (self, self->layered_buffer,
FALSE);
} else if (self->dedicated_dpb) {
ret = gst_buffer_pool_acquire_buffer (priv->dpb_pool, &pic->dpb, NULL);
if (ret != GST_FLOW_OK)
return FALSE;
pic->img_view_ref =
gst_vulkan_decoder_picture_create_view (self, pic->dpb, FALSE);
} else {
pic->img_view_ref = gst_vulkan_image_view_ref (pic->img_view_out);
}
pic->slice_offs = NULL;
return TRUE;
}
/**
* gst_vulkan_decoder_picture_release:
* @pic: a #GstVulkanDecoderPicture
*
* Releases the internal resource of @pic.
*/
void
gst_vulkan_decoder_picture_release (GstVulkanDecoderPicture * pic)
{
gst_clear_vulkan_image_view (&pic->img_view_ref);
gst_clear_vulkan_image_view (&pic->img_view_out);
gst_clear_buffer (&pic->out);
gst_clear_buffer (&pic->dpb);
g_clear_pointer (&pic->slice_offs, g_array_unref);
}
/**
* gst_vulkan_decoder_append_slice:
* @self: a #GstVulkanDecoder
* @pic: a #GstVulkanDecoderPicture
* @data: slice's bitstream data
* @size: the size of @data
* @add_startcode: whether add start code
*
* Appends slices's @data bitstream into @pic internal input buffer.
*
* Returns: whether the slice @data were added.
*/
gboolean
gst_vulkan_decoder_append_slice (GstVulkanDecoder * self,
GstVulkanDecoderPicture * pic, const guint8 * data, size_t size,
gboolean add_startcode)
{
GstVulkanDecoderPrivate *priv;
static const guint8 startcode[3] = { 0x0, 0x0, 0x1 };
size_t new_size, cur_size, buf_size, startcode_len;
GstBuffer *new_buf = NULL;
g_return_val_if_fail (GST_IS_VULKAN_DECODER (self), FALSE);
priv = gst_vulkan_decoder_get_instance_private (self);
startcode_len = add_startcode ? sizeof (startcode) : 0;
buf_size = self->input_buffer ? gst_buffer_get_size (self->input_buffer) : 0;
cur_size = pic->slice_offs ?
g_array_index (pic->slice_offs, guint32, pic->slice_offs->len - 1) : 0;
new_size = cur_size + startcode_len + size;
new_size = GST_ROUND_UP_N (new_size,
priv->caps.caps.minBitstreamBufferSizeAlignment);
if (new_size > buf_size) {
new_buf = gst_vulkan_video_codec_buffer_new (self->queue->device,
&self->profile, VK_BUFFER_USAGE_VIDEO_DECODE_SRC_BIT_KHR, new_size);
if (!new_buf)
goto error;
if (self->input_buffer) {
if (!gst_buffer_copy_into (new_buf, self->input_buffer,
GST_BUFFER_COPY_MEMORY | GST_BUFFER_COPY_DEEP, 0, -1))
goto error;
}
gst_clear_buffer (&self->input_buffer);
self->input_buffer = new_buf;
}
/* append data */
{
GstBufferMapInfo mapinfo;
guint32 offset;
if (!gst_buffer_map (self->input_buffer, &mapinfo, GST_MAP_WRITE))
goto error;
memcpy (mapinfo.data + cur_size, startcode, startcode_len);
memcpy (mapinfo.data + cur_size + startcode_len, data, size);
gst_buffer_unmap (self->input_buffer, &mapinfo);
if (!pic->slice_offs) {
offset = 0;
pic->slice_offs = g_array_new (FALSE, FALSE, sizeof (guint32));
g_array_append_val (pic->slice_offs, offset);
}
offset = cur_size + startcode_len + size;
g_array_append_val (pic->slice_offs, offset);
}
return TRUE;
error:
gst_clear_buffer (&new_buf);
return FALSE;
}
/**
* gst_vulkan_decoder_wait:
* @self: a #GstVulkanDecoder
*
* Waits indefinitely for decoding fences to signal, and queries the operation
* result if available.
*
* Returns: whether the wait succeeded in waiting for all the fences to be
* freed.
*/
gboolean
gst_vulkan_decoder_wait (GstVulkanDecoder * self)
{
GstVulkanDecoderPrivate *priv;
gint32 *query = NULL;
GError *error = NULL;
g_return_val_if_fail (GST_IS_VULKAN_DECODER (self), FALSE);
priv = gst_vulkan_decoder_get_instance_private (self);
if (!gst_vulkan_operation_wait (priv->exec))
return FALSE;
if (!gst_vulkan_operation_get_query (priv->exec, (gpointer *) & query,
&error)) {
GST_WARNING_OBJECT (self, "Operation query error: %s", error->message);
g_clear_error (&error);
} else if (query && query[0] != 1) {
GST_WARNING_OBJECT (self, "query result: %d", query[0]);
}
return TRUE;
}
/**
* gst_vulkan_decoder_new_from_queue:
* @queue: a #GstVulkanQueue
* @codec: (type guint): the VkVideoCodecOperationFlagBitsKHR to decode
*
* Creates a #GstVulkanDecoder object if @codec decoding is supported by @queue
*
* Returns: (transfer full) (nullable): the #GstVulkanDecoder object
*/
GstVulkanDecoder *
gst_vulkan_decoder_new_from_queue (GstVulkanQueue * queue, guint codec)
{
GstVulkanPhysicalDevice *device;
GstVulkanDecoder *decoder;
guint flags, expected_flag, supported_video_ops;
const char *extension;
g_return_val_if_fail (GST_IS_VULKAN_QUEUE (queue), NULL);
device = queue->device->physical_device;
expected_flag = VK_QUEUE_VIDEO_DECODE_BIT_KHR;
flags = device->queue_family_props[queue->family].queueFlags;
supported_video_ops = device->queue_family_ops[queue->family].video;
if (device->properties.apiVersion < VK_MAKE_VERSION (1, 3, 275)) {
GST_WARNING_OBJECT (queue,
"Driver API version [%d.%d.%d] doesn't support Video extensions",
VK_VERSION_MAJOR (device->properties.apiVersion),
VK_VERSION_MINOR (device->properties.apiVersion),
VK_VERSION_PATCH (device->properties.apiVersion));
return NULL;
}
switch (codec) {
case VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR:
extension = VK_KHR_VIDEO_DECODE_H264_EXTENSION_NAME;
break;
case VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR:
extension = VK_KHR_VIDEO_DECODE_H265_EXTENSION_NAME;
break;
default:
GST_WARNING_OBJECT (queue, "Unsupported codec %u", codec);
return NULL;
}
if ((flags & expected_flag) != expected_flag) {
GST_WARNING_OBJECT (queue, "Queue doesn't support decoding");
return NULL;
}
if ((supported_video_ops & codec) != codec) {
GST_WARNING_OBJECT (queue, "Queue doesn't support codec %u decoding",
codec);
return NULL;
}
if (!(gst_vulkan_device_is_extension_enabled (queue->device,
VK_KHR_VIDEO_QUEUE_EXTENSION_NAME)
&& gst_vulkan_device_is_extension_enabled (queue->device,
VK_KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME)
&& gst_vulkan_device_is_extension_enabled (queue->device, extension)))
return NULL;
decoder = g_object_new (GST_TYPE_VULKAN_DECODER, NULL);
gst_object_ref_sink (decoder);
decoder->queue = gst_object_ref (queue);
decoder->codec = codec;
return decoder;
}
Reference in a new issue View git blame Copy permalink