FFmpeg: libavcodec/vulkan_av1.c Source File

FFmpeg
vulkan_av1.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 "av1dec.h"
20 
21 #include "vulkan_decode.h"
22 
23 /* Maximum number of tiles specified by any defined level */
24  #define MAX_TILES 256
25 
26  const FFVulkanDecodeDescriptor ff_vk_dec_av1_desc = {
27  .codec_id = AV_CODEC_ID_AV1,
28  .decode_extension = FF_VK_EXT_VIDEO_DECODE_AV1,
29  .decode_op = VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR,
30  .ext_props = {
31  .extensionName = VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_EXTENSION_NAME,
32  .specVersion = VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_SPEC_VERSION,
33  },
34 };
35 
36  typedef struct AV1VulkanDecodePicture {
37   FFVulkanDecodePicture vp;
38 
39  /* TODO: investigate if this can be removed to make decoding completely
40  * independent. */
41   FFVulkanDecodeContext *dec;
42 
43   uint32_t tile_sizes[MAX_TILES];
44 
45  /* Current picture */
46   StdVideoDecodeAV1ReferenceInfo std_ref;
47   VkVideoDecodeAV1DpbSlotInfoKHR vkav1_ref;
48   uint16_t width_in_sbs_minus1[64];
49   uint16_t height_in_sbs_minus1[64];
50   uint16_t mi_col_starts[64];
51   uint16_t mi_row_starts[64];
52   StdVideoAV1TileInfo tile_info;
53   StdVideoAV1Quantization quantization;
54   StdVideoAV1Segmentation segmentation;
55   StdVideoAV1LoopFilter loop_filter;
56   StdVideoAV1CDEF cdef;
57   StdVideoAV1LoopRestoration loop_restoration;
58   StdVideoAV1GlobalMotion global_motion;
59   StdVideoAV1FilmGrain film_grain;
60   StdVideoDecodeAV1PictureInfo std_pic_info;
61   VkVideoDecodeAV1PictureInfoKHR av1_pic_info;
62 
63  /* Picture refs */
64   const AV1Frame *ref_src [AV1_NUM_REF_FRAMES];
65   StdVideoDecodeAV1ReferenceInfo std_refs [AV1_NUM_REF_FRAMES];
66   VkVideoDecodeAV1DpbSlotInfoKHR vkav1_refs[AV1_NUM_REF_FRAMES];
67 
68   uint8_t frame_id_set;
69   uint8_t frame_id;
70   uint8_t ref_frame_sign_bias_mask;
71 } AV1VulkanDecodePicture;
72 
73  static int vk_av1_fill_pict(AVCodecContext *avctx, const AV1Frame **ref_src,
74  VkVideoReferenceSlotInfoKHR *ref_slot, /* Main structure */
75  VkVideoPictureResourceInfoKHR *ref, /* Goes in ^ */
76  StdVideoDecodeAV1ReferenceInfo *vkav1_std_ref,
77  VkVideoDecodeAV1DpbSlotInfoKHR *vkav1_ref, /* Goes in ^ */
78  const AV1Frame *pic, int is_current, int has_grain,
79  const uint8_t *saved_order_hints)
80 {
81  FFVulkanDecodeContext *dec = avctx->internal->hwaccel_priv_data;
82  FFVulkanDecodeShared *ctx = dec->shared_ctx;
83  AV1VulkanDecodePicture *hp = pic->hwaccel_picture_private;
84  FFVulkanDecodePicture *vkpic = &hp->vp;
85 
86  int err = ff_vk_decode_prepare_frame(dec, pic->f, vkpic, is_current,
87  has_grain || dec->dedicated_dpb);
88  if (err < 0)
89  return err;
90 
91  *vkav1_std_ref = (StdVideoDecodeAV1ReferenceInfo) {
92  .flags = (StdVideoDecodeAV1ReferenceInfoFlags) {
93  .disable_frame_end_update_cdf = pic->raw_frame_header->disable_frame_end_update_cdf,
94  .segmentation_enabled = pic->raw_frame_header->segmentation_enabled,
95  },
96  .frame_type = pic->raw_frame_header->frame_type,
97  .OrderHint = pic->raw_frame_header->order_hint,
98  .RefFrameSignBias = hp->ref_frame_sign_bias_mask,
99  };
100 
101  if (saved_order_hints) {
102  if (dec->quirk_av1_offset)
103  for (int i = 1; i < STD_VIDEO_AV1_TOTAL_REFS_PER_FRAME; i++)
104  vkav1_std_ref->SavedOrderHints[i - 1] = saved_order_hints[i];
105  else
106  for (int i = 0; i < STD_VIDEO_AV1_TOTAL_REFS_PER_FRAME; i++)
107  vkav1_std_ref->SavedOrderHints[i] = saved_order_hints[i];
108  }
109 
110  *vkav1_ref = (VkVideoDecodeAV1DpbSlotInfoKHR) {
111  .sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR,
112  .pStdReferenceInfo = vkav1_std_ref,
113  };
114 
115  vkav1_std_ref->flags.disable_frame_end_update_cdf = pic->raw_frame_header->disable_frame_end_update_cdf;
116  vkav1_std_ref->flags.segmentation_enabled = pic->raw_frame_header->segmentation_enabled;
117  vkav1_std_ref->frame_type = pic->raw_frame_header->frame_type;
118 
119  *ref = (VkVideoPictureResourceInfoKHR) {
120  .sType = VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR,
121  .codedOffset = (VkOffset2D){ 0, 0 },
122  .codedExtent = (VkExtent2D){ pic->f->width, pic->f->height },
123  .baseArrayLayer = ((has_grain || dec->dedicated_dpb) && ctx->common.layered_dpb) ?
124  hp->frame_id : 0,
125  .imageViewBinding = vkpic->img_view_ref,
126  };
127 
128  *ref_slot = (VkVideoReferenceSlotInfoKHR) {
129  .sType = VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR,
130  .pNext = vkav1_ref,
131  .slotIndex = hp->frame_id,
132  .pPictureResource = ref,
133  };
134 
135  if (ref_src)
136  *ref_src = pic;
137 
138  return 0;
139 }
140 
141  static int vk_av1_create_params(AVCodecContext *avctx, AVBufferRef **buf)
142 {
143  const AV1DecContext *s = avctx->priv_data;
144  FFVulkanDecodeContext *dec = avctx->internal->hwaccel_priv_data;
145  FFVulkanDecodeShared *ctx = dec->shared_ctx;
146 
147  const AV1RawSequenceHeader *seq = s->raw_seq;
148 
149  StdVideoAV1SequenceHeader av1_sequence_header;
150  StdVideoAV1TimingInfo av1_timing_info;
151  StdVideoAV1ColorConfig av1_color_config;
152  VkVideoDecodeAV1SessionParametersCreateInfoKHR av1_params;
153  VkVideoSessionParametersCreateInfoKHR session_params_create;
154 
155  int err;
156 
157  av1_timing_info = (StdVideoAV1TimingInfo) {
158  .flags = (StdVideoAV1TimingInfoFlags) {
159  .equal_picture_interval = seq->timing_info.equal_picture_interval,
160  },
161  .num_units_in_display_tick = seq->timing_info.num_units_in_display_tick,
162  .time_scale = seq->timing_info.time_scale,
163  .num_ticks_per_picture_minus_1 = seq->timing_info.num_ticks_per_picture_minus_1,
164  };
165 
166  av1_color_config = (StdVideoAV1ColorConfig) {
167  .flags = (StdVideoAV1ColorConfigFlags) {
168  .mono_chrome = seq->color_config.mono_chrome,
169  .color_range = seq->color_config.color_range,
170  .separate_uv_delta_q = seq->color_config.separate_uv_delta_q,
171  },
172  .BitDepth = seq->color_config.twelve_bit ? 12 :
173  seq->color_config.high_bitdepth ? 10 : 8,
174  .subsampling_x = seq->color_config.subsampling_x,
175  .subsampling_y = seq->color_config.subsampling_y,
176  .color_primaries = seq->color_config.color_primaries,
177  .transfer_characteristics = seq->color_config.transfer_characteristics,
178  .matrix_coefficients = seq->color_config.matrix_coefficients,
179  };
180 
181  av1_sequence_header = (StdVideoAV1SequenceHeader) {
182  .flags = (StdVideoAV1SequenceHeaderFlags) {
183  .still_picture = seq->still_picture,
184  .reduced_still_picture_header = seq->reduced_still_picture_header,
185  .use_128x128_superblock = seq->use_128x128_superblock,
186  .enable_filter_intra = seq->enable_filter_intra,
187  .enable_intra_edge_filter = seq->enable_intra_edge_filter,
188  .enable_interintra_compound = seq->enable_interintra_compound,
189  .enable_masked_compound = seq->enable_masked_compound,
190  .enable_warped_motion = seq->enable_warped_motion,
191  .enable_dual_filter = seq->enable_dual_filter,
192  .enable_order_hint = seq->enable_order_hint,
193  .enable_jnt_comp = seq->enable_jnt_comp,
194  .enable_ref_frame_mvs = seq->enable_ref_frame_mvs,
195  .frame_id_numbers_present_flag = seq->frame_id_numbers_present_flag,
196  .enable_superres = seq->enable_superres,
197  .enable_cdef = seq->enable_cdef,
198  .enable_restoration = seq->enable_restoration,
199  .film_grain_params_present = seq->film_grain_params_present,
200  .timing_info_present_flag = seq->timing_info_present_flag,
201  .initial_display_delay_present_flag = seq->initial_display_delay_present_flag,
202  },
203  .seq_profile = seq->seq_profile,
204  .frame_width_bits_minus_1 = seq->frame_width_bits_minus_1,
205  .frame_height_bits_minus_1 = seq->frame_height_bits_minus_1,
206  .max_frame_width_minus_1 = seq->max_frame_width_minus_1,
207  .max_frame_height_minus_1 = seq->max_frame_height_minus_1,
208  .delta_frame_id_length_minus_2 = seq->delta_frame_id_length_minus_2,
209  .additional_frame_id_length_minus_1 = seq->additional_frame_id_length_minus_1,
210  .order_hint_bits_minus_1 = seq->order_hint_bits_minus_1,
211  .seq_force_integer_mv = seq->seq_force_integer_mv,
212  .seq_force_screen_content_tools = seq->seq_force_screen_content_tools,
213  .pTimingInfo = &av1_timing_info,
214  .pColorConfig = &av1_color_config,
215  };
216 
217  av1_params = (VkVideoDecodeAV1SessionParametersCreateInfoKHR) {
218  .sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR,
219  .pStdSequenceHeader = &av1_sequence_header,
220  };
221  session_params_create = (VkVideoSessionParametersCreateInfoKHR) {
222  .sType = VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR,
223  .pNext = &av1_params,
224  .videoSession = ctx->common.session,
225  .videoSessionParametersTemplate = VK_NULL_HANDLE,
226  };
227 
228  err = ff_vk_decode_create_params(buf, avctx, ctx, &session_params_create);
229  if (err < 0)
230  return err;
231 
232  av_log(avctx, AV_LOG_DEBUG, "Created frame parameters\n");
233 
234  return 0;
235 }
236 
237  static int vk_av1_start_frame(AVCodecContext *avctx,
238  av_unused const uint8_t *buffer,
239  av_unused uint32_t size)
240 {
241  int err;
242  int ref_count = 0;
243  AV1DecContext *s = avctx->priv_data;
244  const AV1Frame *pic = &s->cur_frame;
245  FFVulkanDecodeContext *dec = avctx->internal->hwaccel_priv_data;
246  AV1VulkanDecodePicture *ap = pic->hwaccel_picture_private;
247  FFVulkanDecodePicture *vp = &ap->vp;
248 
249  const AV1RawFrameHeader *frame_header = s->raw_frame_header;
250  const AV1RawFilmGrainParams *film_grain = &s->cur_frame.film_grain;
251 
252  const int apply_grain = !(avctx->export_side_data & AV_CODEC_EXPORT_DATA_FILM_GRAIN) &&
253  film_grain->apply_grain;
254  StdVideoAV1FrameRestorationType remap_lr_type[4] = { STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_NONE,
255  STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_SWITCHABLE,
256  STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_WIENER,
257  STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_SGRPROJ };
258 
259  if (!dec->session_params) {
260  err = vk_av1_create_params(avctx, &dec->session_params);
261  if (err < 0)
262  return err;
263  }
264 
265  if (!ap->frame_id_set) {
266  unsigned slot_idx = 0;
267  for (unsigned i = 0; i < 32; i++) {
268  if (!(dec->frame_id_alloc_mask & (1 << i))) {
269  slot_idx = i;
270  break;
271  }
272  }
273  ap->frame_id = slot_idx;
274  ap->frame_id_set = 1;
275  dec->frame_id_alloc_mask |= (1 << slot_idx);
276  }
277 
278  ap->ref_frame_sign_bias_mask = 0x0;
279  for (int i = 0; i < STD_VIDEO_AV1_TOTAL_REFS_PER_FRAME; i++)
280  ap->ref_frame_sign_bias_mask |= pic->ref_frame_sign_bias[i] << i;
281 
282  for (int i = 0; i < STD_VIDEO_AV1_REFS_PER_FRAME; i++) {
283  const int idx = pic->raw_frame_header->ref_frame_idx[i];
284  const AV1Frame *ref_frame = &s->ref[idx];
285  AV1VulkanDecodePicture *hp = ref_frame->hwaccel_picture_private;
286  int found = 0;
287 
288  if (!ref_frame->f)
289  continue;
290 
291  for (int j = 0; j < ref_count; j++) {
292  if (vp->ref_slots[j].slotIndex == hp->frame_id) {
293  found = 1;
294  break;
295  }
296  }
297  if (found)
298  continue;
299 
300  err = vk_av1_fill_pict(avctx, &ap->ref_src[ref_count], &vp->ref_slots[ref_count],
301  &vp->refs[ref_count], &ap->std_refs[ref_count], &ap->vkav1_refs[ref_count],
302  ref_frame, 0, 0, ref_frame->order_hints);
303  if (err < 0)
304  return err;
305 
306  ref_count++;
307  }
308 
309  err = vk_av1_fill_pict(avctx, NULL, &vp->ref_slot, &vp->ref,
310  &ap->std_ref,
311  &ap->vkav1_ref,
312  pic, 1, apply_grain, NULL);
313  if (err < 0)
314  return err;
315 
316  ap->av1_pic_info = (VkVideoDecodeAV1PictureInfoKHR) {
317  .sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR,
318  .pStdPictureInfo = &ap->std_pic_info,
319  .frameHeaderOffset = 0,
320  .tileCount = 0,
321  .pTileOffsets = NULL,
322  .pTileSizes = ap->tile_sizes,
323  };
324 
325  for (int i = 0; i < STD_VIDEO_AV1_REFS_PER_FRAME; i++) {
326  const int idx = pic->raw_frame_header->ref_frame_idx[i];
327  const AV1Frame *ref_frame = &s->ref[idx];
328  AV1VulkanDecodePicture *hp = ref_frame->hwaccel_picture_private;
329 
330  if (!ref_frame->f)
331  ap->av1_pic_info.referenceNameSlotIndices[i] = AV1_REF_FRAME_NONE;
332  else
333  ap->av1_pic_info.referenceNameSlotIndices[i] = hp->frame_id;
334  }
335 
336  vp->decode_info = (VkVideoDecodeInfoKHR) {
337  .sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR,
338  .pNext = &ap->av1_pic_info,
339  .flags = 0x0,
340  .pSetupReferenceSlot = &vp->ref_slot,
341  .referenceSlotCount = ref_count,
342  .pReferenceSlots = vp->ref_slots,
343  .dstPictureResource = (VkVideoPictureResourceInfoKHR) {
344  .sType = VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR,
345  .codedOffset = (VkOffset2D){ 0, 0 },
346  .codedExtent = (VkExtent2D){ pic->f->width, pic->f->height },
347  .baseArrayLayer = 0,
348  .imageViewBinding = vp->img_view_out,
349  },
350  };
351 
352  ap->tile_info = (StdVideoAV1TileInfo) {
353  .flags = (StdVideoAV1TileInfoFlags) {
354  .uniform_tile_spacing_flag = frame_header->uniform_tile_spacing_flag,
355  },
356  .TileCols = frame_header->tile_cols,
357  .TileRows = frame_header->tile_rows,
358  .context_update_tile_id = frame_header->context_update_tile_id,
359  .tile_size_bytes_minus_1 = frame_header->tile_size_bytes_minus1,
360  .pWidthInSbsMinus1 = ap->width_in_sbs_minus1,
361  .pHeightInSbsMinus1 = ap->height_in_sbs_minus1,
362  .pMiColStarts = ap->mi_col_starts,
363  .pMiRowStarts = ap->mi_row_starts,
364  };
365 
366  ap->quantization = (StdVideoAV1Quantization) {
367  .flags.using_qmatrix = frame_header->using_qmatrix,
368  .flags.diff_uv_delta = frame_header->diff_uv_delta,
369  .base_q_idx = frame_header->base_q_idx,
370  .DeltaQYDc = frame_header->delta_q_y_dc,
371  .DeltaQUDc = frame_header->delta_q_u_dc,
372  .DeltaQUAc = frame_header->delta_q_u_ac,
373  .DeltaQVDc = frame_header->delta_q_v_dc,
374  .DeltaQVAc = frame_header->delta_q_v_ac,
375  .qm_y = frame_header->qm_y,
376  .qm_u = frame_header->qm_u,
377  .qm_v = frame_header->qm_v,
378  };
379 
380  ap->loop_filter = (StdVideoAV1LoopFilter) {
381  .flags = (StdVideoAV1LoopFilterFlags) {
382  .loop_filter_delta_enabled = frame_header->loop_filter_delta_enabled,
383  .loop_filter_delta_update = frame_header->loop_filter_delta_update,
384  },
385  .loop_filter_sharpness = frame_header->loop_filter_sharpness,
386  };
387 
388  for (int i = 0; i < STD_VIDEO_AV1_MAX_LOOP_FILTER_STRENGTHS; i++)
389  ap->loop_filter.loop_filter_level[i] = frame_header->loop_filter_level[i];
390  for (int i = 0; i < STD_VIDEO_AV1_LOOP_FILTER_ADJUSTMENTS; i++)
391  ap->loop_filter.loop_filter_mode_deltas[i] = frame_header->loop_filter_mode_deltas[i];
392 
393  ap->cdef = (StdVideoAV1CDEF) {
394  .cdef_damping_minus_3 = frame_header->cdef_damping_minus_3,
395  .cdef_bits = frame_header->cdef_bits,
396  };
397 
398  ap->loop_restoration = (StdVideoAV1LoopRestoration) {
399  .FrameRestorationType[0] = remap_lr_type[frame_header->lr_type[0]],
400  .FrameRestorationType[1] = remap_lr_type[frame_header->lr_type[1]],
401  .FrameRestorationType[2] = remap_lr_type[frame_header->lr_type[2]],
402  .LoopRestorationSize[0] = 1 + frame_header->lr_unit_shift,
403  .LoopRestorationSize[1] = 1 + frame_header->lr_unit_shift - frame_header->lr_uv_shift,
404  .LoopRestorationSize[2] = 1 + frame_header->lr_unit_shift - frame_header->lr_uv_shift,
405  };
406 
407  ap->film_grain = (StdVideoAV1FilmGrain) {
408  .flags = (StdVideoAV1FilmGrainFlags) {
409  .chroma_scaling_from_luma = film_grain->chroma_scaling_from_luma,
410  .overlap_flag = film_grain->overlap_flag,
411  .clip_to_restricted_range = film_grain->clip_to_restricted_range,
412  },
413  .grain_scaling_minus_8 = film_grain->grain_scaling_minus_8,
414  .ar_coeff_lag = film_grain->ar_coeff_lag,
415  .ar_coeff_shift_minus_6 = film_grain->ar_coeff_shift_minus_6,
416  .grain_scale_shift = film_grain->grain_scale_shift,
417  .grain_seed = film_grain->grain_seed,
418  .film_grain_params_ref_idx = film_grain->film_grain_params_ref_idx,
419  .num_y_points = film_grain->num_y_points,
420  .num_cb_points = film_grain->num_cb_points,
421  .num_cr_points = film_grain->num_cr_points,
422  .cb_mult = film_grain->cb_mult,
423  .cb_luma_mult = film_grain->cb_luma_mult,
424  .cb_offset = film_grain->cb_offset,
425  .cr_mult = film_grain->cr_mult,
426  .cr_luma_mult = film_grain->cr_luma_mult,
427  .cr_offset = film_grain->cr_offset,
428  };
429 
430  /* Setup frame header */
431  ap->std_pic_info = (StdVideoDecodeAV1PictureInfo) {
432  .flags = (StdVideoDecodeAV1PictureInfoFlags) {
433  .error_resilient_mode = frame_header->error_resilient_mode,
434  .disable_cdf_update = frame_header->disable_cdf_update,
435  .use_superres = frame_header->use_superres,
436  .render_and_frame_size_different = frame_header->render_and_frame_size_different,
437  .allow_screen_content_tools = frame_header->allow_screen_content_tools,
438  .is_filter_switchable = frame_header->is_filter_switchable,
439  .force_integer_mv = pic->force_integer_mv,
440  .frame_size_override_flag = frame_header->frame_size_override_flag,
441  .buffer_removal_time_present_flag = frame_header->buffer_removal_time_present_flag,
442  .allow_intrabc = frame_header->allow_intrabc,
443  .frame_refs_short_signaling = frame_header->frame_refs_short_signaling,
444  .allow_high_precision_mv = frame_header->allow_high_precision_mv,
445  .is_motion_mode_switchable = frame_header->is_motion_mode_switchable,
446  .use_ref_frame_mvs = frame_header->use_ref_frame_mvs,
447  .disable_frame_end_update_cdf = frame_header->disable_frame_end_update_cdf,
448  .allow_warped_motion = frame_header->allow_warped_motion,
449  .reduced_tx_set = frame_header->reduced_tx_set,
450  .reference_select = frame_header->reference_select,
451  .skip_mode_present = frame_header->skip_mode_present,
452  .delta_q_present = frame_header->delta_q_present,
453  .delta_lf_present = frame_header->delta_lf_present,
454  .delta_lf_multi = frame_header->delta_lf_multi,
455  .segmentation_enabled = frame_header->segmentation_enabled,
456  .segmentation_update_map = frame_header->segmentation_update_map,
457  .segmentation_temporal_update = frame_header->segmentation_temporal_update,
458  .segmentation_update_data = frame_header->segmentation_update_data,
459  .UsesLr = frame_header->lr_type[0] || frame_header->lr_type[1] || frame_header->lr_type[2],
460  .apply_grain = apply_grain,
461  },
462  .frame_type = frame_header->frame_type,
463  .current_frame_id = frame_header->current_frame_id,
464  .OrderHint = frame_header->order_hint,
465  .primary_ref_frame = frame_header->primary_ref_frame,
466  .refresh_frame_flags = frame_header->refresh_frame_flags,
467  .interpolation_filter = frame_header->interpolation_filter,
468  .TxMode = frame_header->tx_mode,
469  .delta_q_res = frame_header->delta_q_res,
470  .delta_lf_res = frame_header->delta_lf_res,
471  .SkipModeFrame[0] = s->cur_frame.skip_mode_frame_idx[0],
472  .SkipModeFrame[1] = s->cur_frame.skip_mode_frame_idx[1],
473  .coded_denom = frame_header->coded_denom,
474  .pTileInfo = &ap->tile_info,
475  .pQuantization = &ap->quantization,
476  .pSegmentation = &ap->segmentation,
477  .pLoopFilter = &ap->loop_filter,
478  .pCDEF = &ap->cdef,
479  .pLoopRestoration = &ap->loop_restoration,
480  .pGlobalMotion = &ap->global_motion,
481  .pFilmGrain = apply_grain ? &ap->film_grain : NULL,
482  };
483 
484  for (int i = 0; i < 64; i++) {
485  ap->width_in_sbs_minus1[i] = frame_header->width_in_sbs_minus_1[i];
486  ap->height_in_sbs_minus1[i] = frame_header->height_in_sbs_minus_1[i];
487  ap->mi_col_starts[i] = frame_header->tile_start_col_sb[i];
488  ap->mi_row_starts[i] = frame_header->tile_start_row_sb[i];
489  }
490 
491  for (int i = 0; i < STD_VIDEO_AV1_MAX_SEGMENTS; i++) {
492  ap->segmentation.FeatureEnabled[i] = 0x0;
493  for (int j = 0; j < STD_VIDEO_AV1_SEG_LVL_MAX; j++) {
494  ap->segmentation.FeatureEnabled[i] |= (frame_header->feature_enabled[i][j] << j);
495  ap->segmentation.FeatureData[i][j] = frame_header->feature_value[i][j];
496  }
497  }
498 
499  if (dec->quirk_av1_offset)
500  for (int i = 1; i < STD_VIDEO_AV1_TOTAL_REFS_PER_FRAME; i++)
501  ap->std_pic_info.OrderHints[i - 1] = pic->order_hints[i];
502  else
503  for (int i = 0; i < STD_VIDEO_AV1_TOTAL_REFS_PER_FRAME; i++)
504  ap->std_pic_info.OrderHints[i] = pic->order_hints[i];
505 
506  for (int i = 0; i < STD_VIDEO_AV1_TOTAL_REFS_PER_FRAME; i++) {
507  ap->loop_filter.loop_filter_ref_deltas[i] = frame_header->loop_filter_ref_deltas[i];
508  ap->global_motion.GmType[i] = s->cur_frame.gm_type[i];
509  for (int j = 0; j < STD_VIDEO_AV1_GLOBAL_MOTION_PARAMS; j++) {
510  ap->global_motion.gm_params[i][j] = s->cur_frame.gm_params[i][j];
511  }
512  }
513 
514  for (int i = 0; i < STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS; i++) {
515  ap->cdef.cdef_y_pri_strength[i] = frame_header->cdef_y_pri_strength[i];
516  ap->cdef.cdef_y_sec_strength[i] = frame_header->cdef_y_sec_strength[i];
517  ap->cdef.cdef_uv_pri_strength[i] = frame_header->cdef_uv_pri_strength[i];
518  ap->cdef.cdef_uv_sec_strength[i] = frame_header->cdef_uv_sec_strength[i];
519  }
520 
521  if (apply_grain) {
522  for (int i = 0; i < STD_VIDEO_AV1_MAX_NUM_Y_POINTS; i++) {
523  ap->film_grain.point_y_value[i] = film_grain->point_y_value[i];
524  ap->film_grain.point_y_scaling[i] = film_grain->point_y_scaling[i];
525  }
526 
527  for (int i = 0; i < STD_VIDEO_AV1_MAX_NUM_CB_POINTS; i++) {
528  ap->film_grain.point_cb_value[i] = film_grain->point_cb_value[i];
529  ap->film_grain.point_cb_scaling[i] = film_grain->point_cb_scaling[i];
530  ap->film_grain.point_cr_value[i] = film_grain->point_cr_value[i];
531  ap->film_grain.point_cr_scaling[i] = film_grain->point_cr_scaling[i];
532  }
533 
534  for (int i = 0; i < STD_VIDEO_AV1_MAX_NUM_POS_LUMA; i++)
535  ap->film_grain.ar_coeffs_y_plus_128[i] = film_grain->ar_coeffs_y_plus_128[i];
536 
537  for (int i = 0; i < STD_VIDEO_AV1_MAX_NUM_POS_CHROMA; i++) {
538  ap->film_grain.ar_coeffs_cb_plus_128[i] = film_grain->ar_coeffs_cb_plus_128[i];
539  ap->film_grain.ar_coeffs_cr_plus_128[i] = film_grain->ar_coeffs_cr_plus_128[i];
540  }
541  }
542 
543  ap->dec = dec;
544 
545  return 0;
546 }
547 
548  static int vk_av1_decode_slice(AVCodecContext *avctx,
549  const uint8_t *data,
550  uint32_t size)
551 {
552  int err;
553  const AV1DecContext *s = avctx->priv_data;
554  AV1VulkanDecodePicture *ap = s->cur_frame.hwaccel_picture_private;
555  FFVulkanDecodePicture *vp = &ap->vp;
556 
557  /* Too many tiles, exceeding all defined levels in the AV1 spec */
558  if (ap->av1_pic_info.tileCount > MAX_TILES)
559  return AVERROR(ENOSYS);
560 
561  for (int i = s->tg_start; i <= s->tg_end; i++) {
562  ap->tile_sizes[ap->av1_pic_info.tileCount] = s->tile_group_info[i].tile_size;
563 
564  err = ff_vk_decode_add_slice(avctx, vp,
565  data + s->tile_group_info[i].tile_offset,
566  s->tile_group_info[i].tile_size, 0,
567  &ap->av1_pic_info.tileCount,
568  &ap->av1_pic_info.pTileOffsets);
569  if (err < 0)
570  return err;
571  }
572 
573  return 0;
574 }
575 
576  static int vk_av1_end_frame(AVCodecContext *avctx)
577 {
578  const AV1DecContext *s = avctx->priv_data;
579  FFVulkanDecodeContext *dec = avctx->internal->hwaccel_priv_data;
580  const AV1Frame *pic = &s->cur_frame;
581  AV1VulkanDecodePicture *ap = pic->hwaccel_picture_private;
582  FFVulkanDecodePicture *vp = &ap->vp;
583  FFVulkanDecodePicture *rvp[AV1_NUM_REF_FRAMES] = { 0 };
584  AVFrame *rav[AV1_NUM_REF_FRAMES] = { 0 };
585 
586  if (!ap->av1_pic_info.tileCount)
587  return 0;
588 
589  if (!dec->session_params) {
590  int err = vk_av1_create_params(avctx, &dec->session_params);
591  if (err < 0)
592  return err;
593  }
594 
595  for (int i = 0; i < vp->decode_info.referenceSlotCount; i++) {
596  const AV1Frame *rp = ap->ref_src[i];
597  AV1VulkanDecodePicture *rhp = rp->hwaccel_picture_private;
598 
599  rvp[i] = &rhp->vp;
600  rav[i] = ap->ref_src[i]->f;
601  }
602 
603  av_log(avctx, AV_LOG_VERBOSE, "Decoding frame, %"SIZE_SPECIFIER " bytes, %i tiles\n",
604  vp->slices_size, ap->av1_pic_info.tileCount);
605 
606  return ff_vk_decode_frame(avctx, pic->f, vp, rav, rvp);
607 }
608 
609  static void vk_av1_free_frame_priv(FFRefStructOpaque _hwctx, void *data)
610 {
611  AVHWDeviceContext *hwctx = _hwctx.nc;
612  AV1VulkanDecodePicture *ap = data;
613 
614  /* Workaround for a spec issue. */
615  if (ap->frame_id_set)
616  ap->dec->frame_id_alloc_mask &= ~(1 << ap->frame_id);
617 
618  /* Free frame resources, this also destroys the session parameters. */
619  ff_vk_decode_free_frame(hwctx, &ap->vp);
620 }
621 
622  const FFHWAccel ff_av1_vulkan_hwaccel = {
623  .p.name = "av1_vulkan",
624  .p.type = AVMEDIA_TYPE_VIDEO,
625  .p.id = AV_CODEC_ID_AV1,
626  .p.pix_fmt = AV_PIX_FMT_VULKAN,
627  .start_frame = &vk_av1_start_frame,
628  .decode_slice = &vk_av1_decode_slice,
629  .end_frame = &vk_av1_end_frame,
630  .free_frame_priv = &vk_av1_free_frame_priv,
631  .frame_priv_data_size = sizeof(AV1VulkanDecodePicture),
632  .init = &ff_vk_decode_init,
633  .update_thread_context = &ff_vk_update_thread_context,
634  .decode_params = &ff_vk_params_invalidate,
635  .flush = &ff_vk_decode_flush,
636  .uninit = &ff_vk_decode_uninit,
637  .frame_params = &ff_vk_frame_params,
638  .priv_data_size = sizeof(FFVulkanDecodeContext),
639 
640  /* NOTE: Threading is intentionally disabled here. Due to the design of Vulkan,
641  * where frames are opaque to users, and mostly opaque for driver developers,
642  * there's an issue with current hardware accelerator implementations of AV1,
643  * where they require an internal index. With regular hwaccel APIs, this index
644  * is given to users as an opaque handle directly. With Vulkan, due to increased
645  * flexibility, this index cannot be present anywhere.
646  * The current implementation tracks the index for the driver and submits it
647  * as necessary information. Due to needing to modify the decoding context,
648  * which is not thread-safe, on frame free, threading is disabled. */
649  .caps_internal = HWACCEL_CAP_ASYNC_SAFE,
650 };
ff_av1_vulkan_hwaccel
const FFHWAccel ff_av1_vulkan_hwaccel
Definition: vulkan_av1.c:622
AV1RawTimingInfo::num_units_in_display_tick
uint32_t num_units_in_display_tick
Definition: cbs_av1.h:59
AV1RawTimingInfo::time_scale
uint32_t time_scale
Definition: cbs_av1.h:60
AV1RawSequenceHeader::seq_force_integer_mv
uint8_t seq_force_integer_mv
Definition: cbs_av1.h:120
FFVulkanDecodePicture::slices_size
size_t slices_size
Definition: vulkan_decode.h:105
AV1RawColorConfig::color_primaries
uint8_t color_primaries
Definition: cbs_av1.h:47
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
AV1RawSequenceHeader::timing_info_present_flag
uint8_t timing_info_present_flag
Definition: cbs_av1.h:78
AV1RawSequenceHeader
Definition: cbs_av1.h:73
AV1RawColorConfig::color_range
uint8_t color_range
Definition: cbs_av1.h:51
FFVulkanDecodeContext::shared_ctx
FFVulkanDecodeShared * shared_ctx
Definition: vulkan_decode.h:60
MAX_TILES
#define MAX_TILES
Definition: vulkan_av1.c:24
AV1RawFilmGrainParams::apply_grain
uint8_t apply_grain
Definition: cbs_av1.h:134
AV1VulkanDecodePicture::cdef
StdVideoAV1CDEF cdef
Definition: vulkan_av1.c:56
av_unused
#define av_unused
Definition: attributes.h:131
FFHWAccel::p
AVHWAccel p
The public AVHWAccel.
Definition: hwaccel_internal.h:38
AV1VulkanDecodePicture::height_in_sbs_minus1
uint16_t height_in_sbs_minus1[64]
Definition: vulkan_av1.c:49
FF_VK_EXT_VIDEO_DECODE_AV1
@ FF_VK_EXT_VIDEO_DECODE_AV1
Definition: vulkan_functions.h:46
AV1VulkanDecodePicture::loop_filter
StdVideoAV1LoopFilter loop_filter
Definition: vulkan_av1.c:55
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:389
AVFrame::width
int width
Definition: frame.h:461
ff_vk_dec_av1_desc
const FFVulkanDecodeDescriptor ff_vk_dec_av1_desc
Definition: vulkan_av1.c:26
AV1Frame::raw_frame_header
AV1RawFrameHeader * raw_frame_header
Definition: av1dec.h:48
data
const char data[16]
Definition: mxf.c:148
AV1RawFrameHeader::disable_frame_end_update_cdf
uint8_t disable_frame_end_update_cdf
Definition: cbs_av1.h:213
FFVulkanDecodeDescriptor::codec_id
enum AVCodecID codec_id
Definition: vulkan_decode.h:30
AV1RawSequenceHeader::timing_info
AV1RawTimingInfo timing_info
Definition: cbs_av1.h:83
FFVulkanDecodeContext::frame_id_alloc_mask
uint32_t frame_id_alloc_mask
Definition: vulkan_decode.h:66
vk_av1_start_frame
static int vk_av1_start_frame(AVCodecContext *avctx, av_unused const uint8_t *buffer, av_unused uint32_t size)
Definition: vulkan_av1.c:237
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
AV1RawSequenceHeader::frame_id_numbers_present_flag
uint8_t frame_id_numbers_present_flag
Definition: cbs_av1.h:101
FFRefStructOpaque
RefStruct is an API for creating reference-counted objects with minimal overhead.
Definition: refstruct.h:58
vk_av1_create_params
static int vk_av1_create_params(AVCodecContext *avctx, AVBufferRef **buf)
Definition: vulkan_av1.c:141
AV1VulkanDecodePicture::tile_info
StdVideoAV1TileInfo tile_info
Definition: vulkan_av1.c:52
FFVulkanDecodeContext
Definition: vulkan_decode.h:59
AV_PIX_FMT_VULKAN
@ AV_PIX_FMT_VULKAN
Vulkan hardware images.
Definition: pixfmt.h:379
ff_vk_decode_prepare_frame
int ff_vk_decode_prepare_frame(FFVulkanDecodeContext *dec, AVFrame *pic, FFVulkanDecodePicture *vkpic, int is_current, int alloc_dpb)
Prepare a frame, creates the image view, and sets up the dpb fields.
Definition: vulkan_decode.c:141
AV1RawSequenceHeader::seq_profile
uint8_t seq_profile
Definition: cbs_av1.h:74
AV1RawColorConfig::subsampling_y
uint8_t subsampling_y
Definition: cbs_av1.h:53
AV1RawColorConfig::separate_uv_delta_q
uint8_t separate_uv_delta_q
Definition: cbs_av1.h:55
FFVulkanDecodeContext::session_params
AVBufferRef * session_params
Definition: vulkan_decode.h:61
AV1RawSequenceHeader::film_grain_params_present
uint8_t film_grain_params_present
Definition: cbs_av1.h:130
FFHWAccel
Definition: hwaccel_internal.h:34
AV1RawSequenceHeader::enable_ref_frame_mvs
uint8_t enable_ref_frame_mvs
Definition: cbs_av1.h:115
AV1RawSequenceHeader::enable_filter_intra
uint8_t enable_filter_intra
Definition: cbs_av1.h:106
AV1VulkanDecodePicture::quantization
StdVideoAV1Quantization quantization
Definition: vulkan_av1.c:53
vk_av1_end_frame
static int vk_av1_end_frame(AVCodecContext *avctx)
Definition: vulkan_av1.c:576
AV1RawSequenceHeader::delta_frame_id_length_minus_2
uint8_t delta_frame_id_length_minus_2
Definition: cbs_av1.h:102
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
AVHWDeviceContext
This struct aggregates all the (hardware/vendor-specific) "high-level" state, i.e.
Definition: hwcontext.h:60
AV1Frame
Definition: av1dec.h:37
AV1RawSequenceHeader::enable_masked_compound
uint8_t enable_masked_compound
Definition: cbs_av1.h:109
AV1VulkanDecodePicture::std_pic_info
StdVideoDecodeAV1PictureInfo std_pic_info
Definition: vulkan_av1.c:60
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
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
AV1VulkanDecodePicture::std_ref
StdVideoDecodeAV1ReferenceInfo std_ref
Definition: vulkan_av1.c:46
AV1RawColorConfig::transfer_characteristics
uint8_t transfer_characteristics
Definition: cbs_av1.h:48
AV1RawFrameHeader::segmentation_enabled
uint8_t segmentation_enabled
Definition: cbs_av1.h:242
av1dec.h
AV1Frame::f
struct AVFrame * f
Definition: av1dec.h:40
HWACCEL_CAP_ASYNC_SAFE
#define HWACCEL_CAP_ASYNC_SAFE
Header providing the internals of AVHWAccel.
Definition: hwaccel_internal.h:31
AV1_NUM_REF_FRAMES
@ AV1_NUM_REF_FRAMES
Definition: av1.h:84
FFVulkanDecodePicture::img_view_ref
VkImageView img_view_ref
Definition: vulkan_decode.h:83
NULL
#define NULL
Definition: coverity.c:32
AV_CODEC_ID_AV1
@ AV_CODEC_ID_AV1
Definition: codec_id.h:280
AV1RawFrameHeader
Definition: cbs_av1.h:165
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
AV1_REF_FRAME_NONE
@ AV1_REF_FRAME_NONE
Definition: av1.h:61
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:1066
flush
void(* flush)(AVBSFContext *ctx)
Definition: dts2pts.c:370
AV1RawSequenceHeader::enable_jnt_comp
uint8_t enable_jnt_comp
Definition: cbs_av1.h:114
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
AV1RawSequenceHeader::seq_force_screen_content_tools
uint8_t seq_force_screen_content_tools
Definition: cbs_av1.h:118
AV1VulkanDecodePicture::ref_frame_sign_bias_mask
uint8_t ref_frame_sign_bias_mask
Definition: vulkan_av1.c:70
AV1RawSequenceHeader::max_frame_height_minus_1
uint16_t max_frame_height_minus_1
Definition: cbs_av1.h:99
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:368
AV1VulkanDecodePicture::loop_restoration
StdVideoAV1LoopRestoration loop_restoration
Definition: vulkan_av1.c:57
AV1RawTimingInfo::num_ticks_per_picture_minus_1
uint32_t num_ticks_per_picture_minus_1
Definition: cbs_av1.h:63
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
AV1VulkanDecodePicture::mi_col_starts
uint16_t mi_col_starts[64]
Definition: vulkan_av1.c:50
size
int size
Definition: twinvq_data.h:10344
AV1DecContext
Definition: av1dec.h:85
AV1RawSequenceHeader::use_128x128_superblock
uint8_t use_128x128_superblock
Definition: cbs_av1.h:105
AV1RawSequenceHeader::frame_height_bits_minus_1
uint8_t frame_height_bits_minus_1
Definition: cbs_av1.h:97
ref_frame
static int ref_frame(VVCFrame *dst, const VVCFrame *src)
Definition: dec.c:596
FFRefStructOpaque::nc
void * nc
Definition: refstruct.h:59
AV1RawSequenceHeader::still_picture
uint8_t still_picture
Definition: cbs_av1.h:75
AV1RawSequenceHeader::initial_display_delay_present_flag
uint8_t initial_display_delay_present_flag
Definition: cbs_av1.h:80
AV1RawSequenceHeader::enable_interintra_compound
uint8_t enable_interintra_compound
Definition: cbs_av1.h:108
AV1RawFrameHeader::order_hint
uint8_t order_hint
Definition: cbs_av1.h:182
AVHWAccel::name
const char * name
Name of the hardware accelerated codec.
Definition: avcodec.h:2105
uninit
static void uninit(AVBSFContext *ctx)
Definition: pcm_rechunk.c:68
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AV1RawSequenceHeader::enable_dual_filter
uint8_t enable_dual_filter
Definition: cbs_av1.h:111
AV1VulkanDecodePicture::vkav1_refs
VkVideoDecodeAV1DpbSlotInfoKHR vkav1_refs[AV1_NUM_REF_FRAMES]
Definition: vulkan_av1.c:66
AV1RawSequenceHeader::enable_superres
uint8_t enable_superres
Definition: cbs_av1.h:124
AV1Frame::hwaccel_picture_private
void * hwaccel_picture_private
RefStruct reference.
Definition: av1dec.h:45
AV1RawTimingInfo::equal_picture_interval
uint8_t equal_picture_interval
Definition: cbs_av1.h:62
AV1RawSequenceHeader::enable_intra_edge_filter
uint8_t enable_intra_edge_filter
Definition: cbs_av1.h:107
AV1RawSequenceHeader::max_frame_width_minus_1
uint16_t max_frame_width_minus_1
Definition: cbs_av1.h:98
AV1VulkanDecodePicture::av1_pic_info
VkVideoDecodeAV1PictureInfoKHR av1_pic_info
Definition: vulkan_av1.c:61
AV1RawSequenceHeader::color_config
AV1RawColorConfig color_config
Definition: cbs_av1.h:128
AV1VulkanDecodePicture::tile_sizes
uint32_t tile_sizes[MAX_TILES]
Definition: vulkan_av1.c:43
AV1VulkanDecodePicture::segmentation
StdVideoAV1Segmentation segmentation
Definition: vulkan_av1.c:54
AV1RawSequenceHeader::enable_order_hint
uint8_t enable_order_hint
Definition: cbs_av1.h:113
AV1VulkanDecodePicture::width_in_sbs_minus1
uint16_t width_in_sbs_minus1[64]
Definition: vulkan_av1.c:48
ff_vk_decode_flush
void ff_vk_decode_flush(AVCodecContext *avctx)
Flush decoder.
Definition: vulkan_decode.c:276
AV1RawColorConfig::subsampling_x
uint8_t subsampling_x
Definition: cbs_av1.h:52
AV1VulkanDecodePicture::global_motion
StdVideoAV1GlobalMotion global_motion
Definition: vulkan_av1.c:58
AV1VulkanDecodePicture::film_grain
StdVideoAV1FilmGrain film_grain
Definition: vulkan_av1.c:59
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
AV1RawColorConfig::high_bitdepth
uint8_t high_bitdepth
Definition: cbs_av1.h:42
AV1VulkanDecodePicture::ref_src
const AV1Frame * ref_src[AV1_NUM_REF_FRAMES]
Definition: vulkan_av1.c:64
SIZE_SPECIFIER
#define SIZE_SPECIFIER
Definition: internal.h:129
AV1VulkanDecodePicture::mi_row_starts
uint16_t mi_row_starts[64]
Definition: vulkan_av1.c:51
AV1RawSequenceHeader::frame_width_bits_minus_1
uint8_t frame_width_bits_minus_1
Definition: cbs_av1.h:96
AV1RawSequenceHeader::enable_warped_motion
uint8_t enable_warped_motion
Definition: cbs_av1.h:110
AVCodecContext
main external API structure.
Definition: avcodec.h:451
AVFrame::height
int height
Definition: frame.h:461
FFVulkanDecodeContext::dedicated_dpb
int dedicated_dpb
Definition: vulkan_decode.h:64
frame_header
Definition: truemotion1.c:88
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
AV1RawColorConfig::mono_chrome
uint8_t mono_chrome
Definition: cbs_av1.h:44
update_thread_context
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call have update_thread_context() run it in the next thread. Add AV_CODEC_CAP_FRAME_THREADS to the codec capabilities. There will be very little speed gain at this point but it should work. Use ff_thread_get_buffer()(or ff_progress_frame_get_buffer() in case you have inter-frame dependencies and use the ProgressFrame API) to allocate frame buffers. Call ff_progress_frame_report() after some part of the current picture has decoded. A good place to put this is where draw_horiz_band() is called - add this if it isn 't called anywhere
FFVulkanDecodeDescriptor
Definition: vulkan_decode.h:29
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:112
AVCodecContext::export_side_data
int export_side_data
Bit set of AV_CODEC_EXPORT_DATA_* flags, which affects the kind of metadata exported in frame,...
Definition: avcodec.h:1937
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
AV1VulkanDecodePicture::vkav1_ref
VkVideoDecodeAV1DpbSlotInfoKHR vkav1_ref
Definition: vulkan_av1.c:47
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
AV1RawSequenceHeader::order_hint_bits_minus_1
uint8_t order_hint_bits_minus_1
Definition: cbs_av1.h:122
AV1RawColorConfig::matrix_coefficients
uint8_t matrix_coefficients
Definition: cbs_av1.h:49
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
frame_header::flags
uint8_t flags
Definition: truemotion1.c:98
AV1RawSequenceHeader::enable_restoration
uint8_t enable_restoration
Definition: cbs_av1.h:126
vulkan_decode.h
AV1RawColorConfig::twelve_bit
uint8_t twelve_bit
Definition: cbs_av1.h:43
AV1VulkanDecodePicture::vp
FFVulkanDecodePicture vp
Definition: vulkan_av1.c:37
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:478
AV1RawSequenceHeader::additional_frame_id_length_minus_1
uint8_t additional_frame_id_length_minus_1
Definition: cbs_av1.h:103
AV1RawSequenceHeader::enable_cdef
uint8_t enable_cdef
Definition: cbs_av1.h:125
AV1RawSequenceHeader::reduced_still_picture_header
uint8_t reduced_still_picture_header
Definition: cbs_av1.h:76
AV1RawFilmGrainParams
Definition: cbs_av1.h:133
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AV1VulkanDecodePicture::std_refs
StdVideoDecodeAV1ReferenceInfo std_refs[AV1_NUM_REF_FRAMES]
Definition: vulkan_av1.c:65
ff_vk_decode_init
int ff_vk_decode_init(AVCodecContext *avctx)
Initialize decoder.
Definition: vulkan_decode.c:1081
FFVulkanDecodePicture::decode_info
VkVideoDecodeInfoKHR decode_info
Definition: vulkan_decode.h:101
AV1VulkanDecodePicture
Definition: vulkan_av1.c:36
AV1VulkanDecodePicture::frame_id
uint8_t frame_id
Definition: vulkan_av1.c:69
vk_av1_fill_pict
static int vk_av1_fill_pict(AVCodecContext *avctx, const AV1Frame **ref_src, VkVideoReferenceSlotInfoKHR *ref_slot, VkVideoPictureResourceInfoKHR *ref, StdVideoDecodeAV1ReferenceInfo *vkav1_std_ref, VkVideoDecodeAV1DpbSlotInfoKHR *vkav1_ref, const AV1Frame *pic, int is_current, int has_grain, const uint8_t *saved_order_hints)
Definition: vulkan_av1.c:73
AV1VulkanDecodePicture::dec
FFVulkanDecodeContext * dec
Definition: vulkan_av1.c:41
AV1VulkanDecodePicture::frame_id_set
uint8_t frame_id_set
Definition: vulkan_av1.c:68
vk_av1_decode_slice
static int vk_av1_decode_slice(AVCodecContext *avctx, const uint8_t *data, uint32_t size)
Definition: vulkan_av1.c:548
FFVulkanDecodeContext::quirk_av1_offset
int quirk_av1_offset
Definition: vulkan_decode.h:70
AV_CODEC_EXPORT_DATA_FILM_GRAIN
#define AV_CODEC_EXPORT_DATA_FILM_GRAIN
Decoding only.
Definition: avcodec.h:420
vk_av1_free_frame_priv
static void vk_av1_free_frame_priv(FFRefStructOpaque _hwctx, void *data)
Definition: vulkan_av1.c:609
AV1RawFrameHeader::frame_type
uint8_t frame_type
Definition: cbs_av1.h:171
Generated on Fri Aug 22 2025 13:58:58 for FFmpeg by   doxygen 1.8.17

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