|
1501
|
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
|
