22 #include "config_components.h"
27 #if CONFIG_H264_VULKAN_HWACCEL
30 #if CONFIG_HEVC_VULKAN_HWACCEL
33 #if CONFIG_AV1_VULKAN_HWACCEL
38 #if CONFIG_H264_VULKAN_HWACCEL
41 #if CONFIG_HEVC_VULKAN_HWACCEL
44 #if CONFIG_AV1_VULKAN_HWACCEL
60 const VkVideoProfileListInfoKHR *profile_list;
62 VkStructureType profile_struct_type =
69 VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR);
73 for (
int i = 0;
i < profile_list->profileCount;
i++)
75 return &profile_list->pProfiles[
i];
99 VK_QUERY_TYPE_RESULT_STATUS_ONLY_KHR, 0,
137 VkSamplerYcbcrConversionInfo yuv_sampler_info = {
138 .sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO,
139 .conversion =
ctx->yuv_sampler,
141 VkImageViewCreateInfo img_view_create_info = {
142 .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
143 .pNext = &yuv_sampler_info,
145 VK_IMAGE_VIEW_TYPE_2D_ARRAY : VK_IMAGE_VIEW_TYPE_2D,
147 .image =
src->img[0],
148 .components = (VkComponentMapping) {
149 .r = VK_COMPONENT_SWIZZLE_IDENTITY,
150 .g = VK_COMPONENT_SWIZZLE_IDENTITY,
151 .b = VK_COMPONENT_SWIZZLE_IDENTITY,
152 .a = VK_COMPONENT_SWIZZLE_IDENTITY,
154 .subresourceRange = (VkImageSubresourceRange) {
155 .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
158 VK_REMAINING_ARRAY_LAYERS : 1,
163 ret = vk->CreateImageView(
ctx->s.hwctx->act_dev, &img_view_create_info,
164 ctx->s.hwctx->alloc, dst_view);
165 if (
ret != VK_SUCCESS)
168 *aspect = aspect_mask;
213 }
else if (alloc_dpb) {
224 dpb_hwfc->format[0], is_current);
231 if (!alloc_dpb || is_current) {
238 hwfc->format[0], 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;
266 ctx->caps.minBitstreamBufferSizeAlignment;
267 new_size =
FFALIGN(new_size,
ctx->caps.minBitstreamBufferSizeAlignment);
270 (nb + 1)*
sizeof(slice_off));
278 if (!vkbuf || vkbuf->
buf.
size < new_size) {
283 VK_BUFFER_USAGE_VIDEO_DECODE_SRC_BIT_KHR,
284 ctx->s.hwfc->create_pnext, new_size);
302 memcpy(slices + vp->
slices_size, startcode_prefix, startcode_len);
319 VkVideoBeginCodingInfoKHR decode_start = {
320 .sType = VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR,
321 .videoSession =
ctx->common.session,
322 .videoSessionParameters =
ctx->empty_session_params,
324 VkVideoCodingControlInfoKHR decode_ctrl = {
325 .sType = VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR,
326 .
flags = VK_VIDEO_CODING_CONTROL_RESET_BIT_KHR,
329 .sType = VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR,
332 VkCommandBuffer cmd_buf;
337 vk->CmdBeginVideoCodingKHR(cmd_buf, &decode_start);
338 vk->CmdControlVideoCodingKHR(cmd_buf, &decode_ctrl);
339 vk->CmdEndVideoCodingKHR(cmd_buf, &
decode_end);
349 VkCommandBuffer cmd_buf;
362 VkVideoSessionParametersKHR *par = (VkVideoSessionParametersKHR *)dec->
session_params->
data;
363 VkVideoBeginCodingInfoKHR decode_start = {
364 .sType = VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR,
365 .videoSession =
ctx->common.session,
366 .videoSessionParameters = *par,
367 .referenceSlotCount = vp->
decode_info.referenceSlotCount,
368 .pReferenceSlots = vp->
decode_info.pReferenceSlots,
371 .sType = VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR,
374 VkImageMemoryBarrier2 img_bar[37];
377 ctx->caps.minBitstreamBufferSizeAlignment);
382 VkVideoReferenceSlotInfoKHR *cur_vk_ref;
383 cur_vk_ref = (
void *)&decode_start.pReferenceSlots[decode_start.referenceSlotCount];
385 cur_vk_ref[0].slotIndex = -1;
386 decode_start.referenceSlotCount++;
389 int64_t prev_sub_res = 0;
392 if (
ret != VK_NOT_READY &&
ret != VK_SUCCESS) {
398 if (
ret == VK_SUCCESS)
400 "Result of previous frame decoding: %"PRId64
"\n", prev_sub_res);
406 if (!(sd_buf->
buf.
flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)) {
407 VkMappedMemoryRange flush_buf = {
408 .sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE,
409 .memory = sd_buf->
buf.
mem,
412 ctx->s.props.properties.limits.nonCoherentAtomSize),
415 ret = vk->FlushMappedMemoryRanges(
ctx->s.hwctx->act_dev, 1, &flush_buf);
416 if (
ret != VK_SUCCESS) {
445 VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR,
446 VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR);
456 img_bar[nb_img_bar] = (VkImageMemoryBarrier2) {
457 .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2,
459 .srcStageMask = VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR,
460 .dstStageMask = VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR,
461 .srcAccessMask = VK_ACCESS_2_NONE,
462 .dstAccessMask = VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR,
463 .oldLayout = vkf->
layout[0],
465 VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR :
466 VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR,
468 .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
469 .image = vkf->
img[0],
470 .subresourceRange = (VkImageSubresourceRange) {
477 &img_bar[nb_img_bar], &nb_img_bar);
482 VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR,
483 VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR);
497 VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR,
498 VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR);
513 img_bar[nb_img_bar] = (VkImageMemoryBarrier2) {
514 .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2,
516 .srcStageMask = VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR,
517 .dstStageMask = VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR,
518 .srcAccessMask = VK_ACCESS_2_NONE,
519 .dstAccessMask = VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR |
520 VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR,
521 .oldLayout = rvkf->
layout[0],
522 .newLayout = VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR,
524 .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
525 .image = rvkf->
img[0],
526 .subresourceRange = (VkImageSubresourceRange) {
533 &img_bar[nb_img_bar], &nb_img_bar);
540 VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR,
541 VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR);
547 vk->CmdPipelineBarrier2(cmd_buf, &(VkDependencyInfo) {
548 .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
549 .dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT,
550 .pImageMemoryBarriers = img_bar,
551 .imageMemoryBarrierCount = nb_img_bar,
555 vk->CmdBeginVideoCodingKHR(cmd_buf, &decode_start);
567 vk->CmdEndVideoCodingKHR(cmd_buf, &
decode_end);
577 VkSemaphoreWaitInfo
sem_wait = (VkSemaphoreWaitInfo) {
578 .sType = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO,
579 .pSemaphores = &vp->
sem,
611 if (
ctx->layered_view)
612 vk->DestroyImageView(
s->hwctx->act_dev,
ctx->layered_view,
s->hwctx->alloc);
619 if (
ctx->empty_session_params)
620 vk->DestroyVideoSessionParametersKHR(
s->hwctx->act_dev,
621 ctx->empty_session_params,
626 if (
ctx->yuv_sampler)
627 vk->DestroySamplerYcbcrConversion(
s->hwctx->act_dev,
ctx->yuv_sampler,
657 VK_KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME);
676 VkVideoDecodeH264CapabilitiesKHR *h264_caps,
677 VkVideoDecodeH265CapabilitiesKHR *h265_caps,
678 VkVideoDecodeAV1CapabilitiesKHR *av1_caps,
679 VkVideoCapabilitiesKHR *caps,
680 VkVideoDecodeCapabilitiesKHR *dec_caps,
683 VkVideoDecodeUsageInfoKHR *
usage = &prof->
usage;
685 VkVideoProfileListInfoKHR *profile_list = &prof->
profile_list;
687 VkVideoDecodeH264ProfileInfoKHR *h264_profile = &prof->
h264_profile;
688 VkVideoDecodeH265ProfileInfoKHR *h265_profile = &prof->
h265_profile;
689 VkVideoDecodeAV1ProfileInfoKHR *av1_profile = &prof->
av1_profile;
696 dec_caps->pNext = h264_caps;
697 usage->pNext = h264_profile;
698 h264_profile->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR;
707 VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHR :
708 VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_KHR;
710 dec_caps->pNext = h265_caps;
711 usage->pNext = h265_profile;
712 h265_profile->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR;
713 h265_profile->stdProfileIdc = cur_profile;
715 dec_caps->pNext = av1_caps;
716 usage->pNext = av1_profile;
717 av1_profile->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR;
718 av1_profile->stdProfile = cur_profile;
722 usage->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR;
723 usage->videoUsageHints = VK_VIDEO_DECODE_USAGE_DEFAULT_KHR;
725 profile->sType = VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR;
732 profile_list->sType = VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR;
733 profile_list->profileCount = 1;
734 profile_list->pProfiles =
profile;
737 caps->sType = VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR;
738 caps->pNext = dec_caps;
739 dec_caps->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR;
742 return vk->GetPhysicalDeviceVideoCapabilitiesKHR(hwctx->
phys_dev,
profile,
752 int max_level, base_profile, cur_profile;
765 VkVideoCapabilitiesKHR *caps = &
ctx->caps;
766 VkVideoDecodeCapabilitiesKHR *dec_caps = &
ctx->dec_caps;
768 VkVideoDecodeH264CapabilitiesKHR h264_caps = {
769 .sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR,
771 VkVideoDecodeH265CapabilitiesKHR h265_caps = {
772 .sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR,
774 VkVideoDecodeAV1CapabilitiesKHR av1_caps = {
775 .sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR,
778 VkPhysicalDeviceVideoFormatInfoKHR fmt_info = {
779 .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR,
782 VkVideoFormatPropertiesKHR *ret_info;
783 uint32_t nb_out_fmts = 0;
804 if (
ret == VK_ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR &&
806 avctx->
profile != base_profile) {
808 "again with profile %s\n",
812 cur_profile = base_profile;
822 if (
ret == VK_ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR) {
824 "%s profile \"%s\" not supported!\n",
828 }
else if (
ret == VK_ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR) {
830 "format (%s) not supported!\n",
833 }
else if (
ret == VK_ERROR_FEATURE_NOT_PRESENT ||
834 ret == VK_ERROR_FORMAT_NOT_SUPPORTED) {
836 }
else if (
ret != VK_SUCCESS) {
849 max_level, avctx->
level);
851 caps->minCodedExtent.width, caps->maxCodedExtent.width);
853 caps->minCodedExtent.height, caps->maxCodedExtent.height);
855 caps->pictureAccessGranularity.width);
857 caps->pictureAccessGranularity.height);
859 caps->minBitstreamBufferOffsetAlignment);
861 caps->minBitstreamBufferSizeAlignment);
865 caps->maxActiveReferencePictures);
867 caps->stdHeaderVersion.extensionName,
869 av_log(avctx,
AV_LOG_VERBOSE,
" Codec header version: %i.%i.%i (driver), %i.%i.%i (compiled)\n",
870 CODEC_VER(caps->stdHeaderVersion.specVersion),
873 dec_caps->flags ?
"" :
875 dec_caps->flags & VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR ?
876 " reuse_dst_dpb" :
"",
877 dec_caps->flags & VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR ?
878 " dedicated_dpb" :
"");
882 caps->flags & VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR ?
884 caps->flags & VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR ?
885 " separate_references" :
"");
888 if (avctx->
coded_width < caps->minCodedExtent.width ||
895 avctx->
level > max_level)
899 if (!(dec_caps->flags & (VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR |
900 VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR))) {
902 "VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR nor "
903 "VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR are set!\n");
905 }
else if ((dec_caps->flags & (VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR |
906 VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR) ==
907 VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR) &&
908 !(caps->flags & VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR)) {
909 av_log(avctx,
AV_LOG_ERROR,
"Cannot initialize Vulkan decoding session, buggy driver: "
910 "VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR set "
911 "but VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR is unset!\n");
916 dec->
dedicated_dpb = !(dec_caps->flags & VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR);
917 dec->
layered_dpb = !(caps->flags & VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR);
920 fmt_info.imageUsage = VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR;
922 fmt_info.imageUsage = VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR |
923 VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR |
924 VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
925 VK_IMAGE_USAGE_SAMPLED_BIT;
929 ret = vk->GetPhysicalDeviceVideoFormatPropertiesKHR(hwctx->
phys_dev,
932 if (
ret == VK_ERROR_FORMAT_NOT_SUPPORTED ||
933 (!nb_out_fmts &&
ret == VK_SUCCESS)) {
935 }
else if (
ret != VK_SUCCESS) {
941 ret_info =
av_mallocz(
sizeof(*ret_info)*nb_out_fmts);
945 for (
int i = 0;
i < nb_out_fmts;
i++)
946 ret_info[
i].sType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR;
948 ret = vk->GetPhysicalDeviceVideoFormatPropertiesKHR(hwctx->
phys_dev,
950 &nb_out_fmts, ret_info);
951 if (
ret == VK_ERROR_FORMAT_NOT_SUPPORTED ||
952 (!nb_out_fmts &&
ret == VK_SUCCESS)) {
955 }
else if (
ret != VK_SUCCESS) {
964 *vk_fmt = best_vkfmt = VK_FORMAT_UNDEFINED;
967 av_log(avctx,
AV_LOG_DEBUG,
"Choosing best pixel format for decoding from %i:\n", nb_out_fmts);
968 for (
int i = 0;
i < nb_out_fmts;
i++) {
976 if (
tmp == best_format)
977 best_vkfmt = ret_info[
i].format;
987 av_log(avctx,
AV_LOG_ERROR,
"No valid/compatible pixel format found for decoding!\n");
995 *vk_fmt = best_vkfmt;
1010 int err, dedicated_dpb;
1028 prof, &dedicated_dpb);
1041 hwfc->format[0] = vkfmt;
1042 hwfc->create_pnext = &prof->profile_list;
1043 hwfc->tiling = VK_IMAGE_TILING_OPTIMAL;
1044 hwfc->usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
1045 VK_IMAGE_USAGE_SAMPLED_BIT |
1046 VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR;
1048 if (!dec->dedicated_dpb)
1049 hwfc->usage |= VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR;
1058 VkVideoSessionParametersKHR *par = (VkVideoSessionParametersKHR *)
data;
1059 vk->DestroyVideoSessionParametersKHR(
ctx->s.hwctx->act_dev, *par,
1060 ctx->s.hwctx->alloc);
1065 const VkVideoSessionParametersCreateInfoKHR *session_params_create)
1067 VkVideoSessionParametersKHR *par =
av_malloc(
sizeof(*par));
1075 ret = vk->CreateVideoSessionParametersKHR(
ctx->s.hwctx->act_dev, session_params_create,
1076 ctx->s.hwctx->alloc, par);
1077 if (
ret != VK_SUCCESS) {
1078 av_log(logctx,
AV_LOG_ERROR,
"Unable to create Vulkan video session parameters: %s!\n",
1110 int err, qf, cxpos = 0, cypos = 0, nb_q = 0;
1116 const VkVideoProfileInfoKHR *
profile;
1118 const VkPhysicalDeviceDriverProperties *driver_props;
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,
1126 StdVideoAV1SequenceHeader av1_empty_seq = { 0 };
1127 VkVideoDecodeAV1SessionParametersCreateInfoKHR av1_params = {
1128 .sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR,
1129 .pStdSequenceHeader = &av1_empty_seq,
1131 VkVideoSessionParametersCreateInfoKHR session_params_create = {
1132 .sType = VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR,
1138 VkVideoSessionCreateInfoKHR session_create = {
1139 .sType = VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR,
1141 VkSamplerYcbcrConversionCreateInfo yuv_sampler_info = {
1142 .sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO,
1144 .ycbcrModel = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY,
1159 s->hwfc =
s->frames->hwctx;
1162 s->hwctx =
s->device->hwctx;
1179 if (!(
s->video_props[qf].videoCodecOperations & vk_desc->
decode_op)) {
1186 if (
s->query_props[qf].queryResultStatusSupport)
1189 session_create.flags = 0x0;
1190 session_create.queueFamilyIndex =
s->hwctx->queue_family_decode_index;
1191 session_create.maxCodedExtent =
ctx->caps.maxCodedExtent;
1192 session_create.maxDpbSlots =
ctx->caps.maxDpbSlots;
1193 session_create.maxActiveReferencePictures =
ctx->caps.maxActiveReferencePictures;
1194 session_create.pictureFormat =
s->hwfc->format[0];
1195 session_create.referencePictureFormat = session_create.pictureFormat;
1196 session_create.pStdHeaderVersion = &vk_desc->
ext_props;
1197 session_create.pVideoProfile =
profile;
1203 nb_q, VK_QUERY_TYPE_RESULT_STATUS_ONLY_KHR, 0,
1214 yuv_sampler_info.xChromaOffset = cxpos >> 7;
1215 yuv_sampler_info.yChromaOffset = cypos >> 7;
1216 yuv_sampler_info.format =
s->hwfc->format[0];
1217 ret = vk->CreateSamplerYcbcrConversion(
s->hwctx->act_dev, &yuv_sampler_info,
1218 s->hwctx->alloc, &
ctx->yuv_sampler);
1219 if (
ret != VK_SUCCESS) {
1230 if (!
ctx->dpb_hwfc_ref) {
1243 VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR);
1244 dpb_hwfc->
format[0] =
s->hwfc->format[0];
1245 dpb_hwfc->
tiling = VK_IMAGE_TILING_OPTIMAL;
1246 dpb_hwfc->
usage = VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR |
1247 VK_IMAGE_USAGE_SAMPLED_BIT;
1258 if (!
ctx->layered_frame) {
1265 s->hwfc->format[0], 0);
1271 session_params_create.videoSession =
ctx->common.session;
1272 ret = vk->CreateVideoSessionParametersKHR(
s->hwctx->act_dev, &session_params_create,
1273 s->hwctx->alloc, &
ctx->empty_session_params);
1274 if (
ret != VK_SUCCESS) {
1275 av_log(avctx,
AV_LOG_ERROR,
"Unable to create empty Vulkan video session parameters: %s!\n",
1281 if (driver_props->driverID == VK_DRIVER_ID_NVIDIA_PROPRIETARY &&
1282 driver_props->conformanceVersion.major == 1 &&
1283 driver_props->conformanceVersion.minor == 3 &&
1284 driver_props->conformanceVersion.subminor == 8 &&
1285 driver_props->conformanceVersion.patch < 3)