21 #include "config_components.h"
23 #if CONFIG_H264_VULKAN_HWACCEL
26 #if CONFIG_HEVC_VULKAN_HWACCEL
29 #if CONFIG_AV1_VULKAN_HWACCEL
33 static const VkExtensionProperties *
dec_ext[] = {
34 #if CONFIG_H264_VULKAN_HWACCEL
37 #if CONFIG_HEVC_VULKAN_HWACCEL
40 #if CONFIG_AV1_VULKAN_HWACCEL
47 const VkVideoProfileListInfoKHR *profile_list;
49 VkStructureType profile_struct_type =
56 VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR);
60 for (
int i = 0;
i < profile_list->profileCount;
i++)
62 return &profile_list->pProfiles[
i];
86 VK_QUERY_TYPE_RESULT_STATUS_ONLY_KHR, 0,
125 VkSamplerYcbcrConversionInfo yuv_sampler_info = {
126 .sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO,
127 .conversion =
ctx->yuv_sampler,
129 VkImageViewCreateInfo img_view_create_info = {
130 .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
131 .pNext = &yuv_sampler_info,
132 .viewType = VK_IMAGE_VIEW_TYPE_2D,
134 .image =
src->img[0],
135 .components = (VkComponentMapping) {
136 .r = VK_COMPONENT_SWIZZLE_IDENTITY,
137 .g = VK_COMPONENT_SWIZZLE_IDENTITY,
138 .b = VK_COMPONENT_SWIZZLE_IDENTITY,
139 .a = VK_COMPONENT_SWIZZLE_IDENTITY,
141 .subresourceRange = (VkImageSubresourceRange) {
142 .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
144 .layerCount = VK_REMAINING_ARRAY_LAYERS,
149 ret = vk->CreateImageView(
ctx->s.hwctx->act_dev, &img_view_create_info,
150 ctx->s.hwctx->alloc, dst_view);
151 if (
ret != VK_SUCCESS)
154 *aspect = aspect_mask;
199 }
else if (alloc_dpb) {
210 dpb_hwfc->format[0]);
217 if (!alloc_dpb || is_current) {
238 const uint8_t *
data,
size_t size,
int add_startcode,
239 uint32_t *nb_slices,
const uint32_t **
offsets)
244 static const uint8_t startcode_prefix[3] = { 0x0, 0x0, 0x1 };
245 const size_t startcode_len = add_startcode ?
sizeof(startcode_prefix) : 0;
246 const int nb = *nb_slices;
251 size_t new_size = vp->slices_size + startcode_len +
size +
252 ctx->caps.minBitstreamBufferSizeAlignment;
253 new_size =
FFALIGN(new_size,
ctx->caps.minBitstreamBufferSizeAlignment);
256 (nb + 1)*
sizeof(slice_off));
260 *
offsets = dec->slice_off = slice_off;
261 slice_off[nb] = vp->slices_size;
264 if (!vkbuf || vkbuf->
buf.
size < new_size) {
269 VK_BUFFER_USAGE_VIDEO_DECODE_SRC_BIT_KHR,
270 ctx->s.hwfc->create_pnext, new_size);
278 memcpy(new_buf->
mem, vkbuf->
mem, vp->slices_size);
282 vp->slices_buf = new_ref;
288 memcpy(slices + vp->slices_size, startcode_prefix, startcode_len);
291 memcpy(slices + vp->slices_size + startcode_len,
data,
size);
294 vp->slices_size += startcode_len +
size;
305 VkVideoBeginCodingInfoKHR decode_start = {
306 .sType = VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR,
307 .videoSession =
ctx->common.session,
308 .videoSessionParameters =
ctx->empty_session_params,
310 VkVideoCodingControlInfoKHR decode_ctrl = {
311 .sType = VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR,
312 .
flags = VK_VIDEO_CODING_CONTROL_RESET_BIT_KHR,
315 .sType = VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR,
318 VkCommandBuffer cmd_buf;
323 vk->CmdBeginVideoCodingKHR(cmd_buf, &decode_start);
324 vk->CmdControlVideoCodingKHR(cmd_buf, &decode_ctrl);
325 vk->CmdEndVideoCodingKHR(cmd_buf, &
decode_end);
335 VkCommandBuffer cmd_buf;
348 VkVideoSessionParametersKHR *par = (VkVideoSessionParametersKHR *)dec->
session_params->
data;
349 VkVideoBeginCodingInfoKHR decode_start = {
350 .sType = VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR,
351 .videoSession =
ctx->common.session,
352 .videoSessionParameters = *par,
353 .referenceSlotCount = vp->
decode_info.referenceSlotCount,
354 .pReferenceSlots = vp->
decode_info.pReferenceSlots,
357 .sType = VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR,
360 VkImageMemoryBarrier2 img_bar[37];
362 size_t data_size =
FFALIGN(vp->slices_size,
363 ctx->caps.minBitstreamBufferSizeAlignment);
368 VkVideoReferenceSlotInfoKHR *cur_vk_ref;
369 cur_vk_ref = (
void *)&decode_start.pReferenceSlots[decode_start.referenceSlotCount];
370 cur_vk_ref[0] = vp->ref_slot;
371 cur_vk_ref[0].slotIndex = -1;
372 decode_start.referenceSlotCount++;
374 if (dec->exec_pool.nb_queries) {
375 int64_t prev_sub_res = 0;
378 if (
ret != VK_NOT_READY &&
ret != VK_SUCCESS) {
384 if (
ret == VK_SUCCESS)
386 "Result of previous frame decoding: %"PRId64
"\n", prev_sub_res);
392 if (!(sd_buf->buf.flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)) {
393 VkMappedMemoryRange flush_buf = {
394 .sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE,
395 .memory = sd_buf->buf.mem,
397 .size =
FFALIGN(vp->slices_size,
398 ctx->s.props.properties.limits.nonCoherentAtomSize),
401 ret = vk->FlushMappedMemoryRanges(
ctx->s.hwctx->act_dev, 1, &flush_buf);
402 if (
ret != VK_SUCCESS) {
409 vp->decode_info.srcBuffer = sd_buf->buf.buf;
410 vp->decode_info.srcBufferOffset = 0;
411 vp->decode_info.srcBufferRange = data_size;
423 vp->slices_buf =
NULL;
431 VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR,
432 VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR);
442 img_bar[nb_img_bar] = (VkImageMemoryBarrier2) {
443 .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2,
445 .srcStageMask = VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR,
446 .dstStageMask = VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR,
447 .srcAccessMask = VK_ACCESS_2_NONE,
448 .dstAccessMask = VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR,
449 .oldLayout = vkf->layout[0],
450 .newLayout = vp->dpb_frame ? VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR :
451 VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR,
452 .srcQueueFamilyIndex = vkf->queue_family[0],
453 .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
454 .image = vkf->img[0],
455 .subresourceRange = (VkImageSubresourceRange) {
456 .aspectMask = vp->img_aspect,
462 &img_bar[nb_img_bar], &nb_img_bar);
467 VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR,
468 VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR);
476 for (
int i = 0;
i < vp->decode_info.referenceSlotCount;
i++) {
482 VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR,
483 VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR);
498 img_bar[nb_img_bar] = (VkImageMemoryBarrier2) {
499 .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2,
501 .srcStageMask = VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR,
502 .dstStageMask = VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR,
503 .srcAccessMask = VK_ACCESS_2_NONE,
504 .dstAccessMask = VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR |
505 VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR,
506 .oldLayout = rvkf->
layout[0],
507 .newLayout = VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR,
509 .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
510 .image = rvkf->
img[0],
511 .subresourceRange = (VkImageSubresourceRange) {
518 &img_bar[nb_img_bar], &nb_img_bar);
521 }
else if (vp->decode_info.referenceSlotCount ||
522 vp->img_view_out != vp->img_view_ref) {
525 VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR,
526 VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR);
532 vk->CmdPipelineBarrier2(cmd_buf, &(VkDependencyInfo) {
533 .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
534 .dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT,
535 .pImageMemoryBarriers = img_bar,
536 .imageMemoryBarrierCount = nb_img_bar,
540 vk->CmdBeginVideoCodingKHR(cmd_buf, &decode_start);
543 if (dec->exec_pool.nb_queries)
544 vk->CmdBeginQuery(cmd_buf, dec->exec_pool.query_pool, exec->
query_idx + 0, 0);
546 vk->CmdDecodeVideoKHR(cmd_buf, &vp->decode_info);
549 if (dec->exec_pool.nb_queries)
550 vk->CmdEndQuery(cmd_buf, dec->exec_pool.query_pool, exec->
query_idx + 0);
552 vk->CmdEndVideoCodingKHR(cmd_buf, &
decode_end);
562 VkSemaphoreWaitInfo
sem_wait = (VkSemaphoreWaitInfo) {
563 .sType = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO,
564 .pSemaphores = &vp->
sem,
596 if (
ctx->layered_view)
597 vk->DestroyImageView(
s->hwctx->act_dev,
ctx->layered_view,
s->hwctx->alloc);
604 if (
ctx->empty_session_params)
605 vk->DestroyVideoSessionParametersKHR(
s->hwctx->act_dev,
606 ctx->empty_session_params,
611 if (
ctx->yuv_sampler)
612 vk->DestroySamplerYcbcrConversion(
s->hwctx->act_dev,
ctx->yuv_sampler,
650 VK_KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME);
669 VkVideoDecodeH264CapabilitiesKHR *h264_caps,
670 VkVideoDecodeH265CapabilitiesKHR *h265_caps,
672 VkVideoCapabilitiesKHR *caps,
673 VkVideoDecodeCapabilitiesKHR *dec_caps,
676 VkVideoDecodeUsageInfoKHR *
usage = &prof->
usage;
678 VkVideoProfileListInfoKHR *profile_list = &prof->
profile_list;
680 VkVideoDecodeH264ProfileInfoKHR *h264_profile = &prof->
h264_profile;
681 VkVideoDecodeH265ProfileInfoKHR *h265_profile = &prof->
h265_profile;
689 dec_caps->pNext = h264_caps;
690 usage->pNext = h264_profile;
691 h264_profile->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR;
700 VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHR :
701 VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_KHR;
703 dec_caps->pNext = h265_caps;
704 usage->pNext = h265_profile;
705 h265_profile->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR;
706 h265_profile->stdProfileIdc = cur_profile;
708 dec_caps->pNext = av1_caps;
709 usage->pNext = av1_profile;
714 usage->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR;
715 usage->videoUsageHints = VK_VIDEO_DECODE_USAGE_DEFAULT_KHR;
717 profile->sType = VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR;
724 profile_list->sType = VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR;
725 profile_list->profileCount = 1;
726 profile_list->pProfiles =
profile;
729 caps->sType = VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR;
730 caps->pNext = dec_caps;
731 dec_caps->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR;
734 return vk->GetPhysicalDeviceVideoCapabilitiesKHR(hwctx->
phys_dev,
profile,
744 int max_level, base_profile, cur_profile;
757 VkVideoCapabilitiesKHR *caps = &
ctx->caps;
758 VkVideoDecodeCapabilitiesKHR *dec_caps = &
ctx->dec_caps;
760 VkVideoDecodeH264CapabilitiesKHR h264_caps = {
761 .sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR,
763 VkVideoDecodeH265CapabilitiesKHR h265_caps = {
764 .sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR,
770 VkPhysicalDeviceVideoFormatInfoKHR fmt_info = {
771 .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR,
772 .pNext = &prof->profile_list,
774 VkVideoFormatPropertiesKHR *ret_info;
775 uint32_t nb_out_fmts = 0;
777 if (!vk_codec->decode_op || !vk_codec->decode_extension) {
781 }
else if (!(vk_codec->decode_extension &
ctx->s.extensions)) {
787 cur_profile = avctx->profile;
800 if (
ret == VK_ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR &&
802 avctx->profile != base_profile) {
804 "again with profile %s\n",
808 cur_profile = base_profile;
818 if (
ret == VK_ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR) {
820 "%s profile \"%s\" not supported!\n",
824 }
else if (
ret == VK_ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR) {
826 "format (%s) not supported!\n",
829 }
else if (
ret == VK_ERROR_FEATURE_NOT_PRESENT ||
830 ret == VK_ERROR_FORMAT_NOT_SUPPORTED) {
832 }
else if (
ret != VK_SUCCESS) {
845 max_level, avctx->level);
847 caps->minCodedExtent.width, caps->maxCodedExtent.width);
849 caps->minCodedExtent.height, caps->maxCodedExtent.height);
851 caps->pictureAccessGranularity.width);
853 caps->pictureAccessGranularity.height);
855 caps->minBitstreamBufferOffsetAlignment);
857 caps->minBitstreamBufferSizeAlignment);
861 caps->maxActiveReferencePictures);
863 caps->stdHeaderVersion.extensionName,
864 dec_ext[avctx->codec_id]->extensionName);
865 av_log(avctx,
AV_LOG_VERBOSE,
" Codec header version: %i.%i.%i (driver), %i.%i.%i (compiled)\n",
866 CODEC_VER(caps->stdHeaderVersion.specVersion),
869 dec_caps->flags ?
"" :
871 dec_caps->flags & VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR ?
872 " reuse_dst_dpb" :
"",
873 dec_caps->flags & VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR ?
874 " dedicated_dpb" :
"");
878 caps->flags & VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR ?
880 caps->flags & VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR ?
881 " separate_references" :
"");
884 if (avctx->width < caps->minCodedExtent.width ||
885 avctx->height < caps->minCodedExtent.height ||
886 avctx->width > caps->maxCodedExtent.width ||
887 avctx->height > caps->maxCodedExtent.height)
891 avctx->level > max_level)
895 if (!(dec_caps->flags & (VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR |
896 VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR))) {
898 "VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR nor "
899 "VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR are set!\n");
901 }
else if ((dec_caps->flags & (VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR |
902 VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR) ==
903 VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR) &&
904 !(caps->flags & VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR)) {
905 av_log(avctx,
AV_LOG_ERROR,
"Cannot initialize Vulkan decoding session, buggy driver: "
906 "VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR set "
907 "but VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR is unset!\n");
909 }
else if (!(dec_caps->flags & VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR) &&
911 av_log(avctx,
AV_LOG_ERROR,
"Cannot initialize Vulkan decoding session, buggy driver: "
912 "codec is AV1, but VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR isn't set!\n");
917 dec->dedicated_dpb = !(dec_caps->flags & VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR);
918 dec->layered_dpb = !(caps->flags & VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR);
921 if (dec->dedicated_dpb) {
922 fmt_info.imageUsage = VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR;
924 fmt_info.imageUsage = VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR |
925 VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR |
926 VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
927 VK_IMAGE_USAGE_SAMPLED_BIT;
931 ret = vk->GetPhysicalDeviceVideoFormatPropertiesKHR(hwctx->phys_dev,
934 if (
ret == VK_ERROR_FORMAT_NOT_SUPPORTED ||
935 (!nb_out_fmts &&
ret == VK_SUCCESS)) {
937 }
else if (
ret != VK_SUCCESS) {
943 ret_info =
av_mallocz(
sizeof(*ret_info)*nb_out_fmts);
947 for (
int i = 0;
i < nb_out_fmts;
i++)
948 ret_info[
i].sType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR;
950 ret = vk->GetPhysicalDeviceVideoFormatPropertiesKHR(hwctx->phys_dev,
952 &nb_out_fmts, ret_info);
953 if (
ret == VK_ERROR_FORMAT_NOT_SUPPORTED ||
954 (!nb_out_fmts &&
ret == VK_SUCCESS)) {
957 }
else if (
ret != VK_SUCCESS) {
966 *vk_fmt = best_vkfmt = VK_FORMAT_UNDEFINED;
967 source_format = avctx->sw_pix_fmt;
969 av_log(avctx,
AV_LOG_DEBUG,
"Choosing best pixel format for decoding from %i:\n", nb_out_fmts);
970 for (
int i = 0;
i < nb_out_fmts;
i++) {
978 if (
tmp == best_format)
979 best_vkfmt = ret_info[
i].format;
989 av_log(avctx,
AV_LOG_ERROR,
"No valid/compatible pixel format found for decoding!\n");
997 *vk_fmt = best_vkfmt;
999 *dpb_dedicate = dec->dedicated_dpb;
1012 int err, dedicated_dpb;
1030 prof, &dedicated_dpb);
1043 hwfc->format[0] = vkfmt;
1044 hwfc->create_pnext = &prof->profile_list;
1045 hwfc->tiling = VK_IMAGE_TILING_OPTIMAL;
1046 hwfc->usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
1047 VK_IMAGE_USAGE_SAMPLED_BIT |
1048 VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR;
1050 if (!dec->dedicated_dpb)
1051 hwfc->usage |= VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR;
1060 VkVideoSessionParametersKHR *par = (VkVideoSessionParametersKHR *)
data;
1061 vk->DestroyVideoSessionParametersKHR(
ctx->s.hwctx->act_dev, *par,
1062 ctx->s.hwctx->alloc);
1067 const VkVideoSessionParametersCreateInfoKHR *session_params_create)
1069 VkVideoSessionParametersKHR *par =
av_malloc(
sizeof(*par));
1077 ret = vk->CreateVideoSessionParametersKHR(
ctx->s.hwctx->act_dev, session_params_create,
1078 ctx->s.hwctx->alloc, par);
1079 if (
ret != VK_SUCCESS) {
1080 av_log(logctx,
AV_LOG_ERROR,
"Unable to create Vulkan video session parameters: %s!\n",
1112 int err, qf, cxpos = 0, cypos = 0, nb_q = 0;
1118 const VkVideoProfileInfoKHR *
profile;
1120 VkVideoDecodeH264SessionParametersCreateInfoKHR h264_params = {
1121 .sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR,
1123 VkVideoDecodeH265SessionParametersCreateInfoKHR h265_params = {
1124 .sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR,
1129 VkVideoSessionParametersCreateInfoKHR session_params_create = {
1130 .sType = VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR,
1136 VkVideoSessionCreateInfoKHR session_create = {
1137 .sType = VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR,
1139 VkSamplerYcbcrConversionCreateInfo yuv_sampler_info = {
1140 .sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO,
1142 .ycbcrModel = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY,
1157 s->hwfc =
s->frames->hwctx;
1160 s->hwctx =
s->device->hwctx;
1176 if (!(
s->video_props[qf].videoCodecOperations &
1184 if (
s->query_props[qf].queryResultStatusSupport)
1187 session_create.flags = 0x0;
1188 session_create.queueFamilyIndex =
s->hwctx->queue_family_decode_index;
1189 session_create.maxCodedExtent =
ctx->caps.maxCodedExtent;
1190 session_create.maxDpbSlots =
ctx->caps.maxDpbSlots;
1191 session_create.maxActiveReferencePictures =
ctx->caps.maxActiveReferencePictures;
1192 session_create.pictureFormat =
s->hwfc->format[0];
1193 session_create.referencePictureFormat = session_create.pictureFormat;
1195 session_create.pVideoProfile =
profile;
1201 nb_q, VK_QUERY_TYPE_RESULT_STATUS_ONLY_KHR, 0,
1212 yuv_sampler_info.xChromaOffset = cxpos >> 7;
1213 yuv_sampler_info.yChromaOffset = cypos >> 7;
1214 yuv_sampler_info.format =
s->hwfc->format[0];
1215 ret = vk->CreateSamplerYcbcrConversion(
s->hwctx->act_dev, &yuv_sampler_info,
1216 s->hwctx->alloc, &
ctx->yuv_sampler);
1217 if (
ret != VK_SUCCESS) {
1228 if (!
ctx->dpb_hwfc_ref) {
1241 VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR);
1242 dpb_hwfc->
format[0] =
s->hwfc->format[0];
1243 dpb_hwfc->
tiling = VK_IMAGE_TILING_OPTIMAL;
1244 dpb_hwfc->
usage = VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR |
1245 VK_IMAGE_USAGE_SAMPLED_BIT;
1256 if (!
ctx->layered_frame) {
1263 s->hwfc->format[0]);
1269 session_params_create.videoSession =
ctx->common.session;
1270 ret = vk->CreateVideoSessionParametersKHR(
s->hwctx->act_dev, &session_params_create,
1271 s->hwctx->alloc, &
ctx->empty_session_params);
1272 if (
ret != VK_SUCCESS) {
1273 av_log(avctx,
AV_LOG_ERROR,
"Unable to create empty Vulkan video session parameters: %s!\n",