Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
PojavLauncherTeam
GitHub Repository: PojavLauncherTeam/mesa
 Path: blob/21.2-virgl/include/vulkan/vulkan_beta.h
4545 views
1
#ifndef VULKAN_BETA_H_

2
#define VULKAN_BETA_H_ 1

3


4
/*

5
** Copyright 2015-2021 The Khronos Group Inc.

6
**

7
** SPDX-License-Identifier: Apache-2.0

8
*/

9


10
/*

11
** This header is generated from the Khronos Vulkan XML API Registry.

12
**

13
*/

14


15


16
#ifdef __cplusplus

17
extern "C" {

18
#endif

19


20


21


22
#define VK_KHR_video_queue 1

23
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkVideoSessionKHR)

24
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkVideoSessionParametersKHR)

25
#define VK_KHR_VIDEO_QUEUE_SPEC_VERSION   1

26
#define VK_KHR_VIDEO_QUEUE_EXTENSION_NAME "VK_KHR_video_queue"

27


28
typedef enum VkQueryResultStatusKHR {

29
    VK_QUERY_RESULT_STATUS_ERROR_KHR = -1,

30
    VK_QUERY_RESULT_STATUS_NOT_READY_KHR = 0,

31
    VK_QUERY_RESULT_STATUS_COMPLETE_KHR = 1,

32
    VK_QUERY_RESULT_STATUS_MAX_ENUM_KHR = 0x7FFFFFFF

33
} VkQueryResultStatusKHR;

34


35
typedef enum VkVideoCodecOperationFlagBitsKHR {

36
    VK_VIDEO_CODEC_OPERATION_INVALID_BIT_KHR = 0,

37
#ifdef VK_ENABLE_BETA_EXTENSIONS

38
    VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_EXT = 0x00010000,

39
#endif

40
#ifdef VK_ENABLE_BETA_EXTENSIONS

41
    VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_EXT = 0x00000001,

42
#endif

43
#ifdef VK_ENABLE_BETA_EXTENSIONS

44
    VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_EXT = 0x00000002,

45
#endif

46
    VK_VIDEO_CODEC_OPERATION_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF

47
} VkVideoCodecOperationFlagBitsKHR;

48
typedef VkFlags VkVideoCodecOperationFlagsKHR;

49


50
typedef enum VkVideoChromaSubsamplingFlagBitsKHR {

51
    VK_VIDEO_CHROMA_SUBSAMPLING_INVALID_BIT_KHR = 0,

52
    VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR = 0x00000001,

53
    VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR = 0x00000002,

54
    VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR = 0x00000004,

55
    VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR = 0x00000008,

56
    VK_VIDEO_CHROMA_SUBSAMPLING_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF

57
} VkVideoChromaSubsamplingFlagBitsKHR;

58
typedef VkFlags VkVideoChromaSubsamplingFlagsKHR;

59


60
typedef enum VkVideoComponentBitDepthFlagBitsKHR {

61
    VK_VIDEO_COMPONENT_BIT_DEPTH_INVALID_KHR = 0,

62
    VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR = 0x00000001,

63
    VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR = 0x00000004,

64
    VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR = 0x00000010,

65
    VK_VIDEO_COMPONENT_BIT_DEPTH_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF

66
} VkVideoComponentBitDepthFlagBitsKHR;

67
typedef VkFlags VkVideoComponentBitDepthFlagsKHR;

68


69
typedef enum VkVideoCapabilitiesFlagBitsKHR {

70
    VK_VIDEO_CAPABILITIES_PROTECTED_CONTENT_BIT_KHR = 0x00000001,

71
    VK_VIDEO_CAPABILITIES_SEPARATE_REFERENCE_IMAGES_BIT_KHR = 0x00000002,

72
    VK_VIDEO_CAPABILITIES_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF

73
} VkVideoCapabilitiesFlagBitsKHR;

74
typedef VkFlags VkVideoCapabilitiesFlagsKHR;

75


76
typedef enum VkVideoSessionCreateFlagBitsKHR {

77
    VK_VIDEO_SESSION_CREATE_DEFAULT_KHR = 0,

78
    VK_VIDEO_SESSION_CREATE_PROTECTED_CONTENT_BIT_KHR = 0x00000001,

79
    VK_VIDEO_SESSION_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF

80
} VkVideoSessionCreateFlagBitsKHR;

81
typedef VkFlags VkVideoSessionCreateFlagsKHR;

82
typedef VkFlags VkVideoBeginCodingFlagsKHR;

83
typedef VkFlags VkVideoEndCodingFlagsKHR;

84


85
typedef enum VkVideoCodingControlFlagBitsKHR {

86
    VK_VIDEO_CODING_CONTROL_DEFAULT_KHR = 0,

87
    VK_VIDEO_CODING_CONTROL_RESET_BIT_KHR = 0x00000001,

88
    VK_VIDEO_CODING_CONTROL_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF

89
} VkVideoCodingControlFlagBitsKHR;

90
typedef VkFlags VkVideoCodingControlFlagsKHR;

91


92
typedef enum VkVideoCodingQualityPresetFlagBitsKHR {

93
    VK_VIDEO_CODING_QUALITY_PRESET_DEFAULT_BIT_KHR = 0,

94
    VK_VIDEO_CODING_QUALITY_PRESET_NORMAL_BIT_KHR = 0x00000001,

95
    VK_VIDEO_CODING_QUALITY_PRESET_POWER_BIT_KHR = 0x00000002,

96
    VK_VIDEO_CODING_QUALITY_PRESET_QUALITY_BIT_KHR = 0x00000004,

97
    VK_VIDEO_CODING_QUALITY_PRESET_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF

98
} VkVideoCodingQualityPresetFlagBitsKHR;

99
typedef VkFlags VkVideoCodingQualityPresetFlagsKHR;

100
typedef struct VkVideoQueueFamilyProperties2KHR {

101
    VkStructureType                  sType;

102
    void*                            pNext;

103
    VkVideoCodecOperationFlagsKHR    videoCodecOperations;

104
} VkVideoQueueFamilyProperties2KHR;

105


106
typedef struct VkVideoProfileKHR {

107
    VkStructureType                     sType;

108
    void*                               pNext;

109
    VkVideoCodecOperationFlagBitsKHR    videoCodecOperation;

110
    VkVideoChromaSubsamplingFlagsKHR    chromaSubsampling;

111
    VkVideoComponentBitDepthFlagsKHR    lumaBitDepth;

112
    VkVideoComponentBitDepthFlagsKHR    chromaBitDepth;

113
} VkVideoProfileKHR;

114


115
typedef struct VkVideoProfilesKHR {

116
    VkStructureType             sType;

117
    void*                       pNext;

118
    uint32_t                    profileCount;

119
    const VkVideoProfileKHR*    pProfiles;

120
} VkVideoProfilesKHR;

121


122
typedef struct VkVideoCapabilitiesKHR {

123
    VkStructureType                sType;

124
    void*                          pNext;

125
    VkVideoCapabilitiesFlagsKHR    capabilityFlags;

126
    VkDeviceSize                   minBitstreamBufferOffsetAlignment;

127
    VkDeviceSize                   minBitstreamBufferSizeAlignment;

128
    VkExtent2D                     videoPictureExtentGranularity;

129
    VkExtent2D                     minExtent;

130
    VkExtent2D                     maxExtent;

131
    uint32_t                       maxReferencePicturesSlotsCount;

132
    uint32_t                       maxReferencePicturesActiveCount;

133
} VkVideoCapabilitiesKHR;

134


135
typedef struct VkPhysicalDeviceVideoFormatInfoKHR {

136
    VkStructureType              sType;

137
    const void*                  pNext;

138
    VkImageUsageFlags            imageUsage;

139
    const VkVideoProfilesKHR*    pVideoProfiles;

140
} VkPhysicalDeviceVideoFormatInfoKHR;

141


142
typedef struct VkVideoFormatPropertiesKHR {

143
    VkStructureType    sType;

144
    void*              pNext;

145
    VkFormat           format;

146
} VkVideoFormatPropertiesKHR;

147


148
typedef struct VkVideoPictureResourceKHR {

149
    VkStructureType    sType;

150
    const void*        pNext;

151
    VkOffset2D         codedOffset;

152
    VkExtent2D         codedExtent;

153
    uint32_t           baseArrayLayer;

154
    VkImageView        imageViewBinding;

155
} VkVideoPictureResourceKHR;

156


157
typedef struct VkVideoReferenceSlotKHR {

158
    VkStructureType                     sType;

159
    const void*                         pNext;

160
    int8_t                              slotIndex;

161
    const VkVideoPictureResourceKHR*    pPictureResource;

162
} VkVideoReferenceSlotKHR;

163


164
typedef struct VkVideoGetMemoryPropertiesKHR {

165
    VkStructureType           sType;

166
    const void*               pNext;

167
    uint32_t                  memoryBindIndex;

168
    VkMemoryRequirements2*    pMemoryRequirements;

169
} VkVideoGetMemoryPropertiesKHR;

170


171
typedef struct VkVideoBindMemoryKHR {

172
    VkStructureType    sType;

173
    const void*        pNext;

174
    uint32_t           memoryBindIndex;

175
    VkDeviceMemory     memory;

176
    VkDeviceSize       memoryOffset;

177
    VkDeviceSize       memorySize;

178
} VkVideoBindMemoryKHR;

179


180
typedef struct VkVideoSessionCreateInfoKHR {

181
    VkStructureType                 sType;

182
    const void*                     pNext;

183
    uint32_t                        queueFamilyIndex;

184
    VkVideoSessionCreateFlagsKHR    flags;

185
    const VkVideoProfileKHR*        pVideoProfile;

186
    VkFormat                        pictureFormat;

187
    VkExtent2D                      maxCodedExtent;

188
    VkFormat                        referencePicturesFormat;

189
    uint32_t                        maxReferencePicturesSlotsCount;

190
    uint32_t                        maxReferencePicturesActiveCount;

191
} VkVideoSessionCreateInfoKHR;

192


193
typedef struct VkVideoSessionParametersCreateInfoKHR {

194
    VkStructureType                sType;

195
    const void*                    pNext;

196
    VkVideoSessionParametersKHR    videoSessionParametersTemplate;

197
    VkVideoSessionKHR              videoSession;

198
} VkVideoSessionParametersCreateInfoKHR;

199


200
typedef struct VkVideoSessionParametersUpdateInfoKHR {

201
    VkStructureType    sType;

202
    const void*        pNext;

203
    uint32_t           updateSequenceCount;

204
} VkVideoSessionParametersUpdateInfoKHR;

205


206
typedef struct VkVideoBeginCodingInfoKHR {

207
    VkStructureType                       sType;

208
    const void*                           pNext;

209
    VkVideoBeginCodingFlagsKHR            flags;

210
    VkVideoCodingQualityPresetFlagsKHR    codecQualityPreset;

211
    VkVideoSessionKHR                     videoSession;

212
    VkVideoSessionParametersKHR           videoSessionParameters;

213
    uint32_t                              referenceSlotCount;

214
    const VkVideoReferenceSlotKHR*        pReferenceSlots;

215
} VkVideoBeginCodingInfoKHR;

216


217
typedef struct VkVideoEndCodingInfoKHR {

218
    VkStructureType             sType;

219
    const void*                 pNext;

220
    VkVideoEndCodingFlagsKHR    flags;

221
} VkVideoEndCodingInfoKHR;

222


223
typedef struct VkVideoCodingControlInfoKHR {

224
    VkStructureType                 sType;

225
    const void*                     pNext;

226
    VkVideoCodingControlFlagsKHR    flags;

227
} VkVideoCodingControlInfoKHR;

228


229
typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR)(VkPhysicalDevice physicalDevice, const VkVideoProfileKHR* pVideoProfile, VkVideoCapabilitiesKHR* pCapabilities);

230
typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, uint32_t* pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR* pVideoFormatProperties);

231
typedef VkResult (VKAPI_PTR *PFN_vkCreateVideoSessionKHR)(VkDevice device, const VkVideoSessionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionKHR* pVideoSession);

232
typedef void (VKAPI_PTR *PFN_vkDestroyVideoSessionKHR)(VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks* pAllocator);

233
typedef VkResult (VKAPI_PTR *PFN_vkGetVideoSessionMemoryRequirementsKHR)(VkDevice device, VkVideoSessionKHR videoSession, uint32_t* pVideoSessionMemoryRequirementsCount, VkVideoGetMemoryPropertiesKHR* pVideoSessionMemoryRequirements);

234
typedef VkResult (VKAPI_PTR *PFN_vkBindVideoSessionMemoryKHR)(VkDevice device, VkVideoSessionKHR videoSession, uint32_t videoSessionBindMemoryCount, const VkVideoBindMemoryKHR* pVideoSessionBindMemories);

235
typedef VkResult (VKAPI_PTR *PFN_vkCreateVideoSessionParametersKHR)(VkDevice device, const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionParametersKHR* pVideoSessionParameters);

236
typedef VkResult (VKAPI_PTR *PFN_vkUpdateVideoSessionParametersKHR)(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo);

237
typedef void (VKAPI_PTR *PFN_vkDestroyVideoSessionParametersKHR)(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkAllocationCallbacks* pAllocator);

238
typedef void (VKAPI_PTR *PFN_vkCmdBeginVideoCodingKHR)(VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR* pBeginInfo);

239
typedef void (VKAPI_PTR *PFN_vkCmdEndVideoCodingKHR)(VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR* pEndCodingInfo);

240
typedef void (VKAPI_PTR *PFN_vkCmdControlVideoCodingKHR)(VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR* pCodingControlInfo);

241


242
#ifndef VK_NO_PROTOTYPES

243
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceVideoCapabilitiesKHR(

244
    VkPhysicalDevice                            physicalDevice,

245
    const VkVideoProfileKHR*                    pVideoProfile,

246
    VkVideoCapabilitiesKHR*                     pCapabilities);

247


248
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceVideoFormatPropertiesKHR(

249
    VkPhysicalDevice                            physicalDevice,

250
    const VkPhysicalDeviceVideoFormatInfoKHR*   pVideoFormatInfo,

251
    uint32_t*                                   pVideoFormatPropertyCount,

252
    VkVideoFormatPropertiesKHR*                 pVideoFormatProperties);

253


254
VKAPI_ATTR VkResult VKAPI_CALL vkCreateVideoSessionKHR(

255
    VkDevice                                    device,

256
    const VkVideoSessionCreateInfoKHR*          pCreateInfo,

257
    const VkAllocationCallbacks*                pAllocator,

258
    VkVideoSessionKHR*                          pVideoSession);

259


260
VKAPI_ATTR void VKAPI_CALL vkDestroyVideoSessionKHR(

261
    VkDevice                                    device,

262
    VkVideoSessionKHR                           videoSession,

263
    const VkAllocationCallbacks*                pAllocator);

264


265
VKAPI_ATTR VkResult VKAPI_CALL vkGetVideoSessionMemoryRequirementsKHR(

266
    VkDevice                                    device,

267
    VkVideoSessionKHR                           videoSession,

268
    uint32_t*                                   pVideoSessionMemoryRequirementsCount,

269
    VkVideoGetMemoryPropertiesKHR*              pVideoSessionMemoryRequirements);

270


271
VKAPI_ATTR VkResult VKAPI_CALL vkBindVideoSessionMemoryKHR(

272
    VkDevice                                    device,

273
    VkVideoSessionKHR                           videoSession,

274
    uint32_t                                    videoSessionBindMemoryCount,

275
    const VkVideoBindMemoryKHR*                 pVideoSessionBindMemories);

276


277
VKAPI_ATTR VkResult VKAPI_CALL vkCreateVideoSessionParametersKHR(

278
    VkDevice                                    device,

279
    const VkVideoSessionParametersCreateInfoKHR* pCreateInfo,

280
    const VkAllocationCallbacks*                pAllocator,

281
    VkVideoSessionParametersKHR*                pVideoSessionParameters);

282


283
VKAPI_ATTR VkResult VKAPI_CALL vkUpdateVideoSessionParametersKHR(

284
    VkDevice                                    device,

285
    VkVideoSessionParametersKHR                 videoSessionParameters,

286
    const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo);

287


288
VKAPI_ATTR void VKAPI_CALL vkDestroyVideoSessionParametersKHR(

289
    VkDevice                                    device,

290
    VkVideoSessionParametersKHR                 videoSessionParameters,

291
    const VkAllocationCallbacks*                pAllocator);

292


293
VKAPI_ATTR void VKAPI_CALL vkCmdBeginVideoCodingKHR(

294
    VkCommandBuffer                             commandBuffer,

295
    const VkVideoBeginCodingInfoKHR*            pBeginInfo);

296


297
VKAPI_ATTR void VKAPI_CALL vkCmdEndVideoCodingKHR(

298
    VkCommandBuffer                             commandBuffer,

299
    const VkVideoEndCodingInfoKHR*              pEndCodingInfo);

300


301
VKAPI_ATTR void VKAPI_CALL vkCmdControlVideoCodingKHR(

302
    VkCommandBuffer                             commandBuffer,

303
    const VkVideoCodingControlInfoKHR*          pCodingControlInfo);

304
#endif

305


306


307
#define VK_KHR_video_decode_queue 1

308
#define VK_KHR_VIDEO_DECODE_QUEUE_SPEC_VERSION 1

309
#define VK_KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME "VK_KHR_video_decode_queue"

310


311
typedef enum VkVideoDecodeFlagBitsKHR {

312
    VK_VIDEO_DECODE_DEFAULT_KHR = 0,

313
    VK_VIDEO_DECODE_RESERVED_0_BIT_KHR = 0x00000001,

314
    VK_VIDEO_DECODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF

315
} VkVideoDecodeFlagBitsKHR;

316
typedef VkFlags VkVideoDecodeFlagsKHR;

317
typedef struct VkVideoDecodeInfoKHR {

318
    VkStructureType                   sType;

319
    const void*                       pNext;

320
    VkVideoDecodeFlagsKHR             flags;

321
    VkOffset2D                        codedOffset;

322
    VkExtent2D                        codedExtent;

323
    VkBuffer                          srcBuffer;

324
    VkDeviceSize                      srcBufferOffset;

325
    VkDeviceSize                      srcBufferRange;

326
    VkVideoPictureResourceKHR         dstPictureResource;

327
    const VkVideoReferenceSlotKHR*    pSetupReferenceSlot;

328
    uint32_t                          referenceSlotCount;

329
    const VkVideoReferenceSlotKHR*    pReferenceSlots;

330
} VkVideoDecodeInfoKHR;

331


332
typedef void (VKAPI_PTR *PFN_vkCmdDecodeVideoKHR)(VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR* pFrameInfo);

333


334
#ifndef VK_NO_PROTOTYPES

335
VKAPI_ATTR void VKAPI_CALL vkCmdDecodeVideoKHR(

336
    VkCommandBuffer                             commandBuffer,

337
    const VkVideoDecodeInfoKHR*                 pFrameInfo);

338
#endif

339


340


341
#define VK_KHR_portability_subset 1

342
#define VK_KHR_PORTABILITY_SUBSET_SPEC_VERSION 1

343
#define VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME "VK_KHR_portability_subset"

344
typedef struct VkPhysicalDevicePortabilitySubsetFeaturesKHR {

345
    VkStructureType    sType;

346
    void*              pNext;

347
    VkBool32           constantAlphaColorBlendFactors;

348
    VkBool32           events;

349
    VkBool32           imageViewFormatReinterpretation;

350
    VkBool32           imageViewFormatSwizzle;

351
    VkBool32           imageView2DOn3DImage;

352
    VkBool32           multisampleArrayImage;

353
    VkBool32           mutableComparisonSamplers;

354
    VkBool32           pointPolygons;

355
    VkBool32           samplerMipLodBias;

356
    VkBool32           separateStencilMaskRef;

357
    VkBool32           shaderSampleRateInterpolationFunctions;

358
    VkBool32           tessellationIsolines;

359
    VkBool32           tessellationPointMode;

360
    VkBool32           triangleFans;

361
    VkBool32           vertexAttributeAccessBeyondStride;

362
} VkPhysicalDevicePortabilitySubsetFeaturesKHR;

363


364
typedef struct VkPhysicalDevicePortabilitySubsetPropertiesKHR {

365
    VkStructureType    sType;

366
    void*              pNext;

367
    uint32_t           minVertexInputBindingStrideAlignment;

368
} VkPhysicalDevicePortabilitySubsetPropertiesKHR;

369


370


371


372
#define VK_KHR_video_encode_queue 1

373
#define VK_KHR_VIDEO_ENCODE_QUEUE_SPEC_VERSION 2

374
#define VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME "VK_KHR_video_encode_queue"

375


376
typedef enum VkVideoEncodeFlagBitsKHR {

377
    VK_VIDEO_ENCODE_DEFAULT_KHR = 0,

378
    VK_VIDEO_ENCODE_RESERVED_0_BIT_KHR = 0x00000001,

379
    VK_VIDEO_ENCODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF

380
} VkVideoEncodeFlagBitsKHR;

381
typedef VkFlags VkVideoEncodeFlagsKHR;

382


383
typedef enum VkVideoEncodeRateControlFlagBitsKHR {

384
    VK_VIDEO_ENCODE_RATE_CONTROL_DEFAULT_KHR = 0,

385
    VK_VIDEO_ENCODE_RATE_CONTROL_RESET_BIT_KHR = 0x00000001,

386
    VK_VIDEO_ENCODE_RATE_CONTROL_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF

387
} VkVideoEncodeRateControlFlagBitsKHR;

388
typedef VkFlags VkVideoEncodeRateControlFlagsKHR;

389


390
typedef enum VkVideoEncodeRateControlModeFlagBitsKHR {

391
    VK_VIDEO_ENCODE_RATE_CONTROL_MODE_NONE_BIT_KHR = 0,

392
    VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR = 1,

393
    VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR = 2,

394
    VK_VIDEO_ENCODE_RATE_CONTROL_MODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF

395
} VkVideoEncodeRateControlModeFlagBitsKHR;

396
typedef VkFlags VkVideoEncodeRateControlModeFlagsKHR;

397
typedef struct VkVideoEncodeInfoKHR {

398
    VkStructureType                   sType;

399
    const void*                       pNext;

400
    VkVideoEncodeFlagsKHR             flags;

401
    uint32_t                          qualityLevel;

402
    VkExtent2D                        codedExtent;

403
    VkBuffer                          dstBitstreamBuffer;

404
    VkDeviceSize                      dstBitstreamBufferOffset;

405
    VkDeviceSize                      dstBitstreamBufferMaxRange;

406
    VkVideoPictureResourceKHR         srcPictureResource;

407
    const VkVideoReferenceSlotKHR*    pSetupReferenceSlot;

408
    uint32_t                          referenceSlotCount;

409
    const VkVideoReferenceSlotKHR*    pReferenceSlots;

410
} VkVideoEncodeInfoKHR;

411


412
typedef struct VkVideoEncodeRateControlInfoKHR {

413
    VkStructureType                            sType;

414
    const void*                                pNext;

415
    VkVideoEncodeRateControlFlagsKHR           flags;

416
    VkVideoEncodeRateControlModeFlagBitsKHR    rateControlMode;

417
    uint32_t                                   averageBitrate;

418
    uint16_t                                   peakToAverageBitrateRatio;

419
    uint16_t                                   frameRateNumerator;

420
    uint16_t                                   frameRateDenominator;

421
    uint32_t                                   virtualBufferSizeInMs;

422
} VkVideoEncodeRateControlInfoKHR;

423


424
typedef void (VKAPI_PTR *PFN_vkCmdEncodeVideoKHR)(VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo);

425


426
#ifndef VK_NO_PROTOTYPES

427
VKAPI_ATTR void VKAPI_CALL vkCmdEncodeVideoKHR(

428
    VkCommandBuffer                             commandBuffer,

429
    const VkVideoEncodeInfoKHR*                 pEncodeInfo);

430
#endif

431


432


433
#define VK_EXT_video_encode_h264 1

434
#include "vk_video/vulkan_video_codec_h264std.h"

435
#include "vk_video/vulkan_video_codec_h264std_encode.h"

436
#define VK_EXT_VIDEO_ENCODE_H264_SPEC_VERSION 1

437
#define VK_EXT_VIDEO_ENCODE_H264_EXTENSION_NAME "VK_EXT_video_encode_h264"

438


439
typedef enum VkVideoEncodeH264CapabilitiesFlagBitsEXT {

440
    VK_VIDEO_ENCODE_H264_CAPABILITY_CABAC_BIT_EXT = 0x00000001,

441
    VK_VIDEO_ENCODE_H264_CAPABILITY_CAVLC_BIT_EXT = 0x00000002,

442
    VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_BI_PRED_IMPLICIT_BIT_EXT = 0x00000004,

443
    VK_VIDEO_ENCODE_H264_CAPABILITY_TRANSFORM_8X8_BIT_EXT = 0x00000008,

444
    VK_VIDEO_ENCODE_H264_CAPABILITY_CHROMA_QP_OFFSET_BIT_EXT = 0x00000010,

445
    VK_VIDEO_ENCODE_H264_CAPABILITY_SECOND_CHROMA_QP_OFFSET_BIT_EXT = 0x00000020,

446
    VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_DISABLED_BIT_EXT = 0x00000040,

447
    VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_ENABLED_BIT_EXT = 0x00000080,

448
    VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_PARTIAL_BIT_EXT = 0x00000100,

449
    VK_VIDEO_ENCODE_H264_CAPABILITY_MULTIPLE_SLICE_PER_FRAME_BIT_EXT = 0x00000200,

450
    VK_VIDEO_ENCODE_H264_CAPABILITY_EVENLY_DISTRIBUTED_SLICE_SIZE_BIT_EXT = 0x00000400,

451
    VK_VIDEO_ENCODE_H264_CAPABILITIES_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF

452
} VkVideoEncodeH264CapabilitiesFlagBitsEXT;

453
typedef VkFlags VkVideoEncodeH264CapabilitiesFlagsEXT;

454


455
typedef enum VkVideoEncodeH264InputModeFlagBitsEXT {

456
    VK_VIDEO_ENCODE_H264_INPUT_MODE_FRAME_BIT_EXT = 0x00000001,

457
    VK_VIDEO_ENCODE_H264_INPUT_MODE_SLICE_BIT_EXT = 0x00000002,

458
    VK_VIDEO_ENCODE_H264_INPUT_MODE_NON_VCL_BIT_EXT = 0x00000004,

459
    VK_VIDEO_ENCODE_H264_INPUT_MODE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF

460
} VkVideoEncodeH264InputModeFlagBitsEXT;

461
typedef VkFlags VkVideoEncodeH264InputModeFlagsEXT;

462


463
typedef enum VkVideoEncodeH264OutputModeFlagBitsEXT {

464
    VK_VIDEO_ENCODE_H264_OUTPUT_MODE_FRAME_BIT_EXT = 0x00000001,

465
    VK_VIDEO_ENCODE_H264_OUTPUT_MODE_SLICE_BIT_EXT = 0x00000002,

466
    VK_VIDEO_ENCODE_H264_OUTPUT_MODE_NON_VCL_BIT_EXT = 0x00000004,

467
    VK_VIDEO_ENCODE_H264_OUTPUT_MODE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF

468
} VkVideoEncodeH264OutputModeFlagBitsEXT;

469
typedef VkFlags VkVideoEncodeH264OutputModeFlagsEXT;

470


471
typedef enum VkVideoEncodeH264CreateFlagBitsEXT {

472
    VK_VIDEO_ENCODE_H264_CREATE_DEFAULT_EXT = 0,

473
    VK_VIDEO_ENCODE_H264_CREATE_RESERVED_0_BIT_EXT = 0x00000001,

474
    VK_VIDEO_ENCODE_H264_CREATE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF

475
} VkVideoEncodeH264CreateFlagBitsEXT;

476
typedef VkFlags VkVideoEncodeH264CreateFlagsEXT;

477
typedef struct VkVideoEncodeH264CapabilitiesEXT {

478
    VkStructureType                          sType;

479
    const void*                              pNext;

480
    VkVideoEncodeH264CapabilitiesFlagsEXT    flags;

481
    VkVideoEncodeH264InputModeFlagsEXT       inputModeFlags;

482
    VkVideoEncodeH264OutputModeFlagsEXT      outputModeFlags;

483
    VkExtent2D                               minPictureSizeInMbs;

484
    VkExtent2D                               maxPictureSizeInMbs;

485
    VkExtent2D                               inputImageDataAlignment;

486
    uint8_t                                  maxNumL0ReferenceForP;

487
    uint8_t                                  maxNumL0ReferenceForB;

488
    uint8_t                                  maxNumL1Reference;

489
    uint8_t                                  qualityLevelCount;

490
    VkExtensionProperties                    stdExtensionVersion;

491
} VkVideoEncodeH264CapabilitiesEXT;

492


493
typedef struct VkVideoEncodeH264SessionCreateInfoEXT {

494
    VkStructureType                    sType;

495
    const void*                        pNext;

496
    VkVideoEncodeH264CreateFlagsEXT    flags;

497
    VkExtent2D                         maxPictureSizeInMbs;

498
    const VkExtensionProperties*       pStdExtensionVersion;

499
} VkVideoEncodeH264SessionCreateInfoEXT;

500


501
typedef struct VkVideoEncodeH264SessionParametersAddInfoEXT {

502
    VkStructureType                            sType;

503
    const void*                                pNext;

504
    uint32_t                                   spsStdCount;

505
    const StdVideoH264SequenceParameterSet*    pSpsStd;

506
    uint32_t                                   ppsStdCount;

507
    const StdVideoH264PictureParameterSet*     pPpsStd;

508
} VkVideoEncodeH264SessionParametersAddInfoEXT;

509


510
typedef struct VkVideoEncodeH264SessionParametersCreateInfoEXT {

511
    VkStructureType                                        sType;

512
    const void*                                            pNext;

513
    uint32_t                                               maxSpsStdCount;

514
    uint32_t                                               maxPpsStdCount;

515
    const VkVideoEncodeH264SessionParametersAddInfoEXT*    pParametersAddInfo;

516
} VkVideoEncodeH264SessionParametersCreateInfoEXT;

517


518
typedef struct VkVideoEncodeH264DpbSlotInfoEXT {

519
    VkStructureType                         sType;

520
    const void*                             pNext;

521
    int8_t                                  slotIndex;

522
    const StdVideoEncodeH264PictureInfo*    pStdPictureInfo;

523
} VkVideoEncodeH264DpbSlotInfoEXT;

524


525
typedef struct VkVideoEncodeH264NaluSliceEXT {

526
    VkStructureType                           sType;

527
    const void*                               pNext;

528
    const StdVideoEncodeH264SliceHeader*      pSliceHeaderStd;

529
    uint32_t                                  mbCount;

530
    uint8_t                                   refFinalList0EntryCount;

531
    const VkVideoEncodeH264DpbSlotInfoEXT*    pRefFinalList0Entries;

532
    uint8_t                                   refFinalList1EntryCount;

533
    const VkVideoEncodeH264DpbSlotInfoEXT*    pRefFinalList1Entries;

534
    uint32_t                                  precedingNaluBytes;

535
    uint8_t                                   minQp;

536
    uint8_t                                   maxQp;

537
} VkVideoEncodeH264NaluSliceEXT;

538


539
typedef struct VkVideoEncodeH264VclFrameInfoEXT {

540
    VkStructureType                           sType;

541
    const void*                               pNext;

542
    uint8_t                                   refDefaultFinalList0EntryCount;

543
    const VkVideoEncodeH264DpbSlotInfoEXT*    pRefDefaultFinalList0Entries;

544
    uint8_t                                   refDefaultFinalList1EntryCount;

545
    const VkVideoEncodeH264DpbSlotInfoEXT*    pRefDefaultFinalList1Entries;

546
    uint32_t                                  naluSliceEntryCount;

547
    const VkVideoEncodeH264NaluSliceEXT*      pNaluSliceEntries;

548
    const VkVideoEncodeH264DpbSlotInfoEXT*    pCurrentPictureInfo;

549
} VkVideoEncodeH264VclFrameInfoEXT;

550


551
typedef struct VkVideoEncodeH264EmitPictureParametersEXT {

552
    VkStructureType    sType;

553
    const void*        pNext;

554
    uint8_t            spsId;

555
    VkBool32           emitSpsEnable;

556
    uint32_t           ppsIdEntryCount;

557
    const uint8_t*     ppsIdEntries;

558
} VkVideoEncodeH264EmitPictureParametersEXT;

559


560
typedef struct VkVideoEncodeH264ProfileEXT {

561
    VkStructureType           sType;

562
    const void*               pNext;

563
    StdVideoH264ProfileIdc    stdProfileIdc;

564
} VkVideoEncodeH264ProfileEXT;

565


566


567


568
#define VK_EXT_video_decode_h264 1

569
#include "vk_video/vulkan_video_codec_h264std_decode.h"

570
#define VK_EXT_VIDEO_DECODE_H264_SPEC_VERSION 1

571
#define VK_EXT_VIDEO_DECODE_H264_EXTENSION_NAME "VK_EXT_video_decode_h264"

572


573
typedef enum VkVideoDecodeH264FieldLayoutFlagBitsEXT {

574
    VK_VIDEO_DECODE_H264_PROGRESSIVE_PICTURES_ONLY_EXT = 0,

575
    VK_VIDEO_DECODE_H264_FIELD_LAYOUT_LINE_INTERLACED_PLANE_BIT_EXT = 0x00000001,

576
    VK_VIDEO_DECODE_H264_FIELD_LAYOUT_SEPARATE_INTERLACED_PLANE_BIT_EXT = 0x00000002,

577
    VK_VIDEO_DECODE_H264_FIELD_LAYOUT_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF

578
} VkVideoDecodeH264FieldLayoutFlagBitsEXT;

579
typedef VkFlags VkVideoDecodeH264FieldLayoutFlagsEXT;

580
typedef VkFlags VkVideoDecodeH264CreateFlagsEXT;

581
typedef struct VkVideoDecodeH264ProfileEXT {

582
    VkStructureType                         sType;

583
    const void*                             pNext;

584
    StdVideoH264ProfileIdc                  stdProfileIdc;

585
    VkVideoDecodeH264FieldLayoutFlagsEXT    fieldLayout;

586
} VkVideoDecodeH264ProfileEXT;

587


588
typedef struct VkVideoDecodeH264CapabilitiesEXT {

589
    VkStructureType          sType;

590
    void*                    pNext;

591
    uint32_t                 maxLevel;

592
    VkOffset2D               fieldOffsetGranularity;

593
    VkExtensionProperties    stdExtensionVersion;

594
} VkVideoDecodeH264CapabilitiesEXT;

595


596
typedef struct VkVideoDecodeH264SessionCreateInfoEXT {

597
    VkStructureType                    sType;

598
    const void*                        pNext;

599
    VkVideoDecodeH264CreateFlagsEXT    flags;

600
    const VkExtensionProperties*       pStdExtensionVersion;

601
} VkVideoDecodeH264SessionCreateInfoEXT;

602


603
typedef struct VkVideoDecodeH264SessionParametersAddInfoEXT {

604
    VkStructureType                            sType;

605
    const void*                                pNext;

606
    uint32_t                                   spsStdCount;

607
    const StdVideoH264SequenceParameterSet*    pSpsStd;

608
    uint32_t                                   ppsStdCount;

609
    const StdVideoH264PictureParameterSet*     pPpsStd;

610
} VkVideoDecodeH264SessionParametersAddInfoEXT;

611


612
typedef struct VkVideoDecodeH264SessionParametersCreateInfoEXT {

613
    VkStructureType                                        sType;

614
    const void*                                            pNext;

615
    uint32_t                                               maxSpsStdCount;

616
    uint32_t                                               maxPpsStdCount;

617
    const VkVideoDecodeH264SessionParametersAddInfoEXT*    pParametersAddInfo;

618
} VkVideoDecodeH264SessionParametersCreateInfoEXT;

619


620
typedef struct VkVideoDecodeH264PictureInfoEXT {

621
    VkStructureType                         sType;

622
    const void*                             pNext;

623
    const StdVideoDecodeH264PictureInfo*    pStdPictureInfo;

624
    uint32_t                                slicesCount;

625
    const uint32_t*                         pSlicesDataOffsets;

626
} VkVideoDecodeH264PictureInfoEXT;

627


628
typedef struct VkVideoDecodeH264MvcEXT {

629
    VkStructureType                 sType;

630
    const void*                     pNext;

631
    const StdVideoDecodeH264Mvc*    pStdMvc;

632
} VkVideoDecodeH264MvcEXT;

633


634
typedef struct VkVideoDecodeH264DpbSlotInfoEXT {

635
    VkStructureType                           sType;

636
    const void*                               pNext;

637
    const StdVideoDecodeH264ReferenceInfo*    pStdReferenceInfo;

638
} VkVideoDecodeH264DpbSlotInfoEXT;

639


640


641


642
#define VK_EXT_video_decode_h265 1

643
#include "vk_video/vulkan_video_codec_h265std.h"

644
#include "vk_video/vulkan_video_codec_h265std_decode.h"

645
#define VK_EXT_VIDEO_DECODE_H265_SPEC_VERSION 1

646
#define VK_EXT_VIDEO_DECODE_H265_EXTENSION_NAME "VK_EXT_video_decode_h265"

647
typedef VkFlags VkVideoDecodeH265CreateFlagsEXT;

648
typedef struct VkVideoDecodeH265ProfileEXT {

649
    VkStructureType           sType;

650
    const void*               pNext;

651
    StdVideoH265ProfileIdc    stdProfileIdc;

652
} VkVideoDecodeH265ProfileEXT;

653


654
typedef struct VkVideoDecodeH265CapabilitiesEXT {

655
    VkStructureType          sType;

656
    void*                    pNext;

657
    uint32_t                 maxLevel;

658
    VkExtensionProperties    stdExtensionVersion;

659
} VkVideoDecodeH265CapabilitiesEXT;

660


661
typedef struct VkVideoDecodeH265SessionCreateInfoEXT {

662
    VkStructureType                    sType;

663
    const void*                        pNext;

664
    VkVideoDecodeH265CreateFlagsEXT    flags;

665
    const VkExtensionProperties*       pStdExtensionVersion;

666
} VkVideoDecodeH265SessionCreateInfoEXT;

667


668
typedef struct VkVideoDecodeH265SessionParametersAddInfoEXT {

669
    VkStructureType                            sType;

670
    const void*                                pNext;

671
    uint32_t                                   spsStdCount;

672
    const StdVideoH265SequenceParameterSet*    pSpsStd;

673
    uint32_t                                   ppsStdCount;

674
    const StdVideoH265PictureParameterSet*     pPpsStd;

675
} VkVideoDecodeH265SessionParametersAddInfoEXT;

676


677
typedef struct VkVideoDecodeH265SessionParametersCreateInfoEXT {

678
    VkStructureType                                        sType;

679
    const void*                                            pNext;

680
    uint32_t                                               maxSpsStdCount;

681
    uint32_t                                               maxPpsStdCount;

682
    const VkVideoDecodeH265SessionParametersAddInfoEXT*    pParametersAddInfo;

683
} VkVideoDecodeH265SessionParametersCreateInfoEXT;

684


685
typedef struct VkVideoDecodeH265PictureInfoEXT {

686
    VkStructureType                   sType;

687
    const void*                       pNext;

688
    StdVideoDecodeH265PictureInfo*    pStdPictureInfo;

689
    uint32_t                          slicesCount;

690
    const uint32_t*                   pSlicesDataOffsets;

691
} VkVideoDecodeH265PictureInfoEXT;

692


693
typedef struct VkVideoDecodeH265DpbSlotInfoEXT {

694
    VkStructureType                           sType;

695
    const void*                               pNext;

696
    const StdVideoDecodeH265ReferenceInfo*    pStdReferenceInfo;

697
} VkVideoDecodeH265DpbSlotInfoEXT;

698


699


700
#ifdef __cplusplus

701
}

702
#endif

703


704
#endif

705


706