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