From: Alexander Galazin Date: Tue, 13 Apr 2021 09:57:15 +0000 (+0300) Subject: Update Vulkan beta Headers X-Git-Tag: upstream/1.3.5~679^2~21 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=c19b2aa69fa15aad364c19911a55797dc9e5f16e;p=platform%2Fupstream%2FVK-GL-CTS.git Update Vulkan beta Headers Components: Vulkan Change-Id: I29364f15c3c9c83424a7c0814b7634aaadfd4ab2 (cherry picked from commit 476acb91ebc242858d6d73253f54b7f8521f4d98) --- diff --git a/external/vulkancts/framework/vulkan/vkBasicTypes.inl b/external/vulkancts/framework/vulkan/vkBasicTypes.inl index 5b5ddfe..4176845 100644 --- a/external/vulkancts/framework/vulkan/vkBasicTypes.inl +++ b/external/vulkancts/framework/vulkan/vkBasicTypes.inl @@ -65,6 +65,8 @@ VK_DEFINE_NON_DISPATCHABLE_HANDLE (VkPerformanceConfigurationINTEL, HANDLE_TYPE_ VK_DEFINE_NON_DISPATCHABLE_HANDLE (VkIndirectCommandsLayoutNV, HANDLE_TYPE_INDIRECT_COMMANDS_LAYOUT_NV); VK_DEFINE_NON_DISPATCHABLE_HANDLE (VkPrivateDataSlotEXT, HANDLE_TYPE_PRIVATE_DATA_SLOT_EXT); VK_DEFINE_NON_DISPATCHABLE_HANDLE (VkAccelerationStructureKHR, HANDLE_TYPE_ACCELERATION_STRUCTURE_KHR); +VK_DEFINE_NON_DISPATCHABLE_HANDLE (VkVideoSessionKHR, HANDLE_TYPE_VIDEO_SESSION_KHR); +VK_DEFINE_NON_DISPATCHABLE_HANDLE (VkVideoSessionParametersKHR, HANDLE_TYPE_VIDEO_SESSION_PARAMETERS_KHR); VK_DEFINE_NON_DISPATCHABLE_HANDLE (VkSamplerYcbcrConversionKHR, HANDLE_TYPE_SAMPLER_YCBCR_CONVERSION); VK_DEFINE_NON_DISPATCHABLE_HANDLE (VkDescriptorUpdateTemplateKHR, HANDLE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE); @@ -2271,6 +2273,208 @@ enum VkShaderGroupShaderKHR VK_SHADER_GROUP_SHADER_MAX_ENUM_KHR = 0x7FFFFFFF, }; +enum VkQueryResultStatusKHR +{ + VK_QUERY_RESULT_STATUS_ERROR_KHR = -1, + VK_QUERY_RESULT_STATUS_NOT_READY_KHR = 0, + VK_QUERY_RESULT_STATUS_COMPLETE_KHR = 1, + VK_QUERY_RESULT_STATUS_MAX_ENUM_KHR = 0x7FFFFFFF, +}; + +enum StdVideoH264ChromaFormatIdc +{ + std_video_h264_chroma_format_idc_monochrome = 0, + std_video_h264_chroma_format_idc_420 = 1, + std_video_h264_chroma_format_idc_422 = 2, + std_video_h264_chroma_format_idc_444 = 3, + STD_VIDEO_H264_CHROMA_FORMAT_IDC_LAST, +}; + +enum StdVideoH264ProfileIdc +{ + std_video_h264_profile_idc_baseline = 66, + std_video_h264_profile_idc_main = 77, + std_video_h264_profile_idc_high = 100, + std_video_h264_profile_idc_high_444_predictive = 244, + std_video_h264_profile_idc_invalid = 0x7FFFFFFF, +}; + +enum StdVideoH264Level +{ + std_video_h264_level_1_0 = 0, + std_video_h264_level_1_1 = 1, + std_video_h264_level_1_2 = 2, + std_video_h264_level_1_3 = 3, + std_video_h264_level_2_0 = 4, + std_video_h264_level_2_1 = 5, + std_video_h264_level_2_2 = 6, + std_video_h264_level_3_0 = 7, + std_video_h264_level_3_1 = 8, + std_video_h264_level_3_2 = 9, + std_video_h264_level_4_0 = 10, + std_video_h264_level_4_1 = 11, + std_video_h264_level_4_2 = 12, + std_video_h264_level_5_0 = 13, + std_video_h264_level_5_1 = 14, + std_video_h264_level_5_2 = 15, + std_video_h264_level_6_0 = 16, + std_video_h264_level_6_1 = 17, + std_video_h264_level_6_2 = 18, + STD_VIDEO_H264_LEVEL_LAST, + std_video_h264_level_invalid = 0x7FFFFFFF, +}; + +enum StdVideoH264PocType +{ + std_video_h264_poc_type_0 = 0, + std_video_h264_poc_type_1 = 1, + std_video_h264_poc_type_2 = 2, + STD_VIDEO_H264_POC_TYPE_LAST, + std_video_h264_poc_type_invalid = 0x7FFFFFFF, +}; + +enum StdVideoH264AspectRatioIdc +{ + std_video_h264_aspect_ratio_idc_unspecified = 0, + std_video_h264_aspect_ratio_idc_square = 1, + std_video_h264_aspect_ratio_idc_12_11 = 2, + std_video_h264_aspect_ratio_idc_10_11 = 3, + std_video_h264_aspect_ratio_idc_16_11 = 4, + std_video_h264_aspect_ratio_idc_40_33 = 5, + std_video_h264_aspect_ratio_idc_24_11 = 6, + std_video_h264_aspect_ratio_idc_20_11 = 7, + std_video_h264_aspect_ratio_idc_32_11 = 8, + std_video_h264_aspect_ratio_idc_80_33 = 9, + std_video_h264_aspect_ratio_idc_18_11 = 10, + std_video_h264_aspect_ratio_idc_15_11 = 11, + std_video_h264_aspect_ratio_idc_64_33 = 12, + std_video_h264_aspect_ratio_idc_160_99 = 13, + std_video_h264_aspect_ratio_idc_4_3 = 14, + std_video_h264_aspect_ratio_idc_3_2 = 15, + std_video_h264_aspect_ratio_idc_2_1 = 16, + std_video_h264_aspect_ratio_idc_extended_sar = 255, + std_video_h264_aspect_ratio_idc_invalid = 0x7FFFFFFF, +}; + +enum StdVideoH264WeightedBiPredIdc +{ + std_video_h264_default_weighted_b_slices_prediction_idc = 0, + std_video_h264_explicit_weighted_b_slices_prediction_idc = 1, + std_video_h264_implicit_weighted_b_slices_prediction_idc = 2, + STD_VIDEO_H264_WEIGHTED_BI_PRED_IDC_LAST, + std_video_h264_invalid_weighted_b_slices_prediction_idc = 0x7FFFFFFF, +}; + +enum StdVideoH264ModificationOfPicNumsIdc +{ + std_video_h264_modification_of_pic_nums_idc_short_term_subtract = 0, + std_video_h264_modification_of_pic_nums_idc_short_term_add = 1, + std_video_h264_modification_of_pic_nums_idc_long_term = 2, + std_video_h264_modification_of_pic_nums_idc_end = 3, + STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_LAST, + std_video_h264_modification_of_pic_nums_idc_invalid = 0x7FFFFFFF, +}; + +enum StdVideoH264MemMgmtControlOp +{ + std_video_h264_mem_mgmt_control_op_end = 0, + std_video_h264_mem_mgmt_control_op_unmark_short_term = 1, + std_video_h264_mem_mgmt_control_op_unmark_long_term = 2, + std_video_h264_mem_mgmt_control_op_mark_long_term = 3, + std_video_h264_mem_mgmt_control_op_set_max_long_term_index = 4, + std_video_h264_mem_mgmt_control_op_unmark_all = 5, + std_video_h264_mem_mgmt_control_op_mark_current_as_long_term = 6, + STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_LAST, + std_video_h264_mem_mgmt_control_op_invalid = 0x7FFFFFFF, +}; + +enum StdVideoH264CabacInitIdc +{ + std_video_h264_cabac_init_idc_0 = 0, + std_video_h264_cabac_init_idc_1 = 1, + std_video_h264_cabac_init_idc_2 = 2, + STD_VIDEO_H264_CABAC_INIT_IDC_LAST, + std_video_h264_cabac_init_idc_invalid = 0x7FFFFFFF, +}; + +enum StdVideoH264DisableDeblockingFilterIdc +{ + std_video_h264_disable_deblocking_filter_idc_disabled = 0, + std_video_h264_disable_deblocking_filter_idc_enabled = 1, + std_video_h264_disable_deblocking_filter_idc_partial = 2, + STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_LAST, + std_video_h264_disable_deblocking_filter_idc_invalid = 0x7FFFFFFF, +}; + +enum StdVideoH264PictureType +{ + std_video_h264_picture_type_i = 0, + std_video_h264_picture_type_p = 1, + std_video_h264_picture_type_b = 2, + STD_VIDEO_H264_PICTURE_TYPE_LAST, + std_video_h264_picture_type_invalid = 0x7FFFFFFF, +}; + +enum StdVideoH264SliceType +{ + std_video_h264_slice_type_i = 0, + std_video_h264_slice_type_p = 1, + std_video_h264_slice_type_b = 2, + STD_VIDEO_H264_SLICE_TYPE_LAST, + std_video_h264_slice_type_invalid = 0x7FFFFFFF, +}; + +enum StdVideoH264NonVclNaluType +{ + std_video_h264_non_vcl_nalu_type_sps = 0, + std_video_h264_non_vcl_nalu_type_pps = 1, + std_video_h264_non_vcl_nalu_type_aud = 2, + std_video_h264_non_vcl_nalu_type_prefix = 3, + std_video_h264_non_vcl_nalu_type_end_of_sequence = 4, + std_video_h264_non_vcl_nalu_type_end_of_stream = 5, + std_video_h264_non_vcl_nalu_type_precoded = 6, + STD_VIDEO_H264_NON_VCL_NALU_TYPE_LAST, + std_video_h264_non_vcl_nalu_type_invalid = 0x7FFFFFFF, +}; + +enum StdVideoH265ChromaFormatIdc +{ + std_video_h265_chroma_format_idc_monochrome = 0, + std_video_h265_chroma_format_idc_420 = 1, + std_video_h265_chroma_format_idc_422 = 2, + std_video_h265_chroma_format_idc_444 = 3, + STD_VIDEO_H265_CHROMA_FORMAT_IDC_LAST, +}; + +enum StdVideoH265ProfileIdc +{ + std_video_h265_profile_idc_main = 1, + std_video_h265_profile_idc_main_10 = 2, + std_video_h265_profile_idc_main_still_picture = 3, + std_video_h265_profile_idc_format_range_extensions = 4, + std_video_h265_profile_idc_scc_extensions = 9, + std_video_h265_profile_idc_invalid = 0x7FFFFFFF, +}; + +enum StdVideoH265Level +{ + std_video_h265_level_1_0 = 0, + std_video_h265_level_2_0 = 1, + std_video_h265_level_2_1 = 2, + std_video_h265_level_3_0 = 3, + std_video_h265_level_3_1 = 4, + std_video_h265_level_4_0 = 5, + std_video_h265_level_4_1 = 6, + std_video_h265_level_5_0 = 7, + std_video_h265_level_5_1 = 8, + std_video_h265_level_5_2 = 9, + std_video_h265_level_6_0 = 10, + std_video_h265_level_6_1 = 11, + std_video_h265_level_6_2 = 12, + STD_VIDEO_H265_LEVEL_LAST, + std_video_h265_level_invalid = 0x7FFFFFFF, +}; + enum VkFullScreenExclusiveEXT { VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT = 0, @@ -3319,6 +3523,156 @@ enum VkAccelerationStructureCreateFlagBitsKHR }; typedef deUint32 VkAccelerationStructureCreateFlagsKHR; +enum VkVideoCodecOperationFlagBitsKHR +{ + VK_VIDEO_CODEC_OPERATION_INVALID_BIT_KHR = 0, + VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_EXT = 0x00010000, + VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_EXT = 0x00000001, + VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_EXT = 0x00000002, + VK_VIDEO_CODEC_OPERATION_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF, +}; +typedef deUint32 VkVideoCodecOperationFlagsKHR; + +enum VkVideoChromaSubsamplingFlagBitsKHR +{ + VK_VIDEO_CHROMA_SUBSAMPLING_INVALID_BIT_KHR = 0, + VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR = 0x00000001, + VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR = 0x00000002, + VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR = 0x00000004, + VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR = 0x00000008, + VK_VIDEO_CHROMA_SUBSAMPLING_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF, +}; +typedef deUint32 VkVideoChromaSubsamplingFlagsKHR; + +enum VkVideoComponentBitDepthFlagBitsKHR +{ + VK_VIDEO_COMPONENT_BIT_DEPTH_INVALID_KHR = 0, + VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR = 0x00000001, + VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR = 0x00000004, + VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR = 0x00000010, + VK_VIDEO_COMPONENT_BIT_DEPTH_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF, +}; +typedef deUint32 VkVideoComponentBitDepthFlagsKHR; + +enum VkVideoCapabilitiesFlagBitsKHR +{ + VK_VIDEO_CAPABILITIES_PROTECTED_CONTENT_BIT_KHR = 0x00000001, + VK_VIDEO_CAPABILITIES_SEPARATE_REFERENCE_IMAGES_BIT_KHR = 0x00000002, + VK_VIDEO_CAPABILITIES_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF, +}; +typedef deUint32 VkVideoCapabilitiesFlagsKHR; + +enum VkVideoSessionCreateFlagBitsKHR +{ + VK_VIDEO_SESSION_CREATE_DEFAULT_KHR = 0, + VK_VIDEO_SESSION_CREATE_PROTECTED_CONTENT_BIT_KHR = 0x00000001, + VK_VIDEO_SESSION_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF, +}; +typedef deUint32 VkVideoSessionCreateFlagsKHR; + +enum VkVideoCodingControlFlagBitsKHR +{ + VK_VIDEO_CODING_CONTROL_DEFAULT_KHR = 0, + VK_VIDEO_CODING_CONTROL_RESET_BIT_KHR = 0x00000001, + VK_VIDEO_CODING_CONTROL_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF, +}; +typedef deUint32 VkVideoCodingControlFlagsKHR; + +enum VkVideoCodingQualityPresetFlagBitsKHR +{ + VK_VIDEO_CODING_QUALITY_PRESET_DEFAULT_BIT_KHR = 0, + VK_VIDEO_CODING_QUALITY_PRESET_NORMAL_BIT_KHR = 0x00000001, + VK_VIDEO_CODING_QUALITY_PRESET_POWER_BIT_KHR = 0x00000002, + VK_VIDEO_CODING_QUALITY_PRESET_QUALITY_BIT_KHR = 0x00000004, + VK_VIDEO_CODING_QUALITY_PRESET_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF, +}; +typedef deUint32 VkVideoCodingQualityPresetFlagsKHR; + +enum VkVideoDecodeFlagBitsKHR +{ + VK_VIDEO_DECODE_DEFAULT_KHR = 0, + VK_VIDEO_DECODE_RESERVED_0_BIT_KHR = 0x00000001, + VK_VIDEO_DECODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF, +}; +typedef deUint32 VkVideoDecodeFlagsKHR; + +enum VkVideoEncodeFlagBitsKHR +{ + VK_VIDEO_ENCODE_DEFAULT_KHR = 0, + VK_VIDEO_ENCODE_RESERVED_0_BIT_KHR = 0x00000001, + VK_VIDEO_ENCODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF, +}; +typedef deUint32 VkVideoEncodeFlagsKHR; + +enum VkVideoEncodeRateControlFlagBitsKHR +{ + VK_VIDEO_ENCODE_RATE_CONTROL_DEFAULT_KHR = 0, + VK_VIDEO_ENCODE_RATE_CONTROL_RESET_BIT_KHR = 0x00000001, + VK_VIDEO_ENCODE_RATE_CONTROL_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF, +}; +typedef deUint32 VkVideoEncodeRateControlFlagsKHR; + +enum VkVideoEncodeRateControlModeFlagBitsKHR +{ + VK_VIDEO_ENCODE_RATE_CONTROL_MODE_NONE_BIT_KHR = 0, + VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR = 1, + VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR = 2, + VK_VIDEO_ENCODE_RATE_CONTROL_MODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF, +}; +typedef deUint32 VkVideoEncodeRateControlModeFlagsKHR; + +enum VkVideoEncodeH264CapabilitiesFlagBitsEXT +{ + VK_VIDEO_ENCODE_H264_CAPABILITY_CABAC_BIT_EXT = 0x00000001, + VK_VIDEO_ENCODE_H264_CAPABILITY_CAVLC_BIT_EXT = 0x00000002, + VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_BI_PRED_IMPLICIT_BIT_EXT = 0x00000004, + VK_VIDEO_ENCODE_H264_CAPABILITY_TRANSFORM_8X8_BIT_EXT = 0x00000008, + VK_VIDEO_ENCODE_H264_CAPABILITY_CHROMA_QP_OFFSET_BIT_EXT = 0x00000010, + VK_VIDEO_ENCODE_H264_CAPABILITY_SECOND_CHROMA_QP_OFFSET_BIT_EXT = 0x00000020, + VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_DISABLED_BIT_EXT = 0x00000040, + VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_ENABLED_BIT_EXT = 0x00000080, + VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_PARTIAL_BIT_EXT = 0x00000100, + VK_VIDEO_ENCODE_H264_CAPABILITY_MULTIPLE_SLICE_PER_FRAME_BIT_EXT = 0x00000200, + VK_VIDEO_ENCODE_H264_CAPABILITY_EVENLY_DISTRIBUTED_SLICE_SIZE_BIT_EXT = 0x00000400, + VK_VIDEO_ENCODE_H264_CAPABILITIES_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF, +}; +typedef deUint32 VkVideoEncodeH264CapabilitiesFlagsEXT; + +enum VkVideoEncodeH264InputModeFlagBitsEXT +{ + VK_VIDEO_ENCODE_H264_INPUT_MODE_FRAME_BIT_EXT = 0x00000001, + VK_VIDEO_ENCODE_H264_INPUT_MODE_SLICE_BIT_EXT = 0x00000002, + VK_VIDEO_ENCODE_H264_INPUT_MODE_NON_VCL_BIT_EXT = 0x00000004, + VK_VIDEO_ENCODE_H264_INPUT_MODE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF, +}; +typedef deUint32 VkVideoEncodeH264InputModeFlagsEXT; + +enum VkVideoEncodeH264OutputModeFlagBitsEXT +{ + VK_VIDEO_ENCODE_H264_OUTPUT_MODE_FRAME_BIT_EXT = 0x00000001, + VK_VIDEO_ENCODE_H264_OUTPUT_MODE_SLICE_BIT_EXT = 0x00000002, + VK_VIDEO_ENCODE_H264_OUTPUT_MODE_NON_VCL_BIT_EXT = 0x00000004, + VK_VIDEO_ENCODE_H264_OUTPUT_MODE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF, +}; +typedef deUint32 VkVideoEncodeH264OutputModeFlagsEXT; + +enum VkVideoEncodeH264CreateFlagBitsEXT +{ + VK_VIDEO_ENCODE_H264_CREATE_DEFAULT_EXT = 0, + VK_VIDEO_ENCODE_H264_CREATE_RESERVED_0_BIT_EXT = 0x00000001, + VK_VIDEO_ENCODE_H264_CREATE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF, +}; +typedef deUint32 VkVideoEncodeH264CreateFlagsEXT; + +enum VkVideoDecodeH264FieldLayoutFlagBitsEXT +{ + VK_VIDEO_DECODE_H264_PROGRESSIVE_PICTURES_ONLY_EXT = 0, + VK_VIDEO_DECODE_H264_FIELD_LAYOUT_LINE_INTERLACED_PLANE_BIT_EXT = 0x00000001, + VK_VIDEO_DECODE_H264_FIELD_LAYOUT_SEPARATE_INTERLACED_PLANE_BIT_EXT = 0x00000002, + VK_VIDEO_DECODE_H264_FIELD_LAYOUT_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF, +}; +typedef deUint32 VkVideoDecodeH264FieldLayoutFlagsEXT; + typedef deUint32 VkInstanceCreateFlags; typedef deUint32 VkDeviceCreateFlags; @@ -3389,6 +3743,14 @@ typedef deUint32 VkDeviceMemoryReportFlagsEXT; typedef deUint32 VkAndroidSurfaceCreateFlagsKHR; +typedef deUint32 VkVideoBeginCodingFlagsKHR; + +typedef deUint32 VkVideoEndCodingFlagsKHR; + +typedef deUint32 VkVideoDecodeH264CreateFlagsEXT; + +typedef deUint32 VkVideoDecodeH265CreateFlagsEXT; + typedef deUint32 VkImagePipeSurfaceCreateFlagsFUCHSIA; typedef deUint32 VkStreamDescriptorSurfaceCreateFlagsGGP; @@ -3772,7 +4134,19 @@ VK_DEFINE_PLATFORM_TYPE(CAMetalLayer, void*); #define VK_KHR_RAY_QUERY_SPEC_VERSION 1 #define VK_KHR_ANDROID_SURFACE_SPEC_VERSION 6 #define VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_SPEC_VERSION 3 +#define VK_KHR_VIDEO_QUEUE_SPEC_VERSION 1 +#define VK_KHR_VIDEO_DECODE_QUEUE_SPEC_VERSION 1 #define VK_KHR_PORTABILITY_SUBSET_SPEC_VERSION 1 +#define VK_KHR_VIDEO_ENCODE_QUEUE_SPEC_VERSION 1 +#define VK_STD_VULKAN_VIDEO_CODEC_H264_API_VERSION_0_9 VK_MAKE_VIDEO_STD_VERSION(0, 9, 0) +#define VK_STD_VULKAN_VIDEO_CODEC_H264_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H264_API_VERSION_0_9 +#define VK_STD_VULKAN_VIDEO_CODEC_H264_EXTENSION_NAME "VK_STD_vulkan_video_codec_h264" +#define VK_EXT_VIDEO_ENCODE_H264_SPEC_VERSION 1 +#define VK_EXT_VIDEO_DECODE_H264_SPEC_VERSION 1 +#define VK_STD_VULKAN_VIDEO_CODEC_H265_API_VERSION_0_5 VK_MAKE_VIDEO_STD_VERSION(0, 5, 0) +#define VK_STD_VULKAN_VIDEO_CODEC_H265_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H265_API_VERSION_0_5 +#define VK_STD_VULKAN_VIDEO_CODEC_H265_EXTENSION_NAME "VK_STD_vulkan_video_codec_h265" +#define VK_EXT_VIDEO_DECODE_H265_SPEC_VERSION 1 #define VK_FUCHSIA_IMAGEPIPE_SURFACE_SPEC_VERSION 1 #define VK_FUCHSIA_EXTERNAL_MEMORY_SPEC_VERSION 1 #define VK_FUCHSIA_EXTERNAL_SEMAPHORE_SPEC_VERSION 1 diff --git a/external/vulkancts/framework/vulkan/vkConcreteDeviceInterface.inl b/external/vulkancts/framework/vulkan/vkConcreteDeviceInterface.inl index 5f420c4..ebef599 100644 --- a/external/vulkancts/framework/vulkan/vkConcreteDeviceInterface.inl +++ b/external/vulkancts/framework/vulkan/vkConcreteDeviceInterface.inl @@ -321,6 +321,18 @@ virtual VkDeviceSize getRayTracingShaderGroupStackSizeKHR (VkDevice device, V virtual void cmdSetRayTracingPipelineStackSizeKHR (VkCommandBuffer commandBuffer, deUint32 pipelineStackSize) const; virtual VkResult getAndroidHardwareBufferPropertiesANDROID (VkDevice device, const struct pt::AndroidHardwareBufferPtr buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties) const; virtual VkResult getMemoryAndroidHardwareBufferANDROID (VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct pt::AndroidHardwareBufferPtr* pBuffer) const; +virtual VkResult createVideoSessionKHR (VkDevice device, const VkVideoSessionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionKHR* pVideoSession) const; +virtual void destroyVideoSessionKHR (VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks* pAllocator) const; +virtual VkResult getVideoSessionMemoryRequirementsKHR (VkDevice device, VkVideoSessionKHR videoSession, deUint32* pVideoSessionMemoryRequirementsCount, VkVideoGetMemoryPropertiesKHR* pVideoSessionMemoryRequirements) const; +virtual VkResult bindVideoSessionMemoryKHR (VkDevice device, VkVideoSessionKHR videoSession, deUint32 videoSessionBindMemoryCount, const VkVideoBindMemoryKHR* pVideoSessionBindMemories) const; +virtual VkResult createVideoSessionParametersKHR (VkDevice device, const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionParametersKHR* pVideoSessionParameters) const; +virtual VkResult updateVideoSessionParametersKHR (VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo) const; +virtual void destroyVideoSessionParametersKHR (VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkAllocationCallbacks* pAllocator) const; +virtual void cmdBeginVideoCodingKHR (VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR* pBeginInfo) const; +virtual void cmdEndVideoCodingKHR (VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR* pEndCodingInfo) const; +virtual void cmdControlVideoCodingKHR (VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR* pCodingControlInfo) const; +virtual void cmdDecodeVideoKHR (VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR* pFrameInfo) const; +virtual void cmdEncodeVideoKHR (VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo) const; virtual VkResult getMemoryZirconHandleFUCHSIA (VkDevice device, const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, pt::zx_handle_t* pZirconHandle) const; virtual VkResult getMemoryZirconHandlePropertiesFUCHSIA (VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, pt::zx_handle_t zirconHandle, VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties) const; virtual VkResult importSemaphoreZirconHandleFUCHSIA (VkDevice device, const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo) const; diff --git a/external/vulkancts/framework/vulkan/vkConcreteInstanceInterface.inl b/external/vulkancts/framework/vulkan/vkConcreteInstanceInterface.inl index 345fc2a..555d831 100644 --- a/external/vulkancts/framework/vulkan/vkConcreteInstanceInterface.inl +++ b/external/vulkancts/framework/vulkan/vkConcreteInstanceInterface.inl @@ -64,6 +64,8 @@ virtual VkResult createHeadlessSurfaceEXT (VkInstance instance, const V virtual VkResult acquireWinrtDisplayNV (VkPhysicalDevice physicalDevice, VkDisplayKHR display) const; virtual VkResult getWinrtDisplayNV (VkPhysicalDevice physicalDevice, deUint32 deviceRelativeId, VkDisplayKHR* pDisplay) const; virtual VkResult createAndroidSurfaceKHR (VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) const; +virtual VkResult getPhysicalDeviceVideoCapabilitiesKHR (VkPhysicalDevice physicalDevice, const VkVideoProfileKHR* pVideoProfile, VkVideoCapabilitiesKHR* pCapabilities) const; +virtual VkResult getPhysicalDeviceVideoFormatPropertiesKHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, deUint32* pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR* pVideoFormatProperties) const; virtual VkResult createImagePipeSurfaceFUCHSIA (VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) const; virtual VkResult createStreamDescriptorSurfaceGGP (VkInstance instance, const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) const; virtual VkResult createIOSSurfaceMVK (VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) const; diff --git a/external/vulkancts/framework/vulkan/vkDeviceDriverImpl.inl b/external/vulkancts/framework/vulkan/vkDeviceDriverImpl.inl index 4ec6f39..fe007a2 100644 --- a/external/vulkancts/framework/vulkan/vkDeviceDriverImpl.inl +++ b/external/vulkancts/framework/vulkan/vkDeviceDriverImpl.inl @@ -1602,6 +1602,66 @@ VkResult DeviceDriver::getMemoryAndroidHardwareBufferANDROID (VkDevice device, c return m_vk.getMemoryAndroidHardwareBufferANDROID(device, pInfo, pBuffer); } +VkResult DeviceDriver::createVideoSessionKHR (VkDevice device, const VkVideoSessionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionKHR* pVideoSession) const +{ + return m_vk.createVideoSessionKHR(device, pCreateInfo, pAllocator, pVideoSession); +} + +void DeviceDriver::destroyVideoSessionKHR (VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks* pAllocator) const +{ + m_vk.destroyVideoSessionKHR(device, videoSession, pAllocator); +} + +VkResult DeviceDriver::getVideoSessionMemoryRequirementsKHR (VkDevice device, VkVideoSessionKHR videoSession, deUint32* pVideoSessionMemoryRequirementsCount, VkVideoGetMemoryPropertiesKHR* pVideoSessionMemoryRequirements) const +{ + return m_vk.getVideoSessionMemoryRequirementsKHR(device, videoSession, pVideoSessionMemoryRequirementsCount, pVideoSessionMemoryRequirements); +} + +VkResult DeviceDriver::bindVideoSessionMemoryKHR (VkDevice device, VkVideoSessionKHR videoSession, deUint32 videoSessionBindMemoryCount, const VkVideoBindMemoryKHR* pVideoSessionBindMemories) const +{ + return m_vk.bindVideoSessionMemoryKHR(device, videoSession, videoSessionBindMemoryCount, pVideoSessionBindMemories); +} + +VkResult DeviceDriver::createVideoSessionParametersKHR (VkDevice device, const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionParametersKHR* pVideoSessionParameters) const +{ + return m_vk.createVideoSessionParametersKHR(device, pCreateInfo, pAllocator, pVideoSessionParameters); +} + +VkResult DeviceDriver::updateVideoSessionParametersKHR (VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo) const +{ + return m_vk.updateVideoSessionParametersKHR(device, videoSessionParameters, pUpdateInfo); +} + +void DeviceDriver::destroyVideoSessionParametersKHR (VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkAllocationCallbacks* pAllocator) const +{ + m_vk.destroyVideoSessionParametersKHR(device, videoSessionParameters, pAllocator); +} + +void DeviceDriver::cmdBeginVideoCodingKHR (VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR* pBeginInfo) const +{ + m_vk.cmdBeginVideoCodingKHR(commandBuffer, pBeginInfo); +} + +void DeviceDriver::cmdEndVideoCodingKHR (VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR* pEndCodingInfo) const +{ + m_vk.cmdEndVideoCodingKHR(commandBuffer, pEndCodingInfo); +} + +void DeviceDriver::cmdControlVideoCodingKHR (VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR* pCodingControlInfo) const +{ + m_vk.cmdControlVideoCodingKHR(commandBuffer, pCodingControlInfo); +} + +void DeviceDriver::cmdDecodeVideoKHR (VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR* pFrameInfo) const +{ + m_vk.cmdDecodeVideoKHR(commandBuffer, pFrameInfo); +} + +void DeviceDriver::cmdEncodeVideoKHR (VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo) const +{ + m_vk.cmdEncodeVideoKHR(commandBuffer, pEncodeInfo); +} + VkResult DeviceDriver::getMemoryZirconHandleFUCHSIA (VkDevice device, const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, pt::zx_handle_t* pZirconHandle) const { return m_vk.getMemoryZirconHandleFUCHSIA(device, pGetZirconHandleInfo, pZirconHandle); diff --git a/external/vulkancts/framework/vulkan/vkDeviceFunctionPointers.inl b/external/vulkancts/framework/vulkan/vkDeviceFunctionPointers.inl index 2492a5f..ae07f02 100644 --- a/external/vulkancts/framework/vulkan/vkDeviceFunctionPointers.inl +++ b/external/vulkancts/framework/vulkan/vkDeviceFunctionPointers.inl @@ -321,6 +321,18 @@ GetRayTracingShaderGroupStackSizeKHRFunc getRayTracingShaderGroupStackSizeKHR; CmdSetRayTracingPipelineStackSizeKHRFunc cmdSetRayTracingPipelineStackSizeKHR; GetAndroidHardwareBufferPropertiesANDROIDFunc getAndroidHardwareBufferPropertiesANDROID; GetMemoryAndroidHardwareBufferANDROIDFunc getMemoryAndroidHardwareBufferANDROID; +CreateVideoSessionKHRFunc createVideoSessionKHR; +DestroyVideoSessionKHRFunc destroyVideoSessionKHR; +GetVideoSessionMemoryRequirementsKHRFunc getVideoSessionMemoryRequirementsKHR; +BindVideoSessionMemoryKHRFunc bindVideoSessionMemoryKHR; +CreateVideoSessionParametersKHRFunc createVideoSessionParametersKHR; +UpdateVideoSessionParametersKHRFunc updateVideoSessionParametersKHR; +DestroyVideoSessionParametersKHRFunc destroyVideoSessionParametersKHR; +CmdBeginVideoCodingKHRFunc cmdBeginVideoCodingKHR; +CmdEndVideoCodingKHRFunc cmdEndVideoCodingKHR; +CmdControlVideoCodingKHRFunc cmdControlVideoCodingKHR; +CmdDecodeVideoKHRFunc cmdDecodeVideoKHR; +CmdEncodeVideoKHRFunc cmdEncodeVideoKHR; GetMemoryZirconHandleFUCHSIAFunc getMemoryZirconHandleFUCHSIA; GetMemoryZirconHandlePropertiesFUCHSIAFunc getMemoryZirconHandlePropertiesFUCHSIA; ImportSemaphoreZirconHandleFUCHSIAFunc importSemaphoreZirconHandleFUCHSIA; diff --git a/external/vulkancts/framework/vulkan/vkExtensionFunctions.inl b/external/vulkancts/framework/vulkan/vkExtensionFunctions.inl index 8f2ceda..82aa194 100644 --- a/external/vulkancts/framework/vulkan/vkExtensionFunctions.inl +++ b/external/vulkancts/framework/vulkan/vkExtensionFunctions.inl @@ -888,10 +888,36 @@ void getInstanceExtensionFunctions (deUint32 apiVersion, ::std::string extName, { return; } + if (extName == "VK_KHR_video_queue") + { + functions.push_back("vkGetPhysicalDeviceVideoCapabilitiesKHR"); + functions.push_back("vkGetPhysicalDeviceVideoFormatPropertiesKHR"); + return; + } + if (extName == "VK_KHR_video_decode_queue") + { + return; + } if (extName == "VK_KHR_portability_subset") { return; } + if (extName == "VK_KHR_video_encode_queue") + { + return; + } + if (extName == "VK_EXT_video_encode_h264") + { + return; + } + if (extName == "VK_EXT_video_decode_h264") + { + return; + } + if (extName == "VK_EXT_video_decode_h265") + { + return; + } if (extName == "VK_FUCHSIA_imagepipe_surface") { functions.push_back("vkCreateImagePipeSurfaceFUCHSIA"); @@ -2028,10 +2054,46 @@ void getDeviceExtensionFunctions (deUint32 apiVersion, ::std::string extName, :: functions.push_back("vkGetMemoryAndroidHardwareBufferANDROID"); return; } + if (extName == "VK_KHR_video_queue") + { + functions.push_back("vkCreateVideoSessionKHR"); + functions.push_back("vkDestroyVideoSessionKHR"); + functions.push_back("vkGetVideoSessionMemoryRequirementsKHR"); + functions.push_back("vkBindVideoSessionMemoryKHR"); + functions.push_back("vkCreateVideoSessionParametersKHR"); + functions.push_back("vkUpdateVideoSessionParametersKHR"); + functions.push_back("vkDestroyVideoSessionParametersKHR"); + functions.push_back("vkCmdBeginVideoCodingKHR"); + functions.push_back("vkCmdEndVideoCodingKHR"); + functions.push_back("vkCmdControlVideoCodingKHR"); + return; + } + if (extName == "VK_KHR_video_decode_queue") + { + functions.push_back("vkCmdDecodeVideoKHR"); + return; + } if (extName == "VK_KHR_portability_subset") { return; } + if (extName == "VK_KHR_video_encode_queue") + { + functions.push_back("vkCmdEncodeVideoKHR"); + return; + } + if (extName == "VK_EXT_video_encode_h264") + { + return; + } + if (extName == "VK_EXT_video_decode_h264") + { + return; + } + if (extName == "VK_EXT_video_decode_h265") + { + return; + } if (extName == "VK_FUCHSIA_imagepipe_surface") { return; @@ -2157,6 +2219,7 @@ void getDeviceExtensionFunctions (deUint32 apiVersion, ::std::string extName, :: "VK_EXT_headless_surface", "VK_NV_acquire_winrt_display", "VK_KHR_android_surface", + "VK_KHR_video_queue", "VK_FUCHSIA_imagepipe_surface", "VK_GGP_stream_descriptor_surface", "VK_MVK_ios_surface", @@ -2231,6 +2294,8 @@ void getDeviceExtensionFunctions (deUint32 apiVersion, ::std::string extName, :: "VK_KHR_acceleration_structure", "VK_KHR_ray_tracing_pipeline", "VK_ANDROID_external_memory_android_hardware_buffer", + "VK_KHR_video_decode_queue", + "VK_KHR_video_encode_queue", "VK_FUCHSIA_external_memory", "VK_FUCHSIA_external_semaphore", "VK_KHR_external_memory_win32", diff --git a/external/vulkancts/framework/vulkan/vkFunctionPointerTypes.inl b/external/vulkancts/framework/vulkan/vkFunctionPointerTypes.inl index fcdf1b0..c8e1ea9 100644 --- a/external/vulkancts/framework/vulkan/vkFunctionPointerTypes.inl +++ b/external/vulkancts/framework/vulkan/vkFunctionPointerTypes.inl @@ -428,6 +428,20 @@ typedef VKAPI_ATTR void (VKAPI_CALL* CmdSetRayTracingPipelineStackSizeKHRFun typedef VKAPI_ATTR VkResult (VKAPI_CALL* CreateAndroidSurfaceKHRFunc) (VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); typedef VKAPI_ATTR VkResult (VKAPI_CALL* GetAndroidHardwareBufferPropertiesANDROIDFunc) (VkDevice device, const struct pt::AndroidHardwareBufferPtr buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties); typedef VKAPI_ATTR VkResult (VKAPI_CALL* GetMemoryAndroidHardwareBufferANDROIDFunc) (VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct pt::AndroidHardwareBufferPtr* pBuffer); +typedef VKAPI_ATTR VkResult (VKAPI_CALL* GetPhysicalDeviceVideoCapabilitiesKHRFunc) (VkPhysicalDevice physicalDevice, const VkVideoProfileKHR* pVideoProfile, VkVideoCapabilitiesKHR* pCapabilities); +typedef VKAPI_ATTR VkResult (VKAPI_CALL* GetPhysicalDeviceVideoFormatPropertiesKHRFunc) (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, deUint32* pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR* pVideoFormatProperties); +typedef VKAPI_ATTR VkResult (VKAPI_CALL* CreateVideoSessionKHRFunc) (VkDevice device, const VkVideoSessionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionKHR* pVideoSession); +typedef VKAPI_ATTR void (VKAPI_CALL* DestroyVideoSessionKHRFunc) (VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks* pAllocator); +typedef VKAPI_ATTR VkResult (VKAPI_CALL* GetVideoSessionMemoryRequirementsKHRFunc) (VkDevice device, VkVideoSessionKHR videoSession, deUint32* pVideoSessionMemoryRequirementsCount, VkVideoGetMemoryPropertiesKHR* pVideoSessionMemoryRequirements); +typedef VKAPI_ATTR VkResult (VKAPI_CALL* BindVideoSessionMemoryKHRFunc) (VkDevice device, VkVideoSessionKHR videoSession, deUint32 videoSessionBindMemoryCount, const VkVideoBindMemoryKHR* pVideoSessionBindMemories); +typedef VKAPI_ATTR VkResult (VKAPI_CALL* CreateVideoSessionParametersKHRFunc) (VkDevice device, const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionParametersKHR* pVideoSessionParameters); +typedef VKAPI_ATTR VkResult (VKAPI_CALL* UpdateVideoSessionParametersKHRFunc) (VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo); +typedef VKAPI_ATTR void (VKAPI_CALL* DestroyVideoSessionParametersKHRFunc) (VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkAllocationCallbacks* pAllocator); +typedef VKAPI_ATTR void (VKAPI_CALL* CmdBeginVideoCodingKHRFunc) (VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR* pBeginInfo); +typedef VKAPI_ATTR void (VKAPI_CALL* CmdEndVideoCodingKHRFunc) (VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR* pEndCodingInfo); +typedef VKAPI_ATTR void (VKAPI_CALL* CmdControlVideoCodingKHRFunc) (VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR* pCodingControlInfo); +typedef VKAPI_ATTR void (VKAPI_CALL* CmdDecodeVideoKHRFunc) (VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR* pFrameInfo); +typedef VKAPI_ATTR void (VKAPI_CALL* CmdEncodeVideoKHRFunc) (VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo); typedef VKAPI_ATTR VkResult (VKAPI_CALL* CreateImagePipeSurfaceFUCHSIAFunc) (VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); typedef VKAPI_ATTR VkResult (VKAPI_CALL* GetMemoryZirconHandleFUCHSIAFunc) (VkDevice device, const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, pt::zx_handle_t* pZirconHandle); typedef VKAPI_ATTR VkResult (VKAPI_CALL* GetMemoryZirconHandlePropertiesFUCHSIAFunc) (VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, pt::zx_handle_t zirconHandle, VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties); diff --git a/external/vulkancts/framework/vulkan/vkGetStructureTypeImpl.inl b/external/vulkancts/framework/vulkan/vkGetStructureTypeImpl.inl index 8847138..35602bf 100644 --- a/external/vulkancts/framework/vulkan/vkGetStructureTypeImpl.inl +++ b/external/vulkancts/framework/vulkan/vkGetStructureTypeImpl.inl @@ -2296,6 +2296,91 @@ template<> VkStructureType getStructureType (void) return VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID; } +template<> VkStructureType getStructureType (void) +{ + return VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR; +} + +template<> VkStructureType getStructureType (void) +{ + return VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR; +} + +template<> VkStructureType getStructureType (void) +{ + return VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR; +} + +template<> VkStructureType getStructureType (void) +{ + return VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR; +} + +template<> VkStructureType getStructureType (void) +{ + return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR; +} + +template<> VkStructureType getStructureType (void) +{ + return VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR; +} + +template<> VkStructureType getStructureType (void) +{ + return VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_KHR; +} + +template<> VkStructureType getStructureType (void) +{ + return VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_KHR; +} + +template<> VkStructureType getStructureType (void) +{ + return VK_STRUCTURE_TYPE_VIDEO_GET_MEMORY_PROPERTIES_KHR; +} + +template<> VkStructureType getStructureType (void) +{ + return VK_STRUCTURE_TYPE_VIDEO_BIND_MEMORY_KHR; +} + +template<> VkStructureType getStructureType (void) +{ + return VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR; +} + +template<> VkStructureType getStructureType (void) +{ + return VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR; +} + +template<> VkStructureType getStructureType (void) +{ + return VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR; +} + +template<> VkStructureType getStructureType (void) +{ + return VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR; +} + +template<> VkStructureType getStructureType (void) +{ + return VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR; +} + +template<> VkStructureType getStructureType (void) +{ + return VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR; +} + +template<> VkStructureType getStructureType (void) +{ + return VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR; +} + template<> VkStructureType getStructureType (void) { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR; @@ -2306,6 +2391,136 @@ template<> VkStructureType getStructureType VkStructureType getStructureType (void) +{ + return VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR; +} + +template<> VkStructureType getStructureType (void) +{ + return VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR; +} + +template<> VkStructureType getStructureType (void) +{ + return VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT; +} + +template<> VkStructureType getStructureType (void) +{ + return VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT; +} + +template<> VkStructureType getStructureType (void) +{ + return VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT; +} + +template<> VkStructureType getStructureType (void) +{ + return VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT; +} + +template<> VkStructureType getStructureType (void) +{ + return VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT; +} + +template<> VkStructureType getStructureType (void) +{ + return VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_EXT; +} + +template<> VkStructureType getStructureType (void) +{ + return VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT; +} + +template<> VkStructureType getStructureType (void) +{ + return VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT; +} + +template<> VkStructureType getStructureType (void) +{ + return VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT; +} + +template<> VkStructureType getStructureType (void) +{ + return VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT; +} + +template<> VkStructureType getStructureType (void) +{ + return VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT; +} + +template<> VkStructureType getStructureType (void) +{ + return VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT; +} + +template<> VkStructureType getStructureType (void) +{ + return VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT; +} + +template<> VkStructureType getStructureType (void) +{ + return VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT; +} + +template<> VkStructureType getStructureType (void) +{ + return VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_EXT; +} + +template<> VkStructureType getStructureType (void) +{ + return VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_EXT; +} + +template<> VkStructureType getStructureType (void) +{ + return VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT; +} + +template<> VkStructureType getStructureType (void) +{ + return VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_EXT; +} + +template<> VkStructureType getStructureType (void) +{ + return VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT; +} + +template<> VkStructureType getStructureType (void) +{ + return VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT; +} + +template<> VkStructureType getStructureType (void) +{ + return VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT; +} + +template<> VkStructureType getStructureType (void) +{ + return VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT; +} + +template<> VkStructureType getStructureType (void) +{ + return VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT; +} + +template<> VkStructureType getStructureType (void) +{ + return VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT; +} + template<> VkStructureType getStructureType (void) { return VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA; diff --git a/external/vulkancts/framework/vulkan/vkHandleType.inl b/external/vulkancts/framework/vulkan/vkHandleType.inl index 755dbc4..b45d6c6 100644 --- a/external/vulkancts/framework/vulkan/vkHandleType.inl +++ b/external/vulkancts/framework/vulkan/vkHandleType.inl @@ -43,8 +43,10 @@ enum HandleType HANDLE_TYPE_INDIRECT_COMMANDS_LAYOUT_NV, HANDLE_TYPE_PRIVATE_DATA_SLOT_EXT, HANDLE_TYPE_ACCELERATION_STRUCTURE_KHR, + HANDLE_TYPE_VIDEO_SESSION_KHR, + HANDLE_TYPE_VIDEO_SESSION_PARAMETERS_KHR, HANDLE_TYPE_SAMPLER_YCBCR_CONVERSION_KHR = HANDLE_TYPE_SAMPLER_YCBCR_CONVERSION, HANDLE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR = HANDLE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE, - HANDLE_TYPE_LAST = HANDLE_TYPE_ACCELERATION_STRUCTURE_KHR + 1 + HANDLE_TYPE_LAST = HANDLE_TYPE_VIDEO_SESSION_PARAMETERS_KHR + 1 }; diff --git a/external/vulkancts/framework/vulkan/vkInitDeviceFunctionPointers.inl b/external/vulkancts/framework/vulkan/vkInitDeviceFunctionPointers.inl index c9c31b9..bff3ce4 100644 --- a/external/vulkancts/framework/vulkan/vkInitDeviceFunctionPointers.inl +++ b/external/vulkancts/framework/vulkan/vkInitDeviceFunctionPointers.inl @@ -377,6 +377,18 @@ m_vk.getRayTracingShaderGroupStackSizeKHR = (GetRayTracingShaderGroupStackSiz m_vk.cmdSetRayTracingPipelineStackSizeKHR = (CmdSetRayTracingPipelineStackSizeKHRFunc) GET_PROC_ADDR("vkCmdSetRayTracingPipelineStackSizeKHR"); m_vk.getAndroidHardwareBufferPropertiesANDROID = (GetAndroidHardwareBufferPropertiesANDROIDFunc) GET_PROC_ADDR("vkGetAndroidHardwareBufferPropertiesANDROID"); m_vk.getMemoryAndroidHardwareBufferANDROID = (GetMemoryAndroidHardwareBufferANDROIDFunc) GET_PROC_ADDR("vkGetMemoryAndroidHardwareBufferANDROID"); +m_vk.createVideoSessionKHR = (CreateVideoSessionKHRFunc) GET_PROC_ADDR("vkCreateVideoSessionKHR"); +m_vk.destroyVideoSessionKHR = (DestroyVideoSessionKHRFunc) GET_PROC_ADDR("vkDestroyVideoSessionKHR"); +m_vk.getVideoSessionMemoryRequirementsKHR = (GetVideoSessionMemoryRequirementsKHRFunc) GET_PROC_ADDR("vkGetVideoSessionMemoryRequirementsKHR"); +m_vk.bindVideoSessionMemoryKHR = (BindVideoSessionMemoryKHRFunc) GET_PROC_ADDR("vkBindVideoSessionMemoryKHR"); +m_vk.createVideoSessionParametersKHR = (CreateVideoSessionParametersKHRFunc) GET_PROC_ADDR("vkCreateVideoSessionParametersKHR"); +m_vk.updateVideoSessionParametersKHR = (UpdateVideoSessionParametersKHRFunc) GET_PROC_ADDR("vkUpdateVideoSessionParametersKHR"); +m_vk.destroyVideoSessionParametersKHR = (DestroyVideoSessionParametersKHRFunc) GET_PROC_ADDR("vkDestroyVideoSessionParametersKHR"); +m_vk.cmdBeginVideoCodingKHR = (CmdBeginVideoCodingKHRFunc) GET_PROC_ADDR("vkCmdBeginVideoCodingKHR"); +m_vk.cmdEndVideoCodingKHR = (CmdEndVideoCodingKHRFunc) GET_PROC_ADDR("vkCmdEndVideoCodingKHR"); +m_vk.cmdControlVideoCodingKHR = (CmdControlVideoCodingKHRFunc) GET_PROC_ADDR("vkCmdControlVideoCodingKHR"); +m_vk.cmdDecodeVideoKHR = (CmdDecodeVideoKHRFunc) GET_PROC_ADDR("vkCmdDecodeVideoKHR"); +m_vk.cmdEncodeVideoKHR = (CmdEncodeVideoKHRFunc) GET_PROC_ADDR("vkCmdEncodeVideoKHR"); m_vk.getMemoryZirconHandleFUCHSIA = (GetMemoryZirconHandleFUCHSIAFunc) GET_PROC_ADDR("vkGetMemoryZirconHandleFUCHSIA"); m_vk.getMemoryZirconHandlePropertiesFUCHSIA = (GetMemoryZirconHandlePropertiesFUCHSIAFunc) GET_PROC_ADDR("vkGetMemoryZirconHandlePropertiesFUCHSIA"); m_vk.importSemaphoreZirconHandleFUCHSIA = (ImportSemaphoreZirconHandleFUCHSIAFunc) GET_PROC_ADDR("vkImportSemaphoreZirconHandleFUCHSIA"); diff --git a/external/vulkancts/framework/vulkan/vkInitInstanceFunctionPointers.inl b/external/vulkancts/framework/vulkan/vkInitInstanceFunctionPointers.inl index 91762e4..9f93b6d 100644 --- a/external/vulkancts/framework/vulkan/vkInitInstanceFunctionPointers.inl +++ b/external/vulkancts/framework/vulkan/vkInitInstanceFunctionPointers.inl @@ -96,6 +96,8 @@ m_vk.createHeadlessSurfaceEXT = (CreateHeadlessSurfaceEXTFunc) m_vk.acquireWinrtDisplayNV = (AcquireWinrtDisplayNVFunc) GET_PROC_ADDR("vkAcquireWinrtDisplayNV"); m_vk.getWinrtDisplayNV = (GetWinrtDisplayNVFunc) GET_PROC_ADDR("vkGetWinrtDisplayNV"); m_vk.createAndroidSurfaceKHR = (CreateAndroidSurfaceKHRFunc) GET_PROC_ADDR("vkCreateAndroidSurfaceKHR"); +m_vk.getPhysicalDeviceVideoCapabilitiesKHR = (GetPhysicalDeviceVideoCapabilitiesKHRFunc) GET_PROC_ADDR("vkGetPhysicalDeviceVideoCapabilitiesKHR"); +m_vk.getPhysicalDeviceVideoFormatPropertiesKHR = (GetPhysicalDeviceVideoFormatPropertiesKHRFunc) GET_PROC_ADDR("vkGetPhysicalDeviceVideoFormatPropertiesKHR"); m_vk.createImagePipeSurfaceFUCHSIA = (CreateImagePipeSurfaceFUCHSIAFunc) GET_PROC_ADDR("vkCreateImagePipeSurfaceFUCHSIA"); m_vk.createStreamDescriptorSurfaceGGP = (CreateStreamDescriptorSurfaceGGPFunc) GET_PROC_ADDR("vkCreateStreamDescriptorSurfaceGGP"); m_vk.createIOSSurfaceMVK = (CreateIOSSurfaceMVKFunc) GET_PROC_ADDR("vkCreateIOSSurfaceMVK"); diff --git a/external/vulkancts/framework/vulkan/vkInstanceDriverImpl.inl b/external/vulkancts/framework/vulkan/vkInstanceDriverImpl.inl index 35287ab..3e21058 100644 --- a/external/vulkancts/framework/vulkan/vkInstanceDriverImpl.inl +++ b/external/vulkancts/framework/vulkan/vkInstanceDriverImpl.inl @@ -367,6 +367,16 @@ VkResult InstanceDriver::createAndroidSurfaceKHR (VkInstance instance, const VkA return m_vk.createAndroidSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); } +VkResult InstanceDriver::getPhysicalDeviceVideoCapabilitiesKHR (VkPhysicalDevice physicalDevice, const VkVideoProfileKHR* pVideoProfile, VkVideoCapabilitiesKHR* pCapabilities) const +{ + return m_vk.getPhysicalDeviceVideoCapabilitiesKHR(physicalDevice, pVideoProfile, pCapabilities); +} + +VkResult InstanceDriver::getPhysicalDeviceVideoFormatPropertiesKHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, deUint32* pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR* pVideoFormatProperties) const +{ + return m_vk.getPhysicalDeviceVideoFormatPropertiesKHR(physicalDevice, pVideoFormatInfo, pVideoFormatPropertyCount, pVideoFormatProperties); +} + VkResult InstanceDriver::createImagePipeSurfaceFUCHSIA (VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) const { return m_vk.createImagePipeSurfaceFUCHSIA(instance, pCreateInfo, pAllocator, pSurface); diff --git a/external/vulkancts/framework/vulkan/vkInstanceFunctionPointers.inl b/external/vulkancts/framework/vulkan/vkInstanceFunctionPointers.inl index a0b66a3..9355e33 100644 --- a/external/vulkancts/framework/vulkan/vkInstanceFunctionPointers.inl +++ b/external/vulkancts/framework/vulkan/vkInstanceFunctionPointers.inl @@ -74,6 +74,8 @@ CreateHeadlessSurfaceEXTFunc createHeadlessSurfaceEXT; AcquireWinrtDisplayNVFunc acquireWinrtDisplayNV; GetWinrtDisplayNVFunc getWinrtDisplayNV; CreateAndroidSurfaceKHRFunc createAndroidSurfaceKHR; +GetPhysicalDeviceVideoCapabilitiesKHRFunc getPhysicalDeviceVideoCapabilitiesKHR; +GetPhysicalDeviceVideoFormatPropertiesKHRFunc getPhysicalDeviceVideoFormatPropertiesKHR; CreateImagePipeSurfaceFUCHSIAFunc createImagePipeSurfaceFUCHSIA; CreateStreamDescriptorSurfaceGGPFunc createStreamDescriptorSurfaceGGP; CreateIOSSurfaceMVKFunc createIOSSurfaceMVK; diff --git a/external/vulkancts/framework/vulkan/vkNullDriver.cpp b/external/vulkancts/framework/vulkan/vkNullDriver.cpp index 3ddeb4b..b0dfcea 100644 --- a/external/vulkancts/framework/vulkan/vkNullDriver.cpp +++ b/external/vulkancts/framework/vulkan/vkNullDriver.cpp @@ -545,6 +545,20 @@ public: {} }; +class VideoSessionKHR +{ +public: + VideoSessionKHR (VkDevice, const VkVideoSessionCreateInfoKHR*) + {} +}; + +class VideoSessionParametersKHR +{ +public: + VideoSessionParametersKHR (VkDevice, const VkVideoSessionParametersCreateInfoKHR*) + {} +}; + class ValidationCacheEXT { public: diff --git a/external/vulkancts/framework/vulkan/vkNullDriverImpl.inl b/external/vulkancts/framework/vulkan/vkNullDriverImpl.inl index e3c2234..33ee9d3 100644 --- a/external/vulkancts/framework/vulkan/vkNullDriverImpl.inl +++ b/external/vulkancts/framework/vulkan/vkNullDriverImpl.inl @@ -205,6 +205,18 @@ VKAPI_ATTR VkResult VKAPI_CALL createAndroidSurfaceKHR (VkInstance instance, con VK_NULL_RETURN((*pSurface = allocateNonDispHandle(instance, pCreateInfo, pAllocator))); } +VKAPI_ATTR VkResult VKAPI_CALL createVideoSessionKHR (VkDevice device, const VkVideoSessionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionKHR* pVideoSession) +{ + DE_UNREF(pAllocator); + VK_NULL_RETURN((*pVideoSession = allocateNonDispHandle(device, pCreateInfo, pAllocator))); +} + +VKAPI_ATTR VkResult VKAPI_CALL createVideoSessionParametersKHR (VkDevice device, const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionParametersKHR* pVideoSessionParameters) +{ + DE_UNREF(pAllocator); + VK_NULL_RETURN((*pVideoSessionParameters = allocateNonDispHandle(device, pCreateInfo, pAllocator))); +} + VKAPI_ATTR VkResult VKAPI_CALL createImagePipeSurfaceFUCHSIA (VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { DE_UNREF(pAllocator); @@ -461,6 +473,18 @@ VKAPI_ATTR void VKAPI_CALL destroyAccelerationStructureKHR (VkDevice device, VkA freeNonDispHandle(accelerationStructure, pAllocator); } +VKAPI_ATTR void VKAPI_CALL destroyVideoSessionKHR (VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks* pAllocator) +{ + DE_UNREF(device); + freeNonDispHandle(videoSession, pAllocator); +} + +VKAPI_ATTR void VKAPI_CALL destroyVideoSessionParametersKHR (VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkAllocationCallbacks* pAllocator) +{ + DE_UNREF(device); + freeNonDispHandle(videoSessionParameters, pAllocator); +} + VKAPI_ATTR VkResult VKAPI_CALL enumerateInstanceLayerProperties (deUint32* pPropertyCount, VkLayerProperties* pProperties) { DE_UNREF(pPropertyCount); @@ -2814,6 +2838,79 @@ VKAPI_ATTR VkResult VKAPI_CALL getAndroidHardwareBufferPropertiesANDROID (VkDevi return VK_SUCCESS; } +VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceVideoCapabilitiesKHR (VkPhysicalDevice physicalDevice, const VkVideoProfileKHR* pVideoProfile, VkVideoCapabilitiesKHR* pCapabilities) +{ + DE_UNREF(physicalDevice); + DE_UNREF(pVideoProfile); + DE_UNREF(pCapabilities); + return VK_SUCCESS; +} + +VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceVideoFormatPropertiesKHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, deUint32* pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR* pVideoFormatProperties) +{ + DE_UNREF(physicalDevice); + DE_UNREF(pVideoFormatInfo); + DE_UNREF(pVideoFormatPropertyCount); + DE_UNREF(pVideoFormatProperties); + return VK_SUCCESS; +} + +VKAPI_ATTR VkResult VKAPI_CALL getVideoSessionMemoryRequirementsKHR (VkDevice device, VkVideoSessionKHR videoSession, deUint32* pVideoSessionMemoryRequirementsCount, VkVideoGetMemoryPropertiesKHR* pVideoSessionMemoryRequirements) +{ + DE_UNREF(device); + DE_UNREF(videoSession); + DE_UNREF(pVideoSessionMemoryRequirementsCount); + DE_UNREF(pVideoSessionMemoryRequirements); + return VK_SUCCESS; +} + +VKAPI_ATTR VkResult VKAPI_CALL bindVideoSessionMemoryKHR (VkDevice device, VkVideoSessionKHR videoSession, deUint32 videoSessionBindMemoryCount, const VkVideoBindMemoryKHR* pVideoSessionBindMemories) +{ + DE_UNREF(device); + DE_UNREF(videoSession); + DE_UNREF(videoSessionBindMemoryCount); + DE_UNREF(pVideoSessionBindMemories); + return VK_SUCCESS; +} + +VKAPI_ATTR VkResult VKAPI_CALL updateVideoSessionParametersKHR (VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo) +{ + DE_UNREF(device); + DE_UNREF(videoSessionParameters); + DE_UNREF(pUpdateInfo); + return VK_SUCCESS; +} + +VKAPI_ATTR void VKAPI_CALL cmdBeginVideoCodingKHR (VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR* pBeginInfo) +{ + DE_UNREF(commandBuffer); + DE_UNREF(pBeginInfo); +} + +VKAPI_ATTR void VKAPI_CALL cmdEndVideoCodingKHR (VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR* pEndCodingInfo) +{ + DE_UNREF(commandBuffer); + DE_UNREF(pEndCodingInfo); +} + +VKAPI_ATTR void VKAPI_CALL cmdControlVideoCodingKHR (VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR* pCodingControlInfo) +{ + DE_UNREF(commandBuffer); + DE_UNREF(pCodingControlInfo); +} + +VKAPI_ATTR void VKAPI_CALL cmdDecodeVideoKHR (VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR* pFrameInfo) +{ + DE_UNREF(commandBuffer); + DE_UNREF(pFrameInfo); +} + +VKAPI_ATTR void VKAPI_CALL cmdEncodeVideoKHR (VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo) +{ + DE_UNREF(commandBuffer); + DE_UNREF(pEncodeInfo); +} + VKAPI_ATTR VkResult VKAPI_CALL getMemoryZirconHandleFUCHSIA (VkDevice device, const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, pt::zx_handle_t* pZirconHandle) { DE_UNREF(device); @@ -3068,6 +3165,8 @@ static const tcu::StaticFunctionLibrary::Entry s_instanceFunctions[] = VK_NULL_FUNC_ENTRY(vkAcquireWinrtDisplayNV, acquireWinrtDisplayNV), VK_NULL_FUNC_ENTRY(vkGetWinrtDisplayNV, getWinrtDisplayNV), VK_NULL_FUNC_ENTRY(vkCreateAndroidSurfaceKHR, createAndroidSurfaceKHR), + VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceVideoCapabilitiesKHR, getPhysicalDeviceVideoCapabilitiesKHR), + VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceVideoFormatPropertiesKHR, getPhysicalDeviceVideoFormatPropertiesKHR), VK_NULL_FUNC_ENTRY(vkCreateImagePipeSurfaceFUCHSIA, createImagePipeSurfaceFUCHSIA), VK_NULL_FUNC_ENTRY(vkCreateStreamDescriptorSurfaceGGP, createStreamDescriptorSurfaceGGP), VK_NULL_FUNC_ENTRY(vkCreateIOSSurfaceMVK, createIOSSurfaceMVK), @@ -3437,6 +3536,18 @@ static const tcu::StaticFunctionLibrary::Entry s_deviceFunctions[] = VK_NULL_FUNC_ENTRY(vkCmdSetRayTracingPipelineStackSizeKHR, cmdSetRayTracingPipelineStackSizeKHR), VK_NULL_FUNC_ENTRY(vkGetAndroidHardwareBufferPropertiesANDROID, getAndroidHardwareBufferPropertiesANDROID), VK_NULL_FUNC_ENTRY(vkGetMemoryAndroidHardwareBufferANDROID, getMemoryAndroidHardwareBufferANDROID), + VK_NULL_FUNC_ENTRY(vkCreateVideoSessionKHR, createVideoSessionKHR), + VK_NULL_FUNC_ENTRY(vkDestroyVideoSessionKHR, destroyVideoSessionKHR), + VK_NULL_FUNC_ENTRY(vkGetVideoSessionMemoryRequirementsKHR, getVideoSessionMemoryRequirementsKHR), + VK_NULL_FUNC_ENTRY(vkBindVideoSessionMemoryKHR, bindVideoSessionMemoryKHR), + VK_NULL_FUNC_ENTRY(vkCreateVideoSessionParametersKHR, createVideoSessionParametersKHR), + VK_NULL_FUNC_ENTRY(vkUpdateVideoSessionParametersKHR, updateVideoSessionParametersKHR), + VK_NULL_FUNC_ENTRY(vkDestroyVideoSessionParametersKHR, destroyVideoSessionParametersKHR), + VK_NULL_FUNC_ENTRY(vkCmdBeginVideoCodingKHR, cmdBeginVideoCodingKHR), + VK_NULL_FUNC_ENTRY(vkCmdEndVideoCodingKHR, cmdEndVideoCodingKHR), + VK_NULL_FUNC_ENTRY(vkCmdControlVideoCodingKHR, cmdControlVideoCodingKHR), + VK_NULL_FUNC_ENTRY(vkCmdDecodeVideoKHR, cmdDecodeVideoKHR), + VK_NULL_FUNC_ENTRY(vkCmdEncodeVideoKHR, cmdEncodeVideoKHR), VK_NULL_FUNC_ENTRY(vkGetMemoryZirconHandleFUCHSIA, getMemoryZirconHandleFUCHSIA), VK_NULL_FUNC_ENTRY(vkGetMemoryZirconHandlePropertiesFUCHSIA, getMemoryZirconHandlePropertiesFUCHSIA), VK_NULL_FUNC_ENTRY(vkImportSemaphoreZirconHandleFUCHSIA, importSemaphoreZirconHandleFUCHSIA), diff --git a/external/vulkancts/framework/vulkan/vkObjTypeImpl.inl b/external/vulkancts/framework/vulkan/vkObjTypeImpl.inl index 7ab87b9..10bc0ed 100644 --- a/external/vulkancts/framework/vulkan/vkObjTypeImpl.inl +++ b/external/vulkancts/framework/vulkan/vkObjTypeImpl.inl @@ -44,4 +44,6 @@ template<> inline VkObjectType getObjectType (v template<> inline VkObjectType getObjectType (void) { return VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV; } template<> inline VkObjectType getObjectType (void) { return VK_OBJECT_TYPE_PRIVATE_DATA_SLOT_EXT; } template<> inline VkObjectType getObjectType (void) { return VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR; } +template<> inline VkObjectType getObjectType (void) { return VK_OBJECT_TYPE_VIDEO_SESSION_KHR; } +template<> inline VkObjectType getObjectType (void) { return VK_OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR; } } diff --git a/external/vulkancts/framework/vulkan/vkRefUtil.inl b/external/vulkancts/framework/vulkan/vkRefUtil.inl index 68b4fab..5df489b 100644 --- a/external/vulkancts/framework/vulkan/vkRefUtil.inl +++ b/external/vulkancts/framework/vulkan/vkRefUtil.inl @@ -37,6 +37,8 @@ Move createIndirectCommandsLayoutNV (const DeviceIn Move createPrivateDataSlotEXT (const DeviceInterface& vk, VkDevice device, const VkPrivateDataSlotCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL); Move createAccelerationStructureKHR (const DeviceInterface& vk, VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL); Move createAndroidSurfaceKHR (const InstanceInterface& vk, VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL); +Move createVideoSessionKHR (const DeviceInterface& vk, VkDevice device, const VkVideoSessionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL); +Move createVideoSessionParametersKHR (const DeviceInterface& vk, VkDevice device, const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL); Move createImagePipeSurfaceFUCHSIA (const InstanceInterface& vk, VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL); Move createStreamDescriptorSurfaceGGP (const InstanceInterface& vk, VkInstance instance, const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL); Move createIOSSurfaceMVK (const InstanceInterface& vk, VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL); diff --git a/external/vulkancts/framework/vulkan/vkRefUtilImpl.inl b/external/vulkancts/framework/vulkan/vkRefUtilImpl.inl index bbdef34..74f4ccf 100644 --- a/external/vulkancts/framework/vulkan/vkRefUtilImpl.inl +++ b/external/vulkancts/framework/vulkan/vkRefUtilImpl.inl @@ -172,6 +172,18 @@ void Deleter::operator() (VkAccelerationStructureKHR m_deviceIface->destroyAccelerationStructureKHR(m_device, obj, m_allocator); } +template<> +void Deleter::operator() (VkVideoSessionKHR obj) const +{ + m_deviceIface->destroyVideoSessionKHR(m_device, obj, m_allocator); +} + +template<> +void Deleter::operator() (VkVideoSessionParametersKHR obj) const +{ + m_deviceIface->destroyVideoSessionParametersKHR(m_device, obj, m_allocator); +} + } // refdetails Move createInstance (const PlatformInterface& vk, const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator) @@ -426,6 +438,20 @@ Move createAndroidSurfaceKHR (const InstanceInterface& vk, VkInsta return Move(check(object), Deleter(vk, instance, pAllocator)); } +Move createVideoSessionKHR (const DeviceInterface& vk, VkDevice device, const VkVideoSessionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator) +{ + VkVideoSessionKHR object = 0; + VK_CHECK(vk.createVideoSessionKHR(device, pCreateInfo, pAllocator, &object)); + return Move(check(object), Deleter(vk, device, pAllocator)); +} + +Move createVideoSessionParametersKHR (const DeviceInterface& vk, VkDevice device, const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator) +{ + VkVideoSessionParametersKHR object = 0; + VK_CHECK(vk.createVideoSessionParametersKHR(device, pCreateInfo, pAllocator, &object)); + return Move(check(object), Deleter(vk, device, pAllocator)); +} + Move createImagePipeSurfaceFUCHSIA (const InstanceInterface& vk, VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator) { VkSurfaceKHR object = 0; diff --git a/external/vulkancts/framework/vulkan/vkStrUtil.inl b/external/vulkancts/framework/vulkan/vkStrUtil.inl index 03d94ad..2c16e80 100644 --- a/external/vulkancts/framework/vulkan/vkStrUtil.inl +++ b/external/vulkancts/framework/vulkan/vkStrUtil.inl @@ -97,6 +97,23 @@ const char* getBuildAccelerationStructureModeKHRName (VkBuildAccelerationStru const char* getAccelerationStructureBuildTypeKHRName (VkAccelerationStructureBuildTypeKHR value); const char* getAccelerationStructureCompatibilityKHRName (VkAccelerationStructureCompatibilityKHR value); const char* getShaderGroupShaderKHRName (VkShaderGroupShaderKHR value); +const char* getQueryResultStatusKHRName (VkQueryResultStatusKHR value); +const char* getdVideoH264ChromaFormatIdcName (StdVideoH264ChromaFormatIdc value); +const char* getdVideoH264ProfileIdcName (StdVideoH264ProfileIdc value); +const char* getdVideoH264LevelName (StdVideoH264Level value); +const char* getdVideoH264PocTypeName (StdVideoH264PocType value); +const char* getdVideoH264AspectRatioIdcName (StdVideoH264AspectRatioIdc value); +const char* getdVideoH264WeightedBiPredIdcName (StdVideoH264WeightedBiPredIdc value); +const char* getdVideoH264ModificationOfPicNumsIdcName (StdVideoH264ModificationOfPicNumsIdc value); +const char* getdVideoH264MemMgmtControlOpName (StdVideoH264MemMgmtControlOp value); +const char* getdVideoH264CabacInitIdcName (StdVideoH264CabacInitIdc value); +const char* getdVideoH264DisableDeblockingFilterIdcName (StdVideoH264DisableDeblockingFilterIdc value); +const char* getdVideoH264PictureTypeName (StdVideoH264PictureType value); +const char* getdVideoH264SliceTypeName (StdVideoH264SliceType value); +const char* getdVideoH264NonVclNaluTypeName (StdVideoH264NonVclNaluType value); +const char* getdVideoH265ChromaFormatIdcName (StdVideoH265ChromaFormatIdc value); +const char* getdVideoH265ProfileIdcName (StdVideoH265ProfileIdc value); +const char* getdVideoH265LevelName (StdVideoH265Level value); const char* getFullScreenExclusiveEXTName (VkFullScreenExclusiveEXT value); inline tcu::Format::Enum getResultStr (VkResult value) { return tcu::Format::Enum(getResultName, value); } @@ -195,6 +212,23 @@ inline tcu::Format::Enum getBuildAcceler inline tcu::Format::Enum getAccelerationStructureBuildTypeKHRStr (VkAccelerationStructureBuildTypeKHR value) { return tcu::Format::Enum(getAccelerationStructureBuildTypeKHRName, value); } inline tcu::Format::Enum getAccelerationStructureCompatibilityKHRStr (VkAccelerationStructureCompatibilityKHR value) { return tcu::Format::Enum(getAccelerationStructureCompatibilityKHRName, value); } inline tcu::Format::Enum getShaderGroupShaderKHRStr (VkShaderGroupShaderKHR value) { return tcu::Format::Enum(getShaderGroupShaderKHRName, value); } +inline tcu::Format::Enum getQueryResultStatusKHRStr (VkQueryResultStatusKHR value) { return tcu::Format::Enum(getQueryResultStatusKHRName, value); } +inline tcu::Format::Enum getdVideoH264ChromaFormatIdcStr (StdVideoH264ChromaFormatIdc value) { return tcu::Format::Enum(getdVideoH264ChromaFormatIdcName, value); } +inline tcu::Format::Enum getdVideoH264ProfileIdcStr (StdVideoH264ProfileIdc value) { return tcu::Format::Enum(getdVideoH264ProfileIdcName, value); } +inline tcu::Format::Enum getdVideoH264LevelStr (StdVideoH264Level value) { return tcu::Format::Enum(getdVideoH264LevelName, value); } +inline tcu::Format::Enum getdVideoH264PocTypeStr (StdVideoH264PocType value) { return tcu::Format::Enum(getdVideoH264PocTypeName, value); } +inline tcu::Format::Enum getdVideoH264AspectRatioIdcStr (StdVideoH264AspectRatioIdc value) { return tcu::Format::Enum(getdVideoH264AspectRatioIdcName, value); } +inline tcu::Format::Enum getdVideoH264WeightedBiPredIdcStr (StdVideoH264WeightedBiPredIdc value) { return tcu::Format::Enum(getdVideoH264WeightedBiPredIdcName, value); } +inline tcu::Format::Enum getdVideoH264ModificationOfPicNumsIdcStr (StdVideoH264ModificationOfPicNumsIdc value) { return tcu::Format::Enum(getdVideoH264ModificationOfPicNumsIdcName, value); } +inline tcu::Format::Enum getdVideoH264MemMgmtControlOpStr (StdVideoH264MemMgmtControlOp value) { return tcu::Format::Enum(getdVideoH264MemMgmtControlOpName, value); } +inline tcu::Format::Enum getdVideoH264CabacInitIdcStr (StdVideoH264CabacInitIdc value) { return tcu::Format::Enum(getdVideoH264CabacInitIdcName, value); } +inline tcu::Format::Enum getdVideoH264DisableDeblockingFilterIdcStr (StdVideoH264DisableDeblockingFilterIdc value) { return tcu::Format::Enum(getdVideoH264DisableDeblockingFilterIdcName, value); } +inline tcu::Format::Enum getdVideoH264PictureTypeStr (StdVideoH264PictureType value) { return tcu::Format::Enum(getdVideoH264PictureTypeName, value); } +inline tcu::Format::Enum getdVideoH264SliceTypeStr (StdVideoH264SliceType value) { return tcu::Format::Enum(getdVideoH264SliceTypeName, value); } +inline tcu::Format::Enum getdVideoH264NonVclNaluTypeStr (StdVideoH264NonVclNaluType value) { return tcu::Format::Enum(getdVideoH264NonVclNaluTypeName, value); } +inline tcu::Format::Enum getdVideoH265ChromaFormatIdcStr (StdVideoH265ChromaFormatIdc value) { return tcu::Format::Enum(getdVideoH265ChromaFormatIdcName, value); } +inline tcu::Format::Enum getdVideoH265ProfileIdcStr (StdVideoH265ProfileIdc value) { return tcu::Format::Enum(getdVideoH265ProfileIdcName, value); } +inline tcu::Format::Enum getdVideoH265LevelStr (StdVideoH265Level value) { return tcu::Format::Enum(getdVideoH265LevelName, value); } inline tcu::Format::Enum getFullScreenExclusiveEXTStr (VkFullScreenExclusiveEXT value) { return tcu::Format::Enum(getFullScreenExclusiveEXTName, value); } inline std::ostream& operator<< (std::ostream& s, VkResult value) { return s << getResultStr(value); } @@ -293,6 +327,23 @@ inline std::ostream& operator<< (std::ostream& s, VkBuildAccelerationStructureMo inline std::ostream& operator<< (std::ostream& s, VkAccelerationStructureBuildTypeKHR value) { return s << getAccelerationStructureBuildTypeKHRStr(value); } inline std::ostream& operator<< (std::ostream& s, VkAccelerationStructureCompatibilityKHR value) { return s << getAccelerationStructureCompatibilityKHRStr(value); } inline std::ostream& operator<< (std::ostream& s, VkShaderGroupShaderKHR value) { return s << getShaderGroupShaderKHRStr(value); } +inline std::ostream& operator<< (std::ostream& s, VkQueryResultStatusKHR value) { return s << getQueryResultStatusKHRStr(value); } +inline std::ostream& operator<< (std::ostream& s, StdVideoH264ChromaFormatIdc value) { return s << getdVideoH264ChromaFormatIdcStr(value); } +inline std::ostream& operator<< (std::ostream& s, StdVideoH264ProfileIdc value) { return s << getdVideoH264ProfileIdcStr(value); } +inline std::ostream& operator<< (std::ostream& s, StdVideoH264Level value) { return s << getdVideoH264LevelStr(value); } +inline std::ostream& operator<< (std::ostream& s, StdVideoH264PocType value) { return s << getdVideoH264PocTypeStr(value); } +inline std::ostream& operator<< (std::ostream& s, StdVideoH264AspectRatioIdc value) { return s << getdVideoH264AspectRatioIdcStr(value); } +inline std::ostream& operator<< (std::ostream& s, StdVideoH264WeightedBiPredIdc value) { return s << getdVideoH264WeightedBiPredIdcStr(value); } +inline std::ostream& operator<< (std::ostream& s, StdVideoH264ModificationOfPicNumsIdc value) { return s << getdVideoH264ModificationOfPicNumsIdcStr(value); } +inline std::ostream& operator<< (std::ostream& s, StdVideoH264MemMgmtControlOp value) { return s << getdVideoH264MemMgmtControlOpStr(value); } +inline std::ostream& operator<< (std::ostream& s, StdVideoH264CabacInitIdc value) { return s << getdVideoH264CabacInitIdcStr(value); } +inline std::ostream& operator<< (std::ostream& s, StdVideoH264DisableDeblockingFilterIdc value) { return s << getdVideoH264DisableDeblockingFilterIdcStr(value); } +inline std::ostream& operator<< (std::ostream& s, StdVideoH264PictureType value) { return s << getdVideoH264PictureTypeStr(value); } +inline std::ostream& operator<< (std::ostream& s, StdVideoH264SliceType value) { return s << getdVideoH264SliceTypeStr(value); } +inline std::ostream& operator<< (std::ostream& s, StdVideoH264NonVclNaluType value) { return s << getdVideoH264NonVclNaluTypeStr(value); } +inline std::ostream& operator<< (std::ostream& s, StdVideoH265ChromaFormatIdc value) { return s << getdVideoH265ChromaFormatIdcStr(value); } +inline std::ostream& operator<< (std::ostream& s, StdVideoH265ProfileIdc value) { return s << getdVideoH265ProfileIdcStr(value); } +inline std::ostream& operator<< (std::ostream& s, StdVideoH265Level value) { return s << getdVideoH265LevelStr(value); } inline std::ostream& operator<< (std::ostream& s, VkFullScreenExclusiveEXT value) { return s << getFullScreenExclusiveEXTStr(value); } tcu::Format::Bitfield<32> getAccessFlagsStr (VkAccessFlags value); @@ -377,6 +428,22 @@ tcu::Format::Bitfield<32> getIndirectCommandsLayoutUsageFlagsNVStr (VkIndire tcu::Format::Bitfield<32> getPrivateDataSlotCreateFlagsEXTStr (VkPrivateDataSlotCreateFlagsEXT value); tcu::Format::Bitfield<32> getDeviceDiagnosticsConfigFlagsNVStr (VkDeviceDiagnosticsConfigFlagsNV value); tcu::Format::Bitfield<32> getAccelerationStructureCreateFlagsKHRStr (VkAccelerationStructureCreateFlagsKHR value); +tcu::Format::Bitfield<32> getVideoCodecOperationFlagsKHRStr (VkVideoCodecOperationFlagsKHR value); +tcu::Format::Bitfield<32> getVideoChromaSubsamplingFlagsKHRStr (VkVideoChromaSubsamplingFlagsKHR value); +tcu::Format::Bitfield<32> getVideoComponentBitDepthFlagsKHRStr (VkVideoComponentBitDepthFlagsKHR value); +tcu::Format::Bitfield<32> getVideoCapabilitiesFlagsKHRStr (VkVideoCapabilitiesFlagsKHR value); +tcu::Format::Bitfield<32> getVideoSessionCreateFlagsKHRStr (VkVideoSessionCreateFlagsKHR value); +tcu::Format::Bitfield<32> getVideoCodingControlFlagsKHRStr (VkVideoCodingControlFlagsKHR value); +tcu::Format::Bitfield<32> getVideoCodingQualityPresetFlagsKHRStr (VkVideoCodingQualityPresetFlagsKHR value); +tcu::Format::Bitfield<32> getVideoDecodeFlagsKHRStr (VkVideoDecodeFlagsKHR value); +tcu::Format::Bitfield<32> getVideoEncodeFlagsKHRStr (VkVideoEncodeFlagsKHR value); +tcu::Format::Bitfield<32> getVideoEncodeRateControlFlagsKHRStr (VkVideoEncodeRateControlFlagsKHR value); +tcu::Format::Bitfield<32> getVideoEncodeRateControlModeFlagsKHRStr (VkVideoEncodeRateControlModeFlagsKHR value); +tcu::Format::Bitfield<32> getVideoEncodeH264CapabilitiesFlagsEXTStr (VkVideoEncodeH264CapabilitiesFlagsEXT value); +tcu::Format::Bitfield<32> getVideoEncodeH264InputModeFlagsEXTStr (VkVideoEncodeH264InputModeFlagsEXT value); +tcu::Format::Bitfield<32> getVideoEncodeH264OutputModeFlagsEXTStr (VkVideoEncodeH264OutputModeFlagsEXT value); +tcu::Format::Bitfield<32> getVideoEncodeH264CreateFlagsEXTStr (VkVideoEncodeH264CreateFlagsEXT value); +tcu::Format::Bitfield<32> getVideoDecodeH264FieldLayoutFlagsEXTStr (VkVideoDecodeH264FieldLayoutFlagsEXT value); tcu::Format::Bitfield<32> getInstanceCreateFlagsStr (VkInstanceCreateFlags value); tcu::Format::Bitfield<32> getDeviceCreateFlagsStr (VkDeviceCreateFlags value); tcu::Format::Bitfield<32> getMemoryMapFlagsStr (VkMemoryMapFlags value); @@ -412,6 +479,10 @@ tcu::Format::Bitfield<32> getPipelineCoverageReductionStateCreateFlagsNVStr (V tcu::Format::Bitfield<32> getHeadlessSurfaceCreateFlagsEXTStr (VkHeadlessSurfaceCreateFlagsEXT value); tcu::Format::Bitfield<32> getDeviceMemoryReportFlagsEXTStr (VkDeviceMemoryReportFlagsEXT value); tcu::Format::Bitfield<32> getAndroidSurfaceCreateFlagsKHRStr (VkAndroidSurfaceCreateFlagsKHR value); +tcu::Format::Bitfield<32> getVideoBeginCodingFlagsKHRStr (VkVideoBeginCodingFlagsKHR value); +tcu::Format::Bitfield<32> getVideoEndCodingFlagsKHRStr (VkVideoEndCodingFlagsKHR value); +tcu::Format::Bitfield<32> getVideoDecodeH264CreateFlagsEXTStr (VkVideoDecodeH264CreateFlagsEXT value); +tcu::Format::Bitfield<32> getVideoDecodeH265CreateFlagsEXTStr (VkVideoDecodeH265CreateFlagsEXT value); tcu::Format::Bitfield<32> getImagePipeSurfaceCreateFlagsFUCHSIAStr (VkImagePipeSurfaceCreateFlagsFUCHSIA value); tcu::Format::Bitfield<32> getStreamDescriptorSurfaceCreateFlagsGGPStr (VkStreamDescriptorSurfaceCreateFlagsGGP value); tcu::Format::Bitfield<32> getIOSSurfaceCreateFlagsMVKStr (VkIOSSurfaceCreateFlagsMVK value); @@ -997,8 +1068,92 @@ std::ostream& operator<< (std::ostream& s, const VkAndroidHardwareBufferFormatPr std::ostream& operator<< (std::ostream& s, const VkImportAndroidHardwareBufferInfoANDROID& value); std::ostream& operator<< (std::ostream& s, const VkMemoryGetAndroidHardwareBufferInfoANDROID& value); std::ostream& operator<< (std::ostream& s, const VkExternalFormatANDROID& value); +std::ostream& operator<< (std::ostream& s, const VkVideoQueueFamilyProperties2KHR& value); +std::ostream& operator<< (std::ostream& s, const VkVideoProfileKHR& value); +std::ostream& operator<< (std::ostream& s, const VkVideoProfilesKHR& value); +std::ostream& operator<< (std::ostream& s, const VkVideoCapabilitiesKHR& value); +std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceVideoFormatInfoKHR& value); +std::ostream& operator<< (std::ostream& s, const VkVideoFormatPropertiesKHR& value); +std::ostream& operator<< (std::ostream& s, const VkVideoPictureResourceKHR& value); +std::ostream& operator<< (std::ostream& s, const VkVideoReferenceSlotKHR& value); +std::ostream& operator<< (std::ostream& s, const VkVideoGetMemoryPropertiesKHR& value); +std::ostream& operator<< (std::ostream& s, const VkVideoBindMemoryKHR& value); +std::ostream& operator<< (std::ostream& s, const VkVideoSessionCreateInfoKHR& value); +std::ostream& operator<< (std::ostream& s, const VkVideoSessionParametersCreateInfoKHR& value); +std::ostream& operator<< (std::ostream& s, const VkVideoSessionParametersUpdateInfoKHR& value); +std::ostream& operator<< (std::ostream& s, const VkVideoBeginCodingInfoKHR& value); +std::ostream& operator<< (std::ostream& s, const VkVideoEndCodingInfoKHR& value); +std::ostream& operator<< (std::ostream& s, const VkVideoCodingControlInfoKHR& value); +std::ostream& operator<< (std::ostream& s, const VkVideoDecodeInfoKHR& value); std::ostream& operator<< (std::ostream& s, const VkPhysicalDevicePortabilitySubsetFeaturesKHR& value); std::ostream& operator<< (std::ostream& s, const VkPhysicalDevicePortabilitySubsetPropertiesKHR& value); +std::ostream& operator<< (std::ostream& s, const VkVideoEncodeInfoKHR& value); +std::ostream& operator<< (std::ostream& s, const VkVideoEncodeRateControlInfoKHR& value); +std::ostream& operator<< (std::ostream& s, const StdVideoH264SpsVuiFlags& value); +std::ostream& operator<< (std::ostream& s, const StdVideoH264HrdParameters& value); +std::ostream& operator<< (std::ostream& s, const StdVideoH264SequenceParameterSetVui& value); +std::ostream& operator<< (std::ostream& s, const StdVideoH264SpsFlags& value); +std::ostream& operator<< (std::ostream& s, const StdVideoH264ScalingLists& value); +std::ostream& operator<< (std::ostream& s, const StdVideoH264SequenceParameterSet& value); +std::ostream& operator<< (std::ostream& s, const StdVideoH264PpsFlags& value); +std::ostream& operator<< (std::ostream& s, const StdVideoH264PictureParameterSet& value); +std::ostream& operator<< (std::ostream& s, const StdVideoEncodeH264SliceHeaderFlags& value); +std::ostream& operator<< (std::ostream& s, const StdVideoEncodeH264PictureInfoFlags& value); +std::ostream& operator<< (std::ostream& s, const StdVideoEncodeH264RefMgmtFlags& value); +std::ostream& operator<< (std::ostream& s, const StdVideoEncodeH264RefListModEntry& value); +std::ostream& operator<< (std::ostream& s, const StdVideoEncodeH264RefPicMarkingEntry& value); +std::ostream& operator<< (std::ostream& s, const StdVideoEncodeH264RefMemMgmtCtrlOperations& value); +std::ostream& operator<< (std::ostream& s, const StdVideoEncodeH264PictureInfo& value); +std::ostream& operator<< (std::ostream& s, const StdVideoEncodeH264SliceHeader& value); +std::ostream& operator<< (std::ostream& s, const VkVideoEncodeH264CapabilitiesEXT& value); +std::ostream& operator<< (std::ostream& s, const VkVideoEncodeH264SessionCreateInfoEXT& value); +std::ostream& operator<< (std::ostream& s, const VkVideoEncodeH264SessionParametersAddInfoEXT& value); +std::ostream& operator<< (std::ostream& s, const VkVideoEncodeH264SessionParametersCreateInfoEXT& value); +std::ostream& operator<< (std::ostream& s, const VkVideoEncodeH264DpbSlotInfoEXT& value); +std::ostream& operator<< (std::ostream& s, const VkVideoEncodeH264NaluSliceEXT& value); +std::ostream& operator<< (std::ostream& s, const VkVideoEncodeH264VclFrameInfoEXT& value); +std::ostream& operator<< (std::ostream& s, const VkVideoEncodeH264EmitPictureParametersEXT& value); +std::ostream& operator<< (std::ostream& s, const VkVideoEncodeH264ProfileEXT& value); +std::ostream& operator<< (std::ostream& s, const StdVideoDecodeH264PictureInfoFlags& value); +std::ostream& operator<< (std::ostream& s, const StdVideoDecodeH264PictureInfo& value); +std::ostream& operator<< (std::ostream& s, const StdVideoDecodeH264ReferenceInfoFlags& value); +std::ostream& operator<< (std::ostream& s, const StdVideoDecodeH264ReferenceInfo& value); +std::ostream& operator<< (std::ostream& s, const StdVideoDecodeH264MvcElementFlags& value); +std::ostream& operator<< (std::ostream& s, const StdVideoDecodeH264MvcElement& value); +std::ostream& operator<< (std::ostream& s, const StdVideoDecodeH264Mvc& value); +std::ostream& operator<< (std::ostream& s, const VkVideoDecodeH264ProfileEXT& value); +std::ostream& operator<< (std::ostream& s, const VkVideoDecodeH264CapabilitiesEXT& value); +std::ostream& operator<< (std::ostream& s, const VkVideoDecodeH264SessionCreateInfoEXT& value); +std::ostream& operator<< (std::ostream& s, const VkVideoDecodeH264SessionParametersAddInfoEXT& value); +std::ostream& operator<< (std::ostream& s, const VkVideoDecodeH264SessionParametersCreateInfoEXT& value); +std::ostream& operator<< (std::ostream& s, const VkVideoDecodeH264PictureInfoEXT& value); +std::ostream& operator<< (std::ostream& s, const VkVideoDecodeH264MvcEXT& value); +std::ostream& operator<< (std::ostream& s, const VkVideoDecodeH264DpbSlotInfoEXT& value); +std::ostream& operator<< (std::ostream& s, const StdVideoH265DecPicBufMgr& value); +std::ostream& operator<< (std::ostream& s, const StdVideoH265SubLayerHrdParameters& value); +std::ostream& operator<< (std::ostream& s, const StdVideoH265HrdFlags& value); +std::ostream& operator<< (std::ostream& s, const StdVideoH265HrdParameters& value); +std::ostream& operator<< (std::ostream& s, const StdVideoH265VpsFlags& value); +std::ostream& operator<< (std::ostream& s, const StdVideoH265VideoParameterSet& value); +std::ostream& operator<< (std::ostream& s, const StdVideoH265ScalingLists& value); +std::ostream& operator<< (std::ostream& s, const StdVideoH265SpsVuiFlags& value); +std::ostream& operator<< (std::ostream& s, const StdVideoH265SequenceParameterSetVui& value); +std::ostream& operator<< (std::ostream& s, const StdVideoH265PredictorPaletteEntries& value); +std::ostream& operator<< (std::ostream& s, const StdVideoH265SpsFlags& value); +std::ostream& operator<< (std::ostream& s, const StdVideoH265SequenceParameterSet& value); +std::ostream& operator<< (std::ostream& s, const StdVideoH265PpsFlags& value); +std::ostream& operator<< (std::ostream& s, const StdVideoH265PictureParameterSet& value); +std::ostream& operator<< (std::ostream& s, const StdVideoDecodeH265PictureInfoFlags& value); +std::ostream& operator<< (std::ostream& s, const StdVideoDecodeH265PictureInfo& value); +std::ostream& operator<< (std::ostream& s, const StdVideoDecodeH265ReferenceInfoFlags& value); +std::ostream& operator<< (std::ostream& s, const StdVideoDecodeH265ReferenceInfo& value); +std::ostream& operator<< (std::ostream& s, const VkVideoDecodeH265ProfileEXT& value); +std::ostream& operator<< (std::ostream& s, const VkVideoDecodeH265CapabilitiesEXT& value); +std::ostream& operator<< (std::ostream& s, const VkVideoDecodeH265SessionCreateInfoEXT& value); +std::ostream& operator<< (std::ostream& s, const VkVideoDecodeH265SessionParametersAddInfoEXT& value); +std::ostream& operator<< (std::ostream& s, const VkVideoDecodeH265SessionParametersCreateInfoEXT& value); +std::ostream& operator<< (std::ostream& s, const VkVideoDecodeH265PictureInfoEXT& value); +std::ostream& operator<< (std::ostream& s, const VkVideoDecodeH265DpbSlotInfoEXT& value); std::ostream& operator<< (std::ostream& s, const VkImagePipeSurfaceCreateInfoFUCHSIA& value); std::ostream& operator<< (std::ostream& s, const VkImportMemoryZirconHandleInfoFUCHSIA& value); std::ostream& operator<< (std::ostream& s, const VkMemoryZirconHandlePropertiesFUCHSIA& value); diff --git a/external/vulkancts/framework/vulkan/vkStrUtilImpl.inl b/external/vulkancts/framework/vulkan/vkStrUtilImpl.inl index f9f1cbf..b47f858 100644 --- a/external/vulkancts/framework/vulkan/vkStrUtilImpl.inl +++ b/external/vulkancts/framework/vulkan/vkStrUtilImpl.inl @@ -41,6 +41,8 @@ template<> const char* getTypeName (void) { ret template<> const char* getTypeName (void) { return "VkIndirectCommandsLayoutNV"; } template<> const char* getTypeName (void) { return "VkPrivateDataSlotEXT"; } template<> const char* getTypeName (void) { return "VkAccelerationStructureKHR"; } +template<> const char* getTypeName (void) { return "VkVideoSessionKHR"; } +template<> const char* getTypeName (void) { return "VkVideoSessionParametersKHR"; } namespace pt { @@ -2367,6 +2369,263 @@ const char* getShaderGroupShaderKHRName (VkShaderGroupShaderKHR value) } } +const char* getQueryResultStatusKHRName (VkQueryResultStatusKHR value) +{ + switch (value) + { + case VK_QUERY_RESULT_STATUS_ERROR_KHR: return "VK_QUERY_RESULT_STATUS_ERROR_KHR"; + case VK_QUERY_RESULT_STATUS_NOT_READY_KHR: return "VK_QUERY_RESULT_STATUS_NOT_READY_KHR"; + case VK_QUERY_RESULT_STATUS_COMPLETE_KHR: return "VK_QUERY_RESULT_STATUS_COMPLETE_KHR"; + case VK_QUERY_RESULT_STATUS_MAX_ENUM_KHR: return "VK_QUERY_RESULT_STATUS_MAX_ENUM_KHR"; + default: return DE_NULL; + } +} + +const char* getdVideoH264ChromaFormatIdcName (StdVideoH264ChromaFormatIdc value) +{ + switch (value) + { + case std_video_h264_chroma_format_idc_monochrome: return "std_video_h264_chroma_format_idc_monochrome"; + case std_video_h264_chroma_format_idc_420: return "std_video_h264_chroma_format_idc_420"; + case std_video_h264_chroma_format_idc_422: return "std_video_h264_chroma_format_idc_422"; + case std_video_h264_chroma_format_idc_444: return "std_video_h264_chroma_format_idc_444"; + default: return DE_NULL; + } +} + +const char* getdVideoH264ProfileIdcName (StdVideoH264ProfileIdc value) +{ + switch (value) + { + case std_video_h264_profile_idc_baseline: return "std_video_h264_profile_idc_baseline"; + case std_video_h264_profile_idc_main: return "std_video_h264_profile_idc_main"; + case std_video_h264_profile_idc_high: return "std_video_h264_profile_idc_high"; + case std_video_h264_profile_idc_high_444_predictive: return "std_video_h264_profile_idc_high_444_predictive"; + case std_video_h264_profile_idc_invalid: return "std_video_h264_profile_idc_invalid"; + default: return DE_NULL; + } +} + +const char* getdVideoH264LevelName (StdVideoH264Level value) +{ + switch (value) + { + case std_video_h264_level_1_0: return "std_video_h264_level_1_0"; + case std_video_h264_level_1_1: return "std_video_h264_level_1_1"; + case std_video_h264_level_1_2: return "std_video_h264_level_1_2"; + case std_video_h264_level_1_3: return "std_video_h264_level_1_3"; + case std_video_h264_level_2_0: return "std_video_h264_level_2_0"; + case std_video_h264_level_2_1: return "std_video_h264_level_2_1"; + case std_video_h264_level_2_2: return "std_video_h264_level_2_2"; + case std_video_h264_level_3_0: return "std_video_h264_level_3_0"; + case std_video_h264_level_3_1: return "std_video_h264_level_3_1"; + case std_video_h264_level_3_2: return "std_video_h264_level_3_2"; + case std_video_h264_level_4_0: return "std_video_h264_level_4_0"; + case std_video_h264_level_4_1: return "std_video_h264_level_4_1"; + case std_video_h264_level_4_2: return "std_video_h264_level_4_2"; + case std_video_h264_level_5_0: return "std_video_h264_level_5_0"; + case std_video_h264_level_5_1: return "std_video_h264_level_5_1"; + case std_video_h264_level_5_2: return "std_video_h264_level_5_2"; + case std_video_h264_level_6_0: return "std_video_h264_level_6_0"; + case std_video_h264_level_6_1: return "std_video_h264_level_6_1"; + case std_video_h264_level_6_2: return "std_video_h264_level_6_2"; + case std_video_h264_level_invalid: return "std_video_h264_level_invalid"; + default: return DE_NULL; + } +} + +const char* getdVideoH264PocTypeName (StdVideoH264PocType value) +{ + switch (value) + { + case std_video_h264_poc_type_0: return "std_video_h264_poc_type_0"; + case std_video_h264_poc_type_1: return "std_video_h264_poc_type_1"; + case std_video_h264_poc_type_2: return "std_video_h264_poc_type_2"; + case std_video_h264_poc_type_invalid: return "std_video_h264_poc_type_invalid"; + default: return DE_NULL; + } +} + +const char* getdVideoH264AspectRatioIdcName (StdVideoH264AspectRatioIdc value) +{ + switch (value) + { + case std_video_h264_aspect_ratio_idc_unspecified: return "std_video_h264_aspect_ratio_idc_unspecified"; + case std_video_h264_aspect_ratio_idc_square: return "std_video_h264_aspect_ratio_idc_square"; + case std_video_h264_aspect_ratio_idc_12_11: return "std_video_h264_aspect_ratio_idc_12_11"; + case std_video_h264_aspect_ratio_idc_10_11: return "std_video_h264_aspect_ratio_idc_10_11"; + case std_video_h264_aspect_ratio_idc_16_11: return "std_video_h264_aspect_ratio_idc_16_11"; + case std_video_h264_aspect_ratio_idc_40_33: return "std_video_h264_aspect_ratio_idc_40_33"; + case std_video_h264_aspect_ratio_idc_24_11: return "std_video_h264_aspect_ratio_idc_24_11"; + case std_video_h264_aspect_ratio_idc_20_11: return "std_video_h264_aspect_ratio_idc_20_11"; + case std_video_h264_aspect_ratio_idc_32_11: return "std_video_h264_aspect_ratio_idc_32_11"; + case std_video_h264_aspect_ratio_idc_80_33: return "std_video_h264_aspect_ratio_idc_80_33"; + case std_video_h264_aspect_ratio_idc_18_11: return "std_video_h264_aspect_ratio_idc_18_11"; + case std_video_h264_aspect_ratio_idc_15_11: return "std_video_h264_aspect_ratio_idc_15_11"; + case std_video_h264_aspect_ratio_idc_64_33: return "std_video_h264_aspect_ratio_idc_64_33"; + case std_video_h264_aspect_ratio_idc_160_99: return "std_video_h264_aspect_ratio_idc_160_99"; + case std_video_h264_aspect_ratio_idc_4_3: return "std_video_h264_aspect_ratio_idc_4_3"; + case std_video_h264_aspect_ratio_idc_3_2: return "std_video_h264_aspect_ratio_idc_3_2"; + case std_video_h264_aspect_ratio_idc_2_1: return "std_video_h264_aspect_ratio_idc_2_1"; + case std_video_h264_aspect_ratio_idc_extended_sar: return "std_video_h264_aspect_ratio_idc_extended_sar"; + case std_video_h264_aspect_ratio_idc_invalid: return "std_video_h264_aspect_ratio_idc_invalid"; + default: return DE_NULL; + } +} + +const char* getdVideoH264WeightedBiPredIdcName (StdVideoH264WeightedBiPredIdc value) +{ + switch (value) + { + case std_video_h264_default_weighted_b_slices_prediction_idc: return "std_video_h264_default_weighted_b_slices_prediction_idc"; + case std_video_h264_explicit_weighted_b_slices_prediction_idc: return "std_video_h264_explicit_weighted_b_slices_prediction_idc"; + case std_video_h264_implicit_weighted_b_slices_prediction_idc: return "std_video_h264_implicit_weighted_b_slices_prediction_idc"; + case std_video_h264_invalid_weighted_b_slices_prediction_idc: return "std_video_h264_invalid_weighted_b_slices_prediction_idc"; + default: return DE_NULL; + } +} + +const char* getdVideoH264ModificationOfPicNumsIdcName (StdVideoH264ModificationOfPicNumsIdc value) +{ + switch (value) + { + case std_video_h264_modification_of_pic_nums_idc_short_term_subtract: return "std_video_h264_modification_of_pic_nums_idc_short_term_subtract"; + case std_video_h264_modification_of_pic_nums_idc_short_term_add: return "std_video_h264_modification_of_pic_nums_idc_short_term_add"; + case std_video_h264_modification_of_pic_nums_idc_long_term: return "std_video_h264_modification_of_pic_nums_idc_long_term"; + case std_video_h264_modification_of_pic_nums_idc_end: return "std_video_h264_modification_of_pic_nums_idc_end"; + case std_video_h264_modification_of_pic_nums_idc_invalid: return "std_video_h264_modification_of_pic_nums_idc_invalid"; + default: return DE_NULL; + } +} + +const char* getdVideoH264MemMgmtControlOpName (StdVideoH264MemMgmtControlOp value) +{ + switch (value) + { + case std_video_h264_mem_mgmt_control_op_end: return "std_video_h264_mem_mgmt_control_op_end"; + case std_video_h264_mem_mgmt_control_op_unmark_short_term: return "std_video_h264_mem_mgmt_control_op_unmark_short_term"; + case std_video_h264_mem_mgmt_control_op_unmark_long_term: return "std_video_h264_mem_mgmt_control_op_unmark_long_term"; + case std_video_h264_mem_mgmt_control_op_mark_long_term: return "std_video_h264_mem_mgmt_control_op_mark_long_term"; + case std_video_h264_mem_mgmt_control_op_set_max_long_term_index: return "std_video_h264_mem_mgmt_control_op_set_max_long_term_index"; + case std_video_h264_mem_mgmt_control_op_unmark_all: return "std_video_h264_mem_mgmt_control_op_unmark_all"; + case std_video_h264_mem_mgmt_control_op_mark_current_as_long_term: return "std_video_h264_mem_mgmt_control_op_mark_current_as_long_term"; + case std_video_h264_mem_mgmt_control_op_invalid: return "std_video_h264_mem_mgmt_control_op_invalid"; + default: return DE_NULL; + } +} + +const char* getdVideoH264CabacInitIdcName (StdVideoH264CabacInitIdc value) +{ + switch (value) + { + case std_video_h264_cabac_init_idc_0: return "std_video_h264_cabac_init_idc_0"; + case std_video_h264_cabac_init_idc_1: return "std_video_h264_cabac_init_idc_1"; + case std_video_h264_cabac_init_idc_2: return "std_video_h264_cabac_init_idc_2"; + case std_video_h264_cabac_init_idc_invalid: return "std_video_h264_cabac_init_idc_invalid"; + default: return DE_NULL; + } +} + +const char* getdVideoH264DisableDeblockingFilterIdcName (StdVideoH264DisableDeblockingFilterIdc value) +{ + switch (value) + { + case std_video_h264_disable_deblocking_filter_idc_disabled: return "std_video_h264_disable_deblocking_filter_idc_disabled"; + case std_video_h264_disable_deblocking_filter_idc_enabled: return "std_video_h264_disable_deblocking_filter_idc_enabled"; + case std_video_h264_disable_deblocking_filter_idc_partial: return "std_video_h264_disable_deblocking_filter_idc_partial"; + case std_video_h264_disable_deblocking_filter_idc_invalid: return "std_video_h264_disable_deblocking_filter_idc_invalid"; + default: return DE_NULL; + } +} + +const char* getdVideoH264PictureTypeName (StdVideoH264PictureType value) +{ + switch (value) + { + case std_video_h264_picture_type_i: return "std_video_h264_picture_type_i"; + case std_video_h264_picture_type_p: return "std_video_h264_picture_type_p"; + case std_video_h264_picture_type_b: return "std_video_h264_picture_type_b"; + case std_video_h264_picture_type_invalid: return "std_video_h264_picture_type_invalid"; + default: return DE_NULL; + } +} + +const char* getdVideoH264SliceTypeName (StdVideoH264SliceType value) +{ + switch (value) + { + case std_video_h264_slice_type_i: return "std_video_h264_slice_type_i"; + case std_video_h264_slice_type_p: return "std_video_h264_slice_type_p"; + case std_video_h264_slice_type_b: return "std_video_h264_slice_type_b"; + case std_video_h264_slice_type_invalid: return "std_video_h264_slice_type_invalid"; + default: return DE_NULL; + } +} + +const char* getdVideoH264NonVclNaluTypeName (StdVideoH264NonVclNaluType value) +{ + switch (value) + { + case std_video_h264_non_vcl_nalu_type_sps: return "std_video_h264_non_vcl_nalu_type_sps"; + case std_video_h264_non_vcl_nalu_type_pps: return "std_video_h264_non_vcl_nalu_type_pps"; + case std_video_h264_non_vcl_nalu_type_aud: return "std_video_h264_non_vcl_nalu_type_aud"; + case std_video_h264_non_vcl_nalu_type_prefix: return "std_video_h264_non_vcl_nalu_type_prefix"; + case std_video_h264_non_vcl_nalu_type_end_of_sequence: return "std_video_h264_non_vcl_nalu_type_end_of_sequence"; + case std_video_h264_non_vcl_nalu_type_end_of_stream: return "std_video_h264_non_vcl_nalu_type_end_of_stream"; + case std_video_h264_non_vcl_nalu_type_precoded: return "std_video_h264_non_vcl_nalu_type_precoded"; + case std_video_h264_non_vcl_nalu_type_invalid: return "std_video_h264_non_vcl_nalu_type_invalid"; + default: return DE_NULL; + } +} + +const char* getdVideoH265ChromaFormatIdcName (StdVideoH265ChromaFormatIdc value) +{ + switch (value) + { + case std_video_h265_chroma_format_idc_monochrome: return "std_video_h265_chroma_format_idc_monochrome"; + case std_video_h265_chroma_format_idc_420: return "std_video_h265_chroma_format_idc_420"; + case std_video_h265_chroma_format_idc_422: return "std_video_h265_chroma_format_idc_422"; + case std_video_h265_chroma_format_idc_444: return "std_video_h265_chroma_format_idc_444"; + default: return DE_NULL; + } +} + +const char* getdVideoH265ProfileIdcName (StdVideoH265ProfileIdc value) +{ + switch (value) + { + case std_video_h265_profile_idc_main: return "std_video_h265_profile_idc_main"; + case std_video_h265_profile_idc_main_10: return "std_video_h265_profile_idc_main_10"; + case std_video_h265_profile_idc_main_still_picture: return "std_video_h265_profile_idc_main_still_picture"; + case std_video_h265_profile_idc_format_range_extensions: return "std_video_h265_profile_idc_format_range_extensions"; + case std_video_h265_profile_idc_scc_extensions: return "std_video_h265_profile_idc_scc_extensions"; + case std_video_h265_profile_idc_invalid: return "std_video_h265_profile_idc_invalid"; + default: return DE_NULL; + } +} + +const char* getdVideoH265LevelName (StdVideoH265Level value) +{ + switch (value) + { + case std_video_h265_level_1_0: return "std_video_h265_level_1_0"; + case std_video_h265_level_2_0: return "std_video_h265_level_2_0"; + case std_video_h265_level_2_1: return "std_video_h265_level_2_1"; + case std_video_h265_level_3_0: return "std_video_h265_level_3_0"; + case std_video_h265_level_3_1: return "std_video_h265_level_3_1"; + case std_video_h265_level_4_0: return "std_video_h265_level_4_0"; + case std_video_h265_level_4_1: return "std_video_h265_level_4_1"; + case std_video_h265_level_5_0: return "std_video_h265_level_5_0"; + case std_video_h265_level_5_1: return "std_video_h265_level_5_1"; + case std_video_h265_level_5_2: return "std_video_h265_level_5_2"; + case std_video_h265_level_6_0: return "std_video_h265_level_6_0"; + case std_video_h265_level_6_1: return "std_video_h265_level_6_1"; + case std_video_h265_level_6_2: return "std_video_h265_level_6_2"; + case std_video_h265_level_invalid: return "std_video_h265_level_invalid"; + default: return DE_NULL; + } +} + const char* getFullScreenExclusiveEXTName (VkFullScreenExclusiveEXT value) { switch (value) @@ -3636,6 +3895,204 @@ tcu::Format::Bitfield<32> getAccelerationStructureCreateFlagsKHRStr (VkAccelerat return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc)); } +tcu::Format::Bitfield<32> getVideoCodecOperationFlagsKHRStr (VkVideoCodecOperationFlagsKHR value) +{ + static const tcu::Format::BitDesc s_desc[] = + { + tcu::Format::BitDesc(VK_VIDEO_CODEC_OPERATION_INVALID_BIT_KHR, "VK_VIDEO_CODEC_OPERATION_INVALID_BIT_KHR"), + tcu::Format::BitDesc(VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_EXT, "VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_EXT"), + tcu::Format::BitDesc(VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_EXT, "VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_EXT"), + tcu::Format::BitDesc(VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_EXT, "VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_EXT"), + tcu::Format::BitDesc(VK_VIDEO_CODEC_OPERATION_FLAG_BITS_MAX_ENUM_KHR, "VK_VIDEO_CODEC_OPERATION_FLAG_BITS_MAX_ENUM_KHR"), + }; + return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc)); +} + +tcu::Format::Bitfield<32> getVideoChromaSubsamplingFlagsKHRStr (VkVideoChromaSubsamplingFlagsKHR value) +{ + static const tcu::Format::BitDesc s_desc[] = + { + tcu::Format::BitDesc(VK_VIDEO_CHROMA_SUBSAMPLING_INVALID_BIT_KHR, "VK_VIDEO_CHROMA_SUBSAMPLING_INVALID_BIT_KHR"), + tcu::Format::BitDesc(VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR, "VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR"), + tcu::Format::BitDesc(VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR, "VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR"), + tcu::Format::BitDesc(VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR, "VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR"), + tcu::Format::BitDesc(VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR, "VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR"), + tcu::Format::BitDesc(VK_VIDEO_CHROMA_SUBSAMPLING_FLAG_BITS_MAX_ENUM_KHR, "VK_VIDEO_CHROMA_SUBSAMPLING_FLAG_BITS_MAX_ENUM_KHR"), + }; + return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc)); +} + +tcu::Format::Bitfield<32> getVideoComponentBitDepthFlagsKHRStr (VkVideoComponentBitDepthFlagsKHR value) +{ + static const tcu::Format::BitDesc s_desc[] = + { + tcu::Format::BitDesc(VK_VIDEO_COMPONENT_BIT_DEPTH_INVALID_KHR, "VK_VIDEO_COMPONENT_BIT_DEPTH_INVALID_KHR"), + tcu::Format::BitDesc(VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR, "VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR"), + tcu::Format::BitDesc(VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR, "VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR"), + tcu::Format::BitDesc(VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR, "VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR"), + tcu::Format::BitDesc(VK_VIDEO_COMPONENT_BIT_DEPTH_FLAG_BITS_MAX_ENUM_KHR, "VK_VIDEO_COMPONENT_BIT_DEPTH_FLAG_BITS_MAX_ENUM_KHR"), + }; + return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc)); +} + +tcu::Format::Bitfield<32> getVideoCapabilitiesFlagsKHRStr (VkVideoCapabilitiesFlagsKHR value) +{ + static const tcu::Format::BitDesc s_desc[] = + { + tcu::Format::BitDesc(VK_VIDEO_CAPABILITIES_PROTECTED_CONTENT_BIT_KHR, "VK_VIDEO_CAPABILITIES_PROTECTED_CONTENT_BIT_KHR"), + tcu::Format::BitDesc(VK_VIDEO_CAPABILITIES_SEPARATE_REFERENCE_IMAGES_BIT_KHR, "VK_VIDEO_CAPABILITIES_SEPARATE_REFERENCE_IMAGES_BIT_KHR"), + tcu::Format::BitDesc(VK_VIDEO_CAPABILITIES_FLAG_BITS_MAX_ENUM_KHR, "VK_VIDEO_CAPABILITIES_FLAG_BITS_MAX_ENUM_KHR"), + }; + return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc)); +} + +tcu::Format::Bitfield<32> getVideoSessionCreateFlagsKHRStr (VkVideoSessionCreateFlagsKHR value) +{ + static const tcu::Format::BitDesc s_desc[] = + { + tcu::Format::BitDesc(VK_VIDEO_SESSION_CREATE_DEFAULT_KHR, "VK_VIDEO_SESSION_CREATE_DEFAULT_KHR"), + tcu::Format::BitDesc(VK_VIDEO_SESSION_CREATE_PROTECTED_CONTENT_BIT_KHR, "VK_VIDEO_SESSION_CREATE_PROTECTED_CONTENT_BIT_KHR"), + tcu::Format::BitDesc(VK_VIDEO_SESSION_CREATE_FLAG_BITS_MAX_ENUM_KHR, "VK_VIDEO_SESSION_CREATE_FLAG_BITS_MAX_ENUM_KHR"), + }; + return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc)); +} + +tcu::Format::Bitfield<32> getVideoCodingControlFlagsKHRStr (VkVideoCodingControlFlagsKHR value) +{ + static const tcu::Format::BitDesc s_desc[] = + { + tcu::Format::BitDesc(VK_VIDEO_CODING_CONTROL_DEFAULT_KHR, "VK_VIDEO_CODING_CONTROL_DEFAULT_KHR"), + tcu::Format::BitDesc(VK_VIDEO_CODING_CONTROL_RESET_BIT_KHR, "VK_VIDEO_CODING_CONTROL_RESET_BIT_KHR"), + tcu::Format::BitDesc(VK_VIDEO_CODING_CONTROL_FLAG_BITS_MAX_ENUM_KHR, "VK_VIDEO_CODING_CONTROL_FLAG_BITS_MAX_ENUM_KHR"), + }; + return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc)); +} + +tcu::Format::Bitfield<32> getVideoCodingQualityPresetFlagsKHRStr (VkVideoCodingQualityPresetFlagsKHR value) +{ + static const tcu::Format::BitDesc s_desc[] = + { + tcu::Format::BitDesc(VK_VIDEO_CODING_QUALITY_PRESET_DEFAULT_BIT_KHR, "VK_VIDEO_CODING_QUALITY_PRESET_DEFAULT_BIT_KHR"), + tcu::Format::BitDesc(VK_VIDEO_CODING_QUALITY_PRESET_NORMAL_BIT_KHR, "VK_VIDEO_CODING_QUALITY_PRESET_NORMAL_BIT_KHR"), + tcu::Format::BitDesc(VK_VIDEO_CODING_QUALITY_PRESET_POWER_BIT_KHR, "VK_VIDEO_CODING_QUALITY_PRESET_POWER_BIT_KHR"), + tcu::Format::BitDesc(VK_VIDEO_CODING_QUALITY_PRESET_QUALITY_BIT_KHR, "VK_VIDEO_CODING_QUALITY_PRESET_QUALITY_BIT_KHR"), + tcu::Format::BitDesc(VK_VIDEO_CODING_QUALITY_PRESET_FLAG_BITS_MAX_ENUM_KHR, "VK_VIDEO_CODING_QUALITY_PRESET_FLAG_BITS_MAX_ENUM_KHR"), + }; + return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc)); +} + +tcu::Format::Bitfield<32> getVideoDecodeFlagsKHRStr (VkVideoDecodeFlagsKHR value) +{ + static const tcu::Format::BitDesc s_desc[] = + { + tcu::Format::BitDesc(VK_VIDEO_DECODE_DEFAULT_KHR, "VK_VIDEO_DECODE_DEFAULT_KHR"), + tcu::Format::BitDesc(VK_VIDEO_DECODE_RESERVED_0_BIT_KHR, "VK_VIDEO_DECODE_RESERVED_0_BIT_KHR"), + tcu::Format::BitDesc(VK_VIDEO_DECODE_FLAG_BITS_MAX_ENUM_KHR, "VK_VIDEO_DECODE_FLAG_BITS_MAX_ENUM_KHR"), + }; + return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc)); +} + +tcu::Format::Bitfield<32> getVideoEncodeFlagsKHRStr (VkVideoEncodeFlagsKHR value) +{ + static const tcu::Format::BitDesc s_desc[] = + { + tcu::Format::BitDesc(VK_VIDEO_ENCODE_DEFAULT_KHR, "VK_VIDEO_ENCODE_DEFAULT_KHR"), + tcu::Format::BitDesc(VK_VIDEO_ENCODE_RESERVED_0_BIT_KHR, "VK_VIDEO_ENCODE_RESERVED_0_BIT_KHR"), + tcu::Format::BitDesc(VK_VIDEO_ENCODE_FLAG_BITS_MAX_ENUM_KHR, "VK_VIDEO_ENCODE_FLAG_BITS_MAX_ENUM_KHR"), + }; + return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc)); +} + +tcu::Format::Bitfield<32> getVideoEncodeRateControlFlagsKHRStr (VkVideoEncodeRateControlFlagsKHR value) +{ + static const tcu::Format::BitDesc s_desc[] = + { + tcu::Format::BitDesc(VK_VIDEO_ENCODE_RATE_CONTROL_DEFAULT_KHR, "VK_VIDEO_ENCODE_RATE_CONTROL_DEFAULT_KHR"), + tcu::Format::BitDesc(VK_VIDEO_ENCODE_RATE_CONTROL_RESET_BIT_KHR, "VK_VIDEO_ENCODE_RATE_CONTROL_RESET_BIT_KHR"), + tcu::Format::BitDesc(VK_VIDEO_ENCODE_RATE_CONTROL_FLAG_BITS_MAX_ENUM_KHR, "VK_VIDEO_ENCODE_RATE_CONTROL_FLAG_BITS_MAX_ENUM_KHR"), + }; + return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc)); +} + +tcu::Format::Bitfield<32> getVideoEncodeRateControlModeFlagsKHRStr (VkVideoEncodeRateControlModeFlagsKHR value) +{ + static const tcu::Format::BitDesc s_desc[] = + { + tcu::Format::BitDesc(VK_VIDEO_ENCODE_RATE_CONTROL_MODE_NONE_BIT_KHR, "VK_VIDEO_ENCODE_RATE_CONTROL_MODE_NONE_BIT_KHR"), + tcu::Format::BitDesc(VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR, "VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR"), + tcu::Format::BitDesc(VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR, "VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR"), + tcu::Format::BitDesc(VK_VIDEO_ENCODE_RATE_CONTROL_MODE_FLAG_BITS_MAX_ENUM_KHR, "VK_VIDEO_ENCODE_RATE_CONTROL_MODE_FLAG_BITS_MAX_ENUM_KHR"), + }; + return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc)); +} + +tcu::Format::Bitfield<32> getVideoEncodeH264CapabilitiesFlagsEXTStr (VkVideoEncodeH264CapabilitiesFlagsEXT value) +{ + static const tcu::Format::BitDesc s_desc[] = + { + tcu::Format::BitDesc(VK_VIDEO_ENCODE_H264_CAPABILITY_CABAC_BIT_EXT, "VK_VIDEO_ENCODE_H264_CAPABILITY_CABAC_BIT_EXT"), + tcu::Format::BitDesc(VK_VIDEO_ENCODE_H264_CAPABILITY_CAVLC_BIT_EXT, "VK_VIDEO_ENCODE_H264_CAPABILITY_CAVLC_BIT_EXT"), + tcu::Format::BitDesc(VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_BI_PRED_IMPLICIT_BIT_EXT, "VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_BI_PRED_IMPLICIT_BIT_EXT"), + tcu::Format::BitDesc(VK_VIDEO_ENCODE_H264_CAPABILITY_TRANSFORM_8X8_BIT_EXT, "VK_VIDEO_ENCODE_H264_CAPABILITY_TRANSFORM_8X8_BIT_EXT"), + tcu::Format::BitDesc(VK_VIDEO_ENCODE_H264_CAPABILITY_CHROMA_QP_OFFSET_BIT_EXT, "VK_VIDEO_ENCODE_H264_CAPABILITY_CHROMA_QP_OFFSET_BIT_EXT"), + tcu::Format::BitDesc(VK_VIDEO_ENCODE_H264_CAPABILITY_SECOND_CHROMA_QP_OFFSET_BIT_EXT, "VK_VIDEO_ENCODE_H264_CAPABILITY_SECOND_CHROMA_QP_OFFSET_BIT_EXT"), + tcu::Format::BitDesc(VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_DISABLED_BIT_EXT, "VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_DISABLED_BIT_EXT"), + tcu::Format::BitDesc(VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_ENABLED_BIT_EXT, "VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_ENABLED_BIT_EXT"), + tcu::Format::BitDesc(VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_PARTIAL_BIT_EXT, "VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_PARTIAL_BIT_EXT"), + tcu::Format::BitDesc(VK_VIDEO_ENCODE_H264_CAPABILITY_MULTIPLE_SLICE_PER_FRAME_BIT_EXT, "VK_VIDEO_ENCODE_H264_CAPABILITY_MULTIPLE_SLICE_PER_FRAME_BIT_EXT"), + tcu::Format::BitDesc(VK_VIDEO_ENCODE_H264_CAPABILITY_EVENLY_DISTRIBUTED_SLICE_SIZE_BIT_EXT, "VK_VIDEO_ENCODE_H264_CAPABILITY_EVENLY_DISTRIBUTED_SLICE_SIZE_BIT_EXT"), + tcu::Format::BitDesc(VK_VIDEO_ENCODE_H264_CAPABILITIES_FLAG_BITS_MAX_ENUM_EXT, "VK_VIDEO_ENCODE_H264_CAPABILITIES_FLAG_BITS_MAX_ENUM_EXT"), + }; + return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc)); +} + +tcu::Format::Bitfield<32> getVideoEncodeH264InputModeFlagsEXTStr (VkVideoEncodeH264InputModeFlagsEXT value) +{ + static const tcu::Format::BitDesc s_desc[] = + { + tcu::Format::BitDesc(VK_VIDEO_ENCODE_H264_INPUT_MODE_FRAME_BIT_EXT, "VK_VIDEO_ENCODE_H264_INPUT_MODE_FRAME_BIT_EXT"), + tcu::Format::BitDesc(VK_VIDEO_ENCODE_H264_INPUT_MODE_SLICE_BIT_EXT, "VK_VIDEO_ENCODE_H264_INPUT_MODE_SLICE_BIT_EXT"), + tcu::Format::BitDesc(VK_VIDEO_ENCODE_H264_INPUT_MODE_NON_VCL_BIT_EXT, "VK_VIDEO_ENCODE_H264_INPUT_MODE_NON_VCL_BIT_EXT"), + tcu::Format::BitDesc(VK_VIDEO_ENCODE_H264_INPUT_MODE_FLAG_BITS_MAX_ENUM_EXT, "VK_VIDEO_ENCODE_H264_INPUT_MODE_FLAG_BITS_MAX_ENUM_EXT"), + }; + return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc)); +} + +tcu::Format::Bitfield<32> getVideoEncodeH264OutputModeFlagsEXTStr (VkVideoEncodeH264OutputModeFlagsEXT value) +{ + static const tcu::Format::BitDesc s_desc[] = + { + tcu::Format::BitDesc(VK_VIDEO_ENCODE_H264_OUTPUT_MODE_FRAME_BIT_EXT, "VK_VIDEO_ENCODE_H264_OUTPUT_MODE_FRAME_BIT_EXT"), + tcu::Format::BitDesc(VK_VIDEO_ENCODE_H264_OUTPUT_MODE_SLICE_BIT_EXT, "VK_VIDEO_ENCODE_H264_OUTPUT_MODE_SLICE_BIT_EXT"), + tcu::Format::BitDesc(VK_VIDEO_ENCODE_H264_OUTPUT_MODE_NON_VCL_BIT_EXT, "VK_VIDEO_ENCODE_H264_OUTPUT_MODE_NON_VCL_BIT_EXT"), + tcu::Format::BitDesc(VK_VIDEO_ENCODE_H264_OUTPUT_MODE_FLAG_BITS_MAX_ENUM_EXT, "VK_VIDEO_ENCODE_H264_OUTPUT_MODE_FLAG_BITS_MAX_ENUM_EXT"), + }; + return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc)); +} + +tcu::Format::Bitfield<32> getVideoEncodeH264CreateFlagsEXTStr (VkVideoEncodeH264CreateFlagsEXT value) +{ + static const tcu::Format::BitDesc s_desc[] = + { + tcu::Format::BitDesc(VK_VIDEO_ENCODE_H264_CREATE_DEFAULT_EXT, "VK_VIDEO_ENCODE_H264_CREATE_DEFAULT_EXT"), + tcu::Format::BitDesc(VK_VIDEO_ENCODE_H264_CREATE_RESERVED_0_BIT_EXT, "VK_VIDEO_ENCODE_H264_CREATE_RESERVED_0_BIT_EXT"), + tcu::Format::BitDesc(VK_VIDEO_ENCODE_H264_CREATE_FLAG_BITS_MAX_ENUM_EXT, "VK_VIDEO_ENCODE_H264_CREATE_FLAG_BITS_MAX_ENUM_EXT"), + }; + return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc)); +} + +tcu::Format::Bitfield<32> getVideoDecodeH264FieldLayoutFlagsEXTStr (VkVideoDecodeH264FieldLayoutFlagsEXT value) +{ + static const tcu::Format::BitDesc s_desc[] = + { + tcu::Format::BitDesc(VK_VIDEO_DECODE_H264_PROGRESSIVE_PICTURES_ONLY_EXT, "VK_VIDEO_DECODE_H264_PROGRESSIVE_PICTURES_ONLY_EXT"), + tcu::Format::BitDesc(VK_VIDEO_DECODE_H264_FIELD_LAYOUT_LINE_INTERLACED_PLANE_BIT_EXT, "VK_VIDEO_DECODE_H264_FIELD_LAYOUT_LINE_INTERLACED_PLANE_BIT_EXT"), + tcu::Format::BitDesc(VK_VIDEO_DECODE_H264_FIELD_LAYOUT_SEPARATE_INTERLACED_PLANE_BIT_EXT, "VK_VIDEO_DECODE_H264_FIELD_LAYOUT_SEPARATE_INTERLACED_PLANE_BIT_EXT"), + tcu::Format::BitDesc(VK_VIDEO_DECODE_H264_FIELD_LAYOUT_FLAG_BITS_MAX_ENUM_EXT, "VK_VIDEO_DECODE_H264_FIELD_LAYOUT_FLAG_BITS_MAX_ENUM_EXT"), + }; + return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc)); +} + tcu::Format::Bitfield<32> getInstanceCreateFlagsStr (VkInstanceCreateFlags value) { return tcu::Format::Bitfield<32>(value, DE_NULL, DE_NULL); @@ -3811,6 +4268,26 @@ tcu::Format::Bitfield<32> getAndroidSurfaceCreateFlagsKHRStr (VkAndroidSurfaceCr return tcu::Format::Bitfield<32>(value, DE_NULL, DE_NULL); } +tcu::Format::Bitfield<32> getVideoBeginCodingFlagsKHRStr (VkVideoBeginCodingFlagsKHR value) +{ + return tcu::Format::Bitfield<32>(value, DE_NULL, DE_NULL); +} + +tcu::Format::Bitfield<32> getVideoEndCodingFlagsKHRStr (VkVideoEndCodingFlagsKHR value) +{ + return tcu::Format::Bitfield<32>(value, DE_NULL, DE_NULL); +} + +tcu::Format::Bitfield<32> getVideoDecodeH264CreateFlagsEXTStr (VkVideoDecodeH264CreateFlagsEXT value) +{ + return tcu::Format::Bitfield<32>(value, DE_NULL, DE_NULL); +} + +tcu::Format::Bitfield<32> getVideoDecodeH265CreateFlagsEXTStr (VkVideoDecodeH265CreateFlagsEXT value) +{ + return tcu::Format::Bitfield<32>(value, DE_NULL, DE_NULL); +} + tcu::Format::Bitfield<32> getImagePipeSurfaceCreateFlagsFUCHSIAStr (VkImagePipeSurfaceCreateFlagsFUCHSIA value) { return tcu::Format::Bitfield<32>(value, DE_NULL, DE_NULL); @@ -10989,19 +11466,231 @@ std::ostream& operator<< (std::ostream& s, const VkExternalFormatANDROID& value) return s; } -std::ostream& operator<< (std::ostream& s, const VkPhysicalDevicePortabilitySubsetFeaturesKHR& value) +std::ostream& operator<< (std::ostream& s, const VkVideoQueueFamilyProperties2KHR& value) { - s << "VkPhysicalDevicePortabilitySubsetFeaturesKHR = {\n"; + s << "VkVideoQueueFamilyProperties2KHR = {\n"; s << "\tsType = " << value.sType << '\n'; s << "\tpNext = " << value.pNext << '\n'; - s << "\tconstantAlphaColorBlendFactors = " << value.constantAlphaColorBlendFactors << '\n'; - s << "\tevents = " << value.events << '\n'; - s << "\timageViewFormatReinterpretation = " << value.imageViewFormatReinterpretation << '\n'; - s << "\timageViewFormatSwizzle = " << value.imageViewFormatSwizzle << '\n'; - s << "\timageView2DOn3DImage = " << value.imageView2DOn3DImage << '\n'; - s << "\tmultisampleArrayImage = " << value.multisampleArrayImage << '\n'; - s << "\tmutableComparisonSamplers = " << value.mutableComparisonSamplers << '\n'; - s << "\tpointPolygons = " << value.pointPolygons << '\n'; + s << "\tvideoCodecOperations = " << getVideoCodecOperationFlagsKHRStr(value.videoCodecOperations) << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const VkVideoProfileKHR& value) +{ + s << "VkVideoProfileKHR = {\n"; + s << "\tsType = " << value.sType << '\n'; + s << "\tpNext = " << value.pNext << '\n'; + s << "\tvideoCodecOperation = " << value.videoCodecOperation << '\n'; + s << "\tchromaSubsampling = " << getVideoChromaSubsamplingFlagsKHRStr(value.chromaSubsampling) << '\n'; + s << "\tlumaBitDepth = " << getVideoComponentBitDepthFlagsKHRStr(value.lumaBitDepth) << '\n'; + s << "\tchromaBitDepth = " << getVideoComponentBitDepthFlagsKHRStr(value.chromaBitDepth) << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const VkVideoProfilesKHR& value) +{ + s << "VkVideoProfilesKHR = {\n"; + s << "\tsType = " << value.sType << '\n'; + s << "\tpNext = " << value.pNext << '\n'; + s << "\tprofileCount = " << value.profileCount << '\n'; + s << "\tpProfiles = " << value.pProfiles << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const VkVideoCapabilitiesKHR& value) +{ + s << "VkVideoCapabilitiesKHR = {\n"; + s << "\tsType = " << value.sType << '\n'; + s << "\tpNext = " << value.pNext << '\n'; + s << "\tcapabilityFlags = " << getVideoCapabilitiesFlagsKHRStr(value.capabilityFlags) << '\n'; + s << "\tminBitstreamBufferOffsetAlignment = " << value.minBitstreamBufferOffsetAlignment << '\n'; + s << "\tminBitstreamBufferSizeAlignment = " << value.minBitstreamBufferSizeAlignment << '\n'; + s << "\tvideoPictureExtentGranularity = " << value.videoPictureExtentGranularity << '\n'; + s << "\tminExtent = " << value.minExtent << '\n'; + s << "\tmaxExtent = " << value.maxExtent << '\n'; + s << "\tmaxReferencePicturesSlotsCount = " << value.maxReferencePicturesSlotsCount << '\n'; + s << "\tmaxReferencePicturesActiveCount = " << value.maxReferencePicturesActiveCount << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceVideoFormatInfoKHR& value) +{ + s << "VkPhysicalDeviceVideoFormatInfoKHR = {\n"; + s << "\tsType = " << value.sType << '\n'; + s << "\tpNext = " << value.pNext << '\n'; + s << "\timageUsage = " << getImageUsageFlagsStr(value.imageUsage) << '\n'; + s << "\tpVideoProfiles = " << value.pVideoProfiles << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const VkVideoFormatPropertiesKHR& value) +{ + s << "VkVideoFormatPropertiesKHR = {\n"; + s << "\tsType = " << value.sType << '\n'; + s << "\tpNext = " << value.pNext << '\n'; + s << "\tformat = " << value.format << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const VkVideoPictureResourceKHR& value) +{ + s << "VkVideoPictureResourceKHR = {\n"; + s << "\tsType = " << value.sType << '\n'; + s << "\tpNext = " << value.pNext << '\n'; + s << "\tcodedOffset = " << value.codedOffset << '\n'; + s << "\tcodedExtent = " << value.codedExtent << '\n'; + s << "\tbaseArrayLayer = " << value.baseArrayLayer << '\n'; + s << "\timageViewBinding = " << value.imageViewBinding << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const VkVideoReferenceSlotKHR& value) +{ + s << "VkVideoReferenceSlotKHR = {\n"; + s << "\tsType = " << value.sType << '\n'; + s << "\tpNext = " << value.pNext << '\n'; + s << "\tslotIndex = " << value.slotIndex << '\n'; + s << "\tpPictureResource = " << value.pPictureResource << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const VkVideoGetMemoryPropertiesKHR& value) +{ + s << "VkVideoGetMemoryPropertiesKHR = {\n"; + s << "\tsType = " << value.sType << '\n'; + s << "\tpNext = " << value.pNext << '\n'; + s << "\tmemoryBindIndex = " << value.memoryBindIndex << '\n'; + s << "\tpMemoryRequirements = " << value.pMemoryRequirements << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const VkVideoBindMemoryKHR& value) +{ + s << "VkVideoBindMemoryKHR = {\n"; + s << "\tsType = " << value.sType << '\n'; + s << "\tpNext = " << value.pNext << '\n'; + s << "\tmemoryBindIndex = " << value.memoryBindIndex << '\n'; + s << "\tmemory = " << value.memory << '\n'; + s << "\tmemoryOffset = " << value.memoryOffset << '\n'; + s << "\tmemorySize = " << value.memorySize << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const VkVideoSessionCreateInfoKHR& value) +{ + s << "VkVideoSessionCreateInfoKHR = {\n"; + s << "\tsType = " << value.sType << '\n'; + s << "\tpNext = " << value.pNext << '\n'; + s << "\tqueueFamilyIndex = " << value.queueFamilyIndex << '\n'; + s << "\tflags = " << getVideoSessionCreateFlagsKHRStr(value.flags) << '\n'; + s << "\tpVideoProfile = " << value.pVideoProfile << '\n'; + s << "\tpictureFormat = " << value.pictureFormat << '\n'; + s << "\tmaxCodedExtent = " << value.maxCodedExtent << '\n'; + s << "\treferencePicturesFormat = " << value.referencePicturesFormat << '\n'; + s << "\tmaxReferencePicturesSlotsCount = " << value.maxReferencePicturesSlotsCount << '\n'; + s << "\tmaxReferencePicturesActiveCount = " << value.maxReferencePicturesActiveCount << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const VkVideoSessionParametersCreateInfoKHR& value) +{ + s << "VkVideoSessionParametersCreateInfoKHR = {\n"; + s << "\tsType = " << value.sType << '\n'; + s << "\tpNext = " << value.pNext << '\n'; + s << "\tvideoSessionParametersTemplate = " << value.videoSessionParametersTemplate << '\n'; + s << "\tvideoSession = " << value.videoSession << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const VkVideoSessionParametersUpdateInfoKHR& value) +{ + s << "VkVideoSessionParametersUpdateInfoKHR = {\n"; + s << "\tsType = " << value.sType << '\n'; + s << "\tpNext = " << value.pNext << '\n'; + s << "\tupdateSequenceCount = " << value.updateSequenceCount << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const VkVideoBeginCodingInfoKHR& value) +{ + s << "VkVideoBeginCodingInfoKHR = {\n"; + s << "\tsType = " << value.sType << '\n'; + s << "\tpNext = " << value.pNext << '\n'; + s << "\tflags = " << getVideoBeginCodingFlagsKHRStr(value.flags) << '\n'; + s << "\tcodecQualityPreset = " << getVideoCodingQualityPresetFlagsKHRStr(value.codecQualityPreset) << '\n'; + s << "\tvideoSession = " << value.videoSession << '\n'; + s << "\tvideoSessionParameters = " << value.videoSessionParameters << '\n'; + s << "\treferenceSlotCount = " << value.referenceSlotCount << '\n'; + s << "\tpReferenceSlots = " << value.pReferenceSlots << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const VkVideoEndCodingInfoKHR& value) +{ + s << "VkVideoEndCodingInfoKHR = {\n"; + s << "\tsType = " << value.sType << '\n'; + s << "\tpNext = " << value.pNext << '\n'; + s << "\tflags = " << getVideoEndCodingFlagsKHRStr(value.flags) << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const VkVideoCodingControlInfoKHR& value) +{ + s << "VkVideoCodingControlInfoKHR = {\n"; + s << "\tsType = " << value.sType << '\n'; + s << "\tpNext = " << value.pNext << '\n'; + s << "\tflags = " << getVideoCodingControlFlagsKHRStr(value.flags) << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const VkVideoDecodeInfoKHR& value) +{ + s << "VkVideoDecodeInfoKHR = {\n"; + s << "\tsType = " << value.sType << '\n'; + s << "\tpNext = " << value.pNext << '\n'; + s << "\tflags = " << getVideoDecodeFlagsKHRStr(value.flags) << '\n'; + s << "\tcodedOffset = " << value.codedOffset << '\n'; + s << "\tcodedExtent = " << value.codedExtent << '\n'; + s << "\tsrcBuffer = " << value.srcBuffer << '\n'; + s << "\tsrcBufferOffset = " << value.srcBufferOffset << '\n'; + s << "\tsrcBufferRange = " << value.srcBufferRange << '\n'; + s << "\tdstPictureResource = " << value.dstPictureResource << '\n'; + s << "\tpSetupReferenceSlot = " << value.pSetupReferenceSlot << '\n'; + s << "\treferenceSlotCount = " << value.referenceSlotCount << '\n'; + s << "\tpReferenceSlots = " << value.pReferenceSlots << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const VkPhysicalDevicePortabilitySubsetFeaturesKHR& value) +{ + s << "VkPhysicalDevicePortabilitySubsetFeaturesKHR = {\n"; + s << "\tsType = " << value.sType << '\n'; + s << "\tpNext = " << value.pNext << '\n'; + s << "\tconstantAlphaColorBlendFactors = " << value.constantAlphaColorBlendFactors << '\n'; + s << "\tevents = " << value.events << '\n'; + s << "\timageViewFormatReinterpretation = " << value.imageViewFormatReinterpretation << '\n'; + s << "\timageViewFormatSwizzle = " << value.imageViewFormatSwizzle << '\n'; + s << "\timageView2DOn3DImage = " << value.imageView2DOn3DImage << '\n'; + s << "\tmultisampleArrayImage = " << value.multisampleArrayImage << '\n'; + s << "\tmutableComparisonSamplers = " << value.mutableComparisonSamplers << '\n'; + s << "\tpointPolygons = " << value.pointPolygons << '\n'; s << "\tsamplerMipLodBias = " << value.samplerMipLodBias << '\n'; s << "\tseparateStencilMaskRef = " << value.separateStencilMaskRef << '\n'; s << "\tshaderSampleRateInterpolationFunctions = " << value.shaderSampleRateInterpolationFunctions << '\n'; @@ -11023,6 +11712,1041 @@ std::ostream& operator<< (std::ostream& s, const VkPhysicalDevicePortabilitySubs return s; } +std::ostream& operator<< (std::ostream& s, const VkVideoEncodeInfoKHR& value) +{ + s << "VkVideoEncodeInfoKHR = {\n"; + s << "\tsType = " << value.sType << '\n'; + s << "\tpNext = " << value.pNext << '\n'; + s << "\tflags = " << getVideoEncodeFlagsKHRStr(value.flags) << '\n'; + s << "\tqualityLevel = " << value.qualityLevel << '\n'; + s << "\tcodedExtent = " << value.codedExtent << '\n'; + s << "\tdstBitstreamBuffer = " << value.dstBitstreamBuffer << '\n'; + s << "\tdstBitstreamBufferOffset = " << value.dstBitstreamBufferOffset << '\n'; + s << "\tdstBitstreamBufferMaxRange = " << value.dstBitstreamBufferMaxRange << '\n'; + s << "\tsrcPictureResource = " << value.srcPictureResource << '\n'; + s << "\tpSetupReferenceSlot = " << value.pSetupReferenceSlot << '\n'; + s << "\treferenceSlotCount = " << value.referenceSlotCount << '\n'; + s << "\tpReferenceSlots = " << value.pReferenceSlots << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const VkVideoEncodeRateControlInfoKHR& value) +{ + s << "VkVideoEncodeRateControlInfoKHR = {\n"; + s << "\tsType = " << value.sType << '\n'; + s << "\tpNext = " << value.pNext << '\n'; + s << "\tflags = " << getVideoEncodeRateControlFlagsKHRStr(value.flags) << '\n'; + s << "\trateControlMode = " << value.rateControlMode << '\n'; + s << "\taverageBitrate = " << value.averageBitrate << '\n'; + s << "\tpeakToAverageBitrateRatio = " << value.peakToAverageBitrateRatio << '\n'; + s << "\tframeRateNumerator = " << value.frameRateNumerator << '\n'; + s << "\tframeRateDenominator = " << value.frameRateDenominator << '\n'; + s << "\tvirtualBufferSizeInMs = " << value.virtualBufferSizeInMs << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const StdVideoH264SpsVuiFlags& value) +{ + s << "StdVideoH264SpsVuiFlags = {\n"; + s << "\taspect_ratio_info_present_flag = " << value.aspect_ratio_info_present_flag << '\n'; + s << "\toverscan_info_present_flag = " << value.overscan_info_present_flag << '\n'; + s << "\toverscan_appropriate_flag = " << value.overscan_appropriate_flag << '\n'; + s << "\tvideo_signal_type_present_flag = " << value.video_signal_type_present_flag << '\n'; + s << "\tvideo_full_range_flag = " << value.video_full_range_flag << '\n'; + s << "\tcolor_description_present_flag = " << value.color_description_present_flag << '\n'; + s << "\tchroma_loc_info_present_flag = " << value.chroma_loc_info_present_flag << '\n'; + s << "\ttiming_info_present_flag = " << value.timing_info_present_flag << '\n'; + s << "\tfixed_frame_rate_flag = " << value.fixed_frame_rate_flag << '\n'; + s << "\tbitstream_restriction_flag = " << value.bitstream_restriction_flag << '\n'; + s << "\tnal_hrd_parameters_present_flag = " << value.nal_hrd_parameters_present_flag << '\n'; + s << "\tvcl_hrd_parameters_present_flag = " << value.vcl_hrd_parameters_present_flag << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const StdVideoH264HrdParameters& value) +{ + s << "StdVideoH264HrdParameters = {\n"; + s << "\tcpb_cnt_minus1 = " << value.cpb_cnt_minus1 << '\n'; + s << "\tbit_rate_scale = " << value.bit_rate_scale << '\n'; + s << "\tcpb_size_scale = " << value.cpb_size_scale << '\n'; + s << "\tbit_rate_value_minus1 = " << '\n' << tcu::formatArray(DE_ARRAY_BEGIN(value.bit_rate_value_minus1), DE_ARRAY_END(value.bit_rate_value_minus1)) << '\n'; + s << "\tcpb_size_value_minus1 = " << '\n' << tcu::formatArray(DE_ARRAY_BEGIN(value.cpb_size_value_minus1), DE_ARRAY_END(value.cpb_size_value_minus1)) << '\n'; + s << "\tcbr_flag = " << '\n' << tcu::formatArray(tcu::Format::HexIterator(DE_ARRAY_BEGIN(value.cbr_flag)), tcu::Format::HexIterator(DE_ARRAY_END(value.cbr_flag))) << '\n'; + s << "\tinitial_cpb_removal_delay_length_minus1 = " << value.initial_cpb_removal_delay_length_minus1 << '\n'; + s << "\tcpb_removal_delay_length_minus1 = " << value.cpb_removal_delay_length_minus1 << '\n'; + s << "\tdpb_output_delay_length_minus1 = " << value.dpb_output_delay_length_minus1 << '\n'; + s << "\ttime_offset_length = " << value.time_offset_length << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const StdVideoH264SequenceParameterSetVui& value) +{ + s << "StdVideoH264SequenceParameterSetVui = {\n"; + s << "\taspect_ratio_idc = " << value.aspect_ratio_idc << '\n'; + s << "\tsar_width = " << value.sar_width << '\n'; + s << "\tsar_height = " << value.sar_height << '\n'; + s << "\tvideo_format = " << value.video_format << '\n'; + s << "\tcolor_primaries = " << value.color_primaries << '\n'; + s << "\ttransfer_characteristics = " << value.transfer_characteristics << '\n'; + s << "\tmatrix_coefficients = " << value.matrix_coefficients << '\n'; + s << "\tnum_units_in_tick = " << value.num_units_in_tick << '\n'; + s << "\ttime_scale = " << value.time_scale << '\n'; + s << "\thrd_parameters = " << value.hrd_parameters << '\n'; + s << "\tnum_reorder_frames = " << value.num_reorder_frames << '\n'; + s << "\tmax_dec_frame_buffering = " << value.max_dec_frame_buffering << '\n'; + s << "\tflags = " << value.flags << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const StdVideoH264SpsFlags& value) +{ + s << "StdVideoH264SpsFlags = {\n"; + s << "\tconstraint_set0_flag = " << value.constraint_set0_flag << '\n'; + s << "\tconstraint_set1_flag = " << value.constraint_set1_flag << '\n'; + s << "\tconstraint_set2_flag = " << value.constraint_set2_flag << '\n'; + s << "\tconstraint_set3_flag = " << value.constraint_set3_flag << '\n'; + s << "\tconstraint_set4_flag = " << value.constraint_set4_flag << '\n'; + s << "\tconstraint_set5_flag = " << value.constraint_set5_flag << '\n'; + s << "\tdirect_8x8_inference_flag = " << value.direct_8x8_inference_flag << '\n'; + s << "\tmb_adaptive_frame_field_flag = " << value.mb_adaptive_frame_field_flag << '\n'; + s << "\tframe_mbs_only_flag = " << value.frame_mbs_only_flag << '\n'; + s << "\tdelta_pic_order_always_zero_flag = " << value.delta_pic_order_always_zero_flag << '\n'; + s << "\tresidual_colour_transform_flag = " << value.residual_colour_transform_flag << '\n'; + s << "\tgaps_in_frame_num_value_allowed_flag = " << value.gaps_in_frame_num_value_allowed_flag << '\n'; + s << "\tfirst_picture_after_seek_flag = " << value.first_picture_after_seek_flag << '\n'; + s << "\tqpprime_y_zero_transform_bypass_flag = " << value.qpprime_y_zero_transform_bypass_flag << '\n'; + s << "\tframe_cropping_flag = " << value.frame_cropping_flag << '\n'; + s << "\tscaling_matrix_present_flag = " << value.scaling_matrix_present_flag << '\n'; + s << "\tvui_parameters_present_flag = " << value.vui_parameters_present_flag << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const StdVideoH264ScalingLists& value) +{ + s << "StdVideoH264ScalingLists = {\n"; + s << "\tscaling_list_present_mask = " << value.scaling_list_present_mask << '\n'; + s << "\tuse_default_scaling_matrix_mask = " << value.use_default_scaling_matrix_mask << '\n'; + s << "\tScalingList4x4 = " << '\n' << tcu::formatArray(DE_ARRAY_BEGIN(value.ScalingList4x4), DE_ARRAY_END(value.ScalingList4x4)) << '\n'; + s << "\tScalingList8x8 = " << '\n' << tcu::formatArray(DE_ARRAY_BEGIN(value.ScalingList8x8), DE_ARRAY_END(value.ScalingList8x8)) << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const StdVideoH264SequenceParameterSet& value) +{ + s << "StdVideoH264SequenceParameterSet = {\n"; + s << "\tprofile_idc = " << value.profile_idc << '\n'; + s << "\tlevel_idc = " << value.level_idc << '\n'; + s << "\tseq_parameter_set_id = " << value.seq_parameter_set_id << '\n'; + s << "\tchroma_format_idc = " << value.chroma_format_idc << '\n'; + s << "\tbit_depth_luma_minus8 = " << value.bit_depth_luma_minus8 << '\n'; + s << "\tbit_depth_chroma_minus8 = " << value.bit_depth_chroma_minus8 << '\n'; + s << "\tlog2_max_frame_num_minus4 = " << value.log2_max_frame_num_minus4 << '\n'; + s << "\tpic_order_cnt_type = " << value.pic_order_cnt_type << '\n'; + s << "\tlog2_max_pic_order_cnt_lsb_minus4 = " << value.log2_max_pic_order_cnt_lsb_minus4 << '\n'; + s << "\toffset_for_non_ref_pic = " << value.offset_for_non_ref_pic << '\n'; + s << "\toffset_for_top_to_bottom_field = " << value.offset_for_top_to_bottom_field << '\n'; + s << "\tnum_ref_frames_in_pic_order_cnt_cycle = " << value.num_ref_frames_in_pic_order_cnt_cycle << '\n'; + s << "\tmax_num_ref_frames = " << value.max_num_ref_frames << '\n'; + s << "\tpic_width_in_mbs_minus1 = " << value.pic_width_in_mbs_minus1 << '\n'; + s << "\tpic_height_in_map_units_minus1 = " << value.pic_height_in_map_units_minus1 << '\n'; + s << "\tframe_crop_left_offset = " << value.frame_crop_left_offset << '\n'; + s << "\tframe_crop_right_offset = " << value.frame_crop_right_offset << '\n'; + s << "\tframe_crop_top_offset = " << value.frame_crop_top_offset << '\n'; + s << "\tframe_crop_bottom_offset = " << value.frame_crop_bottom_offset << '\n'; + s << "\tflags = " << value.flags << '\n'; + s << "\toffset_for_ref_frame = " << '\n' << tcu::formatArray(DE_ARRAY_BEGIN(value.offset_for_ref_frame), DE_ARRAY_END(value.offset_for_ref_frame)) << '\n'; + s << "\tpScalingLists = " << value.pScalingLists << '\n'; + s << "\tpSequenceParameterSetVui = " << value.pSequenceParameterSetVui << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const StdVideoH264PpsFlags& value) +{ + s << "StdVideoH264PpsFlags = {\n"; + s << "\ttransform_8x8_mode_flag = " << value.transform_8x8_mode_flag << '\n'; + s << "\tredundant_pic_cnt_present_flag = " << value.redundant_pic_cnt_present_flag << '\n'; + s << "\tconstrained_intra_pred_flag = " << value.constrained_intra_pred_flag << '\n'; + s << "\tdeblocking_filter_control_present_flag = " << value.deblocking_filter_control_present_flag << '\n'; + s << "\tweighted_bipred_idc_flag = " << value.weighted_bipred_idc_flag << '\n'; + s << "\tweighted_pred_flag = " << value.weighted_pred_flag << '\n'; + s << "\tpic_order_present_flag = " << value.pic_order_present_flag << '\n'; + s << "\tentropy_coding_mode_flag = " << value.entropy_coding_mode_flag << '\n'; + s << "\tscaling_matrix_present_flag = " << value.scaling_matrix_present_flag << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const StdVideoH264PictureParameterSet& value) +{ + s << "StdVideoH264PictureParameterSet = {\n"; + s << "\tseq_parameter_set_id = " << value.seq_parameter_set_id << '\n'; + s << "\tpic_parameter_set_id = " << value.pic_parameter_set_id << '\n'; + s << "\tnum_ref_idx_l0_default_active_minus1 = " << value.num_ref_idx_l0_default_active_minus1 << '\n'; + s << "\tnum_ref_idx_l1_default_active_minus1 = " << value.num_ref_idx_l1_default_active_minus1 << '\n'; + s << "\tweighted_bipred_idc = " << value.weighted_bipred_idc << '\n'; + s << "\tpic_init_qp_minus26 = " << value.pic_init_qp_minus26 << '\n'; + s << "\tpic_init_qs_minus26 = " << value.pic_init_qs_minus26 << '\n'; + s << "\tchroma_qp_index_offset = " << value.chroma_qp_index_offset << '\n'; + s << "\tsecond_chroma_qp_index_offset = " << value.second_chroma_qp_index_offset << '\n'; + s << "\tflags = " << value.flags << '\n'; + s << "\tpScalingLists = " << value.pScalingLists << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const StdVideoEncodeH264SliceHeaderFlags& value) +{ + s << "StdVideoEncodeH264SliceHeaderFlags = {\n"; + s << "\tidr_flag = " << value.idr_flag << '\n'; + s << "\tis_reference_flag = " << value.is_reference_flag << '\n'; + s << "\tnum_ref_idx_active_override_flag = " << value.num_ref_idx_active_override_flag << '\n'; + s << "\tno_output_of_prior_pics_flag = " << value.no_output_of_prior_pics_flag << '\n'; + s << "\tlong_term_reference_flag = " << value.long_term_reference_flag << '\n'; + s << "\tadaptive_ref_pic_marking_mode_flag = " << value.adaptive_ref_pic_marking_mode_flag << '\n'; + s << "\tno_prior_references_available_flag = " << value.no_prior_references_available_flag << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const StdVideoEncodeH264PictureInfoFlags& value) +{ + s << "StdVideoEncodeH264PictureInfoFlags = {\n"; + s << "\tidr_flag = " << value.idr_flag << '\n'; + s << "\tis_reference_flag = " << value.is_reference_flag << '\n'; + s << "\tlong_term_reference_flag = " << value.long_term_reference_flag << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const StdVideoEncodeH264RefMgmtFlags& value) +{ + s << "StdVideoEncodeH264RefMgmtFlags = {\n"; + s << "\tref_pic_list_modification_l0_flag = " << value.ref_pic_list_modification_l0_flag << '\n'; + s << "\tref_pic_list_modification_l1_flag = " << value.ref_pic_list_modification_l1_flag << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const StdVideoEncodeH264RefListModEntry& value) +{ + s << "StdVideoEncodeH264RefListModEntry = {\n"; + s << "\tmodification_of_pic_nums_idc = " << value.modification_of_pic_nums_idc << '\n'; + s << "\tabs_diff_pic_num_minus1 = " << value.abs_diff_pic_num_minus1 << '\n'; + s << "\tlong_term_pic_num = " << value.long_term_pic_num << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const StdVideoEncodeH264RefPicMarkingEntry& value) +{ + s << "StdVideoEncodeH264RefPicMarkingEntry = {\n"; + s << "\toperation = " << value.operation << '\n'; + s << "\tdifference_of_pic_nums_minus1 = " << value.difference_of_pic_nums_minus1 << '\n'; + s << "\tlong_term_pic_num = " << value.long_term_pic_num << '\n'; + s << "\tlong_term_frame_idx = " << value.long_term_frame_idx << '\n'; + s << "\tmax_long_term_frame_idx_plus1 = " << value.max_long_term_frame_idx_plus1 << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const StdVideoEncodeH264RefMemMgmtCtrlOperations& value) +{ + s << "StdVideoEncodeH264RefMemMgmtCtrlOperations = {\n"; + s << "\tflags = " << value.flags << '\n'; + s << "\trefList0ModOpCount = " << value.refList0ModOpCount << '\n'; + s << "\tpRefList0ModOperations = " << value.pRefList0ModOperations << '\n'; + s << "\trefList1ModOpCount = " << value.refList1ModOpCount << '\n'; + s << "\tpRefList1ModOperations = " << value.pRefList1ModOperations << '\n'; + s << "\trefPicMarkingOpCount = " << value.refPicMarkingOpCount << '\n'; + s << "\tpRefPicMarkingOperations = " << value.pRefPicMarkingOperations << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const StdVideoEncodeH264PictureInfo& value) +{ + s << "StdVideoEncodeH264PictureInfo = {\n"; + s << "\tflags = " << value.flags << '\n'; + s << "\tpictureType = " << value.pictureType << '\n'; + s << "\tframeNum = " << value.frameNum << '\n'; + s << "\tpictureOrderCount = " << value.pictureOrderCount << '\n'; + s << "\tlong_term_pic_num = " << value.long_term_pic_num << '\n'; + s << "\tlong_term_frame_idx = " << value.long_term_frame_idx << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const StdVideoEncodeH264SliceHeader& value) +{ + s << "StdVideoEncodeH264SliceHeader = {\n"; + s << "\tflags = " << value.flags << '\n'; + s << "\tslice_type = " << value.slice_type << '\n'; + s << "\tseq_parameter_set_id = " << value.seq_parameter_set_id << '\n'; + s << "\tpic_parameter_set_id = " << value.pic_parameter_set_id << '\n'; + s << "\tidr_pic_id = " << value.idr_pic_id << '\n'; + s << "\tnum_ref_idx_l0_active_minus1 = " << value.num_ref_idx_l0_active_minus1 << '\n'; + s << "\tnum_ref_idx_l1_active_minus1 = " << value.num_ref_idx_l1_active_minus1 << '\n'; + s << "\tcabac_init_idc = " << value.cabac_init_idc << '\n'; + s << "\tdisable_deblocking_filter_idc = " << value.disable_deblocking_filter_idc << '\n'; + s << "\tslice_alpha_c0_offset_div2 = " << value.slice_alpha_c0_offset_div2 << '\n'; + s << "\tslice_beta_offset_div2 = " << value.slice_beta_offset_div2 << '\n'; + s << "\tpMemMgmtCtrlOperations = " << value.pMemMgmtCtrlOperations << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const VkVideoEncodeH264CapabilitiesEXT& value) +{ + s << "VkVideoEncodeH264CapabilitiesEXT = {\n"; + s << "\tsType = " << value.sType << '\n'; + s << "\tpNext = " << value.pNext << '\n'; + s << "\tflags = " << getVideoEncodeH264CapabilitiesFlagsEXTStr(value.flags) << '\n'; + s << "\tinputModeFlags = " << getVideoEncodeH264InputModeFlagsEXTStr(value.inputModeFlags) << '\n'; + s << "\toutputModeFlags = " << getVideoEncodeH264OutputModeFlagsEXTStr(value.outputModeFlags) << '\n'; + s << "\tminPictureSizeInMbs = " << value.minPictureSizeInMbs << '\n'; + s << "\tmaxPictureSizeInMbs = " << value.maxPictureSizeInMbs << '\n'; + s << "\tinputImageDataAlignment = " << value.inputImageDataAlignment << '\n'; + s << "\tmaxNumL0ReferenceForP = " << value.maxNumL0ReferenceForP << '\n'; + s << "\tmaxNumL0ReferenceForB = " << value.maxNumL0ReferenceForB << '\n'; + s << "\tmaxNumL1Reference = " << value.maxNumL1Reference << '\n'; + s << "\tqualityLevelCount = " << value.qualityLevelCount << '\n'; + s << "\tstdExtensionVersion = " << value.stdExtensionVersion << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const VkVideoEncodeH264SessionCreateInfoEXT& value) +{ + s << "VkVideoEncodeH264SessionCreateInfoEXT = {\n"; + s << "\tsType = " << value.sType << '\n'; + s << "\tpNext = " << value.pNext << '\n'; + s << "\tflags = " << getVideoEncodeH264CreateFlagsEXTStr(value.flags) << '\n'; + s << "\tmaxPictureSizeInMbs = " << value.maxPictureSizeInMbs << '\n'; + s << "\tpStdExtensionVersion = " << value.pStdExtensionVersion << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const VkVideoEncodeH264SessionParametersAddInfoEXT& value) +{ + s << "VkVideoEncodeH264SessionParametersAddInfoEXT = {\n"; + s << "\tsType = " << value.sType << '\n'; + s << "\tpNext = " << value.pNext << '\n'; + s << "\tspsStdCount = " << value.spsStdCount << '\n'; + s << "\tpSpsStd = " << value.pSpsStd << '\n'; + s << "\tppsStdCount = " << value.ppsStdCount << '\n'; + s << "\tpPpsStd = " << value.pPpsStd << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const VkVideoEncodeH264SessionParametersCreateInfoEXT& value) +{ + s << "VkVideoEncodeH264SessionParametersCreateInfoEXT = {\n"; + s << "\tsType = " << value.sType << '\n'; + s << "\tpNext = " << value.pNext << '\n'; + s << "\tmaxSpsStdCount = " << value.maxSpsStdCount << '\n'; + s << "\tmaxPpsStdCount = " << value.maxPpsStdCount << '\n'; + s << "\tpParametersAddInfo = " << value.pParametersAddInfo << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const VkVideoEncodeH264DpbSlotInfoEXT& value) +{ + s << "VkVideoEncodeH264DpbSlotInfoEXT = {\n"; + s << "\tsType = " << value.sType << '\n'; + s << "\tpNext = " << value.pNext << '\n'; + s << "\tslotIndex = " << value.slotIndex << '\n'; + s << "\tpStdPictureInfo = " << value.pStdPictureInfo << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const VkVideoEncodeH264NaluSliceEXT& value) +{ + s << "VkVideoEncodeH264NaluSliceEXT = {\n"; + s << "\tsType = " << value.sType << '\n'; + s << "\tpNext = " << value.pNext << '\n'; + s << "\tpSliceHeaderStd = " << value.pSliceHeaderStd << '\n'; + s << "\tmbCount = " << value.mbCount << '\n'; + s << "\trefFinalList0EntryCount = " << value.refFinalList0EntryCount << '\n'; + s << "\tpRefFinalList0Entries = " << value.pRefFinalList0Entries << '\n'; + s << "\trefFinalList1EntryCount = " << value.refFinalList1EntryCount << '\n'; + s << "\tpRefFinalList1Entries = " << value.pRefFinalList1Entries << '\n'; + s << "\tprecedingNaluBytes = " << value.precedingNaluBytes << '\n'; + s << "\tminQp = " << value.minQp << '\n'; + s << "\tmaxQp = " << value.maxQp << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const VkVideoEncodeH264VclFrameInfoEXT& value) +{ + s << "VkVideoEncodeH264VclFrameInfoEXT = {\n"; + s << "\tsType = " << value.sType << '\n'; + s << "\tpNext = " << value.pNext << '\n'; + s << "\trefDefaultFinalList0EntryCount = " << value.refDefaultFinalList0EntryCount << '\n'; + s << "\tpRefDefaultFinalList0Entries = " << value.pRefDefaultFinalList0Entries << '\n'; + s << "\trefDefaultFinalList1EntryCount = " << value.refDefaultFinalList1EntryCount << '\n'; + s << "\tpRefDefaultFinalList1Entries = " << value.pRefDefaultFinalList1Entries << '\n'; + s << "\tnaluSliceEntryCount = " << value.naluSliceEntryCount << '\n'; + s << "\tpNaluSliceEntries = " << value.pNaluSliceEntries << '\n'; + s << "\tpCurrentPictureInfo = " << value.pCurrentPictureInfo << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const VkVideoEncodeH264EmitPictureParametersEXT& value) +{ + s << "VkVideoEncodeH264EmitPictureParametersEXT = {\n"; + s << "\tsType = " << value.sType << '\n'; + s << "\tpNext = " << value.pNext << '\n'; + s << "\tspsId = " << value.spsId << '\n'; + s << "\temitSpsEnable = " << value.emitSpsEnable << '\n'; + s << "\tppsIdEntryCount = " << value.ppsIdEntryCount << '\n'; + s << "\tppsIdEntries = " << value.ppsIdEntries << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const VkVideoEncodeH264ProfileEXT& value) +{ + s << "VkVideoEncodeH264ProfileEXT = {\n"; + s << "\tsType = " << value.sType << '\n'; + s << "\tpNext = " << value.pNext << '\n'; + s << "\tstdProfileIdc = " << value.stdProfileIdc << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const StdVideoDecodeH264PictureInfoFlags& value) +{ + s << "StdVideoDecodeH264PictureInfoFlags = {\n"; + s << "\tfield_pic_flag = " << value.field_pic_flag << '\n'; + s << "\tis_intra = " << value.is_intra << '\n'; + s << "\tbottom_field_flag = " << value.bottom_field_flag << '\n'; + s << "\tis_reference = " << value.is_reference << '\n'; + s << "\tcomplementary_field_pair = " << value.complementary_field_pair << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const StdVideoDecodeH264PictureInfo& value) +{ + s << "StdVideoDecodeH264PictureInfo = {\n"; + s << "\tseq_parameter_set_id = " << value.seq_parameter_set_id << '\n'; + s << "\tpic_parameter_set_id = " << value.pic_parameter_set_id << '\n'; + s << "\treserved = " << value.reserved << '\n'; + s << "\tframe_num = " << value.frame_num << '\n'; + s << "\tidr_pic_id = " << value.idr_pic_id << '\n'; + s << "\tPicOrderCnt = " << '\n' << tcu::formatArray(DE_ARRAY_BEGIN(value.PicOrderCnt), DE_ARRAY_END(value.PicOrderCnt)) << '\n'; + s << "\tflags = " << value.flags << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const StdVideoDecodeH264ReferenceInfoFlags& value) +{ + s << "StdVideoDecodeH264ReferenceInfoFlags = {\n"; + s << "\ttop_field_flag = " << value.top_field_flag << '\n'; + s << "\tbottom_field_flag = " << value.bottom_field_flag << '\n'; + s << "\tis_long_term = " << value.is_long_term << '\n'; + s << "\tis_non_existing = " << value.is_non_existing << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const StdVideoDecodeH264ReferenceInfo& value) +{ + s << "StdVideoDecodeH264ReferenceInfo = {\n"; + s << "\tFrameNum = " << value.FrameNum << '\n'; + s << "\treserved = " << value.reserved << '\n'; + s << "\tPicOrderCnt = " << '\n' << tcu::formatArray(DE_ARRAY_BEGIN(value.PicOrderCnt), DE_ARRAY_END(value.PicOrderCnt)) << '\n'; + s << "\tflags = " << value.flags << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const StdVideoDecodeH264MvcElementFlags& value) +{ + s << "StdVideoDecodeH264MvcElementFlags = {\n"; + s << "\tnon_idr = " << value.non_idr << '\n'; + s << "\tanchor_pic = " << value.anchor_pic << '\n'; + s << "\tinter_view = " << value.inter_view << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const StdVideoDecodeH264MvcElement& value) +{ + s << "StdVideoDecodeH264MvcElement = {\n"; + s << "\tflags = " << value.flags << '\n'; + s << "\tviewOrderIndex = " << value.viewOrderIndex << '\n'; + s << "\tviewId = " << value.viewId << '\n'; + s << "\ttemporalId = " << value.temporalId << '\n'; + s << "\tpriorityId = " << value.priorityId << '\n'; + s << "\tnumOfAnchorRefsInL0 = " << value.numOfAnchorRefsInL0 << '\n'; + s << "\tviewIdOfAnchorRefsInL0 = " << '\n' << tcu::formatArray(DE_ARRAY_BEGIN(value.viewIdOfAnchorRefsInL0), DE_ARRAY_END(value.viewIdOfAnchorRefsInL0)) << '\n'; + s << "\tnumOfAnchorRefsInL1 = " << value.numOfAnchorRefsInL1 << '\n'; + s << "\tviewIdOfAnchorRefsInL1 = " << '\n' << tcu::formatArray(DE_ARRAY_BEGIN(value.viewIdOfAnchorRefsInL1), DE_ARRAY_END(value.viewIdOfAnchorRefsInL1)) << '\n'; + s << "\tnumOfNonAnchorRefsInL0 = " << value.numOfNonAnchorRefsInL0 << '\n'; + s << "\tviewIdOfNonAnchorRefsInL0 = " << '\n' << tcu::formatArray(DE_ARRAY_BEGIN(value.viewIdOfNonAnchorRefsInL0), DE_ARRAY_END(value.viewIdOfNonAnchorRefsInL0)) << '\n'; + s << "\tnumOfNonAnchorRefsInL1 = " << value.numOfNonAnchorRefsInL1 << '\n'; + s << "\tviewIdOfNonAnchorRefsInL1 = " << '\n' << tcu::formatArray(DE_ARRAY_BEGIN(value.viewIdOfNonAnchorRefsInL1), DE_ARRAY_END(value.viewIdOfNonAnchorRefsInL1)) << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const StdVideoDecodeH264Mvc& value) +{ + s << "StdVideoDecodeH264Mvc = {\n"; + s << "\tviewId0 = " << value.viewId0 << '\n'; + s << "\tmvcElementCount = " << value.mvcElementCount << '\n'; + s << "\tpMvcElements = " << value.pMvcElements << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const VkVideoDecodeH264ProfileEXT& value) +{ + s << "VkVideoDecodeH264ProfileEXT = {\n"; + s << "\tsType = " << value.sType << '\n'; + s << "\tpNext = " << value.pNext << '\n'; + s << "\tstdProfileIdc = " << value.stdProfileIdc << '\n'; + s << "\tfieldLayout = " << getVideoDecodeH264FieldLayoutFlagsEXTStr(value.fieldLayout) << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const VkVideoDecodeH264CapabilitiesEXT& value) +{ + s << "VkVideoDecodeH264CapabilitiesEXT = {\n"; + s << "\tsType = " << value.sType << '\n'; + s << "\tpNext = " << value.pNext << '\n'; + s << "\tmaxLevel = " << value.maxLevel << '\n'; + s << "\tfieldOffsetGranularity = " << value.fieldOffsetGranularity << '\n'; + s << "\tstdExtensionVersion = " << value.stdExtensionVersion << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const VkVideoDecodeH264SessionCreateInfoEXT& value) +{ + s << "VkVideoDecodeH264SessionCreateInfoEXT = {\n"; + s << "\tsType = " << value.sType << '\n'; + s << "\tpNext = " << value.pNext << '\n'; + s << "\tflags = " << getVideoDecodeH264CreateFlagsEXTStr(value.flags) << '\n'; + s << "\tpStdExtensionVersion = " << value.pStdExtensionVersion << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const VkVideoDecodeH264SessionParametersAddInfoEXT& value) +{ + s << "VkVideoDecodeH264SessionParametersAddInfoEXT = {\n"; + s << "\tsType = " << value.sType << '\n'; + s << "\tpNext = " << value.pNext << '\n'; + s << "\tspsStdCount = " << value.spsStdCount << '\n'; + s << "\tpSpsStd = " << value.pSpsStd << '\n'; + s << "\tppsStdCount = " << value.ppsStdCount << '\n'; + s << "\tpPpsStd = " << value.pPpsStd << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const VkVideoDecodeH264SessionParametersCreateInfoEXT& value) +{ + s << "VkVideoDecodeH264SessionParametersCreateInfoEXT = {\n"; + s << "\tsType = " << value.sType << '\n'; + s << "\tpNext = " << value.pNext << '\n'; + s << "\tmaxSpsStdCount = " << value.maxSpsStdCount << '\n'; + s << "\tmaxPpsStdCount = " << value.maxPpsStdCount << '\n'; + s << "\tpParametersAddInfo = " << value.pParametersAddInfo << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const VkVideoDecodeH264PictureInfoEXT& value) +{ + s << "VkVideoDecodeH264PictureInfoEXT = {\n"; + s << "\tsType = " << value.sType << '\n'; + s << "\tpNext = " << value.pNext << '\n'; + s << "\tpStdPictureInfo = " << value.pStdPictureInfo << '\n'; + s << "\tslicesCount = " << value.slicesCount << '\n'; + s << "\tpSlicesDataOffsets = " << value.pSlicesDataOffsets << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const VkVideoDecodeH264MvcEXT& value) +{ + s << "VkVideoDecodeH264MvcEXT = {\n"; + s << "\tsType = " << value.sType << '\n'; + s << "\tpNext = " << value.pNext << '\n'; + s << "\tpStdMvc = " << value.pStdMvc << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const VkVideoDecodeH264DpbSlotInfoEXT& value) +{ + s << "VkVideoDecodeH264DpbSlotInfoEXT = {\n"; + s << "\tsType = " << value.sType << '\n'; + s << "\tpNext = " << value.pNext << '\n'; + s << "\tpStdReferenceInfo = " << value.pStdReferenceInfo << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const StdVideoH265DecPicBufMgr& value) +{ + s << "StdVideoH265DecPicBufMgr = {\n"; + s << "\tmax_latency_increase_plus1 = " << '\n' << tcu::formatArray(DE_ARRAY_BEGIN(value.max_latency_increase_plus1), DE_ARRAY_END(value.max_latency_increase_plus1)) << '\n'; + s << "\tmax_dec_pic_buffering_minus1 = " << '\n' << tcu::formatArray(tcu::Format::HexIterator(DE_ARRAY_BEGIN(value.max_dec_pic_buffering_minus1)), tcu::Format::HexIterator(DE_ARRAY_END(value.max_dec_pic_buffering_minus1))) << '\n'; + s << "\tmax_num_reorder_pics = " << '\n' << tcu::formatArray(tcu::Format::HexIterator(DE_ARRAY_BEGIN(value.max_num_reorder_pics)), tcu::Format::HexIterator(DE_ARRAY_END(value.max_num_reorder_pics))) << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const StdVideoH265SubLayerHrdParameters& value) +{ + s << "StdVideoH265SubLayerHrdParameters = {\n"; + s << "\tbit_rate_value_minus1 = " << '\n' << tcu::formatArray(DE_ARRAY_BEGIN(value.bit_rate_value_minus1), DE_ARRAY_END(value.bit_rate_value_minus1)) << '\n'; + s << "\tcpb_size_value_minus1 = " << '\n' << tcu::formatArray(DE_ARRAY_BEGIN(value.cpb_size_value_minus1), DE_ARRAY_END(value.cpb_size_value_minus1)) << '\n'; + s << "\tcpb_size_du_value_minus1 = " << '\n' << tcu::formatArray(DE_ARRAY_BEGIN(value.cpb_size_du_value_minus1), DE_ARRAY_END(value.cpb_size_du_value_minus1)) << '\n'; + s << "\tbit_rate_du_value_minus1 = " << '\n' << tcu::formatArray(DE_ARRAY_BEGIN(value.bit_rate_du_value_minus1), DE_ARRAY_END(value.bit_rate_du_value_minus1)) << '\n'; + s << "\tcbr_flag = " << value.cbr_flag << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const StdVideoH265HrdFlags& value) +{ + s << "StdVideoH265HrdFlags = {\n"; + s << "\tnal_hrd_parameters_present_flag = " << value.nal_hrd_parameters_present_flag << '\n'; + s << "\tvcl_hrd_parameters_present_flag = " << value.vcl_hrd_parameters_present_flag << '\n'; + s << "\tsub_pic_hrd_params_present_flag = " << value.sub_pic_hrd_params_present_flag << '\n'; + s << "\tsub_pic_cpb_params_in_pic_timing_sei_flag = " << value.sub_pic_cpb_params_in_pic_timing_sei_flag << '\n'; + s << "\tfixed_pic_rate_general_flag = " << value.fixed_pic_rate_general_flag << '\n'; + s << "\tfixed_pic_rate_within_cvs_flag = " << value.fixed_pic_rate_within_cvs_flag << '\n'; + s << "\tlow_delay_hrd_flag = " << value.low_delay_hrd_flag << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const StdVideoH265HrdParameters& value) +{ + s << "StdVideoH265HrdParameters = {\n"; + s << "\ttick_divisor_minus2 = " << value.tick_divisor_minus2 << '\n'; + s << "\tdu_cpb_removal_delay_increment_length_minus1 = " << value.du_cpb_removal_delay_increment_length_minus1 << '\n'; + s << "\tdpb_output_delay_du_length_minus1 = " << value.dpb_output_delay_du_length_minus1 << '\n'; + s << "\tbit_rate_scale = " << value.bit_rate_scale << '\n'; + s << "\tcpb_size_scale = " << value.cpb_size_scale << '\n'; + s << "\tcpb_size_du_scale = " << value.cpb_size_du_scale << '\n'; + s << "\tinitial_cpb_removal_delay_length_minus1 = " << value.initial_cpb_removal_delay_length_minus1 << '\n'; + s << "\tau_cpb_removal_delay_length_minus1 = " << value.au_cpb_removal_delay_length_minus1 << '\n'; + s << "\tdpb_output_delay_length_minus1 = " << value.dpb_output_delay_length_minus1 << '\n'; + s << "\tcpb_cnt_minus1 = " << '\n' << tcu::formatArray(tcu::Format::HexIterator(DE_ARRAY_BEGIN(value.cpb_cnt_minus1)), tcu::Format::HexIterator(DE_ARRAY_END(value.cpb_cnt_minus1))) << '\n'; + s << "\telemental_duration_in_tc_minus1 = " << '\n' << tcu::formatArray(DE_ARRAY_BEGIN(value.elemental_duration_in_tc_minus1), DE_ARRAY_END(value.elemental_duration_in_tc_minus1)) << '\n'; + s << "\tSubLayerHrdParametersNal = " << '\n' << tcu::formatArray(DE_ARRAY_BEGIN(value.SubLayerHrdParametersNal), DE_ARRAY_END(value.SubLayerHrdParametersNal)) << '\n'; + s << "\tSubLayerHrdParametersVcl = " << '\n' << tcu::formatArray(DE_ARRAY_BEGIN(value.SubLayerHrdParametersVcl), DE_ARRAY_END(value.SubLayerHrdParametersVcl)) << '\n'; + s << "\tflags = " << value.flags << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const StdVideoH265VpsFlags& value) +{ + s << "StdVideoH265VpsFlags = {\n"; + s << "\tvps_temporal_id_nesting_flag = " << value.vps_temporal_id_nesting_flag << '\n'; + s << "\tvps_sub_layer_ordering_info_present_flag = " << value.vps_sub_layer_ordering_info_present_flag << '\n'; + s << "\tvps_timing_info_present_flag = " << value.vps_timing_info_present_flag << '\n'; + s << "\tvps_poc_proportional_to_timing_flag = " << value.vps_poc_proportional_to_timing_flag << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const StdVideoH265VideoParameterSet& value) +{ + s << "StdVideoH265VideoParameterSet = {\n"; + s << "\tvps_video_parameter_set_id = " << value.vps_video_parameter_set_id << '\n'; + s << "\tvps_max_sub_layers_minus1 = " << value.vps_max_sub_layers_minus1 << '\n'; + s << "\tvps_num_units_in_tick = " << value.vps_num_units_in_tick << '\n'; + s << "\tvps_time_scale = " << value.vps_time_scale << '\n'; + s << "\tvps_num_ticks_poc_diff_one_minus1 = " << value.vps_num_ticks_poc_diff_one_minus1 << '\n'; + s << "\tpDecPicBufMgr = " << value.pDecPicBufMgr << '\n'; + s << "\thrd_parameters = " << value.hrd_parameters << '\n'; + s << "\tflags = " << value.flags << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const StdVideoH265ScalingLists& value) +{ + s << "StdVideoH265ScalingLists = {\n"; + s << "\tScalingList4x4 = " << '\n' << tcu::formatArray(DE_ARRAY_BEGIN(value.ScalingList4x4), DE_ARRAY_END(value.ScalingList4x4)) << '\n'; + s << "\tScalingList8x8 = " << '\n' << tcu::formatArray(DE_ARRAY_BEGIN(value.ScalingList8x8), DE_ARRAY_END(value.ScalingList8x8)) << '\n'; + s << "\tScalingList16x16 = " << '\n' << tcu::formatArray(DE_ARRAY_BEGIN(value.ScalingList16x16), DE_ARRAY_END(value.ScalingList16x16)) << '\n'; + s << "\tScalingList32x32 = " << '\n' << tcu::formatArray(DE_ARRAY_BEGIN(value.ScalingList32x32), DE_ARRAY_END(value.ScalingList32x32)) << '\n'; + s << "\tScalingListDCCoef16x16 = " << '\n' << tcu::formatArray(tcu::Format::HexIterator(DE_ARRAY_BEGIN(value.ScalingListDCCoef16x16)), tcu::Format::HexIterator(DE_ARRAY_END(value.ScalingListDCCoef16x16))) << '\n'; + s << "\tScalingListDCCoef32x32 = " << '\n' << tcu::formatArray(tcu::Format::HexIterator(DE_ARRAY_BEGIN(value.ScalingListDCCoef32x32)), tcu::Format::HexIterator(DE_ARRAY_END(value.ScalingListDCCoef32x32))) << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const StdVideoH265SpsVuiFlags& value) +{ + s << "StdVideoH265SpsVuiFlags = {\n"; + s << "\taspect_ratio_info_present_flag = " << value.aspect_ratio_info_present_flag << '\n'; + s << "\toverscan_info_present_flag = " << value.overscan_info_present_flag << '\n'; + s << "\toverscan_appropriate_flag = " << value.overscan_appropriate_flag << '\n'; + s << "\tvideo_signal_type_present_flag = " << value.video_signal_type_present_flag << '\n'; + s << "\tvideo_full_range_flag = " << value.video_full_range_flag << '\n'; + s << "\tcolour_description_present_flag = " << value.colour_description_present_flag << '\n'; + s << "\tchroma_loc_info_present_flag = " << value.chroma_loc_info_present_flag << '\n'; + s << "\tneutral_chroma_indication_flag = " << value.neutral_chroma_indication_flag << '\n'; + s << "\tfield_seq_flag = " << value.field_seq_flag << '\n'; + s << "\tframe_field_info_present_flag = " << value.frame_field_info_present_flag << '\n'; + s << "\tdefault_display_window_flag = " << value.default_display_window_flag << '\n'; + s << "\tvui_timing_info_present_flag = " << value.vui_timing_info_present_flag << '\n'; + s << "\tvui_poc_proportional_to_timing_flag = " << value.vui_poc_proportional_to_timing_flag << '\n'; + s << "\tvui_hrd_parameters_present_flag = " << value.vui_hrd_parameters_present_flag << '\n'; + s << "\tbitstream_restriction_flag = " << value.bitstream_restriction_flag << '\n'; + s << "\ttiles_fixed_structure_flag = " << value.tiles_fixed_structure_flag << '\n'; + s << "\tmotion_vectors_over_pic_boundaries_flag = " << value.motion_vectors_over_pic_boundaries_flag << '\n'; + s << "\trestricted_ref_pic_lists_flag = " << value.restricted_ref_pic_lists_flag << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const StdVideoH265SequenceParameterSetVui& value) +{ + s << "StdVideoH265SequenceParameterSetVui = {\n"; + s << "\taspect_ratio_idc = " << value.aspect_ratio_idc << '\n'; + s << "\tsar_width = " << value.sar_width << '\n'; + s << "\tsar_height = " << value.sar_height << '\n'; + s << "\tvideo_format = " << value.video_format << '\n'; + s << "\tcolour_primaries = " << value.colour_primaries << '\n'; + s << "\ttransfer_characteristics = " << value.transfer_characteristics << '\n'; + s << "\tmatrix_coeffs = " << value.matrix_coeffs << '\n'; + s << "\tchroma_sample_loc_type_top_field = " << value.chroma_sample_loc_type_top_field << '\n'; + s << "\tchroma_sample_loc_type_bottom_field = " << value.chroma_sample_loc_type_bottom_field << '\n'; + s << "\tdef_disp_win_left_offset = " << value.def_disp_win_left_offset << '\n'; + s << "\tdef_disp_win_right_offset = " << value.def_disp_win_right_offset << '\n'; + s << "\tdef_disp_win_top_offset = " << value.def_disp_win_top_offset << '\n'; + s << "\tdef_disp_win_bottom_offset = " << value.def_disp_win_bottom_offset << '\n'; + s << "\tvui_num_units_in_tick = " << value.vui_num_units_in_tick << '\n'; + s << "\tvui_time_scale = " << value.vui_time_scale << '\n'; + s << "\tvui_num_ticks_poc_diff_one_minus1 = " << value.vui_num_ticks_poc_diff_one_minus1 << '\n'; + s << "\thrd_parameters = " << value.hrd_parameters << '\n'; + s << "\tmin_spatial_segmentation_idc = " << value.min_spatial_segmentation_idc << '\n'; + s << "\tmax_bytes_per_pic_denom = " << value.max_bytes_per_pic_denom << '\n'; + s << "\tmax_bits_per_min_cu_denom = " << value.max_bits_per_min_cu_denom << '\n'; + s << "\tlog2_max_mv_length_horizontal = " << value.log2_max_mv_length_horizontal << '\n'; + s << "\tlog2_max_mv_length_vertical = " << value.log2_max_mv_length_vertical << '\n'; + s << "\tflags = " << value.flags << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const StdVideoH265PredictorPaletteEntries& value) +{ + s << "StdVideoH265PredictorPaletteEntries = {\n"; + s << "\tPredictorPaletteEntries = " << '\n' << tcu::formatArray(DE_ARRAY_BEGIN(value.PredictorPaletteEntries), DE_ARRAY_END(value.PredictorPaletteEntries)) << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const StdVideoH265SpsFlags& value) +{ + s << "StdVideoH265SpsFlags = {\n"; + s << "\tsps_temporal_id_nesting_flag = " << value.sps_temporal_id_nesting_flag << '\n'; + s << "\tseparate_colour_plane_flag = " << value.separate_colour_plane_flag << '\n'; + s << "\tscaling_list_enabled_flag = " << value.scaling_list_enabled_flag << '\n'; + s << "\tsps_scaling_list_data_present_flag = " << value.sps_scaling_list_data_present_flag << '\n'; + s << "\tamp_enabled_flag = " << value.amp_enabled_flag << '\n'; + s << "\tsample_adaptive_offset_enabled_flag = " << value.sample_adaptive_offset_enabled_flag << '\n'; + s << "\tpcm_enabled_flag = " << value.pcm_enabled_flag << '\n'; + s << "\tpcm_loop_filter_disabled_flag = " << value.pcm_loop_filter_disabled_flag << '\n'; + s << "\tlong_term_ref_pics_present_flag = " << value.long_term_ref_pics_present_flag << '\n'; + s << "\tsps_temporal_mvp_enabled_flag = " << value.sps_temporal_mvp_enabled_flag << '\n'; + s << "\tstrong_intra_smoothing_enabled_flag = " << value.strong_intra_smoothing_enabled_flag << '\n'; + s << "\tvui_parameters_present_flag = " << value.vui_parameters_present_flag << '\n'; + s << "\tsps_extension_present_flag = " << value.sps_extension_present_flag << '\n'; + s << "\tsps_range_extension_flag = " << value.sps_range_extension_flag << '\n'; + s << "\ttransform_skip_rotation_enabled_flag = " << value.transform_skip_rotation_enabled_flag << '\n'; + s << "\ttransform_skip_context_enabled_flag = " << value.transform_skip_context_enabled_flag << '\n'; + s << "\timplicit_rdpcm_enabled_flag = " << value.implicit_rdpcm_enabled_flag << '\n'; + s << "\texplicit_rdpcm_enabled_flag = " << value.explicit_rdpcm_enabled_flag << '\n'; + s << "\textended_precision_processing_flag = " << value.extended_precision_processing_flag << '\n'; + s << "\tintra_smoothing_disabled_flag = " << value.intra_smoothing_disabled_flag << '\n'; + s << "\thigh_precision_offsets_enabled_flag = " << value.high_precision_offsets_enabled_flag << '\n'; + s << "\tpersistent_rice_adaptation_enabled_flag = " << value.persistent_rice_adaptation_enabled_flag << '\n'; + s << "\tcabac_bypass_alignment_enabled_flag = " << value.cabac_bypass_alignment_enabled_flag << '\n'; + s << "\tsps_curr_pic_ref_enabled_flag = " << value.sps_curr_pic_ref_enabled_flag << '\n'; + s << "\tpalette_mode_enabled_flag = " << value.palette_mode_enabled_flag << '\n'; + s << "\tsps_palette_predictor_initializer_present_flag = " << value.sps_palette_predictor_initializer_present_flag << '\n'; + s << "\tintra_boundary_filtering_disabled_flag = " << value.intra_boundary_filtering_disabled_flag << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const StdVideoH265SequenceParameterSet& value) +{ + s << "StdVideoH265SequenceParameterSet = {\n"; + s << "\tprofile_idc = " << value.profile_idc << '\n'; + s << "\tlevel_idc = " << value.level_idc << '\n'; + s << "\tpic_width_in_luma_samples = " << value.pic_width_in_luma_samples << '\n'; + s << "\tpic_height_in_luma_samples = " << value.pic_height_in_luma_samples << '\n'; + s << "\tsps_video_parameter_set_id = " << value.sps_video_parameter_set_id << '\n'; + s << "\tsps_max_sub_layers_minus1 = " << value.sps_max_sub_layers_minus1 << '\n'; + s << "\tsps_seq_parameter_set_id = " << value.sps_seq_parameter_set_id << '\n'; + s << "\tchroma_format_idc = " << value.chroma_format_idc << '\n'; + s << "\tbit_depth_luma_minus8 = " << value.bit_depth_luma_minus8 << '\n'; + s << "\tbit_depth_chroma_minus8 = " << value.bit_depth_chroma_minus8 << '\n'; + s << "\tlog2_max_pic_order_cnt_lsb_minus4 = " << value.log2_max_pic_order_cnt_lsb_minus4 << '\n'; + s << "\tsps_max_dec_pic_buffering_minus1 = " << value.sps_max_dec_pic_buffering_minus1 << '\n'; + s << "\tlog2_min_luma_coding_block_size_minus3 = " << value.log2_min_luma_coding_block_size_minus3 << '\n'; + s << "\tlog2_diff_max_min_luma_coding_block_size = " << value.log2_diff_max_min_luma_coding_block_size << '\n'; + s << "\tlog2_min_luma_transform_block_size_minus2 = " << value.log2_min_luma_transform_block_size_minus2 << '\n'; + s << "\tlog2_diff_max_min_luma_transform_block_size = " << value.log2_diff_max_min_luma_transform_block_size << '\n'; + s << "\tmax_transform_hierarchy_depth_inter = " << value.max_transform_hierarchy_depth_inter << '\n'; + s << "\tmax_transform_hierarchy_depth_intra = " << value.max_transform_hierarchy_depth_intra << '\n'; + s << "\tnum_short_term_ref_pic_sets = " << value.num_short_term_ref_pic_sets << '\n'; + s << "\tnum_long_term_ref_pics_sps = " << value.num_long_term_ref_pics_sps << '\n'; + s << "\tpcm_sample_bit_depth_luma_minus1 = " << value.pcm_sample_bit_depth_luma_minus1 << '\n'; + s << "\tpcm_sample_bit_depth_chroma_minus1 = " << value.pcm_sample_bit_depth_chroma_minus1 << '\n'; + s << "\tlog2_min_pcm_luma_coding_block_size_minus3 = " << value.log2_min_pcm_luma_coding_block_size_minus3 << '\n'; + s << "\tlog2_diff_max_min_pcm_luma_coding_block_size = " << value.log2_diff_max_min_pcm_luma_coding_block_size << '\n'; + s << "\tconf_win_left_offset = " << value.conf_win_left_offset << '\n'; + s << "\tconf_win_right_offset = " << value.conf_win_right_offset << '\n'; + s << "\tconf_win_top_offset = " << value.conf_win_top_offset << '\n'; + s << "\tconf_win_bottom_offset = " << value.conf_win_bottom_offset << '\n'; + s << "\tpDecPicBufMgr = " << value.pDecPicBufMgr << '\n'; + s << "\tflags = " << value.flags << '\n'; + s << "\tpScalingLists = " << value.pScalingLists << '\n'; + s << "\tpSequenceParameterSetVui = " << value.pSequenceParameterSetVui << '\n'; + s << "\tpalette_max_size = " << value.palette_max_size << '\n'; + s << "\tdelta_palette_max_predictor_size = " << value.delta_palette_max_predictor_size << '\n'; + s << "\tmotion_vector_resolution_control_idc = " << value.motion_vector_resolution_control_idc << '\n'; + s << "\tsps_num_palette_predictor_initializer_minus1 = " << value.sps_num_palette_predictor_initializer_minus1 << '\n'; + s << "\tpPredictorPaletteEntries = " << value.pPredictorPaletteEntries << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const StdVideoH265PpsFlags& value) +{ + s << "StdVideoH265PpsFlags = {\n"; + s << "\tdependent_slice_segments_enabled_flag = " << value.dependent_slice_segments_enabled_flag << '\n'; + s << "\toutput_flag_present_flag = " << value.output_flag_present_flag << '\n'; + s << "\tsign_data_hiding_enabled_flag = " << value.sign_data_hiding_enabled_flag << '\n'; + s << "\tcabac_init_present_flag = " << value.cabac_init_present_flag << '\n'; + s << "\tconstrained_intra_pred_flag = " << value.constrained_intra_pred_flag << '\n'; + s << "\ttransform_skip_enabled_flag = " << value.transform_skip_enabled_flag << '\n'; + s << "\tcu_qp_delta_enabled_flag = " << value.cu_qp_delta_enabled_flag << '\n'; + s << "\tpps_slice_chroma_qp_offsets_present_flag = " << value.pps_slice_chroma_qp_offsets_present_flag << '\n'; + s << "\tweighted_pred_flag = " << value.weighted_pred_flag << '\n'; + s << "\tweighted_bipred_flag = " << value.weighted_bipred_flag << '\n'; + s << "\ttransquant_bypass_enabled_flag = " << value.transquant_bypass_enabled_flag << '\n'; + s << "\ttiles_enabled_flag = " << value.tiles_enabled_flag << '\n'; + s << "\tentropy_coding_sync_enabled_flag = " << value.entropy_coding_sync_enabled_flag << '\n'; + s << "\tuniform_spacing_flag = " << value.uniform_spacing_flag << '\n'; + s << "\tloop_filter_across_tiles_enabled_flag = " << value.loop_filter_across_tiles_enabled_flag << '\n'; + s << "\tpps_loop_filter_across_slices_enabled_flag = " << value.pps_loop_filter_across_slices_enabled_flag << '\n'; + s << "\tdeblocking_filter_control_present_flag = " << value.deblocking_filter_control_present_flag << '\n'; + s << "\tdeblocking_filter_override_enabled_flag = " << value.deblocking_filter_override_enabled_flag << '\n'; + s << "\tpps_deblocking_filter_disabled_flag = " << value.pps_deblocking_filter_disabled_flag << '\n'; + s << "\tpps_scaling_list_data_present_flag = " << value.pps_scaling_list_data_present_flag << '\n'; + s << "\tlists_modification_present_flag = " << value.lists_modification_present_flag << '\n'; + s << "\tslice_segment_header_extension_present_flag = " << value.slice_segment_header_extension_present_flag << '\n'; + s << "\tpps_extension_present_flag = " << value.pps_extension_present_flag << '\n'; + s << "\tcross_component_prediction_enabled_flag = " << value.cross_component_prediction_enabled_flag << '\n'; + s << "\tchroma_qp_offset_list_enabled_flag = " << value.chroma_qp_offset_list_enabled_flag << '\n'; + s << "\tpps_curr_pic_ref_enabled_flag = " << value.pps_curr_pic_ref_enabled_flag << '\n'; + s << "\tresidual_adaptive_colour_transform_enabled_flag = " << value.residual_adaptive_colour_transform_enabled_flag << '\n'; + s << "\tpps_slice_act_qp_offsets_present_flag = " << value.pps_slice_act_qp_offsets_present_flag << '\n'; + s << "\tpps_palette_predictor_initializer_present_flag = " << value.pps_palette_predictor_initializer_present_flag << '\n'; + s << "\tmonochrome_palette_flag = " << value.monochrome_palette_flag << '\n'; + s << "\tpps_range_extension_flag = " << value.pps_range_extension_flag << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const StdVideoH265PictureParameterSet& value) +{ + s << "StdVideoH265PictureParameterSet = {\n"; + s << "\tpps_pic_parameter_set_id = " << value.pps_pic_parameter_set_id << '\n'; + s << "\tpps_seq_parameter_set_id = " << value.pps_seq_parameter_set_id << '\n'; + s << "\tnum_extra_slice_header_bits = " << value.num_extra_slice_header_bits << '\n'; + s << "\tnum_ref_idx_l0_default_active_minus1 = " << value.num_ref_idx_l0_default_active_minus1 << '\n'; + s << "\tnum_ref_idx_l1_default_active_minus1 = " << value.num_ref_idx_l1_default_active_minus1 << '\n'; + s << "\tinit_qp_minus26 = " << value.init_qp_minus26 << '\n'; + s << "\tdiff_cu_qp_delta_depth = " << value.diff_cu_qp_delta_depth << '\n'; + s << "\tpps_cb_qp_offset = " << value.pps_cb_qp_offset << '\n'; + s << "\tpps_cr_qp_offset = " << value.pps_cr_qp_offset << '\n'; + s << "\tnum_tile_columns_minus1 = " << value.num_tile_columns_minus1 << '\n'; + s << "\tnum_tile_rows_minus1 = " << value.num_tile_rows_minus1 << '\n'; + s << "\tcolumn_width_minus1 = " << '\n' << tcu::formatArray(DE_ARRAY_BEGIN(value.column_width_minus1), DE_ARRAY_END(value.column_width_minus1)) << '\n'; + s << "\trow_height_minus1 = " << '\n' << tcu::formatArray(DE_ARRAY_BEGIN(value.row_height_minus1), DE_ARRAY_END(value.row_height_minus1)) << '\n'; + s << "\tpps_beta_offset_div2 = " << value.pps_beta_offset_div2 << '\n'; + s << "\tpps_tc_offset_div2 = " << value.pps_tc_offset_div2 << '\n'; + s << "\tlog2_parallel_merge_level_minus2 = " << value.log2_parallel_merge_level_minus2 << '\n'; + s << "\tflags = " << value.flags << '\n'; + s << "\tpScalingLists = " << value.pScalingLists << '\n'; + s << "\tlog2_max_transform_skip_block_size_minus2 = " << value.log2_max_transform_skip_block_size_minus2 << '\n'; + s << "\tdiff_cu_chroma_qp_offset_depth = " << value.diff_cu_chroma_qp_offset_depth << '\n'; + s << "\tchroma_qp_offset_list_len_minus1 = " << value.chroma_qp_offset_list_len_minus1 << '\n'; + s << "\tcb_qp_offset_list = " << '\n' << tcu::formatArray(DE_ARRAY_BEGIN(value.cb_qp_offset_list), DE_ARRAY_END(value.cb_qp_offset_list)) << '\n'; + s << "\tcr_qp_offset_list = " << '\n' << tcu::formatArray(DE_ARRAY_BEGIN(value.cr_qp_offset_list), DE_ARRAY_END(value.cr_qp_offset_list)) << '\n'; + s << "\tlog2_sao_offset_scale_luma = " << value.log2_sao_offset_scale_luma << '\n'; + s << "\tlog2_sao_offset_scale_chroma = " << value.log2_sao_offset_scale_chroma << '\n'; + s << "\tpps_act_y_qp_offset_plus5 = " << value.pps_act_y_qp_offset_plus5 << '\n'; + s << "\tpps_act_cb_qp_offset_plus5 = " << value.pps_act_cb_qp_offset_plus5 << '\n'; + s << "\tpps_act_cr_qp_offset_plus5 = " << value.pps_act_cr_qp_offset_plus5 << '\n'; + s << "\tpps_num_palette_predictor_initializer = " << value.pps_num_palette_predictor_initializer << '\n'; + s << "\tluma_bit_depth_entry_minus8 = " << value.luma_bit_depth_entry_minus8 << '\n'; + s << "\tchroma_bit_depth_entry_minus8 = " << value.chroma_bit_depth_entry_minus8 << '\n'; + s << "\tpPredictorPaletteEntries = " << value.pPredictorPaletteEntries << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const StdVideoDecodeH265PictureInfoFlags& value) +{ + s << "StdVideoDecodeH265PictureInfoFlags = {\n"; + s << "\tIrapPicFlag = " << value.IrapPicFlag << '\n'; + s << "\tIdrPicFlag = " << value.IdrPicFlag << '\n'; + s << "\tIsReference = " << value.IsReference << '\n'; + s << "\tshort_term_ref_pic_set_sps_flag = " << value.short_term_ref_pic_set_sps_flag << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const StdVideoDecodeH265PictureInfo& value) +{ + s << "StdVideoDecodeH265PictureInfo = {\n"; + s << "\tvps_video_parameter_set_id = " << value.vps_video_parameter_set_id << '\n'; + s << "\tsps_seq_parameter_set_id = " << value.sps_seq_parameter_set_id << '\n'; + s << "\tpps_pic_parameter_set_id = " << value.pps_pic_parameter_set_id << '\n'; + s << "\tnum_short_term_ref_pic_sets = " << value.num_short_term_ref_pic_sets << '\n'; + s << "\tPicOrderCntVal = " << value.PicOrderCntVal << '\n'; + s << "\tNumBitsForSTRefPicSetInSlice = " << value.NumBitsForSTRefPicSetInSlice << '\n'; + s << "\tNumDeltaPocsOfRefRpsIdx = " << value.NumDeltaPocsOfRefRpsIdx << '\n'; + s << "\tRefPicSetStCurrBefore = " << '\n' << tcu::formatArray(tcu::Format::HexIterator(DE_ARRAY_BEGIN(value.RefPicSetStCurrBefore)), tcu::Format::HexIterator(DE_ARRAY_END(value.RefPicSetStCurrBefore))) << '\n'; + s << "\tRefPicSetStCurrAfter = " << '\n' << tcu::formatArray(tcu::Format::HexIterator(DE_ARRAY_BEGIN(value.RefPicSetStCurrAfter)), tcu::Format::HexIterator(DE_ARRAY_END(value.RefPicSetStCurrAfter))) << '\n'; + s << "\tRefPicSetLtCurr = " << '\n' << tcu::formatArray(tcu::Format::HexIterator(DE_ARRAY_BEGIN(value.RefPicSetLtCurr)), tcu::Format::HexIterator(DE_ARRAY_END(value.RefPicSetLtCurr))) << '\n'; + s << "\tflags = " << value.flags << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const StdVideoDecodeH265ReferenceInfoFlags& value) +{ + s << "StdVideoDecodeH265ReferenceInfoFlags = {\n"; + s << "\tis_long_term = " << value.is_long_term << '\n'; + s << "\tis_non_existing = " << value.is_non_existing << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const StdVideoDecodeH265ReferenceInfo& value) +{ + s << "StdVideoDecodeH265ReferenceInfo = {\n"; + s << "\tPicOrderCntVal = " << value.PicOrderCntVal << '\n'; + s << "\tflags = " << value.flags << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const VkVideoDecodeH265ProfileEXT& value) +{ + s << "VkVideoDecodeH265ProfileEXT = {\n"; + s << "\tsType = " << value.sType << '\n'; + s << "\tpNext = " << value.pNext << '\n'; + s << "\tstdProfileIdc = " << value.stdProfileIdc << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const VkVideoDecodeH265CapabilitiesEXT& value) +{ + s << "VkVideoDecodeH265CapabilitiesEXT = {\n"; + s << "\tsType = " << value.sType << '\n'; + s << "\tpNext = " << value.pNext << '\n'; + s << "\tmaxLevel = " << value.maxLevel << '\n'; + s << "\tstdExtensionVersion = " << value.stdExtensionVersion << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const VkVideoDecodeH265SessionCreateInfoEXT& value) +{ + s << "VkVideoDecodeH265SessionCreateInfoEXT = {\n"; + s << "\tsType = " << value.sType << '\n'; + s << "\tpNext = " << value.pNext << '\n'; + s << "\tflags = " << getVideoDecodeH265CreateFlagsEXTStr(value.flags) << '\n'; + s << "\tpStdExtensionVersion = " << value.pStdExtensionVersion << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const VkVideoDecodeH265SessionParametersAddInfoEXT& value) +{ + s << "VkVideoDecodeH265SessionParametersAddInfoEXT = {\n"; + s << "\tsType = " << value.sType << '\n'; + s << "\tpNext = " << value.pNext << '\n'; + s << "\tspsStdCount = " << value.spsStdCount << '\n'; + s << "\tpSpsStd = " << value.pSpsStd << '\n'; + s << "\tppsStdCount = " << value.ppsStdCount << '\n'; + s << "\tpPpsStd = " << value.pPpsStd << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const VkVideoDecodeH265SessionParametersCreateInfoEXT& value) +{ + s << "VkVideoDecodeH265SessionParametersCreateInfoEXT = {\n"; + s << "\tsType = " << value.sType << '\n'; + s << "\tpNext = " << value.pNext << '\n'; + s << "\tmaxSpsStdCount = " << value.maxSpsStdCount << '\n'; + s << "\tmaxPpsStdCount = " << value.maxPpsStdCount << '\n'; + s << "\tpParametersAddInfo = " << value.pParametersAddInfo << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const VkVideoDecodeH265PictureInfoEXT& value) +{ + s << "VkVideoDecodeH265PictureInfoEXT = {\n"; + s << "\tsType = " << value.sType << '\n'; + s << "\tpNext = " << value.pNext << '\n'; + s << "\tpStdPictureInfo = " << value.pStdPictureInfo << '\n'; + s << "\tslicesCount = " << value.slicesCount << '\n'; + s << "\tpSlicesDataOffsets = " << value.pSlicesDataOffsets << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const VkVideoDecodeH265DpbSlotInfoEXT& value) +{ + s << "VkVideoDecodeH265DpbSlotInfoEXT = {\n"; + s << "\tsType = " << value.sType << '\n'; + s << "\tpNext = " << value.pNext << '\n'; + s << "\tpStdReferenceInfo = " << value.pStdReferenceInfo << '\n'; + s << '}'; + return s; +} + std::ostream& operator<< (std::ostream& s, const VkImagePipeSurfaceCreateInfoFUCHSIA& value) { s << "VkImagePipeSurfaceCreateInfoFUCHSIA = {\n"; diff --git a/external/vulkancts/framework/vulkan/vkStructTypes.inl b/external/vulkancts/framework/vulkan/vkStructTypes.inl index 282f546..521c7a7 100644 --- a/external/vulkancts/framework/vulkan/vkStructTypes.inl +++ b/external/vulkancts/framework/vulkan/vkStructTypes.inl @@ -5391,6 +5391,167 @@ struct VkExternalFormatANDROID deUint64 externalFormat; }; +struct VkVideoQueueFamilyProperties2KHR +{ + VkStructureType sType; + void* pNext; + VkVideoCodecOperationFlagsKHR videoCodecOperations; +}; + +struct VkVideoProfileKHR +{ + VkStructureType sType; + void* pNext; + VkVideoCodecOperationFlagBitsKHR videoCodecOperation; + VkVideoChromaSubsamplingFlagsKHR chromaSubsampling; + VkVideoComponentBitDepthFlagsKHR lumaBitDepth; + VkVideoComponentBitDepthFlagsKHR chromaBitDepth; +}; + +struct VkVideoProfilesKHR +{ + VkStructureType sType; + void* pNext; + deUint32 profileCount; + const VkVideoProfileKHR* pProfiles; +}; + +struct VkVideoCapabilitiesKHR +{ + VkStructureType sType; + void* pNext; + VkVideoCapabilitiesFlagsKHR capabilityFlags; + VkDeviceSize minBitstreamBufferOffsetAlignment; + VkDeviceSize minBitstreamBufferSizeAlignment; + VkExtent2D videoPictureExtentGranularity; + VkExtent2D minExtent; + VkExtent2D maxExtent; + deUint32 maxReferencePicturesSlotsCount; + deUint32 maxReferencePicturesActiveCount; +}; + +struct VkPhysicalDeviceVideoFormatInfoKHR +{ + VkStructureType sType; + const void* pNext; + VkImageUsageFlags imageUsage; + const VkVideoProfilesKHR* pVideoProfiles; +}; + +struct VkVideoFormatPropertiesKHR +{ + VkStructureType sType; + void* pNext; + VkFormat format; +}; + +struct VkVideoPictureResourceKHR +{ + VkStructureType sType; + const void* pNext; + VkOffset2D codedOffset; + VkExtent2D codedExtent; + deUint32 baseArrayLayer; + VkImageView imageViewBinding; +}; + +struct VkVideoReferenceSlotKHR +{ + VkStructureType sType; + const void* pNext; + deInt8 slotIndex; + const VkVideoPictureResourceKHR* pPictureResource; +}; + +struct VkVideoGetMemoryPropertiesKHR +{ + VkStructureType sType; + const void* pNext; + deUint32 memoryBindIndex; + VkMemoryRequirements2* pMemoryRequirements; +}; + +struct VkVideoBindMemoryKHR +{ + VkStructureType sType; + const void* pNext; + deUint32 memoryBindIndex; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; + VkDeviceSize memorySize; +}; + +struct VkVideoSessionCreateInfoKHR +{ + VkStructureType sType; + const void* pNext; + deUint32 queueFamilyIndex; + VkVideoSessionCreateFlagsKHR flags; + const VkVideoProfileKHR* pVideoProfile; + VkFormat pictureFormat; + VkExtent2D maxCodedExtent; + VkFormat referencePicturesFormat; + deUint32 maxReferencePicturesSlotsCount; + deUint32 maxReferencePicturesActiveCount; +}; + +struct VkVideoSessionParametersCreateInfoKHR +{ + VkStructureType sType; + const void* pNext; + VkVideoSessionParametersKHR videoSessionParametersTemplate; + VkVideoSessionKHR videoSession; +}; + +struct VkVideoSessionParametersUpdateInfoKHR +{ + VkStructureType sType; + const void* pNext; + deUint32 updateSequenceCount; +}; + +struct VkVideoBeginCodingInfoKHR +{ + VkStructureType sType; + const void* pNext; + VkVideoBeginCodingFlagsKHR flags; + VkVideoCodingQualityPresetFlagsKHR codecQualityPreset; + VkVideoSessionKHR videoSession; + VkVideoSessionParametersKHR videoSessionParameters; + deUint32 referenceSlotCount; + const VkVideoReferenceSlotKHR* pReferenceSlots; +}; + +struct VkVideoEndCodingInfoKHR +{ + VkStructureType sType; + const void* pNext; + VkVideoEndCodingFlagsKHR flags; +}; + +struct VkVideoCodingControlInfoKHR +{ + VkStructureType sType; + const void* pNext; + VkVideoCodingControlFlagsKHR flags; +}; + +struct VkVideoDecodeInfoKHR +{ + VkStructureType sType; + const void* pNext; + VkVideoDecodeFlagsKHR flags; + VkOffset2D codedOffset; + VkExtent2D codedExtent; + VkBuffer srcBuffer; + VkDeviceSize srcBufferOffset; + VkDeviceSize srcBufferRange; + VkVideoPictureResourceKHR dstPictureResource; + const VkVideoReferenceSlotKHR* pSetupReferenceSlot; + deUint32 referenceSlotCount; + const VkVideoReferenceSlotKHR* pReferenceSlots; +}; + struct VkPhysicalDevicePortabilitySubsetFeaturesKHR { VkStructureType sType; @@ -5419,6 +5580,840 @@ struct VkPhysicalDevicePortabilitySubsetPropertiesKHR deUint32 minVertexInputBindingStrideAlignment; }; +struct VkVideoEncodeInfoKHR +{ + VkStructureType sType; + const void* pNext; + VkVideoEncodeFlagsKHR flags; + deUint32 qualityLevel; + VkExtent2D codedExtent; + VkBuffer dstBitstreamBuffer; + VkDeviceSize dstBitstreamBufferOffset; + VkDeviceSize dstBitstreamBufferMaxRange; + VkVideoPictureResourceKHR srcPictureResource; + const VkVideoReferenceSlotKHR* pSetupReferenceSlot; + deUint32 referenceSlotCount; + const VkVideoReferenceSlotKHR* pReferenceSlots; +}; + +struct VkVideoEncodeRateControlInfoKHR +{ + VkStructureType sType; + const void* pNext; + VkVideoEncodeRateControlFlagsKHR flags; + VkVideoEncodeRateControlModeFlagBitsKHR rateControlMode; + deUint32 averageBitrate; + deUint16 peakToAverageBitrateRatio; + deUint16 frameRateNumerator; + deUint16 frameRateDenominator; + deUint32 virtualBufferSizeInMs; +}; + +struct StdVideoH264SpsVuiFlags +{ + deUint32 aspect_ratio_info_present_flag:1; + deUint32 overscan_info_present_flag:1; + deUint32 overscan_appropriate_flag:1; + deUint32 video_signal_type_present_flag:1; + deUint32 video_full_range_flag:1; + deUint32 color_description_present_flag:1; + deUint32 chroma_loc_info_present_flag:1; + deUint32 timing_info_present_flag:1; + deUint32 fixed_frame_rate_flag:1; + deUint32 bitstream_restriction_flag:1; + deUint32 nal_hrd_parameters_present_flag:1; + deUint32 vcl_hrd_parameters_present_flag:1; +}; + +struct StdVideoH264HrdParameters +{ + deUint8 cpb_cnt_minus1; + deUint8 bit_rate_scale; + deUint8 cpb_size_scale; + deUint32 bit_rate_value_minus1[32]; + deUint32 cpb_size_value_minus1[32]; + deUint8 cbr_flag[32]; + deUint32 initial_cpb_removal_delay_length_minus1; + deUint32 cpb_removal_delay_length_minus1; + deUint32 dpb_output_delay_length_minus1; + deUint32 time_offset_length; +}; + +struct StdVideoH264SequenceParameterSetVui +{ + StdVideoH264AspectRatioIdc aspect_ratio_idc; + deUint16 sar_width; + deUint16 sar_height; + deUint8 video_format; + deUint8 color_primaries; + deUint8 transfer_characteristics; + deUint8 matrix_coefficients; + deUint32 num_units_in_tick; + deUint32 time_scale; + StdVideoH264HrdParameters hrd_parameters; + deUint8 num_reorder_frames; + deUint8 max_dec_frame_buffering; + StdVideoH264SpsVuiFlags flags; +}; + +struct StdVideoH264SpsFlags +{ + deUint32 constraint_set0_flag:1; + deUint32 constraint_set1_flag:1; + deUint32 constraint_set2_flag:1; + deUint32 constraint_set3_flag:1; + deUint32 constraint_set4_flag:1; + deUint32 constraint_set5_flag:1; + deUint32 direct_8x8_inference_flag:1; + deUint32 mb_adaptive_frame_field_flag:1; + deUint32 frame_mbs_only_flag:1; + deUint32 delta_pic_order_always_zero_flag:1; + deUint32 residual_colour_transform_flag:1; + deUint32 gaps_in_frame_num_value_allowed_flag:1; + deUint32 first_picture_after_seek_flag:1; + deUint32 qpprime_y_zero_transform_bypass_flag:1; + deUint32 frame_cropping_flag:1; + deUint32 scaling_matrix_present_flag:1; + deUint32 vui_parameters_present_flag:1; +}; + +struct StdVideoH264ScalingLists +{ + deUint8 scaling_list_present_mask; + deUint8 use_default_scaling_matrix_mask; + deUint8 ScalingList4x4[6][16]; + deUint8 ScalingList8x8[2][64]; +}; + +struct StdVideoH264SequenceParameterSet +{ + StdVideoH264ProfileIdc profile_idc; + StdVideoH264Level level_idc; + deUint8 seq_parameter_set_id; + StdVideoH264ChromaFormatIdc chroma_format_idc; + deUint8 bit_depth_luma_minus8; + deUint8 bit_depth_chroma_minus8; + deUint8 log2_max_frame_num_minus4; + StdVideoH264PocType pic_order_cnt_type; + deUint8 log2_max_pic_order_cnt_lsb_minus4; + deInt32 offset_for_non_ref_pic; + deInt32 offset_for_top_to_bottom_field; + deUint8 num_ref_frames_in_pic_order_cnt_cycle; + deUint8 max_num_ref_frames; + deUint32 pic_width_in_mbs_minus1; + deUint32 pic_height_in_map_units_minus1; + deUint32 frame_crop_left_offset; + deUint32 frame_crop_right_offset; + deUint32 frame_crop_top_offset; + deUint32 frame_crop_bottom_offset; + StdVideoH264SpsFlags flags; + deInt32 offset_for_ref_frame[255]; + StdVideoH264ScalingLists* pScalingLists; + StdVideoH264SequenceParameterSetVui* pSequenceParameterSetVui; +}; + +struct StdVideoH264PpsFlags +{ + deUint32 transform_8x8_mode_flag:1; + deUint32 redundant_pic_cnt_present_flag:1; + deUint32 constrained_intra_pred_flag:1; + deUint32 deblocking_filter_control_present_flag:1; + deUint32 weighted_bipred_idc_flag:1; + deUint32 weighted_pred_flag:1; + deUint32 pic_order_present_flag:1; + deUint32 entropy_coding_mode_flag:1; + deUint32 scaling_matrix_present_flag:1; +}; + +struct StdVideoH264PictureParameterSet +{ + deUint8 seq_parameter_set_id; + deUint8 pic_parameter_set_id; + deUint8 num_ref_idx_l0_default_active_minus1; + deUint8 num_ref_idx_l1_default_active_minus1; + StdVideoH264WeightedBiPredIdc weighted_bipred_idc; + deInt8 pic_init_qp_minus26; + deInt8 pic_init_qs_minus26; + deInt8 chroma_qp_index_offset; + deInt8 second_chroma_qp_index_offset; + StdVideoH264PpsFlags flags; + StdVideoH264ScalingLists* pScalingLists; +}; + +struct StdVideoEncodeH264SliceHeaderFlags +{ + deUint32 idr_flag:1; + deUint32 is_reference_flag:1; + deUint32 num_ref_idx_active_override_flag:1; + deUint32 no_output_of_prior_pics_flag:1; + deUint32 long_term_reference_flag:1; + deUint32 adaptive_ref_pic_marking_mode_flag:1; + deUint32 no_prior_references_available_flag:1; +}; + +struct StdVideoEncodeH264PictureInfoFlags +{ + deUint32 idr_flag:1; + deUint32 is_reference_flag:1; + deUint32 long_term_reference_flag:1; +}; + +struct StdVideoEncodeH264RefMgmtFlags +{ + deUint32 ref_pic_list_modification_l0_flag:1; + deUint32 ref_pic_list_modification_l1_flag:1; +}; + +struct StdVideoEncodeH264RefListModEntry +{ + StdVideoH264ModificationOfPicNumsIdc modification_of_pic_nums_idc; + deUint16 abs_diff_pic_num_minus1; + deUint16 long_term_pic_num; +}; + +struct StdVideoEncodeH264RefPicMarkingEntry +{ + StdVideoH264MemMgmtControlOp operation; + deUint16 difference_of_pic_nums_minus1; + deUint16 long_term_pic_num; + deUint16 long_term_frame_idx; + deUint16 max_long_term_frame_idx_plus1; +}; + +struct StdVideoEncodeH264RefMemMgmtCtrlOperations +{ + StdVideoEncodeH264RefMgmtFlags flags; + deUint8 refList0ModOpCount; + StdVideoEncodeH264RefListModEntry* pRefList0ModOperations; + deUint8 refList1ModOpCount; + StdVideoEncodeH264RefListModEntry* pRefList1ModOperations; + deUint8 refPicMarkingOpCount; + StdVideoEncodeH264RefPicMarkingEntry* pRefPicMarkingOperations; +}; + +struct StdVideoEncodeH264PictureInfo +{ + StdVideoEncodeH264PictureInfoFlags flags; + StdVideoH264PictureType pictureType; + deUint32 frameNum; + deUint32 pictureOrderCount; + deUint16 long_term_pic_num; + deUint16 long_term_frame_idx; +}; + +struct StdVideoEncodeH264SliceHeader +{ + StdVideoEncodeH264SliceHeaderFlags flags; + StdVideoH264SliceType slice_type; + deUint8 seq_parameter_set_id; + deUint8 pic_parameter_set_id; + deUint16 idr_pic_id; + deUint8 num_ref_idx_l0_active_minus1; + deUint8 num_ref_idx_l1_active_minus1; + StdVideoH264CabacInitIdc cabac_init_idc; + StdVideoH264DisableDeblockingFilterIdc disable_deblocking_filter_idc; + deInt8 slice_alpha_c0_offset_div2; + deInt8 slice_beta_offset_div2; + StdVideoEncodeH264RefMemMgmtCtrlOperations* pMemMgmtCtrlOperations; +}; + +struct VkVideoEncodeH264CapabilitiesEXT +{ + VkStructureType sType; + const void* pNext; + VkVideoEncodeH264CapabilitiesFlagsEXT flags; + VkVideoEncodeH264InputModeFlagsEXT inputModeFlags; + VkVideoEncodeH264OutputModeFlagsEXT outputModeFlags; + VkExtent2D minPictureSizeInMbs; + VkExtent2D maxPictureSizeInMbs; + VkExtent2D inputImageDataAlignment; + deUint8 maxNumL0ReferenceForP; + deUint8 maxNumL0ReferenceForB; + deUint8 maxNumL1Reference; + deUint8 qualityLevelCount; + VkExtensionProperties stdExtensionVersion; +}; + +struct VkVideoEncodeH264SessionCreateInfoEXT +{ + VkStructureType sType; + const void* pNext; + VkVideoEncodeH264CreateFlagsEXT flags; + VkExtent2D maxPictureSizeInMbs; + const VkExtensionProperties* pStdExtensionVersion; +}; + +struct VkVideoEncodeH264SessionParametersAddInfoEXT +{ + VkStructureType sType; + const void* pNext; + deUint32 spsStdCount; + const StdVideoH264SequenceParameterSet* pSpsStd; + deUint32 ppsStdCount; + const StdVideoH264PictureParameterSet* pPpsStd; +}; + +struct VkVideoEncodeH264SessionParametersCreateInfoEXT +{ + VkStructureType sType; + const void* pNext; + deUint32 maxSpsStdCount; + deUint32 maxPpsStdCount; + const VkVideoEncodeH264SessionParametersAddInfoEXT* pParametersAddInfo; +}; + +struct VkVideoEncodeH264DpbSlotInfoEXT +{ + VkStructureType sType; + const void* pNext; + deInt8 slotIndex; + const StdVideoEncodeH264PictureInfo* pStdPictureInfo; +}; + +struct VkVideoEncodeH264NaluSliceEXT +{ + VkStructureType sType; + const void* pNext; + const StdVideoEncodeH264SliceHeader* pSliceHeaderStd; + deUint32 mbCount; + deUint8 refFinalList0EntryCount; + const VkVideoEncodeH264DpbSlotInfoEXT* pRefFinalList0Entries; + deUint8 refFinalList1EntryCount; + const VkVideoEncodeH264DpbSlotInfoEXT* pRefFinalList1Entries; + deUint32 precedingNaluBytes; + deUint8 minQp; + deUint8 maxQp; +}; + +struct VkVideoEncodeH264VclFrameInfoEXT +{ + VkStructureType sType; + const void* pNext; + deUint8 refDefaultFinalList0EntryCount; + const VkVideoEncodeH264DpbSlotInfoEXT* pRefDefaultFinalList0Entries; + deUint8 refDefaultFinalList1EntryCount; + const VkVideoEncodeH264DpbSlotInfoEXT* pRefDefaultFinalList1Entries; + deUint32 naluSliceEntryCount; + const VkVideoEncodeH264NaluSliceEXT* pNaluSliceEntries; + const VkVideoEncodeH264DpbSlotInfoEXT* pCurrentPictureInfo; +}; + +struct VkVideoEncodeH264EmitPictureParametersEXT +{ + VkStructureType sType; + const void* pNext; + deUint8 spsId; + VkBool32 emitSpsEnable; + deUint32 ppsIdEntryCount; + const deUint8* ppsIdEntries; +}; + +struct VkVideoEncodeH264ProfileEXT +{ + VkStructureType sType; + const void* pNext; + StdVideoH264ProfileIdc stdProfileIdc; +}; + +struct StdVideoDecodeH264PictureInfoFlags +{ + deUint32 field_pic_flag:1; + deUint32 is_intra:1; + deUint32 bottom_field_flag:1; + deUint32 is_reference:1; + deUint32 complementary_field_pair:1; +}; + +struct StdVideoDecodeH264PictureInfo +{ + deUint8 seq_parameter_set_id; + deUint8 pic_parameter_set_id; + deUint16 reserved; + deUint16 frame_num; + deUint16 idr_pic_id; + deInt32 PicOrderCnt[2]; + StdVideoDecodeH264PictureInfoFlags flags; +}; + +struct StdVideoDecodeH264ReferenceInfoFlags +{ + deUint32 top_field_flag:1; + deUint32 bottom_field_flag:1; + deUint32 is_long_term:1; + deUint32 is_non_existing:1; +}; + +struct StdVideoDecodeH264ReferenceInfo +{ + deUint16 FrameNum; + deUint16 reserved; + deInt32 PicOrderCnt[2]; + StdVideoDecodeH264ReferenceInfoFlags flags; +}; + +struct StdVideoDecodeH264MvcElementFlags +{ + deUint32 non_idr:1; + deUint32 anchor_pic:1; + deUint32 inter_view:1; +}; + +struct StdVideoDecodeH264MvcElement +{ + StdVideoDecodeH264MvcElementFlags flags; + deUint16 viewOrderIndex; + deUint16 viewId; + deUint16 temporalId; + deUint16 priorityId; + deUint16 numOfAnchorRefsInL0; + deUint16 viewIdOfAnchorRefsInL0[15]; + deUint16 numOfAnchorRefsInL1; + deUint16 viewIdOfAnchorRefsInL1[15]; + deUint16 numOfNonAnchorRefsInL0; + deUint16 viewIdOfNonAnchorRefsInL0[15]; + deUint16 numOfNonAnchorRefsInL1; + deUint16 viewIdOfNonAnchorRefsInL1[15]; +}; + +struct StdVideoDecodeH264Mvc +{ + deUint32 viewId0; + deUint32 mvcElementCount; + StdVideoDecodeH264MvcElement* pMvcElements; +}; + +struct VkVideoDecodeH264ProfileEXT +{ + VkStructureType sType; + const void* pNext; + StdVideoH264ProfileIdc stdProfileIdc; + VkVideoDecodeH264FieldLayoutFlagsEXT fieldLayout; +}; + +struct VkVideoDecodeH264CapabilitiesEXT +{ + VkStructureType sType; + void* pNext; + deUint32 maxLevel; + VkOffset2D fieldOffsetGranularity; + VkExtensionProperties stdExtensionVersion; +}; + +struct VkVideoDecodeH264SessionCreateInfoEXT +{ + VkStructureType sType; + const void* pNext; + VkVideoDecodeH264CreateFlagsEXT flags; + const VkExtensionProperties* pStdExtensionVersion; +}; + +struct VkVideoDecodeH264SessionParametersAddInfoEXT +{ + VkStructureType sType; + const void* pNext; + deUint32 spsStdCount; + const StdVideoH264SequenceParameterSet* pSpsStd; + deUint32 ppsStdCount; + const StdVideoH264PictureParameterSet* pPpsStd; +}; + +struct VkVideoDecodeH264SessionParametersCreateInfoEXT +{ + VkStructureType sType; + const void* pNext; + deUint32 maxSpsStdCount; + deUint32 maxPpsStdCount; + const VkVideoDecodeH264SessionParametersAddInfoEXT* pParametersAddInfo; +}; + +struct VkVideoDecodeH264PictureInfoEXT +{ + VkStructureType sType; + const void* pNext; + const StdVideoDecodeH264PictureInfo* pStdPictureInfo; + deUint32 slicesCount; + const deUint32* pSlicesDataOffsets; +}; + +struct VkVideoDecodeH264MvcEXT +{ + VkStructureType sType; + const void* pNext; + const StdVideoDecodeH264Mvc* pStdMvc; +}; + +struct VkVideoDecodeH264DpbSlotInfoEXT +{ + VkStructureType sType; + const void* pNext; + const StdVideoDecodeH264ReferenceInfo* pStdReferenceInfo; +}; + +struct StdVideoH265DecPicBufMgr +{ + deUint32 max_latency_increase_plus1[7]; + deUint8 max_dec_pic_buffering_minus1[7]; + deUint8 max_num_reorder_pics[7]; +}; + +struct StdVideoH265SubLayerHrdParameters +{ + deUint32 bit_rate_value_minus1[32]; + deUint32 cpb_size_value_minus1[32]; + deUint32 cpb_size_du_value_minus1[32]; + deUint32 bit_rate_du_value_minus1[32]; + deUint32 cbr_flag; +}; + +struct StdVideoH265HrdFlags +{ + deUint32 nal_hrd_parameters_present_flag:1; + deUint32 vcl_hrd_parameters_present_flag:1; + deUint32 sub_pic_hrd_params_present_flag:1; + deUint32 sub_pic_cpb_params_in_pic_timing_sei_flag:1; + deUint8 fixed_pic_rate_general_flag; + deUint8 fixed_pic_rate_within_cvs_flag; + deUint8 low_delay_hrd_flag; +}; + +struct StdVideoH265HrdParameters +{ + deUint8 tick_divisor_minus2; + deUint8 du_cpb_removal_delay_increment_length_minus1; + deUint8 dpb_output_delay_du_length_minus1; + deUint8 bit_rate_scale; + deUint8 cpb_size_scale; + deUint8 cpb_size_du_scale; + deUint8 initial_cpb_removal_delay_length_minus1; + deUint8 au_cpb_removal_delay_length_minus1; + deUint8 dpb_output_delay_length_minus1; + deUint8 cpb_cnt_minus1[7]; + deUint16 elemental_duration_in_tc_minus1[7]; + StdVideoH265SubLayerHrdParameters* SubLayerHrdParametersNal[7]; + StdVideoH265SubLayerHrdParameters* SubLayerHrdParametersVcl[7]; + StdVideoH265HrdFlags flags; +}; + +struct StdVideoH265VpsFlags +{ + deUint32 vps_temporal_id_nesting_flag:1; + deUint32 vps_sub_layer_ordering_info_present_flag:1; + deUint32 vps_timing_info_present_flag:1; + deUint32 vps_poc_proportional_to_timing_flag:1; +}; + +struct StdVideoH265VideoParameterSet +{ + deUint8 vps_video_parameter_set_id; + deUint8 vps_max_sub_layers_minus1; + deUint32 vps_num_units_in_tick; + deUint32 vps_time_scale; + deUint32 vps_num_ticks_poc_diff_one_minus1; + StdVideoH265DecPicBufMgr* pDecPicBufMgr; + StdVideoH265HrdParameters* hrd_parameters; + StdVideoH265VpsFlags flags; +}; + +struct StdVideoH265ScalingLists +{ + deUint8 ScalingList4x4[6][16]; + deUint8 ScalingList8x8[6][64]; + deUint8 ScalingList16x16[6][64]; + deUint8 ScalingList32x32[2][64]; + deUint8 ScalingListDCCoef16x16[6]; + deUint8 ScalingListDCCoef32x32[2]; +}; + +struct StdVideoH265SpsVuiFlags +{ + deUint32 aspect_ratio_info_present_flag:1; + deUint32 overscan_info_present_flag:1; + deUint32 overscan_appropriate_flag:1; + deUint32 video_signal_type_present_flag:1; + deUint32 video_full_range_flag:1; + deUint32 colour_description_present_flag:1; + deUint32 chroma_loc_info_present_flag:1; + deUint32 neutral_chroma_indication_flag:1; + deUint32 field_seq_flag:1; + deUint32 frame_field_info_present_flag:1; + deUint32 default_display_window_flag:1; + deUint32 vui_timing_info_present_flag:1; + deUint32 vui_poc_proportional_to_timing_flag:1; + deUint32 vui_hrd_parameters_present_flag:1; + deUint32 bitstream_restriction_flag:1; + deUint32 tiles_fixed_structure_flag:1; + deUint32 motion_vectors_over_pic_boundaries_flag:1; + deUint32 restricted_ref_pic_lists_flag:1; +}; + +struct StdVideoH265SequenceParameterSetVui +{ + deUint8 aspect_ratio_idc; + deUint16 sar_width; + deUint16 sar_height; + deUint8 video_format; + deUint8 colour_primaries; + deUint8 transfer_characteristics; + deUint8 matrix_coeffs; + deUint8 chroma_sample_loc_type_top_field; + deUint8 chroma_sample_loc_type_bottom_field; + deUint16 def_disp_win_left_offset; + deUint16 def_disp_win_right_offset; + deUint16 def_disp_win_top_offset; + deUint16 def_disp_win_bottom_offset; + deUint32 vui_num_units_in_tick; + deUint32 vui_time_scale; + deUint32 vui_num_ticks_poc_diff_one_minus1; + StdVideoH265HrdParameters* hrd_parameters; + deUint16 min_spatial_segmentation_idc; + deUint8 max_bytes_per_pic_denom; + deUint8 max_bits_per_min_cu_denom; + deUint8 log2_max_mv_length_horizontal; + deUint8 log2_max_mv_length_vertical; + StdVideoH265SpsVuiFlags flags; +}; + +struct StdVideoH265PredictorPaletteEntries +{ + deUint16 PredictorPaletteEntries[3][128]; +}; + +struct StdVideoH265SpsFlags +{ + deUint32 sps_temporal_id_nesting_flag:1; + deUint32 separate_colour_plane_flag:1; + deUint32 scaling_list_enabled_flag:1; + deUint32 sps_scaling_list_data_present_flag:1; + deUint32 amp_enabled_flag:1; + deUint32 sample_adaptive_offset_enabled_flag:1; + deUint32 pcm_enabled_flag:1; + deUint32 pcm_loop_filter_disabled_flag:1; + deUint32 long_term_ref_pics_present_flag:1; + deUint32 sps_temporal_mvp_enabled_flag:1; + deUint32 strong_intra_smoothing_enabled_flag:1; + deUint32 vui_parameters_present_flag:1; + deUint32 sps_extension_present_flag:1; + deUint32 sps_range_extension_flag:1; + deUint32 transform_skip_rotation_enabled_flag:1; + deUint32 transform_skip_context_enabled_flag:1; + deUint32 implicit_rdpcm_enabled_flag:1; + deUint32 explicit_rdpcm_enabled_flag:1; + deUint32 extended_precision_processing_flag:1; + deUint32 intra_smoothing_disabled_flag:1; + deUint32 high_precision_offsets_enabled_flag:1; + deUint32 persistent_rice_adaptation_enabled_flag:1; + deUint32 cabac_bypass_alignment_enabled_flag:1; + deUint32 sps_curr_pic_ref_enabled_flag:1; + deUint32 palette_mode_enabled_flag:1; + deUint32 sps_palette_predictor_initializer_present_flag:1; + deUint32 intra_boundary_filtering_disabled_flag:1; +}; + +struct StdVideoH265SequenceParameterSet +{ + StdVideoH265ProfileIdc profile_idc; + StdVideoH265Level level_idc; + deUint32 pic_width_in_luma_samples; + deUint32 pic_height_in_luma_samples; + deUint8 sps_video_parameter_set_id; + deUint8 sps_max_sub_layers_minus1; + deUint8 sps_seq_parameter_set_id; + deUint8 chroma_format_idc; + deUint8 bit_depth_luma_minus8; + deUint8 bit_depth_chroma_minus8; + deUint8 log2_max_pic_order_cnt_lsb_minus4; + deUint8 sps_max_dec_pic_buffering_minus1; + deUint8 log2_min_luma_coding_block_size_minus3; + deUint8 log2_diff_max_min_luma_coding_block_size; + deUint8 log2_min_luma_transform_block_size_minus2; + deUint8 log2_diff_max_min_luma_transform_block_size; + deUint8 max_transform_hierarchy_depth_inter; + deUint8 max_transform_hierarchy_depth_intra; + deUint8 num_short_term_ref_pic_sets; + deUint8 num_long_term_ref_pics_sps; + deUint8 pcm_sample_bit_depth_luma_minus1; + deUint8 pcm_sample_bit_depth_chroma_minus1; + deUint8 log2_min_pcm_luma_coding_block_size_minus3; + deUint8 log2_diff_max_min_pcm_luma_coding_block_size; + deUint32 conf_win_left_offset; + deUint32 conf_win_right_offset; + deUint32 conf_win_top_offset; + deUint32 conf_win_bottom_offset; + StdVideoH265DecPicBufMgr* pDecPicBufMgr; + StdVideoH265SpsFlags flags; + StdVideoH265ScalingLists* pScalingLists; + StdVideoH265SequenceParameterSetVui* pSequenceParameterSetVui; + deUint8 palette_max_size; + deUint8 delta_palette_max_predictor_size; + deUint8 motion_vector_resolution_control_idc; + deUint8 sps_num_palette_predictor_initializer_minus1; + StdVideoH265PredictorPaletteEntries* pPredictorPaletteEntries; +}; + +struct StdVideoH265PpsFlags +{ + deUint32 dependent_slice_segments_enabled_flag:1; + deUint32 output_flag_present_flag:1; + deUint32 sign_data_hiding_enabled_flag:1; + deUint32 cabac_init_present_flag:1; + deUint32 constrained_intra_pred_flag:1; + deUint32 transform_skip_enabled_flag:1; + deUint32 cu_qp_delta_enabled_flag:1; + deUint32 pps_slice_chroma_qp_offsets_present_flag:1; + deUint32 weighted_pred_flag:1; + deUint32 weighted_bipred_flag:1; + deUint32 transquant_bypass_enabled_flag:1; + deUint32 tiles_enabled_flag:1; + deUint32 entropy_coding_sync_enabled_flag:1; + deUint32 uniform_spacing_flag:1; + deUint32 loop_filter_across_tiles_enabled_flag:1; + deUint32 pps_loop_filter_across_slices_enabled_flag:1; + deUint32 deblocking_filter_control_present_flag:1; + deUint32 deblocking_filter_override_enabled_flag:1; + deUint32 pps_deblocking_filter_disabled_flag:1; + deUint32 pps_scaling_list_data_present_flag:1; + deUint32 lists_modification_present_flag:1; + deUint32 slice_segment_header_extension_present_flag:1; + deUint32 pps_extension_present_flag:1; + deUint32 cross_component_prediction_enabled_flag:1; + deUint32 chroma_qp_offset_list_enabled_flag:1; + deUint32 pps_curr_pic_ref_enabled_flag:1; + deUint32 residual_adaptive_colour_transform_enabled_flag:1; + deUint32 pps_slice_act_qp_offsets_present_flag:1; + deUint32 pps_palette_predictor_initializer_present_flag:1; + deUint32 monochrome_palette_flag:1; + deUint32 pps_range_extension_flag:1; +}; + +struct StdVideoH265PictureParameterSet +{ + deUint8 pps_pic_parameter_set_id; + deUint8 pps_seq_parameter_set_id; + deUint8 num_extra_slice_header_bits; + deUint8 num_ref_idx_l0_default_active_minus1; + deUint8 num_ref_idx_l1_default_active_minus1; + deInt8 init_qp_minus26; + deUint8 diff_cu_qp_delta_depth; + deInt8 pps_cb_qp_offset; + deInt8 pps_cr_qp_offset; + deUint8 num_tile_columns_minus1; + deUint8 num_tile_rows_minus1; + deUint16 column_width_minus1[19]; + deUint16 row_height_minus1[21]; + deInt8 pps_beta_offset_div2; + deInt8 pps_tc_offset_div2; + deUint8 log2_parallel_merge_level_minus2; + StdVideoH265PpsFlags flags; + StdVideoH265ScalingLists* pScalingLists; + deUint8 log2_max_transform_skip_block_size_minus2; + deUint8 diff_cu_chroma_qp_offset_depth; + deUint8 chroma_qp_offset_list_len_minus1; + deInt8 cb_qp_offset_list[6]; + deInt8 cr_qp_offset_list[6]; + deUint8 log2_sao_offset_scale_luma; + deUint8 log2_sao_offset_scale_chroma; + deInt8 pps_act_y_qp_offset_plus5; + deInt8 pps_act_cb_qp_offset_plus5; + deInt8 pps_act_cr_qp_offset_plus5; + deUint8 pps_num_palette_predictor_initializer; + deUint8 luma_bit_depth_entry_minus8; + deUint8 chroma_bit_depth_entry_minus8; + StdVideoH265PredictorPaletteEntries* pPredictorPaletteEntries; +}; + +struct StdVideoDecodeH265PictureInfoFlags +{ + deUint32 IrapPicFlag:1; + deUint32 IdrPicFlag:1; + deUint32 IsReference:1; + deUint32 short_term_ref_pic_set_sps_flag:1; +}; + +struct StdVideoDecodeH265PictureInfo +{ + deUint8 vps_video_parameter_set_id; + deUint8 sps_seq_parameter_set_id; + deUint8 pps_pic_parameter_set_id; + deUint8 num_short_term_ref_pic_sets; + deInt32 PicOrderCntVal; + deUint16 NumBitsForSTRefPicSetInSlice; + deUint8 NumDeltaPocsOfRefRpsIdx; + deUint8 RefPicSetStCurrBefore[8]; + deUint8 RefPicSetStCurrAfter[8]; + deUint8 RefPicSetLtCurr[8]; + StdVideoDecodeH265PictureInfoFlags flags; +}; + +struct StdVideoDecodeH265ReferenceInfoFlags +{ + deUint32 is_long_term:1; + deUint32 is_non_existing:1; +}; + +struct StdVideoDecodeH265ReferenceInfo +{ + deInt32 PicOrderCntVal; + StdVideoDecodeH265ReferenceInfoFlags flags; +}; + +struct VkVideoDecodeH265ProfileEXT +{ + VkStructureType sType; + const void* pNext; + StdVideoH265ProfileIdc stdProfileIdc; +}; + +struct VkVideoDecodeH265CapabilitiesEXT +{ + VkStructureType sType; + void* pNext; + deUint32 maxLevel; + VkExtensionProperties stdExtensionVersion; +}; + +struct VkVideoDecodeH265SessionCreateInfoEXT +{ + VkStructureType sType; + const void* pNext; + VkVideoDecodeH265CreateFlagsEXT flags; + const VkExtensionProperties* pStdExtensionVersion; +}; + +struct VkVideoDecodeH265SessionParametersAddInfoEXT +{ + VkStructureType sType; + const void* pNext; + deUint32 spsStdCount; + const StdVideoH265SequenceParameterSet* pSpsStd; + deUint32 ppsStdCount; + const StdVideoH265PictureParameterSet* pPpsStd; +}; + +struct VkVideoDecodeH265SessionParametersCreateInfoEXT +{ + VkStructureType sType; + const void* pNext; + deUint32 maxSpsStdCount; + deUint32 maxPpsStdCount; + const VkVideoDecodeH265SessionParametersAddInfoEXT* pParametersAddInfo; +}; + +struct VkVideoDecodeH265PictureInfoEXT +{ + VkStructureType sType; + const void* pNext; + StdVideoDecodeH265PictureInfo* pStdPictureInfo; + deUint32 slicesCount; + const deUint32* pSlicesDataOffsets; +}; + +struct VkVideoDecodeH265DpbSlotInfoEXT +{ + VkStructureType sType; + const void* pNext; + const StdVideoDecodeH265ReferenceInfo* pStdReferenceInfo; +}; + struct VkImagePipeSurfaceCreateInfoFUCHSIA { VkStructureType sType; diff --git a/external/vulkancts/framework/vulkan/vkTypeUtil.inl b/external/vulkancts/framework/vulkan/vkTypeUtil.inl index dd9c0de..86807f9 100644 --- a/external/vulkancts/framework/vulkan/vkTypeUtil.inl +++ b/external/vulkancts/framework/vulkan/vkTypeUtil.inl @@ -650,3 +650,32 @@ inline VkTraceRaysIndirectCommandKHR makeTraceRaysIndirectCommandKHR (deUint32 w res.depth = depth; return res; } + +inline StdVideoEncodeH264RefListModEntry makeStdVideoEncodeH264RefListModEntry (StdVideoH264ModificationOfPicNumsIdc modification_of_pic_nums_idc, deUint16 abs_diff_pic_num_minus1, deUint16 long_term_pic_num) +{ + StdVideoEncodeH264RefListModEntry res; + res.modification_of_pic_nums_idc = modification_of_pic_nums_idc; + res.abs_diff_pic_num_minus1 = abs_diff_pic_num_minus1; + res.long_term_pic_num = long_term_pic_num; + return res; +} + +inline StdVideoEncodeH264RefPicMarkingEntry makeStdVideoEncodeH264RefPicMarkingEntry (StdVideoH264MemMgmtControlOp operation, deUint16 difference_of_pic_nums_minus1, deUint16 long_term_pic_num, deUint16 long_term_frame_idx, deUint16 max_long_term_frame_idx_plus1) +{ + StdVideoEncodeH264RefPicMarkingEntry res; + res.operation = operation; + res.difference_of_pic_nums_minus1 = difference_of_pic_nums_minus1; + res.long_term_pic_num = long_term_pic_num; + res.long_term_frame_idx = long_term_frame_idx; + res.max_long_term_frame_idx_plus1 = max_long_term_frame_idx_plus1; + return res; +} + +inline StdVideoDecodeH264Mvc makeStdVideoDecodeH264Mvc (deUint32 viewId0, deUint32 mvcElementCount, StdVideoDecodeH264MvcElement* pMvcElements) +{ + StdVideoDecodeH264Mvc res; + res.viewId0 = viewId0; + res.mvcElementCount = mvcElementCount; + res.pMvcElements = pMvcElements; + return res; +} diff --git a/external/vulkancts/framework/vulkan/vkVirtualDeviceInterface.inl b/external/vulkancts/framework/vulkan/vkVirtualDeviceInterface.inl index fcde82c..7943fa2 100644 --- a/external/vulkancts/framework/vulkan/vkVirtualDeviceInterface.inl +++ b/external/vulkancts/framework/vulkan/vkVirtualDeviceInterface.inl @@ -321,6 +321,18 @@ virtual VkDeviceSize getRayTracingShaderGroupStackSizeKHR (VkDevice device, V virtual void cmdSetRayTracingPipelineStackSizeKHR (VkCommandBuffer commandBuffer, deUint32 pipelineStackSize) const = 0; virtual VkResult getAndroidHardwareBufferPropertiesANDROID (VkDevice device, const struct pt::AndroidHardwareBufferPtr buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties) const = 0; virtual VkResult getMemoryAndroidHardwareBufferANDROID (VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct pt::AndroidHardwareBufferPtr* pBuffer) const = 0; +virtual VkResult createVideoSessionKHR (VkDevice device, const VkVideoSessionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionKHR* pVideoSession) const = 0; +virtual void destroyVideoSessionKHR (VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks* pAllocator) const = 0; +virtual VkResult getVideoSessionMemoryRequirementsKHR (VkDevice device, VkVideoSessionKHR videoSession, deUint32* pVideoSessionMemoryRequirementsCount, VkVideoGetMemoryPropertiesKHR* pVideoSessionMemoryRequirements) const = 0; +virtual VkResult bindVideoSessionMemoryKHR (VkDevice device, VkVideoSessionKHR videoSession, deUint32 videoSessionBindMemoryCount, const VkVideoBindMemoryKHR* pVideoSessionBindMemories) const = 0; +virtual VkResult createVideoSessionParametersKHR (VkDevice device, const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionParametersKHR* pVideoSessionParameters) const = 0; +virtual VkResult updateVideoSessionParametersKHR (VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo) const = 0; +virtual void destroyVideoSessionParametersKHR (VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkAllocationCallbacks* pAllocator) const = 0; +virtual void cmdBeginVideoCodingKHR (VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR* pBeginInfo) const = 0; +virtual void cmdEndVideoCodingKHR (VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR* pEndCodingInfo) const = 0; +virtual void cmdControlVideoCodingKHR (VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR* pCodingControlInfo) const = 0; +virtual void cmdDecodeVideoKHR (VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR* pFrameInfo) const = 0; +virtual void cmdEncodeVideoKHR (VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo) const = 0; virtual VkResult getMemoryZirconHandleFUCHSIA (VkDevice device, const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, pt::zx_handle_t* pZirconHandle) const = 0; virtual VkResult getMemoryZirconHandlePropertiesFUCHSIA (VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, pt::zx_handle_t zirconHandle, VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties) const = 0; virtual VkResult importSemaphoreZirconHandleFUCHSIA (VkDevice device, const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo) const = 0; diff --git a/external/vulkancts/framework/vulkan/vkVirtualInstanceInterface.inl b/external/vulkancts/framework/vulkan/vkVirtualInstanceInterface.inl index 97a6094..6ec7727 100644 --- a/external/vulkancts/framework/vulkan/vkVirtualInstanceInterface.inl +++ b/external/vulkancts/framework/vulkan/vkVirtualInstanceInterface.inl @@ -64,6 +64,8 @@ virtual VkResult createHeadlessSurfaceEXT (VkInstance instance, const V virtual VkResult acquireWinrtDisplayNV (VkPhysicalDevice physicalDevice, VkDisplayKHR display) const = 0; virtual VkResult getWinrtDisplayNV (VkPhysicalDevice physicalDevice, deUint32 deviceRelativeId, VkDisplayKHR* pDisplay) const = 0; virtual VkResult createAndroidSurfaceKHR (VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) const = 0; +virtual VkResult getPhysicalDeviceVideoCapabilitiesKHR (VkPhysicalDevice physicalDevice, const VkVideoProfileKHR* pVideoProfile, VkVideoCapabilitiesKHR* pCapabilities) const = 0; +virtual VkResult getPhysicalDeviceVideoFormatPropertiesKHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, deUint32* pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR* pVideoFormatProperties) const = 0; virtual VkResult createImagePipeSurfaceFUCHSIA (VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) const = 0; virtual VkResult createStreamDescriptorSurfaceGGP (VkInstance instance, const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) const = 0; virtual VkResult createIOSSurfaceMVK (VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) const = 0; diff --git a/external/vulkancts/framework/vulkan/vkVulkan_c.inl b/external/vulkancts/framework/vulkan/vkVulkan_c.inl index 7345990..7cde0ff 100644 --- a/external/vulkancts/framework/vulkan/vkVulkan_c.inl +++ b/external/vulkancts/framework/vulkan/vkVulkan_c.inl @@ -1,6 +1,907 @@ /* WARNING: This is auto-generated file. Do not modify, since changes will * be lost! Modify the generating script instead. */ +/* +** Copyright (c) 2019-2021 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +#ifndef VULKAN_VIDEO_CODEC_COMMON_H_ +#define VULKAN_VIDEO_CODEC_COMMON_H_ 1 + +#ifdef __cplusplus +extern "C" { +#endif + +#define VK_MAKE_VIDEO_STD_VERSION(major, minor, patch) \ + ((((deUint32)(major)) << 22) | (((deUint32)(minor)) << 12) | ((deUint32)(patch))) + +#ifdef __cplusplus +} +#endif + +#endif // VULKAN_VIDEO_CODEC_COMMON_H_ +/* +** Copyright (c) 2019-2021 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +#ifndef VULKAN_VIDEO_CODEC_H264STD_H_ +#define VULKAN_VIDEO_CODEC_H264STD_H_ 1 + +#ifdef __cplusplus +extern "C" { +#endif + + + +// Vulkan 0.9 provisional Vulkan video H.264 encode and decode std specification version number +#define VK_STD_VULKAN_VIDEO_CODEC_H264_API_VERSION_0_9 VK_MAKE_VIDEO_STD_VERSION(0, 9, 0) // Patch version should always be set to 0 + +// Format must be in the form XX.XX where the first two digits are the major and the second two, the minor. +#define VK_STD_VULKAN_VIDEO_CODEC_H264_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H264_API_VERSION_0_9 +#define VK_STD_VULKAN_VIDEO_CODEC_H264_EXTENSION_NAME "VK_STD_vulkan_video_codec_h264" + +// ************************************************* +// Video H.264 common definitions: +// ************************************************* + +typedef enum StdVideoH264ChromaFormatIdc { + std_video_h264_chroma_format_idc_monochrome = 0, + std_video_h264_chroma_format_idc_420 = 1, + std_video_h264_chroma_format_idc_422 = 2, + std_video_h264_chroma_format_idc_444 = 3, +} StdVideoH264ChromaFormatIdc; + +typedef enum StdVideoH264ProfileIdc { + std_video_h264_profile_idc_baseline = 66, /* Only constrained baseline is supported */ + std_video_h264_profile_idc_main = 77, + std_video_h264_profile_idc_high = 100, + std_video_h264_profile_idc_high_444_predictive = 244, + std_video_h264_profile_idc_invalid = 0x7FFFFFFF +} StdVideoH264ProfileIdc; + +typedef enum StdVideoH264Level { + std_video_h264_level_1_0 = 0, + std_video_h264_level_1_1 = 1, + std_video_h264_level_1_2 = 2, + std_video_h264_level_1_3 = 3, + std_video_h264_level_2_0 = 4, + std_video_h264_level_2_1 = 5, + std_video_h264_level_2_2 = 6, + std_video_h264_level_3_0 = 7, + std_video_h264_level_3_1 = 8, + std_video_h264_level_3_2 = 9, + std_video_h264_level_4_0 = 10, + std_video_h264_level_4_1 = 11, + std_video_h264_level_4_2 = 12, + std_video_h264_level_5_0 = 13, + std_video_h264_level_5_1 = 14, + std_video_h264_level_5_2 = 15, + std_video_h264_level_6_0 = 16, + std_video_h264_level_6_1 = 17, + std_video_h264_level_6_2 = 18, + std_video_h264_level_invalid = 0x7FFFFFFF +} StdVideoH264Level; + +typedef enum StdVideoH264PocType { + std_video_h264_poc_type_0 = 0, + std_video_h264_poc_type_1 = 1, + std_video_h264_poc_type_2 = 2, + std_video_h264_poc_type_invalid = 0x7FFFFFFF +} StdVideoH264PocType; + +typedef enum StdVideoH264AspectRatioIdc { + std_video_h264_aspect_ratio_idc_unspecified = 0, + std_video_h264_aspect_ratio_idc_square = 1, + std_video_h264_aspect_ratio_idc_12_11 = 2, + std_video_h264_aspect_ratio_idc_10_11 = 3, + std_video_h264_aspect_ratio_idc_16_11 = 4, + std_video_h264_aspect_ratio_idc_40_33 = 5, + std_video_h264_aspect_ratio_idc_24_11 = 6, + std_video_h264_aspect_ratio_idc_20_11 = 7, + std_video_h264_aspect_ratio_idc_32_11 = 8, + std_video_h264_aspect_ratio_idc_80_33 = 9, + std_video_h264_aspect_ratio_idc_18_11 = 10, + std_video_h264_aspect_ratio_idc_15_11 = 11, + std_video_h264_aspect_ratio_idc_64_33 = 12, + std_video_h264_aspect_ratio_idc_160_99 = 13, + std_video_h264_aspect_ratio_idc_4_3 = 14, + std_video_h264_aspect_ratio_idc_3_2 = 15, + std_video_h264_aspect_ratio_idc_2_1 = 16, + std_video_h264_aspect_ratio_idc_extended_sar = 255, + std_video_h264_aspect_ratio_idc_invalid = 0x7FFFFFFF +} StdVideoH264AspectRatioIdc; + +typedef enum StdVideoH264WeightedBiPredIdc { + std_video_h264_default_weighted_b_slices_prediction_idc = 0, + std_video_h264_explicit_weighted_b_slices_prediction_idc = 1, + std_video_h264_implicit_weighted_b_slices_prediction_idc = 2, + std_video_h264_invalid_weighted_b_slices_prediction_idc = 0x7FFFFFFF +} StdVideoH264WeightedBiPredIdc; + +typedef enum StdVideoH264ModificationOfPicNumsIdc { + std_video_h264_modification_of_pic_nums_idc_short_term_subtract = 0, + std_video_h264_modification_of_pic_nums_idc_short_term_add = 1, + std_video_h264_modification_of_pic_nums_idc_long_term = 2, + std_video_h264_modification_of_pic_nums_idc_end = 3, + std_video_h264_modification_of_pic_nums_idc_invalid = 0x7FFFFFFF +} StdVideoH264ModificationOfPicNumsIdc; + +typedef enum StdVideoH264MemMgmtControlOp { + std_video_h264_mem_mgmt_control_op_end = 0, + std_video_h264_mem_mgmt_control_op_unmark_short_term = 1, + std_video_h264_mem_mgmt_control_op_unmark_long_term = 2, + std_video_h264_mem_mgmt_control_op_mark_long_term = 3, + std_video_h264_mem_mgmt_control_op_set_max_long_term_index = 4, + std_video_h264_mem_mgmt_control_op_unmark_all = 5, + std_video_h264_mem_mgmt_control_op_mark_current_as_long_term = 6, + std_video_h264_mem_mgmt_control_op_invalid = 0x7FFFFFFF +} StdVideoH264MemMgmtControlOp; + +typedef enum StdVideoH264CabacInitIdc { + std_video_h264_cabac_init_idc_0 = 0, + std_video_h264_cabac_init_idc_1 = 1, + std_video_h264_cabac_init_idc_2 = 2, + std_video_h264_cabac_init_idc_invalid = 0x7FFFFFFF +} StdVideoH264CabacInitIdc; + +typedef enum StdVideoH264DisableDeblockingFilterIdc { + std_video_h264_disable_deblocking_filter_idc_disabled = 0, + std_video_h264_disable_deblocking_filter_idc_enabled = 1, + std_video_h264_disable_deblocking_filter_idc_partial = 2, + std_video_h264_disable_deblocking_filter_idc_invalid = 0x7FFFFFFF +} StdVideoH264DisableDeblockingFilterIdc; + +typedef enum StdVideoH264PictureType { + std_video_h264_picture_type_i = 0, + std_video_h264_picture_type_p = 1, + std_video_h264_picture_type_b = 2, + std_video_h264_picture_type_invalid = 0x7FFFFFFF +} StdVideoH264PictureType; + +typedef enum StdVideoH264SliceType { + std_video_h264_slice_type_i = 0, + std_video_h264_slice_type_p = 1, + std_video_h264_slice_type_b = 2, + std_video_h264_slice_type_invalid = 0x7FFFFFFF +} StdVideoH264SliceType; + +typedef enum StdVideoH264NonVclNaluType { + std_video_h264_non_vcl_nalu_type_sps = 0, + std_video_h264_non_vcl_nalu_type_pps = 1, + std_video_h264_non_vcl_nalu_type_aud = 2, + std_video_h264_non_vcl_nalu_type_prefix = 3, + std_video_h264_non_vcl_nalu_type_end_of_sequence = 4, + std_video_h264_non_vcl_nalu_type_end_of_stream = 5, + std_video_h264_non_vcl_nalu_type_precoded = 6, + std_video_h264_non_vcl_nalu_type_invalid = 0x7FFFFFFF +} StdVideoH264NonVclNaluType; + +typedef struct StdVideoH264SpsVuiFlags { + deUint32 aspect_ratio_info_present_flag:1; + deUint32 overscan_info_present_flag:1; + deUint32 overscan_appropriate_flag:1; + deUint32 video_signal_type_present_flag:1; + deUint32 video_full_range_flag:1; + deUint32 color_description_present_flag:1; + deUint32 chroma_loc_info_present_flag:1; + deUint32 timing_info_present_flag:1; + deUint32 fixed_frame_rate_flag:1; + deUint32 bitstream_restriction_flag:1; + deUint32 nal_hrd_parameters_present_flag:1; + deUint32 vcl_hrd_parameters_present_flag:1; +} StdVideoH264SpsVuiFlags; + +typedef struct StdVideoH264HrdParameters { + deUint8 cpb_cnt_minus1; + deUint8 bit_rate_scale; + deUint8 cpb_size_scale; + deUint32 bit_rate_value_minus1[32]; + deUint32 cpb_size_value_minus1[32]; + deUint8 cbr_flag[32]; + deUint32 initial_cpb_removal_delay_length_minus1; + deUint32 cpb_removal_delay_length_minus1; + deUint32 dpb_output_delay_length_minus1; + deUint32 time_offset_length; +} StdVideoH264HrdParameters; + +typedef struct StdVideoH264SequenceParameterSetVui { + StdVideoH264AspectRatioIdc aspect_ratio_idc; + deUint16 sar_width; + deUint16 sar_height; + deUint8 video_format; + deUint8 color_primaries; + deUint8 transfer_characteristics; + deUint8 matrix_coefficients; + deUint32 num_units_in_tick; + deUint32 time_scale; + StdVideoH264HrdParameters hrd_parameters; + deUint8 num_reorder_frames; + deUint8 max_dec_frame_buffering; + StdVideoH264SpsVuiFlags flags; +} StdVideoH264SequenceParameterSetVui; + +typedef struct StdVideoH264SpsFlags { + deUint32 constraint_set0_flag:1; + deUint32 constraint_set1_flag:1; + deUint32 constraint_set2_flag:1; + deUint32 constraint_set3_flag:1; + deUint32 constraint_set4_flag:1; + deUint32 constraint_set5_flag:1; + deUint32 direct_8x8_inference_flag:1; + deUint32 mb_adaptive_frame_field_flag:1; + deUint32 frame_mbs_only_flag:1; + deUint32 delta_pic_order_always_zero_flag:1; + deUint32 residual_colour_transform_flag:1; + deUint32 gaps_in_frame_num_value_allowed_flag:1; + deUint32 first_picture_after_seek_flag:1; // where is this being documented? + deUint32 qpprime_y_zero_transform_bypass_flag:1; + deUint32 frame_cropping_flag:1; + deUint32 scaling_matrix_present_flag:1; + deUint32 vui_parameters_present_flag:1; +} StdVideoH264SpsFlags; + +typedef struct StdVideoH264ScalingLists +{ + // scaling_list_present_mask has one bit for each + // seq_scaling_list_present_flag[i] for SPS OR + // pic_scaling_list_present_flag[i] for PPS, + // bit 0 - 5 are for each entry of ScalingList4x4 + // bit 6 - 7 are for each entry plus 6 for ScalingList8x8 + deUint8 scaling_list_present_mask; + // use_default_scaling_matrix_mask has one bit for each + // UseDefaultScalingMatrix4x4Flag[ i ] and + // UseDefaultScalingMatrix8x8Flag[ i - 6 ] for SPS OR PPS + // bit 0 - 5 are for each entry of ScalingList4x4 + // bit 6 - 7 are for each entry plus 6 for ScalingList8x8 + deUint8 use_default_scaling_matrix_mask; + deUint8 ScalingList4x4[6][16]; + deUint8 ScalingList8x8[2][64]; +} StdVideoH264ScalingLists; + +typedef struct StdVideoH264SequenceParameterSet +{ + StdVideoH264ProfileIdc profile_idc; + StdVideoH264Level level_idc; + deUint8 seq_parameter_set_id; + StdVideoH264ChromaFormatIdc chroma_format_idc; + deUint8 bit_depth_luma_minus8; + deUint8 bit_depth_chroma_minus8; + deUint8 log2_max_frame_num_minus4; + StdVideoH264PocType pic_order_cnt_type; + deUint8 log2_max_pic_order_cnt_lsb_minus4; + deInt32 offset_for_non_ref_pic; + deInt32 offset_for_top_to_bottom_field; + deUint8 num_ref_frames_in_pic_order_cnt_cycle; + deUint8 max_num_ref_frames; + deUint32 pic_width_in_mbs_minus1; + deUint32 pic_height_in_map_units_minus1; + deUint32 frame_crop_left_offset; + deUint32 frame_crop_right_offset; + deUint32 frame_crop_top_offset; + deUint32 frame_crop_bottom_offset; + StdVideoH264SpsFlags flags; + deInt32 offset_for_ref_frame[255]; // The number of valid values are defined by the num_ref_frames_in_pic_order_cnt_cycle + StdVideoH264ScalingLists* pScalingLists; // Must be a valid pointer if scaling_matrix_present_flag is set + StdVideoH264SequenceParameterSetVui* pSequenceParameterSetVui; // Must be a valid pointer if StdVideoH264SpsFlags:vui_parameters_present_flag is set +} StdVideoH264SequenceParameterSet; + +typedef struct StdVideoH264PpsFlags { + deUint32 transform_8x8_mode_flag:1; + deUint32 redundant_pic_cnt_present_flag:1; + deUint32 constrained_intra_pred_flag:1; + deUint32 deblocking_filter_control_present_flag:1; + deUint32 weighted_bipred_idc_flag:1; + deUint32 weighted_pred_flag:1; + deUint32 pic_order_present_flag:1; + deUint32 entropy_coding_mode_flag:1; + deUint32 scaling_matrix_present_flag:1; +} StdVideoH264PpsFlags; + +typedef struct StdVideoH264PictureParameterSet +{ + deUint8 seq_parameter_set_id; + deUint8 pic_parameter_set_id; + deUint8 num_ref_idx_l0_default_active_minus1; + deUint8 num_ref_idx_l1_default_active_minus1; + StdVideoH264WeightedBiPredIdc weighted_bipred_idc; + deInt8 pic_init_qp_minus26; + deInt8 pic_init_qs_minus26; + deInt8 chroma_qp_index_offset; + deInt8 second_chroma_qp_index_offset; + StdVideoH264PpsFlags flags; + StdVideoH264ScalingLists* pScalingLists; // Must be a valid pointer if StdVideoH264PpsFlags::scaling_matrix_present_flag is set. +} StdVideoH264PictureParameterSet; + +#ifdef __cplusplus +} +#endif + +#endif // VULKAN_VIDEO_CODEC_H264STD_H_ +/* +** Copyright (c) 2019-2021 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +#ifndef VULKAN_VIDEO_CODEC_H264STD_ENCODE_H_ +#define VULKAN_VIDEO_CODEC_H264STD_ENCODE_H_ 1 + +#ifdef __cplusplus +extern "C" { +#endif + + + +// ************************************************* +// Video H.264 Encode related parameters: +// ************************************************* + +typedef struct StdVideoEncodeH264SliceHeaderFlags { + deUint32 idr_flag:1; + deUint32 is_reference_flag:1; + deUint32 num_ref_idx_active_override_flag:1; + deUint32 no_output_of_prior_pics_flag:1; + deUint32 long_term_reference_flag:1; + deUint32 adaptive_ref_pic_marking_mode_flag:1; + deUint32 no_prior_references_available_flag:1; +} StdVideoEncodeH264SliceHeaderFlags; + +typedef struct StdVideoEncodeH264PictureInfoFlags { + deUint32 idr_flag:1; + deUint32 is_reference_flag:1; + deUint32 long_term_reference_flag:1; +} StdVideoEncodeH264PictureInfoFlags; + +typedef struct StdVideoEncodeH264RefMgmtFlags { + deUint32 ref_pic_list_modification_l0_flag:1; + deUint32 ref_pic_list_modification_l1_flag:1; +} StdVideoEncodeH264RefMgmtFlags; + +typedef struct StdVideoEncodeH264RefListModEntry { + StdVideoH264ModificationOfPicNumsIdc modification_of_pic_nums_idc; + deUint16 abs_diff_pic_num_minus1; + deUint16 long_term_pic_num; +} StdVideoEncodeH264RefListModEntry; + +typedef struct StdVideoEncodeH264RefPicMarkingEntry { + StdVideoH264MemMgmtControlOp operation; + deUint16 difference_of_pic_nums_minus1; + deUint16 long_term_pic_num; + deUint16 long_term_frame_idx; + deUint16 max_long_term_frame_idx_plus1; +} StdVideoEncodeH264RefPicMarkingEntry; + +typedef struct StdVideoEncodeH264RefMemMgmtCtrlOperations { + StdVideoEncodeH264RefMgmtFlags flags; + deUint8 refList0ModOpCount; + StdVideoEncodeH264RefListModEntry* pRefList0ModOperations; + deUint8 refList1ModOpCount; + StdVideoEncodeH264RefListModEntry* pRefList1ModOperations; + deUint8 refPicMarkingOpCount; + StdVideoEncodeH264RefPicMarkingEntry* pRefPicMarkingOperations; +} StdVideoEncodeH264RefMemMgmtCtrlOperations; + +typedef struct StdVideoEncodeH264PictureInfo { + StdVideoEncodeH264PictureInfoFlags flags; + StdVideoH264PictureType pictureType; + deUint32 frameNum; + deUint32 pictureOrderCount; + deUint16 long_term_pic_num; + deUint16 long_term_frame_idx; +} StdVideoEncodeH264PictureInfo; + +typedef struct StdVideoEncodeH264SliceHeader { + StdVideoEncodeH264SliceHeaderFlags flags; + StdVideoH264SliceType slice_type; + deUint8 seq_parameter_set_id; + deUint8 pic_parameter_set_id; + deUint16 idr_pic_id; + deUint8 num_ref_idx_l0_active_minus1; + deUint8 num_ref_idx_l1_active_minus1; + StdVideoH264CabacInitIdc cabac_init_idc; + StdVideoH264DisableDeblockingFilterIdc disable_deblocking_filter_idc; + deInt8 slice_alpha_c0_offset_div2; + deInt8 slice_beta_offset_div2; + StdVideoEncodeH264RefMemMgmtCtrlOperations* pMemMgmtCtrlOperations; +} StdVideoEncodeH264SliceHeader; + + +#ifdef __cplusplus +} +#endif + +#endif // VULKAN_VIDEO_CODEC_H264STD_ENCODE_H_ +/* +** Copyright (c) 2019-2021 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +#ifndef VULKAN_VIDEO_CODEC_H265STD_H_ +#define VULKAN_VIDEO_CODEC_H265STD_H_ 1 + +#ifdef __cplusplus +extern "C" { +#endif + + + +// Vulkan 0.5 version number WIP +#define VK_STD_VULKAN_VIDEO_CODEC_H265_API_VERSION_0_5 VK_MAKE_VIDEO_STD_VERSION(0, 5, 0) // Patch version should always be set to 0 + +// Format must be in the form XX.XX where the first two digits are the major and the second two, the minor. +#define VK_STD_VULKAN_VIDEO_CODEC_H265_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H265_API_VERSION_0_5 +#define VK_STD_VULKAN_VIDEO_CODEC_H265_EXTENSION_NAME "VK_STD_vulkan_video_codec_h265" + +typedef enum StdVideoH265ChromaFormatIdc { + std_video_h265_chroma_format_idc_monochrome = 0, + std_video_h265_chroma_format_idc_420 = 1, + std_video_h265_chroma_format_idc_422 = 2, + std_video_h265_chroma_format_idc_444 = 3, +} StdVideoH265ChromaFormatIdc; + +typedef enum StdVideoH265ProfileIdc { + std_video_h265_profile_idc_main = 1, + std_video_h265_profile_idc_main_10 = 2, + std_video_h265_profile_idc_main_still_picture = 3, + std_video_h265_profile_idc_format_range_extensions = 4, + std_video_h265_profile_idc_scc_extensions = 9, + std_video_h265_profile_idc_invalid = 0x7FFFFFFF +} StdVideoH265ProfileIdc; + +typedef enum StdVideoH265Level { + std_video_h265_level_1_0 = 0, + std_video_h265_level_2_0 = 1, + std_video_h265_level_2_1 = 2, + std_video_h265_level_3_0 = 3, + std_video_h265_level_3_1 = 4, + std_video_h265_level_4_0 = 5, + std_video_h265_level_4_1 = 6, + std_video_h265_level_5_0 = 7, + std_video_h265_level_5_1 = 8, + std_video_h265_level_5_2 = 9, + std_video_h265_level_6_0 = 10, + std_video_h265_level_6_1 = 11, + std_video_h265_level_6_2 = 12, + std_video_h265_level_invalid = 0x7FFFFFFF +} StdVideoH265Level; + + +typedef struct StdVideoH265DecPicBufMgr +{ + deUint32 max_latency_increase_plus1[7]; + deUint8 max_dec_pic_buffering_minus1[7]; + deUint8 max_num_reorder_pics[7]; +} StdVideoH265DecPicBufMgr; + +typedef struct StdVideoH265SubLayerHrdParameters { + deUint32 bit_rate_value_minus1[32]; + deUint32 cpb_size_value_minus1[32]; + deUint32 cpb_size_du_value_minus1[32]; + deUint32 bit_rate_du_value_minus1[32]; + deUint32 cbr_flag; // each bit represents a range of CpbCounts (bit 0 - cpb_cnt_minus1) per sub-layer +} StdVideoH265SubLayerHrdParameters; + +typedef struct StdVideoH265HrdFlags { + deUint32 nal_hrd_parameters_present_flag : 1; + deUint32 vcl_hrd_parameters_present_flag : 1; + deUint32 sub_pic_hrd_params_present_flag : 1; + deUint32 sub_pic_cpb_params_in_pic_timing_sei_flag : 1; + deUint8 fixed_pic_rate_general_flag; // each bit represents a sublayer, bit 0 - vps_max_sub_layers_minus1 + deUint8 fixed_pic_rate_within_cvs_flag; // each bit represents a sublayer, bit 0 - vps_max_sub_layers_minus1 + deUint8 low_delay_hrd_flag; // each bit represents a sublayer, bit 0 - vps_max_sub_layers_minus1 +} StdVideoH265HrdFlags; + +typedef struct StdVideoH265HrdParameters { + deUint8 tick_divisor_minus2; + deUint8 du_cpb_removal_delay_increment_length_minus1; + deUint8 dpb_output_delay_du_length_minus1; + deUint8 bit_rate_scale; + deUint8 cpb_size_scale; + deUint8 cpb_size_du_scale; + deUint8 initial_cpb_removal_delay_length_minus1; + deUint8 au_cpb_removal_delay_length_minus1; + deUint8 dpb_output_delay_length_minus1; + deUint8 cpb_cnt_minus1[7]; + deUint16 elemental_duration_in_tc_minus1[7]; + StdVideoH265SubLayerHrdParameters* SubLayerHrdParametersNal[7]; + StdVideoH265SubLayerHrdParameters* SubLayerHrdParametersVcl[7]; + StdVideoH265HrdFlags flags; +} StdVideoH265HrdParameters; + +typedef struct StdVideoH265VpsFlags { + deUint32 vps_temporal_id_nesting_flag : 1; + deUint32 vps_sub_layer_ordering_info_present_flag : 1; + deUint32 vps_timing_info_present_flag : 1; + deUint32 vps_poc_proportional_to_timing_flag : 1; +} StdVideoH265VpsFlags; + +typedef struct StdVideoH265VideoParameterSet +{ + deUint8 vps_video_parameter_set_id; + deUint8 vps_max_sub_layers_minus1; + deUint32 vps_num_units_in_tick; + deUint32 vps_time_scale; + deUint32 vps_num_ticks_poc_diff_one_minus1; + StdVideoH265DecPicBufMgr* pDecPicBufMgr; + StdVideoH265HrdParameters* hrd_parameters; + StdVideoH265VpsFlags flags; +} StdVideoH265VideoParameterSet; + +typedef struct StdVideoH265ScalingLists +{ + deUint8 ScalingList4x4[6][16]; // ScalingList[ 0 ][ MatrixID ][ i ] (sizeID = 0) + deUint8 ScalingList8x8[6][64]; // ScalingList[ 1 ][ MatrixID ][ i ] (sizeID = 1) + deUint8 ScalingList16x16[6][64]; // ScalingList[ 2 ][ MatrixID ][ i ] (sizeID = 2) + deUint8 ScalingList32x32[2][64]; // ScalingList[ 3 ][ MatrixID ][ i ] (sizeID = 3) + deUint8 ScalingListDCCoef16x16[6]; // scaling_list_dc_coef_minus8[ sizeID - 2 ][ matrixID ] + 8, sizeID = 2 + deUint8 ScalingListDCCoef32x32[2]; // scaling_list_dc_coef_minus8[ sizeID - 2 ][ matrixID ] + 8. sizeID = 3 +} StdVideoH265ScalingLists; + +typedef struct StdVideoH265SpsVuiFlags { + deUint32 aspect_ratio_info_present_flag : 1; + deUint32 overscan_info_present_flag : 1; + deUint32 overscan_appropriate_flag : 1; + deUint32 video_signal_type_present_flag : 1; + deUint32 video_full_range_flag : 1; + deUint32 colour_description_present_flag : 1; + deUint32 chroma_loc_info_present_flag : 1; + deUint32 neutral_chroma_indication_flag : 1; + deUint32 field_seq_flag : 1; + deUint32 frame_field_info_present_flag : 1; + deUint32 default_display_window_flag : 1; + deUint32 vui_timing_info_present_flag : 1; + deUint32 vui_poc_proportional_to_timing_flag : 1; + deUint32 vui_hrd_parameters_present_flag : 1; + deUint32 bitstream_restriction_flag : 1; + deUint32 tiles_fixed_structure_flag : 1; + deUint32 motion_vectors_over_pic_boundaries_flag : 1; + deUint32 restricted_ref_pic_lists_flag : 1; +} StdVideoH265SpsVuiFlags; + +typedef struct StdVideoH265SequenceParameterSetVui { + deUint8 aspect_ratio_idc; + deUint16 sar_width; + deUint16 sar_height; + deUint8 video_format; + deUint8 colour_primaries; + deUint8 transfer_characteristics; + deUint8 matrix_coeffs; + deUint8 chroma_sample_loc_type_top_field; + deUint8 chroma_sample_loc_type_bottom_field; + deUint16 def_disp_win_left_offset; + deUint16 def_disp_win_right_offset; + deUint16 def_disp_win_top_offset; + deUint16 def_disp_win_bottom_offset; + deUint32 vui_num_units_in_tick; + deUint32 vui_time_scale; + deUint32 vui_num_ticks_poc_diff_one_minus1; + StdVideoH265HrdParameters* hrd_parameters; + deUint16 min_spatial_segmentation_idc; + deUint8 max_bytes_per_pic_denom; + deUint8 max_bits_per_min_cu_denom; + deUint8 log2_max_mv_length_horizontal; + deUint8 log2_max_mv_length_vertical; + StdVideoH265SpsVuiFlags flags; +} StdVideoH265SequenceParameterSetVui; + +typedef struct StdVideoH265PredictorPaletteEntries +{ + deUint16 PredictorPaletteEntries[3][128]; +} StdVideoH265PredictorPaletteEntries; + + +typedef struct StdVideoH265SpsFlags { + deUint32 sps_temporal_id_nesting_flag : 1; + deUint32 separate_colour_plane_flag : 1; + deUint32 scaling_list_enabled_flag : 1; + deUint32 sps_scaling_list_data_present_flag : 1; + deUint32 amp_enabled_flag : 1; + deUint32 sample_adaptive_offset_enabled_flag : 1; + deUint32 pcm_enabled_flag : 1; + deUint32 pcm_loop_filter_disabled_flag : 1; + deUint32 long_term_ref_pics_present_flag : 1; + deUint32 sps_temporal_mvp_enabled_flag : 1; + deUint32 strong_intra_smoothing_enabled_flag : 1; + deUint32 vui_parameters_present_flag : 1; + deUint32 sps_extension_present_flag : 1; + deUint32 sps_range_extension_flag : 1; + + // extension SPS flags, valid when std_video_h265_profile_idc_format_range_extensions is set + deUint32 transform_skip_rotation_enabled_flag : 1; + deUint32 transform_skip_context_enabled_flag : 1; + deUint32 implicit_rdpcm_enabled_flag : 1; + deUint32 explicit_rdpcm_enabled_flag : 1; + deUint32 extended_precision_processing_flag : 1; + deUint32 intra_smoothing_disabled_flag : 1; + deUint32 high_precision_offsets_enabled_flag : 1; + deUint32 persistent_rice_adaptation_enabled_flag : 1; + deUint32 cabac_bypass_alignment_enabled_flag : 1; + + // extension SPS flags, valid when std_video_h265_profile_idc_scc_extensions is set + deUint32 sps_curr_pic_ref_enabled_flag : 1; + deUint32 palette_mode_enabled_flag : 1; + deUint32 sps_palette_predictor_initializer_present_flag : 1; + deUint32 intra_boundary_filtering_disabled_flag : 1; +} StdVideoH265SpsFlags; + +typedef struct StdVideoH265SequenceParameterSet +{ + StdVideoH265ProfileIdc profile_idc; + StdVideoH265Level level_idc; + deUint32 pic_width_in_luma_samples; + deUint32 pic_height_in_luma_samples; + deUint8 sps_video_parameter_set_id; + deUint8 sps_max_sub_layers_minus1; + deUint8 sps_seq_parameter_set_id; + deUint8 chroma_format_idc; + deUint8 bit_depth_luma_minus8; + deUint8 bit_depth_chroma_minus8; + deUint8 log2_max_pic_order_cnt_lsb_minus4; + deUint8 sps_max_dec_pic_buffering_minus1; + deUint8 log2_min_luma_coding_block_size_minus3; + deUint8 log2_diff_max_min_luma_coding_block_size; + deUint8 log2_min_luma_transform_block_size_minus2; + deUint8 log2_diff_max_min_luma_transform_block_size; + deUint8 max_transform_hierarchy_depth_inter; + deUint8 max_transform_hierarchy_depth_intra; + deUint8 num_short_term_ref_pic_sets; + deUint8 num_long_term_ref_pics_sps; + deUint8 pcm_sample_bit_depth_luma_minus1; + deUint8 pcm_sample_bit_depth_chroma_minus1; + deUint8 log2_min_pcm_luma_coding_block_size_minus3; + deUint8 log2_diff_max_min_pcm_luma_coding_block_size; + deUint32 conf_win_left_offset; + deUint32 conf_win_right_offset; + deUint32 conf_win_top_offset; + deUint32 conf_win_bottom_offset; + StdVideoH265DecPicBufMgr* pDecPicBufMgr; + StdVideoH265SpsFlags flags; + StdVideoH265ScalingLists* pScalingLists; // Must be a valid pointer if sps_scaling_list_data_present_flag is set + StdVideoH265SequenceParameterSetVui* pSequenceParameterSetVui; // Must be a valid pointer if StdVideoH265SpsFlags:vui_parameters_present_flag is set palette_max_size; + + // extension SPS flags, valid when std_video_h265_profile_idc_scc_extensions is set + deUint8 palette_max_size; + deUint8 delta_palette_max_predictor_size; + deUint8 motion_vector_resolution_control_idc; + deUint8 sps_num_palette_predictor_initializer_minus1; + StdVideoH265PredictorPaletteEntries* pPredictorPaletteEntries; // Must be a valid pointer if sps_palette_predictor_initializer_present_flag is set +} StdVideoH265SequenceParameterSet; + + +typedef struct StdVideoH265PpsFlags { + deUint32 dependent_slice_segments_enabled_flag : 1; + deUint32 output_flag_present_flag : 1; + deUint32 sign_data_hiding_enabled_flag : 1; + deUint32 cabac_init_present_flag : 1; + deUint32 constrained_intra_pred_flag : 1; + deUint32 transform_skip_enabled_flag : 1; + deUint32 cu_qp_delta_enabled_flag : 1; + deUint32 pps_slice_chroma_qp_offsets_present_flag : 1; + deUint32 weighted_pred_flag : 1; + deUint32 weighted_bipred_flag : 1; + deUint32 transquant_bypass_enabled_flag : 1; + deUint32 tiles_enabled_flag : 1; + deUint32 entropy_coding_sync_enabled_flag : 1; + deUint32 uniform_spacing_flag : 1; + deUint32 loop_filter_across_tiles_enabled_flag : 1; + deUint32 pps_loop_filter_across_slices_enabled_flag : 1; + deUint32 deblocking_filter_control_present_flag : 1; + deUint32 deblocking_filter_override_enabled_flag : 1; + deUint32 pps_deblocking_filter_disabled_flag : 1; + deUint32 pps_scaling_list_data_present_flag : 1; + deUint32 lists_modification_present_flag : 1; + deUint32 slice_segment_header_extension_present_flag : 1; + deUint32 pps_extension_present_flag : 1; + + // extension PPS flags, valid when std_video_h265_profile_idc_format_range_extensions is set + deUint32 cross_component_prediction_enabled_flag : 1; + deUint32 chroma_qp_offset_list_enabled_flag : 1; + + // extension PPS flags, valid when std_video_h265_profile_idc_scc_extensions is set + deUint32 pps_curr_pic_ref_enabled_flag : 1; + deUint32 residual_adaptive_colour_transform_enabled_flag : 1; + deUint32 pps_slice_act_qp_offsets_present_flag : 1; + deUint32 pps_palette_predictor_initializer_present_flag : 1; + deUint32 monochrome_palette_flag : 1; + deUint32 pps_range_extension_flag : 1; +} StdVideoH265PpsFlags; + +typedef struct StdVideoH265PictureParameterSet +{ + deUint8 pps_pic_parameter_set_id; + deUint8 pps_seq_parameter_set_id; + deUint8 num_extra_slice_header_bits; + deUint8 num_ref_idx_l0_default_active_minus1; + deUint8 num_ref_idx_l1_default_active_minus1; + deInt8 init_qp_minus26; + deUint8 diff_cu_qp_delta_depth; + deInt8 pps_cb_qp_offset; + deInt8 pps_cr_qp_offset; + deUint8 num_tile_columns_minus1; + deUint8 num_tile_rows_minus1; + deUint16 column_width_minus1[19]; + deUint16 row_height_minus1[21]; + deInt8 pps_beta_offset_div2; + deInt8 pps_tc_offset_div2; + deUint8 log2_parallel_merge_level_minus2; + StdVideoH265PpsFlags flags; + StdVideoH265ScalingLists* pScalingLists; // Must be a valid pointer if pps_scaling_list_data_present_flag is set + + // extension PPS, valid when std_video_h265_profile_idc_format_range_extensions is set + deUint8 log2_max_transform_skip_block_size_minus2; + deUint8 diff_cu_chroma_qp_offset_depth; + deUint8 chroma_qp_offset_list_len_minus1; + deInt8 cb_qp_offset_list[6]; + deInt8 cr_qp_offset_list[6]; + deUint8 log2_sao_offset_scale_luma; + deUint8 log2_sao_offset_scale_chroma; + + // extension PPS, valid when std_video_h265_profile_idc_scc_extensions is set + deInt8 pps_act_y_qp_offset_plus5; + deInt8 pps_act_cb_qp_offset_plus5; + deInt8 pps_act_cr_qp_offset_plus5; + deUint8 pps_num_palette_predictor_initializer; + deUint8 luma_bit_depth_entry_minus8; + deUint8 chroma_bit_depth_entry_minus8; + StdVideoH265PredictorPaletteEntries* pPredictorPaletteEntries; // Must be a valid pointer if pps_palette_predictor_initializer_present_flag is set +} StdVideoH265PictureParameterSet; + +#ifdef __cplusplus +} +#endif + +#endif // VULKAN_VIDEO_CODEC_H265STD_H_ +/* +** Copyright (c) 2019-2020 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +#ifndef VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ +#define VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ 1 + +#ifdef __cplusplus +extern "C" { +#endif + + + +// ************************************************* +// Video H.264 Decode related parameters: +// ************************************************* + +typedef struct StdVideoDecodeH264PictureInfoFlags { + deUint32 field_pic_flag:1; // Is field picture + deUint32 is_intra:1; // Is intra picture + deUint32 bottom_field_flag:1; // bottom (true) or top (false) field if field_pic_flag is set. + deUint32 is_reference:1; // This only applies to picture info, and not to the DPB lists. + deUint32 complementary_field_pair:1; // complementary field pair, complementary non-reference field pair, complementary reference field pair +} StdVideoDecodeH264PictureInfoFlags; + +typedef struct StdVideoDecodeH264PictureInfo { + deUint8 seq_parameter_set_id; // Selecting SPS from the Picture Parameters + deUint8 pic_parameter_set_id; // Selecting PPS from the Picture Parameters and the SPS + deUint16 reserved; // for structure members 32-bit packing/alignment + deUint16 frame_num; // 7.4.3 Slice header semantics + deUint16 idr_pic_id; // 7.4.3 Slice header semantics + // PicOrderCnt is based on TopFieldOrderCnt and BottomFieldOrderCnt. See 8.2.1 Decoding process for picture order count type 0 - 2 + deInt32 PicOrderCnt[2]; // TopFieldOrderCnt and BottomFieldOrderCnt fields. + StdVideoDecodeH264PictureInfoFlags flags; +} StdVideoDecodeH264PictureInfo; + +typedef struct StdVideoDecodeH264ReferenceInfoFlags { + deUint32 top_field_flag:1; // Reference is used for top field reference. + deUint32 bottom_field_flag:1; // Reference is used for bottom field reference. + deUint32 is_long_term:1; // this is a long term reference + deUint32 is_non_existing:1; // Must be handled in accordance with 8.2.5.2: Decoding process for gaps in frame_num +} StdVideoDecodeH264ReferenceInfoFlags; + +typedef struct StdVideoDecodeH264ReferenceInfo { + // FrameNum = is_long_term ? long_term_frame_idx : frame_num + deUint16 FrameNum; // 7.4.3.3 Decoded reference picture marking semantics + deUint16 reserved; // for structure members 32-bit packing/alignment + deInt32 PicOrderCnt[2]; // TopFieldOrderCnt and BottomFieldOrderCnt fields. + StdVideoDecodeH264ReferenceInfoFlags flags; +} StdVideoDecodeH264ReferenceInfo; + +typedef struct StdVideoDecodeH264MvcElementFlags { + deUint32 non_idr:1; + deUint32 anchor_pic:1; + deUint32 inter_view:1; +} StdVideoDecodeH264MvcElementFlags; + +typedef struct StdVideoDecodeH264MvcElement { + StdVideoDecodeH264MvcElementFlags flags; + deUint16 viewOrderIndex; + deUint16 viewId; + deUint16 temporalId; // move out? + deUint16 priorityId; // move out? + deUint16 numOfAnchorRefsInL0; + deUint16 viewIdOfAnchorRefsInL0[15]; + deUint16 numOfAnchorRefsInL1; + deUint16 viewIdOfAnchorRefsInL1[15]; + deUint16 numOfNonAnchorRefsInL0; + deUint16 viewIdOfNonAnchorRefsInL0[15]; + deUint16 numOfNonAnchorRefsInL1; + deUint16 viewIdOfNonAnchorRefsInL1[15]; +} StdVideoDecodeH264MvcElement; + +typedef struct StdVideoDecodeH264Mvc { + deUint32 viewId0; + deUint32 mvcElementCount; + StdVideoDecodeH264MvcElement* pMvcElements; +} StdVideoDecodeH264Mvc; + + +#ifdef __cplusplus +} +#endif + +#endif // VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ +/* +** Copyright (c) 2019-2021 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +#ifndef VULKAN_VIDEO_CODEC_H265STD_DECODE_H_ +#define VULKAN_VIDEO_CODEC_H265STD_DECODE_H_ 1 + +#ifdef __cplusplus +extern "C" { +#endif + + + +// ************************************************* +// Video h265 Decode related parameters: +// ************************************************* + +typedef struct StdVideoDecodeH265PictureInfoFlags { + deUint32 IrapPicFlag : 1; + deUint32 IdrPicFlag : 1; + deUint32 IsReference : 1; + deUint32 short_term_ref_pic_set_sps_flag : 1; +} StdVideoDecodeH265PictureInfoFlags; + +typedef struct StdVideoDecodeH265PictureInfo { + deUint8 vps_video_parameter_set_id; + deUint8 sps_seq_parameter_set_id; + deUint8 pps_pic_parameter_set_id; + deUint8 num_short_term_ref_pic_sets; + deInt32 PicOrderCntVal; + deUint16 NumBitsForSTRefPicSetInSlice; // number of bits used in st_ref_pic_set() + //when short_term_ref_pic_set_sps_flag is 0; otherwise set to 0. + deUint8 NumDeltaPocsOfRefRpsIdx; // NumDeltaPocs[ RefRpsIdx ] when short_term_ref_pic_set_sps_flag = 1, otherwise 0 + deUint8 RefPicSetStCurrBefore[8]; // slotIndex as used in VkVideoReferenceSlotKHR structures representing + //pReferenceSlots in VkVideoDecodeInfoKHR, 0xff for invalid slotIndex + deUint8 RefPicSetStCurrAfter[8]; // slotIndex as used in VkVideoReferenceSlotKHR structures representing + //pReferenceSlots in VkVideoDecodeInfoKHR, 0xff for invalid slotIndex + deUint8 RefPicSetLtCurr[8]; // slotIndex as used in VkVideoReferenceSlotKHR structures representing + //pReferenceSlots in VkVideoDecodeInfoKHR, 0xff for invalid slotIndex + StdVideoDecodeH265PictureInfoFlags flags; +} StdVideoDecodeH265PictureInfo; + +typedef struct StdVideoDecodeH265ReferenceInfoFlags { + deUint32 is_long_term : 1; + deUint32 is_non_existing : 1; +} StdVideoDecodeH265ReferenceInfoFlags; + +typedef struct StdVideoDecodeH265ReferenceInfo { + deInt32 PicOrderCntVal; + StdVideoDecodeH265ReferenceInfoFlags flags; +} StdVideoDecodeH265ReferenceInfo; + +#ifdef __cplusplus +} +#endif + +#endif // VULKAN_VIDEO_CODEC_H265STD_DECODE_H_ #ifndef VULKAN_CORE_H_ #define VULKAN_CORE_H_ 1 diff --git a/external/vulkancts/scripts/gen_framework.py b/external/vulkancts/scripts/gen_framework.py index 69fe1d9..5b56bd9 100755 --- a/external/vulkancts/scripts/gen_framework.py +++ b/external/vulkancts/scripts/gen_framework.py @@ -155,6 +155,8 @@ def prefixName (prefix, name): name = name.replace("VULKAN_12_PROPERTIES", "VULKAN_1_2_PROPERTIES") name = name.replace("INT_8_", "INT8_") name = name.replace("AABBNV", "AABB_NV") + name = name.replace("_H_264_", "_H264_") + name = name.replace("_H_265_", "_H265_") return prefix + name @@ -296,6 +298,9 @@ class Variable: def getAsString (self, separator): return '%s%s%s%s%s' % (self.getType(), separator, self.name, self.arraySize, self.fieldWidth) + def getAsStringForArgumentList (self, separator): + return '%s%s%s%s' % (self.getType(), separator, self.name, self.arraySize) + def __repr__ (self): return '<%s> <%s> <%s>' % (self.type, self.name, self.arraySize) @@ -474,9 +479,9 @@ def parseEnums (src): return enums def parseCompositeType (type, name, src): - typeNamePtrn = r'(' + TYPE_PTRN + r')(\s+' + IDENT_PTRN + r')((\[[^\]]+\]|:[0-9]+)*)\s*;' + typeNamePtrn = r'(' + TYPE_PTRN + r')(\s+' + IDENT_PTRN + r')((\[[^\]]+\]|\s*:\s*[0-9]+)*)\s*;' matches = re.findall(typeNamePtrn, src) - members = [Variable(t.strip(), n.strip(), a.strip()) for t, n, a, _ in matches] + members = [Variable(t.strip(), n.strip(), a.replace(' ', '')) for t, n, a, _ in matches] return CompositeType(type, name, members) def parseCompositeTypes (src): @@ -1018,7 +1023,7 @@ def writeCompositeTypes (api, filename): writeInlFile(filename, INL_HEADER, gen()) def argListToStr (args): - return ", ".join(v.getAsString(' ') for v in args) + return ", ".join(v.getAsStringForArgumentList(' ') for v in args) def writeInterfaceDecl (api, filename, functionTypes, concrete): def genProtos (): @@ -1176,9 +1181,10 @@ def writeStrUtilImpl (api, filename): elif member.getType() == PLATFORM_TYPE_NAMESPACE + "::Win32LPCWSTR": valFmt = "getWStr(value.%s)" % member.name elif member.arraySize != '': + singleDimensional = not '][' in member.arraySize if member.name in ["extensionName", "deviceName", "layerName", "description"]: valFmt = "(const char*)value.%s" % member.name - elif member.getType() == 'char' or member.getType() == 'deUint8': + elif singleDimensional and (member.getType() == 'char' or member.getType() == 'deUint8'): newLine = "'\\n' << " valFmt = "tcu::formatArray(tcu::Format::HexIterator<%s>(DE_ARRAY_BEGIN(value.%s)), tcu::Format::HexIterator<%s>(DE_ARRAY_END(value.%s)))" % (member.getType(), member.name, member.getType(), member.name) else: @@ -1455,6 +1461,23 @@ def writeTypeUtil (api, filename): "VkQueueFamilyProperties", "VkMemoryType", "VkMemoryHeap", + "StdVideoH264SpsVuiFlags", + "StdVideoH264SpsFlags", + "StdVideoH264PpsFlags", + "StdVideoDecodeH264PictureInfoFlags", + "StdVideoDecodeH264ReferenceInfoFlags", + "StdVideoDecodeH264MvcElementFlags", + "StdVideoEncodeH264SliceHeaderFlags", + "StdVideoEncodeH264PictureInfoFlags", + "StdVideoEncodeH264RefMgmtFlags", + "StdVideoH265HrdFlags", + "StdVideoH265VpsFlags", + "StdVideoH265SpsVuiFlags", + "StdVideoH265SpsFlags", + "StdVideoH265PpsFlags", + "StdVideoDecodeH265PictureInfoFlags", + "StdVideoDecodeH265ReferenceInfoFlags", + "StdVideoEncodeH265PictureInfoFlags" ]) COMPOSITE_TYPES = set([t.name for t in api.compositeTypes if not t.isAlias]) @@ -1482,8 +1505,10 @@ def writeTypeUtil (api, filename): if not isSimpleStruct(type) or type.isAlias: continue + name = type.name[2:] if type.name[:2].lower() == "vk" else type.name + yield "" - yield "inline %s make%s (%s)" % (type.name, type.name[2:], argListToStr(type.members)) + yield "inline %s make%s (%s)" % (type.name, name, argListToStr(type.members)) yield "{" yield "\t%s res;" % type.name for line in indentLines(["\tres.%s\t= %s;" % (m.name, m.name) for m in type.members]): @@ -2338,16 +2363,36 @@ def writeExtensionList(filename, patternPart): stream.append('};\n') writeInlFile(filename, INL_HEADER, stream) +def preprocessTopInclude(src, dir): + pattern = r'#include\s+"([^\n]+)"' + while True: + inc = re.search(pattern, src) + if inc is None: + return src + incFileName = inc.string[inc.start(1):inc.end(1)] + patternIncNamed = r'#include\s+"' + incFileName + '"' + incBody = readFile(os.path.join(dir, incFileName)) if incFileName != 'vk_platform.h' else '' + incBodySanitized = re.sub(pattern, '', incBody) + bodyEndSanitized = re.sub(patternIncNamed, '', src[inc.end(0):]) + src = src[0:inc.start(0)] + incBodySanitized + bodyEndSanitized + return src + if __name__ == "__main__": # Read all .h files, with vulkan_core.h first files = os.listdir(VULKAN_H_DIR) files = [f for f in files if f.endswith(".h")] files.sort() files.remove("vulkan_core.h") - files.insert(0, "vulkan_core.h") + first = ["vk_video/vulkan_video_codecs_common.h", "vulkan_core.h"] + files = first + files + src = "" for file in files: - src += readFile(os.path.join(VULKAN_H_DIR,file)) + src += preprocessTopInclude(readFile(os.path.join(VULKAN_H_DIR,file)), VULKAN_H_DIR) + + src = re.sub('\s*//[^\n]*', '', src) + src = re.sub('\n\n', '\n', src) + api = parseAPI(src) platformFuncs = [Function.TYPE_PLATFORM] diff --git a/external/vulkancts/scripts/gen_framework_c.py b/external/vulkancts/scripts/gen_framework_c.py index 630f5dd..8e12e27 100644 --- a/external/vulkancts/scripts/gen_framework_c.py +++ b/external/vulkancts/scripts/gen_framework_c.py @@ -22,14 +22,23 @@ import os import sys - +import re sys.path.append(os.path.join(os.path.dirname(__file__), "..", "..", "..", "scripts")) from build.common import DEQP_DIR from khr_util.format import writeInlFile -VULKAN_H = os.path.join(os.path.dirname(__file__), "src", "vulkan_core.h") +VULKAN_H = [ + os.path.join(os.path.dirname(__file__), "src", "vk_video", "vulkan_video_codecs_common.h"), + os.path.join(os.path.dirname(__file__), "src", "vk_video", "vulkan_video_codec_h264std.h"), + os.path.join(os.path.dirname(__file__), "src", "vk_video", "vulkan_video_codec_h264std_encode.h"), + os.path.join(os.path.dirname(__file__), "src", "vk_video", "vulkan_video_codec_h265std.h"), + os.path.join(os.path.dirname(__file__), "src", "vk_video", "vulkan_video_codec_h264std_decode.h"), + os.path.join(os.path.dirname(__file__), "src", "vk_video", "vulkan_video_codec_h265std_decode.h"), + os.path.join(os.path.dirname(__file__), "src", "vulkan_core.h"), + ] +#VULKAN_H = os.path.join(os.path.dirname(__file__), "src", "vulkan_core.h") VULKAN_DIR = os.path.join(os.path.dirname(__file__), "..", "framework", "vulkan") INL_HEADER = """\ @@ -57,7 +66,7 @@ def readFile (filename): def writeVulkanCHeader (src, filename): def gen (): - dst = src.replace('#include "vk_platform.h"','') + dst = re.sub(r'(#include "[^\s,\n}]+")', '', src) # Amber is compiled using C++11 but under MSVC __cplusplus macro # is incorrectly recognized and this triggers invalid definition @@ -69,5 +78,8 @@ def writeVulkanCHeader (src, filename): writeInlFile(filename, INL_HEADER, gen()) if __name__ == "__main__": - src = readFile(VULKAN_H) + src = "" + for file in VULKAN_H: + src += readFile(file) + writeVulkanCHeader (src, os.path.join(VULKAN_DIR, "vkVulkan_c.inl")) diff --git a/external/vulkancts/scripts/src/vk_video/vulkan_video_codec_h264std.h b/external/vulkancts/scripts/src/vk_video/vulkan_video_codec_h264std.h new file mode 100644 index 0000000..f8c0cef --- /dev/null +++ b/external/vulkancts/scripts/src/vk_video/vulkan_video_codec_h264std.h @@ -0,0 +1,299 @@ +/* +** Copyright (c) 2019-2021 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +#ifndef VULKAN_VIDEO_CODEC_H264STD_H_ +#define VULKAN_VIDEO_CODEC_H264STD_H_ 1 + +#ifdef __cplusplus +extern "C" { +#endif + +#include "vk_video/vulkan_video_codecs_common.h" + +// Vulkan 0.9 provisional Vulkan video H.264 encode and decode std specification version number +#define VK_STD_VULKAN_VIDEO_CODEC_H264_API_VERSION_0_9 VK_MAKE_VIDEO_STD_VERSION(0, 9, 0) // Patch version should always be set to 0 + +// Format must be in the form XX.XX where the first two digits are the major and the second two, the minor. +#define VK_STD_VULKAN_VIDEO_CODEC_H264_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H264_API_VERSION_0_9 +#define VK_STD_VULKAN_VIDEO_CODEC_H264_EXTENSION_NAME "VK_STD_vulkan_video_codec_h264" + +// ************************************************* +// Video H.264 common definitions: +// ************************************************* + +typedef enum StdVideoH264ChromaFormatIdc { + std_video_h264_chroma_format_idc_monochrome = 0, + std_video_h264_chroma_format_idc_420 = 1, + std_video_h264_chroma_format_idc_422 = 2, + std_video_h264_chroma_format_idc_444 = 3, +} StdVideoH264ChromaFormatIdc; + +typedef enum StdVideoH264ProfileIdc { + std_video_h264_profile_idc_baseline = 66, /* Only constrained baseline is supported */ + std_video_h264_profile_idc_main = 77, + std_video_h264_profile_idc_high = 100, + std_video_h264_profile_idc_high_444_predictive = 244, + std_video_h264_profile_idc_invalid = 0x7FFFFFFF +} StdVideoH264ProfileIdc; + +typedef enum StdVideoH264Level { + std_video_h264_level_1_0 = 0, + std_video_h264_level_1_1 = 1, + std_video_h264_level_1_2 = 2, + std_video_h264_level_1_3 = 3, + std_video_h264_level_2_0 = 4, + std_video_h264_level_2_1 = 5, + std_video_h264_level_2_2 = 6, + std_video_h264_level_3_0 = 7, + std_video_h264_level_3_1 = 8, + std_video_h264_level_3_2 = 9, + std_video_h264_level_4_0 = 10, + std_video_h264_level_4_1 = 11, + std_video_h264_level_4_2 = 12, + std_video_h264_level_5_0 = 13, + std_video_h264_level_5_1 = 14, + std_video_h264_level_5_2 = 15, + std_video_h264_level_6_0 = 16, + std_video_h264_level_6_1 = 17, + std_video_h264_level_6_2 = 18, + std_video_h264_level_invalid = 0x7FFFFFFF +} StdVideoH264Level; + +typedef enum StdVideoH264PocType { + std_video_h264_poc_type_0 = 0, + std_video_h264_poc_type_1 = 1, + std_video_h264_poc_type_2 = 2, + std_video_h264_poc_type_invalid = 0x7FFFFFFF +} StdVideoH264PocType; + +typedef enum StdVideoH264AspectRatioIdc { + std_video_h264_aspect_ratio_idc_unspecified = 0, + std_video_h264_aspect_ratio_idc_square = 1, + std_video_h264_aspect_ratio_idc_12_11 = 2, + std_video_h264_aspect_ratio_idc_10_11 = 3, + std_video_h264_aspect_ratio_idc_16_11 = 4, + std_video_h264_aspect_ratio_idc_40_33 = 5, + std_video_h264_aspect_ratio_idc_24_11 = 6, + std_video_h264_aspect_ratio_idc_20_11 = 7, + std_video_h264_aspect_ratio_idc_32_11 = 8, + std_video_h264_aspect_ratio_idc_80_33 = 9, + std_video_h264_aspect_ratio_idc_18_11 = 10, + std_video_h264_aspect_ratio_idc_15_11 = 11, + std_video_h264_aspect_ratio_idc_64_33 = 12, + std_video_h264_aspect_ratio_idc_160_99 = 13, + std_video_h264_aspect_ratio_idc_4_3 = 14, + std_video_h264_aspect_ratio_idc_3_2 = 15, + std_video_h264_aspect_ratio_idc_2_1 = 16, + std_video_h264_aspect_ratio_idc_extended_sar = 255, + std_video_h264_aspect_ratio_idc_invalid = 0x7FFFFFFF +} StdVideoH264AspectRatioIdc; + +typedef enum StdVideoH264WeightedBiPredIdc { + std_video_h264_default_weighted_b_slices_prediction_idc = 0, + std_video_h264_explicit_weighted_b_slices_prediction_idc = 1, + std_video_h264_implicit_weighted_b_slices_prediction_idc = 2, + std_video_h264_invalid_weighted_b_slices_prediction_idc = 0x7FFFFFFF +} StdVideoH264WeightedBiPredIdc; + +typedef enum StdVideoH264ModificationOfPicNumsIdc { + std_video_h264_modification_of_pic_nums_idc_short_term_subtract = 0, + std_video_h264_modification_of_pic_nums_idc_short_term_add = 1, + std_video_h264_modification_of_pic_nums_idc_long_term = 2, + std_video_h264_modification_of_pic_nums_idc_end = 3, + std_video_h264_modification_of_pic_nums_idc_invalid = 0x7FFFFFFF +} StdVideoH264ModificationOfPicNumsIdc; + +typedef enum StdVideoH264MemMgmtControlOp { + std_video_h264_mem_mgmt_control_op_end = 0, + std_video_h264_mem_mgmt_control_op_unmark_short_term = 1, + std_video_h264_mem_mgmt_control_op_unmark_long_term = 2, + std_video_h264_mem_mgmt_control_op_mark_long_term = 3, + std_video_h264_mem_mgmt_control_op_set_max_long_term_index = 4, + std_video_h264_mem_mgmt_control_op_unmark_all = 5, + std_video_h264_mem_mgmt_control_op_mark_current_as_long_term = 6, + std_video_h264_mem_mgmt_control_op_invalid = 0x7FFFFFFF +} StdVideoH264MemMgmtControlOp; + +typedef enum StdVideoH264CabacInitIdc { + std_video_h264_cabac_init_idc_0 = 0, + std_video_h264_cabac_init_idc_1 = 1, + std_video_h264_cabac_init_idc_2 = 2, + std_video_h264_cabac_init_idc_invalid = 0x7FFFFFFF +} StdVideoH264CabacInitIdc; + +typedef enum StdVideoH264DisableDeblockingFilterIdc { + std_video_h264_disable_deblocking_filter_idc_disabled = 0, + std_video_h264_disable_deblocking_filter_idc_enabled = 1, + std_video_h264_disable_deblocking_filter_idc_partial = 2, + std_video_h264_disable_deblocking_filter_idc_invalid = 0x7FFFFFFF +} StdVideoH264DisableDeblockingFilterIdc; + +typedef enum StdVideoH264PictureType { + std_video_h264_picture_type_i = 0, + std_video_h264_picture_type_p = 1, + std_video_h264_picture_type_b = 2, + std_video_h264_picture_type_invalid = 0x7FFFFFFF +} StdVideoH264PictureType; + +typedef enum StdVideoH264SliceType { + std_video_h264_slice_type_i = 0, + std_video_h264_slice_type_p = 1, + std_video_h264_slice_type_b = 2, + std_video_h264_slice_type_invalid = 0x7FFFFFFF +} StdVideoH264SliceType; + +typedef enum StdVideoH264NonVclNaluType { + std_video_h264_non_vcl_nalu_type_sps = 0, + std_video_h264_non_vcl_nalu_type_pps = 1, + std_video_h264_non_vcl_nalu_type_aud = 2, + std_video_h264_non_vcl_nalu_type_prefix = 3, + std_video_h264_non_vcl_nalu_type_end_of_sequence = 4, + std_video_h264_non_vcl_nalu_type_end_of_stream = 5, + std_video_h264_non_vcl_nalu_type_precoded = 6, + std_video_h264_non_vcl_nalu_type_invalid = 0x7FFFFFFF +} StdVideoH264NonVclNaluType; + +typedef struct StdVideoH264SpsVuiFlags { + uint32_t aspect_ratio_info_present_flag:1; + uint32_t overscan_info_present_flag:1; + uint32_t overscan_appropriate_flag:1; + uint32_t video_signal_type_present_flag:1; + uint32_t video_full_range_flag:1; + uint32_t color_description_present_flag:1; + uint32_t chroma_loc_info_present_flag:1; + uint32_t timing_info_present_flag:1; + uint32_t fixed_frame_rate_flag:1; + uint32_t bitstream_restriction_flag:1; + uint32_t nal_hrd_parameters_present_flag:1; + uint32_t vcl_hrd_parameters_present_flag:1; +} StdVideoH264SpsVuiFlags; + +typedef struct StdVideoH264HrdParameters { + uint8_t cpb_cnt_minus1; + uint8_t bit_rate_scale; + uint8_t cpb_size_scale; + uint32_t bit_rate_value_minus1[32]; + uint32_t cpb_size_value_minus1[32]; + uint8_t cbr_flag[32]; + uint32_t initial_cpb_removal_delay_length_minus1; + uint32_t cpb_removal_delay_length_minus1; + uint32_t dpb_output_delay_length_minus1; + uint32_t time_offset_length; +} StdVideoH264HrdParameters; + +typedef struct StdVideoH264SequenceParameterSetVui { + StdVideoH264AspectRatioIdc aspect_ratio_idc; + uint16_t sar_width; + uint16_t sar_height; + uint8_t video_format; + uint8_t color_primaries; + uint8_t transfer_characteristics; + uint8_t matrix_coefficients; + uint32_t num_units_in_tick; + uint32_t time_scale; + StdVideoH264HrdParameters hrd_parameters; + uint8_t num_reorder_frames; + uint8_t max_dec_frame_buffering; + StdVideoH264SpsVuiFlags flags; +} StdVideoH264SequenceParameterSetVui; + +typedef struct StdVideoH264SpsFlags { + uint32_t constraint_set0_flag:1; + uint32_t constraint_set1_flag:1; + uint32_t constraint_set2_flag:1; + uint32_t constraint_set3_flag:1; + uint32_t constraint_set4_flag:1; + uint32_t constraint_set5_flag:1; + uint32_t direct_8x8_inference_flag:1; + uint32_t mb_adaptive_frame_field_flag:1; + uint32_t frame_mbs_only_flag:1; + uint32_t delta_pic_order_always_zero_flag:1; + uint32_t residual_colour_transform_flag:1; + uint32_t gaps_in_frame_num_value_allowed_flag:1; + uint32_t first_picture_after_seek_flag:1; // where is this being documented? + uint32_t qpprime_y_zero_transform_bypass_flag:1; + uint32_t frame_cropping_flag:1; + uint32_t scaling_matrix_present_flag:1; + uint32_t vui_parameters_present_flag:1; +} StdVideoH264SpsFlags; + +typedef struct StdVideoH264ScalingLists +{ + // scaling_list_present_mask has one bit for each + // seq_scaling_list_present_flag[i] for SPS OR + // pic_scaling_list_present_flag[i] for PPS, + // bit 0 - 5 are for each entry of ScalingList4x4 + // bit 6 - 7 are for each entry plus 6 for ScalingList8x8 + uint8_t scaling_list_present_mask; + // use_default_scaling_matrix_mask has one bit for each + // UseDefaultScalingMatrix4x4Flag[ i ] and + // UseDefaultScalingMatrix8x8Flag[ i - 6 ] for SPS OR PPS + // bit 0 - 5 are for each entry of ScalingList4x4 + // bit 6 - 7 are for each entry plus 6 for ScalingList8x8 + uint8_t use_default_scaling_matrix_mask; + uint8_t ScalingList4x4[6][16]; + uint8_t ScalingList8x8[2][64]; +} StdVideoH264ScalingLists; + +typedef struct StdVideoH264SequenceParameterSet +{ + StdVideoH264ProfileIdc profile_idc; + StdVideoH264Level level_idc; + uint8_t seq_parameter_set_id; + StdVideoH264ChromaFormatIdc chroma_format_idc; + uint8_t bit_depth_luma_minus8; + uint8_t bit_depth_chroma_minus8; + uint8_t log2_max_frame_num_minus4; + StdVideoH264PocType pic_order_cnt_type; + uint8_t log2_max_pic_order_cnt_lsb_minus4; + int32_t offset_for_non_ref_pic; + int32_t offset_for_top_to_bottom_field; + uint8_t num_ref_frames_in_pic_order_cnt_cycle; + uint8_t max_num_ref_frames; + uint32_t pic_width_in_mbs_minus1; + uint32_t pic_height_in_map_units_minus1; + uint32_t frame_crop_left_offset; + uint32_t frame_crop_right_offset; + uint32_t frame_crop_top_offset; + uint32_t frame_crop_bottom_offset; + StdVideoH264SpsFlags flags; + int32_t offset_for_ref_frame[255]; // The number of valid values are defined by the num_ref_frames_in_pic_order_cnt_cycle + StdVideoH264ScalingLists* pScalingLists; // Must be a valid pointer if scaling_matrix_present_flag is set + StdVideoH264SequenceParameterSetVui* pSequenceParameterSetVui; // Must be a valid pointer if StdVideoH264SpsFlags:vui_parameters_present_flag is set +} StdVideoH264SequenceParameterSet; + +typedef struct StdVideoH264PpsFlags { + uint32_t transform_8x8_mode_flag:1; + uint32_t redundant_pic_cnt_present_flag:1; + uint32_t constrained_intra_pred_flag:1; + uint32_t deblocking_filter_control_present_flag:1; + uint32_t weighted_bipred_idc_flag:1; + uint32_t weighted_pred_flag:1; + uint32_t pic_order_present_flag:1; + uint32_t entropy_coding_mode_flag:1; + uint32_t scaling_matrix_present_flag:1; +} StdVideoH264PpsFlags; + +typedef struct StdVideoH264PictureParameterSet +{ + uint8_t seq_parameter_set_id; + uint8_t pic_parameter_set_id; + uint8_t num_ref_idx_l0_default_active_minus1; + uint8_t num_ref_idx_l1_default_active_minus1; + StdVideoH264WeightedBiPredIdc weighted_bipred_idc; + int8_t pic_init_qp_minus26; + int8_t pic_init_qs_minus26; + int8_t chroma_qp_index_offset; + int8_t second_chroma_qp_index_offset; + StdVideoH264PpsFlags flags; + StdVideoH264ScalingLists* pScalingLists; // Must be a valid pointer if StdVideoH264PpsFlags::scaling_matrix_present_flag is set. +} StdVideoH264PictureParameterSet; + +#ifdef __cplusplus +} +#endif + +#endif // VULKAN_VIDEO_CODEC_H264STD_H_ diff --git a/external/vulkancts/scripts/src/vk_video/vulkan_video_codec_h264std_decode.h b/external/vulkancts/scripts/src/vk_video/vulkan_video_codec_h264std_decode.h new file mode 100644 index 0000000..2b4fc64 --- /dev/null +++ b/external/vulkancts/scripts/src/vk_video/vulkan_video_codec_h264std_decode.h @@ -0,0 +1,87 @@ +/* +** Copyright (c) 2019-2020 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +#ifndef VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ +#define VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ 1 + +#ifdef __cplusplus +extern "C" { +#endif + +#include "vk_video/vulkan_video_codec_h264std.h" + +// ************************************************* +// Video H.264 Decode related parameters: +// ************************************************* + +typedef struct StdVideoDecodeH264PictureInfoFlags { + uint32_t field_pic_flag:1; // Is field picture + uint32_t is_intra:1; // Is intra picture + uint32_t bottom_field_flag:1; // bottom (true) or top (false) field if field_pic_flag is set. + uint32_t is_reference:1; // This only applies to picture info, and not to the DPB lists. + uint32_t complementary_field_pair:1; // complementary field pair, complementary non-reference field pair, complementary reference field pair +} StdVideoDecodeH264PictureInfoFlags; + +typedef struct StdVideoDecodeH264PictureInfo { + uint8_t seq_parameter_set_id; // Selecting SPS from the Picture Parameters + uint8_t pic_parameter_set_id; // Selecting PPS from the Picture Parameters and the SPS + uint16_t reserved; // for structure members 32-bit packing/alignment + uint16_t frame_num; // 7.4.3 Slice header semantics + uint16_t idr_pic_id; // 7.4.3 Slice header semantics + // PicOrderCnt is based on TopFieldOrderCnt and BottomFieldOrderCnt. See 8.2.1 Decoding process for picture order count type 0 - 2 + int32_t PicOrderCnt[2]; // TopFieldOrderCnt and BottomFieldOrderCnt fields. + StdVideoDecodeH264PictureInfoFlags flags; +} StdVideoDecodeH264PictureInfo; + +typedef struct StdVideoDecodeH264ReferenceInfoFlags { + uint32_t top_field_flag:1; // Reference is used for top field reference. + uint32_t bottom_field_flag:1; // Reference is used for bottom field reference. + uint32_t is_long_term:1; // this is a long term reference + uint32_t is_non_existing:1; // Must be handled in accordance with 8.2.5.2: Decoding process for gaps in frame_num +} StdVideoDecodeH264ReferenceInfoFlags; + +typedef struct StdVideoDecodeH264ReferenceInfo { + // FrameNum = is_long_term ? long_term_frame_idx : frame_num + uint16_t FrameNum; // 7.4.3.3 Decoded reference picture marking semantics + uint16_t reserved; // for structure members 32-bit packing/alignment + int32_t PicOrderCnt[2]; // TopFieldOrderCnt and BottomFieldOrderCnt fields. + StdVideoDecodeH264ReferenceInfoFlags flags; +} StdVideoDecodeH264ReferenceInfo; + +typedef struct StdVideoDecodeH264MvcElementFlags { + uint32_t non_idr:1; + uint32_t anchor_pic:1; + uint32_t inter_view:1; +} StdVideoDecodeH264MvcElementFlags; + +typedef struct StdVideoDecodeH264MvcElement { + StdVideoDecodeH264MvcElementFlags flags; + uint16_t viewOrderIndex; + uint16_t viewId; + uint16_t temporalId; // move out? + uint16_t priorityId; // move out? + uint16_t numOfAnchorRefsInL0; + uint16_t viewIdOfAnchorRefsInL0[15]; + uint16_t numOfAnchorRefsInL1; + uint16_t viewIdOfAnchorRefsInL1[15]; + uint16_t numOfNonAnchorRefsInL0; + uint16_t viewIdOfNonAnchorRefsInL0[15]; + uint16_t numOfNonAnchorRefsInL1; + uint16_t viewIdOfNonAnchorRefsInL1[15]; +} StdVideoDecodeH264MvcElement; + +typedef struct StdVideoDecodeH264Mvc { + uint32_t viewId0; + uint32_t mvcElementCount; + StdVideoDecodeH264MvcElement* pMvcElements; +} StdVideoDecodeH264Mvc; + + +#ifdef __cplusplus +} +#endif + +#endif // VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ diff --git a/external/vulkancts/scripts/src/vk_video/vulkan_video_codec_h264std_encode.h b/external/vulkancts/scripts/src/vk_video/vulkan_video_codec_h264std_encode.h new file mode 100644 index 0000000..7184562 --- /dev/null +++ b/external/vulkancts/scripts/src/vk_video/vulkan_video_codec_h264std_encode.h @@ -0,0 +1,94 @@ +/* +** Copyright (c) 2019-2021 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +#ifndef VULKAN_VIDEO_CODEC_H264STD_ENCODE_H_ +#define VULKAN_VIDEO_CODEC_H264STD_ENCODE_H_ 1 + +#ifdef __cplusplus +extern "C" { +#endif + +#include "vk_video/vulkan_video_codec_h264std.h" + +// ************************************************* +// Video H.264 Encode related parameters: +// ************************************************* + +typedef struct StdVideoEncodeH264SliceHeaderFlags { + uint32_t idr_flag:1; + uint32_t is_reference_flag:1; + uint32_t num_ref_idx_active_override_flag:1; + uint32_t no_output_of_prior_pics_flag:1; + uint32_t long_term_reference_flag:1; + uint32_t adaptive_ref_pic_marking_mode_flag:1; + uint32_t no_prior_references_available_flag:1; +} StdVideoEncodeH264SliceHeaderFlags; + +typedef struct StdVideoEncodeH264PictureInfoFlags { + uint32_t idr_flag:1; + uint32_t is_reference_flag:1; + uint32_t long_term_reference_flag:1; +} StdVideoEncodeH264PictureInfoFlags; + +typedef struct StdVideoEncodeH264RefMgmtFlags { + uint32_t ref_pic_list_modification_l0_flag:1; + uint32_t ref_pic_list_modification_l1_flag:1; +} StdVideoEncodeH264RefMgmtFlags; + +typedef struct StdVideoEncodeH264RefListModEntry { + StdVideoH264ModificationOfPicNumsIdc modification_of_pic_nums_idc; + uint16_t abs_diff_pic_num_minus1; + uint16_t long_term_pic_num; +} StdVideoEncodeH264RefListModEntry; + +typedef struct StdVideoEncodeH264RefPicMarkingEntry { + StdVideoH264MemMgmtControlOp operation; + uint16_t difference_of_pic_nums_minus1; + uint16_t long_term_pic_num; + uint16_t long_term_frame_idx; + uint16_t max_long_term_frame_idx_plus1; +} StdVideoEncodeH264RefPicMarkingEntry; + +typedef struct StdVideoEncodeH264RefMemMgmtCtrlOperations { + StdVideoEncodeH264RefMgmtFlags flags; + uint8_t refList0ModOpCount; + StdVideoEncodeH264RefListModEntry* pRefList0ModOperations; + uint8_t refList1ModOpCount; + StdVideoEncodeH264RefListModEntry* pRefList1ModOperations; + uint8_t refPicMarkingOpCount; + StdVideoEncodeH264RefPicMarkingEntry* pRefPicMarkingOperations; +} StdVideoEncodeH264RefMemMgmtCtrlOperations; + +typedef struct StdVideoEncodeH264PictureInfo { + StdVideoEncodeH264PictureInfoFlags flags; + StdVideoH264PictureType pictureType; + uint32_t frameNum; + uint32_t pictureOrderCount; + uint16_t long_term_pic_num; + uint16_t long_term_frame_idx; +} StdVideoEncodeH264PictureInfo; + +typedef struct StdVideoEncodeH264SliceHeader { + StdVideoEncodeH264SliceHeaderFlags flags; + StdVideoH264SliceType slice_type; + uint8_t seq_parameter_set_id; + uint8_t pic_parameter_set_id; + uint16_t idr_pic_id; + uint8_t num_ref_idx_l0_active_minus1; + uint8_t num_ref_idx_l1_active_minus1; + StdVideoH264CabacInitIdc cabac_init_idc; + StdVideoH264DisableDeblockingFilterIdc disable_deblocking_filter_idc; + int8_t slice_alpha_c0_offset_div2; + int8_t slice_beta_offset_div2; + StdVideoEncodeH264RefMemMgmtCtrlOperations* pMemMgmtCtrlOperations; +} StdVideoEncodeH264SliceHeader; + + +#ifdef __cplusplus +} +#endif + +#endif // VULKAN_VIDEO_CODEC_H264STD_ENCODE_H_ diff --git a/external/vulkancts/scripts/src/vk_video/vulkan_video_codec_h265std.h b/external/vulkancts/scripts/src/vk_video/vulkan_video_codec_h265std.h new file mode 100644 index 0000000..185b550 --- /dev/null +++ b/external/vulkancts/scripts/src/vk_video/vulkan_video_codec_h265std.h @@ -0,0 +1,341 @@ +/* +** Copyright (c) 2019-2021 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +#ifndef VULKAN_VIDEO_CODEC_H265STD_H_ +#define VULKAN_VIDEO_CODEC_H265STD_H_ 1 + +#ifdef __cplusplus +extern "C" { +#endif + +#include "vk_video/vulkan_video_codecs_common.h" + +// Vulkan 0.5 version number WIP +#define VK_STD_VULKAN_VIDEO_CODEC_H265_API_VERSION_0_5 VK_MAKE_VIDEO_STD_VERSION(0, 5, 0) // Patch version should always be set to 0 + +// Format must be in the form XX.XX where the first two digits are the major and the second two, the minor. +#define VK_STD_VULKAN_VIDEO_CODEC_H265_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H265_API_VERSION_0_5 +#define VK_STD_VULKAN_VIDEO_CODEC_H265_EXTENSION_NAME "VK_STD_vulkan_video_codec_h265" + +typedef enum StdVideoH265ChromaFormatIdc { + std_video_h265_chroma_format_idc_monochrome = 0, + std_video_h265_chroma_format_idc_420 = 1, + std_video_h265_chroma_format_idc_422 = 2, + std_video_h265_chroma_format_idc_444 = 3, +} StdVideoH265ChromaFormatIdc; + +typedef enum StdVideoH265ProfileIdc { + std_video_h265_profile_idc_main = 1, + std_video_h265_profile_idc_main_10 = 2, + std_video_h265_profile_idc_main_still_picture = 3, + std_video_h265_profile_idc_format_range_extensions = 4, + std_video_h265_profile_idc_scc_extensions = 9, + std_video_h265_profile_idc_invalid = 0x7FFFFFFF +} StdVideoH265ProfileIdc; + +typedef enum StdVideoH265Level { + std_video_h265_level_1_0 = 0, + std_video_h265_level_2_0 = 1, + std_video_h265_level_2_1 = 2, + std_video_h265_level_3_0 = 3, + std_video_h265_level_3_1 = 4, + std_video_h265_level_4_0 = 5, + std_video_h265_level_4_1 = 6, + std_video_h265_level_5_0 = 7, + std_video_h265_level_5_1 = 8, + std_video_h265_level_5_2 = 9, + std_video_h265_level_6_0 = 10, + std_video_h265_level_6_1 = 11, + std_video_h265_level_6_2 = 12, + std_video_h265_level_invalid = 0x7FFFFFFF +} StdVideoH265Level; + + +typedef struct StdVideoH265DecPicBufMgr +{ + uint32_t max_latency_increase_plus1[7]; + uint8_t max_dec_pic_buffering_minus1[7]; + uint8_t max_num_reorder_pics[7]; +} StdVideoH265DecPicBufMgr; + +typedef struct StdVideoH265SubLayerHrdParameters { + uint32_t bit_rate_value_minus1[32]; + uint32_t cpb_size_value_minus1[32]; + uint32_t cpb_size_du_value_minus1[32]; + uint32_t bit_rate_du_value_minus1[32]; + uint32_t cbr_flag; // each bit represents a range of CpbCounts (bit 0 - cpb_cnt_minus1) per sub-layer +} StdVideoH265SubLayerHrdParameters; + +typedef struct StdVideoH265HrdFlags { + uint32_t nal_hrd_parameters_present_flag : 1; + uint32_t vcl_hrd_parameters_present_flag : 1; + uint32_t sub_pic_hrd_params_present_flag : 1; + uint32_t sub_pic_cpb_params_in_pic_timing_sei_flag : 1; + uint8_t fixed_pic_rate_general_flag; // each bit represents a sublayer, bit 0 - vps_max_sub_layers_minus1 + uint8_t fixed_pic_rate_within_cvs_flag; // each bit represents a sublayer, bit 0 - vps_max_sub_layers_minus1 + uint8_t low_delay_hrd_flag; // each bit represents a sublayer, bit 0 - vps_max_sub_layers_minus1 +} StdVideoH265HrdFlags; + +typedef struct StdVideoH265HrdParameters { + uint8_t tick_divisor_minus2; + uint8_t du_cpb_removal_delay_increment_length_minus1; + uint8_t dpb_output_delay_du_length_minus1; + uint8_t bit_rate_scale; + uint8_t cpb_size_scale; + uint8_t cpb_size_du_scale; + uint8_t initial_cpb_removal_delay_length_minus1; + uint8_t au_cpb_removal_delay_length_minus1; + uint8_t dpb_output_delay_length_minus1; + uint8_t cpb_cnt_minus1[7]; + uint16_t elemental_duration_in_tc_minus1[7]; + StdVideoH265SubLayerHrdParameters* SubLayerHrdParametersNal[7]; + StdVideoH265SubLayerHrdParameters* SubLayerHrdParametersVcl[7]; + StdVideoH265HrdFlags flags; +} StdVideoH265HrdParameters; + +typedef struct StdVideoH265VpsFlags { + uint32_t vps_temporal_id_nesting_flag : 1; + uint32_t vps_sub_layer_ordering_info_present_flag : 1; + uint32_t vps_timing_info_present_flag : 1; + uint32_t vps_poc_proportional_to_timing_flag : 1; +} StdVideoH265VpsFlags; + +typedef struct StdVideoH265VideoParameterSet +{ + uint8_t vps_video_parameter_set_id; + uint8_t vps_max_sub_layers_minus1; + uint32_t vps_num_units_in_tick; + uint32_t vps_time_scale; + uint32_t vps_num_ticks_poc_diff_one_minus1; + StdVideoH265DecPicBufMgr* pDecPicBufMgr; + StdVideoH265HrdParameters* hrd_parameters; + StdVideoH265VpsFlags flags; +} StdVideoH265VideoParameterSet; + +typedef struct StdVideoH265ScalingLists +{ + uint8_t ScalingList4x4[6][16]; // ScalingList[ 0 ][ MatrixID ][ i ] (sizeID = 0) + uint8_t ScalingList8x8[6][64]; // ScalingList[ 1 ][ MatrixID ][ i ] (sizeID = 1) + uint8_t ScalingList16x16[6][64]; // ScalingList[ 2 ][ MatrixID ][ i ] (sizeID = 2) + uint8_t ScalingList32x32[2][64]; // ScalingList[ 3 ][ MatrixID ][ i ] (sizeID = 3) + uint8_t ScalingListDCCoef16x16[6]; // scaling_list_dc_coef_minus8[ sizeID - 2 ][ matrixID ] + 8, sizeID = 2 + uint8_t ScalingListDCCoef32x32[2]; // scaling_list_dc_coef_minus8[ sizeID - 2 ][ matrixID ] + 8. sizeID = 3 +} StdVideoH265ScalingLists; + +typedef struct StdVideoH265SpsVuiFlags { + uint32_t aspect_ratio_info_present_flag : 1; + uint32_t overscan_info_present_flag : 1; + uint32_t overscan_appropriate_flag : 1; + uint32_t video_signal_type_present_flag : 1; + uint32_t video_full_range_flag : 1; + uint32_t colour_description_present_flag : 1; + uint32_t chroma_loc_info_present_flag : 1; + uint32_t neutral_chroma_indication_flag : 1; + uint32_t field_seq_flag : 1; + uint32_t frame_field_info_present_flag : 1; + uint32_t default_display_window_flag : 1; + uint32_t vui_timing_info_present_flag : 1; + uint32_t vui_poc_proportional_to_timing_flag : 1; + uint32_t vui_hrd_parameters_present_flag : 1; + uint32_t bitstream_restriction_flag : 1; + uint32_t tiles_fixed_structure_flag : 1; + uint32_t motion_vectors_over_pic_boundaries_flag : 1; + uint32_t restricted_ref_pic_lists_flag : 1; +} StdVideoH265SpsVuiFlags; + +typedef struct StdVideoH265SequenceParameterSetVui { + uint8_t aspect_ratio_idc; + uint16_t sar_width; + uint16_t sar_height; + uint8_t video_format; + uint8_t colour_primaries; + uint8_t transfer_characteristics; + uint8_t matrix_coeffs; + uint8_t chroma_sample_loc_type_top_field; + uint8_t chroma_sample_loc_type_bottom_field; + uint16_t def_disp_win_left_offset; + uint16_t def_disp_win_right_offset; + uint16_t def_disp_win_top_offset; + uint16_t def_disp_win_bottom_offset; + uint32_t vui_num_units_in_tick; + uint32_t vui_time_scale; + uint32_t vui_num_ticks_poc_diff_one_minus1; + StdVideoH265HrdParameters* hrd_parameters; + uint16_t min_spatial_segmentation_idc; + uint8_t max_bytes_per_pic_denom; + uint8_t max_bits_per_min_cu_denom; + uint8_t log2_max_mv_length_horizontal; + uint8_t log2_max_mv_length_vertical; + StdVideoH265SpsVuiFlags flags; +} StdVideoH265SequenceParameterSetVui; + +typedef struct StdVideoH265PredictorPaletteEntries +{ + uint16_t PredictorPaletteEntries[3][128]; +} StdVideoH265PredictorPaletteEntries; + + +typedef struct StdVideoH265SpsFlags { + uint32_t sps_temporal_id_nesting_flag : 1; + uint32_t separate_colour_plane_flag : 1; + uint32_t scaling_list_enabled_flag : 1; + uint32_t sps_scaling_list_data_present_flag : 1; + uint32_t amp_enabled_flag : 1; + uint32_t sample_adaptive_offset_enabled_flag : 1; + uint32_t pcm_enabled_flag : 1; + uint32_t pcm_loop_filter_disabled_flag : 1; + uint32_t long_term_ref_pics_present_flag : 1; + uint32_t sps_temporal_mvp_enabled_flag : 1; + uint32_t strong_intra_smoothing_enabled_flag : 1; + uint32_t vui_parameters_present_flag : 1; + uint32_t sps_extension_present_flag : 1; + uint32_t sps_range_extension_flag : 1; + + // extension SPS flags, valid when std_video_h265_profile_idc_format_range_extensions is set + uint32_t transform_skip_rotation_enabled_flag : 1; + uint32_t transform_skip_context_enabled_flag : 1; + uint32_t implicit_rdpcm_enabled_flag : 1; + uint32_t explicit_rdpcm_enabled_flag : 1; + uint32_t extended_precision_processing_flag : 1; + uint32_t intra_smoothing_disabled_flag : 1; + uint32_t high_precision_offsets_enabled_flag : 1; + uint32_t persistent_rice_adaptation_enabled_flag : 1; + uint32_t cabac_bypass_alignment_enabled_flag : 1; + + // extension SPS flags, valid when std_video_h265_profile_idc_scc_extensions is set + uint32_t sps_curr_pic_ref_enabled_flag : 1; + uint32_t palette_mode_enabled_flag : 1; + uint32_t sps_palette_predictor_initializer_present_flag : 1; + uint32_t intra_boundary_filtering_disabled_flag : 1; +} StdVideoH265SpsFlags; + +typedef struct StdVideoH265SequenceParameterSet +{ + StdVideoH265ProfileIdc profile_idc; + StdVideoH265Level level_idc; + uint32_t pic_width_in_luma_samples; + uint32_t pic_height_in_luma_samples; + uint8_t sps_video_parameter_set_id; + uint8_t sps_max_sub_layers_minus1; + uint8_t sps_seq_parameter_set_id; + uint8_t chroma_format_idc; + uint8_t bit_depth_luma_minus8; + uint8_t bit_depth_chroma_minus8; + uint8_t log2_max_pic_order_cnt_lsb_minus4; + uint8_t sps_max_dec_pic_buffering_minus1; + uint8_t log2_min_luma_coding_block_size_minus3; + uint8_t log2_diff_max_min_luma_coding_block_size; + uint8_t log2_min_luma_transform_block_size_minus2; + uint8_t log2_diff_max_min_luma_transform_block_size; + uint8_t max_transform_hierarchy_depth_inter; + uint8_t max_transform_hierarchy_depth_intra; + uint8_t num_short_term_ref_pic_sets; + uint8_t num_long_term_ref_pics_sps; + uint8_t pcm_sample_bit_depth_luma_minus1; + uint8_t pcm_sample_bit_depth_chroma_minus1; + uint8_t log2_min_pcm_luma_coding_block_size_minus3; + uint8_t log2_diff_max_min_pcm_luma_coding_block_size; + uint32_t conf_win_left_offset; + uint32_t conf_win_right_offset; + uint32_t conf_win_top_offset; + uint32_t conf_win_bottom_offset; + StdVideoH265DecPicBufMgr* pDecPicBufMgr; + StdVideoH265SpsFlags flags; + StdVideoH265ScalingLists* pScalingLists; // Must be a valid pointer if sps_scaling_list_data_present_flag is set + StdVideoH265SequenceParameterSetVui* pSequenceParameterSetVui; // Must be a valid pointer if StdVideoH265SpsFlags:vui_parameters_present_flag is set palette_max_size; + + // extension SPS flags, valid when std_video_h265_profile_idc_scc_extensions is set + uint8_t palette_max_size; + uint8_t delta_palette_max_predictor_size; + uint8_t motion_vector_resolution_control_idc; + uint8_t sps_num_palette_predictor_initializer_minus1; + StdVideoH265PredictorPaletteEntries* pPredictorPaletteEntries; // Must be a valid pointer if sps_palette_predictor_initializer_present_flag is set +} StdVideoH265SequenceParameterSet; + + +typedef struct StdVideoH265PpsFlags { + uint32_t dependent_slice_segments_enabled_flag : 1; + uint32_t output_flag_present_flag : 1; + uint32_t sign_data_hiding_enabled_flag : 1; + uint32_t cabac_init_present_flag : 1; + uint32_t constrained_intra_pred_flag : 1; + uint32_t transform_skip_enabled_flag : 1; + uint32_t cu_qp_delta_enabled_flag : 1; + uint32_t pps_slice_chroma_qp_offsets_present_flag : 1; + uint32_t weighted_pred_flag : 1; + uint32_t weighted_bipred_flag : 1; + uint32_t transquant_bypass_enabled_flag : 1; + uint32_t tiles_enabled_flag : 1; + uint32_t entropy_coding_sync_enabled_flag : 1; + uint32_t uniform_spacing_flag : 1; + uint32_t loop_filter_across_tiles_enabled_flag : 1; + uint32_t pps_loop_filter_across_slices_enabled_flag : 1; + uint32_t deblocking_filter_control_present_flag : 1; + uint32_t deblocking_filter_override_enabled_flag : 1; + uint32_t pps_deblocking_filter_disabled_flag : 1; + uint32_t pps_scaling_list_data_present_flag : 1; + uint32_t lists_modification_present_flag : 1; + uint32_t slice_segment_header_extension_present_flag : 1; + uint32_t pps_extension_present_flag : 1; + + // extension PPS flags, valid when std_video_h265_profile_idc_format_range_extensions is set + uint32_t cross_component_prediction_enabled_flag : 1; + uint32_t chroma_qp_offset_list_enabled_flag : 1; + + // extension PPS flags, valid when std_video_h265_profile_idc_scc_extensions is set + uint32_t pps_curr_pic_ref_enabled_flag : 1; + uint32_t residual_adaptive_colour_transform_enabled_flag : 1; + uint32_t pps_slice_act_qp_offsets_present_flag : 1; + uint32_t pps_palette_predictor_initializer_present_flag : 1; + uint32_t monochrome_palette_flag : 1; + uint32_t pps_range_extension_flag : 1; +} StdVideoH265PpsFlags; + +typedef struct StdVideoH265PictureParameterSet +{ + uint8_t pps_pic_parameter_set_id; + uint8_t pps_seq_parameter_set_id; + uint8_t num_extra_slice_header_bits; + uint8_t num_ref_idx_l0_default_active_minus1; + uint8_t num_ref_idx_l1_default_active_minus1; + int8_t init_qp_minus26; + uint8_t diff_cu_qp_delta_depth; + int8_t pps_cb_qp_offset; + int8_t pps_cr_qp_offset; + uint8_t num_tile_columns_minus1; + uint8_t num_tile_rows_minus1; + uint16_t column_width_minus1[19]; + uint16_t row_height_minus1[21]; + int8_t pps_beta_offset_div2; + int8_t pps_tc_offset_div2; + uint8_t log2_parallel_merge_level_minus2; + StdVideoH265PpsFlags flags; + StdVideoH265ScalingLists* pScalingLists; // Must be a valid pointer if pps_scaling_list_data_present_flag is set + + // extension PPS, valid when std_video_h265_profile_idc_format_range_extensions is set + uint8_t log2_max_transform_skip_block_size_minus2; + uint8_t diff_cu_chroma_qp_offset_depth; + uint8_t chroma_qp_offset_list_len_minus1; + int8_t cb_qp_offset_list[6]; + int8_t cr_qp_offset_list[6]; + uint8_t log2_sao_offset_scale_luma; + uint8_t log2_sao_offset_scale_chroma; + + // extension PPS, valid when std_video_h265_profile_idc_scc_extensions is set + int8_t pps_act_y_qp_offset_plus5; + int8_t pps_act_cb_qp_offset_plus5; + int8_t pps_act_cr_qp_offset_plus5; + uint8_t pps_num_palette_predictor_initializer; + uint8_t luma_bit_depth_entry_minus8; + uint8_t chroma_bit_depth_entry_minus8; + StdVideoH265PredictorPaletteEntries* pPredictorPaletteEntries; // Must be a valid pointer if pps_palette_predictor_initializer_present_flag is set +} StdVideoH265PictureParameterSet; + +#ifdef __cplusplus +} +#endif + +#endif // VULKAN_VIDEO_CODEC_H265STD_H_ diff --git a/external/vulkancts/scripts/src/vk_video/vulkan_video_codec_h265std_decode.h b/external/vulkancts/scripts/src/vk_video/vulkan_video_codec_h265std_decode.h new file mode 100644 index 0000000..4be8b5f --- /dev/null +++ b/external/vulkancts/scripts/src/vk_video/vulkan_video_codec_h265std_decode.h @@ -0,0 +1,59 @@ +/* +** Copyright (c) 2019-2021 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +#ifndef VULKAN_VIDEO_CODEC_H265STD_DECODE_H_ +#define VULKAN_VIDEO_CODEC_H265STD_DECODE_H_ 1 + +#ifdef __cplusplus +extern "C" { +#endif + +#include "vk_video/vulkan_video_codec_h265std.h" + +// ************************************************* +// Video h265 Decode related parameters: +// ************************************************* + +typedef struct StdVideoDecodeH265PictureInfoFlags { + uint32_t IrapPicFlag : 1; + uint32_t IdrPicFlag : 1; + uint32_t IsReference : 1; + uint32_t short_term_ref_pic_set_sps_flag : 1; +} StdVideoDecodeH265PictureInfoFlags; + +typedef struct StdVideoDecodeH265PictureInfo { + uint8_t vps_video_parameter_set_id; + uint8_t sps_seq_parameter_set_id; + uint8_t pps_pic_parameter_set_id; + uint8_t num_short_term_ref_pic_sets; + int32_t PicOrderCntVal; + uint16_t NumBitsForSTRefPicSetInSlice; // number of bits used in st_ref_pic_set() + //when short_term_ref_pic_set_sps_flag is 0; otherwise set to 0. + uint8_t NumDeltaPocsOfRefRpsIdx; // NumDeltaPocs[ RefRpsIdx ] when short_term_ref_pic_set_sps_flag = 1, otherwise 0 + uint8_t RefPicSetStCurrBefore[8]; // slotIndex as used in VkVideoReferenceSlotKHR structures representing + //pReferenceSlots in VkVideoDecodeInfoKHR, 0xff for invalid slotIndex + uint8_t RefPicSetStCurrAfter[8]; // slotIndex as used in VkVideoReferenceSlotKHR structures representing + //pReferenceSlots in VkVideoDecodeInfoKHR, 0xff for invalid slotIndex + uint8_t RefPicSetLtCurr[8]; // slotIndex as used in VkVideoReferenceSlotKHR structures representing + //pReferenceSlots in VkVideoDecodeInfoKHR, 0xff for invalid slotIndex + StdVideoDecodeH265PictureInfoFlags flags; +} StdVideoDecodeH265PictureInfo; + +typedef struct StdVideoDecodeH265ReferenceInfoFlags { + uint32_t is_long_term : 1; + uint32_t is_non_existing : 1; +} StdVideoDecodeH265ReferenceInfoFlags; + +typedef struct StdVideoDecodeH265ReferenceInfo { + int32_t PicOrderCntVal; + StdVideoDecodeH265ReferenceInfoFlags flags; +} StdVideoDecodeH265ReferenceInfo; + +#ifdef __cplusplus +} +#endif + +#endif // VULKAN_VIDEO_CODEC_H265STD_DECODE_H_ diff --git a/external/vulkancts/scripts/src/vk_video/vulkan_video_codecs_common.h b/external/vulkancts/scripts/src/vk_video/vulkan_video_codecs_common.h new file mode 100644 index 0000000..8cc227a --- /dev/null +++ b/external/vulkancts/scripts/src/vk_video/vulkan_video_codecs_common.h @@ -0,0 +1,21 @@ +/* +** Copyright (c) 2019-2021 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +#ifndef VULKAN_VIDEO_CODEC_COMMON_H_ +#define VULKAN_VIDEO_CODEC_COMMON_H_ 1 + +#ifdef __cplusplus +extern "C" { +#endif + +#define VK_MAKE_VIDEO_STD_VERSION(major, minor, patch) \ + ((((uint32_t)(major)) << 22) | (((uint32_t)(minor)) << 12) | ((uint32_t)(patch))) + +#ifdef __cplusplus +} +#endif + +#endif // VULKAN_VIDEO_CODEC_COMMON_H_ diff --git a/external/vulkancts/scripts/src/vulkan_beta.h b/external/vulkancts/scripts/src/vulkan_beta.h index 23513b3..35d78b2 100644 --- a/external/vulkancts/scripts/src/vulkan_beta.h +++ b/external/vulkancts/scripts/src/vulkan_beta.h @@ -2,7 +2,7 @@ #define VULKAN_BETA_H_ 1 /* -** Copyright (c) 2015-2020 The Khronos Group Inc. +** Copyright 2015-2021 The Khronos Group Inc. ** ** SPDX-License-Identifier: Apache-2.0 */ @@ -19,6 +19,325 @@ extern "C" { +#define VK_KHR_video_queue 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkVideoSessionKHR) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkVideoSessionParametersKHR) +#define VK_KHR_VIDEO_QUEUE_SPEC_VERSION 1 +#define VK_KHR_VIDEO_QUEUE_EXTENSION_NAME "VK_KHR_video_queue" + +typedef enum VkQueryResultStatusKHR { + VK_QUERY_RESULT_STATUS_ERROR_KHR = -1, + VK_QUERY_RESULT_STATUS_NOT_READY_KHR = 0, + VK_QUERY_RESULT_STATUS_COMPLETE_KHR = 1, + VK_QUERY_RESULT_STATUS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkQueryResultStatusKHR; + +typedef enum VkVideoCodecOperationFlagBitsKHR { + VK_VIDEO_CODEC_OPERATION_INVALID_BIT_KHR = 0, +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_EXT = 0x00010000, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_EXT = 0x00000001, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_EXT = 0x00000002, +#endif + VK_VIDEO_CODEC_OPERATION_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoCodecOperationFlagBitsKHR; +typedef VkFlags VkVideoCodecOperationFlagsKHR; + +typedef enum VkVideoChromaSubsamplingFlagBitsKHR { + VK_VIDEO_CHROMA_SUBSAMPLING_INVALID_BIT_KHR = 0, + VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR = 0x00000001, + VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR = 0x00000002, + VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR = 0x00000004, + VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR = 0x00000008, + VK_VIDEO_CHROMA_SUBSAMPLING_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoChromaSubsamplingFlagBitsKHR; +typedef VkFlags VkVideoChromaSubsamplingFlagsKHR; + +typedef enum VkVideoComponentBitDepthFlagBitsKHR { + VK_VIDEO_COMPONENT_BIT_DEPTH_INVALID_KHR = 0, + VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR = 0x00000001, + VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR = 0x00000004, + VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR = 0x00000010, + VK_VIDEO_COMPONENT_BIT_DEPTH_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoComponentBitDepthFlagBitsKHR; +typedef VkFlags VkVideoComponentBitDepthFlagsKHR; + +typedef enum VkVideoCapabilitiesFlagBitsKHR { + VK_VIDEO_CAPABILITIES_PROTECTED_CONTENT_BIT_KHR = 0x00000001, + VK_VIDEO_CAPABILITIES_SEPARATE_REFERENCE_IMAGES_BIT_KHR = 0x00000002, + VK_VIDEO_CAPABILITIES_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoCapabilitiesFlagBitsKHR; +typedef VkFlags VkVideoCapabilitiesFlagsKHR; + +typedef enum VkVideoSessionCreateFlagBitsKHR { + VK_VIDEO_SESSION_CREATE_DEFAULT_KHR = 0, + VK_VIDEO_SESSION_CREATE_PROTECTED_CONTENT_BIT_KHR = 0x00000001, + VK_VIDEO_SESSION_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoSessionCreateFlagBitsKHR; +typedef VkFlags VkVideoSessionCreateFlagsKHR; +typedef VkFlags VkVideoBeginCodingFlagsKHR; +typedef VkFlags VkVideoEndCodingFlagsKHR; + +typedef enum VkVideoCodingControlFlagBitsKHR { + VK_VIDEO_CODING_CONTROL_DEFAULT_KHR = 0, + VK_VIDEO_CODING_CONTROL_RESET_BIT_KHR = 0x00000001, + VK_VIDEO_CODING_CONTROL_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoCodingControlFlagBitsKHR; +typedef VkFlags VkVideoCodingControlFlagsKHR; + +typedef enum VkVideoCodingQualityPresetFlagBitsKHR { + VK_VIDEO_CODING_QUALITY_PRESET_DEFAULT_BIT_KHR = 0, + VK_VIDEO_CODING_QUALITY_PRESET_NORMAL_BIT_KHR = 0x00000001, + VK_VIDEO_CODING_QUALITY_PRESET_POWER_BIT_KHR = 0x00000002, + VK_VIDEO_CODING_QUALITY_PRESET_QUALITY_BIT_KHR = 0x00000004, + VK_VIDEO_CODING_QUALITY_PRESET_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoCodingQualityPresetFlagBitsKHR; +typedef VkFlags VkVideoCodingQualityPresetFlagsKHR; +typedef struct VkVideoQueueFamilyProperties2KHR { + VkStructureType sType; + void* pNext; + VkVideoCodecOperationFlagsKHR videoCodecOperations; +} VkVideoQueueFamilyProperties2KHR; + +typedef struct VkVideoProfileKHR { + VkStructureType sType; + void* pNext; + VkVideoCodecOperationFlagBitsKHR videoCodecOperation; + VkVideoChromaSubsamplingFlagsKHR chromaSubsampling; + VkVideoComponentBitDepthFlagsKHR lumaBitDepth; + VkVideoComponentBitDepthFlagsKHR chromaBitDepth; +} VkVideoProfileKHR; + +typedef struct VkVideoProfilesKHR { + VkStructureType sType; + void* pNext; + uint32_t profileCount; + const VkVideoProfileKHR* pProfiles; +} VkVideoProfilesKHR; + +typedef struct VkVideoCapabilitiesKHR { + VkStructureType sType; + void* pNext; + VkVideoCapabilitiesFlagsKHR capabilityFlags; + VkDeviceSize minBitstreamBufferOffsetAlignment; + VkDeviceSize minBitstreamBufferSizeAlignment; + VkExtent2D videoPictureExtentGranularity; + VkExtent2D minExtent; + VkExtent2D maxExtent; + uint32_t maxReferencePicturesSlotsCount; + uint32_t maxReferencePicturesActiveCount; +} VkVideoCapabilitiesKHR; + +typedef struct VkPhysicalDeviceVideoFormatInfoKHR { + VkStructureType sType; + const void* pNext; + VkImageUsageFlags imageUsage; + const VkVideoProfilesKHR* pVideoProfiles; +} VkPhysicalDeviceVideoFormatInfoKHR; + +typedef struct VkVideoFormatPropertiesKHR { + VkStructureType sType; + void* pNext; + VkFormat format; +} VkVideoFormatPropertiesKHR; + +typedef struct VkVideoPictureResourceKHR { + VkStructureType sType; + const void* pNext; + VkOffset2D codedOffset; + VkExtent2D codedExtent; + uint32_t baseArrayLayer; + VkImageView imageViewBinding; +} VkVideoPictureResourceKHR; + +typedef struct VkVideoReferenceSlotKHR { + VkStructureType sType; + const void* pNext; + int8_t slotIndex; + const VkVideoPictureResourceKHR* pPictureResource; +} VkVideoReferenceSlotKHR; + +typedef struct VkVideoGetMemoryPropertiesKHR { + VkStructureType sType; + const void* pNext; + uint32_t memoryBindIndex; + VkMemoryRequirements2* pMemoryRequirements; +} VkVideoGetMemoryPropertiesKHR; + +typedef struct VkVideoBindMemoryKHR { + VkStructureType sType; + const void* pNext; + uint32_t memoryBindIndex; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; + VkDeviceSize memorySize; +} VkVideoBindMemoryKHR; + +typedef struct VkVideoSessionCreateInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t queueFamilyIndex; + VkVideoSessionCreateFlagsKHR flags; + const VkVideoProfileKHR* pVideoProfile; + VkFormat pictureFormat; + VkExtent2D maxCodedExtent; + VkFormat referencePicturesFormat; + uint32_t maxReferencePicturesSlotsCount; + uint32_t maxReferencePicturesActiveCount; +} VkVideoSessionCreateInfoKHR; + +typedef struct VkVideoSessionParametersCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkVideoSessionParametersKHR videoSessionParametersTemplate; + VkVideoSessionKHR videoSession; +} VkVideoSessionParametersCreateInfoKHR; + +typedef struct VkVideoSessionParametersUpdateInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t updateSequenceCount; +} VkVideoSessionParametersUpdateInfoKHR; + +typedef struct VkVideoBeginCodingInfoKHR { + VkStructureType sType; + const void* pNext; + VkVideoBeginCodingFlagsKHR flags; + VkVideoCodingQualityPresetFlagsKHR codecQualityPreset; + VkVideoSessionKHR videoSession; + VkVideoSessionParametersKHR videoSessionParameters; + uint32_t referenceSlotCount; + const VkVideoReferenceSlotKHR* pReferenceSlots; +} VkVideoBeginCodingInfoKHR; + +typedef struct VkVideoEndCodingInfoKHR { + VkStructureType sType; + const void* pNext; + VkVideoEndCodingFlagsKHR flags; +} VkVideoEndCodingInfoKHR; + +typedef struct VkVideoCodingControlInfoKHR { + VkStructureType sType; + const void* pNext; + VkVideoCodingControlFlagsKHR flags; +} VkVideoCodingControlInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR)(VkPhysicalDevice physicalDevice, const VkVideoProfileKHR* pVideoProfile, VkVideoCapabilitiesKHR* pCapabilities); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, uint32_t* pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR* pVideoFormatProperties); +typedef VkResult (VKAPI_PTR *PFN_vkCreateVideoSessionKHR)(VkDevice device, const VkVideoSessionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionKHR* pVideoSession); +typedef void (VKAPI_PTR *PFN_vkDestroyVideoSessionKHR)(VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkGetVideoSessionMemoryRequirementsKHR)(VkDevice device, VkVideoSessionKHR videoSession, uint32_t* pVideoSessionMemoryRequirementsCount, VkVideoGetMemoryPropertiesKHR* pVideoSessionMemoryRequirements); +typedef VkResult (VKAPI_PTR *PFN_vkBindVideoSessionMemoryKHR)(VkDevice device, VkVideoSessionKHR videoSession, uint32_t videoSessionBindMemoryCount, const VkVideoBindMemoryKHR* pVideoSessionBindMemories); +typedef VkResult (VKAPI_PTR *PFN_vkCreateVideoSessionParametersKHR)(VkDevice device, const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionParametersKHR* pVideoSessionParameters); +typedef VkResult (VKAPI_PTR *PFN_vkUpdateVideoSessionParametersKHR)(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo); +typedef void (VKAPI_PTR *PFN_vkDestroyVideoSessionParametersKHR)(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkCmdBeginVideoCodingKHR)(VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR* pBeginInfo); +typedef void (VKAPI_PTR *PFN_vkCmdEndVideoCodingKHR)(VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR* pEndCodingInfo); +typedef void (VKAPI_PTR *PFN_vkCmdControlVideoCodingKHR)(VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR* pCodingControlInfo); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceVideoCapabilitiesKHR( + VkPhysicalDevice physicalDevice, + const VkVideoProfileKHR* pVideoProfile, + VkVideoCapabilitiesKHR* pCapabilities); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceVideoFormatPropertiesKHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, + uint32_t* pVideoFormatPropertyCount, + VkVideoFormatPropertiesKHR* pVideoFormatProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateVideoSessionKHR( + VkDevice device, + const VkVideoSessionCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkVideoSessionKHR* pVideoSession); + +VKAPI_ATTR void VKAPI_CALL vkDestroyVideoSessionKHR( + VkDevice device, + VkVideoSessionKHR videoSession, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetVideoSessionMemoryRequirementsKHR( + VkDevice device, + VkVideoSessionKHR videoSession, + uint32_t* pVideoSessionMemoryRequirementsCount, + VkVideoGetMemoryPropertiesKHR* pVideoSessionMemoryRequirements); + +VKAPI_ATTR VkResult VKAPI_CALL vkBindVideoSessionMemoryKHR( + VkDevice device, + VkVideoSessionKHR videoSession, + uint32_t videoSessionBindMemoryCount, + const VkVideoBindMemoryKHR* pVideoSessionBindMemories); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateVideoSessionParametersKHR( + VkDevice device, + const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkVideoSessionParametersKHR* pVideoSessionParameters); + +VKAPI_ATTR VkResult VKAPI_CALL vkUpdateVideoSessionParametersKHR( + VkDevice device, + VkVideoSessionParametersKHR videoSessionParameters, + const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo); + +VKAPI_ATTR void VKAPI_CALL vkDestroyVideoSessionParametersKHR( + VkDevice device, + VkVideoSessionParametersKHR videoSessionParameters, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR void VKAPI_CALL vkCmdBeginVideoCodingKHR( + VkCommandBuffer commandBuffer, + const VkVideoBeginCodingInfoKHR* pBeginInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdEndVideoCodingKHR( + VkCommandBuffer commandBuffer, + const VkVideoEndCodingInfoKHR* pEndCodingInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdControlVideoCodingKHR( + VkCommandBuffer commandBuffer, + const VkVideoCodingControlInfoKHR* pCodingControlInfo); +#endif + + +#define VK_KHR_video_decode_queue 1 +#define VK_KHR_VIDEO_DECODE_QUEUE_SPEC_VERSION 1 +#define VK_KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME "VK_KHR_video_decode_queue" + +typedef enum VkVideoDecodeFlagBitsKHR { + VK_VIDEO_DECODE_DEFAULT_KHR = 0, + VK_VIDEO_DECODE_RESERVED_0_BIT_KHR = 0x00000001, + VK_VIDEO_DECODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoDecodeFlagBitsKHR; +typedef VkFlags VkVideoDecodeFlagsKHR; +typedef struct VkVideoDecodeInfoKHR { + VkStructureType sType; + const void* pNext; + VkVideoDecodeFlagsKHR flags; + VkOffset2D codedOffset; + VkExtent2D codedExtent; + VkBuffer srcBuffer; + VkDeviceSize srcBufferOffset; + VkDeviceSize srcBufferRange; + VkVideoPictureResourceKHR dstPictureResource; + const VkVideoReferenceSlotKHR* pSetupReferenceSlot; + uint32_t referenceSlotCount; + const VkVideoReferenceSlotKHR* pReferenceSlots; +} VkVideoDecodeInfoKHR; + +typedef void (VKAPI_PTR *PFN_vkCmdDecodeVideoKHR)(VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR* pFrameInfo); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDecodeVideoKHR( + VkCommandBuffer commandBuffer, + const VkVideoDecodeInfoKHR* pFrameInfo); +#endif + + #define VK_KHR_portability_subset 1 #define VK_KHR_PORTABILITY_SUBSET_SPEC_VERSION 1 #define VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME "VK_KHR_portability_subset" @@ -49,6 +368,335 @@ typedef struct VkPhysicalDevicePortabilitySubsetPropertiesKHR { } VkPhysicalDevicePortabilitySubsetPropertiesKHR; + +#define VK_KHR_video_encode_queue 1 +#define VK_KHR_VIDEO_ENCODE_QUEUE_SPEC_VERSION 1 +#define VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME "VK_KHR_video_encode_queue" + +typedef enum VkVideoEncodeFlagBitsKHR { + VK_VIDEO_ENCODE_DEFAULT_KHR = 0, + VK_VIDEO_ENCODE_RESERVED_0_BIT_KHR = 0x00000001, + VK_VIDEO_ENCODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoEncodeFlagBitsKHR; +typedef VkFlags VkVideoEncodeFlagsKHR; + +typedef enum VkVideoEncodeRateControlFlagBitsKHR { + VK_VIDEO_ENCODE_RATE_CONTROL_DEFAULT_KHR = 0, + VK_VIDEO_ENCODE_RATE_CONTROL_RESET_BIT_KHR = 0x00000001, + VK_VIDEO_ENCODE_RATE_CONTROL_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoEncodeRateControlFlagBitsKHR; +typedef VkFlags VkVideoEncodeRateControlFlagsKHR; + +typedef enum VkVideoEncodeRateControlModeFlagBitsKHR { + VK_VIDEO_ENCODE_RATE_CONTROL_MODE_NONE_BIT_KHR = 0, + VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR = 1, + VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR = 2, + VK_VIDEO_ENCODE_RATE_CONTROL_MODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoEncodeRateControlModeFlagBitsKHR; +typedef VkFlags VkVideoEncodeRateControlModeFlagsKHR; +typedef struct VkVideoEncodeInfoKHR { + VkStructureType sType; + const void* pNext; + VkVideoEncodeFlagsKHR flags; + uint32_t qualityLevel; + VkExtent2D codedExtent; + VkBuffer dstBitstreamBuffer; + VkDeviceSize dstBitstreamBufferOffset; + VkDeviceSize dstBitstreamBufferMaxRange; + VkVideoPictureResourceKHR srcPictureResource; + const VkVideoReferenceSlotKHR* pSetupReferenceSlot; + uint32_t referenceSlotCount; + const VkVideoReferenceSlotKHR* pReferenceSlots; +} VkVideoEncodeInfoKHR; + +typedef struct VkVideoEncodeRateControlInfoKHR { + VkStructureType sType; + const void* pNext; + VkVideoEncodeRateControlFlagsKHR flags; + VkVideoEncodeRateControlModeFlagBitsKHR rateControlMode; + uint32_t averageBitrate; + uint16_t peakToAverageBitrateRatio; + uint16_t frameRateNumerator; + uint16_t frameRateDenominator; + uint32_t virtualBufferSizeInMs; +} VkVideoEncodeRateControlInfoKHR; + +typedef void (VKAPI_PTR *PFN_vkCmdEncodeVideoKHR)(VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdEncodeVideoKHR( + VkCommandBuffer commandBuffer, + const VkVideoEncodeInfoKHR* pEncodeInfo); +#endif + + +#define VK_EXT_video_encode_h264 1 +#include "vk_video/vulkan_video_codec_h264std.h" +#include "vk_video/vulkan_video_codec_h264std_encode.h" +#define VK_EXT_VIDEO_ENCODE_H264_SPEC_VERSION 1 +#define VK_EXT_VIDEO_ENCODE_H264_EXTENSION_NAME "VK_EXT_video_encode_h264" + +typedef enum VkVideoEncodeH264CapabilitiesFlagBitsEXT { + VK_VIDEO_ENCODE_H264_CAPABILITY_CABAC_BIT_EXT = 0x00000001, + VK_VIDEO_ENCODE_H264_CAPABILITY_CAVLC_BIT_EXT = 0x00000002, + VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_BI_PRED_IMPLICIT_BIT_EXT = 0x00000004, + VK_VIDEO_ENCODE_H264_CAPABILITY_TRANSFORM_8X8_BIT_EXT = 0x00000008, + VK_VIDEO_ENCODE_H264_CAPABILITY_CHROMA_QP_OFFSET_BIT_EXT = 0x00000010, + VK_VIDEO_ENCODE_H264_CAPABILITY_SECOND_CHROMA_QP_OFFSET_BIT_EXT = 0x00000020, + VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_DISABLED_BIT_EXT = 0x00000040, + VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_ENABLED_BIT_EXT = 0x00000080, + VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_PARTIAL_BIT_EXT = 0x00000100, + VK_VIDEO_ENCODE_H264_CAPABILITY_MULTIPLE_SLICE_PER_FRAME_BIT_EXT = 0x00000200, + VK_VIDEO_ENCODE_H264_CAPABILITY_EVENLY_DISTRIBUTED_SLICE_SIZE_BIT_EXT = 0x00000400, + VK_VIDEO_ENCODE_H264_CAPABILITIES_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkVideoEncodeH264CapabilitiesFlagBitsEXT; +typedef VkFlags VkVideoEncodeH264CapabilitiesFlagsEXT; + +typedef enum VkVideoEncodeH264InputModeFlagBitsEXT { + VK_VIDEO_ENCODE_H264_INPUT_MODE_FRAME_BIT_EXT = 0x00000001, + VK_VIDEO_ENCODE_H264_INPUT_MODE_SLICE_BIT_EXT = 0x00000002, + VK_VIDEO_ENCODE_H264_INPUT_MODE_NON_VCL_BIT_EXT = 0x00000004, + VK_VIDEO_ENCODE_H264_INPUT_MODE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkVideoEncodeH264InputModeFlagBitsEXT; +typedef VkFlags VkVideoEncodeH264InputModeFlagsEXT; + +typedef enum VkVideoEncodeH264OutputModeFlagBitsEXT { + VK_VIDEO_ENCODE_H264_OUTPUT_MODE_FRAME_BIT_EXT = 0x00000001, + VK_VIDEO_ENCODE_H264_OUTPUT_MODE_SLICE_BIT_EXT = 0x00000002, + VK_VIDEO_ENCODE_H264_OUTPUT_MODE_NON_VCL_BIT_EXT = 0x00000004, + VK_VIDEO_ENCODE_H264_OUTPUT_MODE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkVideoEncodeH264OutputModeFlagBitsEXT; +typedef VkFlags VkVideoEncodeH264OutputModeFlagsEXT; + +typedef enum VkVideoEncodeH264CreateFlagBitsEXT { + VK_VIDEO_ENCODE_H264_CREATE_DEFAULT_EXT = 0, + VK_VIDEO_ENCODE_H264_CREATE_RESERVED_0_BIT_EXT = 0x00000001, + VK_VIDEO_ENCODE_H264_CREATE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkVideoEncodeH264CreateFlagBitsEXT; +typedef VkFlags VkVideoEncodeH264CreateFlagsEXT; +typedef struct VkVideoEncodeH264CapabilitiesEXT { + VkStructureType sType; + const void* pNext; + VkVideoEncodeH264CapabilitiesFlagsEXT flags; + VkVideoEncodeH264InputModeFlagsEXT inputModeFlags; + VkVideoEncodeH264OutputModeFlagsEXT outputModeFlags; + VkExtent2D minPictureSizeInMbs; + VkExtent2D maxPictureSizeInMbs; + VkExtent2D inputImageDataAlignment; + uint8_t maxNumL0ReferenceForP; + uint8_t maxNumL0ReferenceForB; + uint8_t maxNumL1Reference; + uint8_t qualityLevelCount; + VkExtensionProperties stdExtensionVersion; +} VkVideoEncodeH264CapabilitiesEXT; + +typedef struct VkVideoEncodeH264SessionCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkVideoEncodeH264CreateFlagsEXT flags; + VkExtent2D maxPictureSizeInMbs; + const VkExtensionProperties* pStdExtensionVersion; +} VkVideoEncodeH264SessionCreateInfoEXT; + +typedef struct VkVideoEncodeH264SessionParametersAddInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t spsStdCount; + const StdVideoH264SequenceParameterSet* pSpsStd; + uint32_t ppsStdCount; + const StdVideoH264PictureParameterSet* pPpsStd; +} VkVideoEncodeH264SessionParametersAddInfoEXT; + +typedef struct VkVideoEncodeH264SessionParametersCreateInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t maxSpsStdCount; + uint32_t maxPpsStdCount; + const VkVideoEncodeH264SessionParametersAddInfoEXT* pParametersAddInfo; +} VkVideoEncodeH264SessionParametersCreateInfoEXT; + +typedef struct VkVideoEncodeH264DpbSlotInfoEXT { + VkStructureType sType; + const void* pNext; + int8_t slotIndex; + const StdVideoEncodeH264PictureInfo* pStdPictureInfo; +} VkVideoEncodeH264DpbSlotInfoEXT; + +typedef struct VkVideoEncodeH264NaluSliceEXT { + VkStructureType sType; + const void* pNext; + const StdVideoEncodeH264SliceHeader* pSliceHeaderStd; + uint32_t mbCount; + uint8_t refFinalList0EntryCount; + const VkVideoEncodeH264DpbSlotInfoEXT* pRefFinalList0Entries; + uint8_t refFinalList1EntryCount; + const VkVideoEncodeH264DpbSlotInfoEXT* pRefFinalList1Entries; + uint32_t precedingNaluBytes; + uint8_t minQp; + uint8_t maxQp; +} VkVideoEncodeH264NaluSliceEXT; + +typedef struct VkVideoEncodeH264VclFrameInfoEXT { + VkStructureType sType; + const void* pNext; + uint8_t refDefaultFinalList0EntryCount; + const VkVideoEncodeH264DpbSlotInfoEXT* pRefDefaultFinalList0Entries; + uint8_t refDefaultFinalList1EntryCount; + const VkVideoEncodeH264DpbSlotInfoEXT* pRefDefaultFinalList1Entries; + uint32_t naluSliceEntryCount; + const VkVideoEncodeH264NaluSliceEXT* pNaluSliceEntries; + const VkVideoEncodeH264DpbSlotInfoEXT* pCurrentPictureInfo; +} VkVideoEncodeH264VclFrameInfoEXT; + +typedef struct VkVideoEncodeH264EmitPictureParametersEXT { + VkStructureType sType; + const void* pNext; + uint8_t spsId; + VkBool32 emitSpsEnable; + uint32_t ppsIdEntryCount; + const uint8_t* ppsIdEntries; +} VkVideoEncodeH264EmitPictureParametersEXT; + +typedef struct VkVideoEncodeH264ProfileEXT { + VkStructureType sType; + const void* pNext; + StdVideoH264ProfileIdc stdProfileIdc; +} VkVideoEncodeH264ProfileEXT; + + + +#define VK_EXT_video_decode_h264 1 +#include "vk_video/vulkan_video_codec_h264std_decode.h" +#define VK_EXT_VIDEO_DECODE_H264_SPEC_VERSION 1 +#define VK_EXT_VIDEO_DECODE_H264_EXTENSION_NAME "VK_EXT_video_decode_h264" + +typedef enum VkVideoDecodeH264FieldLayoutFlagBitsEXT { + VK_VIDEO_DECODE_H264_PROGRESSIVE_PICTURES_ONLY_EXT = 0, + VK_VIDEO_DECODE_H264_FIELD_LAYOUT_LINE_INTERLACED_PLANE_BIT_EXT = 0x00000001, + VK_VIDEO_DECODE_H264_FIELD_LAYOUT_SEPARATE_INTERLACED_PLANE_BIT_EXT = 0x00000002, + VK_VIDEO_DECODE_H264_FIELD_LAYOUT_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkVideoDecodeH264FieldLayoutFlagBitsEXT; +typedef VkFlags VkVideoDecodeH264FieldLayoutFlagsEXT; +typedef VkFlags VkVideoDecodeH264CreateFlagsEXT; +typedef struct VkVideoDecodeH264ProfileEXT { + VkStructureType sType; + const void* pNext; + StdVideoH264ProfileIdc stdProfileIdc; + VkVideoDecodeH264FieldLayoutFlagsEXT fieldLayout; +} VkVideoDecodeH264ProfileEXT; + +typedef struct VkVideoDecodeH264CapabilitiesEXT { + VkStructureType sType; + void* pNext; + uint32_t maxLevel; + VkOffset2D fieldOffsetGranularity; + VkExtensionProperties stdExtensionVersion; +} VkVideoDecodeH264CapabilitiesEXT; + +typedef struct VkVideoDecodeH264SessionCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkVideoDecodeH264CreateFlagsEXT flags; + const VkExtensionProperties* pStdExtensionVersion; +} VkVideoDecodeH264SessionCreateInfoEXT; + +typedef struct VkVideoDecodeH264SessionParametersAddInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t spsStdCount; + const StdVideoH264SequenceParameterSet* pSpsStd; + uint32_t ppsStdCount; + const StdVideoH264PictureParameterSet* pPpsStd; +} VkVideoDecodeH264SessionParametersAddInfoEXT; + +typedef struct VkVideoDecodeH264SessionParametersCreateInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t maxSpsStdCount; + uint32_t maxPpsStdCount; + const VkVideoDecodeH264SessionParametersAddInfoEXT* pParametersAddInfo; +} VkVideoDecodeH264SessionParametersCreateInfoEXT; + +typedef struct VkVideoDecodeH264PictureInfoEXT { + VkStructureType sType; + const void* pNext; + const StdVideoDecodeH264PictureInfo* pStdPictureInfo; + uint32_t slicesCount; + const uint32_t* pSlicesDataOffsets; +} VkVideoDecodeH264PictureInfoEXT; + +typedef struct VkVideoDecodeH264MvcEXT { + VkStructureType sType; + const void* pNext; + const StdVideoDecodeH264Mvc* pStdMvc; +} VkVideoDecodeH264MvcEXT; + +typedef struct VkVideoDecodeH264DpbSlotInfoEXT { + VkStructureType sType; + const void* pNext; + const StdVideoDecodeH264ReferenceInfo* pStdReferenceInfo; +} VkVideoDecodeH264DpbSlotInfoEXT; + + + +#define VK_EXT_video_decode_h265 1 +#include "vk_video/vulkan_video_codec_h265std.h" +#include "vk_video/vulkan_video_codec_h265std_decode.h" +#define VK_EXT_VIDEO_DECODE_H265_SPEC_VERSION 1 +#define VK_EXT_VIDEO_DECODE_H265_EXTENSION_NAME "VK_EXT_video_decode_h265" +typedef VkFlags VkVideoDecodeH265CreateFlagsEXT; +typedef struct VkVideoDecodeH265ProfileEXT { + VkStructureType sType; + const void* pNext; + StdVideoH265ProfileIdc stdProfileIdc; +} VkVideoDecodeH265ProfileEXT; + +typedef struct VkVideoDecodeH265CapabilitiesEXT { + VkStructureType sType; + void* pNext; + uint32_t maxLevel; + VkExtensionProperties stdExtensionVersion; +} VkVideoDecodeH265CapabilitiesEXT; + +typedef struct VkVideoDecodeH265SessionCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkVideoDecodeH265CreateFlagsEXT flags; + const VkExtensionProperties* pStdExtensionVersion; +} VkVideoDecodeH265SessionCreateInfoEXT; + +typedef struct VkVideoDecodeH265SessionParametersAddInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t spsStdCount; + const StdVideoH265SequenceParameterSet* pSpsStd; + uint32_t ppsStdCount; + const StdVideoH265PictureParameterSet* pPpsStd; +} VkVideoDecodeH265SessionParametersAddInfoEXT; + +typedef struct VkVideoDecodeH265SessionParametersCreateInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t maxSpsStdCount; + uint32_t maxPpsStdCount; + const VkVideoDecodeH265SessionParametersAddInfoEXT* pParametersAddInfo; +} VkVideoDecodeH265SessionParametersCreateInfoEXT; + +typedef struct VkVideoDecodeH265PictureInfoEXT { + VkStructureType sType; + const void* pNext; + StdVideoDecodeH265PictureInfo* pStdPictureInfo; + uint32_t slicesCount; + const uint32_t* pSlicesDataOffsets; +} VkVideoDecodeH265PictureInfoEXT; + +typedef struct VkVideoDecodeH265DpbSlotInfoEXT { + VkStructureType sType; + const void* pNext; + const StdVideoDecodeH265ReferenceInfo* pStdReferenceInfo; +} VkVideoDecodeH265DpbSlotInfoEXT; + + #ifdef __cplusplus } #endif