1 // Copyright 2021-2023 The Khronos Group Inc. 2 // SPDX-License-Identifier: Apache-2.0 OR MIT 3 // 4 5 // This header is generated from the Khronos Vulkan XML API Registry. 6 7 #include <vk_video/vulkan_video_codec_h264std.h> 8 #include <vk_video/vulkan_video_codec_h264std_decode.h> 9 #include <vk_video/vulkan_video_codec_h264std_encode.h> 10 #include <vk_video/vulkan_video_codec_h265std.h> 11 #include <vk_video/vulkan_video_codec_h265std_decode.h> 12 #include <vk_video/vulkan_video_codec_h265std_encode.h> 13 #include <vk_video/vulkan_video_codecs_common.h> 14 #include <vulkan/vulkan.hpp> 15 16 #if !defined( VULKAN_HPP_VIDEO_NAMESPACE ) 17 # define VULKAN_HPP_VIDEO_NAMESPACE video 18 #endif 19 20 namespace VULKAN_HPP_NAMESPACE 21 { 22 namespace VULKAN_HPP_VIDEO_NAMESPACE 23 { 24 25 //============= 26 //=== ENUMs === 27 //============= 28 29 //=== vulkan_video_codec_h264std === 30 31 enum class H264ChromaFormatIdc 32 { 33 eMonochrome = STD_VIDEO_H264_CHROMA_FORMAT_IDC_MONOCHROME, 34 e420 = STD_VIDEO_H264_CHROMA_FORMAT_IDC_420, 35 e422 = STD_VIDEO_H264_CHROMA_FORMAT_IDC_422, 36 e444 = STD_VIDEO_H264_CHROMA_FORMAT_IDC_444, 37 eInvalid = STD_VIDEO_H264_CHROMA_FORMAT_IDC_INVALID 38 }; 39 40 enum class H264ProfileIdc 41 { 42 eBaseline = STD_VIDEO_H264_PROFILE_IDC_BASELINE, 43 eMain = STD_VIDEO_H264_PROFILE_IDC_MAIN, 44 eHigh = STD_VIDEO_H264_PROFILE_IDC_HIGH, 45 eHigh444Predictive = STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE, 46 eInvalid = STD_VIDEO_H264_PROFILE_IDC_INVALID 47 }; 48 49 enum class H264LevelIdc 50 { 51 e1_0 = STD_VIDEO_H264_LEVEL_IDC_1_0, 52 e1_1 = STD_VIDEO_H264_LEVEL_IDC_1_1, 53 e1_2 = STD_VIDEO_H264_LEVEL_IDC_1_2, 54 e1_3 = STD_VIDEO_H264_LEVEL_IDC_1_3, 55 e2_0 = STD_VIDEO_H264_LEVEL_IDC_2_0, 56 e2_1 = STD_VIDEO_H264_LEVEL_IDC_2_1, 57 e2_2 = STD_VIDEO_H264_LEVEL_IDC_2_2, 58 e3_0 = STD_VIDEO_H264_LEVEL_IDC_3_0, 59 e3_1 = STD_VIDEO_H264_LEVEL_IDC_3_1, 60 e3_2 = STD_VIDEO_H264_LEVEL_IDC_3_2, 61 e4_0 = STD_VIDEO_H264_LEVEL_IDC_4_0, 62 e4_1 = STD_VIDEO_H264_LEVEL_IDC_4_1, 63 e4_2 = STD_VIDEO_H264_LEVEL_IDC_4_2, 64 e5_0 = STD_VIDEO_H264_LEVEL_IDC_5_0, 65 e5_1 = STD_VIDEO_H264_LEVEL_IDC_5_1, 66 e5_2 = STD_VIDEO_H264_LEVEL_IDC_5_2, 67 e6_0 = STD_VIDEO_H264_LEVEL_IDC_6_0, 68 e6_1 = STD_VIDEO_H264_LEVEL_IDC_6_1, 69 e6_2 = STD_VIDEO_H264_LEVEL_IDC_6_2, 70 eInvalid = STD_VIDEO_H264_LEVEL_IDC_INVALID 71 }; 72 73 enum class H264PocType 74 { 75 e0 = STD_VIDEO_H264_POC_TYPE_0, 76 e1 = STD_VIDEO_H264_POC_TYPE_1, 77 e2 = STD_VIDEO_H264_POC_TYPE_2, 78 eInvalid = STD_VIDEO_H264_POC_TYPE_INVALID 79 }; 80 81 enum class H264AspectRatioIdc 82 { 83 eUnspecified = STD_VIDEO_H264_ASPECT_RATIO_IDC_UNSPECIFIED, 84 eSquare = STD_VIDEO_H264_ASPECT_RATIO_IDC_SQUARE, 85 e12_11 = STD_VIDEO_H264_ASPECT_RATIO_IDC_12_11, 86 e10_11 = STD_VIDEO_H264_ASPECT_RATIO_IDC_10_11, 87 e16_11 = STD_VIDEO_H264_ASPECT_RATIO_IDC_16_11, 88 e40_33 = STD_VIDEO_H264_ASPECT_RATIO_IDC_40_33, 89 e24_11 = STD_VIDEO_H264_ASPECT_RATIO_IDC_24_11, 90 e20_11 = STD_VIDEO_H264_ASPECT_RATIO_IDC_20_11, 91 e32_11 = STD_VIDEO_H264_ASPECT_RATIO_IDC_32_11, 92 e80_33 = STD_VIDEO_H264_ASPECT_RATIO_IDC_80_33, 93 e18_11 = STD_VIDEO_H264_ASPECT_RATIO_IDC_18_11, 94 e15_11 = STD_VIDEO_H264_ASPECT_RATIO_IDC_15_11, 95 e64_33 = STD_VIDEO_H264_ASPECT_RATIO_IDC_64_33, 96 e160_99 = STD_VIDEO_H264_ASPECT_RATIO_IDC_160_99, 97 e4_3 = STD_VIDEO_H264_ASPECT_RATIO_IDC_4_3, 98 e3_2 = STD_VIDEO_H264_ASPECT_RATIO_IDC_3_2, 99 e2_1 = STD_VIDEO_H264_ASPECT_RATIO_IDC_2_1, 100 eExtendedSar = STD_VIDEO_H264_ASPECT_RATIO_IDC_EXTENDED_SAR, 101 eInvalid = STD_VIDEO_H264_ASPECT_RATIO_IDC_INVALID 102 }; 103 104 enum class H264WeightedBipredIdc 105 { 106 eDefault = STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_DEFAULT, 107 eExplicit = STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_EXPLICIT, 108 eImplicit = STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_IMPLICIT, 109 eInvalid = STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_INVALID 110 }; 111 112 enum class H264ModificationOfPicNumsIdc 113 { 114 eShortTermSubtract = STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_SUBTRACT, 115 eShortTermAdd = STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_ADD, 116 eLongTerm = STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_LONG_TERM, 117 eEnd = STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_END, 118 eInvalid = STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_INVALID 119 }; 120 121 enum class H264MemMgmtControlOp 122 { 123 eEnd = STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_END, 124 eUnmarkShortTerm = STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_SHORT_TERM, 125 eUnmarkLongTerm = STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_LONG_TERM, 126 eMarkLongTerm = STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_LONG_TERM, 127 eSetMaxLongTermIndex = STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_SET_MAX_LONG_TERM_INDEX, 128 eUnmarkAll = STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_ALL, 129 eMarkCurrentAsLongTerm = STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_CURRENT_AS_LONG_TERM, 130 eInvalid = STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_INVALID 131 }; 132 133 enum class H264CabacInitIdc 134 { 135 e0 = STD_VIDEO_H264_CABAC_INIT_IDC_0, 136 e1 = STD_VIDEO_H264_CABAC_INIT_IDC_1, 137 e2 = STD_VIDEO_H264_CABAC_INIT_IDC_2, 138 eInvalid = STD_VIDEO_H264_CABAC_INIT_IDC_INVALID 139 }; 140 141 enum class H264DisableDeblockingFilterIdc 142 { 143 eDisabled = STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_DISABLED, 144 eEnabled = STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_ENABLED, 145 ePartial = STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_PARTIAL, 146 eInvalid = STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_INVALID 147 }; 148 149 enum class H264SliceType 150 { 151 eP = STD_VIDEO_H264_SLICE_TYPE_P, 152 eB = STD_VIDEO_H264_SLICE_TYPE_B, 153 eI = STD_VIDEO_H264_SLICE_TYPE_I, 154 eInvalid = STD_VIDEO_H264_SLICE_TYPE_INVALID 155 }; 156 157 enum class H264PictureType 158 { 159 eP = STD_VIDEO_H264_PICTURE_TYPE_P, 160 eB = STD_VIDEO_H264_PICTURE_TYPE_B, 161 eI = STD_VIDEO_H264_PICTURE_TYPE_I, 162 eIdr = STD_VIDEO_H264_PICTURE_TYPE_IDR, 163 eInvalid = STD_VIDEO_H264_PICTURE_TYPE_INVALID 164 }; 165 166 enum class H264NonVclNaluType 167 { 168 eSps = STD_VIDEO_H264_NON_VCL_NALU_TYPE_SPS, 169 ePps = STD_VIDEO_H264_NON_VCL_NALU_TYPE_PPS, 170 eAud = STD_VIDEO_H264_NON_VCL_NALU_TYPE_AUD, 171 ePrefix = STD_VIDEO_H264_NON_VCL_NALU_TYPE_PREFIX, 172 eEndOfSequence = STD_VIDEO_H264_NON_VCL_NALU_TYPE_END_OF_SEQUENCE, 173 eEndOfStream = STD_VIDEO_H264_NON_VCL_NALU_TYPE_END_OF_STREAM, 174 ePrecoded = STD_VIDEO_H264_NON_VCL_NALU_TYPE_PRECODED, 175 eInvalid = STD_VIDEO_H264_NON_VCL_NALU_TYPE_INVALID 176 }; 177 178 //=== vulkan_video_codec_h264std_decode === 179 180 enum class DecodeH264FieldOrderCount 181 { 182 eTop = STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_TOP, 183 eBottom = STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_BOTTOM, 184 eInvalid = STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_INVALID 185 }; 186 187 //=== vulkan_video_codec_h265std === 188 189 enum class H265ChromaFormatIdc 190 { 191 eMonochrome = STD_VIDEO_H265_CHROMA_FORMAT_IDC_MONOCHROME, 192 e420 = STD_VIDEO_H265_CHROMA_FORMAT_IDC_420, 193 e422 = STD_VIDEO_H265_CHROMA_FORMAT_IDC_422, 194 e444 = STD_VIDEO_H265_CHROMA_FORMAT_IDC_444, 195 eInvalid = STD_VIDEO_H265_CHROMA_FORMAT_IDC_INVALID 196 }; 197 198 enum class H265ProfileIdc 199 { 200 eMain = STD_VIDEO_H265_PROFILE_IDC_MAIN, 201 eMain10 = STD_VIDEO_H265_PROFILE_IDC_MAIN_10, 202 eMainStillPicture = STD_VIDEO_H265_PROFILE_IDC_MAIN_STILL_PICTURE, 203 eFormatRangeExtensions = STD_VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS, 204 eSccExtensions = STD_VIDEO_H265_PROFILE_IDC_SCC_EXTENSIONS, 205 eInvalid = STD_VIDEO_H265_PROFILE_IDC_INVALID 206 }; 207 208 enum class H265LevelIdc 209 { 210 e1_0 = STD_VIDEO_H265_LEVEL_IDC_1_0, 211 e2_0 = STD_VIDEO_H265_LEVEL_IDC_2_0, 212 e2_1 = STD_VIDEO_H265_LEVEL_IDC_2_1, 213 e3_0 = STD_VIDEO_H265_LEVEL_IDC_3_0, 214 e3_1 = STD_VIDEO_H265_LEVEL_IDC_3_1, 215 e4_0 = STD_VIDEO_H265_LEVEL_IDC_4_0, 216 e4_1 = STD_VIDEO_H265_LEVEL_IDC_4_1, 217 e5_0 = STD_VIDEO_H265_LEVEL_IDC_5_0, 218 e5_1 = STD_VIDEO_H265_LEVEL_IDC_5_1, 219 e5_2 = STD_VIDEO_H265_LEVEL_IDC_5_2, 220 e6_0 = STD_VIDEO_H265_LEVEL_IDC_6_0, 221 e6_1 = STD_VIDEO_H265_LEVEL_IDC_6_1, 222 e6_2 = STD_VIDEO_H265_LEVEL_IDC_6_2, 223 eInvalid = STD_VIDEO_H265_LEVEL_IDC_INVALID 224 }; 225 226 enum class H265SliceType 227 { 228 eB = STD_VIDEO_H265_SLICE_TYPE_B, 229 eP = STD_VIDEO_H265_SLICE_TYPE_P, 230 eI = STD_VIDEO_H265_SLICE_TYPE_I, 231 eInvalid = STD_VIDEO_H265_SLICE_TYPE_INVALID 232 }; 233 234 enum class H265PictureType 235 { 236 eP = STD_VIDEO_H265_PICTURE_TYPE_P, 237 eB = STD_VIDEO_H265_PICTURE_TYPE_B, 238 eI = STD_VIDEO_H265_PICTURE_TYPE_I, 239 eIdr = STD_VIDEO_H265_PICTURE_TYPE_IDR, 240 eInvalid = STD_VIDEO_H265_PICTURE_TYPE_INVALID 241 }; 242 243 enum class H265AspectRatioIdc 244 { 245 eUnspecified = STD_VIDEO_H265_ASPECT_RATIO_IDC_UNSPECIFIED, 246 eSquare = STD_VIDEO_H265_ASPECT_RATIO_IDC_SQUARE, 247 e12_11 = STD_VIDEO_H265_ASPECT_RATIO_IDC_12_11, 248 e10_11 = STD_VIDEO_H265_ASPECT_RATIO_IDC_10_11, 249 e16_11 = STD_VIDEO_H265_ASPECT_RATIO_IDC_16_11, 250 e40_33 = STD_VIDEO_H265_ASPECT_RATIO_IDC_40_33, 251 e24_11 = STD_VIDEO_H265_ASPECT_RATIO_IDC_24_11, 252 e20_11 = STD_VIDEO_H265_ASPECT_RATIO_IDC_20_11, 253 e32_11 = STD_VIDEO_H265_ASPECT_RATIO_IDC_32_11, 254 e80_33 = STD_VIDEO_H265_ASPECT_RATIO_IDC_80_33, 255 e18_11 = STD_VIDEO_H265_ASPECT_RATIO_IDC_18_11, 256 e15_11 = STD_VIDEO_H265_ASPECT_RATIO_IDC_15_11, 257 e64_33 = STD_VIDEO_H265_ASPECT_RATIO_IDC_64_33, 258 e160_99 = STD_VIDEO_H265_ASPECT_RATIO_IDC_160_99, 259 e4_3 = STD_VIDEO_H265_ASPECT_RATIO_IDC_4_3, 260 e3_2 = STD_VIDEO_H265_ASPECT_RATIO_IDC_3_2, 261 e2_1 = STD_VIDEO_H265_ASPECT_RATIO_IDC_2_1, 262 eExtendedSar = STD_VIDEO_H265_ASPECT_RATIO_IDC_EXTENDED_SAR, 263 eInvalid = STD_VIDEO_H265_ASPECT_RATIO_IDC_INVALID 264 }; 265 266 //=============== 267 //=== STRUCTS === 268 //=============== 269 270 //=== vulkan_video_codec_h264std === 271 272 struct H264SpsVuiFlags 273 { 274 using NativeType = StdVideoH264SpsVuiFlags; 275 operator StdVideoH264SpsVuiFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SpsVuiFlags276 operator StdVideoH264SpsVuiFlags const &() const VULKAN_HPP_NOEXCEPT 277 { 278 return *reinterpret_cast<const StdVideoH264SpsVuiFlags *>( this ); 279 } 280 operator StdVideoH264SpsVuiFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SpsVuiFlags281 operator StdVideoH264SpsVuiFlags &() VULKAN_HPP_NOEXCEPT 282 { 283 return *reinterpret_cast<StdVideoH264SpsVuiFlags *>( this ); 284 } 285 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SpsVuiFlags286 bool operator==( H264SpsVuiFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 287 { 288 return ( aspect_ratio_info_present_flag == rhs.aspect_ratio_info_present_flag ) && ( overscan_info_present_flag == rhs.overscan_info_present_flag ) && 289 ( overscan_appropriate_flag == rhs.overscan_appropriate_flag ) && ( video_signal_type_present_flag == rhs.video_signal_type_present_flag ) && 290 ( video_full_range_flag == rhs.video_full_range_flag ) && ( color_description_present_flag == rhs.color_description_present_flag ) && 291 ( chroma_loc_info_present_flag == rhs.chroma_loc_info_present_flag ) && ( timing_info_present_flag == rhs.timing_info_present_flag ) && 292 ( fixed_frame_rate_flag == rhs.fixed_frame_rate_flag ) && ( bitstream_restriction_flag == rhs.bitstream_restriction_flag ) && 293 ( nal_hrd_parameters_present_flag == rhs.nal_hrd_parameters_present_flag ) && 294 ( vcl_hrd_parameters_present_flag == rhs.vcl_hrd_parameters_present_flag ); 295 } 296 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SpsVuiFlags297 bool operator!=( H264SpsVuiFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 298 { 299 return !operator==( rhs ); 300 } 301 302 public: 303 uint32_t aspect_ratio_info_present_flag : 1; 304 uint32_t overscan_info_present_flag : 1; 305 uint32_t overscan_appropriate_flag : 1; 306 uint32_t video_signal_type_present_flag : 1; 307 uint32_t video_full_range_flag : 1; 308 uint32_t color_description_present_flag : 1; 309 uint32_t chroma_loc_info_present_flag : 1; 310 uint32_t timing_info_present_flag : 1; 311 uint32_t fixed_frame_rate_flag : 1; 312 uint32_t bitstream_restriction_flag : 1; 313 uint32_t nal_hrd_parameters_present_flag : 1; 314 uint32_t vcl_hrd_parameters_present_flag : 1; 315 }; 316 317 struct H264HrdParameters 318 { 319 using NativeType = StdVideoH264HrdParameters; 320 operator StdVideoH264HrdParameters const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264HrdParameters321 operator StdVideoH264HrdParameters const &() const VULKAN_HPP_NOEXCEPT 322 { 323 return *reinterpret_cast<const StdVideoH264HrdParameters *>( this ); 324 } 325 operator StdVideoH264HrdParameters&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264HrdParameters326 operator StdVideoH264HrdParameters &() VULKAN_HPP_NOEXCEPT 327 { 328 return *reinterpret_cast<StdVideoH264HrdParameters *>( this ); 329 } 330 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264HrdParameters331 bool operator==( H264HrdParameters const & rhs ) const VULKAN_HPP_NOEXCEPT 332 { 333 return ( cpb_cnt_minus1 == rhs.cpb_cnt_minus1 ) && ( bit_rate_scale == rhs.bit_rate_scale ) && ( cpb_size_scale == rhs.cpb_size_scale ) && 334 ( reserved1 == rhs.reserved1 ) && ( bit_rate_value_minus1 == rhs.bit_rate_value_minus1 ) && 335 ( cpb_size_value_minus1 == rhs.cpb_size_value_minus1 ) && ( cbr_flag == rhs.cbr_flag ) && 336 ( initial_cpb_removal_delay_length_minus1 == rhs.initial_cpb_removal_delay_length_minus1 ) && 337 ( cpb_removal_delay_length_minus1 == rhs.cpb_removal_delay_length_minus1 ) && 338 ( dpb_output_delay_length_minus1 == rhs.dpb_output_delay_length_minus1 ) && ( time_offset_length == rhs.time_offset_length ); 339 } 340 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264HrdParameters341 bool operator!=( H264HrdParameters const & rhs ) const VULKAN_HPP_NOEXCEPT 342 { 343 return !operator==( rhs ); 344 } 345 346 public: 347 uint8_t cpb_cnt_minus1 = {}; 348 uint8_t bit_rate_scale = {}; 349 uint8_t cpb_size_scale = {}; 350 uint8_t reserved1 = {}; 351 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, STD_VIDEO_H264_CPB_CNT_LIST_SIZE> bit_rate_value_minus1 = {}; 352 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, STD_VIDEO_H264_CPB_CNT_LIST_SIZE> cpb_size_value_minus1 = {}; 353 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H264_CPB_CNT_LIST_SIZE> cbr_flag = {}; 354 uint32_t initial_cpb_removal_delay_length_minus1 = {}; 355 uint32_t cpb_removal_delay_length_minus1 = {}; 356 uint32_t dpb_output_delay_length_minus1 = {}; 357 uint32_t time_offset_length = {}; 358 }; 359 360 struct H264SequenceParameterSetVui 361 { 362 using NativeType = StdVideoH264SequenceParameterSetVui; 363 operator StdVideoH264SequenceParameterSetVui const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SequenceParameterSetVui364 operator StdVideoH264SequenceParameterSetVui const &() const VULKAN_HPP_NOEXCEPT 365 { 366 return *reinterpret_cast<const StdVideoH264SequenceParameterSetVui *>( this ); 367 } 368 operator StdVideoH264SequenceParameterSetVui&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SequenceParameterSetVui369 operator StdVideoH264SequenceParameterSetVui &() VULKAN_HPP_NOEXCEPT 370 { 371 return *reinterpret_cast<StdVideoH264SequenceParameterSetVui *>( this ); 372 } 373 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SequenceParameterSetVui374 bool operator==( H264SequenceParameterSetVui const & rhs ) const VULKAN_HPP_NOEXCEPT 375 { 376 return ( flags == rhs.flags ) && ( aspect_ratio_idc == rhs.aspect_ratio_idc ) && ( sar_width == rhs.sar_width ) && ( sar_height == rhs.sar_height ) && 377 ( video_format == rhs.video_format ) && ( colour_primaries == rhs.colour_primaries ) && 378 ( transfer_characteristics == rhs.transfer_characteristics ) && ( matrix_coefficients == rhs.matrix_coefficients ) && 379 ( num_units_in_tick == rhs.num_units_in_tick ) && ( time_scale == rhs.time_scale ) && ( max_num_reorder_frames == rhs.max_num_reorder_frames ) && 380 ( max_dec_frame_buffering == rhs.max_dec_frame_buffering ) && ( chroma_sample_loc_type_top_field == rhs.chroma_sample_loc_type_top_field ) && 381 ( chroma_sample_loc_type_bottom_field == rhs.chroma_sample_loc_type_bottom_field ) && ( reserved1 == rhs.reserved1 ) && 382 ( pHrdParameters == rhs.pHrdParameters ); 383 } 384 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SequenceParameterSetVui385 bool operator!=( H264SequenceParameterSetVui const & rhs ) const VULKAN_HPP_NOEXCEPT 386 { 387 return !operator==( rhs ); 388 } 389 390 public: 391 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SpsVuiFlags flags = {}; 392 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264AspectRatioIdc aspect_ratio_idc = 393 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264AspectRatioIdc::eUnspecified; 394 uint16_t sar_width = {}; 395 uint16_t sar_height = {}; 396 uint8_t video_format = {}; 397 uint8_t colour_primaries = {}; 398 uint8_t transfer_characteristics = {}; 399 uint8_t matrix_coefficients = {}; 400 uint32_t num_units_in_tick = {}; 401 uint32_t time_scale = {}; 402 uint8_t max_num_reorder_frames = {}; 403 uint8_t max_dec_frame_buffering = {}; 404 uint8_t chroma_sample_loc_type_top_field = {}; 405 uint8_t chroma_sample_loc_type_bottom_field = {}; 406 uint32_t reserved1 = {}; 407 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264HrdParameters * pHrdParameters = {}; 408 }; 409 410 struct H264SpsFlags 411 { 412 using NativeType = StdVideoH264SpsFlags; 413 operator StdVideoH264SpsFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SpsFlags414 operator StdVideoH264SpsFlags const &() const VULKAN_HPP_NOEXCEPT 415 { 416 return *reinterpret_cast<const StdVideoH264SpsFlags *>( this ); 417 } 418 operator StdVideoH264SpsFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SpsFlags419 operator StdVideoH264SpsFlags &() VULKAN_HPP_NOEXCEPT 420 { 421 return *reinterpret_cast<StdVideoH264SpsFlags *>( this ); 422 } 423 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SpsFlags424 bool operator==( H264SpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 425 { 426 return ( constraint_set0_flag == rhs.constraint_set0_flag ) && ( constraint_set1_flag == rhs.constraint_set1_flag ) && 427 ( constraint_set2_flag == rhs.constraint_set2_flag ) && ( constraint_set3_flag == rhs.constraint_set3_flag ) && 428 ( constraint_set4_flag == rhs.constraint_set4_flag ) && ( constraint_set5_flag == rhs.constraint_set5_flag ) && 429 ( direct_8x8_inference_flag == rhs.direct_8x8_inference_flag ) && ( mb_adaptive_frame_field_flag == rhs.mb_adaptive_frame_field_flag ) && 430 ( frame_mbs_only_flag == rhs.frame_mbs_only_flag ) && ( delta_pic_order_always_zero_flag == rhs.delta_pic_order_always_zero_flag ) && 431 ( separate_colour_plane_flag == rhs.separate_colour_plane_flag ) && 432 ( gaps_in_frame_num_value_allowed_flag == rhs.gaps_in_frame_num_value_allowed_flag ) && 433 ( qpprime_y_zero_transform_bypass_flag == rhs.qpprime_y_zero_transform_bypass_flag ) && ( frame_cropping_flag == rhs.frame_cropping_flag ) && 434 ( seq_scaling_matrix_present_flag == rhs.seq_scaling_matrix_present_flag ) && ( vui_parameters_present_flag == rhs.vui_parameters_present_flag ); 435 } 436 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SpsFlags437 bool operator!=( H264SpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 438 { 439 return !operator==( rhs ); 440 } 441 442 public: 443 uint32_t constraint_set0_flag : 1; 444 uint32_t constraint_set1_flag : 1; 445 uint32_t constraint_set2_flag : 1; 446 uint32_t constraint_set3_flag : 1; 447 uint32_t constraint_set4_flag : 1; 448 uint32_t constraint_set5_flag : 1; 449 uint32_t direct_8x8_inference_flag : 1; 450 uint32_t mb_adaptive_frame_field_flag : 1; 451 uint32_t frame_mbs_only_flag : 1; 452 uint32_t delta_pic_order_always_zero_flag : 1; 453 uint32_t separate_colour_plane_flag : 1; 454 uint32_t gaps_in_frame_num_value_allowed_flag : 1; 455 uint32_t qpprime_y_zero_transform_bypass_flag : 1; 456 uint32_t frame_cropping_flag : 1; 457 uint32_t seq_scaling_matrix_present_flag : 1; 458 uint32_t vui_parameters_present_flag : 1; 459 }; 460 461 struct H264ScalingLists 462 { 463 using NativeType = StdVideoH264ScalingLists; 464 operator StdVideoH264ScalingLists const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingLists465 operator StdVideoH264ScalingLists const &() const VULKAN_HPP_NOEXCEPT 466 { 467 return *reinterpret_cast<const StdVideoH264ScalingLists *>( this ); 468 } 469 operator StdVideoH264ScalingLists&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingLists470 operator StdVideoH264ScalingLists &() VULKAN_HPP_NOEXCEPT 471 { 472 return *reinterpret_cast<StdVideoH264ScalingLists *>( this ); 473 } 474 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingLists475 bool operator==( H264ScalingLists const & rhs ) const VULKAN_HPP_NOEXCEPT 476 { 477 return ( scaling_list_present_mask == rhs.scaling_list_present_mask ) && ( use_default_scaling_matrix_mask == rhs.use_default_scaling_matrix_mask ) && 478 ( ScalingList4x4 == rhs.ScalingList4x4 ) && ( ScalingList8x8 == rhs.ScalingList8x8 ); 479 } 480 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingLists481 bool operator!=( H264ScalingLists const & rhs ) const VULKAN_HPP_NOEXCEPT 482 { 483 return !operator==( rhs ); 484 } 485 486 public: 487 uint16_t scaling_list_present_mask = {}; 488 uint16_t use_default_scaling_matrix_mask = {}; 489 VULKAN_HPP_NAMESPACE::ArrayWrapper2D<uint8_t, STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS, STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS> 490 ScalingList4x4 = {}; 491 VULKAN_HPP_NAMESPACE::ArrayWrapper2D<uint8_t, STD_VIDEO_H264_SCALING_LIST_8X8_NUM_LISTS, STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS> 492 ScalingList8x8 = {}; 493 }; 494 495 struct H264SequenceParameterSet 496 { 497 using NativeType = StdVideoH264SequenceParameterSet; 498 operator StdVideoH264SequenceParameterSet const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SequenceParameterSet499 operator StdVideoH264SequenceParameterSet const &() const VULKAN_HPP_NOEXCEPT 500 { 501 return *reinterpret_cast<const StdVideoH264SequenceParameterSet *>( this ); 502 } 503 operator StdVideoH264SequenceParameterSet&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SequenceParameterSet504 operator StdVideoH264SequenceParameterSet &() VULKAN_HPP_NOEXCEPT 505 { 506 return *reinterpret_cast<StdVideoH264SequenceParameterSet *>( this ); 507 } 508 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SequenceParameterSet509 bool operator==( H264SequenceParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT 510 { 511 return ( flags == rhs.flags ) && ( profile_idc == rhs.profile_idc ) && ( level_idc == rhs.level_idc ) && 512 ( chroma_format_idc == rhs.chroma_format_idc ) && ( seq_parameter_set_id == rhs.seq_parameter_set_id ) && 513 ( bit_depth_luma_minus8 == rhs.bit_depth_luma_minus8 ) && ( bit_depth_chroma_minus8 == rhs.bit_depth_chroma_minus8 ) && 514 ( log2_max_frame_num_minus4 == rhs.log2_max_frame_num_minus4 ) && ( pic_order_cnt_type == rhs.pic_order_cnt_type ) && 515 ( offset_for_non_ref_pic == rhs.offset_for_non_ref_pic ) && ( offset_for_top_to_bottom_field == rhs.offset_for_top_to_bottom_field ) && 516 ( log2_max_pic_order_cnt_lsb_minus4 == rhs.log2_max_pic_order_cnt_lsb_minus4 ) && 517 ( num_ref_frames_in_pic_order_cnt_cycle == rhs.num_ref_frames_in_pic_order_cnt_cycle ) && ( max_num_ref_frames == rhs.max_num_ref_frames ) && 518 ( reserved1 == rhs.reserved1 ) && ( pic_width_in_mbs_minus1 == rhs.pic_width_in_mbs_minus1 ) && 519 ( pic_height_in_map_units_minus1 == rhs.pic_height_in_map_units_minus1 ) && ( frame_crop_left_offset == rhs.frame_crop_left_offset ) && 520 ( frame_crop_right_offset == rhs.frame_crop_right_offset ) && ( frame_crop_top_offset == rhs.frame_crop_top_offset ) && 521 ( frame_crop_bottom_offset == rhs.frame_crop_bottom_offset ) && ( reserved2 == rhs.reserved2 ) && 522 ( pOffsetForRefFrame == rhs.pOffsetForRefFrame ) && ( pScalingLists == rhs.pScalingLists ) && 523 ( pSequenceParameterSetVui == rhs.pSequenceParameterSetVui ); 524 } 525 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SequenceParameterSet526 bool operator!=( H264SequenceParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT 527 { 528 return !operator==( rhs ); 529 } 530 531 public: 532 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SpsFlags flags = {}; 533 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ProfileIdc profile_idc = 534 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ProfileIdc::eBaseline; 535 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264LevelIdc level_idc = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264LevelIdc::e1_0; 536 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ChromaFormatIdc chroma_format_idc = 537 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ChromaFormatIdc::eMonochrome; 538 uint8_t seq_parameter_set_id = {}; 539 uint8_t bit_depth_luma_minus8 = {}; 540 uint8_t bit_depth_chroma_minus8 = {}; 541 uint8_t log2_max_frame_num_minus4 = {}; 542 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PocType pic_order_cnt_type = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PocType::e0; 543 int32_t offset_for_non_ref_pic = {}; 544 int32_t offset_for_top_to_bottom_field = {}; 545 uint8_t log2_max_pic_order_cnt_lsb_minus4 = {}; 546 uint8_t num_ref_frames_in_pic_order_cnt_cycle = {}; 547 uint8_t max_num_ref_frames = {}; 548 uint8_t reserved1 = {}; 549 uint32_t pic_width_in_mbs_minus1 = {}; 550 uint32_t pic_height_in_map_units_minus1 = {}; 551 uint32_t frame_crop_left_offset = {}; 552 uint32_t frame_crop_right_offset = {}; 553 uint32_t frame_crop_top_offset = {}; 554 uint32_t frame_crop_bottom_offset = {}; 555 uint32_t reserved2 = {}; 556 const int32_t * pOffsetForRefFrame = {}; 557 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingLists * pScalingLists = {}; 558 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SequenceParameterSetVui * pSequenceParameterSetVui = {}; 559 }; 560 561 struct H264PpsFlags 562 { 563 using NativeType = StdVideoH264PpsFlags; 564 operator StdVideoH264PpsFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PpsFlags565 operator StdVideoH264PpsFlags const &() const VULKAN_HPP_NOEXCEPT 566 { 567 return *reinterpret_cast<const StdVideoH264PpsFlags *>( this ); 568 } 569 operator StdVideoH264PpsFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PpsFlags570 operator StdVideoH264PpsFlags &() VULKAN_HPP_NOEXCEPT 571 { 572 return *reinterpret_cast<StdVideoH264PpsFlags *>( this ); 573 } 574 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PpsFlags575 bool operator==( H264PpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 576 { 577 return ( transform_8x8_mode_flag == rhs.transform_8x8_mode_flag ) && ( redundant_pic_cnt_present_flag == rhs.redundant_pic_cnt_present_flag ) && 578 ( constrained_intra_pred_flag == rhs.constrained_intra_pred_flag ) && 579 ( deblocking_filter_control_present_flag == rhs.deblocking_filter_control_present_flag ) && ( weighted_pred_flag == rhs.weighted_pred_flag ) && 580 ( bottom_field_pic_order_in_frame_present_flag == rhs.bottom_field_pic_order_in_frame_present_flag ) && 581 ( entropy_coding_mode_flag == rhs.entropy_coding_mode_flag ) && ( pic_scaling_matrix_present_flag == rhs.pic_scaling_matrix_present_flag ); 582 } 583 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PpsFlags584 bool operator!=( H264PpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 585 { 586 return !operator==( rhs ); 587 } 588 589 public: 590 uint32_t transform_8x8_mode_flag : 1; 591 uint32_t redundant_pic_cnt_present_flag : 1; 592 uint32_t constrained_intra_pred_flag : 1; 593 uint32_t deblocking_filter_control_present_flag : 1; 594 uint32_t weighted_pred_flag : 1; 595 uint32_t bottom_field_pic_order_in_frame_present_flag : 1; 596 uint32_t entropy_coding_mode_flag : 1; 597 uint32_t pic_scaling_matrix_present_flag : 1; 598 }; 599 600 struct H264PictureParameterSet 601 { 602 using NativeType = StdVideoH264PictureParameterSet; 603 operator StdVideoH264PictureParameterSet const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PictureParameterSet604 operator StdVideoH264PictureParameterSet const &() const VULKAN_HPP_NOEXCEPT 605 { 606 return *reinterpret_cast<const StdVideoH264PictureParameterSet *>( this ); 607 } 608 operator StdVideoH264PictureParameterSet&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PictureParameterSet609 operator StdVideoH264PictureParameterSet &() VULKAN_HPP_NOEXCEPT 610 { 611 return *reinterpret_cast<StdVideoH264PictureParameterSet *>( this ); 612 } 613 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PictureParameterSet614 bool operator==( H264PictureParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT 615 { 616 return ( flags == rhs.flags ) && ( seq_parameter_set_id == rhs.seq_parameter_set_id ) && ( pic_parameter_set_id == rhs.pic_parameter_set_id ) && 617 ( num_ref_idx_l0_default_active_minus1 == rhs.num_ref_idx_l0_default_active_minus1 ) && 618 ( num_ref_idx_l1_default_active_minus1 == rhs.num_ref_idx_l1_default_active_minus1 ) && ( weighted_bipred_idc == rhs.weighted_bipred_idc ) && 619 ( pic_init_qp_minus26 == rhs.pic_init_qp_minus26 ) && ( pic_init_qs_minus26 == rhs.pic_init_qs_minus26 ) && 620 ( chroma_qp_index_offset == rhs.chroma_qp_index_offset ) && ( second_chroma_qp_index_offset == rhs.second_chroma_qp_index_offset ) && 621 ( pScalingLists == rhs.pScalingLists ); 622 } 623 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PictureParameterSet624 bool operator!=( H264PictureParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT 625 { 626 return !operator==( rhs ); 627 } 628 629 public: 630 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PpsFlags flags = {}; 631 uint8_t seq_parameter_set_id = {}; 632 uint8_t pic_parameter_set_id = {}; 633 uint8_t num_ref_idx_l0_default_active_minus1 = {}; 634 uint8_t num_ref_idx_l1_default_active_minus1 = {}; 635 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264WeightedBipredIdc weighted_bipred_idc = 636 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264WeightedBipredIdc::eDefault; 637 int8_t pic_init_qp_minus26 = {}; 638 int8_t pic_init_qs_minus26 = {}; 639 int8_t chroma_qp_index_offset = {}; 640 int8_t second_chroma_qp_index_offset = {}; 641 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingLists * pScalingLists = {}; 642 }; 643 644 //=== vulkan_video_codec_h264std_decode === 645 646 struct DecodeH264PictureInfoFlags 647 { 648 using NativeType = StdVideoDecodeH264PictureInfoFlags; 649 operator StdVideoDecodeH264PictureInfoFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264PictureInfoFlags650 operator StdVideoDecodeH264PictureInfoFlags const &() const VULKAN_HPP_NOEXCEPT 651 { 652 return *reinterpret_cast<const StdVideoDecodeH264PictureInfoFlags *>( this ); 653 } 654 operator StdVideoDecodeH264PictureInfoFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264PictureInfoFlags655 operator StdVideoDecodeH264PictureInfoFlags &() VULKAN_HPP_NOEXCEPT 656 { 657 return *reinterpret_cast<StdVideoDecodeH264PictureInfoFlags *>( this ); 658 } 659 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264PictureInfoFlags660 bool operator==( DecodeH264PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 661 { 662 return ( field_pic_flag == rhs.field_pic_flag ) && ( is_intra == rhs.is_intra ) && ( IdrPicFlag == rhs.IdrPicFlag ) && 663 ( bottom_field_flag == rhs.bottom_field_flag ) && ( is_reference == rhs.is_reference ) && 664 ( complementary_field_pair == rhs.complementary_field_pair ); 665 } 666 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264PictureInfoFlags667 bool operator!=( DecodeH264PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 668 { 669 return !operator==( rhs ); 670 } 671 672 public: 673 uint32_t field_pic_flag : 1; 674 uint32_t is_intra : 1; 675 uint32_t IdrPicFlag : 1; 676 uint32_t bottom_field_flag : 1; 677 uint32_t is_reference : 1; 678 uint32_t complementary_field_pair : 1; 679 }; 680 681 struct DecodeH264PictureInfo 682 { 683 using NativeType = StdVideoDecodeH264PictureInfo; 684 operator StdVideoDecodeH264PictureInfo const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264PictureInfo685 operator StdVideoDecodeH264PictureInfo const &() const VULKAN_HPP_NOEXCEPT 686 { 687 return *reinterpret_cast<const StdVideoDecodeH264PictureInfo *>( this ); 688 } 689 operator StdVideoDecodeH264PictureInfo&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264PictureInfo690 operator StdVideoDecodeH264PictureInfo &() VULKAN_HPP_NOEXCEPT 691 { 692 return *reinterpret_cast<StdVideoDecodeH264PictureInfo *>( this ); 693 } 694 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264PictureInfo695 bool operator==( DecodeH264PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 696 { 697 return ( flags == rhs.flags ) && ( seq_parameter_set_id == rhs.seq_parameter_set_id ) && ( pic_parameter_set_id == rhs.pic_parameter_set_id ) && 698 ( reserved1 == rhs.reserved1 ) && ( reserved2 == rhs.reserved2 ) && ( frame_num == rhs.frame_num ) && ( idr_pic_id == rhs.idr_pic_id ) && 699 ( PicOrderCnt == rhs.PicOrderCnt ); 700 } 701 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264PictureInfo702 bool operator!=( DecodeH264PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 703 { 704 return !operator==( rhs ); 705 } 706 707 public: 708 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264PictureInfoFlags flags = {}; 709 uint8_t seq_parameter_set_id = {}; 710 uint8_t pic_parameter_set_id = {}; 711 uint8_t reserved1 = {}; 712 uint8_t reserved2 = {}; 713 uint16_t frame_num = {}; 714 uint16_t idr_pic_id = {}; 715 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int32_t, STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE> PicOrderCnt = {}; 716 }; 717 718 struct DecodeH264ReferenceInfoFlags 719 { 720 using NativeType = StdVideoDecodeH264ReferenceInfoFlags; 721 operator StdVideoDecodeH264ReferenceInfoFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264ReferenceInfoFlags722 operator StdVideoDecodeH264ReferenceInfoFlags const &() const VULKAN_HPP_NOEXCEPT 723 { 724 return *reinterpret_cast<const StdVideoDecodeH264ReferenceInfoFlags *>( this ); 725 } 726 operator StdVideoDecodeH264ReferenceInfoFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264ReferenceInfoFlags727 operator StdVideoDecodeH264ReferenceInfoFlags &() VULKAN_HPP_NOEXCEPT 728 { 729 return *reinterpret_cast<StdVideoDecodeH264ReferenceInfoFlags *>( this ); 730 } 731 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264ReferenceInfoFlags732 bool operator==( DecodeH264ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 733 { 734 return ( top_field_flag == rhs.top_field_flag ) && ( bottom_field_flag == rhs.bottom_field_flag ) && 735 ( used_for_long_term_reference == rhs.used_for_long_term_reference ) && ( is_non_existing == rhs.is_non_existing ); 736 } 737 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264ReferenceInfoFlags738 bool operator!=( DecodeH264ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 739 { 740 return !operator==( rhs ); 741 } 742 743 public: 744 uint32_t top_field_flag : 1; 745 uint32_t bottom_field_flag : 1; 746 uint32_t used_for_long_term_reference : 1; 747 uint32_t is_non_existing : 1; 748 }; 749 750 struct DecodeH264ReferenceInfo 751 { 752 using NativeType = StdVideoDecodeH264ReferenceInfo; 753 operator StdVideoDecodeH264ReferenceInfo const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264ReferenceInfo754 operator StdVideoDecodeH264ReferenceInfo const &() const VULKAN_HPP_NOEXCEPT 755 { 756 return *reinterpret_cast<const StdVideoDecodeH264ReferenceInfo *>( this ); 757 } 758 operator StdVideoDecodeH264ReferenceInfo&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264ReferenceInfo759 operator StdVideoDecodeH264ReferenceInfo &() VULKAN_HPP_NOEXCEPT 760 { 761 return *reinterpret_cast<StdVideoDecodeH264ReferenceInfo *>( this ); 762 } 763 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264ReferenceInfo764 bool operator==( DecodeH264ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 765 { 766 return ( flags == rhs.flags ) && ( FrameNum == rhs.FrameNum ) && ( reserved == rhs.reserved ) && ( PicOrderCnt == rhs.PicOrderCnt ); 767 } 768 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264ReferenceInfo769 bool operator!=( DecodeH264ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 770 { 771 return !operator==( rhs ); 772 } 773 774 public: 775 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264ReferenceInfoFlags flags = {}; 776 uint16_t FrameNum = {}; 777 uint16_t reserved = {}; 778 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int32_t, STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE> PicOrderCnt = {}; 779 }; 780 781 //=== vulkan_video_codec_h264std_encode === 782 783 struct EncodeH264WeightTableFlags 784 { 785 using NativeType = StdVideoEncodeH264WeightTableFlags; 786 operator StdVideoEncodeH264WeightTableFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTableFlags787 operator StdVideoEncodeH264WeightTableFlags const &() const VULKAN_HPP_NOEXCEPT 788 { 789 return *reinterpret_cast<const StdVideoEncodeH264WeightTableFlags *>( this ); 790 } 791 operator StdVideoEncodeH264WeightTableFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTableFlags792 operator StdVideoEncodeH264WeightTableFlags &() VULKAN_HPP_NOEXCEPT 793 { 794 return *reinterpret_cast<StdVideoEncodeH264WeightTableFlags *>( this ); 795 } 796 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTableFlags797 bool operator==( EncodeH264WeightTableFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 798 { 799 return ( luma_weight_l0_flag == rhs.luma_weight_l0_flag ) && ( chroma_weight_l0_flag == rhs.chroma_weight_l0_flag ) && 800 ( luma_weight_l1_flag == rhs.luma_weight_l1_flag ) && ( chroma_weight_l1_flag == rhs.chroma_weight_l1_flag ); 801 } 802 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTableFlags803 bool operator!=( EncodeH264WeightTableFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 804 { 805 return !operator==( rhs ); 806 } 807 808 public: 809 uint32_t luma_weight_l0_flag = {}; 810 uint32_t chroma_weight_l0_flag = {}; 811 uint32_t luma_weight_l1_flag = {}; 812 uint32_t chroma_weight_l1_flag = {}; 813 }; 814 815 struct EncodeH264WeightTable 816 { 817 using NativeType = StdVideoEncodeH264WeightTable; 818 operator StdVideoEncodeH264WeightTable const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTable819 operator StdVideoEncodeH264WeightTable const &() const VULKAN_HPP_NOEXCEPT 820 { 821 return *reinterpret_cast<const StdVideoEncodeH264WeightTable *>( this ); 822 } 823 operator StdVideoEncodeH264WeightTable&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTable824 operator StdVideoEncodeH264WeightTable &() VULKAN_HPP_NOEXCEPT 825 { 826 return *reinterpret_cast<StdVideoEncodeH264WeightTable *>( this ); 827 } 828 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTable829 bool operator==( EncodeH264WeightTable const & rhs ) const VULKAN_HPP_NOEXCEPT 830 { 831 return ( flags == rhs.flags ) && ( luma_log2_weight_denom == rhs.luma_log2_weight_denom ) && 832 ( chroma_log2_weight_denom == rhs.chroma_log2_weight_denom ) && ( luma_weight_l0 == rhs.luma_weight_l0 ) && 833 ( luma_offset_l0 == rhs.luma_offset_l0 ) && ( chroma_weight_l0 == rhs.chroma_weight_l0 ) && ( chroma_offset_l0 == rhs.chroma_offset_l0 ) && 834 ( luma_weight_l1 == rhs.luma_weight_l1 ) && ( luma_offset_l1 == rhs.luma_offset_l1 ) && ( chroma_weight_l1 == rhs.chroma_weight_l1 ) && 835 ( chroma_offset_l1 == rhs.chroma_offset_l1 ); 836 } 837 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTable838 bool operator!=( EncodeH264WeightTable const & rhs ) const VULKAN_HPP_NOEXCEPT 839 { 840 return !operator==( rhs ); 841 } 842 843 public: 844 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTableFlags flags = {}; 845 uint8_t luma_log2_weight_denom = {}; 846 uint8_t chroma_log2_weight_denom = {}; 847 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF> luma_weight_l0 = {}; 848 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF> luma_offset_l0 = {}; 849 VULKAN_HPP_NAMESPACE::ArrayWrapper2D<int8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF, STD_VIDEO_H264_MAX_CHROMA_PLANES> chroma_weight_l0 = {}; 850 VULKAN_HPP_NAMESPACE::ArrayWrapper2D<int8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF, STD_VIDEO_H264_MAX_CHROMA_PLANES> chroma_offset_l0 = {}; 851 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF> luma_weight_l1 = {}; 852 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF> luma_offset_l1 = {}; 853 VULKAN_HPP_NAMESPACE::ArrayWrapper2D<int8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF, STD_VIDEO_H264_MAX_CHROMA_PLANES> chroma_weight_l1 = {}; 854 VULKAN_HPP_NAMESPACE::ArrayWrapper2D<int8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF, STD_VIDEO_H264_MAX_CHROMA_PLANES> chroma_offset_l1 = {}; 855 }; 856 857 struct EncodeH264SliceHeaderFlags 858 { 859 using NativeType = StdVideoEncodeH264SliceHeaderFlags; 860 operator StdVideoEncodeH264SliceHeaderFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264SliceHeaderFlags861 operator StdVideoEncodeH264SliceHeaderFlags const &() const VULKAN_HPP_NOEXCEPT 862 { 863 return *reinterpret_cast<const StdVideoEncodeH264SliceHeaderFlags *>( this ); 864 } 865 operator StdVideoEncodeH264SliceHeaderFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264SliceHeaderFlags866 operator StdVideoEncodeH264SliceHeaderFlags &() VULKAN_HPP_NOEXCEPT 867 { 868 return *reinterpret_cast<StdVideoEncodeH264SliceHeaderFlags *>( this ); 869 } 870 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264SliceHeaderFlags871 bool operator==( EncodeH264SliceHeaderFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 872 { 873 return ( direct_spatial_mv_pred_flag == rhs.direct_spatial_mv_pred_flag ) && 874 ( num_ref_idx_active_override_flag == rhs.num_ref_idx_active_override_flag ) && ( reserved == rhs.reserved ); 875 } 876 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264SliceHeaderFlags877 bool operator!=( EncodeH264SliceHeaderFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 878 { 879 return !operator==( rhs ); 880 } 881 882 public: 883 uint32_t direct_spatial_mv_pred_flag : 1; 884 uint32_t num_ref_idx_active_override_flag : 1; 885 uint32_t reserved : 30; 886 }; 887 888 struct EncodeH264PictureInfoFlags 889 { 890 using NativeType = StdVideoEncodeH264PictureInfoFlags; 891 operator StdVideoEncodeH264PictureInfoFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264PictureInfoFlags892 operator StdVideoEncodeH264PictureInfoFlags const &() const VULKAN_HPP_NOEXCEPT 893 { 894 return *reinterpret_cast<const StdVideoEncodeH264PictureInfoFlags *>( this ); 895 } 896 operator StdVideoEncodeH264PictureInfoFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264PictureInfoFlags897 operator StdVideoEncodeH264PictureInfoFlags &() VULKAN_HPP_NOEXCEPT 898 { 899 return *reinterpret_cast<StdVideoEncodeH264PictureInfoFlags *>( this ); 900 } 901 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264PictureInfoFlags902 bool operator==( EncodeH264PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 903 { 904 return ( IdrPicFlag == rhs.IdrPicFlag ) && ( is_reference == rhs.is_reference ) && 905 ( no_output_of_prior_pics_flag == rhs.no_output_of_prior_pics_flag ) && ( long_term_reference_flag == rhs.long_term_reference_flag ) && 906 ( adaptive_ref_pic_marking_mode_flag == rhs.adaptive_ref_pic_marking_mode_flag ) && ( reserved == rhs.reserved ); 907 } 908 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264PictureInfoFlags909 bool operator!=( EncodeH264PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 910 { 911 return !operator==( rhs ); 912 } 913 914 public: 915 uint32_t IdrPicFlag : 1; 916 uint32_t is_reference : 1; 917 uint32_t no_output_of_prior_pics_flag : 1; 918 uint32_t long_term_reference_flag : 1; 919 uint32_t adaptive_ref_pic_marking_mode_flag : 1; 920 uint32_t reserved : 27; 921 }; 922 923 struct EncodeH264ReferenceInfoFlags 924 { 925 using NativeType = StdVideoEncodeH264ReferenceInfoFlags; 926 operator StdVideoEncodeH264ReferenceInfoFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceInfoFlags927 operator StdVideoEncodeH264ReferenceInfoFlags const &() const VULKAN_HPP_NOEXCEPT 928 { 929 return *reinterpret_cast<const StdVideoEncodeH264ReferenceInfoFlags *>( this ); 930 } 931 operator StdVideoEncodeH264ReferenceInfoFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceInfoFlags932 operator StdVideoEncodeH264ReferenceInfoFlags &() VULKAN_HPP_NOEXCEPT 933 { 934 return *reinterpret_cast<StdVideoEncodeH264ReferenceInfoFlags *>( this ); 935 } 936 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceInfoFlags937 bool operator==( EncodeH264ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 938 { 939 return ( used_for_long_term_reference == rhs.used_for_long_term_reference ) && ( reserved == rhs.reserved ); 940 } 941 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceInfoFlags942 bool operator!=( EncodeH264ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 943 { 944 return !operator==( rhs ); 945 } 946 947 public: 948 uint32_t used_for_long_term_reference : 1; 949 uint32_t reserved : 31; 950 }; 951 952 struct EncodeH264ReferenceListsInfoFlags 953 { 954 using NativeType = StdVideoEncodeH264ReferenceListsInfoFlags; 955 operator StdVideoEncodeH264ReferenceListsInfoFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfoFlags956 operator StdVideoEncodeH264ReferenceListsInfoFlags const &() const VULKAN_HPP_NOEXCEPT 957 { 958 return *reinterpret_cast<const StdVideoEncodeH264ReferenceListsInfoFlags *>( this ); 959 } 960 operator StdVideoEncodeH264ReferenceListsInfoFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfoFlags961 operator StdVideoEncodeH264ReferenceListsInfoFlags &() VULKAN_HPP_NOEXCEPT 962 { 963 return *reinterpret_cast<StdVideoEncodeH264ReferenceListsInfoFlags *>( this ); 964 } 965 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfoFlags966 bool operator==( EncodeH264ReferenceListsInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 967 { 968 return ( ref_pic_list_modification_flag_l0 == rhs.ref_pic_list_modification_flag_l0 ) && 969 ( ref_pic_list_modification_flag_l1 == rhs.ref_pic_list_modification_flag_l1 ) && ( reserved == rhs.reserved ); 970 } 971 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfoFlags972 bool operator!=( EncodeH264ReferenceListsInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 973 { 974 return !operator==( rhs ); 975 } 976 977 public: 978 uint32_t ref_pic_list_modification_flag_l0 : 1; 979 uint32_t ref_pic_list_modification_flag_l1 : 1; 980 uint32_t reserved : 30; 981 }; 982 983 struct EncodeH264RefListModEntry 984 { 985 using NativeType = StdVideoEncodeH264RefListModEntry; 986 operator StdVideoEncodeH264RefListModEntry const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefListModEntry987 operator StdVideoEncodeH264RefListModEntry const &() const VULKAN_HPP_NOEXCEPT 988 { 989 return *reinterpret_cast<const StdVideoEncodeH264RefListModEntry *>( this ); 990 } 991 operator StdVideoEncodeH264RefListModEntry&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefListModEntry992 operator StdVideoEncodeH264RefListModEntry &() VULKAN_HPP_NOEXCEPT 993 { 994 return *reinterpret_cast<StdVideoEncodeH264RefListModEntry *>( this ); 995 } 996 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefListModEntry997 bool operator==( EncodeH264RefListModEntry const & rhs ) const VULKAN_HPP_NOEXCEPT 998 { 999 return ( modification_of_pic_nums_idc == rhs.modification_of_pic_nums_idc ) && ( abs_diff_pic_num_minus1 == rhs.abs_diff_pic_num_minus1 ) && 1000 ( long_term_pic_num == rhs.long_term_pic_num ); 1001 } 1002 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefListModEntry1003 bool operator!=( EncodeH264RefListModEntry const & rhs ) const VULKAN_HPP_NOEXCEPT 1004 { 1005 return !operator==( rhs ); 1006 } 1007 1008 public: 1009 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ModificationOfPicNumsIdc modification_of_pic_nums_idc = 1010 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ModificationOfPicNumsIdc::eShortTermSubtract; 1011 uint16_t abs_diff_pic_num_minus1 = {}; 1012 uint16_t long_term_pic_num = {}; 1013 }; 1014 1015 struct EncodeH264RefPicMarkingEntry 1016 { 1017 using NativeType = StdVideoEncodeH264RefPicMarkingEntry; 1018 operator StdVideoEncodeH264RefPicMarkingEntry const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefPicMarkingEntry1019 operator StdVideoEncodeH264RefPicMarkingEntry const &() const VULKAN_HPP_NOEXCEPT 1020 { 1021 return *reinterpret_cast<const StdVideoEncodeH264RefPicMarkingEntry *>( this ); 1022 } 1023 operator StdVideoEncodeH264RefPicMarkingEntry&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefPicMarkingEntry1024 operator StdVideoEncodeH264RefPicMarkingEntry &() VULKAN_HPP_NOEXCEPT 1025 { 1026 return *reinterpret_cast<StdVideoEncodeH264RefPicMarkingEntry *>( this ); 1027 } 1028 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefPicMarkingEntry1029 bool operator==( EncodeH264RefPicMarkingEntry const & rhs ) const VULKAN_HPP_NOEXCEPT 1030 { 1031 return ( operation == rhs.operation ) && ( difference_of_pic_nums_minus1 == rhs.difference_of_pic_nums_minus1 ) && 1032 ( long_term_pic_num == rhs.long_term_pic_num ) && ( long_term_frame_idx == rhs.long_term_frame_idx ) && 1033 ( max_long_term_frame_idx_plus1 == rhs.max_long_term_frame_idx_plus1 ); 1034 } 1035 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefPicMarkingEntry1036 bool operator!=( EncodeH264RefPicMarkingEntry const & rhs ) const VULKAN_HPP_NOEXCEPT 1037 { 1038 return !operator==( rhs ); 1039 } 1040 1041 public: 1042 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264MemMgmtControlOp operation = 1043 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264MemMgmtControlOp::eEnd; 1044 uint16_t difference_of_pic_nums_minus1 = {}; 1045 uint16_t long_term_pic_num = {}; 1046 uint16_t long_term_frame_idx = {}; 1047 uint16_t max_long_term_frame_idx_plus1 = {}; 1048 }; 1049 1050 struct EncodeH264ReferenceListsInfo 1051 { 1052 using NativeType = StdVideoEncodeH264ReferenceListsInfo; 1053 operator StdVideoEncodeH264ReferenceListsInfo const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfo1054 operator StdVideoEncodeH264ReferenceListsInfo const &() const VULKAN_HPP_NOEXCEPT 1055 { 1056 return *reinterpret_cast<const StdVideoEncodeH264ReferenceListsInfo *>( this ); 1057 } 1058 operator StdVideoEncodeH264ReferenceListsInfo&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfo1059 operator StdVideoEncodeH264ReferenceListsInfo &() VULKAN_HPP_NOEXCEPT 1060 { 1061 return *reinterpret_cast<StdVideoEncodeH264ReferenceListsInfo *>( this ); 1062 } 1063 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfo1064 bool operator==( EncodeH264ReferenceListsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 1065 { 1066 return ( flags == rhs.flags ) && ( num_ref_idx_l0_active_minus1 == rhs.num_ref_idx_l0_active_minus1 ) && 1067 ( num_ref_idx_l1_active_minus1 == rhs.num_ref_idx_l1_active_minus1 ) && ( RefPicList0 == rhs.RefPicList0 ) && 1068 ( RefPicList1 == rhs.RefPicList1 ) && ( refList0ModOpCount == rhs.refList0ModOpCount ) && ( refList1ModOpCount == rhs.refList1ModOpCount ) && 1069 ( refPicMarkingOpCount == rhs.refPicMarkingOpCount ) && ( reserved1 == rhs.reserved1 ) && 1070 ( pRefList0ModOperations == rhs.pRefList0ModOperations ) && ( pRefList1ModOperations == rhs.pRefList1ModOperations ) && 1071 ( pRefPicMarkingOperations == rhs.pRefPicMarkingOperations ); 1072 } 1073 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfo1074 bool operator!=( EncodeH264ReferenceListsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 1075 { 1076 return !operator==( rhs ); 1077 } 1078 1079 public: 1080 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfoFlags flags = {}; 1081 uint8_t num_ref_idx_l0_active_minus1 = {}; 1082 uint8_t num_ref_idx_l1_active_minus1 = {}; 1083 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF> RefPicList0 = {}; 1084 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF> RefPicList1 = {}; 1085 uint8_t refList0ModOpCount = {}; 1086 uint8_t refList1ModOpCount = {}; 1087 uint8_t refPicMarkingOpCount = {}; 1088 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, 7> reserved1 = {}; 1089 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefListModEntry * pRefList0ModOperations = {}; 1090 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefListModEntry * pRefList1ModOperations = {}; 1091 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefPicMarkingEntry * pRefPicMarkingOperations = {}; 1092 }; 1093 1094 struct EncodeH264PictureInfo 1095 { 1096 using NativeType = StdVideoEncodeH264PictureInfo; 1097 operator StdVideoEncodeH264PictureInfo const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264PictureInfo1098 operator StdVideoEncodeH264PictureInfo const &() const VULKAN_HPP_NOEXCEPT 1099 { 1100 return *reinterpret_cast<const StdVideoEncodeH264PictureInfo *>( this ); 1101 } 1102 operator StdVideoEncodeH264PictureInfo&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264PictureInfo1103 operator StdVideoEncodeH264PictureInfo &() VULKAN_HPP_NOEXCEPT 1104 { 1105 return *reinterpret_cast<StdVideoEncodeH264PictureInfo *>( this ); 1106 } 1107 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264PictureInfo1108 bool operator==( EncodeH264PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 1109 { 1110 return ( flags == rhs.flags ) && ( seq_parameter_set_id == rhs.seq_parameter_set_id ) && ( pic_parameter_set_id == rhs.pic_parameter_set_id ) && 1111 ( idr_pic_id == rhs.idr_pic_id ) && ( primary_pic_type == rhs.primary_pic_type ) && ( frame_num == rhs.frame_num ) && 1112 ( PicOrderCnt == rhs.PicOrderCnt ) && ( temporal_id == rhs.temporal_id ) && ( reserved1 == rhs.reserved1 ) && ( pRefLists == rhs.pRefLists ); 1113 } 1114 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264PictureInfo1115 bool operator!=( EncodeH264PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 1116 { 1117 return !operator==( rhs ); 1118 } 1119 1120 public: 1121 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264PictureInfoFlags flags = {}; 1122 uint8_t seq_parameter_set_id = {}; 1123 uint8_t pic_parameter_set_id = {}; 1124 uint16_t idr_pic_id = {}; 1125 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PictureType primary_pic_type = 1126 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PictureType::eP; 1127 uint32_t frame_num = {}; 1128 int32_t PicOrderCnt = {}; 1129 uint8_t temporal_id = {}; 1130 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, 3> reserved1 = {}; 1131 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfo * pRefLists = {}; 1132 }; 1133 1134 struct EncodeH264ReferenceInfo 1135 { 1136 using NativeType = StdVideoEncodeH264ReferenceInfo; 1137 operator StdVideoEncodeH264ReferenceInfo const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceInfo1138 operator StdVideoEncodeH264ReferenceInfo const &() const VULKAN_HPP_NOEXCEPT 1139 { 1140 return *reinterpret_cast<const StdVideoEncodeH264ReferenceInfo *>( this ); 1141 } 1142 operator StdVideoEncodeH264ReferenceInfo&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceInfo1143 operator StdVideoEncodeH264ReferenceInfo &() VULKAN_HPP_NOEXCEPT 1144 { 1145 return *reinterpret_cast<StdVideoEncodeH264ReferenceInfo *>( this ); 1146 } 1147 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceInfo1148 bool operator==( EncodeH264ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 1149 { 1150 return ( flags == rhs.flags ) && ( primary_pic_type == rhs.primary_pic_type ) && ( FrameNum == rhs.FrameNum ) && ( PicOrderCnt == rhs.PicOrderCnt ) && 1151 ( long_term_pic_num == rhs.long_term_pic_num ) && ( long_term_frame_idx == rhs.long_term_frame_idx ) && ( temporal_id == rhs.temporal_id ); 1152 } 1153 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceInfo1154 bool operator!=( EncodeH264ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 1155 { 1156 return !operator==( rhs ); 1157 } 1158 1159 public: 1160 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceInfoFlags flags = {}; 1161 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PictureType primary_pic_type = 1162 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PictureType::eP; 1163 uint32_t FrameNum = {}; 1164 int32_t PicOrderCnt = {}; 1165 uint16_t long_term_pic_num = {}; 1166 uint16_t long_term_frame_idx = {}; 1167 uint8_t temporal_id = {}; 1168 }; 1169 1170 struct EncodeH264SliceHeader 1171 { 1172 using NativeType = StdVideoEncodeH264SliceHeader; 1173 operator StdVideoEncodeH264SliceHeader const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264SliceHeader1174 operator StdVideoEncodeH264SliceHeader const &() const VULKAN_HPP_NOEXCEPT 1175 { 1176 return *reinterpret_cast<const StdVideoEncodeH264SliceHeader *>( this ); 1177 } 1178 operator StdVideoEncodeH264SliceHeader&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264SliceHeader1179 operator StdVideoEncodeH264SliceHeader &() VULKAN_HPP_NOEXCEPT 1180 { 1181 return *reinterpret_cast<StdVideoEncodeH264SliceHeader *>( this ); 1182 } 1183 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264SliceHeader1184 bool operator==( EncodeH264SliceHeader const & rhs ) const VULKAN_HPP_NOEXCEPT 1185 { 1186 return ( flags == rhs.flags ) && ( first_mb_in_slice == rhs.first_mb_in_slice ) && ( slice_type == rhs.slice_type ) && 1187 ( slice_alpha_c0_offset_div2 == rhs.slice_alpha_c0_offset_div2 ) && ( slice_beta_offset_div2 == rhs.slice_beta_offset_div2 ) && 1188 ( reserved1 == rhs.reserved1 ) && ( cabac_init_idc == rhs.cabac_init_idc ) && 1189 ( disable_deblocking_filter_idc == rhs.disable_deblocking_filter_idc ) && ( pWeightTable == rhs.pWeightTable ); 1190 } 1191 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264SliceHeader1192 bool operator!=( EncodeH264SliceHeader const & rhs ) const VULKAN_HPP_NOEXCEPT 1193 { 1194 return !operator==( rhs ); 1195 } 1196 1197 public: 1198 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264SliceHeaderFlags flags = {}; 1199 uint32_t first_mb_in_slice = {}; 1200 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SliceType slice_type = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SliceType::eP; 1201 int8_t slice_alpha_c0_offset_div2 = {}; 1202 int8_t slice_beta_offset_div2 = {}; 1203 uint16_t reserved1 = {}; 1204 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264CabacInitIdc cabac_init_idc = 1205 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264CabacInitIdc::e0; 1206 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264DisableDeblockingFilterIdc disable_deblocking_filter_idc = 1207 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264DisableDeblockingFilterIdc::eDisabled; 1208 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTable * pWeightTable = {}; 1209 }; 1210 1211 //=== vulkan_video_codec_h265std === 1212 1213 struct H265DecPicBufMgr 1214 { 1215 using NativeType = StdVideoH265DecPicBufMgr; 1216 operator StdVideoH265DecPicBufMgr const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265DecPicBufMgr1217 operator StdVideoH265DecPicBufMgr const &() const VULKAN_HPP_NOEXCEPT 1218 { 1219 return *reinterpret_cast<const StdVideoH265DecPicBufMgr *>( this ); 1220 } 1221 operator StdVideoH265DecPicBufMgr&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265DecPicBufMgr1222 operator StdVideoH265DecPicBufMgr &() VULKAN_HPP_NOEXCEPT 1223 { 1224 return *reinterpret_cast<StdVideoH265DecPicBufMgr *>( this ); 1225 } 1226 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265DecPicBufMgr1227 bool operator==( H265DecPicBufMgr const & rhs ) const VULKAN_HPP_NOEXCEPT 1228 { 1229 return ( max_latency_increase_plus1 == rhs.max_latency_increase_plus1 ) && ( max_dec_pic_buffering_minus1 == rhs.max_dec_pic_buffering_minus1 ) && 1230 ( max_num_reorder_pics == rhs.max_num_reorder_pics ); 1231 } 1232 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265DecPicBufMgr1233 bool operator!=( H265DecPicBufMgr const & rhs ) const VULKAN_HPP_NOEXCEPT 1234 { 1235 return !operator==( rhs ); 1236 } 1237 1238 public: 1239 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, STD_VIDEO_H265_SUBLAYERS_LIST_SIZE> max_latency_increase_plus1 = {}; 1240 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H265_SUBLAYERS_LIST_SIZE> max_dec_pic_buffering_minus1 = {}; 1241 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H265_SUBLAYERS_LIST_SIZE> max_num_reorder_pics = {}; 1242 }; 1243 1244 struct H265SubLayerHrdParameters 1245 { 1246 using NativeType = StdVideoH265SubLayerHrdParameters; 1247 operator StdVideoH265SubLayerHrdParameters const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SubLayerHrdParameters1248 operator StdVideoH265SubLayerHrdParameters const &() const VULKAN_HPP_NOEXCEPT 1249 { 1250 return *reinterpret_cast<const StdVideoH265SubLayerHrdParameters *>( this ); 1251 } 1252 operator StdVideoH265SubLayerHrdParameters&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SubLayerHrdParameters1253 operator StdVideoH265SubLayerHrdParameters &() VULKAN_HPP_NOEXCEPT 1254 { 1255 return *reinterpret_cast<StdVideoH265SubLayerHrdParameters *>( this ); 1256 } 1257 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SubLayerHrdParameters1258 bool operator==( H265SubLayerHrdParameters const & rhs ) const VULKAN_HPP_NOEXCEPT 1259 { 1260 return ( bit_rate_value_minus1 == rhs.bit_rate_value_minus1 ) && ( cpb_size_value_minus1 == rhs.cpb_size_value_minus1 ) && 1261 ( cpb_size_du_value_minus1 == rhs.cpb_size_du_value_minus1 ) && ( bit_rate_du_value_minus1 == rhs.bit_rate_du_value_minus1 ) && 1262 ( cbr_flag == rhs.cbr_flag ); 1263 } 1264 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SubLayerHrdParameters1265 bool operator!=( H265SubLayerHrdParameters const & rhs ) const VULKAN_HPP_NOEXCEPT 1266 { 1267 return !operator==( rhs ); 1268 } 1269 1270 public: 1271 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, STD_VIDEO_H265_CPB_CNT_LIST_SIZE> bit_rate_value_minus1 = {}; 1272 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, STD_VIDEO_H265_CPB_CNT_LIST_SIZE> cpb_size_value_minus1 = {}; 1273 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, STD_VIDEO_H265_CPB_CNT_LIST_SIZE> cpb_size_du_value_minus1 = {}; 1274 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, STD_VIDEO_H265_CPB_CNT_LIST_SIZE> bit_rate_du_value_minus1 = {}; 1275 uint32_t cbr_flag = {}; 1276 }; 1277 1278 struct H265HrdFlags 1279 { 1280 using NativeType = StdVideoH265HrdFlags; 1281 operator StdVideoH265HrdFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdFlags1282 operator StdVideoH265HrdFlags const &() const VULKAN_HPP_NOEXCEPT 1283 { 1284 return *reinterpret_cast<const StdVideoH265HrdFlags *>( this ); 1285 } 1286 operator StdVideoH265HrdFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdFlags1287 operator StdVideoH265HrdFlags &() VULKAN_HPP_NOEXCEPT 1288 { 1289 return *reinterpret_cast<StdVideoH265HrdFlags *>( this ); 1290 } 1291 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdFlags1292 bool operator==( H265HrdFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 1293 { 1294 return ( nal_hrd_parameters_present_flag == rhs.nal_hrd_parameters_present_flag ) && 1295 ( vcl_hrd_parameters_present_flag == rhs.vcl_hrd_parameters_present_flag ) && 1296 ( sub_pic_hrd_params_present_flag == rhs.sub_pic_hrd_params_present_flag ) && 1297 ( sub_pic_cpb_params_in_pic_timing_sei_flag == rhs.sub_pic_cpb_params_in_pic_timing_sei_flag ) && 1298 ( fixed_pic_rate_general_flag == rhs.fixed_pic_rate_general_flag ) && ( fixed_pic_rate_within_cvs_flag == rhs.fixed_pic_rate_within_cvs_flag ) && 1299 ( low_delay_hrd_flag == rhs.low_delay_hrd_flag ); 1300 } 1301 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdFlags1302 bool operator!=( H265HrdFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 1303 { 1304 return !operator==( rhs ); 1305 } 1306 1307 public: 1308 uint32_t nal_hrd_parameters_present_flag : 1; 1309 uint32_t vcl_hrd_parameters_present_flag : 1; 1310 uint32_t sub_pic_hrd_params_present_flag : 1; 1311 uint32_t sub_pic_cpb_params_in_pic_timing_sei_flag : 1; 1312 uint32_t fixed_pic_rate_general_flag : 8; 1313 uint32_t fixed_pic_rate_within_cvs_flag : 8; 1314 uint32_t low_delay_hrd_flag : 8; 1315 }; 1316 1317 struct H265HrdParameters 1318 { 1319 using NativeType = StdVideoH265HrdParameters; 1320 operator StdVideoH265HrdParameters const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdParameters1321 operator StdVideoH265HrdParameters const &() const VULKAN_HPP_NOEXCEPT 1322 { 1323 return *reinterpret_cast<const StdVideoH265HrdParameters *>( this ); 1324 } 1325 operator StdVideoH265HrdParameters&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdParameters1326 operator StdVideoH265HrdParameters &() VULKAN_HPP_NOEXCEPT 1327 { 1328 return *reinterpret_cast<StdVideoH265HrdParameters *>( this ); 1329 } 1330 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdParameters1331 bool operator==( H265HrdParameters const & rhs ) const VULKAN_HPP_NOEXCEPT 1332 { 1333 return ( flags == rhs.flags ) && ( tick_divisor_minus2 == rhs.tick_divisor_minus2 ) && 1334 ( du_cpb_removal_delay_increment_length_minus1 == rhs.du_cpb_removal_delay_increment_length_minus1 ) && 1335 ( dpb_output_delay_du_length_minus1 == rhs.dpb_output_delay_du_length_minus1 ) && ( bit_rate_scale == rhs.bit_rate_scale ) && 1336 ( cpb_size_scale == rhs.cpb_size_scale ) && ( cpb_size_du_scale == rhs.cpb_size_du_scale ) && 1337 ( initial_cpb_removal_delay_length_minus1 == rhs.initial_cpb_removal_delay_length_minus1 ) && 1338 ( au_cpb_removal_delay_length_minus1 == rhs.au_cpb_removal_delay_length_minus1 ) && 1339 ( dpb_output_delay_length_minus1 == rhs.dpb_output_delay_length_minus1 ) && ( cpb_cnt_minus1 == rhs.cpb_cnt_minus1 ) && 1340 ( elemental_duration_in_tc_minus1 == rhs.elemental_duration_in_tc_minus1 ) && ( reserved == rhs.reserved ) && 1341 ( pSubLayerHrdParametersNal == rhs.pSubLayerHrdParametersNal ) && ( pSubLayerHrdParametersVcl == rhs.pSubLayerHrdParametersVcl ); 1342 } 1343 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdParameters1344 bool operator!=( H265HrdParameters const & rhs ) const VULKAN_HPP_NOEXCEPT 1345 { 1346 return !operator==( rhs ); 1347 } 1348 1349 public: 1350 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdFlags flags = {}; 1351 uint8_t tick_divisor_minus2 = {}; 1352 uint8_t du_cpb_removal_delay_increment_length_minus1 = {}; 1353 uint8_t dpb_output_delay_du_length_minus1 = {}; 1354 uint8_t bit_rate_scale = {}; 1355 uint8_t cpb_size_scale = {}; 1356 uint8_t cpb_size_du_scale = {}; 1357 uint8_t initial_cpb_removal_delay_length_minus1 = {}; 1358 uint8_t au_cpb_removal_delay_length_minus1 = {}; 1359 uint8_t dpb_output_delay_length_minus1 = {}; 1360 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H265_SUBLAYERS_LIST_SIZE> cpb_cnt_minus1 = {}; 1361 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint16_t, STD_VIDEO_H265_SUBLAYERS_LIST_SIZE> elemental_duration_in_tc_minus1 = {}; 1362 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint16_t, 3> reserved = {}; 1363 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SubLayerHrdParameters * pSubLayerHrdParametersNal = {}; 1364 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SubLayerHrdParameters * pSubLayerHrdParametersVcl = {}; 1365 }; 1366 1367 struct H265VpsFlags 1368 { 1369 using NativeType = StdVideoH265VpsFlags; 1370 operator StdVideoH265VpsFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265VpsFlags1371 operator StdVideoH265VpsFlags const &() const VULKAN_HPP_NOEXCEPT 1372 { 1373 return *reinterpret_cast<const StdVideoH265VpsFlags *>( this ); 1374 } 1375 operator StdVideoH265VpsFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265VpsFlags1376 operator StdVideoH265VpsFlags &() VULKAN_HPP_NOEXCEPT 1377 { 1378 return *reinterpret_cast<StdVideoH265VpsFlags *>( this ); 1379 } 1380 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265VpsFlags1381 bool operator==( H265VpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 1382 { 1383 return ( vps_temporal_id_nesting_flag == rhs.vps_temporal_id_nesting_flag ) && 1384 ( vps_sub_layer_ordering_info_present_flag == rhs.vps_sub_layer_ordering_info_present_flag ) && 1385 ( vps_timing_info_present_flag == rhs.vps_timing_info_present_flag ) && 1386 ( vps_poc_proportional_to_timing_flag == rhs.vps_poc_proportional_to_timing_flag ); 1387 } 1388 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265VpsFlags1389 bool operator!=( H265VpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 1390 { 1391 return !operator==( rhs ); 1392 } 1393 1394 public: 1395 uint32_t vps_temporal_id_nesting_flag : 1; 1396 uint32_t vps_sub_layer_ordering_info_present_flag : 1; 1397 uint32_t vps_timing_info_present_flag : 1; 1398 uint32_t vps_poc_proportional_to_timing_flag : 1; 1399 }; 1400 1401 struct H265ProfileTierLevelFlags 1402 { 1403 using NativeType = StdVideoH265ProfileTierLevelFlags; 1404 operator StdVideoH265ProfileTierLevelFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevelFlags1405 operator StdVideoH265ProfileTierLevelFlags const &() const VULKAN_HPP_NOEXCEPT 1406 { 1407 return *reinterpret_cast<const StdVideoH265ProfileTierLevelFlags *>( this ); 1408 } 1409 operator StdVideoH265ProfileTierLevelFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevelFlags1410 operator StdVideoH265ProfileTierLevelFlags &() VULKAN_HPP_NOEXCEPT 1411 { 1412 return *reinterpret_cast<StdVideoH265ProfileTierLevelFlags *>( this ); 1413 } 1414 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevelFlags1415 bool operator==( H265ProfileTierLevelFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 1416 { 1417 return ( general_tier_flag == rhs.general_tier_flag ) && ( general_progressive_source_flag == rhs.general_progressive_source_flag ) && 1418 ( general_interlaced_source_flag == rhs.general_interlaced_source_flag ) && 1419 ( general_non_packed_constraint_flag == rhs.general_non_packed_constraint_flag ) && 1420 ( general_frame_only_constraint_flag == rhs.general_frame_only_constraint_flag ); 1421 } 1422 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevelFlags1423 bool operator!=( H265ProfileTierLevelFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 1424 { 1425 return !operator==( rhs ); 1426 } 1427 1428 public: 1429 uint32_t general_tier_flag : 1; 1430 uint32_t general_progressive_source_flag : 1; 1431 uint32_t general_interlaced_source_flag : 1; 1432 uint32_t general_non_packed_constraint_flag : 1; 1433 uint32_t general_frame_only_constraint_flag : 1; 1434 }; 1435 1436 struct H265ProfileTierLevel 1437 { 1438 using NativeType = StdVideoH265ProfileTierLevel; 1439 operator StdVideoH265ProfileTierLevel const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevel1440 operator StdVideoH265ProfileTierLevel const &() const VULKAN_HPP_NOEXCEPT 1441 { 1442 return *reinterpret_cast<const StdVideoH265ProfileTierLevel *>( this ); 1443 } 1444 operator StdVideoH265ProfileTierLevel&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevel1445 operator StdVideoH265ProfileTierLevel &() VULKAN_HPP_NOEXCEPT 1446 { 1447 return *reinterpret_cast<StdVideoH265ProfileTierLevel *>( this ); 1448 } 1449 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevel1450 bool operator==( H265ProfileTierLevel const & rhs ) const VULKAN_HPP_NOEXCEPT 1451 { 1452 return ( flags == rhs.flags ) && ( general_profile_idc == rhs.general_profile_idc ) && ( general_level_idc == rhs.general_level_idc ); 1453 } 1454 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevel1455 bool operator!=( H265ProfileTierLevel const & rhs ) const VULKAN_HPP_NOEXCEPT 1456 { 1457 return !operator==( rhs ); 1458 } 1459 1460 public: 1461 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevelFlags flags = {}; 1462 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileIdc general_profile_idc = 1463 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileIdc::eMain; 1464 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265LevelIdc general_level_idc = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265LevelIdc::e1_0; 1465 }; 1466 1467 struct H265VideoParameterSet 1468 { 1469 using NativeType = StdVideoH265VideoParameterSet; 1470 operator StdVideoH265VideoParameterSet const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265VideoParameterSet1471 operator StdVideoH265VideoParameterSet const &() const VULKAN_HPP_NOEXCEPT 1472 { 1473 return *reinterpret_cast<const StdVideoH265VideoParameterSet *>( this ); 1474 } 1475 operator StdVideoH265VideoParameterSet&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265VideoParameterSet1476 operator StdVideoH265VideoParameterSet &() VULKAN_HPP_NOEXCEPT 1477 { 1478 return *reinterpret_cast<StdVideoH265VideoParameterSet *>( this ); 1479 } 1480 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265VideoParameterSet1481 bool operator==( H265VideoParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT 1482 { 1483 return ( flags == rhs.flags ) && ( vps_video_parameter_set_id == rhs.vps_video_parameter_set_id ) && 1484 ( vps_max_sub_layers_minus1 == rhs.vps_max_sub_layers_minus1 ) && ( reserved1 == rhs.reserved1 ) && ( reserved2 == rhs.reserved2 ) && 1485 ( vps_num_units_in_tick == rhs.vps_num_units_in_tick ) && ( vps_time_scale == rhs.vps_time_scale ) && 1486 ( vps_num_ticks_poc_diff_one_minus1 == rhs.vps_num_ticks_poc_diff_one_minus1 ) && ( reserved3 == rhs.reserved3 ) && 1487 ( pDecPicBufMgr == rhs.pDecPicBufMgr ) && ( pHrdParameters == rhs.pHrdParameters ) && ( pProfileTierLevel == rhs.pProfileTierLevel ); 1488 } 1489 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265VideoParameterSet1490 bool operator!=( H265VideoParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT 1491 { 1492 return !operator==( rhs ); 1493 } 1494 1495 public: 1496 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265VpsFlags flags = {}; 1497 uint8_t vps_video_parameter_set_id = {}; 1498 uint8_t vps_max_sub_layers_minus1 = {}; 1499 uint8_t reserved1 = {}; 1500 uint8_t reserved2 = {}; 1501 uint32_t vps_num_units_in_tick = {}; 1502 uint32_t vps_time_scale = {}; 1503 uint32_t vps_num_ticks_poc_diff_one_minus1 = {}; 1504 uint32_t reserved3 = {}; 1505 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265DecPicBufMgr * pDecPicBufMgr = {}; 1506 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdParameters * pHrdParameters = {}; 1507 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevel * pProfileTierLevel = {}; 1508 }; 1509 1510 struct H265ScalingLists 1511 { 1512 using NativeType = StdVideoH265ScalingLists; 1513 operator StdVideoH265ScalingLists const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingLists1514 operator StdVideoH265ScalingLists const &() const VULKAN_HPP_NOEXCEPT 1515 { 1516 return *reinterpret_cast<const StdVideoH265ScalingLists *>( this ); 1517 } 1518 operator StdVideoH265ScalingLists&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingLists1519 operator StdVideoH265ScalingLists &() VULKAN_HPP_NOEXCEPT 1520 { 1521 return *reinterpret_cast<StdVideoH265ScalingLists *>( this ); 1522 } 1523 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingLists1524 bool operator==( H265ScalingLists const & rhs ) const VULKAN_HPP_NOEXCEPT 1525 { 1526 return ( ScalingList4x4 == rhs.ScalingList4x4 ) && ( ScalingList8x8 == rhs.ScalingList8x8 ) && ( ScalingList16x16 == rhs.ScalingList16x16 ) && 1527 ( ScalingList32x32 == rhs.ScalingList32x32 ) && ( ScalingListDCCoef16x16 == rhs.ScalingListDCCoef16x16 ) && 1528 ( ScalingListDCCoef32x32 == rhs.ScalingListDCCoef32x32 ); 1529 } 1530 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingLists1531 bool operator!=( H265ScalingLists const & rhs ) const VULKAN_HPP_NOEXCEPT 1532 { 1533 return !operator==( rhs ); 1534 } 1535 1536 public: 1537 VULKAN_HPP_NAMESPACE::ArrayWrapper2D<uint8_t, STD_VIDEO_H265_SCALING_LIST_4X4_NUM_LISTS, STD_VIDEO_H265_SCALING_LIST_4X4_NUM_ELEMENTS> 1538 ScalingList4x4 = {}; 1539 VULKAN_HPP_NAMESPACE::ArrayWrapper2D<uint8_t, STD_VIDEO_H265_SCALING_LIST_8X8_NUM_LISTS, STD_VIDEO_H265_SCALING_LIST_8X8_NUM_ELEMENTS> 1540 ScalingList8x8 = {}; 1541 VULKAN_HPP_NAMESPACE::ArrayWrapper2D<uint8_t, STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS, STD_VIDEO_H265_SCALING_LIST_16X16_NUM_ELEMENTS> 1542 ScalingList16x16 = {}; 1543 VULKAN_HPP_NAMESPACE::ArrayWrapper2D<uint8_t, STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS, STD_VIDEO_H265_SCALING_LIST_32X32_NUM_ELEMENTS> 1544 ScalingList32x32 = {}; 1545 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS> ScalingListDCCoef16x16 = {}; 1546 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS> ScalingListDCCoef32x32 = {}; 1547 }; 1548 1549 struct H265SpsVuiFlags 1550 { 1551 using NativeType = StdVideoH265SpsVuiFlags; 1552 operator StdVideoH265SpsVuiFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SpsVuiFlags1553 operator StdVideoH265SpsVuiFlags const &() const VULKAN_HPP_NOEXCEPT 1554 { 1555 return *reinterpret_cast<const StdVideoH265SpsVuiFlags *>( this ); 1556 } 1557 operator StdVideoH265SpsVuiFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SpsVuiFlags1558 operator StdVideoH265SpsVuiFlags &() VULKAN_HPP_NOEXCEPT 1559 { 1560 return *reinterpret_cast<StdVideoH265SpsVuiFlags *>( this ); 1561 } 1562 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SpsVuiFlags1563 bool operator==( H265SpsVuiFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 1564 { 1565 return ( aspect_ratio_info_present_flag == rhs.aspect_ratio_info_present_flag ) && ( overscan_info_present_flag == rhs.overscan_info_present_flag ) && 1566 ( overscan_appropriate_flag == rhs.overscan_appropriate_flag ) && ( video_signal_type_present_flag == rhs.video_signal_type_present_flag ) && 1567 ( video_full_range_flag == rhs.video_full_range_flag ) && ( colour_description_present_flag == rhs.colour_description_present_flag ) && 1568 ( chroma_loc_info_present_flag == rhs.chroma_loc_info_present_flag ) && 1569 ( neutral_chroma_indication_flag == rhs.neutral_chroma_indication_flag ) && ( field_seq_flag == rhs.field_seq_flag ) && 1570 ( frame_field_info_present_flag == rhs.frame_field_info_present_flag ) && ( default_display_window_flag == rhs.default_display_window_flag ) && 1571 ( vui_timing_info_present_flag == rhs.vui_timing_info_present_flag ) && 1572 ( vui_poc_proportional_to_timing_flag == rhs.vui_poc_proportional_to_timing_flag ) && 1573 ( vui_hrd_parameters_present_flag == rhs.vui_hrd_parameters_present_flag ) && ( bitstream_restriction_flag == rhs.bitstream_restriction_flag ) && 1574 ( tiles_fixed_structure_flag == rhs.tiles_fixed_structure_flag ) && 1575 ( motion_vectors_over_pic_boundaries_flag == rhs.motion_vectors_over_pic_boundaries_flag ) && 1576 ( restricted_ref_pic_lists_flag == rhs.restricted_ref_pic_lists_flag ); 1577 } 1578 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SpsVuiFlags1579 bool operator!=( H265SpsVuiFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 1580 { 1581 return !operator==( rhs ); 1582 } 1583 1584 public: 1585 uint32_t aspect_ratio_info_present_flag : 1; 1586 uint32_t overscan_info_present_flag : 1; 1587 uint32_t overscan_appropriate_flag : 1; 1588 uint32_t video_signal_type_present_flag : 1; 1589 uint32_t video_full_range_flag : 1; 1590 uint32_t colour_description_present_flag : 1; 1591 uint32_t chroma_loc_info_present_flag : 1; 1592 uint32_t neutral_chroma_indication_flag : 1; 1593 uint32_t field_seq_flag : 1; 1594 uint32_t frame_field_info_present_flag : 1; 1595 uint32_t default_display_window_flag : 1; 1596 uint32_t vui_timing_info_present_flag : 1; 1597 uint32_t vui_poc_proportional_to_timing_flag : 1; 1598 uint32_t vui_hrd_parameters_present_flag : 1; 1599 uint32_t bitstream_restriction_flag : 1; 1600 uint32_t tiles_fixed_structure_flag : 1; 1601 uint32_t motion_vectors_over_pic_boundaries_flag : 1; 1602 uint32_t restricted_ref_pic_lists_flag : 1; 1603 }; 1604 1605 struct H265SequenceParameterSetVui 1606 { 1607 using NativeType = StdVideoH265SequenceParameterSetVui; 1608 operator StdVideoH265SequenceParameterSetVui const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SequenceParameterSetVui1609 operator StdVideoH265SequenceParameterSetVui const &() const VULKAN_HPP_NOEXCEPT 1610 { 1611 return *reinterpret_cast<const StdVideoH265SequenceParameterSetVui *>( this ); 1612 } 1613 operator StdVideoH265SequenceParameterSetVui&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SequenceParameterSetVui1614 operator StdVideoH265SequenceParameterSetVui &() VULKAN_HPP_NOEXCEPT 1615 { 1616 return *reinterpret_cast<StdVideoH265SequenceParameterSetVui *>( this ); 1617 } 1618 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SequenceParameterSetVui1619 bool operator==( H265SequenceParameterSetVui const & rhs ) const VULKAN_HPP_NOEXCEPT 1620 { 1621 return ( flags == rhs.flags ) && ( aspect_ratio_idc == rhs.aspect_ratio_idc ) && ( sar_width == rhs.sar_width ) && ( sar_height == rhs.sar_height ) && 1622 ( video_format == rhs.video_format ) && ( colour_primaries == rhs.colour_primaries ) && 1623 ( transfer_characteristics == rhs.transfer_characteristics ) && ( matrix_coeffs == rhs.matrix_coeffs ) && 1624 ( chroma_sample_loc_type_top_field == rhs.chroma_sample_loc_type_top_field ) && 1625 ( chroma_sample_loc_type_bottom_field == rhs.chroma_sample_loc_type_bottom_field ) && ( reserved1 == rhs.reserved1 ) && 1626 ( reserved2 == rhs.reserved2 ) && ( def_disp_win_left_offset == rhs.def_disp_win_left_offset ) && 1627 ( def_disp_win_right_offset == rhs.def_disp_win_right_offset ) && ( def_disp_win_top_offset == rhs.def_disp_win_top_offset ) && 1628 ( def_disp_win_bottom_offset == rhs.def_disp_win_bottom_offset ) && ( vui_num_units_in_tick == rhs.vui_num_units_in_tick ) && 1629 ( vui_time_scale == rhs.vui_time_scale ) && ( vui_num_ticks_poc_diff_one_minus1 == rhs.vui_num_ticks_poc_diff_one_minus1 ) && 1630 ( min_spatial_segmentation_idc == rhs.min_spatial_segmentation_idc ) && ( reserved3 == rhs.reserved3 ) && 1631 ( max_bytes_per_pic_denom == rhs.max_bytes_per_pic_denom ) && ( max_bits_per_min_cu_denom == rhs.max_bits_per_min_cu_denom ) && 1632 ( log2_max_mv_length_horizontal == rhs.log2_max_mv_length_horizontal ) && ( log2_max_mv_length_vertical == rhs.log2_max_mv_length_vertical ) && 1633 ( pHrdParameters == rhs.pHrdParameters ); 1634 } 1635 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SequenceParameterSetVui1636 bool operator!=( H265SequenceParameterSetVui const & rhs ) const VULKAN_HPP_NOEXCEPT 1637 { 1638 return !operator==( rhs ); 1639 } 1640 1641 public: 1642 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SpsVuiFlags flags = {}; 1643 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265AspectRatioIdc aspect_ratio_idc = 1644 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265AspectRatioIdc::eUnspecified; 1645 uint16_t sar_width = {}; 1646 uint16_t sar_height = {}; 1647 uint8_t video_format = {}; 1648 uint8_t colour_primaries = {}; 1649 uint8_t transfer_characteristics = {}; 1650 uint8_t matrix_coeffs = {}; 1651 uint8_t chroma_sample_loc_type_top_field = {}; 1652 uint8_t chroma_sample_loc_type_bottom_field = {}; 1653 uint8_t reserved1 = {}; 1654 uint8_t reserved2 = {}; 1655 uint16_t def_disp_win_left_offset = {}; 1656 uint16_t def_disp_win_right_offset = {}; 1657 uint16_t def_disp_win_top_offset = {}; 1658 uint16_t def_disp_win_bottom_offset = {}; 1659 uint32_t vui_num_units_in_tick = {}; 1660 uint32_t vui_time_scale = {}; 1661 uint32_t vui_num_ticks_poc_diff_one_minus1 = {}; 1662 uint16_t min_spatial_segmentation_idc = {}; 1663 uint16_t reserved3 = {}; 1664 uint8_t max_bytes_per_pic_denom = {}; 1665 uint8_t max_bits_per_min_cu_denom = {}; 1666 uint8_t log2_max_mv_length_horizontal = {}; 1667 uint8_t log2_max_mv_length_vertical = {}; 1668 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdParameters * pHrdParameters = {}; 1669 }; 1670 1671 struct H265PredictorPaletteEntries 1672 { 1673 using NativeType = StdVideoH265PredictorPaletteEntries; 1674 operator StdVideoH265PredictorPaletteEntries const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PredictorPaletteEntries1675 operator StdVideoH265PredictorPaletteEntries const &() const VULKAN_HPP_NOEXCEPT 1676 { 1677 return *reinterpret_cast<const StdVideoH265PredictorPaletteEntries *>( this ); 1678 } 1679 operator StdVideoH265PredictorPaletteEntries&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PredictorPaletteEntries1680 operator StdVideoH265PredictorPaletteEntries &() VULKAN_HPP_NOEXCEPT 1681 { 1682 return *reinterpret_cast<StdVideoH265PredictorPaletteEntries *>( this ); 1683 } 1684 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PredictorPaletteEntries1685 bool operator==( H265PredictorPaletteEntries const & rhs ) const VULKAN_HPP_NOEXCEPT 1686 { 1687 return ( PredictorPaletteEntries == rhs.PredictorPaletteEntries ); 1688 } 1689 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PredictorPaletteEntries1690 bool operator!=( H265PredictorPaletteEntries const & rhs ) const VULKAN_HPP_NOEXCEPT 1691 { 1692 return !operator==( rhs ); 1693 } 1694 1695 public: 1696 VULKAN_HPP_NAMESPACE:: 1697 ArrayWrapper2D<uint16_t, STD_VIDEO_H265_PREDICTOR_PALETTE_COMPONENTS_LIST_SIZE, STD_VIDEO_H265_PREDICTOR_PALETTE_COMP_ENTRIES_LIST_SIZE> 1698 PredictorPaletteEntries = {}; 1699 }; 1700 1701 struct H265SpsFlags 1702 { 1703 using NativeType = StdVideoH265SpsFlags; 1704 operator StdVideoH265SpsFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SpsFlags1705 operator StdVideoH265SpsFlags const &() const VULKAN_HPP_NOEXCEPT 1706 { 1707 return *reinterpret_cast<const StdVideoH265SpsFlags *>( this ); 1708 } 1709 operator StdVideoH265SpsFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SpsFlags1710 operator StdVideoH265SpsFlags &() VULKAN_HPP_NOEXCEPT 1711 { 1712 return *reinterpret_cast<StdVideoH265SpsFlags *>( this ); 1713 } 1714 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SpsFlags1715 bool operator==( H265SpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 1716 { 1717 return ( sps_temporal_id_nesting_flag == rhs.sps_temporal_id_nesting_flag ) && ( separate_colour_plane_flag == rhs.separate_colour_plane_flag ) && 1718 ( conformance_window_flag == rhs.conformance_window_flag ) && 1719 ( sps_sub_layer_ordering_info_present_flag == rhs.sps_sub_layer_ordering_info_present_flag ) && 1720 ( scaling_list_enabled_flag == rhs.scaling_list_enabled_flag ) && 1721 ( sps_scaling_list_data_present_flag == rhs.sps_scaling_list_data_present_flag ) && ( amp_enabled_flag == rhs.amp_enabled_flag ) && 1722 ( sample_adaptive_offset_enabled_flag == rhs.sample_adaptive_offset_enabled_flag ) && ( pcm_enabled_flag == rhs.pcm_enabled_flag ) && 1723 ( pcm_loop_filter_disabled_flag == rhs.pcm_loop_filter_disabled_flag ) && 1724 ( long_term_ref_pics_present_flag == rhs.long_term_ref_pics_present_flag ) && 1725 ( sps_temporal_mvp_enabled_flag == rhs.sps_temporal_mvp_enabled_flag ) && 1726 ( strong_intra_smoothing_enabled_flag == rhs.strong_intra_smoothing_enabled_flag ) && 1727 ( vui_parameters_present_flag == rhs.vui_parameters_present_flag ) && ( sps_extension_present_flag == rhs.sps_extension_present_flag ) && 1728 ( sps_range_extension_flag == rhs.sps_range_extension_flag ) && 1729 ( transform_skip_rotation_enabled_flag == rhs.transform_skip_rotation_enabled_flag ) && 1730 ( transform_skip_context_enabled_flag == rhs.transform_skip_context_enabled_flag ) && 1731 ( implicit_rdpcm_enabled_flag == rhs.implicit_rdpcm_enabled_flag ) && ( explicit_rdpcm_enabled_flag == rhs.explicit_rdpcm_enabled_flag ) && 1732 ( extended_precision_processing_flag == rhs.extended_precision_processing_flag ) && 1733 ( intra_smoothing_disabled_flag == rhs.intra_smoothing_disabled_flag ) && 1734 ( high_precision_offsets_enabled_flag == rhs.high_precision_offsets_enabled_flag ) && 1735 ( persistent_rice_adaptation_enabled_flag == rhs.persistent_rice_adaptation_enabled_flag ) && 1736 ( cabac_bypass_alignment_enabled_flag == rhs.cabac_bypass_alignment_enabled_flag ) && ( sps_scc_extension_flag == rhs.sps_scc_extension_flag ) && 1737 ( sps_curr_pic_ref_enabled_flag == rhs.sps_curr_pic_ref_enabled_flag ) && ( palette_mode_enabled_flag == rhs.palette_mode_enabled_flag ) && 1738 ( sps_palette_predictor_initializers_present_flag == rhs.sps_palette_predictor_initializers_present_flag ) && 1739 ( intra_boundary_filtering_disabled_flag == rhs.intra_boundary_filtering_disabled_flag ); 1740 } 1741 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SpsFlags1742 bool operator!=( H265SpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 1743 { 1744 return !operator==( rhs ); 1745 } 1746 1747 public: 1748 uint32_t sps_temporal_id_nesting_flag : 1; 1749 uint32_t separate_colour_plane_flag : 1; 1750 uint32_t conformance_window_flag : 1; 1751 uint32_t sps_sub_layer_ordering_info_present_flag : 1; 1752 uint32_t scaling_list_enabled_flag : 1; 1753 uint32_t sps_scaling_list_data_present_flag : 1; 1754 uint32_t amp_enabled_flag : 1; 1755 uint32_t sample_adaptive_offset_enabled_flag : 1; 1756 uint32_t pcm_enabled_flag : 1; 1757 uint32_t pcm_loop_filter_disabled_flag : 1; 1758 uint32_t long_term_ref_pics_present_flag : 1; 1759 uint32_t sps_temporal_mvp_enabled_flag : 1; 1760 uint32_t strong_intra_smoothing_enabled_flag : 1; 1761 uint32_t vui_parameters_present_flag : 1; 1762 uint32_t sps_extension_present_flag : 1; 1763 uint32_t sps_range_extension_flag : 1; 1764 uint32_t transform_skip_rotation_enabled_flag : 1; 1765 uint32_t transform_skip_context_enabled_flag : 1; 1766 uint32_t implicit_rdpcm_enabled_flag : 1; 1767 uint32_t explicit_rdpcm_enabled_flag : 1; 1768 uint32_t extended_precision_processing_flag : 1; 1769 uint32_t intra_smoothing_disabled_flag : 1; 1770 uint32_t high_precision_offsets_enabled_flag : 1; 1771 uint32_t persistent_rice_adaptation_enabled_flag : 1; 1772 uint32_t cabac_bypass_alignment_enabled_flag : 1; 1773 uint32_t sps_scc_extension_flag : 1; 1774 uint32_t sps_curr_pic_ref_enabled_flag : 1; 1775 uint32_t palette_mode_enabled_flag : 1; 1776 uint32_t sps_palette_predictor_initializers_present_flag : 1; 1777 uint32_t intra_boundary_filtering_disabled_flag : 1; 1778 }; 1779 1780 struct H265ShortTermRefPicSetFlags 1781 { 1782 using NativeType = StdVideoH265ShortTermRefPicSetFlags; 1783 operator StdVideoH265ShortTermRefPicSetFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSetFlags1784 operator StdVideoH265ShortTermRefPicSetFlags const &() const VULKAN_HPP_NOEXCEPT 1785 { 1786 return *reinterpret_cast<const StdVideoH265ShortTermRefPicSetFlags *>( this ); 1787 } 1788 operator StdVideoH265ShortTermRefPicSetFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSetFlags1789 operator StdVideoH265ShortTermRefPicSetFlags &() VULKAN_HPP_NOEXCEPT 1790 { 1791 return *reinterpret_cast<StdVideoH265ShortTermRefPicSetFlags *>( this ); 1792 } 1793 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSetFlags1794 bool operator==( H265ShortTermRefPicSetFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 1795 { 1796 return ( inter_ref_pic_set_prediction_flag == rhs.inter_ref_pic_set_prediction_flag ) && ( delta_rps_sign == rhs.delta_rps_sign ); 1797 } 1798 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSetFlags1799 bool operator!=( H265ShortTermRefPicSetFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 1800 { 1801 return !operator==( rhs ); 1802 } 1803 1804 public: 1805 uint32_t inter_ref_pic_set_prediction_flag : 1; 1806 uint32_t delta_rps_sign : 1; 1807 }; 1808 1809 struct H265ShortTermRefPicSet 1810 { 1811 using NativeType = StdVideoH265ShortTermRefPicSet; 1812 operator StdVideoH265ShortTermRefPicSet const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSet1813 operator StdVideoH265ShortTermRefPicSet const &() const VULKAN_HPP_NOEXCEPT 1814 { 1815 return *reinterpret_cast<const StdVideoH265ShortTermRefPicSet *>( this ); 1816 } 1817 operator StdVideoH265ShortTermRefPicSet&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSet1818 operator StdVideoH265ShortTermRefPicSet &() VULKAN_HPP_NOEXCEPT 1819 { 1820 return *reinterpret_cast<StdVideoH265ShortTermRefPicSet *>( this ); 1821 } 1822 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSet1823 bool operator==( H265ShortTermRefPicSet const & rhs ) const VULKAN_HPP_NOEXCEPT 1824 { 1825 return ( flags == rhs.flags ) && ( delta_idx_minus1 == rhs.delta_idx_minus1 ) && ( use_delta_flag == rhs.use_delta_flag ) && 1826 ( abs_delta_rps_minus1 == rhs.abs_delta_rps_minus1 ) && ( used_by_curr_pic_flag == rhs.used_by_curr_pic_flag ) && 1827 ( used_by_curr_pic_s0_flag == rhs.used_by_curr_pic_s0_flag ) && ( used_by_curr_pic_s1_flag == rhs.used_by_curr_pic_s1_flag ) && 1828 ( reserved1 == rhs.reserved1 ) && ( reserved2 == rhs.reserved2 ) && ( reserved3 == rhs.reserved3 ) && 1829 ( num_negative_pics == rhs.num_negative_pics ) && ( num_positive_pics == rhs.num_positive_pics ) && 1830 ( delta_poc_s0_minus1 == rhs.delta_poc_s0_minus1 ) && ( delta_poc_s1_minus1 == rhs.delta_poc_s1_minus1 ); 1831 } 1832 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSet1833 bool operator!=( H265ShortTermRefPicSet const & rhs ) const VULKAN_HPP_NOEXCEPT 1834 { 1835 return !operator==( rhs ); 1836 } 1837 1838 public: 1839 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSetFlags flags = {}; 1840 uint32_t delta_idx_minus1 = {}; 1841 uint16_t use_delta_flag = {}; 1842 uint16_t abs_delta_rps_minus1 = {}; 1843 uint16_t used_by_curr_pic_flag = {}; 1844 uint16_t used_by_curr_pic_s0_flag = {}; 1845 uint16_t used_by_curr_pic_s1_flag = {}; 1846 uint16_t reserved1 = {}; 1847 uint8_t reserved2 = {}; 1848 uint8_t reserved3 = {}; 1849 uint8_t num_negative_pics = {}; 1850 uint8_t num_positive_pics = {}; 1851 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint16_t, STD_VIDEO_H265_MAX_DPB_SIZE> delta_poc_s0_minus1 = {}; 1852 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint16_t, STD_VIDEO_H265_MAX_DPB_SIZE> delta_poc_s1_minus1 = {}; 1853 }; 1854 1855 struct H265LongTermRefPicsSps 1856 { 1857 using NativeType = StdVideoH265LongTermRefPicsSps; 1858 operator StdVideoH265LongTermRefPicsSps const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265LongTermRefPicsSps1859 operator StdVideoH265LongTermRefPicsSps const &() const VULKAN_HPP_NOEXCEPT 1860 { 1861 return *reinterpret_cast<const StdVideoH265LongTermRefPicsSps *>( this ); 1862 } 1863 operator StdVideoH265LongTermRefPicsSps&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265LongTermRefPicsSps1864 operator StdVideoH265LongTermRefPicsSps &() VULKAN_HPP_NOEXCEPT 1865 { 1866 return *reinterpret_cast<StdVideoH265LongTermRefPicsSps *>( this ); 1867 } 1868 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265LongTermRefPicsSps1869 bool operator==( H265LongTermRefPicsSps const & rhs ) const VULKAN_HPP_NOEXCEPT 1870 { 1871 return ( used_by_curr_pic_lt_sps_flag == rhs.used_by_curr_pic_lt_sps_flag ) && ( lt_ref_pic_poc_lsb_sps == rhs.lt_ref_pic_poc_lsb_sps ); 1872 } 1873 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265LongTermRefPicsSps1874 bool operator!=( H265LongTermRefPicsSps const & rhs ) const VULKAN_HPP_NOEXCEPT 1875 { 1876 return !operator==( rhs ); 1877 } 1878 1879 public: 1880 uint32_t used_by_curr_pic_lt_sps_flag = {}; 1881 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS> lt_ref_pic_poc_lsb_sps = {}; 1882 }; 1883 1884 struct H265SequenceParameterSet 1885 { 1886 using NativeType = StdVideoH265SequenceParameterSet; 1887 operator StdVideoH265SequenceParameterSet const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SequenceParameterSet1888 operator StdVideoH265SequenceParameterSet const &() const VULKAN_HPP_NOEXCEPT 1889 { 1890 return *reinterpret_cast<const StdVideoH265SequenceParameterSet *>( this ); 1891 } 1892 operator StdVideoH265SequenceParameterSet&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SequenceParameterSet1893 operator StdVideoH265SequenceParameterSet &() VULKAN_HPP_NOEXCEPT 1894 { 1895 return *reinterpret_cast<StdVideoH265SequenceParameterSet *>( this ); 1896 } 1897 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SequenceParameterSet1898 bool operator==( H265SequenceParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT 1899 { 1900 return ( flags == rhs.flags ) && ( chroma_format_idc == rhs.chroma_format_idc ) && ( pic_width_in_luma_samples == rhs.pic_width_in_luma_samples ) && 1901 ( pic_height_in_luma_samples == rhs.pic_height_in_luma_samples ) && ( sps_video_parameter_set_id == rhs.sps_video_parameter_set_id ) && 1902 ( sps_max_sub_layers_minus1 == rhs.sps_max_sub_layers_minus1 ) && ( sps_seq_parameter_set_id == rhs.sps_seq_parameter_set_id ) && 1903 ( bit_depth_luma_minus8 == rhs.bit_depth_luma_minus8 ) && ( bit_depth_chroma_minus8 == rhs.bit_depth_chroma_minus8 ) && 1904 ( log2_max_pic_order_cnt_lsb_minus4 == rhs.log2_max_pic_order_cnt_lsb_minus4 ) && 1905 ( log2_min_luma_coding_block_size_minus3 == rhs.log2_min_luma_coding_block_size_minus3 ) && 1906 ( log2_diff_max_min_luma_coding_block_size == rhs.log2_diff_max_min_luma_coding_block_size ) && 1907 ( log2_min_luma_transform_block_size_minus2 == rhs.log2_min_luma_transform_block_size_minus2 ) && 1908 ( log2_diff_max_min_luma_transform_block_size == rhs.log2_diff_max_min_luma_transform_block_size ) && 1909 ( max_transform_hierarchy_depth_inter == rhs.max_transform_hierarchy_depth_inter ) && 1910 ( max_transform_hierarchy_depth_intra == rhs.max_transform_hierarchy_depth_intra ) && 1911 ( num_short_term_ref_pic_sets == rhs.num_short_term_ref_pic_sets ) && ( num_long_term_ref_pics_sps == rhs.num_long_term_ref_pics_sps ) && 1912 ( pcm_sample_bit_depth_luma_minus1 == rhs.pcm_sample_bit_depth_luma_minus1 ) && 1913 ( pcm_sample_bit_depth_chroma_minus1 == rhs.pcm_sample_bit_depth_chroma_minus1 ) && 1914 ( log2_min_pcm_luma_coding_block_size_minus3 == rhs.log2_min_pcm_luma_coding_block_size_minus3 ) && 1915 ( log2_diff_max_min_pcm_luma_coding_block_size == rhs.log2_diff_max_min_pcm_luma_coding_block_size ) && ( reserved1 == rhs.reserved1 ) && 1916 ( reserved2 == rhs.reserved2 ) && ( palette_max_size == rhs.palette_max_size ) && 1917 ( delta_palette_max_predictor_size == rhs.delta_palette_max_predictor_size ) && 1918 ( motion_vector_resolution_control_idc == rhs.motion_vector_resolution_control_idc ) && 1919 ( sps_num_palette_predictor_initializers_minus1 == rhs.sps_num_palette_predictor_initializers_minus1 ) && 1920 ( conf_win_left_offset == rhs.conf_win_left_offset ) && ( conf_win_right_offset == rhs.conf_win_right_offset ) && 1921 ( conf_win_top_offset == rhs.conf_win_top_offset ) && ( conf_win_bottom_offset == rhs.conf_win_bottom_offset ) && 1922 ( pProfileTierLevel == rhs.pProfileTierLevel ) && ( pDecPicBufMgr == rhs.pDecPicBufMgr ) && ( pScalingLists == rhs.pScalingLists ) && 1923 ( pShortTermRefPicSet == rhs.pShortTermRefPicSet ) && ( pLongTermRefPicsSps == rhs.pLongTermRefPicsSps ) && 1924 ( pSequenceParameterSetVui == rhs.pSequenceParameterSetVui ) && ( pPredictorPaletteEntries == rhs.pPredictorPaletteEntries ); 1925 } 1926 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SequenceParameterSet1927 bool operator!=( H265SequenceParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT 1928 { 1929 return !operator==( rhs ); 1930 } 1931 1932 public: 1933 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SpsFlags flags = {}; 1934 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ChromaFormatIdc chroma_format_idc = 1935 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ChromaFormatIdc::eMonochrome; 1936 uint32_t pic_width_in_luma_samples = {}; 1937 uint32_t pic_height_in_luma_samples = {}; 1938 uint8_t sps_video_parameter_set_id = {}; 1939 uint8_t sps_max_sub_layers_minus1 = {}; 1940 uint8_t sps_seq_parameter_set_id = {}; 1941 uint8_t bit_depth_luma_minus8 = {}; 1942 uint8_t bit_depth_chroma_minus8 = {}; 1943 uint8_t log2_max_pic_order_cnt_lsb_minus4 = {}; 1944 uint8_t log2_min_luma_coding_block_size_minus3 = {}; 1945 uint8_t log2_diff_max_min_luma_coding_block_size = {}; 1946 uint8_t log2_min_luma_transform_block_size_minus2 = {}; 1947 uint8_t log2_diff_max_min_luma_transform_block_size = {}; 1948 uint8_t max_transform_hierarchy_depth_inter = {}; 1949 uint8_t max_transform_hierarchy_depth_intra = {}; 1950 uint8_t num_short_term_ref_pic_sets = {}; 1951 uint8_t num_long_term_ref_pics_sps = {}; 1952 uint8_t pcm_sample_bit_depth_luma_minus1 = {}; 1953 uint8_t pcm_sample_bit_depth_chroma_minus1 = {}; 1954 uint8_t log2_min_pcm_luma_coding_block_size_minus3 = {}; 1955 uint8_t log2_diff_max_min_pcm_luma_coding_block_size = {}; 1956 uint8_t reserved1 = {}; 1957 uint8_t reserved2 = {}; 1958 uint8_t palette_max_size = {}; 1959 uint8_t delta_palette_max_predictor_size = {}; 1960 uint8_t motion_vector_resolution_control_idc = {}; 1961 uint8_t sps_num_palette_predictor_initializers_minus1 = {}; 1962 uint32_t conf_win_left_offset = {}; 1963 uint32_t conf_win_right_offset = {}; 1964 uint32_t conf_win_top_offset = {}; 1965 uint32_t conf_win_bottom_offset = {}; 1966 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevel * pProfileTierLevel = {}; 1967 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265DecPicBufMgr * pDecPicBufMgr = {}; 1968 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingLists * pScalingLists = {}; 1969 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSet * pShortTermRefPicSet = {}; 1970 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265LongTermRefPicsSps * pLongTermRefPicsSps = {}; 1971 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SequenceParameterSetVui * pSequenceParameterSetVui = {}; 1972 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PredictorPaletteEntries * pPredictorPaletteEntries = {}; 1973 }; 1974 1975 struct H265PpsFlags 1976 { 1977 using NativeType = StdVideoH265PpsFlags; 1978 operator StdVideoH265PpsFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PpsFlags1979 operator StdVideoH265PpsFlags const &() const VULKAN_HPP_NOEXCEPT 1980 { 1981 return *reinterpret_cast<const StdVideoH265PpsFlags *>( this ); 1982 } 1983 operator StdVideoH265PpsFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PpsFlags1984 operator StdVideoH265PpsFlags &() VULKAN_HPP_NOEXCEPT 1985 { 1986 return *reinterpret_cast<StdVideoH265PpsFlags *>( this ); 1987 } 1988 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PpsFlags1989 bool operator==( H265PpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 1990 { 1991 return ( dependent_slice_segments_enabled_flag == rhs.dependent_slice_segments_enabled_flag ) && 1992 ( output_flag_present_flag == rhs.output_flag_present_flag ) && ( sign_data_hiding_enabled_flag == rhs.sign_data_hiding_enabled_flag ) && 1993 ( cabac_init_present_flag == rhs.cabac_init_present_flag ) && ( constrained_intra_pred_flag == rhs.constrained_intra_pred_flag ) && 1994 ( transform_skip_enabled_flag == rhs.transform_skip_enabled_flag ) && ( cu_qp_delta_enabled_flag == rhs.cu_qp_delta_enabled_flag ) && 1995 ( pps_slice_chroma_qp_offsets_present_flag == rhs.pps_slice_chroma_qp_offsets_present_flag ) && 1996 ( weighted_pred_flag == rhs.weighted_pred_flag ) && ( weighted_bipred_flag == rhs.weighted_bipred_flag ) && 1997 ( transquant_bypass_enabled_flag == rhs.transquant_bypass_enabled_flag ) && ( tiles_enabled_flag == rhs.tiles_enabled_flag ) && 1998 ( entropy_coding_sync_enabled_flag == rhs.entropy_coding_sync_enabled_flag ) && ( uniform_spacing_flag == rhs.uniform_spacing_flag ) && 1999 ( loop_filter_across_tiles_enabled_flag == rhs.loop_filter_across_tiles_enabled_flag ) && 2000 ( pps_loop_filter_across_slices_enabled_flag == rhs.pps_loop_filter_across_slices_enabled_flag ) && 2001 ( deblocking_filter_control_present_flag == rhs.deblocking_filter_control_present_flag ) && 2002 ( deblocking_filter_override_enabled_flag == rhs.deblocking_filter_override_enabled_flag ) && 2003 ( pps_deblocking_filter_disabled_flag == rhs.pps_deblocking_filter_disabled_flag ) && 2004 ( pps_scaling_list_data_present_flag == rhs.pps_scaling_list_data_present_flag ) && 2005 ( lists_modification_present_flag == rhs.lists_modification_present_flag ) && 2006 ( slice_segment_header_extension_present_flag == rhs.slice_segment_header_extension_present_flag ) && 2007 ( pps_extension_present_flag == rhs.pps_extension_present_flag ) && 2008 ( cross_component_prediction_enabled_flag == rhs.cross_component_prediction_enabled_flag ) && 2009 ( chroma_qp_offset_list_enabled_flag == rhs.chroma_qp_offset_list_enabled_flag ) && 2010 ( pps_curr_pic_ref_enabled_flag == rhs.pps_curr_pic_ref_enabled_flag ) && 2011 ( residual_adaptive_colour_transform_enabled_flag == rhs.residual_adaptive_colour_transform_enabled_flag ) && 2012 ( pps_slice_act_qp_offsets_present_flag == rhs.pps_slice_act_qp_offsets_present_flag ) && 2013 ( pps_palette_predictor_initializers_present_flag == rhs.pps_palette_predictor_initializers_present_flag ) && 2014 ( monochrome_palette_flag == rhs.monochrome_palette_flag ) && ( pps_range_extension_flag == rhs.pps_range_extension_flag ); 2015 } 2016 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PpsFlags2017 bool operator!=( H265PpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 2018 { 2019 return !operator==( rhs ); 2020 } 2021 2022 public: 2023 uint32_t dependent_slice_segments_enabled_flag : 1; 2024 uint32_t output_flag_present_flag : 1; 2025 uint32_t sign_data_hiding_enabled_flag : 1; 2026 uint32_t cabac_init_present_flag : 1; 2027 uint32_t constrained_intra_pred_flag : 1; 2028 uint32_t transform_skip_enabled_flag : 1; 2029 uint32_t cu_qp_delta_enabled_flag : 1; 2030 uint32_t pps_slice_chroma_qp_offsets_present_flag : 1; 2031 uint32_t weighted_pred_flag : 1; 2032 uint32_t weighted_bipred_flag : 1; 2033 uint32_t transquant_bypass_enabled_flag : 1; 2034 uint32_t tiles_enabled_flag : 1; 2035 uint32_t entropy_coding_sync_enabled_flag : 1; 2036 uint32_t uniform_spacing_flag : 1; 2037 uint32_t loop_filter_across_tiles_enabled_flag : 1; 2038 uint32_t pps_loop_filter_across_slices_enabled_flag : 1; 2039 uint32_t deblocking_filter_control_present_flag : 1; 2040 uint32_t deblocking_filter_override_enabled_flag : 1; 2041 uint32_t pps_deblocking_filter_disabled_flag : 1; 2042 uint32_t pps_scaling_list_data_present_flag : 1; 2043 uint32_t lists_modification_present_flag : 1; 2044 uint32_t slice_segment_header_extension_present_flag : 1; 2045 uint32_t pps_extension_present_flag : 1; 2046 uint32_t cross_component_prediction_enabled_flag : 1; 2047 uint32_t chroma_qp_offset_list_enabled_flag : 1; 2048 uint32_t pps_curr_pic_ref_enabled_flag : 1; 2049 uint32_t residual_adaptive_colour_transform_enabled_flag : 1; 2050 uint32_t pps_slice_act_qp_offsets_present_flag : 1; 2051 uint32_t pps_palette_predictor_initializers_present_flag : 1; 2052 uint32_t monochrome_palette_flag : 1; 2053 uint32_t pps_range_extension_flag : 1; 2054 }; 2055 2056 struct H265PictureParameterSet 2057 { 2058 using NativeType = StdVideoH265PictureParameterSet; 2059 operator StdVideoH265PictureParameterSet const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureParameterSet2060 operator StdVideoH265PictureParameterSet const &() const VULKAN_HPP_NOEXCEPT 2061 { 2062 return *reinterpret_cast<const StdVideoH265PictureParameterSet *>( this ); 2063 } 2064 operator StdVideoH265PictureParameterSet&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureParameterSet2065 operator StdVideoH265PictureParameterSet &() VULKAN_HPP_NOEXCEPT 2066 { 2067 return *reinterpret_cast<StdVideoH265PictureParameterSet *>( this ); 2068 } 2069 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureParameterSet2070 bool operator==( H265PictureParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT 2071 { 2072 return ( flags == rhs.flags ) && ( pps_pic_parameter_set_id == rhs.pps_pic_parameter_set_id ) && 2073 ( pps_seq_parameter_set_id == rhs.pps_seq_parameter_set_id ) && ( sps_video_parameter_set_id == rhs.sps_video_parameter_set_id ) && 2074 ( num_extra_slice_header_bits == rhs.num_extra_slice_header_bits ) && 2075 ( num_ref_idx_l0_default_active_minus1 == rhs.num_ref_idx_l0_default_active_minus1 ) && 2076 ( num_ref_idx_l1_default_active_minus1 == rhs.num_ref_idx_l1_default_active_minus1 ) && ( init_qp_minus26 == rhs.init_qp_minus26 ) && 2077 ( diff_cu_qp_delta_depth == rhs.diff_cu_qp_delta_depth ) && ( pps_cb_qp_offset == rhs.pps_cb_qp_offset ) && 2078 ( pps_cr_qp_offset == rhs.pps_cr_qp_offset ) && ( pps_beta_offset_div2 == rhs.pps_beta_offset_div2 ) && 2079 ( pps_tc_offset_div2 == rhs.pps_tc_offset_div2 ) && ( log2_parallel_merge_level_minus2 == rhs.log2_parallel_merge_level_minus2 ) && 2080 ( log2_max_transform_skip_block_size_minus2 == rhs.log2_max_transform_skip_block_size_minus2 ) && 2081 ( diff_cu_chroma_qp_offset_depth == rhs.diff_cu_chroma_qp_offset_depth ) && 2082 ( chroma_qp_offset_list_len_minus1 == rhs.chroma_qp_offset_list_len_minus1 ) && ( cb_qp_offset_list == rhs.cb_qp_offset_list ) && 2083 ( cr_qp_offset_list == rhs.cr_qp_offset_list ) && ( log2_sao_offset_scale_luma == rhs.log2_sao_offset_scale_luma ) && 2084 ( log2_sao_offset_scale_chroma == rhs.log2_sao_offset_scale_chroma ) && ( pps_act_y_qp_offset_plus5 == rhs.pps_act_y_qp_offset_plus5 ) && 2085 ( pps_act_cb_qp_offset_plus5 == rhs.pps_act_cb_qp_offset_plus5 ) && ( pps_act_cr_qp_offset_plus3 == rhs.pps_act_cr_qp_offset_plus3 ) && 2086 ( pps_num_palette_predictor_initializers == rhs.pps_num_palette_predictor_initializers ) && 2087 ( luma_bit_depth_entry_minus8 == rhs.luma_bit_depth_entry_minus8 ) && ( chroma_bit_depth_entry_minus8 == rhs.chroma_bit_depth_entry_minus8 ) && 2088 ( num_tile_columns_minus1 == rhs.num_tile_columns_minus1 ) && ( num_tile_rows_minus1 == rhs.num_tile_rows_minus1 ) && 2089 ( reserved1 == rhs.reserved1 ) && ( reserved2 == rhs.reserved2 ) && ( column_width_minus1 == rhs.column_width_minus1 ) && 2090 ( row_height_minus1 == rhs.row_height_minus1 ) && ( reserved3 == rhs.reserved3 ) && ( pScalingLists == rhs.pScalingLists ) && 2091 ( pPredictorPaletteEntries == rhs.pPredictorPaletteEntries ); 2092 } 2093 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureParameterSet2094 bool operator!=( H265PictureParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT 2095 { 2096 return !operator==( rhs ); 2097 } 2098 2099 public: 2100 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PpsFlags flags = {}; 2101 uint8_t pps_pic_parameter_set_id = {}; 2102 uint8_t pps_seq_parameter_set_id = {}; 2103 uint8_t sps_video_parameter_set_id = {}; 2104 uint8_t num_extra_slice_header_bits = {}; 2105 uint8_t num_ref_idx_l0_default_active_minus1 = {}; 2106 uint8_t num_ref_idx_l1_default_active_minus1 = {}; 2107 int8_t init_qp_minus26 = {}; 2108 uint8_t diff_cu_qp_delta_depth = {}; 2109 int8_t pps_cb_qp_offset = {}; 2110 int8_t pps_cr_qp_offset = {}; 2111 int8_t pps_beta_offset_div2 = {}; 2112 int8_t pps_tc_offset_div2 = {}; 2113 uint8_t log2_parallel_merge_level_minus2 = {}; 2114 uint8_t log2_max_transform_skip_block_size_minus2 = {}; 2115 uint8_t diff_cu_chroma_qp_offset_depth = {}; 2116 uint8_t chroma_qp_offset_list_len_minus1 = {}; 2117 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE> cb_qp_offset_list = {}; 2118 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE> cr_qp_offset_list = {}; 2119 uint8_t log2_sao_offset_scale_luma = {}; 2120 uint8_t log2_sao_offset_scale_chroma = {}; 2121 int8_t pps_act_y_qp_offset_plus5 = {}; 2122 int8_t pps_act_cb_qp_offset_plus5 = {}; 2123 int8_t pps_act_cr_qp_offset_plus3 = {}; 2124 uint8_t pps_num_palette_predictor_initializers = {}; 2125 uint8_t luma_bit_depth_entry_minus8 = {}; 2126 uint8_t chroma_bit_depth_entry_minus8 = {}; 2127 uint8_t num_tile_columns_minus1 = {}; 2128 uint8_t num_tile_rows_minus1 = {}; 2129 uint8_t reserved1 = {}; 2130 uint8_t reserved2 = {}; 2131 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint16_t, STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE> column_width_minus1 = {}; 2132 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint16_t, STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE> row_height_minus1 = {}; 2133 uint32_t reserved3 = {}; 2134 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingLists * pScalingLists = {}; 2135 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PredictorPaletteEntries * pPredictorPaletteEntries = {}; 2136 }; 2137 2138 //=== vulkan_video_codec_h265std_decode === 2139 2140 struct DecodeH265PictureInfoFlags 2141 { 2142 using NativeType = StdVideoDecodeH265PictureInfoFlags; 2143 operator StdVideoDecodeH265PictureInfoFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265PictureInfoFlags2144 operator StdVideoDecodeH265PictureInfoFlags const &() const VULKAN_HPP_NOEXCEPT 2145 { 2146 return *reinterpret_cast<const StdVideoDecodeH265PictureInfoFlags *>( this ); 2147 } 2148 operator StdVideoDecodeH265PictureInfoFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265PictureInfoFlags2149 operator StdVideoDecodeH265PictureInfoFlags &() VULKAN_HPP_NOEXCEPT 2150 { 2151 return *reinterpret_cast<StdVideoDecodeH265PictureInfoFlags *>( this ); 2152 } 2153 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265PictureInfoFlags2154 bool operator==( DecodeH265PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 2155 { 2156 return ( IrapPicFlag == rhs.IrapPicFlag ) && ( IdrPicFlag == rhs.IdrPicFlag ) && ( IsReference == rhs.IsReference ) && 2157 ( short_term_ref_pic_set_sps_flag == rhs.short_term_ref_pic_set_sps_flag ); 2158 } 2159 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265PictureInfoFlags2160 bool operator!=( DecodeH265PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 2161 { 2162 return !operator==( rhs ); 2163 } 2164 2165 public: 2166 uint32_t IrapPicFlag : 1; 2167 uint32_t IdrPicFlag : 1; 2168 uint32_t IsReference : 1; 2169 uint32_t short_term_ref_pic_set_sps_flag : 1; 2170 }; 2171 2172 struct DecodeH265PictureInfo 2173 { 2174 using NativeType = StdVideoDecodeH265PictureInfo; 2175 operator StdVideoDecodeH265PictureInfo const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265PictureInfo2176 operator StdVideoDecodeH265PictureInfo const &() const VULKAN_HPP_NOEXCEPT 2177 { 2178 return *reinterpret_cast<const StdVideoDecodeH265PictureInfo *>( this ); 2179 } 2180 operator StdVideoDecodeH265PictureInfo&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265PictureInfo2181 operator StdVideoDecodeH265PictureInfo &() VULKAN_HPP_NOEXCEPT 2182 { 2183 return *reinterpret_cast<StdVideoDecodeH265PictureInfo *>( this ); 2184 } 2185 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265PictureInfo2186 bool operator==( DecodeH265PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 2187 { 2188 return ( flags == rhs.flags ) && ( sps_video_parameter_set_id == rhs.sps_video_parameter_set_id ) && 2189 ( pps_seq_parameter_set_id == rhs.pps_seq_parameter_set_id ) && ( pps_pic_parameter_set_id == rhs.pps_pic_parameter_set_id ) && 2190 ( NumDeltaPocsOfRefRpsIdx == rhs.NumDeltaPocsOfRefRpsIdx ) && ( PicOrderCntVal == rhs.PicOrderCntVal ) && 2191 ( NumBitsForSTRefPicSetInSlice == rhs.NumBitsForSTRefPicSetInSlice ) && ( reserved == rhs.reserved ) && 2192 ( RefPicSetStCurrBefore == rhs.RefPicSetStCurrBefore ) && ( RefPicSetStCurrAfter == rhs.RefPicSetStCurrAfter ) && 2193 ( RefPicSetLtCurr == rhs.RefPicSetLtCurr ); 2194 } 2195 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265PictureInfo2196 bool operator!=( DecodeH265PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 2197 { 2198 return !operator==( rhs ); 2199 } 2200 2201 public: 2202 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265PictureInfoFlags flags = {}; 2203 uint8_t sps_video_parameter_set_id = {}; 2204 uint8_t pps_seq_parameter_set_id = {}; 2205 uint8_t pps_pic_parameter_set_id = {}; 2206 uint8_t NumDeltaPocsOfRefRpsIdx = {}; 2207 int32_t PicOrderCntVal = {}; 2208 uint16_t NumBitsForSTRefPicSetInSlice = {}; 2209 uint16_t reserved = {}; 2210 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE> RefPicSetStCurrBefore = {}; 2211 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE> RefPicSetStCurrAfter = {}; 2212 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE> RefPicSetLtCurr = {}; 2213 }; 2214 2215 struct DecodeH265ReferenceInfoFlags 2216 { 2217 using NativeType = StdVideoDecodeH265ReferenceInfoFlags; 2218 operator StdVideoDecodeH265ReferenceInfoFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265ReferenceInfoFlags2219 operator StdVideoDecodeH265ReferenceInfoFlags const &() const VULKAN_HPP_NOEXCEPT 2220 { 2221 return *reinterpret_cast<const StdVideoDecodeH265ReferenceInfoFlags *>( this ); 2222 } 2223 operator StdVideoDecodeH265ReferenceInfoFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265ReferenceInfoFlags2224 operator StdVideoDecodeH265ReferenceInfoFlags &() VULKAN_HPP_NOEXCEPT 2225 { 2226 return *reinterpret_cast<StdVideoDecodeH265ReferenceInfoFlags *>( this ); 2227 } 2228 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265ReferenceInfoFlags2229 bool operator==( DecodeH265ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 2230 { 2231 return ( used_for_long_term_reference == rhs.used_for_long_term_reference ) && ( unused_for_reference == rhs.unused_for_reference ); 2232 } 2233 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265ReferenceInfoFlags2234 bool operator!=( DecodeH265ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 2235 { 2236 return !operator==( rhs ); 2237 } 2238 2239 public: 2240 uint32_t used_for_long_term_reference : 1; 2241 uint32_t unused_for_reference : 1; 2242 }; 2243 2244 struct DecodeH265ReferenceInfo 2245 { 2246 using NativeType = StdVideoDecodeH265ReferenceInfo; 2247 operator StdVideoDecodeH265ReferenceInfo const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265ReferenceInfo2248 operator StdVideoDecodeH265ReferenceInfo const &() const VULKAN_HPP_NOEXCEPT 2249 { 2250 return *reinterpret_cast<const StdVideoDecodeH265ReferenceInfo *>( this ); 2251 } 2252 operator StdVideoDecodeH265ReferenceInfo&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265ReferenceInfo2253 operator StdVideoDecodeH265ReferenceInfo &() VULKAN_HPP_NOEXCEPT 2254 { 2255 return *reinterpret_cast<StdVideoDecodeH265ReferenceInfo *>( this ); 2256 } 2257 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265ReferenceInfo2258 bool operator==( DecodeH265ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 2259 { 2260 return ( flags == rhs.flags ) && ( PicOrderCntVal == rhs.PicOrderCntVal ); 2261 } 2262 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265ReferenceInfo2263 bool operator!=( DecodeH265ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 2264 { 2265 return !operator==( rhs ); 2266 } 2267 2268 public: 2269 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265ReferenceInfoFlags flags = {}; 2270 int32_t PicOrderCntVal = {}; 2271 }; 2272 2273 //=== vulkan_video_codec_h265std_encode === 2274 2275 struct EncodeH265WeightTableFlags 2276 { 2277 using NativeType = StdVideoEncodeH265WeightTableFlags; 2278 operator StdVideoEncodeH265WeightTableFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTableFlags2279 operator StdVideoEncodeH265WeightTableFlags const &() const VULKAN_HPP_NOEXCEPT 2280 { 2281 return *reinterpret_cast<const StdVideoEncodeH265WeightTableFlags *>( this ); 2282 } 2283 operator StdVideoEncodeH265WeightTableFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTableFlags2284 operator StdVideoEncodeH265WeightTableFlags &() VULKAN_HPP_NOEXCEPT 2285 { 2286 return *reinterpret_cast<StdVideoEncodeH265WeightTableFlags *>( this ); 2287 } 2288 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTableFlags2289 bool operator==( EncodeH265WeightTableFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 2290 { 2291 return ( luma_weight_l0_flag == rhs.luma_weight_l0_flag ) && ( chroma_weight_l0_flag == rhs.chroma_weight_l0_flag ) && 2292 ( luma_weight_l1_flag == rhs.luma_weight_l1_flag ) && ( chroma_weight_l1_flag == rhs.chroma_weight_l1_flag ); 2293 } 2294 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTableFlags2295 bool operator!=( EncodeH265WeightTableFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 2296 { 2297 return !operator==( rhs ); 2298 } 2299 2300 public: 2301 uint16_t luma_weight_l0_flag = {}; 2302 uint16_t chroma_weight_l0_flag = {}; 2303 uint16_t luma_weight_l1_flag = {}; 2304 uint16_t chroma_weight_l1_flag = {}; 2305 }; 2306 2307 struct EncodeH265WeightTable 2308 { 2309 using NativeType = StdVideoEncodeH265WeightTable; 2310 operator StdVideoEncodeH265WeightTable const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTable2311 operator StdVideoEncodeH265WeightTable const &() const VULKAN_HPP_NOEXCEPT 2312 { 2313 return *reinterpret_cast<const StdVideoEncodeH265WeightTable *>( this ); 2314 } 2315 operator StdVideoEncodeH265WeightTable&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTable2316 operator StdVideoEncodeH265WeightTable &() VULKAN_HPP_NOEXCEPT 2317 { 2318 return *reinterpret_cast<StdVideoEncodeH265WeightTable *>( this ); 2319 } 2320 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTable2321 bool operator==( EncodeH265WeightTable const & rhs ) const VULKAN_HPP_NOEXCEPT 2322 { 2323 return ( flags == rhs.flags ) && ( luma_log2_weight_denom == rhs.luma_log2_weight_denom ) && 2324 ( delta_chroma_log2_weight_denom == rhs.delta_chroma_log2_weight_denom ) && ( delta_luma_weight_l0 == rhs.delta_luma_weight_l0 ) && 2325 ( luma_offset_l0 == rhs.luma_offset_l0 ) && ( delta_chroma_weight_l0 == rhs.delta_chroma_weight_l0 ) && 2326 ( delta_chroma_offset_l0 == rhs.delta_chroma_offset_l0 ) && ( delta_luma_weight_l1 == rhs.delta_luma_weight_l1 ) && 2327 ( luma_offset_l1 == rhs.luma_offset_l1 ) && ( delta_chroma_weight_l1 == rhs.delta_chroma_weight_l1 ) && 2328 ( delta_chroma_offset_l1 == rhs.delta_chroma_offset_l1 ); 2329 } 2330 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTable2331 bool operator!=( EncodeH265WeightTable const & rhs ) const VULKAN_HPP_NOEXCEPT 2332 { 2333 return !operator==( rhs ); 2334 } 2335 2336 public: 2337 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTableFlags flags = {}; 2338 uint8_t luma_log2_weight_denom = {}; 2339 int8_t delta_chroma_log2_weight_denom = {}; 2340 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF> delta_luma_weight_l0 = {}; 2341 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF> luma_offset_l0 = {}; 2342 VULKAN_HPP_NAMESPACE::ArrayWrapper2D<int8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF, STD_VIDEO_H265_MAX_CHROMA_PLANES> delta_chroma_weight_l0 = {}; 2343 VULKAN_HPP_NAMESPACE::ArrayWrapper2D<int8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF, STD_VIDEO_H265_MAX_CHROMA_PLANES> delta_chroma_offset_l0 = {}; 2344 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF> delta_luma_weight_l1 = {}; 2345 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF> luma_offset_l1 = {}; 2346 VULKAN_HPP_NAMESPACE::ArrayWrapper2D<int8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF, STD_VIDEO_H265_MAX_CHROMA_PLANES> delta_chroma_weight_l1 = {}; 2347 VULKAN_HPP_NAMESPACE::ArrayWrapper2D<int8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF, STD_VIDEO_H265_MAX_CHROMA_PLANES> delta_chroma_offset_l1 = {}; 2348 }; 2349 2350 struct EncodeH265SliceSegmentHeaderFlags 2351 { 2352 using NativeType = StdVideoEncodeH265SliceSegmentHeaderFlags; 2353 operator StdVideoEncodeH265SliceSegmentHeaderFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentHeaderFlags2354 operator StdVideoEncodeH265SliceSegmentHeaderFlags const &() const VULKAN_HPP_NOEXCEPT 2355 { 2356 return *reinterpret_cast<const StdVideoEncodeH265SliceSegmentHeaderFlags *>( this ); 2357 } 2358 operator StdVideoEncodeH265SliceSegmentHeaderFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentHeaderFlags2359 operator StdVideoEncodeH265SliceSegmentHeaderFlags &() VULKAN_HPP_NOEXCEPT 2360 { 2361 return *reinterpret_cast<StdVideoEncodeH265SliceSegmentHeaderFlags *>( this ); 2362 } 2363 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentHeaderFlags2364 bool operator==( EncodeH265SliceSegmentHeaderFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 2365 { 2366 return ( first_slice_segment_in_pic_flag == rhs.first_slice_segment_in_pic_flag ) && 2367 ( dependent_slice_segment_flag == rhs.dependent_slice_segment_flag ) && ( slice_sao_luma_flag == rhs.slice_sao_luma_flag ) && 2368 ( slice_sao_chroma_flag == rhs.slice_sao_chroma_flag ) && ( num_ref_idx_active_override_flag == rhs.num_ref_idx_active_override_flag ) && 2369 ( mvd_l1_zero_flag == rhs.mvd_l1_zero_flag ) && ( cabac_init_flag == rhs.cabac_init_flag ) && 2370 ( cu_chroma_qp_offset_enabled_flag == rhs.cu_chroma_qp_offset_enabled_flag ) && 2371 ( deblocking_filter_override_flag == rhs.deblocking_filter_override_flag ) && 2372 ( slice_deblocking_filter_disabled_flag == rhs.slice_deblocking_filter_disabled_flag ) && 2373 ( collocated_from_l0_flag == rhs.collocated_from_l0_flag ) && 2374 ( slice_loop_filter_across_slices_enabled_flag == rhs.slice_loop_filter_across_slices_enabled_flag ) && ( reserved == rhs.reserved ); 2375 } 2376 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentHeaderFlags2377 bool operator!=( EncodeH265SliceSegmentHeaderFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 2378 { 2379 return !operator==( rhs ); 2380 } 2381 2382 public: 2383 uint32_t first_slice_segment_in_pic_flag : 1; 2384 uint32_t dependent_slice_segment_flag : 1; 2385 uint32_t slice_sao_luma_flag : 1; 2386 uint32_t slice_sao_chroma_flag : 1; 2387 uint32_t num_ref_idx_active_override_flag : 1; 2388 uint32_t mvd_l1_zero_flag : 1; 2389 uint32_t cabac_init_flag : 1; 2390 uint32_t cu_chroma_qp_offset_enabled_flag : 1; 2391 uint32_t deblocking_filter_override_flag : 1; 2392 uint32_t slice_deblocking_filter_disabled_flag : 1; 2393 uint32_t collocated_from_l0_flag : 1; 2394 uint32_t slice_loop_filter_across_slices_enabled_flag : 1; 2395 uint32_t reserved : 20; 2396 }; 2397 2398 struct EncodeH265SliceSegmentHeader 2399 { 2400 using NativeType = StdVideoEncodeH265SliceSegmentHeader; 2401 operator StdVideoEncodeH265SliceSegmentHeader const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentHeader2402 operator StdVideoEncodeH265SliceSegmentHeader const &() const VULKAN_HPP_NOEXCEPT 2403 { 2404 return *reinterpret_cast<const StdVideoEncodeH265SliceSegmentHeader *>( this ); 2405 } 2406 operator StdVideoEncodeH265SliceSegmentHeader&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentHeader2407 operator StdVideoEncodeH265SliceSegmentHeader &() VULKAN_HPP_NOEXCEPT 2408 { 2409 return *reinterpret_cast<StdVideoEncodeH265SliceSegmentHeader *>( this ); 2410 } 2411 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentHeader2412 bool operator==( EncodeH265SliceSegmentHeader const & rhs ) const VULKAN_HPP_NOEXCEPT 2413 { 2414 return ( flags == rhs.flags ) && ( slice_type == rhs.slice_type ) && ( slice_segment_address == rhs.slice_segment_address ) && 2415 ( collocated_ref_idx == rhs.collocated_ref_idx ) && ( MaxNumMergeCand == rhs.MaxNumMergeCand ) && 2416 ( slice_cb_qp_offset == rhs.slice_cb_qp_offset ) && ( slice_cr_qp_offset == rhs.slice_cr_qp_offset ) && 2417 ( slice_beta_offset_div2 == rhs.slice_beta_offset_div2 ) && ( slice_tc_offset_div2 == rhs.slice_tc_offset_div2 ) && 2418 ( slice_act_y_qp_offset == rhs.slice_act_y_qp_offset ) && ( slice_act_cb_qp_offset == rhs.slice_act_cb_qp_offset ) && 2419 ( slice_act_cr_qp_offset == rhs.slice_act_cr_qp_offset ) && ( reserved1 == rhs.reserved1 ) && ( pWeightTable == rhs.pWeightTable ); 2420 } 2421 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentHeader2422 bool operator!=( EncodeH265SliceSegmentHeader const & rhs ) const VULKAN_HPP_NOEXCEPT 2423 { 2424 return !operator==( rhs ); 2425 } 2426 2427 public: 2428 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentHeaderFlags flags = {}; 2429 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SliceType slice_type = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SliceType::eB; 2430 uint32_t slice_segment_address = {}; 2431 uint8_t collocated_ref_idx = {}; 2432 uint8_t MaxNumMergeCand = {}; 2433 int8_t slice_cb_qp_offset = {}; 2434 int8_t slice_cr_qp_offset = {}; 2435 int8_t slice_beta_offset_div2 = {}; 2436 int8_t slice_tc_offset_div2 = {}; 2437 int8_t slice_act_y_qp_offset = {}; 2438 int8_t slice_act_cb_qp_offset = {}; 2439 int8_t slice_act_cr_qp_offset = {}; 2440 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, 3> reserved1 = {}; 2441 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTable * pWeightTable = {}; 2442 }; 2443 2444 struct EncodeH265ReferenceListsInfoFlags 2445 { 2446 using NativeType = StdVideoEncodeH265ReferenceListsInfoFlags; 2447 operator StdVideoEncodeH265ReferenceListsInfoFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfoFlags2448 operator StdVideoEncodeH265ReferenceListsInfoFlags const &() const VULKAN_HPP_NOEXCEPT 2449 { 2450 return *reinterpret_cast<const StdVideoEncodeH265ReferenceListsInfoFlags *>( this ); 2451 } 2452 operator StdVideoEncodeH265ReferenceListsInfoFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfoFlags2453 operator StdVideoEncodeH265ReferenceListsInfoFlags &() VULKAN_HPP_NOEXCEPT 2454 { 2455 return *reinterpret_cast<StdVideoEncodeH265ReferenceListsInfoFlags *>( this ); 2456 } 2457 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfoFlags2458 bool operator==( EncodeH265ReferenceListsInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 2459 { 2460 return ( ref_pic_list_modification_flag_l0 == rhs.ref_pic_list_modification_flag_l0 ) && 2461 ( ref_pic_list_modification_flag_l1 == rhs.ref_pic_list_modification_flag_l1 ) && ( reserved == rhs.reserved ); 2462 } 2463 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfoFlags2464 bool operator!=( EncodeH265ReferenceListsInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 2465 { 2466 return !operator==( rhs ); 2467 } 2468 2469 public: 2470 uint32_t ref_pic_list_modification_flag_l0 : 1; 2471 uint32_t ref_pic_list_modification_flag_l1 : 1; 2472 uint32_t reserved : 30; 2473 }; 2474 2475 struct EncodeH265ReferenceListsInfo 2476 { 2477 using NativeType = StdVideoEncodeH265ReferenceListsInfo; 2478 operator StdVideoEncodeH265ReferenceListsInfo const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfo2479 operator StdVideoEncodeH265ReferenceListsInfo const &() const VULKAN_HPP_NOEXCEPT 2480 { 2481 return *reinterpret_cast<const StdVideoEncodeH265ReferenceListsInfo *>( this ); 2482 } 2483 operator StdVideoEncodeH265ReferenceListsInfo&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfo2484 operator StdVideoEncodeH265ReferenceListsInfo &() VULKAN_HPP_NOEXCEPT 2485 { 2486 return *reinterpret_cast<StdVideoEncodeH265ReferenceListsInfo *>( this ); 2487 } 2488 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfo2489 bool operator==( EncodeH265ReferenceListsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 2490 { 2491 return ( flags == rhs.flags ) && ( num_ref_idx_l0_active_minus1 == rhs.num_ref_idx_l0_active_minus1 ) && 2492 ( num_ref_idx_l1_active_minus1 == rhs.num_ref_idx_l1_active_minus1 ) && ( RefPicList0 == rhs.RefPicList0 ) && 2493 ( RefPicList1 == rhs.RefPicList1 ) && ( list_entry_l0 == rhs.list_entry_l0 ) && ( list_entry_l1 == rhs.list_entry_l1 ); 2494 } 2495 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfo2496 bool operator!=( EncodeH265ReferenceListsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 2497 { 2498 return !operator==( rhs ); 2499 } 2500 2501 public: 2502 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfoFlags flags = {}; 2503 uint8_t num_ref_idx_l0_active_minus1 = {}; 2504 uint8_t num_ref_idx_l1_active_minus1 = {}; 2505 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF> RefPicList0 = {}; 2506 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF> RefPicList1 = {}; 2507 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF> list_entry_l0 = {}; 2508 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF> list_entry_l1 = {}; 2509 }; 2510 2511 struct EncodeH265PictureInfoFlags 2512 { 2513 using NativeType = StdVideoEncodeH265PictureInfoFlags; 2514 operator StdVideoEncodeH265PictureInfoFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265PictureInfoFlags2515 operator StdVideoEncodeH265PictureInfoFlags const &() const VULKAN_HPP_NOEXCEPT 2516 { 2517 return *reinterpret_cast<const StdVideoEncodeH265PictureInfoFlags *>( this ); 2518 } 2519 operator StdVideoEncodeH265PictureInfoFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265PictureInfoFlags2520 operator StdVideoEncodeH265PictureInfoFlags &() VULKAN_HPP_NOEXCEPT 2521 { 2522 return *reinterpret_cast<StdVideoEncodeH265PictureInfoFlags *>( this ); 2523 } 2524 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265PictureInfoFlags2525 bool operator==( EncodeH265PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 2526 { 2527 return ( is_reference == rhs.is_reference ) && ( IrapPicFlag == rhs.IrapPicFlag ) && 2528 ( used_for_long_term_reference == rhs.used_for_long_term_reference ) && ( discardable_flag == rhs.discardable_flag ) && 2529 ( cross_layer_bla_flag == rhs.cross_layer_bla_flag ) && ( pic_output_flag == rhs.pic_output_flag ) && 2530 ( no_output_of_prior_pics_flag == rhs.no_output_of_prior_pics_flag ) && 2531 ( short_term_ref_pic_set_sps_flag == rhs.short_term_ref_pic_set_sps_flag ) && 2532 ( slice_temporal_mvp_enabled_flag == rhs.slice_temporal_mvp_enabled_flag ) && ( reserved == rhs.reserved ); 2533 } 2534 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265PictureInfoFlags2535 bool operator!=( EncodeH265PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 2536 { 2537 return !operator==( rhs ); 2538 } 2539 2540 public: 2541 uint32_t is_reference : 1; 2542 uint32_t IrapPicFlag : 1; 2543 uint32_t used_for_long_term_reference : 1; 2544 uint32_t discardable_flag : 1; 2545 uint32_t cross_layer_bla_flag : 1; 2546 uint32_t pic_output_flag : 1; 2547 uint32_t no_output_of_prior_pics_flag : 1; 2548 uint32_t short_term_ref_pic_set_sps_flag : 1; 2549 uint32_t slice_temporal_mvp_enabled_flag : 1; 2550 uint32_t reserved : 23; 2551 }; 2552 2553 struct EncodeH265SliceSegmentLongTermRefPics 2554 { 2555 using NativeType = StdVideoEncodeH265SliceSegmentLongTermRefPics; 2556 operator StdVideoEncodeH265SliceSegmentLongTermRefPics const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentLongTermRefPics2557 operator StdVideoEncodeH265SliceSegmentLongTermRefPics const &() const VULKAN_HPP_NOEXCEPT 2558 { 2559 return *reinterpret_cast<const StdVideoEncodeH265SliceSegmentLongTermRefPics *>( this ); 2560 } 2561 operator StdVideoEncodeH265SliceSegmentLongTermRefPics&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentLongTermRefPics2562 operator StdVideoEncodeH265SliceSegmentLongTermRefPics &() VULKAN_HPP_NOEXCEPT 2563 { 2564 return *reinterpret_cast<StdVideoEncodeH265SliceSegmentLongTermRefPics *>( this ); 2565 } 2566 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentLongTermRefPics2567 bool operator==( EncodeH265SliceSegmentLongTermRefPics const & rhs ) const VULKAN_HPP_NOEXCEPT 2568 { 2569 return ( num_long_term_sps == rhs.num_long_term_sps ) && ( num_long_term_pics == rhs.num_long_term_pics ) && ( lt_idx_sps == rhs.lt_idx_sps ) && 2570 ( poc_lsb_lt == rhs.poc_lsb_lt ) && ( used_by_curr_pic_lt_flag == rhs.used_by_curr_pic_lt_flag ) && 2571 ( delta_poc_msb_present_flag == rhs.delta_poc_msb_present_flag ) && ( delta_poc_msb_cycle_lt == rhs.delta_poc_msb_cycle_lt ); 2572 } 2573 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentLongTermRefPics2574 bool operator!=( EncodeH265SliceSegmentLongTermRefPics const & rhs ) const VULKAN_HPP_NOEXCEPT 2575 { 2576 return !operator==( rhs ); 2577 } 2578 2579 public: 2580 uint8_t num_long_term_sps = {}; 2581 uint8_t num_long_term_pics = {}; 2582 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS> lt_idx_sps = {}; 2583 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H265_MAX_LONG_TERM_PICS> poc_lsb_lt = {}; 2584 uint16_t used_by_curr_pic_lt_flag = {}; 2585 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H265_MAX_DELTA_POC> delta_poc_msb_present_flag = {}; 2586 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H265_MAX_DELTA_POC> delta_poc_msb_cycle_lt = {}; 2587 }; 2588 2589 struct EncodeH265PictureInfo 2590 { 2591 using NativeType = StdVideoEncodeH265PictureInfo; 2592 operator StdVideoEncodeH265PictureInfo const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265PictureInfo2593 operator StdVideoEncodeH265PictureInfo const &() const VULKAN_HPP_NOEXCEPT 2594 { 2595 return *reinterpret_cast<const StdVideoEncodeH265PictureInfo *>( this ); 2596 } 2597 operator StdVideoEncodeH265PictureInfo&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265PictureInfo2598 operator StdVideoEncodeH265PictureInfo &() VULKAN_HPP_NOEXCEPT 2599 { 2600 return *reinterpret_cast<StdVideoEncodeH265PictureInfo *>( this ); 2601 } 2602 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265PictureInfo2603 bool operator==( EncodeH265PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 2604 { 2605 return ( flags == rhs.flags ) && ( pic_type == rhs.pic_type ) && ( sps_video_parameter_set_id == rhs.sps_video_parameter_set_id ) && 2606 ( pps_seq_parameter_set_id == rhs.pps_seq_parameter_set_id ) && ( pps_pic_parameter_set_id == rhs.pps_pic_parameter_set_id ) && 2607 ( short_term_ref_pic_set_idx == rhs.short_term_ref_pic_set_idx ) && ( PicOrderCntVal == rhs.PicOrderCntVal ) && 2608 ( TemporalId == rhs.TemporalId ) && ( reserved1 == rhs.reserved1 ) && ( pRefLists == rhs.pRefLists ) && 2609 ( pShortTermRefPicSet == rhs.pShortTermRefPicSet ) && ( pLongTermRefPics == rhs.pLongTermRefPics ); 2610 } 2611 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265PictureInfo2612 bool operator!=( EncodeH265PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 2613 { 2614 return !operator==( rhs ); 2615 } 2616 2617 public: 2618 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265PictureInfoFlags flags = {}; 2619 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureType pic_type = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureType::eP; 2620 uint8_t sps_video_parameter_set_id = {}; 2621 uint8_t pps_seq_parameter_set_id = {}; 2622 uint8_t pps_pic_parameter_set_id = {}; 2623 uint8_t short_term_ref_pic_set_idx = {}; 2624 int32_t PicOrderCntVal = {}; 2625 uint8_t TemporalId = {}; 2626 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, 7> reserved1 = {}; 2627 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfo * pRefLists = {}; 2628 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSet * pShortTermRefPicSet = {}; 2629 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentLongTermRefPics * pLongTermRefPics = {}; 2630 }; 2631 2632 struct EncodeH265ReferenceInfoFlags 2633 { 2634 using NativeType = StdVideoEncodeH265ReferenceInfoFlags; 2635 operator StdVideoEncodeH265ReferenceInfoFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceInfoFlags2636 operator StdVideoEncodeH265ReferenceInfoFlags const &() const VULKAN_HPP_NOEXCEPT 2637 { 2638 return *reinterpret_cast<const StdVideoEncodeH265ReferenceInfoFlags *>( this ); 2639 } 2640 operator StdVideoEncodeH265ReferenceInfoFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceInfoFlags2641 operator StdVideoEncodeH265ReferenceInfoFlags &() VULKAN_HPP_NOEXCEPT 2642 { 2643 return *reinterpret_cast<StdVideoEncodeH265ReferenceInfoFlags *>( this ); 2644 } 2645 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceInfoFlags2646 bool operator==( EncodeH265ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 2647 { 2648 return ( used_for_long_term_reference == rhs.used_for_long_term_reference ) && ( unused_for_reference == rhs.unused_for_reference ) && 2649 ( reserved == rhs.reserved ); 2650 } 2651 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceInfoFlags2652 bool operator!=( EncodeH265ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 2653 { 2654 return !operator==( rhs ); 2655 } 2656 2657 public: 2658 uint32_t used_for_long_term_reference : 1; 2659 uint32_t unused_for_reference : 1; 2660 uint32_t reserved : 30; 2661 }; 2662 2663 struct EncodeH265ReferenceInfo 2664 { 2665 using NativeType = StdVideoEncodeH265ReferenceInfo; 2666 operator StdVideoEncodeH265ReferenceInfo const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceInfo2667 operator StdVideoEncodeH265ReferenceInfo const &() const VULKAN_HPP_NOEXCEPT 2668 { 2669 return *reinterpret_cast<const StdVideoEncodeH265ReferenceInfo *>( this ); 2670 } 2671 operator StdVideoEncodeH265ReferenceInfo&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceInfo2672 operator StdVideoEncodeH265ReferenceInfo &() VULKAN_HPP_NOEXCEPT 2673 { 2674 return *reinterpret_cast<StdVideoEncodeH265ReferenceInfo *>( this ); 2675 } 2676 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceInfo2677 bool operator==( EncodeH265ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 2678 { 2679 return ( flags == rhs.flags ) && ( pic_type == rhs.pic_type ) && ( PicOrderCntVal == rhs.PicOrderCntVal ) && ( TemporalId == rhs.TemporalId ); 2680 } 2681 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceInfo2682 bool operator!=( EncodeH265ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 2683 { 2684 return !operator==( rhs ); 2685 } 2686 2687 public: 2688 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceInfoFlags flags = {}; 2689 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureType pic_type = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureType::eP; 2690 int32_t PicOrderCntVal = {}; 2691 uint8_t TemporalId = {}; 2692 }; 2693 2694 } // namespace VULKAN_HPP_VIDEO_NAMESPACE 2695 } // namespace VULKAN_HPP_NAMESPACE 2696 #endif 2697