FFmpeg: libavcodec/vulkan_h264.c Source File

FFmpeg
vulkan_h264.c
Go to the documentation of this file.
1 /*
2  * This file is part of FFmpeg.
3  *
4  * FFmpeg is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * FFmpeg is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with FFmpeg; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17  */
18 
19 #include "h264dec.h"
20 #include "h264_ps.h"
21 
22 #include "vulkan_decode.h"
23 
24  const FFVulkanDecodeDescriptor ff_vk_dec_h264_desc = {
25  .codec_id = AV_CODEC_ID_H264,
26  .decode_extension = FF_VK_EXT_VIDEO_DECODE_H264,
27  .queue_flags = VK_QUEUE_VIDEO_DECODE_BIT_KHR,
28  .decode_op = VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR,
29  .ext_props = {
30  .extensionName = VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_EXTENSION_NAME,
31  .specVersion = VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_SPEC_VERSION,
32  },
33 };
34 
35  typedef struct H264VulkanDecodePicture {
36   FFVulkanDecodePicture vp;
37 
38  /* Current picture */
39   StdVideoDecodeH264ReferenceInfo h264_ref;
40   VkVideoDecodeH264DpbSlotInfoKHR vkh264_ref;
41 
42  /* Picture refs */
43   H264Picture *ref_src [H264_MAX_PICTURE_COUNT];
44   StdVideoDecodeH264ReferenceInfo h264_refs [H264_MAX_PICTURE_COUNT];
45   VkVideoDecodeH264DpbSlotInfoKHR vkh264_refs[H264_MAX_PICTURE_COUNT];
46 
47  /* Current picture (contd.) */
48   StdVideoDecodeH264PictureInfo h264pic;
49   VkVideoDecodeH264PictureInfoKHR h264_pic_info;
50 } H264VulkanDecodePicture;
51 
52  const static int h264_scaling_list8_order[] = { 0, 3, 1, 4, 2, 5 };
53 
54  static int vk_h264_fill_pict(AVCodecContext *avctx, H264Picture **ref_src,
55  VkVideoReferenceSlotInfoKHR *ref_slot, /* Main structure */
56  VkVideoPictureResourceInfoKHR *ref, /* Goes in ^ */
57  VkVideoDecodeH264DpbSlotInfoKHR *vkh264_ref, /* Goes in ^ */
58  StdVideoDecodeH264ReferenceInfo *h264_ref, /* Goes in ^ */
59  H264Picture *pic, int is_current,
60  int is_field, int picture_structure,
61  int dpb_slot_index)
62 {
63  FFVulkanDecodeContext *dec = avctx->internal->hwaccel_priv_data;
64  FFVulkanDecodeShared *ctx = dec->shared_ctx;
65  H264VulkanDecodePicture *hp = pic->hwaccel_picture_private;
66  FFVulkanDecodePicture *vkpic = &hp->vp;
67 
68  int err = ff_vk_decode_prepare_frame(dec, pic->f, vkpic, is_current,
69  dec->dedicated_dpb);
70  if (err < 0)
71  return err;
72 
73  *h264_ref = (StdVideoDecodeH264ReferenceInfo) {
74  .FrameNum = pic->long_ref ? pic->pic_id : pic->frame_num,
75  .PicOrderCnt = { pic->field_poc[0], pic->field_poc[1] },
76  .flags = (StdVideoDecodeH264ReferenceInfoFlags) {
77  .top_field_flag = is_field ? !!(picture_structure & PICT_TOP_FIELD) : 0,
78  .bottom_field_flag = is_field ? !!(picture_structure & PICT_BOTTOM_FIELD) : 0,
79  .used_for_long_term_reference = pic->reference && pic->long_ref,
80  /*
81  * flags.is_non_existing is used to indicate whether the picture is marked as
82  * "non-existing" as defined in section 8.2.5.2 of the ITU-T H.264 Specification;
83  * 8.2.5.2 Decoding process for gaps in frame_num
84  * corresponds to the code in h264_slice.c:h264_field_start,
85  * which sets the invalid_gap flag when decoding.
86  */
87  .is_non_existing = pic->invalid_gap,
88  },
89  };
90 
91  *vkh264_ref = (VkVideoDecodeH264DpbSlotInfoKHR) {
92  .sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR,
93  .pStdReferenceInfo = h264_ref,
94  };
95 
96  *ref = (VkVideoPictureResourceInfoKHR) {
97  .sType = VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR,
98  .codedOffset = (VkOffset2D){ 0, 0 },
99  .codedExtent = (VkExtent2D){ pic->f->width, pic->f->height },
100  .baseArrayLayer = ctx->common.layered_dpb ? dpb_slot_index : 0,
101  .imageViewBinding = vkpic->view.ref[0],
102  };
103 
104  *ref_slot = (VkVideoReferenceSlotInfoKHR) {
105  .sType = VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR,
106  .pNext = vkh264_ref,
107  .slotIndex = dpb_slot_index,
108  .pPictureResource = ref,
109  };
110 
111  if (ref_src)
112  *ref_src = pic;
113 
114  return 0;
115 }
116 
117  static StdVideoH264LevelIdc convert_to_vk_level_idc(int level_idc)
118 {
119  switch (level_idc) {
120  case 10: return STD_VIDEO_H264_LEVEL_IDC_1_0;
121  case 11: return STD_VIDEO_H264_LEVEL_IDC_1_1;
122  case 12: return STD_VIDEO_H264_LEVEL_IDC_1_2;
123  case 13: return STD_VIDEO_H264_LEVEL_IDC_1_3;
124  case 20: return STD_VIDEO_H264_LEVEL_IDC_2_0;
125  case 21: return STD_VIDEO_H264_LEVEL_IDC_2_1;
126  case 22: return STD_VIDEO_H264_LEVEL_IDC_2_2;
127  case 30: return STD_VIDEO_H264_LEVEL_IDC_3_0;
128  case 31: return STD_VIDEO_H264_LEVEL_IDC_3_1;
129  case 32: return STD_VIDEO_H264_LEVEL_IDC_3_2;
130  case 40: return STD_VIDEO_H264_LEVEL_IDC_4_0;
131  case 41: return STD_VIDEO_H264_LEVEL_IDC_4_1;
132  case 42: return STD_VIDEO_H264_LEVEL_IDC_4_2;
133  case 50: return STD_VIDEO_H264_LEVEL_IDC_5_0;
134  case 51: return STD_VIDEO_H264_LEVEL_IDC_5_1;
135  case 52: return STD_VIDEO_H264_LEVEL_IDC_5_2;
136  case 60: return STD_VIDEO_H264_LEVEL_IDC_6_0;
137  case 61: return STD_VIDEO_H264_LEVEL_IDC_6_1;
138  default:
139  case 62: return STD_VIDEO_H264_LEVEL_IDC_6_2;
140  }
141 }
142 
143  static void set_sps(const SPS *sps,
144  StdVideoH264ScalingLists *vksps_scaling,
145  StdVideoH264HrdParameters *vksps_vui_header,
146  StdVideoH264SequenceParameterSetVui *vksps_vui,
147  StdVideoH264SequenceParameterSet *vksps)
148 {
149  *vksps_scaling = (StdVideoH264ScalingLists) {
150  .scaling_list_present_mask = sps->scaling_matrix_present_mask,
151  .use_default_scaling_matrix_mask = 0, /* We already fill in the default matrix */
152  };
153 
154  for (int i = 0; i < STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS; i++)
155  for (int j = 0; j < STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS; j++)
156  vksps_scaling->ScalingList4x4[i][j] = sps->scaling_matrix4[i][ff_zigzag_scan[j]];
157 
158  for (int i = 0; i < STD_VIDEO_H264_SCALING_LIST_8X8_NUM_LISTS; i++)
159  for (int j = 0; j < STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS; j++)
160  vksps_scaling->ScalingList8x8[i][j] =
161  sps->scaling_matrix8[h264_scaling_list8_order[i]][ff_zigzag_direct[j]];
162 
163  *vksps_vui_header = (StdVideoH264HrdParameters) {
164  .cpb_cnt_minus1 = sps->cpb_cnt - 1,
165  .bit_rate_scale = sps->bit_rate_scale,
166  .initial_cpb_removal_delay_length_minus1 = sps->initial_cpb_removal_delay_length - 1,
167  .cpb_removal_delay_length_minus1 = sps->cpb_removal_delay_length - 1,
168  .dpb_output_delay_length_minus1 = sps->dpb_output_delay_length - 1,
169  .time_offset_length = sps->time_offset_length,
170  };
171 
172  for (int i = 0; i < sps->cpb_cnt; i++) {
173  vksps_vui_header->bit_rate_value_minus1[i] = sps->bit_rate_value[i] - 1;
174  vksps_vui_header->cpb_size_value_minus1[i] = sps->cpb_size_value[i] - 1;
175  vksps_vui_header->cbr_flag[i] = (sps->cpr_flag >> i) & 0x1;
176  }
177 
178  *vksps_vui = (StdVideoH264SequenceParameterSetVui) {
179  .aspect_ratio_idc = sps->vui.aspect_ratio_idc,
180  .sar_width = sps->vui.sar.num,
181  .sar_height = sps->vui.sar.den,
182  .video_format = sps->vui.video_format,
183  .colour_primaries = sps->vui.colour_primaries,
184  .transfer_characteristics = sps->vui.transfer_characteristics,
185  .matrix_coefficients = sps->vui.matrix_coeffs,
186  .num_units_in_tick = sps->num_units_in_tick,
187  .time_scale = sps->time_scale,
188  .pHrdParameters = vksps_vui_header,
189  .max_num_reorder_frames = sps->num_reorder_frames,
190  .max_dec_frame_buffering = sps->max_dec_frame_buffering,
191  .flags = (StdVideoH264SpsVuiFlags) {
192  .aspect_ratio_info_present_flag = sps->vui.aspect_ratio_info_present_flag,
193  .overscan_info_present_flag = sps->vui.overscan_info_present_flag,
194  .overscan_appropriate_flag = sps->vui.overscan_appropriate_flag,
195  .video_signal_type_present_flag = sps->vui.video_signal_type_present_flag,
196  .video_full_range_flag = sps->vui.video_full_range_flag,
197  .color_description_present_flag = sps->vui.colour_description_present_flag,
198  .chroma_loc_info_present_flag = sps->vui.chroma_loc_info_present_flag,
199  .timing_info_present_flag = sps->timing_info_present_flag,
200  .fixed_frame_rate_flag = sps->fixed_frame_rate_flag,
201  .bitstream_restriction_flag = sps->bitstream_restriction_flag,
202  .nal_hrd_parameters_present_flag = sps->nal_hrd_parameters_present_flag,
203  .vcl_hrd_parameters_present_flag = sps->vcl_hrd_parameters_present_flag,
204  },
205  };
206 
207  *vksps = (StdVideoH264SequenceParameterSet) {
208  .profile_idc = sps->profile_idc,
209  .level_idc = convert_to_vk_level_idc(sps->level_idc),
210  .seq_parameter_set_id = sps->sps_id,
211  .chroma_format_idc = sps->chroma_format_idc,
212  .bit_depth_luma_minus8 = sps->bit_depth_luma - 8,
213  .bit_depth_chroma_minus8 = sps->bit_depth_chroma - 8,
214  .log2_max_frame_num_minus4 = sps->log2_max_frame_num - 4,
215  .pic_order_cnt_type = sps->poc_type,
216  .log2_max_pic_order_cnt_lsb_minus4 = sps->poc_type ? 0 : sps->log2_max_poc_lsb - 4,
217  .offset_for_non_ref_pic = sps->offset_for_non_ref_pic,
218  .offset_for_top_to_bottom_field = sps->offset_for_top_to_bottom_field,
219  .num_ref_frames_in_pic_order_cnt_cycle = sps->poc_cycle_length,
220  .max_num_ref_frames = sps->ref_frame_count,
221  .pic_width_in_mbs_minus1 = sps->mb_width - 1,
222  .pic_height_in_map_units_minus1 = (sps->mb_height/(2 - sps->frame_mbs_only_flag)) - 1,
223  .frame_crop_left_offset = sps->crop_left,
224  .frame_crop_right_offset = sps->crop_right,
225  .frame_crop_top_offset = sps->crop_top,
226  .frame_crop_bottom_offset = sps->crop_bottom,
227  .flags = (StdVideoH264SpsFlags) {
228  .constraint_set0_flag = (sps->constraint_set_flags >> 0) & 0x1,
229  .constraint_set1_flag = (sps->constraint_set_flags >> 1) & 0x1,
230  .constraint_set2_flag = (sps->constraint_set_flags >> 2) & 0x1,
231  .constraint_set3_flag = (sps->constraint_set_flags >> 3) & 0x1,
232  .constraint_set4_flag = (sps->constraint_set_flags >> 4) & 0x1,
233  .constraint_set5_flag = (sps->constraint_set_flags >> 5) & 0x1,
234  .direct_8x8_inference_flag = sps->direct_8x8_inference_flag,
235  .mb_adaptive_frame_field_flag = sps->mb_aff,
236  .frame_mbs_only_flag = sps->frame_mbs_only_flag,
237  .delta_pic_order_always_zero_flag = sps->delta_pic_order_always_zero_flag,
238  .separate_colour_plane_flag = sps->residual_color_transform_flag,
239  .gaps_in_frame_num_value_allowed_flag = sps->gaps_in_frame_num_allowed_flag,
240  .qpprime_y_zero_transform_bypass_flag = sps->transform_bypass,
241  .frame_cropping_flag = sps->crop,
242  .seq_scaling_matrix_present_flag = sps->scaling_matrix_present,
243  .vui_parameters_present_flag = sps->vui_parameters_present_flag,
244  },
245  .pOffsetForRefFrame = sps->offset_for_ref_frame,
246  .pScalingLists = vksps_scaling,
247  .pSequenceParameterSetVui = vksps_vui,
248  };
249 }
250 
251  static void set_pps(const PPS *pps, const SPS *sps,
252  StdVideoH264ScalingLists *vkpps_scaling,
253  StdVideoH264PictureParameterSet *vkpps)
254 {
255  *vkpps_scaling = (StdVideoH264ScalingLists) {
256  .scaling_list_present_mask = pps->pic_scaling_matrix_present_mask,
257  .use_default_scaling_matrix_mask = 0, /* We already fill in the default matrix */
258  };
259 
260  for (int i = 0; i < STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS; i++)
261  for (int j = 0; j < STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS; j++)
262  vkpps_scaling->ScalingList4x4[i][j] = pps->scaling_matrix4[i][ff_zigzag_scan[j]];
263 
264  for (int i = 0; i < STD_VIDEO_H264_SCALING_LIST_8X8_NUM_LISTS; i++)
265  for (int j = 0; j < STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS; j++)
266  vkpps_scaling->ScalingList8x8[i][j] =
267  pps->scaling_matrix8[h264_scaling_list8_order[i]][ff_zigzag_direct[j]];
268 
269  *vkpps = (StdVideoH264PictureParameterSet) {
270  .seq_parameter_set_id = pps->sps_id,
271  .pic_parameter_set_id = pps->pps_id,
272  .num_ref_idx_l0_default_active_minus1 = pps->ref_count[0] - 1,
273  .num_ref_idx_l1_default_active_minus1 = pps->ref_count[1] - 1,
274  .weighted_bipred_idc = pps->weighted_bipred_idc,
275  .pic_init_qp_minus26 = pps->init_qp - 26,
276  .pic_init_qs_minus26 = pps->init_qs - 26,
277  .chroma_qp_index_offset = pps->chroma_qp_index_offset[0],
278  .second_chroma_qp_index_offset = pps->chroma_qp_index_offset[1],
279  .flags = (StdVideoH264PpsFlags) {
280  .transform_8x8_mode_flag = pps->transform_8x8_mode,
281  .redundant_pic_cnt_present_flag = pps->redundant_pic_cnt_present,
282  .constrained_intra_pred_flag = pps->constrained_intra_pred,
283  .deblocking_filter_control_present_flag = pps->deblocking_filter_parameters_present,
284  .weighted_pred_flag = pps->weighted_pred,
285  .bottom_field_pic_order_in_frame_present_flag = pps->pic_order_present,
286  .entropy_coding_mode_flag = pps->cabac,
287  .pic_scaling_matrix_present_flag = pps->pic_scaling_matrix_present_flag,
288  },
289  .pScalingLists = vkpps_scaling,
290  };
291 }
292 
293  static int vk_h264_create_params(AVCodecContext *avctx, AVBufferRef **buf)
294 {
295  int err;
296  FFVulkanDecodeContext *dec = avctx->internal->hwaccel_priv_data;
297  FFVulkanDecodeShared *ctx = dec->shared_ctx;
298  const H264Context *h = avctx->priv_data;
299 
300  /* SPS */
301  StdVideoH264ScalingLists vksps_scaling[MAX_SPS_COUNT];
302  StdVideoH264HrdParameters vksps_vui_header[MAX_SPS_COUNT];
303  StdVideoH264SequenceParameterSetVui vksps_vui[MAX_SPS_COUNT];
304  StdVideoH264SequenceParameterSet vksps[MAX_SPS_COUNT];
305 
306  /* PPS */
307  StdVideoH264ScalingLists vkpps_scaling[MAX_PPS_COUNT];
308  StdVideoH264PictureParameterSet vkpps[MAX_PPS_COUNT];
309 
310  VkVideoDecodeH264SessionParametersAddInfoKHR h264_params_info = {
311  .sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR,
312  .pStdSPSs = vksps,
313  .stdSPSCount = 0,
314  .pStdPPSs = vkpps,
315  .stdPPSCount = 0,
316  };
317  VkVideoDecodeH264SessionParametersCreateInfoKHR h264_params = {
318  .sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR,
319  .pParametersAddInfo = &h264_params_info,
320  };
321  VkVideoSessionParametersCreateInfoKHR session_params_create = {
322  .sType = VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR,
323  .pNext = &h264_params,
324  .videoSession = ctx->common.session,
325  .videoSessionParametersTemplate = VK_NULL_HANDLE,
326  };
327 
328  /* SPS list */
329  for (int i = 0; i < FF_ARRAY_ELEMS(h->ps.sps_list); i++) {
330  if (h->ps.sps_list[i]) {
331  const SPS *sps_l = h->ps.sps_list[i];
332  int idx = h264_params_info.stdSPSCount;
333  set_sps(sps_l, &vksps_scaling[idx], &vksps_vui_header[idx], &vksps_vui[idx], &vksps[idx]);
334  h264_params_info.stdSPSCount++;
335  }
336  }
337 
338  /* PPS list */
339  for (int i = 0; i < FF_ARRAY_ELEMS(h->ps.pps_list); i++) {
340  if (h->ps.pps_list[i]) {
341  const PPS *pps_l = h->ps.pps_list[i];
342  int idx = h264_params_info.stdPPSCount;
343  set_pps(pps_l, pps_l->sps, &vkpps_scaling[idx], &vkpps[idx]);
344  h264_params_info.stdPPSCount++;
345  }
346  }
347 
348  h264_params.maxStdSPSCount = h264_params_info.stdSPSCount;
349  h264_params.maxStdPPSCount = h264_params_info.stdPPSCount;
350 
351  err = ff_vk_decode_create_params(buf, avctx, ctx, &session_params_create);
352  if (err < 0)
353  return err;
354 
355  av_log(avctx, AV_LOG_DEBUG, "Created frame parameters: %i SPS %i PPS\n",
356  h264_params_info.stdSPSCount, h264_params_info.stdPPSCount);
357 
358  return 0;
359 }
360 
361  static int vk_h264_start_frame(AVCodecContext *avctx,
362  av_unused const AVBufferRef *buffer_ref,
363  av_unused const uint8_t *buffer,
364  av_unused uint32_t size)
365 {
366  int err;
367  int dpb_slot_index = 0;
368  H264Context *h = avctx->priv_data;
369 
370  H264Picture *pic = h->cur_pic_ptr;
371  H264VulkanDecodePicture *hp = pic->hwaccel_picture_private;
372  FFVulkanDecodePicture *vp = &hp->vp;
373 
374  /* Fill in main slot */
375  dpb_slot_index = 0;
376  for (unsigned slot = 0; slot < H264_MAX_PICTURE_COUNT; slot++) {
377  if (pic == &h->DPB[slot]) {
378  dpb_slot_index = slot;
379  break;
380  }
381  }
382 
383  err = vk_h264_fill_pict(avctx, NULL, &vp->ref_slot, &vp->ref,
384  &hp->vkh264_ref, &hp->h264_ref, pic, 1,
385  h->DPB[dpb_slot_index].field_picture,
386  h->DPB[dpb_slot_index].reference,
387  dpb_slot_index);
388  if (err < 0)
389  return err;
390 
391  /* Fill in short-term references */
392  for (int i = 0; i < h->short_ref_count; i++) {
393  dpb_slot_index = 0;
394  for (unsigned slot = 0; slot < H264_MAX_PICTURE_COUNT; slot++) {
395  if (h->short_ref[i] == &h->DPB[slot]) {
396  dpb_slot_index = slot;
397  break;
398  }
399  }
400  err = vk_h264_fill_pict(avctx, &hp->ref_src[i], &vp->ref_slots[i],
401  &vp->refs[i], &hp->vkh264_refs[i],
402  &hp->h264_refs[i], h->short_ref[i], 0,
403  h->DPB[dpb_slot_index].field_picture,
404  h->DPB[dpb_slot_index].reference,
405  dpb_slot_index);
406  if (err < 0)
407  return err;
408  }
409 
410  /* Fill in long-term refs */
411  for (int r = 0, i = h->short_ref_count; r < H264_MAX_DPB_FRAMES &&
412  i < h->short_ref_count + h->long_ref_count; r++) {
413  if (!h->long_ref[r])
414  continue;
415 
416  dpb_slot_index = 0;
417  for (unsigned slot = 0; slot < 16; slot++) {
418  if (h->long_ref[r] == &h->DPB[slot]) {
419  dpb_slot_index = slot;
420  break;
421  }
422  }
423  err = vk_h264_fill_pict(avctx, &hp->ref_src[i], &vp->ref_slots[i],
424  &vp->refs[i], &hp->vkh264_refs[i],
425  &hp->h264_refs[i], h->long_ref[r], 0,
426  h->DPB[dpb_slot_index].field_picture,
427  h->DPB[dpb_slot_index].reference,
428  dpb_slot_index);
429  if (err < 0)
430  return err;
431  i++;
432  }
433 
434  hp->h264pic = (StdVideoDecodeH264PictureInfo) {
435  .seq_parameter_set_id = pic->pps->sps_id,
436  .pic_parameter_set_id = pic->pps->pps_id,
437  .frame_num = 0, /* Set later */
438  .idr_pic_id = 0, /* Set later */
439  .PicOrderCnt[0] = pic->field_poc[0],
440  .PicOrderCnt[1] = pic->field_poc[1],
441  .flags = (StdVideoDecodeH264PictureInfoFlags) {
442  .field_pic_flag = FIELD_PICTURE(h),
443  .is_intra = 1, /* Set later */
444  .IdrPicFlag = h->picture_idr,
445  .bottom_field_flag = h->picture_structure != PICT_FRAME &&
446  h->picture_structure & PICT_BOTTOM_FIELD,
447  .is_reference = h->nal_ref_idc != 0,
448  .complementary_field_pair = h->first_field && FIELD_PICTURE(h),
449  },
450  };
451 
452  hp->h264_pic_info = (VkVideoDecodeH264PictureInfoKHR) {
453  .sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR,
454  .pStdPictureInfo = &hp->h264pic,
455  };
456 
457  vp->decode_info = (VkVideoDecodeInfoKHR) {
458  .sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR,
459  .pNext = &hp->h264_pic_info,
460  .flags = 0x0,
461  .pSetupReferenceSlot = &vp->ref_slot,
462  .referenceSlotCount = h->short_ref_count + h->long_ref_count,
463  .pReferenceSlots = vp->ref_slots,
464  .dstPictureResource = (VkVideoPictureResourceInfoKHR) {
465  .sType = VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR,
466  .codedOffset = (VkOffset2D){ 0, 0 },
467  .codedExtent = (VkExtent2D){ pic->f->width, pic->f->height },
468  .baseArrayLayer = 0,
469  .imageViewBinding = vp->view.out[0],
470  },
471  };
472 
473  return 0;
474 }
475 
476  static int vk_h264_decode_slice(AVCodecContext *avctx,
477  const uint8_t *data,
478  uint32_t size)
479 {
480  const H264Context *h = avctx->priv_data;
481  const H264SliceContext *sl = &h->slice_ctx[0];
482  H264VulkanDecodePicture *hp = h->cur_pic_ptr->hwaccel_picture_private;
483  FFVulkanDecodePicture *vp = &hp->vp;
484 
485  int err = ff_vk_decode_add_slice(avctx, vp, data, size, 1,
486  &hp->h264_pic_info.sliceCount,
487  &hp->h264_pic_info.pSliceOffsets);
488  if (err < 0)
489  return err;
490 
491  hp->h264pic.frame_num = sl->frame_num;
492  hp->h264pic.idr_pic_id = sl->idr_pic_id;
493 
494  /* Frame is only intra of all slices are marked as intra */
495  if (sl->slice_type != AV_PICTURE_TYPE_I && sl->slice_type != AV_PICTURE_TYPE_SI)
496  hp->h264pic.flags.is_intra = 0;
497 
498  return 0;
499 }
500 
501  static int vk_h264_end_frame(AVCodecContext *avctx)
502 {
503  const H264Context *h = avctx->priv_data;
504  FFVulkanDecodeContext *dec = avctx->internal->hwaccel_priv_data;
505  FFVulkanDecodeShared *ctx = dec->shared_ctx;
506 
507  H264Picture *pic = h->cur_pic_ptr;
508  H264VulkanDecodePicture *hp = pic->hwaccel_picture_private;
509  FFVulkanDecodePicture *vp = &hp->vp;
510  FFVulkanDecodePicture *rvp[H264_MAX_PICTURE_COUNT] = { 0 };
511  AVFrame *rav[H264_MAX_PICTURE_COUNT] = { 0 };
512 
513 #ifdef VK_KHR_video_maintenance2
514  StdVideoH264ScalingLists vksps_scaling;
515  StdVideoH264HrdParameters vksps_vui_header;
516  StdVideoH264SequenceParameterSetVui vksps_vui;
517  StdVideoH264SequenceParameterSet vksps;
518  StdVideoH264ScalingLists vkpps_scaling;
519  StdVideoH264PictureParameterSet vkpps;
520  VkVideoDecodeH264InlineSessionParametersInfoKHR h264_params;
521 
522  if (ctx->s.extensions & FF_VK_EXT_VIDEO_MAINTENANCE_2) {
523  set_sps(h->ps.sps, &vksps_scaling,
524  &vksps_vui_header, &vksps_vui, &vksps);
525  set_pps(h->ps.pps, h->ps.sps, &vkpps_scaling, &vkpps);
526  h264_params = (VkVideoDecodeH264InlineSessionParametersInfoKHR) {
527  .sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR,
528  .pStdSPS = &vksps,
529  .pStdPPS = &vkpps,
530  };
531  hp->h264_pic_info.pNext = &h264_params;
532  }
533 #endif
534 
535  if (!hp->h264_pic_info.sliceCount)
536  return 0;
537 
538  if (!vp->slices_buf)
539  return AVERROR(EINVAL);
540 
541  if (!dec->session_params &&
542  !(ctx->s.extensions & FF_VK_EXT_VIDEO_MAINTENANCE_2)) {
543  int err = vk_h264_create_params(avctx, &dec->session_params);
544  if (err < 0)
545  return err;
546 
547  hp->h264pic.seq_parameter_set_id = pic->pps->sps_id;
548  hp->h264pic.pic_parameter_set_id = pic->pps->pps_id;
549  }
550 
551  for (int i = 0; i < vp->decode_info.referenceSlotCount; i++) {
552  H264Picture *rp = hp->ref_src[i];
553  H264VulkanDecodePicture *rhp = rp->hwaccel_picture_private;
554 
555  rvp[i] = &rhp->vp;
556  rav[i] = hp->ref_src[i]->f;
557  }
558 
559  av_log(avctx, AV_LOG_DEBUG, "Decoding frame, %"SIZE_SPECIFIER " bytes, %i slices\n",
560  vp->slices_size, hp->h264_pic_info.sliceCount);
561 
562  return ff_vk_decode_frame(avctx, pic->f, vp, rav, rvp);
563 }
564 
565  static void vk_h264_free_frame_priv(AVRefStructOpaque _hwctx, void *data)
566 {
567  AVHWDeviceContext *hwctx = _hwctx.nc;
568  H264VulkanDecodePicture *hp = data;
569 
570  /* Free frame resources, this also destroys the session parameters. */
571  ff_vk_decode_free_frame(hwctx, &hp->vp);
572 }
573 
574  const FFHWAccel ff_h264_vulkan_hwaccel = {
575  .p.name = "h264_vulkan",
576  .p.type = AVMEDIA_TYPE_VIDEO,
577  .p.id = AV_CODEC_ID_H264,
578  .p.pix_fmt = AV_PIX_FMT_VULKAN,
579  .start_frame = &vk_h264_start_frame,
580  .decode_slice = &vk_h264_decode_slice,
581  .end_frame = &vk_h264_end_frame,
582  .free_frame_priv = &vk_h264_free_frame_priv,
583  .frame_priv_data_size = sizeof(H264VulkanDecodePicture),
584  .init = &ff_vk_decode_init,
585  .update_thread_context = &ff_vk_update_thread_context,
586  .decode_params = &ff_vk_params_invalidate,
587  .flush = &ff_vk_decode_flush,
588  .uninit = &ff_vk_decode_uninit,
589  .frame_params = &ff_vk_frame_params,
590  .priv_data_size = sizeof(FFVulkanDecodeContext),
591  .caps_internal = HWACCEL_CAP_ASYNC_SAFE,
592 };
PICT_FRAME
#define PICT_FRAME
Definition: mpegutils.h:33
FFVulkanDecodePicture::slices_size
size_t slices_size
Definition: vulkan_decode.h:102
r
const char * r
Definition: vf_curves.c:127
AVERROR
Filter the word "frame" indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
H264Picture::f
AVFrame * f
Definition: h264dec.h:113
H264VulkanDecodePicture::h264_ref
StdVideoDecodeH264ReferenceInfo h264_ref
Definition: vulkan_h264.c:39
set_sps
static void set_sps(const SPS *sps, StdVideoH264ScalingLists *vksps_scaling, StdVideoH264HrdParameters *vksps_vui_header, StdVideoH264SequenceParameterSetVui *vksps_vui, StdVideoH264SequenceParameterSet *vksps)
Definition: vulkan_h264.c:143
FFVulkanDecodeContext::shared_ctx
FFVulkanDecodeShared * shared_ctx
Definition: vulkan_decode.h:57
AVRefStructOpaque
RefStruct is an API for creating reference-counted objects with minimal overhead.
Definition: refstruct.h:58
FF_VK_EXT_VIDEO_MAINTENANCE_2
#define FF_VK_EXT_VIDEO_MAINTENANCE_2
Definition: vulkan_functions.h:58
H264VulkanDecodePicture::h264_pic_info
VkVideoDecodeH264PictureInfoKHR h264_pic_info
Definition: vulkan_h264.c:49
AVRefStructOpaque::nc
void * nc
Definition: refstruct.h:59
av_unused
#define av_unused
Definition: attributes.h:151
H264Picture::pps
const PPS * pps
Definition: h264dec.h:156
FFHWAccel::p
AVHWAccel p
The public AVHWAccel.
Definition: hwaccel_internal.h:38
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:427
AVFrame::width
int width
Definition: frame.h:499
level_idc
int level_idc
Definition: h264_levels.c:29
set_pps
static void set_pps(const PPS *pps, const SPS *sps, StdVideoH264ScalingLists *vkpps_scaling, StdVideoH264PictureParameterSet *vkpps)
Definition: vulkan_h264.c:251
data
const char data[16]
Definition: mxf.c:149
FFVulkanDecodeDescriptor::codec_id
enum AVCodecID codec_id
Definition: vulkan_decode.h:30
FFVulkanDecodePicture::view
struct FFVulkanDecodePicture::@324 view
PICT_BOTTOM_FIELD
#define PICT_BOTTOM_FIELD
Definition: mpegutils.h:32
H264VulkanDecodePicture::vkh264_ref
VkVideoDecodeH264DpbSlotInfoKHR vkh264_ref
Definition: vulkan_h264.c:40
H264VulkanDecodePicture::h264pic
StdVideoDecodeH264PictureInfo h264pic
Definition: vulkan_h264.c:48
vk_h264_create_params
static int vk_h264_create_params(AVCodecContext *avctx, AVBufferRef **buf)
Definition: vulkan_h264.c:293
H264Picture::invalid_gap
int invalid_gap
Definition: h264dec.h:152
FFVulkanDecodeContext
Definition: vulkan_decode.h:56
AV_PIX_FMT_VULKAN
@ AV_PIX_FMT_VULKAN
Vulkan hardware images.
Definition: pixfmt.h:379
ff_vk_decode_prepare_frame
int ff_vk_decode_prepare_frame(FFVulkanDecodeContext *dec, AVFrame *pic, FFVulkanDecodePicture *vkpic, int is_current, int alloc_dpb)
Prepare a frame, creates the image view, and sets up the dpb fields.
Definition: vulkan_decode.c:183
FFVulkanDecodeContext::session_params
AVBufferRef * session_params
Definition: vulkan_decode.h:58
H264Picture::frame_num
int frame_num
frame_num (raw frame_num from slice header)
Definition: h264dec.h:134
H264SliceContext
Definition: h264dec.h:178
ff_h264_vulkan_hwaccel
const FFHWAccel ff_h264_vulkan_hwaccel
Definition: vulkan_h264.c:574
FFHWAccel
Definition: hwaccel_internal.h:34
ff_vk_decode_frame
int ff_vk_decode_frame(AVCodecContext *avctx, AVFrame *pic, FFVulkanDecodePicture *vp, AVFrame *rpic[], FFVulkanDecodePicture *rvkp[])
Decode a frame.
Definition: vulkan_decode.c:404
FFVulkanDecodeShared
Definition: vulkan_decode.h:38
AVHWDeviceContext
This struct aggregates all the (hardware/vendor-specific) "high-level" state, i.e.
Definition: hwcontext.h:63
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
vk_h264_decode_slice
static int vk_h264_decode_slice(AVCodecContext *avctx, const uint8_t *data, uint32_t size)
Definition: vulkan_h264.c:476
FFVulkanDecodePicture::refs
VkVideoPictureResourceInfoKHR refs[36]
Definition: vulkan_decode.h:94
H264VulkanDecodePicture
Definition: vulkan_h264.c:35
FFVulkanDecodePicture
Definition: vulkan_decode.h:75
ff_vk_decode_create_params
int ff_vk_decode_create_params(AVBufferRef **par_ref, void *logctx, FFVulkanDecodeShared *ctx, const VkVideoSessionParametersCreateInfoKHR *session_params_create)
Create VkVideoSessionParametersKHR wrapped in an AVBufferRef.
Definition: vulkan_decode.c:1170
PPS::pps_id
unsigned int pps_id
Definition: h264_ps.h:111
H264VulkanDecodePicture::h264_refs
StdVideoDecodeH264ReferenceInfo h264_refs[H264_MAX_PICTURE_COUNT]
Definition: vulkan_h264.c:44
FIELD_PICTURE
#define FIELD_PICTURE(h)
Definition: h264dec.h:65
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:231
ctx
AVFormatContext * ctx
Definition: movenc.c:49
PICT_TOP_FIELD
#define PICT_TOP_FIELD
Definition: mpegutils.h:31
H264VulkanDecodePicture::ref_src
H264Picture * ref_src[H264_MAX_PICTURE_COUNT]
Definition: vulkan_h264.c:43
H264SliceContext::slice_type
int slice_type
Definition: h264dec.h:184
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:79
HWACCEL_CAP_ASYNC_SAFE
#define HWACCEL_CAP_ASYNC_SAFE
Header providing the internals of AVHWAccel.
Definition: hwaccel_internal.h:31
NULL
#define NULL
Definition: coverity.c:32
ff_vk_decode_free_frame
void ff_vk_decode_free_frame(AVHWDeviceContext *dev_ctx, FFVulkanDecodePicture *vp)
Free a frame and its state.
Definition: vulkan_decode.c:610
convert_to_vk_level_idc
static StdVideoH264LevelIdc convert_to_vk_level_idc(int level_idc)
Definition: vulkan_h264.c:117
SPS
Sequence parameter set.
Definition: h264_ps.h:44
AVCodecContext::internal
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:466
AV_PICTURE_TYPE_SI
@ AV_PICTURE_TYPE_SI
Switching Intra.
Definition: avutil.h:282
vk_h264_start_frame
static int vk_h264_start_frame(AVCodecContext *avctx, av_unused const AVBufferRef *buffer_ref, av_unused const uint8_t *buffer, av_unused uint32_t size)
Definition: vulkan_h264.c:361
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:278
PPS
Picture parameter set.
Definition: h264_ps.h:110
ff_vk_decode_uninit
int ff_vk_decode_uninit(AVCodecContext *avctx)
Free decoder.
Definition: vulkan_decode.c:1199
flush
void(* flush)(AVBSFContext *ctx)
Definition: dts2pts.c:552
MAX_PPS_COUNT
#define MAX_PPS_COUNT
Definition: h264_ps.h:38
ff_vk_frame_params
int ff_vk_frame_params(AVCodecContext *avctx, AVBufferRef *hw_frames_ctx)
Initialize hw_frames_ctx with the parameters needed to decode the stream using the parameters from av...
Definition: vulkan_decode.c:1082
h264_ps.h
H264Picture::pic_id
int pic_id
pic_num (short -> no wrap version of pic_num, pic_num & max_pic_num; long -> long_pic_num)
Definition: h264dec.h:137
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:550
ff_zigzag_scan
const uint8_t ff_zigzag_scan[16+1]
Definition: mathtables.c:148
H264Picture::reference
int reference
Definition: h264dec.h:150
AVCodecInternal::hwaccel_priv_data
void * hwaccel_priv_data
hwaccel-specific private data
Definition: internal.h:130
H264_MAX_DPB_FRAMES
@ H264_MAX_DPB_FRAMES
Definition: h264.h:76
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:424
FFVulkanDecodePicture::ref
VkImageView ref[AV_NUM_DATA_POINTERS]
Definition: vulkan_decode.h:79
size
int size
Definition: twinvq_data.h:10344
h264_scaling_list8_order
const static int h264_scaling_list8_order[]
Definition: vulkan_h264.c:52
ff_vk_dec_h264_desc
const FFVulkanDecodeDescriptor ff_vk_dec_h264_desc
Definition: vulkan_h264.c:24
AVHWAccel::name
const char * name
Name of the hardware accelerated codec.
Definition: avcodec.h:1949
h264dec.h
uninit
static void uninit(AVBSFContext *ctx)
Definition: pcm_rechunk.c:68
FFVulkanDecodePicture::out
VkImageView out[AV_NUM_DATA_POINTERS]
Definition: vulkan_decode.h:80
H264Context
H264Context.
Definition: h264dec.h:338
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
vk_h264_end_frame
static int vk_h264_end_frame(AVCodecContext *avctx)
Definition: vulkan_h264.c:501
FF_VK_EXT_VIDEO_DECODE_H264
#define FF_VK_EXT_VIDEO_DECODE_H264
Definition: vulkan_functions.h:61
H264SliceContext::frame_num
int frame_num
Definition: h264dec.h:326
H264VulkanDecodePicture::vp
FFVulkanDecodePicture vp
Definition: vulkan_h264.c:36
FFVulkanDecodePicture::ref_slot
VkVideoReferenceSlotInfoKHR ref_slot
Definition: vulkan_decode.h:91
FFVulkanDecodePicture::ref_slots
VkVideoReferenceSlotInfoKHR ref_slots[36]
Definition: vulkan_decode.h:95
ff_zigzag_direct
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:137
ff_vk_decode_flush
void ff_vk_decode_flush(AVCodecContext *avctx)
Flush decoder.
Definition: vulkan_decode.c:368
PPS::sps
const SPS * sps
RefStruct reference.
Definition: h264_ps.h:141
vk_h264_fill_pict
static int vk_h264_fill_pict(AVCodecContext *avctx, H264Picture **ref_src, VkVideoReferenceSlotInfoKHR *ref_slot, VkVideoPictureResourceInfoKHR *ref, VkVideoDecodeH264DpbSlotInfoKHR *vkh264_ref, StdVideoDecodeH264ReferenceInfo *h264_ref, H264Picture *pic, int is_current, int is_field, int picture_structure, int dpb_slot_index)
Definition: vulkan_h264.c:54
vk_h264_free_frame_priv
static void vk_h264_free_frame_priv(AVRefStructOpaque _hwctx, void *data)
Definition: vulkan_h264.c:565
sps
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
Definition: cbs_h264_syntax_template.c:260
ff_vk_decode_add_slice
int ff_vk_decode_add_slice(AVCodecContext *avctx, FFVulkanDecodePicture *vp, const uint8_t *data, size_t size, int add_startcode, uint32_t *nb_slices, const uint32_t **offsets)
Add slice data to frame.
Definition: vulkan_decode.c:287
SIZE_SPECIFIER
#define SIZE_SPECIFIER
Definition: internal.h:119
PPS::sps_id
unsigned int sps_id
Definition: h264_ps.h:112
AVCodecContext
main external API structure.
Definition: avcodec.h:431
AVFrame::height
int height
Definition: frame.h:499
FFVulkanDecodeContext::dedicated_dpb
int dedicated_dpb
Definition: vulkan_decode.h:60
H264Picture::field_poc
int field_poc[2]
top/bottom POC
Definition: h264dec.h:132
buffer
the frame and frame reference mechanism is intended to as much as expensive copies of that data while still allowing the filters to produce correct results The data is stored in buffers represented by AVFrame structures Several references can point to the same frame buffer
Definition: filter_design.txt:49
H264Picture
Definition: h264dec.h:112
update_thread_context
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call have update_thread_context() run it in the next thread. Add AV_CODEC_CAP_FRAME_THREADS to the codec capabilities. There will be very little speed gain at this point but it should work. Use ff_thread_get_buffer()(or ff_progress_frame_get_buffer() in case you have inter-frame dependencies and use the ProgressFrame API) to allocate frame buffers. Call ff_progress_frame_report() after some part of the current picture has decoded. A good place to put this is where draw_horiz_band() is called - add this if it isn 't called anywhere
FFVulkanDecodeDescriptor
Definition: vulkan_decode.h:29
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:117
pps
uint64_t pps
Definition: dovi_rpuenc.c:36
ff_vk_params_invalidate
int ff_vk_params_invalidate(AVCodecContext *avctx, int t, const uint8_t *b, uint32_t s)
Removes current session parameters to recreate them.
Definition: vulkan_decode.c:145
MAX_SPS_COUNT
#define MAX_SPS_COUNT
Definition: h264_ps.h:37
ff_vk_update_thread_context
int ff_vk_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
Synchronize the contexts between 2 threads.
Definition: vulkan_decode.c:127
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:200
FFVulkanDecodePicture::slices_buf
AVBufferRef * slices_buf
Definition: vulkan_decode.h:101
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
H264Picture::hwaccel_picture_private
void * hwaccel_picture_private
RefStruct reference for hardware accelerator private data.
Definition: h264dec.h:128
vulkan_decode.h
H264SliceContext::idr_pic_id
int idr_pic_id
Definition: h264dec.h:327
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:458
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
ff_vk_decode_init
int ff_vk_decode_init(AVCodecContext *avctx)
Initialize decoder.
Definition: vulkan_decode.c:1251
h
h
Definition: vp9dsp_template.c:2070
FFVulkanDecodePicture::decode_info
VkVideoDecodeInfoKHR decode_info
Definition: vulkan_decode.h:98
H264_MAX_PICTURE_COUNT
#define H264_MAX_PICTURE_COUNT
Definition: h264dec.h:47
H264VulkanDecodePicture::vkh264_refs
VkVideoDecodeH264DpbSlotInfoKHR vkh264_refs[H264_MAX_PICTURE_COUNT]
Definition: vulkan_h264.c:45
H264Picture::long_ref
int long_ref
1->long term reference 0->short term reference
Definition: h264dec.h:139
Generated on Wed Nov 19 2025 19:22:38 for FFmpeg by   doxygen 1.8.17

AltStyle によって変換されたページ (->オリジナル) /