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