Mercurial > games > semicongine

comparison fuhtark_test/Vulkan-Headers-1.4.334/include/vulkan/vulkan_video.hpp @ 1501:f40d9d814c08 default tip

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
did: correct vulkan-api generator
author sam <sam@basx.dev>
date Wed, 26 Nov 2025 23:34:29 +0700
parents
children
comparison
equal deleted inserted replaced
1500:91c8c3b7cbf0 1501:f40d9d814c08
1 // Copyright 2021-2025 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 #ifndef VULKAN_VIDEO_HPP
8 #define VULKAN_VIDEO_HPP
9
10 // here, we consider include files to be available when __has_include is not defined
11 #if !defined( __has_include )
12 # define __has_include( x ) true
13 # define has_include_was_not_defined
14 #endif
15
16 // clang-format off
17 #include <vulkan/vulkan.hpp>
18 // clang-format on
19
20 #if __has_include( <vk_video/vulkan_video_codecs_common.h> )
21 # include <vk_video/vulkan_video_codecs_common.h>
22 #endif
23 #if __has_include( <vk_video/vulkan_video_codec_h264std.h> )
24 # include <vk_video/vulkan_video_codec_h264std.h>
25 #endif
26 #if __has_include( <vk_video/vulkan_video_codec_h264std_decode.h> )
27 # include <vk_video/vulkan_video_codec_h264std_decode.h>
28 #endif
29 #if __has_include( <vk_video/vulkan_video_codec_h264std_encode.h> )
30 # include <vk_video/vulkan_video_codec_h264std_encode.h>
31 #endif
32 #if __has_include( <vk_video/vulkan_video_codec_h265std.h> )
33 # include <vk_video/vulkan_video_codec_h265std.h>
34 #endif
35 #if __has_include( <vk_video/vulkan_video_codec_h265std_decode.h> )
36 # include <vk_video/vulkan_video_codec_h265std_decode.h>
37 #endif
38 #if __has_include( <vk_video/vulkan_video_codec_h265std_encode.h> )
39 # include <vk_video/vulkan_video_codec_h265std_encode.h>
40 #endif
41 #if __has_include( <vk_video/vulkan_video_codec_vp9std.h> )
42 # include <vk_video/vulkan_video_codec_vp9std.h>
43 #endif
44 #if __has_include( <vk_video/vulkan_video_codec_vp9std_decode.h> )
45 # include <vk_video/vulkan_video_codec_vp9std_decode.h>
46 #endif
47 #if __has_include( <vk_video/vulkan_video_codec_av1std.h> )
48 # include <vk_video/vulkan_video_codec_av1std.h>
49 #endif
50 #if __has_include( <vk_video/vulkan_video_codec_av1std_decode.h> )
51 # include <vk_video/vulkan_video_codec_av1std_decode.h>
52 #endif
53 #if __has_include( <vk_video/vulkan_video_codec_av1std_encode.h> )
54 # include <vk_video/vulkan_video_codec_av1std_encode.h>
55 #endif
56
57 #if !defined( VULKAN_HPP_VIDEO_NAMESPACE )
58 # define VULKAN_HPP_VIDEO_NAMESPACE video
59 #endif
60
61 namespace VULKAN_HPP_NAMESPACE
62 {
63 namespace VULKAN_HPP_VIDEO_NAMESPACE
64 {
65
66 //=================
67 //=== CONSTANTs ===
68 //=================
69
70 #if defined( VULKAN_VIDEO_CODEC_H264STD_H_ )
71 //=== vulkan_video_codec_h264std ===
72 VULKAN_HPP_CONSTEXPR_INLINE uint32_t H264CpbCntListSize = 32;
73 VULKAN_HPP_CONSTEXPR_INLINE uint32_t H264MaxChromaPlanes = 2;
74 VULKAN_HPP_CONSTEXPR_INLINE uint32_t H264MaxNumListRef = 32;
75 VULKAN_HPP_CONSTEXPR_INLINE uint8_t H264NoReferencePicture = 0xFF;
76 VULKAN_HPP_CONSTEXPR_INLINE uint32_t H264ScalingList4X4NumElements = 16;
77 VULKAN_HPP_CONSTEXPR_INLINE uint32_t H264ScalingList4X4NumLists = 6;
78 VULKAN_HPP_CONSTEXPR_INLINE uint32_t H264ScalingList8X8NumElements = 64;
79 VULKAN_HPP_CONSTEXPR_INLINE uint32_t H264ScalingList8X8NumLists = 6;
80 #endif
81
82 #if defined( VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ )
83 //=== vulkan_video_codec_h264std_decode ===
84 VULKAN_HPP_CONSTEXPR_INLINE uint32_t DecodeH264FieldOrderCountListSize = 2;
85 #endif
86
87 #if defined( VULKAN_VIDEO_CODEC_H265STD_H_ )
88 //=== vulkan_video_codec_h265std ===
89 VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265ChromaQpOffsetListSize = 6;
90 VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265ChromaQpOffsetTileColsListSize = 19;
91 VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265ChromaQpOffsetTileRowsListSize = 21;
92 VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265CpbCntListSize = 32;
93 VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265MaxChromaPlanes = 2;
94 VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265MaxDeltaPoc = 48;
95 VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265MaxDpbSize = 16;
96 VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265MaxLongTermPics = 16;
97 VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265MaxLongTermRefPicsSps = 32;
98 VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265MaxNumListRef = 15;
99 VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265MaxShortTermRefPicSets = 64;
100 VULKAN_HPP_CONSTEXPR_INLINE uint8_t H265NoReferencePicture = 0xFF;
101 VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265PredictorPaletteComponentsListSize = 3;
102 VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265PredictorPaletteCompEntriesListSize = 128;
103 VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265ScalingList16X16NumElements = 64;
104 VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265ScalingList16X16NumLists = 6;
105 VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265ScalingList32X32NumElements = 64;
106 VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265ScalingList32X32NumLists = 2;
107 VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265ScalingList4X4NumElements = 16;
108 VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265ScalingList4X4NumLists = 6;
109 VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265ScalingList8X8NumElements = 64;
110 VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265ScalingList8X8NumLists = 6;
111 VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265SublayersListSize = 7;
112 #endif
113
114 #if defined( VULKAN_VIDEO_CODEC_H265STD_DECODE_H_ )
115 //=== vulkan_video_codec_h265std_decode ===
116 VULKAN_HPP_CONSTEXPR_INLINE uint32_t DecodeH265RefPicSetListSize = 8;
117 #endif
118
119 #if defined( VULKAN_VIDEO_CODEC_VP9STD_H_ )
120 //=== vulkan_video_codec_vp9std ===
121 VULKAN_HPP_CONSTEXPR_INLINE uint32_t Vp9LoopFilterAdjustments = 2;
122 VULKAN_HPP_CONSTEXPR_INLINE uint32_t Vp9MaxRefFrames = 4;
123 VULKAN_HPP_CONSTEXPR_INLINE uint32_t Vp9MaxSegmentationPredProb = 3;
124 VULKAN_HPP_CONSTEXPR_INLINE uint32_t Vp9MaxSegmentationTreeProbs = 7;
125 VULKAN_HPP_CONSTEXPR_INLINE uint32_t Vp9MaxSegments = 8;
126 VULKAN_HPP_CONSTEXPR_INLINE uint32_t Vp9NumRefFrames = 8;
127 VULKAN_HPP_CONSTEXPR_INLINE uint32_t Vp9RefsPerFrame = 3;
128 VULKAN_HPP_CONSTEXPR_INLINE uint32_t Vp9SegLvlMax = 4;
129 #endif
130
131 #if defined( VULKAN_VIDEO_CODEC_AV1STD_H_ )
132 //=== vulkan_video_codec_av1std ===
133 VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1GlobalMotionParams = 6;
134 VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1LoopFilterAdjustments = 2;
135 VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1MaxCdefFilterStrengths = 8;
136 VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1MaxLoopFilterStrengths = 4;
137 VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1MaxNumCbPoints = 10;
138 VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1MaxNumCrPoints = 10;
139 VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1MaxNumPlanes = 3;
140 VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1MaxNumPosChroma = 25;
141 VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1MaxNumPosLuma = 24;
142 VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1MaxNumYPoints = 14;
143 VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1MaxSegments = 8;
144 VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1MaxTileCols = 64;
145 VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1MaxTileRows = 64;
146 VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1NumRefFrames = 8;
147 VULKAN_HPP_CONSTEXPR_INLINE uint8_t Av1PrimaryRefNone = 7;
148 VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1RefsPerFrame = 7;
149 VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1SegLvlMax = 8;
150 VULKAN_HPP_CONSTEXPR_INLINE uint8_t Av1SelectIntegerMv = 2;
151 VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1SelectScreenContentTools = 2;
152 VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1SkipModeFrames = 2;
153 VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1TotalRefsPerFrame = 8;
154 #endif
155
156 //=============
157 //=== ENUMs ===
158 //=============
159
160 #if defined( VULKAN_VIDEO_CODEC_H264STD_H_ )
161 //=== vulkan_video_codec_h264std ===
162
163 enum class H264ChromaFormatIdc
164 {
165 eMonochrome = STD_VIDEO_H264_CHROMA_FORMAT_IDC_MONOCHROME,
166 e420 = STD_VIDEO_H264_CHROMA_FORMAT_IDC_420,
167 e422 = STD_VIDEO_H264_CHROMA_FORMAT_IDC_422,
168 e444 = STD_VIDEO_H264_CHROMA_FORMAT_IDC_444,
169 eInvalid = STD_VIDEO_H264_CHROMA_FORMAT_IDC_INVALID
170 };
171
172 enum class H264ProfileIdc
173 {
174 eBaseline = STD_VIDEO_H264_PROFILE_IDC_BASELINE,
175 eMain = STD_VIDEO_H264_PROFILE_IDC_MAIN,
176 eHigh = STD_VIDEO_H264_PROFILE_IDC_HIGH,
177 eHigh444Predictive = STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE,
178 eInvalid = STD_VIDEO_H264_PROFILE_IDC_INVALID
179 };
180
181 enum class H264LevelIdc
182 {
183 e1_0 = STD_VIDEO_H264_LEVEL_IDC_1_0,
184 e1_1 = STD_VIDEO_H264_LEVEL_IDC_1_1,
185 e1_2 = STD_VIDEO_H264_LEVEL_IDC_1_2,
186 e1_3 = STD_VIDEO_H264_LEVEL_IDC_1_3,
187 e2_0 = STD_VIDEO_H264_LEVEL_IDC_2_0,
188 e2_1 = STD_VIDEO_H264_LEVEL_IDC_2_1,
189 e2_2 = STD_VIDEO_H264_LEVEL_IDC_2_2,
190 e3_0 = STD_VIDEO_H264_LEVEL_IDC_3_0,
191 e3_1 = STD_VIDEO_H264_LEVEL_IDC_3_1,
192 e3_2 = STD_VIDEO_H264_LEVEL_IDC_3_2,
193 e4_0 = STD_VIDEO_H264_LEVEL_IDC_4_0,
194 e4_1 = STD_VIDEO_H264_LEVEL_IDC_4_1,
195 e4_2 = STD_VIDEO_H264_LEVEL_IDC_4_2,
196 e5_0 = STD_VIDEO_H264_LEVEL_IDC_5_0,
197 e5_1 = STD_VIDEO_H264_LEVEL_IDC_5_1,
198 e5_2 = STD_VIDEO_H264_LEVEL_IDC_5_2,
199 e6_0 = STD_VIDEO_H264_LEVEL_IDC_6_0,
200 e6_1 = STD_VIDEO_H264_LEVEL_IDC_6_1,
201 e6_2 = STD_VIDEO_H264_LEVEL_IDC_6_2,
202 eInvalid = STD_VIDEO_H264_LEVEL_IDC_INVALID
203 };
204
205 enum class H264PocType
206 {
207 e0 = STD_VIDEO_H264_POC_TYPE_0,
208 e1 = STD_VIDEO_H264_POC_TYPE_1,
209 e2 = STD_VIDEO_H264_POC_TYPE_2,
210 eInvalid = STD_VIDEO_H264_POC_TYPE_INVALID
211 };
212
213 enum class H264AspectRatioIdc
214 {
215 eUnspecified = STD_VIDEO_H264_ASPECT_RATIO_IDC_UNSPECIFIED,
216 eSquare = STD_VIDEO_H264_ASPECT_RATIO_IDC_SQUARE,
217 e12_11 = STD_VIDEO_H264_ASPECT_RATIO_IDC_12_11,
218 e10_11 = STD_VIDEO_H264_ASPECT_RATIO_IDC_10_11,
219 e16_11 = STD_VIDEO_H264_ASPECT_RATIO_IDC_16_11,
220 e40_33 = STD_VIDEO_H264_ASPECT_RATIO_IDC_40_33,
221 e24_11 = STD_VIDEO_H264_ASPECT_RATIO_IDC_24_11,
222 e20_11 = STD_VIDEO_H264_ASPECT_RATIO_IDC_20_11,
223 e32_11 = STD_VIDEO_H264_ASPECT_RATIO_IDC_32_11,
224 e80_33 = STD_VIDEO_H264_ASPECT_RATIO_IDC_80_33,
225 e18_11 = STD_VIDEO_H264_ASPECT_RATIO_IDC_18_11,
226 e15_11 = STD_VIDEO_H264_ASPECT_RATIO_IDC_15_11,
227 e64_33 = STD_VIDEO_H264_ASPECT_RATIO_IDC_64_33,
228 e160_99 = STD_VIDEO_H264_ASPECT_RATIO_IDC_160_99,
229 e4_3 = STD_VIDEO_H264_ASPECT_RATIO_IDC_4_3,
230 e3_2 = STD_VIDEO_H264_ASPECT_RATIO_IDC_3_2,
231 e2_1 = STD_VIDEO_H264_ASPECT_RATIO_IDC_2_1,
232 eExtendedSar = STD_VIDEO_H264_ASPECT_RATIO_IDC_EXTENDED_SAR,
233 eInvalid = STD_VIDEO_H264_ASPECT_RATIO_IDC_INVALID
234 };
235
236 enum class H264WeightedBipredIdc
237 {
238 eDefault = STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_DEFAULT,
239 eExplicit = STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_EXPLICIT,
240 eImplicit = STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_IMPLICIT,
241 eInvalid = STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_INVALID
242 };
243
244 enum class H264ModificationOfPicNumsIdc
245 {
246 eShortTermSubtract = STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_SUBTRACT,
247 eShortTermAdd = STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_ADD,
248 eLongTerm = STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_LONG_TERM,
249 eEnd = STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_END,
250 eInvalid = STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_INVALID
251 };
252
253 enum class H264MemMgmtControlOp
254 {
255 eEnd = STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_END,
256 eUnmarkShortTerm = STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_SHORT_TERM,
257 eUnmarkLongTerm = STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_LONG_TERM,
258 eMarkLongTerm = STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_LONG_TERM,
259 eSetMaxLongTermIndex = STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_SET_MAX_LONG_TERM_INDEX,
260 eUnmarkAll = STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_ALL,
261 eMarkCurrentAsLongTerm = STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_CURRENT_AS_LONG_TERM,
262 eInvalid = STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_INVALID
263 };
264
265 enum class H264CabacInitIdc
266 {
267 e0 = STD_VIDEO_H264_CABAC_INIT_IDC_0,
268 e1 = STD_VIDEO_H264_CABAC_INIT_IDC_1,
269 e2 = STD_VIDEO_H264_CABAC_INIT_IDC_2,
270 eInvalid = STD_VIDEO_H264_CABAC_INIT_IDC_INVALID
271 };
272
273 enum class H264DisableDeblockingFilterIdc
274 {
275 eDisabled = STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_DISABLED,
276 eEnabled = STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_ENABLED,
277 ePartial = STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_PARTIAL,
278 eInvalid = STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_INVALID
279 };
280
281 enum class H264SliceType
282 {
283 eP = STD_VIDEO_H264_SLICE_TYPE_P,
284 eB = STD_VIDEO_H264_SLICE_TYPE_B,
285 eI = STD_VIDEO_H264_SLICE_TYPE_I,
286 eInvalid = STD_VIDEO_H264_SLICE_TYPE_INVALID
287 };
288
289 enum class H264PictureType
290 {
291 eP = STD_VIDEO_H264_PICTURE_TYPE_P,
292 eB = STD_VIDEO_H264_PICTURE_TYPE_B,
293 eI = STD_VIDEO_H264_PICTURE_TYPE_I,
294 eIdr = STD_VIDEO_H264_PICTURE_TYPE_IDR,
295 eInvalid = STD_VIDEO_H264_PICTURE_TYPE_INVALID
296 };
297
298 enum class H264NonVclNaluType
299 {
300 eSps = STD_VIDEO_H264_NON_VCL_NALU_TYPE_SPS,
301 ePps = STD_VIDEO_H264_NON_VCL_NALU_TYPE_PPS,
302 eAud = STD_VIDEO_H264_NON_VCL_NALU_TYPE_AUD,
303 ePrefix = STD_VIDEO_H264_NON_VCL_NALU_TYPE_PREFIX,
304 eEndOfSequence = STD_VIDEO_H264_NON_VCL_NALU_TYPE_END_OF_SEQUENCE,
305 eEndOfStream = STD_VIDEO_H264_NON_VCL_NALU_TYPE_END_OF_STREAM,
306 ePrecoded = STD_VIDEO_H264_NON_VCL_NALU_TYPE_PRECODED,
307 eInvalid = STD_VIDEO_H264_NON_VCL_NALU_TYPE_INVALID
308 };
309 #endif
310
311 #if defined( VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ )
312 //=== vulkan_video_codec_h264std_decode ===
313
314 enum class DecodeH264FieldOrderCount
315 {
316 eTop = STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_TOP,
317 eBottom = STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_BOTTOM,
318 eInvalid = STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_INVALID
319 };
320 #endif
321
322 #if defined( VULKAN_VIDEO_CODEC_H265STD_H_ )
323 //=== vulkan_video_codec_h265std ===
324
325 enum class H265ChromaFormatIdc
326 {
327 eMonochrome = STD_VIDEO_H265_CHROMA_FORMAT_IDC_MONOCHROME,
328 e420 = STD_VIDEO_H265_CHROMA_FORMAT_IDC_420,
329 e422 = STD_VIDEO_H265_CHROMA_FORMAT_IDC_422,
330 e444 = STD_VIDEO_H265_CHROMA_FORMAT_IDC_444,
331 eInvalid = STD_VIDEO_H265_CHROMA_FORMAT_IDC_INVALID
332 };
333
334 enum class H265ProfileIdc
335 {
336 eMain = STD_VIDEO_H265_PROFILE_IDC_MAIN,
337 eMain10 = STD_VIDEO_H265_PROFILE_IDC_MAIN_10,
338 eMainStillPicture = STD_VIDEO_H265_PROFILE_IDC_MAIN_STILL_PICTURE,
339 eFormatRangeExtensions = STD_VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS,
340 eSccExtensions = STD_VIDEO_H265_PROFILE_IDC_SCC_EXTENSIONS,
341 eInvalid = STD_VIDEO_H265_PROFILE_IDC_INVALID
342 };
343
344 enum class H265LevelIdc
345 {
346 e1_0 = STD_VIDEO_H265_LEVEL_IDC_1_0,
347 e2_0 = STD_VIDEO_H265_LEVEL_IDC_2_0,
348 e2_1 = STD_VIDEO_H265_LEVEL_IDC_2_1,
349 e3_0 = STD_VIDEO_H265_LEVEL_IDC_3_0,
350 e3_1 = STD_VIDEO_H265_LEVEL_IDC_3_1,
351 e4_0 = STD_VIDEO_H265_LEVEL_IDC_4_0,
352 e4_1 = STD_VIDEO_H265_LEVEL_IDC_4_1,
353 e5_0 = STD_VIDEO_H265_LEVEL_IDC_5_0,
354 e5_1 = STD_VIDEO_H265_LEVEL_IDC_5_1,
355 e5_2 = STD_VIDEO_H265_LEVEL_IDC_5_2,
356 e6_0 = STD_VIDEO_H265_LEVEL_IDC_6_0,
357 e6_1 = STD_VIDEO_H265_LEVEL_IDC_6_1,
358 e6_2 = STD_VIDEO_H265_LEVEL_IDC_6_2,
359 eInvalid = STD_VIDEO_H265_LEVEL_IDC_INVALID
360 };
361
362 enum class H265SliceType
363 {
364 eB = STD_VIDEO_H265_SLICE_TYPE_B,
365 eP = STD_VIDEO_H265_SLICE_TYPE_P,
366 eI = STD_VIDEO_H265_SLICE_TYPE_I,
367 eInvalid = STD_VIDEO_H265_SLICE_TYPE_INVALID
368 };
369
370 enum class H265PictureType
371 {
372 eP = STD_VIDEO_H265_PICTURE_TYPE_P,
373 eB = STD_VIDEO_H265_PICTURE_TYPE_B,
374 eI = STD_VIDEO_H265_PICTURE_TYPE_I,
375 eIdr = STD_VIDEO_H265_PICTURE_TYPE_IDR,
376 eInvalid = STD_VIDEO_H265_PICTURE_TYPE_INVALID
377 };
378
379 enum class H265AspectRatioIdc
380 {
381 eUnspecified = STD_VIDEO_H265_ASPECT_RATIO_IDC_UNSPECIFIED,
382 eSquare = STD_VIDEO_H265_ASPECT_RATIO_IDC_SQUARE,
383 e12_11 = STD_VIDEO_H265_ASPECT_RATIO_IDC_12_11,
384 e10_11 = STD_VIDEO_H265_ASPECT_RATIO_IDC_10_11,
385 e16_11 = STD_VIDEO_H265_ASPECT_RATIO_IDC_16_11,
386 e40_33 = STD_VIDEO_H265_ASPECT_RATIO_IDC_40_33,
387 e24_11 = STD_VIDEO_H265_ASPECT_RATIO_IDC_24_11,
388 e20_11 = STD_VIDEO_H265_ASPECT_RATIO_IDC_20_11,
389 e32_11 = STD_VIDEO_H265_ASPECT_RATIO_IDC_32_11,
390 e80_33 = STD_VIDEO_H265_ASPECT_RATIO_IDC_80_33,
391 e18_11 = STD_VIDEO_H265_ASPECT_RATIO_IDC_18_11,
392 e15_11 = STD_VIDEO_H265_ASPECT_RATIO_IDC_15_11,
393 e64_33 = STD_VIDEO_H265_ASPECT_RATIO_IDC_64_33,
394 e160_99 = STD_VIDEO_H265_ASPECT_RATIO_IDC_160_99,
395 e4_3 = STD_VIDEO_H265_ASPECT_RATIO_IDC_4_3,
396 e3_2 = STD_VIDEO_H265_ASPECT_RATIO_IDC_3_2,
397 e2_1 = STD_VIDEO_H265_ASPECT_RATIO_IDC_2_1,
398 eExtendedSar = STD_VIDEO_H265_ASPECT_RATIO_IDC_EXTENDED_SAR,
399 eInvalid = STD_VIDEO_H265_ASPECT_RATIO_IDC_INVALID
400 };
401 #endif
402
403 #if defined( VULKAN_VIDEO_CODEC_VP9STD_H_ )
404 //=== vulkan_video_codec_vp9std ===
405
406 enum class VP9Profile
407 {
408 e0 = STD_VIDEO_VP9_PROFILE_0,
409 e1 = STD_VIDEO_VP9_PROFILE_1,
410 e2 = STD_VIDEO_VP9_PROFILE_2,
411 e3 = STD_VIDEO_VP9_PROFILE_3,
412 eInvalid = STD_VIDEO_VP9_PROFILE_INVALID
413 };
414
415 enum class VP9Level
416 {
417 e1_0 = STD_VIDEO_VP9_LEVEL_1_0,
418 e1_1 = STD_VIDEO_VP9_LEVEL_1_1,
419 e2_0 = STD_VIDEO_VP9_LEVEL_2_0,
420 e2_1 = STD_VIDEO_VP9_LEVEL_2_1,
421 e3_0 = STD_VIDEO_VP9_LEVEL_3_0,
422 e3_1 = STD_VIDEO_VP9_LEVEL_3_1,
423 e4_0 = STD_VIDEO_VP9_LEVEL_4_0,
424 e4_1 = STD_VIDEO_VP9_LEVEL_4_1,
425 e5_0 = STD_VIDEO_VP9_LEVEL_5_0,
426 e5_1 = STD_VIDEO_VP9_LEVEL_5_1,
427 e5_2 = STD_VIDEO_VP9_LEVEL_5_2,
428 e6_0 = STD_VIDEO_VP9_LEVEL_6_0,
429 e6_1 = STD_VIDEO_VP9_LEVEL_6_1,
430 e6_2 = STD_VIDEO_VP9_LEVEL_6_2,
431 eInvalid = STD_VIDEO_VP9_LEVEL_INVALID
432 };
433
434 enum class VP9FrameType
435 {
436 eKey = STD_VIDEO_VP9_FRAME_TYPE_KEY,
437 eNonKey = STD_VIDEO_VP9_FRAME_TYPE_NON_KEY,
438 eInvalid = STD_VIDEO_VP9_FRAME_TYPE_INVALID
439 };
440
441 enum class VP9ReferenceName
442 {
443 eIntraFrame = STD_VIDEO_VP9_REFERENCE_NAME_INTRA_FRAME,
444 eLastFrame = STD_VIDEO_VP9_REFERENCE_NAME_LAST_FRAME,
445 eGoldenFrame = STD_VIDEO_VP9_REFERENCE_NAME_GOLDEN_FRAME,
446 eAltrefFrame = STD_VIDEO_VP9_REFERENCE_NAME_ALTREF_FRAME,
447 eInvalid = STD_VIDEO_VP9_REFERENCE_NAME_INVALID
448 };
449
450 enum class VP9InterpolationFilter
451 {
452 eEighttap = STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP,
453 eEighttapSmooth = STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH,
454 eEighttapSharp = STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP_SHARP,
455 eBilinear = STD_VIDEO_VP9_INTERPOLATION_FILTER_BILINEAR,
456 eSwitchable = STD_VIDEO_VP9_INTERPOLATION_FILTER_SWITCHABLE,
457 eInvalid = STD_VIDEO_VP9_INTERPOLATION_FILTER_INVALID
458 };
459
460 enum class VP9ColorSpace
461 {
462 eUnknown = STD_VIDEO_VP9_COLOR_SPACE_UNKNOWN,
463 eBt601 = STD_VIDEO_VP9_COLOR_SPACE_BT_601,
464 eBt709 = STD_VIDEO_VP9_COLOR_SPACE_BT_709,
465 eSmpte170 = STD_VIDEO_VP9_COLOR_SPACE_SMPTE_170,
466 eSmpte240 = STD_VIDEO_VP9_COLOR_SPACE_SMPTE_240,
467 eBt2020 = STD_VIDEO_VP9_COLOR_SPACE_BT_2020,
468 eReserved = STD_VIDEO_VP9_COLOR_SPACE_RESERVED,
469 eRgb = STD_VIDEO_VP9_COLOR_SPACE_RGB,
470 eInvalid = STD_VIDEO_VP9_COLOR_SPACE_INVALID
471 };
472 #endif
473
474 #if defined( VULKAN_VIDEO_CODEC_AV1STD_H_ )
475 //=== vulkan_video_codec_av1std ===
476
477 enum class AV1Profile
478 {
479 eMain = STD_VIDEO_AV1_PROFILE_MAIN,
480 eHigh = STD_VIDEO_AV1_PROFILE_HIGH,
481 eProfessional = STD_VIDEO_AV1_PROFILE_PROFESSIONAL,
482 eInvalid = STD_VIDEO_AV1_PROFILE_INVALID
483 };
484
485 enum class AV1Level
486 {
487 e2_0 = STD_VIDEO_AV1_LEVEL_2_0,
488 e2_1 = STD_VIDEO_AV1_LEVEL_2_1,
489 e2_2 = STD_VIDEO_AV1_LEVEL_2_2,
490 e2_3 = STD_VIDEO_AV1_LEVEL_2_3,
491 e3_0 = STD_VIDEO_AV1_LEVEL_3_0,
492 e3_1 = STD_VIDEO_AV1_LEVEL_3_1,
493 e3_2 = STD_VIDEO_AV1_LEVEL_3_2,
494 e3_3 = STD_VIDEO_AV1_LEVEL_3_3,
495 e4_0 = STD_VIDEO_AV1_LEVEL_4_0,
496 e4_1 = STD_VIDEO_AV1_LEVEL_4_1,
497 e4_2 = STD_VIDEO_AV1_LEVEL_4_2,
498 e4_3 = STD_VIDEO_AV1_LEVEL_4_3,
499 e5_0 = STD_VIDEO_AV1_LEVEL_5_0,
500 e5_1 = STD_VIDEO_AV1_LEVEL_5_1,
501 e5_2 = STD_VIDEO_AV1_LEVEL_5_2,
502 e5_3 = STD_VIDEO_AV1_LEVEL_5_3,
503 e6_0 = STD_VIDEO_AV1_LEVEL_6_0,
504 e6_1 = STD_VIDEO_AV1_LEVEL_6_1,
505 e6_2 = STD_VIDEO_AV1_LEVEL_6_2,
506 e6_3 = STD_VIDEO_AV1_LEVEL_6_3,
507 e7_0 = STD_VIDEO_AV1_LEVEL_7_0,
508 e7_1 = STD_VIDEO_AV1_LEVEL_7_1,
509 e7_2 = STD_VIDEO_AV1_LEVEL_7_2,
510 e7_3 = STD_VIDEO_AV1_LEVEL_7_3,
511 eInvalid = STD_VIDEO_AV1_LEVEL_INVALID
512 };
513
514 enum class AV1FrameType
515 {
516 eKey = STD_VIDEO_AV1_FRAME_TYPE_KEY,
517 eInter = STD_VIDEO_AV1_FRAME_TYPE_INTER,
518 eIntraOnly = STD_VIDEO_AV1_FRAME_TYPE_INTRA_ONLY,
519 eSwitch = STD_VIDEO_AV1_FRAME_TYPE_SWITCH,
520 eInvalid = STD_VIDEO_AV1_FRAME_TYPE_INVALID
521 };
522
523 enum class AV1ReferenceName
524 {
525 eIntraFrame = STD_VIDEO_AV1_REFERENCE_NAME_INTRA_FRAME,
526 eLastFrame = STD_VIDEO_AV1_REFERENCE_NAME_LAST_FRAME,
527 eLast2Frame = STD_VIDEO_AV1_REFERENCE_NAME_LAST2_FRAME,
528 eLast3Frame = STD_VIDEO_AV1_REFERENCE_NAME_LAST3_FRAME,
529 eGoldenFrame = STD_VIDEO_AV1_REFERENCE_NAME_GOLDEN_FRAME,
530 eBwdrefFrame = STD_VIDEO_AV1_REFERENCE_NAME_BWDREF_FRAME,
531 eAltref2Frame = STD_VIDEO_AV1_REFERENCE_NAME_ALTREF2_FRAME,
532 eAltrefFrame = STD_VIDEO_AV1_REFERENCE_NAME_ALTREF_FRAME,
533 eInvalid = STD_VIDEO_AV1_REFERENCE_NAME_INVALID
534 };
535
536 enum class AV1InterpolationFilter
537 {
538 eEighttap = STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP,
539 eEighttapSmooth = STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH,
540 eEighttapSharp = STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP_SHARP,
541 eBilinear = STD_VIDEO_AV1_INTERPOLATION_FILTER_BILINEAR,
542 eSwitchable = STD_VIDEO_AV1_INTERPOLATION_FILTER_SWITCHABLE,
543 eInvalid = STD_VIDEO_AV1_INTERPOLATION_FILTER_INVALID
544 };
545
546 enum class AV1TxMode
547 {
548 eOnly4X4 = STD_VIDEO_AV1_TX_MODE_ONLY_4X4,
549 eLargest = STD_VIDEO_AV1_TX_MODE_LARGEST,
550 eSelect = STD_VIDEO_AV1_TX_MODE_SELECT,
551 eInvalid = STD_VIDEO_AV1_TX_MODE_INVALID
552 };
553
554 enum class AV1FrameRestorationType
555 {
556 eNone = STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_NONE,
557 eWiener = STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_WIENER,
558 eSgrproj = STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_SGRPROJ,
559 eSwitchable = STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_SWITCHABLE,
560 eInvalid = STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_INVALID
561 };
562
563 enum class AV1ColorPrimaries
564 {
565 eBt709 = STD_VIDEO_AV1_COLOR_PRIMARIES_BT_709,
566 eUnspecified = STD_VIDEO_AV1_COLOR_PRIMARIES_UNSPECIFIED,
567 eBtUnspecified VULKAN_HPP_DEPRECATED_17( "eBtUnspecified is deprecated, eUnspecified should be used instead." ) =
568 STD_VIDEO_AV1_COLOR_PRIMARIES_BT_UNSPECIFIED,
569 eBt470M = STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_M,
570 eBt470BG = STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_B_G,
571 eBt601 = STD_VIDEO_AV1_COLOR_PRIMARIES_BT_601,
572 eSmpte240 = STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_240,
573 eGenericFilm = STD_VIDEO_AV1_COLOR_PRIMARIES_GENERIC_FILM,
574 eBt2020 = STD_VIDEO_AV1_COLOR_PRIMARIES_BT_2020,
575 eXyz = STD_VIDEO_AV1_COLOR_PRIMARIES_XYZ,
576 eSmpte431 = STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_431,
577 eSmpte432 = STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_432,
578 eEbu3213 = STD_VIDEO_AV1_COLOR_PRIMARIES_EBU_3213,
579 eInvalid = STD_VIDEO_AV1_COLOR_PRIMARIES_INVALID
580 };
581
582 enum class AV1TransferCharacteristics
583 {
584 eReserved0 = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_RESERVED_0,
585 eBt709 = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_709,
586 eUnspecified = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_UNSPECIFIED,
587 eReserved3 = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_RESERVED_3,
588 eBt470M = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_470_M,
589 eBt470BG = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_470_B_G,
590 eBt601 = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_601,
591 eSmpte240 = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_240,
592 eLinear = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LINEAR,
593 eLog100 = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LOG_100,
594 eLog100Sqrt10 = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LOG_100_SQRT10,
595 eIec61966 = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_IEC_61966,
596 eBt1361 = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_1361,
597 eSrgb = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SRGB,
598 eBt2020_10Bit = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_2020_10_BIT,
599 eBt2020_12Bit = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_2020_12_BIT,
600 eSmpte2084 = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_2084,
601 eSmpte428 = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_428,
602 eHlg = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_HLG,
603 eInvalid = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_INVALID
604 };
605
606 enum class AV1MatrixCoefficients
607 {
608 eIdentity = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_IDENTITY,
609 eBt709 = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_709,
610 eUnspecified = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_UNSPECIFIED,
611 eReserved3 = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_RESERVED_3,
612 eFcc = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_FCC,
613 eBt470BG = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_470_B_G,
614 eBt601 = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_601,
615 eSmpte240 = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_240,
616 eSmpteYcgco = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_YCGCO,
617 eBt2020Ncl = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_2020_NCL,
618 eBt2020Cl = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_2020_CL,
619 eSmpte2085 = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_2085,
620 eChromatNcl = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_CHROMAT_NCL,
621 eChromatCl = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_CHROMAT_CL,
622 eIctcp = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_ICTCP,
623 eInvalid = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_INVALID
624 };
625
626 enum class AV1ChromaSamplePosition
627 {
628 eUnknown = STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_UNKNOWN,
629 eVertical = STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_VERTICAL,
630 eColocated = STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_COLOCATED,
631 eReserved = STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_RESERVED,
632 eInvalid = STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_INVALID
633 };
634 #endif
635
636 //===============
637 //=== STRUCTS ===
638 //===============
639
640 #if defined( VULKAN_VIDEO_CODEC_H264STD_H_ )
641 //=== vulkan_video_codec_h264std ===
642
643 struct H264SpsVuiFlags
644 {
645 using NativeType = StdVideoH264SpsVuiFlags;
646
647 operator StdVideoH264SpsVuiFlags const &() const VULKAN_HPP_NOEXCEPT
648 {
649 return *reinterpret_cast<const StdVideoH264SpsVuiFlags *>( this );
650 }
651
652 operator StdVideoH264SpsVuiFlags &() VULKAN_HPP_NOEXCEPT
653 {
654 return *reinterpret_cast<StdVideoH264SpsVuiFlags *>( this );
655 }
656
657 operator StdVideoH264SpsVuiFlags const *() const VULKAN_HPP_NOEXCEPT
658 {
659 return reinterpret_cast<const StdVideoH264SpsVuiFlags *>( this );
660 }
661
662 operator StdVideoH264SpsVuiFlags *() VULKAN_HPP_NOEXCEPT
663 {
664 return reinterpret_cast<StdVideoH264SpsVuiFlags *>( this );
665 }
666
667 bool operator==( H264SpsVuiFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
668 {
669 return ( aspect_ratio_info_present_flag == rhs.aspect_ratio_info_present_flag ) && ( overscan_info_present_flag == rhs.overscan_info_present_flag ) &&
670 ( overscan_appropriate_flag == rhs.overscan_appropriate_flag ) && ( video_signal_type_present_flag == rhs.video_signal_type_present_flag ) &&
671 ( video_full_range_flag == rhs.video_full_range_flag ) && ( color_description_present_flag == rhs.color_description_present_flag ) &&
672 ( chroma_loc_info_present_flag == rhs.chroma_loc_info_present_flag ) && ( timing_info_present_flag == rhs.timing_info_present_flag ) &&
673 ( fixed_frame_rate_flag == rhs.fixed_frame_rate_flag ) && ( bitstream_restriction_flag == rhs.bitstream_restriction_flag ) &&
674 ( nal_hrd_parameters_present_flag == rhs.nal_hrd_parameters_present_flag ) &&
675 ( vcl_hrd_parameters_present_flag == rhs.vcl_hrd_parameters_present_flag );
676 }
677
678 bool operator!=( H264SpsVuiFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
679 {
680 return !operator==( rhs );
681 }
682
683 public:
684 uint32_t aspect_ratio_info_present_flag : 1;
685 uint32_t overscan_info_present_flag : 1;
686 uint32_t overscan_appropriate_flag : 1;
687 uint32_t video_signal_type_present_flag : 1;
688 uint32_t video_full_range_flag : 1;
689 uint32_t color_description_present_flag : 1;
690 uint32_t chroma_loc_info_present_flag : 1;
691 uint32_t timing_info_present_flag : 1;
692 uint32_t fixed_frame_rate_flag : 1;
693 uint32_t bitstream_restriction_flag : 1;
694 uint32_t nal_hrd_parameters_present_flag : 1;
695 uint32_t vcl_hrd_parameters_present_flag : 1;
696 };
697
698 struct H264HrdParameters
699 {
700 using NativeType = StdVideoH264HrdParameters;
701
702 operator StdVideoH264HrdParameters const &() const VULKAN_HPP_NOEXCEPT
703 {
704 return *reinterpret_cast<const StdVideoH264HrdParameters *>( this );
705 }
706
707 operator StdVideoH264HrdParameters &() VULKAN_HPP_NOEXCEPT
708 {
709 return *reinterpret_cast<StdVideoH264HrdParameters *>( this );
710 }
711
712 operator StdVideoH264HrdParameters const *() const VULKAN_HPP_NOEXCEPT
713 {
714 return reinterpret_cast<const StdVideoH264HrdParameters *>( this );
715 }
716
717 operator StdVideoH264HrdParameters *() VULKAN_HPP_NOEXCEPT
718 {
719 return reinterpret_cast<StdVideoH264HrdParameters *>( this );
720 }
721
722 bool operator==( H264HrdParameters const & rhs ) const VULKAN_HPP_NOEXCEPT
723 {
724 return ( cpb_cnt_minus1 == rhs.cpb_cnt_minus1 ) && ( bit_rate_scale == rhs.bit_rate_scale ) && ( cpb_size_scale == rhs.cpb_size_scale ) &&
725 ( reserved1 == rhs.reserved1 ) && ( bit_rate_value_minus1 == rhs.bit_rate_value_minus1 ) &&
726 ( cpb_size_value_minus1 == rhs.cpb_size_value_minus1 ) && ( cbr_flag == rhs.cbr_flag ) &&
727 ( initial_cpb_removal_delay_length_minus1 == rhs.initial_cpb_removal_delay_length_minus1 ) &&
728 ( cpb_removal_delay_length_minus1 == rhs.cpb_removal_delay_length_minus1 ) &&
729 ( dpb_output_delay_length_minus1 == rhs.dpb_output_delay_length_minus1 ) && ( time_offset_length == rhs.time_offset_length );
730 }
731
732 bool operator!=( H264HrdParameters const & rhs ) const VULKAN_HPP_NOEXCEPT
733 {
734 return !operator==( rhs );
735 }
736
737 public:
738 uint8_t cpb_cnt_minus1 = {};
739 uint8_t bit_rate_scale = {};
740 uint8_t cpb_size_scale = {};
741 uint8_t reserved1 = {};
742 ArrayWrapper1D<uint32_t, STD_VIDEO_H264_CPB_CNT_LIST_SIZE> bit_rate_value_minus1 = {};
743 ArrayWrapper1D<uint32_t, STD_VIDEO_H264_CPB_CNT_LIST_SIZE> cpb_size_value_minus1 = {};
744 ArrayWrapper1D<uint8_t, STD_VIDEO_H264_CPB_CNT_LIST_SIZE> cbr_flag = {};
745 uint32_t initial_cpb_removal_delay_length_minus1 = {};
746 uint32_t cpb_removal_delay_length_minus1 = {};
747 uint32_t dpb_output_delay_length_minus1 = {};
748 uint32_t time_offset_length = {};
749 };
750
751 struct H264SequenceParameterSetVui
752 {
753 using NativeType = StdVideoH264SequenceParameterSetVui;
754
755 operator StdVideoH264SequenceParameterSetVui const &() const VULKAN_HPP_NOEXCEPT
756 {
757 return *reinterpret_cast<const StdVideoH264SequenceParameterSetVui *>( this );
758 }
759
760 operator StdVideoH264SequenceParameterSetVui &() VULKAN_HPP_NOEXCEPT
761 {
762 return *reinterpret_cast<StdVideoH264SequenceParameterSetVui *>( this );
763 }
764
765 operator StdVideoH264SequenceParameterSetVui const *() const VULKAN_HPP_NOEXCEPT
766 {
767 return reinterpret_cast<const StdVideoH264SequenceParameterSetVui *>( this );
768 }
769
770 operator StdVideoH264SequenceParameterSetVui *() VULKAN_HPP_NOEXCEPT
771 {
772 return reinterpret_cast<StdVideoH264SequenceParameterSetVui *>( this );
773 }
774
775 bool operator==( H264SequenceParameterSetVui const & rhs ) const VULKAN_HPP_NOEXCEPT
776 {
777 return ( flags == rhs.flags ) && ( aspect_ratio_idc == rhs.aspect_ratio_idc ) && ( sar_width == rhs.sar_width ) && ( sar_height == rhs.sar_height ) &&
778 ( video_format == rhs.video_format ) && ( colour_primaries == rhs.colour_primaries ) &&
779 ( transfer_characteristics == rhs.transfer_characteristics ) && ( matrix_coefficients == rhs.matrix_coefficients ) &&
780 ( num_units_in_tick == rhs.num_units_in_tick ) && ( time_scale == rhs.time_scale ) && ( max_num_reorder_frames == rhs.max_num_reorder_frames ) &&
781 ( max_dec_frame_buffering == rhs.max_dec_frame_buffering ) && ( chroma_sample_loc_type_top_field == rhs.chroma_sample_loc_type_top_field ) &&
782 ( chroma_sample_loc_type_bottom_field == rhs.chroma_sample_loc_type_bottom_field ) && ( reserved1 == rhs.reserved1 ) &&
783 ( pHrdParameters == rhs.pHrdParameters );
784 }
785
786 bool operator!=( H264SequenceParameterSetVui const & rhs ) const VULKAN_HPP_NOEXCEPT
787 {
788 return !operator==( rhs );
789 }
790
791 public:
792 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SpsVuiFlags flags = {};
793 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264AspectRatioIdc aspect_ratio_idc =
794 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264AspectRatioIdc::eUnspecified;
795 uint16_t sar_width = {};
796 uint16_t sar_height = {};
797 uint8_t video_format = {};
798 uint8_t colour_primaries = {};
799 uint8_t transfer_characteristics = {};
800 uint8_t matrix_coefficients = {};
801 uint32_t num_units_in_tick = {};
802 uint32_t time_scale = {};
803 uint8_t max_num_reorder_frames = {};
804 uint8_t max_dec_frame_buffering = {};
805 uint8_t chroma_sample_loc_type_top_field = {};
806 uint8_t chroma_sample_loc_type_bottom_field = {};
807 uint32_t reserved1 = {};
808 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264HrdParameters * pHrdParameters = {};
809 };
810
811 struct H264SpsFlags
812 {
813 using NativeType = StdVideoH264SpsFlags;
814
815 operator StdVideoH264SpsFlags const &() const VULKAN_HPP_NOEXCEPT
816 {
817 return *reinterpret_cast<const StdVideoH264SpsFlags *>( this );
818 }
819
820 operator StdVideoH264SpsFlags &() VULKAN_HPP_NOEXCEPT
821 {
822 return *reinterpret_cast<StdVideoH264SpsFlags *>( this );
823 }
824
825 operator StdVideoH264SpsFlags const *() const VULKAN_HPP_NOEXCEPT
826 {
827 return reinterpret_cast<const StdVideoH264SpsFlags *>( this );
828 }
829
830 operator StdVideoH264SpsFlags *() VULKAN_HPP_NOEXCEPT
831 {
832 return reinterpret_cast<StdVideoH264SpsFlags *>( this );
833 }
834
835 bool operator==( H264SpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
836 {
837 return ( constraint_set0_flag == rhs.constraint_set0_flag ) && ( constraint_set1_flag == rhs.constraint_set1_flag ) &&
838 ( constraint_set2_flag == rhs.constraint_set2_flag ) && ( constraint_set3_flag == rhs.constraint_set3_flag ) &&
839 ( constraint_set4_flag == rhs.constraint_set4_flag ) && ( constraint_set5_flag == rhs.constraint_set5_flag ) &&
840 ( direct_8x8_inference_flag == rhs.direct_8x8_inference_flag ) && ( mb_adaptive_frame_field_flag == rhs.mb_adaptive_frame_field_flag ) &&
841 ( frame_mbs_only_flag == rhs.frame_mbs_only_flag ) && ( delta_pic_order_always_zero_flag == rhs.delta_pic_order_always_zero_flag ) &&
842 ( separate_colour_plane_flag == rhs.separate_colour_plane_flag ) &&
843 ( gaps_in_frame_num_value_allowed_flag == rhs.gaps_in_frame_num_value_allowed_flag ) &&
844 ( qpprime_y_zero_transform_bypass_flag == rhs.qpprime_y_zero_transform_bypass_flag ) && ( frame_cropping_flag == rhs.frame_cropping_flag ) &&
845 ( seq_scaling_matrix_present_flag == rhs.seq_scaling_matrix_present_flag ) && ( vui_parameters_present_flag == rhs.vui_parameters_present_flag );
846 }
847
848 bool operator!=( H264SpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
849 {
850 return !operator==( rhs );
851 }
852
853 public:
854 uint32_t constraint_set0_flag : 1;
855 uint32_t constraint_set1_flag : 1;
856 uint32_t constraint_set2_flag : 1;
857 uint32_t constraint_set3_flag : 1;
858 uint32_t constraint_set4_flag : 1;
859 uint32_t constraint_set5_flag : 1;
860 uint32_t direct_8x8_inference_flag : 1;
861 uint32_t mb_adaptive_frame_field_flag : 1;
862 uint32_t frame_mbs_only_flag : 1;
863 uint32_t delta_pic_order_always_zero_flag : 1;
864 uint32_t separate_colour_plane_flag : 1;
865 uint32_t gaps_in_frame_num_value_allowed_flag : 1;
866 uint32_t qpprime_y_zero_transform_bypass_flag : 1;
867 uint32_t frame_cropping_flag : 1;
868 uint32_t seq_scaling_matrix_present_flag : 1;
869 uint32_t vui_parameters_present_flag : 1;
870 };
871
872 struct H264ScalingLists
873 {
874 using NativeType = StdVideoH264ScalingLists;
875
876 operator StdVideoH264ScalingLists const &() const VULKAN_HPP_NOEXCEPT
877 {
878 return *reinterpret_cast<const StdVideoH264ScalingLists *>( this );
879 }
880
881 operator StdVideoH264ScalingLists &() VULKAN_HPP_NOEXCEPT
882 {
883 return *reinterpret_cast<StdVideoH264ScalingLists *>( this );
884 }
885
886 operator StdVideoH264ScalingLists const *() const VULKAN_HPP_NOEXCEPT
887 {
888 return reinterpret_cast<const StdVideoH264ScalingLists *>( this );
889 }
890
891 operator StdVideoH264ScalingLists *() VULKAN_HPP_NOEXCEPT
892 {
893 return reinterpret_cast<StdVideoH264ScalingLists *>( this );
894 }
895
896 bool operator==( H264ScalingLists const & rhs ) const VULKAN_HPP_NOEXCEPT
897 {
898 return ( scaling_list_present_mask == rhs.scaling_list_present_mask ) && ( use_default_scaling_matrix_mask == rhs.use_default_scaling_matrix_mask ) &&
899 ( ScalingList4x4 == rhs.ScalingList4x4 ) && ( ScalingList8x8 == rhs.ScalingList8x8 );
900 }
901
902 bool operator!=( H264ScalingLists const & rhs ) const VULKAN_HPP_NOEXCEPT
903 {
904 return !operator==( rhs );
905 }
906
907 public:
908 uint16_t scaling_list_present_mask = {};
909 uint16_t use_default_scaling_matrix_mask = {};
910 ArrayWrapper2D<uint8_t, STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS, STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS> ScalingList4x4 = {};
911 ArrayWrapper2D<uint8_t, STD_VIDEO_H264_SCALING_LIST_8X8_NUM_LISTS, STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS> ScalingList8x8 = {};
912 };
913
914 struct H264SequenceParameterSet
915 {
916 using NativeType = StdVideoH264SequenceParameterSet;
917
918 operator StdVideoH264SequenceParameterSet const &() const VULKAN_HPP_NOEXCEPT
919 {
920 return *reinterpret_cast<const StdVideoH264SequenceParameterSet *>( this );
921 }
922
923 operator StdVideoH264SequenceParameterSet &() VULKAN_HPP_NOEXCEPT
924 {
925 return *reinterpret_cast<StdVideoH264SequenceParameterSet *>( this );
926 }
927
928 operator StdVideoH264SequenceParameterSet const *() const VULKAN_HPP_NOEXCEPT
929 {
930 return reinterpret_cast<const StdVideoH264SequenceParameterSet *>( this );
931 }
932
933 operator StdVideoH264SequenceParameterSet *() VULKAN_HPP_NOEXCEPT
934 {
935 return reinterpret_cast<StdVideoH264SequenceParameterSet *>( this );
936 }
937
938 bool operator==( H264SequenceParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT
939 {
940 return ( flags == rhs.flags ) && ( profile_idc == rhs.profile_idc ) && ( level_idc == rhs.level_idc ) &&
941 ( chroma_format_idc == rhs.chroma_format_idc ) && ( seq_parameter_set_id == rhs.seq_parameter_set_id ) &&
942 ( bit_depth_luma_minus8 == rhs.bit_depth_luma_minus8 ) && ( bit_depth_chroma_minus8 == rhs.bit_depth_chroma_minus8 ) &&
943 ( log2_max_frame_num_minus4 == rhs.log2_max_frame_num_minus4 ) && ( pic_order_cnt_type == rhs.pic_order_cnt_type ) &&
944 ( offset_for_non_ref_pic == rhs.offset_for_non_ref_pic ) && ( offset_for_top_to_bottom_field == rhs.offset_for_top_to_bottom_field ) &&
945 ( log2_max_pic_order_cnt_lsb_minus4 == rhs.log2_max_pic_order_cnt_lsb_minus4 ) &&
946 ( 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 ) &&
947 ( reserved1 == rhs.reserved1 ) && ( pic_width_in_mbs_minus1 == rhs.pic_width_in_mbs_minus1 ) &&
948 ( pic_height_in_map_units_minus1 == rhs.pic_height_in_map_units_minus1 ) && ( frame_crop_left_offset == rhs.frame_crop_left_offset ) &&
949 ( frame_crop_right_offset == rhs.frame_crop_right_offset ) && ( frame_crop_top_offset == rhs.frame_crop_top_offset ) &&
950 ( frame_crop_bottom_offset == rhs.frame_crop_bottom_offset ) && ( reserved2 == rhs.reserved2 ) &&
951 ( pOffsetForRefFrame == rhs.pOffsetForRefFrame ) && ( pScalingLists == rhs.pScalingLists ) &&
952 ( pSequenceParameterSetVui == rhs.pSequenceParameterSetVui );
953 }
954
955 bool operator!=( H264SequenceParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT
956 {
957 return !operator==( rhs );
958 }
959
960 public:
961 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SpsFlags flags = {};
962 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ProfileIdc profile_idc =
963 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ProfileIdc::eBaseline;
964 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264LevelIdc level_idc = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264LevelIdc::e1_0;
965 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ChromaFormatIdc chroma_format_idc =
966 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ChromaFormatIdc::eMonochrome;
967 uint8_t seq_parameter_set_id = {};
968 uint8_t bit_depth_luma_minus8 = {};
969 uint8_t bit_depth_chroma_minus8 = {};
970 uint8_t log2_max_frame_num_minus4 = {};
971 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PocType pic_order_cnt_type = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PocType::e0;
972 int32_t offset_for_non_ref_pic = {};
973 int32_t offset_for_top_to_bottom_field = {};
974 uint8_t log2_max_pic_order_cnt_lsb_minus4 = {};
975 uint8_t num_ref_frames_in_pic_order_cnt_cycle = {};
976 uint8_t max_num_ref_frames = {};
977 uint8_t reserved1 = {};
978 uint32_t pic_width_in_mbs_minus1 = {};
979 uint32_t pic_height_in_map_units_minus1 = {};
980 uint32_t frame_crop_left_offset = {};
981 uint32_t frame_crop_right_offset = {};
982 uint32_t frame_crop_top_offset = {};
983 uint32_t frame_crop_bottom_offset = {};
984 uint32_t reserved2 = {};
985 const int32_t * pOffsetForRefFrame = {};
986 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingLists * pScalingLists = {};
987 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SequenceParameterSetVui * pSequenceParameterSetVui = {};
988 };
989
990 struct H264PpsFlags
991 {
992 using NativeType = StdVideoH264PpsFlags;
993
994 operator StdVideoH264PpsFlags const &() const VULKAN_HPP_NOEXCEPT
995 {
996 return *reinterpret_cast<const StdVideoH264PpsFlags *>( this );
997 }
998
999 operator StdVideoH264PpsFlags &() VULKAN_HPP_NOEXCEPT
1000 {
1001 return *reinterpret_cast<StdVideoH264PpsFlags *>( this );
1002 }
1003
1004 operator StdVideoH264PpsFlags const *() const VULKAN_HPP_NOEXCEPT
1005 {
1006 return reinterpret_cast<const StdVideoH264PpsFlags *>( this );
1007 }
1008
1009 operator StdVideoH264PpsFlags *() VULKAN_HPP_NOEXCEPT
1010 {
1011 return reinterpret_cast<StdVideoH264PpsFlags *>( this );
1012 }
1013
1014 bool operator==( H264PpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
1015 {
1016 return ( transform_8x8_mode_flag == rhs.transform_8x8_mode_flag ) && ( redundant_pic_cnt_present_flag == rhs.redundant_pic_cnt_present_flag ) &&
1017 ( constrained_intra_pred_flag == rhs.constrained_intra_pred_flag ) &&
1018 ( deblocking_filter_control_present_flag == rhs.deblocking_filter_control_present_flag ) && ( weighted_pred_flag == rhs.weighted_pred_flag ) &&
1019 ( bottom_field_pic_order_in_frame_present_flag == rhs.bottom_field_pic_order_in_frame_present_flag ) &&
1020 ( entropy_coding_mode_flag == rhs.entropy_coding_mode_flag ) && ( pic_scaling_matrix_present_flag == rhs.pic_scaling_matrix_present_flag );
1021 }
1022
1023 bool operator!=( H264PpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
1024 {
1025 return !operator==( rhs );
1026 }
1027
1028 public:
1029 uint32_t transform_8x8_mode_flag : 1;
1030 uint32_t redundant_pic_cnt_present_flag : 1;
1031 uint32_t constrained_intra_pred_flag : 1;
1032 uint32_t deblocking_filter_control_present_flag : 1;
1033 uint32_t weighted_pred_flag : 1;
1034 uint32_t bottom_field_pic_order_in_frame_present_flag : 1;
1035 uint32_t entropy_coding_mode_flag : 1;
1036 uint32_t pic_scaling_matrix_present_flag : 1;
1037 };
1038
1039 struct H264PictureParameterSet
1040 {
1041 using NativeType = StdVideoH264PictureParameterSet;
1042
1043 operator StdVideoH264PictureParameterSet const &() const VULKAN_HPP_NOEXCEPT
1044 {
1045 return *reinterpret_cast<const StdVideoH264PictureParameterSet *>( this );
1046 }
1047
1048 operator StdVideoH264PictureParameterSet &() VULKAN_HPP_NOEXCEPT
1049 {
1050 return *reinterpret_cast<StdVideoH264PictureParameterSet *>( this );
1051 }
1052
1053 operator StdVideoH264PictureParameterSet const *() const VULKAN_HPP_NOEXCEPT
1054 {
1055 return reinterpret_cast<const StdVideoH264PictureParameterSet *>( this );
1056 }
1057
1058 operator StdVideoH264PictureParameterSet *() VULKAN_HPP_NOEXCEPT
1059 {
1060 return reinterpret_cast<StdVideoH264PictureParameterSet *>( this );
1061 }
1062
1063 bool operator==( H264PictureParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT
1064 {
1065 return ( flags == rhs.flags ) && ( seq_parameter_set_id == rhs.seq_parameter_set_id ) && ( pic_parameter_set_id == rhs.pic_parameter_set_id ) &&
1066 ( num_ref_idx_l0_default_active_minus1 == rhs.num_ref_idx_l0_default_active_minus1 ) &&
1067 ( num_ref_idx_l1_default_active_minus1 == rhs.num_ref_idx_l1_default_active_minus1 ) && ( weighted_bipred_idc == rhs.weighted_bipred_idc ) &&
1068 ( pic_init_qp_minus26 == rhs.pic_init_qp_minus26 ) && ( pic_init_qs_minus26 == rhs.pic_init_qs_minus26 ) &&
1069 ( chroma_qp_index_offset == rhs.chroma_qp_index_offset ) && ( second_chroma_qp_index_offset == rhs.second_chroma_qp_index_offset ) &&
1070 ( pScalingLists == rhs.pScalingLists );
1071 }
1072
1073 bool operator!=( H264PictureParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT
1074 {
1075 return !operator==( rhs );
1076 }
1077
1078 public:
1079 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PpsFlags flags = {};
1080 uint8_t seq_parameter_set_id = {};
1081 uint8_t pic_parameter_set_id = {};
1082 uint8_t num_ref_idx_l0_default_active_minus1 = {};
1083 uint8_t num_ref_idx_l1_default_active_minus1 = {};
1084 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264WeightedBipredIdc weighted_bipred_idc =
1085 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264WeightedBipredIdc::eDefault;
1086 int8_t pic_init_qp_minus26 = {};
1087 int8_t pic_init_qs_minus26 = {};
1088 int8_t chroma_qp_index_offset = {};
1089 int8_t second_chroma_qp_index_offset = {};
1090 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingLists * pScalingLists = {};
1091 };
1092 #endif
1093
1094 #if defined( VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ )
1095 //=== vulkan_video_codec_h264std_decode ===
1096
1097 struct DecodeH264PictureInfoFlags
1098 {
1099 using NativeType = StdVideoDecodeH264PictureInfoFlags;
1100
1101 operator StdVideoDecodeH264PictureInfoFlags const &() const VULKAN_HPP_NOEXCEPT
1102 {
1103 return *reinterpret_cast<const StdVideoDecodeH264PictureInfoFlags *>( this );
1104 }
1105
1106 operator StdVideoDecodeH264PictureInfoFlags &() VULKAN_HPP_NOEXCEPT
1107 {
1108 return *reinterpret_cast<StdVideoDecodeH264PictureInfoFlags *>( this );
1109 }
1110
1111 operator StdVideoDecodeH264PictureInfoFlags const *() const VULKAN_HPP_NOEXCEPT
1112 {
1113 return reinterpret_cast<const StdVideoDecodeH264PictureInfoFlags *>( this );
1114 }
1115
1116 operator StdVideoDecodeH264PictureInfoFlags *() VULKAN_HPP_NOEXCEPT
1117 {
1118 return reinterpret_cast<StdVideoDecodeH264PictureInfoFlags *>( this );
1119 }
1120
1121 bool operator==( DecodeH264PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
1122 {
1123 return ( field_pic_flag == rhs.field_pic_flag ) && ( is_intra == rhs.is_intra ) && ( IdrPicFlag == rhs.IdrPicFlag ) &&
1124 ( bottom_field_flag == rhs.bottom_field_flag ) && ( is_reference == rhs.is_reference ) &&
1125 ( complementary_field_pair == rhs.complementary_field_pair );
1126 }
1127
1128 bool operator!=( DecodeH264PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
1129 {
1130 return !operator==( rhs );
1131 }
1132
1133 public:
1134 uint32_t field_pic_flag : 1;
1135 uint32_t is_intra : 1;
1136 uint32_t IdrPicFlag : 1;
1137 uint32_t bottom_field_flag : 1;
1138 uint32_t is_reference : 1;
1139 uint32_t complementary_field_pair : 1;
1140 };
1141
1142 struct DecodeH264PictureInfo
1143 {
1144 using NativeType = StdVideoDecodeH264PictureInfo;
1145
1146 operator StdVideoDecodeH264PictureInfo const &() const VULKAN_HPP_NOEXCEPT
1147 {
1148 return *reinterpret_cast<const StdVideoDecodeH264PictureInfo *>( this );
1149 }
1150
1151 operator StdVideoDecodeH264PictureInfo &() VULKAN_HPP_NOEXCEPT
1152 {
1153 return *reinterpret_cast<StdVideoDecodeH264PictureInfo *>( this );
1154 }
1155
1156 operator StdVideoDecodeH264PictureInfo const *() const VULKAN_HPP_NOEXCEPT
1157 {
1158 return reinterpret_cast<const StdVideoDecodeH264PictureInfo *>( this );
1159 }
1160
1161 operator StdVideoDecodeH264PictureInfo *() VULKAN_HPP_NOEXCEPT
1162 {
1163 return reinterpret_cast<StdVideoDecodeH264PictureInfo *>( this );
1164 }
1165
1166 bool operator==( DecodeH264PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
1167 {
1168 return ( flags == rhs.flags ) && ( seq_parameter_set_id == rhs.seq_parameter_set_id ) && ( pic_parameter_set_id == rhs.pic_parameter_set_id ) &&
1169 ( reserved1 == rhs.reserved1 ) && ( reserved2 == rhs.reserved2 ) && ( frame_num == rhs.frame_num ) && ( idr_pic_id == rhs.idr_pic_id ) &&
1170 ( PicOrderCnt == rhs.PicOrderCnt );
1171 }
1172
1173 bool operator!=( DecodeH264PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
1174 {
1175 return !operator==( rhs );
1176 }
1177
1178 public:
1179 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264PictureInfoFlags flags = {};
1180 uint8_t seq_parameter_set_id = {};
1181 uint8_t pic_parameter_set_id = {};
1182 uint8_t reserved1 = {};
1183 uint8_t reserved2 = {};
1184 uint16_t frame_num = {};
1185 uint16_t idr_pic_id = {};
1186 ArrayWrapper1D<int32_t, STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE> PicOrderCnt = {};
1187 };
1188
1189 struct DecodeH264ReferenceInfoFlags
1190 {
1191 using NativeType = StdVideoDecodeH264ReferenceInfoFlags;
1192
1193 operator StdVideoDecodeH264ReferenceInfoFlags const &() const VULKAN_HPP_NOEXCEPT
1194 {
1195 return *reinterpret_cast<const StdVideoDecodeH264ReferenceInfoFlags *>( this );
1196 }
1197
1198 operator StdVideoDecodeH264ReferenceInfoFlags &() VULKAN_HPP_NOEXCEPT
1199 {
1200 return *reinterpret_cast<StdVideoDecodeH264ReferenceInfoFlags *>( this );
1201 }
1202
1203 operator StdVideoDecodeH264ReferenceInfoFlags const *() const VULKAN_HPP_NOEXCEPT
1204 {
1205 return reinterpret_cast<const StdVideoDecodeH264ReferenceInfoFlags *>( this );
1206 }
1207
1208 operator StdVideoDecodeH264ReferenceInfoFlags *() VULKAN_HPP_NOEXCEPT
1209 {
1210 return reinterpret_cast<StdVideoDecodeH264ReferenceInfoFlags *>( this );
1211 }
1212
1213 bool operator==( DecodeH264ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
1214 {
1215 return ( top_field_flag == rhs.top_field_flag ) && ( bottom_field_flag == rhs.bottom_field_flag ) &&
1216 ( used_for_long_term_reference == rhs.used_for_long_term_reference ) && ( is_non_existing == rhs.is_non_existing );
1217 }
1218
1219 bool operator!=( DecodeH264ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
1220 {
1221 return !operator==( rhs );
1222 }
1223
1224 public:
1225 uint32_t top_field_flag : 1;
1226 uint32_t bottom_field_flag : 1;
1227 uint32_t used_for_long_term_reference : 1;
1228 uint32_t is_non_existing : 1;
1229 };
1230
1231 struct DecodeH264ReferenceInfo
1232 {
1233 using NativeType = StdVideoDecodeH264ReferenceInfo;
1234
1235 operator StdVideoDecodeH264ReferenceInfo const &() const VULKAN_HPP_NOEXCEPT
1236 {
1237 return *reinterpret_cast<const StdVideoDecodeH264ReferenceInfo *>( this );
1238 }
1239
1240 operator StdVideoDecodeH264ReferenceInfo &() VULKAN_HPP_NOEXCEPT
1241 {
1242 return *reinterpret_cast<StdVideoDecodeH264ReferenceInfo *>( this );
1243 }
1244
1245 operator StdVideoDecodeH264ReferenceInfo const *() const VULKAN_HPP_NOEXCEPT
1246 {
1247 return reinterpret_cast<const StdVideoDecodeH264ReferenceInfo *>( this );
1248 }
1249
1250 operator StdVideoDecodeH264ReferenceInfo *() VULKAN_HPP_NOEXCEPT
1251 {
1252 return reinterpret_cast<StdVideoDecodeH264ReferenceInfo *>( this );
1253 }
1254
1255 bool operator==( DecodeH264ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
1256 {
1257 return ( flags == rhs.flags ) && ( FrameNum == rhs.FrameNum ) && ( reserved == rhs.reserved ) && ( PicOrderCnt == rhs.PicOrderCnt );
1258 }
1259
1260 bool operator!=( DecodeH264ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
1261 {
1262 return !operator==( rhs );
1263 }
1264
1265 public:
1266 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264ReferenceInfoFlags flags = {};
1267 uint16_t FrameNum = {};
1268 uint16_t reserved = {};
1269 ArrayWrapper1D<int32_t, STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE> PicOrderCnt = {};
1270 };
1271 #endif
1272
1273 #if defined( VULKAN_VIDEO_CODEC_H264STD_ENCODE_H_ )
1274 //=== vulkan_video_codec_h264std_encode ===
1275
1276 struct EncodeH264WeightTableFlags
1277 {
1278 using NativeType = StdVideoEncodeH264WeightTableFlags;
1279
1280 operator StdVideoEncodeH264WeightTableFlags const &() const VULKAN_HPP_NOEXCEPT
1281 {
1282 return *reinterpret_cast<const StdVideoEncodeH264WeightTableFlags *>( this );
1283 }
1284
1285 operator StdVideoEncodeH264WeightTableFlags &() VULKAN_HPP_NOEXCEPT
1286 {
1287 return *reinterpret_cast<StdVideoEncodeH264WeightTableFlags *>( this );
1288 }
1289
1290 operator StdVideoEncodeH264WeightTableFlags const *() const VULKAN_HPP_NOEXCEPT
1291 {
1292 return reinterpret_cast<const StdVideoEncodeH264WeightTableFlags *>( this );
1293 }
1294
1295 operator StdVideoEncodeH264WeightTableFlags *() VULKAN_HPP_NOEXCEPT
1296 {
1297 return reinterpret_cast<StdVideoEncodeH264WeightTableFlags *>( this );
1298 }
1299
1300 bool operator==( EncodeH264WeightTableFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
1301 {
1302 return ( luma_weight_l0_flag == rhs.luma_weight_l0_flag ) && ( chroma_weight_l0_flag == rhs.chroma_weight_l0_flag ) &&
1303 ( luma_weight_l1_flag == rhs.luma_weight_l1_flag ) && ( chroma_weight_l1_flag == rhs.chroma_weight_l1_flag );
1304 }
1305
1306 bool operator!=( EncodeH264WeightTableFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
1307 {
1308 return !operator==( rhs );
1309 }
1310
1311 public:
1312 uint32_t luma_weight_l0_flag = {};
1313 uint32_t chroma_weight_l0_flag = {};
1314 uint32_t luma_weight_l1_flag = {};
1315 uint32_t chroma_weight_l1_flag = {};
1316 };
1317
1318 struct EncodeH264WeightTable
1319 {
1320 using NativeType = StdVideoEncodeH264WeightTable;
1321
1322 operator StdVideoEncodeH264WeightTable const &() const VULKAN_HPP_NOEXCEPT
1323 {
1324 return *reinterpret_cast<const StdVideoEncodeH264WeightTable *>( this );
1325 }
1326
1327 operator StdVideoEncodeH264WeightTable &() VULKAN_HPP_NOEXCEPT
1328 {
1329 return *reinterpret_cast<StdVideoEncodeH264WeightTable *>( this );
1330 }
1331
1332 operator StdVideoEncodeH264WeightTable const *() const VULKAN_HPP_NOEXCEPT
1333 {
1334 return reinterpret_cast<const StdVideoEncodeH264WeightTable *>( this );
1335 }
1336
1337 operator StdVideoEncodeH264WeightTable *() VULKAN_HPP_NOEXCEPT
1338 {
1339 return reinterpret_cast<StdVideoEncodeH264WeightTable *>( this );
1340 }
1341
1342 bool operator==( EncodeH264WeightTable const & rhs ) const VULKAN_HPP_NOEXCEPT
1343 {
1344 return ( flags == rhs.flags ) && ( luma_log2_weight_denom == rhs.luma_log2_weight_denom ) &&
1345 ( chroma_log2_weight_denom == rhs.chroma_log2_weight_denom ) && ( luma_weight_l0 == rhs.luma_weight_l0 ) &&
1346 ( luma_offset_l0 == rhs.luma_offset_l0 ) && ( chroma_weight_l0 == rhs.chroma_weight_l0 ) && ( chroma_offset_l0 == rhs.chroma_offset_l0 ) &&
1347 ( luma_weight_l1 == rhs.luma_weight_l1 ) && ( luma_offset_l1 == rhs.luma_offset_l1 ) && ( chroma_weight_l1 == rhs.chroma_weight_l1 ) &&
1348 ( chroma_offset_l1 == rhs.chroma_offset_l1 );
1349 }
1350
1351 bool operator!=( EncodeH264WeightTable const & rhs ) const VULKAN_HPP_NOEXCEPT
1352 {
1353 return !operator==( rhs );
1354 }
1355
1356 public:
1357 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTableFlags flags = {};
1358 uint8_t luma_log2_weight_denom = {};
1359 uint8_t chroma_log2_weight_denom = {};
1360 ArrayWrapper1D<int8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF> luma_weight_l0 = {};
1361 ArrayWrapper1D<int8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF> luma_offset_l0 = {};
1362 ArrayWrapper2D<int8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF, STD_VIDEO_H264_MAX_CHROMA_PLANES> chroma_weight_l0 = {};
1363 ArrayWrapper2D<int8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF, STD_VIDEO_H264_MAX_CHROMA_PLANES> chroma_offset_l0 = {};
1364 ArrayWrapper1D<int8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF> luma_weight_l1 = {};
1365 ArrayWrapper1D<int8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF> luma_offset_l1 = {};
1366 ArrayWrapper2D<int8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF, STD_VIDEO_H264_MAX_CHROMA_PLANES> chroma_weight_l1 = {};
1367 ArrayWrapper2D<int8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF, STD_VIDEO_H264_MAX_CHROMA_PLANES> chroma_offset_l1 = {};
1368 };
1369
1370 struct EncodeH264SliceHeaderFlags
1371 {
1372 using NativeType = StdVideoEncodeH264SliceHeaderFlags;
1373
1374 operator StdVideoEncodeH264SliceHeaderFlags const &() const VULKAN_HPP_NOEXCEPT
1375 {
1376 return *reinterpret_cast<const StdVideoEncodeH264SliceHeaderFlags *>( this );
1377 }
1378
1379 operator StdVideoEncodeH264SliceHeaderFlags &() VULKAN_HPP_NOEXCEPT
1380 {
1381 return *reinterpret_cast<StdVideoEncodeH264SliceHeaderFlags *>( this );
1382 }
1383
1384 operator StdVideoEncodeH264SliceHeaderFlags const *() const VULKAN_HPP_NOEXCEPT
1385 {
1386 return reinterpret_cast<const StdVideoEncodeH264SliceHeaderFlags *>( this );
1387 }
1388
1389 operator StdVideoEncodeH264SliceHeaderFlags *() VULKAN_HPP_NOEXCEPT
1390 {
1391 return reinterpret_cast<StdVideoEncodeH264SliceHeaderFlags *>( this );
1392 }
1393
1394 bool operator==( EncodeH264SliceHeaderFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
1395 {
1396 return ( direct_spatial_mv_pred_flag == rhs.direct_spatial_mv_pred_flag ) &&
1397 ( num_ref_idx_active_override_flag == rhs.num_ref_idx_active_override_flag ) && ( reserved == rhs.reserved );
1398 }
1399
1400 bool operator!=( EncodeH264SliceHeaderFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
1401 {
1402 return !operator==( rhs );
1403 }
1404
1405 public:
1406 uint32_t direct_spatial_mv_pred_flag : 1;
1407 uint32_t num_ref_idx_active_override_flag : 1;
1408 uint32_t reserved : 30;
1409 };
1410
1411 struct EncodeH264PictureInfoFlags
1412 {
1413 using NativeType = StdVideoEncodeH264PictureInfoFlags;
1414
1415 operator StdVideoEncodeH264PictureInfoFlags const &() const VULKAN_HPP_NOEXCEPT
1416 {
1417 return *reinterpret_cast<const StdVideoEncodeH264PictureInfoFlags *>( this );
1418 }
1419
1420 operator StdVideoEncodeH264PictureInfoFlags &() VULKAN_HPP_NOEXCEPT
1421 {
1422 return *reinterpret_cast<StdVideoEncodeH264PictureInfoFlags *>( this );
1423 }
1424
1425 operator StdVideoEncodeH264PictureInfoFlags const *() const VULKAN_HPP_NOEXCEPT
1426 {
1427 return reinterpret_cast<const StdVideoEncodeH264PictureInfoFlags *>( this );
1428 }
1429
1430 operator StdVideoEncodeH264PictureInfoFlags *() VULKAN_HPP_NOEXCEPT
1431 {
1432 return reinterpret_cast<StdVideoEncodeH264PictureInfoFlags *>( this );
1433 }
1434
1435 bool operator==( EncodeH264PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
1436 {
1437 return ( IdrPicFlag == rhs.IdrPicFlag ) && ( is_reference == rhs.is_reference ) &&
1438 ( no_output_of_prior_pics_flag == rhs.no_output_of_prior_pics_flag ) && ( long_term_reference_flag == rhs.long_term_reference_flag ) &&
1439 ( adaptive_ref_pic_marking_mode_flag == rhs.adaptive_ref_pic_marking_mode_flag ) && ( reserved == rhs.reserved );
1440 }
1441
1442 bool operator!=( EncodeH264PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
1443 {
1444 return !operator==( rhs );
1445 }
1446
1447 public:
1448 uint32_t IdrPicFlag : 1;
1449 uint32_t is_reference : 1;
1450 uint32_t no_output_of_prior_pics_flag : 1;
1451 uint32_t long_term_reference_flag : 1;
1452 uint32_t adaptive_ref_pic_marking_mode_flag : 1;
1453 uint32_t reserved : 27;
1454 };
1455
1456 struct EncodeH264ReferenceInfoFlags
1457 {
1458 using NativeType = StdVideoEncodeH264ReferenceInfoFlags;
1459
1460 operator StdVideoEncodeH264ReferenceInfoFlags const &() const VULKAN_HPP_NOEXCEPT
1461 {
1462 return *reinterpret_cast<const StdVideoEncodeH264ReferenceInfoFlags *>( this );
1463 }
1464
1465 operator StdVideoEncodeH264ReferenceInfoFlags &() VULKAN_HPP_NOEXCEPT
1466 {
1467 return *reinterpret_cast<StdVideoEncodeH264ReferenceInfoFlags *>( this );
1468 }
1469
1470 operator StdVideoEncodeH264ReferenceInfoFlags const *() const VULKAN_HPP_NOEXCEPT
1471 {
1472 return reinterpret_cast<const StdVideoEncodeH264ReferenceInfoFlags *>( this );
1473 }
1474
1475 operator StdVideoEncodeH264ReferenceInfoFlags *() VULKAN_HPP_NOEXCEPT
1476 {
1477 return reinterpret_cast<StdVideoEncodeH264ReferenceInfoFlags *>( this );
1478 }
1479
1480 bool operator==( EncodeH264ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
1481 {
1482 return ( used_for_long_term_reference == rhs.used_for_long_term_reference ) && ( reserved == rhs.reserved );
1483 }
1484
1485 bool operator!=( EncodeH264ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
1486 {
1487 return !operator==( rhs );
1488 }
1489
1490 public:
1491 uint32_t used_for_long_term_reference : 1;
1492 uint32_t reserved : 31;
1493 };
1494
1495 struct EncodeH264ReferenceListsInfoFlags
1496 {
1497 using NativeType = StdVideoEncodeH264ReferenceListsInfoFlags;
1498
1499 operator StdVideoEncodeH264ReferenceListsInfoFlags const &() const VULKAN_HPP_NOEXCEPT
1500 {
1501 return *reinterpret_cast<const StdVideoEncodeH264ReferenceListsInfoFlags *>( this );
1502 }
1503
1504 operator StdVideoEncodeH264ReferenceListsInfoFlags &() VULKAN_HPP_NOEXCEPT
1505 {
1506 return *reinterpret_cast<StdVideoEncodeH264ReferenceListsInfoFlags *>( this );
1507 }
1508
1509 operator StdVideoEncodeH264ReferenceListsInfoFlags const *() const VULKAN_HPP_NOEXCEPT
1510 {
1511 return reinterpret_cast<const StdVideoEncodeH264ReferenceListsInfoFlags *>( this );
1512 }
1513
1514 operator StdVideoEncodeH264ReferenceListsInfoFlags *() VULKAN_HPP_NOEXCEPT
1515 {
1516 return reinterpret_cast<StdVideoEncodeH264ReferenceListsInfoFlags *>( this );
1517 }
1518
1519 bool operator==( EncodeH264ReferenceListsInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
1520 {
1521 return ( ref_pic_list_modification_flag_l0 == rhs.ref_pic_list_modification_flag_l0 ) &&
1522 ( ref_pic_list_modification_flag_l1 == rhs.ref_pic_list_modification_flag_l1 ) && ( reserved == rhs.reserved );
1523 }
1524
1525 bool operator!=( EncodeH264ReferenceListsInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
1526 {
1527 return !operator==( rhs );
1528 }
1529
1530 public:
1531 uint32_t ref_pic_list_modification_flag_l0 : 1;
1532 uint32_t ref_pic_list_modification_flag_l1 : 1;
1533 uint32_t reserved : 30;
1534 };
1535
1536 struct EncodeH264RefListModEntry
1537 {
1538 using NativeType = StdVideoEncodeH264RefListModEntry;
1539
1540 operator StdVideoEncodeH264RefListModEntry const &() const VULKAN_HPP_NOEXCEPT
1541 {
1542 return *reinterpret_cast<const StdVideoEncodeH264RefListModEntry *>( this );
1543 }
1544
1545 operator StdVideoEncodeH264RefListModEntry &() VULKAN_HPP_NOEXCEPT
1546 {
1547 return *reinterpret_cast<StdVideoEncodeH264RefListModEntry *>( this );
1548 }
1549
1550 operator StdVideoEncodeH264RefListModEntry const *() const VULKAN_HPP_NOEXCEPT
1551 {
1552 return reinterpret_cast<const StdVideoEncodeH264RefListModEntry *>( this );
1553 }
1554
1555 operator StdVideoEncodeH264RefListModEntry *() VULKAN_HPP_NOEXCEPT
1556 {
1557 return reinterpret_cast<StdVideoEncodeH264RefListModEntry *>( this );
1558 }
1559
1560 bool operator==( EncodeH264RefListModEntry const & rhs ) const VULKAN_HPP_NOEXCEPT
1561 {
1562 return ( modification_of_pic_nums_idc == rhs.modification_of_pic_nums_idc ) && ( abs_diff_pic_num_minus1 == rhs.abs_diff_pic_num_minus1 ) &&
1563 ( long_term_pic_num == rhs.long_term_pic_num );
1564 }
1565
1566 bool operator!=( EncodeH264RefListModEntry const & rhs ) const VULKAN_HPP_NOEXCEPT
1567 {
1568 return !operator==( rhs );
1569 }
1570
1571 public:
1572 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ModificationOfPicNumsIdc modification_of_pic_nums_idc =
1573 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ModificationOfPicNumsIdc::eShortTermSubtract;
1574 uint16_t abs_diff_pic_num_minus1 = {};
1575 uint16_t long_term_pic_num = {};
1576 };
1577
1578 struct EncodeH264RefPicMarkingEntry
1579 {
1580 using NativeType = StdVideoEncodeH264RefPicMarkingEntry;
1581
1582 operator StdVideoEncodeH264RefPicMarkingEntry const &() const VULKAN_HPP_NOEXCEPT
1583 {
1584 return *reinterpret_cast<const StdVideoEncodeH264RefPicMarkingEntry *>( this );
1585 }
1586
1587 operator StdVideoEncodeH264RefPicMarkingEntry &() VULKAN_HPP_NOEXCEPT
1588 {
1589 return *reinterpret_cast<StdVideoEncodeH264RefPicMarkingEntry *>( this );
1590 }
1591
1592 operator StdVideoEncodeH264RefPicMarkingEntry const *() const VULKAN_HPP_NOEXCEPT
1593 {
1594 return reinterpret_cast<const StdVideoEncodeH264RefPicMarkingEntry *>( this );
1595 }
1596
1597 operator StdVideoEncodeH264RefPicMarkingEntry *() VULKAN_HPP_NOEXCEPT
1598 {
1599 return reinterpret_cast<StdVideoEncodeH264RefPicMarkingEntry *>( this );
1600 }
1601
1602 bool operator==( EncodeH264RefPicMarkingEntry const & rhs ) const VULKAN_HPP_NOEXCEPT
1603 {
1604 return ( memory_management_control_operation == rhs.memory_management_control_operation ) &&
1605 ( difference_of_pic_nums_minus1 == rhs.difference_of_pic_nums_minus1 ) && ( long_term_pic_num == rhs.long_term_pic_num ) &&
1606 ( long_term_frame_idx == rhs.long_term_frame_idx ) && ( max_long_term_frame_idx_plus1 == rhs.max_long_term_frame_idx_plus1 );
1607 }
1608
1609 bool operator!=( EncodeH264RefPicMarkingEntry const & rhs ) const VULKAN_HPP_NOEXCEPT
1610 {
1611 return !operator==( rhs );
1612 }
1613
1614 public:
1615 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264MemMgmtControlOp memory_management_control_operation =
1616 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264MemMgmtControlOp::eEnd;
1617 uint16_t difference_of_pic_nums_minus1 = {};
1618 uint16_t long_term_pic_num = {};
1619 uint16_t long_term_frame_idx = {};
1620 uint16_t max_long_term_frame_idx_plus1 = {};
1621 };
1622
1623 struct EncodeH264ReferenceListsInfo
1624 {
1625 using NativeType = StdVideoEncodeH264ReferenceListsInfo;
1626
1627 operator StdVideoEncodeH264ReferenceListsInfo const &() const VULKAN_HPP_NOEXCEPT
1628 {
1629 return *reinterpret_cast<const StdVideoEncodeH264ReferenceListsInfo *>( this );
1630 }
1631
1632 operator StdVideoEncodeH264ReferenceListsInfo &() VULKAN_HPP_NOEXCEPT
1633 {
1634 return *reinterpret_cast<StdVideoEncodeH264ReferenceListsInfo *>( this );
1635 }
1636
1637 operator StdVideoEncodeH264ReferenceListsInfo const *() const VULKAN_HPP_NOEXCEPT
1638 {
1639 return reinterpret_cast<const StdVideoEncodeH264ReferenceListsInfo *>( this );
1640 }
1641
1642 operator StdVideoEncodeH264ReferenceListsInfo *() VULKAN_HPP_NOEXCEPT
1643 {
1644 return reinterpret_cast<StdVideoEncodeH264ReferenceListsInfo *>( this );
1645 }
1646
1647 bool operator==( EncodeH264ReferenceListsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
1648 {
1649 return ( flags == rhs.flags ) && ( num_ref_idx_l0_active_minus1 == rhs.num_ref_idx_l0_active_minus1 ) &&
1650 ( num_ref_idx_l1_active_minus1 == rhs.num_ref_idx_l1_active_minus1 ) && ( RefPicList0 == rhs.RefPicList0 ) &&
1651 ( RefPicList1 == rhs.RefPicList1 ) && ( refList0ModOpCount == rhs.refList0ModOpCount ) && ( refList1ModOpCount == rhs.refList1ModOpCount ) &&
1652 ( refPicMarkingOpCount == rhs.refPicMarkingOpCount ) && ( reserved1 == rhs.reserved1 ) &&
1653 ( pRefList0ModOperations == rhs.pRefList0ModOperations ) && ( pRefList1ModOperations == rhs.pRefList1ModOperations ) &&
1654 ( pRefPicMarkingOperations == rhs.pRefPicMarkingOperations );
1655 }
1656
1657 bool operator!=( EncodeH264ReferenceListsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
1658 {
1659 return !operator==( rhs );
1660 }
1661
1662 public:
1663 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfoFlags flags = {};
1664 uint8_t num_ref_idx_l0_active_minus1 = {};
1665 uint8_t num_ref_idx_l1_active_minus1 = {};
1666 ArrayWrapper1D<uint8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF> RefPicList0 = {};
1667 ArrayWrapper1D<uint8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF> RefPicList1 = {};
1668 uint8_t refList0ModOpCount = {};
1669 uint8_t refList1ModOpCount = {};
1670 uint8_t refPicMarkingOpCount = {};
1671 ArrayWrapper1D<uint8_t, 7> reserved1 = {};
1672 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefListModEntry * pRefList0ModOperations = {};
1673 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefListModEntry * pRefList1ModOperations = {};
1674 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefPicMarkingEntry * pRefPicMarkingOperations = {};
1675 };
1676
1677 struct EncodeH264PictureInfo
1678 {
1679 using NativeType = StdVideoEncodeH264PictureInfo;
1680
1681 operator StdVideoEncodeH264PictureInfo const &() const VULKAN_HPP_NOEXCEPT
1682 {
1683 return *reinterpret_cast<const StdVideoEncodeH264PictureInfo *>( this );
1684 }
1685
1686 operator StdVideoEncodeH264PictureInfo &() VULKAN_HPP_NOEXCEPT
1687 {
1688 return *reinterpret_cast<StdVideoEncodeH264PictureInfo *>( this );
1689 }
1690
1691 operator StdVideoEncodeH264PictureInfo const *() const VULKAN_HPP_NOEXCEPT
1692 {
1693 return reinterpret_cast<const StdVideoEncodeH264PictureInfo *>( this );
1694 }
1695
1696 operator StdVideoEncodeH264PictureInfo *() VULKAN_HPP_NOEXCEPT
1697 {
1698 return reinterpret_cast<StdVideoEncodeH264PictureInfo *>( this );
1699 }
1700
1701 bool operator==( EncodeH264PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
1702 {
1703 return ( flags == rhs.flags ) && ( seq_parameter_set_id == rhs.seq_parameter_set_id ) && ( pic_parameter_set_id == rhs.pic_parameter_set_id ) &&
1704 ( idr_pic_id == rhs.idr_pic_id ) && ( primary_pic_type == rhs.primary_pic_type ) && ( frame_num == rhs.frame_num ) &&
1705 ( PicOrderCnt == rhs.PicOrderCnt ) && ( temporal_id == rhs.temporal_id ) && ( reserved1 == rhs.reserved1 ) && ( pRefLists == rhs.pRefLists );
1706 }
1707
1708 bool operator!=( EncodeH264PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
1709 {
1710 return !operator==( rhs );
1711 }
1712
1713 public:
1714 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264PictureInfoFlags flags = {};
1715 uint8_t seq_parameter_set_id = {};
1716 uint8_t pic_parameter_set_id = {};
1717 uint16_t idr_pic_id = {};
1718 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PictureType primary_pic_type =
1719 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PictureType::eP;
1720 uint32_t frame_num = {};
1721 int32_t PicOrderCnt = {};
1722 uint8_t temporal_id = {};
1723 ArrayWrapper1D<uint8_t, 3> reserved1 = {};
1724 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfo * pRefLists = {};
1725 };
1726
1727 struct EncodeH264ReferenceInfo
1728 {
1729 using NativeType = StdVideoEncodeH264ReferenceInfo;
1730
1731 operator StdVideoEncodeH264ReferenceInfo const &() const VULKAN_HPP_NOEXCEPT
1732 {
1733 return *reinterpret_cast<const StdVideoEncodeH264ReferenceInfo *>( this );
1734 }
1735
1736 operator StdVideoEncodeH264ReferenceInfo &() VULKAN_HPP_NOEXCEPT
1737 {
1738 return *reinterpret_cast<StdVideoEncodeH264ReferenceInfo *>( this );
1739 }
1740
1741 operator StdVideoEncodeH264ReferenceInfo const *() const VULKAN_HPP_NOEXCEPT
1742 {
1743 return reinterpret_cast<const StdVideoEncodeH264ReferenceInfo *>( this );
1744 }
1745
1746 operator StdVideoEncodeH264ReferenceInfo *() VULKAN_HPP_NOEXCEPT
1747 {
1748 return reinterpret_cast<StdVideoEncodeH264ReferenceInfo *>( this );
1749 }
1750
1751 bool operator==( EncodeH264ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
1752 {
1753 return ( flags == rhs.flags ) && ( primary_pic_type == rhs.primary_pic_type ) && ( FrameNum == rhs.FrameNum ) && ( PicOrderCnt == rhs.PicOrderCnt ) &&
1754 ( long_term_pic_num == rhs.long_term_pic_num ) && ( long_term_frame_idx == rhs.long_term_frame_idx ) && ( temporal_id == rhs.temporal_id );
1755 }
1756
1757 bool operator!=( EncodeH264ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
1758 {
1759 return !operator==( rhs );
1760 }
1761
1762 public:
1763 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceInfoFlags flags = {};
1764 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PictureType primary_pic_type =
1765 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PictureType::eP;
1766 uint32_t FrameNum = {};
1767 int32_t PicOrderCnt = {};
1768 uint16_t long_term_pic_num = {};
1769 uint16_t long_term_frame_idx = {};
1770 uint8_t temporal_id = {};
1771 };
1772
1773 struct EncodeH264SliceHeader
1774 {
1775 using NativeType = StdVideoEncodeH264SliceHeader;
1776
1777 operator StdVideoEncodeH264SliceHeader const &() const VULKAN_HPP_NOEXCEPT
1778 {
1779 return *reinterpret_cast<const StdVideoEncodeH264SliceHeader *>( this );
1780 }
1781
1782 operator StdVideoEncodeH264SliceHeader &() VULKAN_HPP_NOEXCEPT
1783 {
1784 return *reinterpret_cast<StdVideoEncodeH264SliceHeader *>( this );
1785 }
1786
1787 operator StdVideoEncodeH264SliceHeader const *() const VULKAN_HPP_NOEXCEPT
1788 {
1789 return reinterpret_cast<const StdVideoEncodeH264SliceHeader *>( this );
1790 }
1791
1792 operator StdVideoEncodeH264SliceHeader *() VULKAN_HPP_NOEXCEPT
1793 {
1794 return reinterpret_cast<StdVideoEncodeH264SliceHeader *>( this );
1795 }
1796
1797 bool operator==( EncodeH264SliceHeader const & rhs ) const VULKAN_HPP_NOEXCEPT
1798 {
1799 return ( flags == rhs.flags ) && ( first_mb_in_slice == rhs.first_mb_in_slice ) && ( slice_type == rhs.slice_type ) &&
1800 ( slice_alpha_c0_offset_div2 == rhs.slice_alpha_c0_offset_div2 ) && ( slice_beta_offset_div2 == rhs.slice_beta_offset_div2 ) &&
1801 ( slice_qp_delta == rhs.slice_qp_delta ) && ( reserved1 == rhs.reserved1 ) && ( cabac_init_idc == rhs.cabac_init_idc ) &&
1802 ( disable_deblocking_filter_idc == rhs.disable_deblocking_filter_idc ) && ( pWeightTable == rhs.pWeightTable );
1803 }
1804
1805 bool operator!=( EncodeH264SliceHeader const & rhs ) const VULKAN_HPP_NOEXCEPT
1806 {
1807 return !operator==( rhs );
1808 }
1809
1810 public:
1811 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264SliceHeaderFlags flags = {};
1812 uint32_t first_mb_in_slice = {};
1813 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SliceType slice_type = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SliceType::eP;
1814 int8_t slice_alpha_c0_offset_div2 = {};
1815 int8_t slice_beta_offset_div2 = {};
1816 int8_t slice_qp_delta = {};
1817 uint8_t reserved1 = {};
1818 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264CabacInitIdc cabac_init_idc =
1819 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264CabacInitIdc::e0;
1820 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264DisableDeblockingFilterIdc disable_deblocking_filter_idc =
1821 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264DisableDeblockingFilterIdc::eDisabled;
1822 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTable * pWeightTable = {};
1823 };
1824 #endif
1825
1826 #if defined( VULKAN_VIDEO_CODEC_H265STD_H_ )
1827 //=== vulkan_video_codec_h265std ===
1828
1829 struct H265DecPicBufMgr
1830 {
1831 using NativeType = StdVideoH265DecPicBufMgr;
1832
1833 operator StdVideoH265DecPicBufMgr const &() const VULKAN_HPP_NOEXCEPT
1834 {
1835 return *reinterpret_cast<const StdVideoH265DecPicBufMgr *>( this );
1836 }
1837
1838 operator StdVideoH265DecPicBufMgr &() VULKAN_HPP_NOEXCEPT
1839 {
1840 return *reinterpret_cast<StdVideoH265DecPicBufMgr *>( this );
1841 }
1842
1843 operator StdVideoH265DecPicBufMgr const *() const VULKAN_HPP_NOEXCEPT
1844 {
1845 return reinterpret_cast<const StdVideoH265DecPicBufMgr *>( this );
1846 }
1847
1848 operator StdVideoH265DecPicBufMgr *() VULKAN_HPP_NOEXCEPT
1849 {
1850 return reinterpret_cast<StdVideoH265DecPicBufMgr *>( this );
1851 }
1852
1853 bool operator==( H265DecPicBufMgr const & rhs ) const VULKAN_HPP_NOEXCEPT
1854 {
1855 return ( max_latency_increase_plus1 == rhs.max_latency_increase_plus1 ) && ( max_dec_pic_buffering_minus1 == rhs.max_dec_pic_buffering_minus1 ) &&
1856 ( max_num_reorder_pics == rhs.max_num_reorder_pics );
1857 }
1858
1859 bool operator!=( H265DecPicBufMgr const & rhs ) const VULKAN_HPP_NOEXCEPT
1860 {
1861 return !operator==( rhs );
1862 }
1863
1864 public:
1865 ArrayWrapper1D<uint32_t, STD_VIDEO_H265_SUBLAYERS_LIST_SIZE> max_latency_increase_plus1 = {};
1866 ArrayWrapper1D<uint8_t, STD_VIDEO_H265_SUBLAYERS_LIST_SIZE> max_dec_pic_buffering_minus1 = {};
1867 ArrayWrapper1D<uint8_t, STD_VIDEO_H265_SUBLAYERS_LIST_SIZE> max_num_reorder_pics = {};
1868 };
1869
1870 struct H265SubLayerHrdParameters
1871 {
1872 using NativeType = StdVideoH265SubLayerHrdParameters;
1873
1874 operator StdVideoH265SubLayerHrdParameters const &() const VULKAN_HPP_NOEXCEPT
1875 {
1876 return *reinterpret_cast<const StdVideoH265SubLayerHrdParameters *>( this );
1877 }
1878
1879 operator StdVideoH265SubLayerHrdParameters &() VULKAN_HPP_NOEXCEPT
1880 {
1881 return *reinterpret_cast<StdVideoH265SubLayerHrdParameters *>( this );
1882 }
1883
1884 operator StdVideoH265SubLayerHrdParameters const *() const VULKAN_HPP_NOEXCEPT
1885 {
1886 return reinterpret_cast<const StdVideoH265SubLayerHrdParameters *>( this );
1887 }
1888
1889 operator StdVideoH265SubLayerHrdParameters *() VULKAN_HPP_NOEXCEPT
1890 {
1891 return reinterpret_cast<StdVideoH265SubLayerHrdParameters *>( this );
1892 }
1893
1894 bool operator==( H265SubLayerHrdParameters const & rhs ) const VULKAN_HPP_NOEXCEPT
1895 {
1896 return ( bit_rate_value_minus1 == rhs.bit_rate_value_minus1 ) && ( cpb_size_value_minus1 == rhs.cpb_size_value_minus1 ) &&
1897 ( cpb_size_du_value_minus1 == rhs.cpb_size_du_value_minus1 ) && ( bit_rate_du_value_minus1 == rhs.bit_rate_du_value_minus1 ) &&
1898 ( cbr_flag == rhs.cbr_flag );
1899 }
1900
1901 bool operator!=( H265SubLayerHrdParameters const & rhs ) const VULKAN_HPP_NOEXCEPT
1902 {
1903 return !operator==( rhs );
1904 }
1905
1906 public:
1907 ArrayWrapper1D<uint32_t, STD_VIDEO_H265_CPB_CNT_LIST_SIZE> bit_rate_value_minus1 = {};
1908 ArrayWrapper1D<uint32_t, STD_VIDEO_H265_CPB_CNT_LIST_SIZE> cpb_size_value_minus1 = {};
1909 ArrayWrapper1D<uint32_t, STD_VIDEO_H265_CPB_CNT_LIST_SIZE> cpb_size_du_value_minus1 = {};
1910 ArrayWrapper1D<uint32_t, STD_VIDEO_H265_CPB_CNT_LIST_SIZE> bit_rate_du_value_minus1 = {};
1911 uint32_t cbr_flag = {};
1912 };
1913
1914 struct H265HrdFlags
1915 {
1916 using NativeType = StdVideoH265HrdFlags;
1917
1918 operator StdVideoH265HrdFlags const &() const VULKAN_HPP_NOEXCEPT
1919 {
1920 return *reinterpret_cast<const StdVideoH265HrdFlags *>( this );
1921 }
1922
1923 operator StdVideoH265HrdFlags &() VULKAN_HPP_NOEXCEPT
1924 {
1925 return *reinterpret_cast<StdVideoH265HrdFlags *>( this );
1926 }
1927
1928 operator StdVideoH265HrdFlags const *() const VULKAN_HPP_NOEXCEPT
1929 {
1930 return reinterpret_cast<const StdVideoH265HrdFlags *>( this );
1931 }
1932
1933 operator StdVideoH265HrdFlags *() VULKAN_HPP_NOEXCEPT
1934 {
1935 return reinterpret_cast<StdVideoH265HrdFlags *>( this );
1936 }
1937
1938 bool operator==( H265HrdFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
1939 {
1940 return ( nal_hrd_parameters_present_flag == rhs.nal_hrd_parameters_present_flag ) &&
1941 ( vcl_hrd_parameters_present_flag == rhs.vcl_hrd_parameters_present_flag ) &&
1942 ( sub_pic_hrd_params_present_flag == rhs.sub_pic_hrd_params_present_flag ) &&
1943 ( sub_pic_cpb_params_in_pic_timing_sei_flag == rhs.sub_pic_cpb_params_in_pic_timing_sei_flag ) &&
1944 ( fixed_pic_rate_general_flag == rhs.fixed_pic_rate_general_flag ) && ( fixed_pic_rate_within_cvs_flag == rhs.fixed_pic_rate_within_cvs_flag ) &&
1945 ( low_delay_hrd_flag == rhs.low_delay_hrd_flag );
1946 }
1947
1948 bool operator!=( H265HrdFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
1949 {
1950 return !operator==( rhs );
1951 }
1952
1953 public:
1954 uint32_t nal_hrd_parameters_present_flag : 1;
1955 uint32_t vcl_hrd_parameters_present_flag : 1;
1956 uint32_t sub_pic_hrd_params_present_flag : 1;
1957 uint32_t sub_pic_cpb_params_in_pic_timing_sei_flag : 1;
1958 uint32_t fixed_pic_rate_general_flag : 8;
1959 uint32_t fixed_pic_rate_within_cvs_flag : 8;
1960 uint32_t low_delay_hrd_flag : 8;
1961 };
1962
1963 struct H265HrdParameters
1964 {
1965 using NativeType = StdVideoH265HrdParameters;
1966
1967 operator StdVideoH265HrdParameters const &() const VULKAN_HPP_NOEXCEPT
1968 {
1969 return *reinterpret_cast<const StdVideoH265HrdParameters *>( this );
1970 }
1971
1972 operator StdVideoH265HrdParameters &() VULKAN_HPP_NOEXCEPT
1973 {
1974 return *reinterpret_cast<StdVideoH265HrdParameters *>( this );
1975 }
1976
1977 operator StdVideoH265HrdParameters const *() const VULKAN_HPP_NOEXCEPT
1978 {
1979 return reinterpret_cast<const StdVideoH265HrdParameters *>( this );
1980 }
1981
1982 operator StdVideoH265HrdParameters *() VULKAN_HPP_NOEXCEPT
1983 {
1984 return reinterpret_cast<StdVideoH265HrdParameters *>( this );
1985 }
1986
1987 bool operator==( H265HrdParameters const & rhs ) const VULKAN_HPP_NOEXCEPT
1988 {
1989 return ( flags == rhs.flags ) && ( tick_divisor_minus2 == rhs.tick_divisor_minus2 ) &&
1990 ( du_cpb_removal_delay_increment_length_minus1 == rhs.du_cpb_removal_delay_increment_length_minus1 ) &&
1991 ( dpb_output_delay_du_length_minus1 == rhs.dpb_output_delay_du_length_minus1 ) && ( bit_rate_scale == rhs.bit_rate_scale ) &&
1992 ( cpb_size_scale == rhs.cpb_size_scale ) && ( cpb_size_du_scale == rhs.cpb_size_du_scale ) &&
1993 ( initial_cpb_removal_delay_length_minus1 == rhs.initial_cpb_removal_delay_length_minus1 ) &&
1994 ( au_cpb_removal_delay_length_minus1 == rhs.au_cpb_removal_delay_length_minus1 ) &&
1995 ( dpb_output_delay_length_minus1 == rhs.dpb_output_delay_length_minus1 ) && ( cpb_cnt_minus1 == rhs.cpb_cnt_minus1 ) &&
1996 ( elemental_duration_in_tc_minus1 == rhs.elemental_duration_in_tc_minus1 ) && ( reserved == rhs.reserved ) &&
1997 ( pSubLayerHrdParametersNal == rhs.pSubLayerHrdParametersNal ) && ( pSubLayerHrdParametersVcl == rhs.pSubLayerHrdParametersVcl );
1998 }
1999
2000 bool operator!=( H265HrdParameters const & rhs ) const VULKAN_HPP_NOEXCEPT
2001 {
2002 return !operator==( rhs );
2003 }
2004
2005 public:
2006 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdFlags flags = {};
2007 uint8_t tick_divisor_minus2 = {};
2008 uint8_t du_cpb_removal_delay_increment_length_minus1 = {};
2009 uint8_t dpb_output_delay_du_length_minus1 = {};
2010 uint8_t bit_rate_scale = {};
2011 uint8_t cpb_size_scale = {};
2012 uint8_t cpb_size_du_scale = {};
2013 uint8_t initial_cpb_removal_delay_length_minus1 = {};
2014 uint8_t au_cpb_removal_delay_length_minus1 = {};
2015 uint8_t dpb_output_delay_length_minus1 = {};
2016 ArrayWrapper1D<uint8_t, STD_VIDEO_H265_SUBLAYERS_LIST_SIZE> cpb_cnt_minus1 = {};
2017 ArrayWrapper1D<uint16_t, STD_VIDEO_H265_SUBLAYERS_LIST_SIZE> elemental_duration_in_tc_minus1 = {};
2018 ArrayWrapper1D<uint16_t, 3> reserved = {};
2019 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SubLayerHrdParameters * pSubLayerHrdParametersNal = {};
2020 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SubLayerHrdParameters * pSubLayerHrdParametersVcl = {};
2021 };
2022
2023 struct H265VpsFlags
2024 {
2025 using NativeType = StdVideoH265VpsFlags;
2026
2027 operator StdVideoH265VpsFlags const &() const VULKAN_HPP_NOEXCEPT
2028 {
2029 return *reinterpret_cast<const StdVideoH265VpsFlags *>( this );
2030 }
2031
2032 operator StdVideoH265VpsFlags &() VULKAN_HPP_NOEXCEPT
2033 {
2034 return *reinterpret_cast<StdVideoH265VpsFlags *>( this );
2035 }
2036
2037 operator StdVideoH265VpsFlags const *() const VULKAN_HPP_NOEXCEPT
2038 {
2039 return reinterpret_cast<const StdVideoH265VpsFlags *>( this );
2040 }
2041
2042 operator StdVideoH265VpsFlags *() VULKAN_HPP_NOEXCEPT
2043 {
2044 return reinterpret_cast<StdVideoH265VpsFlags *>( this );
2045 }
2046
2047 bool operator==( H265VpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
2048 {
2049 return ( vps_temporal_id_nesting_flag == rhs.vps_temporal_id_nesting_flag ) &&
2050 ( vps_sub_layer_ordering_info_present_flag == rhs.vps_sub_layer_ordering_info_present_flag ) &&
2051 ( vps_timing_info_present_flag == rhs.vps_timing_info_present_flag ) &&
2052 ( vps_poc_proportional_to_timing_flag == rhs.vps_poc_proportional_to_timing_flag );
2053 }
2054
2055 bool operator!=( H265VpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
2056 {
2057 return !operator==( rhs );
2058 }
2059
2060 public:
2061 uint32_t vps_temporal_id_nesting_flag : 1;
2062 uint32_t vps_sub_layer_ordering_info_present_flag : 1;
2063 uint32_t vps_timing_info_present_flag : 1;
2064 uint32_t vps_poc_proportional_to_timing_flag : 1;
2065 };
2066
2067 struct H265ProfileTierLevelFlags
2068 {
2069 using NativeType = StdVideoH265ProfileTierLevelFlags;
2070
2071 operator StdVideoH265ProfileTierLevelFlags const &() const VULKAN_HPP_NOEXCEPT
2072 {
2073 return *reinterpret_cast<const StdVideoH265ProfileTierLevelFlags *>( this );
2074 }
2075
2076 operator StdVideoH265ProfileTierLevelFlags &() VULKAN_HPP_NOEXCEPT
2077 {
2078 return *reinterpret_cast<StdVideoH265ProfileTierLevelFlags *>( this );
2079 }
2080
2081 operator StdVideoH265ProfileTierLevelFlags const *() const VULKAN_HPP_NOEXCEPT
2082 {
2083 return reinterpret_cast<const StdVideoH265ProfileTierLevelFlags *>( this );
2084 }
2085
2086 operator StdVideoH265ProfileTierLevelFlags *() VULKAN_HPP_NOEXCEPT
2087 {
2088 return reinterpret_cast<StdVideoH265ProfileTierLevelFlags *>( this );
2089 }
2090
2091 bool operator==( H265ProfileTierLevelFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
2092 {
2093 return ( general_tier_flag == rhs.general_tier_flag ) && ( general_progressive_source_flag == rhs.general_progressive_source_flag ) &&
2094 ( general_interlaced_source_flag == rhs.general_interlaced_source_flag ) &&
2095 ( general_non_packed_constraint_flag == rhs.general_non_packed_constraint_flag ) &&
2096 ( general_frame_only_constraint_flag == rhs.general_frame_only_constraint_flag );
2097 }
2098
2099 bool operator!=( H265ProfileTierLevelFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
2100 {
2101 return !operator==( rhs );
2102 }
2103
2104 public:
2105 uint32_t general_tier_flag : 1;
2106 uint32_t general_progressive_source_flag : 1;
2107 uint32_t general_interlaced_source_flag : 1;
2108 uint32_t general_non_packed_constraint_flag : 1;
2109 uint32_t general_frame_only_constraint_flag : 1;
2110 };
2111
2112 struct H265ProfileTierLevel
2113 {
2114 using NativeType = StdVideoH265ProfileTierLevel;
2115
2116 operator StdVideoH265ProfileTierLevel const &() const VULKAN_HPP_NOEXCEPT
2117 {
2118 return *reinterpret_cast<const StdVideoH265ProfileTierLevel *>( this );
2119 }
2120
2121 operator StdVideoH265ProfileTierLevel &() VULKAN_HPP_NOEXCEPT
2122 {
2123 return *reinterpret_cast<StdVideoH265ProfileTierLevel *>( this );
2124 }
2125
2126 operator StdVideoH265ProfileTierLevel const *() const VULKAN_HPP_NOEXCEPT
2127 {
2128 return reinterpret_cast<const StdVideoH265ProfileTierLevel *>( this );
2129 }
2130
2131 operator StdVideoH265ProfileTierLevel *() VULKAN_HPP_NOEXCEPT
2132 {
2133 return reinterpret_cast<StdVideoH265ProfileTierLevel *>( this );
2134 }
2135
2136 bool operator==( H265ProfileTierLevel const & rhs ) const VULKAN_HPP_NOEXCEPT
2137 {
2138 return ( flags == rhs.flags ) && ( general_profile_idc == rhs.general_profile_idc ) && ( general_level_idc == rhs.general_level_idc );
2139 }
2140
2141 bool operator!=( H265ProfileTierLevel const & rhs ) const VULKAN_HPP_NOEXCEPT
2142 {
2143 return !operator==( rhs );
2144 }
2145
2146 public:
2147 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevelFlags flags = {};
2148 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileIdc general_profile_idc =
2149 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileIdc::eMain;
2150 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265LevelIdc general_level_idc = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265LevelIdc::e1_0;
2151 };
2152
2153 struct H265VideoParameterSet
2154 {
2155 using NativeType = StdVideoH265VideoParameterSet;
2156
2157 operator StdVideoH265VideoParameterSet const &() const VULKAN_HPP_NOEXCEPT
2158 {
2159 return *reinterpret_cast<const StdVideoH265VideoParameterSet *>( this );
2160 }
2161
2162 operator StdVideoH265VideoParameterSet &() VULKAN_HPP_NOEXCEPT
2163 {
2164 return *reinterpret_cast<StdVideoH265VideoParameterSet *>( this );
2165 }
2166
2167 operator StdVideoH265VideoParameterSet const *() const VULKAN_HPP_NOEXCEPT
2168 {
2169 return reinterpret_cast<const StdVideoH265VideoParameterSet *>( this );
2170 }
2171
2172 operator StdVideoH265VideoParameterSet *() VULKAN_HPP_NOEXCEPT
2173 {
2174 return reinterpret_cast<StdVideoH265VideoParameterSet *>( this );
2175 }
2176
2177 bool operator==( H265VideoParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT
2178 {
2179 return ( flags == rhs.flags ) && ( vps_video_parameter_set_id == rhs.vps_video_parameter_set_id ) &&
2180 ( vps_max_sub_layers_minus1 == rhs.vps_max_sub_layers_minus1 ) && ( reserved1 == rhs.reserved1 ) && ( reserved2 == rhs.reserved2 ) &&
2181 ( vps_num_units_in_tick == rhs.vps_num_units_in_tick ) && ( vps_time_scale == rhs.vps_time_scale ) &&
2182 ( vps_num_ticks_poc_diff_one_minus1 == rhs.vps_num_ticks_poc_diff_one_minus1 ) && ( reserved3 == rhs.reserved3 ) &&
2183 ( pDecPicBufMgr == rhs.pDecPicBufMgr ) && ( pHrdParameters == rhs.pHrdParameters ) && ( pProfileTierLevel == rhs.pProfileTierLevel );
2184 }
2185
2186 bool operator!=( H265VideoParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT
2187 {
2188 return !operator==( rhs );
2189 }
2190
2191 public:
2192 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265VpsFlags flags = {};
2193 uint8_t vps_video_parameter_set_id = {};
2194 uint8_t vps_max_sub_layers_minus1 = {};
2195 uint8_t reserved1 = {};
2196 uint8_t reserved2 = {};
2197 uint32_t vps_num_units_in_tick = {};
2198 uint32_t vps_time_scale = {};
2199 uint32_t vps_num_ticks_poc_diff_one_minus1 = {};
2200 uint32_t reserved3 = {};
2201 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265DecPicBufMgr * pDecPicBufMgr = {};
2202 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdParameters * pHrdParameters = {};
2203 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevel * pProfileTierLevel = {};
2204 };
2205
2206 struct H265ScalingLists
2207 {
2208 using NativeType = StdVideoH265ScalingLists;
2209
2210 operator StdVideoH265ScalingLists const &() const VULKAN_HPP_NOEXCEPT
2211 {
2212 return *reinterpret_cast<const StdVideoH265ScalingLists *>( this );
2213 }
2214
2215 operator StdVideoH265ScalingLists &() VULKAN_HPP_NOEXCEPT
2216 {
2217 return *reinterpret_cast<StdVideoH265ScalingLists *>( this );
2218 }
2219
2220 operator StdVideoH265ScalingLists const *() const VULKAN_HPP_NOEXCEPT
2221 {
2222 return reinterpret_cast<const StdVideoH265ScalingLists *>( this );
2223 }
2224
2225 operator StdVideoH265ScalingLists *() VULKAN_HPP_NOEXCEPT
2226 {
2227 return reinterpret_cast<StdVideoH265ScalingLists *>( this );
2228 }
2229
2230 bool operator==( H265ScalingLists const & rhs ) const VULKAN_HPP_NOEXCEPT
2231 {
2232 return ( ScalingList4x4 == rhs.ScalingList4x4 ) && ( ScalingList8x8 == rhs.ScalingList8x8 ) && ( ScalingList16x16 == rhs.ScalingList16x16 ) &&
2233 ( ScalingList32x32 == rhs.ScalingList32x32 ) && ( ScalingListDCCoef16x16 == rhs.ScalingListDCCoef16x16 ) &&
2234 ( ScalingListDCCoef32x32 == rhs.ScalingListDCCoef32x32 );
2235 }
2236
2237 bool operator!=( H265ScalingLists const & rhs ) const VULKAN_HPP_NOEXCEPT
2238 {
2239 return !operator==( rhs );
2240 }
2241
2242 public:
2243 ArrayWrapper2D<uint8_t, STD_VIDEO_H265_SCALING_LIST_4X4_NUM_LISTS, STD_VIDEO_H265_SCALING_LIST_4X4_NUM_ELEMENTS> ScalingList4x4 = {};
2244 ArrayWrapper2D<uint8_t, STD_VIDEO_H265_SCALING_LIST_8X8_NUM_LISTS, STD_VIDEO_H265_SCALING_LIST_8X8_NUM_ELEMENTS> ScalingList8x8 = {};
2245 ArrayWrapper2D<uint8_t, STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS, STD_VIDEO_H265_SCALING_LIST_16X16_NUM_ELEMENTS> ScalingList16x16 = {};
2246 ArrayWrapper2D<uint8_t, STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS, STD_VIDEO_H265_SCALING_LIST_32X32_NUM_ELEMENTS> ScalingList32x32 = {};
2247 ArrayWrapper1D<uint8_t, STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS> ScalingListDCCoef16x16 = {};
2248 ArrayWrapper1D<uint8_t, STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS> ScalingListDCCoef32x32 = {};
2249 };
2250
2251 struct H265SpsVuiFlags
2252 {
2253 using NativeType = StdVideoH265SpsVuiFlags;
2254
2255 operator StdVideoH265SpsVuiFlags const &() const VULKAN_HPP_NOEXCEPT
2256 {
2257 return *reinterpret_cast<const StdVideoH265SpsVuiFlags *>( this );
2258 }
2259
2260 operator StdVideoH265SpsVuiFlags &() VULKAN_HPP_NOEXCEPT
2261 {
2262 return *reinterpret_cast<StdVideoH265SpsVuiFlags *>( this );
2263 }
2264
2265 operator StdVideoH265SpsVuiFlags const *() const VULKAN_HPP_NOEXCEPT
2266 {
2267 return reinterpret_cast<const StdVideoH265SpsVuiFlags *>( this );
2268 }
2269
2270 operator StdVideoH265SpsVuiFlags *() VULKAN_HPP_NOEXCEPT
2271 {
2272 return reinterpret_cast<StdVideoH265SpsVuiFlags *>( this );
2273 }
2274
2275 bool operator==( H265SpsVuiFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
2276 {
2277 return ( aspect_ratio_info_present_flag == rhs.aspect_ratio_info_present_flag ) && ( overscan_info_present_flag == rhs.overscan_info_present_flag ) &&
2278 ( overscan_appropriate_flag == rhs.overscan_appropriate_flag ) && ( video_signal_type_present_flag == rhs.video_signal_type_present_flag ) &&
2279 ( video_full_range_flag == rhs.video_full_range_flag ) && ( colour_description_present_flag == rhs.colour_description_present_flag ) &&
2280 ( chroma_loc_info_present_flag == rhs.chroma_loc_info_present_flag ) &&
2281 ( neutral_chroma_indication_flag == rhs.neutral_chroma_indication_flag ) && ( field_seq_flag == rhs.field_seq_flag ) &&
2282 ( frame_field_info_present_flag == rhs.frame_field_info_present_flag ) && ( default_display_window_flag == rhs.default_display_window_flag ) &&
2283 ( vui_timing_info_present_flag == rhs.vui_timing_info_present_flag ) &&
2284 ( vui_poc_proportional_to_timing_flag == rhs.vui_poc_proportional_to_timing_flag ) &&
2285 ( vui_hrd_parameters_present_flag == rhs.vui_hrd_parameters_present_flag ) && ( bitstream_restriction_flag == rhs.bitstream_restriction_flag ) &&
2286 ( tiles_fixed_structure_flag == rhs.tiles_fixed_structure_flag ) &&
2287 ( motion_vectors_over_pic_boundaries_flag == rhs.motion_vectors_over_pic_boundaries_flag ) &&
2288 ( restricted_ref_pic_lists_flag == rhs.restricted_ref_pic_lists_flag );
2289 }
2290
2291 bool operator!=( H265SpsVuiFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
2292 {
2293 return !operator==( rhs );
2294 }
2295
2296 public:
2297 uint32_t aspect_ratio_info_present_flag : 1;
2298 uint32_t overscan_info_present_flag : 1;
2299 uint32_t overscan_appropriate_flag : 1;
2300 uint32_t video_signal_type_present_flag : 1;
2301 uint32_t video_full_range_flag : 1;
2302 uint32_t colour_description_present_flag : 1;
2303 uint32_t chroma_loc_info_present_flag : 1;
2304 uint32_t neutral_chroma_indication_flag : 1;
2305 uint32_t field_seq_flag : 1;
2306 uint32_t frame_field_info_present_flag : 1;
2307 uint32_t default_display_window_flag : 1;
2308 uint32_t vui_timing_info_present_flag : 1;
2309 uint32_t vui_poc_proportional_to_timing_flag : 1;
2310 uint32_t vui_hrd_parameters_present_flag : 1;
2311 uint32_t bitstream_restriction_flag : 1;
2312 uint32_t tiles_fixed_structure_flag : 1;
2313 uint32_t motion_vectors_over_pic_boundaries_flag : 1;
2314 uint32_t restricted_ref_pic_lists_flag : 1;
2315 };
2316
2317 struct H265SequenceParameterSetVui
2318 {
2319 using NativeType = StdVideoH265SequenceParameterSetVui;
2320
2321 operator StdVideoH265SequenceParameterSetVui const &() const VULKAN_HPP_NOEXCEPT
2322 {
2323 return *reinterpret_cast<const StdVideoH265SequenceParameterSetVui *>( this );
2324 }
2325
2326 operator StdVideoH265SequenceParameterSetVui &() VULKAN_HPP_NOEXCEPT
2327 {
2328 return *reinterpret_cast<StdVideoH265SequenceParameterSetVui *>( this );
2329 }
2330
2331 operator StdVideoH265SequenceParameterSetVui const *() const VULKAN_HPP_NOEXCEPT
2332 {
2333 return reinterpret_cast<const StdVideoH265SequenceParameterSetVui *>( this );
2334 }
2335
2336 operator StdVideoH265SequenceParameterSetVui *() VULKAN_HPP_NOEXCEPT
2337 {
2338 return reinterpret_cast<StdVideoH265SequenceParameterSetVui *>( this );
2339 }
2340
2341 bool operator==( H265SequenceParameterSetVui const & rhs ) const VULKAN_HPP_NOEXCEPT
2342 {
2343 return ( flags == rhs.flags ) && ( aspect_ratio_idc == rhs.aspect_ratio_idc ) && ( sar_width == rhs.sar_width ) && ( sar_height == rhs.sar_height ) &&
2344 ( video_format == rhs.video_format ) && ( colour_primaries == rhs.colour_primaries ) &&
2345 ( transfer_characteristics == rhs.transfer_characteristics ) && ( matrix_coeffs == rhs.matrix_coeffs ) &&
2346 ( chroma_sample_loc_type_top_field == rhs.chroma_sample_loc_type_top_field ) &&
2347 ( chroma_sample_loc_type_bottom_field == rhs.chroma_sample_loc_type_bottom_field ) && ( reserved1 == rhs.reserved1 ) &&
2348 ( reserved2 == rhs.reserved2 ) && ( def_disp_win_left_offset == rhs.def_disp_win_left_offset ) &&
2349 ( def_disp_win_right_offset == rhs.def_disp_win_right_offset ) && ( def_disp_win_top_offset == rhs.def_disp_win_top_offset ) &&
2350 ( def_disp_win_bottom_offset == rhs.def_disp_win_bottom_offset ) && ( vui_num_units_in_tick == rhs.vui_num_units_in_tick ) &&
2351 ( vui_time_scale == rhs.vui_time_scale ) && ( vui_num_ticks_poc_diff_one_minus1 == rhs.vui_num_ticks_poc_diff_one_minus1 ) &&
2352 ( min_spatial_segmentation_idc == rhs.min_spatial_segmentation_idc ) && ( reserved3 == rhs.reserved3 ) &&
2353 ( max_bytes_per_pic_denom == rhs.max_bytes_per_pic_denom ) && ( max_bits_per_min_cu_denom == rhs.max_bits_per_min_cu_denom ) &&
2354 ( log2_max_mv_length_horizontal == rhs.log2_max_mv_length_horizontal ) && ( log2_max_mv_length_vertical == rhs.log2_max_mv_length_vertical ) &&
2355 ( pHrdParameters == rhs.pHrdParameters );
2356 }
2357
2358 bool operator!=( H265SequenceParameterSetVui const & rhs ) const VULKAN_HPP_NOEXCEPT
2359 {
2360 return !operator==( rhs );
2361 }
2362
2363 public:
2364 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SpsVuiFlags flags = {};
2365 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265AspectRatioIdc aspect_ratio_idc =
2366 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265AspectRatioIdc::eUnspecified;
2367 uint16_t sar_width = {};
2368 uint16_t sar_height = {};
2369 uint8_t video_format = {};
2370 uint8_t colour_primaries = {};
2371 uint8_t transfer_characteristics = {};
2372 uint8_t matrix_coeffs = {};
2373 uint8_t chroma_sample_loc_type_top_field = {};
2374 uint8_t chroma_sample_loc_type_bottom_field = {};
2375 uint8_t reserved1 = {};
2376 uint8_t reserved2 = {};
2377 uint16_t def_disp_win_left_offset = {};
2378 uint16_t def_disp_win_right_offset = {};
2379 uint16_t def_disp_win_top_offset = {};
2380 uint16_t def_disp_win_bottom_offset = {};
2381 uint32_t vui_num_units_in_tick = {};
2382 uint32_t vui_time_scale = {};
2383 uint32_t vui_num_ticks_poc_diff_one_minus1 = {};
2384 uint16_t min_spatial_segmentation_idc = {};
2385 uint16_t reserved3 = {};
2386 uint8_t max_bytes_per_pic_denom = {};
2387 uint8_t max_bits_per_min_cu_denom = {};
2388 uint8_t log2_max_mv_length_horizontal = {};
2389 uint8_t log2_max_mv_length_vertical = {};
2390 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdParameters * pHrdParameters = {};
2391 };
2392
2393 struct H265PredictorPaletteEntries
2394 {
2395 using NativeType = StdVideoH265PredictorPaletteEntries;
2396
2397 operator StdVideoH265PredictorPaletteEntries const &() const VULKAN_HPP_NOEXCEPT
2398 {
2399 return *reinterpret_cast<const StdVideoH265PredictorPaletteEntries *>( this );
2400 }
2401
2402 operator StdVideoH265PredictorPaletteEntries &() VULKAN_HPP_NOEXCEPT
2403 {
2404 return *reinterpret_cast<StdVideoH265PredictorPaletteEntries *>( this );
2405 }
2406
2407 operator StdVideoH265PredictorPaletteEntries const *() const VULKAN_HPP_NOEXCEPT
2408 {
2409 return reinterpret_cast<const StdVideoH265PredictorPaletteEntries *>( this );
2410 }
2411
2412 operator StdVideoH265PredictorPaletteEntries *() VULKAN_HPP_NOEXCEPT
2413 {
2414 return reinterpret_cast<StdVideoH265PredictorPaletteEntries *>( this );
2415 }
2416
2417 bool operator==( H265PredictorPaletteEntries const & rhs ) const VULKAN_HPP_NOEXCEPT
2418 {
2419 return ( PredictorPaletteEntries == rhs.PredictorPaletteEntries );
2420 }
2421
2422 bool operator!=( H265PredictorPaletteEntries const & rhs ) const VULKAN_HPP_NOEXCEPT
2423 {
2424 return !operator==( rhs );
2425 }
2426
2427 public:
2428 ArrayWrapper2D<uint16_t, STD_VIDEO_H265_PREDICTOR_PALETTE_COMPONENTS_LIST_SIZE, STD_VIDEO_H265_PREDICTOR_PALETTE_COMP_ENTRIES_LIST_SIZE>
2429 PredictorPaletteEntries = {};
2430 };
2431
2432 struct H265SpsFlags
2433 {
2434 using NativeType = StdVideoH265SpsFlags;
2435
2436 operator StdVideoH265SpsFlags const &() const VULKAN_HPP_NOEXCEPT
2437 {
2438 return *reinterpret_cast<const StdVideoH265SpsFlags *>( this );
2439 }
2440
2441 operator StdVideoH265SpsFlags &() VULKAN_HPP_NOEXCEPT
2442 {
2443 return *reinterpret_cast<StdVideoH265SpsFlags *>( this );
2444 }
2445
2446 operator StdVideoH265SpsFlags const *() const VULKAN_HPP_NOEXCEPT
2447 {
2448 return reinterpret_cast<const StdVideoH265SpsFlags *>( this );
2449 }
2450
2451 operator StdVideoH265SpsFlags *() VULKAN_HPP_NOEXCEPT
2452 {
2453 return reinterpret_cast<StdVideoH265SpsFlags *>( this );
2454 }
2455
2456 bool operator==( H265SpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
2457 {
2458 return ( sps_temporal_id_nesting_flag == rhs.sps_temporal_id_nesting_flag ) && ( separate_colour_plane_flag == rhs.separate_colour_plane_flag ) &&
2459 ( conformance_window_flag == rhs.conformance_window_flag ) &&
2460 ( sps_sub_layer_ordering_info_present_flag == rhs.sps_sub_layer_ordering_info_present_flag ) &&
2461 ( scaling_list_enabled_flag == rhs.scaling_list_enabled_flag ) &&
2462 ( sps_scaling_list_data_present_flag == rhs.sps_scaling_list_data_present_flag ) && ( amp_enabled_flag == rhs.amp_enabled_flag ) &&
2463 ( sample_adaptive_offset_enabled_flag == rhs.sample_adaptive_offset_enabled_flag ) && ( pcm_enabled_flag == rhs.pcm_enabled_flag ) &&
2464 ( pcm_loop_filter_disabled_flag == rhs.pcm_loop_filter_disabled_flag ) &&
2465 ( long_term_ref_pics_present_flag == rhs.long_term_ref_pics_present_flag ) &&
2466 ( sps_temporal_mvp_enabled_flag == rhs.sps_temporal_mvp_enabled_flag ) &&
2467 ( strong_intra_smoothing_enabled_flag == rhs.strong_intra_smoothing_enabled_flag ) &&
2468 ( vui_parameters_present_flag == rhs.vui_parameters_present_flag ) && ( sps_extension_present_flag == rhs.sps_extension_present_flag ) &&
2469 ( sps_range_extension_flag == rhs.sps_range_extension_flag ) &&
2470 ( transform_skip_rotation_enabled_flag == rhs.transform_skip_rotation_enabled_flag ) &&
2471 ( transform_skip_context_enabled_flag == rhs.transform_skip_context_enabled_flag ) &&
2472 ( implicit_rdpcm_enabled_flag == rhs.implicit_rdpcm_enabled_flag ) && ( explicit_rdpcm_enabled_flag == rhs.explicit_rdpcm_enabled_flag ) &&
2473 ( extended_precision_processing_flag == rhs.extended_precision_processing_flag ) &&
2474 ( intra_smoothing_disabled_flag == rhs.intra_smoothing_disabled_flag ) &&
2475 ( high_precision_offsets_enabled_flag == rhs.high_precision_offsets_enabled_flag ) &&
2476 ( persistent_rice_adaptation_enabled_flag == rhs.persistent_rice_adaptation_enabled_flag ) &&
2477 ( cabac_bypass_alignment_enabled_flag == rhs.cabac_bypass_alignment_enabled_flag ) && ( sps_scc_extension_flag == rhs.sps_scc_extension_flag ) &&
2478 ( sps_curr_pic_ref_enabled_flag == rhs.sps_curr_pic_ref_enabled_flag ) && ( palette_mode_enabled_flag == rhs.palette_mode_enabled_flag ) &&
2479 ( sps_palette_predictor_initializers_present_flag == rhs.sps_palette_predictor_initializers_present_flag ) &&
2480 ( intra_boundary_filtering_disabled_flag == rhs.intra_boundary_filtering_disabled_flag );
2481 }
2482
2483 bool operator!=( H265SpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
2484 {
2485 return !operator==( rhs );
2486 }
2487
2488 public:
2489 uint32_t sps_temporal_id_nesting_flag : 1;
2490 uint32_t separate_colour_plane_flag : 1;
2491 uint32_t conformance_window_flag : 1;
2492 uint32_t sps_sub_layer_ordering_info_present_flag : 1;
2493 uint32_t scaling_list_enabled_flag : 1;
2494 uint32_t sps_scaling_list_data_present_flag : 1;
2495 uint32_t amp_enabled_flag : 1;
2496 uint32_t sample_adaptive_offset_enabled_flag : 1;
2497 uint32_t pcm_enabled_flag : 1;
2498 uint32_t pcm_loop_filter_disabled_flag : 1;
2499 uint32_t long_term_ref_pics_present_flag : 1;
2500 uint32_t sps_temporal_mvp_enabled_flag : 1;
2501 uint32_t strong_intra_smoothing_enabled_flag : 1;
2502 uint32_t vui_parameters_present_flag : 1;
2503 uint32_t sps_extension_present_flag : 1;
2504 uint32_t sps_range_extension_flag : 1;
2505 uint32_t transform_skip_rotation_enabled_flag : 1;
2506 uint32_t transform_skip_context_enabled_flag : 1;
2507 uint32_t implicit_rdpcm_enabled_flag : 1;
2508 uint32_t explicit_rdpcm_enabled_flag : 1;
2509 uint32_t extended_precision_processing_flag : 1;
2510 uint32_t intra_smoothing_disabled_flag : 1;
2511 uint32_t high_precision_offsets_enabled_flag : 1;
2512 uint32_t persistent_rice_adaptation_enabled_flag : 1;
2513 uint32_t cabac_bypass_alignment_enabled_flag : 1;
2514 uint32_t sps_scc_extension_flag : 1;
2515 uint32_t sps_curr_pic_ref_enabled_flag : 1;
2516 uint32_t palette_mode_enabled_flag : 1;
2517 uint32_t sps_palette_predictor_initializers_present_flag : 1;
2518 uint32_t intra_boundary_filtering_disabled_flag : 1;
2519 };
2520
2521 struct H265ShortTermRefPicSetFlags
2522 {
2523 using NativeType = StdVideoH265ShortTermRefPicSetFlags;
2524
2525 operator StdVideoH265ShortTermRefPicSetFlags const &() const VULKAN_HPP_NOEXCEPT
2526 {
2527 return *reinterpret_cast<const StdVideoH265ShortTermRefPicSetFlags *>( this );
2528 }
2529
2530 operator StdVideoH265ShortTermRefPicSetFlags &() VULKAN_HPP_NOEXCEPT
2531 {
2532 return *reinterpret_cast<StdVideoH265ShortTermRefPicSetFlags *>( this );
2533 }
2534
2535 operator StdVideoH265ShortTermRefPicSetFlags const *() const VULKAN_HPP_NOEXCEPT
2536 {
2537 return reinterpret_cast<const StdVideoH265ShortTermRefPicSetFlags *>( this );
2538 }
2539
2540 operator StdVideoH265ShortTermRefPicSetFlags *() VULKAN_HPP_NOEXCEPT
2541 {
2542 return reinterpret_cast<StdVideoH265ShortTermRefPicSetFlags *>( this );
2543 }
2544
2545 bool operator==( H265ShortTermRefPicSetFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
2546 {
2547 return ( inter_ref_pic_set_prediction_flag == rhs.inter_ref_pic_set_prediction_flag ) && ( delta_rps_sign == rhs.delta_rps_sign );
2548 }
2549
2550 bool operator!=( H265ShortTermRefPicSetFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
2551 {
2552 return !operator==( rhs );
2553 }
2554
2555 public:
2556 uint32_t inter_ref_pic_set_prediction_flag : 1;
2557 uint32_t delta_rps_sign : 1;
2558 };
2559
2560 struct H265ShortTermRefPicSet
2561 {
2562 using NativeType = StdVideoH265ShortTermRefPicSet;
2563
2564 operator StdVideoH265ShortTermRefPicSet const &() const VULKAN_HPP_NOEXCEPT
2565 {
2566 return *reinterpret_cast<const StdVideoH265ShortTermRefPicSet *>( this );
2567 }
2568
2569 operator StdVideoH265ShortTermRefPicSet &() VULKAN_HPP_NOEXCEPT
2570 {
2571 return *reinterpret_cast<StdVideoH265ShortTermRefPicSet *>( this );
2572 }
2573
2574 operator StdVideoH265ShortTermRefPicSet const *() const VULKAN_HPP_NOEXCEPT
2575 {
2576 return reinterpret_cast<const StdVideoH265ShortTermRefPicSet *>( this );
2577 }
2578
2579 operator StdVideoH265ShortTermRefPicSet *() VULKAN_HPP_NOEXCEPT
2580 {
2581 return reinterpret_cast<StdVideoH265ShortTermRefPicSet *>( this );
2582 }
2583
2584 bool operator==( H265ShortTermRefPicSet const & rhs ) const VULKAN_HPP_NOEXCEPT
2585 {
2586 return ( flags == rhs.flags ) && ( delta_idx_minus1 == rhs.delta_idx_minus1 ) && ( use_delta_flag == rhs.use_delta_flag ) &&
2587 ( abs_delta_rps_minus1 == rhs.abs_delta_rps_minus1 ) && ( used_by_curr_pic_flag == rhs.used_by_curr_pic_flag ) &&
2588 ( 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 ) &&
2589 ( reserved1 == rhs.reserved1 ) && ( reserved2 == rhs.reserved2 ) && ( reserved3 == rhs.reserved3 ) &&
2590 ( num_negative_pics == rhs.num_negative_pics ) && ( num_positive_pics == rhs.num_positive_pics ) &&
2591 ( delta_poc_s0_minus1 == rhs.delta_poc_s0_minus1 ) && ( delta_poc_s1_minus1 == rhs.delta_poc_s1_minus1 );
2592 }
2593
2594 bool operator!=( H265ShortTermRefPicSet const & rhs ) const VULKAN_HPP_NOEXCEPT
2595 {
2596 return !operator==( rhs );
2597 }
2598
2599 public:
2600 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSetFlags flags = {};
2601 uint32_t delta_idx_minus1 = {};
2602 uint16_t use_delta_flag = {};
2603 uint16_t abs_delta_rps_minus1 = {};
2604 uint16_t used_by_curr_pic_flag = {};
2605 uint16_t used_by_curr_pic_s0_flag = {};
2606 uint16_t used_by_curr_pic_s1_flag = {};
2607 uint16_t reserved1 = {};
2608 uint8_t reserved2 = {};
2609 uint8_t reserved3 = {};
2610 uint8_t num_negative_pics = {};
2611 uint8_t num_positive_pics = {};
2612 ArrayWrapper1D<uint16_t, STD_VIDEO_H265_MAX_DPB_SIZE> delta_poc_s0_minus1 = {};
2613 ArrayWrapper1D<uint16_t, STD_VIDEO_H265_MAX_DPB_SIZE> delta_poc_s1_minus1 = {};
2614 };
2615
2616 struct H265LongTermRefPicsSps
2617 {
2618 using NativeType = StdVideoH265LongTermRefPicsSps;
2619
2620 operator StdVideoH265LongTermRefPicsSps const &() const VULKAN_HPP_NOEXCEPT
2621 {
2622 return *reinterpret_cast<const StdVideoH265LongTermRefPicsSps *>( this );
2623 }
2624
2625 operator StdVideoH265LongTermRefPicsSps &() VULKAN_HPP_NOEXCEPT
2626 {
2627 return *reinterpret_cast<StdVideoH265LongTermRefPicsSps *>( this );
2628 }
2629
2630 operator StdVideoH265LongTermRefPicsSps const *() const VULKAN_HPP_NOEXCEPT
2631 {
2632 return reinterpret_cast<const StdVideoH265LongTermRefPicsSps *>( this );
2633 }
2634
2635 operator StdVideoH265LongTermRefPicsSps *() VULKAN_HPP_NOEXCEPT
2636 {
2637 return reinterpret_cast<StdVideoH265LongTermRefPicsSps *>( this );
2638 }
2639
2640 bool operator==( H265LongTermRefPicsSps const & rhs ) const VULKAN_HPP_NOEXCEPT
2641 {
2642 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 );
2643 }
2644
2645 bool operator!=( H265LongTermRefPicsSps const & rhs ) const VULKAN_HPP_NOEXCEPT
2646 {
2647 return !operator==( rhs );
2648 }
2649
2650 public:
2651 uint32_t used_by_curr_pic_lt_sps_flag = {};
2652 ArrayWrapper1D<uint32_t, STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS> lt_ref_pic_poc_lsb_sps = {};
2653 };
2654
2655 struct H265SequenceParameterSet
2656 {
2657 using NativeType = StdVideoH265SequenceParameterSet;
2658
2659 operator StdVideoH265SequenceParameterSet const &() const VULKAN_HPP_NOEXCEPT
2660 {
2661 return *reinterpret_cast<const StdVideoH265SequenceParameterSet *>( this );
2662 }
2663
2664 operator StdVideoH265SequenceParameterSet &() VULKAN_HPP_NOEXCEPT
2665 {
2666 return *reinterpret_cast<StdVideoH265SequenceParameterSet *>( this );
2667 }
2668
2669 operator StdVideoH265SequenceParameterSet const *() const VULKAN_HPP_NOEXCEPT
2670 {
2671 return reinterpret_cast<const StdVideoH265SequenceParameterSet *>( this );
2672 }
2673
2674 operator StdVideoH265SequenceParameterSet *() VULKAN_HPP_NOEXCEPT
2675 {
2676 return reinterpret_cast<StdVideoH265SequenceParameterSet *>( this );
2677 }
2678
2679 bool operator==( H265SequenceParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT
2680 {
2681 return ( flags == rhs.flags ) && ( chroma_format_idc == rhs.chroma_format_idc ) && ( pic_width_in_luma_samples == rhs.pic_width_in_luma_samples ) &&
2682 ( pic_height_in_luma_samples == rhs.pic_height_in_luma_samples ) && ( sps_video_parameter_set_id == rhs.sps_video_parameter_set_id ) &&
2683 ( sps_max_sub_layers_minus1 == rhs.sps_max_sub_layers_minus1 ) && ( sps_seq_parameter_set_id == rhs.sps_seq_parameter_set_id ) &&
2684 ( bit_depth_luma_minus8 == rhs.bit_depth_luma_minus8 ) && ( bit_depth_chroma_minus8 == rhs.bit_depth_chroma_minus8 ) &&
2685 ( log2_max_pic_order_cnt_lsb_minus4 == rhs.log2_max_pic_order_cnt_lsb_minus4 ) &&
2686 ( log2_min_luma_coding_block_size_minus3 == rhs.log2_min_luma_coding_block_size_minus3 ) &&
2687 ( log2_diff_max_min_luma_coding_block_size == rhs.log2_diff_max_min_luma_coding_block_size ) &&
2688 ( log2_min_luma_transform_block_size_minus2 == rhs.log2_min_luma_transform_block_size_minus2 ) &&
2689 ( log2_diff_max_min_luma_transform_block_size == rhs.log2_diff_max_min_luma_transform_block_size ) &&
2690 ( max_transform_hierarchy_depth_inter == rhs.max_transform_hierarchy_depth_inter ) &&
2691 ( max_transform_hierarchy_depth_intra == rhs.max_transform_hierarchy_depth_intra ) &&
2692 ( 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 ) &&
2693 ( pcm_sample_bit_depth_luma_minus1 == rhs.pcm_sample_bit_depth_luma_minus1 ) &&
2694 ( pcm_sample_bit_depth_chroma_minus1 == rhs.pcm_sample_bit_depth_chroma_minus1 ) &&
2695 ( log2_min_pcm_luma_coding_block_size_minus3 == rhs.log2_min_pcm_luma_coding_block_size_minus3 ) &&
2696 ( log2_diff_max_min_pcm_luma_coding_block_size == rhs.log2_diff_max_min_pcm_luma_coding_block_size ) && ( reserved1 == rhs.reserved1 ) &&
2697 ( reserved2 == rhs.reserved2 ) && ( palette_max_size == rhs.palette_max_size ) &&
2698 ( delta_palette_max_predictor_size == rhs.delta_palette_max_predictor_size ) &&
2699 ( motion_vector_resolution_control_idc == rhs.motion_vector_resolution_control_idc ) &&
2700 ( sps_num_palette_predictor_initializers_minus1 == rhs.sps_num_palette_predictor_initializers_minus1 ) &&
2701 ( conf_win_left_offset == rhs.conf_win_left_offset ) && ( conf_win_right_offset == rhs.conf_win_right_offset ) &&
2702 ( conf_win_top_offset == rhs.conf_win_top_offset ) && ( conf_win_bottom_offset == rhs.conf_win_bottom_offset ) &&
2703 ( pProfileTierLevel == rhs.pProfileTierLevel ) && ( pDecPicBufMgr == rhs.pDecPicBufMgr ) && ( pScalingLists == rhs.pScalingLists ) &&
2704 ( pShortTermRefPicSet == rhs.pShortTermRefPicSet ) && ( pLongTermRefPicsSps == rhs.pLongTermRefPicsSps ) &&
2705 ( pSequenceParameterSetVui == rhs.pSequenceParameterSetVui ) && ( pPredictorPaletteEntries == rhs.pPredictorPaletteEntries );
2706 }
2707
2708 bool operator!=( H265SequenceParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT
2709 {
2710 return !operator==( rhs );
2711 }
2712
2713 public:
2714 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SpsFlags flags = {};
2715 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ChromaFormatIdc chroma_format_idc =
2716 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ChromaFormatIdc::eMonochrome;
2717 uint32_t pic_width_in_luma_samples = {};
2718 uint32_t pic_height_in_luma_samples = {};
2719 uint8_t sps_video_parameter_set_id = {};
2720 uint8_t sps_max_sub_layers_minus1 = {};
2721 uint8_t sps_seq_parameter_set_id = {};
2722 uint8_t bit_depth_luma_minus8 = {};
2723 uint8_t bit_depth_chroma_minus8 = {};
2724 uint8_t log2_max_pic_order_cnt_lsb_minus4 = {};
2725 uint8_t log2_min_luma_coding_block_size_minus3 = {};
2726 uint8_t log2_diff_max_min_luma_coding_block_size = {};
2727 uint8_t log2_min_luma_transform_block_size_minus2 = {};
2728 uint8_t log2_diff_max_min_luma_transform_block_size = {};
2729 uint8_t max_transform_hierarchy_depth_inter = {};
2730 uint8_t max_transform_hierarchy_depth_intra = {};
2731 uint8_t num_short_term_ref_pic_sets = {};
2732 uint8_t num_long_term_ref_pics_sps = {};
2733 uint8_t pcm_sample_bit_depth_luma_minus1 = {};
2734 uint8_t pcm_sample_bit_depth_chroma_minus1 = {};
2735 uint8_t log2_min_pcm_luma_coding_block_size_minus3 = {};
2736 uint8_t log2_diff_max_min_pcm_luma_coding_block_size = {};
2737 uint8_t reserved1 = {};
2738 uint8_t reserved2 = {};
2739 uint8_t palette_max_size = {};
2740 uint8_t delta_palette_max_predictor_size = {};
2741 uint8_t motion_vector_resolution_control_idc = {};
2742 uint8_t sps_num_palette_predictor_initializers_minus1 = {};
2743 uint32_t conf_win_left_offset = {};
2744 uint32_t conf_win_right_offset = {};
2745 uint32_t conf_win_top_offset = {};
2746 uint32_t conf_win_bottom_offset = {};
2747 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevel * pProfileTierLevel = {};
2748 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265DecPicBufMgr * pDecPicBufMgr = {};
2749 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingLists * pScalingLists = {};
2750 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSet * pShortTermRefPicSet = {};
2751 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265LongTermRefPicsSps * pLongTermRefPicsSps = {};
2752 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SequenceParameterSetVui * pSequenceParameterSetVui = {};
2753 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PredictorPaletteEntries * pPredictorPaletteEntries = {};
2754 };
2755
2756 struct H265PpsFlags
2757 {
2758 using NativeType = StdVideoH265PpsFlags;
2759
2760 operator StdVideoH265PpsFlags const &() const VULKAN_HPP_NOEXCEPT
2761 {
2762 return *reinterpret_cast<const StdVideoH265PpsFlags *>( this );
2763 }
2764
2765 operator StdVideoH265PpsFlags &() VULKAN_HPP_NOEXCEPT
2766 {
2767 return *reinterpret_cast<StdVideoH265PpsFlags *>( this );
2768 }
2769
2770 operator StdVideoH265PpsFlags const *() const VULKAN_HPP_NOEXCEPT
2771 {
2772 return reinterpret_cast<const StdVideoH265PpsFlags *>( this );
2773 }
2774
2775 operator StdVideoH265PpsFlags *() VULKAN_HPP_NOEXCEPT
2776 {
2777 return reinterpret_cast<StdVideoH265PpsFlags *>( this );
2778 }
2779
2780 bool operator==( H265PpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
2781 {
2782 return ( dependent_slice_segments_enabled_flag == rhs.dependent_slice_segments_enabled_flag ) &&
2783 ( output_flag_present_flag == rhs.output_flag_present_flag ) && ( sign_data_hiding_enabled_flag == rhs.sign_data_hiding_enabled_flag ) &&
2784 ( cabac_init_present_flag == rhs.cabac_init_present_flag ) && ( constrained_intra_pred_flag == rhs.constrained_intra_pred_flag ) &&
2785 ( transform_skip_enabled_flag == rhs.transform_skip_enabled_flag ) && ( cu_qp_delta_enabled_flag == rhs.cu_qp_delta_enabled_flag ) &&
2786 ( pps_slice_chroma_qp_offsets_present_flag == rhs.pps_slice_chroma_qp_offsets_present_flag ) &&
2787 ( weighted_pred_flag == rhs.weighted_pred_flag ) && ( weighted_bipred_flag == rhs.weighted_bipred_flag ) &&
2788 ( transquant_bypass_enabled_flag == rhs.transquant_bypass_enabled_flag ) && ( tiles_enabled_flag == rhs.tiles_enabled_flag ) &&
2789 ( entropy_coding_sync_enabled_flag == rhs.entropy_coding_sync_enabled_flag ) && ( uniform_spacing_flag == rhs.uniform_spacing_flag ) &&
2790 ( loop_filter_across_tiles_enabled_flag == rhs.loop_filter_across_tiles_enabled_flag ) &&
2791 ( pps_loop_filter_across_slices_enabled_flag == rhs.pps_loop_filter_across_slices_enabled_flag ) &&
2792 ( deblocking_filter_control_present_flag == rhs.deblocking_filter_control_present_flag ) &&
2793 ( deblocking_filter_override_enabled_flag == rhs.deblocking_filter_override_enabled_flag ) &&
2794 ( pps_deblocking_filter_disabled_flag == rhs.pps_deblocking_filter_disabled_flag ) &&
2795 ( pps_scaling_list_data_present_flag == rhs.pps_scaling_list_data_present_flag ) &&
2796 ( lists_modification_present_flag == rhs.lists_modification_present_flag ) &&
2797 ( slice_segment_header_extension_present_flag == rhs.slice_segment_header_extension_present_flag ) &&
2798 ( pps_extension_present_flag == rhs.pps_extension_present_flag ) &&
2799 ( cross_component_prediction_enabled_flag == rhs.cross_component_prediction_enabled_flag ) &&
2800 ( chroma_qp_offset_list_enabled_flag == rhs.chroma_qp_offset_list_enabled_flag ) &&
2801 ( pps_curr_pic_ref_enabled_flag == rhs.pps_curr_pic_ref_enabled_flag ) &&
2802 ( residual_adaptive_colour_transform_enabled_flag == rhs.residual_adaptive_colour_transform_enabled_flag ) &&
2803 ( pps_slice_act_qp_offsets_present_flag == rhs.pps_slice_act_qp_offsets_present_flag ) &&
2804 ( pps_palette_predictor_initializers_present_flag == rhs.pps_palette_predictor_initializers_present_flag ) &&
2805 ( monochrome_palette_flag == rhs.monochrome_palette_flag ) && ( pps_range_extension_flag == rhs.pps_range_extension_flag );
2806 }
2807
2808 bool operator!=( H265PpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
2809 {
2810 return !operator==( rhs );
2811 }
2812
2813 public:
2814 uint32_t dependent_slice_segments_enabled_flag : 1;
2815 uint32_t output_flag_present_flag : 1;
2816 uint32_t sign_data_hiding_enabled_flag : 1;
2817 uint32_t cabac_init_present_flag : 1;
2818 uint32_t constrained_intra_pred_flag : 1;
2819 uint32_t transform_skip_enabled_flag : 1;
2820 uint32_t cu_qp_delta_enabled_flag : 1;
2821 uint32_t pps_slice_chroma_qp_offsets_present_flag : 1;
2822 uint32_t weighted_pred_flag : 1;
2823 uint32_t weighted_bipred_flag : 1;
2824 uint32_t transquant_bypass_enabled_flag : 1;
2825 uint32_t tiles_enabled_flag : 1;
2826 uint32_t entropy_coding_sync_enabled_flag : 1;
2827 uint32_t uniform_spacing_flag : 1;
2828 uint32_t loop_filter_across_tiles_enabled_flag : 1;
2829 uint32_t pps_loop_filter_across_slices_enabled_flag : 1;
2830 uint32_t deblocking_filter_control_present_flag : 1;
2831 uint32_t deblocking_filter_override_enabled_flag : 1;
2832 uint32_t pps_deblocking_filter_disabled_flag : 1;
2833 uint32_t pps_scaling_list_data_present_flag : 1;
2834 uint32_t lists_modification_present_flag : 1;
2835 uint32_t slice_segment_header_extension_present_flag : 1;
2836 uint32_t pps_extension_present_flag : 1;
2837 uint32_t cross_component_prediction_enabled_flag : 1;
2838 uint32_t chroma_qp_offset_list_enabled_flag : 1;
2839 uint32_t pps_curr_pic_ref_enabled_flag : 1;
2840 uint32_t residual_adaptive_colour_transform_enabled_flag : 1;
2841 uint32_t pps_slice_act_qp_offsets_present_flag : 1;
2842 uint32_t pps_palette_predictor_initializers_present_flag : 1;
2843 uint32_t monochrome_palette_flag : 1;
2844 uint32_t pps_range_extension_flag : 1;
2845 };
2846
2847 struct H265PictureParameterSet
2848 {
2849 using NativeType = StdVideoH265PictureParameterSet;
2850
2851 operator StdVideoH265PictureParameterSet const &() const VULKAN_HPP_NOEXCEPT
2852 {
2853 return *reinterpret_cast<const StdVideoH265PictureParameterSet *>( this );
2854 }
2855
2856 operator StdVideoH265PictureParameterSet &() VULKAN_HPP_NOEXCEPT
2857 {
2858 return *reinterpret_cast<StdVideoH265PictureParameterSet *>( this );
2859 }
2860
2861 operator StdVideoH265PictureParameterSet const *() const VULKAN_HPP_NOEXCEPT
2862 {
2863 return reinterpret_cast<const StdVideoH265PictureParameterSet *>( this );
2864 }
2865
2866 operator StdVideoH265PictureParameterSet *() VULKAN_HPP_NOEXCEPT
2867 {
2868 return reinterpret_cast<StdVideoH265PictureParameterSet *>( this );
2869 }
2870
2871 bool operator==( H265PictureParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT
2872 {
2873 return ( flags == rhs.flags ) && ( pps_pic_parameter_set_id == rhs.pps_pic_parameter_set_id ) &&
2874 ( pps_seq_parameter_set_id == rhs.pps_seq_parameter_set_id ) && ( sps_video_parameter_set_id == rhs.sps_video_parameter_set_id ) &&
2875 ( num_extra_slice_header_bits == rhs.num_extra_slice_header_bits ) &&
2876 ( num_ref_idx_l0_default_active_minus1 == rhs.num_ref_idx_l0_default_active_minus1 ) &&
2877 ( num_ref_idx_l1_default_active_minus1 == rhs.num_ref_idx_l1_default_active_minus1 ) && ( init_qp_minus26 == rhs.init_qp_minus26 ) &&
2878 ( diff_cu_qp_delta_depth == rhs.diff_cu_qp_delta_depth ) && ( pps_cb_qp_offset == rhs.pps_cb_qp_offset ) &&
2879 ( pps_cr_qp_offset == rhs.pps_cr_qp_offset ) && ( pps_beta_offset_div2 == rhs.pps_beta_offset_div2 ) &&
2880 ( pps_tc_offset_div2 == rhs.pps_tc_offset_div2 ) && ( log2_parallel_merge_level_minus2 == rhs.log2_parallel_merge_level_minus2 ) &&
2881 ( log2_max_transform_skip_block_size_minus2 == rhs.log2_max_transform_skip_block_size_minus2 ) &&
2882 ( diff_cu_chroma_qp_offset_depth == rhs.diff_cu_chroma_qp_offset_depth ) &&
2883 ( chroma_qp_offset_list_len_minus1 == rhs.chroma_qp_offset_list_len_minus1 ) && ( cb_qp_offset_list == rhs.cb_qp_offset_list ) &&
2884 ( cr_qp_offset_list == rhs.cr_qp_offset_list ) && ( log2_sao_offset_scale_luma == rhs.log2_sao_offset_scale_luma ) &&
2885 ( log2_sao_offset_scale_chroma == rhs.log2_sao_offset_scale_chroma ) && ( pps_act_y_qp_offset_plus5 == rhs.pps_act_y_qp_offset_plus5 ) &&
2886 ( 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 ) &&
2887 ( pps_num_palette_predictor_initializers == rhs.pps_num_palette_predictor_initializers ) &&
2888 ( luma_bit_depth_entry_minus8 == rhs.luma_bit_depth_entry_minus8 ) && ( chroma_bit_depth_entry_minus8 == rhs.chroma_bit_depth_entry_minus8 ) &&
2889 ( num_tile_columns_minus1 == rhs.num_tile_columns_minus1 ) && ( num_tile_rows_minus1 == rhs.num_tile_rows_minus1 ) &&
2890 ( reserved1 == rhs.reserved1 ) && ( reserved2 == rhs.reserved2 ) && ( column_width_minus1 == rhs.column_width_minus1 ) &&
2891 ( row_height_minus1 == rhs.row_height_minus1 ) && ( reserved3 == rhs.reserved3 ) && ( pScalingLists == rhs.pScalingLists ) &&
2892 ( pPredictorPaletteEntries == rhs.pPredictorPaletteEntries );
2893 }
2894
2895 bool operator!=( H265PictureParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT
2896 {
2897 return !operator==( rhs );
2898 }
2899
2900 public:
2901 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PpsFlags flags = {};
2902 uint8_t pps_pic_parameter_set_id = {};
2903 uint8_t pps_seq_parameter_set_id = {};
2904 uint8_t sps_video_parameter_set_id = {};
2905 uint8_t num_extra_slice_header_bits = {};
2906 uint8_t num_ref_idx_l0_default_active_minus1 = {};
2907 uint8_t num_ref_idx_l1_default_active_minus1 = {};
2908 int8_t init_qp_minus26 = {};
2909 uint8_t diff_cu_qp_delta_depth = {};
2910 int8_t pps_cb_qp_offset = {};
2911 int8_t pps_cr_qp_offset = {};
2912 int8_t pps_beta_offset_div2 = {};
2913 int8_t pps_tc_offset_div2 = {};
2914 uint8_t log2_parallel_merge_level_minus2 = {};
2915 uint8_t log2_max_transform_skip_block_size_minus2 = {};
2916 uint8_t diff_cu_chroma_qp_offset_depth = {};
2917 uint8_t chroma_qp_offset_list_len_minus1 = {};
2918 ArrayWrapper1D<int8_t, STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE> cb_qp_offset_list = {};
2919 ArrayWrapper1D<int8_t, STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE> cr_qp_offset_list = {};
2920 uint8_t log2_sao_offset_scale_luma = {};
2921 uint8_t log2_sao_offset_scale_chroma = {};
2922 int8_t pps_act_y_qp_offset_plus5 = {};
2923 int8_t pps_act_cb_qp_offset_plus5 = {};
2924 int8_t pps_act_cr_qp_offset_plus3 = {};
2925 uint8_t pps_num_palette_predictor_initializers = {};
2926 uint8_t luma_bit_depth_entry_minus8 = {};
2927 uint8_t chroma_bit_depth_entry_minus8 = {};
2928 uint8_t num_tile_columns_minus1 = {};
2929 uint8_t num_tile_rows_minus1 = {};
2930 uint8_t reserved1 = {};
2931 uint8_t reserved2 = {};
2932 ArrayWrapper1D<uint16_t, STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE> column_width_minus1 = {};
2933 ArrayWrapper1D<uint16_t, STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE> row_height_minus1 = {};
2934 uint32_t reserved3 = {};
2935 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingLists * pScalingLists = {};
2936 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PredictorPaletteEntries * pPredictorPaletteEntries = {};
2937 };
2938 #endif
2939
2940 #if defined( VULKAN_VIDEO_CODEC_H265STD_DECODE_H_ )
2941 //=== vulkan_video_codec_h265std_decode ===
2942
2943 struct DecodeH265PictureInfoFlags
2944 {
2945 using NativeType = StdVideoDecodeH265PictureInfoFlags;
2946
2947 operator StdVideoDecodeH265PictureInfoFlags const &() const VULKAN_HPP_NOEXCEPT
2948 {
2949 return *reinterpret_cast<const StdVideoDecodeH265PictureInfoFlags *>( this );
2950 }
2951
2952 operator StdVideoDecodeH265PictureInfoFlags &() VULKAN_HPP_NOEXCEPT
2953 {
2954 return *reinterpret_cast<StdVideoDecodeH265PictureInfoFlags *>( this );
2955 }
2956
2957 operator StdVideoDecodeH265PictureInfoFlags const *() const VULKAN_HPP_NOEXCEPT
2958 {
2959 return reinterpret_cast<const StdVideoDecodeH265PictureInfoFlags *>( this );
2960 }
2961
2962 operator StdVideoDecodeH265PictureInfoFlags *() VULKAN_HPP_NOEXCEPT
2963 {
2964 return reinterpret_cast<StdVideoDecodeH265PictureInfoFlags *>( this );
2965 }
2966
2967 bool operator==( DecodeH265PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
2968 {
2969 return ( IrapPicFlag == rhs.IrapPicFlag ) && ( IdrPicFlag == rhs.IdrPicFlag ) && ( IsReference == rhs.IsReference ) &&
2970 ( short_term_ref_pic_set_sps_flag == rhs.short_term_ref_pic_set_sps_flag );
2971 }
2972
2973 bool operator!=( DecodeH265PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
2974 {
2975 return !operator==( rhs );
2976 }
2977
2978 public:
2979 uint32_t IrapPicFlag : 1;
2980 uint32_t IdrPicFlag : 1;
2981 uint32_t IsReference : 1;
2982 uint32_t short_term_ref_pic_set_sps_flag : 1;
2983 };
2984
2985 struct DecodeH265PictureInfo
2986 {
2987 using NativeType = StdVideoDecodeH265PictureInfo;
2988
2989 operator StdVideoDecodeH265PictureInfo const &() const VULKAN_HPP_NOEXCEPT
2990 {
2991 return *reinterpret_cast<const StdVideoDecodeH265PictureInfo *>( this );
2992 }
2993
2994 operator StdVideoDecodeH265PictureInfo &() VULKAN_HPP_NOEXCEPT
2995 {
2996 return *reinterpret_cast<StdVideoDecodeH265PictureInfo *>( this );
2997 }
2998
2999 operator StdVideoDecodeH265PictureInfo const *() const VULKAN_HPP_NOEXCEPT
3000 {
3001 return reinterpret_cast<const StdVideoDecodeH265PictureInfo *>( this );
3002 }
3003
3004 operator StdVideoDecodeH265PictureInfo *() VULKAN_HPP_NOEXCEPT
3005 {
3006 return reinterpret_cast<StdVideoDecodeH265PictureInfo *>( this );
3007 }
3008
3009 bool operator==( DecodeH265PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
3010 {
3011 return ( flags == rhs.flags ) && ( sps_video_parameter_set_id == rhs.sps_video_parameter_set_id ) &&
3012 ( pps_seq_parameter_set_id == rhs.pps_seq_parameter_set_id ) && ( pps_pic_parameter_set_id == rhs.pps_pic_parameter_set_id ) &&
3013 ( NumDeltaPocsOfRefRpsIdx == rhs.NumDeltaPocsOfRefRpsIdx ) && ( PicOrderCntVal == rhs.PicOrderCntVal ) &&
3014 ( NumBitsForSTRefPicSetInSlice == rhs.NumBitsForSTRefPicSetInSlice ) && ( reserved == rhs.reserved ) &&
3015 ( RefPicSetStCurrBefore == rhs.RefPicSetStCurrBefore ) && ( RefPicSetStCurrAfter == rhs.RefPicSetStCurrAfter ) &&
3016 ( RefPicSetLtCurr == rhs.RefPicSetLtCurr );
3017 }
3018
3019 bool operator!=( DecodeH265PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
3020 {
3021 return !operator==( rhs );
3022 }
3023
3024 public:
3025 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265PictureInfoFlags flags = {};
3026 uint8_t sps_video_parameter_set_id = {};
3027 uint8_t pps_seq_parameter_set_id = {};
3028 uint8_t pps_pic_parameter_set_id = {};
3029 uint8_t NumDeltaPocsOfRefRpsIdx = {};
3030 int32_t PicOrderCntVal = {};
3031 uint16_t NumBitsForSTRefPicSetInSlice = {};
3032 uint16_t reserved = {};
3033 ArrayWrapper1D<uint8_t, STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE> RefPicSetStCurrBefore = {};
3034 ArrayWrapper1D<uint8_t, STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE> RefPicSetStCurrAfter = {};
3035 ArrayWrapper1D<uint8_t, STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE> RefPicSetLtCurr = {};
3036 };
3037
3038 struct DecodeH265ReferenceInfoFlags
3039 {
3040 using NativeType = StdVideoDecodeH265ReferenceInfoFlags;
3041
3042 operator StdVideoDecodeH265ReferenceInfoFlags const &() const VULKAN_HPP_NOEXCEPT
3043 {
3044 return *reinterpret_cast<const StdVideoDecodeH265ReferenceInfoFlags *>( this );
3045 }
3046
3047 operator StdVideoDecodeH265ReferenceInfoFlags &() VULKAN_HPP_NOEXCEPT
3048 {
3049 return *reinterpret_cast<StdVideoDecodeH265ReferenceInfoFlags *>( this );
3050 }
3051
3052 operator StdVideoDecodeH265ReferenceInfoFlags const *() const VULKAN_HPP_NOEXCEPT
3053 {
3054 return reinterpret_cast<const StdVideoDecodeH265ReferenceInfoFlags *>( this );
3055 }
3056
3057 operator StdVideoDecodeH265ReferenceInfoFlags *() VULKAN_HPP_NOEXCEPT
3058 {
3059 return reinterpret_cast<StdVideoDecodeH265ReferenceInfoFlags *>( this );
3060 }
3061
3062 bool operator==( DecodeH265ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
3063 {
3064 return ( used_for_long_term_reference == rhs.used_for_long_term_reference ) && ( unused_for_reference == rhs.unused_for_reference );
3065 }
3066
3067 bool operator!=( DecodeH265ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
3068 {
3069 return !operator==( rhs );
3070 }
3071
3072 public:
3073 uint32_t used_for_long_term_reference : 1;
3074 uint32_t unused_for_reference : 1;
3075 };
3076
3077 struct DecodeH265ReferenceInfo
3078 {
3079 using NativeType = StdVideoDecodeH265ReferenceInfo;
3080
3081 operator StdVideoDecodeH265ReferenceInfo const &() const VULKAN_HPP_NOEXCEPT
3082 {
3083 return *reinterpret_cast<const StdVideoDecodeH265ReferenceInfo *>( this );
3084 }
3085
3086 operator StdVideoDecodeH265ReferenceInfo &() VULKAN_HPP_NOEXCEPT
3087 {
3088 return *reinterpret_cast<StdVideoDecodeH265ReferenceInfo *>( this );
3089 }
3090
3091 operator StdVideoDecodeH265ReferenceInfo const *() const VULKAN_HPP_NOEXCEPT
3092 {
3093 return reinterpret_cast<const StdVideoDecodeH265ReferenceInfo *>( this );
3094 }
3095
3096 operator StdVideoDecodeH265ReferenceInfo *() VULKAN_HPP_NOEXCEPT
3097 {
3098 return reinterpret_cast<StdVideoDecodeH265ReferenceInfo *>( this );
3099 }
3100
3101 bool operator==( DecodeH265ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
3102 {
3103 return ( flags == rhs.flags ) && ( PicOrderCntVal == rhs.PicOrderCntVal );
3104 }
3105
3106 bool operator!=( DecodeH265ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
3107 {
3108 return !operator==( rhs );
3109 }
3110
3111 public:
3112 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265ReferenceInfoFlags flags = {};
3113 int32_t PicOrderCntVal = {};
3114 };
3115 #endif
3116
3117 #if defined( VULKAN_VIDEO_CODEC_H265STD_ENCODE_H_ )
3118 //=== vulkan_video_codec_h265std_encode ===
3119
3120 struct EncodeH265WeightTableFlags
3121 {
3122 using NativeType = StdVideoEncodeH265WeightTableFlags;
3123
3124 operator StdVideoEncodeH265WeightTableFlags const &() const VULKAN_HPP_NOEXCEPT
3125 {
3126 return *reinterpret_cast<const StdVideoEncodeH265WeightTableFlags *>( this );
3127 }
3128
3129 operator StdVideoEncodeH265WeightTableFlags &() VULKAN_HPP_NOEXCEPT
3130 {
3131 return *reinterpret_cast<StdVideoEncodeH265WeightTableFlags *>( this );
3132 }
3133
3134 operator StdVideoEncodeH265WeightTableFlags const *() const VULKAN_HPP_NOEXCEPT
3135 {
3136 return reinterpret_cast<const StdVideoEncodeH265WeightTableFlags *>( this );
3137 }
3138
3139 operator StdVideoEncodeH265WeightTableFlags *() VULKAN_HPP_NOEXCEPT
3140 {
3141 return reinterpret_cast<StdVideoEncodeH265WeightTableFlags *>( this );
3142 }
3143
3144 bool operator==( EncodeH265WeightTableFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
3145 {
3146 return ( luma_weight_l0_flag == rhs.luma_weight_l0_flag ) && ( chroma_weight_l0_flag == rhs.chroma_weight_l0_flag ) &&
3147 ( luma_weight_l1_flag == rhs.luma_weight_l1_flag ) && ( chroma_weight_l1_flag == rhs.chroma_weight_l1_flag );
3148 }
3149
3150 bool operator!=( EncodeH265WeightTableFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
3151 {
3152 return !operator==( rhs );
3153 }
3154
3155 public:
3156 uint16_t luma_weight_l0_flag = {};
3157 uint16_t chroma_weight_l0_flag = {};
3158 uint16_t luma_weight_l1_flag = {};
3159 uint16_t chroma_weight_l1_flag = {};
3160 };
3161
3162 struct EncodeH265WeightTable
3163 {
3164 using NativeType = StdVideoEncodeH265WeightTable;
3165
3166 operator StdVideoEncodeH265WeightTable const &() const VULKAN_HPP_NOEXCEPT
3167 {
3168 return *reinterpret_cast<const StdVideoEncodeH265WeightTable *>( this );
3169 }
3170
3171 operator StdVideoEncodeH265WeightTable &() VULKAN_HPP_NOEXCEPT
3172 {
3173 return *reinterpret_cast<StdVideoEncodeH265WeightTable *>( this );
3174 }
3175
3176 operator StdVideoEncodeH265WeightTable const *() const VULKAN_HPP_NOEXCEPT
3177 {
3178 return reinterpret_cast<const StdVideoEncodeH265WeightTable *>( this );
3179 }
3180
3181 operator StdVideoEncodeH265WeightTable *() VULKAN_HPP_NOEXCEPT
3182 {
3183 return reinterpret_cast<StdVideoEncodeH265WeightTable *>( this );
3184 }
3185
3186 bool operator==( EncodeH265WeightTable const & rhs ) const VULKAN_HPP_NOEXCEPT
3187 {
3188 return ( flags == rhs.flags ) && ( luma_log2_weight_denom == rhs.luma_log2_weight_denom ) &&
3189 ( delta_chroma_log2_weight_denom == rhs.delta_chroma_log2_weight_denom ) && ( delta_luma_weight_l0 == rhs.delta_luma_weight_l0 ) &&
3190 ( luma_offset_l0 == rhs.luma_offset_l0 ) && ( delta_chroma_weight_l0 == rhs.delta_chroma_weight_l0 ) &&
3191 ( delta_chroma_offset_l0 == rhs.delta_chroma_offset_l0 ) && ( delta_luma_weight_l1 == rhs.delta_luma_weight_l1 ) &&
3192 ( luma_offset_l1 == rhs.luma_offset_l1 ) && ( delta_chroma_weight_l1 == rhs.delta_chroma_weight_l1 ) &&
3193 ( delta_chroma_offset_l1 == rhs.delta_chroma_offset_l1 );
3194 }
3195
3196 bool operator!=( EncodeH265WeightTable const & rhs ) const VULKAN_HPP_NOEXCEPT
3197 {
3198 return !operator==( rhs );
3199 }
3200
3201 public:
3202 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTableFlags flags = {};
3203 uint8_t luma_log2_weight_denom = {};
3204 int8_t delta_chroma_log2_weight_denom = {};
3205 ArrayWrapper1D<int8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF> delta_luma_weight_l0 = {};
3206 ArrayWrapper1D<int8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF> luma_offset_l0 = {};
3207 ArrayWrapper2D<int8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF, STD_VIDEO_H265_MAX_CHROMA_PLANES> delta_chroma_weight_l0 = {};
3208 ArrayWrapper2D<int8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF, STD_VIDEO_H265_MAX_CHROMA_PLANES> delta_chroma_offset_l0 = {};
3209 ArrayWrapper1D<int8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF> delta_luma_weight_l1 = {};
3210 ArrayWrapper1D<int8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF> luma_offset_l1 = {};
3211 ArrayWrapper2D<int8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF, STD_VIDEO_H265_MAX_CHROMA_PLANES> delta_chroma_weight_l1 = {};
3212 ArrayWrapper2D<int8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF, STD_VIDEO_H265_MAX_CHROMA_PLANES> delta_chroma_offset_l1 = {};
3213 };
3214
3215 struct EncodeH265SliceSegmentHeaderFlags
3216 {
3217 using NativeType = StdVideoEncodeH265SliceSegmentHeaderFlags;
3218
3219 operator StdVideoEncodeH265SliceSegmentHeaderFlags const &() const VULKAN_HPP_NOEXCEPT
3220 {
3221 return *reinterpret_cast<const StdVideoEncodeH265SliceSegmentHeaderFlags *>( this );
3222 }
3223
3224 operator StdVideoEncodeH265SliceSegmentHeaderFlags &() VULKAN_HPP_NOEXCEPT
3225 {
3226 return *reinterpret_cast<StdVideoEncodeH265SliceSegmentHeaderFlags *>( this );
3227 }
3228
3229 operator StdVideoEncodeH265SliceSegmentHeaderFlags const *() const VULKAN_HPP_NOEXCEPT
3230 {
3231 return reinterpret_cast<const StdVideoEncodeH265SliceSegmentHeaderFlags *>( this );
3232 }
3233
3234 operator StdVideoEncodeH265SliceSegmentHeaderFlags *() VULKAN_HPP_NOEXCEPT
3235 {
3236 return reinterpret_cast<StdVideoEncodeH265SliceSegmentHeaderFlags *>( this );
3237 }
3238
3239 bool operator==( EncodeH265SliceSegmentHeaderFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
3240 {
3241 return ( first_slice_segment_in_pic_flag == rhs.first_slice_segment_in_pic_flag ) &&
3242 ( dependent_slice_segment_flag == rhs.dependent_slice_segment_flag ) && ( slice_sao_luma_flag == rhs.slice_sao_luma_flag ) &&
3243 ( slice_sao_chroma_flag == rhs.slice_sao_chroma_flag ) && ( num_ref_idx_active_override_flag == rhs.num_ref_idx_active_override_flag ) &&
3244 ( mvd_l1_zero_flag == rhs.mvd_l1_zero_flag ) && ( cabac_init_flag == rhs.cabac_init_flag ) &&
3245 ( cu_chroma_qp_offset_enabled_flag == rhs.cu_chroma_qp_offset_enabled_flag ) &&
3246 ( deblocking_filter_override_flag == rhs.deblocking_filter_override_flag ) &&
3247 ( slice_deblocking_filter_disabled_flag == rhs.slice_deblocking_filter_disabled_flag ) &&
3248 ( collocated_from_l0_flag == rhs.collocated_from_l0_flag ) &&
3249 ( slice_loop_filter_across_slices_enabled_flag == rhs.slice_loop_filter_across_slices_enabled_flag ) && ( reserved == rhs.reserved );
3250 }
3251
3252 bool operator!=( EncodeH265SliceSegmentHeaderFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
3253 {
3254 return !operator==( rhs );
3255 }
3256
3257 public:
3258 uint32_t first_slice_segment_in_pic_flag : 1;
3259 uint32_t dependent_slice_segment_flag : 1;
3260 uint32_t slice_sao_luma_flag : 1;
3261 uint32_t slice_sao_chroma_flag : 1;
3262 uint32_t num_ref_idx_active_override_flag : 1;
3263 uint32_t mvd_l1_zero_flag : 1;
3264 uint32_t cabac_init_flag : 1;
3265 uint32_t cu_chroma_qp_offset_enabled_flag : 1;
3266 uint32_t deblocking_filter_override_flag : 1;
3267 uint32_t slice_deblocking_filter_disabled_flag : 1;
3268 uint32_t collocated_from_l0_flag : 1;
3269 uint32_t slice_loop_filter_across_slices_enabled_flag : 1;
3270 uint32_t reserved : 20;
3271 };
3272
3273 struct EncodeH265SliceSegmentHeader
3274 {
3275 using NativeType = StdVideoEncodeH265SliceSegmentHeader;
3276
3277 operator StdVideoEncodeH265SliceSegmentHeader const &() const VULKAN_HPP_NOEXCEPT
3278 {
3279 return *reinterpret_cast<const StdVideoEncodeH265SliceSegmentHeader *>( this );
3280 }
3281
3282 operator StdVideoEncodeH265SliceSegmentHeader &() VULKAN_HPP_NOEXCEPT
3283 {
3284 return *reinterpret_cast<StdVideoEncodeH265SliceSegmentHeader *>( this );
3285 }
3286
3287 operator StdVideoEncodeH265SliceSegmentHeader const *() const VULKAN_HPP_NOEXCEPT
3288 {
3289 return reinterpret_cast<const StdVideoEncodeH265SliceSegmentHeader *>( this );
3290 }
3291
3292 operator StdVideoEncodeH265SliceSegmentHeader *() VULKAN_HPP_NOEXCEPT
3293 {
3294 return reinterpret_cast<StdVideoEncodeH265SliceSegmentHeader *>( this );
3295 }
3296
3297 bool operator==( EncodeH265SliceSegmentHeader const & rhs ) const VULKAN_HPP_NOEXCEPT
3298 {
3299 return ( flags == rhs.flags ) && ( slice_type == rhs.slice_type ) && ( slice_segment_address == rhs.slice_segment_address ) &&
3300 ( collocated_ref_idx == rhs.collocated_ref_idx ) && ( MaxNumMergeCand == rhs.MaxNumMergeCand ) &&
3301 ( slice_cb_qp_offset == rhs.slice_cb_qp_offset ) && ( slice_cr_qp_offset == rhs.slice_cr_qp_offset ) &&
3302 ( slice_beta_offset_div2 == rhs.slice_beta_offset_div2 ) && ( slice_tc_offset_div2 == rhs.slice_tc_offset_div2 ) &&
3303 ( slice_act_y_qp_offset == rhs.slice_act_y_qp_offset ) && ( slice_act_cb_qp_offset == rhs.slice_act_cb_qp_offset ) &&
3304 ( slice_act_cr_qp_offset == rhs.slice_act_cr_qp_offset ) && ( slice_qp_delta == rhs.slice_qp_delta ) && ( reserved1 == rhs.reserved1 ) &&
3305 ( pWeightTable == rhs.pWeightTable );
3306 }
3307
3308 bool operator!=( EncodeH265SliceSegmentHeader const & rhs ) const VULKAN_HPP_NOEXCEPT
3309 {
3310 return !operator==( rhs );
3311 }
3312
3313 public:
3314 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentHeaderFlags flags = {};
3315 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SliceType slice_type = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SliceType::eB;
3316 uint32_t slice_segment_address = {};
3317 uint8_t collocated_ref_idx = {};
3318 uint8_t MaxNumMergeCand = {};
3319 int8_t slice_cb_qp_offset = {};
3320 int8_t slice_cr_qp_offset = {};
3321 int8_t slice_beta_offset_div2 = {};
3322 int8_t slice_tc_offset_div2 = {};
3323 int8_t slice_act_y_qp_offset = {};
3324 int8_t slice_act_cb_qp_offset = {};
3325 int8_t slice_act_cr_qp_offset = {};
3326 int8_t slice_qp_delta = {};
3327 uint16_t reserved1 = {};
3328 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTable * pWeightTable = {};
3329 };
3330
3331 struct EncodeH265ReferenceListsInfoFlags
3332 {
3333 using NativeType = StdVideoEncodeH265ReferenceListsInfoFlags;
3334
3335 operator StdVideoEncodeH265ReferenceListsInfoFlags const &() const VULKAN_HPP_NOEXCEPT
3336 {
3337 return *reinterpret_cast<const StdVideoEncodeH265ReferenceListsInfoFlags *>( this );
3338 }
3339
3340 operator StdVideoEncodeH265ReferenceListsInfoFlags &() VULKAN_HPP_NOEXCEPT
3341 {
3342 return *reinterpret_cast<StdVideoEncodeH265ReferenceListsInfoFlags *>( this );
3343 }
3344
3345 operator StdVideoEncodeH265ReferenceListsInfoFlags const *() const VULKAN_HPP_NOEXCEPT
3346 {
3347 return reinterpret_cast<const StdVideoEncodeH265ReferenceListsInfoFlags *>( this );
3348 }
3349
3350 operator StdVideoEncodeH265ReferenceListsInfoFlags *() VULKAN_HPP_NOEXCEPT
3351 {
3352 return reinterpret_cast<StdVideoEncodeH265ReferenceListsInfoFlags *>( this );
3353 }
3354
3355 bool operator==( EncodeH265ReferenceListsInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
3356 {
3357 return ( ref_pic_list_modification_flag_l0 == rhs.ref_pic_list_modification_flag_l0 ) &&
3358 ( ref_pic_list_modification_flag_l1 == rhs.ref_pic_list_modification_flag_l1 ) && ( reserved == rhs.reserved );
3359 }
3360
3361 bool operator!=( EncodeH265ReferenceListsInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
3362 {
3363 return !operator==( rhs );
3364 }
3365
3366 public:
3367 uint32_t ref_pic_list_modification_flag_l0 : 1;
3368 uint32_t ref_pic_list_modification_flag_l1 : 1;
3369 uint32_t reserved : 30;
3370 };
3371
3372 struct EncodeH265ReferenceListsInfo
3373 {
3374 using NativeType = StdVideoEncodeH265ReferenceListsInfo;
3375
3376 operator StdVideoEncodeH265ReferenceListsInfo const &() const VULKAN_HPP_NOEXCEPT
3377 {
3378 return *reinterpret_cast<const StdVideoEncodeH265ReferenceListsInfo *>( this );
3379 }
3380
3381 operator StdVideoEncodeH265ReferenceListsInfo &() VULKAN_HPP_NOEXCEPT
3382 {
3383 return *reinterpret_cast<StdVideoEncodeH265ReferenceListsInfo *>( this );
3384 }
3385
3386 operator StdVideoEncodeH265ReferenceListsInfo const *() const VULKAN_HPP_NOEXCEPT
3387 {
3388 return reinterpret_cast<const StdVideoEncodeH265ReferenceListsInfo *>( this );
3389 }
3390
3391 operator StdVideoEncodeH265ReferenceListsInfo *() VULKAN_HPP_NOEXCEPT
3392 {
3393 return reinterpret_cast<StdVideoEncodeH265ReferenceListsInfo *>( this );
3394 }
3395
3396 bool operator==( EncodeH265ReferenceListsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
3397 {
3398 return ( flags == rhs.flags ) && ( num_ref_idx_l0_active_minus1 == rhs.num_ref_idx_l0_active_minus1 ) &&
3399 ( num_ref_idx_l1_active_minus1 == rhs.num_ref_idx_l1_active_minus1 ) && ( RefPicList0 == rhs.RefPicList0 ) &&
3400 ( RefPicList1 == rhs.RefPicList1 ) && ( list_entry_l0 == rhs.list_entry_l0 ) && ( list_entry_l1 == rhs.list_entry_l1 );
3401 }
3402
3403 bool operator!=( EncodeH265ReferenceListsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
3404 {
3405 return !operator==( rhs );
3406 }
3407
3408 public:
3409 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfoFlags flags = {};
3410 uint8_t num_ref_idx_l0_active_minus1 = {};
3411 uint8_t num_ref_idx_l1_active_minus1 = {};
3412 ArrayWrapper1D<uint8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF> RefPicList0 = {};
3413 ArrayWrapper1D<uint8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF> RefPicList1 = {};
3414 ArrayWrapper1D<uint8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF> list_entry_l0 = {};
3415 ArrayWrapper1D<uint8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF> list_entry_l1 = {};
3416 };
3417
3418 struct EncodeH265PictureInfoFlags
3419 {
3420 using NativeType = StdVideoEncodeH265PictureInfoFlags;
3421
3422 operator StdVideoEncodeH265PictureInfoFlags const &() const VULKAN_HPP_NOEXCEPT
3423 {
3424 return *reinterpret_cast<const StdVideoEncodeH265PictureInfoFlags *>( this );
3425 }
3426
3427 operator StdVideoEncodeH265PictureInfoFlags &() VULKAN_HPP_NOEXCEPT
3428 {
3429 return *reinterpret_cast<StdVideoEncodeH265PictureInfoFlags *>( this );
3430 }
3431
3432 operator StdVideoEncodeH265PictureInfoFlags const *() const VULKAN_HPP_NOEXCEPT
3433 {
3434 return reinterpret_cast<const StdVideoEncodeH265PictureInfoFlags *>( this );
3435 }
3436
3437 operator StdVideoEncodeH265PictureInfoFlags *() VULKAN_HPP_NOEXCEPT
3438 {
3439 return reinterpret_cast<StdVideoEncodeH265PictureInfoFlags *>( this );
3440 }
3441
3442 bool operator==( EncodeH265PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
3443 {
3444 return ( is_reference == rhs.is_reference ) && ( IrapPicFlag == rhs.IrapPicFlag ) &&
3445 ( used_for_long_term_reference == rhs.used_for_long_term_reference ) && ( discardable_flag == rhs.discardable_flag ) &&
3446 ( cross_layer_bla_flag == rhs.cross_layer_bla_flag ) && ( pic_output_flag == rhs.pic_output_flag ) &&
3447 ( no_output_of_prior_pics_flag == rhs.no_output_of_prior_pics_flag ) &&
3448 ( short_term_ref_pic_set_sps_flag == rhs.short_term_ref_pic_set_sps_flag ) &&
3449 ( slice_temporal_mvp_enabled_flag == rhs.slice_temporal_mvp_enabled_flag ) && ( reserved == rhs.reserved );
3450 }
3451
3452 bool operator!=( EncodeH265PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
3453 {
3454 return !operator==( rhs );
3455 }
3456
3457 public:
3458 uint32_t is_reference : 1;
3459 uint32_t IrapPicFlag : 1;
3460 uint32_t used_for_long_term_reference : 1;
3461 uint32_t discardable_flag : 1;
3462 uint32_t cross_layer_bla_flag : 1;
3463 uint32_t pic_output_flag : 1;
3464 uint32_t no_output_of_prior_pics_flag : 1;
3465 uint32_t short_term_ref_pic_set_sps_flag : 1;
3466 uint32_t slice_temporal_mvp_enabled_flag : 1;
3467 uint32_t reserved : 23;
3468 };
3469
3470 struct EncodeH265LongTermRefPics
3471 {
3472 using NativeType = StdVideoEncodeH265LongTermRefPics;
3473
3474 operator StdVideoEncodeH265LongTermRefPics const &() const VULKAN_HPP_NOEXCEPT
3475 {
3476 return *reinterpret_cast<const StdVideoEncodeH265LongTermRefPics *>( this );
3477 }
3478
3479 operator StdVideoEncodeH265LongTermRefPics &() VULKAN_HPP_NOEXCEPT
3480 {
3481 return *reinterpret_cast<StdVideoEncodeH265LongTermRefPics *>( this );
3482 }
3483
3484 operator StdVideoEncodeH265LongTermRefPics const *() const VULKAN_HPP_NOEXCEPT
3485 {
3486 return reinterpret_cast<const StdVideoEncodeH265LongTermRefPics *>( this );
3487 }
3488
3489 operator StdVideoEncodeH265LongTermRefPics *() VULKAN_HPP_NOEXCEPT
3490 {
3491 return reinterpret_cast<StdVideoEncodeH265LongTermRefPics *>( this );
3492 }
3493
3494 bool operator==( EncodeH265LongTermRefPics const & rhs ) const VULKAN_HPP_NOEXCEPT
3495 {
3496 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 ) &&
3497 ( poc_lsb_lt == rhs.poc_lsb_lt ) && ( used_by_curr_pic_lt_flag == rhs.used_by_curr_pic_lt_flag ) &&
3498 ( delta_poc_msb_present_flag == rhs.delta_poc_msb_present_flag ) && ( delta_poc_msb_cycle_lt == rhs.delta_poc_msb_cycle_lt );
3499 }
3500
3501 bool operator!=( EncodeH265LongTermRefPics const & rhs ) const VULKAN_HPP_NOEXCEPT
3502 {
3503 return !operator==( rhs );
3504 }
3505
3506 public:
3507 uint8_t num_long_term_sps = {};
3508 uint8_t num_long_term_pics = {};
3509 ArrayWrapper1D<uint8_t, STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS> lt_idx_sps = {};
3510 ArrayWrapper1D<uint8_t, STD_VIDEO_H265_MAX_LONG_TERM_PICS> poc_lsb_lt = {};
3511 uint16_t used_by_curr_pic_lt_flag = {};
3512 ArrayWrapper1D<uint8_t, STD_VIDEO_H265_MAX_DELTA_POC> delta_poc_msb_present_flag = {};
3513 ArrayWrapper1D<uint8_t, STD_VIDEO_H265_MAX_DELTA_POC> delta_poc_msb_cycle_lt = {};
3514 };
3515
3516 struct EncodeH265PictureInfo
3517 {
3518 using NativeType = StdVideoEncodeH265PictureInfo;
3519
3520 operator StdVideoEncodeH265PictureInfo const &() const VULKAN_HPP_NOEXCEPT
3521 {
3522 return *reinterpret_cast<const StdVideoEncodeH265PictureInfo *>( this );
3523 }
3524
3525 operator StdVideoEncodeH265PictureInfo &() VULKAN_HPP_NOEXCEPT
3526 {
3527 return *reinterpret_cast<StdVideoEncodeH265PictureInfo *>( this );
3528 }
3529
3530 operator StdVideoEncodeH265PictureInfo const *() const VULKAN_HPP_NOEXCEPT
3531 {
3532 return reinterpret_cast<const StdVideoEncodeH265PictureInfo *>( this );
3533 }
3534
3535 operator StdVideoEncodeH265PictureInfo *() VULKAN_HPP_NOEXCEPT
3536 {
3537 return reinterpret_cast<StdVideoEncodeH265PictureInfo *>( this );
3538 }
3539
3540 bool operator==( EncodeH265PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
3541 {
3542 return ( flags == rhs.flags ) && ( pic_type == rhs.pic_type ) && ( sps_video_parameter_set_id == rhs.sps_video_parameter_set_id ) &&
3543 ( pps_seq_parameter_set_id == rhs.pps_seq_parameter_set_id ) && ( pps_pic_parameter_set_id == rhs.pps_pic_parameter_set_id ) &&
3544 ( short_term_ref_pic_set_idx == rhs.short_term_ref_pic_set_idx ) && ( PicOrderCntVal == rhs.PicOrderCntVal ) &&
3545 ( TemporalId == rhs.TemporalId ) && ( reserved1 == rhs.reserved1 ) && ( pRefLists == rhs.pRefLists ) &&
3546 ( pShortTermRefPicSet == rhs.pShortTermRefPicSet ) && ( pLongTermRefPics == rhs.pLongTermRefPics );
3547 }
3548
3549 bool operator!=( EncodeH265PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
3550 {
3551 return !operator==( rhs );
3552 }
3553
3554 public:
3555 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265PictureInfoFlags flags = {};
3556 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureType pic_type = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureType::eP;
3557 uint8_t sps_video_parameter_set_id = {};
3558 uint8_t pps_seq_parameter_set_id = {};
3559 uint8_t pps_pic_parameter_set_id = {};
3560 uint8_t short_term_ref_pic_set_idx = {};
3561 int32_t PicOrderCntVal = {};
3562 uint8_t TemporalId = {};
3563 ArrayWrapper1D<uint8_t, 7> reserved1 = {};
3564 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfo * pRefLists = {};
3565 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSet * pShortTermRefPicSet = {};
3566 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265LongTermRefPics * pLongTermRefPics = {};
3567 };
3568
3569 struct EncodeH265ReferenceInfoFlags
3570 {
3571 using NativeType = StdVideoEncodeH265ReferenceInfoFlags;
3572
3573 operator StdVideoEncodeH265ReferenceInfoFlags const &() const VULKAN_HPP_NOEXCEPT
3574 {
3575 return *reinterpret_cast<const StdVideoEncodeH265ReferenceInfoFlags *>( this );
3576 }
3577
3578 operator StdVideoEncodeH265ReferenceInfoFlags &() VULKAN_HPP_NOEXCEPT
3579 {
3580 return *reinterpret_cast<StdVideoEncodeH265ReferenceInfoFlags *>( this );
3581 }
3582
3583 operator StdVideoEncodeH265ReferenceInfoFlags const *() const VULKAN_HPP_NOEXCEPT
3584 {
3585 return reinterpret_cast<const StdVideoEncodeH265ReferenceInfoFlags *>( this );
3586 }
3587
3588 operator StdVideoEncodeH265ReferenceInfoFlags *() VULKAN_HPP_NOEXCEPT
3589 {
3590 return reinterpret_cast<StdVideoEncodeH265ReferenceInfoFlags *>( this );
3591 }
3592
3593 bool operator==( EncodeH265ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
3594 {
3595 return ( used_for_long_term_reference == rhs.used_for_long_term_reference ) && ( unused_for_reference == rhs.unused_for_reference ) &&
3596 ( reserved == rhs.reserved );
3597 }
3598
3599 bool operator!=( EncodeH265ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
3600 {
3601 return !operator==( rhs );
3602 }
3603
3604 public:
3605 uint32_t used_for_long_term_reference : 1;
3606 uint32_t unused_for_reference : 1;
3607 uint32_t reserved : 30;
3608 };
3609
3610 struct EncodeH265ReferenceInfo
3611 {
3612 using NativeType = StdVideoEncodeH265ReferenceInfo;
3613
3614 operator StdVideoEncodeH265ReferenceInfo const &() const VULKAN_HPP_NOEXCEPT
3615 {
3616 return *reinterpret_cast<const StdVideoEncodeH265ReferenceInfo *>( this );
3617 }
3618
3619 operator StdVideoEncodeH265ReferenceInfo &() VULKAN_HPP_NOEXCEPT
3620 {
3621 return *reinterpret_cast<StdVideoEncodeH265ReferenceInfo *>( this );
3622 }
3623
3624 operator StdVideoEncodeH265ReferenceInfo const *() const VULKAN_HPP_NOEXCEPT
3625 {
3626 return reinterpret_cast<const StdVideoEncodeH265ReferenceInfo *>( this );
3627 }
3628
3629 operator StdVideoEncodeH265ReferenceInfo *() VULKAN_HPP_NOEXCEPT
3630 {
3631 return reinterpret_cast<StdVideoEncodeH265ReferenceInfo *>( this );
3632 }
3633
3634 bool operator==( EncodeH265ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
3635 {
3636 return ( flags == rhs.flags ) && ( pic_type == rhs.pic_type ) && ( PicOrderCntVal == rhs.PicOrderCntVal ) && ( TemporalId == rhs.TemporalId );
3637 }
3638
3639 bool operator!=( EncodeH265ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
3640 {
3641 return !operator==( rhs );
3642 }
3643
3644 public:
3645 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceInfoFlags flags = {};
3646 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureType pic_type = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureType::eP;
3647 int32_t PicOrderCntVal = {};
3648 uint8_t TemporalId = {};
3649 };
3650 #endif
3651
3652 #if defined( VULKAN_VIDEO_CODEC_VP9STD_H_ )
3653 //=== vulkan_video_codec_vp9std ===
3654
3655 struct VP9ColorConfigFlags
3656 {
3657 using NativeType = StdVideoVP9ColorConfigFlags;
3658
3659 operator StdVideoVP9ColorConfigFlags const &() const VULKAN_HPP_NOEXCEPT
3660 {
3661 return *reinterpret_cast<const StdVideoVP9ColorConfigFlags *>( this );
3662 }
3663
3664 operator StdVideoVP9ColorConfigFlags &() VULKAN_HPP_NOEXCEPT
3665 {
3666 return *reinterpret_cast<StdVideoVP9ColorConfigFlags *>( this );
3667 }
3668
3669 operator StdVideoVP9ColorConfigFlags const *() const VULKAN_HPP_NOEXCEPT
3670 {
3671 return reinterpret_cast<const StdVideoVP9ColorConfigFlags *>( this );
3672 }
3673
3674 operator StdVideoVP9ColorConfigFlags *() VULKAN_HPP_NOEXCEPT
3675 {
3676 return reinterpret_cast<StdVideoVP9ColorConfigFlags *>( this );
3677 }
3678
3679 bool operator==( VP9ColorConfigFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
3680 {
3681 return ( color_range == rhs.color_range ) && ( reserved == rhs.reserved );
3682 }
3683
3684 bool operator!=( VP9ColorConfigFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
3685 {
3686 return !operator==( rhs );
3687 }
3688
3689 public:
3690 uint32_t color_range : 1;
3691 uint32_t reserved : 31;
3692 };
3693
3694 struct VP9ColorConfig
3695 {
3696 using NativeType = StdVideoVP9ColorConfig;
3697
3698 operator StdVideoVP9ColorConfig const &() const VULKAN_HPP_NOEXCEPT
3699 {
3700 return *reinterpret_cast<const StdVideoVP9ColorConfig *>( this );
3701 }
3702
3703 operator StdVideoVP9ColorConfig &() VULKAN_HPP_NOEXCEPT
3704 {
3705 return *reinterpret_cast<StdVideoVP9ColorConfig *>( this );
3706 }
3707
3708 operator StdVideoVP9ColorConfig const *() const VULKAN_HPP_NOEXCEPT
3709 {
3710 return reinterpret_cast<const StdVideoVP9ColorConfig *>( this );
3711 }
3712
3713 operator StdVideoVP9ColorConfig *() VULKAN_HPP_NOEXCEPT
3714 {
3715 return reinterpret_cast<StdVideoVP9ColorConfig *>( this );
3716 }
3717
3718 bool operator==( VP9ColorConfig const & rhs ) const VULKAN_HPP_NOEXCEPT
3719 {
3720 return ( flags == rhs.flags ) && ( BitDepth == rhs.BitDepth ) && ( subsampling_x == rhs.subsampling_x ) && ( subsampling_y == rhs.subsampling_y ) &&
3721 ( reserved1 == rhs.reserved1 ) && ( color_space == rhs.color_space );
3722 }
3723
3724 bool operator!=( VP9ColorConfig const & rhs ) const VULKAN_HPP_NOEXCEPT
3725 {
3726 return !operator==( rhs );
3727 }
3728
3729 public:
3730 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9ColorConfigFlags flags = {};
3731 uint8_t BitDepth = {};
3732 uint8_t subsampling_x = {};
3733 uint8_t subsampling_y = {};
3734 uint8_t reserved1 = {};
3735 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9ColorSpace color_space = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9ColorSpace::eUnknown;
3736 };
3737
3738 struct VP9LoopFilterFlags
3739 {
3740 using NativeType = StdVideoVP9LoopFilterFlags;
3741
3742 operator StdVideoVP9LoopFilterFlags const &() const VULKAN_HPP_NOEXCEPT
3743 {
3744 return *reinterpret_cast<const StdVideoVP9LoopFilterFlags *>( this );
3745 }
3746
3747 operator StdVideoVP9LoopFilterFlags &() VULKAN_HPP_NOEXCEPT
3748 {
3749 return *reinterpret_cast<StdVideoVP9LoopFilterFlags *>( this );
3750 }
3751
3752 operator StdVideoVP9LoopFilterFlags const *() const VULKAN_HPP_NOEXCEPT
3753 {
3754 return reinterpret_cast<const StdVideoVP9LoopFilterFlags *>( this );
3755 }
3756
3757 operator StdVideoVP9LoopFilterFlags *() VULKAN_HPP_NOEXCEPT
3758 {
3759 return reinterpret_cast<StdVideoVP9LoopFilterFlags *>( this );
3760 }
3761
3762 bool operator==( VP9LoopFilterFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
3763 {
3764 return ( loop_filter_delta_enabled == rhs.loop_filter_delta_enabled ) && ( loop_filter_delta_update == rhs.loop_filter_delta_update ) &&
3765 ( reserved == rhs.reserved );
3766 }
3767
3768 bool operator!=( VP9LoopFilterFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
3769 {
3770 return !operator==( rhs );
3771 }
3772
3773 public:
3774 uint32_t loop_filter_delta_enabled : 1;
3775 uint32_t loop_filter_delta_update : 1;
3776 uint32_t reserved : 30;
3777 };
3778
3779 struct VP9LoopFilter
3780 {
3781 using NativeType = StdVideoVP9LoopFilter;
3782
3783 operator StdVideoVP9LoopFilter const &() const VULKAN_HPP_NOEXCEPT
3784 {
3785 return *reinterpret_cast<const StdVideoVP9LoopFilter *>( this );
3786 }
3787
3788 operator StdVideoVP9LoopFilter &() VULKAN_HPP_NOEXCEPT
3789 {
3790 return *reinterpret_cast<StdVideoVP9LoopFilter *>( this );
3791 }
3792
3793 operator StdVideoVP9LoopFilter const *() const VULKAN_HPP_NOEXCEPT
3794 {
3795 return reinterpret_cast<const StdVideoVP9LoopFilter *>( this );
3796 }
3797
3798 operator StdVideoVP9LoopFilter *() VULKAN_HPP_NOEXCEPT
3799 {
3800 return reinterpret_cast<StdVideoVP9LoopFilter *>( this );
3801 }
3802
3803 bool operator==( VP9LoopFilter const & rhs ) const VULKAN_HPP_NOEXCEPT
3804 {
3805 return ( flags == rhs.flags ) && ( loop_filter_level == rhs.loop_filter_level ) && ( loop_filter_sharpness == rhs.loop_filter_sharpness ) &&
3806 ( update_ref_delta == rhs.update_ref_delta ) && ( loop_filter_ref_deltas == rhs.loop_filter_ref_deltas ) &&
3807 ( update_mode_delta == rhs.update_mode_delta ) && ( loop_filter_mode_deltas == rhs.loop_filter_mode_deltas );
3808 }
3809
3810 bool operator!=( VP9LoopFilter const & rhs ) const VULKAN_HPP_NOEXCEPT
3811 {
3812 return !operator==( rhs );
3813 }
3814
3815 public:
3816 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9LoopFilterFlags flags = {};
3817 uint8_t loop_filter_level = {};
3818 uint8_t loop_filter_sharpness = {};
3819 uint8_t update_ref_delta = {};
3820 ArrayWrapper1D<int8_t, STD_VIDEO_VP9_MAX_REF_FRAMES> loop_filter_ref_deltas = {};
3821 uint8_t update_mode_delta = {};
3822 ArrayWrapper1D<int8_t, STD_VIDEO_VP9_LOOP_FILTER_ADJUSTMENTS> loop_filter_mode_deltas = {};
3823 };
3824
3825 struct VP9SegmentationFlags
3826 {
3827 using NativeType = StdVideoVP9SegmentationFlags;
3828
3829 operator StdVideoVP9SegmentationFlags const &() const VULKAN_HPP_NOEXCEPT
3830 {
3831 return *reinterpret_cast<const StdVideoVP9SegmentationFlags *>( this );
3832 }
3833
3834 operator StdVideoVP9SegmentationFlags &() VULKAN_HPP_NOEXCEPT
3835 {
3836 return *reinterpret_cast<StdVideoVP9SegmentationFlags *>( this );
3837 }
3838
3839 operator StdVideoVP9SegmentationFlags const *() const VULKAN_HPP_NOEXCEPT
3840 {
3841 return reinterpret_cast<const StdVideoVP9SegmentationFlags *>( this );
3842 }
3843
3844 operator StdVideoVP9SegmentationFlags *() VULKAN_HPP_NOEXCEPT
3845 {
3846 return reinterpret_cast<StdVideoVP9SegmentationFlags *>( this );
3847 }
3848
3849 bool operator==( VP9SegmentationFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
3850 {
3851 return ( segmentation_update_map == rhs.segmentation_update_map ) && ( segmentation_temporal_update == rhs.segmentation_temporal_update ) &&
3852 ( segmentation_update_data == rhs.segmentation_update_data ) && ( segmentation_abs_or_delta_update == rhs.segmentation_abs_or_delta_update ) &&
3853 ( reserved == rhs.reserved );
3854 }
3855
3856 bool operator!=( VP9SegmentationFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
3857 {
3858 return !operator==( rhs );
3859 }
3860
3861 public:
3862 uint32_t segmentation_update_map : 1;
3863 uint32_t segmentation_temporal_update : 1;
3864 uint32_t segmentation_update_data : 1;
3865 uint32_t segmentation_abs_or_delta_update : 1;
3866 uint32_t reserved : 28;
3867 };
3868
3869 struct VP9Segmentation
3870 {
3871 using NativeType = StdVideoVP9Segmentation;
3872
3873 operator StdVideoVP9Segmentation const &() const VULKAN_HPP_NOEXCEPT
3874 {
3875 return *reinterpret_cast<const StdVideoVP9Segmentation *>( this );
3876 }
3877
3878 operator StdVideoVP9Segmentation &() VULKAN_HPP_NOEXCEPT
3879 {
3880 return *reinterpret_cast<StdVideoVP9Segmentation *>( this );
3881 }
3882
3883 operator StdVideoVP9Segmentation const *() const VULKAN_HPP_NOEXCEPT
3884 {
3885 return reinterpret_cast<const StdVideoVP9Segmentation *>( this );
3886 }
3887
3888 operator StdVideoVP9Segmentation *() VULKAN_HPP_NOEXCEPT
3889 {
3890 return reinterpret_cast<StdVideoVP9Segmentation *>( this );
3891 }
3892
3893 bool operator==( VP9Segmentation const & rhs ) const VULKAN_HPP_NOEXCEPT
3894 {
3895 return ( flags == rhs.flags ) && ( segmentation_tree_probs == rhs.segmentation_tree_probs ) &&
3896 ( segmentation_pred_prob == rhs.segmentation_pred_prob ) && ( FeatureEnabled == rhs.FeatureEnabled ) && ( FeatureData == rhs.FeatureData );
3897 }
3898
3899 bool operator!=( VP9Segmentation const & rhs ) const VULKAN_HPP_NOEXCEPT
3900 {
3901 return !operator==( rhs );
3902 }
3903
3904 public:
3905 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9SegmentationFlags flags = {};
3906 ArrayWrapper1D<uint8_t, STD_VIDEO_VP9_MAX_SEGMENTATION_TREE_PROBS> segmentation_tree_probs = {};
3907 ArrayWrapper1D<uint8_t, STD_VIDEO_VP9_MAX_SEGMENTATION_PRED_PROB> segmentation_pred_prob = {};
3908 ArrayWrapper1D<uint8_t, STD_VIDEO_VP9_MAX_SEGMENTS> FeatureEnabled = {};
3909 ArrayWrapper2D<int16_t, STD_VIDEO_VP9_MAX_SEGMENTS, STD_VIDEO_VP9_SEG_LVL_MAX> FeatureData = {};
3910 };
3911 #endif
3912
3913 #if defined( VULKAN_VIDEO_CODEC_VP9STD_DECODE_H_ )
3914 //=== vulkan_video_codec_vp9std_decode ===
3915
3916 struct DecodeVP9PictureInfoFlags
3917 {
3918 using NativeType = StdVideoDecodeVP9PictureInfoFlags;
3919
3920 operator StdVideoDecodeVP9PictureInfoFlags const &() const VULKAN_HPP_NOEXCEPT
3921 {
3922 return *reinterpret_cast<const StdVideoDecodeVP9PictureInfoFlags *>( this );
3923 }
3924
3925 operator StdVideoDecodeVP9PictureInfoFlags &() VULKAN_HPP_NOEXCEPT
3926 {
3927 return *reinterpret_cast<StdVideoDecodeVP9PictureInfoFlags *>( this );
3928 }
3929
3930 operator StdVideoDecodeVP9PictureInfoFlags const *() const VULKAN_HPP_NOEXCEPT
3931 {
3932 return reinterpret_cast<const StdVideoDecodeVP9PictureInfoFlags *>( this );
3933 }
3934
3935 operator StdVideoDecodeVP9PictureInfoFlags *() VULKAN_HPP_NOEXCEPT
3936 {
3937 return reinterpret_cast<StdVideoDecodeVP9PictureInfoFlags *>( this );
3938 }
3939
3940 bool operator==( DecodeVP9PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
3941 {
3942 return ( error_resilient_mode == rhs.error_resilient_mode ) && ( intra_only == rhs.intra_only ) &&
3943 ( allow_high_precision_mv == rhs.allow_high_precision_mv ) && ( refresh_frame_context == rhs.refresh_frame_context ) &&
3944 ( frame_parallel_decoding_mode == rhs.frame_parallel_decoding_mode ) && ( segmentation_enabled == rhs.segmentation_enabled ) &&
3945 ( show_frame == rhs.show_frame ) && ( UsePrevFrameMvs == rhs.UsePrevFrameMvs ) && ( reserved == rhs.reserved );
3946 }
3947
3948 bool operator!=( DecodeVP9PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
3949 {
3950 return !operator==( rhs );
3951 }
3952
3953 public:
3954 uint32_t error_resilient_mode : 1;
3955 uint32_t intra_only : 1;
3956 uint32_t allow_high_precision_mv : 1;
3957 uint32_t refresh_frame_context : 1;
3958 uint32_t frame_parallel_decoding_mode : 1;
3959 uint32_t segmentation_enabled : 1;
3960 uint32_t show_frame : 1;
3961 uint32_t UsePrevFrameMvs : 1;
3962 uint32_t reserved : 24;
3963 };
3964
3965 struct DecodeVP9PictureInfo
3966 {
3967 using NativeType = StdVideoDecodeVP9PictureInfo;
3968
3969 operator StdVideoDecodeVP9PictureInfo const &() const VULKAN_HPP_NOEXCEPT
3970 {
3971 return *reinterpret_cast<const StdVideoDecodeVP9PictureInfo *>( this );
3972 }
3973
3974 operator StdVideoDecodeVP9PictureInfo &() VULKAN_HPP_NOEXCEPT
3975 {
3976 return *reinterpret_cast<StdVideoDecodeVP9PictureInfo *>( this );
3977 }
3978
3979 operator StdVideoDecodeVP9PictureInfo const *() const VULKAN_HPP_NOEXCEPT
3980 {
3981 return reinterpret_cast<const StdVideoDecodeVP9PictureInfo *>( this );
3982 }
3983
3984 operator StdVideoDecodeVP9PictureInfo *() VULKAN_HPP_NOEXCEPT
3985 {
3986 return reinterpret_cast<StdVideoDecodeVP9PictureInfo *>( this );
3987 }
3988
3989 bool operator==( DecodeVP9PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
3990 {
3991 return ( flags == rhs.flags ) && ( profile == rhs.profile ) && ( frame_type == rhs.frame_type ) && ( frame_context_idx == rhs.frame_context_idx ) &&
3992 ( reset_frame_context == rhs.reset_frame_context ) && ( refresh_frame_flags == rhs.refresh_frame_flags ) &&
3993 ( ref_frame_sign_bias_mask == rhs.ref_frame_sign_bias_mask ) && ( interpolation_filter == rhs.interpolation_filter ) &&
3994 ( base_q_idx == rhs.base_q_idx ) && ( delta_q_y_dc == rhs.delta_q_y_dc ) && ( delta_q_uv_dc == rhs.delta_q_uv_dc ) &&
3995 ( delta_q_uv_ac == rhs.delta_q_uv_ac ) && ( tile_cols_log2 == rhs.tile_cols_log2 ) && ( tile_rows_log2 == rhs.tile_rows_log2 ) &&
3996 ( reserved1 == rhs.reserved1 ) && ( pColorConfig == rhs.pColorConfig ) && ( pLoopFilter == rhs.pLoopFilter ) &&
3997 ( pSegmentation == rhs.pSegmentation );
3998 }
3999
4000 bool operator!=( DecodeVP9PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
4001 {
4002 return !operator==( rhs );
4003 }
4004
4005 public:
4006 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeVP9PictureInfoFlags flags = {};
4007 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9Profile profile = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9Profile::e0;
4008 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9FrameType frame_type = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9FrameType::eKey;
4009 uint8_t frame_context_idx = {};
4010 uint8_t reset_frame_context = {};
4011 uint8_t refresh_frame_flags = {};
4012 uint8_t ref_frame_sign_bias_mask = {};
4013 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9InterpolationFilter interpolation_filter =
4014 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9InterpolationFilter::eEighttap;
4015 uint8_t base_q_idx = {};
4016 int8_t delta_q_y_dc = {};
4017 int8_t delta_q_uv_dc = {};
4018 int8_t delta_q_uv_ac = {};
4019 uint8_t tile_cols_log2 = {};
4020 uint8_t tile_rows_log2 = {};
4021 ArrayWrapper1D<uint16_t, 3> reserved1 = {};
4022 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9ColorConfig * pColorConfig = {};
4023 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9LoopFilter * pLoopFilter = {};
4024 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9Segmentation * pSegmentation = {};
4025 };
4026 #endif
4027
4028 #if defined( VULKAN_VIDEO_CODEC_AV1STD_H_ )
4029 //=== vulkan_video_codec_av1std ===
4030
4031 struct AV1ColorConfigFlags
4032 {
4033 using NativeType = StdVideoAV1ColorConfigFlags;
4034
4035 operator StdVideoAV1ColorConfigFlags const &() const VULKAN_HPP_NOEXCEPT
4036 {
4037 return *reinterpret_cast<const StdVideoAV1ColorConfigFlags *>( this );
4038 }
4039
4040 operator StdVideoAV1ColorConfigFlags &() VULKAN_HPP_NOEXCEPT
4041 {
4042 return *reinterpret_cast<StdVideoAV1ColorConfigFlags *>( this );
4043 }
4044
4045 operator StdVideoAV1ColorConfigFlags const *() const VULKAN_HPP_NOEXCEPT
4046 {
4047 return reinterpret_cast<const StdVideoAV1ColorConfigFlags *>( this );
4048 }
4049
4050 operator StdVideoAV1ColorConfigFlags *() VULKAN_HPP_NOEXCEPT
4051 {
4052 return reinterpret_cast<StdVideoAV1ColorConfigFlags *>( this );
4053 }
4054
4055 bool operator==( AV1ColorConfigFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
4056 {
4057 return ( mono_chrome == rhs.mono_chrome ) && ( color_range == rhs.color_range ) && ( separate_uv_delta_q == rhs.separate_uv_delta_q ) &&
4058 ( color_description_present_flag == rhs.color_description_present_flag ) && ( reserved == rhs.reserved );
4059 }
4060
4061 bool operator!=( AV1ColorConfigFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
4062 {
4063 return !operator==( rhs );
4064 }
4065
4066 public:
4067 uint32_t mono_chrome : 1;
4068 uint32_t color_range : 1;
4069 uint32_t separate_uv_delta_q : 1;
4070 uint32_t color_description_present_flag : 1;
4071 uint32_t reserved : 28;
4072 };
4073
4074 struct AV1ColorConfig
4075 {
4076 using NativeType = StdVideoAV1ColorConfig;
4077
4078 operator StdVideoAV1ColorConfig const &() const VULKAN_HPP_NOEXCEPT
4079 {
4080 return *reinterpret_cast<const StdVideoAV1ColorConfig *>( this );
4081 }
4082
4083 operator StdVideoAV1ColorConfig &() VULKAN_HPP_NOEXCEPT
4084 {
4085 return *reinterpret_cast<StdVideoAV1ColorConfig *>( this );
4086 }
4087
4088 operator StdVideoAV1ColorConfig const *() const VULKAN_HPP_NOEXCEPT
4089 {
4090 return reinterpret_cast<const StdVideoAV1ColorConfig *>( this );
4091 }
4092
4093 operator StdVideoAV1ColorConfig *() VULKAN_HPP_NOEXCEPT
4094 {
4095 return reinterpret_cast<StdVideoAV1ColorConfig *>( this );
4096 }
4097
4098 bool operator==( AV1ColorConfig const & rhs ) const VULKAN_HPP_NOEXCEPT
4099 {
4100 return ( flags == rhs.flags ) && ( BitDepth == rhs.BitDepth ) && ( subsampling_x == rhs.subsampling_x ) && ( subsampling_y == rhs.subsampling_y ) &&
4101 ( reserved1 == rhs.reserved1 ) && ( color_primaries == rhs.color_primaries ) && ( transfer_characteristics == rhs.transfer_characteristics ) &&
4102 ( matrix_coefficients == rhs.matrix_coefficients ) && ( chroma_sample_position == rhs.chroma_sample_position );
4103 }
4104
4105 bool operator!=( AV1ColorConfig const & rhs ) const VULKAN_HPP_NOEXCEPT
4106 {
4107 return !operator==( rhs );
4108 }
4109
4110 public:
4111 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorConfigFlags flags = {};
4112 uint8_t BitDepth = {};
4113 uint8_t subsampling_x = {};
4114 uint8_t subsampling_y = {};
4115 uint8_t reserved1 = {};
4116 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorPrimaries color_primaries =
4117 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorPrimaries::eBt709;
4118 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TransferCharacteristics transfer_characteristics =
4119 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TransferCharacteristics::eReserved0;
4120 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1MatrixCoefficients matrix_coefficients =
4121 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1MatrixCoefficients::eIdentity;
4122 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ChromaSamplePosition chroma_sample_position =
4123 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ChromaSamplePosition::eUnknown;
4124 };
4125
4126 struct AV1TimingInfoFlags
4127 {
4128 using NativeType = StdVideoAV1TimingInfoFlags;
4129
4130 operator StdVideoAV1TimingInfoFlags const &() const VULKAN_HPP_NOEXCEPT
4131 {
4132 return *reinterpret_cast<const StdVideoAV1TimingInfoFlags *>( this );
4133 }
4134
4135 operator StdVideoAV1TimingInfoFlags &() VULKAN_HPP_NOEXCEPT
4136 {
4137 return *reinterpret_cast<StdVideoAV1TimingInfoFlags *>( this );
4138 }
4139
4140 operator StdVideoAV1TimingInfoFlags const *() const VULKAN_HPP_NOEXCEPT
4141 {
4142 return reinterpret_cast<const StdVideoAV1TimingInfoFlags *>( this );
4143 }
4144
4145 operator StdVideoAV1TimingInfoFlags *() VULKAN_HPP_NOEXCEPT
4146 {
4147 return reinterpret_cast<StdVideoAV1TimingInfoFlags *>( this );
4148 }
4149
4150 bool operator==( AV1TimingInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
4151 {
4152 return ( equal_picture_interval == rhs.equal_picture_interval ) && ( reserved == rhs.reserved );
4153 }
4154
4155 bool operator!=( AV1TimingInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
4156 {
4157 return !operator==( rhs );
4158 }
4159
4160 public:
4161 uint32_t equal_picture_interval : 1;
4162 uint32_t reserved : 31;
4163 };
4164
4165 struct AV1TimingInfo
4166 {
4167 using NativeType = StdVideoAV1TimingInfo;
4168
4169 operator StdVideoAV1TimingInfo const &() const VULKAN_HPP_NOEXCEPT
4170 {
4171 return *reinterpret_cast<const StdVideoAV1TimingInfo *>( this );
4172 }
4173
4174 operator StdVideoAV1TimingInfo &() VULKAN_HPP_NOEXCEPT
4175 {
4176 return *reinterpret_cast<StdVideoAV1TimingInfo *>( this );
4177 }
4178
4179 operator StdVideoAV1TimingInfo const *() const VULKAN_HPP_NOEXCEPT
4180 {
4181 return reinterpret_cast<const StdVideoAV1TimingInfo *>( this );
4182 }
4183
4184 operator StdVideoAV1TimingInfo *() VULKAN_HPP_NOEXCEPT
4185 {
4186 return reinterpret_cast<StdVideoAV1TimingInfo *>( this );
4187 }
4188
4189 bool operator==( AV1TimingInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
4190 {
4191 return ( flags == rhs.flags ) && ( num_units_in_display_tick == rhs.num_units_in_display_tick ) && ( time_scale == rhs.time_scale ) &&
4192 ( num_ticks_per_picture_minus_1 == rhs.num_ticks_per_picture_minus_1 );
4193 }
4194
4195 bool operator!=( AV1TimingInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
4196 {
4197 return !operator==( rhs );
4198 }
4199
4200 public:
4201 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TimingInfoFlags flags = {};
4202 uint32_t num_units_in_display_tick = {};
4203 uint32_t time_scale = {};
4204 uint32_t num_ticks_per_picture_minus_1 = {};
4205 };
4206
4207 struct AV1LoopFilterFlags
4208 {
4209 using NativeType = StdVideoAV1LoopFilterFlags;
4210
4211 operator StdVideoAV1LoopFilterFlags const &() const VULKAN_HPP_NOEXCEPT
4212 {
4213 return *reinterpret_cast<const StdVideoAV1LoopFilterFlags *>( this );
4214 }
4215
4216 operator StdVideoAV1LoopFilterFlags &() VULKAN_HPP_NOEXCEPT
4217 {
4218 return *reinterpret_cast<StdVideoAV1LoopFilterFlags *>( this );
4219 }
4220
4221 operator StdVideoAV1LoopFilterFlags const *() const VULKAN_HPP_NOEXCEPT
4222 {
4223 return reinterpret_cast<const StdVideoAV1LoopFilterFlags *>( this );
4224 }
4225
4226 operator StdVideoAV1LoopFilterFlags *() VULKAN_HPP_NOEXCEPT
4227 {
4228 return reinterpret_cast<StdVideoAV1LoopFilterFlags *>( this );
4229 }
4230
4231 bool operator==( AV1LoopFilterFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
4232 {
4233 return ( loop_filter_delta_enabled == rhs.loop_filter_delta_enabled ) && ( loop_filter_delta_update == rhs.loop_filter_delta_update ) &&
4234 ( reserved == rhs.reserved );
4235 }
4236
4237 bool operator!=( AV1LoopFilterFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
4238 {
4239 return !operator==( rhs );
4240 }
4241
4242 public:
4243 uint32_t loop_filter_delta_enabled : 1;
4244 uint32_t loop_filter_delta_update : 1;
4245 uint32_t reserved : 30;
4246 };
4247
4248 struct AV1LoopFilter
4249 {
4250 using NativeType = StdVideoAV1LoopFilter;
4251
4252 operator StdVideoAV1LoopFilter const &() const VULKAN_HPP_NOEXCEPT
4253 {
4254 return *reinterpret_cast<const StdVideoAV1LoopFilter *>( this );
4255 }
4256
4257 operator StdVideoAV1LoopFilter &() VULKAN_HPP_NOEXCEPT
4258 {
4259 return *reinterpret_cast<StdVideoAV1LoopFilter *>( this );
4260 }
4261
4262 operator StdVideoAV1LoopFilter const *() const VULKAN_HPP_NOEXCEPT
4263 {
4264 return reinterpret_cast<const StdVideoAV1LoopFilter *>( this );
4265 }
4266
4267 operator StdVideoAV1LoopFilter *() VULKAN_HPP_NOEXCEPT
4268 {
4269 return reinterpret_cast<StdVideoAV1LoopFilter *>( this );
4270 }
4271
4272 bool operator==( AV1LoopFilter const & rhs ) const VULKAN_HPP_NOEXCEPT
4273 {
4274 return ( flags == rhs.flags ) && ( loop_filter_level == rhs.loop_filter_level ) && ( loop_filter_sharpness == rhs.loop_filter_sharpness ) &&
4275 ( update_ref_delta == rhs.update_ref_delta ) && ( loop_filter_ref_deltas == rhs.loop_filter_ref_deltas ) &&
4276 ( update_mode_delta == rhs.update_mode_delta ) && ( loop_filter_mode_deltas == rhs.loop_filter_mode_deltas );
4277 }
4278
4279 bool operator!=( AV1LoopFilter const & rhs ) const VULKAN_HPP_NOEXCEPT
4280 {
4281 return !operator==( rhs );
4282 }
4283
4284 public:
4285 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopFilterFlags flags = {};
4286 ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_MAX_LOOP_FILTER_STRENGTHS> loop_filter_level = {};
4287 uint8_t loop_filter_sharpness = {};
4288 uint8_t update_ref_delta = {};
4289 ArrayWrapper1D<int8_t, STD_VIDEO_AV1_TOTAL_REFS_PER_FRAME> loop_filter_ref_deltas = {};
4290 uint8_t update_mode_delta = {};
4291 ArrayWrapper1D<int8_t, STD_VIDEO_AV1_LOOP_FILTER_ADJUSTMENTS> loop_filter_mode_deltas = {};
4292 };
4293
4294 struct AV1QuantizationFlags
4295 {
4296 using NativeType = StdVideoAV1QuantizationFlags;
4297
4298 operator StdVideoAV1QuantizationFlags const &() const VULKAN_HPP_NOEXCEPT
4299 {
4300 return *reinterpret_cast<const StdVideoAV1QuantizationFlags *>( this );
4301 }
4302
4303 operator StdVideoAV1QuantizationFlags &() VULKAN_HPP_NOEXCEPT
4304 {
4305 return *reinterpret_cast<StdVideoAV1QuantizationFlags *>( this );
4306 }
4307
4308 operator StdVideoAV1QuantizationFlags const *() const VULKAN_HPP_NOEXCEPT
4309 {
4310 return reinterpret_cast<const StdVideoAV1QuantizationFlags *>( this );
4311 }
4312
4313 operator StdVideoAV1QuantizationFlags *() VULKAN_HPP_NOEXCEPT
4314 {
4315 return reinterpret_cast<StdVideoAV1QuantizationFlags *>( this );
4316 }
4317
4318 bool operator==( AV1QuantizationFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
4319 {
4320 return ( using_qmatrix == rhs.using_qmatrix ) && ( diff_uv_delta == rhs.diff_uv_delta ) && ( reserved == rhs.reserved );
4321 }
4322
4323 bool operator!=( AV1QuantizationFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
4324 {
4325 return !operator==( rhs );
4326 }
4327
4328 public:
4329 uint32_t using_qmatrix : 1;
4330 uint32_t diff_uv_delta : 1;
4331 uint32_t reserved : 30;
4332 };
4333
4334 struct AV1Quantization
4335 {
4336 using NativeType = StdVideoAV1Quantization;
4337
4338 operator StdVideoAV1Quantization const &() const VULKAN_HPP_NOEXCEPT
4339 {
4340 return *reinterpret_cast<const StdVideoAV1Quantization *>( this );
4341 }
4342
4343 operator StdVideoAV1Quantization &() VULKAN_HPP_NOEXCEPT
4344 {
4345 return *reinterpret_cast<StdVideoAV1Quantization *>( this );
4346 }
4347
4348 operator StdVideoAV1Quantization const *() const VULKAN_HPP_NOEXCEPT
4349 {
4350 return reinterpret_cast<const StdVideoAV1Quantization *>( this );
4351 }
4352
4353 operator StdVideoAV1Quantization *() VULKAN_HPP_NOEXCEPT
4354 {
4355 return reinterpret_cast<StdVideoAV1Quantization *>( this );
4356 }
4357
4358 bool operator==( AV1Quantization const & rhs ) const VULKAN_HPP_NOEXCEPT
4359 {
4360 return ( flags == rhs.flags ) && ( base_q_idx == rhs.base_q_idx ) && ( DeltaQYDc == rhs.DeltaQYDc ) && ( DeltaQUDc == rhs.DeltaQUDc ) &&
4361 ( DeltaQUAc == rhs.DeltaQUAc ) && ( DeltaQVDc == rhs.DeltaQVDc ) && ( DeltaQVAc == rhs.DeltaQVAc ) && ( qm_y == rhs.qm_y ) &&
4362 ( qm_u == rhs.qm_u ) && ( qm_v == rhs.qm_v );
4363 }
4364
4365 bool operator!=( AV1Quantization const & rhs ) const VULKAN_HPP_NOEXCEPT
4366 {
4367 return !operator==( rhs );
4368 }
4369
4370 public:
4371 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1QuantizationFlags flags = {};
4372 uint8_t base_q_idx = {};
4373 int8_t DeltaQYDc = {};
4374 int8_t DeltaQUDc = {};
4375 int8_t DeltaQUAc = {};
4376 int8_t DeltaQVDc = {};
4377 int8_t DeltaQVAc = {};
4378 uint8_t qm_y = {};
4379 uint8_t qm_u = {};
4380 uint8_t qm_v = {};
4381 };
4382
4383 struct AV1Segmentation
4384 {
4385 using NativeType = StdVideoAV1Segmentation;
4386
4387 operator StdVideoAV1Segmentation const &() const VULKAN_HPP_NOEXCEPT
4388 {
4389 return *reinterpret_cast<const StdVideoAV1Segmentation *>( this );
4390 }
4391
4392 operator StdVideoAV1Segmentation &() VULKAN_HPP_NOEXCEPT
4393 {
4394 return *reinterpret_cast<StdVideoAV1Segmentation *>( this );
4395 }
4396
4397 operator StdVideoAV1Segmentation const *() const VULKAN_HPP_NOEXCEPT
4398 {
4399 return reinterpret_cast<const StdVideoAV1Segmentation *>( this );
4400 }
4401
4402 operator StdVideoAV1Segmentation *() VULKAN_HPP_NOEXCEPT
4403 {
4404 return reinterpret_cast<StdVideoAV1Segmentation *>( this );
4405 }
4406
4407 bool operator==( AV1Segmentation const & rhs ) const VULKAN_HPP_NOEXCEPT
4408 {
4409 return ( FeatureEnabled == rhs.FeatureEnabled ) && ( FeatureData == rhs.FeatureData );
4410 }
4411
4412 bool operator!=( AV1Segmentation const & rhs ) const VULKAN_HPP_NOEXCEPT
4413 {
4414 return !operator==( rhs );
4415 }
4416
4417 public:
4418 ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_MAX_SEGMENTS> FeatureEnabled = {};
4419 ArrayWrapper2D<int16_t, STD_VIDEO_AV1_MAX_SEGMENTS, STD_VIDEO_AV1_SEG_LVL_MAX> FeatureData = {};
4420 };
4421
4422 struct AV1TileInfoFlags
4423 {
4424 using NativeType = StdVideoAV1TileInfoFlags;
4425
4426 operator StdVideoAV1TileInfoFlags const &() const VULKAN_HPP_NOEXCEPT
4427 {
4428 return *reinterpret_cast<const StdVideoAV1TileInfoFlags *>( this );
4429 }
4430
4431 operator StdVideoAV1TileInfoFlags &() VULKAN_HPP_NOEXCEPT
4432 {
4433 return *reinterpret_cast<StdVideoAV1TileInfoFlags *>( this );
4434 }
4435
4436 operator StdVideoAV1TileInfoFlags const *() const VULKAN_HPP_NOEXCEPT
4437 {
4438 return reinterpret_cast<const StdVideoAV1TileInfoFlags *>( this );
4439 }
4440
4441 operator StdVideoAV1TileInfoFlags *() VULKAN_HPP_NOEXCEPT
4442 {
4443 return reinterpret_cast<StdVideoAV1TileInfoFlags *>( this );
4444 }
4445
4446 bool operator==( AV1TileInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
4447 {
4448 return ( uniform_tile_spacing_flag == rhs.uniform_tile_spacing_flag ) && ( reserved == rhs.reserved );
4449 }
4450
4451 bool operator!=( AV1TileInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
4452 {
4453 return !operator==( rhs );
4454 }
4455
4456 public:
4457 uint32_t uniform_tile_spacing_flag : 1;
4458 uint32_t reserved : 31;
4459 };
4460
4461 struct AV1TileInfo
4462 {
4463 using NativeType = StdVideoAV1TileInfo;
4464
4465 operator StdVideoAV1TileInfo const &() const VULKAN_HPP_NOEXCEPT
4466 {
4467 return *reinterpret_cast<const StdVideoAV1TileInfo *>( this );
4468 }
4469
4470 operator StdVideoAV1TileInfo &() VULKAN_HPP_NOEXCEPT
4471 {
4472 return *reinterpret_cast<StdVideoAV1TileInfo *>( this );
4473 }
4474
4475 operator StdVideoAV1TileInfo const *() const VULKAN_HPP_NOEXCEPT
4476 {
4477 return reinterpret_cast<const StdVideoAV1TileInfo *>( this );
4478 }
4479
4480 operator StdVideoAV1TileInfo *() VULKAN_HPP_NOEXCEPT
4481 {
4482 return reinterpret_cast<StdVideoAV1TileInfo *>( this );
4483 }
4484
4485 bool operator==( AV1TileInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
4486 {
4487 return ( flags == rhs.flags ) && ( TileCols == rhs.TileCols ) && ( TileRows == rhs.TileRows ) &&
4488 ( context_update_tile_id == rhs.context_update_tile_id ) && ( tile_size_bytes_minus_1 == rhs.tile_size_bytes_minus_1 ) &&
4489 ( reserved1 == rhs.reserved1 ) && ( pMiColStarts == rhs.pMiColStarts ) && ( pMiRowStarts == rhs.pMiRowStarts ) &&
4490 ( pWidthInSbsMinus1 == rhs.pWidthInSbsMinus1 ) && ( pHeightInSbsMinus1 == rhs.pHeightInSbsMinus1 );
4491 }
4492
4493 bool operator!=( AV1TileInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
4494 {
4495 return !operator==( rhs );
4496 }
4497
4498 public:
4499 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TileInfoFlags flags = {};
4500 uint8_t TileCols = {};
4501 uint8_t TileRows = {};
4502 uint16_t context_update_tile_id = {};
4503 uint8_t tile_size_bytes_minus_1 = {};
4504 ArrayWrapper1D<uint8_t, 7> reserved1 = {};
4505 const uint16_t * pMiColStarts = {};
4506 const uint16_t * pMiRowStarts = {};
4507 const uint16_t * pWidthInSbsMinus1 = {};
4508 const uint16_t * pHeightInSbsMinus1 = {};
4509 };
4510
4511 struct AV1CDEF
4512 {
4513 using NativeType = StdVideoAV1CDEF;
4514
4515 operator StdVideoAV1CDEF const &() const VULKAN_HPP_NOEXCEPT
4516 {
4517 return *reinterpret_cast<const StdVideoAV1CDEF *>( this );
4518 }
4519
4520 operator StdVideoAV1CDEF &() VULKAN_HPP_NOEXCEPT
4521 {
4522 return *reinterpret_cast<StdVideoAV1CDEF *>( this );
4523 }
4524
4525 operator StdVideoAV1CDEF const *() const VULKAN_HPP_NOEXCEPT
4526 {
4527 return reinterpret_cast<const StdVideoAV1CDEF *>( this );
4528 }
4529
4530 operator StdVideoAV1CDEF *() VULKAN_HPP_NOEXCEPT
4531 {
4532 return reinterpret_cast<StdVideoAV1CDEF *>( this );
4533 }
4534
4535 bool operator==( AV1CDEF const & rhs ) const VULKAN_HPP_NOEXCEPT
4536 {
4537 return ( cdef_damping_minus_3 == rhs.cdef_damping_minus_3 ) && ( cdef_bits == rhs.cdef_bits ) && ( cdef_y_pri_strength == rhs.cdef_y_pri_strength ) &&
4538 ( cdef_y_sec_strength == rhs.cdef_y_sec_strength ) && ( cdef_uv_pri_strength == rhs.cdef_uv_pri_strength ) &&
4539 ( cdef_uv_sec_strength == rhs.cdef_uv_sec_strength );
4540 }
4541
4542 bool operator!=( AV1CDEF const & rhs ) const VULKAN_HPP_NOEXCEPT
4543 {
4544 return !operator==( rhs );
4545 }
4546
4547 public:
4548 uint8_t cdef_damping_minus_3 = {};
4549 uint8_t cdef_bits = {};
4550 ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS> cdef_y_pri_strength = {};
4551 ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS> cdef_y_sec_strength = {};
4552 ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS> cdef_uv_pri_strength = {};
4553 ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS> cdef_uv_sec_strength = {};
4554 };
4555
4556 struct AV1LoopRestoration
4557 {
4558 using NativeType = StdVideoAV1LoopRestoration;
4559
4560 operator StdVideoAV1LoopRestoration const &() const VULKAN_HPP_NOEXCEPT
4561 {
4562 return *reinterpret_cast<const StdVideoAV1LoopRestoration *>( this );
4563 }
4564
4565 operator StdVideoAV1LoopRestoration &() VULKAN_HPP_NOEXCEPT
4566 {
4567 return *reinterpret_cast<StdVideoAV1LoopRestoration *>( this );
4568 }
4569
4570 operator StdVideoAV1LoopRestoration const *() const VULKAN_HPP_NOEXCEPT
4571 {
4572 return reinterpret_cast<const StdVideoAV1LoopRestoration *>( this );
4573 }
4574
4575 operator StdVideoAV1LoopRestoration *() VULKAN_HPP_NOEXCEPT
4576 {
4577 return reinterpret_cast<StdVideoAV1LoopRestoration *>( this );
4578 }
4579
4580 bool operator==( AV1LoopRestoration const & rhs ) const VULKAN_HPP_NOEXCEPT
4581 {
4582 return ( FrameRestorationType == rhs.FrameRestorationType ) && ( LoopRestorationSize == rhs.LoopRestorationSize );
4583 }
4584
4585 bool operator!=( AV1LoopRestoration const & rhs ) const VULKAN_HPP_NOEXCEPT
4586 {
4587 return !operator==( rhs );
4588 }
4589
4590 public:
4591 ArrayWrapper1D<StdVideoAV1FrameRestorationType, STD_VIDEO_AV1_MAX_NUM_PLANES> FrameRestorationType = {};
4592 ArrayWrapper1D<uint16_t, STD_VIDEO_AV1_MAX_NUM_PLANES> LoopRestorationSize = {};
4593 };
4594
4595 struct AV1GlobalMotion
4596 {
4597 using NativeType = StdVideoAV1GlobalMotion;
4598
4599 operator StdVideoAV1GlobalMotion const &() const VULKAN_HPP_NOEXCEPT
4600 {
4601 return *reinterpret_cast<const StdVideoAV1GlobalMotion *>( this );
4602 }
4603
4604 operator StdVideoAV1GlobalMotion &() VULKAN_HPP_NOEXCEPT
4605 {
4606 return *reinterpret_cast<StdVideoAV1GlobalMotion *>( this );
4607 }
4608
4609 operator StdVideoAV1GlobalMotion const *() const VULKAN_HPP_NOEXCEPT
4610 {
4611 return reinterpret_cast<const StdVideoAV1GlobalMotion *>( this );
4612 }
4613
4614 operator StdVideoAV1GlobalMotion *() VULKAN_HPP_NOEXCEPT
4615 {
4616 return reinterpret_cast<StdVideoAV1GlobalMotion *>( this );
4617 }
4618
4619 bool operator==( AV1GlobalMotion const & rhs ) const VULKAN_HPP_NOEXCEPT
4620 {
4621 return ( GmType == rhs.GmType ) && ( gm_params == rhs.gm_params );
4622 }
4623
4624 bool operator!=( AV1GlobalMotion const & rhs ) const VULKAN_HPP_NOEXCEPT
4625 {
4626 return !operator==( rhs );
4627 }
4628
4629 public:
4630 ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_NUM_REF_FRAMES> GmType = {};
4631 ArrayWrapper2D<int32_t, STD_VIDEO_AV1_NUM_REF_FRAMES, STD_VIDEO_AV1_GLOBAL_MOTION_PARAMS> gm_params = {};
4632 };
4633
4634 struct AV1FilmGrainFlags
4635 {
4636 using NativeType = StdVideoAV1FilmGrainFlags;
4637
4638 operator StdVideoAV1FilmGrainFlags const &() const VULKAN_HPP_NOEXCEPT
4639 {
4640 return *reinterpret_cast<const StdVideoAV1FilmGrainFlags *>( this );
4641 }
4642
4643 operator StdVideoAV1FilmGrainFlags &() VULKAN_HPP_NOEXCEPT
4644 {
4645 return *reinterpret_cast<StdVideoAV1FilmGrainFlags *>( this );
4646 }
4647
4648 operator StdVideoAV1FilmGrainFlags const *() const VULKAN_HPP_NOEXCEPT
4649 {
4650 return reinterpret_cast<const StdVideoAV1FilmGrainFlags *>( this );
4651 }
4652
4653 operator StdVideoAV1FilmGrainFlags *() VULKAN_HPP_NOEXCEPT
4654 {
4655 return reinterpret_cast<StdVideoAV1FilmGrainFlags *>( this );
4656 }
4657
4658 bool operator==( AV1FilmGrainFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
4659 {
4660 return ( chroma_scaling_from_luma == rhs.chroma_scaling_from_luma ) && ( overlap_flag == rhs.overlap_flag ) &&
4661 ( clip_to_restricted_range == rhs.clip_to_restricted_range ) && ( update_grain == rhs.update_grain ) && ( reserved == rhs.reserved );
4662 }
4663
4664 bool operator!=( AV1FilmGrainFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
4665 {
4666 return !operator==( rhs );
4667 }
4668
4669 public:
4670 uint32_t chroma_scaling_from_luma : 1;
4671 uint32_t overlap_flag : 1;
4672 uint32_t clip_to_restricted_range : 1;
4673 uint32_t update_grain : 1;
4674 uint32_t reserved : 28;
4675 };
4676
4677 struct AV1FilmGrain
4678 {
4679 using NativeType = StdVideoAV1FilmGrain;
4680
4681 operator StdVideoAV1FilmGrain const &() const VULKAN_HPP_NOEXCEPT
4682 {
4683 return *reinterpret_cast<const StdVideoAV1FilmGrain *>( this );
4684 }
4685
4686 operator StdVideoAV1FilmGrain &() VULKAN_HPP_NOEXCEPT
4687 {
4688 return *reinterpret_cast<StdVideoAV1FilmGrain *>( this );
4689 }
4690
4691 operator StdVideoAV1FilmGrain const *() const VULKAN_HPP_NOEXCEPT
4692 {
4693 return reinterpret_cast<const StdVideoAV1FilmGrain *>( this );
4694 }
4695
4696 operator StdVideoAV1FilmGrain *() VULKAN_HPP_NOEXCEPT
4697 {
4698 return reinterpret_cast<StdVideoAV1FilmGrain *>( this );
4699 }
4700
4701 bool operator==( AV1FilmGrain const & rhs ) const VULKAN_HPP_NOEXCEPT
4702 {
4703 return ( flags == rhs.flags ) && ( grain_scaling_minus_8 == rhs.grain_scaling_minus_8 ) && ( ar_coeff_lag == rhs.ar_coeff_lag ) &&
4704 ( ar_coeff_shift_minus_6 == rhs.ar_coeff_shift_minus_6 ) && ( grain_scale_shift == rhs.grain_scale_shift ) && ( grain_seed == rhs.grain_seed ) &&
4705 ( film_grain_params_ref_idx == rhs.film_grain_params_ref_idx ) && ( num_y_points == rhs.num_y_points ) &&
4706 ( point_y_value == rhs.point_y_value ) && ( point_y_scaling == rhs.point_y_scaling ) && ( num_cb_points == rhs.num_cb_points ) &&
4707 ( point_cb_value == rhs.point_cb_value ) && ( point_cb_scaling == rhs.point_cb_scaling ) && ( num_cr_points == rhs.num_cr_points ) &&
4708 ( point_cr_value == rhs.point_cr_value ) && ( point_cr_scaling == rhs.point_cr_scaling ) &&
4709 ( ar_coeffs_y_plus_128 == rhs.ar_coeffs_y_plus_128 ) && ( ar_coeffs_cb_plus_128 == rhs.ar_coeffs_cb_plus_128 ) &&
4710 ( ar_coeffs_cr_plus_128 == rhs.ar_coeffs_cr_plus_128 ) && ( cb_mult == rhs.cb_mult ) && ( cb_luma_mult == rhs.cb_luma_mult ) &&
4711 ( cb_offset == rhs.cb_offset ) && ( cr_mult == rhs.cr_mult ) && ( cr_luma_mult == rhs.cr_luma_mult ) && ( cr_offset == rhs.cr_offset );
4712 }
4713
4714 bool operator!=( AV1FilmGrain const & rhs ) const VULKAN_HPP_NOEXCEPT
4715 {
4716 return !operator==( rhs );
4717 }
4718
4719 public:
4720 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FilmGrainFlags flags = {};
4721 uint8_t grain_scaling_minus_8 = {};
4722 uint8_t ar_coeff_lag = {};
4723 uint8_t ar_coeff_shift_minus_6 = {};
4724 uint8_t grain_scale_shift = {};
4725 uint16_t grain_seed = {};
4726 uint8_t film_grain_params_ref_idx = {};
4727 uint8_t num_y_points = {};
4728 ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_MAX_NUM_Y_POINTS> point_y_value = {};
4729 ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_MAX_NUM_Y_POINTS> point_y_scaling = {};
4730 uint8_t num_cb_points = {};
4731 ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_MAX_NUM_CB_POINTS> point_cb_value = {};
4732 ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_MAX_NUM_CB_POINTS> point_cb_scaling = {};
4733 uint8_t num_cr_points = {};
4734 ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_MAX_NUM_CR_POINTS> point_cr_value = {};
4735 ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_MAX_NUM_CR_POINTS> point_cr_scaling = {};
4736 ArrayWrapper1D<int8_t, STD_VIDEO_AV1_MAX_NUM_POS_LUMA> ar_coeffs_y_plus_128 = {};
4737 ArrayWrapper1D<int8_t, STD_VIDEO_AV1_MAX_NUM_POS_CHROMA> ar_coeffs_cb_plus_128 = {};
4738 ArrayWrapper1D<int8_t, STD_VIDEO_AV1_MAX_NUM_POS_CHROMA> ar_coeffs_cr_plus_128 = {};
4739 uint8_t cb_mult = {};
4740 uint8_t cb_luma_mult = {};
4741 uint16_t cb_offset = {};
4742 uint8_t cr_mult = {};
4743 uint8_t cr_luma_mult = {};
4744 uint16_t cr_offset = {};
4745 };
4746
4747 struct AV1SequenceHeaderFlags
4748 {
4749 using NativeType = StdVideoAV1SequenceHeaderFlags;
4750
4751 operator StdVideoAV1SequenceHeaderFlags const &() const VULKAN_HPP_NOEXCEPT
4752 {
4753 return *reinterpret_cast<const StdVideoAV1SequenceHeaderFlags *>( this );
4754 }
4755
4756 operator StdVideoAV1SequenceHeaderFlags &() VULKAN_HPP_NOEXCEPT
4757 {
4758 return *reinterpret_cast<StdVideoAV1SequenceHeaderFlags *>( this );
4759 }
4760
4761 operator StdVideoAV1SequenceHeaderFlags const *() const VULKAN_HPP_NOEXCEPT
4762 {
4763 return reinterpret_cast<const StdVideoAV1SequenceHeaderFlags *>( this );
4764 }
4765
4766 operator StdVideoAV1SequenceHeaderFlags *() VULKAN_HPP_NOEXCEPT
4767 {
4768 return reinterpret_cast<StdVideoAV1SequenceHeaderFlags *>( this );
4769 }
4770
4771 bool operator==( AV1SequenceHeaderFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
4772 {
4773 return ( still_picture == rhs.still_picture ) && ( reduced_still_picture_header == rhs.reduced_still_picture_header ) &&
4774 ( use_128x128_superblock == rhs.use_128x128_superblock ) && ( enable_filter_intra == rhs.enable_filter_intra ) &&
4775 ( enable_intra_edge_filter == rhs.enable_intra_edge_filter ) && ( enable_interintra_compound == rhs.enable_interintra_compound ) &&
4776 ( enable_masked_compound == rhs.enable_masked_compound ) && ( enable_warped_motion == rhs.enable_warped_motion ) &&
4777 ( enable_dual_filter == rhs.enable_dual_filter ) && ( enable_order_hint == rhs.enable_order_hint ) &&
4778 ( enable_jnt_comp == rhs.enable_jnt_comp ) && ( enable_ref_frame_mvs == rhs.enable_ref_frame_mvs ) &&
4779 ( frame_id_numbers_present_flag == rhs.frame_id_numbers_present_flag ) && ( enable_superres == rhs.enable_superres ) &&
4780 ( enable_cdef == rhs.enable_cdef ) && ( enable_restoration == rhs.enable_restoration ) &&
4781 ( film_grain_params_present == rhs.film_grain_params_present ) && ( timing_info_present_flag == rhs.timing_info_present_flag ) &&
4782 ( initial_display_delay_present_flag == rhs.initial_display_delay_present_flag ) && ( reserved == rhs.reserved );
4783 }
4784
4785 bool operator!=( AV1SequenceHeaderFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
4786 {
4787 return !operator==( rhs );
4788 }
4789
4790 public:
4791 uint32_t still_picture : 1;
4792 uint32_t reduced_still_picture_header : 1;
4793 uint32_t use_128x128_superblock : 1;
4794 uint32_t enable_filter_intra : 1;
4795 uint32_t enable_intra_edge_filter : 1;
4796 uint32_t enable_interintra_compound : 1;
4797 uint32_t enable_masked_compound : 1;
4798 uint32_t enable_warped_motion : 1;
4799 uint32_t enable_dual_filter : 1;
4800 uint32_t enable_order_hint : 1;
4801 uint32_t enable_jnt_comp : 1;
4802 uint32_t enable_ref_frame_mvs : 1;
4803 uint32_t frame_id_numbers_present_flag : 1;
4804 uint32_t enable_superres : 1;
4805 uint32_t enable_cdef : 1;
4806 uint32_t enable_restoration : 1;
4807 uint32_t film_grain_params_present : 1;
4808 uint32_t timing_info_present_flag : 1;
4809 uint32_t initial_display_delay_present_flag : 1;
4810 uint32_t reserved : 13;
4811 };
4812
4813 struct AV1SequenceHeader
4814 {
4815 using NativeType = StdVideoAV1SequenceHeader;
4816
4817 operator StdVideoAV1SequenceHeader const &() const VULKAN_HPP_NOEXCEPT
4818 {
4819 return *reinterpret_cast<const StdVideoAV1SequenceHeader *>( this );
4820 }
4821
4822 operator StdVideoAV1SequenceHeader &() VULKAN_HPP_NOEXCEPT
4823 {
4824 return *reinterpret_cast<StdVideoAV1SequenceHeader *>( this );
4825 }
4826
4827 operator StdVideoAV1SequenceHeader const *() const VULKAN_HPP_NOEXCEPT
4828 {
4829 return reinterpret_cast<const StdVideoAV1SequenceHeader *>( this );
4830 }
4831
4832 operator StdVideoAV1SequenceHeader *() VULKAN_HPP_NOEXCEPT
4833 {
4834 return reinterpret_cast<StdVideoAV1SequenceHeader *>( this );
4835 }
4836
4837 bool operator==( AV1SequenceHeader const & rhs ) const VULKAN_HPP_NOEXCEPT
4838 {
4839 return ( flags == rhs.flags ) && ( seq_profile == rhs.seq_profile ) && ( frame_width_bits_minus_1 == rhs.frame_width_bits_minus_1 ) &&
4840 ( frame_height_bits_minus_1 == rhs.frame_height_bits_minus_1 ) && ( max_frame_width_minus_1 == rhs.max_frame_width_minus_1 ) &&
4841 ( max_frame_height_minus_1 == rhs.max_frame_height_minus_1 ) && ( delta_frame_id_length_minus_2 == rhs.delta_frame_id_length_minus_2 ) &&
4842 ( additional_frame_id_length_minus_1 == rhs.additional_frame_id_length_minus_1 ) && ( order_hint_bits_minus_1 == rhs.order_hint_bits_minus_1 ) &&
4843 ( seq_force_integer_mv == rhs.seq_force_integer_mv ) && ( seq_force_screen_content_tools == rhs.seq_force_screen_content_tools ) &&
4844 ( reserved1 == rhs.reserved1 ) && ( pColorConfig == rhs.pColorConfig ) && ( pTimingInfo == rhs.pTimingInfo );
4845 }
4846
4847 bool operator!=( AV1SequenceHeader const & rhs ) const VULKAN_HPP_NOEXCEPT
4848 {
4849 return !operator==( rhs );
4850 }
4851
4852 public:
4853 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1SequenceHeaderFlags flags = {};
4854 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Profile seq_profile = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Profile::eMain;
4855 uint8_t frame_width_bits_minus_1 = {};
4856 uint8_t frame_height_bits_minus_1 = {};
4857 uint16_t max_frame_width_minus_1 = {};
4858 uint16_t max_frame_height_minus_1 = {};
4859 uint8_t delta_frame_id_length_minus_2 = {};
4860 uint8_t additional_frame_id_length_minus_1 = {};
4861 uint8_t order_hint_bits_minus_1 = {};
4862 uint8_t seq_force_integer_mv = {};
4863 uint8_t seq_force_screen_content_tools = {};
4864 ArrayWrapper1D<uint8_t, 5> reserved1 = {};
4865 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorConfig * pColorConfig = {};
4866 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TimingInfo * pTimingInfo = {};
4867 };
4868 #endif
4869
4870 #if defined( VULKAN_VIDEO_CODEC_AV1STD_DECODE_H_ )
4871 //=== vulkan_video_codec_av1std_decode ===
4872
4873 struct DecodeAV1PictureInfoFlags
4874 {
4875 using NativeType = StdVideoDecodeAV1PictureInfoFlags;
4876
4877 operator StdVideoDecodeAV1PictureInfoFlags const &() const VULKAN_HPP_NOEXCEPT
4878 {
4879 return *reinterpret_cast<const StdVideoDecodeAV1PictureInfoFlags *>( this );
4880 }
4881
4882 operator StdVideoDecodeAV1PictureInfoFlags &() VULKAN_HPP_NOEXCEPT
4883 {
4884 return *reinterpret_cast<StdVideoDecodeAV1PictureInfoFlags *>( this );
4885 }
4886
4887 operator StdVideoDecodeAV1PictureInfoFlags const *() const VULKAN_HPP_NOEXCEPT
4888 {
4889 return reinterpret_cast<const StdVideoDecodeAV1PictureInfoFlags *>( this );
4890 }
4891
4892 operator StdVideoDecodeAV1PictureInfoFlags *() VULKAN_HPP_NOEXCEPT
4893 {
4894 return reinterpret_cast<StdVideoDecodeAV1PictureInfoFlags *>( this );
4895 }
4896
4897 bool operator==( DecodeAV1PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
4898 {
4899 return ( error_resilient_mode == rhs.error_resilient_mode ) && ( disable_cdf_update == rhs.disable_cdf_update ) &&
4900 ( use_superres == rhs.use_superres ) && ( render_and_frame_size_different == rhs.render_and_frame_size_different ) &&
4901 ( allow_screen_content_tools == rhs.allow_screen_content_tools ) && ( is_filter_switchable == rhs.is_filter_switchable ) &&
4902 ( force_integer_mv == rhs.force_integer_mv ) && ( frame_size_override_flag == rhs.frame_size_override_flag ) &&
4903 ( buffer_removal_time_present_flag == rhs.buffer_removal_time_present_flag ) && ( allow_intrabc == rhs.allow_intrabc ) &&
4904 ( frame_refs_short_signaling == rhs.frame_refs_short_signaling ) && ( allow_high_precision_mv == rhs.allow_high_precision_mv ) &&
4905 ( is_motion_mode_switchable == rhs.is_motion_mode_switchable ) && ( use_ref_frame_mvs == rhs.use_ref_frame_mvs ) &&
4906 ( disable_frame_end_update_cdf == rhs.disable_frame_end_update_cdf ) && ( allow_warped_motion == rhs.allow_warped_motion ) &&
4907 ( reduced_tx_set == rhs.reduced_tx_set ) && ( reference_select == rhs.reference_select ) && ( skip_mode_present == rhs.skip_mode_present ) &&
4908 ( delta_q_present == rhs.delta_q_present ) && ( delta_lf_present == rhs.delta_lf_present ) && ( delta_lf_multi == rhs.delta_lf_multi ) &&
4909 ( segmentation_enabled == rhs.segmentation_enabled ) && ( segmentation_update_map == rhs.segmentation_update_map ) &&
4910 ( segmentation_temporal_update == rhs.segmentation_temporal_update ) && ( segmentation_update_data == rhs.segmentation_update_data ) &&
4911 ( UsesLr == rhs.UsesLr ) && ( usesChromaLr == rhs.usesChromaLr ) && ( apply_grain == rhs.apply_grain ) && ( reserved == rhs.reserved );
4912 }
4913
4914 bool operator!=( DecodeAV1PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
4915 {
4916 return !operator==( rhs );
4917 }
4918
4919 public:
4920 uint32_t error_resilient_mode : 1;
4921 uint32_t disable_cdf_update : 1;
4922 uint32_t use_superres : 1;
4923 uint32_t render_and_frame_size_different : 1;
4924 uint32_t allow_screen_content_tools : 1;
4925 uint32_t is_filter_switchable : 1;
4926 uint32_t force_integer_mv : 1;
4927 uint32_t frame_size_override_flag : 1;
4928 uint32_t buffer_removal_time_present_flag : 1;
4929 uint32_t allow_intrabc : 1;
4930 uint32_t frame_refs_short_signaling : 1;
4931 uint32_t allow_high_precision_mv : 1;
4932 uint32_t is_motion_mode_switchable : 1;
4933 uint32_t use_ref_frame_mvs : 1;
4934 uint32_t disable_frame_end_update_cdf : 1;
4935 uint32_t allow_warped_motion : 1;
4936 uint32_t reduced_tx_set : 1;
4937 uint32_t reference_select : 1;
4938 uint32_t skip_mode_present : 1;
4939 uint32_t delta_q_present : 1;
4940 uint32_t delta_lf_present : 1;
4941 uint32_t delta_lf_multi : 1;
4942 uint32_t segmentation_enabled : 1;
4943 uint32_t segmentation_update_map : 1;
4944 uint32_t segmentation_temporal_update : 1;
4945 uint32_t segmentation_update_data : 1;
4946 uint32_t UsesLr : 1;
4947 uint32_t usesChromaLr : 1;
4948 uint32_t apply_grain : 1;
4949 uint32_t reserved : 3;
4950 };
4951
4952 struct DecodeAV1PictureInfo
4953 {
4954 using NativeType = StdVideoDecodeAV1PictureInfo;
4955
4956 operator StdVideoDecodeAV1PictureInfo const &() const VULKAN_HPP_NOEXCEPT
4957 {
4958 return *reinterpret_cast<const StdVideoDecodeAV1PictureInfo *>( this );
4959 }
4960
4961 operator StdVideoDecodeAV1PictureInfo &() VULKAN_HPP_NOEXCEPT
4962 {
4963 return *reinterpret_cast<StdVideoDecodeAV1PictureInfo *>( this );
4964 }
4965
4966 operator StdVideoDecodeAV1PictureInfo const *() const VULKAN_HPP_NOEXCEPT
4967 {
4968 return reinterpret_cast<const StdVideoDecodeAV1PictureInfo *>( this );
4969 }
4970
4971 operator StdVideoDecodeAV1PictureInfo *() VULKAN_HPP_NOEXCEPT
4972 {
4973 return reinterpret_cast<StdVideoDecodeAV1PictureInfo *>( this );
4974 }
4975
4976 bool operator==( DecodeAV1PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
4977 {
4978 return ( flags == rhs.flags ) && ( frame_type == rhs.frame_type ) && ( current_frame_id == rhs.current_frame_id ) && ( OrderHint == rhs.OrderHint ) &&
4979 ( primary_ref_frame == rhs.primary_ref_frame ) && ( refresh_frame_flags == rhs.refresh_frame_flags ) && ( reserved1 == rhs.reserved1 ) &&
4980 ( interpolation_filter == rhs.interpolation_filter ) && ( TxMode == rhs.TxMode ) && ( delta_q_res == rhs.delta_q_res ) &&
4981 ( delta_lf_res == rhs.delta_lf_res ) && ( SkipModeFrame == rhs.SkipModeFrame ) && ( coded_denom == rhs.coded_denom ) &&
4982 ( reserved2 == rhs.reserved2 ) && ( OrderHints == rhs.OrderHints ) && ( expectedFrameId == rhs.expectedFrameId ) &&
4983 ( pTileInfo == rhs.pTileInfo ) && ( pQuantization == rhs.pQuantization ) && ( pSegmentation == rhs.pSegmentation ) &&
4984 ( pLoopFilter == rhs.pLoopFilter ) && ( pCDEF == rhs.pCDEF ) && ( pLoopRestoration == rhs.pLoopRestoration ) &&
4985 ( pGlobalMotion == rhs.pGlobalMotion ) && ( pFilmGrain == rhs.pFilmGrain );
4986 }
4987
4988 bool operator!=( DecodeAV1PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
4989 {
4990 return !operator==( rhs );
4991 }
4992
4993 public:
4994 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1PictureInfoFlags flags = {};
4995 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameType frame_type = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameType::eKey;
4996 uint32_t current_frame_id = {};
4997 uint8_t OrderHint = {};
4998 uint8_t primary_ref_frame = {};
4999 uint8_t refresh_frame_flags = {};
5000 uint8_t reserved1 = {};
5001 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1InterpolationFilter interpolation_filter =
5002 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1InterpolationFilter::eEighttap;
5003 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TxMode TxMode = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TxMode::eOnly4X4;
5004 uint8_t delta_q_res = {};
5005 uint8_t delta_lf_res = {};
5006 ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_SKIP_MODE_FRAMES> SkipModeFrame = {};
5007 uint8_t coded_denom = {};
5008 ArrayWrapper1D<uint8_t, 3> reserved2 = {};
5009 ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_NUM_REF_FRAMES> OrderHints = {};
5010 ArrayWrapper1D<uint32_t, STD_VIDEO_AV1_NUM_REF_FRAMES> expectedFrameId = {};
5011 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TileInfo * pTileInfo = {};
5012 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Quantization * pQuantization = {};
5013 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Segmentation * pSegmentation = {};
5014 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopFilter * pLoopFilter = {};
5015 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1CDEF * pCDEF = {};
5016 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopRestoration * pLoopRestoration = {};
5017 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1GlobalMotion * pGlobalMotion = {};
5018 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FilmGrain * pFilmGrain = {};
5019 };
5020
5021 struct DecodeAV1ReferenceInfoFlags
5022 {
5023 using NativeType = StdVideoDecodeAV1ReferenceInfoFlags;
5024
5025 operator StdVideoDecodeAV1ReferenceInfoFlags const &() const VULKAN_HPP_NOEXCEPT
5026 {
5027 return *reinterpret_cast<const StdVideoDecodeAV1ReferenceInfoFlags *>( this );
5028 }
5029
5030 operator StdVideoDecodeAV1ReferenceInfoFlags &() VULKAN_HPP_NOEXCEPT
5031 {
5032 return *reinterpret_cast<StdVideoDecodeAV1ReferenceInfoFlags *>( this );
5033 }
5034
5035 operator StdVideoDecodeAV1ReferenceInfoFlags const *() const VULKAN_HPP_NOEXCEPT
5036 {
5037 return reinterpret_cast<const StdVideoDecodeAV1ReferenceInfoFlags *>( this );
5038 }
5039
5040 operator StdVideoDecodeAV1ReferenceInfoFlags *() VULKAN_HPP_NOEXCEPT
5041 {
5042 return reinterpret_cast<StdVideoDecodeAV1ReferenceInfoFlags *>( this );
5043 }
5044
5045 bool operator==( DecodeAV1ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
5046 {
5047 return ( disable_frame_end_update_cdf == rhs.disable_frame_end_update_cdf ) && ( segmentation_enabled == rhs.segmentation_enabled ) &&
5048 ( reserved == rhs.reserved );
5049 }
5050
5051 bool operator!=( DecodeAV1ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
5052 {
5053 return !operator==( rhs );
5054 }
5055
5056 public:
5057 uint32_t disable_frame_end_update_cdf : 1;
5058 uint32_t segmentation_enabled : 1;
5059 uint32_t reserved : 30;
5060 };
5061
5062 struct DecodeAV1ReferenceInfo
5063 {
5064 using NativeType = StdVideoDecodeAV1ReferenceInfo;
5065
5066 operator StdVideoDecodeAV1ReferenceInfo const &() const VULKAN_HPP_NOEXCEPT
5067 {
5068 return *reinterpret_cast<const StdVideoDecodeAV1ReferenceInfo *>( this );
5069 }
5070
5071 operator StdVideoDecodeAV1ReferenceInfo &() VULKAN_HPP_NOEXCEPT
5072 {
5073 return *reinterpret_cast<StdVideoDecodeAV1ReferenceInfo *>( this );
5074 }
5075
5076 operator StdVideoDecodeAV1ReferenceInfo const *() const VULKAN_HPP_NOEXCEPT
5077 {
5078 return reinterpret_cast<const StdVideoDecodeAV1ReferenceInfo *>( this );
5079 }
5080
5081 operator StdVideoDecodeAV1ReferenceInfo *() VULKAN_HPP_NOEXCEPT
5082 {
5083 return reinterpret_cast<StdVideoDecodeAV1ReferenceInfo *>( this );
5084 }
5085
5086 bool operator==( DecodeAV1ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
5087 {
5088 return ( flags == rhs.flags ) && ( frame_type == rhs.frame_type ) && ( RefFrameSignBias == rhs.RefFrameSignBias ) && ( OrderHint == rhs.OrderHint ) &&
5089 ( SavedOrderHints == rhs.SavedOrderHints );
5090 }
5091
5092 bool operator!=( DecodeAV1ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
5093 {
5094 return !operator==( rhs );
5095 }
5096
5097 public:
5098 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1ReferenceInfoFlags flags = {};
5099 uint8_t frame_type = {};
5100 uint8_t RefFrameSignBias = {};
5101 uint8_t OrderHint = {};
5102 ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_NUM_REF_FRAMES> SavedOrderHints = {};
5103 };
5104 #endif
5105
5106 #if defined( VULKAN_VIDEO_CODEC_AV1STD_ENCODE_H_ )
5107 //=== vulkan_video_codec_av1std_encode ===
5108
5109 struct EncodeAV1DecoderModelInfo
5110 {
5111 using NativeType = StdVideoEncodeAV1DecoderModelInfo;
5112
5113 operator StdVideoEncodeAV1DecoderModelInfo const &() const VULKAN_HPP_NOEXCEPT
5114 {
5115 return *reinterpret_cast<const StdVideoEncodeAV1DecoderModelInfo *>( this );
5116 }
5117
5118 operator StdVideoEncodeAV1DecoderModelInfo &() VULKAN_HPP_NOEXCEPT
5119 {
5120 return *reinterpret_cast<StdVideoEncodeAV1DecoderModelInfo *>( this );
5121 }
5122
5123 operator StdVideoEncodeAV1DecoderModelInfo const *() const VULKAN_HPP_NOEXCEPT
5124 {
5125 return reinterpret_cast<const StdVideoEncodeAV1DecoderModelInfo *>( this );
5126 }
5127
5128 operator StdVideoEncodeAV1DecoderModelInfo *() VULKAN_HPP_NOEXCEPT
5129 {
5130 return reinterpret_cast<StdVideoEncodeAV1DecoderModelInfo *>( this );
5131 }
5132
5133 bool operator==( EncodeAV1DecoderModelInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
5134 {
5135 return ( buffer_delay_length_minus_1 == rhs.buffer_delay_length_minus_1 ) &&
5136 ( buffer_removal_time_length_minus_1 == rhs.buffer_removal_time_length_minus_1 ) &&
5137 ( frame_presentation_time_length_minus_1 == rhs.frame_presentation_time_length_minus_1 ) && ( reserved1 == rhs.reserved1 ) &&
5138 ( num_units_in_decoding_tick == rhs.num_units_in_decoding_tick );
5139 }
5140
5141 bool operator!=( EncodeAV1DecoderModelInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
5142 {
5143 return !operator==( rhs );
5144 }
5145
5146 public:
5147 uint8_t buffer_delay_length_minus_1 = {};
5148 uint8_t buffer_removal_time_length_minus_1 = {};
5149 uint8_t frame_presentation_time_length_minus_1 = {};
5150 uint8_t reserved1 = {};
5151 uint32_t num_units_in_decoding_tick = {};
5152 };
5153
5154 struct EncodeAV1ExtensionHeader
5155 {
5156 using NativeType = StdVideoEncodeAV1ExtensionHeader;
5157
5158 operator StdVideoEncodeAV1ExtensionHeader const &() const VULKAN_HPP_NOEXCEPT
5159 {
5160 return *reinterpret_cast<const StdVideoEncodeAV1ExtensionHeader *>( this );
5161 }
5162
5163 operator StdVideoEncodeAV1ExtensionHeader &() VULKAN_HPP_NOEXCEPT
5164 {
5165 return *reinterpret_cast<StdVideoEncodeAV1ExtensionHeader *>( this );
5166 }
5167
5168 operator StdVideoEncodeAV1ExtensionHeader const *() const VULKAN_HPP_NOEXCEPT
5169 {
5170 return reinterpret_cast<const StdVideoEncodeAV1ExtensionHeader *>( this );
5171 }
5172
5173 operator StdVideoEncodeAV1ExtensionHeader *() VULKAN_HPP_NOEXCEPT
5174 {
5175 return reinterpret_cast<StdVideoEncodeAV1ExtensionHeader *>( this );
5176 }
5177
5178 bool operator==( EncodeAV1ExtensionHeader const & rhs ) const VULKAN_HPP_NOEXCEPT
5179 {
5180 return ( temporal_id == rhs.temporal_id ) && ( spatial_id == rhs.spatial_id );
5181 }
5182
5183 bool operator!=( EncodeAV1ExtensionHeader const & rhs ) const VULKAN_HPP_NOEXCEPT
5184 {
5185 return !operator==( rhs );
5186 }
5187
5188 public:
5189 uint8_t temporal_id = {};
5190 uint8_t spatial_id = {};
5191 };
5192
5193 struct EncodeAV1OperatingPointInfoFlags
5194 {
5195 using NativeType = StdVideoEncodeAV1OperatingPointInfoFlags;
5196
5197 operator StdVideoEncodeAV1OperatingPointInfoFlags const &() const VULKAN_HPP_NOEXCEPT
5198 {
5199 return *reinterpret_cast<const StdVideoEncodeAV1OperatingPointInfoFlags *>( this );
5200 }
5201
5202 operator StdVideoEncodeAV1OperatingPointInfoFlags &() VULKAN_HPP_NOEXCEPT
5203 {
5204 return *reinterpret_cast<StdVideoEncodeAV1OperatingPointInfoFlags *>( this );
5205 }
5206
5207 operator StdVideoEncodeAV1OperatingPointInfoFlags const *() const VULKAN_HPP_NOEXCEPT
5208 {
5209 return reinterpret_cast<const StdVideoEncodeAV1OperatingPointInfoFlags *>( this );
5210 }
5211
5212 operator StdVideoEncodeAV1OperatingPointInfoFlags *() VULKAN_HPP_NOEXCEPT
5213 {
5214 return reinterpret_cast<StdVideoEncodeAV1OperatingPointInfoFlags *>( this );
5215 }
5216
5217 bool operator==( EncodeAV1OperatingPointInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
5218 {
5219 return ( decoder_model_present_for_this_op == rhs.decoder_model_present_for_this_op ) && ( low_delay_mode_flag == rhs.low_delay_mode_flag ) &&
5220 ( initial_display_delay_present_for_this_op == rhs.initial_display_delay_present_for_this_op ) && ( reserved == rhs.reserved );
5221 }
5222
5223 bool operator!=( EncodeAV1OperatingPointInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
5224 {
5225 return !operator==( rhs );
5226 }
5227
5228 public:
5229 uint32_t decoder_model_present_for_this_op : 1;
5230 uint32_t low_delay_mode_flag : 1;
5231 uint32_t initial_display_delay_present_for_this_op : 1;
5232 uint32_t reserved : 29;
5233 };
5234
5235 struct EncodeAV1OperatingPointInfo
5236 {
5237 using NativeType = StdVideoEncodeAV1OperatingPointInfo;
5238
5239 operator StdVideoEncodeAV1OperatingPointInfo const &() const VULKAN_HPP_NOEXCEPT
5240 {
5241 return *reinterpret_cast<const StdVideoEncodeAV1OperatingPointInfo *>( this );
5242 }
5243
5244 operator StdVideoEncodeAV1OperatingPointInfo &() VULKAN_HPP_NOEXCEPT
5245 {
5246 return *reinterpret_cast<StdVideoEncodeAV1OperatingPointInfo *>( this );
5247 }
5248
5249 operator StdVideoEncodeAV1OperatingPointInfo const *() const VULKAN_HPP_NOEXCEPT
5250 {
5251 return reinterpret_cast<const StdVideoEncodeAV1OperatingPointInfo *>( this );
5252 }
5253
5254 operator StdVideoEncodeAV1OperatingPointInfo *() VULKAN_HPP_NOEXCEPT
5255 {
5256 return reinterpret_cast<StdVideoEncodeAV1OperatingPointInfo *>( this );
5257 }
5258
5259 bool operator==( EncodeAV1OperatingPointInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
5260 {
5261 return ( flags == rhs.flags ) && ( operating_point_idc == rhs.operating_point_idc ) && ( seq_level_idx == rhs.seq_level_idx ) &&
5262 ( seq_tier == rhs.seq_tier ) && ( decoder_buffer_delay == rhs.decoder_buffer_delay ) && ( encoder_buffer_delay == rhs.encoder_buffer_delay ) &&
5263 ( initial_display_delay_minus_1 == rhs.initial_display_delay_minus_1 );
5264 }
5265
5266 bool operator!=( EncodeAV1OperatingPointInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
5267 {
5268 return !operator==( rhs );
5269 }
5270
5271 public:
5272 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1OperatingPointInfoFlags flags = {};
5273 uint16_t operating_point_idc = {};
5274 uint8_t seq_level_idx = {};
5275 uint8_t seq_tier = {};
5276 uint32_t decoder_buffer_delay = {};
5277 uint32_t encoder_buffer_delay = {};
5278 uint8_t initial_display_delay_minus_1 = {};
5279 };
5280
5281 struct EncodeAV1PictureInfoFlags
5282 {
5283 using NativeType = StdVideoEncodeAV1PictureInfoFlags;
5284
5285 operator StdVideoEncodeAV1PictureInfoFlags const &() const VULKAN_HPP_NOEXCEPT
5286 {
5287 return *reinterpret_cast<const StdVideoEncodeAV1PictureInfoFlags *>( this );
5288 }
5289
5290 operator StdVideoEncodeAV1PictureInfoFlags &() VULKAN_HPP_NOEXCEPT
5291 {
5292 return *reinterpret_cast<StdVideoEncodeAV1PictureInfoFlags *>( this );
5293 }
5294
5295 operator StdVideoEncodeAV1PictureInfoFlags const *() const VULKAN_HPP_NOEXCEPT
5296 {
5297 return reinterpret_cast<const StdVideoEncodeAV1PictureInfoFlags *>( this );
5298 }
5299
5300 operator StdVideoEncodeAV1PictureInfoFlags *() VULKAN_HPP_NOEXCEPT
5301 {
5302 return reinterpret_cast<StdVideoEncodeAV1PictureInfoFlags *>( this );
5303 }
5304
5305 bool operator==( EncodeAV1PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
5306 {
5307 return ( error_resilient_mode == rhs.error_resilient_mode ) && ( disable_cdf_update == rhs.disable_cdf_update ) &&
5308 ( use_superres == rhs.use_superres ) && ( render_and_frame_size_different == rhs.render_and_frame_size_different ) &&
5309 ( allow_screen_content_tools == rhs.allow_screen_content_tools ) && ( is_filter_switchable == rhs.is_filter_switchable ) &&
5310 ( force_integer_mv == rhs.force_integer_mv ) && ( frame_size_override_flag == rhs.frame_size_override_flag ) &&
5311 ( buffer_removal_time_present_flag == rhs.buffer_removal_time_present_flag ) && ( allow_intrabc == rhs.allow_intrabc ) &&
5312 ( frame_refs_short_signaling == rhs.frame_refs_short_signaling ) && ( allow_high_precision_mv == rhs.allow_high_precision_mv ) &&
5313 ( is_motion_mode_switchable == rhs.is_motion_mode_switchable ) && ( use_ref_frame_mvs == rhs.use_ref_frame_mvs ) &&
5314 ( disable_frame_end_update_cdf == rhs.disable_frame_end_update_cdf ) && ( allow_warped_motion == rhs.allow_warped_motion ) &&
5315 ( reduced_tx_set == rhs.reduced_tx_set ) && ( skip_mode_present == rhs.skip_mode_present ) && ( delta_q_present == rhs.delta_q_present ) &&
5316 ( delta_lf_present == rhs.delta_lf_present ) && ( delta_lf_multi == rhs.delta_lf_multi ) &&
5317 ( segmentation_enabled == rhs.segmentation_enabled ) && ( segmentation_update_map == rhs.segmentation_update_map ) &&
5318 ( segmentation_temporal_update == rhs.segmentation_temporal_update ) && ( segmentation_update_data == rhs.segmentation_update_data ) &&
5319 ( UsesLr == rhs.UsesLr ) && ( usesChromaLr == rhs.usesChromaLr ) && ( show_frame == rhs.show_frame ) &&
5320 ( showable_frame == rhs.showable_frame ) && ( reserved == rhs.reserved );
5321 }
5322
5323 bool operator!=( EncodeAV1PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
5324 {
5325 return !operator==( rhs );
5326 }
5327
5328 public:
5329 uint32_t error_resilient_mode : 1;
5330 uint32_t disable_cdf_update : 1;
5331 uint32_t use_superres : 1;
5332 uint32_t render_and_frame_size_different : 1;
5333 uint32_t allow_screen_content_tools : 1;
5334 uint32_t is_filter_switchable : 1;
5335 uint32_t force_integer_mv : 1;
5336 uint32_t frame_size_override_flag : 1;
5337 uint32_t buffer_removal_time_present_flag : 1;
5338 uint32_t allow_intrabc : 1;
5339 uint32_t frame_refs_short_signaling : 1;
5340 uint32_t allow_high_precision_mv : 1;
5341 uint32_t is_motion_mode_switchable : 1;
5342 uint32_t use_ref_frame_mvs : 1;
5343 uint32_t disable_frame_end_update_cdf : 1;
5344 uint32_t allow_warped_motion : 1;
5345 uint32_t reduced_tx_set : 1;
5346 uint32_t skip_mode_present : 1;
5347 uint32_t delta_q_present : 1;
5348 uint32_t delta_lf_present : 1;
5349 uint32_t delta_lf_multi : 1;
5350 uint32_t segmentation_enabled : 1;
5351 uint32_t segmentation_update_map : 1;
5352 uint32_t segmentation_temporal_update : 1;
5353 uint32_t segmentation_update_data : 1;
5354 uint32_t UsesLr : 1;
5355 uint32_t usesChromaLr : 1;
5356 uint32_t show_frame : 1;
5357 uint32_t showable_frame : 1;
5358 uint32_t reserved : 3;
5359 };
5360
5361 struct EncodeAV1PictureInfo
5362 {
5363 using NativeType = StdVideoEncodeAV1PictureInfo;
5364
5365 operator StdVideoEncodeAV1PictureInfo const &() const VULKAN_HPP_NOEXCEPT
5366 {
5367 return *reinterpret_cast<const StdVideoEncodeAV1PictureInfo *>( this );
5368 }
5369
5370 operator StdVideoEncodeAV1PictureInfo &() VULKAN_HPP_NOEXCEPT
5371 {
5372 return *reinterpret_cast<StdVideoEncodeAV1PictureInfo *>( this );
5373 }
5374
5375 operator StdVideoEncodeAV1PictureInfo const *() const VULKAN_HPP_NOEXCEPT
5376 {
5377 return reinterpret_cast<const StdVideoEncodeAV1PictureInfo *>( this );
5378 }
5379
5380 operator StdVideoEncodeAV1PictureInfo *() VULKAN_HPP_NOEXCEPT
5381 {
5382 return reinterpret_cast<StdVideoEncodeAV1PictureInfo *>( this );
5383 }
5384
5385 bool operator==( EncodeAV1PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
5386 {
5387 return ( flags == rhs.flags ) && ( frame_type == rhs.frame_type ) && ( frame_presentation_time == rhs.frame_presentation_time ) &&
5388 ( current_frame_id == rhs.current_frame_id ) && ( order_hint == rhs.order_hint ) && ( primary_ref_frame == rhs.primary_ref_frame ) &&
5389 ( refresh_frame_flags == rhs.refresh_frame_flags ) && ( coded_denom == rhs.coded_denom ) &&
5390 ( render_width_minus_1 == rhs.render_width_minus_1 ) && ( render_height_minus_1 == rhs.render_height_minus_1 ) &&
5391 ( interpolation_filter == rhs.interpolation_filter ) && ( TxMode == rhs.TxMode ) && ( delta_q_res == rhs.delta_q_res ) &&
5392 ( delta_lf_res == rhs.delta_lf_res ) && ( ref_order_hint == rhs.ref_order_hint ) && ( ref_frame_idx == rhs.ref_frame_idx ) &&
5393 ( reserved1 == rhs.reserved1 ) && ( delta_frame_id_minus_1 == rhs.delta_frame_id_minus_1 ) && ( pTileInfo == rhs.pTileInfo ) &&
5394 ( pQuantization == rhs.pQuantization ) && ( pSegmentation == rhs.pSegmentation ) && ( pLoopFilter == rhs.pLoopFilter ) &&
5395 ( pCDEF == rhs.pCDEF ) && ( pLoopRestoration == rhs.pLoopRestoration ) && ( pGlobalMotion == rhs.pGlobalMotion ) &&
5396 ( pExtensionHeader == rhs.pExtensionHeader ) && ( pBufferRemovalTimes == rhs.pBufferRemovalTimes );
5397 }
5398
5399 bool operator!=( EncodeAV1PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
5400 {
5401 return !operator==( rhs );
5402 }
5403
5404 public:
5405 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1PictureInfoFlags flags = {};
5406 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameType frame_type = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameType::eKey;
5407 uint32_t frame_presentation_time = {};
5408 uint32_t current_frame_id = {};
5409 uint8_t order_hint = {};
5410 uint8_t primary_ref_frame = {};
5411 uint8_t refresh_frame_flags = {};
5412 uint8_t coded_denom = {};
5413 uint16_t render_width_minus_1 = {};
5414 uint16_t render_height_minus_1 = {};
5415 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1InterpolationFilter interpolation_filter =
5416 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1InterpolationFilter::eEighttap;
5417 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TxMode TxMode = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TxMode::eOnly4X4;
5418 uint8_t delta_q_res = {};
5419 uint8_t delta_lf_res = {};
5420 ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_NUM_REF_FRAMES> ref_order_hint = {};
5421 ArrayWrapper1D<int8_t, STD_VIDEO_AV1_REFS_PER_FRAME> ref_frame_idx = {};
5422 ArrayWrapper1D<uint8_t, 3> reserved1 = {};
5423 ArrayWrapper1D<uint32_t, STD_VIDEO_AV1_REFS_PER_FRAME> delta_frame_id_minus_1 = {};
5424 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TileInfo * pTileInfo = {};
5425 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Quantization * pQuantization = {};
5426 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Segmentation * pSegmentation = {};
5427 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopFilter * pLoopFilter = {};
5428 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1CDEF * pCDEF = {};
5429 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopRestoration * pLoopRestoration = {};
5430 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1GlobalMotion * pGlobalMotion = {};
5431 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ExtensionHeader * pExtensionHeader = {};
5432 const uint32_t * pBufferRemovalTimes = {};
5433 };
5434
5435 struct EncodeAV1ReferenceInfoFlags
5436 {
5437 using NativeType = StdVideoEncodeAV1ReferenceInfoFlags;
5438
5439 operator StdVideoEncodeAV1ReferenceInfoFlags const &() const VULKAN_HPP_NOEXCEPT
5440 {
5441 return *reinterpret_cast<const StdVideoEncodeAV1ReferenceInfoFlags *>( this );
5442 }
5443
5444 operator StdVideoEncodeAV1ReferenceInfoFlags &() VULKAN_HPP_NOEXCEPT
5445 {
5446 return *reinterpret_cast<StdVideoEncodeAV1ReferenceInfoFlags *>( this );
5447 }
5448
5449 operator StdVideoEncodeAV1ReferenceInfoFlags const *() const VULKAN_HPP_NOEXCEPT
5450 {
5451 return reinterpret_cast<const StdVideoEncodeAV1ReferenceInfoFlags *>( this );
5452 }
5453
5454 operator StdVideoEncodeAV1ReferenceInfoFlags *() VULKAN_HPP_NOEXCEPT
5455 {
5456 return reinterpret_cast<StdVideoEncodeAV1ReferenceInfoFlags *>( this );
5457 }
5458
5459 bool operator==( EncodeAV1ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
5460 {
5461 return ( disable_frame_end_update_cdf == rhs.disable_frame_end_update_cdf ) && ( segmentation_enabled == rhs.segmentation_enabled ) &&
5462 ( reserved == rhs.reserved );
5463 }
5464
5465 bool operator!=( EncodeAV1ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
5466 {
5467 return !operator==( rhs );
5468 }
5469
5470 public:
5471 uint32_t disable_frame_end_update_cdf : 1;
5472 uint32_t segmentation_enabled : 1;
5473 uint32_t reserved : 30;
5474 };
5475
5476 struct EncodeAV1ReferenceInfo
5477 {
5478 using NativeType = StdVideoEncodeAV1ReferenceInfo;
5479
5480 operator StdVideoEncodeAV1ReferenceInfo const &() const VULKAN_HPP_NOEXCEPT
5481 {
5482 return *reinterpret_cast<const StdVideoEncodeAV1ReferenceInfo *>( this );
5483 }
5484
5485 operator StdVideoEncodeAV1ReferenceInfo &() VULKAN_HPP_NOEXCEPT
5486 {
5487 return *reinterpret_cast<StdVideoEncodeAV1ReferenceInfo *>( this );
5488 }
5489
5490 operator StdVideoEncodeAV1ReferenceInfo const *() const VULKAN_HPP_NOEXCEPT
5491 {
5492 return reinterpret_cast<const StdVideoEncodeAV1ReferenceInfo *>( this );
5493 }
5494
5495 operator StdVideoEncodeAV1ReferenceInfo *() VULKAN_HPP_NOEXCEPT
5496 {
5497 return reinterpret_cast<StdVideoEncodeAV1ReferenceInfo *>( this );
5498 }
5499
5500 bool operator==( EncodeAV1ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
5501 {
5502 return ( flags == rhs.flags ) && ( RefFrameId == rhs.RefFrameId ) && ( frame_type == rhs.frame_type ) && ( OrderHint == rhs.OrderHint ) &&
5503 ( reserved1 == rhs.reserved1 ) && ( pExtensionHeader == rhs.pExtensionHeader );
5504 }
5505
5506 bool operator!=( EncodeAV1ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
5507 {
5508 return !operator==( rhs );
5509 }
5510
5511 public:
5512 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ReferenceInfoFlags flags = {};
5513 uint32_t RefFrameId = {};
5514 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameType frame_type = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameType::eKey;
5515 uint8_t OrderHint = {};
5516 ArrayWrapper1D<uint8_t, 3> reserved1 = {};
5517 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ExtensionHeader * pExtensionHeader = {};
5518 };
5519 #endif
5520
5521 } // namespace VULKAN_HPP_VIDEO_NAMESPACE
5522 } // namespace VULKAN_HPP_NAMESPACE
5523
5524 #if defined( has_include_was_not_defined )
5525 # undef has_include_was_not_defined
5526 # undef __has_include
5527 #endif
5528
5529 #endif