FFmpeg
vulkan_ffv1.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2024 Lynne <dev@lynne.ee>
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 #include "vulkan_decode.h"
22 #include "hwaccel_internal.h"
23 
24 #include "ffv1.h"
25 #include "ffv1_vulkan.h"
26 #include "libavutil/vulkan_spirv.h"
27 #include "libavutil/mem.h"
28 
29 #define RGB_LINECACHE 2
30 
31 extern const char *ff_source_common_comp;
32 extern const char *ff_source_rangecoder_comp;
33 extern const char *ff_source_ffv1_vlc_comp;
34 extern const char *ff_source_ffv1_common_comp;
35 extern const char *ff_source_ffv1_dec_setup_comp;
36 extern const char *ff_source_ffv1_reset_comp;
37 extern const char *ff_source_ffv1_dec_comp;
38 
39 const FFVulkanDecodeDescriptor ff_vk_dec_ffv1_desc = {
40  .codec_id = AV_CODEC_ID_FFV1,
41  .decode_extension = FF_VK_EXT_PUSH_DESCRIPTOR,
42  .queue_flags = VK_QUEUE_COMPUTE_BIT,
43 };
44 
45 typedef struct FFv1VulkanDecodePicture {
46  FFVulkanDecodePicture vp;
47 
48  AVBufferRef *slice_state;
49  uint32_t plane_state_size;
50  uint32_t slice_state_size;
51  uint32_t slice_data_size;
52 
53  AVBufferRef *slice_offset_buf;
54  uint32_t *slice_offset;
55  int slice_num;
56 
57  AVBufferRef *slice_status_buf;
58  int crc_checked;
59 } FFv1VulkanDecodePicture;
60 
61 typedef struct FFv1VulkanDecodeContext {
62  AVBufferRef *intermediate_frames_ref;
63 
64  FFVulkanShader setup;
65  FFVulkanShader reset;
66  FFVulkanShader decode;
67 
68  FFVkBuffer rangecoder_static_buf;
69  FFVkBuffer quant_buf;
70  FFVkBuffer crc_tab_buf;
71 
72  AVBufferPool *slice_state_pool;
73  AVBufferPool *slice_offset_pool;
74  AVBufferPool *slice_status_pool;
75 } FFv1VulkanDecodeContext;
76 
77 typedef struct FFv1VkParameters {
78  VkDeviceAddress slice_data;
79  VkDeviceAddress slice_state;
80 
81  int fmt_lut[4];
82  uint32_t img_size[2];
83  uint32_t chroma_shift[2];
84 
85  uint32_t plane_state_size;
86  uint32_t crcref;
87  int rct_offset;
88 
89  uint8_t extend_lookup[8];
90  uint8_t bits_per_raw_sample;
91  uint8_t quant_table_count;
92  uint8_t version;
93  uint8_t micro_version;
94  uint8_t key_frame;
95  uint8_t planes;
96  uint8_t codec_planes;
97  uint8_t color_planes;
98  uint8_t transparency;
99  uint8_t planar_rgb;
100  uint8_t colorspace;
101  uint8_t ec;
102  uint8_t golomb;
103  uint8_t check_crc;
104  uint8_t padding[3];
105 } FFv1VkParameters;
106 
107 static void add_push_data(FFVulkanShader *shd)
108 {
109  GLSLC(0, layout(push_constant, scalar) uniform pushConstants { );
110  GLSLC(1, u8buf slice_data; );
111  GLSLC(1, u8buf slice_state; );
112  GLSLC(0, );
113  GLSLC(1, ivec4 fmt_lut; );
114  GLSLC(1, uvec2 img_size; );
115  GLSLC(1, uvec2 chroma_shift; );
116  GLSLC(0, );
117  GLSLC(1, uint plane_state_size; );
118  GLSLC(1, uint32_t crcref; );
119  GLSLC(1, int rct_offset; );
120  GLSLC(0, );
121  GLSLC(1, uint8_t extend_lookup[8]; );
122  GLSLC(1, uint8_t bits_per_raw_sample; );
123  GLSLC(1, uint8_t quant_table_count; );
124  GLSLC(1, uint8_t version; );
125  GLSLC(1, uint8_t micro_version; );
126  GLSLC(1, uint8_t key_frame; );
127  GLSLC(1, uint8_t planes; );
128  GLSLC(1, uint8_t codec_planes; );
129  GLSLC(1, uint8_t color_planes; );
130  GLSLC(1, uint8_t transparency; );
131  GLSLC(1, uint8_t planar_rgb; );
132  GLSLC(1, uint8_t colorspace; );
133  GLSLC(1, uint8_t ec; );
134  GLSLC(1, uint8_t golomb; );
135  GLSLC(1, uint8_t check_crc; );
136  GLSLC(1, uint8_t padding[3]; );
137  GLSLC(0, }; );
138  ff_vk_shader_add_push_const(shd, 0, sizeof(FFv1VkParameters),
139  VK_SHADER_STAGE_COMPUTE_BIT);
140 }
141 
142 static int vk_ffv1_start_frame(AVCodecContext *avctx,
143  const AVBufferRef *buffer_ref,
144  av_unused const uint8_t *buffer,
145  av_unused uint32_t size)
146 {
147  int err;
148  FFVulkanDecodeContext *dec = avctx->internal->hwaccel_priv_data;
149  FFVulkanDecodeShared *ctx = dec->shared_ctx;
150  FFv1VulkanDecodeContext *fv = ctx->sd_ctx;
151  FFV1Context *f = avctx->priv_data;
152 
153  FFv1VulkanDecodePicture *fp = f->hwaccel_picture_private;
154  FFVulkanDecodePicture *vp = &fp->vp;
155 
156  AVHWFramesContext *hwfc = (AVHWFramesContext *)avctx->hw_frames_ctx->data;
157  enum AVPixelFormat sw_format = hwfc->sw_format;
158 
159  int max_contexts;
160  int is_rgb = !(f->colorspace == 0 && sw_format != AV_PIX_FMT_YA8) &&
161  !(sw_format == AV_PIX_FMT_YA8);
162 
163  fp->slice_num = 0;
164 
165  max_contexts = 0;
166  for (int i = 0; i < f->quant_table_count; i++)
167  max_contexts = FFMAX(f->context_count[i], max_contexts);
168 
169  /* Allocate slice buffer data */
170  if (f->ac == AC_GOLOMB_RICE)
171  fp->plane_state_size = 8;
172  else
173  fp->plane_state_size = CONTEXT_SIZE;
174 
175  fp->plane_state_size *= max_contexts;
176  fp->slice_state_size = fp->plane_state_size*f->plane_count;
177 
178  fp->slice_data_size = 256; /* Overestimation for the SliceContext struct */
179  fp->slice_state_size += fp->slice_data_size;
180  fp->slice_state_size = FFALIGN(fp->slice_state_size, 8);
181 
182  fp->crc_checked = f->ec && (avctx->err_recognition & AV_EF_CRCCHECK);
183 
184  /* Host map the input slices data if supported */
185  if (ctx->s.extensions & FF_VK_EXT_EXTERNAL_HOST_MEMORY)
186  ff_vk_host_map_buffer(&ctx->s, &vp->slices_buf, buffer_ref->data,
187  buffer_ref,
188  VK_BUFFER_USAGE_STORAGE_BUFFER_BIT |
189  VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT);
190 
191  /* Allocate slice state data */
192  if (f->picture.f->flags & AV_FRAME_FLAG_KEY) {
193  err = ff_vk_get_pooled_buffer(&ctx->s, &fv->slice_state_pool,
194  &fp->slice_state,
195  VK_BUFFER_USAGE_STORAGE_BUFFER_BIT |
196  VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
197  NULL, f->slice_count*fp->slice_state_size,
198  VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
199  if (err < 0)
200  return err;
201  } else {
202  FFv1VulkanDecodePicture *fpl = f->hwaccel_last_picture_private;
203  fp->slice_state = av_buffer_ref(fpl->slice_state);
204  if (!fp->slice_state)
205  return AVERROR(ENOMEM);
206  }
207 
208  /* Allocate slice offsets buffer */
209  err = ff_vk_get_pooled_buffer(&ctx->s, &fv->slice_offset_pool,
210  &fp->slice_offset_buf,
211  VK_BUFFER_USAGE_STORAGE_BUFFER_BIT |
212  VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
213  NULL, 2*f->slice_count*sizeof(uint32_t),
214  VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT |
215  VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
216  if (err < 0)
217  return err;
218 
219  /* Allocate slice status buffer */
220  err = ff_vk_get_pooled_buffer(&ctx->s, &fv->slice_status_pool,
221  &fp->slice_status_buf,
222  VK_BUFFER_USAGE_STORAGE_BUFFER_BIT |
223  VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
224  NULL, 2*f->slice_count*sizeof(uint32_t),
225  VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT |
226  VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
227  if (err < 0)
228  return err;
229 
230  /* Prepare frame to be used */
231  err = ff_vk_decode_prepare_frame_sdr(dec, f->picture.f, vp, 1,
232  FF_VK_REP_NATIVE, 0);
233  if (err < 0)
234  return err;
235 
236  /* Create a temporaty frame for RGB */
237  if (is_rgb) {
238  vp->dpb_frame = av_frame_alloc();
239  if (!vp->dpb_frame)
240  return AVERROR(ENOMEM);
241 
242  err = av_hwframe_get_buffer(fv->intermediate_frames_ref,
243  vp->dpb_frame, 0);
244  if (err < 0)
245  return err;
246  }
247 
248  return 0;
249 }
250 
251 static int vk_ffv1_decode_slice(AVCodecContext *avctx,
252  const uint8_t *data,
253  uint32_t size)
254 {
255  FFV1Context *f = avctx->priv_data;
256 
257  FFv1VulkanDecodePicture *fp = f->hwaccel_picture_private;
258  FFVulkanDecodePicture *vp = &fp->vp;
259 
260  FFVkBuffer *slice_offset = (FFVkBuffer *)fp->slice_offset_buf->data;
261  FFVkBuffer *slices_buf = vp->slices_buf ? (FFVkBuffer *)vp->slices_buf->data : NULL;
262 
263  if (slices_buf && slices_buf->host_ref) {
264  AV_WN32(slice_offset->mapped_mem + (2*fp->slice_num + 0)*sizeof(uint32_t),
265  data - slices_buf->mapped_mem);
266  AV_WN32(slice_offset->mapped_mem + (2*fp->slice_num + 1)*sizeof(uint32_t),
267  size);
268 
269  fp->slice_num++;
270  } else {
271  int err = ff_vk_decode_add_slice(avctx, vp, data, size, 0,
272  &fp->slice_num,
273  (const uint32_t **)&fp->slice_offset);
274  if (err < 0)
275  return err;
276 
277  AV_WN32(slice_offset->mapped_mem + (2*(fp->slice_num - 1) + 0)*sizeof(uint32_t),
278  fp->slice_offset[fp->slice_num - 1]);
279  AV_WN32(slice_offset->mapped_mem + (2*(fp->slice_num - 1) + 1)*sizeof(uint32_t),
280  size);
281  }
282 
283  return 0;
284 }
285 
286 static int vk_ffv1_end_frame(AVCodecContext *avctx)
287 {
288  int err;
289  FFVulkanDecodeContext *dec = avctx->internal->hwaccel_priv_data;
290  FFVulkanDecodeShared *ctx = dec->shared_ctx;
291  FFVulkanFunctions *vk = &ctx->s.vkfn;
292 
293  FFV1Context *f = avctx->priv_data;
294  FFv1VulkanDecodeContext *fv = ctx->sd_ctx;
295  FFv1VkParameters pd;
296  FFv1VkResetParameters pd_reset;
297 
298  AVHWFramesContext *hwfc = (AVHWFramesContext *)avctx->hw_frames_ctx->data;
299  enum AVPixelFormat sw_format = hwfc->sw_format;
300 
301  int bits = f->avctx->bits_per_raw_sample > 0 ? f->avctx->bits_per_raw_sample : 8;
302  int is_rgb = !(f->colorspace == 0 && sw_format != AV_PIX_FMT_YA8) &&
303  !(sw_format == AV_PIX_FMT_YA8);
304  int color_planes = av_pix_fmt_desc_get(avctx->sw_pix_fmt)->nb_components;
305 
306  FFVulkanShader *reset_shader;
307  FFVulkanShader *decode_shader;
308 
309  FFv1VulkanDecodePicture *fp = f->hwaccel_picture_private;
310  FFVulkanDecodePicture *vp = &fp->vp;
311 
312  FFVkBuffer *slices_buf = (FFVkBuffer *)vp->slices_buf->data;
313  FFVkBuffer *slice_state = (FFVkBuffer *)fp->slice_state->data;
314  FFVkBuffer *slice_offset = (FFVkBuffer *)fp->slice_offset_buf->data;
315  FFVkBuffer *slice_status = (FFVkBuffer *)fp->slice_status_buf->data;
316 
317  VkImageView rct_image_views[AV_NUM_DATA_POINTERS];
318 
319  AVFrame *decode_dst = is_rgb ? vp->dpb_frame : f->picture.f;
320  VkImageView *decode_dst_view = is_rgb ? rct_image_views : vp->view.out;
321 
322  VkImageMemoryBarrier2 img_bar[37];
323  int nb_img_bar = 0;
324  VkBufferMemoryBarrier2 buf_bar[8];
325  int nb_buf_bar = 0;
326 
327  FFVkExecContext *exec = ff_vk_exec_get(&ctx->s, &ctx->exec_pool);
328  ff_vk_exec_start(&ctx->s, exec);
329 
330  /* Prepare deps */
331  RET(ff_vk_exec_add_dep_frame(&ctx->s, exec, f->picture.f,
332  VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
333  VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT));
334 
335  err = ff_vk_exec_mirror_sem_value(&ctx->s, exec, &vp->sem, &vp->sem_value,
336  f->picture.f);
337  if (err < 0)
338  return err;
339 
340  if (is_rgb) {
341  RET(ff_vk_create_imageviews(&ctx->s, exec, rct_image_views,
342  vp->dpb_frame, FF_VK_REP_NATIVE));
343  RET(ff_vk_exec_add_dep_frame(&ctx->s, exec, vp->dpb_frame,
344  VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
345  VK_PIPELINE_STAGE_2_CLEAR_BIT));
346  ff_vk_frame_barrier(&ctx->s, exec, decode_dst, img_bar, &nb_img_bar,
347  VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
348  VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
349  VK_ACCESS_2_TRANSFER_WRITE_BIT,
350  VK_IMAGE_LAYOUT_GENERAL,
351  VK_QUEUE_FAMILY_IGNORED);
352  }
353 
354  if (!(f->picture.f->flags & AV_FRAME_FLAG_KEY)) {
355  FFv1VulkanDecodePicture *fpl = f->hwaccel_last_picture_private;
356  FFVulkanDecodePicture *vpl = &fpl->vp;
357 
358  /* Wait on the previous frame */
359  RET(ff_vk_exec_add_dep_wait_sem(&ctx->s, exec, vpl->sem, vpl->sem_value,
360  VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT));
361  }
362 
363  RET(ff_vk_exec_add_dep_buf(&ctx->s, exec, &fp->slice_state, 1, 1));
364  RET(ff_vk_exec_add_dep_buf(&ctx->s, exec, &fp->slice_status_buf, 1, 1));
365  RET(ff_vk_exec_add_dep_buf(&ctx->s, exec, &vp->slices_buf, 1, 0));
366  vp->slices_buf = NULL;
367  RET(ff_vk_exec_add_dep_buf(&ctx->s, exec, &fp->slice_offset_buf, 1, 0));
368  fp->slice_offset_buf = NULL;
369 
370  /* Entry barrier for the slice state */
371  buf_bar[nb_buf_bar++] = (VkBufferMemoryBarrier2) {
372  .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2,
373  .srcStageMask = slice_state->stage,
374  .dstStageMask = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
375  .srcAccessMask = slice_state->access,
376  .dstAccessMask = VK_ACCESS_2_SHADER_STORAGE_READ_BIT |
377  VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT,
378  .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
379  .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
380  .buffer = slice_state->buf,
381  .offset = 0,
382  .size = fp->slice_data_size*f->slice_count,
383  };
384 
385  vk->CmdPipelineBarrier2(exec->buf, &(VkDependencyInfo) {
386  .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
387  .pImageMemoryBarriers = img_bar,
388  .imageMemoryBarrierCount = nb_img_bar,
389  .pBufferMemoryBarriers = buf_bar,
390  .bufferMemoryBarrierCount = nb_buf_bar,
391  });
392  slice_state->stage = buf_bar[0].dstStageMask;
393  slice_state->access = buf_bar[0].dstAccessMask;
394  nb_buf_bar = 0;
395  nb_img_bar = 0;
396 
397  /* Setup shader */
398  ff_vk_shader_update_desc_buffer(&ctx->s, exec, &fv->setup,
399  1, 0, 0,
400  slice_state,
401  0, fp->slice_data_size*f->slice_count,
402  VK_FORMAT_UNDEFINED);
403  ff_vk_shader_update_desc_buffer(&ctx->s, exec, &fv->setup,
404  1, 1, 0,
405  slice_offset,
406  0, 2*f->slice_count*sizeof(uint32_t),
407  VK_FORMAT_UNDEFINED);
408  ff_vk_shader_update_desc_buffer(&ctx->s, exec, &fv->setup,
409  1, 2, 0,
410  slice_status,
411  0, 2*f->slice_count*sizeof(uint32_t),
412  VK_FORMAT_UNDEFINED);
413 
414  ff_vk_exec_bind_shader(&ctx->s, exec, &fv->setup);
415  pd = (FFv1VkParameters) {
416  .slice_data = slices_buf->address,
417  .slice_state = slice_state->address + f->slice_count*fp->slice_data_size,
418 
419  .img_size[0] = f->picture.f->width,
420  .img_size[1] = f->picture.f->height,
421  .chroma_shift[0] = f->chroma_h_shift,
422  .chroma_shift[1] = f->chroma_v_shift,
423 
424  .plane_state_size = fp->plane_state_size,
425  .crcref = f->crcref,
426  .rct_offset = 1 << bits,
427 
428  .bits_per_raw_sample = bits,
429  .quant_table_count = f->quant_table_count,
430  .version = f->version,
431  .micro_version = f->micro_version,
432  .key_frame = f->picture.f->flags & AV_FRAME_FLAG_KEY,
433  .planes = av_pix_fmt_count_planes(sw_format),
434  .codec_planes = f->plane_count,
435  .color_planes = color_planes,
436  .transparency = f->transparency,
437  .planar_rgb = ff_vk_mt_is_np_rgb(sw_format) &&
438  (ff_vk_count_images((AVVkFrame *)f->picture.f->data[0]) > 1),
439  .colorspace = f->colorspace,
440  .ec = f->ec,
441  .golomb = f->ac == AC_GOLOMB_RICE,
442  .check_crc = !!(avctx->err_recognition & AV_EF_CRCCHECK),
443  };
444  for (int i = 0; i < f->quant_table_count; i++)
445  pd.extend_lookup[i] = (f->quant_tables[i][3][127] != 0) ||
446  (f->quant_tables[i][4][127] != 0);
447 
448 
449  /* For some reason the C FFv1 encoder/decoder treats these differently */
450  if (sw_format == AV_PIX_FMT_GBRP10 || sw_format == AV_PIX_FMT_GBRP12 ||
451  sw_format == AV_PIX_FMT_GBRP14)
452  memcpy(pd.fmt_lut, (int [4]) { 2, 1, 0, 3 }, 4*sizeof(int));
453  else
454  ff_vk_set_perm(sw_format, pd.fmt_lut, 0);
455 
456  ff_vk_shader_update_push_const(&ctx->s, exec, &fv->setup,
457  VK_SHADER_STAGE_COMPUTE_BIT,
458  0, sizeof(pd), &pd);
459 
460  vk->CmdDispatch(exec->buf, f->num_h_slices, f->num_v_slices, 1);
461 
462  if (is_rgb) {
463  AVVkFrame *vkf = (AVVkFrame *)vp->dpb_frame->data[0];
464  for (int i = 0; i < color_planes; i++)
465  vk->CmdClearColorImage(exec->buf, vkf->img[i], VK_IMAGE_LAYOUT_GENERAL,
466  &((VkClearColorValue) { 0 }),
467  1, &((VkImageSubresourceRange) {
468  .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
469  .levelCount = 1,
470  .layerCount = 1,
471  }));
472  }
473 
474  /* Reset shader */
475  reset_shader = &fv->reset;
476  ff_vk_shader_update_desc_buffer(&ctx->s, exec, reset_shader,
477  1, 0, 0,
478  slice_state,
479  0, fp->slice_data_size*f->slice_count,
480  VK_FORMAT_UNDEFINED);
481 
482  ff_vk_exec_bind_shader(&ctx->s, exec, reset_shader);
483 
484  pd_reset = (FFv1VkResetParameters) {
485  .slice_state = slice_state->address + f->slice_count*fp->slice_data_size,
486  .plane_state_size = fp->plane_state_size,
487  .codec_planes = f->plane_count,
488  .key_frame = f->picture.f->flags & AV_FRAME_FLAG_KEY,
489  .version = f->version,
490  .micro_version = f->micro_version,
491  };
492  for (int i = 0; i < f->quant_table_count; i++)
493  pd_reset.context_count[i] = f->context_count[i];
494 
495  ff_vk_shader_update_push_const(&ctx->s, exec, reset_shader,
496  VK_SHADER_STAGE_COMPUTE_BIT,
497  0, sizeof(pd_reset), &pd_reset);
498 
499  /* Sync between setup and reset shaders */
500  buf_bar[nb_buf_bar++] = (VkBufferMemoryBarrier2) {
501  .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2,
502  .srcStageMask = slice_state->stage,
503  .dstStageMask = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
504  .srcAccessMask = slice_state->access,
505  .dstAccessMask = VK_ACCESS_2_SHADER_STORAGE_READ_BIT,
506  .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
507  .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
508  .buffer = slice_state->buf,
509  .offset = 0,
510  .size = fp->slice_data_size*f->slice_count,
511  };
512  vk->CmdPipelineBarrier2(exec->buf, &(VkDependencyInfo) {
513  .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
514  .pImageMemoryBarriers = img_bar,
515  .imageMemoryBarrierCount = nb_img_bar,
516  .pBufferMemoryBarriers = buf_bar,
517  .bufferMemoryBarrierCount = nb_buf_bar,
518  });
519  slice_state->stage = buf_bar[0].dstStageMask;
520  slice_state->access = buf_bar[0].dstAccessMask;
521  nb_buf_bar = 0;
522  nb_img_bar = 0;
523 
524  vk->CmdDispatch(exec->buf, f->num_h_slices, f->num_v_slices,
525  f->plane_count);
526 
527  /* Decode */
528  decode_shader = &fv->decode;
529  ff_vk_shader_update_desc_buffer(&ctx->s, exec, decode_shader,
530  1, 0, 0,
531  slice_state,
532  0, fp->slice_data_size*f->slice_count,
533  VK_FORMAT_UNDEFINED);
534  ff_vk_shader_update_img_array(&ctx->s, exec, decode_shader,
535  decode_dst, decode_dst_view,
536  1, 1,
537  VK_IMAGE_LAYOUT_GENERAL,
538  VK_NULL_HANDLE);
539  ff_vk_shader_update_desc_buffer(&ctx->s, exec, decode_shader,
540  1, 2, 0,
541  slice_status,
542  0, 2*f->slice_count*sizeof(uint32_t),
543  VK_FORMAT_UNDEFINED);
544  if (is_rgb)
545  ff_vk_shader_update_img_array(&ctx->s, exec, decode_shader,
546  f->picture.f, vp->view.out,
547  1, 3,
548  VK_IMAGE_LAYOUT_GENERAL,
549  VK_NULL_HANDLE);
550 
551  ff_vk_exec_bind_shader(&ctx->s, exec, decode_shader);
552  ff_vk_shader_update_push_const(&ctx->s, exec, decode_shader,
553  VK_SHADER_STAGE_COMPUTE_BIT,
554  0, sizeof(pd), &pd);
555 
556  /* Sync between reset and decode shaders */
557  buf_bar[nb_buf_bar++] = (VkBufferMemoryBarrier2) {
558  .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2,
559  .srcStageMask = slice_state->stage,
560  .dstStageMask = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
561  .srcAccessMask = slice_state->access,
562  .dstAccessMask = VK_ACCESS_2_SHADER_STORAGE_READ_BIT |
563  VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT,
564  .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
565  .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
566  .buffer = slice_state->buf,
567  .offset = fp->slice_data_size*f->slice_count,
568  .size = f->slice_count*(fp->slice_state_size - fp->slice_data_size),
569  };
570 
571  /* Input frame barrier */
572  ff_vk_frame_barrier(&ctx->s, exec, f->picture.f, img_bar, &nb_img_bar,
573  VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
574  VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
575  VK_ACCESS_SHADER_WRITE_BIT |
576  (!is_rgb ? VK_ACCESS_SHADER_READ_BIT : 0),
577  VK_IMAGE_LAYOUT_GENERAL,
578  VK_QUEUE_FAMILY_IGNORED);
579  if (is_rgb)
580  ff_vk_frame_barrier(&ctx->s, exec, vp->dpb_frame, img_bar, &nb_img_bar,
581  VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
582  VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
583  VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT,
584  VK_IMAGE_LAYOUT_GENERAL,
585  VK_QUEUE_FAMILY_IGNORED);
586 
587  vk->CmdPipelineBarrier2(exec->buf, &(VkDependencyInfo) {
588  .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
589  .pImageMemoryBarriers = img_bar,
590  .imageMemoryBarrierCount = nb_img_bar,
591  .pBufferMemoryBarriers = buf_bar,
592  .bufferMemoryBarrierCount = nb_buf_bar,
593  });
594  slice_state->stage = buf_bar[0].dstStageMask;
595  slice_state->access = buf_bar[0].dstAccessMask;
596  nb_img_bar = 0;
597  nb_buf_bar = 0;
598 
599  vk->CmdDispatch(exec->buf, f->num_h_slices, f->num_v_slices, 1);
600 
601  err = ff_vk_exec_submit(&ctx->s, exec);
602  if (err < 0)
603  return err;
604 
605  /* We don't need the temporary frame after decoding */
606  av_frame_free(&vp->dpb_frame);
607 
608 fail:
609  return 0;
610 }
611 
612 static void define_shared_code(FFVulkanShader *shd, int use32bit)
613 {
614  int smp_bits = use32bit ? 32 : 16;
615 
616  GLSLC(0, #define DECODE );
617 
618  av_bprintf(&shd->src, "#define RGB_LINECACHE %i\n" ,RGB_LINECACHE);
619  av_bprintf(&shd->src, "#define CONTEXT_SIZE %i\n" ,CONTEXT_SIZE);
620  av_bprintf(&shd->src, "#define MAX_QUANT_TABLE_MASK 0x%x\n" ,MAX_QUANT_TABLE_MASK);
621 
622  GLSLF(0, #define TYPE int%i_t ,smp_bits);
623  GLSLF(0, #define VTYPE2 i%ivec2 ,smp_bits);
624  GLSLF(0, #define VTYPE3 i%ivec3 ,smp_bits);
625  GLSLD(ff_source_rangecoder_comp);
626  GLSLD(ff_source_ffv1_common_comp);
627 }
628 
629 static int init_setup_shader(FFV1Context *f, FFVulkanContext *s,
630  FFVkExecPool *pool, FFVkSPIRVCompiler *spv,
631  FFVulkanShader *shd)
632 {
633  int err;
634  FFVulkanDescriptorSetBinding *desc_set;
635 
636  uint8_t *spv_data;
637  size_t spv_len;
638  void *spv_opaque = NULL;
639 
640  RET(ff_vk_shader_init(s, shd, "ffv1_dec_setup",
641  VK_SHADER_STAGE_COMPUTE_BIT,
642  (const char *[]) { "GL_EXT_buffer_reference",
643  "GL_EXT_buffer_reference2" }, 2,
644  1, 1, 1,
645  0));
646 
647  /* Common codec header */
648  GLSLD(ff_source_common_comp);
649 
650  add_push_data(shd);
651 
652  av_bprintf(&shd->src, "#define MAX_QUANT_TABLES %i\n", MAX_QUANT_TABLES);
653  av_bprintf(&shd->src, "#define MAX_CONTEXT_INPUTS %i\n", MAX_CONTEXT_INPUTS);
654  av_bprintf(&shd->src, "#define MAX_QUANT_TABLE_SIZE %i\n", MAX_QUANT_TABLE_SIZE);
655 
656  desc_set = (FFVulkanDescriptorSetBinding []) {
657  {
658  .name = "rangecoder_static_buf",
659  .type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
660  .stages = VK_SHADER_STAGE_COMPUTE_BIT,
661  .mem_layout = "scalar",
662  .buf_content = "uint8_t zero_one_state[512];",
663  },
664  {
665  .name = "crc_ieee_buf",
666  .type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
667  .stages = VK_SHADER_STAGE_COMPUTE_BIT,
668  .mem_layout = "scalar",
669  .buf_content = "uint32_t crc_ieee[256];",
670  },
671  {
672  .name = "quant_buf",
673  .type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
674  .stages = VK_SHADER_STAGE_COMPUTE_BIT,
675  .mem_layout = "scalar",
676  .buf_content = "int16_t quant_table[MAX_QUANT_TABLES]"
677  "[MAX_CONTEXT_INPUTS][MAX_QUANT_TABLE_SIZE];",
678  },
679  };
680 
681  RET(ff_vk_shader_add_descriptor_set(s, shd, desc_set, 3, 1, 0));
682 
683  define_shared_code(shd, 0 /* Irrelevant */);
684 
685  desc_set = (FFVulkanDescriptorSetBinding []) {
686  {
687  .name = "slice_data_buf",
688  .type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
689  .stages = VK_SHADER_STAGE_COMPUTE_BIT,
690  .buf_content = "SliceContext slice_ctx",
691  .buf_elems = f->max_slice_count,
692  },
693  {
694  .name = "slice_offsets_buf",
695  .type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
696  .stages = VK_SHADER_STAGE_COMPUTE_BIT,
697  .mem_quali = "readonly",
698  .buf_content = "u32vec2 slice_offsets",
699  .buf_elems = 2*f->max_slice_count,
700  },
701  {
702  .name = "slice_status_buf",
703  .type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
704  .stages = VK_SHADER_STAGE_COMPUTE_BIT,
705  .mem_quali = "writeonly",
706  .buf_content = "uint32_t slice_status",
707  .buf_elems = 2*f->max_slice_count,
708  },
709  };
710  RET(ff_vk_shader_add_descriptor_set(s, shd, desc_set, 3, 0, 0));
711 
712  GLSLD(ff_source_ffv1_dec_setup_comp);
713 
714  RET(spv->compile_shader(s, spv, shd, &spv_data, &spv_len, "main",
715  &spv_opaque));
716  RET(ff_vk_shader_link(s, shd, spv_data, spv_len, "main"));
717 
718  RET(ff_vk_shader_register_exec(s, pool, shd));
719 
720 fail:
721  if (spv_opaque)
722  spv->free_shader(spv, &spv_opaque);
723 
724  return err;
725 }
726 
727 static int init_reset_shader(FFV1Context *f, FFVulkanContext *s,
728  FFVkExecPool *pool, FFVkSPIRVCompiler *spv,
729  FFVulkanShader *shd, int ac)
730 {
731  int err;
732  FFVulkanDescriptorSetBinding *desc_set;
733 
734  uint8_t *spv_data;
735  size_t spv_len;
736  void *spv_opaque = NULL;
737  int wg_dim = FFMIN(s->props.properties.limits.maxComputeWorkGroupSize[0], 1024);
738 
739  RET(ff_vk_shader_init(s, shd, "ffv1_dec_reset",
740  VK_SHADER_STAGE_COMPUTE_BIT,
741  (const char *[]) { "GL_EXT_buffer_reference",
742  "GL_EXT_buffer_reference2" }, 2,
743  wg_dim, 1, 1,
744  0));
745 
746  if (ac == AC_GOLOMB_RICE)
747  av_bprintf(&shd->src, "#define GOLOMB\n");
748 
749  /* Common codec header */
750  GLSLD(ff_source_common_comp);
751 
752  GLSLC(0, layout(push_constant, scalar) uniform pushConstants { );
753  GLSLF(1, uint context_count[%i]; ,MAX_QUANT_TABLES);
754  GLSLC(1, u8buf slice_state; );
755  GLSLC(1, uint plane_state_size; );
756  GLSLC(1, uint8_t codec_planes; );
757  GLSLC(1, uint8_t key_frame; );
758  GLSLC(1, uint8_t version; );
759  GLSLC(1, uint8_t micro_version; );
760  GLSLC(1, uint8_t padding[1]; );
761  GLSLC(0, }; );
762  ff_vk_shader_add_push_const(shd, 0, sizeof(FFv1VkResetParameters),
763  VK_SHADER_STAGE_COMPUTE_BIT);
764 
765  av_bprintf(&shd->src, "#define MAX_QUANT_TABLES %i\n", MAX_QUANT_TABLES);
766  av_bprintf(&shd->src, "#define MAX_CONTEXT_INPUTS %i\n", MAX_CONTEXT_INPUTS);
767  av_bprintf(&shd->src, "#define MAX_QUANT_TABLE_SIZE %i\n", MAX_QUANT_TABLE_SIZE);
768 
769  desc_set = (FFVulkanDescriptorSetBinding []) {
770  {
771  .name = "rangecoder_static_buf",
772  .type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
773  .stages = VK_SHADER_STAGE_COMPUTE_BIT,
774  .mem_layout = "scalar",
775  .buf_content = "uint8_t zero_one_state[512];",
776  },
777  {
778  .name = "quant_buf",
779  .type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
780  .stages = VK_SHADER_STAGE_COMPUTE_BIT,
781  .mem_layout = "scalar",
782  .buf_content = "int16_t quant_table[MAX_QUANT_TABLES]"
783  "[MAX_CONTEXT_INPUTS][MAX_QUANT_TABLE_SIZE];",
784  },
785  };
786  RET(ff_vk_shader_add_descriptor_set(s, shd, desc_set, 2, 1, 0));
787 
788  define_shared_code(shd, 0 /* Bit depth irrelevant for the reset shader */);
789  if (ac == AC_GOLOMB_RICE)
790  GLSLD(ff_source_ffv1_vlc_comp);
791 
792  desc_set = (FFVulkanDescriptorSetBinding []) {
793  {
794  .name = "slice_data_buf",
795  .type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
796  .mem_quali = "readonly",
797  .stages = VK_SHADER_STAGE_COMPUTE_BIT,
798  .buf_content = "SliceContext slice_ctx",
799  .buf_elems = f->max_slice_count,
800  },
801  };
802  RET(ff_vk_shader_add_descriptor_set(s, shd, desc_set, 1, 0, 0));
803 
804  GLSLD(ff_source_ffv1_reset_comp);
805 
806  RET(spv->compile_shader(s, spv, shd, &spv_data, &spv_len, "main",
807  &spv_opaque));
808  RET(ff_vk_shader_link(s, shd, spv_data, spv_len, "main"));
809 
810  RET(ff_vk_shader_register_exec(s, pool, shd));
811 
812 fail:
813  if (spv_opaque)
814  spv->free_shader(spv, &spv_opaque);
815 
816  return err;
817 }
818 
819 static int init_decode_shader(FFV1Context *f, FFVulkanContext *s,
820  FFVkExecPool *pool, FFVkSPIRVCompiler *spv,
821  FFVulkanShader *shd,
822  AVHWFramesContext *dec_frames_ctx,
823  AVHWFramesContext *out_frames_ctx,
824  int ac, int rgb)
825 {
826  int err;
827  FFVulkanDescriptorSetBinding *desc_set;
828 
829  uint8_t *spv_data;
830  size_t spv_len;
831  void *spv_opaque = NULL;
832 
833  int use_cached_reader = ac != AC_GOLOMB_RICE &&
834  s->driver_props.driverID == VK_DRIVER_ID_MESA_RADV;
835 
836  RET(ff_vk_shader_init(s, shd, "ffv1_dec",
837  VK_SHADER_STAGE_COMPUTE_BIT,
838  (const char *[]) { "GL_EXT_buffer_reference",
839  "GL_EXT_buffer_reference2" }, 2,
840  use_cached_reader ? CONTEXT_SIZE : 1, 1, 1,
841  0));
842 
843  if (ac == AC_GOLOMB_RICE)
844  av_bprintf(&shd->src, "#define GOLOMB\n");
845 
846  if (rgb)
847  av_bprintf(&shd->src, "#define RGB\n");
848 
849  if (use_cached_reader)
850  av_bprintf(&shd->src, "#define CACHED_SYMBOL_READER 1\n");
851 
852  /* Common codec header */
853  GLSLD(ff_source_common_comp);
854 
855  add_push_data(shd);
856 
857  av_bprintf(&shd->src, "#define MAX_QUANT_TABLES %i\n", MAX_QUANT_TABLES);
858  av_bprintf(&shd->src, "#define MAX_CONTEXT_INPUTS %i\n", MAX_CONTEXT_INPUTS);
859  av_bprintf(&shd->src, "#define MAX_QUANT_TABLE_SIZE %i\n", MAX_QUANT_TABLE_SIZE);
860 
861  desc_set = (FFVulkanDescriptorSetBinding []) {
862  {
863  .name = "rangecoder_static_buf",
864  .type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
865  .stages = VK_SHADER_STAGE_COMPUTE_BIT,
866  .mem_layout = "scalar",
867  .buf_content = "uint8_t zero_one_state[512];",
868  },
869  {
870  .name = "quant_buf",
871  .type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
872  .stages = VK_SHADER_STAGE_COMPUTE_BIT,
873  .mem_layout = "scalar",
874  .buf_content = "int16_t quant_table[MAX_QUANT_TABLES]"
875  "[MAX_CONTEXT_INPUTS][MAX_QUANT_TABLE_SIZE];",
876  },
877  };
878 
879  RET(ff_vk_shader_add_descriptor_set(s, shd, desc_set, 2, 1, 0));
880 
881  define_shared_code(shd, f->use32bit);
882  if (ac == AC_GOLOMB_RICE)
883  GLSLD(ff_source_ffv1_vlc_comp);
884 
885  desc_set = (FFVulkanDescriptorSetBinding []) {
886  {
887  .name = "slice_data_buf",
888  .type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
889  .stages = VK_SHADER_STAGE_COMPUTE_BIT,
890  .buf_content = "SliceContext slice_ctx",
891  .buf_elems = f->max_slice_count,
892  },
893  {
894  .name = "dec",
895  .type = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
896  .dimensions = 2,
897  .mem_layout = ff_vk_shader_rep_fmt(dec_frames_ctx->sw_format,
898  FF_VK_REP_NATIVE),
899  .elems = av_pix_fmt_count_planes(dec_frames_ctx->sw_format),
900  .stages = VK_SHADER_STAGE_COMPUTE_BIT,
901  },
902  {
903  .name = "slice_status_buf",
904  .type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
905  .stages = VK_SHADER_STAGE_COMPUTE_BIT,
906  .mem_quali = "writeonly",
907  .buf_content = "uint32_t slice_status",
908  .buf_elems = 2*f->max_slice_count,
909  },
910  {
911  .name = "dst",
912  .type = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
913  .dimensions = 2,
914  .mem_layout = ff_vk_shader_rep_fmt(out_frames_ctx->sw_format,
915  FF_VK_REP_NATIVE),
916  .mem_quali = "writeonly",
917  .elems = av_pix_fmt_count_planes(out_frames_ctx->sw_format),
918  .stages = VK_SHADER_STAGE_COMPUTE_BIT,
919  },
920  };
921  RET(ff_vk_shader_add_descriptor_set(s, shd, desc_set, 3 + rgb, 0, 0));
922 
923  GLSLD(ff_source_ffv1_dec_comp);
924 
925  RET(spv->compile_shader(s, spv, shd, &spv_data, &spv_len, "main",
926  &spv_opaque));
927  RET(ff_vk_shader_link(s, shd, spv_data, spv_len, "main"));
928 
929  RET(ff_vk_shader_register_exec(s, pool, shd));
930 
931 fail:
932  if (spv_opaque)
933  spv->free_shader(spv, &spv_opaque);
934 
935  return err;
936 }
937 
938 static int init_indirect(AVCodecContext *avctx, FFVulkanContext *s,
939  AVBufferRef **dst, enum AVPixelFormat sw_format)
940 {
941  int err;
942  AVHWFramesContext *frames_ctx;
943  AVVulkanFramesContext *vk_frames;
944  FFV1Context *f = avctx->priv_data;
945 
946  *dst = av_hwframe_ctx_alloc(s->device_ref);
947  if (!(*dst))
948  return AVERROR(ENOMEM);
949 
950  frames_ctx = (AVHWFramesContext *)((*dst)->data);
951  frames_ctx->format = AV_PIX_FMT_VULKAN;
952  frames_ctx->sw_format = sw_format;
953  frames_ctx->width = s->frames->width;
954  frames_ctx->height = f->num_v_slices*RGB_LINECACHE;
955 
956  vk_frames = frames_ctx->hwctx;
957  vk_frames->tiling = VK_IMAGE_TILING_OPTIMAL;
958  vk_frames->img_flags = VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
959  vk_frames->usage = VK_IMAGE_USAGE_STORAGE_BIT |
960  VK_IMAGE_USAGE_TRANSFER_DST_BIT;
961 
962  err = av_hwframe_ctx_init(*dst);
963  if (err < 0) {
964  av_log(avctx, AV_LOG_ERROR, "Unable to initialize frame pool with format %s: %s\n",
965  av_get_pix_fmt_name(sw_format), av_err2str(err));
966  av_buffer_unref(dst);
967  return err;
968  }
969 
970  return 0;
971 }
972 
973 static void vk_decode_ffv1_uninit(FFVulkanDecodeShared *ctx)
974 {
975  FFv1VulkanDecodeContext *fv = ctx->sd_ctx;
976 
977  av_buffer_unref(&fv->intermediate_frames_ref);
978 
979  ff_vk_shader_free(&ctx->s, &fv->setup);
980  ff_vk_shader_free(&ctx->s, &fv->reset);
981  ff_vk_shader_free(&ctx->s, &fv->decode);
982 
983  ff_vk_free_buf(&ctx->s, &fv->quant_buf);
984  ff_vk_free_buf(&ctx->s, &fv->rangecoder_static_buf);
985  ff_vk_free_buf(&ctx->s, &fv->crc_tab_buf);
986 
987  av_buffer_pool_uninit(&fv->slice_state_pool);
988  av_buffer_pool_uninit(&fv->slice_offset_pool);
989  av_buffer_pool_uninit(&fv->slice_status_pool);
990 
991  av_freep(&fv);
992 }
993 
994 static int vk_decode_ffv1_init(AVCodecContext *avctx)
995 {
996  int err;
997  FFV1Context *f = avctx->priv_data;
998  FFVulkanDecodeContext *dec = avctx->internal->hwaccel_priv_data;
999  FFVulkanDecodeShared *ctx = NULL;
1000  FFv1VulkanDecodeContext *fv;
1001  FFVkSPIRVCompiler *spv;
1002 
1003  if (f->version < 3 ||
1004  (f->version == 4 && f->micro_version > 3))
1005  return AVERROR(ENOTSUP);
1006 
1007  spv = ff_vk_spirv_init();
1008  if (!spv) {
1009  av_log(avctx, AV_LOG_ERROR, "Unable to initialize SPIR-V compiler!\n");
1010  return AVERROR_EXTERNAL;
1011  }
1012 
1013  err = ff_vk_decode_init(avctx);
1014  if (err < 0)
1015  return err;
1016  ctx = dec->shared_ctx;
1017 
1018  fv = ctx->sd_ctx = av_mallocz(sizeof(*fv));
1019  if (!fv) {
1020  err = AVERROR(ENOMEM);
1021  goto fail;
1022  }
1023 
1024  ctx->sd_ctx_free = &vk_decode_ffv1_uninit;
1025 
1026  AVHWFramesContext *hwfc = (AVHWFramesContext *)avctx->hw_frames_ctx->data;
1027  AVHWFramesContext *dctx = hwfc;
1028  enum AVPixelFormat sw_format = hwfc->sw_format;
1029  int is_rgb = !(f->colorspace == 0 && sw_format != AV_PIX_FMT_YA8) &&
1030  !(sw_format == AV_PIX_FMT_YA8);
1031 
1032  /* Intermediate frame pool for RCT */
1033  if (is_rgb) {
1034  RET(init_indirect(avctx, &ctx->s, &fv->intermediate_frames_ref,
1035  f->use32bit ? AV_PIX_FMT_GBRAP32 : AV_PIX_FMT_GBRAP16));
1036  dctx = (AVHWFramesContext *)fv->intermediate_frames_ref->data;
1037  }
1038 
1039  /* Setup shader */
1040  RET(init_setup_shader(f, &ctx->s, &ctx->exec_pool, spv, &fv->setup));
1041 
1042  /* Reset shader */
1043  RET(init_reset_shader(f, &ctx->s, &ctx->exec_pool,
1044  spv, &fv->reset, f->ac));
1045 
1046  /* Decode shaders */
1047  RET(init_decode_shader(f, &ctx->s, &ctx->exec_pool,
1048  spv, &fv->decode,
1049  dctx,
1050  hwfc,
1051  f->ac,
1052  is_rgb));
1053 
1054  /* Range coder data */
1055  RET(ff_ffv1_vk_init_state_transition_data(&ctx->s,
1056  &fv->rangecoder_static_buf,
1057  f));
1058 
1059  /* Quantization table data */
1060  RET(ff_ffv1_vk_init_quant_table_data(&ctx->s,
1061  &fv->quant_buf,
1062  f));
1063 
1064  /* CRC table buffer */
1065  RET(ff_ffv1_vk_init_crc_table_data(&ctx->s,
1066  &fv->crc_tab_buf,
1067  f));
1068 
1069  /* Update setup global descriptors */
1070  RET(ff_vk_shader_update_desc_buffer(&ctx->s, &ctx->exec_pool.contexts[0],
1071  &fv->setup, 0, 0, 0,
1072  &fv->rangecoder_static_buf,
1073  0, fv->rangecoder_static_buf.size,
1074  VK_FORMAT_UNDEFINED));
1075  RET(ff_vk_shader_update_desc_buffer(&ctx->s, &ctx->exec_pool.contexts[0],
1076  &fv->setup, 0, 1, 0,
1077  &fv->crc_tab_buf,
1078  0, fv->crc_tab_buf.size,
1079  VK_FORMAT_UNDEFINED));
1080 
1081  /* Update decode global descriptors */
1082  RET(ff_vk_shader_update_desc_buffer(&ctx->s, &ctx->exec_pool.contexts[0],
1083  &fv->decode, 0, 0, 0,
1084  &fv->rangecoder_static_buf,
1085  0, fv->rangecoder_static_buf.size,
1086  VK_FORMAT_UNDEFINED));
1087  RET(ff_vk_shader_update_desc_buffer(&ctx->s, &ctx->exec_pool.contexts[0],
1088  &fv->decode, 0, 1, 0,
1089  &fv->quant_buf,
1090  0, fv->quant_buf.size,
1091  VK_FORMAT_UNDEFINED));
1092 
1093 fail:
1094  spv->uninit(&spv);
1095 
1096  return err;
1097 }
1098 
1099 static void vk_ffv1_free_frame_priv(AVRefStructOpaque _hwctx, void *data)
1100 {
1101  AVHWDeviceContext *dev_ctx = _hwctx.nc;
1102  AVVulkanDeviceContext *hwctx = dev_ctx->hwctx;
1103 
1104  FFv1VulkanDecodePicture *fp = data;
1105  FFVulkanDecodePicture *vp = &fp->vp;
1106  FFVkBuffer *slice_status = (FFVkBuffer *)fp->slice_status_buf->data;
1107 
1108  ff_vk_decode_free_frame(dev_ctx, vp);
1109 
1110  /* Invalidate slice/output data if needed */
1111  if (!(slice_status->flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)) {
1112  VkMappedMemoryRange invalidate_data = {
1113  .sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE,
1114  .memory = slice_status->mem,
1115  .offset = 0,
1116  .size = 2*fp->slice_num*sizeof(uint32_t),
1117  };
1118  vp->invalidate_memory_ranges(hwctx->act_dev,
1119  1, &invalidate_data);
1120  }
1121 
1122  for (int i = 0; i < fp->slice_num; i++) {
1123  uint32_t crc_res = 0;
1124  if (fp->crc_checked)
1125  crc_res = AV_RN32(slice_status->mapped_mem + 2*i*sizeof(uint32_t) + 0);
1126  uint32_t status = AV_RN32(slice_status->mapped_mem + 2*i*sizeof(uint32_t) + 4);
1127  if (status || crc_res)
1128  av_log(dev_ctx, AV_LOG_ERROR, "Slice %i status: 0x%x, CRC 0x%x\n",
1129  i, status, crc_res);
1130  }
1131 
1132  av_buffer_unref(&fp->slice_state);
1133  av_buffer_unref(&fp->slice_offset_buf);
1134  av_buffer_unref(&fp->slice_status_buf);
1135 }
1136 
1137 const FFHWAccel ff_ffv1_vulkan_hwaccel = {
1138  .p.name = "ffv1_vulkan",
1139  .p.type = AVMEDIA_TYPE_VIDEO,
1140  .p.id = AV_CODEC_ID_FFV1,
1141  .p.pix_fmt = AV_PIX_FMT_VULKAN,
1142  .start_frame = &vk_ffv1_start_frame,
1143  .decode_slice = &vk_ffv1_decode_slice,
1144  .end_frame = &vk_ffv1_end_frame,
1145  .free_frame_priv = &vk_ffv1_free_frame_priv,
1146  .frame_priv_data_size = sizeof(FFv1VulkanDecodePicture),
1147  .init = &vk_decode_ffv1_init,
1148  .update_thread_context = &ff_vk_update_thread_context,
1149  .decode_params = &ff_vk_params_invalidate,
1150  .flush = &ff_vk_decode_flush,
1151  .uninit = &ff_vk_decode_uninit,
1152  .frame_params = &ff_vk_frame_params,
1153  .priv_data_size = sizeof(FFVulkanDecodeContext),
1154  .caps_internal = HWACCEL_CAP_ASYNC_SAFE | HWACCEL_CAP_THREAD_SAFE,
1155 };
AVHWDeviceContext::hwctx
void * hwctx
The format-specific data, allocated and freed by libavutil along with this context.
Definition: hwcontext.h:88
AV_PIX_FMT_GBRAP16
#define AV_PIX_FMT_GBRAP16
Definition: pixfmt.h:565
FFv1VkResetParameters::context_count
uint32_t context_count[MAX_QUANT_TABLES]
Definition: ffv1_vulkan.h:52
FFv1VkParameters::planes
uint8_t planes
Definition: ffv1enc_vulkan.c:141
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
FFv1VkParameters::extend_lookup
uint8_t extend_lookup[8]
Definition: ffv1enc_vulkan.c:133
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
AV_PIX_FMT_YA8
@ AV_PIX_FMT_YA8
8 bits gray, 8 bits alpha
Definition: pixfmt.h:140
ff_source_ffv1_dec_setup_comp
const char * ff_source_ffv1_dec_setup_comp
ff_vk_shader_free
void ff_vk_shader_free(FFVulkanContext *s, FFVulkanShader *shd)
Free a shader.
Definition: vulkan.c:2961
FFv1VulkanDecodeContext::rangecoder_static_buf
FFVkBuffer rangecoder_static_buf
Definition: vulkan_ffv1.c:68
ff_vk_shader_init
int ff_vk_shader_init(FFVulkanContext *s, FFVulkanShader *shd, const char *name, VkPipelineStageFlags stage, const char *extensions[], int nb_extensions, int lg_x, int lg_y, int lg_z, uint32_t required_subgroup_size)
Initialize a shader object, with a specific set of extensions, type+bind, local group size,...
Definition: vulkan.c:2093
AVBufferPool
The buffer pool.
Definition: buffer_internal.h:88
ff_vk_decode_prepare_frame_sdr
int ff_vk_decode_prepare_frame_sdr(FFVulkanDecodeContext *dec, AVFrame *pic, FFVulkanDecodePicture *vkpic, int is_current, enum FFVkShaderRepFormat rep_fmt, int alloc_dpb)
Software-defined decoder version of ff_vk_decode_prepare_frame.
Definition: vulkan_decode.c:247
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3456
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:90
FFVulkanDecodeContext::shared_ctx
FFVulkanDecodeShared * shared_ctx
Definition: vulkan_decode.h:57
RET
#define RET(x)
Definition: vulkan.h:66
AVRefStructOpaque
RefStruct is an API for creating reference-counted objects with minimal overhead.
Definition: refstruct.h:58
AVHWFramesContext::format
enum AVPixelFormat format
The pixel format identifying the underlying HW surface type.
Definition: hwcontext.h:200
AVCodecContext::err_recognition
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:1398
FFv1VkParameters::slice_data
VkDeviceAddress slice_data
Definition: vulkan_ffv1.c:78
AVRefStructOpaque::nc
void * nc
Definition: refstruct.h:59
av_unused
#define av_unused
Definition: attributes.h:151
FFVulkanDecodePicture::invalidate_memory_ranges
PFN_vkInvalidateMappedMemoryRanges invalidate_memory_ranges
Definition: vulkan_decode.h:107
FFHWAccel::p
AVHWAccel p
The public AVHWAccel.
Definition: hwaccel_internal.h:38
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:64
FFv1VkParameters::key_frame
uint8_t key_frame
Definition: ffv1enc_vulkan.c:139
av_hwframe_ctx_init
int av_hwframe_ctx_init(AVBufferRef *ref)
Finalize the context before use.
Definition: hwcontext.c:337
ff_ffv1_vk_init_quant_table_data
int ff_ffv1_vk_init_quant_table_data(FFVulkanContext *s, FFVkBuffer *vkb, FFV1Context *f)
Definition: ffv1_vulkan.c:72
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:427
FFv1VkParameters::slice_state
VkDeviceAddress slice_state
Definition: ffv1enc_vulkan.c:119
av_hwframe_ctx_alloc
AVBufferRef * av_hwframe_ctx_alloc(AVBufferRef *device_ref_in)
Allocate an AVHWFramesContext tied to a given device context.
Definition: hwcontext.c:263
FFv1VulkanDecodePicture::slice_data_size
uint32_t slice_data_size
Definition: vulkan_ffv1.c:51
FFVulkanShader::src
AVBPrint src
Definition: vulkan.h:195
MAX_QUANT_TABLE_SIZE
#define MAX_QUANT_TABLE_SIZE
Definition: ffv1.h:48
ff_source_ffv1_vlc_comp
const char * ff_source_ffv1_vlc_comp
data
const char data[16]
Definition: mxf.c:149
FFVulkanDecodeDescriptor::codec_id
enum AVCodecID codec_id
Definition: vulkan_decode.h:30
FFv1VkResetParameters::slice_state
VkDeviceAddress slice_state
Definition: ffv1_vulkan.h:53
FFVkBuffer::address
VkDeviceAddress address
Definition: vulkan.h:92
ff_source_ffv1_common_comp
const char * ff_source_ffv1_common_comp
ff_vk_exec_get
FFVkExecContext * ff_vk_exec_get(FFVulkanContext *s, FFVkExecPool *pool)
Retrieve an execution pool.
Definition: vulkan.c:547
FF_VK_REP_NATIVE
@ FF_VK_REP_NATIVE
Definition: vulkan.h:406
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
FFVkSPIRVCompiler::uninit
void(* uninit)(struct FFVkSPIRVCompiler **ctx)
Definition: vulkan_spirv.h:32
av_buffer_ref
AVBufferRef * av_buffer_ref(const AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:103
AVHWFramesContext::width
int width
The allocated dimensions of the frames in this pool.
Definition: hwcontext.h:220
FFv1VkParameters::micro_version
uint8_t micro_version
Definition: ffv1enc_vulkan.c:137
FFv1VkParameters::padding
uint8_t padding[3]
Definition: ffv1enc_vulkan.c:151
FFv1VulkanDecodePicture::slice_status_buf
AVBufferRef * slice_status_buf
Definition: vulkan_ffv1.c:57
FFv1VkParameters::golomb
uint8_t golomb
Definition: vulkan_ffv1.c:102
FFVulkanDecodeContext
Definition: vulkan_decode.h:56
AV_PIX_FMT_VULKAN
@ AV_PIX_FMT_VULKAN
Vulkan hardware images.
Definition: pixfmt.h:379
ff_vk_exec_add_dep_frame
int ff_vk_exec_add_dep_frame(FFVulkanContext *s, FFVkExecContext *e, AVFrame *f, VkPipelineStageFlagBits2 wait_stage, VkPipelineStageFlagBits2 signal_stage)
Definition: vulkan.c:779
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:448
FFv1VulkanDecodeContext::slice_state_pool
AVBufferPool * slice_state_pool
Definition: vulkan_ffv1.c:72
FFv1VkParameters::color_planes
uint8_t color_planes
Definition: vulkan_ffv1.c:97
av_pix_fmt_count_planes
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3496
init_decode_shader
static int init_decode_shader(FFV1Context *f, FFVulkanContext *s, FFVkExecPool *pool, FFVkSPIRVCompiler *spv, FFVulkanShader *shd, AVHWFramesContext *dec_frames_ctx, AVHWFramesContext *out_frames_ctx, int ac, int rgb)
Definition: vulkan_ffv1.c:819
rgb
Definition: rpzaenc.c:60
MAX_QUANT_TABLE_MASK
#define MAX_QUANT_TABLE_MASK
Definition: ffv1.h:49
AV_PIX_FMT_GBRP14
#define AV_PIX_FMT_GBRP14
Definition: pixfmt.h:560
FFHWAccel
Definition: hwaccel_internal.h:34
AVVkFrame::img
VkImage img[AV_NUM_DATA_POINTERS]
Vulkan images to which the memory is bound to.
Definition: hwcontext_vulkan.h:303
FFv1VulkanDecodeContext::reset
FFVulkanShader reset
Definition: vulkan_ffv1.c:65
fail
#define fail()
Definition: checkasm.h:208
FFVulkanDecodePicture::sem_value
uint64_t sem_value
Definition: vulkan_decode.h:87
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:558
init_indirect
static int init_indirect(AVCodecContext *avctx, FFVulkanContext *s, AVBufferRef **dst, enum AVPixelFormat sw_format)
Definition: vulkan_ffv1.c:938
ff_vk_shader_update_img_array
void ff_vk_shader_update_img_array(FFVulkanContext *s, FFVkExecContext *e, FFVulkanShader *shd, AVFrame *f, VkImageView *views, int set, int binding, VkImageLayout layout, VkSampler sampler)
Update a descriptor in a buffer with an image array.
Definition: vulkan.c:2838
AVVulkanFramesContext
Allocated as AVHWFramesContext.hwctx, used to set pool-specific options.
Definition: hwcontext_vulkan.h:208
ff_vk_frame_barrier
void ff_vk_frame_barrier(FFVulkanContext *s, FFVkExecContext *e, AVFrame *pic, VkImageMemoryBarrier2 *bar, int *nb_bar, VkPipelineStageFlags2 src_stage, VkPipelineStageFlags2 dst_stage, VkAccessFlagBits2 new_access, VkImageLayout new_layout, uint32_t new_qf)
Definition: vulkan.c:2050
FFv1VkParameters::transparency
uint8_t transparency
Definition: ffv1enc_vulkan.c:144
HWACCEL_CAP_THREAD_SAFE
#define HWACCEL_CAP_THREAD_SAFE
Definition: hwaccel_internal.h:32
ff_vk_shader_register_exec
int ff_vk_shader_register_exec(FFVulkanContext *s, FFVkExecPool *pool, FFVulkanShader *shd)
Register a shader with an exec pool.
Definition: vulkan.c:2601
init_setup_shader
static int init_setup_shader(FFV1Context *f, FFVulkanContext *s, FFVkExecPool *pool, FFVkSPIRVCompiler *spv, FFVulkanShader *shd)
Definition: vulkan_ffv1.c:629
FFv1VkParameters::plane_state_size
uint32_t plane_state_size
Definition: ffv1enc_vulkan.c:127
ff_vk_host_map_buffer
int ff_vk_host_map_buffer(FFVulkanContext *s, AVBufferRef **dst, uint8_t *src_data, const AVBufferRef *src_buf, VkBufferUsageFlags usage)
Maps a system RAM buffer into a Vulkan buffer.
Definition: vulkan.c:1392
ff_vk_shader_add_descriptor_set
int ff_vk_shader_add_descriptor_set(FFVulkanContext *s, FFVulkanShader *shd, FFVulkanDescriptorSetBinding *desc, int nb, int singular, int print_to_shader_only)
Add descriptor to a shader.
Definition: vulkan.c:2465
CONTEXT_SIZE
#define CONTEXT_SIZE
Definition: ffv1.h:45
add_push_data
static void add_push_data(FFVulkanShader *shd)
Definition: vulkan_ffv1.c:107
FFVulkanDecodeShared
Definition: vulkan_decode.h:38
AVHWDeviceContext
This struct aggregates all the (hardware/vendor-specific) "high-level" state, i.e.
Definition: hwcontext.h:63
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:52
GLSLC
#define GLSLC(N, S)
Definition: vulkan.h:43
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
FFv1VulkanDecodeContext::slice_status_pool
AVBufferPool * slice_status_pool
Definition: vulkan_ffv1.c:74
AVHWFramesContext::height
int height
Definition: hwcontext.h:220
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition: frame.h:642
FFv1VkParameters::codec_planes
uint8_t codec_planes
Definition: ffv1enc_vulkan.c:142
define_shared_code
static void define_shared_code(FFVulkanShader *shd, int use32bit)
Definition: vulkan_ffv1.c:612
s
#define s(width, name)
Definition: cbs_vp9.c:198
FFVulkanDecodePicture
Definition: vulkan_decode.h:75
ff_vk_exec_mirror_sem_value
int ff_vk_exec_mirror_sem_value(FFVulkanContext *s, FFVkExecContext *e, VkSemaphore *dst, uint64_t *dst_val, AVFrame *f)
Definition: vulkan.c:878
FFVulkanDecodePicture::view
struct FFVulkanDecodePicture::@326 view
FFv1VulkanDecodeContext
Definition: vulkan_ffv1.c:61
FFv1VkParameters::bits_per_raw_sample
uint8_t bits_per_raw_sample
Definition: ffv1enc_vulkan.c:134
ff_vk_set_perm
void ff_vk_set_perm(enum AVPixelFormat pix_fmt, int lut[4], int inv)
Since storage images may not be swizzled, we have to do this in the shader itself.
Definition: vulkan.c:1582
bits
uint8_t bits
Definition: vp3data.h:128
AVVulkanFramesContext::img_flags
VkImageCreateFlags img_flags
Flags to set during image creation.
Definition: hwcontext_vulkan.h:261
AV_PIX_FMT_GBRAP32
#define AV_PIX_FMT_GBRAP32
Definition: pixfmt.h:566
ctx
AVFormatContext * ctx
Definition: movenc.c:49
FFv1VulkanDecodePicture::vp
FFVulkanDecodePicture vp
Definition: vulkan_ffv1.c:46
vk_ffv1_decode_slice
static int vk_ffv1_decode_slice(AVCodecContext *avctx, const uint8_t *data, uint32_t size)
Definition: vulkan_ffv1.c:251
FFv1VulkanDecodePicture
Definition: vulkan_ffv1.c:45
ff_vk_exec_add_dep_buf
int ff_vk_exec_add_dep_buf(FFVulkanContext *s, FFVkExecContext *e, AVBufferRef **deps, int nb_deps, int ref)
Execution dependency management.
Definition: vulkan.c:619
GLSLD
#define GLSLD(D)
Definition: vulkan.h:58
FFv1VkParameters::crcref
uint32_t crcref
Definition: ffv1enc_vulkan.c:129
vk_decode_ffv1_uninit
static void vk_decode_ffv1_uninit(FFVulkanDecodeShared *ctx)
Definition: vulkan_ffv1.c:973
init_reset_shader
static int init_reset_shader(FFV1Context *f, FFVulkanContext *s, FFVkExecPool *pool, FFVkSPIRVCompiler *spv, FFVulkanShader *shd, int ac)
Definition: vulkan_ffv1.c:727
FFv1VulkanDecodePicture::slice_state
AVBufferRef * slice_state
Definition: vulkan_ffv1.c:48
FFv1VulkanDecodePicture::plane_state_size
uint32_t plane_state_size
Definition: vulkan_ffv1.c:49
ff_vk_exec_add_dep_wait_sem
int ff_vk_exec_add_dep_wait_sem(FFVulkanContext *s, FFVkExecContext *e, VkSemaphore sem, uint64_t val, VkPipelineStageFlagBits2 stage)
Definition: vulkan.c:696
FFv1VkParameters::chroma_shift
uint32_t chroma_shift[2]
Definition: ffv1enc_vulkan.c:125
AVVulkanDeviceContext
Main Vulkan context, allocated as AVHWDeviceContext.hwctx.
Definition: hwcontext_vulkan.h:59
TYPE
#define TYPE
Definition: ffv1dec.c:96
HWACCEL_CAP_ASYNC_SAFE
#define HWACCEL_CAP_ASYNC_SAFE
Header providing the internals of AVHWAccel.
Definition: hwaccel_internal.h:31
ff_vk_shader_rep_fmt
const char * ff_vk_shader_rep_fmt(enum AVPixelFormat pix_fmt, enum FFVkShaderRepFormat rep_fmt)
Definition: vulkan.c:1626
NULL
#define NULL
Definition: coverity.c:32
AVHWFramesContext::sw_format
enum AVPixelFormat sw_format
The pixel format identifying the actual data layout of the hardware frames.
Definition: hwcontext.h:213
AC_GOLOMB_RICE
#define AC_GOLOMB_RICE
Definition: ffv1.h:52
av_buffer_unref
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it.
Definition: buffer.c:139
AVPixFmtDescriptor::nb_components
uint8_t nb_components
The number of components each pixel has, (1-4)
Definition: pixdesc.h:71
hwaccel_internal.h
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:617
ff_source_rangecoder_comp
const char * ff_source_rangecoder_comp
AVCodecContext::internal
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:466
FFv1VkParameters::version
uint8_t version
Definition: ffv1enc_vulkan.c:136
vk_ffv1_end_frame
static int vk_ffv1_end_frame(AVCodecContext *avctx)
Definition: vulkan_ffv1.c:286
AV_RN32
#define AV_RN32(p)
Definition: intreadwrite.h:360
av_buffer_pool_uninit
void av_buffer_pool_uninit(AVBufferPool **ppool)
Mark the pool as being available for freeing.
Definition: buffer.c:328
ff_vk_decode_uninit
int ff_vk_decode_uninit(AVCodecContext *avctx)
Free decoder.
Definition: vulkan_decode.c:1215
flush
void(* flush)(AVBSFContext *ctx)
Definition: dts2pts.c:552
FFVkBuffer::size
size_t size
Definition: vulkan.h:91
AVVulkanFramesContext::usage
VkImageUsageFlagBits usage
Defines extra usage of output frames.
Definition: hwcontext_vulkan.h:228
ff_source_ffv1_dec_comp
const char * ff_source_ffv1_dec_comp
ffv1_vulkan.h
FFVkBuffer::mapped_mem
uint8_t * mapped_mem
Definition: vulkan.h:100
FFv1VulkanDecodeContext::slice_offset_pool
AVBufferPool * slice_offset_pool
Definition: vulkan_ffv1.c:73
FFVulkanContext
Definition: vulkan.h:274
FFv1VulkanDecodeContext::quant_buf
FFVkBuffer quant_buf
Definition: vulkan_ffv1.c:69
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:1089
AV_EF_CRCCHECK
#define AV_EF_CRCCHECK
Verify checksums embedded in the bitstream (could be of either encoded or decoded data,...
Definition: defs.h:48
FFv1VkParameters::planar_rgb
uint8_t planar_rgb
Definition: ffv1enc_vulkan.c:143
FFv1VulkanDecodeContext::crc_tab_buf
FFVkBuffer crc_tab_buf
Definition: vulkan_ffv1.c:70
AV_CODEC_ID_FFV1
@ AV_CODEC_ID_FFV1
Definition: codec_id.h:85
f
f
Definition: af_crystalizer.c:122
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:550
FFv1VkParameters::fmt_lut
int32_t fmt_lut[4]
Definition: ffv1enc_vulkan.c:123
ff_vk_shader_update_push_const
void ff_vk_shader_update_push_const(FFVulkanContext *s, FFVkExecContext *e, FFVulkanShader *shd, VkShaderStageFlagBits stage, int offset, size_t size, void *src)
Update push constant in a shader.
Definition: vulkan.c:2917
FFVulkanDescriptorSetBinding
Definition: vulkan.h:74
AV_WN32
#define AV_WN32(p, v)
Definition: intreadwrite.h:372
AVCodecInternal::hwaccel_priv_data
void * hwaccel_priv_data
hwaccel-specific private data
Definition: internal.h:130
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:87
AVVkFrame
Definition: hwcontext_vulkan.h:298
av_err2str
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: error.h:122
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:424
vk_ffv1_free_frame_priv
static void vk_ffv1_free_frame_priv(AVRefStructOpaque _hwctx, void *data)
Definition: vulkan_ffv1.c:1099
size
int size
Definition: twinvq_data.h:10344
AV_NUM_DATA_POINTERS
#define AV_NUM_DATA_POINTERS
Definition: frame.h:428
FFv1VkParameters::quant_table_count
uint8_t quant_table_count
Definition: vulkan_ffv1.c:91
FF_VK_EXT_PUSH_DESCRIPTOR
#define FF_VK_EXT_PUSH_DESCRIPTOR
Definition: vulkan_functions.h:48
FFVulkanShader
Definition: vulkan.h:190
ff_source_ffv1_reset_comp
const char * ff_source_ffv1_reset_comp
ff_ffv1_vk_init_crc_table_data
int ff_ffv1_vk_init_crc_table_data(FFVulkanContext *s, FFVkBuffer *vkb, FFV1Context *f)
Definition: ffv1_vulkan.c:100
DECODE
#define DECODE(size, endian, src, dst, n, shift, offset)
Read PCM samples macro.
Definition: pcm.c:385
FFVkBuffer::flags
VkMemoryPropertyFlagBits flags
Definition: vulkan.h:90
FFv1VulkanDecodeContext::intermediate_frames_ref
AVBufferRef * intermediate_frames_ref
Definition: vulkan_ffv1.c:62
FFVkSPIRVCompiler::compile_shader
int(* compile_shader)(FFVulkanContext *s, struct FFVkSPIRVCompiler *ctx, FFVulkanShader *shd, uint8_t **data, size_t *size, const char *entrypoint, void **opaque)
Definition: vulkan_spirv.h:28
AVERROR_EXTERNAL
#define AVERROR_EXTERNAL
Generic error in an external library.
Definition: error.h:59
FFVkExecContext
Definition: vulkan.h:111
ff_vk_shader_update_desc_buffer
int ff_vk_shader_update_desc_buffer(FFVulkanContext *s, FFVkExecContext *e, FFVulkanShader *shd, int set, int bind, int elem, FFVkBuffer *buf, VkDeviceSize offset, VkDeviceSize len, VkFormat fmt)
Update a descriptor in a buffer with a buffer.
Definition: vulkan.c:2851
FFVulkanDescriptorSetBinding::name
const char * name
Definition: vulkan.h:75
version
version
Definition: libkvazaar.c:313
ff_vk_mt_is_np_rgb
int ff_vk_mt_is_np_rgb(enum AVPixelFormat pix_fmt)
Returns 1 if pixfmt is a usable RGB format.
Definition: vulkan.c:1560
FFVkSPIRVCompiler
Definition: vulkan_spirv.h:26
AVHWAccel::name
const char * name
Name of the hardware accelerated codec.
Definition: avcodec.h:1949
layout
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 layout
Definition: filter_design.txt:18
FF_VK_EXT_EXTERNAL_HOST_MEMORY
#define FF_VK_EXT_EXTERNAL_HOST_MEMORY
Definition: vulkan_functions.h:36
uninit
static void uninit(AVBSFContext *ctx)
Definition: pcm_rechunk.c:68
FFVulkanDecodePicture::out
VkImageView out[AV_NUM_DATA_POINTERS]
Definition: vulkan_decode.h:80
ff_vk_exec_start
int ff_vk_exec_start(FFVulkanContext *s, FFVkExecContext *e)
Start/submit/wait an execution.
Definition: vulkan.c:559
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
FFv1VulkanDecodePicture::slice_state_size
uint32_t slice_state_size
Definition: vulkan_ffv1.c:50
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:559
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
ff_vk_shader_link
int ff_vk_shader_link(FFVulkanContext *s, FFVulkanShader *shd, uint8_t *spirv, size_t spirv_len, const char *entrypoint)
Link a shader into an executable.
Definition: vulkan.c:2390
ffv1.h
FFVkBuffer::mem
VkDeviceMemory mem
Definition: vulkan.h:89
FFVulkanDecodePicture::sem
VkSemaphore sem
Definition: vulkan_decode.h:86
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
planes
static const struct @546 planes[]
vulkan_spirv.h
ff_vk_free_buf
void ff_vk_free_buf(FFVulkanContext *s, FFVkBuffer *buf)
Definition: vulkan.c:1243
MAX_CONTEXT_INPUTS
#define MAX_CONTEXT_INPUTS
Definition: ffv1.h:50
FFVkSPIRVCompiler::free_shader
void(* free_shader)(struct FFVkSPIRVCompiler *ctx, void **opaque)
Definition: vulkan_spirv.h:31
ff_vk_exec_bind_shader
void ff_vk_exec_bind_shader(FFVulkanContext *s, FFVkExecContext *e, FFVulkanShader *shd)
Bind a shader.
Definition: vulkan.c:2927
AVCodecContext::hw_frames_ctx
AVBufferRef * hw_frames_ctx
A reference to the AVHWFramesContext describing the input (for encoding) or output (decoding) frames.
Definition: avcodec.h:1453
AVHWFramesContext
This struct describes a set or pool of "hardware" frames (i.e.
Definition: hwcontext.h:118
ff_vk_decode_flush
void ff_vk_decode_flush(AVCodecContext *avctx)
Flush decoder.
Definition: vulkan_decode.c:375
ff_ffv1_vulkan_hwaccel
const FFHWAccel ff_ffv1_vulkan_hwaccel
Definition: vulkan_ffv1.c:1137
ff_vk_create_imageviews
int ff_vk_create_imageviews(FFVulkanContext *s, FFVkExecContext *e, VkImageView views[AV_NUM_DATA_POINTERS], AVFrame *f, enum FFVkShaderRepFormat rep_fmt)
Create an imageview and add it as a dependency to an execution.
Definition: vulkan.c:1967
AVHWFramesContext::hwctx
void * hwctx
The format-specific data, allocated and freed automatically along with this context.
Definition: hwcontext.h:153
FFVkExecPool
Definition: vulkan.h:252
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:294
av_bprintf
void av_bprintf(AVBPrint *buf, const char *fmt,...)
Definition: bprint.c:122
ff_vk_shader_add_push_const
int ff_vk_shader_add_push_const(FFVulkanShader *shd, int offset, int size, VkShaderStageFlagBits stage)
Add/update push constants for execution.
Definition: vulkan.c:1490
FFVkExecContext::buf
VkCommandBuffer buf
Definition: vulkan.h:122
AVCodecContext
main external API structure.
Definition: avcodec.h:431
status
ov_status_e status
Definition: dnn_backend_openvino.c:100
FFv1VulkanDecodeContext::decode
FFVulkanShader decode
Definition: vulkan_ffv1.c:66
ff_ffv1_vk_init_state_transition_data
int ff_ffv1_vk_init_state_transition_data(FFVulkanContext *s, FFVkBuffer *vkb, FFV1Context *f)
Definition: ffv1_vulkan.c:65
FFv1VkParameters::img_size
uint32_t img_size[2]
Definition: vulkan_ffv1.c:82
ff_vk_dec_ffv1_desc
const FFVulkanDecodeDescriptor ff_vk_dec_ffv1_desc
Definition: vulkan_ffv1.c:39
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
FFv1VkParameters::rct_offset
int rct_offset
Definition: ffv1enc_vulkan.c:131
GLSLF
#define GLSLF(N, S,...)
Definition: vulkan.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
FFv1VulkanDecodePicture::slice_offset
uint32_t * slice_offset
Definition: vulkan_ffv1.c:54
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:152
FFVulkanDecodePicture::dpb_frame
AVFrame * dpb_frame
Definition: vulkan_decode.h:76
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:134
AVVulkanFramesContext::tiling
VkImageTiling tiling
Controls the tiling of allocated frames.
Definition: hwcontext_vulkan.h:217
FFv1VkResetParameters
Definition: ffv1_vulkan.h:51
FFv1VkParameters::colorspace
uint8_t colorspace
Definition: ffv1enc_vulkan.c:145
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:200
FFVulkanDecodePicture::slices_buf
AVBufferRef * slices_buf
Definition: vulkan_decode.h:101
mem.h
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
MAX_QUANT_TABLES
#define MAX_QUANT_TABLES
Definition: ffv1.h:47
AVVulkanDeviceContext::act_dev
VkDevice act_dev
Active device.
Definition: hwcontext_vulkan.h:84
vulkan_decode.h
FFV1Context
Definition: ffv1.h:122
ff_vk_count_images
static int ff_vk_count_images(AVVkFrame *f)
Definition: vulkan.h:323
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:458
FFv1VulkanDecodeContext::setup
FFVulkanShader setup
Definition: vulkan_ffv1.c:64
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
FFVkBuffer
Definition: vulkan.h:87
ff_vk_exec_submit
int ff_vk_exec_submit(FFVulkanContext *s, FFVkExecContext *e)
Definition: vulkan.c:904
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
ff_vk_decode_init
int ff_vk_decode_init(AVCodecContext *avctx)
Initialize decoder.
Definition: vulkan_decode.c:1267
FFv1VkParameters
Definition: ffv1enc_vulkan.c:118
AVCodecContext::sw_pix_fmt
enum AVPixelFormat sw_pix_fmt
Nominal unaccelerated pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:638
FFv1VulkanDecodePicture::slice_offset_buf
AVBufferRef * slice_offset_buf
Definition: vulkan_ffv1.c:53
FFv1VulkanDecodePicture::crc_checked
int crc_checked
Definition: vulkan_ffv1.c:58
RGB_LINECACHE
#define RGB_LINECACHE
Definition: vulkan_ffv1.c:29
av_hwframe_get_buffer
int av_hwframe_get_buffer(AVBufferRef *hwframe_ref, AVFrame *frame, int flags)
Allocate a new frame attached to the given AVHWFramesContext.
Definition: hwcontext.c:506
FFv1VkParameters::check_crc
uint8_t check_crc
Definition: vulkan_ffv1.c:103
FFVulkanFunctions
Definition: vulkan_functions.h:277
ff_vk_get_pooled_buffer
int ff_vk_get_pooled_buffer(FFVulkanContext *ctx, AVBufferPool **buf_pool, AVBufferRef **buf, VkBufferUsageFlags usage, void *create_pNext, size_t size, VkMemoryPropertyFlagBits mem_props)
Initialize a pool and create AVBufferRefs containing FFVkBuffer.
Definition: vulkan.c:1285
ff_source_common_comp
const char * ff_source_common_comp
vk_ffv1_start_frame
static int vk_ffv1_start_frame(AVCodecContext *avctx, const AVBufferRef *buffer_ref, av_unused const uint8_t *buffer, av_unused uint32_t size)
Definition: vulkan_ffv1.c:142
vk_decode_ffv1_init
static int vk_decode_ffv1_init(AVCodecContext *avctx)
Definition: vulkan_ffv1.c:994
av_get_pix_fmt_name
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
Definition: pixdesc.c:3376
FFv1VkParameters::ec
uint8_t ec
Definition: ffv1enc_vulkan.c:147
FFv1VulkanDecodePicture::slice_num
int slice_num
Definition: vulkan_ffv1.c:55
Generated on Mon Dec 1 2025 19:22:40 for FFmpeg by   doxygen 1.8.17