1 /*
2 * Copyright © 2021 Red Hat
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
13 * Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
21 * IN THE SOFTWARE.
22 */
23
24 #include "vk_video.h"
25 #include "vk_util.h"
26 #include "vk_log.h"
27 #include "vk_alloc.h"
28 #include "vk_device.h"
29 #include "util/vl_rbsp.h"
30 #include "util/vl_bitstream.h"
31
32 VkResult
vk_video_session_init(struct vk_device * device,struct vk_video_session * vid,const VkVideoSessionCreateInfoKHR * create_info)33 vk_video_session_init(struct vk_device *device,
34 struct vk_video_session *vid,
35 const VkVideoSessionCreateInfoKHR *create_info)
36 {
37 vk_object_base_init(device, &vid->base, VK_OBJECT_TYPE_VIDEO_SESSION_KHR);
38
39 vid->flags = create_info->flags;
40 vid->op = create_info->pVideoProfile->videoCodecOperation;
41 vid->max_coded = create_info->maxCodedExtent;
42 vid->picture_format = create_info->pictureFormat;
43 vid->ref_format = create_info->referencePictureFormat;
44 vid->max_dpb_slots = create_info->maxDpbSlots;
45 vid->max_active_ref_pics = create_info->maxActiveReferencePictures;
46
47 switch (vid->op) {
48 case VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR: {
49 const struct VkVideoDecodeH264ProfileInfoKHR *h264_profile =
50 vk_find_struct_const(create_info->pVideoProfile->pNext,
51 VIDEO_DECODE_H264_PROFILE_INFO_KHR);
52 vid->h264.profile_idc = h264_profile->stdProfileIdc;
53 break;
54 }
55 case VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR: {
56 const struct VkVideoDecodeH265ProfileInfoKHR *h265_profile =
57 vk_find_struct_const(create_info->pVideoProfile->pNext,
58 VIDEO_DECODE_H265_PROFILE_INFO_KHR);
59 vid->h265.profile_idc = h265_profile->stdProfileIdc;
60 break;
61 }
62 case VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR: {
63 const struct VkVideoDecodeAV1ProfileInfoKHR *av1_profile =
64 vk_find_struct_const(create_info->pVideoProfile->pNext,
65 VIDEO_DECODE_AV1_PROFILE_INFO_KHR);
66 vid->av1.profile = av1_profile->stdProfile;
67 vid->av1.film_grain_support = av1_profile->filmGrainSupport;
68 break;
69 };
70 case VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR: {
71 const struct VkVideoEncodeH264ProfileInfoKHR *h264_profile =
72 vk_find_struct_const(create_info->pVideoProfile->pNext, VIDEO_ENCODE_H264_PROFILE_INFO_KHR);
73 vid->h264.profile_idc = h264_profile->stdProfileIdc;
74 break;
75 }
76 case VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR: {
77 const struct VkVideoEncodeH265ProfileInfoKHR *h265_profile =
78 vk_find_struct_const(create_info->pVideoProfile->pNext, VIDEO_ENCODE_H265_PROFILE_INFO_KHR);
79 vid->h265.profile_idc = h265_profile->stdProfileIdc;
80 break;
81 }
82 default:
83 return VK_ERROR_FEATURE_NOT_PRESENT;
84 }
85
86 if (vid->op == VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR ||
87 vid->op == VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR) {
88 const struct VkVideoEncodeUsageInfoKHR *encode_usage_profile =
89 vk_find_struct_const(create_info->pVideoProfile->pNext, VIDEO_ENCODE_USAGE_INFO_KHR);
90 if (encode_usage_profile) {
91 vid->enc_usage.video_usage_hints = encode_usage_profile->videoUsageHints;
92 vid->enc_usage.video_content_hints = encode_usage_profile->videoContentHints;
93 vid->enc_usage.tuning_mode = encode_usage_profile->tuningMode;
94 } else {
95 vid->enc_usage.video_usage_hints = VK_VIDEO_ENCODE_USAGE_DEFAULT_KHR;
96 vid->enc_usage.video_content_hints = VK_VIDEO_ENCODE_CONTENT_DEFAULT_KHR;
97 vid->enc_usage.tuning_mode = VK_VIDEO_ENCODE_TUNING_MODE_DEFAULT_KHR;
98 }
99 }
100
101 return VK_SUCCESS;
102 }
103
104 static void
vk_video_deep_copy_h264_sps(struct vk_video_h264_sps * dst,const StdVideoH264SequenceParameterSet * src)105 vk_video_deep_copy_h264_sps(struct vk_video_h264_sps *dst,
106 const StdVideoH264SequenceParameterSet *src)
107 {
108 memcpy(&dst->base, src, sizeof(StdVideoH264SequenceParameterSet));
109 if (src->num_ref_frames_in_pic_order_cnt_cycle && src->pOffsetForRefFrame) {
110 memcpy(dst->offsets_for_ref_frame, src->pOffsetForRefFrame, sizeof(int32_t) * src->num_ref_frames_in_pic_order_cnt_cycle);
111 dst->base.pOffsetForRefFrame = dst->offsets_for_ref_frame;
112 }
113 if (src->flags.seq_scaling_matrix_present_flag && src->pScalingLists) {
114 memcpy(&dst->scaling_lists, src->pScalingLists, sizeof(StdVideoH264ScalingLists));
115 dst->base.pScalingLists = &dst->scaling_lists;
116 }
117 if (src->flags.vui_parameters_present_flag && src->pSequenceParameterSetVui) {
118 memcpy(&dst->vui, src->pSequenceParameterSetVui, sizeof(StdVideoH264SequenceParameterSetVui));
119 dst->base.pSequenceParameterSetVui = &dst->vui;
120
121 if (src->pSequenceParameterSetVui->pHrdParameters) {
122 memcpy(&dst->vui_hrd_parameters, src->pSequenceParameterSetVui->pHrdParameters,
123 sizeof(StdVideoH264HrdParameters));
124 dst->vui.pHrdParameters = &dst->vui_hrd_parameters;
125 }
126 }
127 }
128
129 static void
vk_video_deep_copy_h264_pps(struct vk_video_h264_pps * dst,const StdVideoH264PictureParameterSet * src)130 vk_video_deep_copy_h264_pps(struct vk_video_h264_pps *dst,
131 const StdVideoH264PictureParameterSet *src)
132 {
133 memcpy(&dst->base, src, sizeof(StdVideoH264PictureParameterSet));
134 if (src->flags.pic_scaling_matrix_present_flag && src->pScalingLists) {
135 memcpy(&dst->scaling_lists, src->pScalingLists, sizeof(StdVideoH264ScalingLists));
136 dst->base.pScalingLists = &dst->scaling_lists;
137 }
138 }
139
140 static void
vk_video_deep_copy_h265_vps(struct vk_video_h265_vps * dst,const StdVideoH265VideoParameterSet * src)141 vk_video_deep_copy_h265_vps(struct vk_video_h265_vps *dst,
142 const StdVideoH265VideoParameterSet *src)
143 {
144 memcpy(&dst->base, src, sizeof(StdVideoH265VideoParameterSet));
145 if (src->pDecPicBufMgr) {
146 memcpy(&dst->dec_pic_buf_mgr, src->pDecPicBufMgr, sizeof(StdVideoH265DecPicBufMgr));
147 dst->base.pDecPicBufMgr = &dst->dec_pic_buf_mgr;
148 }
149 if (src->pHrdParameters) {
150 memcpy(&dst->hrd_parameters, src->pHrdParameters, sizeof(StdVideoH265HrdParameters));
151 dst->base.pHrdParameters = &dst->hrd_parameters;
152 if (src->pHrdParameters->pSubLayerHrdParametersNal) {
153 memcpy(&dst->hrd_parameters_nal, src->pHrdParameters->pSubLayerHrdParametersNal,
154 sizeof(StdVideoH265SubLayerHrdParameters));
155 dst->hrd_parameters.pSubLayerHrdParametersNal = &dst->hrd_parameters_nal;
156 }
157 if (src->pHrdParameters->pSubLayerHrdParametersVcl) {
158 memcpy(&dst->hrd_parameters_vcl, src->pHrdParameters->pSubLayerHrdParametersVcl,
159 sizeof(StdVideoH265SubLayerHrdParameters));
160 dst->hrd_parameters.pSubLayerHrdParametersVcl = &dst->hrd_parameters_vcl;
161 }
162 }
163
164 if (src->pProfileTierLevel) {
165 memcpy(&dst->tier_level, src->pProfileTierLevel, sizeof(StdVideoH265ProfileTierLevel));
166 dst->base.pProfileTierLevel = &dst->tier_level;
167 }
168 }
169
170 static void
vk_video_deep_copy_h265_sps(struct vk_video_h265_sps * dst,const StdVideoH265SequenceParameterSet * src)171 vk_video_deep_copy_h265_sps(struct vk_video_h265_sps *dst,
172 const StdVideoH265SequenceParameterSet *src)
173 {
174 memcpy(&dst->base, src, sizeof(StdVideoH265SequenceParameterSet));
175 if (src->pProfileTierLevel) {
176 memcpy(&dst->tier_level, src->pProfileTierLevel, sizeof(StdVideoH265ProfileTierLevel));
177 dst->base.pProfileTierLevel = &dst->tier_level;
178 }
179 if (src->pDecPicBufMgr) {
180 memcpy(&dst->dec_pic_buf_mgr, src->pDecPicBufMgr, sizeof(StdVideoH265DecPicBufMgr));
181 dst->base.pDecPicBufMgr = &dst->dec_pic_buf_mgr;
182 }
183 if (src->flags.sps_scaling_list_data_present_flag && src->pScalingLists) {
184 memcpy(&dst->scaling_lists, src->pScalingLists, sizeof(StdVideoH265ScalingLists));
185 dst->base.pScalingLists = &dst->scaling_lists;
186 }
187
188 if (src->pShortTermRefPicSet) {
189 memcpy(&dst->short_term_ref_pic_set, src->pShortTermRefPicSet, sizeof(StdVideoH265ShortTermRefPicSet));
190 dst->base.pShortTermRefPicSet = &dst->short_term_ref_pic_set;
191 }
192
193 if (src->pLongTermRefPicsSps) {
194 memcpy(&dst->long_term_ref_pics_sps, src->pLongTermRefPicsSps, sizeof(StdVideoH265LongTermRefPicsSps));
195 dst->base.pLongTermRefPicsSps = &dst->long_term_ref_pics_sps;
196 }
197
198 if (src->pSequenceParameterSetVui) {
199 memcpy(&dst->vui, src->pSequenceParameterSetVui, sizeof(StdVideoH265SequenceParameterSetVui));
200 dst->base.pSequenceParameterSetVui = &dst->vui;
201
202 if (src->pSequenceParameterSetVui->pHrdParameters) {
203 memcpy(&dst->hrd_parameters, src->pSequenceParameterSetVui->pHrdParameters, sizeof(StdVideoH265HrdParameters));
204 dst->vui.pHrdParameters = &dst->hrd_parameters;
205 if (src->pSequenceParameterSetVui->pHrdParameters->pSubLayerHrdParametersNal) {
206 memcpy(&dst->hrd_parameters_nal, src->pSequenceParameterSetVui->pHrdParameters->pSubLayerHrdParametersNal,
207 sizeof(StdVideoH265SubLayerHrdParameters));
208 dst->hrd_parameters.pSubLayerHrdParametersNal = &dst->hrd_parameters_nal;
209 }
210 if (src->pSequenceParameterSetVui->pHrdParameters->pSubLayerHrdParametersVcl) {
211 memcpy(&dst->hrd_parameters_vcl, src->pSequenceParameterSetVui->pHrdParameters->pSubLayerHrdParametersVcl,
212 sizeof(StdVideoH265SubLayerHrdParameters));
213 dst->hrd_parameters.pSubLayerHrdParametersVcl = &dst->hrd_parameters_vcl;
214 }
215 }
216 }
217 if (src->flags.sps_palette_predictor_initializers_present_flag && src->pPredictorPaletteEntries) {
218 memcpy(&dst->palette_entries, src->pPredictorPaletteEntries, sizeof(StdVideoH265PredictorPaletteEntries));
219 dst->base.pPredictorPaletteEntries = &dst->palette_entries;
220 }
221 }
222
223 static void
vk_video_deep_copy_h265_pps(struct vk_video_h265_pps * dst,const StdVideoH265PictureParameterSet * src)224 vk_video_deep_copy_h265_pps(struct vk_video_h265_pps *dst,
225 const StdVideoH265PictureParameterSet *src)
226 {
227 memcpy(&dst->base, src, sizeof(StdVideoH265PictureParameterSet));
228 if (src->flags.pps_scaling_list_data_present_flag && src->pScalingLists) {
229 memcpy(&dst->scaling_lists, src->pScalingLists, sizeof(StdVideoH265ScalingLists));
230 dst->base.pScalingLists = &dst->scaling_lists;
231 }
232
233 if (src->flags.pps_palette_predictor_initializers_present_flag && src->pPredictorPaletteEntries) {
234 memcpy(&dst->palette_entries, src->pPredictorPaletteEntries, sizeof(StdVideoH265PredictorPaletteEntries));
235 dst->base.pPredictorPaletteEntries = &dst->palette_entries;
236 }
237 }
238
239
240 #define FIND(PARAMSET, SS, SET, ID) \
241 static struct vk_video_##SET *find_##SS##_##SET(const struct vk_video_session_parameters *params, uint32_t id) { \
242 for (unsigned i = 0; i < params->SS.SET##_count; i++) { \
243 if (params->SS.SET[i].base.ID == id) \
244 return ¶ms->SS.SET[i]; \
245 } \
246 return NULL; \
247 } \
248 \
249 static void add_##SS##_##SET(struct vk_video_session_parameters *params, \
250 const PARAMSET *new_set, bool noreplace) { \
251 struct vk_video_##SET *set = find_##SS##_##SET(params, new_set->ID); \
252 if (set) { \
253 if (noreplace) \
254 return; \
255 vk_video_deep_copy_##SET(set, new_set); \
256 } else \
257 vk_video_deep_copy_##SET(¶ms->SS.SET[params->SS.SET##_count++], new_set); \
258 } \
259 \
260 static VkResult update_##SS##_##SET(struct vk_video_session_parameters *params, \
261 uint32_t count, const PARAMSET *updates) { \
262 if (params->SS.SET##_count + count >= params->SS.max_##SET##_count) \
263 return VK_ERROR_TOO_MANY_OBJECTS; \
264 for (unsigned _c = 0; _c < count; _c++) \
265 vk_video_deep_copy_##SET(¶ms->SS.SET[params->SS.SET##_count + _c], &updates[_c]); \
266 params->SS.SET##_count += count; \
267 return VK_SUCCESS; \
268 }
269
FIND(StdVideoH264SequenceParameterSet,h264_dec,h264_sps,seq_parameter_set_id)270 FIND(StdVideoH264SequenceParameterSet, h264_dec, h264_sps, seq_parameter_set_id)
271 FIND(StdVideoH264PictureParameterSet, h264_dec, h264_pps, pic_parameter_set_id)
272 FIND(StdVideoH265VideoParameterSet, h265_dec, h265_vps, vps_video_parameter_set_id)
273 FIND(StdVideoH265SequenceParameterSet, h265_dec, h265_sps, sps_seq_parameter_set_id)
274 FIND(StdVideoH265PictureParameterSet, h265_dec, h265_pps, pps_pic_parameter_set_id)
275
276 FIND(StdVideoH264SequenceParameterSet, h264_enc, h264_sps, seq_parameter_set_id)
277 FIND(StdVideoH264PictureParameterSet, h264_enc, h264_pps, pic_parameter_set_id)
278
279 FIND(StdVideoH265VideoParameterSet, h265_enc, h265_vps, vps_video_parameter_set_id)
280 FIND(StdVideoH265SequenceParameterSet, h265_enc, h265_sps, sps_seq_parameter_set_id)
281 FIND(StdVideoH265PictureParameterSet, h265_enc, h265_pps, pps_pic_parameter_set_id)
282
283 static void
284 init_add_h264_dec_session_parameters(struct vk_video_session_parameters *params,
285 const struct VkVideoDecodeH264SessionParametersAddInfoKHR *h264_add,
286 const struct vk_video_session_parameters *templ)
287 {
288 unsigned i;
289
290 if (h264_add) {
291 for (i = 0; i < h264_add->stdSPSCount; i++) {
292 add_h264_dec_h264_sps(params, &h264_add->pStdSPSs[i], false);
293 }
294 }
295 if (templ) {
296 for (i = 0; i < templ->h264_dec.h264_sps_count; i++) {
297 add_h264_dec_h264_sps(params, &templ->h264_dec.h264_sps[i].base, true);
298 }
299 }
300
301 if (h264_add) {
302 for (i = 0; i < h264_add->stdPPSCount; i++) {
303 add_h264_dec_h264_pps(params, &h264_add->pStdPPSs[i], false);
304 }
305 }
306 if (templ) {
307 for (i = 0; i < templ->h264_dec.h264_pps_count; i++) {
308 add_h264_dec_h264_pps(params, &templ->h264_dec.h264_pps[i].base, true);
309 }
310 }
311 }
312
313 static void
init_add_h264_enc_session_parameters(struct vk_video_session_parameters * params,const struct VkVideoEncodeH264SessionParametersAddInfoKHR * h264_add,const struct vk_video_session_parameters * templ)314 init_add_h264_enc_session_parameters(struct vk_video_session_parameters *params,
315 const struct VkVideoEncodeH264SessionParametersAddInfoKHR *h264_add,
316 const struct vk_video_session_parameters *templ)
317 {
318 unsigned i;
319 if (h264_add) {
320 for (i = 0; i < h264_add->stdSPSCount; i++) {
321 add_h264_enc_h264_sps(params, &h264_add->pStdSPSs[i], false);
322 }
323 }
324 if (templ) {
325 for (i = 0; i < templ->h264_dec.h264_sps_count; i++) {
326 add_h264_enc_h264_sps(params, &templ->h264_enc.h264_sps[i].base, true);
327 }
328 }
329
330 if (h264_add) {
331 for (i = 0; i < h264_add->stdPPSCount; i++) {
332 add_h264_enc_h264_pps(params, &h264_add->pStdPPSs[i], false);
333 }
334 }
335 if (templ) {
336 for (i = 0; i < templ->h264_enc.h264_pps_count; i++) {
337 add_h264_enc_h264_pps(params, &templ->h264_enc.h264_pps[i].base, true);
338 }
339 }
340 }
341
342 static void
init_add_h265_dec_session_parameters(struct vk_video_session_parameters * params,const struct VkVideoDecodeH265SessionParametersAddInfoKHR * h265_add,const struct vk_video_session_parameters * templ)343 init_add_h265_dec_session_parameters(struct vk_video_session_parameters *params,
344 const struct VkVideoDecodeH265SessionParametersAddInfoKHR *h265_add,
345 const struct vk_video_session_parameters *templ)
346 {
347 unsigned i;
348
349 if (h265_add) {
350 for (i = 0; i < h265_add->stdVPSCount; i++) {
351 add_h265_dec_h265_vps(params, &h265_add->pStdVPSs[i], false);
352 }
353 }
354 if (templ) {
355 for (i = 0; i < templ->h265_dec.h265_vps_count; i++) {
356 add_h265_dec_h265_vps(params, &templ->h265_dec.h265_vps[i].base, true);
357 }
358 }
359 if (h265_add) {
360 for (i = 0; i < h265_add->stdSPSCount; i++) {
361 add_h265_dec_h265_sps(params, &h265_add->pStdSPSs[i], false);
362 }
363 }
364 if (templ) {
365 for (i = 0; i < templ->h265_dec.h265_sps_count; i++) {
366 add_h265_dec_h265_sps(params, &templ->h265_dec.h265_sps[i].base, true);
367 }
368 }
369
370 if (h265_add) {
371 for (i = 0; i < h265_add->stdPPSCount; i++) {
372 add_h265_dec_h265_pps(params, &h265_add->pStdPPSs[i], false);
373 }
374 }
375 if (templ) {
376 for (i = 0; i < templ->h265_dec.h265_pps_count; i++) {
377 add_h265_dec_h265_pps(params, &templ->h265_dec.h265_pps[i].base, true);
378 }
379 }
380 }
381
382 static void
init_add_h265_enc_session_parameters(struct vk_video_session_parameters * params,const struct VkVideoEncodeH265SessionParametersAddInfoKHR * h265_add,const struct vk_video_session_parameters * templ)383 init_add_h265_enc_session_parameters(struct vk_video_session_parameters *params,
384 const struct VkVideoEncodeH265SessionParametersAddInfoKHR *h265_add,
385 const struct vk_video_session_parameters *templ)
386 {
387 unsigned i;
388
389 if (h265_add) {
390 for (i = 0; i < h265_add->stdVPSCount; i++) {
391 add_h265_enc_h265_vps(params, &h265_add->pStdVPSs[i], false);
392 }
393 }
394 if (templ) {
395 for (i = 0; i < templ->h265_enc.h265_vps_count; i++) {
396 add_h265_enc_h265_vps(params, &templ->h265_enc.h265_vps[i].base, true);
397 }
398 }
399 if (h265_add) {
400 for (i = 0; i < h265_add->stdSPSCount; i++) {
401 add_h265_enc_h265_sps(params, &h265_add->pStdSPSs[i], false);
402 }
403 }
404 if (templ) {
405 for (i = 0; i < templ->h265_enc.h265_sps_count; i++) {
406 add_h265_enc_h265_sps(params, &templ->h265_enc.h265_sps[i].base, true);
407 }
408 }
409
410 if (h265_add) {
411 for (i = 0; i < h265_add->stdPPSCount; i++) {
412 add_h265_enc_h265_pps(params, &h265_add->pStdPPSs[i], false);
413 }
414 }
415 if (templ) {
416 for (i = 0; i < templ->h265_enc.h265_pps_count; i++) {
417 add_h265_enc_h265_pps(params, &templ->h265_enc.h265_pps[i].base, true);
418 }
419 }
420 }
421
422 static void
vk_video_deep_copy_av1_seq_hdr(struct vk_video_av1_seq_hdr * dst,const StdVideoAV1SequenceHeader * src)423 vk_video_deep_copy_av1_seq_hdr(struct vk_video_av1_seq_hdr *dst,
424 const StdVideoAV1SequenceHeader *src)
425 {
426 memcpy(&dst->base, src, sizeof(StdVideoAV1SequenceHeader));
427 if (src->pColorConfig) {
428 memcpy(&dst->color_config, src->pColorConfig, sizeof(StdVideoAV1ColorConfig));
429 dst->base.pColorConfig = &dst->color_config;
430 }
431 if (src->pTimingInfo) {
432 memcpy(&dst->timing_info, src->pTimingInfo, sizeof(StdVideoAV1TimingInfo));
433 dst->base.pTimingInfo = &dst->timing_info;
434 }
435 }
436
437 VkResult
vk_video_session_parameters_init(struct vk_device * device,struct vk_video_session_parameters * params,const struct vk_video_session * vid,const struct vk_video_session_parameters * templ,const VkVideoSessionParametersCreateInfoKHR * create_info)438 vk_video_session_parameters_init(struct vk_device *device,
439 struct vk_video_session_parameters *params,
440 const struct vk_video_session *vid,
441 const struct vk_video_session_parameters *templ,
442 const VkVideoSessionParametersCreateInfoKHR *create_info)
443 {
444 memset(params, 0, sizeof(*params));
445 vk_object_base_init(device, ¶ms->base, VK_OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR);
446
447 params->op = vid->op;
448
449 switch (vid->op) {
450 case VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR: {
451 const struct VkVideoDecodeH264SessionParametersCreateInfoKHR *h264_create =
452 vk_find_struct_const(create_info->pNext, VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR);
453
454 params->h264_dec.max_h264_sps_count = h264_create->maxStdSPSCount;
455 params->h264_dec.max_h264_pps_count = h264_create->maxStdPPSCount;
456
457 uint32_t sps_size = params->h264_dec.max_h264_sps_count * sizeof(struct vk_video_h264_sps);
458 uint32_t pps_size = params->h264_dec.max_h264_pps_count * sizeof(struct vk_video_h264_pps);
459
460 params->h264_dec.h264_sps = vk_alloc(&device->alloc, sps_size, 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
461 params->h264_dec.h264_pps = vk_alloc(&device->alloc, pps_size, 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
462 if (!params->h264_dec.h264_sps || !params->h264_dec.h264_pps) {
463 vk_free(&device->alloc, params->h264_dec.h264_sps);
464 vk_free(&device->alloc, params->h264_dec.h264_pps);
465 return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
466 }
467
468 init_add_h264_dec_session_parameters(params, h264_create->pParametersAddInfo, templ);
469 break;
470 }
471 case VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR: {
472 const struct VkVideoDecodeH265SessionParametersCreateInfoKHR *h265_create =
473 vk_find_struct_const(create_info->pNext, VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR);
474
475 params->h265_dec.max_h265_vps_count = h265_create->maxStdVPSCount;
476 params->h265_dec.max_h265_sps_count = h265_create->maxStdSPSCount;
477 params->h265_dec.max_h265_pps_count = h265_create->maxStdPPSCount;
478
479 uint32_t vps_size = params->h265_dec.max_h265_vps_count * sizeof(struct vk_video_h265_vps);
480 uint32_t sps_size = params->h265_dec.max_h265_sps_count * sizeof(struct vk_video_h265_sps);
481 uint32_t pps_size = params->h265_dec.max_h265_pps_count * sizeof(struct vk_video_h265_pps);
482
483 params->h265_dec.h265_vps = vk_alloc(&device->alloc, vps_size, 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
484 params->h265_dec.h265_sps = vk_alloc(&device->alloc, sps_size, 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
485 params->h265_dec.h265_pps = vk_alloc(&device->alloc, pps_size, 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
486 if (!params->h265_dec.h265_sps || !params->h265_dec.h265_pps || !params->h265_dec.h265_vps) {
487 vk_free(&device->alloc, params->h265_dec.h265_vps);
488 vk_free(&device->alloc, params->h265_dec.h265_sps);
489 vk_free(&device->alloc, params->h265_dec.h265_pps);
490 return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
491 }
492
493 init_add_h265_dec_session_parameters(params, h265_create->pParametersAddInfo, templ);
494 break;
495 }
496 case VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR: {
497 const struct VkVideoDecodeAV1SessionParametersCreateInfoKHR *av1_create =
498 vk_find_struct_const(create_info->pNext, VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR);
499 if (av1_create && av1_create->pStdSequenceHeader) {
500 vk_video_deep_copy_av1_seq_hdr(¶ms->av1_dec.seq_hdr,
501 av1_create->pStdSequenceHeader);
502 }
503 break;
504 }
505 case VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR: {
506 const struct VkVideoEncodeH264SessionParametersCreateInfoKHR *h264_create =
507 vk_find_struct_const(create_info->pNext, VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR);
508
509 params->h264_enc.max_h264_sps_count = h264_create->maxStdSPSCount;
510 params->h264_enc.max_h264_pps_count = h264_create->maxStdPPSCount;
511
512 uint32_t sps_size = params->h264_enc.max_h264_sps_count * sizeof(struct vk_video_h264_sps);
513 uint32_t pps_size = params->h264_enc.max_h264_pps_count * sizeof(struct vk_video_h264_pps);
514
515 params->h264_enc.h264_sps = vk_alloc(&device->alloc, sps_size, 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
516 params->h264_enc.h264_pps = vk_alloc(&device->alloc, pps_size, 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
517 if (!params->h264_enc.h264_sps || !params->h264_enc.h264_pps) {
518 vk_free(&device->alloc, params->h264_enc.h264_sps);
519 vk_free(&device->alloc, params->h264_enc.h264_pps);
520 return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
521 }
522
523 init_add_h264_enc_session_parameters(params, h264_create->pParametersAddInfo, templ);
524 break;
525 }
526 case VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR: {
527 const struct VkVideoEncodeH265SessionParametersCreateInfoKHR *h265_create =
528 vk_find_struct_const(create_info->pNext, VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR);
529
530 params->h265_enc.max_h265_vps_count = h265_create->maxStdVPSCount;
531 params->h265_enc.max_h265_sps_count = h265_create->maxStdSPSCount;
532 params->h265_enc.max_h265_pps_count = h265_create->maxStdPPSCount;
533
534 uint32_t vps_size = params->h265_enc.max_h265_vps_count * sizeof(struct vk_video_h265_vps);
535 uint32_t sps_size = params->h265_enc.max_h265_sps_count * sizeof(struct vk_video_h265_sps);
536 uint32_t pps_size = params->h265_enc.max_h265_pps_count * sizeof(struct vk_video_h265_pps);
537
538 params->h265_enc.h265_vps = vk_alloc(&device->alloc, vps_size, 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
539 params->h265_enc.h265_sps = vk_alloc(&device->alloc, sps_size, 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
540 params->h265_enc.h265_pps = vk_alloc(&device->alloc, pps_size, 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
541 if (!params->h265_enc.h265_sps || !params->h265_enc.h265_pps || !params->h265_enc.h265_vps) {
542 vk_free(&device->alloc, params->h265_enc.h265_vps);
543 vk_free(&device->alloc, params->h265_enc.h265_sps);
544 vk_free(&device->alloc, params->h265_enc.h265_pps);
545 return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
546 }
547
548 init_add_h265_enc_session_parameters(params, h265_create->pParametersAddInfo, templ);
549 break;
550 }
551 default:
552 unreachable("Unsupported video codec operation");
553 break;
554 }
555 return VK_SUCCESS;
556 }
557
558 void
vk_video_session_parameters_finish(struct vk_device * device,struct vk_video_session_parameters * params)559 vk_video_session_parameters_finish(struct vk_device *device,
560 struct vk_video_session_parameters *params)
561 {
562 switch (params->op) {
563 case VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR:
564 vk_free(&device->alloc, params->h264_dec.h264_sps);
565 vk_free(&device->alloc, params->h264_dec.h264_pps);
566 break;
567 case VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR:
568 vk_free(&device->alloc, params->h265_dec.h265_vps);
569 vk_free(&device->alloc, params->h265_dec.h265_sps);
570 vk_free(&device->alloc, params->h265_dec.h265_pps);
571 break;
572 case VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR:
573 vk_free(&device->alloc, params->h264_enc.h264_sps);
574 vk_free(&device->alloc, params->h264_enc.h264_pps);
575 break;
576 case VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR:
577 vk_free(&device->alloc, params->h265_enc.h265_vps);
578 vk_free(&device->alloc, params->h265_enc.h265_sps);
579 vk_free(&device->alloc, params->h265_enc.h265_pps);
580 break;
581 default:
582 break;
583 }
584 vk_object_base_finish(¶ms->base);
585 }
586
587 static VkResult
update_h264_dec_session_parameters(struct vk_video_session_parameters * params,const struct VkVideoDecodeH264SessionParametersAddInfoKHR * h264_add)588 update_h264_dec_session_parameters(struct vk_video_session_parameters *params,
589 const struct VkVideoDecodeH264SessionParametersAddInfoKHR *h264_add)
590 {
591 VkResult result = VK_SUCCESS;
592
593 result = update_h264_dec_h264_sps(params, h264_add->stdSPSCount, h264_add->pStdSPSs);
594 if (result != VK_SUCCESS)
595 return result;
596
597 result = update_h264_dec_h264_pps(params, h264_add->stdPPSCount, h264_add->pStdPPSs);
598 return result;
599 }
600
601 static VkResult
update_h264_enc_session_parameters(struct vk_video_session_parameters * params,const struct VkVideoEncodeH264SessionParametersAddInfoKHR * h264_add)602 update_h264_enc_session_parameters(struct vk_video_session_parameters *params,
603 const struct VkVideoEncodeH264SessionParametersAddInfoKHR *h264_add)
604 {
605 VkResult result = VK_SUCCESS;
606 result = update_h264_enc_h264_sps(params, h264_add->stdSPSCount, h264_add->pStdSPSs);
607 if (result != VK_SUCCESS)
608 return result;
609
610 result = update_h264_enc_h264_pps(params, h264_add->stdPPSCount, h264_add->pStdPPSs);
611 return result;
612 }
613
614 static VkResult
update_h265_enc_session_parameters(struct vk_video_session_parameters * params,const struct VkVideoEncodeH265SessionParametersAddInfoKHR * h265_add)615 update_h265_enc_session_parameters(struct vk_video_session_parameters *params,
616 const struct VkVideoEncodeH265SessionParametersAddInfoKHR *h265_add)
617 {
618 VkResult result = VK_SUCCESS;
619
620 result = update_h265_enc_h265_vps(params, h265_add->stdVPSCount, h265_add->pStdVPSs);
621 if (result != VK_SUCCESS)
622 return result;
623
624 result = update_h265_enc_h265_sps(params, h265_add->stdSPSCount, h265_add->pStdSPSs);
625 if (result != VK_SUCCESS)
626 return result;
627
628 result = update_h265_enc_h265_pps(params, h265_add->stdPPSCount, h265_add->pStdPPSs);
629 return result;
630 }
631
632 static VkResult
update_h265_session_parameters(struct vk_video_session_parameters * params,const struct VkVideoDecodeH265SessionParametersAddInfoKHR * h265_add)633 update_h265_session_parameters(struct vk_video_session_parameters *params,
634 const struct VkVideoDecodeH265SessionParametersAddInfoKHR *h265_add)
635 {
636 VkResult result = VK_SUCCESS;
637 result = update_h265_dec_h265_vps(params, h265_add->stdVPSCount, h265_add->pStdVPSs);
638 if (result != VK_SUCCESS)
639 return result;
640
641 result = update_h265_dec_h265_sps(params, h265_add->stdSPSCount, h265_add->pStdSPSs);
642 if (result != VK_SUCCESS)
643 return result;
644
645 result = update_h265_dec_h265_pps(params, h265_add->stdPPSCount, h265_add->pStdPPSs);
646 return result;
647 }
648
649 VkResult
vk_video_session_parameters_update(struct vk_video_session_parameters * params,const VkVideoSessionParametersUpdateInfoKHR * update)650 vk_video_session_parameters_update(struct vk_video_session_parameters *params,
651 const VkVideoSessionParametersUpdateInfoKHR *update)
652 {
653 /* 39.6.5. Decoder Parameter Sets -
654 * "The provided H.264 SPS/PPS parameters must be within the limits specified during decoder
655 * creation for the decoder specified in VkVideoSessionParametersCreateInfoKHR."
656 */
657
658 /*
659 * There is no need to deduplicate here.
660 * videoSessionParameters must not already contain a StdVideoH264PictureParameterSet entry with
661 * both seq_parameter_set_id and pic_parameter_set_id matching any of the elements of
662 * VkVideoDecodeH264SessionParametersAddInfoKHR::pStdPPS
663 */
664 VkResult result = VK_SUCCESS;
665
666 switch (params->op) {
667 case VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR: {
668 const struct VkVideoDecodeH264SessionParametersAddInfoKHR *h264_add =
669 vk_find_struct_const(update->pNext, VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR);
670 return update_h264_dec_session_parameters(params, h264_add);
671 }
672 case VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR: {
673 const struct VkVideoDecodeH265SessionParametersAddInfoKHR *h265_add =
674 vk_find_struct_const(update->pNext, VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR);
675
676 return update_h265_session_parameters(params, h265_add);
677 }
678 case VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR: {
679 const struct VkVideoEncodeH264SessionParametersAddInfoKHR *h264_add =
680 vk_find_struct_const(update->pNext, VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR);
681 return update_h264_enc_session_parameters(params, h264_add);
682 }
683 case VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR: {
684 const struct VkVideoEncodeH265SessionParametersAddInfoKHR *h265_add =
685 vk_find_struct_const(update->pNext, VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR);
686 return update_h265_enc_session_parameters(params, h265_add);
687 }
688 default:
689 unreachable("Unknown codec\n");
690 }
691 return result;
692 }
693
694 const uint8_t h264_scaling_list_default_4x4_intra[] =
695 {
696 /* Table 7-3 - Default_4x4_Intra */
697 6, 13, 13, 20, 20, 20, 28, 28, 28, 28, 32, 32, 32, 37, 37, 42
698 };
699
700 const uint8_t h264_scaling_list_default_4x4_inter[] =
701 {
702 /* Table 7-3 - Default_4x4_Inter */
703 10, 14, 14, 20, 20, 20, 24, 24, 24, 24, 27, 27, 27, 30, 30, 34
704 };
705
706 const uint8_t h264_scaling_list_default_8x8_intra[] =
707 {
708 /* Table 7-4 - Default_8x8_Intra */
709 6, 10, 10, 13, 11, 13, 16, 16, 16, 16, 18, 18, 18, 18, 18, 23,
710 23, 23, 23, 23, 23, 25, 25, 25, 25, 25, 25, 25, 27, 27, 27, 27,
711 27, 27, 27, 27, 29, 29, 29, 29, 29, 29, 29, 31, 31, 31, 31, 31,
712 31, 33, 33, 33, 33, 33, 36, 36, 36, 36, 38, 38, 38, 40, 40, 42,
713 };
714
715 const uint8_t h264_scaling_list_default_8x8_inter[] =
716 {
717 /* Table 7-4 - Default_8x8_Inter */
718 9 , 13, 13, 15, 13, 15, 17, 17, 17, 17, 19, 19, 19, 19, 19, 21,
719 21, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 24, 24, 24, 24,
720 24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 27, 27, 27, 27, 27,
721 27, 28, 28, 28, 28, 28, 30, 30, 30, 30, 32, 32, 32, 33, 33, 35,
722 };
723
724 void
vk_video_derive_h264_scaling_list(const StdVideoH264SequenceParameterSet * sps,const StdVideoH264PictureParameterSet * pps,StdVideoH264ScalingLists * list)725 vk_video_derive_h264_scaling_list(const StdVideoH264SequenceParameterSet *sps,
726 const StdVideoH264PictureParameterSet *pps,
727 StdVideoH264ScalingLists *list)
728 {
729 StdVideoH264ScalingLists temp;
730
731 /* derive SPS scaling list first, because PPS may depend on it in fall-back
732 * rule B */
733 if (sps->flags.seq_scaling_matrix_present_flag)
734 {
735 for (int i = 0; i < STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS; i++)
736 {
737 if (sps->pScalingLists->scaling_list_present_mask & (1 << i))
738 memcpy(temp.ScalingList4x4[i],
739 pps->pScalingLists->ScalingList4x4[i],
740 STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS);
741 else /* fall-back rule A */
742 {
743 if (i == 0)
744 memcpy(temp.ScalingList4x4[i],
745 h264_scaling_list_default_4x4_intra,
746 STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS);
747 else if (i == 3)
748 memcpy(temp.ScalingList4x4[i],
749 h264_scaling_list_default_4x4_inter,
750 STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS);
751 else
752 memcpy(temp.ScalingList4x4[i],
753 temp.ScalingList4x4[i - 1],
754 STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS);
755 }
756 }
757
758 for (int j = 0; j < STD_VIDEO_H264_SCALING_LIST_8X8_NUM_LISTS; j++)
759 {
760 int i = j + STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS;
761 if (sps->pScalingLists->scaling_list_present_mask & (1 << i))
762 memcpy(temp.ScalingList8x8[j], pps->pScalingLists->ScalingList8x8[j],
763 STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS);
764 else /* fall-back rule A */
765 {
766 if (i == 6)
767 memcpy(temp.ScalingList8x8[j],
768 h264_scaling_list_default_8x8_intra,
769 STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS);
770 else if (i == 7)
771 memcpy(temp.ScalingList8x8[j],
772 h264_scaling_list_default_8x8_inter,
773 STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS);
774 else
775 memcpy(temp.ScalingList8x8[j], temp.ScalingList8x8[j - 2],
776 STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS);
777 }
778 }
779 }
780 else
781 {
782 memset(temp.ScalingList4x4, 0x10,
783 STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS *
784 STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS);
785 memset(temp.ScalingList8x8, 0x10,
786 STD_VIDEO_H264_SCALING_LIST_8X8_NUM_LISTS *
787 STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS);
788 }
789
790 if (pps->flags.pic_scaling_matrix_present_flag)
791 {
792 for (int i = 0; i < STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS; i++)
793 {
794 if (pps->pScalingLists->scaling_list_present_mask & (1 << i))
795 memcpy(list->ScalingList4x4[i], pps->pScalingLists->ScalingList4x4[i],
796 STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS);
797 else if (sps->flags.seq_scaling_matrix_present_flag) /* fall-back rule B */
798 {
799 if (i == 0 || i == 3)
800 memcpy(list->ScalingList4x4[i], temp.ScalingList4x4[i],
801 STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS);
802 else
803 memcpy(list->ScalingList4x4[i], list->ScalingList4x4[i - 1],
804 STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS);
805 }
806 else /* fall-back rule A */
807 {
808 if (i == 0)
809 memcpy(list->ScalingList4x4[i],
810 h264_scaling_list_default_4x4_intra,
811 STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS);
812 else if (i == 3)
813 memcpy(list->ScalingList4x4[i],
814 h264_scaling_list_default_4x4_inter,
815 STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS);
816 else
817 memcpy(list->ScalingList4x4[i],
818 list->ScalingList4x4[i - 1],
819 STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS);
820 }
821 }
822
823 for (int j = 0; j < STD_VIDEO_H264_SCALING_LIST_8X8_NUM_LISTS; j++)
824 {
825 int i = j + STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS;
826 if (pps->pScalingLists->scaling_list_present_mask & (1 << i))
827 memcpy(list->ScalingList8x8[j], pps->pScalingLists->ScalingList8x8[j],
828 STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS);
829 else if (sps->flags.seq_scaling_matrix_present_flag) /* fall-back rule B */
830 {
831 if (i == 6 || i == 7)
832 memcpy(list->ScalingList8x8[j], temp.ScalingList8x8[j],
833 STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS);
834 else
835 memcpy(list->ScalingList8x8[j], list->ScalingList8x8[j - 2],
836 STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS);
837 }
838 else /* fall-back rule A */
839 {
840 if (i == 6)
841 memcpy(list->ScalingList8x8[j],
842 h264_scaling_list_default_8x8_intra,
843 STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS);
844 else if (i == 7)
845 memcpy(list->ScalingList8x8[j],
846 h264_scaling_list_default_8x8_inter,
847 STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS);
848 else
849 memcpy(list->ScalingList8x8[j], list->ScalingList8x8[j - 2],
850 STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS);
851 }
852 }
853 }
854 else
855 {
856 memcpy(list->ScalingList4x4, temp.ScalingList4x4,
857 STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS *
858 STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS);
859 memcpy(list->ScalingList8x8, temp.ScalingList8x8,
860 STD_VIDEO_H264_SCALING_LIST_8X8_NUM_LISTS *
861 STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS);
862 }
863 }
864
865 const StdVideoH264SequenceParameterSet *
vk_video_find_h264_dec_std_sps(const struct vk_video_session_parameters * params,uint32_t id)866 vk_video_find_h264_dec_std_sps(const struct vk_video_session_parameters *params,
867 uint32_t id)
868 {
869 return &find_h264_dec_h264_sps(params, id)->base;
870 }
871
872 const StdVideoH264PictureParameterSet *
vk_video_find_h264_dec_std_pps(const struct vk_video_session_parameters * params,uint32_t id)873 vk_video_find_h264_dec_std_pps(const struct vk_video_session_parameters *params,
874 uint32_t id)
875 {
876 return &find_h264_dec_h264_pps(params, id)->base;
877 }
878
879 const StdVideoH265VideoParameterSet *
vk_video_find_h265_dec_std_vps(const struct vk_video_session_parameters * params,uint32_t id)880 vk_video_find_h265_dec_std_vps(const struct vk_video_session_parameters *params,
881 uint32_t id)
882 {
883 return &find_h265_dec_h265_vps(params, id)->base;
884 }
885
886 const StdVideoH265SequenceParameterSet *
vk_video_find_h265_dec_std_sps(const struct vk_video_session_parameters * params,uint32_t id)887 vk_video_find_h265_dec_std_sps(const struct vk_video_session_parameters *params,
888 uint32_t id)
889 {
890 return &find_h265_dec_h265_sps(params, id)->base;
891 }
892
893 const StdVideoH265PictureParameterSet *
vk_video_find_h265_dec_std_pps(const struct vk_video_session_parameters * params,uint32_t id)894 vk_video_find_h265_dec_std_pps(const struct vk_video_session_parameters *params,
895 uint32_t id)
896 {
897 return &find_h265_dec_h265_pps(params, id)->base;
898 }
899
900 int
vk_video_h265_poc_by_slot(const struct VkVideoDecodeInfoKHR * frame_info,int slot)901 vk_video_h265_poc_by_slot(const struct VkVideoDecodeInfoKHR *frame_info, int slot)
902 {
903 for (unsigned i = 0; i < frame_info->referenceSlotCount; i++) {
904 const VkVideoDecodeH265DpbSlotInfoKHR *dpb_slot_info =
905 vk_find_struct_const(frame_info->pReferenceSlots[i].pNext, VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR);
906 if (frame_info->pReferenceSlots[i].slotIndex == slot)
907 return dpb_slot_info->pStdReferenceInfo->PicOrderCntVal;
908 }
909
910 assert(0);
911
912 return 0;
913 }
914
915 void
vk_fill_video_h265_reference_info(const VkVideoDecodeInfoKHR * frame_info,const struct VkVideoDecodeH265PictureInfoKHR * pic,const struct vk_video_h265_slice_params * slice_params,struct vk_video_h265_reference ref_slots[][8])916 vk_fill_video_h265_reference_info(const VkVideoDecodeInfoKHR *frame_info,
917 const struct VkVideoDecodeH265PictureInfoKHR *pic,
918 const struct vk_video_h265_slice_params *slice_params,
919 struct vk_video_h265_reference ref_slots[][8])
920 {
921 uint8_t list_cnt = slice_params->slice_type == STD_VIDEO_H265_SLICE_TYPE_B ? 2 : 1;
922 uint8_t list_idx;
923 int i, j;
924
925 for (list_idx = 0; list_idx < list_cnt; list_idx++) {
926 /* The order is
927 * L0: Short term current before set - Short term current after set - long term current
928 * L1: Short term current after set - short term current before set - long term current
929 */
930 const uint8_t *rps[3] = {
931 list_idx ? pic->pStdPictureInfo->RefPicSetStCurrAfter : pic->pStdPictureInfo->RefPicSetStCurrBefore,
932 list_idx ? pic->pStdPictureInfo->RefPicSetStCurrBefore : pic->pStdPictureInfo->RefPicSetStCurrAfter,
933 pic->pStdPictureInfo->RefPicSetLtCurr
934 };
935
936 uint8_t ref_idx = 0;
937 for (i = 0; i < 3; i++) {
938 const uint8_t *cur_rps = rps[i];
939
940 for (j = 0; (cur_rps[j] != 0xff) && ((j + ref_idx) < 8); j++) {
941 ref_slots[list_idx][j + ref_idx].slot_index = cur_rps[j];
942 ref_slots[list_idx][j + ref_idx].pic_order_cnt = vk_video_h265_poc_by_slot(frame_info, cur_rps[j]);
943 }
944 ref_idx += j;
945 }
946
947 /* TODO: should handle cases where rpl_modification_flag is true. */
948 assert(!slice_params->rpl_modification_flag[0] && !slice_params->rpl_modification_flag[1]);
949 }
950 }
951
952 static void
h265_pred_weight_table(struct vk_video_h265_slice_params * params,struct vl_rbsp * rbsp,const StdVideoH265SequenceParameterSet * sps,StdVideoH265SliceType slice_type)953 h265_pred_weight_table(struct vk_video_h265_slice_params *params,
954 struct vl_rbsp *rbsp,
955 const StdVideoH265SequenceParameterSet *sps,
956 StdVideoH265SliceType slice_type)
957 {
958 unsigned chroma_array_type = sps->flags.separate_colour_plane_flag ? 0 : sps->chroma_format_idc;
959 unsigned i, j;
960
961 params->luma_log2_weight_denom = vl_rbsp_ue(rbsp);
962
963 assert(params->luma_log2_weight_denom >= 0 && params->luma_log2_weight_denom < 8);
964
965 if (chroma_array_type != 0) {
966 params->chroma_log2_weight_denom = params->luma_log2_weight_denom + vl_rbsp_se(rbsp);
967 assert(params->chroma_log2_weight_denom >= 0 && params->chroma_log2_weight_denom < 8);
968 }
969
970 for (i = 0; i < params->num_ref_idx_l0_active; ++i) {
971 params->luma_weight_l0_flag[i] = vl_rbsp_u(rbsp, 1);
972 if (!params->luma_weight_l0_flag[i]) {
973 params->luma_weight_l0[i] = 1 << params->luma_log2_weight_denom;
974 params->luma_offset_l0[i] = 0;
975 }
976 }
977
978 for (i = 0; i < params->num_ref_idx_l0_active; ++i) {
979 if (chroma_array_type == 0) {
980 params->chroma_weight_l0_flag[i] = 0;
981 } else {
982 params->chroma_weight_l0_flag[i] = vl_rbsp_u(rbsp, 1);
983 }
984 }
985
986 for (i = 0; i < params->num_ref_idx_l0_active; ++i) {
987 if (params->luma_weight_l0_flag[i]) {
988 params->delta_luma_weight_l0[i] = vl_rbsp_se(rbsp);
989 params->luma_weight_l0[i] = (1 << params->luma_log2_weight_denom) + params->delta_luma_weight_l0[i];
990 params->luma_offset_l0[i] = vl_rbsp_se(rbsp);
991 }
992
993 if (params->chroma_weight_l0_flag[i]) {
994 for (j = 0; j < 2; j++) {
995 params->delta_chroma_weight_l0[i][j] = vl_rbsp_se(rbsp);
996 params->delta_chroma_offset_l0[i][j] = vl_rbsp_se(rbsp);
997
998 params->chroma_weight_l0[i][j] =
999 (1 << params->chroma_log2_weight_denom) + params->delta_chroma_weight_l0[i][j];
1000 params->chroma_offset_l0[i][j] = CLAMP(params->delta_chroma_offset_l0[i][j] -
1001 ((128 * params->chroma_weight_l0[i][j]) >> params->chroma_log2_weight_denom) + 128, -128, 127);
1002 }
1003 } else {
1004 for (j = 0; j < 2; j++) {
1005 params->chroma_weight_l0[i][j] = 1 << params->chroma_log2_weight_denom;
1006 params->chroma_offset_l0[i][j] = 0;
1007 }
1008 }
1009 }
1010
1011 if (slice_type == STD_VIDEO_H265_SLICE_TYPE_B) {
1012 for (i = 0; i < params->num_ref_idx_l1_active; ++i) {
1013 params->luma_weight_l1_flag[i] = vl_rbsp_u(rbsp, 1);
1014 if (!params->luma_weight_l1_flag[i]) {
1015 params->luma_weight_l1[i] = 1 << params->luma_log2_weight_denom;
1016 params->luma_offset_l1[i] = 0;
1017 }
1018 }
1019
1020 for (i = 0; i < params->num_ref_idx_l1_active; ++i) {
1021 if (chroma_array_type == 0) {
1022 params->chroma_weight_l1_flag[i] = 0;
1023 } else {
1024 params->chroma_weight_l1_flag[i] = vl_rbsp_u(rbsp, 1);
1025 }
1026 }
1027
1028 for (i = 0; i < params->num_ref_idx_l1_active; ++i) {
1029 if (params->luma_weight_l1_flag[i]) {
1030 params->delta_luma_weight_l1[i] = vl_rbsp_se(rbsp);
1031 params->luma_weight_l1[i] =
1032 (1 << params->luma_log2_weight_denom) + params->delta_luma_weight_l1[i];
1033 params->luma_offset_l1[i] = vl_rbsp_se(rbsp);
1034 }
1035
1036 if (params->chroma_weight_l1_flag[i]) {
1037 for (j = 0; j < 2; j++) {
1038 params->delta_chroma_weight_l1[i][j] = vl_rbsp_se(rbsp);
1039 params->delta_chroma_offset_l1[i][j] = vl_rbsp_se(rbsp);
1040
1041 params->chroma_weight_l1[i][j] =
1042 (1 << params->chroma_log2_weight_denom) + params->delta_chroma_weight_l1[i][j];
1043 params->chroma_offset_l1[i][j] = CLAMP(params->delta_chroma_offset_l1[i][j] -
1044 ((128 * params->chroma_weight_l1[i][j]) >> params->chroma_log2_weight_denom) + 128, -128, 127);
1045 }
1046 } else {
1047 for (j = 0; j < 2; j++) {
1048 params->chroma_weight_l1[i][j] = 1 << params->chroma_log2_weight_denom;
1049 params->chroma_offset_l1[i][j] = 0;
1050 }
1051 }
1052 }
1053 }
1054 }
1055
1056 void
vk_video_parse_h265_slice_header(const struct VkVideoDecodeInfoKHR * frame_info,const VkVideoDecodeH265PictureInfoKHR * pic_info,const StdVideoH265SequenceParameterSet * sps,const StdVideoH265PictureParameterSet * pps,void * slice_data,uint32_t slice_size,struct vk_video_h265_slice_params * params)1057 vk_video_parse_h265_slice_header(const struct VkVideoDecodeInfoKHR *frame_info,
1058 const VkVideoDecodeH265PictureInfoKHR *pic_info,
1059 const StdVideoH265SequenceParameterSet *sps,
1060 const StdVideoH265PictureParameterSet *pps,
1061 void *slice_data,
1062 uint32_t slice_size,
1063 struct vk_video_h265_slice_params *params)
1064 {
1065 struct vl_vlc vlc;
1066 const void *slice_headers[1] = { slice_data };
1067 vl_vlc_init(&vlc, 1, slice_headers, &slice_size);
1068
1069 assert(vl_vlc_peekbits(&vlc, 24) == 0x000001);
1070
1071 vl_vlc_eatbits(&vlc, 24);
1072
1073 /* forbidden_zero_bit */
1074 vl_vlc_eatbits(&vlc, 1);
1075
1076 if (vl_vlc_valid_bits(&vlc) < 15)
1077 vl_vlc_fillbits(&vlc);
1078
1079 vl_vlc_get_uimsbf(&vlc, 6); /* nal_unit_type */
1080 vl_vlc_get_uimsbf(&vlc, 6); /* nuh_layer_id */
1081 vl_vlc_get_uimsbf(&vlc, 3); /* nuh_temporal_id_plus1 */
1082
1083 struct vl_rbsp rbsp;
1084 vl_rbsp_init(&rbsp, &vlc, 128, /* emulation_bytes */ true);
1085
1086 memset(params, 0, sizeof(*params));
1087
1088 params->slice_size = slice_size;
1089 params->first_slice_segment_in_pic_flag = vl_rbsp_u(&rbsp, 1);
1090
1091 /* no_output_of_prior_pics_flag */
1092 if (pic_info->pStdPictureInfo->flags.IrapPicFlag)
1093 vl_rbsp_u(&rbsp, 1);
1094
1095 /* pps id */
1096 vl_rbsp_ue(&rbsp);
1097
1098 if (!params->first_slice_segment_in_pic_flag) {
1099 int size, num;
1100 int bits_slice_segment_address = 0;
1101
1102 if (pps->flags.dependent_slice_segments_enabled_flag)
1103 params->dependent_slice_segment = vl_rbsp_u(&rbsp, 1);
1104
1105 size = 1 << (sps->log2_min_luma_coding_block_size_minus3 + 3 +
1106 sps->log2_diff_max_min_luma_coding_block_size);
1107
1108 num = ((sps->pic_width_in_luma_samples + size - 1) / size) *
1109 ((sps->pic_height_in_luma_samples + size - 1) / size);
1110
1111 while (num > (1 << bits_slice_segment_address))
1112 bits_slice_segment_address++;
1113
1114 /* slice_segment_address */
1115 params->slice_segment_address = vl_rbsp_u(&rbsp, bits_slice_segment_address);
1116 }
1117
1118 if (params->dependent_slice_segment)
1119 return;
1120
1121 for (unsigned i = 0; i < pps->num_extra_slice_header_bits; ++i)
1122 /* slice_reserved_flag */
1123 vl_rbsp_u(&rbsp, 1);
1124
1125 /* slice_type */
1126 params->slice_type = vl_rbsp_ue(&rbsp);
1127
1128 if (pps->flags.output_flag_present_flag)
1129 /* pic output flag */
1130 vl_rbsp_u(&rbsp, 1);
1131
1132 if (sps->flags.separate_colour_plane_flag)
1133 /* colour_plane_id */
1134 vl_rbsp_u(&rbsp, 2);
1135
1136 if (!pic_info->pStdPictureInfo->flags.IdrPicFlag) {
1137 /* slice_pic_order_cnt_lsb */
1138 params->pic_order_cnt_lsb =
1139 vl_rbsp_u(&rbsp, sps->log2_max_pic_order_cnt_lsb_minus4 + 4);
1140
1141 /* short_term_ref_pic_set_sps_flag */
1142 if (!vl_rbsp_u(&rbsp, 1)) {
1143 uint8_t rps_predict = 0;
1144
1145 if (sps->num_short_term_ref_pic_sets)
1146 rps_predict = vl_rbsp_u(&rbsp, 1);
1147
1148 if (rps_predict) {
1149 /* delta_idx */
1150 vl_rbsp_ue(&rbsp);
1151 /* delta_rps_sign */
1152 vl_rbsp_u(&rbsp, 1);
1153 /* abs_delta_rps */
1154 vl_rbsp_ue(&rbsp);
1155
1156 for (int i = 0 ; i <= pic_info->pStdPictureInfo->NumDeltaPocsOfRefRpsIdx; i++) {
1157 uint8_t used = vl_rbsp_u(&rbsp, 1);
1158 if (!used)
1159 vl_rbsp_u(&rbsp, 1);
1160 }
1161 } else {
1162 /* num_negative_pics */
1163 unsigned num_neg_pics = vl_rbsp_ue(&rbsp);
1164 /* num_positive_pics */
1165 unsigned num_pos_pics = vl_rbsp_ue(&rbsp);
1166
1167 for(unsigned i = 0 ; i < num_neg_pics; ++i) {
1168 /* delta_poc_s0_minus1 */
1169 vl_rbsp_ue(&rbsp);
1170 /* used_by_curr_pic_s0_flag */
1171 vl_rbsp_u(&rbsp, 1);
1172 }
1173
1174 for(unsigned i = 0; i < num_pos_pics; ++i) {
1175 /* delta_poc_s1_minus1 */
1176 vl_rbsp_ue(&rbsp);
1177 /* used_by_curr_pic_s0_flag */
1178 vl_rbsp_u(&rbsp, 1);
1179 }
1180 }
1181
1182 } else {
1183 unsigned num_st_rps = sps->num_short_term_ref_pic_sets;
1184
1185 int numbits = util_logbase2_ceil(num_st_rps);
1186 if (numbits > 0)
1187 /* short_term_ref_pic_set_idx */
1188 vl_rbsp_u(&rbsp, numbits);
1189 }
1190
1191 if (sps->flags.long_term_ref_pics_present_flag) {
1192 unsigned num_lt_sps = 0;
1193
1194 if (sps->num_long_term_ref_pics_sps > 0)
1195 num_lt_sps = vl_rbsp_ue(&rbsp);
1196
1197 unsigned num_lt_pics = vl_rbsp_ue(&rbsp);
1198 unsigned num_refs = num_lt_pics + num_lt_sps;
1199
1200 for (unsigned i = 0; i < num_refs; i++) {
1201 if (i < num_lt_sps) {
1202 if (sps->num_long_term_ref_pics_sps > 1)
1203 /* lt_idx_sps */
1204 vl_rbsp_u(&rbsp,
1205 util_logbase2_ceil(sps->num_long_term_ref_pics_sps));
1206 } else {
1207 /* poc_lsb_lt */
1208 vl_rbsp_u(&rbsp, sps->log2_max_pic_order_cnt_lsb_minus4 + 4);
1209 /* used_by_curr_pic_lt_flag */
1210 vl_rbsp_u(&rbsp, 1);
1211 }
1212
1213 /* poc_msb_present */
1214 if (vl_rbsp_u(&rbsp, 1)) {
1215 /* delta_poc_msb_cycle_lt */
1216 vl_rbsp_ue(&rbsp);
1217 }
1218 }
1219 }
1220
1221 if (sps->flags.sps_temporal_mvp_enabled_flag)
1222 params->temporal_mvp_enable = vl_rbsp_u(&rbsp, 1);
1223 }
1224
1225 if (sps->flags.sample_adaptive_offset_enabled_flag) {
1226 params->sao_luma_flag = vl_rbsp_u(&rbsp, 1);
1227 if (sps->chroma_format_idc)
1228 params->sao_chroma_flag = vl_rbsp_u(&rbsp, 1);
1229 }
1230
1231 params->max_num_merge_cand = 5;
1232
1233 if (params->slice_type != STD_VIDEO_H265_SLICE_TYPE_I) {
1234
1235 params->num_ref_idx_l0_active = pps->num_ref_idx_l0_default_active_minus1 + 1;
1236
1237 if (params->slice_type == STD_VIDEO_H265_SLICE_TYPE_B)
1238 params->num_ref_idx_l1_active = pps->num_ref_idx_l1_default_active_minus1 + 1;
1239 else
1240 params->num_ref_idx_l1_active = 0;
1241
1242 /* num_ref_idx_active_override_flag */
1243 if (vl_rbsp_u(&rbsp, 1)) {
1244 params->num_ref_idx_l0_active = vl_rbsp_ue(&rbsp) + 1;
1245 if (params->slice_type == STD_VIDEO_H265_SLICE_TYPE_B)
1246 params->num_ref_idx_l1_active = vl_rbsp_ue(&rbsp) + 1;
1247 }
1248
1249 if (pps->flags.lists_modification_present_flag) {
1250 params->rpl_modification_flag[0] = vl_rbsp_u(&rbsp, 1);
1251 if (params->rpl_modification_flag[0]) {
1252 for (int i = 0; i < params->num_ref_idx_l0_active; i++) {
1253 /* list_entry_l0 */
1254 vl_rbsp_u(&rbsp,
1255 util_logbase2_ceil(params->num_ref_idx_l0_active + params->num_ref_idx_l1_active));
1256 }
1257 }
1258
1259 if (params->slice_type == STD_VIDEO_H265_SLICE_TYPE_B) {
1260 params->rpl_modification_flag[1] = vl_rbsp_u(&rbsp, 1);
1261 if (params->rpl_modification_flag[1]) {
1262 for (int i = 0; i < params->num_ref_idx_l1_active; i++) {
1263 /* list_entry_l1 */
1264 vl_rbsp_u(&rbsp,
1265 util_logbase2_ceil(params->num_ref_idx_l0_active + params->num_ref_idx_l1_active));
1266 }
1267 }
1268 }
1269 }
1270
1271 if (params->slice_type == STD_VIDEO_H265_SLICE_TYPE_B)
1272 params->mvd_l1_zero_flag = vl_rbsp_u(&rbsp, 1);
1273
1274 if (pps->flags.cabac_init_present_flag)
1275 /* cabac_init_flag */
1276 params->cabac_init_idc = vl_rbsp_u(&rbsp, 1);
1277
1278 if (params->temporal_mvp_enable) {
1279 if (params->slice_type == STD_VIDEO_H265_SLICE_TYPE_B)
1280 params->collocated_list = !vl_rbsp_u(&rbsp, 1);
1281
1282 if (params->collocated_list == 0) {
1283 if (params->num_ref_idx_l0_active > 1)
1284 params->collocated_ref_idx = vl_rbsp_ue(&rbsp);
1285 } else if (params->collocated_list == 1) {
1286 if (params->num_ref_idx_l1_active > 1)
1287 params->collocated_ref_idx = vl_rbsp_ue(&rbsp);
1288 }
1289 }
1290
1291 if ((pps->flags.weighted_pred_flag && params->slice_type == STD_VIDEO_H265_SLICE_TYPE_P) ||
1292 (pps->flags.weighted_bipred_flag && params->slice_type == STD_VIDEO_H265_SLICE_TYPE_B)) {
1293 h265_pred_weight_table(params, &rbsp, sps, params->slice_type);
1294 }
1295
1296 params->max_num_merge_cand -= vl_rbsp_ue(&rbsp);
1297 }
1298
1299 params->slice_qp_delta = vl_rbsp_se(&rbsp);
1300
1301 if (pps->flags.pps_slice_chroma_qp_offsets_present_flag) {
1302 params->slice_cb_qp_offset = vl_rbsp_se(&rbsp);
1303 params->slice_cr_qp_offset = vl_rbsp_se(&rbsp);
1304 }
1305
1306 if (pps->flags.chroma_qp_offset_list_enabled_flag)
1307 /* cu_chroma_qp_offset_enabled_flag */
1308 vl_rbsp_u(&rbsp, 1);
1309
1310 if (pps->flags.deblocking_filter_control_present_flag) {
1311 if (pps->flags.deblocking_filter_override_enabled_flag) {
1312 /* deblocking_filter_override_flag */
1313 if (vl_rbsp_u(&rbsp, 1)) {
1314 params->disable_deblocking_filter_idc = vl_rbsp_u(&rbsp, 1);
1315
1316 if (!params->disable_deblocking_filter_idc) {
1317 params->beta_offset_div2 = vl_rbsp_se(&rbsp);
1318 params->tc_offset_div2 = vl_rbsp_se(&rbsp);
1319 }
1320 } else {
1321 params->disable_deblocking_filter_idc =
1322 pps->flags.pps_deblocking_filter_disabled_flag;
1323 }
1324 }
1325 }
1326
1327 if (pps->flags.pps_loop_filter_across_slices_enabled_flag &&
1328 (params->sao_luma_flag || params->sao_chroma_flag ||
1329 !params->disable_deblocking_filter_idc))
1330 params->loop_filter_across_slices_enable = vl_rbsp_u(&rbsp, 1);
1331
1332 if (pps->flags.tiles_enabled_flag || pps->flags.entropy_coding_sync_enabled_flag) {
1333 unsigned num_entry_points_offsets = vl_rbsp_ue(&rbsp);
1334
1335 if (num_entry_points_offsets > 0) {
1336 unsigned offset_len = vl_rbsp_ue(&rbsp) + 1;
1337 for (unsigned i = 0; i < num_entry_points_offsets; i++) {
1338 /* entry_point_offset_minus1 */
1339 vl_rbsp_u(&rbsp, offset_len);
1340 }
1341 }
1342 }
1343
1344 if (pps->flags.pps_extension_present_flag) {
1345 unsigned length = vl_rbsp_ue(&rbsp);
1346 for (unsigned i = 0; i < length; i++)
1347 /* slice_reserved_undetermined_flag */
1348 vl_rbsp_u(&rbsp, 1);
1349 }
1350
1351 unsigned header_bits =
1352 (slice_size * 8 - 24 /* start code */) - vl_vlc_bits_left(&rbsp.nal) - rbsp.removed;
1353 params->slice_data_bytes_offset = (header_bits + 8) / 8;
1354 }
1355
1356 void
vk_video_get_profile_alignments(const VkVideoProfileListInfoKHR * profile_list,uint32_t * width_align_out,uint32_t * height_align_out)1357 vk_video_get_profile_alignments(const VkVideoProfileListInfoKHR *profile_list,
1358 uint32_t *width_align_out, uint32_t *height_align_out)
1359 {
1360 uint32_t width_align = 1, height_align = 1;
1361 for (unsigned i = 0; i < profile_list->profileCount; i++) {
1362 if (profile_list->pProfiles[i].videoCodecOperation == VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR ||
1363 profile_list->pProfiles[i].videoCodecOperation == VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR
1364 ) {
1365 width_align = MAX2(width_align, VK_VIDEO_H264_MACROBLOCK_WIDTH);
1366 height_align = MAX2(height_align, VK_VIDEO_H264_MACROBLOCK_HEIGHT);
1367 }
1368 if (profile_list->pProfiles[i].videoCodecOperation == VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR ||
1369 profile_list->pProfiles[i].videoCodecOperation == VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR
1370 ) {
1371 width_align = MAX2(width_align, VK_VIDEO_H265_CTU_MAX_WIDTH);
1372 height_align = MAX2(height_align, VK_VIDEO_H265_CTU_MAX_HEIGHT);
1373 }
1374 if (profile_list->pProfiles[i].videoCodecOperation == VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR) {
1375 width_align = MAX2(width_align, VK_VIDEO_AV1_BLOCK_WIDTH);
1376 height_align = MAX2(height_align, VK_VIDEO_AV1_BLOCK_HEIGHT);
1377 }
1378 }
1379 *width_align_out = width_align;
1380 *height_align_out = height_align;
1381 }
1382
1383 static const uint8_t vk_video_h264_levels[] = {10, 11, 12, 13, 20, 21, 22, 30, 31, 32, 40, 41, 42, 50, 51, 52, 60, 61, 62};
1384 uint8_t
vk_video_get_h264_level(StdVideoH264LevelIdc level)1385 vk_video_get_h264_level(StdVideoH264LevelIdc level)
1386 {
1387 assert(level <= STD_VIDEO_H264_LEVEL_IDC_6_2);
1388 return vk_video_h264_levels[level];
1389 }
1390
1391 const StdVideoH264SequenceParameterSet *
vk_video_find_h264_enc_std_sps(const struct vk_video_session_parameters * params,uint32_t id)1392 vk_video_find_h264_enc_std_sps(const struct vk_video_session_parameters *params,
1393 uint32_t id)
1394 {
1395 return &find_h264_enc_h264_sps(params, id)->base;
1396 }
1397
1398 const StdVideoH264PictureParameterSet *
vk_video_find_h264_enc_std_pps(const struct vk_video_session_parameters * params,uint32_t id)1399 vk_video_find_h264_enc_std_pps(const struct vk_video_session_parameters *params,
1400 uint32_t id)
1401 {
1402 return &find_h264_enc_h264_pps(params, id)->base;
1403 }
1404
1405 const StdVideoH265VideoParameterSet *
vk_video_find_h265_enc_std_vps(const struct vk_video_session_parameters * params,uint32_t id)1406 vk_video_find_h265_enc_std_vps(const struct vk_video_session_parameters *params,
1407 uint32_t id)
1408 {
1409 return &find_h265_enc_h265_vps(params, id)->base;
1410 }
1411
1412 const StdVideoH265SequenceParameterSet *
vk_video_find_h265_enc_std_sps(const struct vk_video_session_parameters * params,uint32_t id)1413 vk_video_find_h265_enc_std_sps(const struct vk_video_session_parameters *params,
1414 uint32_t id)
1415 {
1416 return &find_h265_enc_h265_sps(params, id)->base;
1417 }
1418
1419 const StdVideoH265PictureParameterSet *
vk_video_find_h265_enc_std_pps(const struct vk_video_session_parameters * params,uint32_t id)1420 vk_video_find_h265_enc_std_pps(const struct vk_video_session_parameters *params,
1421 uint32_t id)
1422 {
1423 return &find_h265_enc_h265_pps(params, id)->base;
1424 }
1425
1426 enum H264NALUType
1427 {
1428 H264_NAL_UNSPECIFIED = 0,
1429 H264_NAL_SLICE = 1,
1430 H264_NAL_SLICEDATA_A = 2,
1431 H264_NAL_SLICEDATA_B = 3,
1432 H264_NAL_SLICEDATA_C = 4,
1433 H264_NAL_IDR = 5,
1434 H264_NAL_SEI = 6,
1435 H264_NAL_SPS = 7,
1436 H264_NAL_PPS = 8,
1437 H264_NAL_ACCESS_UNIT_DEMILITER = 9,
1438 H264_NAL_END_OF_SEQUENCE = 10,
1439 H264_NAL_END_OF_STREAM = 11,
1440 H264_NAL_FILLER_DATA = 12,
1441 H264_NAL_SPS_EXTENSION = 13,
1442 H264_NAL_PREFIX = 14,
1443 /* 15...18 RESERVED */
1444 H264_NAL_AUXILIARY_SLICE = 19,
1445 /* 20...23 RESERVED */
1446 /* 24...31 UNSPECIFIED */
1447 };
1448
1449 enum HEVCNALUnitType {
1450 HEVC_NAL_TRAIL_N = 0,
1451 HEVC_NAL_TRAIL_R = 1,
1452 HEVC_NAL_TSA_N = 2,
1453 HEVC_NAL_TSA_R = 3,
1454 HEVC_NAL_STSA_N = 4,
1455 HEVC_NAL_STSA_R = 5,
1456 HEVC_NAL_RADL_N = 6,
1457 HEVC_NAL_RADL_R = 7,
1458 HEVC_NAL_RASL_N = 8,
1459 HEVC_NAL_RASL_R = 9,
1460 HEVC_NAL_VCL_N10 = 10,
1461 HEVC_NAL_VCL_R11 = 11,
1462 HEVC_NAL_VCL_N12 = 12,
1463 HEVC_NAL_VCL_R13 = 13,
1464 HEVC_NAL_VCL_N14 = 14,
1465 HEVC_NAL_VCL_R15 = 15,
1466 HEVC_NAL_BLA_W_LP = 16,
1467 HEVC_NAL_BLA_W_RADL = 17,
1468 HEVC_NAL_BLA_N_LP = 18,
1469 HEVC_NAL_IDR_W_RADL = 19,
1470 HEVC_NAL_IDR_N_LP = 20,
1471 HEVC_NAL_CRA_NUT = 21,
1472 HEVC_NAL_VPS_NUT = 32,
1473 HEVC_NAL_SPS_NUT = 33,
1474 HEVC_NAL_PPS_NUT = 34,
1475 };
1476
1477 unsigned
vk_video_get_h265_nal_unit(StdVideoH265PictureType pic_type,bool irap_pic_flag)1478 vk_video_get_h265_nal_unit(StdVideoH265PictureType pic_type, bool irap_pic_flag)
1479 {
1480 switch (pic_type) {
1481 case STD_VIDEO_H265_PICTURE_TYPE_IDR:
1482 return HEVC_NAL_IDR_W_RADL;
1483 case STD_VIDEO_H265_PICTURE_TYPE_I:
1484 return HEVC_NAL_CRA_NUT;
1485 case STD_VIDEO_H265_PICTURE_TYPE_P:
1486 return HEVC_NAL_TRAIL_R;
1487 case STD_VIDEO_H265_PICTURE_TYPE_B:
1488 if (irap_pic_flag)
1489 return HEVC_NAL_RASL_R;
1490 else
1491 return HEVC_NAL_TRAIL_R;
1492 break;
1493 default:
1494 assert(0);
1495 break;
1496 }
1497 return 0;
1498 }
1499
1500 static const uint8_t vk_video_h265_levels[] = {10, 20, 21, 30, 31, 40, 41, 50, 51, 52, 60, 61, 62};
1501
1502 static uint8_t
vk_video_get_h265_level(StdVideoH265LevelIdc level)1503 vk_video_get_h265_level(StdVideoH265LevelIdc level)
1504 {
1505 assert(level <= STD_VIDEO_H265_LEVEL_IDC_6_2);
1506 return vk_video_h265_levels[level];
1507 }
1508
1509 static void
emit_nalu_header(struct vl_bitstream_encoder * enc,int nal_ref,int nal_unit)1510 emit_nalu_header(struct vl_bitstream_encoder *enc,
1511 int nal_ref, int nal_unit)
1512 {
1513 enc->prevent_start_code = false;
1514
1515 vl_bitstream_put_bits(enc, 24, 0);
1516 vl_bitstream_put_bits(enc, 8, 1);
1517 vl_bitstream_put_bits(enc, 1, 0);
1518 vl_bitstream_put_bits(enc, 2, nal_ref); /* SPS NAL REF */
1519 vl_bitstream_put_bits(enc, 5, nal_unit); /* SPS NAL UNIT */
1520 vl_bitstream_flush(enc);
1521
1522 enc->prevent_start_code = true;
1523 }
1524
1525 static void
encode_hrd_params(struct vl_bitstream_encoder * enc,const StdVideoH264HrdParameters * hrd)1526 encode_hrd_params(struct vl_bitstream_encoder *enc,
1527 const StdVideoH264HrdParameters *hrd)
1528 {
1529 vl_bitstream_exp_golomb_ue(enc, hrd->cpb_cnt_minus1);
1530 vl_bitstream_put_bits(enc, 4, hrd->bit_rate_scale);
1531 vl_bitstream_put_bits(enc, 4, hrd->cpb_size_scale);
1532 for (int sched_sel_idx = 0; sched_sel_idx <= hrd->cpb_cnt_minus1; sched_sel_idx++) {
1533 vl_bitstream_exp_golomb_ue(enc, hrd->bit_rate_value_minus1[sched_sel_idx]);
1534 vl_bitstream_exp_golomb_ue(enc, hrd->cpb_size_value_minus1[sched_sel_idx]);
1535 vl_bitstream_put_bits(enc, 1, hrd->cbr_flag[sched_sel_idx]);
1536 }
1537 vl_bitstream_put_bits(enc, 5, hrd->initial_cpb_removal_delay_length_minus1);
1538 vl_bitstream_put_bits(enc, 5, hrd->cpb_removal_delay_length_minus1);
1539 vl_bitstream_put_bits(enc, 5, hrd->dpb_output_delay_length_minus1);
1540 vl_bitstream_put_bits(enc, 5, hrd->time_offset_length);
1541 }
1542
1543 void
vk_video_encode_h264_sps(const StdVideoH264SequenceParameterSet * sps,size_t size_limit,size_t * data_size_ptr,void * data_ptr)1544 vk_video_encode_h264_sps(const StdVideoH264SequenceParameterSet *sps,
1545 size_t size_limit,
1546 size_t *data_size_ptr,
1547 void *data_ptr)
1548 {
1549 struct vl_bitstream_encoder enc;
1550 uint32_t data_size = *data_size_ptr;
1551
1552 vl_bitstream_encoder_clear(&enc, data_ptr, data_size, size_limit);
1553
1554 emit_nalu_header(&enc, 3, H264_NAL_SPS);
1555
1556 vl_bitstream_put_bits(&enc, 8, sps->profile_idc);
1557 vl_bitstream_put_bits(&enc, 1, sps->flags.constraint_set0_flag);
1558 vl_bitstream_put_bits(&enc, 1, sps->flags.constraint_set1_flag);
1559 vl_bitstream_put_bits(&enc, 1, sps->flags.constraint_set2_flag);
1560 vl_bitstream_put_bits(&enc, 1, sps->flags.constraint_set3_flag);
1561 vl_bitstream_put_bits(&enc, 1, sps->flags.constraint_set4_flag);
1562 vl_bitstream_put_bits(&enc, 1, sps->flags.constraint_set5_flag);
1563 vl_bitstream_put_bits(&enc, 2, 0);
1564 vl_bitstream_put_bits(&enc, 8, vk_video_get_h264_level(sps->level_idc));
1565 vl_bitstream_exp_golomb_ue(&enc, sps->seq_parameter_set_id);
1566
1567 if (sps->profile_idc == STD_VIDEO_H264_PROFILE_IDC_HIGH /* high10 as well */) {
1568 vl_bitstream_exp_golomb_ue(&enc, sps->chroma_format_idc);
1569 vl_bitstream_exp_golomb_ue(&enc, sps->bit_depth_luma_minus8);
1570 vl_bitstream_exp_golomb_ue(&enc, sps->bit_depth_chroma_minus8);
1571 vl_bitstream_put_bits(&enc, 1, sps->flags.qpprime_y_zero_transform_bypass_flag);
1572 vl_bitstream_put_bits(&enc, 1, sps->flags.seq_scaling_matrix_present_flag);
1573 }
1574
1575 vl_bitstream_exp_golomb_ue(&enc, sps->log2_max_frame_num_minus4);
1576
1577 vl_bitstream_exp_golomb_ue(&enc, sps->pic_order_cnt_type);
1578 if (sps->pic_order_cnt_type == 0)
1579 vl_bitstream_exp_golomb_ue(&enc, sps->log2_max_pic_order_cnt_lsb_minus4);
1580
1581 vl_bitstream_exp_golomb_ue(&enc, sps->max_num_ref_frames);
1582 vl_bitstream_put_bits(&enc, 1, sps->flags.gaps_in_frame_num_value_allowed_flag);
1583 vl_bitstream_exp_golomb_ue(&enc, sps->pic_width_in_mbs_minus1);
1584 vl_bitstream_exp_golomb_ue(&enc, sps->pic_height_in_map_units_minus1);
1585
1586 vl_bitstream_put_bits(&enc, 1, sps->flags.frame_mbs_only_flag);
1587 vl_bitstream_put_bits(&enc, 1, sps->flags.direct_8x8_inference_flag);
1588
1589 vl_bitstream_put_bits(&enc, 1, sps->flags.frame_cropping_flag);
1590 if (sps->flags.frame_cropping_flag) {
1591 vl_bitstream_exp_golomb_ue(&enc, sps->frame_crop_left_offset);
1592 vl_bitstream_exp_golomb_ue(&enc, sps->frame_crop_right_offset);
1593 vl_bitstream_exp_golomb_ue(&enc, sps->frame_crop_top_offset);
1594 vl_bitstream_exp_golomb_ue(&enc, sps->frame_crop_bottom_offset);
1595 }
1596
1597 vl_bitstream_put_bits(&enc, 1, sps->flags.vui_parameters_present_flag); /* vui parameters present flag */
1598 if (sps->flags.vui_parameters_present_flag) {
1599 const StdVideoH264SequenceParameterSetVui *vui = sps->pSequenceParameterSetVui;
1600 vl_bitstream_put_bits(&enc, 1, vui->flags.aspect_ratio_info_present_flag);
1601
1602 if (vui->flags.aspect_ratio_info_present_flag) {
1603 vl_bitstream_put_bits(&enc, 8, vui->aspect_ratio_idc);
1604 if (vui->aspect_ratio_idc == STD_VIDEO_H264_ASPECT_RATIO_IDC_EXTENDED_SAR) {
1605 vl_bitstream_put_bits(&enc, 16, vui->sar_width);
1606 vl_bitstream_put_bits(&enc, 16, vui->sar_height);
1607 }
1608 }
1609
1610 vl_bitstream_put_bits(&enc, 1, vui->flags.overscan_info_present_flag);
1611 if (vui->flags.overscan_info_present_flag)
1612 vl_bitstream_put_bits(&enc, 1, vui->flags.overscan_appropriate_flag);
1613 vl_bitstream_put_bits(&enc, 1, vui->flags.video_signal_type_present_flag);
1614 if (vui->flags.video_signal_type_present_flag) {
1615 vl_bitstream_put_bits(&enc, 3, vui->video_format);
1616 vl_bitstream_put_bits(&enc, 1, vui->flags.video_full_range_flag);
1617 vl_bitstream_put_bits(&enc, 1, vui->flags.color_description_present_flag);
1618 if (vui->flags.color_description_present_flag) {
1619 vl_bitstream_put_bits(&enc, 8, vui->colour_primaries);
1620 vl_bitstream_put_bits(&enc, 8, vui->transfer_characteristics);
1621 vl_bitstream_put_bits(&enc, 8, vui->matrix_coefficients);
1622 }
1623 }
1624
1625 vl_bitstream_put_bits(&enc, 1, vui->flags.chroma_loc_info_present_flag);
1626 if (vui->flags.chroma_loc_info_present_flag) {
1627 vl_bitstream_exp_golomb_ue(&enc, vui->chroma_sample_loc_type_top_field);
1628 vl_bitstream_exp_golomb_ue(&enc, vui->chroma_sample_loc_type_bottom_field);
1629 }
1630 vl_bitstream_put_bits(&enc, 1, vui->flags.timing_info_present_flag);
1631 if (vui->flags.timing_info_present_flag) {
1632 vl_bitstream_put_bits(&enc, 32, vui->num_units_in_tick);
1633 vl_bitstream_put_bits(&enc, 32, vui->time_scale);
1634 vl_bitstream_put_bits(&enc, 32, vui->flags.fixed_frame_rate_flag);
1635 }
1636 vl_bitstream_put_bits(&enc, 1, vui->flags.nal_hrd_parameters_present_flag);
1637 if (vui->flags.nal_hrd_parameters_present_flag)
1638 encode_hrd_params(&enc, vui->pHrdParameters);
1639 vl_bitstream_put_bits(&enc, 1, vui->flags.vcl_hrd_parameters_present_flag);
1640 if (vui->flags.vcl_hrd_parameters_present_flag)
1641 encode_hrd_params(&enc, vui->pHrdParameters);
1642 if (vui->flags.nal_hrd_parameters_present_flag || vui->flags.vcl_hrd_parameters_present_flag)
1643 vl_bitstream_put_bits(&enc, 1, 0);
1644 vl_bitstream_put_bits(&enc, 1, 0);
1645 vl_bitstream_put_bits(&enc, 1, vui->flags.bitstream_restriction_flag);
1646 if (vui->flags.bitstream_restriction_flag) {
1647 vl_bitstream_put_bits(&enc, 1, 0);
1648 vl_bitstream_exp_golomb_ue(&enc, 0);
1649 vl_bitstream_exp_golomb_ue(&enc, 0);
1650 vl_bitstream_exp_golomb_ue(&enc, 0);
1651 vl_bitstream_exp_golomb_ue(&enc, 0);
1652 vl_bitstream_exp_golomb_ue(&enc, vui->max_num_reorder_frames);
1653 vl_bitstream_exp_golomb_ue(&enc, vui->max_dec_frame_buffering);
1654 }
1655 }
1656
1657 vl_bitstream_rbsp_trailing(&enc);
1658
1659 vl_bitstream_flush(&enc);
1660 *data_size_ptr += vl_bitstream_get_byte_count(&enc);
1661 vl_bitstream_encoder_free(&enc);
1662 }
1663
1664 void
vk_video_encode_h264_pps(const StdVideoH264PictureParameterSet * pps,bool high_profile,size_t size_limit,size_t * data_size_ptr,void * data_ptr)1665 vk_video_encode_h264_pps(const StdVideoH264PictureParameterSet *pps,
1666 bool high_profile,
1667 size_t size_limit,
1668 size_t *data_size_ptr,
1669 void *data_ptr)
1670 {
1671 struct vl_bitstream_encoder enc;
1672 uint32_t data_size = *data_size_ptr;
1673
1674 vl_bitstream_encoder_clear(&enc, data_ptr, data_size, size_limit);
1675
1676 emit_nalu_header(&enc, 3, H264_NAL_PPS);
1677
1678 vl_bitstream_exp_golomb_ue(&enc, pps->pic_parameter_set_id);
1679 vl_bitstream_exp_golomb_ue(&enc, pps->seq_parameter_set_id);
1680 vl_bitstream_put_bits(&enc, 1, pps->flags.entropy_coding_mode_flag);
1681 vl_bitstream_put_bits(&enc, 1, pps->flags.bottom_field_pic_order_in_frame_present_flag);
1682 vl_bitstream_exp_golomb_ue(&enc, 0); /* num_slice_groups_minus1 */
1683
1684 vl_bitstream_exp_golomb_ue(&enc, pps->num_ref_idx_l0_default_active_minus1);
1685 vl_bitstream_exp_golomb_ue(&enc, pps->num_ref_idx_l1_default_active_minus1);
1686 vl_bitstream_put_bits(&enc, 1, pps->flags.weighted_pred_flag);
1687 vl_bitstream_put_bits(&enc, 2, pps->weighted_bipred_idc);
1688 vl_bitstream_exp_golomb_se(&enc, pps->pic_init_qp_minus26);
1689 vl_bitstream_exp_golomb_se(&enc, pps->pic_init_qs_minus26);
1690 vl_bitstream_exp_golomb_se(&enc, pps->chroma_qp_index_offset);
1691 vl_bitstream_put_bits(&enc, 1, pps->flags.deblocking_filter_control_present_flag);
1692 vl_bitstream_put_bits(&enc, 1, pps->flags.constrained_intra_pred_flag);
1693 vl_bitstream_put_bits(&enc, 1, pps->flags.redundant_pic_cnt_present_flag);
1694
1695 /* high profile */
1696 if (high_profile) {
1697 vl_bitstream_put_bits(&enc, 1, pps->flags.transform_8x8_mode_flag);
1698 vl_bitstream_put_bits(&enc, 1, pps->flags.pic_scaling_matrix_present_flag);
1699 vl_bitstream_exp_golomb_se(&enc, pps->second_chroma_qp_index_offset);
1700 }
1701 vl_bitstream_rbsp_trailing(&enc);
1702
1703 vl_bitstream_flush(&enc);
1704 *data_size_ptr += vl_bitstream_get_byte_count(&enc);
1705 vl_bitstream_encoder_free(&enc);
1706 }
1707
1708 static void
emit_nalu_h265_header(struct vl_bitstream_encoder * enc,int nal_unit_type)1709 emit_nalu_h265_header(struct vl_bitstream_encoder *enc,
1710 int nal_unit_type)
1711 {
1712 enc->prevent_start_code = false;
1713
1714 vl_bitstream_put_bits(enc, 24, 0);
1715 vl_bitstream_put_bits(enc, 8, 1);
1716 vl_bitstream_put_bits(enc, 1, 0);
1717 vl_bitstream_put_bits(enc, 6, nal_unit_type); /* SPS NAL REF */
1718 vl_bitstream_put_bits(enc, 6, 0);//nuh_layer_id
1719 vl_bitstream_put_bits(enc, 3, 1);//nuh_temporal_id_plus1;
1720 vl_bitstream_flush(enc);
1721
1722 enc->prevent_start_code = true;
1723 }
1724
1725 static void
encode_h265_profile_tier_level(struct vl_bitstream_encoder * enc,const StdVideoH265ProfileTierLevel * ptl)1726 encode_h265_profile_tier_level(struct vl_bitstream_encoder *enc,
1727 const StdVideoH265ProfileTierLevel *ptl)
1728 {
1729 vl_bitstream_put_bits(enc, 2, 0);
1730 vl_bitstream_put_bits(enc, 1, ptl->flags.general_tier_flag);
1731 vl_bitstream_put_bits(enc, 5, ptl->general_profile_idc);
1732
1733 for (int j = 0; j < 32; j++)
1734 vl_bitstream_put_bits(enc, 1, j == ptl->general_profile_idc);
1735
1736 vl_bitstream_put_bits(enc, 1, ptl->flags.general_progressive_source_flag);
1737 vl_bitstream_put_bits(enc, 1, ptl->flags.general_interlaced_source_flag);
1738 vl_bitstream_put_bits(enc, 1, ptl->flags.general_non_packed_constraint_flag);
1739 vl_bitstream_put_bits(enc, 1, ptl->flags.general_frame_only_constraint_flag);
1740 vl_bitstream_put_bits(enc, 31, 0);
1741 vl_bitstream_put_bits(enc, 13, 0);
1742 vl_bitstream_put_bits(enc, 8, vk_video_get_h265_level(ptl->general_level_idc));
1743 }
1744
1745 void
vk_video_encode_h265_vps(const StdVideoH265VideoParameterSet * vps,size_t size_limit,size_t * data_size_ptr,void * data_ptr)1746 vk_video_encode_h265_vps(const StdVideoH265VideoParameterSet *vps,
1747 size_t size_limit,
1748 size_t *data_size_ptr,
1749 void *data_ptr)
1750 {
1751 struct vl_bitstream_encoder enc;
1752 uint32_t data_size = *data_size_ptr;
1753
1754 vl_bitstream_encoder_clear(&enc, data_ptr, data_size, size_limit);
1755
1756 emit_nalu_h265_header(&enc, HEVC_NAL_VPS_NUT);
1757
1758 vl_bitstream_put_bits(&enc, 4, vps->vps_video_parameter_set_id);
1759 vl_bitstream_put_bits(&enc, 2, 3);
1760 vl_bitstream_put_bits(&enc, 6, 0);//vps->vps_max_layers_minus1);
1761 vl_bitstream_put_bits(&enc, 3, vps->vps_max_sub_layers_minus1);
1762 vl_bitstream_put_bits(&enc, 1, vps->flags.vps_temporal_id_nesting_flag);
1763 vl_bitstream_put_bits(&enc, 16, 0xffff);
1764
1765 encode_h265_profile_tier_level(&enc, vps->pProfileTierLevel);
1766
1767 vl_bitstream_put_bits(&enc, 1, vps->flags.vps_sub_layer_ordering_info_present_flag);
1768
1769 for (int i = 0; i <= vps->vps_max_sub_layers_minus1; i++) {
1770 vl_bitstream_exp_golomb_ue(&enc, vps->pDecPicBufMgr->max_dec_pic_buffering_minus1[i]);
1771 vl_bitstream_exp_golomb_ue(&enc, vps->pDecPicBufMgr->max_num_reorder_pics[i]);
1772 vl_bitstream_exp_golomb_ue(&enc, vps->pDecPicBufMgr->max_latency_increase_plus1[i]);
1773 }
1774
1775
1776 vl_bitstream_put_bits(&enc, 6, 0);//vps->vps_max_layer_id);
1777 vl_bitstream_exp_golomb_ue(&enc, 0);//vps->vps_num_layer_sets_minus1);
1778 vl_bitstream_put_bits(&enc, 1, vps->flags.vps_timing_info_present_flag);
1779
1780 if (vps->flags.vps_timing_info_present_flag) {
1781 vl_bitstream_put_bits(&enc, 32, vps->vps_num_units_in_tick);
1782 vl_bitstream_put_bits(&enc, 32, vps->vps_time_scale);
1783 vl_bitstream_put_bits(&enc, 1, vps->flags.vps_poc_proportional_to_timing_flag);
1784 if (vps->flags.vps_poc_proportional_to_timing_flag)
1785 vl_bitstream_exp_golomb_ue(&enc, vps->vps_num_ticks_poc_diff_one_minus1);
1786 vl_bitstream_exp_golomb_ue(&enc, 0);
1787 }
1788
1789 vl_bitstream_put_bits(&enc, 1, 0); /* vps extension flag */
1790 vl_bitstream_rbsp_trailing(&enc);
1791
1792 vl_bitstream_flush(&enc);
1793 *data_size_ptr += vl_bitstream_get_byte_count(&enc);
1794 vl_bitstream_encoder_free(&enc);
1795 }
1796
1797 static void
encode_rps(struct vl_bitstream_encoder * enc,const StdVideoH265SequenceParameterSet * sps,int st_rps_idx)1798 encode_rps(struct vl_bitstream_encoder *enc,
1799 const StdVideoH265SequenceParameterSet *sps,
1800 int st_rps_idx)
1801 {
1802 const StdVideoH265ShortTermRefPicSet *rps = &sps->pShortTermRefPicSet[st_rps_idx];
1803 if (st_rps_idx != 0)
1804 vl_bitstream_put_bits(enc, 1, rps->flags.inter_ref_pic_set_prediction_flag);
1805
1806 if (rps->flags.inter_ref_pic_set_prediction_flag) {
1807 int ref_rps_idx = st_rps_idx - (rps->delta_idx_minus1 + 1);
1808 vl_bitstream_put_bits(enc, 1, rps->flags.delta_rps_sign);
1809 vl_bitstream_exp_golomb_ue(enc, rps->abs_delta_rps_minus1);
1810
1811 const StdVideoH265ShortTermRefPicSet *rps_ref = &sps->pShortTermRefPicSet[ref_rps_idx];
1812 int num_delta_pocs = rps_ref->num_negative_pics + rps_ref->num_positive_pics;
1813
1814 for (int j = 0; j < num_delta_pocs; j++) {
1815 vl_bitstream_put_bits(enc, 1, !!(rps->used_by_curr_pic_flag & (1 << j)));
1816 if (!(rps->used_by_curr_pic_flag & (1 << j))) {
1817 vl_bitstream_put_bits(enc, 1, !!(rps->use_delta_flag & (1 << j)));
1818 }
1819 }
1820 } else {
1821 vl_bitstream_exp_golomb_ue(enc, rps->num_negative_pics);
1822 vl_bitstream_exp_golomb_ue(enc, rps->num_positive_pics);
1823
1824 for (int i = 0; i < rps->num_negative_pics; i++) {
1825 vl_bitstream_exp_golomb_ue(enc, rps->delta_poc_s0_minus1[i]);
1826 vl_bitstream_put_bits(enc, 1, !!(rps->used_by_curr_pic_s0_flag & (1 << i)));
1827 }
1828 for (int i = 0; i < rps->num_positive_pics; i++) {
1829 vl_bitstream_exp_golomb_ue(enc, rps->delta_poc_s1_minus1[i]);
1830 vl_bitstream_put_bits(enc, 1, !!(rps->used_by_curr_pic_s1_flag & (1 << i)));
1831 }
1832 }
1833 }
1834
1835 void
vk_video_encode_h265_sps(const StdVideoH265SequenceParameterSet * sps,size_t size_limit,size_t * data_size_ptr,void * data_ptr)1836 vk_video_encode_h265_sps(const StdVideoH265SequenceParameterSet *sps,
1837 size_t size_limit,
1838 size_t *data_size_ptr,
1839 void *data_ptr)
1840 {
1841 struct vl_bitstream_encoder enc;
1842 uint32_t data_size = *data_size_ptr;
1843
1844 vl_bitstream_encoder_clear(&enc, data_ptr, data_size, size_limit);
1845
1846 emit_nalu_h265_header(&enc, HEVC_NAL_SPS_NUT);
1847
1848 vl_bitstream_put_bits(&enc, 4, sps->sps_video_parameter_set_id);
1849 vl_bitstream_put_bits(&enc, 3, sps->sps_max_sub_layers_minus1);
1850 vl_bitstream_put_bits(&enc, 1, sps->flags.sps_temporal_id_nesting_flag);
1851
1852 encode_h265_profile_tier_level(&enc, sps->pProfileTierLevel);
1853
1854 vl_bitstream_exp_golomb_ue(&enc, sps->sps_seq_parameter_set_id);
1855 vl_bitstream_exp_golomb_ue(&enc, sps->chroma_format_idc);
1856
1857 vl_bitstream_exp_golomb_ue(&enc, sps->pic_width_in_luma_samples);
1858 vl_bitstream_exp_golomb_ue(&enc, sps->pic_height_in_luma_samples);
1859
1860 vl_bitstream_put_bits(&enc, 1, sps->flags.conformance_window_flag);
1861
1862 if (sps->flags.conformance_window_flag) {
1863 vl_bitstream_exp_golomb_ue(&enc, sps->conf_win_left_offset);
1864 vl_bitstream_exp_golomb_ue(&enc, sps->conf_win_right_offset);
1865 vl_bitstream_exp_golomb_ue(&enc, sps->conf_win_top_offset);
1866 vl_bitstream_exp_golomb_ue(&enc, sps->conf_win_bottom_offset);
1867 }
1868
1869 vl_bitstream_exp_golomb_ue(&enc, sps->bit_depth_luma_minus8);
1870 vl_bitstream_exp_golomb_ue(&enc, sps->bit_depth_chroma_minus8);
1871
1872 vl_bitstream_exp_golomb_ue(&enc, sps->log2_max_pic_order_cnt_lsb_minus4);
1873 vl_bitstream_put_bits(&enc, 1, sps->flags.sps_sub_layer_ordering_info_present_flag);
1874
1875 for (int i = 0; i <= sps->sps_max_sub_layers_minus1; i++) {
1876 vl_bitstream_exp_golomb_ue(&enc, sps->pDecPicBufMgr->max_dec_pic_buffering_minus1[i]);
1877 vl_bitstream_exp_golomb_ue(&enc, sps->pDecPicBufMgr->max_num_reorder_pics[i]);
1878 vl_bitstream_exp_golomb_ue(&enc, sps->pDecPicBufMgr->max_latency_increase_plus1[i]);
1879 }
1880
1881 vl_bitstream_exp_golomb_ue(&enc, sps->log2_min_luma_coding_block_size_minus3);
1882 vl_bitstream_exp_golomb_ue(&enc, sps->log2_diff_max_min_luma_coding_block_size);
1883 vl_bitstream_exp_golomb_ue(&enc, sps->log2_min_luma_transform_block_size_minus2);
1884 vl_bitstream_exp_golomb_ue(&enc, sps->log2_diff_max_min_luma_transform_block_size);
1885
1886 vl_bitstream_exp_golomb_ue(&enc, sps->max_transform_hierarchy_depth_inter);
1887 vl_bitstream_exp_golomb_ue(&enc, sps->max_transform_hierarchy_depth_intra);
1888
1889 vl_bitstream_put_bits(&enc, 1, sps->flags.scaling_list_enabled_flag);
1890
1891 vl_bitstream_put_bits(&enc, 1, sps->flags.amp_enabled_flag);
1892 vl_bitstream_put_bits(&enc, 1, sps->flags.sample_adaptive_offset_enabled_flag);
1893
1894 vl_bitstream_put_bits(&enc, 1, sps->flags.pcm_enabled_flag);
1895
1896 if (sps->flags.pcm_enabled_flag) {
1897 vl_bitstream_put_bits(&enc, 4, sps->bit_depth_luma_minus8 + 7);
1898 vl_bitstream_put_bits(&enc, 4, sps->bit_depth_chroma_minus8 + 7);
1899 vl_bitstream_exp_golomb_ue(&enc, sps->log2_min_luma_coding_block_size_minus3);
1900 vl_bitstream_exp_golomb_ue(&enc, sps->log2_diff_max_min_luma_coding_block_size);
1901 vl_bitstream_put_bits(&enc, 1, sps->flags.pcm_loop_filter_disabled_flag);
1902 }
1903
1904 vl_bitstream_exp_golomb_ue(&enc, sps->num_short_term_ref_pic_sets);
1905 for (int i = 0; i < sps->num_short_term_ref_pic_sets; i++)
1906 encode_rps(&enc, sps, i);
1907
1908 vl_bitstream_put_bits(&enc, 1, sps->flags.long_term_ref_pics_present_flag);
1909 if (sps->flags.long_term_ref_pics_present_flag) {
1910 vl_bitstream_exp_golomb_ue(&enc, sps->num_long_term_ref_pics_sps);
1911 for (int i = 0; i < sps->num_long_term_ref_pics_sps; i++) {
1912 vl_bitstream_put_bits(&enc, sps->log2_max_pic_order_cnt_lsb_minus4 + 4, sps->pLongTermRefPicsSps->lt_ref_pic_poc_lsb_sps[i]);
1913 vl_bitstream_put_bits(&enc, 1, sps->pLongTermRefPicsSps->used_by_curr_pic_lt_sps_flag);
1914 }
1915 }
1916
1917 vl_bitstream_put_bits(&enc, 1, sps->flags.sps_temporal_mvp_enabled_flag);
1918 vl_bitstream_put_bits(&enc, 1, sps->flags.strong_intra_smoothing_enabled_flag);
1919 vl_bitstream_put_bits(&enc, 1, sps->flags.vui_parameters_present_flag);
1920
1921 if (sps->flags.vui_parameters_present_flag) {
1922 const StdVideoH265SequenceParameterSetVui *vui = sps->pSequenceParameterSetVui;
1923 vl_bitstream_put_bits(&enc, 1, vui->flags.aspect_ratio_info_present_flag);
1924 if (vui->flags.aspect_ratio_info_present_flag) {
1925 vl_bitstream_put_bits(&enc, 8, vui->aspect_ratio_idc);
1926 if (vui->aspect_ratio_idc == STD_VIDEO_H265_ASPECT_RATIO_IDC_EXTENDED_SAR) {
1927 vl_bitstream_put_bits(&enc, 16, vui->sar_width);
1928 vl_bitstream_put_bits(&enc, 16, vui->sar_height);
1929 }
1930 }
1931 vl_bitstream_put_bits(&enc, 1, vui->flags.overscan_info_present_flag);
1932 if (vui->flags.overscan_info_present_flag)
1933 vl_bitstream_put_bits(&enc, 1, vui->flags.overscan_appropriate_flag);
1934 vl_bitstream_put_bits(&enc, 1, vui->flags.video_signal_type_present_flag);
1935 if (vui->flags.video_signal_type_present_flag) {
1936 vl_bitstream_put_bits(&enc, 3, vui->video_format);
1937 vl_bitstream_put_bits(&enc, 1, vui->flags.video_full_range_flag);
1938 vl_bitstream_put_bits(&enc, 1, vui->flags.colour_description_present_flag);
1939 if (vui->flags.colour_description_present_flag) {
1940 vl_bitstream_put_bits(&enc, 8, vui->colour_primaries);
1941 vl_bitstream_put_bits(&enc, 8, vui->transfer_characteristics);
1942 vl_bitstream_put_bits(&enc, 8, vui->matrix_coeffs);
1943 }
1944 }
1945 vl_bitstream_put_bits(&enc, 1, vui->flags.chroma_loc_info_present_flag);
1946 if (vui->flags.chroma_loc_info_present_flag) {
1947 vl_bitstream_exp_golomb_ue(&enc, vui->chroma_sample_loc_type_top_field);
1948 vl_bitstream_exp_golomb_ue(&enc, vui->chroma_sample_loc_type_bottom_field);
1949 }
1950 vl_bitstream_put_bits(&enc, 1, vui->flags.neutral_chroma_indication_flag);
1951 vl_bitstream_put_bits(&enc, 1, vui->flags.field_seq_flag);
1952 vl_bitstream_put_bits(&enc, 1, vui->flags.frame_field_info_present_flag);
1953 vl_bitstream_put_bits(&enc, 1, vui->flags.default_display_window_flag);
1954 if (vui->flags.default_display_window_flag) {
1955 vl_bitstream_exp_golomb_ue(&enc, vui->def_disp_win_left_offset);
1956 vl_bitstream_exp_golomb_ue(&enc, vui->def_disp_win_right_offset);
1957 vl_bitstream_exp_golomb_ue(&enc, vui->def_disp_win_top_offset);
1958 vl_bitstream_exp_golomb_ue(&enc, vui->def_disp_win_bottom_offset);
1959 }
1960 vl_bitstream_put_bits(&enc, 1, vui->flags.vui_timing_info_present_flag);
1961 if (vui->flags.vui_timing_info_present_flag) {
1962 vl_bitstream_put_bits(&enc, 32, vui->vui_num_units_in_tick);
1963 vl_bitstream_put_bits(&enc, 32, vui->vui_time_scale);
1964 vl_bitstream_put_bits(&enc, 1, vui->flags.vui_poc_proportional_to_timing_flag);
1965 if (vui->flags.vui_poc_proportional_to_timing_flag)
1966 vl_bitstream_exp_golomb_ue(&enc, vui->vui_num_ticks_poc_diff_one_minus1);
1967 vl_bitstream_put_bits(&enc, 1, 0);//vui->flags.vui_hrd_parameters_present_flag);
1968 // HRD
1969 }
1970
1971 vl_bitstream_put_bits(&enc, 1, vui->flags.bitstream_restriction_flag);
1972 if (vui->flags.bitstream_restriction_flag) {
1973 vl_bitstream_put_bits(&enc, 1, vui->flags.tiles_fixed_structure_flag);
1974 vl_bitstream_put_bits(&enc, 1, vui->flags.motion_vectors_over_pic_boundaries_flag);
1975 vl_bitstream_put_bits(&enc, 1, vui->flags.restricted_ref_pic_lists_flag);
1976 vl_bitstream_exp_golomb_ue(&enc, vui->min_spatial_segmentation_idc);
1977 vl_bitstream_exp_golomb_ue(&enc, vui->max_bytes_per_pic_denom);
1978 vl_bitstream_exp_golomb_ue(&enc, vui->max_bits_per_min_cu_denom);
1979 vl_bitstream_exp_golomb_ue(&enc, vui->log2_max_mv_length_horizontal);
1980 vl_bitstream_exp_golomb_ue(&enc, vui->log2_max_mv_length_vertical);
1981 }
1982 }
1983
1984 vl_bitstream_put_bits(&enc, 1, 0); /* sps extension flg */
1985 vl_bitstream_rbsp_trailing(&enc);
1986
1987 vl_bitstream_flush(&enc);
1988 *data_size_ptr += vl_bitstream_get_byte_count(&enc);
1989 vl_bitstream_encoder_free(&enc);
1990 }
1991
1992 void
vk_video_encode_h265_pps(const StdVideoH265PictureParameterSet * pps,size_t size_limit,size_t * data_size_ptr,void * data_ptr)1993 vk_video_encode_h265_pps(const StdVideoH265PictureParameterSet *pps,
1994 size_t size_limit,
1995 size_t *data_size_ptr,
1996 void *data_ptr)
1997 {
1998 struct vl_bitstream_encoder enc;
1999 uint32_t data_size = *data_size_ptr;
2000
2001 vl_bitstream_encoder_clear(&enc, data_ptr, data_size, size_limit);
2002
2003 emit_nalu_h265_header(&enc, HEVC_NAL_PPS_NUT);
2004 vl_bitstream_exp_golomb_ue(&enc, pps->pps_pic_parameter_set_id);
2005 vl_bitstream_exp_golomb_ue(&enc, pps->pps_seq_parameter_set_id);
2006
2007 vl_bitstream_put_bits(&enc, 1, pps->flags.dependent_slice_segments_enabled_flag);
2008
2009 vl_bitstream_put_bits(&enc, 1, pps->flags.output_flag_present_flag);
2010 vl_bitstream_put_bits(&enc, 3, pps->num_extra_slice_header_bits);
2011
2012 vl_bitstream_put_bits(&enc, 1, pps->flags.sign_data_hiding_enabled_flag);
2013 vl_bitstream_put_bits(&enc, 1, pps->flags.cabac_init_present_flag);
2014
2015 vl_bitstream_exp_golomb_ue(&enc, pps->num_ref_idx_l0_default_active_minus1);
2016 vl_bitstream_exp_golomb_ue(&enc, pps->num_ref_idx_l1_default_active_minus1);
2017
2018 vl_bitstream_exp_golomb_se(&enc, pps->init_qp_minus26);
2019
2020 vl_bitstream_put_bits(&enc, 1, pps->flags.constrained_intra_pred_flag);
2021 vl_bitstream_put_bits(&enc, 1, pps->flags.transform_skip_enabled_flag);
2022 vl_bitstream_put_bits(&enc, 1, pps->flags.cu_qp_delta_enabled_flag);
2023
2024 if (pps->flags.cu_qp_delta_enabled_flag)
2025 vl_bitstream_exp_golomb_ue(&enc, pps->diff_cu_qp_delta_depth);
2026
2027 vl_bitstream_exp_golomb_se(&enc, pps->pps_cb_qp_offset);
2028 vl_bitstream_exp_golomb_se(&enc, pps->pps_cr_qp_offset);
2029
2030 vl_bitstream_put_bits(&enc, 1, pps->flags.pps_slice_chroma_qp_offsets_present_flag);
2031 vl_bitstream_put_bits(&enc, 1, pps->flags.weighted_pred_flag);
2032 vl_bitstream_put_bits(&enc, 1, pps->flags.weighted_bipred_flag);
2033 vl_bitstream_put_bits(&enc, 1, pps->flags.transquant_bypass_enabled_flag);
2034
2035 vl_bitstream_put_bits(&enc, 1, pps->flags.tiles_enabled_flag);
2036 vl_bitstream_put_bits(&enc, 1, pps->flags.entropy_coding_sync_enabled_flag);
2037
2038 assert (!pps->flags.tiles_enabled_flag);
2039
2040 vl_bitstream_put_bits(&enc, 1, pps->flags.pps_loop_filter_across_slices_enabled_flag);
2041 vl_bitstream_put_bits(&enc, 1, pps->flags.deblocking_filter_control_present_flag);
2042
2043 if (pps->flags.deblocking_filter_control_present_flag) {
2044 vl_bitstream_put_bits(&enc, 1, pps->flags.deblocking_filter_override_enabled_flag);
2045 vl_bitstream_put_bits(&enc, 1, pps->flags.pps_deblocking_filter_disabled_flag);
2046 if (!pps->flags.pps_deblocking_filter_disabled_flag) {
2047 vl_bitstream_exp_golomb_se(&enc, pps->pps_beta_offset_div2);
2048 vl_bitstream_exp_golomb_se(&enc, pps->pps_tc_offset_div2);
2049 }
2050 }
2051
2052 vl_bitstream_put_bits(&enc, 1, pps->flags.pps_scaling_list_data_present_flag);
2053 assert (!pps->flags.pps_scaling_list_data_present_flag);
2054
2055 vl_bitstream_put_bits(&enc, 1, pps->flags.lists_modification_present_flag);
2056 vl_bitstream_exp_golomb_ue(&enc, pps->log2_parallel_merge_level_minus2);
2057 vl_bitstream_put_bits(&enc, 1, pps->flags.slice_segment_header_extension_present_flag);
2058
2059 vl_bitstream_put_bits(&enc, 1, 0); /* pps extension flag */
2060 vl_bitstream_rbsp_trailing(&enc);
2061
2062 vl_bitstream_flush(&enc);
2063 *data_size_ptr += vl_bitstream_get_byte_count(&enc);
2064 vl_bitstream_encoder_free(&enc);
2065 }
2066