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[2]; /* 16/32 bit */
63 
64  FFVulkanShader setup;
65  FFVulkanShader reset[2]; /* AC/Golomb */
66  FFVulkanShader decode[2][2][2]; /* 16/32 bit, AC/Golomb, Normal/RGB */
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[f->use32bit],
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_GBRP10MSB || sw_format == AV_PIX_FMT_GBRP12MSB)
451  memcpy(pd.fmt_lut, (int [4]) { 2, 1, 0, 3 }, 4*sizeof(int));
452  else if (sw_format == AV_PIX_FMT_X2BGR10)
453  memcpy(pd.fmt_lut, (int [4]) { 0, 2, 1, 3 }, 4*sizeof(int));
454  else
455  ff_vk_set_perm(sw_format, pd.fmt_lut, 0);
456 
457  ff_vk_shader_update_push_const(&ctx->s, exec, &fv->setup,
458  VK_SHADER_STAGE_COMPUTE_BIT,
459  0, sizeof(pd), &pd);
460 
461  vk->CmdDispatch(exec->buf, f->num_h_slices, f->num_v_slices, 1);
462 
463  if (is_rgb) {
464  AVVkFrame *vkf = (AVVkFrame *)vp->dpb_frame->data[0];
465  for (int i = 0; i < color_planes; i++)
466  vk->CmdClearColorImage(exec->buf, vkf->img[i], VK_IMAGE_LAYOUT_GENERAL,
467  &((VkClearColorValue) { 0 }),
468  1, &((VkImageSubresourceRange) {
469  .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
470  .levelCount = 1,
471  .layerCount = 1,
472  }));
473  }
474 
475  /* Reset shader */
476  reset_shader = &fv->reset[f->ac == AC_GOLOMB_RICE];
477  ff_vk_shader_update_desc_buffer(&ctx->s, exec, reset_shader,
478  1, 0, 0,
479  slice_state,
480  0, fp->slice_data_size*f->slice_count,
481  VK_FORMAT_UNDEFINED);
482 
483  ff_vk_exec_bind_shader(&ctx->s, exec, reset_shader);
484 
485  pd_reset = (FFv1VkResetParameters) {
486  .slice_state = slice_state->address + f->slice_count*fp->slice_data_size,
487  .plane_state_size = fp->plane_state_size,
488  .codec_planes = f->plane_count,
489  .key_frame = f->picture.f->flags & AV_FRAME_FLAG_KEY,
490  .version = f->version,
491  .micro_version = f->micro_version,
492  };
493  for (int i = 0; i < f->quant_table_count; i++)
494  pd_reset.context_count[i] = f->context_count[i];
495 
496  ff_vk_shader_update_push_const(&ctx->s, exec, reset_shader,
497  VK_SHADER_STAGE_COMPUTE_BIT,
498  0, sizeof(pd_reset), &pd_reset);
499 
500  /* Sync between setup and reset shaders */
501  buf_bar[nb_buf_bar++] = (VkBufferMemoryBarrier2) {
502  .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2,
503  .srcStageMask = slice_state->stage,
504  .dstStageMask = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
505  .srcAccessMask = slice_state->access,
506  .dstAccessMask = VK_ACCESS_2_SHADER_STORAGE_READ_BIT,
507  .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
508  .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
509  .buffer = slice_state->buf,
510  .offset = 0,
511  .size = fp->slice_data_size*f->slice_count,
512  };
513  vk->CmdPipelineBarrier2(exec->buf, &(VkDependencyInfo) {
514  .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
515  .pImageMemoryBarriers = img_bar,
516  .imageMemoryBarrierCount = nb_img_bar,
517  .pBufferMemoryBarriers = buf_bar,
518  .bufferMemoryBarrierCount = nb_buf_bar,
519  });
520  slice_state->stage = buf_bar[0].dstStageMask;
521  slice_state->access = buf_bar[0].dstAccessMask;
522  nb_buf_bar = 0;
523  nb_img_bar = 0;
524 
525  vk->CmdDispatch(exec->buf, f->num_h_slices, f->num_v_slices,
526  f->plane_count);
527 
528  /* Decode */
529  decode_shader = &fv->decode[f->use32bit][f->ac == AC_GOLOMB_RICE][is_rgb];
530  ff_vk_shader_update_desc_buffer(&ctx->s, exec, decode_shader,
531  1, 0, 0,
532  slice_state,
533  0, fp->slice_data_size*f->slice_count,
534  VK_FORMAT_UNDEFINED);
535  ff_vk_shader_update_img_array(&ctx->s, exec, decode_shader,
536  decode_dst, decode_dst_view,
537  1, 1,
538  VK_IMAGE_LAYOUT_GENERAL,
539  VK_NULL_HANDLE);
540  ff_vk_shader_update_desc_buffer(&ctx->s, exec, decode_shader,
541  1, 2, 0,
542  slice_status,
543  0, 2*f->slice_count*sizeof(uint32_t),
544  VK_FORMAT_UNDEFINED);
545  if (is_rgb)
546  ff_vk_shader_update_img_array(&ctx->s, exec, decode_shader,
547  f->picture.f, vp->view.out,
548  1, 3,
549  VK_IMAGE_LAYOUT_GENERAL,
550  VK_NULL_HANDLE);
551 
552  ff_vk_exec_bind_shader(&ctx->s, exec, decode_shader);
553  ff_vk_shader_update_push_const(&ctx->s, exec, decode_shader,
554  VK_SHADER_STAGE_COMPUTE_BIT,
555  0, sizeof(pd), &pd);
556 
557  /* Sync between reset and decode shaders */
558  buf_bar[nb_buf_bar++] = (VkBufferMemoryBarrier2) {
559  .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2,
560  .srcStageMask = slice_state->stage,
561  .dstStageMask = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
562  .srcAccessMask = slice_state->access,
563  .dstAccessMask = VK_ACCESS_2_SHADER_STORAGE_READ_BIT |
564  VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT,
565  .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
566  .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
567  .buffer = slice_state->buf,
568  .offset = fp->slice_data_size*f->slice_count,
569  .size = f->slice_count*(fp->slice_state_size - fp->slice_data_size),
570  };
571 
572  /* Input frame barrier */
573  ff_vk_frame_barrier(&ctx->s, exec, f->picture.f, img_bar, &nb_img_bar,
574  VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
575  VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
576  VK_ACCESS_SHADER_WRITE_BIT |
577  (!is_rgb ? VK_ACCESS_SHADER_READ_BIT : 0),
578  VK_IMAGE_LAYOUT_GENERAL,
579  VK_QUEUE_FAMILY_IGNORED);
580  if (is_rgb)
581  ff_vk_frame_barrier(&ctx->s, exec, vp->dpb_frame, img_bar, &nb_img_bar,
582  VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
583  VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
584  VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT,
585  VK_IMAGE_LAYOUT_GENERAL,
586  VK_QUEUE_FAMILY_IGNORED);
587 
588  vk->CmdPipelineBarrier2(exec->buf, &(VkDependencyInfo) {
589  .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
590  .pImageMemoryBarriers = img_bar,
591  .imageMemoryBarrierCount = nb_img_bar,
592  .pBufferMemoryBarriers = buf_bar,
593  .bufferMemoryBarrierCount = nb_buf_bar,
594  });
595  slice_state->stage = buf_bar[0].dstStageMask;
596  slice_state->access = buf_bar[0].dstAccessMask;
597  nb_img_bar = 0;
598  nb_buf_bar = 0;
599 
600  vk->CmdDispatch(exec->buf, f->num_h_slices, f->num_v_slices, 1);
601 
602  err = ff_vk_exec_submit(&ctx->s, exec);
603  if (err < 0)
604  return err;
605 
606  /* We don't need the temporary frame after decoding */
607  av_frame_free(&vp->dpb_frame);
608 
609 fail:
610  return 0;
611 }
612 
613 static void define_shared_code(FFVulkanShader *shd, int use32bit)
614 {
615  int smp_bits = use32bit ? 32 : 16;
616 
617  GLSLC(0, #define DECODE );
618 
619  av_bprintf(&shd->src, "#define RGB_LINECACHE %i\n" ,RGB_LINECACHE);
620  av_bprintf(&shd->src, "#define CONTEXT_SIZE %i\n" ,CONTEXT_SIZE);
621  av_bprintf(&shd->src, "#define MAX_QUANT_TABLE_MASK 0x%x\n" ,MAX_QUANT_TABLE_MASK);
622 
623  GLSLF(0, #define TYPE int%i_t ,smp_bits);
624  GLSLF(0, #define VTYPE2 i%ivec2 ,smp_bits);
625  GLSLF(0, #define VTYPE3 i%ivec3 ,smp_bits);
626  GLSLD(ff_source_rangecoder_comp);
627  GLSLD(ff_source_ffv1_common_comp);
628 }
629 
630 static int init_setup_shader(FFV1Context *f, FFVulkanContext *s,
631  FFVkExecPool *pool, FFVkSPIRVCompiler *spv,
632  FFVulkanShader *shd)
633 {
634  int err;
635  FFVulkanDescriptorSetBinding *desc_set;
636 
637  uint8_t *spv_data;
638  size_t spv_len;
639  void *spv_opaque = NULL;
640 
641  RET(ff_vk_shader_init(s, shd, "ffv1_dec_setup",
642  VK_SHADER_STAGE_COMPUTE_BIT,
643  (const char *[]) { "GL_EXT_buffer_reference",
644  "GL_EXT_buffer_reference2" }, 2,
645  1, 1, 1,
646  0));
647 
648  /* Common codec header */
649  GLSLD(ff_source_common_comp);
650 
651  add_push_data(shd);
652 
653  av_bprintf(&shd->src, "#define MAX_QUANT_TABLES %i\n", MAX_QUANT_TABLES);
654  av_bprintf(&shd->src, "#define MAX_CONTEXT_INPUTS %i\n", MAX_CONTEXT_INPUTS);
655  av_bprintf(&shd->src, "#define MAX_QUANT_TABLE_SIZE %i\n", MAX_QUANT_TABLE_SIZE);
656 
657  desc_set = (FFVulkanDescriptorSetBinding []) {
658  {
659  .name = "rangecoder_static_buf",
660  .type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
661  .stages = VK_SHADER_STAGE_COMPUTE_BIT,
662  .mem_layout = "scalar",
663  .buf_content = "uint8_t zero_one_state[512];",
664  },
665  {
666  .name = "crc_ieee_buf",
667  .type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
668  .stages = VK_SHADER_STAGE_COMPUTE_BIT,
669  .mem_layout = "scalar",
670  .buf_content = "uint32_t crc_ieee[256];",
671  },
672  {
673  .name = "quant_buf",
674  .type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
675  .stages = VK_SHADER_STAGE_COMPUTE_BIT,
676  .mem_layout = "scalar",
677  .buf_content = "int16_t quant_table[MAX_QUANT_TABLES]"
678  "[MAX_CONTEXT_INPUTS][MAX_QUANT_TABLE_SIZE];",
679  },
680  };
681 
682  RET(ff_vk_shader_add_descriptor_set(s, shd, desc_set, 3, 1, 0));
683 
684  define_shared_code(shd, 0 /* Irrelevant */);
685 
686  desc_set = (FFVulkanDescriptorSetBinding []) {
687  {
688  .name = "slice_data_buf",
689  .type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
690  .stages = VK_SHADER_STAGE_COMPUTE_BIT,
691  .buf_content = "SliceContext slice_ctx",
692  .buf_elems = f->max_slice_count,
693  },
694  {
695  .name = "slice_offsets_buf",
696  .type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
697  .stages = VK_SHADER_STAGE_COMPUTE_BIT,
698  .mem_quali = "readonly",
699  .buf_content = "uint32_t slice_offsets",
700  .buf_elems = 2*f->max_slice_count,
701  },
702  {
703  .name = "slice_status_buf",
704  .type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
705  .stages = VK_SHADER_STAGE_COMPUTE_BIT,
706  .mem_quali = "writeonly",
707  .buf_content = "uint32_t slice_status",
708  .buf_elems = 2*f->max_slice_count,
709  },
710  };
711  RET(ff_vk_shader_add_descriptor_set(s, shd, desc_set, 3, 0, 0));
712 
713  GLSLD(ff_source_ffv1_dec_setup_comp);
714 
715  RET(spv->compile_shader(s, spv, shd, &spv_data, &spv_len, "main",
716  &spv_opaque));
717  RET(ff_vk_shader_link(s, shd, spv_data, spv_len, "main"));
718 
719  RET(ff_vk_shader_register_exec(s, pool, shd));
720 
721 fail:
722  if (spv_opaque)
723  spv->free_shader(spv, &spv_opaque);
724 
725  return err;
726 }
727 
728 static int init_reset_shader(FFV1Context *f, FFVulkanContext *s,
729  FFVkExecPool *pool, FFVkSPIRVCompiler *spv,
730  FFVulkanShader *shd, int ac)
731 {
732  int err;
733  FFVulkanDescriptorSetBinding *desc_set;
734 
735  uint8_t *spv_data;
736  size_t spv_len;
737  void *spv_opaque = NULL;
738  int wg_dim = FFMIN(s->props.properties.limits.maxComputeWorkGroupSize[0], 1024);
739 
740  RET(ff_vk_shader_init(s, shd, "ffv1_dec_reset",
741  VK_SHADER_STAGE_COMPUTE_BIT,
742  (const char *[]) { "GL_EXT_buffer_reference",
743  "GL_EXT_buffer_reference2" }, 2,
744  wg_dim, 1, 1,
745  0));
746 
747  if (ac == AC_GOLOMB_RICE)
748  av_bprintf(&shd->src, "#define GOLOMB\n");
749 
750  /* Common codec header */
751  GLSLD(ff_source_common_comp);
752 
753  GLSLC(0, layout(push_constant, scalar) uniform pushConstants { );
754  GLSLF(1, uint context_count[%i]; ,MAX_QUANT_TABLES);
755  GLSLC(1, u8buf slice_state; );
756  GLSLC(1, uint plane_state_size; );
757  GLSLC(1, uint8_t codec_planes; );
758  GLSLC(1, uint8_t key_frame; );
759  GLSLC(1, uint8_t version; );
760  GLSLC(1, uint8_t micro_version; );
761  GLSLC(1, uint8_t padding[1]; );
762  GLSLC(0, }; );
763  ff_vk_shader_add_push_const(shd, 0, sizeof(FFv1VkResetParameters),
764  VK_SHADER_STAGE_COMPUTE_BIT);
765 
766  av_bprintf(&shd->src, "#define MAX_QUANT_TABLES %i\n", MAX_QUANT_TABLES);
767  av_bprintf(&shd->src, "#define MAX_CONTEXT_INPUTS %i\n", MAX_CONTEXT_INPUTS);
768  av_bprintf(&shd->src, "#define MAX_QUANT_TABLE_SIZE %i\n", MAX_QUANT_TABLE_SIZE);
769 
770  desc_set = (FFVulkanDescriptorSetBinding []) {
771  {
772  .name = "rangecoder_static_buf",
773  .type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
774  .stages = VK_SHADER_STAGE_COMPUTE_BIT,
775  .mem_layout = "scalar",
776  .buf_content = "uint8_t zero_one_state[512];",
777  },
778  {
779  .name = "quant_buf",
780  .type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
781  .stages = VK_SHADER_STAGE_COMPUTE_BIT,
782  .mem_layout = "scalar",
783  .buf_content = "int16_t quant_table[MAX_QUANT_TABLES]"
784  "[MAX_CONTEXT_INPUTS][MAX_QUANT_TABLE_SIZE];",
785  },
786  };
787  RET(ff_vk_shader_add_descriptor_set(s, shd, desc_set, 2, 1, 0));
788 
789  define_shared_code(shd, 0 /* Bit depth irrelevant for the reset shader */);
790  if (ac == AC_GOLOMB_RICE)
791  GLSLD(ff_source_ffv1_vlc_comp);
792 
793  desc_set = (FFVulkanDescriptorSetBinding []) {
794  {
795  .name = "slice_data_buf",
796  .type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
797  .mem_quali = "readonly",
798  .stages = VK_SHADER_STAGE_COMPUTE_BIT,
799  .buf_content = "SliceContext slice_ctx",
800  .buf_elems = f->max_slice_count,
801  },
802  };
803  RET(ff_vk_shader_add_descriptor_set(s, shd, desc_set, 1, 0, 0));
804 
805  GLSLD(ff_source_ffv1_reset_comp);
806 
807  RET(spv->compile_shader(s, spv, shd, &spv_data, &spv_len, "main",
808  &spv_opaque));
809  RET(ff_vk_shader_link(s, shd, spv_data, spv_len, "main"));
810 
811  RET(ff_vk_shader_register_exec(s, pool, shd));
812 
813 fail:
814  if (spv_opaque)
815  spv->free_shader(spv, &spv_opaque);
816 
817  return err;
818 }
819 
820 static int init_decode_shader(FFV1Context *f, FFVulkanContext *s,
821  FFVkExecPool *pool, FFVkSPIRVCompiler *spv,
822  FFVulkanShader *shd,
823  AVHWFramesContext *dec_frames_ctx,
824  AVHWFramesContext *out_frames_ctx,
825  int use32bit, int ac, int rgb)
826 {
827  int err;
828  FFVulkanDescriptorSetBinding *desc_set;
829 
830  uint8_t *spv_data;
831  size_t spv_len;
832  void *spv_opaque = NULL;
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, 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  ff_vk_shader_free(&ctx->s, &fv->setup);
978 
979  for (int i = 0; i < 2; i++) /* 16/32 bit */
980  av_buffer_unref(&fv->intermediate_frames_ref[i]);
981 
982  for (int i = 0; i < 2; i++) /* AC/Golomb */
983  ff_vk_shader_free(&ctx->s, &fv->reset[i]);
984 
985  for (int i = 0; i < 2; i++) /* 16/32 bit */
986  for (int j = 0; j < 2; j++) /* AC/Golomb */
987  for (int k = 0; k < 2; k++) /* Normal/RGB */
988  ff_vk_shader_free(&ctx->s, &fv->decode[i][j][k]);
989 
990  ff_vk_free_buf(&ctx->s, &fv->quant_buf);
991  ff_vk_free_buf(&ctx->s, &fv->rangecoder_static_buf);
992  ff_vk_free_buf(&ctx->s, &fv->crc_tab_buf);
993 
994  av_buffer_pool_uninit(&fv->slice_state_pool);
995  av_buffer_pool_uninit(&fv->slice_offset_pool);
996  av_buffer_pool_uninit(&fv->slice_status_pool);
997 
998  av_freep(&fv);
999 }
1000 
1001 static int vk_decode_ffv1_init(AVCodecContext *avctx)
1002 {
1003  int err;
1004  FFV1Context *f = avctx->priv_data;
1005  FFVulkanDecodeContext *dec = avctx->internal->hwaccel_priv_data;
1006  FFVulkanDecodeShared *ctx = NULL;
1007  FFv1VulkanDecodeContext *fv;
1008  FFVkSPIRVCompiler *spv;
1009 
1010  if (f->version < 3 ||
1011  (f->version == 4 && f->micro_version > 3))
1012  return AVERROR(ENOTSUP);
1013 
1014  spv = ff_vk_spirv_init();
1015  if (!spv) {
1016  av_log(avctx, AV_LOG_ERROR, "Unable to initialize SPIR-V compiler!\n");
1017  return AVERROR_EXTERNAL;
1018  }
1019 
1020  err = ff_vk_decode_init(avctx);
1021  if (err < 0)
1022  return err;
1023  ctx = dec->shared_ctx;
1024 
1025  fv = ctx->sd_ctx = av_mallocz(sizeof(*fv));
1026  if (!fv) {
1027  err = AVERROR(ENOMEM);
1028  goto fail;
1029  }
1030 
1031  ctx->sd_ctx_free = &vk_decode_ffv1_uninit;
1032 
1033  /* Intermediate frame pool for RCT */
1034  for (int i = 0; i < 2; i++) { /* 16/32 bit */
1035  RET(init_indirect(avctx, &ctx->s, &fv->intermediate_frames_ref[i],
1036  i ? AV_PIX_FMT_GBRAP32 : AV_PIX_FMT_GBRAP16));
1037  }
1038 
1039  /* Setup shader */
1040  RET(init_setup_shader(f, &ctx->s, &ctx->exec_pool, spv, &fv->setup));
1041 
1042  /* Reset shaders */
1043  for (int i = 0; i < 2; i++) { /* AC/Golomb */
1044  RET(init_reset_shader(f, &ctx->s, &ctx->exec_pool,
1045  spv, &fv->reset[i], !i ? AC_RANGE_CUSTOM_TAB : 0));
1046  }
1047 
1048  /* Decode shaders */
1049  for (int i = 0; i < 2; i++) { /* 16/32 bit */
1050  for (int j = 0; j < 2; j++) { /* AC/Golomb */
1051  for (int k = 0; k < 2; k++) { /* Normal/RGB */
1052  AVHWFramesContext *dec_frames_ctx;
1053  dec_frames_ctx = k ? (AVHWFramesContext *)fv->intermediate_frames_ref[i]->data :
1054  (AVHWFramesContext *)avctx->hw_frames_ctx->data;
1055  RET(init_decode_shader(f, &ctx->s, &ctx->exec_pool,
1056  spv, &fv->decode[i][j][k],
1057  dec_frames_ctx,
1058  (AVHWFramesContext *)avctx->hw_frames_ctx->data,
1059  i,
1060  !j ? AC_RANGE_CUSTOM_TAB : AC_GOLOMB_RICE,
1061  k));
1062  }
1063  }
1064  }
1065 
1066  /* Range coder data */
1067  RET(ff_ffv1_vk_init_state_transition_data(&ctx->s,
1068  &fv->rangecoder_static_buf,
1069  f));
1070 
1071  /* Quantization table data */
1072  RET(ff_ffv1_vk_init_quant_table_data(&ctx->s,
1073  &fv->quant_buf,
1074  f));
1075 
1076  /* CRC table buffer */
1077  RET(ff_ffv1_vk_init_crc_table_data(&ctx->s,
1078  &fv->crc_tab_buf,
1079  f));
1080 
1081  /* Update setup global descriptors */
1082  RET(ff_vk_shader_update_desc_buffer(&ctx->s, &ctx->exec_pool.contexts[0],
1083  &fv->setup, 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->setup, 0, 1, 0,
1089  &fv->crc_tab_buf,
1090  0, fv->crc_tab_buf.size,
1091  VK_FORMAT_UNDEFINED));
1092 
1093  /* Update decode global descriptors */
1094  for (int i = 0; i < 2; i++) { /* 16/32 bit */
1095  for (int j = 0; j < 2; j++) { /* AC/Golomb */
1096  for (int k = 0; k < 2; k++) { /* Normal/RGB */
1097  RET(ff_vk_shader_update_desc_buffer(&ctx->s, &ctx->exec_pool.contexts[0],
1098  &fv->decode[i][j][k], 0, 0, 0,
1099  &fv->rangecoder_static_buf,
1100  0, fv->rangecoder_static_buf.size,
1101  VK_FORMAT_UNDEFINED));
1102  RET(ff_vk_shader_update_desc_buffer(&ctx->s, &ctx->exec_pool.contexts[0],
1103  &fv->decode[i][j][k], 0, 1, 0,
1104  &fv->quant_buf,
1105  0, fv->quant_buf.size,
1106  VK_FORMAT_UNDEFINED));
1107  }
1108  }
1109  }
1110 
1111 fail:
1112  spv->uninit(&spv);
1113 
1114  return err;
1115 }
1116 
1117 static void vk_ffv1_free_frame_priv(AVRefStructOpaque _hwctx, void *data)
1118 {
1119  AVHWDeviceContext *dev_ctx = _hwctx.nc;
1120  AVVulkanDeviceContext *hwctx = dev_ctx->hwctx;
1121 
1122  FFv1VulkanDecodePicture *fp = data;
1123  FFVulkanDecodePicture *vp = &fp->vp;
1124  FFVkBuffer *slice_status = (FFVkBuffer *)fp->slice_status_buf->data;
1125 
1126  ff_vk_decode_free_frame(dev_ctx, vp);
1127 
1128  /* Invalidate slice/output data if needed */
1129  if (!(slice_status->flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)) {
1130  VkMappedMemoryRange invalidate_data = {
1131  .sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE,
1132  .memory = slice_status->mem,
1133  .offset = 0,
1134  .size = 2*fp->slice_num*sizeof(uint32_t),
1135  };
1136  vp->invalidate_memory_ranges(hwctx->act_dev,
1137  1, &invalidate_data);
1138  }
1139 
1140  for (int i = 0; i < fp->slice_num; i++) {
1141  uint32_t crc_res = 0;
1142  if (fp->crc_checked)
1143  crc_res = AV_RN32(slice_status->mapped_mem + 2*i*sizeof(uint32_t) + 0);
1144  uint32_t status = AV_RN32(slice_status->mapped_mem + 2*i*sizeof(uint32_t) + 4);
1145  if (status || crc_res)
1146  av_log(dev_ctx, AV_LOG_ERROR, "Slice %i status: 0x%x, CRC 0x%x\n",
1147  i, status, crc_res);
1148  }
1149 
1150  av_buffer_unref(&vp->slices_buf);
1151  av_buffer_unref(&fp->slice_state);
1152  av_buffer_unref(&fp->slice_offset_buf);
1153  av_buffer_unref(&fp->slice_status_buf);
1154 }
1155 
1156 const FFHWAccel ff_ffv1_vulkan_hwaccel = {
1157  .p.name = "ffv1_vulkan",
1158  .p.type = AVMEDIA_TYPE_VIDEO,
1159  .p.id = AV_CODEC_ID_FFV1,
1160  .p.pix_fmt = AV_PIX_FMT_VULKAN,
1161  .start_frame = &vk_ffv1_start_frame,
1162  .decode_slice = &vk_ffv1_decode_slice,
1163  .end_frame = &vk_ffv1_end_frame,
1164  .free_frame_priv = &vk_ffv1_free_frame_priv,
1165  .frame_priv_data_size = sizeof(FFv1VulkanDecodePicture),
1166  .init = &vk_decode_ffv1_init,
1167  .update_thread_context = &ff_vk_update_thread_context,
1168  .decode_params = &ff_vk_params_invalidate,
1169  .flush = &ff_vk_decode_flush,
1170  .uninit = &ff_vk_decode_uninit,
1171  .frame_params = &ff_vk_frame_params,
1172  .priv_data_size = sizeof(FFVulkanDecodeContext),
1173  .caps_internal = HWACCEL_CAP_ASYNC_SAFE | HWACCEL_CAP_THREAD_SAFE,
1174 };
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:584
FFv1VkResetParameters::context_count
uint32_t context_count[MAX_QUANT_TABLES]
Definition: ffv1_vulkan.h:52
FFv1VkParameters::planes
uint8_t planes
Definition: ffv1enc_vulkan.c:144
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
FFv1VkParameters::extend_lookup
uint8_t extend_lookup[8]
Definition: ffv1enc_vulkan.c:136
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:2915
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:2048
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:240
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3594
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
FFv1VulkanDecodeContext::reset
FFVulkanShader reset[2]
Definition: vulkan_ffv1.c:65
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:142
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:122
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
FFVulkanDecodePicture::view
struct FFVulkanDecodePicture::@324 view
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
AC_RANGE_CUSTOM_TAB
#define AC_RANGE_CUSTOM_TAB
Definition: ffv1.h:54
FFv1VkParameters::micro_version
uint8_t micro_version
Definition: ffv1enc_vulkan.c:140
FFv1VkParameters::padding
uint8_t padding[3]
Definition: ffv1enc_vulkan.c:154
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:3634
rgb
Definition: rpzaenc.c:60
MAX_QUANT_TABLE_MASK
#define MAX_QUANT_TABLE_MASK
Definition: ffv1.h:49
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
fail
#define fail()
Definition: checkasm.h:206
AV_PIX_FMT_GBRP12MSB
#define AV_PIX_FMT_GBRP12MSB
Definition: pixfmt.h:588
FFVulkanDecodePicture::sem_value
uint64_t sem_value
Definition: vulkan_decode.h:87
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:2792
AVVulkanFramesContext
Allocated as AVHWFramesContext.hwctx, used to set pool-specific options.
Definition: hwcontext_vulkan.h:208
FFv1VkParameters::transparency
uint8_t transparency
Definition: ffv1enc_vulkan.c:147
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:2555
init_setup_shader
static int init_setup_shader(FFV1Context *f, FFVulkanContext *s, FFVkExecPool *pool, FFVkSPIRVCompiler *spv, FFVulkanShader *shd)
Definition: vulkan_ffv1.c:630
FFv1VkParameters::plane_state_size
uint32_t plane_state_size
Definition: ffv1enc_vulkan.c:130
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:1361
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:2420
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:145
define_shared_code
static void define_shared_code(FFVulkanShader *shd, int use32bit)
Definition: vulkan_ffv1.c:613
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
FFv1VulkanDecodeContext
Definition: vulkan_ffv1.c:61
FFv1VkParameters::bits_per_raw_sample
uint8_t bits_per_raw_sample
Definition: ffv1enc_vulkan.c:137
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:1551
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:585
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:132
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:728
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:128
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:1588
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:610
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:139
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:1209
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:1082
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:146
AV_PIX_FMT_X2BGR10
#define AV_PIX_FMT_X2BGR10
Definition: pixfmt.h:633
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:126
planes
static const struct @542 planes[]
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:2871
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:1117
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
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
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 use32bit, int ac, int rgb)
Definition: vulkan_ffv1.c:820
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:2805
FFVulkanDescriptorSetBinding::name
const char * name
Definition: vulkan.h:75
version
version
Definition: libkvazaar.c:315
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:1529
FFv1VulkanDecodeContext::intermediate_frames_ref
AVBufferRef * intermediate_frames_ref[2]
Definition: vulkan_ffv1.c:62
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
ff_vk_frame_barrier
void ff_vk_frame_barrier(FFVulkanContext *s, FFVkExecContext *e, AVFrame *pic, VkImageMemoryBarrier2 *bar, int *nb_bar, VkPipelineStageFlags src_stage, VkPipelineStageFlags dst_stage, VkAccessFlagBits new_access, VkImageLayout new_layout, uint32_t new_qf)
Definition: vulkan.c:2005
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:2345
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
vulkan_spirv.h
ff_vk_free_buf
void ff_vk_free_buf(FFVulkanContext *s, FFVkBuffer *buf)
Definition: vulkan.c:1212
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:2881
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:368
ff_ffv1_vulkan_hwaccel
const FFHWAccel ff_ffv1_vulkan_hwaccel
Definition: vulkan_ffv1.c:1156
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:1922
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:287
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:1459
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
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:134
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:145
FFv1VulkanDecodeContext::decode
FFVulkanShader decode[2][2][2]
Definition: vulkan_ffv1.c:66
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:127
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:148
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:1261
AV_PIX_FMT_GBRP10MSB
#define AV_PIX_FMT_GBRP10MSB
Definition: pixfmt.h:587
FFv1VkParameters
Definition: ffv1enc_vulkan.c:121
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:1254
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:1001
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:3514
FFv1VkParameters::ec
uint8_t ec
Definition: ffv1enc_vulkan.c:150
FFv1VulkanDecodePicture::slice_num
int slice_num
Definition: vulkan_ffv1.c:55
Generated on Thu Nov 6 2025 19:22:29 for FFmpeg by   doxygen 1.8.17