22 #include "config_components.h"
27 #define DECODER_IS_SDR(codec_id) \
28 ((codec_id) == AV_CODEC_ID_FFV1)
30 #if CONFIG_H264_VULKAN_HWACCEL
33 #if CONFIG_HEVC_VULKAN_HWACCEL
36 #if CONFIG_AV1_VULKAN_HWACCEL
39 #if CONFIG_FFV1_VULKAN_HWACCEL
44 #if CONFIG_H264_VULKAN_HWACCEL
47 #if CONFIG_HEVC_VULKAN_HWACCEL
50 #if CONFIG_AV1_VULKAN_HWACCEL
53 #if CONFIG_FFV1_VULKAN_HWACCEL
69 const VkVideoProfileListInfoKHR *profile_list;
71 VkStructureType profile_struct_type =
75 VK_STRUCTURE_TYPE_MAX_ENUM;
76 if (profile_struct_type == VK_STRUCTURE_TYPE_MAX_ENUM)
80 VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR);
84 for (
int i = 0;
i < profile_list->profileCount;
i++)
86 return &profile_list->pProfiles[
i];
138 vkpic->
view.
ref[
i] = VK_NULL_HANDLE;
139 vkpic->
view.
out[
i] = VK_NULL_HANDLE;
140 vkpic->
view.
dst[
i] = VK_NULL_HANDLE;
163 if (
ctx->common.layered_dpb && alloc_dpb) {
164 vkpic->
view.
ref[0] =
ctx->common.layered_view;
166 }
else if (alloc_dpb) {
177 dpb_hwfc->format[0], !is_current);
184 if (!alloc_dpb || is_current) {
191 hwfc->format[0], !is_current);
234 if (!alloc_dpb || is_current) {
252 const uint8_t *
data,
size_t size,
int add_startcode,
253 uint32_t *nb_slices,
const uint32_t **
offsets)
258 static const uint8_t startcode_prefix[3] = { 0x0, 0x0, 0x1 };
259 const size_t startcode_len = add_startcode ?
sizeof(startcode_prefix) : 0;
260 const int nb = nb_slices ? *nb_slices : 0;
266 ctx->caps.minBitstreamBufferSizeAlignment;
267 new_size =
FFALIGN(new_size,
ctx->caps.minBitstreamBufferSizeAlignment);
271 (nb + 1)*
sizeof(slice_off));
281 if (!vkbuf || vkbuf->
size < new_size) {
287 size_t buf_size =
FFMAX(new_size, 1024*1024);
291 buf_size = 2 <<
av_log2(buf_size);
295 (VK_BUFFER_USAGE_STORAGE_BUFFER_BIT |
296 VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT) :
297 VK_BUFFER_USAGE_VIDEO_DECODE_SRC_BIT_KHR,
298 ctx->s.hwfc->create_pnext, buf_size,
299 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
301 VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT : 0x0));
319 memcpy(slices + vp->
slices_size, startcode_prefix, startcode_len);
338 VkVideoBeginCodingInfoKHR decode_start = {
339 .sType = VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR,
340 .videoSession =
ctx->common.session,
341 .videoSessionParameters =
ctx->empty_session_params,
343 VkVideoCodingControlInfoKHR decode_ctrl = {
344 .sType = VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR,
345 .
flags = VK_VIDEO_CODING_CONTROL_RESET_BIT_KHR,
348 .sType = VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR,
351 VkCommandBuffer cmd_buf;
362 vk->CmdBeginVideoCodingKHR(cmd_buf, &decode_start);
363 vk->CmdControlVideoCodingKHR(cmd_buf, &decode_ctrl);
364 vk->CmdEndVideoCodingKHR(cmd_buf, &
decode_end);
374 VkCommandBuffer cmd_buf;
385 const int layered_dpb =
ctx->common.layered_dpb;
387 VkVideoBeginCodingInfoKHR decode_start = {
388 .sType = VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR,
389 .videoSession =
ctx->common.session,
393 .referenceSlotCount = vp->
decode_info.referenceSlotCount,
394 .pReferenceSlots = vp->
decode_info.pReferenceSlots,
397 .sType = VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR,
400 VkImageMemoryBarrier2 img_bar[37];
402 size_t data_size =
FFALIGN(vp->slices_size,
403 ctx->caps.minBitstreamBufferSizeAlignment);
408 VkVideoReferenceSlotInfoKHR *cur_vk_ref;
409 cur_vk_ref = (
void *)&decode_start.pReferenceSlots[decode_start.referenceSlotCount];
410 cur_vk_ref[0] = vp->ref_slot;
411 cur_vk_ref[0].slotIndex = -1;
412 decode_start.referenceSlotCount++;
417 if (!(sd_buf->flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)) {
418 VkMappedMemoryRange flush_buf = {
419 .sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE,
420 .memory = sd_buf->mem,
422 .size =
FFALIGN(vp->slices_size,
423 ctx->s.props.properties.limits.nonCoherentAtomSize),
426 ret = vk->FlushMappedMemoryRanges(
ctx->s.hwctx->act_dev, 1, &flush_buf);
427 if (
ret != VK_SUCCESS) {
434 vp->decode_info.srcBuffer = sd_buf->buf;
435 vp->decode_info.srcBufferOffset = 0;
436 vp->decode_info.srcBufferRange = data_size;
448 vp->slices_buf =
NULL;
456 VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR,
457 VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR);
467 img_bar[nb_img_bar] = (VkImageMemoryBarrier2) {
468 .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2,
470 .srcStageMask = VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR,
471 .dstStageMask = VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR,
472 .srcAccessMask = VK_ACCESS_2_NONE,
473 .dstAccessMask = VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR,
474 .oldLayout = vkf->layout[0],
475 .newLayout = (layered_dpb || vp->dpb_frame) ?
476 VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR :
477 VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR,
478 .srcQueueFamilyIndex = vkf->queue_family[0],
479 .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
480 .image = vkf->img[0],
481 .subresourceRange = (VkImageSubresourceRange) {
482 .aspectMask = vp->view.aspect[0],
488 &img_bar[nb_img_bar], &nb_img_bar);
493 VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR,
494 VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR);
502 for (
int i = 0;
i < vp->decode_info.referenceSlotCount;
i++) {
508 VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR,
509 VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR);
524 img_bar[nb_img_bar] = (VkImageMemoryBarrier2) {
525 .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2,
527 .srcStageMask = VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR,
528 .dstStageMask = VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR,
529 .srcAccessMask = VK_ACCESS_2_NONE,
530 .dstAccessMask = VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR |
531 VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR,
532 .oldLayout = rvkf->
layout[0],
533 .newLayout = VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR,
535 .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
536 .image = rvkf->
img[0],
537 .subresourceRange = (VkImageSubresourceRange) {
544 &img_bar[nb_img_bar], &nb_img_bar);
547 }
else if (vp->decode_info.referenceSlotCount ||
548 vp->view.out[0] != vp->view.ref[0]) {
551 VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR,
552 VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR);
558 vk->CmdPipelineBarrier2(cmd_buf, &(VkDependencyInfo) {
559 .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
560 .dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT,
561 .pImageMemoryBarriers = img_bar,
562 .imageMemoryBarrierCount = nb_img_bar,
566 vk->CmdBeginVideoCodingKHR(cmd_buf, &decode_start);
567 vk->CmdDecodeVideoKHR(cmd_buf, &vp->decode_info);
568 vk->CmdEndVideoCodingKHR(cmd_buf, &
decode_end);
578 VkSemaphoreWaitInfo
sem_wait = (VkSemaphoreWaitInfo) {
579 .sType = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO,
580 .pSemaphores = &vp->
sem,
620 if (
ctx->empty_session_params)
621 vk->DestroyVideoSessionParametersKHR(
s->hwctx->act_dev,
622 ctx->empty_session_params,
629 if (
ctx->sd_ctx_free)
658 if (vk_desc->
queue_flags & VK_QUEUE_VIDEO_DECODE_BIT_KHR) {
661 VK_KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME);
681 VkVideoDecodeH264CapabilitiesKHR *h264_caps,
682 VkVideoDecodeH265CapabilitiesKHR *h265_caps,
683 VkVideoDecodeAV1CapabilitiesKHR *av1_caps,
684 VkVideoCapabilitiesKHR *caps,
685 VkVideoDecodeCapabilitiesKHR *dec_caps,
688 VkVideoDecodeUsageInfoKHR *
usage = &prof->
usage;
690 VkVideoProfileListInfoKHR *profile_list = &prof->
profile_list;
692 VkVideoDecodeH264ProfileInfoKHR *h264_profile = &prof->
h264_profile;
693 VkVideoDecodeH265ProfileInfoKHR *h265_profile = &prof->
h265_profile;
694 VkVideoDecodeAV1ProfileInfoKHR *av1_profile = &prof->
av1_profile;
701 dec_caps->pNext = h264_caps;
702 usage->pNext = h264_profile;
703 h264_profile->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR;
712 VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHR :
713 VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_KHR;
715 dec_caps->pNext = h265_caps;
716 usage->pNext = h265_profile;
717 h265_profile->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR;
718 h265_profile->stdProfileIdc = cur_profile;
720 dec_caps->pNext = av1_caps;
721 usage->pNext = av1_profile;
722 av1_profile->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR;
723 av1_profile->stdProfile = cur_profile;
727 usage->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR;
728 usage->videoUsageHints = VK_VIDEO_DECODE_USAGE_DEFAULT_KHR;
730 profile->sType = VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR;
737 profile_list->sType = VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR;
738 profile_list->profileCount = 1;
739 profile_list->pProfiles =
profile;
742 caps->sType = VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR;
743 caps->pNext = dec_caps;
744 dec_caps->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR;
747 return vk->GetPhysicalDeviceVideoCapabilitiesKHR(hwctx->
phys_dev,
profile,
757 int max_level, base_profile, cur_profile;
770 VkVideoCapabilitiesKHR *caps = &
ctx->caps;
771 VkVideoDecodeCapabilitiesKHR *dec_caps = &
ctx->dec_caps;
773 VkVideoDecodeH264CapabilitiesKHR h264_caps = {
774 .sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR,
776 VkVideoDecodeH265CapabilitiesKHR h265_caps = {
777 .sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR,
779 VkVideoDecodeAV1CapabilitiesKHR av1_caps = {
780 .sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR,
783 VkPhysicalDeviceVideoFormatInfoKHR fmt_info = {
784 .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR,
787 VkVideoFormatPropertiesKHR *ret_info;
788 uint32_t nb_out_fmts = 0;
809 if (
ret == VK_ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR &&
811 avctx->
profile != base_profile) {
813 "again with profile %s\n",
817 cur_profile = base_profile;
827 if (
ret == VK_ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR) {
829 "%s profile \"%s\" not supported!\n",
833 }
else if (
ret == VK_ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR) {
835 "format (%s) not supported!\n",
838 }
else if (
ret == VK_ERROR_FEATURE_NOT_PRESENT ||
839 ret == VK_ERROR_FORMAT_NOT_SUPPORTED) {
841 }
else if (
ret != VK_SUCCESS) {
854 max_level, avctx->
level);
856 caps->minCodedExtent.width, caps->maxCodedExtent.width);
858 caps->minCodedExtent.height, caps->maxCodedExtent.height);
860 caps->pictureAccessGranularity.width);
862 caps->pictureAccessGranularity.height);
864 caps->minBitstreamBufferOffsetAlignment);
866 caps->minBitstreamBufferSizeAlignment);
870 caps->maxActiveReferencePictures);
872 caps->stdHeaderVersion.extensionName,
874 av_log(avctx,
AV_LOG_VERBOSE,
" Codec header version: %i.%i.%i (driver), %i.%i.%i (compiled)\n",
875 CODEC_VER(caps->stdHeaderVersion.specVersion),
878 dec_caps->flags ?
"" :
880 dec_caps->flags & VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR ?
881 " reuse_dst_dpb" :
"",
882 dec_caps->flags & VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR ?
883 " dedicated_dpb" :
"");
887 caps->flags & VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR ?
889 caps->flags & VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR ?
890 " separate_references" :
"");
893 if (avctx->
coded_width < caps->minCodedExtent.width ||
900 avctx->
level > max_level)
904 if (!(dec_caps->flags & (VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR |
905 VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR))) {
907 "VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR nor "
908 "VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR are set!\n");
910 }
else if ((dec_caps->flags & (VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR |
911 VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR) ==
912 VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR) &&
913 !(caps->flags & VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR)) {
914 av_log(avctx,
AV_LOG_ERROR,
"Cannot initialize Vulkan decoding session, buggy driver: "
915 "VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR set "
916 "but VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR is unset!\n");
920 dec->
dedicated_dpb = !(dec_caps->flags & VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR);
922 !(caps->flags & VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR);
925 fmt_info.imageUsage = VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR;
927 fmt_info.imageUsage = VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR |
928 VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR |
929 VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
930 VK_IMAGE_USAGE_SAMPLED_BIT;
934 fmt_info.imageUsage |= VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR;
938 ret = vk->GetPhysicalDeviceVideoFormatPropertiesKHR(hwctx->
phys_dev,
941 if (
ret == VK_ERROR_FORMAT_NOT_SUPPORTED ||
942 (!nb_out_fmts &&
ret == VK_SUCCESS)) {
944 }
else if (
ret != VK_SUCCESS) {
950 ret_info =
av_mallocz(
sizeof(*ret_info)*nb_out_fmts);
954 for (
int i = 0;
i < nb_out_fmts;
i++)
955 ret_info[
i].sType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR;
957 ret = vk->GetPhysicalDeviceVideoFormatPropertiesKHR(hwctx->
phys_dev,
959 &nb_out_fmts, ret_info);
960 if (
ret == VK_ERROR_FORMAT_NOT_SUPPORTED ||
961 (!nb_out_fmts &&
ret == VK_SUCCESS)) {
964 }
else if (
ret != VK_SUCCESS) {
973 *vk_fmt = best_vkfmt = VK_FORMAT_UNDEFINED;
976 av_log(avctx,
AV_LOG_DEBUG,
"Choosing best pixel format for decoding from %i:\n", nb_out_fmts);
977 for (
int i = 0;
i < nb_out_fmts;
i++) {
985 if (
tmp == best_format)
986 best_vkfmt = ret_info[
i].format;
996 av_log(avctx,
AV_LOG_ERROR,
"No valid/compatible pixel format found for decoding!\n");
1004 *vk_fmt = best_vkfmt;
1018 VkFormat vkfmt = VK_FORMAT_UNDEFINED;
1019 int err, dedicated_dpb;
1038 prof, &dedicated_dpb);
1047 hwfc->create_pnext = &prof->profile_list;
1071 hwfc->format[0] = vkfmt;
1072 hwfc->tiling = VK_IMAGE_TILING_OPTIMAL;
1073 hwfc->usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
1074 VK_IMAGE_USAGE_SAMPLED_BIT;
1079 hwfc->usage |= VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR;
1080 if (!dec->dedicated_dpb)
1081 hwfc->usage |= VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR;
1083 ctx = dec->shared_ctx;
1086 hwfc->usage |= VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR;
1088 hwfc->usage |= VK_IMAGE_USAGE_STORAGE_BIT;
1098 VkVideoSessionParametersKHR *par = (VkVideoSessionParametersKHR *)
data;
1099 vk->DestroyVideoSessionParametersKHR(
ctx->s.hwctx->act_dev, *par,
1100 ctx->s.hwctx->alloc);
1105 const VkVideoSessionParametersCreateInfoKHR *session_params_create)
1107 VkVideoSessionParametersKHR *par =
av_malloc(
sizeof(*par));
1115 ret = vk->CreateVideoSessionParametersKHR(
ctx->s.hwctx->act_dev, session_params_create,
1116 ctx->s.hwctx->alloc, par);
1117 if (
ret != VK_SUCCESS) {
1118 av_log(logctx,
AV_LOG_ERROR,
"Unable to create Vulkan video session parameters: %s!\n",
1151 VkVideoDecodeH264SessionParametersCreateInfoKHR h264_params = {
1152 .sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR,
1154 VkVideoDecodeH265SessionParametersCreateInfoKHR h265_params = {
1155 .sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR,
1157 StdVideoAV1SequenceHeader av1_empty_seq = { 0 };
1158 VkVideoDecodeAV1SessionParametersCreateInfoKHR av1_params = {
1159 .sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR,
1160 .pStdSequenceHeader = &av1_empty_seq,
1162 VkVideoSessionParametersCreateInfoKHR session_params_create = {
1163 .sType = VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR,
1168 .videoSession =
ctx->common.session,
1171 ret = vk->CreateVideoSessionParametersKHR(
s->hwctx->act_dev, &session_params_create,
1172 s->hwctx->alloc, &
ctx->empty_session_params);
1173 if (
ret != VK_SUCCESS) {
1174 av_log(avctx,
AV_LOG_ERROR,
"Unable to create empty Vulkan video session parameters: %s!\n",
1189 const VkVideoProfileInfoKHR *
profile;
1191 const VkPhysicalDeviceDriverProperties *driver_props;
1193 VkVideoSessionCreateInfoKHR session_create = {
1194 .sType = VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR,
1226 session_create.queueFamilyIndex =
ctx->qf->idx;
1227 session_create.maxCodedExtent =
ctx->caps.maxCodedExtent;
1228 session_create.maxDpbSlots =
ctx->caps.maxDpbSlots;
1229 session_create.maxActiveReferencePictures =
ctx->caps.maxActiveReferencePictures;
1230 session_create.pictureFormat =
s->hwfc->format[0];
1231 session_create.referencePictureFormat = session_create.pictureFormat;
1232 session_create.pStdHeaderVersion = &vk_desc->
ext_props;
1233 session_create.pVideoProfile =
profile;
1234 #ifdef VK_KHR_video_maintenance2
1236 session_create.flags = VK_VIDEO_SESSION_CREATE_INLINE_SESSION_PARAMETERS_BIT_KHR;
1242 async_depth = 2*
ctx->qf->num;
1249 async_depth, 0, 0, 0,
profile);
1265 if (!
ctx->common.dpb_hwfc_ref) {
1278 VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR);
1279 dpb_hwfc->
format[0] =
s->hwfc->format[0];
1280 dpb_hwfc->
tiling = VK_IMAGE_TILING_OPTIMAL;
1281 dpb_hwfc->
usage = VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR |
1282 VK_IMAGE_USAGE_SAMPLED_BIT;
1284 if (
ctx->common.layered_dpb)
1291 if (
ctx->common.layered_dpb) {
1293 if (!
ctx->common.layered_frame) {
1299 &
ctx->common.layered_view,
1300 &
ctx->common.layered_aspect,
1302 s->hwfc->format[0], 1);
1321 if (driver_props->driverID == VK_DRIVER_ID_NVIDIA_PROPRIETARY &&
1322 driver_props->conformanceVersion.major == 1 &&
1323 driver_props->conformanceVersion.minor == 3 &&
1324 driver_props->conformanceVersion.subminor == 8 &&
1325 driver_props->conformanceVersion.patch < 3)