From 5a5c9a643484d888873e32c5d7d484fae8e71d3d Mon Sep 17 00:00:00 2001 From: Jon Leech Date: Thu, 1 Feb 2024 05:48:32 -0800 Subject: [PATCH] Update for Vulkan-Docs 1.3.277 --- include/vk_video/vulkan_video_codec_av1std.h | 392 ++++++++++++ .../vulkan_video_codec_av1std_decode.h | 109 ++++ include/vulkan/vulkan.cppm | 12 + include/vulkan/vulkan.hpp | 68 +- include/vulkan/vulkan_core.h | 57 +- include/vulkan/vulkan_enums.hpp | 32 +- .../vulkan/vulkan_extension_inspection.hpp | 23 +- include/vulkan/vulkan_handles.hpp | 7 + include/vulkan/vulkan_hash.hpp | 75 +++ include/vulkan/vulkan_static_assertions.hpp | 34 + include/vulkan/vulkan_structs.hpp | 595 ++++++++++++++++++ include/vulkan/vulkan_to_string.hpp | 14 + registry/validusage.json | 242 +++++-- registry/video.xml | 485 ++++++++++++++ registry/vk.xml | 92 ++- registry/vkconventions.py | 1 + 16 files changed, 2169 insertions(+), 69 deletions(-) create mode 100644 include/vk_video/vulkan_video_codec_av1std.h create mode 100644 include/vk_video/vulkan_video_codec_av1std_decode.h diff --git a/include/vk_video/vulkan_video_codec_av1std.h b/include/vk_video/vulkan_video_codec_av1std.h new file mode 100644 index 0000000..8ce283e --- /dev/null +++ b/include/vk_video/vulkan_video_codec_av1std.h @@ -0,0 +1,392 @@ +#ifndef VULKAN_VIDEO_CODEC_AV1STD_H_ +#define VULKAN_VIDEO_CODEC_AV1STD_H_ 1 + +/* +** Copyright 2015-2024 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +// vulkan_video_codec_av1std is a preprocessor guard. Do not pass it to API calls. +#define vulkan_video_codec_av1std 1 +#include "vulkan_video_codecs_common.h" +#define STD_VIDEO_AV1_NUM_REF_FRAMES 8 +#define STD_VIDEO_AV1_REFS_PER_FRAME 7 +#define STD_VIDEO_AV1_TOTAL_REFS_PER_FRAME 8 +#define STD_VIDEO_AV1_MAX_TILE_COLS 64 +#define STD_VIDEO_AV1_MAX_TILE_ROWS 64 +#define STD_VIDEO_AV1_MAX_SEGMENTS 8 +#define STD_VIDEO_AV1_SEG_LVL_MAX 8 +#define STD_VIDEO_AV1_PRIMARY_REF_NONE 7 +#define STD_VIDEO_AV1_SELECT_INTEGER_MV 2 +#define STD_VIDEO_AV1_SELECT_SCREEN_CONTENT_TOOLS 2 +#define STD_VIDEO_AV1_SKIP_MODE_FRAMES 2 +#define STD_VIDEO_AV1_MAX_LOOP_FILTER_STRENGTHS 4 +#define STD_VIDEO_AV1_LOOP_FILTER_ADJUSTMENTS 2 +#define STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS 8 +#define STD_VIDEO_AV1_MAX_NUM_PLANES 3 +#define STD_VIDEO_AV1_GLOBAL_MOTION_PARAMS 6 +#define STD_VIDEO_AV1_MAX_NUM_Y_POINTS 14 +#define STD_VIDEO_AV1_MAX_NUM_CB_POINTS 10 +#define STD_VIDEO_AV1_MAX_NUM_CR_POINTS 10 +#define STD_VIDEO_AV1_MAX_NUM_POS_LUMA 24 +#define STD_VIDEO_AV1_MAX_NUM_POS_CHROMA 25 + +typedef enum StdVideoAV1Profile { + STD_VIDEO_AV1_PROFILE_MAIN = 0, + STD_VIDEO_AV1_PROFILE_HIGH = 1, + STD_VIDEO_AV1_PROFILE_PROFESSIONAL = 2, + STD_VIDEO_AV1_PROFILE_INVALID = 0x7FFFFFFF, + STD_VIDEO_AV1_PROFILE_MAX_ENUM = 0x7FFFFFFF +} StdVideoAV1Profile; + +typedef enum StdVideoAV1Level { + STD_VIDEO_AV1_LEVEL_2_0 = 0, + STD_VIDEO_AV1_LEVEL_2_1 = 1, + STD_VIDEO_AV1_LEVEL_2_2 = 2, + STD_VIDEO_AV1_LEVEL_2_3 = 3, + STD_VIDEO_AV1_LEVEL_3_0 = 4, + STD_VIDEO_AV1_LEVEL_3_1 = 5, + STD_VIDEO_AV1_LEVEL_3_2 = 6, + STD_VIDEO_AV1_LEVEL_3_3 = 7, + STD_VIDEO_AV1_LEVEL_4_0 = 8, + STD_VIDEO_AV1_LEVEL_4_1 = 9, + STD_VIDEO_AV1_LEVEL_4_2 = 10, + STD_VIDEO_AV1_LEVEL_4_3 = 11, + STD_VIDEO_AV1_LEVEL_5_0 = 12, + STD_VIDEO_AV1_LEVEL_5_1 = 13, + STD_VIDEO_AV1_LEVEL_5_2 = 14, + STD_VIDEO_AV1_LEVEL_5_3 = 15, + STD_VIDEO_AV1_LEVEL_6_0 = 16, + STD_VIDEO_AV1_LEVEL_6_1 = 17, + STD_VIDEO_AV1_LEVEL_6_2 = 18, + STD_VIDEO_AV1_LEVEL_6_3 = 19, + STD_VIDEO_AV1_LEVEL_7_0 = 20, + STD_VIDEO_AV1_LEVEL_7_1 = 21, + STD_VIDEO_AV1_LEVEL_7_2 = 22, + STD_VIDEO_AV1_LEVEL_7_3 = 23, + STD_VIDEO_AV1_LEVEL_INVALID = 0x7FFFFFFF, + STD_VIDEO_AV1_LEVEL_MAX_ENUM = 0x7FFFFFFF +} StdVideoAV1Level; + +typedef enum StdVideoAV1FrameType { + STD_VIDEO_AV1_FRAME_TYPE_KEY = 0, + STD_VIDEO_AV1_FRAME_TYPE_INTER = 1, + STD_VIDEO_AV1_FRAME_TYPE_INTRA_ONLY = 2, + STD_VIDEO_AV1_FRAME_TYPE_SWITCH = 3, + STD_VIDEO_AV1_FRAME_TYPE_INVALID = 0x7FFFFFFF, + STD_VIDEO_AV1_FRAME_TYPE_MAX_ENUM = 0x7FFFFFFF +} StdVideoAV1FrameType; + +typedef enum StdVideoAV1ReferenceName { + STD_VIDEO_AV1_REFERENCE_NAME_INTRA_FRAME = 0, + STD_VIDEO_AV1_REFERENCE_NAME_LAST_FRAME = 1, + STD_VIDEO_AV1_REFERENCE_NAME_LAST2_FRAME = 2, + STD_VIDEO_AV1_REFERENCE_NAME_LAST3_FRAME = 3, + STD_VIDEO_AV1_REFERENCE_NAME_GOLDEN_FRAME = 4, + STD_VIDEO_AV1_REFERENCE_NAME_BWDREF_FRAME = 5, + STD_VIDEO_AV1_REFERENCE_NAME_ALTREF2_FRAME = 6, + STD_VIDEO_AV1_REFERENCE_NAME_ALTREF_FRAME = 7, + STD_VIDEO_AV1_REFERENCE_NAME_INVALID = 0x7FFFFFFF, + STD_VIDEO_AV1_REFERENCE_NAME_MAX_ENUM = 0x7FFFFFFF +} StdVideoAV1ReferenceName; + +typedef enum StdVideoAV1InterpolationFilter { + STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP = 0, + STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH = 1, + STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP_SHARP = 2, + STD_VIDEO_AV1_INTERPOLATION_FILTER_BILINEAR = 3, + STD_VIDEO_AV1_INTERPOLATION_FILTER_SWITCHABLE = 4, + STD_VIDEO_AV1_INTERPOLATION_FILTER_INVALID = 0x7FFFFFFF, + STD_VIDEO_AV1_INTERPOLATION_FILTER_MAX_ENUM = 0x7FFFFFFF +} StdVideoAV1InterpolationFilter; + +typedef enum StdVideoAV1TxMode { + STD_VIDEO_AV1_TX_MODE_ONLY_4X4 = 0, + STD_VIDEO_AV1_TX_MODE_LARGEST = 1, + STD_VIDEO_AV1_TX_MODE_SELECT = 2, + STD_VIDEO_AV1_TX_MODE_INVALID = 0x7FFFFFFF, + STD_VIDEO_AV1_TX_MODE_MAX_ENUM = 0x7FFFFFFF +} StdVideoAV1TxMode; + +typedef enum StdVideoAV1FrameRestorationType { + STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_NONE = 0, + STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_WIENER = 1, + STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_SGRPROJ = 2, + STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_SWITCHABLE = 3, + STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_INVALID = 0x7FFFFFFF, + STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_MAX_ENUM = 0x7FFFFFFF +} StdVideoAV1FrameRestorationType; + +typedef enum StdVideoAV1ColorPrimaries { + STD_VIDEO_AV1_COLOR_PRIMARIES_BT_709 = 1, + STD_VIDEO_AV1_COLOR_PRIMARIES_BT_UNSPECIFIED = 2, + STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_M = 4, + STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_B_G = 5, + STD_VIDEO_AV1_COLOR_PRIMARIES_BT_601 = 6, + STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_240 = 7, + STD_VIDEO_AV1_COLOR_PRIMARIES_GENERIC_FILM = 8, + STD_VIDEO_AV1_COLOR_PRIMARIES_BT_2020 = 9, + STD_VIDEO_AV1_COLOR_PRIMARIES_XYZ = 10, + STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_431 = 11, + STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_432 = 12, + STD_VIDEO_AV1_COLOR_PRIMARIES_EBU_3213 = 22, + STD_VIDEO_AV1_COLOR_PRIMARIES_INVALID = 0x7FFFFFFF, + STD_VIDEO_AV1_COLOR_PRIMARIES_MAX_ENUM = 0x7FFFFFFF +} StdVideoAV1ColorPrimaries; + +typedef enum StdVideoAV1TransferCharacteristics { + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_RESERVED_0 = 0, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_709 = 1, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_UNSPECIFIED = 2, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_RESERVED_3 = 3, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_470_M = 4, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_470_B_G = 5, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_601 = 6, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_240 = 7, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LINEAR = 8, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LOG_100 = 9, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LOG_100_SQRT10 = 10, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_IEC_61966 = 11, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_1361 = 12, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SRGB = 13, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_2020_10_BIT = 14, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_2020_12_BIT = 15, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_2084 = 16, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_428 = 17, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_HLG = 18, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_INVALID = 0x7FFFFFFF, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_MAX_ENUM = 0x7FFFFFFF +} StdVideoAV1TransferCharacteristics; + +typedef enum StdVideoAV1MatrixCoefficients { + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_IDENTITY = 0, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_709 = 1, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_UNSPECIFIED = 2, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_RESERVED_3 = 3, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_FCC = 4, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_470_B_G = 5, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_601 = 6, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_240 = 7, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_YCGCO = 8, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_2020_NCL = 9, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_2020_CL = 10, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_2085 = 11, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_CHROMAT_NCL = 12, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_CHROMAT_CL = 13, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_ICTCP = 14, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_INVALID = 0x7FFFFFFF, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_MAX_ENUM = 0x7FFFFFFF +} StdVideoAV1MatrixCoefficients; + +typedef enum StdVideoAV1ChromaSamplePosition { + STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_UNKNOWN = 0, + STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_VERTICAL = 1, + STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_COLOCATED = 2, + STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_RESERVED = 3, + STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_INVALID = 0x7FFFFFFF, + STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_MAX_ENUM = 0x7FFFFFFF +} StdVideoAV1ChromaSamplePosition; +typedef struct StdVideoAV1ColorConfigFlags { + uint32_t mono_chrome : 1; + uint32_t color_range : 1; + uint32_t separate_uv_delta_q : 1; + uint32_t color_description_present_flag : 1; + uint32_t reserved : 28; +} StdVideoAV1ColorConfigFlags; + +typedef struct StdVideoAV1ColorConfig { + StdVideoAV1ColorConfigFlags flags; + uint8_t BitDepth; + uint8_t subsampling_x; + uint8_t subsampling_y; + uint8_t reserved1; + StdVideoAV1ColorPrimaries color_primaries; + StdVideoAV1TransferCharacteristics transfer_characteristics; + StdVideoAV1MatrixCoefficients matrix_coefficients; + StdVideoAV1ChromaSamplePosition chroma_sample_position; +} StdVideoAV1ColorConfig; + +typedef struct StdVideoAV1TimingInfoFlags { + uint32_t equal_picture_interval : 1; + uint32_t reserved : 31; +} StdVideoAV1TimingInfoFlags; + +typedef struct StdVideoAV1TimingInfo { + StdVideoAV1TimingInfoFlags flags; + uint32_t num_units_in_display_tick; + uint32_t time_scale; + uint32_t num_ticks_per_picture_minus_1; +} StdVideoAV1TimingInfo; + +typedef struct StdVideoAV1LoopFilterFlags { + uint32_t loop_filter_delta_enabled : 1; + uint32_t loop_filter_delta_update : 1; + uint32_t reserved : 30; +} StdVideoAV1LoopFilterFlags; + +typedef struct StdVideoAV1LoopFilter { + StdVideoAV1LoopFilterFlags flags; + uint8_t loop_filter_level[STD_VIDEO_AV1_MAX_LOOP_FILTER_STRENGTHS]; + uint8_t loop_filter_sharpness; + uint8_t update_ref_delta; + int8_t loop_filter_ref_deltas[STD_VIDEO_AV1_TOTAL_REFS_PER_FRAME]; + uint8_t update_mode_delta; + int8_t loop_filter_mode_deltas[STD_VIDEO_AV1_LOOP_FILTER_ADJUSTMENTS]; +} StdVideoAV1LoopFilter; + +typedef struct StdVideoAV1QuantizationFlags { + uint32_t using_qmatrix : 1; + uint32_t diff_uv_delta : 1; + uint32_t reserved : 30; +} StdVideoAV1QuantizationFlags; + +typedef struct StdVideoAV1Quantization { + StdVideoAV1QuantizationFlags flags; + uint8_t base_q_idx; + int8_t DeltaQYDc; + int8_t DeltaQUDc; + int8_t DeltaQUAc; + int8_t DeltaQVDc; + int8_t DeltaQVAc; + uint8_t qm_y; + uint8_t qm_u; + uint8_t qm_v; +} StdVideoAV1Quantization; + +typedef struct StdVideoAV1Segmentation { + uint8_t FeatureEnabled[STD_VIDEO_AV1_MAX_SEGMENTS]; + int16_t FeatureData[STD_VIDEO_AV1_MAX_SEGMENTS][STD_VIDEO_AV1_SEG_LVL_MAX]; +} StdVideoAV1Segmentation; + +typedef struct StdVideoAV1TileInfoFlags { + uint32_t uniform_tile_spacing_flag : 1; + uint32_t reserved : 31; +} StdVideoAV1TileInfoFlags; + +typedef struct StdVideoAV1TileInfo { + StdVideoAV1TileInfoFlags flags; + uint8_t TileCols; + uint8_t TileRows; + uint16_t context_update_tile_id; + uint8_t tile_size_bytes_minus_1; + uint8_t reserved1[7]; + const uint16_t* pMiColStarts; + const uint16_t* pMiRowStarts; + const uint16_t* pWidthInSbsMinus1; + const uint16_t* pHeightInSbsMinus1; +} StdVideoAV1TileInfo; + +typedef struct StdVideoAV1CDEF { + uint8_t cdef_damping_minus_3; + uint8_t cdef_bits; + uint8_t cdef_y_pri_strength[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS]; + uint8_t cdef_y_sec_strength[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS]; + uint8_t cdef_uv_pri_strength[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS]; + uint8_t cdef_uv_sec_strength[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS]; +} StdVideoAV1CDEF; + +typedef struct StdVideoAV1LoopRestoration { + StdVideoAV1FrameRestorationType FrameRestorationType[STD_VIDEO_AV1_MAX_NUM_PLANES]; + uint16_t LoopRestorationSize[STD_VIDEO_AV1_MAX_NUM_PLANES]; +} StdVideoAV1LoopRestoration; + +typedef struct StdVideoAV1GlobalMotion { + uint8_t GmType[STD_VIDEO_AV1_NUM_REF_FRAMES]; + int32_t gm_params[STD_VIDEO_AV1_NUM_REF_FRAMES][STD_VIDEO_AV1_GLOBAL_MOTION_PARAMS]; +} StdVideoAV1GlobalMotion; + +typedef struct StdVideoAV1FilmGrainFlags { + uint32_t chroma_scaling_from_luma : 1; + uint32_t overlap_flag : 1; + uint32_t clip_to_restricted_range : 1; + uint32_t update_grain : 1; + uint32_t reserved : 28; +} StdVideoAV1FilmGrainFlags; + +typedef struct StdVideoAV1FilmGrain { + StdVideoAV1FilmGrainFlags flags; + uint8_t grain_scaling_minus_8; + uint8_t ar_coeff_lag; + uint8_t ar_coeff_shift_minus_6; + uint8_t grain_scale_shift; + uint16_t grain_seed; + uint8_t film_grain_params_ref_idx; + uint8_t num_y_points; + uint8_t point_y_value[STD_VIDEO_AV1_MAX_NUM_Y_POINTS]; + uint8_t point_y_scaling[STD_VIDEO_AV1_MAX_NUM_Y_POINTS]; + uint8_t num_cb_points; + uint8_t point_cb_value[STD_VIDEO_AV1_MAX_NUM_CB_POINTS]; + uint8_t point_cb_scaling[STD_VIDEO_AV1_MAX_NUM_CB_POINTS]; + uint8_t num_cr_points; + uint8_t point_cr_value[STD_VIDEO_AV1_MAX_NUM_CR_POINTS]; + uint8_t point_cr_scaling[STD_VIDEO_AV1_MAX_NUM_CR_POINTS]; + int8_t ar_coeffs_y_plus_128[STD_VIDEO_AV1_MAX_NUM_POS_LUMA]; + int8_t ar_coeffs_cb_plus_128[STD_VIDEO_AV1_MAX_NUM_POS_CHROMA]; + int8_t ar_coeffs_cr_plus_128[STD_VIDEO_AV1_MAX_NUM_POS_CHROMA]; + uint8_t cb_mult; + uint8_t cb_luma_mult; + uint16_t cb_offset; + uint8_t cr_mult; + uint8_t cr_luma_mult; + uint16_t cr_offset; +} StdVideoAV1FilmGrain; + +typedef struct StdVideoAV1SequenceHeaderFlags { + uint32_t still_picture : 1; + uint32_t reduced_still_picture_header : 1; + uint32_t use_128x128_superblock : 1; + uint32_t enable_filter_intra : 1; + uint32_t enable_intra_edge_filter : 1; + uint32_t enable_interintra_compound : 1; + uint32_t enable_masked_compound : 1; + uint32_t enable_warped_motion : 1; + uint32_t enable_dual_filter : 1; + uint32_t enable_order_hint : 1; + uint32_t enable_jnt_comp : 1; + uint32_t enable_ref_frame_mvs : 1; + uint32_t frame_id_numbers_present_flag : 1; + uint32_t enable_superres : 1; + uint32_t enable_cdef : 1; + uint32_t enable_restoration : 1; + uint32_t film_grain_params_present : 1; + uint32_t timing_info_present_flag : 1; + uint32_t initial_display_delay_present_flag : 1; + uint32_t reserved : 13; +} StdVideoAV1SequenceHeaderFlags; + +typedef struct StdVideoAV1SequenceHeader { + StdVideoAV1SequenceHeaderFlags flags; + StdVideoAV1Profile seq_profile; + uint8_t frame_width_bits_minus_1; + uint8_t frame_height_bits_minus_1; + uint16_t max_frame_width_minus_1; + uint16_t max_frame_height_minus_1; + uint8_t delta_frame_id_length_minus_2; + uint8_t additional_frame_id_length_minus_1; + uint8_t order_hint_bits_minus_1; + uint8_t seq_force_integer_mv; + uint8_t seq_force_screen_content_tools; + uint8_t reserved1[5]; + const StdVideoAV1ColorConfig* pColorConfig; + const StdVideoAV1TimingInfo* pTimingInfo; +} StdVideoAV1SequenceHeader; + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/vk_video/vulkan_video_codec_av1std_decode.h b/include/vk_video/vulkan_video_codec_av1std_decode.h new file mode 100644 index 0000000..6b8130c --- /dev/null +++ b/include/vk_video/vulkan_video_codec_av1std_decode.h @@ -0,0 +1,109 @@ +#ifndef VULKAN_VIDEO_CODEC_AV1STD_DECODE_H_ +#define VULKAN_VIDEO_CODEC_AV1STD_DECODE_H_ 1 + +/* +** Copyright 2015-2024 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +// vulkan_video_codec_av1std_decode is a preprocessor guard. Do not pass it to API calls. +#define vulkan_video_codec_av1std_decode 1 +#include "vulkan_video_codec_av1std.h" + +#define VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_API_VERSION_1_0_0 VK_MAKE_VIDEO_STD_VERSION(1, 0, 0) + +#define VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_API_VERSION_1_0_0 +#define VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_av1_decode" +typedef struct StdVideoDecodeAV1PictureInfoFlags { + uint32_t error_resilient_mode : 1; + uint32_t disable_cdf_update : 1; + uint32_t use_superres : 1; + uint32_t render_and_frame_size_different : 1; + uint32_t allow_screen_content_tools : 1; + uint32_t is_filter_switchable : 1; + uint32_t force_integer_mv : 1; + uint32_t frame_size_override_flag : 1; + uint32_t buffer_removal_time_present_flag : 1; + uint32_t allow_intrabc : 1; + uint32_t frame_refs_short_signaling : 1; + uint32_t allow_high_precision_mv : 1; + uint32_t is_motion_mode_switchable : 1; + uint32_t use_ref_frame_mvs : 1; + uint32_t disable_frame_end_update_cdf : 1; + uint32_t allow_warped_motion : 1; + uint32_t reduced_tx_set : 1; + uint32_t reference_select : 1; + uint32_t skip_mode_present : 1; + uint32_t delta_q_present : 1; + uint32_t delta_lf_present : 1; + uint32_t delta_lf_multi : 1; + uint32_t segmentation_enabled : 1; + uint32_t segmentation_update_map : 1; + uint32_t segmentation_temporal_update : 1; + uint32_t segmentation_update_data : 1; + uint32_t UsesLr : 1; + uint32_t usesChromaLr : 1; + uint32_t apply_grain : 1; + uint32_t reserved : 3; +} StdVideoDecodeAV1PictureInfoFlags; + +typedef struct StdVideoDecodeAV1PictureInfo { + StdVideoDecodeAV1PictureInfoFlags flags; + StdVideoAV1FrameType frame_type; + uint32_t current_frame_id; + uint8_t OrderHint; + uint8_t primary_ref_frame; + uint8_t refresh_frame_flags; + uint8_t reserved1; + StdVideoAV1InterpolationFilter interpolation_filter; + StdVideoAV1TxMode TxMode; + uint8_t delta_q_res; + uint8_t delta_lf_res; + uint8_t SkipModeFrame[STD_VIDEO_AV1_SKIP_MODE_FRAMES]; + uint8_t coded_denom; + uint8_t reserved2[3]; + uint8_t OrderHints[STD_VIDEO_AV1_NUM_REF_FRAMES]; + uint32_t expectedFrameId[STD_VIDEO_AV1_NUM_REF_FRAMES]; + const StdVideoAV1TileInfo* pTileInfo; + const StdVideoAV1Quantization* pQuantization; + const StdVideoAV1Segmentation* pSegmentation; + const StdVideoAV1LoopFilter* pLoopFilter; + const StdVideoAV1CDEF* pCDEF; + const StdVideoAV1LoopRestoration* pLoopRestoration; + const StdVideoAV1GlobalMotion* pGlobalMotion; + const StdVideoAV1FilmGrain* pFilmGrain; +} StdVideoDecodeAV1PictureInfo; + +typedef struct StdVideoDecodeAV1ReferenceInfoFlags { + uint32_t disable_frame_end_update_cdf : 1; + uint32_t segmentation_enabled : 1; + uint32_t reserved : 30; +} StdVideoDecodeAV1ReferenceInfoFlags; + +typedef struct StdVideoDecodeAV1ReferenceInfo { + StdVideoDecodeAV1ReferenceInfoFlags flags; + uint8_t frame_type; + uint8_t RefFrameSignBias; + uint8_t OrderHint; + uint8_t SavedOrderHints[STD_VIDEO_AV1_NUM_REF_FRAMES]; +} StdVideoDecodeAV1ReferenceInfo; + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/vulkan/vulkan.cppm b/include/vulkan/vulkan.cppm index cf3c71f..c24ddce 100644 --- a/include/vulkan/vulkan.cppm +++ b/include/vulkan/vulkan.cppm @@ -2412,6 +2412,11 @@ export namespace VULKAN_HPP_NAMESPACE using VULKAN_HPP_NAMESPACE::QCOMMultiviewPerViewRenderAreasExtensionName; using VULKAN_HPP_NAMESPACE::QCOMMultiviewPerViewRenderAreasSpecVersion; + //=== VK_KHR_video_decode_av1 === + using VULKAN_HPP_NAMESPACE::KHRVideoDecodeAv1ExtensionName; + using VULKAN_HPP_NAMESPACE::KHRVideoDecodeAv1SpecVersion; + using VULKAN_HPP_NAMESPACE::MaxVideoAv1ReferencesPerFrameKHR; + //=== VK_KHR_video_maintenance1 === using VULKAN_HPP_NAMESPACE::KHRVideoMaintenance1ExtensionName; using VULKAN_HPP_NAMESPACE::KHRVideoMaintenance1SpecVersion; @@ -4227,6 +4232,13 @@ export namespace VULKAN_HPP_NAMESPACE using VULKAN_HPP_NAMESPACE::MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM; using VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM; + //=== VK_KHR_video_decode_av1 === + using VULKAN_HPP_NAMESPACE::VideoDecodeAV1CapabilitiesKHR; + using VULKAN_HPP_NAMESPACE::VideoDecodeAV1DpbSlotInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoDecodeAV1PictureInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoDecodeAV1ProfileInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoDecodeAV1SessionParametersCreateInfoKHR; + //=== VK_KHR_video_maintenance1 === using VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoMaintenance1FeaturesKHR; using VULKAN_HPP_NAMESPACE::VideoInlineQueryInfoKHR; diff --git a/include/vulkan/vulkan.hpp b/include/vulkan/vulkan.hpp index 23ca0cd..c893919 100644 --- a/include/vulkan/vulkan.hpp +++ b/include/vulkan/vulkan.hpp @@ -56,7 +56,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h # include #endif -static_assert( VK_HEADER_VERSION == 276, "Wrong VK_HEADER_VERSION!" ); +static_assert( VK_HEADER_VERSION == 277, "Wrong VK_HEADER_VERSION!" ); // includes through some other header // this results in major(x) being resolved to gnu_dev_major(x) @@ -6852,6 +6852,9 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_EXT_shader_module_identifier === VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxShaderModuleIdentifierSizeEXT = VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT; + //=== VK_KHR_video_decode_av1 === + VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxVideoAv1ReferencesPerFrameKHR = VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR; + //======================== //=== CONSTEXPR VALUEs === //======================== @@ -7969,8 +7972,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_CONSTEXPR_INLINE auto KHRBufferDeviceAddressSpecVersion = VK_KHR_BUFFER_DEVICE_ADDRESS_SPEC_VERSION; //=== VK_EXT_line_rasterization === + VULKAN_HPP_DEPRECATED( "The VK_EXT_line_rasterization extension has been promoted to VK_KHR_line_rasterization." ) VULKAN_HPP_CONSTEXPR_INLINE auto EXTLineRasterizationExtensionName = VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTLineRasterizationSpecVersion = VK_EXT_LINE_RASTERIZATION_SPEC_VERSION; + VULKAN_HPP_DEPRECATED( "The VK_EXT_line_rasterization extension has been promoted to VK_KHR_line_rasterization." ) + VULKAN_HPP_CONSTEXPR_INLINE auto EXTLineRasterizationSpecVersion = VK_EXT_LINE_RASTERIZATION_SPEC_VERSION; //=== VK_EXT_shader_atomic_float === VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderAtomicFloatExtensionName = VK_EXT_SHADER_ATOMIC_FLOAT_EXTENSION_NAME; @@ -8584,6 +8589,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_CONSTEXPR_INLINE auto QCOMMultiviewPerViewRenderAreasExtensionName = VK_QCOM_MULTIVIEW_PER_VIEW_RENDER_AREAS_EXTENSION_NAME; VULKAN_HPP_CONSTEXPR_INLINE auto QCOMMultiviewPerViewRenderAreasSpecVersion = VK_QCOM_MULTIVIEW_PER_VIEW_RENDER_AREAS_SPEC_VERSION; + //=== VK_KHR_video_decode_av1 === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoDecodeAv1ExtensionName = VK_KHR_VIDEO_DECODE_AV1_EXTENSION_NAME; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoDecodeAv1SpecVersion = VK_KHR_VIDEO_DECODE_AV1_SPEC_VERSION; + //=== VK_KHR_video_maintenance1 === VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoMaintenance1ExtensionName = VK_KHR_VIDEO_MAINTENANCE_1_EXTENSION_NAME; VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoMaintenance1SpecVersion = VK_KHR_VIDEO_MAINTENANCE_1_SPEC_VERSION; @@ -16029,6 +16038,61 @@ namespace VULKAN_HPP_NAMESPACE }; }; + //=== VK_KHR_video_decode_av1 === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + //=== VK_KHR_video_maintenance1 === template <> struct StructExtends diff --git a/include/vulkan/vulkan_core.h b/include/vulkan/vulkan_core.h index 10d97d8..a4666ed 100644 --- a/include/vulkan/vulkan_core.h +++ b/include/vulkan/vulkan_core.h @@ -69,7 +69,7 @@ extern "C" { #define VK_API_VERSION_1_0 VK_MAKE_API_VERSION(0, 1, 0, 0)// Patch version should always be set to 0 // Version of this file -#define VK_HEADER_VERSION 276 +#define VK_HEADER_VERSION 277 // Complete version of this file #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 3, VK_HEADER_VERSION) @@ -1061,6 +1061,11 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR = 1000506002, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM = 1000510000, VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM = 1000510001, + VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR = 1000512000, + VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR = 1000512001, + VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR = 1000512003, + VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000512004, + VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR = 1000512005, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR = 1000515000, VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR = 1000515001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV = 1000516000, @@ -4938,6 +4943,8 @@ typedef enum VkSubgroupFeatureFlagBits { VK_SUBGROUP_FEATURE_CLUSTERED_BIT = 0x00000040, VK_SUBGROUP_FEATURE_QUAD_BIT = 0x00000080, VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV = 0x00000100, + VK_SUBGROUP_FEATURE_ROTATE_BIT_KHR = 0x00000200, + VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT_KHR = 0x00000400, VK_SUBGROUP_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkSubgroupFeatureFlagBits; typedef VkFlags VkSubgroupFeatureFlags; @@ -7977,6 +7984,7 @@ typedef enum VkVideoCodecOperationFlagBitsKHR { VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR = 0x00020000, VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR = 0x00000001, VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR = 0x00000002, + VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR = 0x00000004, VK_VIDEO_CODEC_OPERATION_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF } VkVideoCodecOperationFlagBitsKHR; typedef VkFlags VkVideoCodecOperationFlagsKHR; @@ -11046,7 +11054,7 @@ VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageSparseMemoryRequirementsKHR( // VK_KHR_shader_subgroup_rotate is a preprocessor guard. Do not pass it to API calls. #define VK_KHR_shader_subgroup_rotate 1 -#define VK_KHR_SHADER_SUBGROUP_ROTATE_SPEC_VERSION 1 +#define VK_KHR_SHADER_SUBGROUP_ROTATE_SPEC_VERSION 2 #define VK_KHR_SHADER_SUBGROUP_ROTATE_EXTENSION_NAME "VK_KHR_shader_subgroup_rotate" typedef struct VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR { VkStructureType sType; @@ -11325,6 +11333,51 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR #endif +// VK_KHR_video_decode_av1 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_video_decode_av1 1 +#include "vk_video/vulkan_video_codec_av1std.h" +#include "vk_video/vulkan_video_codec_av1std_decode.h" +#define VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR 7U +#define VK_KHR_VIDEO_DECODE_AV1_SPEC_VERSION 1 +#define VK_KHR_VIDEO_DECODE_AV1_EXTENSION_NAME "VK_KHR_video_decode_av1" +typedef struct VkVideoDecodeAV1ProfileInfoKHR { + VkStructureType sType; + const void* pNext; + StdVideoAV1Profile stdProfile; + VkBool32 filmGrainSupport; +} VkVideoDecodeAV1ProfileInfoKHR; + +typedef struct VkVideoDecodeAV1CapabilitiesKHR { + VkStructureType sType; + void* pNext; + StdVideoAV1Level maxLevel; +} VkVideoDecodeAV1CapabilitiesKHR; + +typedef struct VkVideoDecodeAV1SessionParametersCreateInfoKHR { + VkStructureType sType; + const void* pNext; + const StdVideoAV1SequenceHeader* pStdSequenceHeader; +} VkVideoDecodeAV1SessionParametersCreateInfoKHR; + +typedef struct VkVideoDecodeAV1PictureInfoKHR { + VkStructureType sType; + const void* pNext; + const StdVideoDecodeAV1PictureInfo* pStdPictureInfo; + int32_t referenceNameSlotIndices[VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR]; + uint32_t frameHeaderOffset; + uint32_t tileCount; + const uint32_t* pTileOffsets; + const uint32_t* pTileSizes; +} VkVideoDecodeAV1PictureInfoKHR; + +typedef struct VkVideoDecodeAV1DpbSlotInfoKHR { + VkStructureType sType; + const void* pNext; + const StdVideoDecodeAV1ReferenceInfo* pStdReferenceInfo; +} VkVideoDecodeAV1DpbSlotInfoKHR; + + + // VK_KHR_video_maintenance1 is a preprocessor guard. Do not pass it to API calls. #define VK_KHR_video_maintenance1 1 #define VK_KHR_VIDEO_MAINTENANCE_1_SPEC_VERSION 1 diff --git a/include/vulkan/vulkan_enums.hpp b/include/vulkan/vulkan_enums.hpp index b242eff..547553a 100644 --- a/include/vulkan/vulkan_enums.hpp +++ b/include/vulkan/vulkan_enums.hpp @@ -1372,6 +1372,11 @@ namespace VULKAN_HPP_NAMESPACE ePhysicalDeviceCooperativeMatrixPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR, ePhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM, eMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM, + eVideoDecodeAv1CapabilitiesKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR, + eVideoDecodeAv1PictureInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR, + eVideoDecodeAv1ProfileInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR, + eVideoDecodeAv1SessionParametersCreateInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR, + eVideoDecodeAv1DpbSlotInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR, ePhysicalDeviceVideoMaintenance1FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR, eVideoInlineQueryInfoKHR = VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR, ePhysicalDevicePerStageDescriptorSetFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV, @@ -3587,15 +3592,17 @@ namespace VULKAN_HPP_NAMESPACE enum class SubgroupFeatureFlagBits : VkSubgroupFeatureFlags { - eBasic = VK_SUBGROUP_FEATURE_BASIC_BIT, - eVote = VK_SUBGROUP_FEATURE_VOTE_BIT, - eArithmetic = VK_SUBGROUP_FEATURE_ARITHMETIC_BIT, - eBallot = VK_SUBGROUP_FEATURE_BALLOT_BIT, - eShuffle = VK_SUBGROUP_FEATURE_SHUFFLE_BIT, - eShuffleRelative = VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT, - eClustered = VK_SUBGROUP_FEATURE_CLUSTERED_BIT, - eQuad = VK_SUBGROUP_FEATURE_QUAD_BIT, - ePartitionedNV = VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV + eBasic = VK_SUBGROUP_FEATURE_BASIC_BIT, + eVote = VK_SUBGROUP_FEATURE_VOTE_BIT, + eArithmetic = VK_SUBGROUP_FEATURE_ARITHMETIC_BIT, + eBallot = VK_SUBGROUP_FEATURE_BALLOT_BIT, + eShuffle = VK_SUBGROUP_FEATURE_SHUFFLE_BIT, + eShuffleRelative = VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT, + eClustered = VK_SUBGROUP_FEATURE_CLUSTERED_BIT, + eQuad = VK_SUBGROUP_FEATURE_QUAD_BIT, + ePartitionedNV = VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV, + eRotateKHR = VK_SUBGROUP_FEATURE_ROTATE_BIT_KHR, + eRotateClusteredKHR = VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT_KHR }; using SubgroupFeatureFlags = Flags; @@ -3607,7 +3614,7 @@ namespace VULKAN_HPP_NAMESPACE static VULKAN_HPP_CONST_OR_CONSTEXPR SubgroupFeatureFlags allFlags = SubgroupFeatureFlagBits::eBasic | SubgroupFeatureFlagBits::eVote | SubgroupFeatureFlagBits::eArithmetic | SubgroupFeatureFlagBits::eBallot | SubgroupFeatureFlagBits::eShuffle | SubgroupFeatureFlagBits::eShuffleRelative | SubgroupFeatureFlagBits::eClustered | SubgroupFeatureFlagBits::eQuad | - SubgroupFeatureFlagBits::ePartitionedNV; + SubgroupFeatureFlagBits::ePartitionedNV | SubgroupFeatureFlagBits::eRotateKHR | SubgroupFeatureFlagBits::eRotateClusteredKHR; }; enum class PeerMemoryFeatureFlagBits : VkPeerMemoryFeatureFlags @@ -4699,7 +4706,8 @@ namespace VULKAN_HPP_NAMESPACE eEncodeH264 = VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR, eEncodeH265 = VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR, eDecodeH264 = VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR, - eDecodeH265 = VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR + eDecodeH265 = VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR, + eDecodeAv1 = VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR }; using VideoCodecOperationFlagsKHR = Flags; @@ -4710,7 +4718,7 @@ namespace VULKAN_HPP_NAMESPACE static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR VideoCodecOperationFlagsKHR allFlags = VideoCodecOperationFlagBitsKHR::eNone | VideoCodecOperationFlagBitsKHR::eEncodeH264 | VideoCodecOperationFlagBitsKHR::eEncodeH265 | - VideoCodecOperationFlagBitsKHR::eDecodeH264 | VideoCodecOperationFlagBitsKHR::eDecodeH265; + VideoCodecOperationFlagBitsKHR::eDecodeH264 | VideoCodecOperationFlagBitsKHR::eDecodeH265 | VideoCodecOperationFlagBitsKHR::eDecodeAv1; }; enum class VideoChromaSubsamplingFlagBitsKHR : VkVideoChromaSubsamplingFlagsKHR diff --git a/include/vulkan/vulkan_extension_inspection.hpp b/include/vulkan/vulkan_extension_inspection.hpp index 100b141..75958da 100644 --- a/include/vulkan/vulkan_extension_inspection.hpp +++ b/include/vulkan/vulkan_extension_inspection.hpp @@ -412,6 +412,7 @@ namespace VULKAN_HPP_NAMESPACE "VK_NV_low_latency2", "VK_KHR_cooperative_matrix", "VK_QCOM_multiview_per_view_render_areas", + "VK_KHR_video_decode_av1", "VK_KHR_video_maintenance1", "VK_NV_per_stage_descriptor_set", "VK_QCOM_image_processing2", @@ -2010,6 +2011,11 @@ namespace VULKAN_HPP_NAMESPACE { { "VK_KHR_get_physical_device_properties2", } } } } }, + { "VK_KHR_video_decode_av1", + { { "VK_VERSION_1_0", + { { + "VK_KHR_video_decode_queue", + } } } } }, { "VK_KHR_video_maintenance1", { { "VK_VERSION_1_0", { { @@ -2205,6 +2211,7 @@ namespace VULKAN_HPP_NAMESPACE { "VK_EXT_separate_stencil_usage", "VK_VERSION_1_2" }, { "VK_KHR_uniform_buffer_standard_layout", "VK_VERSION_1_2" }, { "VK_KHR_buffer_device_address", "VK_VERSION_1_2" }, + { "VK_EXT_line_rasterization", "VK_KHR_line_rasterization" }, { "VK_EXT_host_query_reset", "VK_VERSION_1_2" }, { "VK_EXT_index_type_uint8", "VK_KHR_index_type_uint8" }, { "VK_EXT_extended_dynamic_state", "VK_VERSION_1_3" }, @@ -2559,6 +2566,10 @@ namespace VULKAN_HPP_NAMESPACE { return "VK_VERSION_1_2"; } + if ( extension == "VK_EXT_line_rasterization" ) + { + return "VK_KHR_line_rasterization"; + } if ( extension == "VK_EXT_host_query_reset" ) { return "VK_VERSION_1_2"; @@ -2845,8 +2856,8 @@ namespace VULKAN_HPP_NAMESPACE ( extension == "VK_EXT_mutable_descriptor_type" ) || ( extension == "VK_ARM_shader_core_builtins" ) || ( extension == "VK_EXT_pipeline_library_group_handles" ) || ( extension == "VK_EXT_dynamic_rendering_unused_attachments" ) || ( extension == "VK_NV_low_latency2" ) || ( extension == "VK_KHR_cooperative_matrix" ) || - ( extension == "VK_QCOM_multiview_per_view_render_areas" ) || ( extension == "VK_KHR_video_maintenance1" ) || - ( extension == "VK_NV_per_stage_descriptor_set" ) || ( extension == "VK_QCOM_image_processing2" ) || + ( extension == "VK_QCOM_multiview_per_view_render_areas" ) || ( extension == "VK_KHR_video_decode_av1" ) || + ( extension == "VK_KHR_video_maintenance1" ) || ( extension == "VK_NV_per_stage_descriptor_set" ) || ( extension == "VK_QCOM_image_processing2" ) || ( extension == "VK_QCOM_filter_cubic_weights" ) || ( extension == "VK_QCOM_ycbcr_degamma" ) || ( extension == "VK_QCOM_filter_cubic_clamp" ) || ( extension == "VK_EXT_attachment_feedback_loop_dynamic_state" ) || ( extension == "VK_KHR_vertex_attribute_divisor" ) || ( extension == "VK_KHR_load_store_op_none" ) || ( extension == "VK_KHR_shader_float_controls2" ) @@ -2953,10 +2964,10 @@ namespace VULKAN_HPP_NAMESPACE ( extension == "VK_EXT_scalar_block_layout" ) || ( extension == "VK_EXT_subgroup_size_control" ) || ( extension == "VK_KHR_spirv_1_4" ) || ( extension == "VK_KHR_separate_depth_stencil_layouts" ) || ( extension == "VK_EXT_tooling_info" ) || ( extension == "VK_EXT_separate_stencil_usage" ) || ( extension == "VK_KHR_uniform_buffer_standard_layout" ) || - ( extension == "VK_KHR_buffer_device_address" ) || ( extension == "VK_EXT_host_query_reset" ) || ( extension == "VK_EXT_index_type_uint8" ) || - ( extension == "VK_EXT_extended_dynamic_state" ) || ( extension == "VK_EXT_shader_demote_to_helper_invocation" ) || - ( extension == "VK_KHR_shader_integer_dot_product" ) || ( extension == "VK_EXT_texel_buffer_alignment" ) || - ( extension == "VK_KHR_shader_non_semantic_info" ) || ( extension == "VK_EXT_private_data" ) || + ( extension == "VK_KHR_buffer_device_address" ) || ( extension == "VK_EXT_line_rasterization" ) || ( extension == "VK_EXT_host_query_reset" ) || + ( extension == "VK_EXT_index_type_uint8" ) || ( extension == "VK_EXT_extended_dynamic_state" ) || + ( extension == "VK_EXT_shader_demote_to_helper_invocation" ) || ( extension == "VK_KHR_shader_integer_dot_product" ) || + ( extension == "VK_EXT_texel_buffer_alignment" ) || ( extension == "VK_KHR_shader_non_semantic_info" ) || ( extension == "VK_EXT_private_data" ) || ( extension == "VK_EXT_pipeline_creation_cache_control" ) || ( extension == "VK_KHR_synchronization2" ) || ( extension == "VK_KHR_zero_initialize_workgroup_memory" ) || ( extension == "VK_EXT_ycbcr_2plane_444_formats" ) || ( extension == "VK_EXT_image_robustness" ) || ( extension == "VK_KHR_copy_commands2" ) || ( extension == "VK_EXT_4444_formats" ) || diff --git a/include/vulkan/vulkan_handles.hpp b/include/vulkan/vulkan_handles.hpp index d1f6ba1..e6b1481 100644 --- a/include/vulkan/vulkan_handles.hpp +++ b/include/vulkan/vulkan_handles.hpp @@ -1724,6 +1724,13 @@ namespace VULKAN_HPP_NAMESPACE struct PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM; struct MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM; + //=== VK_KHR_video_decode_av1 === + struct VideoDecodeAV1ProfileInfoKHR; + struct VideoDecodeAV1CapabilitiesKHR; + struct VideoDecodeAV1SessionParametersCreateInfoKHR; + struct VideoDecodeAV1PictureInfoKHR; + struct VideoDecodeAV1DpbSlotInfoKHR; + //=== VK_KHR_video_maintenance1 === struct PhysicalDeviceVideoMaintenance1FeaturesKHR; struct VideoInlineQueryInfoKHR; diff --git a/include/vulkan/vulkan_hash.hpp b/include/vulkan/vulkan_hash.hpp index 91e97fd..bebd7cb 100644 --- a/include/vulkan/vulkan_hash.hpp +++ b/include/vulkan/vulkan_hash.hpp @@ -15404,6 +15404,81 @@ namespace std } }; + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeAV1CapabilitiesKHR const & videoDecodeAV1CapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1CapabilitiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1CapabilitiesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1CapabilitiesKHR.maxLevel ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeAV1DpbSlotInfoKHR const & videoDecodeAV1DpbSlotInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1DpbSlotInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1DpbSlotInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1DpbSlotInfoKHR.pStdReferenceInfo ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeAV1PictureInfoKHR const & videoDecodeAV1PictureInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.pStdPictureInfo ); + for ( size_t i = 0; i < VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.referenceNameSlotIndices[i] ); + } + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.frameHeaderOffset ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.tileCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.pTileOffsets ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.pTileSizes ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeAV1ProfileInfoKHR const & videoDecodeAV1ProfileInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1ProfileInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1ProfileInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1ProfileInfoKHR.stdProfile ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1ProfileInfoKHR.filmGrainSupport ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeAV1SessionParametersCreateInfoKHR const & videoDecodeAV1SessionParametersCreateInfoKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1SessionParametersCreateInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1SessionParametersCreateInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1SessionParametersCreateInfoKHR.pStdSequenceHeader ); + return seed; + } + }; + template <> struct hash { diff --git a/include/vulkan/vulkan_static_assertions.hpp b/include/vulkan/vulkan_static_assertions.hpp index 880d905..30f287a 100644 --- a/include/vulkan/vulkan_static_assertions.hpp +++ b/include/vulkan/vulkan_static_assertions.hpp @@ -7104,6 +7104,40 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM is not nothrow_move_constructible!" ); +//=== VK_KHR_video_decode_av1 === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeAV1ProfileInfoKHR ) == sizeof( VkVideoDecodeAV1ProfileInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoDecodeAV1ProfileInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeAV1CapabilitiesKHR ) == sizeof( VkVideoDecodeAV1CapabilitiesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoDecodeAV1CapabilitiesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeAV1SessionParametersCreateInfoKHR ) == + sizeof( VkVideoDecodeAV1SessionParametersCreateInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoDecodeAV1SessionParametersCreateInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeAV1PictureInfoKHR ) == sizeof( VkVideoDecodeAV1PictureInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoDecodeAV1PictureInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeAV1DpbSlotInfoKHR ) == sizeof( VkVideoDecodeAV1DpbSlotInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoDecodeAV1DpbSlotInfoKHR is not nothrow_move_constructible!" ); + //=== VK_KHR_video_maintenance1 === VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoMaintenance1FeaturesKHR ) == sizeof( VkPhysicalDeviceVideoMaintenance1FeaturesKHR ), diff --git a/include/vulkan/vulkan_structs.hpp b/include/vulkan/vulkan_structs.hpp index 6a74e2f..c18fbe9 100644 --- a/include/vulkan/vulkan_structs.hpp +++ b/include/vulkan/vulkan_structs.hpp @@ -114942,6 +114942,601 @@ namespace VULKAN_HPP_NAMESPACE using Type = VideoCodingControlInfoKHR; }; + struct VideoDecodeAV1CapabilitiesKHR + { + using NativeType = VkVideoDecodeAV1CapabilitiesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeAv1CapabilitiesKHR; + +#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoDecodeAV1CapabilitiesKHR( StdVideoAV1Level maxLevel_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext( pNext_ ) + , maxLevel( maxLevel_ ) + { + } + + VULKAN_HPP_CONSTEXPR VideoDecodeAV1CapabilitiesKHR( VideoDecodeAV1CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoDecodeAV1CapabilitiesKHR( VkVideoDecodeAV1CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoDecodeAV1CapabilitiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoDecodeAV1CapabilitiesKHR & operator=( VideoDecodeAV1CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ + + VideoDecodeAV1CapabilitiesKHR & operator=( VkVideoDecodeAV1CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkVideoDecodeAV1CapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeAV1CapabilitiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxLevel ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( VideoDecodeAV1CapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = memcmp( &maxLevel, &rhs.maxLevel, sizeof( StdVideoAV1Level ) ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + + return std::strong_ordering::equivalent; + } +#endif + + bool operator==( VideoDecodeAV1CapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memcmp( &maxLevel, &rhs.maxLevel, sizeof( StdVideoAV1Level ) ) == 0 ); + } + + bool operator!=( VideoDecodeAV1CapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoDecodeAv1CapabilitiesKHR; + void * pNext = {}; + StdVideoAV1Level maxLevel = {}; + }; + + template <> + struct CppType + { + using Type = VideoDecodeAV1CapabilitiesKHR; + }; + + struct VideoDecodeAV1DpbSlotInfoKHR + { + using NativeType = VkVideoDecodeAV1DpbSlotInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeAv1DpbSlotInfoKHR; + +#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoDecodeAV1DpbSlotInfoKHR( const StdVideoDecodeAV1ReferenceInfo * pStdReferenceInfo_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext( pNext_ ) + , pStdReferenceInfo( pStdReferenceInfo_ ) + { + } + + VULKAN_HPP_CONSTEXPR VideoDecodeAV1DpbSlotInfoKHR( VideoDecodeAV1DpbSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoDecodeAV1DpbSlotInfoKHR( VkVideoDecodeAV1DpbSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoDecodeAV1DpbSlotInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoDecodeAV1DpbSlotInfoKHR & operator=( VideoDecodeAV1DpbSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ + + VideoDecodeAV1DpbSlotInfoKHR & operator=( VkVideoDecodeAV1DpbSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1DpbSlotInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1DpbSlotInfoKHR & setPStdReferenceInfo( const StdVideoDecodeAV1ReferenceInfo * pStdReferenceInfo_ ) VULKAN_HPP_NOEXCEPT + { + pStdReferenceInfo = pStdReferenceInfo_; + return *this; + } +#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ + + operator VkVideoDecodeAV1DpbSlotInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeAV1DpbSlotInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pStdReferenceInfo ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoDecodeAV1DpbSlotInfoKHR const & ) const = default; +#else + bool operator==( VideoDecodeAV1DpbSlotInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdReferenceInfo == rhs.pStdReferenceInfo ); +# endif + } + + bool operator!=( VideoDecodeAV1DpbSlotInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoDecodeAv1DpbSlotInfoKHR; + const void * pNext = {}; + const StdVideoDecodeAV1ReferenceInfo * pStdReferenceInfo = {}; + }; + + template <> + struct CppType + { + using Type = VideoDecodeAV1DpbSlotInfoKHR; + }; + + struct VideoDecodeAV1PictureInfoKHR + { + using NativeType = VkVideoDecodeAV1PictureInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeAv1PictureInfoKHR; + +#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1PictureInfoKHR( const StdVideoDecodeAV1PictureInfo * pStdPictureInfo_ = {}, + std::array const & referenceNameSlotIndices_ = {}, + uint32_t frameHeaderOffset_ = {}, + uint32_t tileCount_ = {}, + const uint32_t * pTileOffsets_ = {}, + const uint32_t * pTileSizes_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext( pNext_ ) + , pStdPictureInfo( pStdPictureInfo_ ) + , referenceNameSlotIndices( referenceNameSlotIndices_ ) + , frameHeaderOffset( frameHeaderOffset_ ) + , tileCount( tileCount_ ) + , pTileOffsets( pTileOffsets_ ) + , pTileSizes( pTileSizes_ ) + { + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1PictureInfoKHR( VideoDecodeAV1PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoDecodeAV1PictureInfoKHR( VkVideoDecodeAV1PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoDecodeAV1PictureInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + VideoDecodeAV1PictureInfoKHR( const StdVideoDecodeAV1PictureInfo * pStdPictureInfo_, + std::array const & referenceNameSlotIndices_, + uint32_t frameHeaderOffset_, + VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & tileOffsets_, + VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & tileSizes_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , pStdPictureInfo( pStdPictureInfo_ ) + , referenceNameSlotIndices( referenceNameSlotIndices_ ) + , frameHeaderOffset( frameHeaderOffset_ ) + , tileCount( static_cast( tileOffsets_.size() ) ) + , pTileOffsets( tileOffsets_.data() ) + , pTileSizes( tileSizes_.data() ) + { +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( tileOffsets_.size() == tileSizes_.size() ); +# else + if ( tileOffsets_.size() != tileSizes_.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING + "::VideoDecodeAV1PictureInfoKHR::VideoDecodeAV1PictureInfoKHR: tileOffsets_.size() != tileSizes_.size()" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VideoDecodeAV1PictureInfoKHR & operator=( VideoDecodeAV1PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ + + VideoDecodeAV1PictureInfoKHR & operator=( VkVideoDecodeAV1PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1PictureInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1PictureInfoKHR & setPStdPictureInfo( const StdVideoDecodeAV1PictureInfo * pStdPictureInfo_ ) VULKAN_HPP_NOEXCEPT + { + pStdPictureInfo = pStdPictureInfo_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1PictureInfoKHR & + setReferenceNameSlotIndices( std::array referenceNameSlotIndices_ ) VULKAN_HPP_NOEXCEPT + { + referenceNameSlotIndices = referenceNameSlotIndices_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1PictureInfoKHR & setFrameHeaderOffset( uint32_t frameHeaderOffset_ ) VULKAN_HPP_NOEXCEPT + { + frameHeaderOffset = frameHeaderOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1PictureInfoKHR & setTileCount( uint32_t tileCount_ ) VULKAN_HPP_NOEXCEPT + { + tileCount = tileCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1PictureInfoKHR & setPTileOffsets( const uint32_t * pTileOffsets_ ) VULKAN_HPP_NOEXCEPT + { + pTileOffsets = pTileOffsets_; + return *this; + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + VideoDecodeAV1PictureInfoKHR & setTileOffsets( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & tileOffsets_ ) VULKAN_HPP_NOEXCEPT + { + tileCount = static_cast( tileOffsets_.size() ); + pTileOffsets = tileOffsets_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1PictureInfoKHR & setPTileSizes( const uint32_t * pTileSizes_ ) VULKAN_HPP_NOEXCEPT + { + pTileSizes = pTileSizes_; + return *this; + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + VideoDecodeAV1PictureInfoKHR & setTileSizes( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & tileSizes_ ) VULKAN_HPP_NOEXCEPT + { + tileCount = static_cast( tileSizes_.size() ); + pTileSizes = tileSizes_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ + + operator VkVideoDecodeAV1PictureInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeAV1PictureInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple const &, + uint32_t const &, + uint32_t const &, + const uint32_t * const &, + const uint32_t * const &> +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pStdPictureInfo, referenceNameSlotIndices, frameHeaderOffset, tileCount, pTileOffsets, pTileSizes ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoDecodeAV1PictureInfoKHR const & ) const = default; +#else + bool operator==( VideoDecodeAV1PictureInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdPictureInfo == rhs.pStdPictureInfo ) && + ( referenceNameSlotIndices == rhs.referenceNameSlotIndices ) && ( frameHeaderOffset == rhs.frameHeaderOffset ) && ( tileCount == rhs.tileCount ) && + ( pTileOffsets == rhs.pTileOffsets ) && ( pTileSizes == rhs.pTileSizes ); +# endif + } + + bool operator!=( VideoDecodeAV1PictureInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoDecodeAv1PictureInfoKHR; + const void * pNext = {}; + const StdVideoDecodeAV1PictureInfo * pStdPictureInfo = {}; + VULKAN_HPP_NAMESPACE::ArrayWrapper1D referenceNameSlotIndices = {}; + uint32_t frameHeaderOffset = {}; + uint32_t tileCount = {}; + const uint32_t * pTileOffsets = {}; + const uint32_t * pTileSizes = {}; + }; + + template <> + struct CppType + { + using Type = VideoDecodeAV1PictureInfoKHR; + }; + + struct VideoDecodeAV1ProfileInfoKHR + { + using NativeType = VkVideoDecodeAV1ProfileInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeAv1ProfileInfoKHR; + +#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoDecodeAV1ProfileInfoKHR( StdVideoAV1Profile stdProfile_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 filmGrainSupport_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext( pNext_ ) + , stdProfile( stdProfile_ ) + , filmGrainSupport( filmGrainSupport_ ) + { + } + + VULKAN_HPP_CONSTEXPR VideoDecodeAV1ProfileInfoKHR( VideoDecodeAV1ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoDecodeAV1ProfileInfoKHR( VkVideoDecodeAV1ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoDecodeAV1ProfileInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoDecodeAV1ProfileInfoKHR & operator=( VideoDecodeAV1ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ + + VideoDecodeAV1ProfileInfoKHR & operator=( VkVideoDecodeAV1ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1ProfileInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1ProfileInfoKHR & setStdProfile( StdVideoAV1Profile stdProfile_ ) VULKAN_HPP_NOEXCEPT + { + stdProfile = stdProfile_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1ProfileInfoKHR & setFilmGrainSupport( VULKAN_HPP_NAMESPACE::Bool32 filmGrainSupport_ ) VULKAN_HPP_NOEXCEPT + { + filmGrainSupport = filmGrainSupport_; + return *this; + } +#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ + + operator VkVideoDecodeAV1ProfileInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeAV1ProfileInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, stdProfile, filmGrainSupport ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( VideoDecodeAV1ProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = memcmp( &stdProfile, &rhs.stdProfile, sizeof( StdVideoAV1Profile ) ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = filmGrainSupport <=> rhs.filmGrainSupport; cmp != 0 ) + return cmp; + + return std::strong_ordering::equivalent; + } +#endif + + bool operator==( VideoDecodeAV1ProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memcmp( &stdProfile, &rhs.stdProfile, sizeof( StdVideoAV1Profile ) ) == 0 ) && + ( filmGrainSupport == rhs.filmGrainSupport ); + } + + bool operator!=( VideoDecodeAV1ProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoDecodeAv1ProfileInfoKHR; + const void * pNext = {}; + StdVideoAV1Profile stdProfile = {}; + VULKAN_HPP_NAMESPACE::Bool32 filmGrainSupport = {}; + }; + + template <> + struct CppType + { + using Type = VideoDecodeAV1ProfileInfoKHR; + }; + + struct VideoDecodeAV1SessionParametersCreateInfoKHR + { + using NativeType = VkVideoDecodeAV1SessionParametersCreateInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeAv1SessionParametersCreateInfoKHR; + +#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoDecodeAV1SessionParametersCreateInfoKHR( const StdVideoAV1SequenceHeader * pStdSequenceHeader_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext( pNext_ ) + , pStdSequenceHeader( pStdSequenceHeader_ ) + { + } + + VULKAN_HPP_CONSTEXPR VideoDecodeAV1SessionParametersCreateInfoKHR( VideoDecodeAV1SessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoDecodeAV1SessionParametersCreateInfoKHR( VkVideoDecodeAV1SessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoDecodeAV1SessionParametersCreateInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoDecodeAV1SessionParametersCreateInfoKHR & operator=( VideoDecodeAV1SessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ + + VideoDecodeAV1SessionParametersCreateInfoKHR & operator=( VkVideoDecodeAV1SessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1SessionParametersCreateInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1SessionParametersCreateInfoKHR & + setPStdSequenceHeader( const StdVideoAV1SequenceHeader * pStdSequenceHeader_ ) VULKAN_HPP_NOEXCEPT + { + pStdSequenceHeader = pStdSequenceHeader_; + return *this; + } +#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ + + operator VkVideoDecodeAV1SessionParametersCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeAV1SessionParametersCreateInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pStdSequenceHeader ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoDecodeAV1SessionParametersCreateInfoKHR const & ) const = default; +#else + bool operator==( VideoDecodeAV1SessionParametersCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdSequenceHeader == rhs.pStdSequenceHeader ); +# endif + } + + bool operator!=( VideoDecodeAV1SessionParametersCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoDecodeAv1SessionParametersCreateInfoKHR; + const void * pNext = {}; + const StdVideoAV1SequenceHeader * pStdSequenceHeader = {}; + }; + + template <> + struct CppType + { + using Type = VideoDecodeAV1SessionParametersCreateInfoKHR; + }; + struct VideoDecodeCapabilitiesKHR { using NativeType = VkVideoDecodeCapabilitiesKHR; diff --git a/include/vulkan/vulkan_to_string.hpp b/include/vulkan/vulkan_to_string.hpp index 80aa4a5..b7c08c7 100644 --- a/include/vulkan/vulkan_to_string.hpp +++ b/include/vulkan/vulkan_to_string.hpp @@ -1223,6 +1223,10 @@ namespace VULKAN_HPP_NAMESPACE result += "Quad | "; if ( value & SubgroupFeatureFlagBits::ePartitionedNV ) result += "PartitionedNV | "; + if ( value & SubgroupFeatureFlagBits::eRotateKHR ) + result += "RotateKHR | "; + if ( value & SubgroupFeatureFlagBits::eRotateClusteredKHR ) + result += "RotateClusteredKHR | "; return "{ " + result.substr( 0, result.size() - 3 ) + " }"; } @@ -2039,6 +2043,8 @@ namespace VULKAN_HPP_NAMESPACE result += "DecodeH264 | "; if ( value & VideoCodecOperationFlagBitsKHR::eDecodeH265 ) result += "DecodeH265 | "; + if ( value & VideoCodecOperationFlagBitsKHR::eDecodeAv1 ) + result += "DecodeAv1 | "; return "{ " + result.substr( 0, result.size() - 3 ) + " }"; } @@ -4480,6 +4486,11 @@ namespace VULKAN_HPP_NAMESPACE case StructureType::ePhysicalDeviceCooperativeMatrixPropertiesKHR: return "PhysicalDeviceCooperativeMatrixPropertiesKHR"; case StructureType::ePhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM: return "PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM"; case StructureType::eMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM: return "MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM"; + case StructureType::eVideoDecodeAv1CapabilitiesKHR: return "VideoDecodeAv1CapabilitiesKHR"; + case StructureType::eVideoDecodeAv1PictureInfoKHR: return "VideoDecodeAv1PictureInfoKHR"; + case StructureType::eVideoDecodeAv1ProfileInfoKHR: return "VideoDecodeAv1ProfileInfoKHR"; + case StructureType::eVideoDecodeAv1SessionParametersCreateInfoKHR: return "VideoDecodeAv1SessionParametersCreateInfoKHR"; + case StructureType::eVideoDecodeAv1DpbSlotInfoKHR: return "VideoDecodeAv1DpbSlotInfoKHR"; case StructureType::ePhysicalDeviceVideoMaintenance1FeaturesKHR: return "PhysicalDeviceVideoMaintenance1FeaturesKHR"; case StructureType::eVideoInlineQueryInfoKHR: return "VideoInlineQueryInfoKHR"; case StructureType::ePhysicalDevicePerStageDescriptorSetFeaturesNV: return "PhysicalDevicePerStageDescriptorSetFeaturesNV"; @@ -6227,6 +6238,8 @@ namespace VULKAN_HPP_NAMESPACE case SubgroupFeatureFlagBits::eClustered: return "Clustered"; case SubgroupFeatureFlagBits::eQuad: return "Quad"; case SubgroupFeatureFlagBits::ePartitionedNV: return "PartitionedNV"; + case SubgroupFeatureFlagBits::eRotateKHR: return "RotateKHR"; + case SubgroupFeatureFlagBits::eRotateClusteredKHR: return "RotateClusteredKHR"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; } } @@ -7001,6 +7014,7 @@ namespace VULKAN_HPP_NAMESPACE case VideoCodecOperationFlagBitsKHR::eEncodeH265: return "EncodeH265"; case VideoCodecOperationFlagBitsKHR::eDecodeH264: return "DecodeH264"; case VideoCodecOperationFlagBitsKHR::eDecodeH265: return "DecodeH265"; + case VideoCodecOperationFlagBitsKHR::eDecodeAv1: return "DecodeAv1"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; } } diff --git a/registry/validusage.json b/registry/validusage.json index 64f2c03..ef46fde 100644 --- a/registry/validusage.json +++ b/registry/validusage.json @@ -1,9 +1,9 @@ { "version info": { "schema version": 2, - "api version": "1.3.276", - "comment": "from git branch: github-main commit: bf11e6d4ca4b71ae311bb925ae68d215fbe09a86", - "date": "2024-01-25 08:53:29Z" + "api version": "1.3.277", + "comment": "from git branch: github-main commit: 8c4e3f27f12060fd0bd1302393c4808fee6ce81f", + "date": "2024-02-01 13:38:10Z" }, "validation": { "vkGetInstanceProcAddr": { @@ -5400,7 +5400,7 @@ }, { "vuid": "VUID-vkCmdPipelineBarrier2-None-09553", - "text": "If neither the shaderTileImageColorReadAccess nor shaderTileImageDepthReadAccess features are enabled, and the dynamicRenderingLocalRead feature is not enabled, vkCmdPipelineBarrier2 must not be called within a render pass instance started with vkCmdBeginRendering", + "text": "If none of the shaderTileImageColorReadAccess, shaderTileImageStencilReadAccess, or shaderTileImageDepthReadAccess features are enabled, and the dynamicRenderingLocalRead feature is not enabled, vkCmdPipelineBarrier2 must not be called within a render pass instance started with vkCmdBeginRendering", "page": "vkspec" }, { @@ -5659,7 +5659,7 @@ }, { "vuid": "VUID-vkCmdPipelineBarrier-None-09553", - "text": "If neither the shaderTileImageColorReadAccess nor shaderTileImageDepthReadAccess features are enabled, and the dynamicRenderingLocalRead feature is not enabled, vkCmdPipelineBarrier must not be called within a render pass instance started with vkCmdBeginRendering", + "text": "If none of the shaderTileImageColorReadAccess, shaderTileImageStencilReadAccess, or shaderTileImageDepthReadAccess features are enabled, and the dynamicRenderingLocalRead feature is not enabled, vkCmdPipelineBarrier must not be called within a render pass instance started with vkCmdBeginRendering", "page": "vkspec" }, { @@ -11951,7 +11951,7 @@ "core": [ { "vuid": "VUID-VkFramebufferAttachmentImageInfo-viewFormatCount-09536", - "text": "If viewFormatCount is not 0, each element of pViewFormats must not be VK_FORMAT_UNDEFINED", + "text": "If viewFormatCount is not 0, and the render pass is not being used with an external format resolve attachment, each element of pViewFormats must not be VK_FORMAT_UNDEFINED", "page": "vkspec" }, { @@ -16133,7 +16133,7 @@ }, { "vuid": "VUID-VkGraphicsPipelineCreateInfo-renderPass-06603", - "text": "If pre-rasterization shader state, fragment shader state, or fragment output state, and renderPass is not VK_NULL_HANDLE, renderPass must be a valid VkRenderPass handle", + "text": "If the pipeline requires pre-rasterization shader state, fragment shader state, or fragment output state, and renderPass is not VK_NULL_HANDLE, renderPass must be a valid VkRenderPass handle", "page": "vkspec" }, { @@ -16326,6 +16326,11 @@ "text": "If VkGraphicsPipelineLibraryCreateInfoEXT::flags includes VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT, pMultisampleState->sampleShadingEnable is VK_TRUE, and an element of VkPipelineLibraryCreateInfoKHR::pLibraries was created with VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT, the pMultisampleState used to create that library must be identically defined pMultisampleState", "page": "vkspec" }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pLibraries-09567", + "text": "If one element of VkPipelineLibraryCreateInfoKHR::pLibraries was created with VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT and a value of pMultisampleState->sampleShadingEnable equal VK_TRUE, and if VkGraphicsPipelineLibraryCreateInfoEXT::flags includes VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT, pMultisampleState must be identically defined to that used to create the library", + "page": "vkspec" + }, { "vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-06638", "text": "If VkGraphicsPipelineLibraryCreateInfoEXT::flags includes only one of VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT or VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT, and an element of VkPipelineLibraryCreateInfoKHR::pLibraries includes the other flag, values specified in VkPipelineFragmentShadingRateStateCreateInfoKHR for both this pipeline and that library must be identical", @@ -27133,11 +27138,6 @@ }, { "vuid": "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-pBindingFlags-03004", - "text": "If an element of pBindingFlags includes VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT, then all other elements of VkDescriptorSetLayoutCreateInfo::pBindings must have a smaller value of binding", - "page": "vkspec" - }, - { - "vuid": "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-pBindingFlags-09379", "text": "If an element of pBindingFlags includes VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT, then it must be the element with the highest binding number", "page": "vkspec" }, @@ -27910,11 +27910,6 @@ "text": "If descriptorSetCount is not zero, descriptorSetCount must equal VkDescriptorSetAllocateInfo::descriptorSetCount", "page": "vkspec" }, - { - "vuid": "VUID-VkDescriptorSetVariableDescriptorCountAllocateInfo-pSetLayouts-03046", - "text": "If VkDescriptorSetAllocateInfo::pSetLayouts[i] has a variable-sized descriptor binding, then pDescriptorCounts[i] must be less than or equal to the descriptor count specified for that binding when the descriptor set layout was created", - "page": "vkspec" - }, { "vuid": "VUID-VkDescriptorSetVariableDescriptorCountAllocateInfo-sType-sType", "text": "sType must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO", @@ -29802,14 +29797,9 @@ "text": "If pDescriptorInfo->type is VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER and pDescriptorInfo->data.pCombinedImageSampler has a imageView member that was created with a VkSamplerYcbcrConversionInfo structure in its pNext chain, dataSize must equal the size of VkPhysicalDeviceDescriptorBufferPropertiesEXT::combinedImageSamplerDescriptorSize times VkSamplerYcbcrConversionImageFormatProperties::combinedImageSamplerDescriptorCount", "page": "vkspec" }, - { - "vuid": "VUID-vkGetDescriptorEXT-pDescriptor-08016", - "text": "pDescriptor must be a valid pointer to an array of at least dataSize bytes", - "page": "vkspec" - }, { "vuid": "VUID-vkGetDescriptorEXT-pDescriptorInfo-09507", - "text": "If pDescriptorInfo->type is VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER and pDescriptorInfo->data.pCombinedImageSampler is NULL or it has a imageView that is VK_NULL_HANDLE then dataSize must be equal to the size of VkPhysicalDeviceDescriptorBufferPropertiesEXT::combinedImageSamplerDescriptorSize", + "text": "If pDescriptorInfo->type is VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER and it has a imageView that is VK_NULL_HANDLE then dataSize must be equal to the size of VkPhysicalDeviceDescriptorBufferPropertiesEXT::combinedImageSamplerDescriptorSize", "page": "vkspec" }, { @@ -33502,7 +33492,7 @@ }, { "vuid": "VUID-VkQueryPoolCreateInfo-pNext-pNext", - "text": "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkQueryPoolPerformanceCreateInfoKHR, VkQueryPoolPerformanceQueryCreateInfoINTEL, VkQueryPoolVideoEncodeFeedbackCreateInfoKHR, VkVideoDecodeH264ProfileInfoKHR, VkVideoDecodeH265ProfileInfoKHR, VkVideoDecodeUsageInfoKHR, VkVideoEncodeH264ProfileInfoKHR, VkVideoEncodeH265ProfileInfoKHR, VkVideoEncodeUsageInfoKHR, or VkVideoProfileInfoKHR", + "text": "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkQueryPoolPerformanceCreateInfoKHR, VkQueryPoolPerformanceQueryCreateInfoINTEL, VkQueryPoolVideoEncodeFeedbackCreateInfoKHR, VkVideoDecodeAV1ProfileInfoKHR, VkVideoDecodeH264ProfileInfoKHR, VkVideoDecodeH265ProfileInfoKHR, VkVideoDecodeUsageInfoKHR, VkVideoEncodeH264ProfileInfoKHR, VkVideoEncodeH265ProfileInfoKHR, VkVideoEncodeUsageInfoKHR, or VkVideoProfileInfoKHR", "page": "vkspec" }, { @@ -74536,37 +74526,37 @@ "VkPipelineRasterizationLineStateCreateInfoKHR": { "core": [ { - "vuid": "VUID-VkPipelineRasterizationLineStateCreateInfoEXT-lineRasterizationMode-02768", + "vuid": "VUID-VkPipelineRasterizationLineStateCreateInfoKHR-lineRasterizationMode-02768", "text": "If lineRasterizationMode is VK_LINE_RASTERIZATION_MODE_RECTANGULAR_KHR, then the rectangularLines feature must be enabled", "page": "vkspec" }, { - "vuid": "VUID-VkPipelineRasterizationLineStateCreateInfoEXT-lineRasterizationMode-02769", + "vuid": "VUID-VkPipelineRasterizationLineStateCreateInfoKHR-lineRasterizationMode-02769", "text": "If lineRasterizationMode is VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR, then the bresenhamLines feature must be enabled", "page": "vkspec" }, { - "vuid": "VUID-VkPipelineRasterizationLineStateCreateInfoEXT-lineRasterizationMode-02770", + "vuid": "VUID-VkPipelineRasterizationLineStateCreateInfoKHR-lineRasterizationMode-02770", "text": "If lineRasterizationMode is VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR, then the smoothLines feature must be enabled", "page": "vkspec" }, { - "vuid": "VUID-VkPipelineRasterizationLineStateCreateInfoEXT-stippledLineEnable-02771", + "vuid": "VUID-VkPipelineRasterizationLineStateCreateInfoKHR-stippledLineEnable-02771", "text": "If stippledLineEnable is VK_TRUE and lineRasterizationMode is VK_LINE_RASTERIZATION_MODE_RECTANGULAR_KHR, then the stippledRectangularLines feature must be enabled", "page": "vkspec" }, { - "vuid": "VUID-VkPipelineRasterizationLineStateCreateInfoEXT-stippledLineEnable-02772", + "vuid": "VUID-VkPipelineRasterizationLineStateCreateInfoKHR-stippledLineEnable-02772", "text": "If stippledLineEnable is VK_TRUE and lineRasterizationMode is VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR, then the stippledBresenhamLines feature must be enabled", "page": "vkspec" }, { - "vuid": "VUID-VkPipelineRasterizationLineStateCreateInfoEXT-stippledLineEnable-02773", + "vuid": "VUID-VkPipelineRasterizationLineStateCreateInfoKHR-stippledLineEnable-02773", "text": "If stippledLineEnable is VK_TRUE and lineRasterizationMode is VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR, then the stippledSmoothLines feature must be enabled", "page": "vkspec" }, { - "vuid": "VUID-VkPipelineRasterizationLineStateCreateInfoEXT-stippledLineEnable-02774", + "vuid": "VUID-VkPipelineRasterizationLineStateCreateInfoKHR-stippledLineEnable-02774", "text": "If stippledLineEnable is VK_TRUE and lineRasterizationMode is VK_LINE_RASTERIZATION_MODE_DEFAULT_KHR, then the stippledRectangularLines feature must be enabled and VkPhysicalDeviceLimits::strictLines must be VK_TRUE", "page": "vkspec" }, @@ -74692,7 +74682,7 @@ "vkCmdSetLineStippleKHR": { "core": [ { - "vuid": "VUID-vkCmdSetLineStippleEXT-lineStippleFactor-02776", + "vuid": "VUID-vkCmdSetLineStippleKHR-lineStippleFactor-02776", "text": "lineStippleFactor must be in the range [1,256]", "page": "vkspec" }, @@ -83735,6 +83725,21 @@ "vuid": "VUID-vkReleaseFullScreenExclusiveModeEXT-swapchain-02678", "text": "swapchain must be a swapchain created with a VkSurfaceFullScreenExclusiveInfoEXT structure, with fullScreenExclusive set to VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT", "page": "vkspec" + }, + { + "vuid": "VUID-vkReleaseFullScreenExclusiveModeEXT-device-parameter", + "text": "device must be a valid VkDevice handle", + "page": "vkspec" + }, + { + "vuid": "VUID-vkReleaseFullScreenExclusiveModeEXT-swapchain-parameter", + "text": "swapchain must be a valid VkSwapchainKHR handle", + "page": "vkspec" + }, + { + "vuid": "VUID-vkReleaseFullScreenExclusiveModeEXT-swapchain-parent", + "text": "swapchain must have been created, allocated, or retrieved from device", + "page": "vkspec" } ] }, @@ -86338,7 +86343,7 @@ }, { "vuid": "VUID-VkAccelerationStructureBuildGeometryInfoKHR-pGeometries-03788", - "text": "Only one of pGeometries or ppGeometries can be a valid pointer, the other must be NULL", + "text": "If geometryCount is not 0, exactly one of pGeometries or ppGeometries must be a valid pointer, the other must be NULL", "page": "vkspec" }, { @@ -86798,7 +86803,7 @@ }, { "vuid": "VUID-vkCmdWriteAccelerationStructuresPropertiesKHR-query-04880", - "text": "The sum of query plus accelerationStructureCount must be less than or equal to the number of queries in queryPool", + "text": "The sum of firstQuery plus accelerationStructureCount must be less than or equal to the number of queries in queryPool", "page": "vkspec" }, { @@ -91455,6 +91460,11 @@ "text": "If videoCodecOperation is VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR, then the pNext chain must include a VkVideoDecodeH265ProfileInfoKHR structure", "page": "vkspec" }, + { + "vuid": "VUID-VkVideoProfileInfoKHR-videoCodecOperation-09256", + "text": "If videoCodecOperation is VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR, then the pNext chain must include a VkVideoDecodeAV1ProfileInfoKHR structure", + "page": "vkspec" + }, { "vuid": "VUID-VkVideoProfileInfoKHR-videoCodecOperation-07181", "text": "If videoCodecOperation is VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR, then the pNext chain must include a VkVideoEncodeH264ProfileInfoKHR structure", @@ -91576,6 +91586,11 @@ "text": "If pVideoProfile->videoCodecOperation is VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR, then the pNext chain of pCapabilities must include a VkVideoDecodeH265CapabilitiesKHR structure", "page": "vkspec" }, + { + "vuid": "VUID-vkGetPhysicalDeviceVideoCapabilitiesKHR-pVideoProfile-09257", + "text": "If pVideoProfile->videoCodecOperation is VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR, then the pNext chain of pCapabilities must include a VkVideoDecodeAV1CapabilitiesKHR structure", + "page": "vkspec" + }, { "vuid": "VUID-vkGetPhysicalDeviceVideoCapabilitiesKHR-pVideoProfile-07186", "text": "If pVideoProfile->videoCodecOperation specifies an encode operation, then the pNext chain of pCapabilities must include a VkVideoEncodeCapabilitiesKHR structure", @@ -91617,7 +91632,7 @@ }, { "vuid": "VUID-VkVideoCapabilitiesKHR-pNext-pNext", - "text": "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkVideoDecodeCapabilitiesKHR, VkVideoDecodeH264CapabilitiesKHR, VkVideoDecodeH265CapabilitiesKHR, VkVideoEncodeCapabilitiesKHR, VkVideoEncodeH264CapabilitiesKHR, or VkVideoEncodeH265CapabilitiesKHR", + "text": "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkVideoDecodeAV1CapabilitiesKHR, VkVideoDecodeCapabilitiesKHR, VkVideoDecodeH264CapabilitiesKHR, VkVideoDecodeH265CapabilitiesKHR, VkVideoEncodeCapabilitiesKHR, VkVideoEncodeH264CapabilitiesKHR, or VkVideoEncodeH265CapabilitiesKHR", "page": "vkspec" }, { @@ -92083,6 +92098,16 @@ "text": "If videoSession was created with the video codec operation VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR, then the number of elements of ppsAddList must be less than or equal to the maxStdPPSCount specified in the VkVideoDecodeH265SessionParametersCreateInfoKHR structure included in the pNext chain", "page": "vkspec" }, + { + "vuid": "VUID-VkVideoSessionParametersCreateInfoKHR-videoSession-09258", + "text": "If videoSession was created with the video codec operation VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR, then videoSessionParametersTemplate must be VK_NULL_HANDLE", + "page": "vkspec" + }, + { + "vuid": "VUID-VkVideoSessionParametersCreateInfoKHR-videoSession-09259", + "text": "If videoSession was created with the video codec operation VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR, then the pNext chain must include a VkVideoDecodeAV1SessionParametersCreateInfoKHR structure", + "page": "vkspec" + }, { "vuid": "VUID-VkVideoSessionParametersCreateInfoKHR-videoSession-07210", "text": "If videoSession was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR, then the pNext chain must include a VkVideoEncodeH264SessionParametersCreateInfoKHR structure", @@ -92135,7 +92160,7 @@ }, { "vuid": "VUID-VkVideoSessionParametersCreateInfoKHR-pNext-pNext", - "text": "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkVideoDecodeH264SessionParametersCreateInfoKHR, VkVideoDecodeH265SessionParametersCreateInfoKHR, VkVideoEncodeH264SessionParametersCreateInfoKHR, VkVideoEncodeH265SessionParametersCreateInfoKHR, or VkVideoEncodeQualityLevelInfoKHR", + "text": "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkVideoDecodeAV1SessionParametersCreateInfoKHR, VkVideoDecodeH264SessionParametersCreateInfoKHR, VkVideoDecodeH265SessionParametersCreateInfoKHR, VkVideoEncodeH264SessionParametersCreateInfoKHR, VkVideoEncodeH265SessionParametersCreateInfoKHR, or VkVideoEncodeQualityLevelInfoKHR", "page": "vkspec" }, { @@ -92266,6 +92291,11 @@ "text": "If videoSessionParameters was created with the video codec operation VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR, then the number of StdVideoH265PictureParameterSet entries already stored in it plus the value of the stdPPSCount member of the VkVideoDecodeH265SessionParametersAddInfoKHR structure included in the pUpdateInfo->pNext chain must be less than or equal to the VkVideoDecodeH265SessionParametersCreateInfoKHR::maxStdPPSCount videoSessionParameters was created with", "page": "vkspec" }, + { + "vuid": "VUID-vkUpdateVideoSessionParametersKHR-videoSessionParameters-09260", + "text": "videoSessionParameters must not have been created with the video codec operation VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR", + "page": "vkspec" + }, { "vuid": "VUID-vkUpdateVideoSessionParametersKHR-videoSessionParameters-07226", "text": "If videoSessionParameters was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR and the pNext chain of pUpdateInfo includes a VkVideoEncodeH264SessionParametersAddInfoKHR structure, then videoSessionParameters must not already contain a StdVideoH264SequenceParameterSet entry with seq_parameter_set_id matching any of the elements of VkVideoEncodeH264SessionParametersAddInfoKHR::pStdSPSs", @@ -92528,6 +92558,11 @@ "text": "If videoSession was created with the video codec operation VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR, then videoSessionParameters must not be VK_NULL_HANDLE", "page": "vkspec" }, + { + "vuid": "VUID-VkVideoBeginCodingInfoKHR-videoSession-09261", + "text": "If videoSession was created with the video codec operation VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR, then videoSessionParameters must not be VK_NULL_HANDLE", + "page": "vkspec" + }, { "vuid": "VUID-VkVideoBeginCodingInfoKHR-videoSession-07249", "text": "If videoSession was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR, then videoSessionParameters must not be VK_NULL_HANDLE", @@ -92599,7 +92634,7 @@ }, { "vuid": "VUID-VkVideoReferenceSlotInfoKHR-pNext-pNext", - "text": "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkVideoDecodeH264DpbSlotInfoKHR, VkVideoDecodeH265DpbSlotInfoKHR, VkVideoEncodeH264DpbSlotInfoKHR, or VkVideoEncodeH265DpbSlotInfoKHR", + "text": "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkVideoDecodeAV1DpbSlotInfoKHR, VkVideoDecodeH264DpbSlotInfoKHR, VkVideoDecodeH265DpbSlotInfoKHR, VkVideoEncodeH264DpbSlotInfoKHR, or VkVideoEncodeH265DpbSlotInfoKHR", "page": "vkspec" }, { @@ -92872,7 +92907,7 @@ }, { "vuid": "VUID-vkCmdDecodeVideoKHR-pDecodeInfo-07141", - "text": "If pDecodeInfo->pSetupReferenceSlot is not NULL and VkVideoDecodeCapabilitiesKHR::flags does not include VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR, as returned by vkGetPhysicalDeviceVideoCapabilitiesKHR for the video profile the bound video session was created with, then the video picture resources specified by pDecodeInfo->dstPictureResource and pDecodeInfo->pSetupReferenceSlot->pPictureResource must match", + "text": "If pDecodeInfo->pSetupReferenceSlot is not NULL and none of the following is true:
\n\n
\n
\n

then the video picture resources specified by\n pDecodeInfo->dstPictureResource and\n pDecodeInfo->pSetupReferenceSlot->pPictureResource must\n match

\n
", "page": "vkspec" }, { @@ -93100,6 +93135,56 @@ "text": "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR, then the pNext chain of each element of pDecodeInfo->pReferenceSlots must include a VkVideoDecodeH265DpbSlotInfoKHR structure", "page": "vkspec" }, + { + "vuid": "VUID-vkCmdDecodeVideoKHR-filmGrainSupport-09248", + "text": "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR and VkVideoDecodeAV1ProfileInfoKHR::filmGrainSupport set to VK_FALSE, then film grain must not be enabled for the decoded picture", + "page": "vkspec" + }, + { + "vuid": "VUID-vkCmdDecodeVideoKHR-pDecodeInfo-09249", + "text": "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR, pDecodeInfo->pSetupReferenceSlot is not NULL, and film grain is enabled for the decoded picture, then the video picture resources specified by pDecodeInfo->dstPictureResource and pDecodeInfo->pSetupReferenceSlot->pPictureResource must not match", + "page": "vkspec" + }, + { + "vuid": "VUID-vkCmdDecodeVideoKHR-pNext-09250", + "text": "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR, then the pNext chain of pDecodeInfo must include a VkVideoDecodeAV1PictureInfoKHR structure", + "page": "vkspec" + }, + { + "vuid": "VUID-vkCmdDecodeVideoKHR-frameHeaderOffset-09251", + "text": "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR, then the frameHeaderOffset member of the VkVideoDecodeAV1PictureInfoKHR structure included in the pNext chain of pDecodeInfo must be less than the minimum of pDecodeInfo->srcBufferRange", + "page": "vkspec" + }, + { + "vuid": "VUID-vkCmdDecodeVideoKHR-pTileOffsets-09253", + "text": "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR, then all elements of the pTileOffsets member of the VkVideoDecodeAV1PictureInfoKHR structure included in the pNext chain of pDecodeInfo must be less than pDecodeInfo->srcBufferRange", + "page": "vkspec" + }, + { + "vuid": "VUID-vkCmdDecodeVideoKHR-pTileOffsets-09252", + "text": "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR, then for each element i of the pTileOffsets and pTileSizes members of the VkVideoDecodeAV1PictureInfoKHR structure included in the pNext chain of pDecodeInfo the sum of pTileOffsets[i] and pTileSizes[i] must be less than or equal to pDecodeInfo->srcBufferRange", + "page": "vkspec" + }, + { + "vuid": "VUID-vkCmdDecodeVideoKHR-pDecodeInfo-09254", + "text": "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR and pDecodeInfo->pSetupReferenceSlot is not NULL, then the pNext chain of pDecodeInfo->pSetupReferenceSlot must include a VkVideoDecodeAV1DpbSlotInfoKHR structure", + "page": "vkspec" + }, + { + "vuid": "VUID-vkCmdDecodeVideoKHR-pNext-09255", + "text": "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR, then the pNext chain of each element of pDecodeInfo->pReferenceSlots must include a VkVideoDecodeAV1DpbSlotInfoKHR structure", + "page": "vkspec" + }, + { + "vuid": "VUID-vkCmdDecodeVideoKHR-referenceNameSlotIndices-09262", + "text": "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR, then each element of the referenceNameSlotIndices array member of the VkVideoDecodeAV1PictureInfoKHR structure included in the pNext chain of pDecodeInfo must either be negative or must equal the slotIndex member of one of the elements of pDecodeInfo->pReferenceSlots", + "page": "vkspec" + }, + { + "vuid": "VUID-vkCmdDecodeVideoKHR-slotIndex-09263", + "text": "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR, then the slotIndex member of each element of pDecodeInfo->pReferenceSlots must equal one of the elements of the referenceNameSlotIndices array member of the VkVideoDecodeAV1PictureInfoKHR structure included in the pNext chain of pDecodeInfo", + "page": "vkspec" + }, { "vuid": "VUID-vkCmdDecodeVideoKHR-commandBuffer-parameter", "text": "commandBuffer must be a valid VkCommandBuffer handle", @@ -93181,7 +93266,7 @@ }, { "vuid": "VUID-VkVideoDecodeInfoKHR-pNext-pNext", - "text": "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkVideoDecodeH264PictureInfoKHR, VkVideoDecodeH265PictureInfoKHR, or VkVideoInlineQueryInfoKHR", + "text": "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkVideoDecodeAV1PictureInfoKHR, VkVideoDecodeH264PictureInfoKHR, VkVideoDecodeH265PictureInfoKHR, or VkVideoInlineQueryInfoKHR", "page": "vkspec" }, { @@ -93429,6 +93514,81 @@ } ] }, + "VkVideoDecodeAV1ProfileInfoKHR": { + "core": [ + { + "vuid": "VUID-VkVideoDecodeAV1ProfileInfoKHR-sType-sType", + "text": "sType must be VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR", + "page": "vkspec" + } + ] + }, + "VkVideoDecodeAV1CapabilitiesKHR": { + "core": [ + { + "vuid": "VUID-VkVideoDecodeAV1CapabilitiesKHR-sType-sType", + "text": "sType must be VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR", + "page": "vkspec" + } + ] + }, + "VkVideoDecodeAV1SessionParametersCreateInfoKHR": { + "core": [ + { + "vuid": "VUID-VkVideoDecodeAV1SessionParametersCreateInfoKHR-sType-sType", + "text": "sType must be VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR", + "page": "vkspec" + }, + { + "vuid": "VUID-VkVideoDecodeAV1SessionParametersCreateInfoKHR-pStdSequenceHeader-parameter", + "text": "pStdSequenceHeader must be a valid pointer to a valid StdVideoAV1SequenceHeader value", + "page": "vkspec" + } + ] + }, + "VkVideoDecodeAV1PictureInfoKHR": { + "core": [ + { + "vuid": "VUID-VkVideoDecodeAV1PictureInfoKHR-sType-sType", + "text": "sType must be VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR", + "page": "vkspec" + }, + { + "vuid": "VUID-VkVideoDecodeAV1PictureInfoKHR-pStdPictureInfo-parameter", + "text": "pStdPictureInfo must be a valid pointer to a valid StdVideoDecodeAV1PictureInfo value", + "page": "vkspec" + }, + { + "vuid": "VUID-VkVideoDecodeAV1PictureInfoKHR-pTileOffsets-parameter", + "text": "pTileOffsets must be a valid pointer to an array of tileCount uint32_t values", + "page": "vkspec" + }, + { + "vuid": "VUID-VkVideoDecodeAV1PictureInfoKHR-pTileSizes-parameter", + "text": "pTileSizes must be a valid pointer to an array of tileCount uint32_t values", + "page": "vkspec" + }, + { + "vuid": "VUID-VkVideoDecodeAV1PictureInfoKHR-tileCount-arraylength", + "text": "tileCount must be greater than 0", + "page": "vkspec" + } + ] + }, + "VkVideoDecodeAV1DpbSlotInfoKHR": { + "core": [ + { + "vuid": "VUID-VkVideoDecodeAV1DpbSlotInfoKHR-sType-sType", + "text": "sType must be VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR", + "page": "vkspec" + }, + { + "vuid": "VUID-VkVideoDecodeAV1DpbSlotInfoKHR-pStdReferenceInfo-parameter", + "text": "pStdReferenceInfo must be a valid pointer to a valid StdVideoDecodeAV1ReferenceInfo value", + "page": "vkspec" + } + ] + }, "VkVideoEncodeCapabilitiesKHR": { "core": [ { @@ -103107,12 +103267,12 @@ }, { "vuid": "VUID-RuntimeSpirv-pNext-09226", - "text": "If a OpImageBlockMatchWindow*QCOM operation is used, then target sampled image must have been created using asampler object that included VkSamplerBlockMatchWindowCreateInfoQCOM in the pNext chain. ifdef:VK_KHR_shader_maximal_reconvergence[]", + "text": "If a OpImageBlockMatchWindow*QCOM operation is used, then target sampled image must have been created using asampler object that included VkSamplerBlockMatchWindowCreateInfoQCOM in the pNext chain.", "page": "vkspec" }, { "vuid": "VUID-RuntimeSpirv-MaximallyReconvergesKHR-09565", - "text": "The execution mode MaximallyReconvergesKHR must not be applied to an entry point unless the entry point does not execute any invocation repack instructions. endif:VK_KHR_shader_maximal_reconvergence[]", + "text": "The execution mode MaximallyReconvergesKHR must not be applied to an entry point unless the entry point does not execute any invocation repack instructions.", "page": "vkspec" }, { diff --git a/registry/video.xml b/registry/video.xml index 38b087e..d570742 100644 --- a/registry/video.xml +++ b/registry/video.xml @@ -23,11 +23,13 @@ The current public version of video.xml is maintained in the default branch + #include "vulkan_video_codecs_common.h" #include "vulkan_video_codec_h264std.h" #include "vulkan_video_codec_h265std.h" + #include "vulkan_video_codec_av1std.h" #define VK_MAKE_VIDEO_STD_VERSION(major, minor, patch) \ @@ -49,6 +51,10 @@ The current public version of video.xml is maintained in the default branch #define VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_API_VERSION_1_0_0 VK_MAKE_VIDEO_STD_VERSION(1, 0, 0) + + +#define VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_API_VERSION_1_0_0 VK_MAKE_VIDEO_STD_VERSION(1, 0, 0) + @@ -832,6 +838,277 @@ The current public version of video.xml is maintained in the default branch int32_t PicOrderCntValPicture order count derived as specified in 8.3.1 uint8_t TemporalIdTemporal ID, as defined in 7.4.2.2 + + + + + + + + + + + + + + + + Syntax defined in section 5.5.2, semantics defined in section 6.4.2 + uint32_t mono_chrome : 1 + uint32_t color_range : 1 + uint32_t separate_uv_delta_q : 1 + uint32_t color_description_present_flag : 1 + uint32_t reserved : 28 + + + Syntax defined in section 5.5.2, semantics defined in section 6.4.2 + StdVideoAV1ColorConfigFlags flags + uint8_t BitDepth + uint8_t subsampling_x + uint8_t subsampling_y + uint8_t reserved1Reserved for future use and must be initialized with 0. + StdVideoAV1ColorPrimaries color_primaries + StdVideoAV1TransferCharacteristics transfer_characteristics + StdVideoAV1MatrixCoefficients matrix_coefficients + StdVideoAV1ChromaSamplePosition chroma_sample_position + + + Syntax defined in section 5.5.3, semantics defined in section 6.4.3 + uint32_t equal_picture_interval : 1 + uint32_t reserved : 31 + + + Syntax defined in section 5.5.3, semantics defined in section 6.4.3 + StdVideoAV1TimingInfoFlags flags + uint32_t num_units_in_display_tick + uint32_t time_scale + uint32_t num_ticks_per_picture_minus_1 + + + Syntax defined in section 5.5, semantics defined in section 6.4 + uint32_t still_picture : 1 + uint32_t reduced_still_picture_header : 1 + uint32_t use_128x128_superblock : 1 + uint32_t enable_filter_intra : 1 + uint32_t enable_intra_edge_filter : 1 + uint32_t enable_interintra_compound : 1 + uint32_t enable_masked_compound : 1 + uint32_t enable_warped_motion : 1 + uint32_t enable_dual_filter : 1 + uint32_t enable_order_hint : 1 + uint32_t enable_jnt_comp : 1 + uint32_t enable_ref_frame_mvs : 1 + uint32_t frame_id_numbers_present_flag : 1 + uint32_t enable_superres : 1 + uint32_t enable_cdef : 1 + uint32_t enable_restoration : 1 + uint32_t film_grain_params_present : 1 + uint32_t timing_info_present_flag : 1 + uint32_t initial_display_delay_present_flag : 1 + uint32_t reserved : 13 + + + Syntax defined in section 5.5, semantics defined in section 6.4 + StdVideoAV1SequenceHeaderFlags flags + StdVideoAV1Profile seq_profile + uint8_t frame_width_bits_minus_1 + uint8_t frame_height_bits_minus_1 + uint16_t max_frame_width_minus_1 + uint16_t max_frame_height_minus_1 + uint8_t delta_frame_id_length_minus_2 + uint8_t additional_frame_id_length_minus_1 + uint8_t order_hint_bits_minus_1 + uint8_t seq_force_integer_mvThe final value of of seq_force_integer_mv per the value of seq_choose_integer_mv. + uint8_t seq_force_screen_content_toolsThe final value of of seq_force_screen_content_tools per the value of seq_choose_screen_content_tools. + uint8_t reserved1[5]Reserved for future use and must be initialized with 0. + const StdVideoAV1ColorConfig* pColorConfig + const StdVideoAV1TimingInfo* pTimingInfo + + + Syntax defined in section 5.9.11, semantics defined in section 6.8.10 + uint32_t loop_filter_delta_enabled : 1 + uint32_t loop_filter_delta_update : 1 + uint32_t reserved : 30 + + + Syntax defined in section 5.9.11, semantics defined in section 6.8.10 + StdVideoAV1LoopFilterFlags flags + uint8_t loop_filter_level[STD_VIDEO_AV1_MAX_LOOP_FILTER_STRENGTHS] + uint8_t loop_filter_sharpness + uint8_t update_ref_delta + int8_t loop_filter_ref_deltas[STD_VIDEO_AV1_TOTAL_REFS_PER_FRAME] + uint8_t update_mode_delta + int8_t loop_filter_mode_deltas[STD_VIDEO_AV1_LOOP_FILTER_ADJUSTMENTS] + + + Syntax defined in section 5.9.12, semantics defined in section 6.8.11 + uint32_t using_qmatrix : 1 + uint32_t diff_uv_delta : 1 + uint32_t reserved : 30 + + + Syntax defined in section 5.9.12, semantics defined in section 6.8.11 + StdVideoAV1QuantizationFlags flags + uint8_t base_q_idx + int8_t DeltaQYDc + int8_t DeltaQUDc + int8_t DeltaQUAc + int8_t DeltaQVDc + int8_t DeltaQVAc + uint8_t qm_y + uint8_t qm_u + uint8_t qm_v + + + Syntax defined in section 5.9.14, semantics defined in section 6.8.13 + uint8_t FeatureEnabled[STD_VIDEO_AV1_MAX_SEGMENTS]Each element contains 8 (SEG_LVL_MAX) bits, one bit for each feature within the segment + int16_t FeatureData[STD_VIDEO_AV1_MAX_SEGMENTS][STD_VIDEO_AV1_SEG_LVL_MAX] + + + Syntax defined in section 5.9.15, semantics defined in section 6.8.14 + uint32_t uniform_tile_spacing_flag : 1 + uint32_t reserved : 31 + + + Syntax defined in section 5.9.15, semantics defined in section 6.8.14 + StdVideoAV1TileInfoFlags flags + uint8_t TileCols + uint8_t TileRows + uint16_t context_update_tile_id + uint8_t tile_size_bytes_minus_1 + uint8_t reserved1[7]Reserved for future use and must be initialized with 0. + const uint16_t* pMiColStartsTileCols number of elements + const uint16_t* pMiRowStartsTileRows number of elements + const uint16_t* pWidthInSbsMinus1TileCols number of elements + const uint16_t* pHeightInSbsMinus1TileRows number of elements + + + Syntax defined in section 5.9.19, semantics defined in section 6.10.14 + uint8_t cdef_damping_minus_3 + uint8_t cdef_bits + uint8_t cdef_y_pri_strength[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS] + uint8_t cdef_y_sec_strength[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS] + uint8_t cdef_uv_pri_strength[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS] + uint8_t cdef_uv_sec_strength[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS] + + + Syntax defined in section 5.9.20, semantics defined in section 6.10.15 + StdVideoAV1FrameRestorationType FrameRestorationType[STD_VIDEO_AV1_MAX_NUM_PLANES] + uint16_t LoopRestorationSize[STD_VIDEO_AV1_MAX_NUM_PLANES] + + + Syntax defined in section 5.9.24, semantics defined in section 7.10 + uint8_t GmType[STD_VIDEO_AV1_NUM_REF_FRAMES] + int32_t gm_params[STD_VIDEO_AV1_NUM_REF_FRAMES][STD_VIDEO_AV1_GLOBAL_MOTION_PARAMS] + + + Syntax defined in section 5.9.30, semantics defined in section 6.8.20 + uint32_t chroma_scaling_from_luma : 1 + uint32_t overlap_flag : 1 + uint32_t clip_to_restricted_range : 1 + uint32_t update_grain : 1 + uint32_t reserved : 28 + + + Syntax defined in section 5.9.30, semantics defined in section 6.8.20 + StdVideoAV1FilmGrainFlags flags + uint8_t grain_scaling_minus_8 + uint8_t ar_coeff_lag + uint8_t ar_coeff_shift_minus_6 + uint8_t grain_scale_shift + uint16_t grain_seed + uint8_t film_grain_params_ref_idx + uint8_t num_y_points + uint8_t point_y_value[STD_VIDEO_AV1_MAX_NUM_Y_POINTS] + uint8_t point_y_scaling[STD_VIDEO_AV1_MAX_NUM_Y_POINTS] + uint8_t num_cb_points + uint8_t point_cb_value[STD_VIDEO_AV1_MAX_NUM_CB_POINTS] + uint8_t point_cb_scaling[STD_VIDEO_AV1_MAX_NUM_CB_POINTS] + uint8_t num_cr_points + uint8_t point_cr_value[STD_VIDEO_AV1_MAX_NUM_CR_POINTS] + uint8_t point_cr_scaling[STD_VIDEO_AV1_MAX_NUM_CR_POINTS] + int8_t ar_coeffs_y_plus_128[STD_VIDEO_AV1_MAX_NUM_POS_LUMA] + int8_t ar_coeffs_cb_plus_128[STD_VIDEO_AV1_MAX_NUM_POS_CHROMA] + int8_t ar_coeffs_cr_plus_128[STD_VIDEO_AV1_MAX_NUM_POS_CHROMA] + uint8_t cb_mult + uint8_t cb_luma_mult + uint16_t cb_offset + uint8_t cr_mult + uint8_t cr_luma_mult + uint16_t cr_offset + + + Syntax defined in section 5.9, semantics defined in section 6.8 + uint32_t error_resilient_mode : 1 + uint32_t disable_cdf_update : 1 + uint32_t use_superres : 1 + uint32_t render_and_frame_size_different : 1 + uint32_t allow_screen_content_tools : 1 + uint32_t is_filter_switchable : 1 + uint32_t force_integer_mv : 1 + uint32_t frame_size_override_flag : 1 + uint32_t buffer_removal_time_present_flag : 1 + uint32_t allow_intrabc : 1 + uint32_t frame_refs_short_signaling : 1 + uint32_t allow_high_precision_mv : 1 + uint32_t is_motion_mode_switchable : 1 + uint32_t use_ref_frame_mvs : 1 + uint32_t disable_frame_end_update_cdf : 1 + uint32_t allow_warped_motion : 1 + uint32_t reduced_tx_set : 1 + uint32_t reference_select : 1 + uint32_t skip_mode_present : 1 + uint32_t delta_q_present : 1 + uint32_t delta_lf_present : 1 + uint32_t delta_lf_multi : 1 + uint32_t segmentation_enabled : 1 + uint32_t segmentation_update_map : 1 + uint32_t segmentation_temporal_update : 1 + uint32_t segmentation_update_data : 1 + uint32_t UsesLr : 1 + uint32_t usesChromaLr : 1 + uint32_t apply_grain : 1 + uint32_t reserved : 3 + + + Syntax defined in sections 5.9 and 5.11.1, semantics defined in sections 6.8 and 6.10.1 + StdVideoDecodeAV1PictureInfoFlags flags + StdVideoAV1FrameType frame_type + uint32_t current_frame_id + uint8_t OrderHint + uint8_t primary_ref_frame + uint8_t refresh_frame_flags + uint8_t reserved1Reserved for future use and must be initialized with 0. + StdVideoAV1InterpolationFilter interpolation_filter + StdVideoAV1TxMode TxMode + uint8_t delta_q_res + uint8_t delta_lf_res + uint8_t SkipModeFrame[STD_VIDEO_AV1_SKIP_MODE_FRAMES] + uint8_t coded_denom + uint8_t reserved2[3]Reserved for future use and must be initialized with 0. + uint8_t OrderHints[STD_VIDEO_AV1_NUM_REF_FRAMES] + uint32_t expectedFrameId[STD_VIDEO_AV1_NUM_REF_FRAMES] + const StdVideoAV1TileInfo* pTileInfo + const StdVideoAV1Quantization* pQuantization + const StdVideoAV1Segmentation* pSegmentation + const StdVideoAV1LoopFilter* pLoopFilter + const StdVideoAV1CDEF* pCDEF + const StdVideoAV1LoopRestoration* pLoopRestoration + const StdVideoAV1GlobalMotion* pGlobalMotion + const StdVideoAV1FilmGrain* pFilmGrain + + + uint32_t disable_frame_end_update_cdf : 1 + uint32_t segmentation_enabled : 1 + uint32_t reserved : 30 + + + StdVideoDecodeAV1ReferenceInfoFlags flags + uint8_t frame_type + uint8_t RefFrameSignBias + uint8_t OrderHint + uint8_t SavedOrderHints[STD_VIDEO_AV1_NUM_REF_FRAMES] + @@ -1039,6 +1316,142 @@ The current public version of video.xml is maintained in the default branch + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -1214,5 +1627,77 @@ The current public version of video.xml is maintained in the default branch + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/registry/vk.xml b/registry/vk.xml index 82ec5eb..fb92b7c 100755 --- a/registry/vk.xml +++ b/registry/vk.xml @@ -175,7 +175,7 @@ branch of the member gitlab server. #define VKSC_API_VERSION_1_0 VK_MAKE_API_VERSION(VKSC_API_VARIANT, 1, 0, 0)// Patch version should always be set to 0 // Version of this file -#define VK_HEADER_VERSION 276 +#define VK_HEADER_VERSION 277 // Complete version of this file #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 3, VK_HEADER_VERSION) // Version of this file @@ -6866,6 +6866,44 @@ typedef void* MTLSharedEvent_id; const void* pNext const StdVideoDecodeH265ReferenceInfo* pStdReferenceInfo + #include "vk_video/vulkan_video_codec_av1std.h" + + + + #include "vk_video/vulkan_video_codec_av1std_decode.h" + + + + VkStructureType sType + const void* pNext + StdVideoAV1Profile stdProfile + VkBool32 filmGrainSupport + + + VkStructureType sType + void* pNext + StdVideoAV1Level maxLevel + + + VkStructureType sType + const void* pNext + const StdVideoAV1SequenceHeader* pStdSequenceHeader + + + VkStructureType sType + const void* pNext + const StdVideoDecodeAV1PictureInfo* pStdPictureInfo + int32_t referenceNameSlotIndices[VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR] + uint32_t frameHeaderOffset + uint32_t tileCount + const uint32_t* pTileOffsets + const uint32_t* pTileSizes + + + VkStructureType sType + const void* pNext + const StdVideoDecodeAV1ReferenceInfo* pStdReferenceInfo + VkStructureType sType const void* pNext @@ -9078,6 +9116,7 @@ typedef void* MTLSharedEvent_id; + @@ -20414,7 +20453,7 @@ typedef void* MTLSharedEvent_id; - + @@ -22472,9 +22511,11 @@ typedef void* MTLSharedEvent_id; - + + + @@ -23738,10 +23779,22 @@ typedef void* MTLSharedEvent_id; - + - - + + + + + + + + + + + + + + @@ -24134,6 +24187,30 @@ typedef void* MTLSharedEvent_id; + + + + + + + + + + + + + + + + + + + + + + + + @@ -26284,6 +26361,9 @@ typedef void* MTLSharedEvent_id; + + + diff --git a/registry/vkconventions.py b/registry/vkconventions.py index 07ccebe..cf0803b 100755 --- a/registry/vkconventions.py +++ b/registry/vkconventions.py @@ -119,6 +119,7 @@ class VulkanConventions(ConventionsBase): # The simple-minded rules need modification for some structure names subpats = [ [ r'_H_(26[45])_', r'_H\1_' ], + [ r'_AV_1_', r'_AV1_' ], [ r'_VULKAN_([0-9])([0-9])_', r'_VULKAN_\1_\2_' ], [ r'_VULKAN_SC_([0-9])([0-9])_',r'_VULKAN_SC_\1_\2_' ], [ r'_DIRECT_FB_', r'_DIRECTFB_' ],