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 params->h264_enc.profile_idc = vid->h264.profile_idc;
524 init_add_h264_enc_session_parameters(params, h264_create->pParametersAddInfo, templ);
525 break;
526 }
527 case VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR: {
528 const struct VkVideoEncodeH265SessionParametersCreateInfoKHR *h265_create =
529 vk_find_struct_const(create_info->pNext, VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR);
530
531 params->h265_enc.max_h265_vps_count = h265_create->maxStdVPSCount;
532 params->h265_enc.max_h265_sps_count = h265_create->maxStdSPSCount;
533 params->h265_enc.max_h265_pps_count = h265_create->maxStdPPSCount;
534
535 uint32_t vps_size = params->h265_enc.max_h265_vps_count * sizeof(struct vk_video_h265_vps);
536 uint32_t sps_size = params->h265_enc.max_h265_sps_count * sizeof(struct vk_video_h265_sps);
537 uint32_t pps_size = params->h265_enc.max_h265_pps_count * sizeof(struct vk_video_h265_pps);
538
539 params->h265_enc.h265_vps = vk_alloc(&device->alloc, vps_size, 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
540 params->h265_enc.h265_sps = vk_alloc(&device->alloc, sps_size, 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
541 params->h265_enc.h265_pps = vk_alloc(&device->alloc, pps_size, 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
542 if (!params->h265_enc.h265_sps || !params->h265_enc.h265_pps || !params->h265_enc.h265_vps) {
543 vk_free(&device->alloc, params->h265_enc.h265_vps);
544 vk_free(&device->alloc, params->h265_enc.h265_sps);
545 vk_free(&device->alloc, params->h265_enc.h265_pps);
546 return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
547 }
548
549 init_add_h265_enc_session_parameters(params, h265_create->pParametersAddInfo, templ);
550 break;
551 }
552 default:
553 unreachable("Unsupported video codec operation");
554 break;
555 }
556 return VK_SUCCESS;
557 }
558
559 void
vk_video_session_parameters_finish(struct vk_device * device,struct vk_video_session_parameters * params)560 vk_video_session_parameters_finish(struct vk_device *device,
561 struct vk_video_session_parameters *params)
562 {
563 switch (params->op) {
564 case VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR:
565 vk_free(&device->alloc, params->h264_dec.h264_sps);
566 vk_free(&device->alloc, params->h264_dec.h264_pps);
567 break;
568 case VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR:
569 vk_free(&device->alloc, params->h265_dec.h265_vps);
570 vk_free(&device->alloc, params->h265_dec.h265_sps);
571 vk_free(&device->alloc, params->h265_dec.h265_pps);
572 break;
573 case VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR:
574 vk_free(&device->alloc, params->h264_enc.h264_sps);
575 vk_free(&device->alloc, params->h264_enc.h264_pps);
576 break;
577 case VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR:
578 vk_free(&device->alloc, params->h265_enc.h265_vps);
579 vk_free(&device->alloc, params->h265_enc.h265_sps);
580 vk_free(&device->alloc, params->h265_enc.h265_pps);
581 break;
582 default:
583 break;
584 }
585 vk_object_base_finish(¶ms->base);
586 }
587
588 static VkResult
update_h264_dec_session_parameters(struct vk_video_session_parameters * params,const struct VkVideoDecodeH264SessionParametersAddInfoKHR * h264_add)589 update_h264_dec_session_parameters(struct vk_video_session_parameters *params,
590 const struct VkVideoDecodeH264SessionParametersAddInfoKHR *h264_add)
591 {
592 VkResult result = VK_SUCCESS;
593
594 result = update_h264_dec_h264_sps(params, h264_add->stdSPSCount, h264_add->pStdSPSs);
595 if (result != VK_SUCCESS)
596 return result;
597
598 result = update_h264_dec_h264_pps(params, h264_add->stdPPSCount, h264_add->pStdPPSs);
599 return result;
600 }
601
602 static VkResult
update_h264_enc_session_parameters(struct vk_video_session_parameters * params,const struct VkVideoEncodeH264SessionParametersAddInfoKHR * h264_add)603 update_h264_enc_session_parameters(struct vk_video_session_parameters *params,
604 const struct VkVideoEncodeH264SessionParametersAddInfoKHR *h264_add)
605 {
606 VkResult result = VK_SUCCESS;
607 result = update_h264_enc_h264_sps(params, h264_add->stdSPSCount, h264_add->pStdSPSs);
608 if (result != VK_SUCCESS)
609 return result;
610
611 result = update_h264_enc_h264_pps(params, h264_add->stdPPSCount, h264_add->pStdPPSs);
612 return result;
613 }
614
615 static VkResult
update_h265_enc_session_parameters(struct vk_video_session_parameters * params,const struct VkVideoEncodeH265SessionParametersAddInfoKHR * h265_add)616 update_h265_enc_session_parameters(struct vk_video_session_parameters *params,
617 const struct VkVideoEncodeH265SessionParametersAddInfoKHR *h265_add)
618 {
619 VkResult result = VK_SUCCESS;
620
621 result = update_h265_enc_h265_vps(params, h265_add->stdVPSCount, h265_add->pStdVPSs);
622 if (result != VK_SUCCESS)
623 return result;
624
625 result = update_h265_enc_h265_sps(params, h265_add->stdSPSCount, h265_add->pStdSPSs);
626 if (result != VK_SUCCESS)
627 return result;
628
629 result = update_h265_enc_h265_pps(params, h265_add->stdPPSCount, h265_add->pStdPPSs);
630 return result;
631 }
632
633 static VkResult
update_h265_session_parameters(struct vk_video_session_parameters * params,const struct VkVideoDecodeH265SessionParametersAddInfoKHR * h265_add)634 update_h265_session_parameters(struct vk_video_session_parameters *params,
635 const struct VkVideoDecodeH265SessionParametersAddInfoKHR *h265_add)
636 {
637 VkResult result = VK_SUCCESS;
638 result = update_h265_dec_h265_vps(params, h265_add->stdVPSCount, h265_add->pStdVPSs);
639 if (result != VK_SUCCESS)
640 return result;
641
642 result = update_h265_dec_h265_sps(params, h265_add->stdSPSCount, h265_add->pStdSPSs);
643 if (result != VK_SUCCESS)
644 return result;
645
646 result = update_h265_dec_h265_pps(params, h265_add->stdPPSCount, h265_add->pStdPPSs);
647 return result;
648 }
649
650 VkResult
vk_video_session_parameters_update(struct vk_video_session_parameters * params,const VkVideoSessionParametersUpdateInfoKHR * update)651 vk_video_session_parameters_update(struct vk_video_session_parameters *params,
652 const VkVideoSessionParametersUpdateInfoKHR *update)
653 {
654 /* 39.6.5. Decoder Parameter Sets -
655 * "The provided H.264 SPS/PPS parameters must be within the limits specified during decoder
656 * creation for the decoder specified in VkVideoSessionParametersCreateInfoKHR."
657 */
658
659 /*
660 * There is no need to deduplicate here.
661 * videoSessionParameters must not already contain a StdVideoH264PictureParameterSet entry with
662 * both seq_parameter_set_id and pic_parameter_set_id matching any of the elements of
663 * VkVideoDecodeH264SessionParametersAddInfoKHR::pStdPPS
664 */
665 VkResult result = VK_SUCCESS;
666
667 switch (params->op) {
668 case VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR: {
669 const struct VkVideoDecodeH264SessionParametersAddInfoKHR *h264_add =
670 vk_find_struct_const(update->pNext, VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR);
671 return update_h264_dec_session_parameters(params, h264_add);
672 }
673 case VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR: {
674 const struct VkVideoDecodeH265SessionParametersAddInfoKHR *h265_add =
675 vk_find_struct_const(update->pNext, VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR);
676
677 return update_h265_session_parameters(params, h265_add);
678 }
679 case VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR: {
680 const struct VkVideoEncodeH264SessionParametersAddInfoKHR *h264_add =
681 vk_find_struct_const(update->pNext, VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR);
682 return update_h264_enc_session_parameters(params, h264_add);
683 }
684 case VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR: {
685 const struct VkVideoEncodeH265SessionParametersAddInfoKHR *h265_add =
686 vk_find_struct_const(update->pNext, VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR);
687 return update_h265_enc_session_parameters(params, h265_add);
688 }
689 default:
690 unreachable("Unknown codec\n");
691 }
692 return result;
693 }
694
695 const uint8_t h264_scaling_list_default_4x4_intra[] =
696 {
697 /* Table 7-3 - Default_4x4_Intra */
698 6, 13, 13, 20, 20, 20, 28, 28, 28, 28, 32, 32, 32, 37, 37, 42
699 };
700
701 const uint8_t h264_scaling_list_default_4x4_inter[] =
702 {
703 /* Table 7-3 - Default_4x4_Inter */
704 10, 14, 14, 20, 20, 20, 24, 24, 24, 24, 27, 27, 27, 30, 30, 34
705 };
706
707 const uint8_t h264_scaling_list_default_8x8_intra[] =
708 {
709 /* Table 7-4 - Default_8x8_Intra */
710 6, 10, 10, 13, 11, 13, 16, 16, 16, 16, 18, 18, 18, 18, 18, 23,
711 23, 23, 23, 23, 23, 25, 25, 25, 25, 25, 25, 25, 27, 27, 27, 27,
712 27, 27, 27, 27, 29, 29, 29, 29, 29, 29, 29, 31, 31, 31, 31, 31,
713 31, 33, 33, 33, 33, 33, 36, 36, 36, 36, 38, 38, 38, 40, 40, 42,
714 };
715
716 const uint8_t h264_scaling_list_default_8x8_inter[] =
717 {
718 /* Table 7-4 - Default_8x8_Inter */
719 9 , 13, 13, 15, 13, 15, 17, 17, 17, 17, 19, 19, 19, 19, 19, 21,
720 21, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 24, 24, 24, 24,
721 24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 27, 27, 27, 27, 27,
722 27, 28, 28, 28, 28, 28, 30, 30, 30, 30, 32, 32, 32, 33, 33, 35,
723 };
724
725 void
vk_video_derive_h264_scaling_list(const StdVideoH264SequenceParameterSet * sps,const StdVideoH264PictureParameterSet * pps,StdVideoH264ScalingLists * list)726 vk_video_derive_h264_scaling_list(const StdVideoH264SequenceParameterSet *sps,
727 const StdVideoH264PictureParameterSet *pps,
728 StdVideoH264ScalingLists *list)
729 {
730 StdVideoH264ScalingLists temp;
731
732 /* derive SPS scaling list first, because PPS may depend on it in fall-back
733 * rule B */
734 if (sps->flags.seq_scaling_matrix_present_flag)
735 {
736 for (int i = 0; i < STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS; i++)
737 {
738 if (sps->pScalingLists->scaling_list_present_mask & (1 << i))
739 memcpy(temp.ScalingList4x4[i],
740 sps->pScalingLists->ScalingList4x4[i],
741 STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS);
742 else /* fall-back rule A */
743 {
744 if (i == 0)
745 memcpy(temp.ScalingList4x4[i],
746 h264_scaling_list_default_4x4_intra,
747 STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS);
748 else if (i == 3)
749 memcpy(temp.ScalingList4x4[i],
750 h264_scaling_list_default_4x4_inter,
751 STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS);
752 else
753 memcpy(temp.ScalingList4x4[i],
754 temp.ScalingList4x4[i - 1],
755 STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS);
756 }
757 }
758
759 for (int j = 0; j < STD_VIDEO_H264_SCALING_LIST_8X8_NUM_LISTS; j++)
760 {
761 int i = j + STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS;
762 if (sps->pScalingLists->scaling_list_present_mask & (1 << i))
763 memcpy(temp.ScalingList8x8[j], sps->pScalingLists->ScalingList8x8[j],
764 STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS);
765 else /* fall-back rule A */
766 {
767 if (i == 6)
768 memcpy(temp.ScalingList8x8[j],
769 h264_scaling_list_default_8x8_intra,
770 STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS);
771 else if (i == 7)
772 memcpy(temp.ScalingList8x8[j],
773 h264_scaling_list_default_8x8_inter,
774 STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS);
775 else
776 memcpy(temp.ScalingList8x8[j], temp.ScalingList8x8[j - 2],
777 STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS);
778 }
779 }
780 }
781 else
782 {
783 memset(temp.ScalingList4x4, 0x10,
784 STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS *
785 STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS);
786 memset(temp.ScalingList8x8, 0x10,
787 STD_VIDEO_H264_SCALING_LIST_8X8_NUM_LISTS *
788 STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS);
789 }
790
791 if (pps->flags.pic_scaling_matrix_present_flag)
792 {
793 for (int i = 0; i < STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS; i++)
794 {
795 if (pps->pScalingLists->scaling_list_present_mask & (1 << i))
796 memcpy(list->ScalingList4x4[i], pps->pScalingLists->ScalingList4x4[i],
797 STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS);
798 else if (sps->flags.seq_scaling_matrix_present_flag) /* fall-back rule B */
799 {
800 if (i == 0 || i == 3)
801 memcpy(list->ScalingList4x4[i], temp.ScalingList4x4[i],
802 STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS);
803 else
804 memcpy(list->ScalingList4x4[i], list->ScalingList4x4[i - 1],
805 STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS);
806 }
807 else /* fall-back rule A */
808 {
809 if (i == 0)
810 memcpy(list->ScalingList4x4[i],
811 h264_scaling_list_default_4x4_intra,
812 STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS);
813 else if (i == 3)
814 memcpy(list->ScalingList4x4[i],
815 h264_scaling_list_default_4x4_inter,
816 STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS);
817 else
818 memcpy(list->ScalingList4x4[i],
819 list->ScalingList4x4[i - 1],
820 STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS);
821 }
822 }
823
824 for (int j = 0; j < STD_VIDEO_H264_SCALING_LIST_8X8_NUM_LISTS; j++)
825 {
826 int i = j + STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS;
827 if (pps->pScalingLists->scaling_list_present_mask & (1 << i))
828 memcpy(list->ScalingList8x8[j], pps->pScalingLists->ScalingList8x8[j],
829 STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS);
830 else if (sps->flags.seq_scaling_matrix_present_flag) /* fall-back rule B */
831 {
832 if (i == 6 || i == 7)
833 memcpy(list->ScalingList8x8[j], temp.ScalingList8x8[j],
834 STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS);
835 else
836 memcpy(list->ScalingList8x8[j], list->ScalingList8x8[j - 2],
837 STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS);
838 }
839 else /* fall-back rule A */
840 {
841 if (i == 6)
842 memcpy(list->ScalingList8x8[j],
843 h264_scaling_list_default_8x8_intra,
844 STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS);
845 else if (i == 7)
846 memcpy(list->ScalingList8x8[j],
847 h264_scaling_list_default_8x8_inter,
848 STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS);
849 else
850 memcpy(list->ScalingList8x8[j], list->ScalingList8x8[j - 2],
851 STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS);
852 }
853 }
854 }
855 else
856 {
857 memcpy(list->ScalingList4x4, temp.ScalingList4x4,
858 STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS *
859 STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS);
860 memcpy(list->ScalingList8x8, temp.ScalingList8x8,
861 STD_VIDEO_H264_SCALING_LIST_8X8_NUM_LISTS *
862 STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS);
863 }
864 }
865
866 const StdVideoH264SequenceParameterSet *
vk_video_find_h264_dec_std_sps(const struct vk_video_session_parameters * params,uint32_t id)867 vk_video_find_h264_dec_std_sps(const struct vk_video_session_parameters *params,
868 uint32_t id)
869 {
870 return &find_h264_dec_h264_sps(params, id)->base;
871 }
872
873 const StdVideoH264PictureParameterSet *
vk_video_find_h264_dec_std_pps(const struct vk_video_session_parameters * params,uint32_t id)874 vk_video_find_h264_dec_std_pps(const struct vk_video_session_parameters *params,
875 uint32_t id)
876 {
877 return &find_h264_dec_h264_pps(params, id)->base;
878 }
879
880 const StdVideoH265VideoParameterSet *
vk_video_find_h265_dec_std_vps(const struct vk_video_session_parameters * params,uint32_t id)881 vk_video_find_h265_dec_std_vps(const struct vk_video_session_parameters *params,
882 uint32_t id)
883 {
884 return &find_h265_dec_h265_vps(params, id)->base;
885 }
886
887 const StdVideoH265SequenceParameterSet *
vk_video_find_h265_dec_std_sps(const struct vk_video_session_parameters * params,uint32_t id)888 vk_video_find_h265_dec_std_sps(const struct vk_video_session_parameters *params,
889 uint32_t id)
890 {
891 return &find_h265_dec_h265_sps(params, id)->base;
892 }
893
894 const StdVideoH265PictureParameterSet *
vk_video_find_h265_dec_std_pps(const struct vk_video_session_parameters * params,uint32_t id)895 vk_video_find_h265_dec_std_pps(const struct vk_video_session_parameters *params,
896 uint32_t id)
897 {
898 return &find_h265_dec_h265_pps(params, id)->base;
899 }
900
901 int
vk_video_h265_poc_by_slot(const struct VkVideoDecodeInfoKHR * frame_info,int slot)902 vk_video_h265_poc_by_slot(const struct VkVideoDecodeInfoKHR *frame_info, int slot)
903 {
904 for (unsigned i = 0; i < frame_info->referenceSlotCount; i++) {
905 const VkVideoDecodeH265DpbSlotInfoKHR *dpb_slot_info =
906 vk_find_struct_const(frame_info->pReferenceSlots[i].pNext, VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR);
907 if (frame_info->pReferenceSlots[i].slotIndex == slot)
908 return dpb_slot_info->pStdReferenceInfo->PicOrderCntVal;
909 }
910
911 assert(0);
912
913 return 0;
914 }
915
916 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])917 vk_fill_video_h265_reference_info(const VkVideoDecodeInfoKHR *frame_info,
918 const struct VkVideoDecodeH265PictureInfoKHR *pic,
919 const struct vk_video_h265_slice_params *slice_params,
920 struct vk_video_h265_reference ref_slots[][8])
921 {
922 uint8_t list_cnt = slice_params->slice_type == STD_VIDEO_H265_SLICE_TYPE_B ? 2 : 1;
923 uint8_t list_idx;
924 int i, j;
925
926 for (list_idx = 0; list_idx < list_cnt; list_idx++) {
927 /* The order is
928 * L0: Short term current before set - Short term current after set - long term current
929 * L1: Short term current after set - short term current before set - long term current
930 */
931 const uint8_t *rps[3] = {
932 list_idx ? pic->pStdPictureInfo->RefPicSetStCurrAfter : pic->pStdPictureInfo->RefPicSetStCurrBefore,
933 list_idx ? pic->pStdPictureInfo->RefPicSetStCurrBefore : pic->pStdPictureInfo->RefPicSetStCurrAfter,
934 pic->pStdPictureInfo->RefPicSetLtCurr
935 };
936
937 uint8_t ref_idx = 0;
938 for (i = 0; i < 3; i++) {
939 const uint8_t *cur_rps = rps[i];
940
941 for (j = 0; (cur_rps[j] != 0xff) && ((j + ref_idx) < 8); j++) {
942 ref_slots[list_idx][j + ref_idx].slot_index = cur_rps[j];
943 ref_slots[list_idx][j + ref_idx].pic_order_cnt = vk_video_h265_poc_by_slot(frame_info, cur_rps[j]);
944 }
945 ref_idx += j;
946 }
947
948 /* TODO: should handle cases where rpl_modification_flag is true. */
949 assert(!slice_params->rpl_modification_flag[0] && !slice_params->rpl_modification_flag[1]);
950 }
951 }
952
953 static void
h265_pred_weight_table(struct vk_video_h265_slice_params * params,struct vl_rbsp * rbsp,const StdVideoH265SequenceParameterSet * sps,StdVideoH265SliceType slice_type)954 h265_pred_weight_table(struct vk_video_h265_slice_params *params,
955 struct vl_rbsp *rbsp,
956 const StdVideoH265SequenceParameterSet *sps,
957 StdVideoH265SliceType slice_type)
958 {
959 unsigned chroma_array_type = sps->flags.separate_colour_plane_flag ? 0 : sps->chroma_format_idc;
960 unsigned i, j;
961
962 params->luma_log2_weight_denom = vl_rbsp_ue(rbsp);
963
964 assert(params->luma_log2_weight_denom >= 0 && params->luma_log2_weight_denom < 8);
965
966 if (chroma_array_type != 0) {
967 params->chroma_log2_weight_denom = params->luma_log2_weight_denom + vl_rbsp_se(rbsp);
968 assert(params->chroma_log2_weight_denom >= 0 && params->chroma_log2_weight_denom < 8);
969 }
970
971 for (i = 0; i < params->num_ref_idx_l0_active; ++i) {
972 params->luma_weight_l0_flag[i] = vl_rbsp_u(rbsp, 1);
973 if (!params->luma_weight_l0_flag[i]) {
974 params->luma_weight_l0[i] = 1 << params->luma_log2_weight_denom;
975 params->luma_offset_l0[i] = 0;
976 }
977 }
978
979 for (i = 0; i < params->num_ref_idx_l0_active; ++i) {
980 if (chroma_array_type == 0) {
981 params->chroma_weight_l0_flag[i] = 0;
982 } else {
983 params->chroma_weight_l0_flag[i] = vl_rbsp_u(rbsp, 1);
984 }
985 }
986
987 for (i = 0; i < params->num_ref_idx_l0_active; ++i) {
988 if (params->luma_weight_l0_flag[i]) {
989 params->delta_luma_weight_l0[i] = vl_rbsp_se(rbsp);
990 params->luma_weight_l0[i] = (1 << params->luma_log2_weight_denom) + params->delta_luma_weight_l0[i];
991 params->luma_offset_l0[i] = vl_rbsp_se(rbsp);
992 }
993
994 if (params->chroma_weight_l0_flag[i]) {
995 for (j = 0; j < 2; j++) {
996 params->delta_chroma_weight_l0[i][j] = vl_rbsp_se(rbsp);
997 params->delta_chroma_offset_l0[i][j] = vl_rbsp_se(rbsp);
998
999 params->chroma_weight_l0[i][j] =
1000 (1 << params->chroma_log2_weight_denom) + params->delta_chroma_weight_l0[i][j];
1001 params->chroma_offset_l0[i][j] = CLAMP(params->delta_chroma_offset_l0[i][j] -
1002 ((128 * params->chroma_weight_l0[i][j]) >> params->chroma_log2_weight_denom) + 128, -128, 127);
1003 }
1004 } else {
1005 for (j = 0; j < 2; j++) {
1006 params->chroma_weight_l0[i][j] = 1 << params->chroma_log2_weight_denom;
1007 params->chroma_offset_l0[i][j] = 0;
1008 }
1009 }
1010 }
1011
1012 if (slice_type == STD_VIDEO_H265_SLICE_TYPE_B) {
1013 for (i = 0; i < params->num_ref_idx_l1_active; ++i) {
1014 params->luma_weight_l1_flag[i] = vl_rbsp_u(rbsp, 1);
1015 if (!params->luma_weight_l1_flag[i]) {
1016 params->luma_weight_l1[i] = 1 << params->luma_log2_weight_denom;
1017 params->luma_offset_l1[i] = 0;
1018 }
1019 }
1020
1021 for (i = 0; i < params->num_ref_idx_l1_active; ++i) {
1022 if (chroma_array_type == 0) {
1023 params->chroma_weight_l1_flag[i] = 0;
1024 } else {
1025 params->chroma_weight_l1_flag[i] = vl_rbsp_u(rbsp, 1);
1026 }
1027 }
1028
1029 for (i = 0; i < params->num_ref_idx_l1_active; ++i) {
1030 if (params->luma_weight_l1_flag[i]) {
1031 params->delta_luma_weight_l1[i] = vl_rbsp_se(rbsp);
1032 params->luma_weight_l1[i] =
1033 (1 << params->luma_log2_weight_denom) + params->delta_luma_weight_l1[i];
1034 params->luma_offset_l1[i] = vl_rbsp_se(rbsp);
1035 }
1036
1037 if (params->chroma_weight_l1_flag[i]) {
1038 for (j = 0; j < 2; j++) {
1039 params->delta_chroma_weight_l1[i][j] = vl_rbsp_se(rbsp);
1040 params->delta_chroma_offset_l1[i][j] = vl_rbsp_se(rbsp);
1041
1042 params->chroma_weight_l1[i][j] =
1043 (1 << params->chroma_log2_weight_denom) + params->delta_chroma_weight_l1[i][j];
1044 params->chroma_offset_l1[i][j] = CLAMP(params->delta_chroma_offset_l1[i][j] -
1045 ((128 * params->chroma_weight_l1[i][j]) >> params->chroma_log2_weight_denom) + 128, -128, 127);
1046 }
1047 } else {
1048 for (j = 0; j < 2; j++) {
1049 params->chroma_weight_l1[i][j] = 1 << params->chroma_log2_weight_denom;
1050 params->chroma_offset_l1[i][j] = 0;
1051 }
1052 }
1053 }
1054 }
1055 }
1056
1057 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)1058 vk_video_parse_h265_slice_header(const struct VkVideoDecodeInfoKHR *frame_info,
1059 const VkVideoDecodeH265PictureInfoKHR *pic_info,
1060 const StdVideoH265SequenceParameterSet *sps,
1061 const StdVideoH265PictureParameterSet *pps,
1062 void *slice_data,
1063 uint32_t slice_size,
1064 struct vk_video_h265_slice_params *params)
1065 {
1066 struct vl_vlc vlc;
1067 const void *slice_headers[1] = { slice_data };
1068 vl_vlc_init(&vlc, 1, slice_headers, &slice_size);
1069
1070 assert(vl_vlc_peekbits(&vlc, 24) == 0x000001);
1071
1072 vl_vlc_eatbits(&vlc, 24);
1073
1074 /* forbidden_zero_bit */
1075 vl_vlc_eatbits(&vlc, 1);
1076
1077 if (vl_vlc_valid_bits(&vlc) < 15)
1078 vl_vlc_fillbits(&vlc);
1079
1080 vl_vlc_get_uimsbf(&vlc, 6); /* nal_unit_type */
1081 vl_vlc_get_uimsbf(&vlc, 6); /* nuh_layer_id */
1082 vl_vlc_get_uimsbf(&vlc, 3); /* nuh_temporal_id_plus1 */
1083
1084 struct vl_rbsp rbsp;
1085 vl_rbsp_init(&rbsp, &vlc, 128, /* emulation_bytes */ true);
1086
1087 memset(params, 0, sizeof(*params));
1088
1089 params->slice_size = slice_size;
1090 params->first_slice_segment_in_pic_flag = vl_rbsp_u(&rbsp, 1);
1091
1092 /* no_output_of_prior_pics_flag */
1093 if (pic_info->pStdPictureInfo->flags.IrapPicFlag)
1094 vl_rbsp_u(&rbsp, 1);
1095
1096 /* pps id */
1097 vl_rbsp_ue(&rbsp);
1098
1099 if (!params->first_slice_segment_in_pic_flag) {
1100 int size, num;
1101 int bits_slice_segment_address = 0;
1102
1103 if (pps->flags.dependent_slice_segments_enabled_flag)
1104 params->dependent_slice_segment = vl_rbsp_u(&rbsp, 1);
1105
1106 size = 1 << (sps->log2_min_luma_coding_block_size_minus3 + 3 +
1107 sps->log2_diff_max_min_luma_coding_block_size);
1108
1109 num = ((sps->pic_width_in_luma_samples + size - 1) / size) *
1110 ((sps->pic_height_in_luma_samples + size - 1) / size);
1111
1112 while (num > (1 << bits_slice_segment_address))
1113 bits_slice_segment_address++;
1114
1115 /* slice_segment_address */
1116 params->slice_segment_address = vl_rbsp_u(&rbsp, bits_slice_segment_address);
1117 }
1118
1119 if (params->dependent_slice_segment)
1120 return;
1121
1122 for (unsigned i = 0; i < pps->num_extra_slice_header_bits; ++i)
1123 /* slice_reserved_flag */
1124 vl_rbsp_u(&rbsp, 1);
1125
1126 /* slice_type */
1127 params->slice_type = vl_rbsp_ue(&rbsp);
1128
1129 if (pps->flags.output_flag_present_flag)
1130 /* pic output flag */
1131 vl_rbsp_u(&rbsp, 1);
1132
1133 if (sps->flags.separate_colour_plane_flag)
1134 /* colour_plane_id */
1135 vl_rbsp_u(&rbsp, 2);
1136
1137 if (!pic_info->pStdPictureInfo->flags.IdrPicFlag) {
1138 /* slice_pic_order_cnt_lsb */
1139 params->pic_order_cnt_lsb =
1140 vl_rbsp_u(&rbsp, sps->log2_max_pic_order_cnt_lsb_minus4 + 4);
1141
1142 /* short_term_ref_pic_set_sps_flag */
1143 if (!vl_rbsp_u(&rbsp, 1)) {
1144 uint8_t rps_predict = 0;
1145
1146 if (sps->num_short_term_ref_pic_sets)
1147 rps_predict = vl_rbsp_u(&rbsp, 1);
1148
1149 if (rps_predict) {
1150 /* delta_idx */
1151 vl_rbsp_ue(&rbsp);
1152 /* delta_rps_sign */
1153 vl_rbsp_u(&rbsp, 1);
1154 /* abs_delta_rps */
1155 vl_rbsp_ue(&rbsp);
1156
1157 for (int i = 0 ; i <= pic_info->pStdPictureInfo->NumDeltaPocsOfRefRpsIdx; i++) {
1158 uint8_t used = vl_rbsp_u(&rbsp, 1);
1159 if (!used)
1160 vl_rbsp_u(&rbsp, 1);
1161 }
1162 } else {
1163 /* num_negative_pics */
1164 unsigned num_neg_pics = vl_rbsp_ue(&rbsp);
1165 /* num_positive_pics */
1166 unsigned num_pos_pics = vl_rbsp_ue(&rbsp);
1167
1168 for(unsigned i = 0 ; i < num_neg_pics; ++i) {
1169 /* delta_poc_s0_minus1 */
1170 vl_rbsp_ue(&rbsp);
1171 /* used_by_curr_pic_s0_flag */
1172 vl_rbsp_u(&rbsp, 1);
1173 }
1174
1175 for(unsigned i = 0; i < num_pos_pics; ++i) {
1176 /* delta_poc_s1_minus1 */
1177 vl_rbsp_ue(&rbsp);
1178 /* used_by_curr_pic_s0_flag */
1179 vl_rbsp_u(&rbsp, 1);
1180 }
1181 }
1182
1183 } else {
1184 unsigned num_st_rps = sps->num_short_term_ref_pic_sets;
1185
1186 int numbits = util_logbase2_ceil(num_st_rps);
1187 if (numbits > 0)
1188 /* short_term_ref_pic_set_idx */
1189 vl_rbsp_u(&rbsp, numbits);
1190 }
1191
1192 if (sps->flags.long_term_ref_pics_present_flag) {
1193 unsigned num_lt_sps = 0;
1194
1195 if (sps->num_long_term_ref_pics_sps > 0)
1196 num_lt_sps = vl_rbsp_ue(&rbsp);
1197
1198 unsigned num_lt_pics = vl_rbsp_ue(&rbsp);
1199 unsigned num_refs = num_lt_pics + num_lt_sps;
1200
1201 for (unsigned i = 0; i < num_refs; i++) {
1202 if (i < num_lt_sps) {
1203 if (sps->num_long_term_ref_pics_sps > 1)
1204 /* lt_idx_sps */
1205 vl_rbsp_u(&rbsp,
1206 util_logbase2_ceil(sps->num_long_term_ref_pics_sps));
1207 } else {
1208 /* poc_lsb_lt */
1209 vl_rbsp_u(&rbsp, sps->log2_max_pic_order_cnt_lsb_minus4 + 4);
1210 /* used_by_curr_pic_lt_flag */
1211 vl_rbsp_u(&rbsp, 1);
1212 }
1213
1214 /* poc_msb_present */
1215 if (vl_rbsp_u(&rbsp, 1)) {
1216 /* delta_poc_msb_cycle_lt */
1217 vl_rbsp_ue(&rbsp);
1218 }
1219 }
1220 }
1221
1222 if (sps->flags.sps_temporal_mvp_enabled_flag)
1223 params->temporal_mvp_enable = vl_rbsp_u(&rbsp, 1);
1224 }
1225
1226 if (sps->flags.sample_adaptive_offset_enabled_flag) {
1227 params->sao_luma_flag = vl_rbsp_u(&rbsp, 1);
1228 if (sps->chroma_format_idc)
1229 params->sao_chroma_flag = vl_rbsp_u(&rbsp, 1);
1230 }
1231
1232 params->max_num_merge_cand = 5;
1233
1234 if (params->slice_type != STD_VIDEO_H265_SLICE_TYPE_I) {
1235
1236 params->num_ref_idx_l0_active = pps->num_ref_idx_l0_default_active_minus1 + 1;
1237
1238 if (params->slice_type == STD_VIDEO_H265_SLICE_TYPE_B)
1239 params->num_ref_idx_l1_active = pps->num_ref_idx_l1_default_active_minus1 + 1;
1240 else
1241 params->num_ref_idx_l1_active = 0;
1242
1243 /* num_ref_idx_active_override_flag */
1244 if (vl_rbsp_u(&rbsp, 1)) {
1245 params->num_ref_idx_l0_active = vl_rbsp_ue(&rbsp) + 1;
1246 if (params->slice_type == STD_VIDEO_H265_SLICE_TYPE_B)
1247 params->num_ref_idx_l1_active = vl_rbsp_ue(&rbsp) + 1;
1248 }
1249
1250 if (pps->flags.lists_modification_present_flag) {
1251 params->rpl_modification_flag[0] = vl_rbsp_u(&rbsp, 1);
1252 if (params->rpl_modification_flag[0]) {
1253 for (int i = 0; i < params->num_ref_idx_l0_active; i++) {
1254 /* list_entry_l0 */
1255 vl_rbsp_u(&rbsp,
1256 util_logbase2_ceil(params->num_ref_idx_l0_active + params->num_ref_idx_l1_active));
1257 }
1258 }
1259
1260 if (params->slice_type == STD_VIDEO_H265_SLICE_TYPE_B) {
1261 params->rpl_modification_flag[1] = vl_rbsp_u(&rbsp, 1);
1262 if (params->rpl_modification_flag[1]) {
1263 for (int i = 0; i < params->num_ref_idx_l1_active; i++) {
1264 /* list_entry_l1 */
1265 vl_rbsp_u(&rbsp,
1266 util_logbase2_ceil(params->num_ref_idx_l0_active + params->num_ref_idx_l1_active));
1267 }
1268 }
1269 }
1270 }
1271
1272 if (params->slice_type == STD_VIDEO_H265_SLICE_TYPE_B)
1273 params->mvd_l1_zero_flag = vl_rbsp_u(&rbsp, 1);
1274
1275 if (pps->flags.cabac_init_present_flag)
1276 /* cabac_init_flag */
1277 params->cabac_init_idc = vl_rbsp_u(&rbsp, 1);
1278
1279 if (params->temporal_mvp_enable) {
1280 if (params->slice_type == STD_VIDEO_H265_SLICE_TYPE_B)
1281 params->collocated_list = !vl_rbsp_u(&rbsp, 1);
1282
1283 if (params->collocated_list == 0) {
1284 if (params->num_ref_idx_l0_active > 1)
1285 params->collocated_ref_idx = vl_rbsp_ue(&rbsp);
1286 } else if (params->collocated_list == 1) {
1287 if (params->num_ref_idx_l1_active > 1)
1288 params->collocated_ref_idx = vl_rbsp_ue(&rbsp);
1289 }
1290 }
1291
1292 if ((pps->flags.weighted_pred_flag && params->slice_type == STD_VIDEO_H265_SLICE_TYPE_P) ||
1293 (pps->flags.weighted_bipred_flag && params->slice_type == STD_VIDEO_H265_SLICE_TYPE_B)) {
1294 h265_pred_weight_table(params, &rbsp, sps, params->slice_type);
1295 }
1296
1297 params->max_num_merge_cand -= vl_rbsp_ue(&rbsp);
1298 }
1299
1300 params->slice_qp_delta = vl_rbsp_se(&rbsp);
1301
1302 if (pps->flags.pps_slice_chroma_qp_offsets_present_flag) {
1303 params->slice_cb_qp_offset = vl_rbsp_se(&rbsp);
1304 params->slice_cr_qp_offset = vl_rbsp_se(&rbsp);
1305 }
1306
1307 if (pps->flags.chroma_qp_offset_list_enabled_flag)
1308 /* cu_chroma_qp_offset_enabled_flag */
1309 vl_rbsp_u(&rbsp, 1);
1310
1311 if (pps->flags.deblocking_filter_control_present_flag) {
1312 if (pps->flags.deblocking_filter_override_enabled_flag) {
1313 /* deblocking_filter_override_flag */
1314 if (vl_rbsp_u(&rbsp, 1)) {
1315 params->disable_deblocking_filter_idc = vl_rbsp_u(&rbsp, 1);
1316
1317 if (!params->disable_deblocking_filter_idc) {
1318 params->beta_offset_div2 = vl_rbsp_se(&rbsp);
1319 params->tc_offset_div2 = vl_rbsp_se(&rbsp);
1320 }
1321 } else {
1322 params->disable_deblocking_filter_idc =
1323 pps->flags.pps_deblocking_filter_disabled_flag;
1324 }
1325 }
1326 }
1327
1328 if (pps->flags.pps_loop_filter_across_slices_enabled_flag &&
1329 (params->sao_luma_flag || params->sao_chroma_flag ||
1330 !params->disable_deblocking_filter_idc))
1331 params->loop_filter_across_slices_enable = vl_rbsp_u(&rbsp, 1);
1332
1333 if (pps->flags.tiles_enabled_flag || pps->flags.entropy_coding_sync_enabled_flag) {
1334 unsigned num_entry_points_offsets = vl_rbsp_ue(&rbsp);
1335
1336 if (num_entry_points_offsets > 0) {
1337 unsigned offset_len = vl_rbsp_ue(&rbsp) + 1;
1338 for (unsigned i = 0; i < num_entry_points_offsets; i++) {
1339 /* entry_point_offset_minus1 */
1340 vl_rbsp_u(&rbsp, offset_len);
1341 }
1342 }
1343 }
1344
1345 if (pps->flags.pps_extension_present_flag) {
1346 unsigned length = vl_rbsp_ue(&rbsp);
1347 for (unsigned i = 0; i < length; i++)
1348 /* slice_reserved_undetermined_flag */
1349 vl_rbsp_u(&rbsp, 1);
1350 }
1351
1352 unsigned header_bits =
1353 (slice_size * 8 - 24 /* start code */) - vl_vlc_bits_left(&rbsp.nal) - rbsp.removed;
1354 params->slice_data_bytes_offset = (header_bits + 8) / 8;
1355 }
1356
1357 void
vk_video_get_profile_alignments(const VkVideoProfileListInfoKHR * profile_list,uint32_t * width_align_out,uint32_t * height_align_out)1358 vk_video_get_profile_alignments(const VkVideoProfileListInfoKHR *profile_list,
1359 uint32_t *width_align_out, uint32_t *height_align_out)
1360 {
1361 uint32_t width_align = 1, height_align = 1;
1362
1363 if (!profile_list) {
1364 width_align = MAX2(width_align, VK_VIDEO_H264_MACROBLOCK_WIDTH);
1365 height_align = MAX2(height_align, VK_VIDEO_H264_MACROBLOCK_HEIGHT);
1366 width_align = MAX2(width_align, VK_VIDEO_H265_CTU_MAX_WIDTH);
1367 height_align = MAX2(height_align, VK_VIDEO_H265_CTU_MAX_HEIGHT);
1368 width_align = MAX2(width_align, VK_VIDEO_AV1_BLOCK_WIDTH);
1369 height_align = MAX2(height_align, VK_VIDEO_AV1_BLOCK_HEIGHT);
1370 } else {
1371 for (unsigned i = 0; i < profile_list->profileCount; i++) {
1372 if (profile_list->pProfiles[i].videoCodecOperation == VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR ||
1373 profile_list->pProfiles[i].videoCodecOperation == VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR
1374 ) {
1375 width_align = MAX2(width_align, VK_VIDEO_H264_MACROBLOCK_WIDTH);
1376 height_align = MAX2(height_align, VK_VIDEO_H264_MACROBLOCK_HEIGHT);
1377 }
1378 if (profile_list->pProfiles[i].videoCodecOperation == VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR ||
1379 profile_list->pProfiles[i].videoCodecOperation == VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR
1380 ) {
1381 width_align = MAX2(width_align, VK_VIDEO_H265_CTU_MAX_WIDTH);
1382 height_align = MAX2(height_align, VK_VIDEO_H265_CTU_MAX_HEIGHT);
1383 }
1384 if (profile_list->pProfiles[i].videoCodecOperation == VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR) {
1385 width_align = MAX2(width_align, VK_VIDEO_AV1_BLOCK_WIDTH);
1386 height_align = MAX2(height_align, VK_VIDEO_AV1_BLOCK_HEIGHT);
1387 }
1388 }
1389 }
1390 *width_align_out = width_align;
1391 *height_align_out = height_align;
1392 }
1393
1394 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};
1395 uint8_t
vk_video_get_h264_level(StdVideoH264LevelIdc level)1396 vk_video_get_h264_level(StdVideoH264LevelIdc level)
1397 {
1398 assert(level <= STD_VIDEO_H264_LEVEL_IDC_6_2);
1399 return vk_video_h264_levels[level];
1400 }
1401
1402 const StdVideoH264SequenceParameterSet *
vk_video_find_h264_enc_std_sps(const struct vk_video_session_parameters * params,uint32_t id)1403 vk_video_find_h264_enc_std_sps(const struct vk_video_session_parameters *params,
1404 uint32_t id)
1405 {
1406 return &find_h264_enc_h264_sps(params, id)->base;
1407 }
1408
1409 const StdVideoH264PictureParameterSet *
vk_video_find_h264_enc_std_pps(const struct vk_video_session_parameters * params,uint32_t id)1410 vk_video_find_h264_enc_std_pps(const struct vk_video_session_parameters *params,
1411 uint32_t id)
1412 {
1413 return &find_h264_enc_h264_pps(params, id)->base;
1414 }
1415
1416 const StdVideoH265VideoParameterSet *
vk_video_find_h265_enc_std_vps(const struct vk_video_session_parameters * params,uint32_t id)1417 vk_video_find_h265_enc_std_vps(const struct vk_video_session_parameters *params,
1418 uint32_t id)
1419 {
1420 return &find_h265_enc_h265_vps(params, id)->base;
1421 }
1422
1423 const StdVideoH265SequenceParameterSet *
vk_video_find_h265_enc_std_sps(const struct vk_video_session_parameters * params,uint32_t id)1424 vk_video_find_h265_enc_std_sps(const struct vk_video_session_parameters *params,
1425 uint32_t id)
1426 {
1427 return &find_h265_enc_h265_sps(params, id)->base;
1428 }
1429
1430 const StdVideoH265PictureParameterSet *
vk_video_find_h265_enc_std_pps(const struct vk_video_session_parameters * params,uint32_t id)1431 vk_video_find_h265_enc_std_pps(const struct vk_video_session_parameters *params,
1432 uint32_t id)
1433 {
1434 return &find_h265_enc_h265_pps(params, id)->base;
1435 }
1436
1437 enum H264NALUType
1438 {
1439 H264_NAL_UNSPECIFIED = 0,
1440 H264_NAL_SLICE = 1,
1441 H264_NAL_SLICEDATA_A = 2,
1442 H264_NAL_SLICEDATA_B = 3,
1443 H264_NAL_SLICEDATA_C = 4,
1444 H264_NAL_IDR = 5,
1445 H264_NAL_SEI = 6,
1446 H264_NAL_SPS = 7,
1447 H264_NAL_PPS = 8,
1448 H264_NAL_ACCESS_UNIT_DEMILITER = 9,
1449 H264_NAL_END_OF_SEQUENCE = 10,
1450 H264_NAL_END_OF_STREAM = 11,
1451 H264_NAL_FILLER_DATA = 12,
1452 H264_NAL_SPS_EXTENSION = 13,
1453 H264_NAL_PREFIX = 14,
1454 /* 15...18 RESERVED */
1455 H264_NAL_AUXILIARY_SLICE = 19,
1456 /* 20...23 RESERVED */
1457 /* 24...31 UNSPECIFIED */
1458 };
1459
1460 enum HEVCNALUnitType {
1461 HEVC_NAL_TRAIL_N = 0,
1462 HEVC_NAL_TRAIL_R = 1,
1463 HEVC_NAL_TSA_N = 2,
1464 HEVC_NAL_TSA_R = 3,
1465 HEVC_NAL_STSA_N = 4,
1466 HEVC_NAL_STSA_R = 5,
1467 HEVC_NAL_RADL_N = 6,
1468 HEVC_NAL_RADL_R = 7,
1469 HEVC_NAL_RASL_N = 8,
1470 HEVC_NAL_RASL_R = 9,
1471 HEVC_NAL_VCL_N10 = 10,
1472 HEVC_NAL_VCL_R11 = 11,
1473 HEVC_NAL_VCL_N12 = 12,
1474 HEVC_NAL_VCL_R13 = 13,
1475 HEVC_NAL_VCL_N14 = 14,
1476 HEVC_NAL_VCL_R15 = 15,
1477 HEVC_NAL_BLA_W_LP = 16,
1478 HEVC_NAL_BLA_W_RADL = 17,
1479 HEVC_NAL_BLA_N_LP = 18,
1480 HEVC_NAL_IDR_W_RADL = 19,
1481 HEVC_NAL_IDR_N_LP = 20,
1482 HEVC_NAL_CRA_NUT = 21,
1483 HEVC_NAL_VPS_NUT = 32,
1484 HEVC_NAL_SPS_NUT = 33,
1485 HEVC_NAL_PPS_NUT = 34,
1486 };
1487
1488 unsigned
vk_video_get_h265_nal_unit(const StdVideoEncodeH265PictureInfo * pic_info)1489 vk_video_get_h265_nal_unit(const StdVideoEncodeH265PictureInfo *pic_info)
1490 {
1491 switch (pic_info->pic_type) {
1492 case STD_VIDEO_H265_PICTURE_TYPE_IDR:
1493 return HEVC_NAL_IDR_W_RADL;
1494 case STD_VIDEO_H265_PICTURE_TYPE_I:
1495 return HEVC_NAL_CRA_NUT;
1496 case STD_VIDEO_H265_PICTURE_TYPE_P:
1497 return HEVC_NAL_TRAIL_R;
1498 case STD_VIDEO_H265_PICTURE_TYPE_B:
1499 if (pic_info->flags.IrapPicFlag)
1500 if (pic_info->flags.is_reference)
1501 return HEVC_NAL_RASL_R;
1502 else
1503 return HEVC_NAL_RASL_N;
1504 else
1505 if (pic_info->flags.is_reference)
1506 return HEVC_NAL_TRAIL_R;
1507 else
1508 return HEVC_NAL_TRAIL_N;
1509 break;
1510 default:
1511 assert(0);
1512 break;
1513 }
1514 return 0;
1515 }
1516
1517 static const uint8_t vk_video_h265_levels[] = {10, 20, 21, 30, 31, 40, 41, 50, 51, 52, 60, 61, 62};
1518
1519 static uint8_t
vk_video_get_h265_level(StdVideoH265LevelIdc level)1520 vk_video_get_h265_level(StdVideoH265LevelIdc level)
1521 {
1522 assert(level <= STD_VIDEO_H265_LEVEL_IDC_6_2);
1523 return vk_video_h265_levels[level];
1524 }
1525
1526 static void
emit_nalu_header(struct vl_bitstream_encoder * enc,int nal_ref,int nal_unit)1527 emit_nalu_header(struct vl_bitstream_encoder *enc,
1528 int nal_ref, int nal_unit)
1529 {
1530 enc->prevent_start_code = false;
1531
1532 vl_bitstream_put_bits(enc, 24, 0);
1533 vl_bitstream_put_bits(enc, 8, 1);
1534 vl_bitstream_put_bits(enc, 1, 0);
1535 vl_bitstream_put_bits(enc, 2, nal_ref); /* SPS NAL REF */
1536 vl_bitstream_put_bits(enc, 5, nal_unit); /* SPS NAL UNIT */
1537 vl_bitstream_flush(enc);
1538
1539 enc->prevent_start_code = true;
1540 }
1541
1542 static void
encode_hrd_params(struct vl_bitstream_encoder * enc,const StdVideoH264HrdParameters * hrd)1543 encode_hrd_params(struct vl_bitstream_encoder *enc,
1544 const StdVideoH264HrdParameters *hrd)
1545 {
1546 vl_bitstream_exp_golomb_ue(enc, hrd->cpb_cnt_minus1);
1547 vl_bitstream_put_bits(enc, 4, hrd->bit_rate_scale);
1548 vl_bitstream_put_bits(enc, 4, hrd->cpb_size_scale);
1549 for (int sched_sel_idx = 0; sched_sel_idx <= hrd->cpb_cnt_minus1; sched_sel_idx++) {
1550 vl_bitstream_exp_golomb_ue(enc, hrd->bit_rate_value_minus1[sched_sel_idx]);
1551 vl_bitstream_exp_golomb_ue(enc, hrd->cpb_size_value_minus1[sched_sel_idx]);
1552 vl_bitstream_put_bits(enc, 1, hrd->cbr_flag[sched_sel_idx]);
1553 }
1554 vl_bitstream_put_bits(enc, 5, hrd->initial_cpb_removal_delay_length_minus1);
1555 vl_bitstream_put_bits(enc, 5, hrd->cpb_removal_delay_length_minus1);
1556 vl_bitstream_put_bits(enc, 5, hrd->dpb_output_delay_length_minus1);
1557 vl_bitstream_put_bits(enc, 5, hrd->time_offset_length);
1558 }
1559
1560 void
vk_video_encode_h264_sps(const StdVideoH264SequenceParameterSet * sps,size_t size_limit,size_t * data_size_ptr,void * data_ptr)1561 vk_video_encode_h264_sps(const StdVideoH264SequenceParameterSet *sps,
1562 size_t size_limit,
1563 size_t *data_size_ptr,
1564 void *data_ptr)
1565 {
1566 struct vl_bitstream_encoder enc;
1567 uint32_t data_size = *data_size_ptr;
1568
1569 vl_bitstream_encoder_clear(&enc, data_ptr, data_size, size_limit);
1570
1571 emit_nalu_header(&enc, 3, H264_NAL_SPS);
1572
1573 vl_bitstream_put_bits(&enc, 8, sps->profile_idc);
1574 vl_bitstream_put_bits(&enc, 1, sps->flags.constraint_set0_flag);
1575 vl_bitstream_put_bits(&enc, 1, sps->flags.constraint_set1_flag);
1576 vl_bitstream_put_bits(&enc, 1, sps->flags.constraint_set2_flag);
1577 vl_bitstream_put_bits(&enc, 1, sps->flags.constraint_set3_flag);
1578 vl_bitstream_put_bits(&enc, 1, sps->flags.constraint_set4_flag);
1579 vl_bitstream_put_bits(&enc, 1, sps->flags.constraint_set5_flag);
1580 vl_bitstream_put_bits(&enc, 2, 0);
1581 vl_bitstream_put_bits(&enc, 8, vk_video_get_h264_level(sps->level_idc));
1582 vl_bitstream_exp_golomb_ue(&enc, sps->seq_parameter_set_id);
1583
1584 if (sps->profile_idc == STD_VIDEO_H264_PROFILE_IDC_HIGH /* high10 as well */) {
1585 vl_bitstream_exp_golomb_ue(&enc, sps->chroma_format_idc);
1586 vl_bitstream_exp_golomb_ue(&enc, sps->bit_depth_luma_minus8);
1587 vl_bitstream_exp_golomb_ue(&enc, sps->bit_depth_chroma_minus8);
1588 vl_bitstream_put_bits(&enc, 1, sps->flags.qpprime_y_zero_transform_bypass_flag);
1589 vl_bitstream_put_bits(&enc, 1, sps->flags.seq_scaling_matrix_present_flag);
1590 }
1591
1592 vl_bitstream_exp_golomb_ue(&enc, sps->log2_max_frame_num_minus4);
1593
1594 vl_bitstream_exp_golomb_ue(&enc, sps->pic_order_cnt_type);
1595 if (sps->pic_order_cnt_type == 0)
1596 vl_bitstream_exp_golomb_ue(&enc, sps->log2_max_pic_order_cnt_lsb_minus4);
1597
1598 vl_bitstream_exp_golomb_ue(&enc, sps->max_num_ref_frames);
1599 vl_bitstream_put_bits(&enc, 1, sps->flags.gaps_in_frame_num_value_allowed_flag);
1600 vl_bitstream_exp_golomb_ue(&enc, sps->pic_width_in_mbs_minus1);
1601 vl_bitstream_exp_golomb_ue(&enc, sps->pic_height_in_map_units_minus1);
1602
1603 vl_bitstream_put_bits(&enc, 1, sps->flags.frame_mbs_only_flag);
1604 vl_bitstream_put_bits(&enc, 1, sps->flags.direct_8x8_inference_flag);
1605
1606 vl_bitstream_put_bits(&enc, 1, sps->flags.frame_cropping_flag);
1607 if (sps->flags.frame_cropping_flag) {
1608 vl_bitstream_exp_golomb_ue(&enc, sps->frame_crop_left_offset);
1609 vl_bitstream_exp_golomb_ue(&enc, sps->frame_crop_right_offset);
1610 vl_bitstream_exp_golomb_ue(&enc, sps->frame_crop_top_offset);
1611 vl_bitstream_exp_golomb_ue(&enc, sps->frame_crop_bottom_offset);
1612 }
1613
1614 vl_bitstream_put_bits(&enc, 1, sps->flags.vui_parameters_present_flag); /* vui parameters present flag */
1615 if (sps->flags.vui_parameters_present_flag) {
1616 const StdVideoH264SequenceParameterSetVui *vui = sps->pSequenceParameterSetVui;
1617 vl_bitstream_put_bits(&enc, 1, vui->flags.aspect_ratio_info_present_flag);
1618
1619 if (vui->flags.aspect_ratio_info_present_flag) {
1620 vl_bitstream_put_bits(&enc, 8, vui->aspect_ratio_idc);
1621 if (vui->aspect_ratio_idc == STD_VIDEO_H264_ASPECT_RATIO_IDC_EXTENDED_SAR) {
1622 vl_bitstream_put_bits(&enc, 16, vui->sar_width);
1623 vl_bitstream_put_bits(&enc, 16, vui->sar_height);
1624 }
1625 }
1626
1627 vl_bitstream_put_bits(&enc, 1, vui->flags.overscan_info_present_flag);
1628 if (vui->flags.overscan_info_present_flag)
1629 vl_bitstream_put_bits(&enc, 1, vui->flags.overscan_appropriate_flag);
1630 vl_bitstream_put_bits(&enc, 1, vui->flags.video_signal_type_present_flag);
1631 if (vui->flags.video_signal_type_present_flag) {
1632 vl_bitstream_put_bits(&enc, 3, vui->video_format);
1633 vl_bitstream_put_bits(&enc, 1, vui->flags.video_full_range_flag);
1634 vl_bitstream_put_bits(&enc, 1, vui->flags.color_description_present_flag);
1635 if (vui->flags.color_description_present_flag) {
1636 vl_bitstream_put_bits(&enc, 8, vui->colour_primaries);
1637 vl_bitstream_put_bits(&enc, 8, vui->transfer_characteristics);
1638 vl_bitstream_put_bits(&enc, 8, vui->matrix_coefficients);
1639 }
1640 }
1641
1642 vl_bitstream_put_bits(&enc, 1, vui->flags.chroma_loc_info_present_flag);
1643 if (vui->flags.chroma_loc_info_present_flag) {
1644 vl_bitstream_exp_golomb_ue(&enc, vui->chroma_sample_loc_type_top_field);
1645 vl_bitstream_exp_golomb_ue(&enc, vui->chroma_sample_loc_type_bottom_field);
1646 }
1647 vl_bitstream_put_bits(&enc, 1, vui->flags.timing_info_present_flag);
1648 if (vui->flags.timing_info_present_flag) {
1649 vl_bitstream_put_bits(&enc, 32, vui->num_units_in_tick);
1650 vl_bitstream_put_bits(&enc, 32, vui->time_scale);
1651 vl_bitstream_put_bits(&enc, 1, vui->flags.fixed_frame_rate_flag);
1652 }
1653 vl_bitstream_put_bits(&enc, 1, vui->flags.nal_hrd_parameters_present_flag);
1654 if (vui->flags.nal_hrd_parameters_present_flag)
1655 encode_hrd_params(&enc, vui->pHrdParameters);
1656 vl_bitstream_put_bits(&enc, 1, vui->flags.vcl_hrd_parameters_present_flag);
1657 if (vui->flags.vcl_hrd_parameters_present_flag)
1658 encode_hrd_params(&enc, vui->pHrdParameters);
1659 if (vui->flags.nal_hrd_parameters_present_flag || vui->flags.vcl_hrd_parameters_present_flag)
1660 vl_bitstream_put_bits(&enc, 1, 0);
1661 vl_bitstream_put_bits(&enc, 1, 0);
1662 vl_bitstream_put_bits(&enc, 1, vui->flags.bitstream_restriction_flag);
1663 if (vui->flags.bitstream_restriction_flag) {
1664 vl_bitstream_put_bits(&enc, 1, 0);
1665 vl_bitstream_exp_golomb_ue(&enc, 0);
1666 vl_bitstream_exp_golomb_ue(&enc, 0);
1667 vl_bitstream_exp_golomb_ue(&enc, 0);
1668 vl_bitstream_exp_golomb_ue(&enc, 0);
1669 vl_bitstream_exp_golomb_ue(&enc, vui->max_num_reorder_frames);
1670 vl_bitstream_exp_golomb_ue(&enc, vui->max_dec_frame_buffering);
1671 }
1672 }
1673
1674 vl_bitstream_rbsp_trailing(&enc);
1675
1676 vl_bitstream_flush(&enc);
1677 *data_size_ptr += vl_bitstream_get_byte_count(&enc);
1678 vl_bitstream_encoder_free(&enc);
1679 }
1680
1681 void
vk_video_encode_h264_pps(const StdVideoH264PictureParameterSet * pps,bool high_profile,size_t size_limit,size_t * data_size_ptr,void * data_ptr)1682 vk_video_encode_h264_pps(const StdVideoH264PictureParameterSet *pps,
1683 bool high_profile,
1684 size_t size_limit,
1685 size_t *data_size_ptr,
1686 void *data_ptr)
1687 {
1688 struct vl_bitstream_encoder enc;
1689 uint32_t data_size = *data_size_ptr;
1690
1691 vl_bitstream_encoder_clear(&enc, data_ptr, data_size, size_limit);
1692
1693 emit_nalu_header(&enc, 3, H264_NAL_PPS);
1694
1695 vl_bitstream_exp_golomb_ue(&enc, pps->pic_parameter_set_id);
1696 vl_bitstream_exp_golomb_ue(&enc, pps->seq_parameter_set_id);
1697 vl_bitstream_put_bits(&enc, 1, pps->flags.entropy_coding_mode_flag);
1698 vl_bitstream_put_bits(&enc, 1, pps->flags.bottom_field_pic_order_in_frame_present_flag);
1699 vl_bitstream_exp_golomb_ue(&enc, 0); /* num_slice_groups_minus1 */
1700
1701 vl_bitstream_exp_golomb_ue(&enc, pps->num_ref_idx_l0_default_active_minus1);
1702 vl_bitstream_exp_golomb_ue(&enc, pps->num_ref_idx_l1_default_active_minus1);
1703 vl_bitstream_put_bits(&enc, 1, pps->flags.weighted_pred_flag);
1704 vl_bitstream_put_bits(&enc, 2, pps->weighted_bipred_idc);
1705 vl_bitstream_exp_golomb_se(&enc, pps->pic_init_qp_minus26);
1706 vl_bitstream_exp_golomb_se(&enc, pps->pic_init_qs_minus26);
1707 vl_bitstream_exp_golomb_se(&enc, pps->chroma_qp_index_offset);
1708 vl_bitstream_put_bits(&enc, 1, pps->flags.deblocking_filter_control_present_flag);
1709 vl_bitstream_put_bits(&enc, 1, pps->flags.constrained_intra_pred_flag);
1710 vl_bitstream_put_bits(&enc, 1, pps->flags.redundant_pic_cnt_present_flag);
1711
1712 /* high profile */
1713 if (high_profile) {
1714 vl_bitstream_put_bits(&enc, 1, pps->flags.transform_8x8_mode_flag);
1715 vl_bitstream_put_bits(&enc, 1, pps->flags.pic_scaling_matrix_present_flag);
1716 vl_bitstream_exp_golomb_se(&enc, pps->second_chroma_qp_index_offset);
1717 }
1718 vl_bitstream_rbsp_trailing(&enc);
1719
1720 vl_bitstream_flush(&enc);
1721 *data_size_ptr += vl_bitstream_get_byte_count(&enc);
1722 vl_bitstream_encoder_free(&enc);
1723 }
1724
1725 static void
emit_nalu_h265_header(struct vl_bitstream_encoder * enc,int nal_unit_type)1726 emit_nalu_h265_header(struct vl_bitstream_encoder *enc,
1727 int nal_unit_type)
1728 {
1729 enc->prevent_start_code = false;
1730
1731 vl_bitstream_put_bits(enc, 24, 0);
1732 vl_bitstream_put_bits(enc, 8, 1);
1733 vl_bitstream_put_bits(enc, 1, 0);
1734 vl_bitstream_put_bits(enc, 6, nal_unit_type); /* SPS NAL REF */
1735 vl_bitstream_put_bits(enc, 6, 0);//nuh_layer_id
1736 vl_bitstream_put_bits(enc, 3, 1);//nuh_temporal_id_plus1;
1737 vl_bitstream_flush(enc);
1738
1739 enc->prevent_start_code = true;
1740 }
1741
1742 static void
encode_h265_profile_tier_level(struct vl_bitstream_encoder * enc,const StdVideoH265ProfileTierLevel * ptl,unsigned int max_sub_layers_minus1)1743 encode_h265_profile_tier_level(struct vl_bitstream_encoder *enc,
1744 const StdVideoH265ProfileTierLevel *ptl,
1745 unsigned int max_sub_layers_minus1)
1746 {
1747 vl_bitstream_put_bits(enc, 2, 0);
1748 vl_bitstream_put_bits(enc, 1, ptl->flags.general_tier_flag);
1749 vl_bitstream_put_bits(enc, 5, ptl->general_profile_idc);
1750
1751 for (int j = 0; j < 32; j++)
1752 vl_bitstream_put_bits(enc, 1, j == ptl->general_profile_idc);
1753
1754 vl_bitstream_put_bits(enc, 1, ptl->flags.general_progressive_source_flag);
1755 vl_bitstream_put_bits(enc, 1, ptl->flags.general_interlaced_source_flag);
1756 vl_bitstream_put_bits(enc, 1, ptl->flags.general_non_packed_constraint_flag);
1757 vl_bitstream_put_bits(enc, 1, ptl->flags.general_frame_only_constraint_flag);
1758 vl_bitstream_put_bits(enc, 31, 0);
1759 vl_bitstream_put_bits(enc, 13, 0);
1760 vl_bitstream_put_bits(enc, 8, vk_video_get_h265_level(ptl->general_level_idc));
1761
1762 if (max_sub_layers_minus1 > 0) {
1763 /* sub_layer_(profile|level)_present_flag, plus padding */
1764 vl_bitstream_put_bits(enc, 16, 0);
1765 }
1766 }
1767
1768 void
vk_video_encode_h265_vps(const StdVideoH265VideoParameterSet * vps,size_t size_limit,size_t * data_size_ptr,void * data_ptr)1769 vk_video_encode_h265_vps(const StdVideoH265VideoParameterSet *vps,
1770 size_t size_limit,
1771 size_t *data_size_ptr,
1772 void *data_ptr)
1773 {
1774 struct vl_bitstream_encoder enc;
1775 uint32_t data_size = *data_size_ptr;
1776
1777 vl_bitstream_encoder_clear(&enc, data_ptr, data_size, size_limit);
1778
1779 emit_nalu_h265_header(&enc, HEVC_NAL_VPS_NUT);
1780
1781 vl_bitstream_put_bits(&enc, 4, vps->vps_video_parameter_set_id);
1782 vl_bitstream_put_bits(&enc, 2, 3);
1783 vl_bitstream_put_bits(&enc, 6, 0);//vps->vps_max_layers_minus1);
1784 vl_bitstream_put_bits(&enc, 3, vps->vps_max_sub_layers_minus1);
1785 vl_bitstream_put_bits(&enc, 1, vps->flags.vps_temporal_id_nesting_flag);
1786 vl_bitstream_put_bits(&enc, 16, 0xffff);
1787
1788 encode_h265_profile_tier_level(&enc, vps->pProfileTierLevel, vps->vps_max_sub_layers_minus1);
1789
1790 vl_bitstream_put_bits(&enc, 1, vps->flags.vps_sub_layer_ordering_info_present_flag);
1791
1792 int i = vps->flags.vps_sub_layer_ordering_info_present_flag ? 0 : vps->vps_max_sub_layers_minus1;
1793 for (; i <= vps->vps_max_sub_layers_minus1; i++) {
1794 vl_bitstream_exp_golomb_ue(&enc, vps->pDecPicBufMgr->max_dec_pic_buffering_minus1[i]);
1795 vl_bitstream_exp_golomb_ue(&enc, vps->pDecPicBufMgr->max_num_reorder_pics[i]);
1796 vl_bitstream_exp_golomb_ue(&enc, vps->pDecPicBufMgr->max_latency_increase_plus1[i]);
1797 }
1798
1799 vl_bitstream_put_bits(&enc, 6, 0);//vps->vps_max_layer_id);
1800 vl_bitstream_exp_golomb_ue(&enc, 0);//vps->vps_num_layer_sets_minus1);
1801 vl_bitstream_put_bits(&enc, 1, vps->flags.vps_timing_info_present_flag);
1802
1803 if (vps->flags.vps_timing_info_present_flag) {
1804 vl_bitstream_put_bits(&enc, 32, vps->vps_num_units_in_tick);
1805 vl_bitstream_put_bits(&enc, 32, vps->vps_time_scale);
1806 vl_bitstream_put_bits(&enc, 1, vps->flags.vps_poc_proportional_to_timing_flag);
1807 if (vps->flags.vps_poc_proportional_to_timing_flag)
1808 vl_bitstream_exp_golomb_ue(&enc, vps->vps_num_ticks_poc_diff_one_minus1);
1809 vl_bitstream_exp_golomb_ue(&enc, 0);
1810 }
1811
1812 vl_bitstream_put_bits(&enc, 1, 0); /* vps extension flag */
1813 vl_bitstream_rbsp_trailing(&enc);
1814
1815 vl_bitstream_flush(&enc);
1816 *data_size_ptr += vl_bitstream_get_byte_count(&enc);
1817 vl_bitstream_encoder_free(&enc);
1818 }
1819
1820 static void
encode_rps(struct vl_bitstream_encoder * enc,const StdVideoH265SequenceParameterSet * sps,int st_rps_idx)1821 encode_rps(struct vl_bitstream_encoder *enc,
1822 const StdVideoH265SequenceParameterSet *sps,
1823 int st_rps_idx)
1824 {
1825 const StdVideoH265ShortTermRefPicSet *rps = &sps->pShortTermRefPicSet[st_rps_idx];
1826 if (st_rps_idx != 0)
1827 vl_bitstream_put_bits(enc, 1, rps->flags.inter_ref_pic_set_prediction_flag);
1828
1829 if (rps->flags.inter_ref_pic_set_prediction_flag) {
1830 int ref_rps_idx = st_rps_idx - (rps->delta_idx_minus1 + 1);
1831 vl_bitstream_put_bits(enc, 1, rps->flags.delta_rps_sign);
1832 vl_bitstream_exp_golomb_ue(enc, rps->abs_delta_rps_minus1);
1833
1834 const StdVideoH265ShortTermRefPicSet *rps_ref = &sps->pShortTermRefPicSet[ref_rps_idx];
1835 int num_delta_pocs = rps_ref->num_negative_pics + rps_ref->num_positive_pics;
1836
1837 for (int j = 0; j < num_delta_pocs; j++) {
1838 vl_bitstream_put_bits(enc, 1, !!(rps->used_by_curr_pic_flag & (1 << j)));
1839 if (!(rps->used_by_curr_pic_flag & (1 << j))) {
1840 vl_bitstream_put_bits(enc, 1, !!(rps->use_delta_flag & (1 << j)));
1841 }
1842 }
1843 } else {
1844 vl_bitstream_exp_golomb_ue(enc, rps->num_negative_pics);
1845 vl_bitstream_exp_golomb_ue(enc, rps->num_positive_pics);
1846
1847 for (int i = 0; i < rps->num_negative_pics; i++) {
1848 vl_bitstream_exp_golomb_ue(enc, rps->delta_poc_s0_minus1[i]);
1849 vl_bitstream_put_bits(enc, 1, !!(rps->used_by_curr_pic_s0_flag & (1 << i)));
1850 }
1851 for (int i = 0; i < rps->num_positive_pics; i++) {
1852 vl_bitstream_exp_golomb_ue(enc, rps->delta_poc_s1_minus1[i]);
1853 vl_bitstream_put_bits(enc, 1, !!(rps->used_by_curr_pic_s1_flag & (1 << i)));
1854 }
1855 }
1856 }
1857
1858 void
vk_video_encode_h265_sps(const StdVideoH265SequenceParameterSet * sps,size_t size_limit,size_t * data_size_ptr,void * data_ptr)1859 vk_video_encode_h265_sps(const StdVideoH265SequenceParameterSet *sps,
1860 size_t size_limit,
1861 size_t *data_size_ptr,
1862 void *data_ptr)
1863 {
1864 struct vl_bitstream_encoder enc;
1865 uint32_t data_size = *data_size_ptr;
1866
1867 vl_bitstream_encoder_clear(&enc, data_ptr, data_size, size_limit);
1868
1869 emit_nalu_h265_header(&enc, HEVC_NAL_SPS_NUT);
1870
1871 vl_bitstream_put_bits(&enc, 4, sps->sps_video_parameter_set_id);
1872 vl_bitstream_put_bits(&enc, 3, sps->sps_max_sub_layers_minus1);
1873 vl_bitstream_put_bits(&enc, 1, sps->flags.sps_temporal_id_nesting_flag);
1874
1875 encode_h265_profile_tier_level(&enc, sps->pProfileTierLevel, sps->sps_max_sub_layers_minus1);
1876
1877 vl_bitstream_exp_golomb_ue(&enc, sps->sps_seq_parameter_set_id);
1878 vl_bitstream_exp_golomb_ue(&enc, sps->chroma_format_idc);
1879
1880 vl_bitstream_exp_golomb_ue(&enc, sps->pic_width_in_luma_samples);
1881 vl_bitstream_exp_golomb_ue(&enc, sps->pic_height_in_luma_samples);
1882
1883 vl_bitstream_put_bits(&enc, 1, sps->flags.conformance_window_flag);
1884
1885 if (sps->flags.conformance_window_flag) {
1886 vl_bitstream_exp_golomb_ue(&enc, sps->conf_win_left_offset);
1887 vl_bitstream_exp_golomb_ue(&enc, sps->conf_win_right_offset);
1888 vl_bitstream_exp_golomb_ue(&enc, sps->conf_win_top_offset);
1889 vl_bitstream_exp_golomb_ue(&enc, sps->conf_win_bottom_offset);
1890 }
1891
1892 vl_bitstream_exp_golomb_ue(&enc, sps->bit_depth_luma_minus8);
1893 vl_bitstream_exp_golomb_ue(&enc, sps->bit_depth_chroma_minus8);
1894
1895 vl_bitstream_exp_golomb_ue(&enc, sps->log2_max_pic_order_cnt_lsb_minus4);
1896 vl_bitstream_put_bits(&enc, 1, sps->flags.sps_sub_layer_ordering_info_present_flag);
1897
1898 int i = sps->flags.sps_sub_layer_ordering_info_present_flag ? 0 : sps->sps_max_sub_layers_minus1;
1899 for (; i <= sps->sps_max_sub_layers_minus1; i++) {
1900 vl_bitstream_exp_golomb_ue(&enc, sps->pDecPicBufMgr->max_dec_pic_buffering_minus1[i]);
1901 vl_bitstream_exp_golomb_ue(&enc, sps->pDecPicBufMgr->max_num_reorder_pics[i]);
1902 vl_bitstream_exp_golomb_ue(&enc, sps->pDecPicBufMgr->max_latency_increase_plus1[i]);
1903 }
1904
1905 vl_bitstream_exp_golomb_ue(&enc, sps->log2_min_luma_coding_block_size_minus3);
1906 vl_bitstream_exp_golomb_ue(&enc, sps->log2_diff_max_min_luma_coding_block_size);
1907 vl_bitstream_exp_golomb_ue(&enc, sps->log2_min_luma_transform_block_size_minus2);
1908 vl_bitstream_exp_golomb_ue(&enc, sps->log2_diff_max_min_luma_transform_block_size);
1909
1910 vl_bitstream_exp_golomb_ue(&enc, sps->max_transform_hierarchy_depth_inter);
1911 vl_bitstream_exp_golomb_ue(&enc, sps->max_transform_hierarchy_depth_intra);
1912
1913 vl_bitstream_put_bits(&enc, 1, sps->flags.scaling_list_enabled_flag);
1914
1915 vl_bitstream_put_bits(&enc, 1, sps->flags.amp_enabled_flag);
1916 vl_bitstream_put_bits(&enc, 1, sps->flags.sample_adaptive_offset_enabled_flag);
1917
1918 vl_bitstream_put_bits(&enc, 1, sps->flags.pcm_enabled_flag);
1919
1920 if (sps->flags.pcm_enabled_flag) {
1921 vl_bitstream_put_bits(&enc, 4, sps->bit_depth_luma_minus8 + 7);
1922 vl_bitstream_put_bits(&enc, 4, sps->bit_depth_chroma_minus8 + 7);
1923 vl_bitstream_exp_golomb_ue(&enc, sps->log2_min_luma_coding_block_size_minus3);
1924 vl_bitstream_exp_golomb_ue(&enc, sps->log2_diff_max_min_luma_coding_block_size);
1925 vl_bitstream_put_bits(&enc, 1, sps->flags.pcm_loop_filter_disabled_flag);
1926 }
1927
1928 vl_bitstream_exp_golomb_ue(&enc, sps->num_short_term_ref_pic_sets);
1929 for (int i = 0; i < sps->num_short_term_ref_pic_sets; i++)
1930 encode_rps(&enc, sps, i);
1931
1932 vl_bitstream_put_bits(&enc, 1, sps->flags.long_term_ref_pics_present_flag);
1933 if (sps->flags.long_term_ref_pics_present_flag) {
1934 vl_bitstream_exp_golomb_ue(&enc, sps->num_long_term_ref_pics_sps);
1935 for (int i = 0; i < sps->num_long_term_ref_pics_sps; i++) {
1936 vl_bitstream_put_bits(&enc, sps->log2_max_pic_order_cnt_lsb_minus4 + 4, sps->pLongTermRefPicsSps->lt_ref_pic_poc_lsb_sps[i]);
1937 vl_bitstream_put_bits(&enc, 1, sps->pLongTermRefPicsSps->used_by_curr_pic_lt_sps_flag);
1938 }
1939 }
1940
1941 vl_bitstream_put_bits(&enc, 1, sps->flags.sps_temporal_mvp_enabled_flag);
1942 vl_bitstream_put_bits(&enc, 1, sps->flags.strong_intra_smoothing_enabled_flag);
1943 vl_bitstream_put_bits(&enc, 1, sps->flags.vui_parameters_present_flag);
1944
1945 if (sps->flags.vui_parameters_present_flag) {
1946 const StdVideoH265SequenceParameterSetVui *vui = sps->pSequenceParameterSetVui;
1947 vl_bitstream_put_bits(&enc, 1, vui->flags.aspect_ratio_info_present_flag);
1948 if (vui->flags.aspect_ratio_info_present_flag) {
1949 vl_bitstream_put_bits(&enc, 8, vui->aspect_ratio_idc);
1950 if (vui->aspect_ratio_idc == STD_VIDEO_H265_ASPECT_RATIO_IDC_EXTENDED_SAR) {
1951 vl_bitstream_put_bits(&enc, 16, vui->sar_width);
1952 vl_bitstream_put_bits(&enc, 16, vui->sar_height);
1953 }
1954 }
1955 vl_bitstream_put_bits(&enc, 1, vui->flags.overscan_info_present_flag);
1956 if (vui->flags.overscan_info_present_flag)
1957 vl_bitstream_put_bits(&enc, 1, vui->flags.overscan_appropriate_flag);
1958 vl_bitstream_put_bits(&enc, 1, vui->flags.video_signal_type_present_flag);
1959 if (vui->flags.video_signal_type_present_flag) {
1960 vl_bitstream_put_bits(&enc, 3, vui->video_format);
1961 vl_bitstream_put_bits(&enc, 1, vui->flags.video_full_range_flag);
1962 vl_bitstream_put_bits(&enc, 1, vui->flags.colour_description_present_flag);
1963 if (vui->flags.colour_description_present_flag) {
1964 vl_bitstream_put_bits(&enc, 8, vui->colour_primaries);
1965 vl_bitstream_put_bits(&enc, 8, vui->transfer_characteristics);
1966 vl_bitstream_put_bits(&enc, 8, vui->matrix_coeffs);
1967 }
1968 }
1969 vl_bitstream_put_bits(&enc, 1, vui->flags.chroma_loc_info_present_flag);
1970 if (vui->flags.chroma_loc_info_present_flag) {
1971 vl_bitstream_exp_golomb_ue(&enc, vui->chroma_sample_loc_type_top_field);
1972 vl_bitstream_exp_golomb_ue(&enc, vui->chroma_sample_loc_type_bottom_field);
1973 }
1974 vl_bitstream_put_bits(&enc, 1, vui->flags.neutral_chroma_indication_flag);
1975 vl_bitstream_put_bits(&enc, 1, vui->flags.field_seq_flag);
1976 vl_bitstream_put_bits(&enc, 1, vui->flags.frame_field_info_present_flag);
1977 vl_bitstream_put_bits(&enc, 1, vui->flags.default_display_window_flag);
1978 if (vui->flags.default_display_window_flag) {
1979 vl_bitstream_exp_golomb_ue(&enc, vui->def_disp_win_left_offset);
1980 vl_bitstream_exp_golomb_ue(&enc, vui->def_disp_win_right_offset);
1981 vl_bitstream_exp_golomb_ue(&enc, vui->def_disp_win_top_offset);
1982 vl_bitstream_exp_golomb_ue(&enc, vui->def_disp_win_bottom_offset);
1983 }
1984 vl_bitstream_put_bits(&enc, 1, vui->flags.vui_timing_info_present_flag);
1985 if (vui->flags.vui_timing_info_present_flag) {
1986 vl_bitstream_put_bits(&enc, 32, vui->vui_num_units_in_tick);
1987 vl_bitstream_put_bits(&enc, 32, vui->vui_time_scale);
1988 vl_bitstream_put_bits(&enc, 1, vui->flags.vui_poc_proportional_to_timing_flag);
1989 if (vui->flags.vui_poc_proportional_to_timing_flag)
1990 vl_bitstream_exp_golomb_ue(&enc, vui->vui_num_ticks_poc_diff_one_minus1);
1991 vl_bitstream_put_bits(&enc, 1, 0);//vui->flags.vui_hrd_parameters_present_flag);
1992 // HRD
1993 }
1994
1995 vl_bitstream_put_bits(&enc, 1, vui->flags.bitstream_restriction_flag);
1996 if (vui->flags.bitstream_restriction_flag) {
1997 vl_bitstream_put_bits(&enc, 1, vui->flags.tiles_fixed_structure_flag);
1998 vl_bitstream_put_bits(&enc, 1, vui->flags.motion_vectors_over_pic_boundaries_flag);
1999 vl_bitstream_put_bits(&enc, 1, vui->flags.restricted_ref_pic_lists_flag);
2000 vl_bitstream_exp_golomb_ue(&enc, vui->min_spatial_segmentation_idc);
2001 vl_bitstream_exp_golomb_ue(&enc, vui->max_bytes_per_pic_denom);
2002 vl_bitstream_exp_golomb_ue(&enc, vui->max_bits_per_min_cu_denom);
2003 vl_bitstream_exp_golomb_ue(&enc, vui->log2_max_mv_length_horizontal);
2004 vl_bitstream_exp_golomb_ue(&enc, vui->log2_max_mv_length_vertical);
2005 }
2006 }
2007
2008 vl_bitstream_put_bits(&enc, 1, 0); /* sps extension flg */
2009 vl_bitstream_rbsp_trailing(&enc);
2010
2011 vl_bitstream_flush(&enc);
2012 *data_size_ptr += vl_bitstream_get_byte_count(&enc);
2013 vl_bitstream_encoder_free(&enc);
2014 }
2015
2016 void
vk_video_encode_h265_pps(const StdVideoH265PictureParameterSet * pps,size_t size_limit,size_t * data_size_ptr,void * data_ptr)2017 vk_video_encode_h265_pps(const StdVideoH265PictureParameterSet *pps,
2018 size_t size_limit,
2019 size_t *data_size_ptr,
2020 void *data_ptr)
2021 {
2022 struct vl_bitstream_encoder enc;
2023 uint32_t data_size = *data_size_ptr;
2024
2025 vl_bitstream_encoder_clear(&enc, data_ptr, data_size, size_limit);
2026
2027 emit_nalu_h265_header(&enc, HEVC_NAL_PPS_NUT);
2028 vl_bitstream_exp_golomb_ue(&enc, pps->pps_pic_parameter_set_id);
2029 vl_bitstream_exp_golomb_ue(&enc, pps->pps_seq_parameter_set_id);
2030
2031 vl_bitstream_put_bits(&enc, 1, pps->flags.dependent_slice_segments_enabled_flag);
2032
2033 vl_bitstream_put_bits(&enc, 1, pps->flags.output_flag_present_flag);
2034 vl_bitstream_put_bits(&enc, 3, pps->num_extra_slice_header_bits);
2035
2036 vl_bitstream_put_bits(&enc, 1, pps->flags.sign_data_hiding_enabled_flag);
2037 vl_bitstream_put_bits(&enc, 1, pps->flags.cabac_init_present_flag);
2038
2039 vl_bitstream_exp_golomb_ue(&enc, pps->num_ref_idx_l0_default_active_minus1);
2040 vl_bitstream_exp_golomb_ue(&enc, pps->num_ref_idx_l1_default_active_minus1);
2041
2042 vl_bitstream_exp_golomb_se(&enc, pps->init_qp_minus26);
2043
2044 vl_bitstream_put_bits(&enc, 1, pps->flags.constrained_intra_pred_flag);
2045 vl_bitstream_put_bits(&enc, 1, pps->flags.transform_skip_enabled_flag);
2046 vl_bitstream_put_bits(&enc, 1, pps->flags.cu_qp_delta_enabled_flag);
2047
2048 if (pps->flags.cu_qp_delta_enabled_flag)
2049 vl_bitstream_exp_golomb_ue(&enc, pps->diff_cu_qp_delta_depth);
2050
2051 vl_bitstream_exp_golomb_se(&enc, pps->pps_cb_qp_offset);
2052 vl_bitstream_exp_golomb_se(&enc, pps->pps_cr_qp_offset);
2053
2054 vl_bitstream_put_bits(&enc, 1, pps->flags.pps_slice_chroma_qp_offsets_present_flag);
2055 vl_bitstream_put_bits(&enc, 1, pps->flags.weighted_pred_flag);
2056 vl_bitstream_put_bits(&enc, 1, pps->flags.weighted_bipred_flag);
2057 vl_bitstream_put_bits(&enc, 1, pps->flags.transquant_bypass_enabled_flag);
2058
2059 vl_bitstream_put_bits(&enc, 1, pps->flags.tiles_enabled_flag);
2060 vl_bitstream_put_bits(&enc, 1, pps->flags.entropy_coding_sync_enabled_flag);
2061
2062 assert (!pps->flags.tiles_enabled_flag);
2063
2064 vl_bitstream_put_bits(&enc, 1, pps->flags.pps_loop_filter_across_slices_enabled_flag);
2065 vl_bitstream_put_bits(&enc, 1, pps->flags.deblocking_filter_control_present_flag);
2066
2067 if (pps->flags.deblocking_filter_control_present_flag) {
2068 vl_bitstream_put_bits(&enc, 1, pps->flags.deblocking_filter_override_enabled_flag);
2069 vl_bitstream_put_bits(&enc, 1, pps->flags.pps_deblocking_filter_disabled_flag);
2070 if (!pps->flags.pps_deblocking_filter_disabled_flag) {
2071 vl_bitstream_exp_golomb_se(&enc, pps->pps_beta_offset_div2);
2072 vl_bitstream_exp_golomb_se(&enc, pps->pps_tc_offset_div2);
2073 }
2074 }
2075
2076 vl_bitstream_put_bits(&enc, 1, pps->flags.pps_scaling_list_data_present_flag);
2077 assert (!pps->flags.pps_scaling_list_data_present_flag);
2078
2079 vl_bitstream_put_bits(&enc, 1, pps->flags.lists_modification_present_flag);
2080 vl_bitstream_exp_golomb_ue(&enc, pps->log2_parallel_merge_level_minus2);
2081 vl_bitstream_put_bits(&enc, 1, pps->flags.slice_segment_header_extension_present_flag);
2082
2083 vl_bitstream_put_bits(&enc, 1, 0); /* pps extension flag */
2084 vl_bitstream_rbsp_trailing(&enc);
2085
2086 vl_bitstream_flush(&enc);
2087 *data_size_ptr += vl_bitstream_get_byte_count(&enc);
2088 vl_bitstream_encoder_free(&enc);
2089 }
2090
2091 void
vk_video_encode_h264_slice_header(const StdVideoEncodeH264PictureInfo * pic_info,const StdVideoH264SequenceParameterSet * sps,const StdVideoH264PictureParameterSet * pps,const StdVideoEncodeH264SliceHeader * slice_header,const int8_t slice_qp_delta,size_t * data_size_ptr,void * data_ptr)2092 vk_video_encode_h264_slice_header(const StdVideoEncodeH264PictureInfo *pic_info,
2093 const StdVideoH264SequenceParameterSet *sps,
2094 const StdVideoH264PictureParameterSet *pps,
2095 const StdVideoEncodeH264SliceHeader *slice_header,
2096 const int8_t slice_qp_delta,
2097 size_t *data_size_ptr,
2098 void *data_ptr)
2099 {
2100 struct vl_bitstream_encoder enc;
2101 uint32_t data_size = *data_size_ptr;
2102
2103 int is_idr = !!pic_info->flags.IdrPicFlag;
2104 int is_ref = !!pic_info->flags.is_reference;
2105 uint32_t slice_type = slice_header->slice_type % 5;
2106
2107 vl_bitstream_encoder_clear(&enc, data_ptr, data_size, VL_BITSTREAM_MAX_BUFFER);
2108
2109 if (slice_type == STD_VIDEO_H264_SLICE_TYPE_I) {
2110 emit_nalu_header(&enc, 3, is_idr ? H264_NAL_IDR : H264_NAL_SLICE);
2111 } else if (slice_type == STD_VIDEO_H264_SLICE_TYPE_P) {
2112 assert(!is_idr);
2113 emit_nalu_header(&enc, 2, H264_NAL_SLICE);
2114 } else {
2115 assert(slice_type == STD_VIDEO_H264_SLICE_TYPE_B);
2116 assert(!is_idr);
2117 emit_nalu_header(&enc, is_ref ? 1 : 0, H264_NAL_SLICE);
2118 }
2119
2120 vl_bitstream_put_bits(&enc, 1, slice_header->first_mb_in_slice);
2121 vl_bitstream_exp_golomb_ue(&enc, slice_header->slice_type);
2122 vl_bitstream_exp_golomb_ue(&enc, pic_info->pic_parameter_set_id);
2123
2124 if (sps->flags.separate_colour_plane_flag)
2125 /* colour plane id */
2126 vl_bitstream_put_bits(&enc, 2, 0);
2127
2128 vl_bitstream_put_bits(&enc, sps->log2_max_frame_num_minus4 + 4, pic_info->frame_num);
2129
2130 /* frame_mbs_only_flag == 1 */
2131 if (!sps->flags.frame_mbs_only_flag) {
2132 /* FIXME: */
2133 assert(0);
2134 }
2135
2136 if (pic_info->flags.IdrPicFlag)
2137 vl_bitstream_exp_golomb_ue(&enc, pic_info->idr_pic_id);
2138
2139 if (sps->pic_order_cnt_type == STD_VIDEO_H264_POC_TYPE_0) {
2140 vl_bitstream_put_bits(&enc, sps->log2_max_pic_order_cnt_lsb_minus4 + 4, pic_info->PicOrderCnt);
2141 /* pic_order_present_flag == 0 */
2142 if (pps->flags.bottom_field_pic_order_in_frame_present_flag) {
2143 assert(0);
2144 vl_bitstream_exp_golomb_se(&enc, 0);
2145 }
2146 } else if (sps->pic_order_cnt_type == STD_VIDEO_H264_POC_TYPE_1) {
2147 assert(0);
2148
2149 if (!sps->flags.delta_pic_order_always_zero_flag) {
2150 }
2151 } else if (sps->pic_order_cnt_type == STD_VIDEO_H264_POC_TYPE_2) {
2152 } else {
2153 assert(0);
2154 }
2155
2156 /* redundant_pic_cnt_present_flag == 0 */
2157 if (pps->flags.redundant_pic_cnt_present_flag) {
2158 vl_bitstream_exp_golomb_ue(&enc, 0);
2159 }
2160
2161 /* slice type */
2162 if (slice_type == STD_VIDEO_H264_SLICE_TYPE_P) {
2163 vl_bitstream_put_bits(&enc, 1, slice_header->flags.num_ref_idx_active_override_flag);
2164
2165 if (slice_header->flags.num_ref_idx_active_override_flag) {
2166 vl_bitstream_exp_golomb_ue(&enc, pic_info->pRefLists->num_ref_idx_l0_active_minus1);
2167 }
2168
2169 vl_bitstream_put_bits(&enc, 1, pic_info->pRefLists->flags.ref_pic_list_modification_flag_l0);
2170
2171 if (pic_info->pRefLists->flags.ref_pic_list_modification_flag_l0) {
2172 assert(0);
2173 /* TODO */
2174 for (unsigned i = 0; i < pic_info->pRefLists->refList0ModOpCount; i++) {
2175 }
2176 }
2177 } else if (slice_type == STD_VIDEO_H264_SLICE_TYPE_B) {
2178 vl_bitstream_put_bits(&enc, 1, slice_header->flags.direct_spatial_mv_pred_flag);
2179 vl_bitstream_put_bits(&enc, 1, slice_header->flags.num_ref_idx_active_override_flag);
2180
2181 if (slice_header->flags.num_ref_idx_active_override_flag) {
2182 vl_bitstream_exp_golomb_ue(&enc, pic_info->pRefLists->num_ref_idx_l0_active_minus1);
2183 vl_bitstream_exp_golomb_ue(&enc, pic_info->pRefLists->num_ref_idx_l1_active_minus1);
2184 }
2185
2186 vl_bitstream_put_bits(&enc, 1, pic_info->pRefLists->flags.ref_pic_list_modification_flag_l0);
2187 vl_bitstream_put_bits(&enc, 1, pic_info->pRefLists->flags.ref_pic_list_modification_flag_l1);
2188
2189 if (pic_info->pRefLists->flags.ref_pic_list_modification_flag_l0) {
2190 assert(0);
2191 for (unsigned i = 0; i < pic_info->pRefLists->refList0ModOpCount; i++) {
2192 }
2193 }
2194 if (pic_info->pRefLists->flags.ref_pic_list_modification_flag_l1) {
2195 assert(0);
2196 for (unsigned i = 0; i < pic_info->pRefLists->refList1ModOpCount; i++) {
2197 }
2198 }
2199 }
2200
2201 if ((pps->flags.weighted_pred_flag && (slice_type == STD_VIDEO_H264_SLICE_TYPE_P)) ||
2202 ((pps->weighted_bipred_idc == 1) && (slice_type == STD_VIDEO_H264_SLICE_TYPE_B))) {
2203 /* FIXME: fill weight/offset table */
2204 assert(0);
2205 }
2206
2207 /* dec_ref_pic_marking */
2208 /* nal_ref_idc != 0 */
2209 if (slice_type != STD_VIDEO_H264_SLICE_TYPE_B || pic_info->flags.is_reference) {
2210 unsigned char no_output_of_prior_pics_flag = 0;
2211 unsigned char long_term_reference_flag = 0;
2212 unsigned char adaptive_ref_pic_marking_mode_flag = 0;
2213
2214 if (pic_info->flags.IdrPicFlag) {
2215 vl_bitstream_put_bits(&enc, 1, no_output_of_prior_pics_flag);
2216 vl_bitstream_put_bits(&enc, 1, long_term_reference_flag);
2217 } else {
2218 vl_bitstream_put_bits(&enc, 1, adaptive_ref_pic_marking_mode_flag);
2219 }
2220 }
2221
2222 if (pps->flags.entropy_coding_mode_flag && (slice_type != STD_VIDEO_H264_SLICE_TYPE_I))
2223 vl_bitstream_exp_golomb_ue(&enc, slice_header->cabac_init_idc);
2224
2225 vl_bitstream_exp_golomb_se(&enc, slice_qp_delta);
2226
2227 if (pps->flags.deblocking_filter_control_present_flag) {
2228 vl_bitstream_exp_golomb_ue(&enc, slice_header->disable_deblocking_filter_idc);
2229
2230 if (slice_header->disable_deblocking_filter_idc != 1) {
2231 vl_bitstream_exp_golomb_se(&enc, slice_header->slice_alpha_c0_offset_div2);
2232 vl_bitstream_exp_golomb_se(&enc, slice_header->slice_beta_offset_div2);
2233 }
2234 }
2235
2236 if (pps->flags.entropy_coding_mode_flag) {
2237 int left = vl_bitstream_get_num_bits_for_byte_align(&enc);
2238 int val = (1 << left) - 1;
2239
2240 if (left)
2241 vl_bitstream_put_bits(&enc, left, val);
2242
2243 ASSERTED bool is_aligned = vl_bitstream_is_byte_aligned(&enc);
2244 assert(is_aligned);
2245 }
2246
2247 vl_bitstream_flush(&enc);
2248 *data_size_ptr += vl_bitstream_get_byte_count(&enc);
2249 vl_bitstream_encoder_free(&enc);
2250
2251 return;
2252 }
2253
2254 void
vk_video_encode_h265_slice_header(const StdVideoEncodeH265PictureInfo * pic_info,const StdVideoH265VideoParameterSet * vps,const StdVideoH265SequenceParameterSet * sps,const StdVideoH265PictureParameterSet * pps,const StdVideoEncodeH265SliceSegmentHeader * slice_header,const int8_t slice_qp_delta,size_t * data_size_ptr,void * data_ptr)2255 vk_video_encode_h265_slice_header(const StdVideoEncodeH265PictureInfo *pic_info,
2256 const StdVideoH265VideoParameterSet *vps,
2257 const StdVideoH265SequenceParameterSet *sps,
2258 const StdVideoH265PictureParameterSet *pps,
2259 const StdVideoEncodeH265SliceSegmentHeader *slice_header,
2260 const int8_t slice_qp_delta,
2261 size_t *data_size_ptr,
2262 void *data_ptr)
2263 {
2264 struct vl_bitstream_encoder enc;
2265 uint32_t data_size = *data_size_ptr;
2266
2267 vl_bitstream_encoder_clear(&enc, data_ptr, data_size, VL_BITSTREAM_MAX_BUFFER);
2268 emit_nalu_h265_header(&enc, vk_video_get_h265_nal_unit(pic_info));
2269
2270 vl_bitstream_put_bits(&enc, 1, slice_header->flags.first_slice_segment_in_pic_flag);
2271 if (pic_info->flags.IrapPicFlag) {
2272 vl_bitstream_put_bits(&enc, 1, pic_info->flags.no_output_of_prior_pics_flag);
2273 }
2274
2275 vl_bitstream_exp_golomb_ue(&enc, pic_info->pps_pic_parameter_set_id);
2276
2277 if (!slice_header->flags.first_slice_segment_in_pic_flag) {
2278 unsigned size, num;
2279 unsigned bits_slice_segment_address = 0;
2280
2281 if (pps->flags.dependent_slice_segments_enabled_flag)
2282 vl_bitstream_put_bits(&enc, 1, slice_header->flags.dependent_slice_segment_flag);
2283
2284 size = 1 << (sps->log2_min_luma_coding_block_size_minus3 + 3 +
2285 sps->log2_diff_max_min_luma_coding_block_size);
2286
2287 num = ((sps->pic_width_in_luma_samples + size - 1) / size) *
2288 ((sps->pic_height_in_luma_samples + size - 1) / size);
2289
2290 while (num > (1 << bits_slice_segment_address))
2291 bits_slice_segment_address++;
2292
2293 vl_bitstream_put_bits(&enc, bits_slice_segment_address, slice_header->slice_segment_address);
2294 }
2295
2296 if (slice_header->flags.dependent_slice_segment_flag)
2297 goto finish;
2298
2299 for (unsigned i = 0; i < pps->num_extra_slice_header_bits; ++i)
2300 /* slice_reserved_flag */
2301 vl_bitstream_put_bits(&enc, 1, 0);
2302
2303 vl_bitstream_exp_golomb_ue(&enc, slice_header->slice_type);
2304
2305 if (pps->flags.output_flag_present_flag)
2306 vl_bitstream_put_bits(&enc, 1, pic_info->flags.pic_output_flag);
2307
2308 if (sps->flags.separate_colour_plane_flag)
2309 /* colour_plane_id */
2310 vl_bitstream_put_bits(&enc, 2, 0);
2311
2312 if (pic_info->pic_type != STD_VIDEO_H265_PICTURE_TYPE_IDR) {
2313 /* slice_pic_order_cnt_lsb */
2314 uint32_t slice_pic_order_cnt_lsb =
2315 pic_info->PicOrderCntVal & ((1 << (sps->log2_max_pic_order_cnt_lsb_minus4 + 4)) - 1);
2316
2317 vl_bitstream_put_bits(&enc, sps->log2_max_pic_order_cnt_lsb_minus4 + 4, slice_pic_order_cnt_lsb);
2318 vl_bitstream_put_bits(&enc, 1, pic_info->flags.short_term_ref_pic_set_sps_flag);
2319
2320 if (!pic_info->flags.short_term_ref_pic_set_sps_flag) {
2321 const StdVideoH265ShortTermRefPicSet* st_rps = pic_info->pShortTermRefPicSet;
2322 unsigned num_st_rps = sps->num_short_term_ref_pic_sets;
2323 bool rps_predict = false;
2324
2325 if (num_st_rps) {
2326 rps_predict = st_rps->flags.inter_ref_pic_set_prediction_flag;
2327 vl_bitstream_put_bits(&enc, 1, st_rps->flags.inter_ref_pic_set_prediction_flag);
2328 }
2329
2330 if (rps_predict) {
2331 vl_bitstream_exp_golomb_ue(&enc, st_rps->delta_idx_minus1);
2332 vl_bitstream_put_bits(&enc, 1, st_rps->flags.delta_rps_sign);
2333 vl_bitstream_exp_golomb_ue(&enc, st_rps->abs_delta_rps_minus1);
2334
2335 for (unsigned i = 0; i <= st_rps->num_negative_pics + st_rps->num_positive_pics; i++) {
2336 vl_bitstream_put_bits(&enc, 1, st_rps->used_by_curr_pic_flag);
2337 if (!st_rps->used_by_curr_pic_flag) {
2338 vl_bitstream_put_bits(&enc, 1, st_rps->use_delta_flag);
2339 }
2340 }
2341 } else {
2342 vl_bitstream_exp_golomb_ue(&enc, st_rps->num_negative_pics);
2343 vl_bitstream_exp_golomb_ue(&enc, st_rps->num_positive_pics);
2344
2345 for (unsigned i = 0; i < st_rps->num_negative_pics; i++) {
2346 vl_bitstream_exp_golomb_ue(&enc, st_rps->delta_poc_s0_minus1[i]);
2347 vl_bitstream_put_bits(&enc, 1, st_rps->used_by_curr_pic_s0_flag);
2348 }
2349 for (unsigned i = 0; i < st_rps->num_positive_pics; i++) {
2350 vl_bitstream_exp_golomb_ue(&enc, st_rps->delta_poc_s1_minus1[i]);
2351 vl_bitstream_put_bits(&enc, 1, st_rps->used_by_curr_pic_s1_flag);
2352 }
2353 }
2354 } else {
2355 unsigned num_st_rps = sps->num_short_term_ref_pic_sets;
2356
2357 int numbits = util_logbase2_ceil(num_st_rps);
2358 vl_bitstream_put_bits(&enc, numbits, pic_info->short_term_ref_pic_set_idx);
2359 }
2360
2361 if (sps->flags.long_term_ref_pics_present_flag) {
2362 const StdVideoEncodeH265LongTermRefPics* lt_pics = pic_info->pLongTermRefPics;
2363 unsigned num_lt_sps = 0;
2364 unsigned num_lt_pics = lt_pics->num_long_term_pics;
2365
2366 if (sps->num_long_term_ref_pics_sps > 0) {
2367 num_lt_sps = lt_pics->num_long_term_sps;
2368 vl_bitstream_exp_golomb_ue(&enc, num_lt_sps);
2369 }
2370
2371 vl_bitstream_exp_golomb_ue(&enc, num_lt_pics);
2372
2373 unsigned num_refs = num_lt_sps + num_lt_pics;
2374
2375 for (unsigned i = 0; i < num_refs; i++) {
2376 if (i < num_lt_sps) {
2377 if (sps->num_long_term_ref_pics_sps > 1) {
2378 vl_bitstream_put_bits(&enc, util_logbase2_ceil(sps->num_long_term_ref_pics_sps),
2379 lt_pics->lt_idx_sps[i]);
2380 }
2381 } else {
2382 vl_bitstream_put_bits(&enc, sps->log2_max_pic_order_cnt_lsb_minus4 + 4,
2383 lt_pics->poc_lsb_lt[i]),
2384 vl_bitstream_put_bits(&enc, 1, lt_pics->used_by_curr_pic_lt_flag);
2385 }
2386
2387 vl_bitstream_put_bits(&enc, 1, lt_pics->delta_poc_msb_present_flag[i]);
2388 if (lt_pics->delta_poc_msb_present_flag[i]) {
2389 vl_bitstream_exp_golomb_ue(&enc, lt_pics->delta_poc_msb_cycle_lt[i]);
2390 }
2391 }
2392 }
2393
2394 if (sps->flags.sps_temporal_mvp_enabled_flag)
2395 vl_bitstream_put_bits(&enc, 1, pic_info->flags.slice_temporal_mvp_enabled_flag);
2396 }
2397
2398 if (sps->flags.sample_adaptive_offset_enabled_flag) {
2399 vl_bitstream_put_bits(&enc, 1, slice_header->flags.slice_sao_luma_flag);
2400 if (sps->chroma_format_idc)
2401 vl_bitstream_put_bits(&enc, 1, slice_header->flags.slice_sao_chroma_flag);
2402 }
2403
2404 if (slice_header->slice_type != STD_VIDEO_H265_SLICE_TYPE_I) {
2405 unsigned num_ref_idx_l0_active = pps->num_ref_idx_l0_default_active_minus1 + 1;
2406 unsigned num_ref_idx_l1_active = pps->num_ref_idx_l1_default_active_minus1 + 1;
2407
2408 vl_bitstream_put_bits(&enc, 1, slice_header->flags.num_ref_idx_active_override_flag);
2409 if (slice_header->flags.num_ref_idx_active_override_flag) {
2410 vl_bitstream_exp_golomb_ue(&enc, pic_info->pRefLists->num_ref_idx_l0_active_minus1);
2411 num_ref_idx_l0_active = pic_info->pRefLists->num_ref_idx_l0_active_minus1 + 1;
2412
2413 if (slice_header->slice_type == STD_VIDEO_H265_SLICE_TYPE_B) {
2414 vl_bitstream_exp_golomb_ue(&enc, pic_info->pRefLists->num_ref_idx_l1_active_minus1);
2415 num_ref_idx_l1_active = pic_info->pRefLists->num_ref_idx_l1_active_minus1 + 1;
2416 }
2417 }
2418
2419 if (pps->flags.lists_modification_present_flag) {
2420 vl_bitstream_put_bits(&enc, 1, pic_info->pRefLists->flags.ref_pic_list_modification_flag_l0);
2421 if (pic_info->pRefLists->flags.ref_pic_list_modification_flag_l0) {
2422
2423 for (int i = 0; i < num_ref_idx_l0_active; i++) {
2424 vl_bitstream_put_bits(&enc, util_logbase2_ceil(num_ref_idx_l0_active + num_ref_idx_l1_active),
2425 pic_info->pRefLists->list_entry_l0[i]);
2426 }
2427 }
2428
2429 if (slice_header->slice_type == STD_VIDEO_H265_SLICE_TYPE_B) {
2430 vl_bitstream_put_bits(&enc, 1, pic_info->pRefLists->flags.ref_pic_list_modification_flag_l1);
2431
2432 if (pic_info->pRefLists->flags.ref_pic_list_modification_flag_l1) {
2433 for (int i = 0; i < num_ref_idx_l1_active; i++) {
2434 vl_bitstream_put_bits(&enc, util_logbase2_ceil(num_ref_idx_l0_active + num_ref_idx_l1_active),
2435 pic_info->pRefLists->list_entry_l1[i]);
2436 }
2437 }
2438 }
2439 }
2440
2441 if (slice_header->slice_type == STD_VIDEO_H265_SLICE_TYPE_B)
2442 vl_bitstream_put_bits(&enc, 1, slice_header->flags.mvd_l1_zero_flag);
2443
2444 if (pps->flags.cabac_init_present_flag)
2445 /* cabac_init_flag */
2446 vl_bitstream_put_bits(&enc, 1, slice_header->flags.cabac_init_flag);
2447
2448 if (pic_info->flags.slice_temporal_mvp_enabled_flag) {
2449 unsigned collocated_list = 0;
2450 if (slice_header->slice_type == STD_VIDEO_H265_SLICE_TYPE_B) {
2451 collocated_list = 1;
2452 vl_bitstream_put_bits(&enc, 1, collocated_list);
2453 }
2454
2455 if (collocated_list == 0) {
2456 if (num_ref_idx_l0_active > 1)
2457 vl_bitstream_exp_golomb_ue(&enc, slice_header->collocated_ref_idx);
2458 } else if (collocated_list == 1) {
2459 if (num_ref_idx_l1_active > 1)
2460 vl_bitstream_exp_golomb_ue(&enc, slice_header->collocated_ref_idx);
2461 }
2462 }
2463
2464 if ((pps->flags.weighted_pred_flag && slice_header->slice_type == STD_VIDEO_H265_SLICE_TYPE_P) ||
2465 (pps->flags.weighted_bipred_flag && slice_header->slice_type == STD_VIDEO_H265_SLICE_TYPE_B)) {
2466 /* FIXME : h265_pred_weight_table */
2467 assert(0);
2468 }
2469
2470 vl_bitstream_exp_golomb_ue(&enc, 5 - slice_header->MaxNumMergeCand);
2471 }
2472
2473 vl_bitstream_exp_golomb_se(&enc, slice_qp_delta);
2474
2475 if (pps->flags.pps_slice_chroma_qp_offsets_present_flag) {
2476 vl_bitstream_exp_golomb_se(&enc, slice_header->slice_cb_qp_offset);
2477 vl_bitstream_exp_golomb_se(&enc, slice_header->slice_cr_qp_offset);
2478 }
2479
2480 if (pps->flags.chroma_qp_offset_list_enabled_flag)
2481 vl_bitstream_put_bits(&enc, 1, slice_header->flags.cu_chroma_qp_offset_enabled_flag);
2482
2483 if (pps->flags.deblocking_filter_control_present_flag) {
2484 if (pps->flags.deblocking_filter_override_enabled_flag) {
2485 vl_bitstream_put_bits(&enc, 1, slice_header->flags.deblocking_filter_override_flag);
2486
2487 if (slice_header->flags.deblocking_filter_override_flag) {
2488 vl_bitstream_put_bits(&enc, 1, slice_header->flags.slice_deblocking_filter_disabled_flag);
2489
2490 if (!slice_header->flags.slice_deblocking_filter_disabled_flag) {
2491 vl_bitstream_exp_golomb_se(&enc, slice_header->slice_beta_offset_div2);
2492 vl_bitstream_exp_golomb_se(&enc, slice_header->slice_tc_offset_div2);
2493 }
2494 }
2495 }
2496 }
2497
2498 if (pps->flags.pps_loop_filter_across_slices_enabled_flag &&
2499 (slice_header->flags.slice_sao_luma_flag || slice_header->flags.slice_sao_chroma_flag ||
2500 !slice_header->flags.slice_deblocking_filter_disabled_flag))
2501 vl_bitstream_put_bits(&enc, 1, slice_header->flags.slice_loop_filter_across_slices_enabled_flag);
2502
2503 if (pps->flags.tiles_enabled_flag || pps->flags.entropy_coding_sync_enabled_flag) {
2504 assert(0);
2505 }
2506
2507 if (pps->flags.pps_extension_present_flag) {
2508 assert(0);
2509 }
2510
2511 finish:
2512 vl_bitstream_rbsp_trailing(&enc);
2513 vl_bitstream_flush(&enc);
2514 *data_size_ptr += vl_bitstream_get_byte_count(&enc);
2515 vl_bitstream_encoder_free(&enc);
2516
2517 return;
2518 }
2519