diff options
Diffstat (limited to 'contrib/SDL-3.2.8/src/video/khronos/vk_video')
9 files changed, 1743 insertions, 0 deletions
diff --git a/contrib/SDL-3.2.8/src/video/khronos/vk_video/vulkan_video_codec_av1std.h b/contrib/SDL-3.2.8/src/video/khronos/vk_video/vulkan_video_codec_av1std.h new file mode 100644 index 0000000..8ce283e --- /dev/null +++ b/contrib/SDL-3.2.8/src/video/khronos/vk_video/vulkan_video_codec_av1std.h | |||
| @@ -0,0 +1,392 @@ | |||
| 1 | #ifndef VULKAN_VIDEO_CODEC_AV1STD_H_ | ||
| 2 | #define VULKAN_VIDEO_CODEC_AV1STD_H_ 1 | ||
| 3 | |||
| 4 | /* | ||
| 5 | ** Copyright 2015-2024 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 | // vulkan_video_codec_av1std is a preprocessor guard. Do not pass it to API calls. | ||
| 23 | #define vulkan_video_codec_av1std 1 | ||
| 24 | #include "vulkan_video_codecs_common.h" | ||
| 25 | #define STD_VIDEO_AV1_NUM_REF_FRAMES 8 | ||
| 26 | #define STD_VIDEO_AV1_REFS_PER_FRAME 7 | ||
| 27 | #define STD_VIDEO_AV1_TOTAL_REFS_PER_FRAME 8 | ||
| 28 | #define STD_VIDEO_AV1_MAX_TILE_COLS 64 | ||
| 29 | #define STD_VIDEO_AV1_MAX_TILE_ROWS 64 | ||
| 30 | #define STD_VIDEO_AV1_MAX_SEGMENTS 8 | ||
| 31 | #define STD_VIDEO_AV1_SEG_LVL_MAX 8 | ||
| 32 | #define STD_VIDEO_AV1_PRIMARY_REF_NONE 7 | ||
| 33 | #define STD_VIDEO_AV1_SELECT_INTEGER_MV 2 | ||
| 34 | #define STD_VIDEO_AV1_SELECT_SCREEN_CONTENT_TOOLS 2 | ||
| 35 | #define STD_VIDEO_AV1_SKIP_MODE_FRAMES 2 | ||
| 36 | #define STD_VIDEO_AV1_MAX_LOOP_FILTER_STRENGTHS 4 | ||
| 37 | #define STD_VIDEO_AV1_LOOP_FILTER_ADJUSTMENTS 2 | ||
| 38 | #define STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS 8 | ||
| 39 | #define STD_VIDEO_AV1_MAX_NUM_PLANES 3 | ||
| 40 | #define STD_VIDEO_AV1_GLOBAL_MOTION_PARAMS 6 | ||
| 41 | #define STD_VIDEO_AV1_MAX_NUM_Y_POINTS 14 | ||
| 42 | #define STD_VIDEO_AV1_MAX_NUM_CB_POINTS 10 | ||
| 43 | #define STD_VIDEO_AV1_MAX_NUM_CR_POINTS 10 | ||
| 44 | #define STD_VIDEO_AV1_MAX_NUM_POS_LUMA 24 | ||
| 45 | #define STD_VIDEO_AV1_MAX_NUM_POS_CHROMA 25 | ||
| 46 | |||
| 47 | typedef enum StdVideoAV1Profile { | ||
| 48 | STD_VIDEO_AV1_PROFILE_MAIN = 0, | ||
| 49 | STD_VIDEO_AV1_PROFILE_HIGH = 1, | ||
| 50 | STD_VIDEO_AV1_PROFILE_PROFESSIONAL = 2, | ||
| 51 | STD_VIDEO_AV1_PROFILE_INVALID = 0x7FFFFFFF, | ||
| 52 | STD_VIDEO_AV1_PROFILE_MAX_ENUM = 0x7FFFFFFF | ||
| 53 | } StdVideoAV1Profile; | ||
| 54 | |||
| 55 | typedef enum StdVideoAV1Level { | ||
| 56 | STD_VIDEO_AV1_LEVEL_2_0 = 0, | ||
| 57 | STD_VIDEO_AV1_LEVEL_2_1 = 1, | ||
| 58 | STD_VIDEO_AV1_LEVEL_2_2 = 2, | ||
| 59 | STD_VIDEO_AV1_LEVEL_2_3 = 3, | ||
| 60 | STD_VIDEO_AV1_LEVEL_3_0 = 4, | ||
| 61 | STD_VIDEO_AV1_LEVEL_3_1 = 5, | ||
| 62 | STD_VIDEO_AV1_LEVEL_3_2 = 6, | ||
| 63 | STD_VIDEO_AV1_LEVEL_3_3 = 7, | ||
| 64 | STD_VIDEO_AV1_LEVEL_4_0 = 8, | ||
| 65 | STD_VIDEO_AV1_LEVEL_4_1 = 9, | ||
| 66 | STD_VIDEO_AV1_LEVEL_4_2 = 10, | ||
| 67 | STD_VIDEO_AV1_LEVEL_4_3 = 11, | ||
| 68 | STD_VIDEO_AV1_LEVEL_5_0 = 12, | ||
| 69 | STD_VIDEO_AV1_LEVEL_5_1 = 13, | ||
| 70 | STD_VIDEO_AV1_LEVEL_5_2 = 14, | ||
| 71 | STD_VIDEO_AV1_LEVEL_5_3 = 15, | ||
| 72 | STD_VIDEO_AV1_LEVEL_6_0 = 16, | ||
| 73 | STD_VIDEO_AV1_LEVEL_6_1 = 17, | ||
| 74 | STD_VIDEO_AV1_LEVEL_6_2 = 18, | ||
| 75 | STD_VIDEO_AV1_LEVEL_6_3 = 19, | ||
| 76 | STD_VIDEO_AV1_LEVEL_7_0 = 20, | ||
| 77 | STD_VIDEO_AV1_LEVEL_7_1 = 21, | ||
| 78 | STD_VIDEO_AV1_LEVEL_7_2 = 22, | ||
| 79 | STD_VIDEO_AV1_LEVEL_7_3 = 23, | ||
| 80 | STD_VIDEO_AV1_LEVEL_INVALID = 0x7FFFFFFF, | ||
| 81 | STD_VIDEO_AV1_LEVEL_MAX_ENUM = 0x7FFFFFFF | ||
| 82 | } StdVideoAV1Level; | ||
| 83 | |||
| 84 | typedef enum StdVideoAV1FrameType { | ||
| 85 | STD_VIDEO_AV1_FRAME_TYPE_KEY = 0, | ||
| 86 | STD_VIDEO_AV1_FRAME_TYPE_INTER = 1, | ||
| 87 | STD_VIDEO_AV1_FRAME_TYPE_INTRA_ONLY = 2, | ||
| 88 | STD_VIDEO_AV1_FRAME_TYPE_SWITCH = 3, | ||
| 89 | STD_VIDEO_AV1_FRAME_TYPE_INVALID = 0x7FFFFFFF, | ||
| 90 | STD_VIDEO_AV1_FRAME_TYPE_MAX_ENUM = 0x7FFFFFFF | ||
| 91 | } StdVideoAV1FrameType; | ||
| 92 | |||
| 93 | typedef enum StdVideoAV1ReferenceName { | ||
| 94 | STD_VIDEO_AV1_REFERENCE_NAME_INTRA_FRAME = 0, | ||
| 95 | STD_VIDEO_AV1_REFERENCE_NAME_LAST_FRAME = 1, | ||
| 96 | STD_VIDEO_AV1_REFERENCE_NAME_LAST2_FRAME = 2, | ||
| 97 | STD_VIDEO_AV1_REFERENCE_NAME_LAST3_FRAME = 3, | ||
| 98 | STD_VIDEO_AV1_REFERENCE_NAME_GOLDEN_FRAME = 4, | ||
| 99 | STD_VIDEO_AV1_REFERENCE_NAME_BWDREF_FRAME = 5, | ||
| 100 | STD_VIDEO_AV1_REFERENCE_NAME_ALTREF2_FRAME = 6, | ||
| 101 | STD_VIDEO_AV1_REFERENCE_NAME_ALTREF_FRAME = 7, | ||
| 102 | STD_VIDEO_AV1_REFERENCE_NAME_INVALID = 0x7FFFFFFF, | ||
| 103 | STD_VIDEO_AV1_REFERENCE_NAME_MAX_ENUM = 0x7FFFFFFF | ||
| 104 | } StdVideoAV1ReferenceName; | ||
| 105 | |||
| 106 | typedef enum StdVideoAV1InterpolationFilter { | ||
| 107 | STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP = 0, | ||
| 108 | STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH = 1, | ||
| 109 | STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP_SHARP = 2, | ||
| 110 | STD_VIDEO_AV1_INTERPOLATION_FILTER_BILINEAR = 3, | ||
| 111 | STD_VIDEO_AV1_INTERPOLATION_FILTER_SWITCHABLE = 4, | ||
| 112 | STD_VIDEO_AV1_INTERPOLATION_FILTER_INVALID = 0x7FFFFFFF, | ||
| 113 | STD_VIDEO_AV1_INTERPOLATION_FILTER_MAX_ENUM = 0x7FFFFFFF | ||
| 114 | } StdVideoAV1InterpolationFilter; | ||
| 115 | |||
| 116 | typedef enum StdVideoAV1TxMode { | ||
| 117 | STD_VIDEO_AV1_TX_MODE_ONLY_4X4 = 0, | ||
| 118 | STD_VIDEO_AV1_TX_MODE_LARGEST = 1, | ||
| 119 | STD_VIDEO_AV1_TX_MODE_SELECT = 2, | ||
| 120 | STD_VIDEO_AV1_TX_MODE_INVALID = 0x7FFFFFFF, | ||
| 121 | STD_VIDEO_AV1_TX_MODE_MAX_ENUM = 0x7FFFFFFF | ||
| 122 | } StdVideoAV1TxMode; | ||
| 123 | |||
| 124 | typedef enum StdVideoAV1FrameRestorationType { | ||
| 125 | STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_NONE = 0, | ||
| 126 | STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_WIENER = 1, | ||
| 127 | STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_SGRPROJ = 2, | ||
| 128 | STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_SWITCHABLE = 3, | ||
| 129 | STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_INVALID = 0x7FFFFFFF, | ||
| 130 | STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_MAX_ENUM = 0x7FFFFFFF | ||
| 131 | } StdVideoAV1FrameRestorationType; | ||
| 132 | |||
| 133 | typedef enum StdVideoAV1ColorPrimaries { | ||
| 134 | STD_VIDEO_AV1_COLOR_PRIMARIES_BT_709 = 1, | ||
| 135 | STD_VIDEO_AV1_COLOR_PRIMARIES_BT_UNSPECIFIED = 2, | ||
| 136 | STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_M = 4, | ||
| 137 | STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_B_G = 5, | ||
| 138 | STD_VIDEO_AV1_COLOR_PRIMARIES_BT_601 = 6, | ||
| 139 | STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_240 = 7, | ||
| 140 | STD_VIDEO_AV1_COLOR_PRIMARIES_GENERIC_FILM = 8, | ||
| 141 | STD_VIDEO_AV1_COLOR_PRIMARIES_BT_2020 = 9, | ||
| 142 | STD_VIDEO_AV1_COLOR_PRIMARIES_XYZ = 10, | ||
| 143 | STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_431 = 11, | ||
| 144 | STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_432 = 12, | ||
| 145 | STD_VIDEO_AV1_COLOR_PRIMARIES_EBU_3213 = 22, | ||
| 146 | STD_VIDEO_AV1_COLOR_PRIMARIES_INVALID = 0x7FFFFFFF, | ||
| 147 | STD_VIDEO_AV1_COLOR_PRIMARIES_MAX_ENUM = 0x7FFFFFFF | ||
| 148 | } StdVideoAV1ColorPrimaries; | ||
| 149 | |||
| 150 | typedef enum StdVideoAV1TransferCharacteristics { | ||
| 151 | STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_RESERVED_0 = 0, | ||
| 152 | STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_709 = 1, | ||
| 153 | STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_UNSPECIFIED = 2, | ||
| 154 | STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_RESERVED_3 = 3, | ||
| 155 | STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_470_M = 4, | ||
| 156 | STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_470_B_G = 5, | ||
| 157 | STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_601 = 6, | ||
| 158 | STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_240 = 7, | ||
| 159 | STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LINEAR = 8, | ||
| 160 | STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LOG_100 = 9, | ||
| 161 | STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LOG_100_SQRT10 = 10, | ||
| 162 | STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_IEC_61966 = 11, | ||
| 163 | STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_1361 = 12, | ||
| 164 | STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SRGB = 13, | ||
| 165 | STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_2020_10_BIT = 14, | ||
| 166 | STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_2020_12_BIT = 15, | ||
| 167 | STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_2084 = 16, | ||
| 168 | STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_428 = 17, | ||
| 169 | STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_HLG = 18, | ||
| 170 | STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_INVALID = 0x7FFFFFFF, | ||
| 171 | STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_MAX_ENUM = 0x7FFFFFFF | ||
| 172 | } StdVideoAV1TransferCharacteristics; | ||
| 173 | |||
| 174 | typedef enum StdVideoAV1MatrixCoefficients { | ||
| 175 | STD_VIDEO_AV1_MATRIX_COEFFICIENTS_IDENTITY = 0, | ||
| 176 | STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_709 = 1, | ||
| 177 | STD_VIDEO_AV1_MATRIX_COEFFICIENTS_UNSPECIFIED = 2, | ||
| 178 | STD_VIDEO_AV1_MATRIX_COEFFICIENTS_RESERVED_3 = 3, | ||
| 179 | STD_VIDEO_AV1_MATRIX_COEFFICIENTS_FCC = 4, | ||
| 180 | STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_470_B_G = 5, | ||
| 181 | STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_601 = 6, | ||
| 182 | STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_240 = 7, | ||
| 183 | STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_YCGCO = 8, | ||
| 184 | STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_2020_NCL = 9, | ||
| 185 | STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_2020_CL = 10, | ||
| 186 | STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_2085 = 11, | ||
| 187 | STD_VIDEO_AV1_MATRIX_COEFFICIENTS_CHROMAT_NCL = 12, | ||
| 188 | STD_VIDEO_AV1_MATRIX_COEFFICIENTS_CHROMAT_CL = 13, | ||
| 189 | STD_VIDEO_AV1_MATRIX_COEFFICIENTS_ICTCP = 14, | ||
| 190 | STD_VIDEO_AV1_MATRIX_COEFFICIENTS_INVALID = 0x7FFFFFFF, | ||
| 191 | STD_VIDEO_AV1_MATRIX_COEFFICIENTS_MAX_ENUM = 0x7FFFFFFF | ||
| 192 | } StdVideoAV1MatrixCoefficients; | ||
| 193 | |||
| 194 | typedef enum StdVideoAV1ChromaSamplePosition { | ||
| 195 | STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_UNKNOWN = 0, | ||
| 196 | STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_VERTICAL = 1, | ||
| 197 | STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_COLOCATED = 2, | ||
| 198 | STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_RESERVED = 3, | ||
| 199 | STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_INVALID = 0x7FFFFFFF, | ||
| 200 | STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_MAX_ENUM = 0x7FFFFFFF | ||
| 201 | } StdVideoAV1ChromaSamplePosition; | ||
| 202 | typedef struct StdVideoAV1ColorConfigFlags { | ||
| 203 | uint32_t mono_chrome : 1; | ||
| 204 | uint32_t color_range : 1; | ||
| 205 | uint32_t separate_uv_delta_q : 1; | ||
| 206 | uint32_t color_description_present_flag : 1; | ||
| 207 | uint32_t reserved : 28; | ||
| 208 | } StdVideoAV1ColorConfigFlags; | ||
| 209 | |||
| 210 | typedef struct StdVideoAV1ColorConfig { | ||
| 211 | StdVideoAV1ColorConfigFlags flags; | ||
| 212 | uint8_t BitDepth; | ||
| 213 | uint8_t subsampling_x; | ||
| 214 | uint8_t subsampling_y; | ||
| 215 | uint8_t reserved1; | ||
| 216 | StdVideoAV1ColorPrimaries color_primaries; | ||
| 217 | StdVideoAV1TransferCharacteristics transfer_characteristics; | ||
| 218 | StdVideoAV1MatrixCoefficients matrix_coefficients; | ||
| 219 | StdVideoAV1ChromaSamplePosition chroma_sample_position; | ||
| 220 | } StdVideoAV1ColorConfig; | ||
| 221 | |||
| 222 | typedef struct StdVideoAV1TimingInfoFlags { | ||
| 223 | uint32_t equal_picture_interval : 1; | ||
| 224 | uint32_t reserved : 31; | ||
| 225 | } StdVideoAV1TimingInfoFlags; | ||
| 226 | |||
| 227 | typedef struct StdVideoAV1TimingInfo { | ||
| 228 | StdVideoAV1TimingInfoFlags flags; | ||
| 229 | uint32_t num_units_in_display_tick; | ||
| 230 | uint32_t time_scale; | ||
| 231 | uint32_t num_ticks_per_picture_minus_1; | ||
| 232 | } StdVideoAV1TimingInfo; | ||
| 233 | |||
| 234 | typedef struct StdVideoAV1LoopFilterFlags { | ||
| 235 | uint32_t loop_filter_delta_enabled : 1; | ||
| 236 | uint32_t loop_filter_delta_update : 1; | ||
| 237 | uint32_t reserved : 30; | ||
| 238 | } StdVideoAV1LoopFilterFlags; | ||
| 239 | |||
| 240 | typedef struct StdVideoAV1LoopFilter { | ||
| 241 | StdVideoAV1LoopFilterFlags flags; | ||
| 242 | uint8_t loop_filter_level[STD_VIDEO_AV1_MAX_LOOP_FILTER_STRENGTHS]; | ||
| 243 | uint8_t loop_filter_sharpness; | ||
| 244 | uint8_t update_ref_delta; | ||
| 245 | int8_t loop_filter_ref_deltas[STD_VIDEO_AV1_TOTAL_REFS_PER_FRAME]; | ||
| 246 | uint8_t update_mode_delta; | ||
| 247 | int8_t loop_filter_mode_deltas[STD_VIDEO_AV1_LOOP_FILTER_ADJUSTMENTS]; | ||
| 248 | } StdVideoAV1LoopFilter; | ||
| 249 | |||
| 250 | typedef struct StdVideoAV1QuantizationFlags { | ||
| 251 | uint32_t using_qmatrix : 1; | ||
| 252 | uint32_t diff_uv_delta : 1; | ||
| 253 | uint32_t reserved : 30; | ||
| 254 | } StdVideoAV1QuantizationFlags; | ||
| 255 | |||
| 256 | typedef struct StdVideoAV1Quantization { | ||
| 257 | StdVideoAV1QuantizationFlags flags; | ||
| 258 | uint8_t base_q_idx; | ||
| 259 | int8_t DeltaQYDc; | ||
| 260 | int8_t DeltaQUDc; | ||
| 261 | int8_t DeltaQUAc; | ||
| 262 | int8_t DeltaQVDc; | ||
| 263 | int8_t DeltaQVAc; | ||
| 264 | uint8_t qm_y; | ||
| 265 | uint8_t qm_u; | ||
| 266 | uint8_t qm_v; | ||
| 267 | } StdVideoAV1Quantization; | ||
| 268 | |||
| 269 | typedef struct StdVideoAV1Segmentation { | ||
| 270 | uint8_t FeatureEnabled[STD_VIDEO_AV1_MAX_SEGMENTS]; | ||
| 271 | int16_t FeatureData[STD_VIDEO_AV1_MAX_SEGMENTS][STD_VIDEO_AV1_SEG_LVL_MAX]; | ||
| 272 | } StdVideoAV1Segmentation; | ||
| 273 | |||
| 274 | typedef struct StdVideoAV1TileInfoFlags { | ||
| 275 | uint32_t uniform_tile_spacing_flag : 1; | ||
| 276 | uint32_t reserved : 31; | ||
| 277 | } StdVideoAV1TileInfoFlags; | ||
| 278 | |||
| 279 | typedef struct StdVideoAV1TileInfo { | ||
| 280 | StdVideoAV1TileInfoFlags flags; | ||
| 281 | uint8_t TileCols; | ||
| 282 | uint8_t TileRows; | ||
| 283 | uint16_t context_update_tile_id; | ||
| 284 | uint8_t tile_size_bytes_minus_1; | ||
| 285 | uint8_t reserved1[7]; | ||
| 286 | const uint16_t* pMiColStarts; | ||
| 287 | const uint16_t* pMiRowStarts; | ||
| 288 | const uint16_t* pWidthInSbsMinus1; | ||
| 289 | const uint16_t* pHeightInSbsMinus1; | ||
| 290 | } StdVideoAV1TileInfo; | ||
| 291 | |||
| 292 | typedef struct StdVideoAV1CDEF { | ||
| 293 | uint8_t cdef_damping_minus_3; | ||
| 294 | uint8_t cdef_bits; | ||
| 295 | uint8_t cdef_y_pri_strength[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS]; | ||
| 296 | uint8_t cdef_y_sec_strength[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS]; | ||
| 297 | uint8_t cdef_uv_pri_strength[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS]; | ||
| 298 | uint8_t cdef_uv_sec_strength[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS]; | ||
| 299 | } StdVideoAV1CDEF; | ||
| 300 | |||
| 301 | typedef struct StdVideoAV1LoopRestoration { | ||
| 302 | StdVideoAV1FrameRestorationType FrameRestorationType[STD_VIDEO_AV1_MAX_NUM_PLANES]; | ||
| 303 | uint16_t LoopRestorationSize[STD_VIDEO_AV1_MAX_NUM_PLANES]; | ||
| 304 | } StdVideoAV1LoopRestoration; | ||
| 305 | |||
| 306 | typedef struct StdVideoAV1GlobalMotion { | ||
| 307 | uint8_t GmType[STD_VIDEO_AV1_NUM_REF_FRAMES]; | ||
| 308 | int32_t gm_params[STD_VIDEO_AV1_NUM_REF_FRAMES][STD_VIDEO_AV1_GLOBAL_MOTION_PARAMS]; | ||
| 309 | } StdVideoAV1GlobalMotion; | ||
| 310 | |||
| 311 | typedef struct StdVideoAV1FilmGrainFlags { | ||
| 312 | uint32_t chroma_scaling_from_luma : 1; | ||
| 313 | uint32_t overlap_flag : 1; | ||
| 314 | uint32_t clip_to_restricted_range : 1; | ||
| 315 | uint32_t update_grain : 1; | ||
| 316 | uint32_t reserved : 28; | ||
| 317 | } StdVideoAV1FilmGrainFlags; | ||
| 318 | |||
| 319 | typedef struct StdVideoAV1FilmGrain { | ||
| 320 | StdVideoAV1FilmGrainFlags flags; | ||
| 321 | uint8_t grain_scaling_minus_8; | ||
| 322 | uint8_t ar_coeff_lag; | ||
| 323 | uint8_t ar_coeff_shift_minus_6; | ||
| 324 | uint8_t grain_scale_shift; | ||
| 325 | uint16_t grain_seed; | ||
| 326 | uint8_t film_grain_params_ref_idx; | ||
| 327 | uint8_t num_y_points; | ||
| 328 | uint8_t point_y_value[STD_VIDEO_AV1_MAX_NUM_Y_POINTS]; | ||
| 329 | uint8_t point_y_scaling[STD_VIDEO_AV1_MAX_NUM_Y_POINTS]; | ||
| 330 | uint8_t num_cb_points; | ||
| 331 | uint8_t point_cb_value[STD_VIDEO_AV1_MAX_NUM_CB_POINTS]; | ||
| 332 | uint8_t point_cb_scaling[STD_VIDEO_AV1_MAX_NUM_CB_POINTS]; | ||
| 333 | uint8_t num_cr_points; | ||
| 334 | uint8_t point_cr_value[STD_VIDEO_AV1_MAX_NUM_CR_POINTS]; | ||
| 335 | uint8_t point_cr_scaling[STD_VIDEO_AV1_MAX_NUM_CR_POINTS]; | ||
| 336 | int8_t ar_coeffs_y_plus_128[STD_VIDEO_AV1_MAX_NUM_POS_LUMA]; | ||
| 337 | int8_t ar_coeffs_cb_plus_128[STD_VIDEO_AV1_MAX_NUM_POS_CHROMA]; | ||
| 338 | int8_t ar_coeffs_cr_plus_128[STD_VIDEO_AV1_MAX_NUM_POS_CHROMA]; | ||
| 339 | uint8_t cb_mult; | ||
| 340 | uint8_t cb_luma_mult; | ||
| 341 | uint16_t cb_offset; | ||
| 342 | uint8_t cr_mult; | ||
| 343 | uint8_t cr_luma_mult; | ||
| 344 | uint16_t cr_offset; | ||
| 345 | } StdVideoAV1FilmGrain; | ||
| 346 | |||
| 347 | typedef struct StdVideoAV1SequenceHeaderFlags { | ||
| 348 | uint32_t still_picture : 1; | ||
| 349 | uint32_t reduced_still_picture_header : 1; | ||
| 350 | uint32_t use_128x128_superblock : 1; | ||
| 351 | uint32_t enable_filter_intra : 1; | ||
| 352 | uint32_t enable_intra_edge_filter : 1; | ||
| 353 | uint32_t enable_interintra_compound : 1; | ||
| 354 | uint32_t enable_masked_compound : 1; | ||
| 355 | uint32_t enable_warped_motion : 1; | ||
| 356 | uint32_t enable_dual_filter : 1; | ||
| 357 | uint32_t enable_order_hint : 1; | ||
| 358 | uint32_t enable_jnt_comp : 1; | ||
| 359 | uint32_t enable_ref_frame_mvs : 1; | ||
| 360 | uint32_t frame_id_numbers_present_flag : 1; | ||
| 361 | uint32_t enable_superres : 1; | ||
| 362 | uint32_t enable_cdef : 1; | ||
| 363 | uint32_t enable_restoration : 1; | ||
| 364 | uint32_t film_grain_params_present : 1; | ||
| 365 | uint32_t timing_info_present_flag : 1; | ||
| 366 | uint32_t initial_display_delay_present_flag : 1; | ||
| 367 | uint32_t reserved : 13; | ||
| 368 | } StdVideoAV1SequenceHeaderFlags; | ||
| 369 | |||
| 370 | typedef struct StdVideoAV1SequenceHeader { | ||
| 371 | StdVideoAV1SequenceHeaderFlags flags; | ||
| 372 | StdVideoAV1Profile seq_profile; | ||
| 373 | uint8_t frame_width_bits_minus_1; | ||
| 374 | uint8_t frame_height_bits_minus_1; | ||
| 375 | uint16_t max_frame_width_minus_1; | ||
| 376 | uint16_t max_frame_height_minus_1; | ||
| 377 | uint8_t delta_frame_id_length_minus_2; | ||
| 378 | uint8_t additional_frame_id_length_minus_1; | ||
| 379 | uint8_t order_hint_bits_minus_1; | ||
| 380 | uint8_t seq_force_integer_mv; | ||
| 381 | uint8_t seq_force_screen_content_tools; | ||
| 382 | uint8_t reserved1[5]; | ||
| 383 | const StdVideoAV1ColorConfig* pColorConfig; | ||
| 384 | const StdVideoAV1TimingInfo* pTimingInfo; | ||
| 385 | } StdVideoAV1SequenceHeader; | ||
| 386 | |||
| 387 | |||
| 388 | #ifdef __cplusplus | ||
| 389 | } | ||
| 390 | #endif | ||
| 391 | |||
| 392 | #endif | ||
diff --git a/contrib/SDL-3.2.8/src/video/khronos/vk_video/vulkan_video_codec_av1std_decode.h b/contrib/SDL-3.2.8/src/video/khronos/vk_video/vulkan_video_codec_av1std_decode.h new file mode 100644 index 0000000..6b8130c --- /dev/null +++ b/contrib/SDL-3.2.8/src/video/khronos/vk_video/vulkan_video_codec_av1std_decode.h | |||
| @@ -0,0 +1,109 @@ | |||
| 1 | #ifndef VULKAN_VIDEO_CODEC_AV1STD_DECODE_H_ | ||
| 2 | #define VULKAN_VIDEO_CODEC_AV1STD_DECODE_H_ 1 | ||
| 3 | |||
| 4 | /* | ||
| 5 | ** Copyright 2015-2024 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 | // vulkan_video_codec_av1std_decode is a preprocessor guard. Do not pass it to API calls. | ||
| 23 | #define vulkan_video_codec_av1std_decode 1 | ||
| 24 | #include "vulkan_video_codec_av1std.h" | ||
| 25 | |||
| 26 | #define VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_API_VERSION_1_0_0 VK_MAKE_VIDEO_STD_VERSION(1, 0, 0) | ||
| 27 | |||
| 28 | #define VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_API_VERSION_1_0_0 | ||
| 29 | #define VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_av1_decode" | ||
| 30 | typedef struct StdVideoDecodeAV1PictureInfoFlags { | ||
| 31 | uint32_t error_resilient_mode : 1; | ||
| 32 | uint32_t disable_cdf_update : 1; | ||
| 33 | uint32_t use_superres : 1; | ||
| 34 | uint32_t render_and_frame_size_different : 1; | ||
| 35 | uint32_t allow_screen_content_tools : 1; | ||
| 36 | uint32_t is_filter_switchable : 1; | ||
| 37 | uint32_t force_integer_mv : 1; | ||
| 38 | uint32_t frame_size_override_flag : 1; | ||
| 39 | uint32_t buffer_removal_time_present_flag : 1; | ||
| 40 | uint32_t allow_intrabc : 1; | ||
| 41 | uint32_t frame_refs_short_signaling : 1; | ||
| 42 | uint32_t allow_high_precision_mv : 1; | ||
| 43 | uint32_t is_motion_mode_switchable : 1; | ||
| 44 | uint32_t use_ref_frame_mvs : 1; | ||
| 45 | uint32_t disable_frame_end_update_cdf : 1; | ||
| 46 | uint32_t allow_warped_motion : 1; | ||
| 47 | uint32_t reduced_tx_set : 1; | ||
| 48 | uint32_t reference_select : 1; | ||
| 49 | uint32_t skip_mode_present : 1; | ||
| 50 | uint32_t delta_q_present : 1; | ||
| 51 | uint32_t delta_lf_present : 1; | ||
| 52 | uint32_t delta_lf_multi : 1; | ||
| 53 | uint32_t segmentation_enabled : 1; | ||
| 54 | uint32_t segmentation_update_map : 1; | ||
| 55 | uint32_t segmentation_temporal_update : 1; | ||
| 56 | uint32_t segmentation_update_data : 1; | ||
| 57 | uint32_t UsesLr : 1; | ||
| 58 | uint32_t usesChromaLr : 1; | ||
| 59 | uint32_t apply_grain : 1; | ||
| 60 | uint32_t reserved : 3; | ||
| 61 | } StdVideoDecodeAV1PictureInfoFlags; | ||
| 62 | |||
| 63 | typedef struct StdVideoDecodeAV1PictureInfo { | ||
| 64 | StdVideoDecodeAV1PictureInfoFlags flags; | ||
| 65 | StdVideoAV1FrameType frame_type; | ||
| 66 | uint32_t current_frame_id; | ||
| 67 | uint8_t OrderHint; | ||
| 68 | uint8_t primary_ref_frame; | ||
| 69 | uint8_t refresh_frame_flags; | ||
| 70 | uint8_t reserved1; | ||
| 71 | StdVideoAV1InterpolationFilter interpolation_filter; | ||
| 72 | StdVideoAV1TxMode TxMode; | ||
| 73 | uint8_t delta_q_res; | ||
| 74 | uint8_t delta_lf_res; | ||
| 75 | uint8_t SkipModeFrame[STD_VIDEO_AV1_SKIP_MODE_FRAMES]; | ||
| 76 | uint8_t coded_denom; | ||
| 77 | uint8_t reserved2[3]; | ||
| 78 | uint8_t OrderHints[STD_VIDEO_AV1_NUM_REF_FRAMES]; | ||
| 79 | uint32_t expectedFrameId[STD_VIDEO_AV1_NUM_REF_FRAMES]; | ||
| 80 | const StdVideoAV1TileInfo* pTileInfo; | ||
| 81 | const StdVideoAV1Quantization* pQuantization; | ||
| 82 | const StdVideoAV1Segmentation* pSegmentation; | ||
| 83 | const StdVideoAV1LoopFilter* pLoopFilter; | ||
| 84 | const StdVideoAV1CDEF* pCDEF; | ||
| 85 | const StdVideoAV1LoopRestoration* pLoopRestoration; | ||
| 86 | const StdVideoAV1GlobalMotion* pGlobalMotion; | ||
| 87 | const StdVideoAV1FilmGrain* pFilmGrain; | ||
| 88 | } StdVideoDecodeAV1PictureInfo; | ||
| 89 | |||
| 90 | typedef struct StdVideoDecodeAV1ReferenceInfoFlags { | ||
| 91 | uint32_t disable_frame_end_update_cdf : 1; | ||
| 92 | uint32_t segmentation_enabled : 1; | ||
| 93 | uint32_t reserved : 30; | ||
| 94 | } StdVideoDecodeAV1ReferenceInfoFlags; | ||
| 95 | |||
| 96 | typedef struct StdVideoDecodeAV1ReferenceInfo { | ||
| 97 | StdVideoDecodeAV1ReferenceInfoFlags flags; | ||
| 98 | uint8_t frame_type; | ||
| 99 | uint8_t RefFrameSignBias; | ||
| 100 | uint8_t OrderHint; | ||
| 101 | uint8_t SavedOrderHints[STD_VIDEO_AV1_NUM_REF_FRAMES]; | ||
| 102 | } StdVideoDecodeAV1ReferenceInfo; | ||
| 103 | |||
| 104 | |||
| 105 | #ifdef __cplusplus | ||
| 106 | } | ||
| 107 | #endif | ||
| 108 | |||
| 109 | #endif | ||
diff --git a/contrib/SDL-3.2.8/src/video/khronos/vk_video/vulkan_video_codec_h264std.h b/contrib/SDL-3.2.8/src/video/khronos/vk_video/vulkan_video_codec_h264std.h new file mode 100644 index 0000000..6d27af3 --- /dev/null +++ b/contrib/SDL-3.2.8/src/video/khronos/vk_video/vulkan_video_codec_h264std.h | |||
| @@ -0,0 +1,312 @@ | |||
| 1 | #ifndef VULKAN_VIDEO_CODEC_H264STD_H_ | ||
| 2 | #define VULKAN_VIDEO_CODEC_H264STD_H_ 1 | ||
| 3 | |||
| 4 | /* | ||
| 5 | ** Copyright 2015-2024 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 | // vulkan_video_codec_h264std is a preprocessor guard. Do not pass it to API calls. | ||
| 23 | #define vulkan_video_codec_h264std 1 | ||
| 24 | #include "vulkan_video_codecs_common.h" | ||
| 25 | #define STD_VIDEO_H264_CPB_CNT_LIST_SIZE 32 | ||
| 26 | #define STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS 6 | ||
| 27 | #define STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS 16 | ||
| 28 | #define STD_VIDEO_H264_SCALING_LIST_8X8_NUM_LISTS 6 | ||
| 29 | #define STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS 64 | ||
| 30 | #define STD_VIDEO_H264_MAX_NUM_LIST_REF 32 | ||
| 31 | #define STD_VIDEO_H264_MAX_CHROMA_PLANES 2 | ||
| 32 | #define STD_VIDEO_H264_NO_REFERENCE_PICTURE 0xFF | ||
| 33 | |||
| 34 | typedef enum StdVideoH264ChromaFormatIdc { | ||
| 35 | STD_VIDEO_H264_CHROMA_FORMAT_IDC_MONOCHROME = 0, | ||
| 36 | STD_VIDEO_H264_CHROMA_FORMAT_IDC_420 = 1, | ||
| 37 | STD_VIDEO_H264_CHROMA_FORMAT_IDC_422 = 2, | ||
| 38 | STD_VIDEO_H264_CHROMA_FORMAT_IDC_444 = 3, | ||
| 39 | STD_VIDEO_H264_CHROMA_FORMAT_IDC_INVALID = 0x7FFFFFFF, | ||
| 40 | STD_VIDEO_H264_CHROMA_FORMAT_IDC_MAX_ENUM = 0x7FFFFFFF | ||
| 41 | } StdVideoH264ChromaFormatIdc; | ||
| 42 | |||
| 43 | typedef enum StdVideoH264ProfileIdc { | ||
| 44 | STD_VIDEO_H264_PROFILE_IDC_BASELINE = 66, | ||
| 45 | STD_VIDEO_H264_PROFILE_IDC_MAIN = 77, | ||
| 46 | STD_VIDEO_H264_PROFILE_IDC_HIGH = 100, | ||
| 47 | STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE = 244, | ||
| 48 | STD_VIDEO_H264_PROFILE_IDC_INVALID = 0x7FFFFFFF, | ||
| 49 | STD_VIDEO_H264_PROFILE_IDC_MAX_ENUM = 0x7FFFFFFF | ||
| 50 | } StdVideoH264ProfileIdc; | ||
| 51 | |||
| 52 | typedef enum StdVideoH264LevelIdc { | ||
| 53 | STD_VIDEO_H264_LEVEL_IDC_1_0 = 0, | ||
| 54 | STD_VIDEO_H264_LEVEL_IDC_1_1 = 1, | ||
| 55 | STD_VIDEO_H264_LEVEL_IDC_1_2 = 2, | ||
| 56 | STD_VIDEO_H264_LEVEL_IDC_1_3 = 3, | ||
| 57 | STD_VIDEO_H264_LEVEL_IDC_2_0 = 4, | ||
| 58 | STD_VIDEO_H264_LEVEL_IDC_2_1 = 5, | ||
| 59 | STD_VIDEO_H264_LEVEL_IDC_2_2 = 6, | ||
| 60 | STD_VIDEO_H264_LEVEL_IDC_3_0 = 7, | ||
| 61 | STD_VIDEO_H264_LEVEL_IDC_3_1 = 8, | ||
| 62 | STD_VIDEO_H264_LEVEL_IDC_3_2 = 9, | ||
| 63 | STD_VIDEO_H264_LEVEL_IDC_4_0 = 10, | ||
| 64 | STD_VIDEO_H264_LEVEL_IDC_4_1 = 11, | ||
| 65 | STD_VIDEO_H264_LEVEL_IDC_4_2 = 12, | ||
| 66 | STD_VIDEO_H264_LEVEL_IDC_5_0 = 13, | ||
| 67 | STD_VIDEO_H264_LEVEL_IDC_5_1 = 14, | ||
| 68 | STD_VIDEO_H264_LEVEL_IDC_5_2 = 15, | ||
| 69 | STD_VIDEO_H264_LEVEL_IDC_6_0 = 16, | ||
| 70 | STD_VIDEO_H264_LEVEL_IDC_6_1 = 17, | ||
| 71 | STD_VIDEO_H264_LEVEL_IDC_6_2 = 18, | ||
| 72 | STD_VIDEO_H264_LEVEL_IDC_INVALID = 0x7FFFFFFF, | ||
| 73 | STD_VIDEO_H264_LEVEL_IDC_MAX_ENUM = 0x7FFFFFFF | ||
| 74 | } StdVideoH264LevelIdc; | ||
| 75 | |||
| 76 | typedef enum StdVideoH264PocType { | ||
| 77 | STD_VIDEO_H264_POC_TYPE_0 = 0, | ||
| 78 | STD_VIDEO_H264_POC_TYPE_1 = 1, | ||
| 79 | STD_VIDEO_H264_POC_TYPE_2 = 2, | ||
| 80 | STD_VIDEO_H264_POC_TYPE_INVALID = 0x7FFFFFFF, | ||
| 81 | STD_VIDEO_H264_POC_TYPE_MAX_ENUM = 0x7FFFFFFF | ||
| 82 | } StdVideoH264PocType; | ||
| 83 | |||
| 84 | typedef enum StdVideoH264AspectRatioIdc { | ||
| 85 | STD_VIDEO_H264_ASPECT_RATIO_IDC_UNSPECIFIED = 0, | ||
| 86 | STD_VIDEO_H264_ASPECT_RATIO_IDC_SQUARE = 1, | ||
| 87 | STD_VIDEO_H264_ASPECT_RATIO_IDC_12_11 = 2, | ||
| 88 | STD_VIDEO_H264_ASPECT_RATIO_IDC_10_11 = 3, | ||
| 89 | STD_VIDEO_H264_ASPECT_RATIO_IDC_16_11 = 4, | ||
| 90 | STD_VIDEO_H264_ASPECT_RATIO_IDC_40_33 = 5, | ||
| 91 | STD_VIDEO_H264_ASPECT_RATIO_IDC_24_11 = 6, | ||
| 92 | STD_VIDEO_H264_ASPECT_RATIO_IDC_20_11 = 7, | ||
| 93 | STD_VIDEO_H264_ASPECT_RATIO_IDC_32_11 = 8, | ||
| 94 | STD_VIDEO_H264_ASPECT_RATIO_IDC_80_33 = 9, | ||
| 95 | STD_VIDEO_H264_ASPECT_RATIO_IDC_18_11 = 10, | ||
| 96 | STD_VIDEO_H264_ASPECT_RATIO_IDC_15_11 = 11, | ||
| 97 | STD_VIDEO_H264_ASPECT_RATIO_IDC_64_33 = 12, | ||
| 98 | STD_VIDEO_H264_ASPECT_RATIO_IDC_160_99 = 13, | ||
| 99 | STD_VIDEO_H264_ASPECT_RATIO_IDC_4_3 = 14, | ||
| 100 | STD_VIDEO_H264_ASPECT_RATIO_IDC_3_2 = 15, | ||
| 101 | STD_VIDEO_H264_ASPECT_RATIO_IDC_2_1 = 16, | ||
| 102 | STD_VIDEO_H264_ASPECT_RATIO_IDC_EXTENDED_SAR = 255, | ||
| 103 | STD_VIDEO_H264_ASPECT_RATIO_IDC_INVALID = 0x7FFFFFFF, | ||
| 104 | STD_VIDEO_H264_ASPECT_RATIO_IDC_MAX_ENUM = 0x7FFFFFFF | ||
| 105 | } StdVideoH264AspectRatioIdc; | ||
| 106 | |||
| 107 | typedef enum StdVideoH264WeightedBipredIdc { | ||
| 108 | STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_DEFAULT = 0, | ||
| 109 | STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_EXPLICIT = 1, | ||
| 110 | STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_IMPLICIT = 2, | ||
| 111 | STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_INVALID = 0x7FFFFFFF, | ||
| 112 | STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_MAX_ENUM = 0x7FFFFFFF | ||
| 113 | } StdVideoH264WeightedBipredIdc; | ||
| 114 | |||
| 115 | typedef enum StdVideoH264ModificationOfPicNumsIdc { | ||
| 116 | STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_SUBTRACT = 0, | ||
| 117 | STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_ADD = 1, | ||
| 118 | STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_LONG_TERM = 2, | ||
| 119 | STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_END = 3, | ||
| 120 | STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_INVALID = 0x7FFFFFFF, | ||
| 121 | STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_MAX_ENUM = 0x7FFFFFFF | ||
| 122 | } StdVideoH264ModificationOfPicNumsIdc; | ||
| 123 | |||
| 124 | typedef enum StdVideoH264MemMgmtControlOp { | ||
| 125 | STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_END = 0, | ||
| 126 | STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_SHORT_TERM = 1, | ||
| 127 | STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_LONG_TERM = 2, | ||
| 128 | STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_LONG_TERM = 3, | ||
| 129 | STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_SET_MAX_LONG_TERM_INDEX = 4, | ||
| 130 | STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_ALL = 5, | ||
| 131 | STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_CURRENT_AS_LONG_TERM = 6, | ||
| 132 | STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_INVALID = 0x7FFFFFFF, | ||
| 133 | STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MAX_ENUM = 0x7FFFFFFF | ||
| 134 | } StdVideoH264MemMgmtControlOp; | ||
| 135 | |||
| 136 | typedef enum StdVideoH264CabacInitIdc { | ||
| 137 | STD_VIDEO_H264_CABAC_INIT_IDC_0 = 0, | ||
| 138 | STD_VIDEO_H264_CABAC_INIT_IDC_1 = 1, | ||
| 139 | STD_VIDEO_H264_CABAC_INIT_IDC_2 = 2, | ||
| 140 | STD_VIDEO_H264_CABAC_INIT_IDC_INVALID = 0x7FFFFFFF, | ||
| 141 | STD_VIDEO_H264_CABAC_INIT_IDC_MAX_ENUM = 0x7FFFFFFF | ||
| 142 | } StdVideoH264CabacInitIdc; | ||
| 143 | |||
| 144 | typedef enum StdVideoH264DisableDeblockingFilterIdc { | ||
| 145 | STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_DISABLED = 0, | ||
| 146 | STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_ENABLED = 1, | ||
| 147 | STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_PARTIAL = 2, | ||
| 148 | STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_INVALID = 0x7FFFFFFF, | ||
| 149 | STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_MAX_ENUM = 0x7FFFFFFF | ||
| 150 | } StdVideoH264DisableDeblockingFilterIdc; | ||
| 151 | |||
| 152 | typedef enum StdVideoH264SliceType { | ||
| 153 | STD_VIDEO_H264_SLICE_TYPE_P = 0, | ||
| 154 | STD_VIDEO_H264_SLICE_TYPE_B = 1, | ||
| 155 | STD_VIDEO_H264_SLICE_TYPE_I = 2, | ||
| 156 | STD_VIDEO_H264_SLICE_TYPE_INVALID = 0x7FFFFFFF, | ||
| 157 | STD_VIDEO_H264_SLICE_TYPE_MAX_ENUM = 0x7FFFFFFF | ||
| 158 | } StdVideoH264SliceType; | ||
| 159 | |||
| 160 | typedef enum StdVideoH264PictureType { | ||
| 161 | STD_VIDEO_H264_PICTURE_TYPE_P = 0, | ||
| 162 | STD_VIDEO_H264_PICTURE_TYPE_B = 1, | ||
| 163 | STD_VIDEO_H264_PICTURE_TYPE_I = 2, | ||
| 164 | STD_VIDEO_H264_PICTURE_TYPE_IDR = 5, | ||
| 165 | STD_VIDEO_H264_PICTURE_TYPE_INVALID = 0x7FFFFFFF, | ||
| 166 | STD_VIDEO_H264_PICTURE_TYPE_MAX_ENUM = 0x7FFFFFFF | ||
| 167 | } StdVideoH264PictureType; | ||
| 168 | |||
| 169 | typedef enum StdVideoH264NonVclNaluType { | ||
| 170 | STD_VIDEO_H264_NON_VCL_NALU_TYPE_SPS = 0, | ||
| 171 | STD_VIDEO_H264_NON_VCL_NALU_TYPE_PPS = 1, | ||
| 172 | STD_VIDEO_H264_NON_VCL_NALU_TYPE_AUD = 2, | ||
| 173 | STD_VIDEO_H264_NON_VCL_NALU_TYPE_PREFIX = 3, | ||
| 174 | STD_VIDEO_H264_NON_VCL_NALU_TYPE_END_OF_SEQUENCE = 4, | ||
| 175 | STD_VIDEO_H264_NON_VCL_NALU_TYPE_END_OF_STREAM = 5, | ||
| 176 | STD_VIDEO_H264_NON_VCL_NALU_TYPE_PRECODED = 6, | ||
| 177 | STD_VIDEO_H264_NON_VCL_NALU_TYPE_INVALID = 0x7FFFFFFF, | ||
| 178 | STD_VIDEO_H264_NON_VCL_NALU_TYPE_MAX_ENUM = 0x7FFFFFFF | ||
| 179 | } StdVideoH264NonVclNaluType; | ||
| 180 | typedef struct StdVideoH264SpsVuiFlags { | ||
| 181 | uint32_t aspect_ratio_info_present_flag : 1; | ||
| 182 | uint32_t overscan_info_present_flag : 1; | ||
| 183 | uint32_t overscan_appropriate_flag : 1; | ||
| 184 | uint32_t video_signal_type_present_flag : 1; | ||
| 185 | uint32_t video_full_range_flag : 1; | ||
| 186 | uint32_t color_description_present_flag : 1; | ||
| 187 | uint32_t chroma_loc_info_present_flag : 1; | ||
| 188 | uint32_t timing_info_present_flag : 1; | ||
| 189 | uint32_t fixed_frame_rate_flag : 1; | ||
| 190 | uint32_t bitstream_restriction_flag : 1; | ||
| 191 | uint32_t nal_hrd_parameters_present_flag : 1; | ||
| 192 | uint32_t vcl_hrd_parameters_present_flag : 1; | ||
| 193 | } StdVideoH264SpsVuiFlags; | ||
| 194 | |||
| 195 | typedef struct StdVideoH264HrdParameters { | ||
| 196 | uint8_t cpb_cnt_minus1; | ||
| 197 | uint8_t bit_rate_scale; | ||
| 198 | uint8_t cpb_size_scale; | ||
| 199 | uint8_t reserved1; | ||
| 200 | uint32_t bit_rate_value_minus1[STD_VIDEO_H264_CPB_CNT_LIST_SIZE]; | ||
| 201 | uint32_t cpb_size_value_minus1[STD_VIDEO_H264_CPB_CNT_LIST_SIZE]; | ||
| 202 | uint8_t cbr_flag[STD_VIDEO_H264_CPB_CNT_LIST_SIZE]; | ||
| 203 | uint32_t initial_cpb_removal_delay_length_minus1; | ||
| 204 | uint32_t cpb_removal_delay_length_minus1; | ||
| 205 | uint32_t dpb_output_delay_length_minus1; | ||
| 206 | uint32_t time_offset_length; | ||
| 207 | } StdVideoH264HrdParameters; | ||
| 208 | |||
| 209 | typedef struct StdVideoH264SequenceParameterSetVui { | ||
| 210 | StdVideoH264SpsVuiFlags flags; | ||
| 211 | StdVideoH264AspectRatioIdc aspect_ratio_idc; | ||
| 212 | uint16_t sar_width; | ||
| 213 | uint16_t sar_height; | ||
| 214 | uint8_t video_format; | ||
| 215 | uint8_t colour_primaries; | ||
| 216 | uint8_t transfer_characteristics; | ||
| 217 | uint8_t matrix_coefficients; | ||
| 218 | uint32_t num_units_in_tick; | ||
| 219 | uint32_t time_scale; | ||
| 220 | uint8_t max_num_reorder_frames; | ||
| 221 | uint8_t max_dec_frame_buffering; | ||
| 222 | uint8_t chroma_sample_loc_type_top_field; | ||
| 223 | uint8_t chroma_sample_loc_type_bottom_field; | ||
| 224 | uint32_t reserved1; | ||
| 225 | const StdVideoH264HrdParameters* pHrdParameters; | ||
| 226 | } StdVideoH264SequenceParameterSetVui; | ||
| 227 | |||
| 228 | typedef struct StdVideoH264SpsFlags { | ||
| 229 | uint32_t constraint_set0_flag : 1; | ||
| 230 | uint32_t constraint_set1_flag : 1; | ||
| 231 | uint32_t constraint_set2_flag : 1; | ||
| 232 | uint32_t constraint_set3_flag : 1; | ||
| 233 | uint32_t constraint_set4_flag : 1; | ||
| 234 | uint32_t constraint_set5_flag : 1; | ||
| 235 | uint32_t direct_8x8_inference_flag : 1; | ||
| 236 | uint32_t mb_adaptive_frame_field_flag : 1; | ||
| 237 | uint32_t frame_mbs_only_flag : 1; | ||
| 238 | uint32_t delta_pic_order_always_zero_flag : 1; | ||
| 239 | uint32_t separate_colour_plane_flag : 1; | ||
| 240 | uint32_t gaps_in_frame_num_value_allowed_flag : 1; | ||
| 241 | uint32_t qpprime_y_zero_transform_bypass_flag : 1; | ||
| 242 | uint32_t frame_cropping_flag : 1; | ||
| 243 | uint32_t seq_scaling_matrix_present_flag : 1; | ||
| 244 | uint32_t vui_parameters_present_flag : 1; | ||
| 245 | } StdVideoH264SpsFlags; | ||
| 246 | |||
| 247 | typedef struct StdVideoH264ScalingLists { | ||
| 248 | uint16_t scaling_list_present_mask; | ||
| 249 | uint16_t use_default_scaling_matrix_mask; | ||
| 250 | uint8_t ScalingList4x4[STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS][STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS]; | ||
| 251 | uint8_t ScalingList8x8[STD_VIDEO_H264_SCALING_LIST_8X8_NUM_LISTS][STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS]; | ||
| 252 | } StdVideoH264ScalingLists; | ||
| 253 | |||
| 254 | typedef struct StdVideoH264SequenceParameterSet { | ||
| 255 | StdVideoH264SpsFlags flags; | ||
| 256 | StdVideoH264ProfileIdc profile_idc; | ||
| 257 | StdVideoH264LevelIdc level_idc; | ||
| 258 | StdVideoH264ChromaFormatIdc chroma_format_idc; | ||
| 259 | uint8_t seq_parameter_set_id; | ||
| 260 | uint8_t bit_depth_luma_minus8; | ||
| 261 | uint8_t bit_depth_chroma_minus8; | ||
| 262 | uint8_t log2_max_frame_num_minus4; | ||
| 263 | StdVideoH264PocType pic_order_cnt_type; | ||
| 264 | int32_t offset_for_non_ref_pic; | ||
| 265 | int32_t offset_for_top_to_bottom_field; | ||
| 266 | uint8_t log2_max_pic_order_cnt_lsb_minus4; | ||
| 267 | uint8_t num_ref_frames_in_pic_order_cnt_cycle; | ||
| 268 | uint8_t max_num_ref_frames; | ||
| 269 | uint8_t reserved1; | ||
| 270 | uint32_t pic_width_in_mbs_minus1; | ||
| 271 | uint32_t pic_height_in_map_units_minus1; | ||
| 272 | uint32_t frame_crop_left_offset; | ||
| 273 | uint32_t frame_crop_right_offset; | ||
| 274 | uint32_t frame_crop_top_offset; | ||
| 275 | uint32_t frame_crop_bottom_offset; | ||
| 276 | uint32_t reserved2; | ||
| 277 | const int32_t* pOffsetForRefFrame; | ||
| 278 | const StdVideoH264ScalingLists* pScalingLists; | ||
| 279 | const StdVideoH264SequenceParameterSetVui* pSequenceParameterSetVui; | ||
| 280 | } StdVideoH264SequenceParameterSet; | ||
| 281 | |||
| 282 | typedef struct StdVideoH264PpsFlags { | ||
| 283 | uint32_t transform_8x8_mode_flag : 1; | ||
| 284 | uint32_t redundant_pic_cnt_present_flag : 1; | ||
| 285 | uint32_t constrained_intra_pred_flag : 1; | ||
| 286 | uint32_t deblocking_filter_control_present_flag : 1; | ||
| 287 | uint32_t weighted_pred_flag : 1; | ||
| 288 | uint32_t bottom_field_pic_order_in_frame_present_flag : 1; | ||
| 289 | uint32_t entropy_coding_mode_flag : 1; | ||
| 290 | uint32_t pic_scaling_matrix_present_flag : 1; | ||
| 291 | } StdVideoH264PpsFlags; | ||
| 292 | |||
| 293 | typedef struct StdVideoH264PictureParameterSet { | ||
| 294 | StdVideoH264PpsFlags flags; | ||
| 295 | uint8_t seq_parameter_set_id; | ||
| 296 | uint8_t pic_parameter_set_id; | ||
| 297 | uint8_t num_ref_idx_l0_default_active_minus1; | ||
| 298 | uint8_t num_ref_idx_l1_default_active_minus1; | ||
| 299 | StdVideoH264WeightedBipredIdc weighted_bipred_idc; | ||
| 300 | int8_t pic_init_qp_minus26; | ||
| 301 | int8_t pic_init_qs_minus26; | ||
| 302 | int8_t chroma_qp_index_offset; | ||
| 303 | int8_t second_chroma_qp_index_offset; | ||
| 304 | const StdVideoH264ScalingLists* pScalingLists; | ||
| 305 | } StdVideoH264PictureParameterSet; | ||
| 306 | |||
| 307 | |||
| 308 | #ifdef __cplusplus | ||
| 309 | } | ||
| 310 | #endif | ||
| 311 | |||
| 312 | #endif | ||
diff --git a/contrib/SDL-3.2.8/src/video/khronos/vk_video/vulkan_video_codec_h264std_decode.h b/contrib/SDL-3.2.8/src/video/khronos/vk_video/vulkan_video_codec_h264std_decode.h new file mode 100644 index 0000000..439cb88 --- /dev/null +++ b/contrib/SDL-3.2.8/src/video/khronos/vk_video/vulkan_video_codec_h264std_decode.h | |||
| @@ -0,0 +1,77 @@ | |||
| 1 | #ifndef VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ | ||
| 2 | #define VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ 1 | ||
| 3 | |||
| 4 | /* | ||
| 5 | ** Copyright 2015-2024 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 | // vulkan_video_codec_h264std_decode is a preprocessor guard. Do not pass it to API calls. | ||
| 23 | #define vulkan_video_codec_h264std_decode 1 | ||
| 24 | #include "vulkan_video_codec_h264std.h" | ||
| 25 | |||
| 26 | #define VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_API_VERSION_1_0_0 VK_MAKE_VIDEO_STD_VERSION(1, 0, 0) | ||
| 27 | |||
| 28 | #define VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_API_VERSION_1_0_0 | ||
| 29 | #define VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_h264_decode" | ||
| 30 | #define STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE 2 | ||
| 31 | |||
| 32 | typedef enum StdVideoDecodeH264FieldOrderCount { | ||
| 33 | STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_TOP = 0, | ||
| 34 | STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_BOTTOM = 1, | ||
| 35 | STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_INVALID = 0x7FFFFFFF, | ||
| 36 | STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_MAX_ENUM = 0x7FFFFFFF | ||
| 37 | } StdVideoDecodeH264FieldOrderCount; | ||
| 38 | typedef struct StdVideoDecodeH264PictureInfoFlags { | ||
| 39 | uint32_t field_pic_flag : 1; | ||
| 40 | uint32_t is_intra : 1; | ||
| 41 | uint32_t IdrPicFlag : 1; | ||
| 42 | uint32_t bottom_field_flag : 1; | ||
| 43 | uint32_t is_reference : 1; | ||
| 44 | uint32_t complementary_field_pair : 1; | ||
| 45 | } StdVideoDecodeH264PictureInfoFlags; | ||
| 46 | |||
| 47 | typedef struct StdVideoDecodeH264PictureInfo { | ||
| 48 | StdVideoDecodeH264PictureInfoFlags flags; | ||
| 49 | uint8_t seq_parameter_set_id; | ||
| 50 | uint8_t pic_parameter_set_id; | ||
| 51 | uint8_t reserved1; | ||
| 52 | uint8_t reserved2; | ||
| 53 | uint16_t frame_num; | ||
| 54 | uint16_t idr_pic_id; | ||
| 55 | int32_t PicOrderCnt[STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE]; | ||
| 56 | } StdVideoDecodeH264PictureInfo; | ||
| 57 | |||
| 58 | typedef struct StdVideoDecodeH264ReferenceInfoFlags { | ||
| 59 | uint32_t top_field_flag : 1; | ||
| 60 | uint32_t bottom_field_flag : 1; | ||
| 61 | uint32_t used_for_long_term_reference : 1; | ||
| 62 | uint32_t is_non_existing : 1; | ||
| 63 | } StdVideoDecodeH264ReferenceInfoFlags; | ||
| 64 | |||
| 65 | typedef struct StdVideoDecodeH264ReferenceInfo { | ||
| 66 | StdVideoDecodeH264ReferenceInfoFlags flags; | ||
| 67 | uint16_t FrameNum; | ||
| 68 | uint16_t reserved; | ||
| 69 | int32_t PicOrderCnt[STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE]; | ||
| 70 | } StdVideoDecodeH264ReferenceInfo; | ||
| 71 | |||
| 72 | |||
| 73 | #ifdef __cplusplus | ||
| 74 | } | ||
| 75 | #endif | ||
| 76 | |||
| 77 | #endif | ||
diff --git a/contrib/SDL-3.2.8/src/video/khronos/vk_video/vulkan_video_codec_h264std_encode.h b/contrib/SDL-3.2.8/src/video/khronos/vk_video/vulkan_video_codec_h264std_encode.h new file mode 100644 index 0000000..9e24aa5 --- /dev/null +++ b/contrib/SDL-3.2.8/src/video/khronos/vk_video/vulkan_video_codec_h264std_encode.h | |||
| @@ -0,0 +1,147 @@ | |||
| 1 | #ifndef VULKAN_VIDEO_CODEC_H264STD_ENCODE_H_ | ||
| 2 | #define VULKAN_VIDEO_CODEC_H264STD_ENCODE_H_ 1 | ||
| 3 | |||
| 4 | /* | ||
| 5 | ** Copyright 2015-2024 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 | // vulkan_video_codec_h264std_encode is a preprocessor guard. Do not pass it to API calls. | ||
| 23 | #define vulkan_video_codec_h264std_encode 1 | ||
| 24 | #include "vulkan_video_codec_h264std.h" | ||
| 25 | |||
| 26 | #define VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_API_VERSION_1_0_0 VK_MAKE_VIDEO_STD_VERSION(1, 0, 0) | ||
| 27 | |||
| 28 | #define VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_API_VERSION_1_0_0 | ||
| 29 | #define VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_h264_encode" | ||
| 30 | typedef struct StdVideoEncodeH264WeightTableFlags { | ||
| 31 | uint32_t luma_weight_l0_flag; | ||
| 32 | uint32_t chroma_weight_l0_flag; | ||
| 33 | uint32_t luma_weight_l1_flag; | ||
| 34 | uint32_t chroma_weight_l1_flag; | ||
| 35 | } StdVideoEncodeH264WeightTableFlags; | ||
| 36 | |||
| 37 | typedef struct StdVideoEncodeH264WeightTable { | ||
| 38 | StdVideoEncodeH264WeightTableFlags flags; | ||
| 39 | uint8_t luma_log2_weight_denom; | ||
| 40 | uint8_t chroma_log2_weight_denom; | ||
| 41 | int8_t luma_weight_l0[STD_VIDEO_H264_MAX_NUM_LIST_REF]; | ||
| 42 | int8_t luma_offset_l0[STD_VIDEO_H264_MAX_NUM_LIST_REF]; | ||
| 43 | int8_t chroma_weight_l0[STD_VIDEO_H264_MAX_NUM_LIST_REF][STD_VIDEO_H264_MAX_CHROMA_PLANES]; | ||
| 44 | int8_t chroma_offset_l0[STD_VIDEO_H264_MAX_NUM_LIST_REF][STD_VIDEO_H264_MAX_CHROMA_PLANES]; | ||
| 45 | int8_t luma_weight_l1[STD_VIDEO_H264_MAX_NUM_LIST_REF]; | ||
| 46 | int8_t luma_offset_l1[STD_VIDEO_H264_MAX_NUM_LIST_REF]; | ||
| 47 | int8_t chroma_weight_l1[STD_VIDEO_H264_MAX_NUM_LIST_REF][STD_VIDEO_H264_MAX_CHROMA_PLANES]; | ||
| 48 | int8_t chroma_offset_l1[STD_VIDEO_H264_MAX_NUM_LIST_REF][STD_VIDEO_H264_MAX_CHROMA_PLANES]; | ||
| 49 | } StdVideoEncodeH264WeightTable; | ||
| 50 | |||
| 51 | typedef struct StdVideoEncodeH264SliceHeaderFlags { | ||
| 52 | uint32_t direct_spatial_mv_pred_flag : 1; | ||
| 53 | uint32_t num_ref_idx_active_override_flag : 1; | ||
| 54 | uint32_t reserved : 30; | ||
| 55 | } StdVideoEncodeH264SliceHeaderFlags; | ||
| 56 | |||
| 57 | typedef struct StdVideoEncodeH264PictureInfoFlags { | ||
| 58 | uint32_t IdrPicFlag : 1; | ||
| 59 | uint32_t is_reference : 1; | ||
| 60 | uint32_t no_output_of_prior_pics_flag : 1; | ||
| 61 | uint32_t long_term_reference_flag : 1; | ||
| 62 | uint32_t adaptive_ref_pic_marking_mode_flag : 1; | ||
| 63 | uint32_t reserved : 27; | ||
| 64 | } StdVideoEncodeH264PictureInfoFlags; | ||
| 65 | |||
| 66 | typedef struct StdVideoEncodeH264ReferenceInfoFlags { | ||
| 67 | uint32_t used_for_long_term_reference : 1; | ||
| 68 | uint32_t reserved : 31; | ||
| 69 | } StdVideoEncodeH264ReferenceInfoFlags; | ||
| 70 | |||
| 71 | typedef struct StdVideoEncodeH264ReferenceListsInfoFlags { | ||
| 72 | uint32_t ref_pic_list_modification_flag_l0 : 1; | ||
| 73 | uint32_t ref_pic_list_modification_flag_l1 : 1; | ||
| 74 | uint32_t reserved : 30; | ||
| 75 | } StdVideoEncodeH264ReferenceListsInfoFlags; | ||
| 76 | |||
| 77 | typedef struct StdVideoEncodeH264RefListModEntry { | ||
| 78 | StdVideoH264ModificationOfPicNumsIdc modification_of_pic_nums_idc; | ||
| 79 | uint16_t abs_diff_pic_num_minus1; | ||
| 80 | uint16_t long_term_pic_num; | ||
| 81 | } StdVideoEncodeH264RefListModEntry; | ||
| 82 | |||
| 83 | typedef struct StdVideoEncodeH264RefPicMarkingEntry { | ||
| 84 | StdVideoH264MemMgmtControlOp memory_management_control_operation; | ||
| 85 | uint16_t difference_of_pic_nums_minus1; | ||
| 86 | uint16_t long_term_pic_num; | ||
| 87 | uint16_t long_term_frame_idx; | ||
| 88 | uint16_t max_long_term_frame_idx_plus1; | ||
| 89 | } StdVideoEncodeH264RefPicMarkingEntry; | ||
| 90 | |||
| 91 | typedef struct StdVideoEncodeH264ReferenceListsInfo { | ||
| 92 | StdVideoEncodeH264ReferenceListsInfoFlags flags; | ||
| 93 | uint8_t num_ref_idx_l0_active_minus1; | ||
| 94 | uint8_t num_ref_idx_l1_active_minus1; | ||
| 95 | uint8_t RefPicList0[STD_VIDEO_H264_MAX_NUM_LIST_REF]; | ||
| 96 | uint8_t RefPicList1[STD_VIDEO_H264_MAX_NUM_LIST_REF]; | ||
| 97 | uint8_t refList0ModOpCount; | ||
| 98 | uint8_t refList1ModOpCount; | ||
| 99 | uint8_t refPicMarkingOpCount; | ||
| 100 | uint8_t reserved1[7]; | ||
| 101 | const StdVideoEncodeH264RefListModEntry* pRefList0ModOperations; | ||
| 102 | const StdVideoEncodeH264RefListModEntry* pRefList1ModOperations; | ||
| 103 | const StdVideoEncodeH264RefPicMarkingEntry* pRefPicMarkingOperations; | ||
| 104 | } StdVideoEncodeH264ReferenceListsInfo; | ||
| 105 | |||
| 106 | typedef struct StdVideoEncodeH264PictureInfo { | ||
| 107 | StdVideoEncodeH264PictureInfoFlags flags; | ||
| 108 | uint8_t seq_parameter_set_id; | ||
| 109 | uint8_t pic_parameter_set_id; | ||
| 110 | uint16_t idr_pic_id; | ||
| 111 | StdVideoH264PictureType primary_pic_type; | ||
| 112 | uint32_t frame_num; | ||
| 113 | int32_t PicOrderCnt; | ||
| 114 | uint8_t temporal_id; | ||
| 115 | uint8_t reserved1[3]; | ||
| 116 | const StdVideoEncodeH264ReferenceListsInfo* pRefLists; | ||
| 117 | } StdVideoEncodeH264PictureInfo; | ||
| 118 | |||
| 119 | typedef struct StdVideoEncodeH264ReferenceInfo { | ||
| 120 | StdVideoEncodeH264ReferenceInfoFlags flags; | ||
| 121 | StdVideoH264PictureType primary_pic_type; | ||
| 122 | uint32_t FrameNum; | ||
| 123 | int32_t PicOrderCnt; | ||
| 124 | uint16_t long_term_pic_num; | ||
| 125 | uint16_t long_term_frame_idx; | ||
| 126 | uint8_t temporal_id; | ||
| 127 | } StdVideoEncodeH264ReferenceInfo; | ||
| 128 | |||
| 129 | typedef struct StdVideoEncodeH264SliceHeader { | ||
| 130 | StdVideoEncodeH264SliceHeaderFlags flags; | ||
| 131 | uint32_t first_mb_in_slice; | ||
| 132 | StdVideoH264SliceType slice_type; | ||
| 133 | int8_t slice_alpha_c0_offset_div2; | ||
| 134 | int8_t slice_beta_offset_div2; | ||
| 135 | int8_t slice_qp_delta; | ||
| 136 | uint8_t reserved1; | ||
| 137 | StdVideoH264CabacInitIdc cabac_init_idc; | ||
| 138 | StdVideoH264DisableDeblockingFilterIdc disable_deblocking_filter_idc; | ||
| 139 | const StdVideoEncodeH264WeightTable* pWeightTable; | ||
| 140 | } StdVideoEncodeH264SliceHeader; | ||
| 141 | |||
| 142 | |||
| 143 | #ifdef __cplusplus | ||
| 144 | } | ||
| 145 | #endif | ||
| 146 | |||
| 147 | #endif | ||
diff --git a/contrib/SDL-3.2.8/src/video/khronos/vk_video/vulkan_video_codec_h265std.h b/contrib/SDL-3.2.8/src/video/khronos/vk_video/vulkan_video_codec_h265std.h new file mode 100644 index 0000000..d0a1bac --- /dev/null +++ b/contrib/SDL-3.2.8/src/video/khronos/vk_video/vulkan_video_codec_h265std.h | |||
| @@ -0,0 +1,446 @@ | |||
| 1 | #ifndef VULKAN_VIDEO_CODEC_H265STD_H_ | ||
| 2 | #define VULKAN_VIDEO_CODEC_H265STD_H_ 1 | ||
| 3 | |||
| 4 | /* | ||
| 5 | ** Copyright 2015-2024 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 | // vulkan_video_codec_h265std is a preprocessor guard. Do not pass it to API calls. | ||
| 23 | #define vulkan_video_codec_h265std 1 | ||
| 24 | #include "vulkan_video_codecs_common.h" | ||
| 25 | #define STD_VIDEO_H265_CPB_CNT_LIST_SIZE 32 | ||
| 26 | #define STD_VIDEO_H265_SUBLAYERS_LIST_SIZE 7 | ||
| 27 | #define STD_VIDEO_H265_SCALING_LIST_4X4_NUM_LISTS 6 | ||
| 28 | #define STD_VIDEO_H265_SCALING_LIST_4X4_NUM_ELEMENTS 16 | ||
| 29 | #define STD_VIDEO_H265_SCALING_LIST_8X8_NUM_LISTS 6 | ||
| 30 | #define STD_VIDEO_H265_SCALING_LIST_8X8_NUM_ELEMENTS 64 | ||
| 31 | #define STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS 6 | ||
| 32 | #define STD_VIDEO_H265_SCALING_LIST_16X16_NUM_ELEMENTS 64 | ||
| 33 | #define STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS 2 | ||
| 34 | #define STD_VIDEO_H265_SCALING_LIST_32X32_NUM_ELEMENTS 64 | ||
| 35 | #define STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE 6 | ||
| 36 | #define STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE 19 | ||
| 37 | #define STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE 21 | ||
| 38 | #define STD_VIDEO_H265_PREDICTOR_PALETTE_COMPONENTS_LIST_SIZE 3 | ||
| 39 | #define STD_VIDEO_H265_PREDICTOR_PALETTE_COMP_ENTRIES_LIST_SIZE 128 | ||
| 40 | #define STD_VIDEO_H265_MAX_NUM_LIST_REF 15 | ||
| 41 | #define STD_VIDEO_H265_MAX_CHROMA_PLANES 2 | ||
| 42 | #define STD_VIDEO_H265_MAX_SHORT_TERM_REF_PIC_SETS 64 | ||
| 43 | #define STD_VIDEO_H265_MAX_DPB_SIZE 16 | ||
| 44 | #define STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS 32 | ||
| 45 | #define STD_VIDEO_H265_MAX_LONG_TERM_PICS 16 | ||
| 46 | #define STD_VIDEO_H265_MAX_DELTA_POC 48 | ||
| 47 | #define STD_VIDEO_H265_NO_REFERENCE_PICTURE 0xFF | ||
| 48 | |||
| 49 | typedef enum StdVideoH265ChromaFormatIdc { | ||
| 50 | STD_VIDEO_H265_CHROMA_FORMAT_IDC_MONOCHROME = 0, | ||
| 51 | STD_VIDEO_H265_CHROMA_FORMAT_IDC_420 = 1, | ||
| 52 | STD_VIDEO_H265_CHROMA_FORMAT_IDC_422 = 2, | ||
| 53 | STD_VIDEO_H265_CHROMA_FORMAT_IDC_444 = 3, | ||
| 54 | STD_VIDEO_H265_CHROMA_FORMAT_IDC_INVALID = 0x7FFFFFFF, | ||
| 55 | STD_VIDEO_H265_CHROMA_FORMAT_IDC_MAX_ENUM = 0x7FFFFFFF | ||
| 56 | } StdVideoH265ChromaFormatIdc; | ||
| 57 | |||
| 58 | typedef enum StdVideoH265ProfileIdc { | ||
| 59 | STD_VIDEO_H265_PROFILE_IDC_MAIN = 1, | ||
| 60 | STD_VIDEO_H265_PROFILE_IDC_MAIN_10 = 2, | ||
| 61 | STD_VIDEO_H265_PROFILE_IDC_MAIN_STILL_PICTURE = 3, | ||
| 62 | STD_VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS = 4, | ||
| 63 | STD_VIDEO_H265_PROFILE_IDC_SCC_EXTENSIONS = 9, | ||
| 64 | STD_VIDEO_H265_PROFILE_IDC_INVALID = 0x7FFFFFFF, | ||
| 65 | STD_VIDEO_H265_PROFILE_IDC_MAX_ENUM = 0x7FFFFFFF | ||
| 66 | } StdVideoH265ProfileIdc; | ||
| 67 | |||
| 68 | typedef enum StdVideoH265LevelIdc { | ||
| 69 | STD_VIDEO_H265_LEVEL_IDC_1_0 = 0, | ||
| 70 | STD_VIDEO_H265_LEVEL_IDC_2_0 = 1, | ||
| 71 | STD_VIDEO_H265_LEVEL_IDC_2_1 = 2, | ||
| 72 | STD_VIDEO_H265_LEVEL_IDC_3_0 = 3, | ||
| 73 | STD_VIDEO_H265_LEVEL_IDC_3_1 = 4, | ||
| 74 | STD_VIDEO_H265_LEVEL_IDC_4_0 = 5, | ||
| 75 | STD_VIDEO_H265_LEVEL_IDC_4_1 = 6, | ||
| 76 | STD_VIDEO_H265_LEVEL_IDC_5_0 = 7, | ||
| 77 | STD_VIDEO_H265_LEVEL_IDC_5_1 = 8, | ||
| 78 | STD_VIDEO_H265_LEVEL_IDC_5_2 = 9, | ||
| 79 | STD_VIDEO_H265_LEVEL_IDC_6_0 = 10, | ||
| 80 | STD_VIDEO_H265_LEVEL_IDC_6_1 = 11, | ||
| 81 | STD_VIDEO_H265_LEVEL_IDC_6_2 = 12, | ||
| 82 | STD_VIDEO_H265_LEVEL_IDC_INVALID = 0x7FFFFFFF, | ||
| 83 | STD_VIDEO_H265_LEVEL_IDC_MAX_ENUM = 0x7FFFFFFF | ||
| 84 | } StdVideoH265LevelIdc; | ||
| 85 | |||
| 86 | typedef enum StdVideoH265SliceType { | ||
| 87 | STD_VIDEO_H265_SLICE_TYPE_B = 0, | ||
| 88 | STD_VIDEO_H265_SLICE_TYPE_P = 1, | ||
| 89 | STD_VIDEO_H265_SLICE_TYPE_I = 2, | ||
| 90 | STD_VIDEO_H265_SLICE_TYPE_INVALID = 0x7FFFFFFF, | ||
| 91 | STD_VIDEO_H265_SLICE_TYPE_MAX_ENUM = 0x7FFFFFFF | ||
| 92 | } StdVideoH265SliceType; | ||
| 93 | |||
| 94 | typedef enum StdVideoH265PictureType { | ||
| 95 | STD_VIDEO_H265_PICTURE_TYPE_P = 0, | ||
| 96 | STD_VIDEO_H265_PICTURE_TYPE_B = 1, | ||
| 97 | STD_VIDEO_H265_PICTURE_TYPE_I = 2, | ||
| 98 | STD_VIDEO_H265_PICTURE_TYPE_IDR = 3, | ||
| 99 | STD_VIDEO_H265_PICTURE_TYPE_INVALID = 0x7FFFFFFF, | ||
| 100 | STD_VIDEO_H265_PICTURE_TYPE_MAX_ENUM = 0x7FFFFFFF | ||
| 101 | } StdVideoH265PictureType; | ||
| 102 | |||
| 103 | typedef enum StdVideoH265AspectRatioIdc { | ||
| 104 | STD_VIDEO_H265_ASPECT_RATIO_IDC_UNSPECIFIED = 0, | ||
| 105 | STD_VIDEO_H265_ASPECT_RATIO_IDC_SQUARE = 1, | ||
| 106 | STD_VIDEO_H265_ASPECT_RATIO_IDC_12_11 = 2, | ||
| 107 | STD_VIDEO_H265_ASPECT_RATIO_IDC_10_11 = 3, | ||
| 108 | STD_VIDEO_H265_ASPECT_RATIO_IDC_16_11 = 4, | ||
| 109 | STD_VIDEO_H265_ASPECT_RATIO_IDC_40_33 = 5, | ||
| 110 | STD_VIDEO_H265_ASPECT_RATIO_IDC_24_11 = 6, | ||
| 111 | STD_VIDEO_H265_ASPECT_RATIO_IDC_20_11 = 7, | ||
| 112 | STD_VIDEO_H265_ASPECT_RATIO_IDC_32_11 = 8, | ||
| 113 | STD_VIDEO_H265_ASPECT_RATIO_IDC_80_33 = 9, | ||
| 114 | STD_VIDEO_H265_ASPECT_RATIO_IDC_18_11 = 10, | ||
| 115 | STD_VIDEO_H265_ASPECT_RATIO_IDC_15_11 = 11, | ||
| 116 | STD_VIDEO_H265_ASPECT_RATIO_IDC_64_33 = 12, | ||
| 117 | STD_VIDEO_H265_ASPECT_RATIO_IDC_160_99 = 13, | ||
| 118 | STD_VIDEO_H265_ASPECT_RATIO_IDC_4_3 = 14, | ||
| 119 | STD_VIDEO_H265_ASPECT_RATIO_IDC_3_2 = 15, | ||
| 120 | STD_VIDEO_H265_ASPECT_RATIO_IDC_2_1 = 16, | ||
| 121 | STD_VIDEO_H265_ASPECT_RATIO_IDC_EXTENDED_SAR = 255, | ||
| 122 | STD_VIDEO_H265_ASPECT_RATIO_IDC_INVALID = 0x7FFFFFFF, | ||
| 123 | STD_VIDEO_H265_ASPECT_RATIO_IDC_MAX_ENUM = 0x7FFFFFFF | ||
| 124 | } StdVideoH265AspectRatioIdc; | ||
| 125 | typedef struct StdVideoH265DecPicBufMgr { | ||
| 126 | uint32_t max_latency_increase_plus1[STD_VIDEO_H265_SUBLAYERS_LIST_SIZE]; | ||
| 127 | uint8_t max_dec_pic_buffering_minus1[STD_VIDEO_H265_SUBLAYERS_LIST_SIZE]; | ||
| 128 | uint8_t max_num_reorder_pics[STD_VIDEO_H265_SUBLAYERS_LIST_SIZE]; | ||
| 129 | } StdVideoH265DecPicBufMgr; | ||
| 130 | |||
| 131 | typedef struct StdVideoH265SubLayerHrdParameters { | ||
| 132 | uint32_t bit_rate_value_minus1[STD_VIDEO_H265_CPB_CNT_LIST_SIZE]; | ||
| 133 | uint32_t cpb_size_value_minus1[STD_VIDEO_H265_CPB_CNT_LIST_SIZE]; | ||
| 134 | uint32_t cpb_size_du_value_minus1[STD_VIDEO_H265_CPB_CNT_LIST_SIZE]; | ||
| 135 | uint32_t bit_rate_du_value_minus1[STD_VIDEO_H265_CPB_CNT_LIST_SIZE]; | ||
| 136 | uint32_t cbr_flag; | ||
| 137 | } StdVideoH265SubLayerHrdParameters; | ||
| 138 | |||
| 139 | typedef struct StdVideoH265HrdFlags { | ||
| 140 | uint32_t nal_hrd_parameters_present_flag : 1; | ||
| 141 | uint32_t vcl_hrd_parameters_present_flag : 1; | ||
| 142 | uint32_t sub_pic_hrd_params_present_flag : 1; | ||
| 143 | uint32_t sub_pic_cpb_params_in_pic_timing_sei_flag : 1; | ||
| 144 | uint32_t fixed_pic_rate_general_flag : 8; | ||
| 145 | uint32_t fixed_pic_rate_within_cvs_flag : 8; | ||
| 146 | uint32_t low_delay_hrd_flag : 8; | ||
| 147 | } StdVideoH265HrdFlags; | ||
| 148 | |||
| 149 | typedef struct StdVideoH265HrdParameters { | ||
| 150 | StdVideoH265HrdFlags flags; | ||
| 151 | uint8_t tick_divisor_minus2; | ||
| 152 | uint8_t du_cpb_removal_delay_increment_length_minus1; | ||
| 153 | uint8_t dpb_output_delay_du_length_minus1; | ||
| 154 | uint8_t bit_rate_scale; | ||
| 155 | uint8_t cpb_size_scale; | ||
| 156 | uint8_t cpb_size_du_scale; | ||
| 157 | uint8_t initial_cpb_removal_delay_length_minus1; | ||
| 158 | uint8_t au_cpb_removal_delay_length_minus1; | ||
| 159 | uint8_t dpb_output_delay_length_minus1; | ||
| 160 | uint8_t cpb_cnt_minus1[STD_VIDEO_H265_SUBLAYERS_LIST_SIZE]; | ||
| 161 | uint16_t elemental_duration_in_tc_minus1[STD_VIDEO_H265_SUBLAYERS_LIST_SIZE]; | ||
| 162 | uint16_t reserved[3]; | ||
| 163 | const StdVideoH265SubLayerHrdParameters* pSubLayerHrdParametersNal; | ||
| 164 | const StdVideoH265SubLayerHrdParameters* pSubLayerHrdParametersVcl; | ||
| 165 | } StdVideoH265HrdParameters; | ||
| 166 | |||
| 167 | typedef struct StdVideoH265VpsFlags { | ||
| 168 | uint32_t vps_temporal_id_nesting_flag : 1; | ||
| 169 | uint32_t vps_sub_layer_ordering_info_present_flag : 1; | ||
| 170 | uint32_t vps_timing_info_present_flag : 1; | ||
| 171 | uint32_t vps_poc_proportional_to_timing_flag : 1; | ||
| 172 | } StdVideoH265VpsFlags; | ||
| 173 | |||
| 174 | typedef struct StdVideoH265ProfileTierLevelFlags { | ||
| 175 | uint32_t general_tier_flag : 1; | ||
| 176 | uint32_t general_progressive_source_flag : 1; | ||
| 177 | uint32_t general_interlaced_source_flag : 1; | ||
| 178 | uint32_t general_non_packed_constraint_flag : 1; | ||
| 179 | uint32_t general_frame_only_constraint_flag : 1; | ||
| 180 | } StdVideoH265ProfileTierLevelFlags; | ||
| 181 | |||
| 182 | typedef struct StdVideoH265ProfileTierLevel { | ||
| 183 | StdVideoH265ProfileTierLevelFlags flags; | ||
| 184 | StdVideoH265ProfileIdc general_profile_idc; | ||
| 185 | StdVideoH265LevelIdc general_level_idc; | ||
| 186 | } StdVideoH265ProfileTierLevel; | ||
| 187 | |||
| 188 | typedef struct StdVideoH265VideoParameterSet { | ||
| 189 | StdVideoH265VpsFlags flags; | ||
| 190 | uint8_t vps_video_parameter_set_id; | ||
| 191 | uint8_t vps_max_sub_layers_minus1; | ||
| 192 | uint8_t reserved1; | ||
| 193 | uint8_t reserved2; | ||
| 194 | uint32_t vps_num_units_in_tick; | ||
| 195 | uint32_t vps_time_scale; | ||
| 196 | uint32_t vps_num_ticks_poc_diff_one_minus1; | ||
| 197 | uint32_t reserved3; | ||
| 198 | const StdVideoH265DecPicBufMgr* pDecPicBufMgr; | ||
| 199 | const StdVideoH265HrdParameters* pHrdParameters; | ||
| 200 | const StdVideoH265ProfileTierLevel* pProfileTierLevel; | ||
| 201 | } StdVideoH265VideoParameterSet; | ||
| 202 | |||
| 203 | typedef struct StdVideoH265ScalingLists { | ||
| 204 | uint8_t ScalingList4x4[STD_VIDEO_H265_SCALING_LIST_4X4_NUM_LISTS][STD_VIDEO_H265_SCALING_LIST_4X4_NUM_ELEMENTS]; | ||
| 205 | uint8_t ScalingList8x8[STD_VIDEO_H265_SCALING_LIST_8X8_NUM_LISTS][STD_VIDEO_H265_SCALING_LIST_8X8_NUM_ELEMENTS]; | ||
| 206 | uint8_t ScalingList16x16[STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS][STD_VIDEO_H265_SCALING_LIST_16X16_NUM_ELEMENTS]; | ||
| 207 | uint8_t ScalingList32x32[STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS][STD_VIDEO_H265_SCALING_LIST_32X32_NUM_ELEMENTS]; | ||
| 208 | uint8_t ScalingListDCCoef16x16[STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS]; | ||
| 209 | uint8_t ScalingListDCCoef32x32[STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS]; | ||
| 210 | } StdVideoH265ScalingLists; | ||
| 211 | |||
| 212 | typedef struct StdVideoH265SpsVuiFlags { | ||
| 213 | uint32_t aspect_ratio_info_present_flag : 1; | ||
| 214 | uint32_t overscan_info_present_flag : 1; | ||
| 215 | uint32_t overscan_appropriate_flag : 1; | ||
| 216 | uint32_t video_signal_type_present_flag : 1; | ||
| 217 | uint32_t video_full_range_flag : 1; | ||
| 218 | uint32_t colour_description_present_flag : 1; | ||
| 219 | uint32_t chroma_loc_info_present_flag : 1; | ||
| 220 | uint32_t neutral_chroma_indication_flag : 1; | ||
| 221 | uint32_t field_seq_flag : 1; | ||
| 222 | uint32_t frame_field_info_present_flag : 1; | ||
| 223 | uint32_t default_display_window_flag : 1; | ||
| 224 | uint32_t vui_timing_info_present_flag : 1; | ||
| 225 | uint32_t vui_poc_proportional_to_timing_flag : 1; | ||
| 226 | uint32_t vui_hrd_parameters_present_flag : 1; | ||
| 227 | uint32_t bitstream_restriction_flag : 1; | ||
| 228 | uint32_t tiles_fixed_structure_flag : 1; | ||
| 229 | uint32_t motion_vectors_over_pic_boundaries_flag : 1; | ||
| 230 | uint32_t restricted_ref_pic_lists_flag : 1; | ||
| 231 | } StdVideoH265SpsVuiFlags; | ||
| 232 | |||
| 233 | typedef struct StdVideoH265SequenceParameterSetVui { | ||
| 234 | StdVideoH265SpsVuiFlags flags; | ||
| 235 | StdVideoH265AspectRatioIdc aspect_ratio_idc; | ||
| 236 | uint16_t sar_width; | ||
| 237 | uint16_t sar_height; | ||
| 238 | uint8_t video_format; | ||
| 239 | uint8_t colour_primaries; | ||
| 240 | uint8_t transfer_characteristics; | ||
| 241 | uint8_t matrix_coeffs; | ||
| 242 | uint8_t chroma_sample_loc_type_top_field; | ||
| 243 | uint8_t chroma_sample_loc_type_bottom_field; | ||
| 244 | uint8_t reserved1; | ||
| 245 | uint8_t reserved2; | ||
| 246 | uint16_t def_disp_win_left_offset; | ||
| 247 | uint16_t def_disp_win_right_offset; | ||
| 248 | uint16_t def_disp_win_top_offset; | ||
| 249 | uint16_t def_disp_win_bottom_offset; | ||
| 250 | uint32_t vui_num_units_in_tick; | ||
| 251 | uint32_t vui_time_scale; | ||
| 252 | uint32_t vui_num_ticks_poc_diff_one_minus1; | ||
| 253 | uint16_t min_spatial_segmentation_idc; | ||
| 254 | uint16_t reserved3; | ||
| 255 | uint8_t max_bytes_per_pic_denom; | ||
| 256 | uint8_t max_bits_per_min_cu_denom; | ||
| 257 | uint8_t log2_max_mv_length_horizontal; | ||
| 258 | uint8_t log2_max_mv_length_vertical; | ||
| 259 | const StdVideoH265HrdParameters* pHrdParameters; | ||
| 260 | } StdVideoH265SequenceParameterSetVui; | ||
| 261 | |||
| 262 | typedef struct StdVideoH265PredictorPaletteEntries { | ||
| 263 | uint16_t PredictorPaletteEntries[STD_VIDEO_H265_PREDICTOR_PALETTE_COMPONENTS_LIST_SIZE][STD_VIDEO_H265_PREDICTOR_PALETTE_COMP_ENTRIES_LIST_SIZE]; | ||
| 264 | } StdVideoH265PredictorPaletteEntries; | ||
| 265 | |||
| 266 | typedef struct StdVideoH265SpsFlags { | ||
| 267 | uint32_t sps_temporal_id_nesting_flag : 1; | ||
| 268 | uint32_t separate_colour_plane_flag : 1; | ||
| 269 | uint32_t conformance_window_flag : 1; | ||
| 270 | uint32_t sps_sub_layer_ordering_info_present_flag : 1; | ||
| 271 | uint32_t scaling_list_enabled_flag : 1; | ||
| 272 | uint32_t sps_scaling_list_data_present_flag : 1; | ||
| 273 | uint32_t amp_enabled_flag : 1; | ||
| 274 | uint32_t sample_adaptive_offset_enabled_flag : 1; | ||
| 275 | uint32_t pcm_enabled_flag : 1; | ||
| 276 | uint32_t pcm_loop_filter_disabled_flag : 1; | ||
| 277 | uint32_t long_term_ref_pics_present_flag : 1; | ||
| 278 | uint32_t sps_temporal_mvp_enabled_flag : 1; | ||
| 279 | uint32_t strong_intra_smoothing_enabled_flag : 1; | ||
| 280 | uint32_t vui_parameters_present_flag : 1; | ||
| 281 | uint32_t sps_extension_present_flag : 1; | ||
| 282 | uint32_t sps_range_extension_flag : 1; | ||
| 283 | uint32_t transform_skip_rotation_enabled_flag : 1; | ||
| 284 | uint32_t transform_skip_context_enabled_flag : 1; | ||
| 285 | uint32_t implicit_rdpcm_enabled_flag : 1; | ||
| 286 | uint32_t explicit_rdpcm_enabled_flag : 1; | ||
| 287 | uint32_t extended_precision_processing_flag : 1; | ||
| 288 | uint32_t intra_smoothing_disabled_flag : 1; | ||
| 289 | uint32_t high_precision_offsets_enabled_flag : 1; | ||
| 290 | uint32_t persistent_rice_adaptation_enabled_flag : 1; | ||
| 291 | uint32_t cabac_bypass_alignment_enabled_flag : 1; | ||
| 292 | uint32_t sps_scc_extension_flag : 1; | ||
| 293 | uint32_t sps_curr_pic_ref_enabled_flag : 1; | ||
| 294 | uint32_t palette_mode_enabled_flag : 1; | ||
| 295 | uint32_t sps_palette_predictor_initializers_present_flag : 1; | ||
| 296 | uint32_t intra_boundary_filtering_disabled_flag : 1; | ||
| 297 | } StdVideoH265SpsFlags; | ||
| 298 | |||
| 299 | typedef struct StdVideoH265ShortTermRefPicSetFlags { | ||
| 300 | uint32_t inter_ref_pic_set_prediction_flag : 1; | ||
| 301 | uint32_t delta_rps_sign : 1; | ||
| 302 | } StdVideoH265ShortTermRefPicSetFlags; | ||
| 303 | |||
| 304 | typedef struct StdVideoH265ShortTermRefPicSet { | ||
| 305 | StdVideoH265ShortTermRefPicSetFlags flags; | ||
| 306 | uint32_t delta_idx_minus1; | ||
| 307 | uint16_t use_delta_flag; | ||
| 308 | uint16_t abs_delta_rps_minus1; | ||
| 309 | uint16_t used_by_curr_pic_flag; | ||
| 310 | uint16_t used_by_curr_pic_s0_flag; | ||
| 311 | uint16_t used_by_curr_pic_s1_flag; | ||
| 312 | uint16_t reserved1; | ||
| 313 | uint8_t reserved2; | ||
| 314 | uint8_t reserved3; | ||
| 315 | uint8_t num_negative_pics; | ||
| 316 | uint8_t num_positive_pics; | ||
| 317 | uint16_t delta_poc_s0_minus1[STD_VIDEO_H265_MAX_DPB_SIZE]; | ||
| 318 | uint16_t delta_poc_s1_minus1[STD_VIDEO_H265_MAX_DPB_SIZE]; | ||
| 319 | } StdVideoH265ShortTermRefPicSet; | ||
| 320 | |||
| 321 | typedef struct StdVideoH265LongTermRefPicsSps { | ||
| 322 | uint32_t used_by_curr_pic_lt_sps_flag; | ||
| 323 | uint32_t lt_ref_pic_poc_lsb_sps[STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS]; | ||
| 324 | } StdVideoH265LongTermRefPicsSps; | ||
| 325 | |||
| 326 | typedef struct StdVideoH265SequenceParameterSet { | ||
| 327 | StdVideoH265SpsFlags flags; | ||
| 328 | StdVideoH265ChromaFormatIdc chroma_format_idc; | ||
| 329 | uint32_t pic_width_in_luma_samples; | ||
| 330 | uint32_t pic_height_in_luma_samples; | ||
| 331 | uint8_t sps_video_parameter_set_id; | ||
| 332 | uint8_t sps_max_sub_layers_minus1; | ||
| 333 | uint8_t sps_seq_parameter_set_id; | ||
| 334 | uint8_t bit_depth_luma_minus8; | ||
| 335 | uint8_t bit_depth_chroma_minus8; | ||
| 336 | uint8_t log2_max_pic_order_cnt_lsb_minus4; | ||
| 337 | uint8_t log2_min_luma_coding_block_size_minus3; | ||
| 338 | uint8_t log2_diff_max_min_luma_coding_block_size; | ||
| 339 | uint8_t log2_min_luma_transform_block_size_minus2; | ||
| 340 | uint8_t log2_diff_max_min_luma_transform_block_size; | ||
| 341 | uint8_t max_transform_hierarchy_depth_inter; | ||
| 342 | uint8_t max_transform_hierarchy_depth_intra; | ||
| 343 | uint8_t num_short_term_ref_pic_sets; | ||
| 344 | uint8_t num_long_term_ref_pics_sps; | ||
| 345 | uint8_t pcm_sample_bit_depth_luma_minus1; | ||
| 346 | uint8_t pcm_sample_bit_depth_chroma_minus1; | ||
| 347 | uint8_t log2_min_pcm_luma_coding_block_size_minus3; | ||
| 348 | uint8_t log2_diff_max_min_pcm_luma_coding_block_size; | ||
| 349 | uint8_t reserved1; | ||
| 350 | uint8_t reserved2; | ||
| 351 | uint8_t palette_max_size; | ||
| 352 | uint8_t delta_palette_max_predictor_size; | ||
| 353 | uint8_t motion_vector_resolution_control_idc; | ||
| 354 | uint8_t sps_num_palette_predictor_initializers_minus1; | ||
| 355 | uint32_t conf_win_left_offset; | ||
| 356 | uint32_t conf_win_right_offset; | ||
| 357 | uint32_t conf_win_top_offset; | ||
| 358 | uint32_t conf_win_bottom_offset; | ||
| 359 | const StdVideoH265ProfileTierLevel* pProfileTierLevel; | ||
| 360 | const StdVideoH265DecPicBufMgr* pDecPicBufMgr; | ||
| 361 | const StdVideoH265ScalingLists* pScalingLists; | ||
| 362 | const StdVideoH265ShortTermRefPicSet* pShortTermRefPicSet; | ||
| 363 | const StdVideoH265LongTermRefPicsSps* pLongTermRefPicsSps; | ||
| 364 | const StdVideoH265SequenceParameterSetVui* pSequenceParameterSetVui; | ||
| 365 | const StdVideoH265PredictorPaletteEntries* pPredictorPaletteEntries; | ||
| 366 | } StdVideoH265SequenceParameterSet; | ||
| 367 | |||
| 368 | typedef struct StdVideoH265PpsFlags { | ||
| 369 | uint32_t dependent_slice_segments_enabled_flag : 1; | ||
| 370 | uint32_t output_flag_present_flag : 1; | ||
| 371 | uint32_t sign_data_hiding_enabled_flag : 1; | ||
| 372 | uint32_t cabac_init_present_flag : 1; | ||
| 373 | uint32_t constrained_intra_pred_flag : 1; | ||
| 374 | uint32_t transform_skip_enabled_flag : 1; | ||
| 375 | uint32_t cu_qp_delta_enabled_flag : 1; | ||
| 376 | uint32_t pps_slice_chroma_qp_offsets_present_flag : 1; | ||
| 377 | uint32_t weighted_pred_flag : 1; | ||
| 378 | uint32_t weighted_bipred_flag : 1; | ||
| 379 | uint32_t transquant_bypass_enabled_flag : 1; | ||
| 380 | uint32_t tiles_enabled_flag : 1; | ||
| 381 | uint32_t entropy_coding_sync_enabled_flag : 1; | ||
| 382 | uint32_t uniform_spacing_flag : 1; | ||
| 383 | uint32_t loop_filter_across_tiles_enabled_flag : 1; | ||
| 384 | uint32_t pps_loop_filter_across_slices_enabled_flag : 1; | ||
| 385 | uint32_t deblocking_filter_control_present_flag : 1; | ||
| 386 | uint32_t deblocking_filter_override_enabled_flag : 1; | ||
| 387 | uint32_t pps_deblocking_filter_disabled_flag : 1; | ||
| 388 | uint32_t pps_scaling_list_data_present_flag : 1; | ||
| 389 | uint32_t lists_modification_present_flag : 1; | ||
| 390 | uint32_t slice_segment_header_extension_present_flag : 1; | ||
| 391 | uint32_t pps_extension_present_flag : 1; | ||
| 392 | uint32_t cross_component_prediction_enabled_flag : 1; | ||
| 393 | uint32_t chroma_qp_offset_list_enabled_flag : 1; | ||
| 394 | uint32_t pps_curr_pic_ref_enabled_flag : 1; | ||
| 395 | uint32_t residual_adaptive_colour_transform_enabled_flag : 1; | ||
| 396 | uint32_t pps_slice_act_qp_offsets_present_flag : 1; | ||
| 397 | uint32_t pps_palette_predictor_initializers_present_flag : 1; | ||
| 398 | uint32_t monochrome_palette_flag : 1; | ||
| 399 | uint32_t pps_range_extension_flag : 1; | ||
| 400 | } StdVideoH265PpsFlags; | ||
| 401 | |||
| 402 | typedef struct StdVideoH265PictureParameterSet { | ||
| 403 | StdVideoH265PpsFlags flags; | ||
| 404 | uint8_t pps_pic_parameter_set_id; | ||
| 405 | uint8_t pps_seq_parameter_set_id; | ||
| 406 | uint8_t sps_video_parameter_set_id; | ||
| 407 | uint8_t num_extra_slice_header_bits; | ||
| 408 | uint8_t num_ref_idx_l0_default_active_minus1; | ||
| 409 | uint8_t num_ref_idx_l1_default_active_minus1; | ||
| 410 | int8_t init_qp_minus26; | ||
| 411 | uint8_t diff_cu_qp_delta_depth; | ||
| 412 | int8_t pps_cb_qp_offset; | ||
| 413 | int8_t pps_cr_qp_offset; | ||
| 414 | int8_t pps_beta_offset_div2; | ||
| 415 | int8_t pps_tc_offset_div2; | ||
| 416 | uint8_t log2_parallel_merge_level_minus2; | ||
| 417 | uint8_t log2_max_transform_skip_block_size_minus2; | ||
| 418 | uint8_t diff_cu_chroma_qp_offset_depth; | ||
| 419 | uint8_t chroma_qp_offset_list_len_minus1; | ||
| 420 | int8_t cb_qp_offset_list[STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE]; | ||
| 421 | int8_t cr_qp_offset_list[STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE]; | ||
| 422 | uint8_t log2_sao_offset_scale_luma; | ||
| 423 | uint8_t log2_sao_offset_scale_chroma; | ||
| 424 | int8_t pps_act_y_qp_offset_plus5; | ||
| 425 | int8_t pps_act_cb_qp_offset_plus5; | ||
| 426 | int8_t pps_act_cr_qp_offset_plus3; | ||
| 427 | uint8_t pps_num_palette_predictor_initializers; | ||
| 428 | uint8_t luma_bit_depth_entry_minus8; | ||
| 429 | uint8_t chroma_bit_depth_entry_minus8; | ||
| 430 | uint8_t num_tile_columns_minus1; | ||
| 431 | uint8_t num_tile_rows_minus1; | ||
| 432 | uint8_t reserved1; | ||
| 433 | uint8_t reserved2; | ||
| 434 | uint16_t column_width_minus1[STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE]; | ||
| 435 | uint16_t row_height_minus1[STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE]; | ||
| 436 | uint32_t reserved3; | ||
| 437 | const StdVideoH265ScalingLists* pScalingLists; | ||
| 438 | const StdVideoH265PredictorPaletteEntries* pPredictorPaletteEntries; | ||
| 439 | } StdVideoH265PictureParameterSet; | ||
| 440 | |||
| 441 | |||
| 442 | #ifdef __cplusplus | ||
| 443 | } | ||
| 444 | #endif | ||
| 445 | |||
| 446 | #endif | ||
diff --git a/contrib/SDL-3.2.8/src/video/khronos/vk_video/vulkan_video_codec_h265std_decode.h b/contrib/SDL-3.2.8/src/video/khronos/vk_video/vulkan_video_codec_h265std_decode.h new file mode 100644 index 0000000..0178793 --- /dev/null +++ b/contrib/SDL-3.2.8/src/video/khronos/vk_video/vulkan_video_codec_h265std_decode.h | |||
| @@ -0,0 +1,67 @@ | |||
| 1 | #ifndef VULKAN_VIDEO_CODEC_H265STD_DECODE_H_ | ||
| 2 | #define VULKAN_VIDEO_CODEC_H265STD_DECODE_H_ 1 | ||
| 3 | |||
| 4 | /* | ||
| 5 | ** Copyright 2015-2024 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 | // vulkan_video_codec_h265std_decode is a preprocessor guard. Do not pass it to API calls. | ||
| 23 | #define vulkan_video_codec_h265std_decode 1 | ||
| 24 | #include "vulkan_video_codec_h265std.h" | ||
| 25 | |||
| 26 | #define VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_API_VERSION_1_0_0 VK_MAKE_VIDEO_STD_VERSION(1, 0, 0) | ||
| 27 | |||
| 28 | #define VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_API_VERSION_1_0_0 | ||
| 29 | #define VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_h265_decode" | ||
| 30 | #define STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE 8 | ||
| 31 | typedef struct StdVideoDecodeH265PictureInfoFlags { | ||
| 32 | uint32_t IrapPicFlag : 1; | ||
| 33 | uint32_t IdrPicFlag : 1; | ||
| 34 | uint32_t IsReference : 1; | ||
| 35 | uint32_t short_term_ref_pic_set_sps_flag : 1; | ||
| 36 | } StdVideoDecodeH265PictureInfoFlags; | ||
| 37 | |||
| 38 | typedef struct StdVideoDecodeH265PictureInfo { | ||
| 39 | StdVideoDecodeH265PictureInfoFlags flags; | ||
| 40 | uint8_t sps_video_parameter_set_id; | ||
| 41 | uint8_t pps_seq_parameter_set_id; | ||
| 42 | uint8_t pps_pic_parameter_set_id; | ||
| 43 | uint8_t NumDeltaPocsOfRefRpsIdx; | ||
| 44 | int32_t PicOrderCntVal; | ||
| 45 | uint16_t NumBitsForSTRefPicSetInSlice; | ||
| 46 | uint16_t reserved; | ||
| 47 | uint8_t RefPicSetStCurrBefore[STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE]; | ||
| 48 | uint8_t RefPicSetStCurrAfter[STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE]; | ||
| 49 | uint8_t RefPicSetLtCurr[STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE]; | ||
| 50 | } StdVideoDecodeH265PictureInfo; | ||
| 51 | |||
| 52 | typedef struct StdVideoDecodeH265ReferenceInfoFlags { | ||
| 53 | uint32_t used_for_long_term_reference : 1; | ||
| 54 | uint32_t unused_for_reference : 1; | ||
| 55 | } StdVideoDecodeH265ReferenceInfoFlags; | ||
| 56 | |||
| 57 | typedef struct StdVideoDecodeH265ReferenceInfo { | ||
| 58 | StdVideoDecodeH265ReferenceInfoFlags flags; | ||
| 59 | int32_t PicOrderCntVal; | ||
| 60 | } StdVideoDecodeH265ReferenceInfo; | ||
| 61 | |||
| 62 | |||
| 63 | #ifdef __cplusplus | ||
| 64 | } | ||
| 65 | #endif | ||
| 66 | |||
| 67 | #endif | ||
diff --git a/contrib/SDL-3.2.8/src/video/khronos/vk_video/vulkan_video_codec_h265std_encode.h b/contrib/SDL-3.2.8/src/video/khronos/vk_video/vulkan_video_codec_h265std_encode.h new file mode 100644 index 0000000..ee34491 --- /dev/null +++ b/contrib/SDL-3.2.8/src/video/khronos/vk_video/vulkan_video_codec_h265std_encode.h | |||
| @@ -0,0 +1,157 @@ | |||
| 1 | #ifndef VULKAN_VIDEO_CODEC_H265STD_ENCODE_H_ | ||
| 2 | #define VULKAN_VIDEO_CODEC_H265STD_ENCODE_H_ 1 | ||
| 3 | |||
| 4 | /* | ||
| 5 | ** Copyright 2015-2024 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 | // vulkan_video_codec_h265std_encode is a preprocessor guard. Do not pass it to API calls. | ||
| 23 | #define vulkan_video_codec_h265std_encode 1 | ||
| 24 | #include "vulkan_video_codec_h265std.h" | ||
| 25 | |||
| 26 | #define VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_API_VERSION_1_0_0 VK_MAKE_VIDEO_STD_VERSION(1, 0, 0) | ||
| 27 | |||
| 28 | #define VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_API_VERSION_1_0_0 | ||
| 29 | #define VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_h265_encode" | ||
| 30 | typedef struct StdVideoEncodeH265WeightTableFlags { | ||
| 31 | uint16_t luma_weight_l0_flag; | ||
| 32 | uint16_t chroma_weight_l0_flag; | ||
| 33 | uint16_t luma_weight_l1_flag; | ||
| 34 | uint16_t chroma_weight_l1_flag; | ||
| 35 | } StdVideoEncodeH265WeightTableFlags; | ||
| 36 | |||
| 37 | typedef struct StdVideoEncodeH265WeightTable { | ||
| 38 | StdVideoEncodeH265WeightTableFlags flags; | ||
| 39 | uint8_t luma_log2_weight_denom; | ||
| 40 | int8_t delta_chroma_log2_weight_denom; | ||
| 41 | int8_t delta_luma_weight_l0[STD_VIDEO_H265_MAX_NUM_LIST_REF]; | ||
| 42 | int8_t luma_offset_l0[STD_VIDEO_H265_MAX_NUM_LIST_REF]; | ||
| 43 | int8_t delta_chroma_weight_l0[STD_VIDEO_H265_MAX_NUM_LIST_REF][STD_VIDEO_H265_MAX_CHROMA_PLANES]; | ||
| 44 | int8_t delta_chroma_offset_l0[STD_VIDEO_H265_MAX_NUM_LIST_REF][STD_VIDEO_H265_MAX_CHROMA_PLANES]; | ||
| 45 | int8_t delta_luma_weight_l1[STD_VIDEO_H265_MAX_NUM_LIST_REF]; | ||
| 46 | int8_t luma_offset_l1[STD_VIDEO_H265_MAX_NUM_LIST_REF]; | ||
| 47 | int8_t delta_chroma_weight_l1[STD_VIDEO_H265_MAX_NUM_LIST_REF][STD_VIDEO_H265_MAX_CHROMA_PLANES]; | ||
| 48 | int8_t delta_chroma_offset_l1[STD_VIDEO_H265_MAX_NUM_LIST_REF][STD_VIDEO_H265_MAX_CHROMA_PLANES]; | ||
| 49 | } StdVideoEncodeH265WeightTable; | ||
| 50 | |||
| 51 | typedef struct StdVideoEncodeH265SliceSegmentHeaderFlags { | ||
| 52 | uint32_t first_slice_segment_in_pic_flag : 1; | ||
| 53 | uint32_t dependent_slice_segment_flag : 1; | ||
| 54 | uint32_t slice_sao_luma_flag : 1; | ||
| 55 | uint32_t slice_sao_chroma_flag : 1; | ||
| 56 | uint32_t num_ref_idx_active_override_flag : 1; | ||
| 57 | uint32_t mvd_l1_zero_flag : 1; | ||
| 58 | uint32_t cabac_init_flag : 1; | ||
| 59 | uint32_t cu_chroma_qp_offset_enabled_flag : 1; | ||
| 60 | uint32_t deblocking_filter_override_flag : 1; | ||
| 61 | uint32_t slice_deblocking_filter_disabled_flag : 1; | ||
| 62 | uint32_t collocated_from_l0_flag : 1; | ||
| 63 | uint32_t slice_loop_filter_across_slices_enabled_flag : 1; | ||
| 64 | uint32_t reserved : 20; | ||
| 65 | } StdVideoEncodeH265SliceSegmentHeaderFlags; | ||
| 66 | |||
| 67 | typedef struct StdVideoEncodeH265SliceSegmentHeader { | ||
| 68 | StdVideoEncodeH265SliceSegmentHeaderFlags flags; | ||
| 69 | StdVideoH265SliceType slice_type; | ||
| 70 | uint32_t slice_segment_address; | ||
| 71 | uint8_t collocated_ref_idx; | ||
| 72 | uint8_t MaxNumMergeCand; | ||
| 73 | int8_t slice_cb_qp_offset; | ||
| 74 | int8_t slice_cr_qp_offset; | ||
| 75 | int8_t slice_beta_offset_div2; | ||
| 76 | int8_t slice_tc_offset_div2; | ||
| 77 | int8_t slice_act_y_qp_offset; | ||
| 78 | int8_t slice_act_cb_qp_offset; | ||
| 79 | int8_t slice_act_cr_qp_offset; | ||
| 80 | int8_t slice_qp_delta; | ||
| 81 | uint16_t reserved1; | ||
| 82 | const StdVideoEncodeH265WeightTable* pWeightTable; | ||
| 83 | } StdVideoEncodeH265SliceSegmentHeader; | ||
| 84 | |||
| 85 | typedef struct StdVideoEncodeH265ReferenceListsInfoFlags { | ||
| 86 | uint32_t ref_pic_list_modification_flag_l0 : 1; | ||
| 87 | uint32_t ref_pic_list_modification_flag_l1 : 1; | ||
| 88 | uint32_t reserved : 30; | ||
| 89 | } StdVideoEncodeH265ReferenceListsInfoFlags; | ||
| 90 | |||
| 91 | typedef struct StdVideoEncodeH265ReferenceListsInfo { | ||
| 92 | StdVideoEncodeH265ReferenceListsInfoFlags flags; | ||
| 93 | uint8_t num_ref_idx_l0_active_minus1; | ||
| 94 | uint8_t num_ref_idx_l1_active_minus1; | ||
| 95 | uint8_t RefPicList0[STD_VIDEO_H265_MAX_NUM_LIST_REF]; | ||
| 96 | uint8_t RefPicList1[STD_VIDEO_H265_MAX_NUM_LIST_REF]; | ||
| 97 | uint8_t list_entry_l0[STD_VIDEO_H265_MAX_NUM_LIST_REF]; | ||
| 98 | uint8_t list_entry_l1[STD_VIDEO_H265_MAX_NUM_LIST_REF]; | ||
| 99 | } StdVideoEncodeH265ReferenceListsInfo; | ||
| 100 | |||
| 101 | typedef struct StdVideoEncodeH265PictureInfoFlags { | ||
| 102 | uint32_t is_reference : 1; | ||
| 103 | uint32_t IrapPicFlag : 1; | ||
| 104 | uint32_t used_for_long_term_reference : 1; | ||
| 105 | uint32_t discardable_flag : 1; | ||
| 106 | uint32_t cross_layer_bla_flag : 1; | ||
| 107 | uint32_t pic_output_flag : 1; | ||
| 108 | uint32_t no_output_of_prior_pics_flag : 1; | ||
| 109 | uint32_t short_term_ref_pic_set_sps_flag : 1; | ||
| 110 | uint32_t slice_temporal_mvp_enabled_flag : 1; | ||
| 111 | uint32_t reserved : 23; | ||
| 112 | } StdVideoEncodeH265PictureInfoFlags; | ||
| 113 | |||
| 114 | typedef struct StdVideoEncodeH265LongTermRefPics { | ||
| 115 | uint8_t num_long_term_sps; | ||
| 116 | uint8_t num_long_term_pics; | ||
| 117 | uint8_t lt_idx_sps[STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS]; | ||
| 118 | uint8_t poc_lsb_lt[STD_VIDEO_H265_MAX_LONG_TERM_PICS]; | ||
| 119 | uint16_t used_by_curr_pic_lt_flag; | ||
| 120 | uint8_t delta_poc_msb_present_flag[STD_VIDEO_H265_MAX_DELTA_POC]; | ||
| 121 | uint8_t delta_poc_msb_cycle_lt[STD_VIDEO_H265_MAX_DELTA_POC]; | ||
| 122 | } StdVideoEncodeH265LongTermRefPics; | ||
| 123 | |||
| 124 | typedef struct StdVideoEncodeH265PictureInfo { | ||
| 125 | StdVideoEncodeH265PictureInfoFlags flags; | ||
| 126 | StdVideoH265PictureType pic_type; | ||
| 127 | uint8_t sps_video_parameter_set_id; | ||
| 128 | uint8_t pps_seq_parameter_set_id; | ||
| 129 | uint8_t pps_pic_parameter_set_id; | ||
| 130 | uint8_t short_term_ref_pic_set_idx; | ||
| 131 | int32_t PicOrderCntVal; | ||
| 132 | uint8_t TemporalId; | ||
| 133 | uint8_t reserved1[7]; | ||
| 134 | const StdVideoEncodeH265ReferenceListsInfo* pRefLists; | ||
| 135 | const StdVideoH265ShortTermRefPicSet* pShortTermRefPicSet; | ||
| 136 | const StdVideoEncodeH265LongTermRefPics* pLongTermRefPics; | ||
| 137 | } StdVideoEncodeH265PictureInfo; | ||
| 138 | |||
| 139 | typedef struct StdVideoEncodeH265ReferenceInfoFlags { | ||
| 140 | uint32_t used_for_long_term_reference : 1; | ||
| 141 | uint32_t unused_for_reference : 1; | ||
| 142 | uint32_t reserved : 30; | ||
| 143 | } StdVideoEncodeH265ReferenceInfoFlags; | ||
| 144 | |||
| 145 | typedef struct StdVideoEncodeH265ReferenceInfo { | ||
| 146 | StdVideoEncodeH265ReferenceInfoFlags flags; | ||
| 147 | StdVideoH265PictureType pic_type; | ||
| 148 | int32_t PicOrderCntVal; | ||
| 149 | uint8_t TemporalId; | ||
| 150 | } StdVideoEncodeH265ReferenceInfo; | ||
| 151 | |||
| 152 | |||
| 153 | #ifdef __cplusplus | ||
| 154 | } | ||
| 155 | #endif | ||
| 156 | |||
| 157 | #endif | ||
diff --git a/contrib/SDL-3.2.8/src/video/khronos/vk_video/vulkan_video_codecs_common.h b/contrib/SDL-3.2.8/src/video/khronos/vk_video/vulkan_video_codecs_common.h new file mode 100644 index 0000000..5e6ef1d --- /dev/null +++ b/contrib/SDL-3.2.8/src/video/khronos/vk_video/vulkan_video_codecs_common.h | |||
| @@ -0,0 +1,36 @@ | |||
| 1 | #ifndef VULKAN_VIDEO_CODECS_COMMON_H_ | ||
| 2 | #define VULKAN_VIDEO_CODECS_COMMON_H_ 1 | ||
| 3 | |||
| 4 | /* | ||
| 5 | ** Copyright 2015-2024 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 | // vulkan_video_codecs_common is a preprocessor guard. Do not pass it to API calls. | ||
| 23 | #define vulkan_video_codecs_common 1 | ||
| 24 | #if !defined(VK_NO_STDINT_H) | ||
| 25 | #include <stdint.h> | ||
| 26 | #endif | ||
| 27 | |||
| 28 | #define VK_MAKE_VIDEO_STD_VERSION(major, minor, patch) \ | ||
| 29 | ((((uint32_t)(major)) << 22) | (((uint32_t)(minor)) << 12) | ((uint32_t)(patch))) | ||
| 30 | |||
| 31 | |||
| 32 | #ifdef __cplusplus | ||
| 33 | } | ||
| 34 | #endif | ||
| 35 | |||
| 36 | #endif | ||
