FFmpeg
vulkan_hevc.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 "libavutil/mem.h"
20 #include "hevc/hevcdec.h"
21 #include "hevc/data.h"
22 #include "hevc/ps.h"
23 
24 #include "vulkan_decode.h"
25 
28  .decode_extension = FF_VK_EXT_VIDEO_DECODE_H265,
29  .decode_op = VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR,
30  .ext_props = {
31  .extensionName = VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_EXTENSION_NAME,
32  .specVersion = VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_SPEC_VERSION,
33  },
34 };
35 
36 typedef struct HEVCHeaderSPS {
37  StdVideoH265ScalingLists scaling;
38  StdVideoH265HrdParameters vui_header;
39  StdVideoH265SequenceParameterSetVui vui;
40  StdVideoH265ProfileTierLevel ptl;
41  StdVideoH265DecPicBufMgr dpbm;
42  StdVideoH265PredictorPaletteEntries pal;
43  StdVideoH265SubLayerHrdParameters nal_hdr[HEVC_MAX_SUB_LAYERS];
44  StdVideoH265SubLayerHrdParameters vcl_hdr[HEVC_MAX_SUB_LAYERS];
45  StdVideoH265ShortTermRefPicSet str[HEVC_MAX_SHORT_TERM_REF_PIC_SETS];
46  StdVideoH265LongTermRefPicsSps ltr;
48 
49 typedef struct HEVCHeaderPPS {
50  StdVideoH265ScalingLists scaling;
51  StdVideoH265PredictorPaletteEntries pal;
53 
54 typedef struct HEVCHeaderVPSSet {
55  StdVideoH265SubLayerHrdParameters nal_hdr[HEVC_MAX_SUB_LAYERS];
56  StdVideoH265SubLayerHrdParameters vcl_hdr[HEVC_MAX_SUB_LAYERS];
58 
59 typedef struct HEVCHeaderVPS {
60  StdVideoH265ProfileTierLevel ptl;
61  StdVideoH265DecPicBufMgr dpbm;
62  StdVideoH265HrdParameters hdr[HEVC_MAX_LAYER_SETS];
65 
66 typedef struct HEVCHeaderSet {
67  StdVideoH265SequenceParameterSet sps[HEVC_MAX_SPS_COUNT];
69 
70  StdVideoH265PictureParameterSet pps[HEVC_MAX_PPS_COUNT];
72 
73  StdVideoH265VideoParameterSet vps[HEVC_MAX_PPS_COUNT];
76 
78  int nb_vps,
79  const int vps_list_idx[HEVC_MAX_VPS_COUNT],
80  const HEVCVPS * const vps_list[HEVC_MAX_VPS_COUNT])
81 {
82  uint8_t *data_ptr;
83  HEVCHeaderSet *hdr;
84 
85  size_t buf_size = sizeof(HEVCHeaderSet) + nb_vps*sizeof(HEVCHeaderVPS);
86  for (int i = 0; i < nb_vps; i++) {
87  const HEVCVPS *vps = vps_list[vps_list_idx[i]];
88  buf_size += sizeof(HEVCHeaderVPSSet)*vps->vps_num_hrd_parameters;
89  }
90 
91  if (buf_size > s->hevc_headers_size) {
92  av_freep(&s->hevc_headers);
93  s->hevc_headers_size = 0;
94  s->hevc_headers = av_mallocz(buf_size);
95  if (!s->hevc_headers)
96  return AVERROR(ENOMEM);
97  s->hevc_headers_size = buf_size;
98  }
99 
100  /* Setup struct pointers */
101  hdr = s->hevc_headers;
102  data_ptr = (uint8_t *)hdr;
103  hdr->hvps = (HEVCHeaderVPS *)(data_ptr + sizeof(HEVCHeaderSet));
104  data_ptr += sizeof(HEVCHeaderSet) + nb_vps*sizeof(HEVCHeaderVPS);
105  for (int i = 0; i < nb_vps; i++) {
106  const HEVCVPS *vps = vps_list[vps_list_idx[i]];
107  hdr->hvps[i].sls = (HEVCHeaderVPSSet *)data_ptr;
108  data_ptr += sizeof(HEVCHeaderVPSSet)*vps->vps_num_hrd_parameters;
109  }
110 
111  return 0;
112 }
113 
114 typedef struct HEVCVulkanDecodePicture {
116 
117  /* Current picture */
118  StdVideoDecodeH265ReferenceInfo h265_ref;
119  VkVideoDecodeH265DpbSlotInfoKHR vkh265_ref;
120 
121  /* Picture refs */
123  StdVideoDecodeH265ReferenceInfo h265_refs [HEVC_MAX_REFS];
124  VkVideoDecodeH265DpbSlotInfoKHR vkh265_refs[HEVC_MAX_REFS];
125 
126  /* Current picture (contd.) */
127  StdVideoDecodeH265PictureInfo h265pic;
128  VkVideoDecodeH265PictureInfoKHR h265_pic_info;
130 
131 static int vk_hevc_fill_pict(AVCodecContext *avctx, HEVCFrame **ref_src,
132  VkVideoReferenceSlotInfoKHR *ref_slot, /* Main structure */
133  VkVideoPictureResourceInfoKHR *ref, /* Goes in ^ */
134  VkVideoDecodeH265DpbSlotInfoKHR *vkh265_ref, /* Goes in ^ */
135  StdVideoDecodeH265ReferenceInfo *h265_ref, /* Goes in ^ */
136  HEVCFrame *pic, int is_current, int pic_id)
137 {
141  FFVulkanDecodePicture *vkpic = &hp->vp;
142 
143  int err = ff_vk_decode_prepare_frame(dec, pic->f, vkpic, is_current,
144  dec->dedicated_dpb);
145  if (err < 0)
146  return err;
147 
148  *h265_ref = (StdVideoDecodeH265ReferenceInfo) {
149  .flags = (StdVideoDecodeH265ReferenceInfoFlags) {
150  .used_for_long_term_reference = pic->flags & HEVC_FRAME_FLAG_LONG_REF,
151  .unused_for_reference = 0,
152  },
153  .PicOrderCntVal = pic->poc,
154  };
155 
156  *vkh265_ref = (VkVideoDecodeH265DpbSlotInfoKHR) {
157  .sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR,
158  .pStdReferenceInfo = h265_ref,
159  };
160 
161  *ref = (VkVideoPictureResourceInfoKHR) {
162  .sType = VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR,
163  .codedOffset = (VkOffset2D){ 0, 0 },
164  .codedExtent = (VkExtent2D){ pic->f->width, pic->f->height },
165  .baseArrayLayer = ctx->common.layered_dpb ? pic_id : 0,
166  .imageViewBinding = vkpic->img_view_ref,
167  };
168 
169  *ref_slot = (VkVideoReferenceSlotInfoKHR) {
170  .sType = VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR,
171  .pNext = vkh265_ref,
172  .slotIndex = pic_id,
173  .pPictureResource = ref,
174  };
175 
176  if (ref_src)
177  *ref_src = pic;
178 
179  return 0;
180 }
181 
182 static StdVideoH265LevelIdc convert_to_vk_level_idc(int level_idc)
183 {
184  switch (level_idc) {
185  case 10: return STD_VIDEO_H265_LEVEL_IDC_1_0;
186  case 20: return STD_VIDEO_H265_LEVEL_IDC_2_0;
187  case 21: return STD_VIDEO_H265_LEVEL_IDC_2_1;
188  case 30: return STD_VIDEO_H265_LEVEL_IDC_3_0;
189  case 31: return STD_VIDEO_H265_LEVEL_IDC_3_1;
190  case 40: return STD_VIDEO_H265_LEVEL_IDC_4_0;
191  case 41: return STD_VIDEO_H265_LEVEL_IDC_4_1;
192  case 50: return STD_VIDEO_H265_LEVEL_IDC_5_0;
193  case 51: return STD_VIDEO_H265_LEVEL_IDC_5_1;
194  case 60: return STD_VIDEO_H265_LEVEL_IDC_6_0;
195  case 61: return STD_VIDEO_H265_LEVEL_IDC_6_1;
196  default:
197  case 62: return STD_VIDEO_H265_LEVEL_IDC_6_2;
198  }
199 }
200 
201 static void copy_scaling_list(const ScalingList *sl, StdVideoH265ScalingLists *vksl)
202 {
203  for (int i = 0; i < STD_VIDEO_H265_SCALING_LIST_4X4_NUM_LISTS; i++) {
204  for (int j = 0; j < STD_VIDEO_H265_SCALING_LIST_4X4_NUM_ELEMENTS; j++) {
205  uint8_t pos = 4 * ff_hevc_diag_scan4x4_y[j] + ff_hevc_diag_scan4x4_x[j];
206  vksl->ScalingList4x4[i][j] = sl->sl[0][i][pos];
207  }
208  }
209 
210  for (int i = 0; i < STD_VIDEO_H265_SCALING_LIST_8X8_NUM_LISTS; i++) {
211  for (int j = 0; j < STD_VIDEO_H265_SCALING_LIST_8X8_NUM_ELEMENTS; j++) {
212  uint8_t pos = 8 * ff_hevc_diag_scan8x8_y[j] + ff_hevc_diag_scan8x8_x[j];
213  vksl->ScalingList8x8[i][j] = sl->sl[1][i][pos];
214  }
215  }
216 
217  for (int i = 0; i < STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS; i++) {
218  for (int j = 0; j < STD_VIDEO_H265_SCALING_LIST_16X16_NUM_ELEMENTS; j++) {
219  uint8_t pos = 8 * ff_hevc_diag_scan8x8_y[j] + ff_hevc_diag_scan8x8_x[j];
220  vksl->ScalingList16x16[i][j] = sl->sl[2][i][pos];
221  }
222  }
223 
224  for (int i = 0; i < STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS; i++) {
225  for (int j = 0; j < STD_VIDEO_H265_SCALING_LIST_32X32_NUM_ELEMENTS; j++) {
226  uint8_t pos = 8 * ff_hevc_diag_scan8x8_y[j] + ff_hevc_diag_scan8x8_x[j];
227  vksl->ScalingList32x32[i][j] = sl->sl[3][i * 3][pos];
228  }
229  }
230 
231  memcpy(vksl->ScalingListDCCoef16x16, sl->sl_dc[0],
232  STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS * sizeof(*vksl->ScalingListDCCoef16x16));
233 
234  for (int i = 0; i < STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS; i++)
235  vksl->ScalingListDCCoef32x32[i] = sl->sl_dc[1][i * 3];
236 }
237 
238 static void set_sps(const HEVCSPS *sps, int sps_idx,
239  StdVideoH265ScalingLists *vksps_scaling,
240  StdVideoH265HrdParameters *vksps_vui_header,
241  StdVideoH265SequenceParameterSetVui *vksps_vui,
242  StdVideoH265SequenceParameterSet *vksps,
243  StdVideoH265SubLayerHrdParameters *slhdrnal,
244  StdVideoH265SubLayerHrdParameters *slhdrvcl,
245  StdVideoH265ProfileTierLevel *ptl,
246  StdVideoH265DecPicBufMgr *dpbm,
247  StdVideoH265PredictorPaletteEntries *pal,
248  StdVideoH265ShortTermRefPicSet *str,
249  StdVideoH265LongTermRefPicsSps *ltr)
250 {
251  copy_scaling_list(&sps->scaling_list, vksps_scaling);
252 
253  *vksps_vui_header = (StdVideoH265HrdParameters) {
254  .flags = (StdVideoH265HrdFlags) {
255  .nal_hrd_parameters_present_flag = sps->hdr.nal_hrd_parameters_present_flag,
256  .vcl_hrd_parameters_present_flag = sps->hdr.vcl_hrd_parameters_present_flag,
257  .sub_pic_hrd_params_present_flag = sps->hdr.sub_pic_hrd_params_present_flag,
258  .sub_pic_cpb_params_in_pic_timing_sei_flag = sps->hdr.sub_pic_cpb_params_in_pic_timing_sei_flag,
259  .fixed_pic_rate_general_flag = sps->hdr.flags.fixed_pic_rate_general_flag,
260  .fixed_pic_rate_within_cvs_flag = sps->hdr.flags.fixed_pic_rate_within_cvs_flag,
261  .low_delay_hrd_flag = sps->hdr.flags.low_delay_hrd_flag,
262  },
263  .tick_divisor_minus2 = sps->hdr.tick_divisor_minus2,
264  .du_cpb_removal_delay_increment_length_minus1 = sps->hdr.du_cpb_removal_delay_increment_length_minus1,
265  .dpb_output_delay_du_length_minus1 = sps->hdr.dpb_output_delay_du_length_minus1,
266  .bit_rate_scale = sps->hdr.bit_rate_scale,
267  .cpb_size_scale = sps->hdr.cpb_size_scale,
268  .cpb_size_du_scale = sps->hdr.cpb_size_du_scale,
269  .initial_cpb_removal_delay_length_minus1 = sps->hdr.initial_cpb_removal_delay_length_minus1,
270  .au_cpb_removal_delay_length_minus1 = sps->hdr.au_cpb_removal_delay_length_minus1,
271  .dpb_output_delay_length_minus1 = sps->hdr.dpb_output_delay_length_minus1,
272  /* Reserved - 3*16 bits */
273  .pSubLayerHrdParametersNal = slhdrnal,
274  .pSubLayerHrdParametersVcl = slhdrvcl,
275  };
276 
277  memcpy(vksps_vui_header->cpb_cnt_minus1, sps->hdr.cpb_cnt_minus1,
278  STD_VIDEO_H265_SUBLAYERS_LIST_SIZE*sizeof(*vksps_vui_header->cpb_cnt_minus1));
279  memcpy(vksps_vui_header->elemental_duration_in_tc_minus1, sps->hdr.elemental_duration_in_tc_minus1,
280  STD_VIDEO_H265_SUBLAYERS_LIST_SIZE*sizeof(*vksps_vui_header->elemental_duration_in_tc_minus1));
281 
282  memcpy(slhdrnal, sps->hdr.nal_params, HEVC_MAX_SUB_LAYERS*sizeof(*slhdrnal));
283  memcpy(slhdrvcl, sps->hdr.vcl_params, HEVC_MAX_SUB_LAYERS*sizeof(*slhdrvcl));
284 
285  *vksps_vui = (StdVideoH265SequenceParameterSetVui) {
286  .flags = (StdVideoH265SpsVuiFlags) {
287  .aspect_ratio_info_present_flag = sps->vui.common.aspect_ratio_info_present_flag,
288  .overscan_info_present_flag = sps->vui.common.overscan_info_present_flag,
289  .overscan_appropriate_flag = sps->vui.common.overscan_appropriate_flag,
290  .video_signal_type_present_flag = sps->vui.common.video_signal_type_present_flag,
291  .video_full_range_flag = sps->vui.common.video_full_range_flag,
292  .colour_description_present_flag = sps->vui.common.colour_description_present_flag,
293  .chroma_loc_info_present_flag = sps->vui.common.chroma_loc_info_present_flag,
294  .neutral_chroma_indication_flag = sps->vui.neutra_chroma_indication_flag,
295  .field_seq_flag = sps->vui.field_seq_flag,
296  .frame_field_info_present_flag = sps->vui.frame_field_info_present_flag,
297  .default_display_window_flag = sps->vui.default_display_window_flag,
298  .vui_timing_info_present_flag = sps->vui.vui_timing_info_present_flag,
299  .vui_poc_proportional_to_timing_flag = sps->vui.vui_poc_proportional_to_timing_flag,
300  .vui_hrd_parameters_present_flag = sps->vui.vui_hrd_parameters_present_flag,
301  .bitstream_restriction_flag = sps->vui.bitstream_restriction_flag,
302  .tiles_fixed_structure_flag = sps->vui.tiles_fixed_structure_flag,
303  .motion_vectors_over_pic_boundaries_flag = sps->vui.motion_vectors_over_pic_boundaries_flag,
304  .restricted_ref_pic_lists_flag = sps->vui.restricted_ref_pic_lists_flag,
305  },
306  .aspect_ratio_idc = sps->vui.common.aspect_ratio_idc,
307  .sar_width = sps->vui.common.sar.num,
308  .sar_height = sps->vui.common.sar.den,
309  .video_format = sps->vui.common.video_format,
310  .colour_primaries = sps->vui.common.colour_primaries,
311  .transfer_characteristics = sps->vui.common.transfer_characteristics,
312  .matrix_coeffs = sps->vui.common.matrix_coeffs,
313  .chroma_sample_loc_type_top_field = sps->vui.common.chroma_sample_loc_type_top_field,
314  .chroma_sample_loc_type_bottom_field = sps->vui.common.chroma_sample_loc_type_bottom_field,
315  /* Reserved */
316  /* Reserved */
317  .def_disp_win_left_offset = sps->vui.def_disp_win.left_offset,
318  .def_disp_win_right_offset = sps->vui.def_disp_win.right_offset,
319  .def_disp_win_top_offset = sps->vui.def_disp_win.top_offset,
320  .def_disp_win_bottom_offset = sps->vui.def_disp_win.bottom_offset,
321  .vui_num_units_in_tick = sps->vui.vui_num_units_in_tick,
322  .vui_time_scale = sps->vui.vui_time_scale,
323  .vui_num_ticks_poc_diff_one_minus1 = sps->vui.vui_num_ticks_poc_diff_one_minus1,
324  .min_spatial_segmentation_idc = sps->vui.min_spatial_segmentation_idc,
325  .max_bytes_per_pic_denom = sps->vui.max_bytes_per_pic_denom,
326  .max_bits_per_min_cu_denom = sps->vui.max_bits_per_min_cu_denom,
327  .log2_max_mv_length_horizontal = sps->vui.log2_max_mv_length_horizontal,
328  .log2_max_mv_length_vertical = sps->vui.log2_max_mv_length_vertical,
329  .pHrdParameters = vksps_vui_header,
330  };
331 
332  *ptl = (StdVideoH265ProfileTierLevel) {
333  .flags = (StdVideoH265ProfileTierLevelFlags) {
334  .general_tier_flag = sps->ptl.general_ptl.tier_flag,
335  .general_progressive_source_flag = sps->ptl.general_ptl.progressive_source_flag,
336  .general_interlaced_source_flag = sps->ptl.general_ptl.interlaced_source_flag,
337  .general_non_packed_constraint_flag = sps->ptl.general_ptl.non_packed_constraint_flag,
338  .general_frame_only_constraint_flag = sps->ptl.general_ptl.frame_only_constraint_flag,
339  },
340  .general_profile_idc = sps->ptl.general_ptl.profile_idc,
341  .general_level_idc = convert_to_vk_level_idc(sps->ptl.general_ptl.level_idc),
342  };
343 
344  for (int i = 0; i < sps->max_sub_layers; i++) {
345  dpbm->max_latency_increase_plus1[i] = sps->temporal_layer[i].max_latency_increase + 1;
346  dpbm->max_dec_pic_buffering_minus1[i] = sps->temporal_layer[i].max_dec_pic_buffering - 1;
347  dpbm->max_num_reorder_pics[i] = sps->temporal_layer[i].num_reorder_pics;
348  }
349 
350  for (int i = 0; i < (sps->chroma_format_idc ? 3 : 1); i++)
351  for (int j = 0; j < sps->sps_num_palette_predictor_initializers; j++)
352  pal->PredictorPaletteEntries[i][j] = sps->sps_palette_predictor_initializer[i][j];
353 
354  for (int i = 0; i < sps->nb_st_rps; i++) {
355  const ShortTermRPS *st_rps = &sps->st_rps[i];
356 
357  str[i] = (StdVideoH265ShortTermRefPicSet) {
358  .flags = (StdVideoH265ShortTermRefPicSetFlags) {
359  .inter_ref_pic_set_prediction_flag = sps->st_rps[i].rps_predict,
360  .delta_rps_sign = sps->st_rps[i].delta_rps_sign,
361  },
362  .delta_idx_minus1 = sps->st_rps[i].delta_idx - 1,
363  .use_delta_flag = sps->st_rps[i].use_delta,
364  .abs_delta_rps_minus1 = sps->st_rps[i].abs_delta_rps - 1,
365  .used_by_curr_pic_flag = 0x0,
366  .used_by_curr_pic_s0_flag = 0x0,
367  .used_by_curr_pic_s1_flag = 0x0,
368  /* Reserved */
369  /* Reserved */
370  /* Reserved */
371  .num_negative_pics = sps->st_rps[i].num_negative_pics,
372  .num_positive_pics = sps->st_rps[i].num_delta_pocs - sps->st_rps[i].num_negative_pics,
373  };
374 
375  /* NOTE: This is the predicted, and *reordered* version.
376  * Probably incorrect, but the spec doesn't say which version to use. */
377  str[i].used_by_curr_pic_flag = st_rps->used;
378  str[i].used_by_curr_pic_s0_flag = av_zero_extend(st_rps->used, str[i].num_negative_pics);
379  str[i].used_by_curr_pic_s1_flag = st_rps->used >> str[i].num_negative_pics;
380 
381  for (int j = 0; j < str[i].num_negative_pics; j++)
382  str[i].delta_poc_s0_minus1[j] = st_rps->delta_poc[j] - (j ? st_rps->delta_poc[j - 1] : 0) - 1;
383 
384  for (int j = 0; j < str[i].num_positive_pics; j++)
385  str[i].delta_poc_s1_minus1[j] = st_rps->delta_poc[st_rps->num_negative_pics + j] -
386  (j ? st_rps->delta_poc[st_rps->num_negative_pics + j - 1] : 0) - 1;
387  }
388 
389  *ltr = (StdVideoH265LongTermRefPicsSps) {
390  .used_by_curr_pic_lt_sps_flag = sps->used_by_curr_pic_lt,
391  };
392 
393  for (int i = 0; i < sps->num_long_term_ref_pics_sps; i++) {
394  ltr->lt_ref_pic_poc_lsb_sps[i] = sps->lt_ref_pic_poc_lsb_sps[i];
395  }
396 
397  *vksps = (StdVideoH265SequenceParameterSet) {
398  .flags = (StdVideoH265SpsFlags) {
399  .sps_temporal_id_nesting_flag = sps->temporal_id_nesting,
400  .separate_colour_plane_flag = sps->separate_colour_plane,
401  .conformance_window_flag = sps->conformance_window,
402  .sps_sub_layer_ordering_info_present_flag = sps->sublayer_ordering_info,
403  .scaling_list_enabled_flag = sps->scaling_list_enabled,
404  .sps_scaling_list_data_present_flag = sps->scaling_list_enabled,
405  .amp_enabled_flag = sps->amp_enabled,
406  .sample_adaptive_offset_enabled_flag = sps->sao_enabled,
407  .pcm_enabled_flag = sps->pcm_enabled,
408  .pcm_loop_filter_disabled_flag = sps->pcm_loop_filter_disabled,
409  .long_term_ref_pics_present_flag = sps->long_term_ref_pics_present,
410  .sps_temporal_mvp_enabled_flag = sps->temporal_mvp_enabled,
411  .strong_intra_smoothing_enabled_flag = sps->strong_intra_smoothing_enabled,
412  .vui_parameters_present_flag = sps->vui_present,
413  .sps_extension_present_flag = sps->extension_present,
414  .sps_range_extension_flag = sps->range_extension,
415  .transform_skip_rotation_enabled_flag = sps->transform_skip_rotation_enabled,
416  .transform_skip_context_enabled_flag = sps->transform_skip_context_enabled,
417  .implicit_rdpcm_enabled_flag = sps->implicit_rdpcm_enabled,
418  .explicit_rdpcm_enabled_flag = sps->explicit_rdpcm_enabled,
419  .extended_precision_processing_flag = sps->extended_precision_processing,
420  .intra_smoothing_disabled_flag = sps->intra_smoothing_disabled,
421  .high_precision_offsets_enabled_flag = sps->high_precision_offsets_enabled,
422  .persistent_rice_adaptation_enabled_flag = sps->persistent_rice_adaptation_enabled,
423  .cabac_bypass_alignment_enabled_flag = sps->cabac_bypass_alignment_enabled,
424  .sps_scc_extension_flag = sps->scc_extension,
425  .sps_curr_pic_ref_enabled_flag = sps->curr_pic_ref_enabled,
426  .palette_mode_enabled_flag = sps->palette_mode_enabled,
427  .sps_palette_predictor_initializers_present_flag = sps->palette_predictor_initializers_present,
428  .intra_boundary_filtering_disabled_flag = sps->intra_boundary_filtering_disabled,
429  },
430  .chroma_format_idc = sps->chroma_format_idc,
431  .pic_width_in_luma_samples = sps->width,
432  .pic_height_in_luma_samples = sps->height,
433  .sps_video_parameter_set_id = sps->vps_id,
434  .sps_max_sub_layers_minus1 = sps->max_sub_layers - 1,
435  .sps_seq_parameter_set_id = sps_idx,
436  .bit_depth_luma_minus8 = sps->bit_depth - 8,
437  .bit_depth_chroma_minus8 = sps->bit_depth_chroma - 8,
438  .log2_max_pic_order_cnt_lsb_minus4 = sps->log2_max_poc_lsb - 4,
439  .log2_min_luma_coding_block_size_minus3 = sps->log2_min_cb_size - 3,
440  .log2_diff_max_min_luma_coding_block_size = sps->log2_diff_max_min_coding_block_size,
441  .log2_min_luma_transform_block_size_minus2 = sps->log2_min_tb_size - 2,
442  .log2_diff_max_min_luma_transform_block_size = sps->log2_diff_max_min_transform_block_size,
443  .max_transform_hierarchy_depth_inter = sps->max_transform_hierarchy_depth_inter,
444  .max_transform_hierarchy_depth_intra = sps->max_transform_hierarchy_depth_intra,
445  .num_short_term_ref_pic_sets = sps->nb_st_rps,
446  .num_long_term_ref_pics_sps = sps->num_long_term_ref_pics_sps,
447  .pcm_sample_bit_depth_luma_minus1 = sps->pcm.bit_depth - 1,
448  .pcm_sample_bit_depth_chroma_minus1 = sps->pcm.bit_depth_chroma - 1,
449  .log2_min_pcm_luma_coding_block_size_minus3 = sps->pcm.log2_min_pcm_cb_size - 3,
450  .log2_diff_max_min_pcm_luma_coding_block_size = sps->pcm.log2_max_pcm_cb_size - sps->pcm.log2_min_pcm_cb_size,
451  /* Reserved */
452  /* Reserved */
453  .palette_max_size = sps->palette_max_size,
454  .delta_palette_max_predictor_size = sps->delta_palette_max_predictor_size,
455  .motion_vector_resolution_control_idc = sps->motion_vector_resolution_control_idc,
456  .sps_num_palette_predictor_initializers_minus1 = sps->sps_num_palette_predictor_initializers - 1,
457  .conf_win_left_offset = sps->pic_conf_win.left_offset,
458  .conf_win_right_offset = sps->pic_conf_win.right_offset,
459  .conf_win_top_offset = sps->pic_conf_win.top_offset,
460  .conf_win_bottom_offset = sps->pic_conf_win.bottom_offset,
461  .pProfileTierLevel = ptl,
462  .pDecPicBufMgr = dpbm,
463  .pScalingLists = vksps_scaling,
464  .pShortTermRefPicSet = str,
465  .pLongTermRefPicsSps = ltr,
466  .pSequenceParameterSetVui = vksps_vui,
467  .pPredictorPaletteEntries = pal,
468  };
469 }
470 
471 static void set_pps(const HEVCPPS *pps, const HEVCSPS *sps,
472  StdVideoH265ScalingLists *vkpps_scaling,
473  StdVideoH265PictureParameterSet *vkpps,
474  StdVideoH265PredictorPaletteEntries *pal)
475 {
476  copy_scaling_list(&pps->scaling_list, vkpps_scaling);
477 
478  *vkpps = (StdVideoH265PictureParameterSet) {
479  .flags = (StdVideoH265PpsFlags) {
480  .dependent_slice_segments_enabled_flag = pps->dependent_slice_segments_enabled_flag,
481  .output_flag_present_flag = pps->output_flag_present_flag,
482  .sign_data_hiding_enabled_flag = pps->sign_data_hiding_flag,
483  .cabac_init_present_flag = pps->cabac_init_present_flag,
484  .constrained_intra_pred_flag = pps->constrained_intra_pred_flag,
485  .transform_skip_enabled_flag = pps->transform_skip_enabled_flag,
486  .cu_qp_delta_enabled_flag = pps->cu_qp_delta_enabled_flag,
487  .pps_slice_chroma_qp_offsets_present_flag = pps->pic_slice_level_chroma_qp_offsets_present_flag,
488  .weighted_pred_flag = pps->weighted_pred_flag,
489  .weighted_bipred_flag = pps->weighted_bipred_flag,
490  .transquant_bypass_enabled_flag = pps->transquant_bypass_enable_flag,
491  .tiles_enabled_flag = pps->tiles_enabled_flag,
492  .entropy_coding_sync_enabled_flag = pps->entropy_coding_sync_enabled_flag,
493  .uniform_spacing_flag = pps->uniform_spacing_flag,
494  .loop_filter_across_tiles_enabled_flag = pps->loop_filter_across_tiles_enabled_flag,
495  .pps_loop_filter_across_slices_enabled_flag = pps->seq_loop_filter_across_slices_enabled_flag,
496  .deblocking_filter_control_present_flag = pps->deblocking_filter_control_present_flag,
497  .deblocking_filter_override_enabled_flag = pps->deblocking_filter_override_enabled_flag,
498  .pps_deblocking_filter_disabled_flag = pps->disable_dbf,
499  .pps_scaling_list_data_present_flag = pps->scaling_list_data_present_flag,
500  .lists_modification_present_flag = pps->lists_modification_present_flag,
501  .slice_segment_header_extension_present_flag = pps->slice_header_extension_present_flag,
502  .pps_extension_present_flag = pps->pps_extension_present_flag,
503  .cross_component_prediction_enabled_flag = pps->cross_component_prediction_enabled_flag,
504  .chroma_qp_offset_list_enabled_flag = pps->chroma_qp_offset_list_enabled_flag,
505  .pps_curr_pic_ref_enabled_flag = pps->pps_curr_pic_ref_enabled_flag,
506  .residual_adaptive_colour_transform_enabled_flag = pps->residual_adaptive_colour_transform_enabled_flag,
507  .pps_slice_act_qp_offsets_present_flag = pps->pps_slice_act_qp_offsets_present_flag,
508  .pps_palette_predictor_initializers_present_flag = pps->pps_palette_predictor_initializers_present_flag,
509  .monochrome_palette_flag = pps->monochrome_palette_flag,
510  .pps_range_extension_flag = pps->pps_range_extensions_flag,
511  },
512  .pps_pic_parameter_set_id = pps->pps_id,
513  .pps_seq_parameter_set_id = pps->sps_id,
514  .sps_video_parameter_set_id = sps->vps_id,
515  .num_extra_slice_header_bits = pps->num_extra_slice_header_bits,
516  .num_ref_idx_l0_default_active_minus1 = pps->num_ref_idx_l0_default_active - 1,
517  .num_ref_idx_l1_default_active_minus1 = pps->num_ref_idx_l1_default_active - 1,
518  .init_qp_minus26 = pps->pic_init_qp_minus26,
519  .diff_cu_qp_delta_depth = pps->diff_cu_qp_delta_depth,
520  .pps_cb_qp_offset = pps->cb_qp_offset,
521  .pps_cr_qp_offset = pps->cr_qp_offset,
522  .pps_beta_offset_div2 = pps->beta_offset >> 1,
523  .pps_tc_offset_div2 = pps->tc_offset >> 1,
524  .log2_parallel_merge_level_minus2 = pps->log2_parallel_merge_level - 2,
525  .log2_max_transform_skip_block_size_minus2 = pps->log2_max_transform_skip_block_size - 2,
526  .diff_cu_chroma_qp_offset_depth = pps->diff_cu_chroma_qp_offset_depth,
527  .chroma_qp_offset_list_len_minus1 = pps->chroma_qp_offset_list_len_minus1,
528  .log2_sao_offset_scale_luma = pps->log2_sao_offset_scale_luma,
529  .log2_sao_offset_scale_chroma = pps->log2_sao_offset_scale_chroma,
530  .pps_act_y_qp_offset_plus5 = pps->pps_act_y_qp_offset + 5,
531  .pps_act_cb_qp_offset_plus5 = pps->pps_act_cb_qp_offset + 5,
532  .pps_act_cr_qp_offset_plus3 = pps->pps_act_cr_qp_offset + 3,
533  .pps_num_palette_predictor_initializers = pps->pps_num_palette_predictor_initializers,
534  .luma_bit_depth_entry_minus8 = pps->luma_bit_depth_entry - 8,
535  .chroma_bit_depth_entry_minus8 = pps->chroma_bit_depth_entry - 8,
536  .num_tile_columns_minus1 = pps->num_tile_columns - 1,
537  .num_tile_rows_minus1 = pps->num_tile_rows - 1,
538  .pScalingLists = vkpps_scaling,
539  .pPredictorPaletteEntries = pal,
540  };
541 
542  for (int i = 0; i < (pps->monochrome_palette_flag ? 1 : 3); i++) {
543  for (int j = 0; j < pps->pps_num_palette_predictor_initializers; j++)
544  pal->PredictorPaletteEntries[i][j] = pps->pps_palette_predictor_initializer[i][j];
545  }
546 
547  for (int i = 0; i < pps->num_tile_columns - 1; i++)
548  vkpps->column_width_minus1[i] = pps->column_width[i] - 1;
549 
550  for (int i = 0; i < pps->num_tile_rows - 1; i++)
551  vkpps->row_height_minus1[i] = pps->row_height[i] - 1;
552 
553  for (int i = 0; i <= pps->chroma_qp_offset_list_len_minus1; i++) {
554  vkpps->cb_qp_offset_list[i] = pps->cb_qp_offset_list[i];
555  vkpps->cr_qp_offset_list[i] = pps->cr_qp_offset_list[i];
556  }
557 }
558 
559 static void set_vps(const HEVCVPS *vps,
560  StdVideoH265VideoParameterSet *vkvps,
561  StdVideoH265ProfileTierLevel *ptl,
562  StdVideoH265DecPicBufMgr *dpbm,
563  StdVideoH265HrdParameters *sls_hdr,
564  HEVCHeaderVPSSet sls[])
565 {
566  for (int i = 0; i < vps->vps_num_hrd_parameters; i++) {
567  const HEVCHdrParams *src = &vps->hdr[i];
568 
569  sls_hdr[i] = (StdVideoH265HrdParameters) {
570  .flags = (StdVideoH265HrdFlags) {
571  .nal_hrd_parameters_present_flag = src->nal_hrd_parameters_present_flag,
572  .vcl_hrd_parameters_present_flag = src->vcl_hrd_parameters_present_flag,
573  .sub_pic_hrd_params_present_flag = src->sub_pic_hrd_params_present_flag,
574  .sub_pic_cpb_params_in_pic_timing_sei_flag = src->sub_pic_cpb_params_in_pic_timing_sei_flag,
575  .fixed_pic_rate_general_flag = src->flags.fixed_pic_rate_general_flag,
576  .fixed_pic_rate_within_cvs_flag = src->flags.fixed_pic_rate_within_cvs_flag,
577  .low_delay_hrd_flag = src->flags.low_delay_hrd_flag,
578  },
579  .tick_divisor_minus2 = src->tick_divisor_minus2,
580  .du_cpb_removal_delay_increment_length_minus1 = src->du_cpb_removal_delay_increment_length_minus1,
581  .dpb_output_delay_du_length_minus1 = src->dpb_output_delay_du_length_minus1,
582  .bit_rate_scale = src->bit_rate_scale,
583  .cpb_size_scale = src->cpb_size_scale,
584  .cpb_size_du_scale = src->cpb_size_du_scale,
585  .initial_cpb_removal_delay_length_minus1 = src->initial_cpb_removal_delay_length_minus1,
586  .au_cpb_removal_delay_length_minus1 = src->au_cpb_removal_delay_length_minus1,
587  .dpb_output_delay_length_minus1 = src->dpb_output_delay_length_minus1,
588  /* Reserved - 3*16 bits */
589  .pSubLayerHrdParametersNal = sls[i].nal_hdr,
590  .pSubLayerHrdParametersVcl = sls[i].vcl_hdr,
591  };
592 
593  memcpy(sls_hdr[i].cpb_cnt_minus1, src->cpb_cnt_minus1,
594  STD_VIDEO_H265_SUBLAYERS_LIST_SIZE*sizeof(*sls_hdr[i].cpb_cnt_minus1));
595  memcpy(sls_hdr[i].elemental_duration_in_tc_minus1, src->elemental_duration_in_tc_minus1,
596  STD_VIDEO_H265_SUBLAYERS_LIST_SIZE*sizeof(*sls_hdr[i].elemental_duration_in_tc_minus1));
597 
598  memcpy(sls[i].nal_hdr, src->nal_params, HEVC_MAX_SUB_LAYERS*sizeof(*sls[i].nal_hdr));
599  memcpy(sls[i].vcl_hdr, src->vcl_params, HEVC_MAX_SUB_LAYERS*sizeof(*sls[i].vcl_hdr));
600  }
601 
602  *ptl = (StdVideoH265ProfileTierLevel) {
603  .flags = (StdVideoH265ProfileTierLevelFlags) {
604  .general_tier_flag = vps->ptl.general_ptl.tier_flag,
605  .general_progressive_source_flag = vps->ptl.general_ptl.progressive_source_flag,
606  .general_interlaced_source_flag = vps->ptl.general_ptl.interlaced_source_flag,
607  .general_non_packed_constraint_flag = vps->ptl.general_ptl.non_packed_constraint_flag,
608  .general_frame_only_constraint_flag = vps->ptl.general_ptl.frame_only_constraint_flag,
609  },
610  .general_profile_idc = vps->ptl.general_ptl.profile_idc,
611  .general_level_idc = convert_to_vk_level_idc(vps->ptl.general_ptl.level_idc),
612  };
613 
614  for (int i = 0; i < vps->vps_max_sub_layers; i++) {
615  dpbm->max_latency_increase_plus1[i] = vps->vps_max_latency_increase[i] + 1;
616  dpbm->max_dec_pic_buffering_minus1[i] = vps->vps_max_dec_pic_buffering[i] - 1;
617  dpbm->max_num_reorder_pics[i] = vps->vps_num_reorder_pics[i];
618  }
619 
620  *vkvps = (StdVideoH265VideoParameterSet) {
621  .flags = (StdVideoH265VpsFlags) {
622  .vps_temporal_id_nesting_flag = vps->vps_temporal_id_nesting_flag,
623  .vps_sub_layer_ordering_info_present_flag = vps->vps_sub_layer_ordering_info_present_flag,
624  .vps_timing_info_present_flag = vps->vps_timing_info_present_flag,
625  .vps_poc_proportional_to_timing_flag = vps->vps_poc_proportional_to_timing_flag,
626  },
627  .vps_video_parameter_set_id = vps->vps_id,
628  .vps_max_sub_layers_minus1 = vps->vps_max_sub_layers - 1,
629  /* Reserved */
630  /* Reserved */
631  .vps_num_units_in_tick = vps->vps_num_units_in_tick,
632  .vps_time_scale = vps->vps_time_scale,
633  .vps_num_ticks_poc_diff_one_minus1 = vps->vps_num_ticks_poc_diff_one - 1,
634  /* Reserved */
635  .pDecPicBufMgr = dpbm,
636  .pHrdParameters = sls_hdr,
637  .pProfileTierLevel = ptl,
638  };
639 }
640 
642 {
643  int err;
644  const HEVCContext *h = avctx->priv_data;
647 
648  VkVideoDecodeH265SessionParametersAddInfoKHR h265_params_info = {
649  .sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR,
650  .stdSPSCount = 0,
651  .stdPPSCount = 0,
652  .stdVPSCount = 0,
653  };
654  VkVideoDecodeH265SessionParametersCreateInfoKHR h265_params = {
655  .sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR,
656  .pParametersAddInfo = &h265_params_info,
657  };
658  VkVideoSessionParametersCreateInfoKHR session_params_create = {
659  .sType = VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR,
660  .pNext = &h265_params,
661  .videoSession = ctx->common.session,
662  .videoSessionParametersTemplate = VK_NULL_HANDLE,
663  };
664 
665  HEVCHeaderSet *hdr;
666  int nb_vps = 0;
667  int vps_list_idx[HEVC_MAX_VPS_COUNT];
668 
669  for (int i = 0; i < HEVC_MAX_VPS_COUNT; i++)
670  if (h->ps.vps_list[i])
671  vps_list_idx[nb_vps++] = i;
672 
673  err = alloc_hevc_header_structs(dec, nb_vps, vps_list_idx, h->ps.vps_list);
674  if (err < 0)
675  return err;
676 
677  hdr = dec->hevc_headers;
678 
679  h265_params_info.pStdSPSs = hdr->sps;
680  h265_params_info.pStdPPSs = hdr->pps;
681  h265_params_info.pStdVPSs = hdr->vps;
682 
683  /* SPS list */
684  for (int i = 0; i < HEVC_MAX_SPS_COUNT; i++) {
685  if (h->ps.sps_list[i]) {
686  const HEVCSPS *sps_l = h->ps.sps_list[i];
687  int idx = h265_params_info.stdSPSCount++;
688  set_sps(sps_l, i, &hdr->hsps[idx].scaling, &hdr->hsps[idx].vui_header,
689  &hdr->hsps[idx].vui, &hdr->sps[idx], hdr->hsps[idx].nal_hdr,
690  hdr->hsps[idx].vcl_hdr, &hdr->hsps[idx].ptl, &hdr->hsps[idx].dpbm,
691  &hdr->hsps[idx].pal, hdr->hsps[idx].str, &hdr->hsps[idx].ltr);
692  }
693  }
694 
695  /* PPS list */
696  for (int i = 0; i < HEVC_MAX_PPS_COUNT; i++) {
697  if (h->ps.pps_list[i]) {
698  const HEVCPPS *pps_l = h->ps.pps_list[i];
699  const HEVCSPS *sps_l = h->ps.sps_list[pps_l->sps_id];
700  int idx = h265_params_info.stdPPSCount++;
701  set_pps(pps_l, sps_l, &hdr->hpps[idx].scaling,
702  &hdr->pps[idx], &hdr->hpps[idx].pal);
703  }
704  }
705 
706  /* VPS list */
707  for (int i = 0; i < nb_vps; i++) {
708  const HEVCVPS *vps_l = h->ps.vps_list[vps_list_idx[i]];
709  set_vps(vps_l, &hdr->vps[i], &hdr->hvps[i].ptl, &hdr->hvps[i].dpbm,
710  hdr->hvps[i].hdr, hdr->hvps[i].sls);
711  h265_params_info.stdVPSCount++;
712  }
713 
714  h265_params.maxStdSPSCount = h265_params_info.stdSPSCount;
715  h265_params.maxStdPPSCount = h265_params_info.stdPPSCount;
716  h265_params.maxStdVPSCount = h265_params_info.stdVPSCount;
717 
718  err = ff_vk_decode_create_params(buf, avctx, ctx, &session_params_create);
719  if (err < 0)
720  return err;
721 
722  av_log(avctx, AV_LOG_DEBUG, "Created frame parameters: %i SPS %i PPS %i VPS\n",
723  h265_params_info.stdSPSCount, h265_params_info.stdPPSCount,
724  h265_params_info.stdVPSCount);
725 
726  return 0;
727 }
728 
730  av_unused const uint8_t *buffer,
731  av_unused uint32_t size)
732 {
733  int err;
734  HEVCContext *h = avctx->priv_data;
735  HEVCLayerContext *l = &h->layers[h->cur_layer];
736  HEVCFrame *pic = h->cur_frame;
739  FFVulkanDecodePicture *vp = &hp->vp;
740  const HEVCPPS *pps = h->pps;
741  const HEVCSPS *sps = pps->sps;
742  int nb_refs = 0;
743 
744  if (!dec->session_params) {
745  err = vk_hevc_create_params(avctx, &dec->session_params);
746  if (err < 0)
747  return err;
748  }
749 
750  hp->h265pic = (StdVideoDecodeH265PictureInfo) {
751  .flags = (StdVideoDecodeH265PictureInfoFlags) {
752  .IrapPicFlag = IS_IRAP(h),
753  .IdrPicFlag = IS_IDR(h),
754  .IsReference = h->nal_unit_type < 16 ? h->nal_unit_type & 1 : 1,
755  .short_term_ref_pic_set_sps_flag = h->sh.short_term_ref_pic_set_sps_flag,
756  },
757  .sps_video_parameter_set_id = sps->vps_id,
758  .pps_seq_parameter_set_id = pps->sps_id,
759  .pps_pic_parameter_set_id = pps->pps_id,
760  .NumDeltaPocsOfRefRpsIdx = h->sh.short_term_rps ? h->sh.short_term_rps->rps_idx_num_delta_pocs : 0,
761  .PicOrderCntVal = h->poc,
762  .NumBitsForSTRefPicSetInSlice = !h->sh.short_term_ref_pic_set_sps_flag ?
763  h->sh.short_term_ref_pic_set_size : 0,
764  };
765 
766  /* Fill in references */
767  for (int i = 0; i < FF_ARRAY_ELEMS(l->DPB); i++) {
768  const HEVCFrame *ref = &l->DPB[i];
769  int idx = nb_refs;
770 
772  continue;
773 
774  if (ref == pic) {
775  err = vk_hevc_fill_pict(avctx, NULL, &vp->ref_slot, &vp->ref,
776  &hp->vkh265_ref, &hp->h265_ref, pic, 1, i);
777  if (err < 0)
778  return err;
779 
780  continue;
781  }
782 
783  err = vk_hevc_fill_pict(avctx, &hp->ref_src[idx], &vp->ref_slots[idx],
784  &vp->refs[idx], &hp->vkh265_refs[idx],
785  &hp->h265_refs[idx], (HEVCFrame *)ref, 0, i);
786  if (err < 0)
787  return err;
788 
789  nb_refs++;
790  }
791 
792  memset(hp->h265pic.RefPicSetStCurrBefore, 0xff, 8);
793  for (int i = 0; i < h->rps[ST_CURR_BEF].nb_refs; i++) {
794  HEVCFrame *frame = h->rps[ST_CURR_BEF].ref[i];
795  for (int j = 0; j < FF_ARRAY_ELEMS(l->DPB); j++) {
796  const HEVCFrame *ref = &l->DPB[j];
797  if (ref == frame) {
798  hp->h265pic.RefPicSetStCurrBefore[i] = j;
799  break;
800  }
801  }
802  }
803  memset(hp->h265pic.RefPicSetStCurrAfter, 0xff, 8);
804  for (int i = 0; i < h->rps[ST_CURR_AFT].nb_refs; i++) {
805  HEVCFrame *frame = h->rps[ST_CURR_AFT].ref[i];
806  for (int j = 0; j < FF_ARRAY_ELEMS(l->DPB); j++) {
807  const HEVCFrame *ref = &l->DPB[j];
808  if (ref == frame) {
809  hp->h265pic.RefPicSetStCurrAfter[i] = j;
810  break;
811  }
812  }
813  }
814  memset(hp->h265pic.RefPicSetLtCurr, 0xff, 8);
815  for (int i = 0; i < h->rps[LT_CURR].nb_refs; i++) {
816  HEVCFrame *frame = h->rps[LT_CURR].ref[i];
817  for (int j = 0; j < FF_ARRAY_ELEMS(l->DPB); j++) {
818  const HEVCFrame *ref = &l->DPB[j];
819  if (ref == frame) {
820  hp->h265pic.RefPicSetLtCurr[i] = j;
821  break;
822  }
823  }
824  }
825 
826  hp->h265_pic_info = (VkVideoDecodeH265PictureInfoKHR) {
827  .sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR,
828  .pStdPictureInfo = &hp->h265pic,
829  .sliceSegmentCount = 0,
830  };
831 
832  vp->decode_info = (VkVideoDecodeInfoKHR) {
833  .sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR,
834  .pNext = &hp->h265_pic_info,
835  .flags = 0x0,
836  .pSetupReferenceSlot = &vp->ref_slot,
837  .referenceSlotCount = nb_refs,
838  .pReferenceSlots = vp->ref_slots,
839  .dstPictureResource = (VkVideoPictureResourceInfoKHR) {
840  .sType = VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR,
841  .codedOffset = (VkOffset2D){ 0, 0 },
842  .codedExtent = (VkExtent2D){ pic->f->width, pic->f->height },
843  .baseArrayLayer = 0,
844  .imageViewBinding = vp->img_view_out,
845  },
846  };
847 
848  return 0;
849 }
850 
852  const uint8_t *data,
853  uint32_t size)
854 {
855  const HEVCContext *h = avctx->priv_data;
856  HEVCVulkanDecodePicture *hp = h->cur_frame->hwaccel_picture_private;
857  FFVulkanDecodePicture *vp = &hp->vp;
858 
859  int err = ff_vk_decode_add_slice(avctx, vp, data, size, 1,
860  &hp->h265_pic_info.sliceSegmentCount,
861  &hp->h265_pic_info.pSliceSegmentOffsets);
862  if (err < 0)
863  return err;
864 
865  return 0;
866 }
867 
869 {
870  const HEVCContext *h = avctx->priv_data;
872  HEVCFrame *pic = h->cur_frame;
874  FFVulkanDecodePicture *vp = &hp->vp;
875  FFVulkanDecodePicture *rvp[HEVC_MAX_REFS] = { 0 };
876  AVFrame *rav[HEVC_MAX_REFS] = { 0 };
877  int err;
878 
879  if (!hp->h265_pic_info.sliceSegmentCount)
880  return 0;
881 
882  if (!dec->session_params) {
883  const HEVCPPS *pps = h->pps;
884  const HEVCSPS *sps = pps->sps;
885 
886  if (!pps) {
887  unsigned int pps_id = h->sh.pps_id;
888  if (pps_id < HEVC_MAX_PPS_COUNT && h->ps.pps_list[pps_id] != NULL)
889  pps = h->ps.pps_list[pps_id];
890  }
891 
892  if (!pps) {
893  av_log(avctx, AV_LOG_ERROR,
894  "Encountered frame without a valid active PPS reference.\n");
895  return AVERROR_INVALIDDATA;
896  }
897 
898  err = vk_hevc_create_params(avctx, &dec->session_params);
899  if (err < 0)
900  return err;
901 
902  hp->h265pic.sps_video_parameter_set_id = sps->vps_id;
903  hp->h265pic.pps_seq_parameter_set_id = pps->sps_id;
904  hp->h265pic.pps_pic_parameter_set_id = pps->pps_id;
905  }
906 
907  for (int i = 0; i < vp->decode_info.referenceSlotCount; i++) {
909  rav[i] = hp->ref_src[i]->f;
910  rvp[i] = &rfhp->vp;
911  }
912 
913  av_log(avctx, AV_LOG_VERBOSE, "Decoding frame, %"SIZE_SPECIFIER" bytes, %i slices\n",
914  vp->slices_size, hp->h265_pic_info.sliceSegmentCount);
915 
916  return ff_vk_decode_frame(avctx, pic->f, vp, rav, rvp);
917 }
918 
920 {
921  AVHWDeviceContext *hwctx = _hwctx.nc;
923 
924  /* Free frame resources */
925  ff_vk_decode_free_frame(hwctx, &hp->vp);
926 }
927 
929  .p.name = "hevc_vulkan",
930  .p.type = AVMEDIA_TYPE_VIDEO,
931  .p.id = AV_CODEC_ID_HEVC,
932  .p.pix_fmt = AV_PIX_FMT_VULKAN,
933  .start_frame = &vk_hevc_start_frame,
934  .decode_slice = &vk_hevc_decode_slice,
935  .end_frame = &vk_hevc_end_frame,
936  .free_frame_priv = &vk_hevc_free_frame_priv,
937  .frame_priv_data_size = sizeof(HEVCVulkanDecodePicture),
940  .decode_params = &ff_vk_params_invalidate,
943  .frame_params = &ff_vk_frame_params,
944  .priv_data_size = sizeof(FFVulkanDecodeContext),
946 };
HEVCHeaderSPS::vui_header
StdVideoH265HrdParameters vui_header
Definition: vulkan_hevc.c:38
FFVulkanDecodePicture::slices_size
size_t slices_size
Definition: vulkan_decode.h:105
HEVCFrame::flags
uint8_t flags
A combination of HEVC_FRAME_FLAG_*.
Definition: hevcdec.h:378
HEVCHeaderSet::hvps
HEVCHeaderVPS * hvps
Definition: vulkan_hevc.c:74
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
HEVCHeaderSPS::dpbm
StdVideoH265DecPicBufMgr dpbm
Definition: vulkan_hevc.c:41
HEVCHeaderSPS::pal
StdVideoH265PredictorPaletteEntries pal
Definition: vulkan_hevc.c:42
HEVCHeaderVPSSet::nal_hdr
StdVideoH265SubLayerHrdParameters nal_hdr[HEVC_MAX_SUB_LAYERS]
Definition: vulkan_hevc.c:55
ShortTermRPS::num_negative_pics
uint8_t num_negative_pics
Definition: ps.h:78
HEVCHeaderVPS::sls
HEVCHeaderVPSSet * sls
Definition: vulkan_hevc.c:63
HEVCHeaderSPS::scaling
StdVideoH265ScalingLists scaling
Definition: vulkan_hevc.c:37
FFVulkanDecodeContext::shared_ctx
FFVulkanDecodeShared * shared_ctx
Definition: vulkan_decode.h:60
HEVCHeaderSet::hsps
HEVCHeaderSPS hsps[HEVC_MAX_SPS_COUNT]
Definition: vulkan_hevc.c:68
HEVCHeaderVPSSet
Definition: vulkan_hevc.c:54
av_unused
#define av_unused
Definition: attributes.h:131
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:374
AVFrame::width
int width
Definition: frame.h:446
HEVCFrame::hwaccel_picture_private
void * hwaccel_picture_private
RefStruct reference.
Definition: hevcdec.h:373
level_idc
int level_idc
Definition: h264_levels.c:29
vk_hevc_fill_pict
static int vk_hevc_fill_pict(AVCodecContext *avctx, HEVCFrame **ref_src, VkVideoReferenceSlotInfoKHR *ref_slot, VkVideoPictureResourceInfoKHR *ref, VkVideoDecodeH265DpbSlotInfoKHR *vkh265_ref, StdVideoDecodeH265ReferenceInfo *h265_ref, HEVCFrame *pic, int is_current, int pic_id)
Definition: vulkan_hevc.c:131
HEVCHeaderSPS::ltr
StdVideoH265LongTermRefPicsSps ltr
Definition: vulkan_hevc.c:46
data
const char data[16]
Definition: mxf.c:148
FFVulkanDecodeDescriptor::codec_id
enum AVCodecID codec_id
Definition: vulkan_decode.h:30
ff_hevc_vulkan_hwaccel
const FFHWAccel ff_hevc_vulkan_hwaccel
Definition: vulkan_hevc.c:928
ScalingList::sl
uint8_t sl[4][6][64]
Definition: ps.h:186
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
FFRefStructOpaque
RefStruct is an API for creating reference-counted objects with minimal overhead.
Definition: refstruct.h:58
vk_hevc_decode_slice
static int vk_hevc_decode_slice(AVCodecContext *avctx, const uint8_t *data, uint32_t size)
Definition: vulkan_hevc.c:851
alloc_hevc_header_structs
static int alloc_hevc_header_structs(FFVulkanDecodeContext *s, int nb_vps, const int vps_list_idx[HEVC_MAX_VPS_COUNT], const HEVCVPS *const vps_list[HEVC_MAX_VPS_COUNT])
Definition: vulkan_hevc.c:77
HEVCHdrParams
Definition: ps.h:50
FFVulkanDecodeContext
Definition: vulkan_decode.h:59
FF_VK_EXT_VIDEO_DECODE_H265
@ FF_VK_EXT_VIDEO_DECODE_H265
Definition: vulkan_functions.h:45
AV_PIX_FMT_VULKAN
@ AV_PIX_FMT_VULKAN
Vulkan hardware images.
Definition: pixfmt.h:379
vk_hevc_end_frame
static int vk_hevc_end_frame(AVCodecContext *avctx)
Definition: vulkan_hevc.c:868
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:141
FFVulkanDecodePicture::ref
VkVideoPictureResourceInfoKHR ref
Definition: vulkan_decode.h:93
FFVulkanDecodeContext::session_params
AVBufferRef * session_params
Definition: vulkan_decode.h:61
HEVC_MAX_SHORT_TERM_REF_PIC_SETS
@ HEVC_MAX_SHORT_TERM_REF_PIC_SETS
Definition: hevc.h:122
HEVC_FRAME_FLAG_LONG_REF
#define HEVC_FRAME_FLAG_LONG_REF
Definition: hevcdec.h:351
FFHWAccel
Definition: hwaccel_internal.h:34
HEVCVulkanDecodePicture::ref_src
HEVCFrame * ref_src[HEVC_MAX_REFS]
Definition: vulkan_hevc.c:122
HEVCHeaderPPS
Definition: vulkan_hevc.c:49
HWACCEL_CAP_THREAD_SAFE
#define HWACCEL_CAP_THREAD_SAFE
Definition: hwaccel_internal.h:32
HEVCHeaderSPS
Definition: vulkan_hevc.c:36
HEVCHeaderPPS::scaling
StdVideoH265ScalingLists scaling
Definition: vulkan_hevc.c:50
ff_hevc_diag_scan8x8_y
const uint8_t ff_hevc_diag_scan8x8_y[64]
Definition: data.c:58
HEVCHeaderVPS
Definition: vulkan_hevc.c:59
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:312
FFVulkanDecodeShared
Definition: vulkan_decode.h:46
vk_hevc_start_frame
static int vk_hevc_start_frame(AVCodecContext *avctx, av_unused const uint8_t *buffer, av_unused uint32_t size)
Definition: vulkan_hevc.c:729
AVHWDeviceContext
This struct aggregates all the (hardware/vendor-specific) "high-level" state, i.e.
Definition: hwcontext.h:60
HEVCHeaderSPS::nal_hdr
StdVideoH265SubLayerHrdParameters nal_hdr[HEVC_MAX_SUB_LAYERS]
Definition: vulkan_hevc.c:43
HEVCVulkanDecodePicture::vkh265_refs
VkVideoDecodeH265DpbSlotInfoKHR vkh265_refs[HEVC_MAX_REFS]
Definition: vulkan_hevc.c:124
FFVulkanDecodePicture::img_view_out
VkImageView img_view_out
Definition: vulkan_decode.h:84
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
FFVulkanDecodePicture::refs
VkVideoPictureResourceInfoKHR refs[36]
Definition: vulkan_decode.h:97
ptl
const H265RawProfileTierLevel * ptl
Definition: h265_levels.c:170
HEVCHeaderSet::hpps
HEVCHeaderPPS hpps[HEVC_MAX_PPS_COUNT]
Definition: vulkan_hevc.c:71
HEVCHeaderSPS::vui
StdVideoH265SequenceParameterSetVui vui
Definition: vulkan_hevc.c:39
s
#define s(width, name)
Definition: cbs_vp9.c:198
FFVulkanDecodePicture
Definition: vulkan_decode.h:80
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:1037
HEVCHeaderSet::pps
StdVideoH265PictureParameterSet pps[HEVC_MAX_PPS_COUNT]
Definition: vulkan_hevc.c:70
HEVC_MAX_SPS_COUNT
@ HEVC_MAX_SPS_COUNT
Definition: hevc.h:112
copy_scaling_list
static void copy_scaling_list(const ScalingList *sl, StdVideoH265ScalingLists *vksl)
Definition: vulkan_hevc.c:201
vk_hevc_free_frame_priv
static void vk_hevc_free_frame_priv(FFRefStructOpaque _hwctx, void *data)
Definition: vulkan_hevc.c:919
HEVCVulkanDecodePicture::h265_refs
StdVideoDecodeH265ReferenceInfo h265_refs[HEVC_MAX_REFS]
Definition: vulkan_hevc.c:123
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
ctx
AVFormatContext * ctx
Definition: movenc.c:49
IS_IDR
#define IS_IDR(s)
Definition: hevcdec.h:76
HEVC_FRAME_FLAG_SHORT_REF
#define HEVC_FRAME_FLAG_SHORT_REF
Definition: hevcdec.h:350
HEVCVulkanDecodePicture::h265_ref
StdVideoDecodeH265ReferenceInfo h265_ref
Definition: vulkan_hevc.c:118
ScalingList
Definition: ps.h:183
ff_hevc_diag_scan4x4_y
const uint8_t ff_hevc_diag_scan4x4_y[16]
Definition: data.c:32
HEVC_MAX_PPS_COUNT
@ HEVC_MAX_PPS_COUNT
Definition: hevc.h:114
HWACCEL_CAP_ASYNC_SAFE
#define HWACCEL_CAP_ASYNC_SAFE
Header providing the internals of AVHWAccel.
Definition: hwaccel_internal.h:31
set_sps
static void set_sps(const HEVCSPS *sps, int sps_idx, StdVideoH265ScalingLists *vksps_scaling, StdVideoH265HrdParameters *vksps_vui_header, StdVideoH265SequenceParameterSetVui *vksps_vui, StdVideoH265SequenceParameterSet *vksps, StdVideoH265SubLayerHrdParameters *slhdrnal, StdVideoH265SubLayerHrdParameters *slhdrvcl, StdVideoH265ProfileTierLevel *ptl, StdVideoH265DecPicBufMgr *dpbm, StdVideoH265PredictorPaletteEntries *pal, StdVideoH265ShortTermRefPicSet *str, StdVideoH265LongTermRefPicsSps *ltr)
Definition: vulkan_hevc.c:238
FFVulkanDecodePicture::img_view_ref
VkImageView img_view_ref
Definition: vulkan_decode.h:83
NULL
#define NULL
Definition: coverity.c:32
ScalingList::sl_dc
uint8_t sl_dc[2][6]
Definition: ps.h:187
HEVC_MAX_VPS_COUNT
@ HEVC_MAX_VPS_COUNT
Definition: hevc.h:110
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:543
HEVCVulkanDecodePicture
Definition: vulkan_hevc.c:114
AVCodecContext::internal
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:480
ff_vk_decode_uninit
int ff_vk_decode_uninit(AVCodecContext *avctx)
Free decoder.
Definition: vulkan_decode.c:1066
flush
void(* flush)(AVBSFContext *ctx)
Definition: dts2pts.c:370
vk_hevc_create_params
static int vk_hevc_create_params(AVCodecContext *avctx, AVBufferRef **buf)
Definition: vulkan_hevc.c:641
data.h
vps
static int FUNC() vps(CodedBitstreamContext *ctx, RWContext *rw, H265RawVPS *current)
Definition: cbs_h265_syntax_template.c:423
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:974
H265RawProfileTierLevel::general_tier_flag
uint8_t general_tier_flag
Definition: cbs_h265.h:38
HEVCVulkanDecodePicture::vp
FFVulkanDecodePicture vp
Definition: vulkan_hevc.c:115
ShortTermRPS::used
uint32_t used
Definition: ps.h:75
IS_IRAP
#define IS_IRAP(s)
Definition: hevcdec.h:79
HEVCHeaderVPSSet::vcl_hdr
StdVideoH265SubLayerHrdParameters vcl_hdr[HEVC_MAX_SUB_LAYERS]
Definition: vulkan_hevc.c:56
HEVCHeaderPPS::pal
StdVideoH265PredictorPaletteEntries pal
Definition: vulkan_hevc.c:51
HEVC_MAX_REFS
@ HEVC_MAX_REFS
Definition: hevc.h:119
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:368
set_pps
static void set_pps(const HEVCPPS *pps, const HEVCSPS *sps, StdVideoH265ScalingLists *vkpps_scaling, StdVideoH265PictureParameterSet *vkpps, StdVideoH265PredictorPaletteEntries *pal)
Definition: vulkan_hevc.c:471
HEVCHeaderSPS::ptl
StdVideoH265ProfileTierLevel ptl
Definition: vulkan_hevc.c:40
hevcdec.h
HEVCVulkanDecodePicture::h265pic
StdVideoDecodeH265PictureInfo h265pic
Definition: vulkan_hevc.c:127
convert_to_vk_level_idc
static StdVideoH265LevelIdc convert_to_vk_level_idc(int level_idc)
Definition: vulkan_hevc.c:182
AVCodecInternal::hwaccel_priv_data
void * hwaccel_priv_data
hwaccel-specific private data
Definition: internal.h:130
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
size
int size
Definition: twinvq_data.h:10344
FFRefStructOpaque::nc
void * nc
Definition: refstruct.h:59
ps.h
HEVCVulkanDecodePicture::vkh265_ref
VkVideoDecodeH265DpbSlotInfoKHR vkh265_ref
Definition: vulkan_hevc.c:119
av_zero_extend
#define av_zero_extend
Definition: common.h:151
HEVCHeaderSet
Definition: vulkan_hevc.c:66
AVHWAccel::name
const char * name
Name of the hardware accelerated codec.
Definition: avcodec.h:2099
HEVC_MAX_SUB_LAYERS
@ HEVC_MAX_SUB_LAYERS
Definition: hevc.h:105
uninit
static void uninit(AVBSFContext *ctx)
Definition: pcm_rechunk.c:68
set_vps
static void set_vps(const HEVCVPS *vps, StdVideoH265VideoParameterSet *vkvps, StdVideoH265ProfileTierLevel *ptl, StdVideoH265DecPicBufMgr *dpbm, StdVideoH265HrdParameters *sls_hdr, HEVCHeaderVPSSet sls[])
Definition: vulkan_hevc.c:559
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
HEVCFrame
Definition: hevcdec.h:354
HEVCLayerContext
Definition: hevcdec.h:442
AV_CODEC_ID_HEVC
@ AV_CODEC_ID_HEVC
Definition: codec_id.h:226
FFVulkanDecodePicture::ref_slot
VkVideoReferenceSlotInfoKHR ref_slot
Definition: vulkan_decode.h:94
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:256
FFVulkanDecodePicture::ref_slots
VkVideoReferenceSlotInfoKHR ref_slots[36]
Definition: vulkan_decode.h:98
ff_hevc_diag_scan4x4_x
const uint8_t ff_hevc_diag_scan4x4_x[16]
Definition: data.c:25
HEVCFrame::poc
int poc
Definition: hevcdec.h:367
HEVCFrame::f
AVFrame * f
Definition: hevcdec.h:357
ff_vk_decode_flush
void ff_vk_decode_flush(AVCodecContext *avctx)
Flush decoder.
Definition: vulkan_decode.c:276
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
HEVCHeaderSPS::str
StdVideoH265ShortTermRefPicSet str[HEVC_MAX_SHORT_TERM_REF_PIC_SETS]
Definition: vulkan_hevc.c:45
ST_CURR_BEF
@ ST_CURR_BEF
Definition: hevcdec.h:82
HEVCVulkanDecodePicture::h265_pic_info
VkVideoDecodeH265PictureInfoKHR h265_pic_info
Definition: vulkan_hevc.c:128
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:205
HEVCHeaderVPS::dpbm
StdVideoH265DecPicBufMgr dpbm
Definition: vulkan_hevc.c:61
pos
unsigned int pos
Definition: spdifenc.c:414
HEVCHeaderVPS::hdr
StdVideoH265HrdParameters hdr[HEVC_MAX_LAYER_SETS]
Definition: vulkan_hevc.c:62
FFVulkanDecodeContext::hevc_headers
struct HEVCHeaderSet * hevc_headers
Definition: vulkan_decode.h:73
SIZE_SPECIFIER
#define SIZE_SPECIFIER
Definition: internal.h:129
HEVC_MAX_LAYER_SETS
@ HEVC_MAX_LAYER_SETS
Definition: hevc.h:107
ff_vk_dec_hevc_desc
const FFVulkanDecodeDescriptor ff_vk_dec_hevc_desc
Definition: vulkan_hevc.c:26
LT_CURR
@ LT_CURR
Definition: hevcdec.h:85
AVCodecContext
main external API structure.
Definition: avcodec.h:445
AVFrame::height
int height
Definition: frame.h:446
FFVulkanDecodeContext::dedicated_dpb
int dedicated_dpb
Definition: vulkan_decode.h:64
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
HEVCContext
Definition: hevcdec.h:479
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
HEVCLayerContext::DPB
HEVCFrame DPB[32]
Definition: hevcdec.h:443
FFVulkanDecodeDescriptor
Definition: vulkan_decode.h:29
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:112
pps
uint64_t pps
Definition: dovi_rpuenc.c:35
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:120
ShortTermRPS
Definition: ps.h:73
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:80
ff_hevc_diag_scan8x8_x
const uint8_t ff_hevc_diag_scan8x8_x[64]
Definition: data.c:39
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
mem.h
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
HEVCVPS
Definition: ps.h:156
HEVCSPS
Definition: ps.h:190
HEVCPPS
Definition: ps.h:309
vulkan_decode.h
ST_CURR_AFT
@ ST_CURR_AFT
Definition: hevcdec.h:83
HEVCPPS::sps_id
unsigned int sps_id
seq_parameter_set_id
Definition: ps.h:311
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
HEVCHeaderSPS::vcl_hdr
StdVideoH265SubLayerHrdParameters vcl_hdr[HEVC_MAX_SUB_LAYERS]
Definition: vulkan_hevc.c:44
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
ff_vk_decode_init
int ff_vk_decode_init(AVCodecContext *avctx)
Initialize decoder.
Definition: vulkan_decode.c:1081
ShortTermRPS::delta_poc
int32_t delta_poc[32]
Definition: ps.h:74
h
h
Definition: vp9dsp_template.c:2070
FFVulkanDecodePicture::decode_info
VkVideoDecodeInfoKHR decode_info
Definition: vulkan_decode.h:101
HEVCHeaderSet::vps
StdVideoH265VideoParameterSet vps[HEVC_MAX_PPS_COUNT]
Definition: vulkan_hevc.c:73
src
#define src
Definition: vp8dsp.c:248
HEVCHeaderVPS::ptl
StdVideoH265ProfileTierLevel ptl
Definition: vulkan_hevc.c:60
HEVCHeaderSet::sps
StdVideoH265SequenceParameterSet sps[HEVC_MAX_SPS_COUNT]
Definition: vulkan_hevc.c:67