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);
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,
};
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;
typedef deUint32 VkAndroidSurfaceCreateFlagsKHR;
+typedef deUint32 VkVideoBeginCodingFlagsKHR;
+
+typedef deUint32 VkVideoEndCodingFlagsKHR;
+
+typedef deUint32 VkVideoDecodeH264CreateFlagsEXT;
+
+typedef deUint32 VkVideoDecodeH265CreateFlagsEXT;
+
typedef deUint32 VkImagePipeSurfaceCreateFlagsFUCHSIA;
typedef deUint32 VkStreamDescriptorSurfaceCreateFlagsGGP;
#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
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;
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;
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);
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;
{
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");
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;
"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",
"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",
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);
return VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID;
}
+template<> VkStructureType getStructureType<VkVideoQueueFamilyProperties2KHR> (void)
+{
+ return VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR;
+}
+
+template<> VkStructureType getStructureType<VkVideoProfileKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR;
+}
+
+template<> VkStructureType getStructureType<VkVideoProfilesKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR;
+}
+
+template<> VkStructureType getStructureType<VkVideoCapabilitiesKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR;
+}
+
+template<> VkStructureType getStructureType<VkPhysicalDeviceVideoFormatInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkVideoFormatPropertiesKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR;
+}
+
+template<> VkStructureType getStructureType<VkVideoPictureResourceKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_KHR;
+}
+
+template<> VkStructureType getStructureType<VkVideoReferenceSlotKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_KHR;
+}
+
+template<> VkStructureType getStructureType<VkVideoGetMemoryPropertiesKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_VIDEO_GET_MEMORY_PROPERTIES_KHR;
+}
+
+template<> VkStructureType getStructureType<VkVideoBindMemoryKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_VIDEO_BIND_MEMORY_KHR;
+}
+
+template<> VkStructureType getStructureType<VkVideoSessionCreateInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkVideoSessionParametersCreateInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkVideoSessionParametersUpdateInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkVideoBeginCodingInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkVideoEndCodingInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkVideoCodingControlInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkVideoDecodeInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR;
+}
+
template<> VkStructureType getStructureType<VkPhysicalDevicePortabilitySubsetFeaturesKHR> (void)
{
return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR;
return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR;
}
+template<> VkStructureType getStructureType<VkVideoEncodeInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkVideoEncodeRateControlInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkVideoEncodeH264CapabilitiesEXT> (void)
+{
+ return VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT;
+}
+
+template<> VkStructureType getStructureType<VkVideoEncodeH264SessionCreateInfoEXT> (void)
+{
+ return VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT;
+}
+
+template<> VkStructureType getStructureType<VkVideoEncodeH264SessionParametersAddInfoEXT> (void)
+{
+ return VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT;
+}
+
+template<> VkStructureType getStructureType<VkVideoEncodeH264SessionParametersCreateInfoEXT> (void)
+{
+ return VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT;
+}
+
+template<> VkStructureType getStructureType<VkVideoEncodeH264DpbSlotInfoEXT> (void)
+{
+ return VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT;
+}
+
+template<> VkStructureType getStructureType<VkVideoEncodeH264NaluSliceEXT> (void)
+{
+ return VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_EXT;
+}
+
+template<> VkStructureType getStructureType<VkVideoEncodeH264VclFrameInfoEXT> (void)
+{
+ return VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT;
+}
+
+template<> VkStructureType getStructureType<VkVideoEncodeH264EmitPictureParametersEXT> (void)
+{
+ return VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT;
+}
+
+template<> VkStructureType getStructureType<VkVideoEncodeH264ProfileEXT> (void)
+{
+ return VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT;
+}
+
+template<> VkStructureType getStructureType<VkVideoDecodeH264ProfileEXT> (void)
+{
+ return VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT;
+}
+
+template<> VkStructureType getStructureType<VkVideoDecodeH264CapabilitiesEXT> (void)
+{
+ return VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT;
+}
+
+template<> VkStructureType getStructureType<VkVideoDecodeH264SessionCreateInfoEXT> (void)
+{
+ return VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT;
+}
+
+template<> VkStructureType getStructureType<VkVideoDecodeH264SessionParametersAddInfoEXT> (void)
+{
+ return VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT;
+}
+
+template<> VkStructureType getStructureType<VkVideoDecodeH264SessionParametersCreateInfoEXT> (void)
+{
+ return VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT;
+}
+
+template<> VkStructureType getStructureType<VkVideoDecodeH264PictureInfoEXT> (void)
+{
+ return VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_EXT;
+}
+
+template<> VkStructureType getStructureType<VkVideoDecodeH264MvcEXT> (void)
+{
+ return VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_EXT;
+}
+
+template<> VkStructureType getStructureType<VkVideoDecodeH264DpbSlotInfoEXT> (void)
+{
+ return VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT;
+}
+
+template<> VkStructureType getStructureType<VkVideoDecodeH265ProfileEXT> (void)
+{
+ return VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_EXT;
+}
+
+template<> VkStructureType getStructureType<VkVideoDecodeH265CapabilitiesEXT> (void)
+{
+ return VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT;
+}
+
+template<> VkStructureType getStructureType<VkVideoDecodeH265SessionCreateInfoEXT> (void)
+{
+ return VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT;
+}
+
+template<> VkStructureType getStructureType<VkVideoDecodeH265SessionParametersAddInfoEXT> (void)
+{
+ return VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT;
+}
+
+template<> VkStructureType getStructureType<VkVideoDecodeH265SessionParametersCreateInfoEXT> (void)
+{
+ return VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT;
+}
+
+template<> VkStructureType getStructureType<VkVideoDecodeH265PictureInfoEXT> (void)
+{
+ return VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT;
+}
+
+template<> VkStructureType getStructureType<VkVideoDecodeH265DpbSlotInfoEXT> (void)
+{
+ return VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT;
+}
+
template<> VkStructureType getStructureType<VkImagePipeSurfaceCreateInfoFUCHSIA> (void)
{
return VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA;
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
};
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");
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");
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);
AcquireWinrtDisplayNVFunc acquireWinrtDisplayNV;
GetWinrtDisplayNVFunc getWinrtDisplayNV;
CreateAndroidSurfaceKHRFunc createAndroidSurfaceKHR;
+GetPhysicalDeviceVideoCapabilitiesKHRFunc getPhysicalDeviceVideoCapabilitiesKHR;
+GetPhysicalDeviceVideoFormatPropertiesKHRFunc getPhysicalDeviceVideoFormatPropertiesKHR;
CreateImagePipeSurfaceFUCHSIAFunc createImagePipeSurfaceFUCHSIA;
CreateStreamDescriptorSurfaceGGPFunc createStreamDescriptorSurfaceGGP;
CreateIOSSurfaceMVKFunc createIOSSurfaceMVK;
{}
};
+class VideoSessionKHR
+{
+public:
+ VideoSessionKHR (VkDevice, const VkVideoSessionCreateInfoKHR*)
+ {}
+};
+
+class VideoSessionParametersKHR
+{
+public:
+ VideoSessionParametersKHR (VkDevice, const VkVideoSessionParametersCreateInfoKHR*)
+ {}
+};
+
class ValidationCacheEXT
{
public:
VK_NULL_RETURN((*pSurface = allocateNonDispHandle<SurfaceKHR, VkSurfaceKHR>(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<VideoSessionKHR, VkVideoSessionKHR>(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<VideoSessionParametersKHR, VkVideoSessionParametersKHR>(device, pCreateInfo, pAllocator)));
+}
+
VKAPI_ATTR VkResult VKAPI_CALL createImagePipeSurfaceFUCHSIA (VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
{
DE_UNREF(pAllocator);
freeNonDispHandle<AccelerationStructureKHR, VkAccelerationStructureKHR>(accelerationStructure, pAllocator);
}
+VKAPI_ATTR void VKAPI_CALL destroyVideoSessionKHR (VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks* pAllocator)
+{
+ DE_UNREF(device);
+ freeNonDispHandle<VideoSessionKHR, VkVideoSessionKHR>(videoSession, pAllocator);
+}
+
+VKAPI_ATTR void VKAPI_CALL destroyVideoSessionParametersKHR (VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkAllocationCallbacks* pAllocator)
+{
+ DE_UNREF(device);
+ freeNonDispHandle<VideoSessionParametersKHR, VkVideoSessionParametersKHR>(videoSessionParameters, pAllocator);
+}
+
VKAPI_ATTR VkResult VKAPI_CALL enumerateInstanceLayerProperties (deUint32* pPropertyCount, VkLayerProperties* pProperties)
{
DE_UNREF(pPropertyCount);
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);
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),
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),
template<> inline VkObjectType getObjectType<VkIndirectCommandsLayoutNV> (void) { return VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV; }
template<> inline VkObjectType getObjectType<VkPrivateDataSlotEXT> (void) { return VK_OBJECT_TYPE_PRIVATE_DATA_SLOT_EXT; }
template<> inline VkObjectType getObjectType<VkAccelerationStructureKHR> (void) { return VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR; }
+template<> inline VkObjectType getObjectType<VkVideoSessionKHR> (void) { return VK_OBJECT_TYPE_VIDEO_SESSION_KHR; }
+template<> inline VkObjectType getObjectType<VkVideoSessionParametersKHR> (void) { return VK_OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR; }
}
Move<VkPrivateDataSlotEXT> createPrivateDataSlotEXT (const DeviceInterface& vk, VkDevice device, const VkPrivateDataSlotCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
Move<VkAccelerationStructureKHR> createAccelerationStructureKHR (const DeviceInterface& vk, VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
Move<VkSurfaceKHR> createAndroidSurfaceKHR (const InstanceInterface& vk, VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkVideoSessionKHR> createVideoSessionKHR (const DeviceInterface& vk, VkDevice device, const VkVideoSessionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkVideoSessionParametersKHR> createVideoSessionParametersKHR (const DeviceInterface& vk, VkDevice device, const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
Move<VkSurfaceKHR> createImagePipeSurfaceFUCHSIA (const InstanceInterface& vk, VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
Move<VkSurfaceKHR> createStreamDescriptorSurfaceGGP (const InstanceInterface& vk, VkInstance instance, const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
Move<VkSurfaceKHR> createIOSSurfaceMVK (const InstanceInterface& vk, VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
m_deviceIface->destroyAccelerationStructureKHR(m_device, obj, m_allocator);
}
+template<>
+void Deleter<VkVideoSessionKHR>::operator() (VkVideoSessionKHR obj) const
+{
+ m_deviceIface->destroyVideoSessionKHR(m_device, obj, m_allocator);
+}
+
+template<>
+void Deleter<VkVideoSessionParametersKHR>::operator() (VkVideoSessionParametersKHR obj) const
+{
+ m_deviceIface->destroyVideoSessionParametersKHR(m_device, obj, m_allocator);
+}
+
} // refdetails
Move<VkInstance> createInstance (const PlatformInterface& vk, const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
return Move<VkSurfaceKHR>(check<VkSurfaceKHR>(object), Deleter<VkSurfaceKHR>(vk, instance, pAllocator));
}
+Move<VkVideoSessionKHR> 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<VkVideoSessionKHR>(check<VkVideoSessionKHR>(object), Deleter<VkVideoSessionKHR>(vk, device, pAllocator));
+}
+
+Move<VkVideoSessionParametersKHR> 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<VkVideoSessionParametersKHR>(check<VkVideoSessionParametersKHR>(object), Deleter<VkVideoSessionParametersKHR>(vk, device, pAllocator));
+}
+
Move<VkSurfaceKHR> createImagePipeSurfaceFUCHSIA (const InstanceInterface& vk, VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator)
{
VkSurfaceKHR object = 0;
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<VkResult> getResultStr (VkResult value) { return tcu::Format::Enum<VkResult>(getResultName, value); }
inline tcu::Format::Enum<VkAccelerationStructureBuildTypeKHR> getAccelerationStructureBuildTypeKHRStr (VkAccelerationStructureBuildTypeKHR value) { return tcu::Format::Enum<VkAccelerationStructureBuildTypeKHR>(getAccelerationStructureBuildTypeKHRName, value); }
inline tcu::Format::Enum<VkAccelerationStructureCompatibilityKHR> getAccelerationStructureCompatibilityKHRStr (VkAccelerationStructureCompatibilityKHR value) { return tcu::Format::Enum<VkAccelerationStructureCompatibilityKHR>(getAccelerationStructureCompatibilityKHRName, value); }
inline tcu::Format::Enum<VkShaderGroupShaderKHR> getShaderGroupShaderKHRStr (VkShaderGroupShaderKHR value) { return tcu::Format::Enum<VkShaderGroupShaderKHR>(getShaderGroupShaderKHRName, value); }
+inline tcu::Format::Enum<VkQueryResultStatusKHR> getQueryResultStatusKHRStr (VkQueryResultStatusKHR value) { return tcu::Format::Enum<VkQueryResultStatusKHR>(getQueryResultStatusKHRName, value); }
+inline tcu::Format::Enum<StdVideoH264ChromaFormatIdc> getdVideoH264ChromaFormatIdcStr (StdVideoH264ChromaFormatIdc value) { return tcu::Format::Enum<StdVideoH264ChromaFormatIdc>(getdVideoH264ChromaFormatIdcName, value); }
+inline tcu::Format::Enum<StdVideoH264ProfileIdc> getdVideoH264ProfileIdcStr (StdVideoH264ProfileIdc value) { return tcu::Format::Enum<StdVideoH264ProfileIdc>(getdVideoH264ProfileIdcName, value); }
+inline tcu::Format::Enum<StdVideoH264Level> getdVideoH264LevelStr (StdVideoH264Level value) { return tcu::Format::Enum<StdVideoH264Level>(getdVideoH264LevelName, value); }
+inline tcu::Format::Enum<StdVideoH264PocType> getdVideoH264PocTypeStr (StdVideoH264PocType value) { return tcu::Format::Enum<StdVideoH264PocType>(getdVideoH264PocTypeName, value); }
+inline tcu::Format::Enum<StdVideoH264AspectRatioIdc> getdVideoH264AspectRatioIdcStr (StdVideoH264AspectRatioIdc value) { return tcu::Format::Enum<StdVideoH264AspectRatioIdc>(getdVideoH264AspectRatioIdcName, value); }
+inline tcu::Format::Enum<StdVideoH264WeightedBiPredIdc> getdVideoH264WeightedBiPredIdcStr (StdVideoH264WeightedBiPredIdc value) { return tcu::Format::Enum<StdVideoH264WeightedBiPredIdc>(getdVideoH264WeightedBiPredIdcName, value); }
+inline tcu::Format::Enum<StdVideoH264ModificationOfPicNumsIdc> getdVideoH264ModificationOfPicNumsIdcStr (StdVideoH264ModificationOfPicNumsIdc value) { return tcu::Format::Enum<StdVideoH264ModificationOfPicNumsIdc>(getdVideoH264ModificationOfPicNumsIdcName, value); }
+inline tcu::Format::Enum<StdVideoH264MemMgmtControlOp> getdVideoH264MemMgmtControlOpStr (StdVideoH264MemMgmtControlOp value) { return tcu::Format::Enum<StdVideoH264MemMgmtControlOp>(getdVideoH264MemMgmtControlOpName, value); }
+inline tcu::Format::Enum<StdVideoH264CabacInitIdc> getdVideoH264CabacInitIdcStr (StdVideoH264CabacInitIdc value) { return tcu::Format::Enum<StdVideoH264CabacInitIdc>(getdVideoH264CabacInitIdcName, value); }
+inline tcu::Format::Enum<StdVideoH264DisableDeblockingFilterIdc> getdVideoH264DisableDeblockingFilterIdcStr (StdVideoH264DisableDeblockingFilterIdc value) { return tcu::Format::Enum<StdVideoH264DisableDeblockingFilterIdc>(getdVideoH264DisableDeblockingFilterIdcName, value); }
+inline tcu::Format::Enum<StdVideoH264PictureType> getdVideoH264PictureTypeStr (StdVideoH264PictureType value) { return tcu::Format::Enum<StdVideoH264PictureType>(getdVideoH264PictureTypeName, value); }
+inline tcu::Format::Enum<StdVideoH264SliceType> getdVideoH264SliceTypeStr (StdVideoH264SliceType value) { return tcu::Format::Enum<StdVideoH264SliceType>(getdVideoH264SliceTypeName, value); }
+inline tcu::Format::Enum<StdVideoH264NonVclNaluType> getdVideoH264NonVclNaluTypeStr (StdVideoH264NonVclNaluType value) { return tcu::Format::Enum<StdVideoH264NonVclNaluType>(getdVideoH264NonVclNaluTypeName, value); }
+inline tcu::Format::Enum<StdVideoH265ChromaFormatIdc> getdVideoH265ChromaFormatIdcStr (StdVideoH265ChromaFormatIdc value) { return tcu::Format::Enum<StdVideoH265ChromaFormatIdc>(getdVideoH265ChromaFormatIdcName, value); }
+inline tcu::Format::Enum<StdVideoH265ProfileIdc> getdVideoH265ProfileIdcStr (StdVideoH265ProfileIdc value) { return tcu::Format::Enum<StdVideoH265ProfileIdc>(getdVideoH265ProfileIdcName, value); }
+inline tcu::Format::Enum<StdVideoH265Level> getdVideoH265LevelStr (StdVideoH265Level value) { return tcu::Format::Enum<StdVideoH265Level>(getdVideoH265LevelName, value); }
inline tcu::Format::Enum<VkFullScreenExclusiveEXT> getFullScreenExclusiveEXTStr (VkFullScreenExclusiveEXT value) { return tcu::Format::Enum<VkFullScreenExclusiveEXT>(getFullScreenExclusiveEXTName, value); }
inline std::ostream& operator<< (std::ostream& s, VkResult value) { return s << getResultStr(value); }
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);
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);
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);
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);
template<> const char* getTypeName<VkIndirectCommandsLayoutNV> (void) { return "VkIndirectCommandsLayoutNV"; }
template<> const char* getTypeName<VkPrivateDataSlotEXT> (void) { return "VkPrivateDataSlotEXT"; }
template<> const char* getTypeName<VkAccelerationStructureKHR> (void) { return "VkAccelerationStructureKHR"; }
+template<> const char* getTypeName<VkVideoSessionKHR> (void) { return "VkVideoSessionKHR"; }
+template<> const char* getTypeName<VkVideoSessionParametersKHR> (void) { return "VkVideoSessionParametersKHR"; }
namespace pt
{
}
}
+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)
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);
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);
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';
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<deUint8>(DE_ARRAY_BEGIN(value.cbr_flag)), tcu::Format::HexIterator<deUint8>(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<deUint8>(DE_ARRAY_BEGIN(value.max_dec_pic_buffering_minus1)), tcu::Format::HexIterator<deUint8>(DE_ARRAY_END(value.max_dec_pic_buffering_minus1))) << '\n';
+ s << "\tmax_num_reorder_pics = " << '\n' << tcu::formatArray(tcu::Format::HexIterator<deUint8>(DE_ARRAY_BEGIN(value.max_num_reorder_pics)), tcu::Format::HexIterator<deUint8>(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<deUint8>(DE_ARRAY_BEGIN(value.cpb_cnt_minus1)), tcu::Format::HexIterator<deUint8>(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<deUint8>(DE_ARRAY_BEGIN(value.ScalingListDCCoef16x16)), tcu::Format::HexIterator<deUint8>(DE_ARRAY_END(value.ScalingListDCCoef16x16))) << '\n';
+ s << "\tScalingListDCCoef32x32 = " << '\n' << tcu::formatArray(tcu::Format::HexIterator<deUint8>(DE_ARRAY_BEGIN(value.ScalingListDCCoef32x32)), tcu::Format::HexIterator<deUint8>(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<deUint8>(DE_ARRAY_BEGIN(value.RefPicSetStCurrBefore)), tcu::Format::HexIterator<deUint8>(DE_ARRAY_END(value.RefPicSetStCurrBefore))) << '\n';
+ s << "\tRefPicSetStCurrAfter = " << '\n' << tcu::formatArray(tcu::Format::HexIterator<deUint8>(DE_ARRAY_BEGIN(value.RefPicSetStCurrAfter)), tcu::Format::HexIterator<deUint8>(DE_ARRAY_END(value.RefPicSetStCurrAfter))) << '\n';
+ s << "\tRefPicSetLtCurr = " << '\n' << tcu::formatArray(tcu::Format::HexIterator<deUint8>(DE_ARRAY_BEGIN(value.RefPicSetLtCurr)), tcu::Format::HexIterator<deUint8>(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";
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;
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;
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;
+}
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;
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;
/* 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
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
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)
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):
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 ():
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:
"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])
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]):
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]
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 = """\
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
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"))
--- /dev/null
+/*
+** 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_
--- /dev/null
+/*
+** 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_
--- /dev/null
+/*
+** 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_
--- /dev/null
+/*
+** 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_
--- /dev/null
+/*
+** 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_
--- /dev/null
+/*
+** 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_
#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
*/
+#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"
} 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
projects / platform / upstream / VK-GL-CTS.git / commitdiff