FFmpeg
ffv1enc_vulkan.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 "libavutil/mem.h"
22 #include "libavutil/vulkan.h"
23 #include "libavutil/vulkan_spirv.h"
24 
25 #include "avcodec.h"
26 #include "internal.h"
27 #include "hwconfig.h"
28 #include "encode.h"
29 #include "libavutil/opt.h"
30 #include "codec_internal.h"
31 
32 #include "ffv1.h"
33 #include "ffv1enc.h"
34 #include "ffv1_vulkan.h"
35 
36 /* Parallel Golomb alignment */
37 #define LG_ALIGN_W 32
38 #define LG_ALIGN_H 32
39 
40 /* Unlike the decoder, we need 4 lines (but really only 3) */
41 #define RGB_LINECACHE 4
42 
43 typedef struct VulkanEncodeFFv1FrameData {
44  /* Output data */
45  AVBufferRef *out_data_ref;
46 
47  /* Results data */
48  AVBufferRef *results_data_ref;
49 
50  /* Copied from the source */
51  int64_t pts;
52  int64_t duration;
53  void *frame_opaque;
54  AVBufferRef *frame_opaque_ref;
55 
56  int key_frame;
57 } VulkanEncodeFFv1FrameData;
58 
59 typedef struct VulkanEncodeFFv1Context {
60  FFV1Context ctx;
61  AVFrame *frame;
62 
63  FFVulkanContext s;
64  AVVulkanDeviceQueueFamily *qf;
65  FFVkExecPool exec_pool;
66 
67  AVVulkanDeviceQueueFamily *transfer_qf;
68  FFVkExecPool transfer_exec_pool;
69 
70  VkBufferCopy *buf_regions;
71  VulkanEncodeFFv1FrameData *exec_ctx_info;
72  int in_flight;
73  int async_depth;
74  size_t max_heap_size;
75 
76  FFVulkanShader setup;
77  FFVulkanShader rct_search;
78  FFVulkanShader reset;
79  FFVulkanShader enc;
80 
81  /* Constant read-only buffers */
82  FFVkBuffer quant_buf;
83  FFVkBuffer rangecoder_static_buf;
84  FFVkBuffer crc_tab_buf;
85 
86  /* Slice data buffer pool */
87  AVBufferPool *slice_data_pool;
88  AVBufferRef *keyframe_slice_data_ref;
89 
90  /* Output data buffer */
91  AVBufferPool *out_data_pool;
92 
93  /* Slice results buffer */
94  AVBufferPool *results_data_pool;
95 
96  /* Intermediate frame pool */
97  AVBufferRef *intermediate_frames_ref;
98 
99  int num_h_slices;
100  int num_v_slices;
101  int force_pcm;
102  int optimize_rct;
103 
104  int is_rgb;
105  int ppi;
106  int chunks;
107 } VulkanEncodeFFv1Context;
108 
109 extern const char *ff_source_common_comp;
110 extern const char *ff_source_rangecoder_comp;
111 extern const char *ff_source_ffv1_vlc_comp;
112 extern const char *ff_source_ffv1_common_comp;
113 extern const char *ff_source_ffv1_reset_comp;
114 extern const char *ff_source_ffv1_rct_search_comp;
115 extern const char *ff_source_ffv1_enc_setup_comp;
116 extern const char *ff_source_ffv1_enc_comp;
117 
118 typedef struct FFv1VkParameters {
119  VkDeviceAddress slice_state;
120  VkDeviceAddress scratch_data;
121  VkDeviceAddress out_data;
122 
123  int32_t fmt_lut[4];
124  int32_t sar[2];
125  uint32_t chroma_shift[2];
126 
127  uint32_t plane_state_size;
128  uint32_t context_count;
129  uint32_t crcref;
130  uint32_t slice_size_max;
131  int rct_offset;
132 
133  uint8_t extend_lookup[8];
134  uint8_t bits_per_raw_sample;
135  uint8_t context_model;
136  uint8_t version;
137  uint8_t micro_version;
138  uint8_t force_pcm;
139  uint8_t key_frame;
140  uint8_t components;
141  uint8_t planes;
142  uint8_t codec_planes;
143  uint8_t planar_rgb;
144  uint8_t transparency;
145  uint8_t colorspace;
146  uint8_t pic_mode;
147  uint8_t ec;
148  uint8_t ppi;
149  uint8_t chunks;
150  uint8_t rct_search;
151  uint8_t padding[3];
152 } FFv1VkParameters;
153 
154 static void add_push_data(FFVulkanShader *shd)
155 {
156  GLSLC(0, layout(push_constant, scalar) uniform pushConstants { );
157  GLSLC(1, u8buf slice_state; );
158  GLSLC(1, u8buf scratch_data; );
159  GLSLC(1, u8buf out_data; );
160  GLSLC(0, );
161  GLSLC(1, ivec4 fmt_lut; );
162  GLSLC(1, ivec2 sar; );
163  GLSLC(1, uvec2 chroma_shift; );
164  GLSLC(0, );
165  GLSLC(1, uint plane_state_size; );
166  GLSLC(1, uint context_count; );
167  GLSLC(1, uint32_t crcref; );
168  GLSLC(1, uint32_t slice_size_max; );
169  GLSLC(1, int rct_offset; );
170  GLSLC(0, );
171  GLSLC(1, uint8_t extend_lookup[8]; );
172  GLSLC(1, uint8_t bits_per_raw_sample; );
173  GLSLC(1, uint8_t context_model; );
174  GLSLC(1, uint8_t version; );
175  GLSLC(1, uint8_t micro_version; );
176  GLSLC(1, uint8_t force_pcm; );
177  GLSLC(1, uint8_t key_frame; );
178  GLSLC(1, uint8_t components; );
179  GLSLC(1, uint8_t planes; );
180  GLSLC(1, uint8_t codec_planes; );
181  GLSLC(1, uint8_t planar_rgb; );
182  GLSLC(1, uint8_t transparency; );
183  GLSLC(1, uint8_t colorspace; );
184  GLSLC(1, uint8_t pic_mode; );
185  GLSLC(1, uint8_t ec; );
186  GLSLC(1, uint8_t ppi; );
187  GLSLC(1, uint8_t chunks; );
188  GLSLC(1, uint8_t rct_search; );
189  GLSLC(1, uint8_t padding[3]; );
190  GLSLC(0, }; );
191  ff_vk_shader_add_push_const(shd, 0, sizeof(FFv1VkParameters),
192  VK_SHADER_STAGE_COMPUTE_BIT);
193 }
194 
195 typedef struct FFv1VkRCTSearchParameters {
196  int fmt_lut[4];
197  int rct_offset;
198  uint8_t planar_rgb;
199  uint8_t transparency;
200  uint8_t key_frame;
201  uint8_t force_pcm;
202  uint8_t version;
203  uint8_t micro_version;
204  uint8_t padding[2];
205 } FFv1VkRCTSearchParameters;
206 
207 static int run_rct_search(AVCodecContext *avctx, FFVkExecContext *exec,
208  AVFrame *enc_in, VkImageView *enc_in_views,
209  FFVkBuffer *slice_data_buf, uint32_t slice_data_size)
210 {
211  VulkanEncodeFFv1Context *fv = avctx->priv_data;
212  FFV1Context *f = &fv->ctx;
213  FFVulkanFunctions *vk = &fv->s.vkfn;
214  AVHWFramesContext *src_hwfc = (AVHWFramesContext *)enc_in->hw_frames_ctx->data;
215  FFv1VkRCTSearchParameters pd;
216 
217  /* Update descriptors */
218  ff_vk_shader_update_desc_buffer(&fv->s, exec, &fv->rct_search,
219  0, 0, 0,
220  slice_data_buf,
221  0, slice_data_size*f->slice_count,
222  VK_FORMAT_UNDEFINED);
223  ff_vk_shader_update_img_array(&fv->s, exec, &fv->rct_search,
224  enc_in, enc_in_views,
225  0, 1,
226  VK_IMAGE_LAYOUT_GENERAL,
227  VK_NULL_HANDLE);
228 
229  ff_vk_exec_bind_shader(&fv->s, exec, &fv->rct_search);
230 
231  pd = (FFv1VkRCTSearchParameters) {
232  .rct_offset = 1 << f->bits_per_raw_sample,
233  .planar_rgb = ff_vk_mt_is_np_rgb(src_hwfc->sw_format) &&
234  (ff_vk_count_images((AVVkFrame *)enc_in->data[0]) > 1),
235  .transparency = f->transparency,
236  .key_frame = f->key_frame,
237  .force_pcm = fv->force_pcm,
238  .version = f->version,
239  .micro_version = f->micro_version,
240  };
241 
242  if (avctx->sw_pix_fmt == AV_PIX_FMT_GBRP10 ||
243  avctx->sw_pix_fmt == AV_PIX_FMT_GBRP12 ||
244  avctx->sw_pix_fmt == AV_PIX_FMT_GBRP14)
245  memcpy(pd.fmt_lut, (int [4]) { 2, 1, 0, 3 }, 4*sizeof(int));
246  else
247  ff_vk_set_perm(avctx->sw_pix_fmt, pd.fmt_lut, 1);
248 
249  ff_vk_shader_update_push_const(&fv->s, exec, &fv->rct_search,
250  VK_SHADER_STAGE_COMPUTE_BIT,
251  0, sizeof(pd), &pd);
252 
253  vk->CmdDispatch(exec->buf, fv->ctx.num_h_slices, fv->ctx.num_v_slices, 1);
254 
255  return 0;
256 }
257 
258 static int vulkan_encode_ffv1_submit_frame(AVCodecContext *avctx,
259  FFVkExecContext *exec,
260  const AVFrame *pict)
261 {
262  int err;
263  VulkanEncodeFFv1Context *fv = avctx->priv_data;
264  FFV1Context *f = &fv->ctx;
265  FFVulkanFunctions *vk = &fv->s.vkfn;
266 
267  VulkanEncodeFFv1FrameData *fd = exec->opaque;
268  FFv1VkParameters pd;
269 
270  /* Slice data */
271  AVBufferRef *slice_data_ref;
272  FFVkBuffer *slice_data_buf;
273  uint32_t plane_state_size;
274  uint32_t slice_state_size;
275  uint32_t slice_data_size;
276 
277  /* Output data */
278  size_t maxsize;
279  FFVkBuffer *out_data_buf;
280 
281  /* Results data */
282  FFVkBuffer *results_data_buf;
283 
284  int has_inter = avctx->gop_size > 1;
285  uint32_t context_count = f->context_count[f->context_model];
286  const AVPixFmtDescriptor *fmt_desc = av_pix_fmt_desc_get(avctx->sw_pix_fmt);
287 
288  AVFrame *src = (AVFrame *)pict;
289  VkImageView src_views[AV_NUM_DATA_POINTERS];
290 
291  AVFrame *tmp = NULL;
292  VkImageView tmp_views[AV_NUM_DATA_POINTERS];
293 
294  VkImageMemoryBarrier2 img_bar[37];
295  int nb_img_bar = 0;
296  VkBufferMemoryBarrier2 buf_bar[8];
297  int nb_buf_bar = 0;
298 
299  /* Start recording */
300  ff_vk_exec_start(&fv->s, exec);
301 
302  /* Frame state */
303  f->cur_enc_frame = pict;
304  if (avctx->gop_size == 0 || f->picture_number % avctx->gop_size == 0) {
305  av_buffer_unref(&fv->keyframe_slice_data_ref);
306  f->key_frame = fd->key_frame = 1;
307  f->gob_count++;
308  } else {
309  f->key_frame = fd->key_frame = 0;
310  }
311 
312  f->slice_count = f->max_slice_count;
313 
314  /* Allocate slice buffer data */
315  if (f->ac == AC_GOLOMB_RICE)
316  plane_state_size = 8;
317  else
318  plane_state_size = CONTEXT_SIZE;
319 
320  plane_state_size *= context_count;
321  slice_state_size = plane_state_size*f->plane_count;
322 
323  slice_data_size = 256; /* Overestimation for the SliceContext struct */
324  slice_state_size += slice_data_size;
325  slice_state_size = FFALIGN(slice_state_size, 8);
326 
327  /* Allocate slice data buffer */
328  slice_data_ref = fv->keyframe_slice_data_ref;
329  if (!slice_data_ref) {
330  RET(ff_vk_get_pooled_buffer(&fv->s, &fv->slice_data_pool,
331  &slice_data_ref,
332  VK_BUFFER_USAGE_STORAGE_BUFFER_BIT |
333  VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
334  NULL, slice_state_size*f->slice_count,
335  VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT));
336 
337  /* Only save it if we're going to use it again */
338  if (has_inter)
339  fv->keyframe_slice_data_ref = slice_data_ref;
340  }
341  slice_data_buf = (FFVkBuffer *)slice_data_ref->data;
342  ff_vk_exec_add_dep_buf(&fv->s, exec, &slice_data_ref, 1, has_inter);
343 
344  /* Allocate results buffer */
345  RET(ff_vk_get_pooled_buffer(&fv->s, &fv->results_data_pool,
346  &fd->results_data_ref,
347  VK_BUFFER_USAGE_STORAGE_BUFFER_BIT |
348  VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
349  NULL, 2*f->slice_count*sizeof(uint64_t),
350  VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT |
351  VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT));
352  results_data_buf = (FFVkBuffer *)fd->results_data_ref->data;
353  ff_vk_exec_add_dep_buf(&fv->s, exec, &fd->results_data_ref, 1, 1);
354 
355  /* Output buffer size */
356  maxsize = ff_ffv1_encode_buffer_size(avctx);
357  maxsize = FFMIN(maxsize, fv->s.props_11.maxMemoryAllocationSize);
358 
359  /* Allocate output buffer */
360  RET(ff_vk_get_pooled_buffer(&fv->s, &fv->out_data_pool,
361  &fd->out_data_ref,
362  VK_BUFFER_USAGE_TRANSFER_SRC_BIT |
363  VK_BUFFER_USAGE_STORAGE_BUFFER_BIT |
364  VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
365  NULL, maxsize,
366  VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
367  (maxsize < fv->max_heap_size ?
368  VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT :
369  fv->s.host_cached_flag)));
370  out_data_buf = (FFVkBuffer *)fd->out_data_ref->data;
371  ff_vk_exec_add_dep_buf(&fv->s, exec, &fd->out_data_ref, 1, 1);
372 
373  /* Prepare input frame */
374  RET(ff_vk_exec_add_dep_frame(&fv->s, exec, src,
375  VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
376  VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT));
377 
378  RET(ff_vk_create_imageviews(&fv->s, exec, src_views, src,
379  FF_VK_REP_NATIVE));
380  ff_vk_frame_barrier(&fv->s, exec, src, img_bar, &nb_img_bar,
381  VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
382  VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
383  VK_ACCESS_SHADER_READ_BIT,
384  VK_IMAGE_LAYOUT_GENERAL,
385  VK_QUEUE_FAMILY_IGNORED);
386 
387  if (fv->is_rgb) {
388  /* Create a temporaty frame */
389  tmp = av_frame_alloc();
390  if (!(tmp))
391  return AVERROR(ENOMEM);
392 
393  RET(av_hwframe_get_buffer(fv->intermediate_frames_ref,
394  tmp, 0));
395 
396  RET(ff_vk_exec_add_dep_frame(&fv->s, exec, tmp,
397  VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
398  VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT));
399  RET(ff_vk_create_imageviews(&fv->s, exec, tmp_views,
400  tmp,
401  FF_VK_REP_NATIVE));
402  }
403 
404  /* Setup shader */
405  ff_vk_shader_update_desc_buffer(&fv->s, exec, &fv->setup,
406  1, 0, 0,
407  slice_data_buf,
408  0, slice_data_size*f->slice_count,
409  VK_FORMAT_UNDEFINED);
410  ff_vk_shader_update_img_array(&fv->s, exec, &fv->setup,
411  src, src_views,
412  1, 1,
413  VK_IMAGE_LAYOUT_GENERAL,
414  VK_NULL_HANDLE);
415 
416  /* Add a buffer barrier between previous and current frame */
417  if (!f->key_frame)
418  ff_vk_buf_barrier(buf_bar[nb_buf_bar++], slice_data_buf,
419  ALL_COMMANDS_BIT, NONE_KHR, NONE_KHR,
420  COMPUTE_SHADER_BIT, SHADER_READ_BIT, SHADER_WRITE_BIT,
421  0, slice_data_size*f->slice_count);
422  else
423  ff_vk_buf_barrier(buf_bar[nb_buf_bar++], slice_data_buf,
424  COMPUTE_SHADER_BIT, SHADER_READ_BIT, SHADER_WRITE_BIT,
425  COMPUTE_SHADER_BIT, SHADER_READ_BIT, SHADER_WRITE_BIT,
426  0, slice_data_size*f->slice_count);
427  vk->CmdPipelineBarrier2(exec->buf, &(VkDependencyInfo) {
428  .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
429  .pImageMemoryBarriers = img_bar,
430  .imageMemoryBarrierCount = nb_img_bar,
431  .pBufferMemoryBarriers = buf_bar,
432  .bufferMemoryBarrierCount = nb_buf_bar,
433  });
434  nb_img_bar = 0;
435  nb_buf_bar = 0;
436 
437  if (fv->optimize_rct) {
438  RET(run_rct_search(avctx, exec,
439  src, src_views,
440  slice_data_buf, slice_data_size));
441 
442  /* Make sure the writes are visible to the setup shader */
443  ff_vk_buf_barrier(buf_bar[nb_buf_bar++], slice_data_buf,
444  COMPUTE_SHADER_BIT, SHADER_READ_BIT, SHADER_WRITE_BIT,
445  COMPUTE_SHADER_BIT, SHADER_READ_BIT, SHADER_WRITE_BIT,
446  0, slice_data_size*f->slice_count);
447  vk->CmdPipelineBarrier2(exec->buf, &(VkDependencyInfo) {
448  .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
449  .pBufferMemoryBarriers = buf_bar,
450  .bufferMemoryBarrierCount = nb_buf_bar,
451  });
452  nb_buf_bar = 0;
453  }
454 
455  /* Run setup shader */
456  ff_vk_exec_bind_shader(&fv->s, exec, &fv->setup);
457  pd = (FFv1VkParameters) {
458  .slice_state = slice_data_buf->address + f->slice_count*256,
459  .out_data = out_data_buf->address,
460  .bits_per_raw_sample = f->bits_per_raw_sample,
461  .sar[0] = pict->sample_aspect_ratio.num,
462  .sar[1] = pict->sample_aspect_ratio.den,
463  .chroma_shift[0] = f->chroma_h_shift,
464  .chroma_shift[1] = f->chroma_v_shift,
465  .plane_state_size = plane_state_size,
466  .context_count = context_count,
467  .crcref = f->crcref,
468  .rct_offset = 1 << f->bits_per_raw_sample,
469  .slice_size_max = out_data_buf->size / f->slice_count,
470  .context_model = fv->ctx.context_model,
471  .version = f->version,
472  .micro_version = f->micro_version,
473  .force_pcm = fv->force_pcm,
474  .key_frame = f->key_frame,
475  .components = fmt_desc->nb_components,
476  .planes = av_pix_fmt_count_planes(avctx->sw_pix_fmt),
477  .codec_planes = f->plane_count,
478  .planar_rgb = ff_vk_mt_is_np_rgb(avctx->sw_pix_fmt) &&
479  (ff_vk_count_images((AVVkFrame *)src->data[0]) > 1),
480  .transparency = f->transparency,
481  .colorspace = f->colorspace,
482  .pic_mode = !(pict->flags & AV_FRAME_FLAG_INTERLACED) ? 3 :
483  !(pict->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST) ? 2 : 1,
484  .ec = f->ec,
485  .ppi = fv->ppi,
486  .chunks = fv->chunks,
487  .rct_search = fv->optimize_rct,
488  };
489 
490  /* For some reason the C FFv1 encoder/decoder treats these differently */
491  if (avctx->sw_pix_fmt == AV_PIX_FMT_GBRP10 ||
492  avctx->sw_pix_fmt == AV_PIX_FMT_GBRP12 ||
493  avctx->sw_pix_fmt == AV_PIX_FMT_GBRP14)
494  memcpy(pd.fmt_lut, (int [4]) { 2, 1, 0, 3 }, 4*sizeof(int));
495  else
496  ff_vk_set_perm(avctx->sw_pix_fmt, pd.fmt_lut, 1);
497 
498  for (int i = 0; i < f->quant_table_count; i++)
499  pd.extend_lookup[i] = (f->quant_tables[i][3][127] != 0) ||
500  (f->quant_tables[i][4][127] != 0);
501  ff_vk_shader_update_push_const(&fv->s, exec, &fv->setup,
502  VK_SHADER_STAGE_COMPUTE_BIT,
503  0, sizeof(pd), &pd);
504  vk->CmdDispatch(exec->buf, fv->ctx.num_h_slices, fv->ctx.num_v_slices, 1);
505 
506  /* Clean up temporary image */
507  if (fv->is_rgb) {
508  AVVkFrame *vkf = (AVVkFrame *)tmp->data[0];
509  vk->CmdClearColorImage(exec->buf, vkf->img[0], VK_IMAGE_LAYOUT_GENERAL,
510  &((VkClearColorValue) { 0 }),
511  1, &((VkImageSubresourceRange) {
512  .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
513  .levelCount = 1,
514  .layerCount = 1,
515  }));
516  }
517 
518  /* Sync between setup and reset shaders */
519  ff_vk_buf_barrier(buf_bar[nb_buf_bar++], slice_data_buf,
520  COMPUTE_SHADER_BIT, SHADER_READ_BIT, SHADER_WRITE_BIT,
521  COMPUTE_SHADER_BIT, SHADER_READ_BIT, NONE_KHR,
522  0, slice_data_size*f->slice_count);
523  /* Prepare the probabilities */
524  if (!f->key_frame)
525  ff_vk_buf_barrier(buf_bar[nb_buf_bar++], slice_data_buf,
526  ALL_COMMANDS_BIT, NONE_KHR, NONE_KHR,
527  COMPUTE_SHADER_BIT, SHADER_WRITE_BIT, NONE_KHR,
528  slice_data_size*f->slice_count, VK_WHOLE_SIZE);
529  else
530  ff_vk_buf_barrier(buf_bar[nb_buf_bar++], slice_data_buf,
531  COMPUTE_SHADER_BIT, SHADER_READ_BIT, SHADER_WRITE_BIT,
532  COMPUTE_SHADER_BIT, SHADER_WRITE_BIT, NONE_KHR,
533  slice_data_size*f->slice_count, VK_WHOLE_SIZE);
534  vk->CmdPipelineBarrier2(exec->buf, &(VkDependencyInfo) {
535  .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
536  .pBufferMemoryBarriers = buf_bar,
537  .bufferMemoryBarrierCount = nb_buf_bar,
538  });
539  nb_buf_bar = 0;
540 
541  /* Run reset shader */
542  FFv1VkResetParameters pd_reset;
543  ff_vk_shader_update_desc_buffer(&fv->s, exec, &fv->reset,
544  1, 0, 0,
545  slice_data_buf,
546  0, slice_data_size*f->slice_count,
547  VK_FORMAT_UNDEFINED);
548  ff_vk_exec_bind_shader(&fv->s, exec, &fv->reset);
549  pd_reset = (FFv1VkResetParameters) {
550  .slice_state = slice_data_buf->address + f->slice_count*256,
551  .plane_state_size = plane_state_size,
552  .codec_planes = f->plane_count,
553  .key_frame = f->key_frame,
554  };
555  for (int i = 0; i < f->quant_table_count; i++)
556  pd_reset.context_count[i] = f->context_count[i];
557 
558  ff_vk_shader_update_push_const(&fv->s, exec, &fv->reset,
559  VK_SHADER_STAGE_COMPUTE_BIT,
560  0, sizeof(pd_reset), &pd_reset);
561  vk->CmdDispatch(exec->buf, fv->ctx.num_h_slices, fv->ctx.num_v_slices,
562  f->plane_count);
563 
564  /* Sync between reset and encode shaders */
565  ff_vk_buf_barrier(buf_bar[nb_buf_bar++], slice_data_buf,
566  COMPUTE_SHADER_BIT, SHADER_READ_BIT, NONE_KHR,
567  COMPUTE_SHADER_BIT, SHADER_READ_BIT, SHADER_WRITE_BIT,
568  0, slice_data_size*f->slice_count);
569  ff_vk_buf_barrier(buf_bar[nb_buf_bar++], slice_data_buf,
570  COMPUTE_SHADER_BIT, SHADER_WRITE_BIT, NONE_KHR,
571  COMPUTE_SHADER_BIT, SHADER_READ_BIT, SHADER_WRITE_BIT,
572  slice_data_size*f->slice_count, VK_WHOLE_SIZE);
573  ff_vk_buf_barrier(buf_bar[nb_buf_bar++], results_data_buf,
574  ALL_COMMANDS_BIT, NONE_KHR, NONE_KHR,
575  COMPUTE_SHADER_BIT, SHADER_WRITE_BIT, NONE_KHR,
576  0, VK_WHOLE_SIZE);
577  ff_vk_buf_barrier(buf_bar[nb_buf_bar++], out_data_buf,
578  ALL_COMMANDS_BIT, NONE_KHR, NONE_KHR,
579  COMPUTE_SHADER_BIT, SHADER_WRITE_BIT, NONE_KHR,
580  0, VK_WHOLE_SIZE);
581 
582  if (fv->is_rgb)
583  ff_vk_frame_barrier(&fv->s, exec, tmp, img_bar, &nb_img_bar,
584  VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
585  VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
586  VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT,
587  VK_IMAGE_LAYOUT_GENERAL,
588  VK_QUEUE_FAMILY_IGNORED);
589 
590  vk->CmdPipelineBarrier2(exec->buf, &(VkDependencyInfo) {
591  .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
592  .pImageMemoryBarriers = img_bar,
593  .imageMemoryBarrierCount = nb_img_bar,
594  .pBufferMemoryBarriers = buf_bar,
595  .bufferMemoryBarrierCount = nb_buf_bar,
596  });
597  nb_img_bar = 0;
598  nb_buf_bar = 0;
599 
600  /* Main encode shader */
601  ff_vk_shader_update_desc_buffer(&fv->s, exec, &fv->enc,
602  1, 0, 0,
603  slice_data_buf,
604  0, slice_data_size*f->slice_count,
605  VK_FORMAT_UNDEFINED);
606  ff_vk_shader_update_img_array(&fv->s, exec, &fv->enc,
607  src, src_views,
608  1, 1,
609  VK_IMAGE_LAYOUT_GENERAL,
610  VK_NULL_HANDLE);
611  ff_vk_shader_update_desc_buffer(&fv->s, exec,
612  &fv->enc, 1, 2, 0,
613  results_data_buf,
614  0, results_data_buf->size,
615  VK_FORMAT_UNDEFINED);
616  if (fv->is_rgb)
617  ff_vk_shader_update_img_array(&fv->s, exec, &fv->enc,
618  tmp, tmp_views,
619  1, 3,
620  VK_IMAGE_LAYOUT_GENERAL,
621  VK_NULL_HANDLE);
622 
623  ff_vk_exec_bind_shader(&fv->s, exec, &fv->enc);
624  ff_vk_shader_update_push_const(&fv->s, exec, &fv->enc,
625  VK_SHADER_STAGE_COMPUTE_BIT,
626  0, sizeof(pd), &pd);
627  vk->CmdDispatch(exec->buf, fv->ctx.num_h_slices, fv->ctx.num_v_slices, 1);
628 
629  /* Submit */
630  err = ff_vk_exec_submit(&fv->s, exec);
631  if (err < 0)
632  return err;
633 
634  f->picture_number++;
635 
636  /* This, if needed, was referenced by the execution context
637  * as it was declared as a dependency. */
638  av_frame_free(&tmp);
639  return 0;
640 
641 fail:
642  av_frame_free(&tmp);
643  ff_vk_exec_discard_deps(&fv->s, exec);
644 
645  return err;
646 }
647 
648 static int transfer_slices(AVCodecContext *avctx,
649  VkBufferCopy *buf_regions, int nb_regions,
650  VulkanEncodeFFv1FrameData *fd,
651  uint8_t *dst, AVBufferRef *dst_ref)
652 {
653  int err;
654  VulkanEncodeFFv1Context *fv = avctx->priv_data;
655  FFVulkanFunctions *vk = &fv->s.vkfn;
656  FFVkExecContext *exec;
657 
658  FFVkBuffer *out_data_buf = (FFVkBuffer *)fd->out_data_ref->data;
659 
660  AVBufferRef *mapped_ref;
661  FFVkBuffer *mapped_buf;
662 
663  VkBufferMemoryBarrier2 buf_bar[8];
664  int nb_buf_bar = 0;
665 
666  err = ff_vk_host_map_buffer(&fv->s, &mapped_ref, dst, dst_ref,
667  VK_BUFFER_USAGE_TRANSFER_DST_BIT);
668  if (err < 0)
669  return err;
670 
671  mapped_buf = (FFVkBuffer *)mapped_ref->data;
672 
673  /* Transfer the slices */
674  exec = ff_vk_exec_get(&fv->s, &fv->transfer_exec_pool);
675  ff_vk_exec_start(&fv->s, exec);
676 
677  ff_vk_exec_add_dep_buf(&fv->s, exec, &fd->out_data_ref, 1, 0);
678  fd->out_data_ref = NULL; /* Ownership passed */
679 
680  ff_vk_exec_add_dep_buf(&fv->s, exec, &mapped_ref, 1, 0);
681  mapped_ref = NULL; /* Ownership passed */
682 
683  /* Ensure the output buffer is finished */
684  ff_vk_buf_barrier(buf_bar[nb_buf_bar++], out_data_buf,
685  COMPUTE_SHADER_BIT, SHADER_WRITE_BIT, NONE_KHR,
686  TRANSFER_BIT, TRANSFER_READ_BIT, NONE_KHR,
687  0, VK_WHOLE_SIZE);
688  vk->CmdPipelineBarrier2(exec->buf, &(VkDependencyInfo) {
689  .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
690  .pBufferMemoryBarriers = buf_bar,
691  .bufferMemoryBarrierCount = nb_buf_bar,
692  });
693  nb_buf_bar = 0;
694 
695  for (int i = 0; i < nb_regions; i++)
696  buf_regions[i].dstOffset += mapped_buf->virtual_offset;
697 
698  vk->CmdCopyBuffer(exec->buf,
699  out_data_buf->buf, mapped_buf->buf,
700  nb_regions, buf_regions);
701 
702  /* Submit */
703  err = ff_vk_exec_submit(&fv->s, exec);
704  if (err < 0)
705  return err;
706 
707  /* We need the encoded data immediately */
708  ff_vk_exec_wait(&fv->s, exec);
709 
710  return 0;
711 }
712 
713 static int get_packet(AVCodecContext *avctx, FFVkExecContext *exec,
714  AVPacket *pkt)
715 {
716  int err;
717  VulkanEncodeFFv1Context *fv = avctx->priv_data;
718  FFV1Context *f = &fv->ctx;
719  FFVulkanFunctions *vk = &fv->s.vkfn;
720  VulkanEncodeFFv1FrameData *fd = exec->opaque;
721 
722  FFVkBuffer *out_data_buf = (FFVkBuffer *)fd->out_data_ref->data;
723  FFVkBuffer *results_data_buf = (FFVkBuffer *)fd->results_data_ref->data;
724  uint64_t *sc;
725 
726  /* Make sure encoding's done */
727  ff_vk_exec_wait(&fv->s, exec);
728 
729  /* Invalidate slice/output data if needed */
730  if (!(results_data_buf->flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)) {
731  VkMappedMemoryRange invalidate_data = {
732  .sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE,
733  .memory = results_data_buf->mem,
734  .offset = 0,
735  .size = VK_WHOLE_SIZE,
736  };
737  vk->InvalidateMappedMemoryRanges(fv->s.hwctx->act_dev,
738  1, &invalidate_data);
739  }
740 
741  /* Calculate final size */
742  pkt->size = 0;
743  for (int i = 0; i < f->slice_count; i++) {
744  sc = &((uint64_t *)results_data_buf->mapped_mem)[i*2];
745  av_log(avctx, AV_LOG_DEBUG, "Slice %i size = %"PRIu64", "
746  "src offset = %"PRIu64"\n",
747  i, sc[0], sc[1]);
748 
749  fv->buf_regions[i] = (VkBufferCopy) {
750  .srcOffset = sc[1],
751  .dstOffset = pkt->size,
752  .size = sc[0],
753  };
754  pkt->size += sc[0];
755  }
756  av_log(avctx, AV_LOG_VERBOSE, "Encoded data: %iMiB\n", pkt->size / (1024*1024));
757  av_buffer_unref(&fd->results_data_ref); /* No need for this buffer anymore */
758 
759  /* Allocate packet */
760  if ((err = ff_get_encode_buffer(avctx, pkt, pkt->size, 0)) < 0)
761  return err;
762 
763  pkt->pts = fd->pts;
764  pkt->dts = fd->pts;
765  pkt->duration = fd->duration;
766  pkt->flags |= AV_PKT_FLAG_KEY * fd->key_frame;
767 
768  if (avctx->flags & AV_CODEC_FLAG_COPY_OPAQUE) {
769  pkt->opaque = fd->frame_opaque;
770  pkt->opaque_ref = fd->frame_opaque_ref;
771  fd->frame_opaque_ref = NULL;
772  }
773 
774  /* Try using host mapped memory transfers first */
775  if (fv->s.extensions & FF_VK_EXT_EXTERNAL_HOST_MEMORY) {
776  err = transfer_slices(avctx, fv->buf_regions, f->slice_count, fd,
777  pkt->data, pkt->buf);
778  if (err >= 0)
779  return err;
780  }
781 
782  /* Invalidate slice/output data if needed */
783  if (!(out_data_buf->flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)) {
784  VkMappedMemoryRange invalidate_data = {
785  .sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE,
786  .memory = out_data_buf->mem,
787  .offset = 0,
788  .size = VK_WHOLE_SIZE,
789  };
790  vk->InvalidateMappedMemoryRanges(fv->s.hwctx->act_dev,
791  1, &invalidate_data);
792  }
793 
794  /* Copy each slice */
795  for (int i = 0; i < f->slice_count; i++) {
796  VkBufferCopy *region = &fv->buf_regions[i];
797  memcpy(pkt->data + region->dstOffset,
798  out_data_buf->mapped_mem + region->srcOffset,
799  region->size);
800  }
801 
802  av_buffer_unref(&fd->out_data_ref);
803 
804  return 0;
805 }
806 
807 static int vulkan_encode_ffv1_receive_packet(AVCodecContext *avctx,
808  AVPacket *pkt)
809 {
810  int err;
811  VulkanEncodeFFv1Context *fv = avctx->priv_data;
812  VulkanEncodeFFv1FrameData *fd;
813  FFVkExecContext *exec;
814  AVFrame *frame;
815 
816  while (1) {
817  /* Roll an execution context */
818  exec = ff_vk_exec_get(&fv->s, &fv->exec_pool);
819 
820  /* If it had a frame, immediately output it */
821  if (exec->had_submission) {
822  exec->had_submission = 0;
823  fv->in_flight--;
824  return get_packet(avctx, exec, pkt);
825  }
826 
827  /* Get next frame to encode */
828  frame = fv->frame;
829  err = ff_encode_get_frame(avctx, frame);
830  if (err < 0 && err != AVERROR_EOF) {
831  return err;
832  } else if (err == AVERROR_EOF) {
833  if (!fv->in_flight)
834  return err;
835  continue;
836  }
837 
838  /* Encode frame */
839  fd = exec->opaque;
840  fd->pts = frame->pts;
841  fd->duration = frame->duration;
842  if (avctx->flags & AV_CODEC_FLAG_COPY_OPAQUE) {
843  fd->frame_opaque = frame->opaque;
844  fd->frame_opaque_ref = frame->opaque_ref;
845  frame->opaque_ref = NULL;
846  }
847 
848  err = vulkan_encode_ffv1_submit_frame(avctx, exec, frame);
849  av_frame_unref(frame);
850  if (err < 0)
851  return err;
852 
853  fv->in_flight++;
854  if (fv->in_flight < fv->async_depth)
855  return AVERROR(EAGAIN);
856  }
857 
858  return 0;
859 }
860 
861 static int init_indirect(AVCodecContext *avctx, enum AVPixelFormat sw_format)
862 {
863  int err;
864  VulkanEncodeFFv1Context *fv = avctx->priv_data;
865  FFV1Context *f = &fv->ctx;
866  AVHWFramesContext *frames_ctx;
867  AVVulkanFramesContext *vk_frames;
868 
869  fv->intermediate_frames_ref = av_hwframe_ctx_alloc(fv->s.device_ref);
870  if (!fv->intermediate_frames_ref)
871  return AVERROR(ENOMEM);
872 
873  frames_ctx = (AVHWFramesContext *)fv->intermediate_frames_ref->data;
874  frames_ctx->format = AV_PIX_FMT_VULKAN;
875  frames_ctx->sw_format = sw_format;
876  frames_ctx->width = fv->s.frames->width;
877  frames_ctx->height = f->num_v_slices*RGB_LINECACHE;
878 
879  vk_frames = frames_ctx->hwctx;
880  vk_frames->tiling = VK_IMAGE_TILING_OPTIMAL;
881  vk_frames->usage = VK_IMAGE_USAGE_STORAGE_BIT |
882  VK_IMAGE_USAGE_TRANSFER_DST_BIT;
883  vk_frames->img_flags = VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
884 
885  err = av_hwframe_ctx_init(fv->intermediate_frames_ref);
886  if (err < 0) {
887  av_log(avctx, AV_LOG_ERROR, "Unable to initialize frame pool with format %s: %s\n",
888  av_get_pix_fmt_name(sw_format), av_err2str(err));
889  av_buffer_unref(&fv->intermediate_frames_ref);
890  return err;
891  }
892 
893  return 0;
894 }
895 
896 static int check_support(AVHWFramesConstraints *constraints,
897  enum AVPixelFormat fmt)
898 {
899  for (int i = 0; constraints->valid_sw_formats[i]; i++) {
900  if (constraints->valid_sw_formats[i] == fmt)
901  return 1;
902  }
903  return 0;
904 }
905 
906 static enum AVPixelFormat get_supported_rgb_buffer_fmt(AVCodecContext *avctx)
907 {
908  VulkanEncodeFFv1Context *fv = avctx->priv_data;
909 
910  enum AVPixelFormat fmt;
911  AVHWFramesConstraints *constraints;
912  constraints = av_hwdevice_get_hwframe_constraints(fv->s.device_ref,
913  NULL);
914 
915  /* What we'd like to optimally have */
916  fmt = fv->ctx.use32bit ?
917  (fv->ctx.transparency ? AV_PIX_FMT_RGBA128 : AV_PIX_FMT_RGB96) :
918  (fv->ctx.transparency ? AV_PIX_FMT_RGBA64 : AV_PIX_FMT_RGB48);
919  if (check_support(constraints, fmt))
920  goto end;
921 
922  if (fv->ctx.use32bit) {
923  if (check_support(constraints, (fmt = AV_PIX_FMT_RGBA128)))
924  goto end;
925  } else {
926  if (check_support(constraints, (fmt = AV_PIX_FMT_RGBA64)))
927  goto end;
928 
929  if (!fv->ctx.transparency &&
930  check_support(constraints, (fmt = AV_PIX_FMT_RGB96)))
931  goto end;
932 
933  if (check_support(constraints, (fmt = AV_PIX_FMT_RGBA128)))
934  goto end;
935  }
936 
937  fmt = AV_PIX_FMT_NONE;
938 
939 end:
940  av_hwframe_constraints_free(&constraints);
941  return fmt;
942 }
943 
944 static void define_shared_code(AVCodecContext *avctx, FFVulkanShader *shd)
945 {
946  VulkanEncodeFFv1Context *fv = avctx->priv_data;
947  FFV1Context *f = &fv->ctx;
948  int smp_bits = fv->ctx.use32bit ? 32 : 16;
949 
950  av_bprintf(&shd->src, "#define RGB_LINECACHE %i\n" ,RGB_LINECACHE);
951  av_bprintf(&shd->src, "#define CONTEXT_SIZE %i\n" ,CONTEXT_SIZE);
952  av_bprintf(&shd->src, "#define MAX_QUANT_TABLE_MASK 0x%x\n" ,MAX_QUANT_TABLE_MASK);
953 
954  if (f->ac == AC_GOLOMB_RICE) {
955  av_bprintf(&shd->src, "#define PB_UNALIGNED\n" );
956  av_bprintf(&shd->src, "#define GOLOMB\n" );
957  }
958 
959  if (fv->is_rgb)
960  av_bprintf(&shd->src, "#define RGB\n");
961 
962  GLSLF(0, #define TYPE int%i_t ,smp_bits);
963  GLSLF(0, #define VTYPE2 i%ivec2 ,smp_bits);
964  GLSLF(0, #define VTYPE3 i%ivec3 ,smp_bits);
965  GLSLD(ff_source_rangecoder_comp);
966 
967  if (f->ac == AC_GOLOMB_RICE)
968  GLSLD(ff_source_ffv1_vlc_comp);
969 
970  GLSLD(ff_source_ffv1_common_comp);
971 }
972 
973 static int init_rct_search_shader(AVCodecContext *avctx, FFVkSPIRVCompiler *spv)
974 {
975  int err;
976  VulkanEncodeFFv1Context *fv = avctx->priv_data;
977  FFV1Context *f = &fv->ctx;
978  FFVulkanShader *shd = &fv->rct_search;
979  FFVulkanDescriptorSetBinding *desc_set;
980 
981  uint8_t *spv_data;
982  size_t spv_len;
983  void *spv_opaque = NULL;
984 
985  RET(ff_vk_shader_init(&fv->s, shd, "ffv1_rct_search",
986  VK_SHADER_STAGE_COMPUTE_BIT,
987  (const char *[]) { "GL_EXT_buffer_reference",
988  "GL_EXT_buffer_reference2",
989  "GL_EXT_null_initializer" }, 3,
990  32, 32, 1,
991  0));
992 
993  /* Common codec header */
994  GLSLD(ff_source_common_comp);
995 
996  GLSLC(0, layout(push_constant, scalar) uniform pushConstants { );
997  GLSLC(1, ivec4 fmt_lut; );
998  GLSLC(1, int rct_offset; );
999  GLSLC(1, uint8_t planar_rgb; );
1000  GLSLC(1, uint8_t transparency; );
1001  GLSLC(1, uint8_t key_frame; );
1002  GLSLC(1, uint8_t force_pcm; );
1003  GLSLC(1, uint8_t version; );
1004  GLSLC(1, uint8_t micro_version; );
1005  GLSLC(1, uint8_t padding[3]; );
1006  GLSLC(0, }; );
1007  ff_vk_shader_add_push_const(shd, 0, sizeof(FFv1VkResetParameters),
1008  VK_SHADER_STAGE_COMPUTE_BIT);
1009 
1010  av_bprintf(&shd->src, "#define MAX_QUANT_TABLES %i\n", MAX_QUANT_TABLES);
1011  av_bprintf(&shd->src, "#define MAX_CONTEXT_INPUTS %i\n", MAX_CONTEXT_INPUTS);
1012  av_bprintf(&shd->src, "#define MAX_QUANT_TABLE_SIZE %i\n", MAX_QUANT_TABLE_SIZE);
1013 
1014  /* Never used */
1015  desc_set = (FFVulkanDescriptorSetBinding []) {
1016  {
1017  .name = "rangecoder_static_buf",
1018  .type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
1019  .stages = VK_SHADER_STAGE_COMPUTE_BIT,
1020  .mem_layout = "scalar",
1021  .buf_content = "uint8_t zero_one_state[512];",
1022  },
1023  {
1024  .name = "quant_buf",
1025  .type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
1026  .stages = VK_SHADER_STAGE_COMPUTE_BIT,
1027  .mem_layout = "scalar",
1028  .buf_content = "int16_t quant_table[MAX_QUANT_TABLES]"
1029  "[MAX_CONTEXT_INPUTS][MAX_QUANT_TABLE_SIZE];",
1030  },
1031  };
1032  RET(ff_vk_shader_add_descriptor_set(&fv->s, shd, desc_set, 2, 1, 1));
1033 
1034  define_shared_code(avctx, shd);
1035 
1036  desc_set = (FFVulkanDescriptorSetBinding []) {
1037  {
1038  .name = "slice_data_buf",
1039  .type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
1040  .stages = VK_SHADER_STAGE_COMPUTE_BIT,
1041  .buf_content = "SliceContext slice_ctx",
1042  .buf_elems = f->max_slice_count,
1043  },
1044  {
1045  .name = "src",
1046  .type = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
1047  .dimensions = 2,
1048  .mem_layout = ff_vk_shader_rep_fmt(fv->s.frames->sw_format,
1049  FF_VK_REP_NATIVE),
1050  .elems = av_pix_fmt_count_planes(fv->s.frames->sw_format),
1051  .mem_quali = "readonly",
1052  .stages = VK_SHADER_STAGE_COMPUTE_BIT,
1053  },
1054  };
1055  RET(ff_vk_shader_add_descriptor_set(&fv->s, shd, desc_set, 2, 0, 0));
1056 
1057  GLSLD(ff_source_ffv1_rct_search_comp);
1058 
1059  RET(spv->compile_shader(&fv->s, spv, shd, &spv_data, &spv_len, "main",
1060  &spv_opaque));
1061  RET(ff_vk_shader_link(&fv->s, shd, spv_data, spv_len, "main"));
1062 
1063  RET(ff_vk_shader_register_exec(&fv->s, &fv->exec_pool, shd));
1064 
1065 fail:
1066  if (spv_opaque)
1067  spv->free_shader(spv, &spv_opaque);
1068 
1069  return err;
1070 }
1071 
1072 static int init_setup_shader(AVCodecContext *avctx, FFVkSPIRVCompiler *spv)
1073 {
1074  int err;
1075  VulkanEncodeFFv1Context *fv = avctx->priv_data;
1076  FFV1Context *f = &fv->ctx;
1077  FFVulkanShader *shd = &fv->setup;
1078  FFVulkanDescriptorSetBinding *desc_set;
1079 
1080  uint8_t *spv_data;
1081  size_t spv_len;
1082  void *spv_opaque = NULL;
1083 
1084  RET(ff_vk_shader_init(&fv->s, shd, "ffv1_setup",
1085  VK_SHADER_STAGE_COMPUTE_BIT,
1086  (const char *[]) { "GL_EXT_buffer_reference",
1087  "GL_EXT_buffer_reference2" }, 2,
1088  1, 1, 1,
1089  0));
1090 
1091  /* Common codec header */
1092  GLSLD(ff_source_common_comp);
1093  add_push_data(shd);
1094 
1095  av_bprintf(&shd->src, "#define MAX_QUANT_TABLES %i\n", MAX_QUANT_TABLES);
1096  av_bprintf(&shd->src, "#define MAX_CONTEXT_INPUTS %i\n", MAX_CONTEXT_INPUTS);
1097  av_bprintf(&shd->src, "#define MAX_QUANT_TABLE_SIZE %i\n", MAX_QUANT_TABLE_SIZE);
1098  av_bprintf(&shd->src, "#define FULL_RENORM\n");
1099 
1100  desc_set = (FFVulkanDescriptorSetBinding []) {
1101  {
1102  .name = "rangecoder_static_buf",
1103  .type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
1104  .stages = VK_SHADER_STAGE_COMPUTE_BIT,
1105  .mem_layout = "scalar",
1106  .buf_content = "uint8_t zero_one_state[512];",
1107  },
1108  { /* This descriptor is never used */
1109  .name = "quant_buf",
1110  .type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
1111  .stages = VK_SHADER_STAGE_COMPUTE_BIT,
1112  .mem_layout = "scalar",
1113  .buf_content = "int16_t quant_table[MAX_QUANT_TABLES]"
1114  "[MAX_CONTEXT_INPUTS][MAX_QUANT_TABLE_SIZE];",
1115  },
1116  };
1117  RET(ff_vk_shader_add_descriptor_set(&fv->s, shd, desc_set, 2, 1, 0));
1118 
1119  define_shared_code(avctx, shd);
1120 
1121  desc_set = (FFVulkanDescriptorSetBinding []) {
1122  {
1123  .name = "slice_data_buf",
1124  .type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
1125  .stages = VK_SHADER_STAGE_COMPUTE_BIT,
1126  .buf_content = "SliceContext slice_ctx",
1127  .buf_elems = f->max_slice_count,
1128  },
1129  {
1130  .name = "src",
1131  .type = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
1132  .dimensions = 2,
1133  .mem_layout = ff_vk_shader_rep_fmt(fv->s.frames->sw_format,
1134  FF_VK_REP_NATIVE),
1135  .elems = av_pix_fmt_count_planes(fv->s.frames->sw_format),
1136  .mem_quali = "readonly",
1137  .stages = VK_SHADER_STAGE_COMPUTE_BIT,
1138  },
1139  };
1140  RET(ff_vk_shader_add_descriptor_set(&fv->s, shd, desc_set, 2, 0, 0));
1141 
1142  GLSLD(ff_source_ffv1_enc_setup_comp);
1143 
1144  RET(spv->compile_shader(&fv->s, spv, shd, &spv_data, &spv_len, "main",
1145  &spv_opaque));
1146  RET(ff_vk_shader_link(&fv->s, shd, spv_data, spv_len, "main"));
1147 
1148  RET(ff_vk_shader_register_exec(&fv->s, &fv->exec_pool, shd));
1149 
1150 fail:
1151  if (spv_opaque)
1152  spv->free_shader(spv, &spv_opaque);
1153 
1154  return err;
1155 }
1156 
1157 static int init_reset_shader(AVCodecContext *avctx, FFVkSPIRVCompiler *spv)
1158 {
1159  int err;
1160  VulkanEncodeFFv1Context *fv = avctx->priv_data;
1161  FFV1Context *f = &fv->ctx;
1162  FFVulkanShader *shd = &fv->reset;
1163  FFVulkanDescriptorSetBinding *desc_set;
1164 
1165  uint8_t *spv_data;
1166  size_t spv_len;
1167  void *spv_opaque = NULL;
1168  int wg_dim = FFMIN(fv->s.props.properties.limits.maxComputeWorkGroupSize[0], 1024);
1169 
1170  RET(ff_vk_shader_init(&fv->s, shd, "ffv1_reset",
1171  VK_SHADER_STAGE_COMPUTE_BIT,
1172  (const char *[]) { "GL_EXT_buffer_reference",
1173  "GL_EXT_buffer_reference2" }, 2,
1174  wg_dim, 1, 1,
1175  0));
1176 
1177  /* Common codec header */
1178  GLSLD(ff_source_common_comp);
1179 
1180  GLSLC(0, layout(push_constant, scalar) uniform pushConstants { );
1181  GLSLF(1, uint context_count[%i]; ,MAX_QUANT_TABLES);
1182  GLSLC(1, u8buf slice_state; );
1183  GLSLC(1, uint plane_state_size; );
1184  GLSLC(1, uint8_t codec_planes; );
1185  GLSLC(1, uint8_t key_frame; );
1186  GLSLC(1, uint8_t version; );
1187  GLSLC(1, uint8_t micro_version; );
1188  GLSLC(1, uint8_t padding[1]; );
1189  GLSLC(0, }; );
1190  ff_vk_shader_add_push_const(shd, 0, sizeof(FFv1VkResetParameters),
1191  VK_SHADER_STAGE_COMPUTE_BIT);
1192 
1193  av_bprintf(&shd->src, "#define MAX_QUANT_TABLES %i\n", MAX_QUANT_TABLES);
1194  av_bprintf(&shd->src, "#define MAX_CONTEXT_INPUTS %i\n", MAX_CONTEXT_INPUTS);
1195  av_bprintf(&shd->src, "#define MAX_QUANT_TABLE_SIZE %i\n", MAX_QUANT_TABLE_SIZE);
1196 
1197  desc_set = (FFVulkanDescriptorSetBinding []) {
1198  {
1199  .name = "rangecoder_static_buf",
1200  .type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
1201  .stages = VK_SHADER_STAGE_COMPUTE_BIT,
1202  .mem_layout = "scalar",
1203  .buf_content = "uint8_t zero_one_state[512];",
1204  },
1205  {
1206  .name = "quant_buf",
1207  .type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
1208  .stages = VK_SHADER_STAGE_COMPUTE_BIT,
1209  .mem_layout = "scalar",
1210  .buf_content = "int16_t quant_table[MAX_QUANT_TABLES]"
1211  "[MAX_CONTEXT_INPUTS][MAX_QUANT_TABLE_SIZE];",
1212  },
1213  };
1214  RET(ff_vk_shader_add_descriptor_set(&fv->s, shd, desc_set, 2, 1, 0));
1215 
1216  define_shared_code(avctx, shd);
1217 
1218  desc_set = (FFVulkanDescriptorSetBinding []) {
1219  {
1220  .name = "slice_data_buf",
1221  .type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
1222  .mem_quali = "readonly",
1223  .stages = VK_SHADER_STAGE_COMPUTE_BIT,
1224  .buf_content = "SliceContext slice_ctx",
1225  .buf_elems = f->max_slice_count,
1226  },
1227  };
1228  RET(ff_vk_shader_add_descriptor_set(&fv->s, shd, desc_set, 1, 0, 0));
1229 
1230  GLSLD(ff_source_ffv1_reset_comp);
1231 
1232  RET(spv->compile_shader(&fv->s, spv, shd, &spv_data, &spv_len, "main",
1233  &spv_opaque));
1234  RET(ff_vk_shader_link(&fv->s, shd, spv_data, spv_len, "main"));
1235 
1236  RET(ff_vk_shader_register_exec(&fv->s, &fv->exec_pool, shd));
1237 
1238 fail:
1239  if (spv_opaque)
1240  spv->free_shader(spv, &spv_opaque);
1241 
1242  return err;
1243 }
1244 
1245 static int init_encode_shader(AVCodecContext *avctx, FFVkSPIRVCompiler *spv)
1246 {
1247  int err;
1248  VulkanEncodeFFv1Context *fv = avctx->priv_data;
1249  FFV1Context *f = &fv->ctx;
1250  FFVulkanShader *shd = &fv->enc;
1251  FFVulkanDescriptorSetBinding *desc_set;
1252 
1253  uint8_t *spv_data;
1254  size_t spv_len;
1255  void *spv_opaque = NULL;
1256  int use_cached_reader = fv->ctx.ac != AC_GOLOMB_RICE &&
1257  fv->s.driver_props.driverID == VK_DRIVER_ID_MESA_RADV;
1258 
1259  RET(ff_vk_shader_init(&fv->s, shd, "ffv1_enc",
1260  VK_SHADER_STAGE_COMPUTE_BIT,
1261  (const char *[]) { "GL_EXT_buffer_reference",
1262  "GL_EXT_buffer_reference2" }, 2,
1263  use_cached_reader ? CONTEXT_SIZE : 1, 1, 1,
1264  0));
1265 
1266  /* Common codec header */
1267  GLSLD(ff_source_common_comp);
1268 
1269  add_push_data(shd);
1270 
1271  av_bprintf(&shd->src, "#define MAX_QUANT_TABLES %i\n", MAX_QUANT_TABLES);
1272  av_bprintf(&shd->src, "#define MAX_CONTEXT_INPUTS %i\n", MAX_CONTEXT_INPUTS);
1273  av_bprintf(&shd->src, "#define MAX_QUANT_TABLE_SIZE %i\n", MAX_QUANT_TABLE_SIZE);
1274 
1275  if (use_cached_reader)
1276  av_bprintf(&shd->src, "#define CACHED_SYMBOL_READER 1\n");
1277 
1278  desc_set = (FFVulkanDescriptorSetBinding []) {
1279  {
1280  .name = "rangecoder_static_buf",
1281  .type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
1282  .stages = VK_SHADER_STAGE_COMPUTE_BIT,
1283  .mem_layout = "scalar",
1284  .buf_content = "uint8_t zero_one_state[512];",
1285  },
1286  {
1287  .name = "quant_buf",
1288  .type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
1289  .stages = VK_SHADER_STAGE_COMPUTE_BIT,
1290  .mem_layout = "scalar",
1291  .buf_content = "int16_t quant_table[MAX_QUANT_TABLES]"
1292  "[MAX_CONTEXT_INPUTS][MAX_QUANT_TABLE_SIZE];",
1293  },
1294  {
1295  .name = "crc_ieee_buf",
1296  .type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
1297  .stages = VK_SHADER_STAGE_COMPUTE_BIT,
1298  .mem_layout = "scalar",
1299  .buf_content = "uint32_t crc_ieee[256];",
1300  },
1301  };
1302 
1303  RET(ff_vk_shader_add_descriptor_set(&fv->s, shd, desc_set, 3, 1, 0));
1304 
1305  define_shared_code(avctx, shd);
1306 
1307  desc_set = (FFVulkanDescriptorSetBinding []) {
1308  {
1309  .name = "slice_data_buf",
1310  .type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
1311  .stages = VK_SHADER_STAGE_COMPUTE_BIT,
1312  .buf_content = "SliceContext slice_ctx",
1313  .buf_elems = f->max_slice_count,
1314  },
1315  {
1316  .name = "src",
1317  .type = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
1318  .dimensions = 2,
1319  .mem_layout = ff_vk_shader_rep_fmt(fv->s.frames->sw_format,
1320  FF_VK_REP_NATIVE),
1321  .elems = av_pix_fmt_count_planes(fv->s.frames->sw_format),
1322  .mem_quali = "readonly",
1323  .stages = VK_SHADER_STAGE_COMPUTE_BIT,
1324  },
1325  {
1326  .name = "results_data_buf",
1327  .type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
1328  .stages = VK_SHADER_STAGE_COMPUTE_BIT,
1329  .mem_quali = "writeonly",
1330  .buf_content = "uint64_t slice_results[2048];",
1331  },
1332  { /* place holder for desc_set[3] */
1333  .name = "placeholder",
1334  },
1335  };
1336  if (fv->is_rgb) {
1337  AVHWFramesContext *intermediate_frames_ctx;
1338  intermediate_frames_ctx = (AVHWFramesContext *)fv->intermediate_frames_ref->data;
1339  desc_set[3] = (FFVulkanDescriptorSetBinding) {
1340  .name = "tmp",
1341  .type = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
1342  .dimensions = 2,
1343  .mem_layout = ff_vk_shader_rep_fmt(intermediate_frames_ctx->sw_format,
1344  FF_VK_REP_NATIVE),
1345  .stages = VK_SHADER_STAGE_COMPUTE_BIT,
1346  };
1347  }
1348  RET(ff_vk_shader_add_descriptor_set(&fv->s, shd, desc_set, 3 + fv->is_rgb, 0, 0));
1349 
1350  GLSLD(ff_source_ffv1_enc_comp);
1351 
1352  RET(spv->compile_shader(&fv->s, spv, shd, &spv_data, &spv_len, "main",
1353  &spv_opaque));
1354  RET(ff_vk_shader_link(&fv->s, shd, spv_data, spv_len, "main"));
1355 
1356  RET(ff_vk_shader_register_exec(&fv->s, &fv->exec_pool, shd));
1357 
1358 fail:
1359  if (spv_opaque)
1360  spv->free_shader(spv, &spv_opaque);
1361 
1362  return err;
1363 }
1364 
1365 static av_cold int vulkan_encode_ffv1_init(AVCodecContext *avctx)
1366 {
1367  int err;
1368  size_t maxsize, max_heap_size, max_host_size;
1369  VulkanEncodeFFv1Context *fv = avctx->priv_data;
1370  FFV1Context *f = &fv->ctx;
1371  FFVkSPIRVCompiler *spv;
1372 
1373  if ((err = ff_ffv1_common_init(avctx, f)) < 0)
1374  return err;
1375 
1376  if (f->ac == 1)
1377  f->ac = AC_RANGE_CUSTOM_TAB;
1378 
1379  err = ff_ffv1_encode_setup_plane_info(avctx, avctx->sw_pix_fmt);
1380  if (err < 0)
1381  return err;
1382 
1383  /* Target version 3 by default */
1384  f->version = 3;
1385 
1386  err = ff_ffv1_encode_init(avctx);
1387  if (err < 0)
1388  return err;
1389 
1390  /* Rice coding did not support high bit depths */
1391  if (f->bits_per_raw_sample > (f->version > 3 ? 16 : 8)) {
1392  if (f->ac == AC_GOLOMB_RICE) {
1393  av_log(avctx, AV_LOG_WARNING, "bits_per_raw_sample > 8, "
1394  "forcing range coder\n");
1395  f->ac = AC_RANGE_CUSTOM_TAB;
1396  }
1397  }
1398 
1399  if (f->version < 4 && avctx->gop_size > 1) {
1400  av_log(avctx, AV_LOG_ERROR, "Using inter frames requires version 4 (-level 4)\n");
1401  return AVERROR_INVALIDDATA;
1402  }
1403 
1404  if (f->version == 4 && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
1405  av_log(avctx, AV_LOG_ERROR, "Version 4 is experimental and requires -strict -2\n");
1406  return AVERROR_INVALIDDATA;
1407  }
1408 
1409  /* We target version 4.3 */
1410  if (f->version == 4 && f->micro_version > 4)
1411  f->micro_version = 3;
1412 
1413  //if (fv->ctx.ac == AC_GOLOMB_RICE) {
1414  if (0) {
1415  int w_a = FFALIGN(avctx->width, LG_ALIGN_W);
1416  int h_a = FFALIGN(avctx->height, LG_ALIGN_H);
1417  int w_sl, h_sl;
1418 
1419  /* Pixels per line an invocation handles */
1420  int ppi = 0;
1421  /* Chunk size */
1422  int chunks = 0;
1423 
1424  do {
1425  if (ppi < 2)
1426  ppi++;
1427  chunks++;
1428  w_sl = w_a / (LG_ALIGN_W*ppi);
1429  h_sl = h_a / (LG_ALIGN_H*chunks);
1430  } while (w_sl > MAX_SLICES / h_sl);
1431 
1432  av_log(avctx, AV_LOG_VERBOSE, "Slice config: %ix%i, %i total\n",
1433  LG_ALIGN_W*ppi, LG_ALIGN_H*chunks, w_sl*h_sl);
1434  av_log(avctx, AV_LOG_VERBOSE, "Horizontal slices: %i (%i pixels per invoc)\n",
1435  w_sl, ppi);
1436  av_log(avctx, AV_LOG_VERBOSE, "Vertical slices: %i (%i chunks)\n",
1437  h_sl, chunks);
1438 
1439  f->num_h_slices = w_sl;
1440  f->num_v_slices = h_sl;
1441 
1442  fv->ppi = ppi;
1443  fv->chunks = chunks;
1444  } else {
1445  f->num_h_slices = fv->num_h_slices;
1446  f->num_v_slices = fv->num_v_slices;
1447 
1448  if (f->num_h_slices <= 0 && f->num_v_slices <= 0) {
1449  if (avctx->slices) {
1450  err = ff_ffv1_encode_determine_slices(avctx);
1451  if (err < 0)
1452  return err;
1453  } else {
1454  f->num_h_slices = 32;
1455  f->num_v_slices = 32;
1456  }
1457  } else if (f->num_h_slices && f->num_v_slices <= 0) {
1458  f->num_v_slices = MAX_SLICES / f->num_h_slices;
1459  } else if (f->num_v_slices && f->num_h_slices <= 0) {
1460  f->num_h_slices = MAX_SLICES / f->num_v_slices;
1461  }
1462 
1463  f->num_h_slices = FFMIN(f->num_h_slices, avctx->width);
1464  f->num_v_slices = FFMIN(f->num_v_slices, avctx->height);
1465 
1466  if (f->num_h_slices * f->num_v_slices > MAX_SLICES) {
1467  av_log(avctx, AV_LOG_ERROR, "Too many slices (%i), maximum supported "
1468  "by the standard is %i\n",
1469  f->num_h_slices * f->num_v_slices, MAX_SLICES);
1470  return AVERROR_PATCHWELCOME;
1471  }
1472  }
1473 
1474  f->max_slice_count = f->num_h_slices * f->num_v_slices;
1475 
1476  if ((err = ff_ffv1_write_extradata(avctx)) < 0)
1477  return err;
1478 
1479  if (f->version < 4) {
1480  if (((f->chroma_h_shift > 0) && (avctx->width % (64 << f->chroma_h_shift))) ||
1481  ((f->chroma_v_shift > 0) && (avctx->height % (64 << f->chroma_v_shift)))) {
1482  av_log(avctx, AV_LOG_ERROR, "Encoding frames with subsampling and unaligned "
1483  "dimensions is only supported in version 4 (-level 4)\n");
1484  return AVERROR_PATCHWELCOME;
1485  }
1486  }
1487 
1488  if (fv->force_pcm) {
1489  if (f->version < 4) {
1490  av_log(avctx, AV_LOG_ERROR, "PCM coding only supported by version 4 (-level 4)\n");
1491  return AVERROR_INVALIDDATA;
1492  } else if (f->ac == AC_GOLOMB_RICE) {
1493  av_log(avctx, AV_LOG_ERROR, "PCM coding requires range coding\n");
1494  return AVERROR_INVALIDDATA;
1495  }
1496  }
1497 
1498  /* Init Vulkan */
1499  err = ff_vk_init(&fv->s, avctx, NULL, avctx->hw_frames_ctx);
1500  if (err < 0)
1501  return err;
1502 
1503  fv->qf = ff_vk_qf_find(&fv->s, VK_QUEUE_COMPUTE_BIT, 0);
1504  if (!fv->qf) {
1505  av_log(avctx, AV_LOG_ERROR, "Device has no compute queues!\n");
1506  return err;
1507  }
1508 
1509  /* Try to measure VRAM size */
1510  max_heap_size = 0;
1511  max_host_size = 0;
1512  for (int i = 0; i < fv->s.mprops.memoryHeapCount; i++) {
1513  if (fv->s.mprops.memoryHeaps[i].flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT)
1514  max_heap_size = FFMAX(fv->max_heap_size,
1515  fv->s.mprops.memoryHeaps[i].size);
1516  if (!(fv->s.mprops.memoryHeaps[i].flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT))
1517  max_host_size = FFMAX(max_host_size,
1518  fv->s.mprops.memoryHeaps[i].size);
1519  }
1520  fv->max_heap_size = max_heap_size;
1521 
1522  maxsize = ff_ffv1_encode_buffer_size(avctx);
1523  if (maxsize > fv->s.props_11.maxMemoryAllocationSize) {
1524  av_log(avctx, AV_LOG_WARNING, "Encoding buffer size (%zu) larger "
1525  "than maximum device allocation (%zu), clipping\n",
1526  maxsize, fv->s.props_11.maxMemoryAllocationSize);
1527  maxsize = fv->s.props_11.maxMemoryAllocationSize;
1528  }
1529 
1530  if (max_heap_size < maxsize) {
1531  av_log(avctx, AV_LOG_WARNING, "Encoding buffer (%zu) larger than VRAM (%zu), "
1532  "using host memory (slower)\n",
1533  maxsize, fv->max_heap_size);
1534 
1535  /* Keep 1/2th of RAM as headroom */
1536  max_heap_size = max_host_size - (max_host_size >> 1);
1537  } else {
1538  /* Keep 1/8th of VRAM as headroom */
1539  max_heap_size = max_heap_size - (max_heap_size >> 3);
1540  }
1541 
1542  av_log(avctx, AV_LOG_INFO, "Async buffers: %zuMiB per context, %zuMiB total, depth: %i\n",
1543  maxsize / (1024*1024),
1544  (fv->async_depth * maxsize) / (1024*1024),
1545  fv->async_depth);
1546 
1547  err = ff_vk_exec_pool_init(&fv->s, fv->qf, &fv->exec_pool,
1548  fv->async_depth,
1549  0, 0, 0, NULL);
1550  if (err < 0)
1551  return err;
1552 
1553  fv->transfer_qf = ff_vk_qf_find(&fv->s, VK_QUEUE_TRANSFER_BIT, 0);
1554  if (!fv->transfer_qf) {
1555  av_log(avctx, AV_LOG_ERROR, "Device has no transfer queues!\n");
1556  return err;
1557  }
1558 
1559  err = ff_vk_exec_pool_init(&fv->s, fv->transfer_qf, &fv->transfer_exec_pool,
1560  1,
1561  0, 0, 0, NULL);
1562  if (err < 0)
1563  return err;
1564 
1565  spv = ff_vk_spirv_init();
1566  if (!spv) {
1567  av_log(avctx, AV_LOG_ERROR, "Unable to initialize SPIR-V compiler!\n");
1568  return AVERROR_EXTERNAL;
1569  }
1570 
1571  /* Detect the special RGB coding mode */
1572  fv->is_rgb = !(f->colorspace == 0 && avctx->sw_pix_fmt != AV_PIX_FMT_YA8) &&
1573  !(avctx->sw_pix_fmt == AV_PIX_FMT_YA8);
1574 
1575  /* Init rct search shader */
1576  fv->optimize_rct = fv->is_rgb && f->version >= 4 &&
1577  !fv->force_pcm && fv->optimize_rct;
1578  if (fv->optimize_rct) {
1579  err = init_rct_search_shader(avctx, spv);
1580  if (err < 0) {
1581  spv->uninit(&spv);
1582  return err;
1583  }
1584  }
1585 
1586  /* Init setup shader */
1587  err = init_setup_shader(avctx, spv);
1588  if (err < 0) {
1589  spv->uninit(&spv);
1590  return err;
1591  }
1592 
1593  /* Init reset shader */
1594  err = init_reset_shader(avctx, spv);
1595  if (err < 0) {
1596  spv->uninit(&spv);
1597  return err;
1598  }
1599 
1600  if (fv->is_rgb) {
1601  enum AVPixelFormat intermediate_fmt = get_supported_rgb_buffer_fmt(avctx);
1602  if (intermediate_fmt == AV_PIX_FMT_NONE) {
1603  av_log(avctx, AV_LOG_ERROR, "Unable to find a supported compatible "
1604  "pixel format for RCT buffer!\n");
1605  return AVERROR(ENOTSUP);
1606  }
1607 
1608  RET(init_indirect(avctx, intermediate_fmt));
1609  }
1610 
1611  /* Encode shader */
1612  err = init_encode_shader(avctx, spv);
1613  if (err < 0) {
1614  spv->uninit(&spv);
1615  return err;
1616  }
1617 
1618  spv->uninit(&spv);
1619 
1620  /* Range coder data */
1621  err = ff_ffv1_vk_init_state_transition_data(&fv->s,
1622  &fv->rangecoder_static_buf,
1623  f);
1624  if (err < 0)
1625  return err;
1626 
1627  /* Quantization table data */
1628  err = ff_ffv1_vk_init_quant_table_data(&fv->s,
1629  &fv->quant_buf,
1630  f);
1631  if (err < 0)
1632  return err;
1633 
1634  /* CRC table buffer */
1635  err = ff_ffv1_vk_init_crc_table_data(&fv->s,
1636  &fv->crc_tab_buf,
1637  f);
1638  if (err < 0)
1639  return err;
1640 
1641  /* Update setup global descriptors */
1642  RET(ff_vk_shader_update_desc_buffer(&fv->s, &fv->exec_pool.contexts[0],
1643  &fv->setup, 0, 0, 0,
1644  &fv->rangecoder_static_buf,
1645  0, fv->rangecoder_static_buf.size,
1646  VK_FORMAT_UNDEFINED));
1647 
1648  /* Update encode global descriptors */
1649  RET(ff_vk_shader_update_desc_buffer(&fv->s, &fv->exec_pool.contexts[0],
1650  &fv->enc, 0, 0, 0,
1651  &fv->rangecoder_static_buf,
1652  0, fv->rangecoder_static_buf.size,
1653  VK_FORMAT_UNDEFINED));
1654  RET(ff_vk_shader_update_desc_buffer(&fv->s, &fv->exec_pool.contexts[0],
1655  &fv->enc, 0, 1, 0,
1656  &fv->quant_buf,
1657  0, fv->quant_buf.size,
1658  VK_FORMAT_UNDEFINED));
1659  RET(ff_vk_shader_update_desc_buffer(&fv->s, &fv->exec_pool.contexts[0],
1660  &fv->enc, 0, 2, 0,
1661  &fv->crc_tab_buf,
1662  0, fv->crc_tab_buf.size,
1663  VK_FORMAT_UNDEFINED));
1664 
1665  /* Temporary frame */
1666  fv->frame = av_frame_alloc();
1667  if (!fv->frame)
1668  return AVERROR(ENOMEM);
1669 
1670  /* Async data pool */
1671  fv->async_depth = fv->exec_pool.pool_size;
1672  fv->exec_ctx_info = av_calloc(fv->async_depth, sizeof(*fv->exec_ctx_info));
1673  if (!fv->exec_ctx_info)
1674  return AVERROR(ENOMEM);
1675  for (int i = 0; i < fv->async_depth; i++)
1676  fv->exec_pool.contexts[i].opaque = &fv->exec_ctx_info[i];
1677 
1678  fv->buf_regions = av_malloc_array(f->max_slice_count, sizeof(*fv->buf_regions));
1679  if (!fv->buf_regions)
1680  return AVERROR(ENOMEM);
1681 
1682 fail:
1683  return err;
1684 }
1685 
1686 static av_cold int vulkan_encode_ffv1_close(AVCodecContext *avctx)
1687 {
1688  VulkanEncodeFFv1Context *fv = avctx->priv_data;
1689 
1690  ff_vk_exec_pool_free(&fv->s, &fv->exec_pool);
1691  ff_vk_exec_pool_free(&fv->s, &fv->transfer_exec_pool);
1692 
1693  ff_vk_shader_free(&fv->s, &fv->enc);
1694  ff_vk_shader_free(&fv->s, &fv->reset);
1695  ff_vk_shader_free(&fv->s, &fv->setup);
1696  ff_vk_shader_free(&fv->s, &fv->rct_search);
1697 
1698  if (fv->exec_ctx_info) {
1699  for (int i = 0; i < fv->async_depth; i++) {
1700  VulkanEncodeFFv1FrameData *fd = &fv->exec_ctx_info[i];
1701  av_buffer_unref(&fd->out_data_ref);
1702  av_buffer_unref(&fd->results_data_ref);
1703  av_buffer_unref(&fd->frame_opaque_ref);
1704  }
1705  }
1706  av_free(fv->exec_ctx_info);
1707 
1708  av_buffer_unref(&fv->intermediate_frames_ref);
1709 
1710  av_buffer_pool_uninit(&fv->results_data_pool);
1711 
1712  av_buffer_pool_uninit(&fv->out_data_pool);
1713 
1714  av_buffer_unref(&fv->keyframe_slice_data_ref);
1715  av_buffer_pool_uninit(&fv->slice_data_pool);
1716 
1717  ff_vk_free_buf(&fv->s, &fv->quant_buf);
1718  ff_vk_free_buf(&fv->s, &fv->rangecoder_static_buf);
1719  ff_vk_free_buf(&fv->s, &fv->crc_tab_buf);
1720 
1721  av_free(fv->buf_regions);
1722  av_frame_free(&fv->frame);
1723  ff_vk_uninit(&fv->s);
1724 
1725  return 0;
1726 }
1727 
1728 #define OFFSET(x) offsetof(VulkanEncodeFFv1Context, x)
1729 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1730 static const AVOption vulkan_encode_ffv1_options[] = {
1731  { "slicecrc", "Protect slices with CRCs", OFFSET(ctx.ec), AV_OPT_TYPE_INT,
1732  { .i64 = -1 }, -1, 2, VE },
1733  { "context", "Context model", OFFSET(ctx.context_model), AV_OPT_TYPE_INT,
1734  { .i64 = 0 }, 0, 1, VE },
1735  { "coder", "Coder type", OFFSET(ctx.ac), AV_OPT_TYPE_INT,
1736  { .i64 = AC_RANGE_CUSTOM_TAB }, -2, 2, VE, .unit = "coder" },
1737  { "rice", "Golomb rice", 0, AV_OPT_TYPE_CONST,
1738  { .i64 = AC_GOLOMB_RICE }, INT_MIN, INT_MAX, VE, .unit = "coder" },
1739  { "range_def", "Range with default table", 0, AV_OPT_TYPE_CONST,
1740  { .i64 = AC_RANGE_DEFAULT_TAB_FORCE }, INT_MIN, INT_MAX, VE, .unit = "coder" },
1741  { "range_tab", "Range with custom table", 0, AV_OPT_TYPE_CONST,
1742  { .i64 = AC_RANGE_CUSTOM_TAB }, INT_MIN, INT_MAX, VE, .unit = "coder" },
1743  { "qtable", "Quantization table", OFFSET(ctx.qtable), AV_OPT_TYPE_INT,
1744  { .i64 = -1 }, -1, 2, VE , .unit = "qtable"},
1745  { "default", NULL, 0, AV_OPT_TYPE_CONST,
1746  { .i64 = QTABLE_DEFAULT }, INT_MIN, INT_MAX, VE, .unit = "qtable" },
1747  { "8bit", NULL, 0, AV_OPT_TYPE_CONST,
1748  { .i64 = QTABLE_8BIT }, INT_MIN, INT_MAX, VE, .unit = "qtable" },
1749  { "greater8bit", NULL, 0, AV_OPT_TYPE_CONST,
1750  { .i64 = QTABLE_GT8BIT }, INT_MIN, INT_MAX, VE, .unit = "qtable" },
1751 
1752  { "slices_h", "Number of horizontal slices", OFFSET(num_h_slices), AV_OPT_TYPE_INT,
1753  { .i64 = -1 }, -1, MAX_SLICES, VE },
1754  { "slices_v", "Number of vertical slices", OFFSET(num_v_slices), AV_OPT_TYPE_INT,
1755  { .i64 = -1 }, -1, MAX_SLICES, VE },
1756 
1757  { "force_pcm", "Code all slices with no prediction", OFFSET(force_pcm), AV_OPT_TYPE_BOOL,
1758  { .i64 = 0 }, 0, 1, VE },
1759 
1760  { "rct_search", "Run a search for RCT parameters (level 4 only)", OFFSET(optimize_rct), AV_OPT_TYPE_BOOL,
1761  { .i64 = 1 }, 0, 1, VE },
1762 
1763  { "async_depth", "Internal parallelization depth", OFFSET(async_depth), AV_OPT_TYPE_INT,
1764  { .i64 = 1 }, 1, INT_MAX, VE },
1765 
1766  { NULL }
1767 };
1768 
1769 static const FFCodecDefault vulkan_encode_ffv1_defaults[] = {
1770  { "g", "1" },
1771  { NULL },
1772 };
1773 
1774 static const AVClass vulkan_encode_ffv1_class = {
1775  .class_name = "ffv1_vulkan",
1776  .item_name = av_default_item_name,
1777  .option = vulkan_encode_ffv1_options,
1778  .version = LIBAVUTIL_VERSION_INT,
1779 };
1780 
1781 const AVCodecHWConfigInternal *const vulkan_encode_ffv1_hw_configs[] = {
1782  HW_CONFIG_ENCODER_FRAMES(VULKAN, VULKAN),
1783  NULL,
1784 };
1785 
1786 const FFCodec ff_ffv1_vulkan_encoder = {
1787  .p.name = "ffv1_vulkan",
1788  CODEC_LONG_NAME("FFmpeg video codec #1 (Vulkan)"),
1789  .p.type = AVMEDIA_TYPE_VIDEO,
1790  .p.id = AV_CODEC_ID_FFV1,
1791  .priv_data_size = sizeof(VulkanEncodeFFv1Context),
1792  .init = &vulkan_encode_ffv1_init,
1793  FF_CODEC_RECEIVE_PACKET_CB(&vulkan_encode_ffv1_receive_packet),
1794  .close = &vulkan_encode_ffv1_close,
1795  .p.priv_class = &vulkan_encode_ffv1_class,
1796  .p.capabilities = AV_CODEC_CAP_DELAY |
1797  AV_CODEC_CAP_HARDWARE |
1798  AV_CODEC_CAP_DR1 |
1799  AV_CODEC_CAP_ENCODER_FLUSH |
1800  AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
1801  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP | FF_CODEC_CAP_EOF_FLUSH,
1802  .defaults = vulkan_encode_ffv1_defaults,
1803  CODEC_PIXFMTS(AV_PIX_FMT_VULKAN),
1804  .hw_configs = vulkan_encode_ffv1_hw_configs,
1805  .p.wrapper_name = "vulkan",
1806 };
hwconfig.h
init_rct_search_shader
static int init_rct_search_shader(AVCodecContext *avctx, FFVkSPIRVCompiler *spv)
Definition: ffv1enc_vulkan.c:973
VulkanEncodeFFv1Context::rangecoder_static_buf
FFVkBuffer rangecoder_static_buf
Definition: ffv1enc_vulkan.c:83
CODEC_PIXFMTS
#define CODEC_PIXFMTS(...)
Definition: codec_internal.h:392
FFv1VkResetParameters::context_count
uint32_t context_count[MAX_QUANT_TABLES]
Definition: ffv1_vulkan.h:52
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:216
FFv1VkParameters::planes
uint8_t planes
Definition: ffv1enc_vulkan.c:141
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
ff_ffv1_encode_determine_slices
int ff_ffv1_encode_determine_slices(AVCodecContext *avctx)
Definition: ffv1enc.c:566
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:42
FFv1VkParameters::extend_lookup
uint8_t extend_lookup[8]
Definition: ffv1enc_vulkan.c:133
add_push_data
static void add_push_data(FFVulkanShader *shd)
Definition: ffv1enc_vulkan.c:154
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
opt.h
AV_PIX_FMT_YA8
@ AV_PIX_FMT_YA8
8 bits gray, 8 bits alpha
Definition: pixfmt.h:140
FFVulkanContext::props_11
VkPhysicalDeviceVulkan11Properties props_11
Definition: vulkan.h:277
FFv1VkRCTSearchParameters::force_pcm
uint8_t force_pcm
Definition: ffv1enc_vulkan.c:201
ff_vk_shader_free
void ff_vk_shader_free(FFVulkanContext *s, FFVulkanShader *shd)
Free a shader.
Definition: vulkan.c:2963
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:2095
QTABLE_8BIT
@ QTABLE_8BIT
Definition: ffv1enc.h:30
AVBufferPool
The buffer pool.
Definition: buffer_internal.h:88
FFVulkanContext::device_ref
AVBufferRef * device_ref
Definition: vulkan.h:302
FFVkExecPool::contexts
FFVkExecContext * contexts
Definition: vulkan.h:249
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3456
FFv1VkParameters::scratch_data
VkDeviceAddress scratch_data
Definition: ffv1enc_vulkan.c:120
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:90
AV_CODEC_CAP_HARDWARE
#define AV_CODEC_CAP_HARDWARE
Codec is backed by a hardware implementation.
Definition: codec.h:130
RET
#define RET(x)
Definition: vulkan.h:66
ff_vk_exec_pool_init
int ff_vk_exec_pool_init(FFVulkanContext *s, AVVulkanDeviceQueueFamily *qf, FFVkExecPool *pool, int nb_contexts, int nb_queries, VkQueryType query_type, int query_64bit, const void *query_create_pnext)
Allocates/frees an execution pool.
Definition: vulkan.c:360
VulkanEncodeFFv1Context::is_rgb
int is_rgb
Definition: ffv1enc_vulkan.c:104
AVHWFramesContext::format
enum AVPixelFormat format
The pixel format identifying the underlying HW surface type.
Definition: hwcontext.h:200
FF_CODEC_CAP_EOF_FLUSH
#define FF_CODEC_CAP_EOF_FLUSH
The encoder has AV_CODEC_CAP_DELAY set, but does not actually have delay - it only wants to be flushe...
Definition: codec_internal.h:89
int64_t
long long int64_t
Definition: coverity.c:34
VulkanEncodeFFv1Context::in_flight
int in_flight
Definition: ffv1enc_vulkan.c:72
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
VulkanEncodeFFv1Context::chunks
int chunks
Definition: ffv1enc_vulkan.c:106
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
internal.h
AC_RANGE_DEFAULT_TAB_FORCE
#define AC_RANGE_DEFAULT_TAB_FORCE
Definition: ffv1.h:55
AVPacket::data
uint8_t * data
Definition: packet.h:588
FFv1VkRCTSearchParameters::planar_rgb
uint8_t planar_rgb
Definition: ffv1enc_vulkan.c:198
AVOption
AVOption.
Definition: opt.h:429
encode.h
FFVulkanShader::src
AVBPrint src
Definition: vulkan.h:191
MAX_QUANT_TABLE_SIZE
#define MAX_QUANT_TABLE_SIZE
Definition: ffv1.h:48
VulkanEncodeFFv1Context::rct_search
FFVulkanShader rct_search
Definition: ffv1enc_vulkan.c:77
ff_source_ffv1_vlc_comp
const char * ff_source_ffv1_vlc_comp
AV_PIX_FMT_RGBA128
#define AV_PIX_FMT_RGBA128
Definition: pixfmt.h:630
ff_ffv1_write_extradata
av_cold int ff_ffv1_write_extradata(AVCodecContext *avctx)
Definition: ffv1enc.c:447
FFCodec
Definition: codec_internal.h:127
FFv1VkResetParameters::slice_state
VkDeviceAddress slice_state
Definition: ffv1_vulkan.h:53
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:226
FFV1Context::num_h_slices
int num_h_slices
Definition: ffv1.h:175
FFVkBuffer::address
VkDeviceAddress address
Definition: vulkan.h:92
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:606
ff_vk_init
int ff_vk_init(FFVulkanContext *s, void *log_parent, AVBufferRef *device_ref, AVBufferRef *frames_ref)
Initializes the AVClass, in case this context is not used as the main user's context.
Definition: vulkan.c:3016
ff_vk_exec_get
FFVkExecContext * ff_vk_exec_get(FFVulkanContext *s, FFVkExecPool *pool)
Retrieve an execution pool.
Definition: vulkan.c:551
FF_VK_REP_NATIVE
@ FF_VK_REP_NATIVE
Definition: vulkan.h:404
ff_vk_uninit
void ff_vk_uninit(FFVulkanContext *s)
Frees main context.
Definition: vulkan.c:3004
FF_COMPLIANCE_EXPERIMENTAL
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
Definition: defs.h:62
AVFrame::flags
int flags
Frame flags, a combination of AV_FRAME_FLAGS.
Definition: frame.h:671
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
FFVkSPIRVCompiler::uninit
void(* uninit)(struct FFVkSPIRVCompiler **ctx)
Definition: vulkan_spirv.h:32
define_shared_code
static void define_shared_code(AVCodecContext *avctx, FFVulkanShader *shd)
Definition: ffv1enc_vulkan.c:944
AVHWFramesContext::width
int width
The allocated dimensions of the frames in this pool.
Definition: hwcontext.h:220
av_hwdevice_get_hwframe_constraints
AVHWFramesConstraints * av_hwdevice_get_hwframe_constraints(AVBufferRef *ref, const void *hwconfig)
Get the constraints on HW frames given a device and the HW-specific configuration to be used with tha...
Definition: hwcontext.c:581
AC_RANGE_CUSTOM_TAB
#define AC_RANGE_CUSTOM_TAB
Definition: ffv1.h:54
FFv1VkParameters::micro_version
uint8_t micro_version
Definition: ffv1enc_vulkan.c:137
ff_source_ffv1_reset_comp
const char * ff_source_ffv1_reset_comp
FFv1VkParameters::padding
uint8_t padding[3]
Definition: ffv1enc_vulkan.c:151
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:643
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:783
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:448
FFVkBuffer::buf
VkBuffer buf
Definition: vulkan.h:88
AVHWFramesConstraints
This struct describes the constraints on hardware frames attached to a given device with a hardware-s...
Definition: hwcontext.h:444
AV_FRAME_FLAG_TOP_FIELD_FIRST
#define AV_FRAME_FLAG_TOP_FIELD_FIRST
A flag to mark frames where the top field is displayed first if the content is interlaced.
Definition: frame.h:655
FFv1VkRCTSearchParameters::rct_offset
int rct_offset
Definition: ffv1enc_vulkan.c:197
av_pix_fmt_count_planes
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3496
AV_CODEC_FLAG_COPY_OPAQUE
#define AV_CODEC_FLAG_COPY_OPAQUE
Definition: avcodec.h:279
vulkan_encode_ffv1_class
static const AVClass vulkan_encode_ffv1_class
Definition: ffv1enc_vulkan.c:1774
MAX_QUANT_TABLE_MASK
#define MAX_QUANT_TABLE_MASK
Definition: ffv1.h:49
FFCodecDefault
Definition: codec_internal.h:96
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
AV_PIX_FMT_GBRP14
#define AV_PIX_FMT_GBRP14
Definition: pixfmt.h:560
AVVkFrame::img
VkImage img[AV_NUM_DATA_POINTERS]
Vulkan images to which the memory is bound to.
Definition: hwcontext_vulkan.h:307
VulkanEncodeFFv1FrameData::key_frame
int key_frame
Definition: ffv1enc_vulkan.c:56
AVPacket::opaque_ref
AVBufferRef * opaque_ref
AVBufferRef for free use by the API user.
Definition: packet.h:624
VulkanEncodeFFv1Context::num_v_slices
int num_v_slices
Definition: ffv1enc_vulkan.c:100
FFv1VkParameters::sar
int32_t sar[2]
Definition: ffv1enc_vulkan.c:124
fail
#define fail()
Definition: checkasm.h:214
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:558
FFv1VkParameters::out_data
VkDeviceAddress out_data
Definition: ffv1enc_vulkan.c:121
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:2840
AVVulkanFramesContext
Allocated as AVHWFramesContext.hwctx, used to set pool-specific options.
Definition: hwcontext_vulkan.h:212
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:2052
FFv1VkParameters::transparency
uint8_t transparency
Definition: ffv1enc_vulkan.c:144
VulkanEncodeFFv1Context::crc_tab_buf
FFVkBuffer crc_tab_buf
Definition: ffv1enc_vulkan.c:84
FFv1VkParameters::force_pcm
uint8_t force_pcm
Definition: ffv1enc_vulkan.c:138
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:2603
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:496
VulkanEncodeFFv1Context::ppi
int ppi
Definition: ffv1enc_vulkan.c:105
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:1394
MAX_SLICES
#define MAX_SLICES
Definition: d3d12va_hevc.c:33
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:2467
CONTEXT_SIZE
#define CONTEXT_SIZE
Definition: ffv1.h:45
FFv1VkParameters::pic_mode
uint8_t pic_mode
Definition: ffv1enc_vulkan.c:146
AV_CODEC_CAP_ENCODER_FLUSH
#define AV_CODEC_CAP_ENCODER_FLUSH
This encoder can be flushed using avcodec_flush_buffers().
Definition: codec.h:151
VulkanEncodeFFv1Context::keyframe_slice_data_ref
AVBufferRef * keyframe_slice_data_ref
Definition: ffv1enc_vulkan.c:88
ff_source_ffv1_enc_setup_comp
const char * ff_source_ffv1_enc_setup_comp
VulkanEncodeFFv1FrameData::frame_opaque_ref
AVBufferRef * frame_opaque_ref
Definition: ffv1enc_vulkan.c:54
AVRational::num
int num
Numerator.
Definition: rational.h:59
ff_ffv1_vulkan_encoder
const FFCodec ff_ffv1_vulkan_encoder
Definition: ffv1enc_vulkan.c:1786
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:52
VulkanEncodeFFv1Context::s
FFVulkanContext s
Definition: ffv1enc_vulkan.c:63
GLSLC
#define GLSLC(N, S)
Definition: vulkan.h:43
VulkanEncodeFFv1FrameData
Definition: ffv1enc_vulkan.c:43
FFv1VkRCTSearchParameters::micro_version
uint8_t micro_version
Definition: ffv1enc_vulkan.c:203
vulkan_encode_ffv1_hw_configs
const AVCodecHWConfigInternal *const vulkan_encode_ffv1_hw_configs[]
Definition: ffv1enc_vulkan.c:1781
get_packet
static int get_packet(AVCodecContext *avctx, FFVkExecContext *exec, AVPacket *pkt)
Definition: ffv1enc_vulkan.c:713
pkt
AVPacket * pkt
Definition: movenc.c:60
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
VulkanEncodeFFv1Context::exec_ctx_info
VulkanEncodeFFv1FrameData * exec_ctx_info
Definition: ffv1enc_vulkan.c:71
VulkanEncodeFFv1Context::results_data_pool
AVBufferPool * results_data_pool
Definition: ffv1enc_vulkan.c:94
av_cold
#define av_cold
Definition: attributes.h:106
run_rct_search
static int run_rct_search(AVCodecContext *avctx, FFVkExecContext *exec, AVFrame *enc_in, VkImageView *enc_in_views, FFVkBuffer *slice_data_buf, uint32_t slice_data_size)
Definition: ffv1enc_vulkan.c:207
VulkanEncodeFFv1Context::setup
FFVulkanShader setup
Definition: ffv1enc_vulkan.c:76
AVHWFramesContext::height
int height
Definition: hwcontext.h:220
FFv1VkParameters::codec_planes
uint8_t codec_planes
Definition: ffv1enc_vulkan.c:142
AVHWFramesConstraints::valid_sw_formats
enum AVPixelFormat * valid_sw_formats
A list of possible values for sw_format in the hw_frames_ctx, terminated by AV_PIX_FMT_NONE.
Definition: hwcontext.h:456
FFV1Context::use32bit
int use32bit
Definition: ffv1.h:158
LG_ALIGN_W
#define LG_ALIGN_W
Definition: ffv1enc_vulkan.c:37
av_hwframe_constraints_free
void av_hwframe_constraints_free(AVHWFramesConstraints **constraints)
Free an AVHWFrameConstraints structure.
Definition: hwcontext.c:606
AV_PIX_FMT_RGB96
#define AV_PIX_FMT_RGB96
Definition: pixfmt.h:629
FFVulkanContext::driver_props
VkPhysicalDeviceDriverProperties driver_props
Definition: vulkan.h:278
FFv1VkParameters::bits_per_raw_sample
uint8_t bits_per_raw_sample
Definition: ffv1enc_vulkan.c:134
ff_vk_exec_wait
void ff_vk_exec_wait(FFVulkanContext *s, FFVkExecContext *e)
Definition: vulkan.c:556
AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
#define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
This encoder can reorder user opaque values from input AVFrames and return them with corresponding ou...
Definition: codec.h:144
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:1584
VulkanEncodeFFv1Context::max_heap_size
size_t max_heap_size
Definition: ffv1enc_vulkan.c:74
FFVulkanContext::host_cached_flag
VkMemoryPropertyFlagBits host_cached_flag
Definition: vulkan.h:300
AVVulkanFramesContext::img_flags
VkImageCreateFlags img_flags
Flags to set during image creation.
Definition: hwcontext_vulkan.h:265
vulkan_encode_ffv1_receive_packet
static int vulkan_encode_ffv1_receive_packet(AVCodecContext *avctx, AVPacket *pkt)
Definition: ffv1enc_vulkan.c:807
ff_source_ffv1_common_comp
const char * ff_source_ffv1_common_comp
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:231
ctx
AVFormatContext * ctx
Definition: movenc.c:49
VulkanEncodeFFv1Context::transfer_qf
AVVulkanDeviceQueueFamily * transfer_qf
Definition: ffv1enc_vulkan.c:67
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:623
FFV1Context::ac
int ac
1=range coder <-> 0=golomb rice
Definition: ffv1.h:147
GLSLD
#define GLSLD(D)
Definition: vulkan.h:58
ff_ffv1_encode_setup_plane_info
av_cold int ff_ffv1_encode_setup_plane_info(AVCodecContext *avctx, enum AVPixelFormat pix_fmt)
Definition: ffv1enc.c:801
FFv1VkParameters::crcref
uint32_t crcref
Definition: ffv1enc_vulkan.c:129
ff_vk_exec_pool_free
void ff_vk_exec_pool_free(FFVulkanContext *s, FFVkExecPool *pool)
Definition: vulkan.c:291
AVPacket::opaque
void * opaque
for some private data of the user
Definition: packet.h:613
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:332
tmp
static uint8_t tmp[40]
Definition: aes_ctr.c:52
FFv1VkRCTSearchParameters::transparency
uint8_t transparency
Definition: ffv1enc_vulkan.c:199
FFv1VkParameters::chroma_shift
uint32_t chroma_shift[2]
Definition: ffv1enc_vulkan.c:125
VulkanEncodeFFv1Context::frame
AVFrame * frame
Definition: ffv1enc_vulkan.c:61
TYPE
#define TYPE
Definition: ffv1dec.c:96
AVPacket::buf
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: packet.h:571
AV_PIX_FMT_RGBA64
#define AV_PIX_FMT_RGBA64
Definition: pixfmt.h:529
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
ff_vk_shader_rep_fmt
const char * ff_vk_shader_rep_fmt(enum AVPixelFormat pix_fmt, enum FFVkShaderRepFormat rep_fmt)
Definition: vulkan.c:1628
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:76
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
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
FFv1VkParameters::ppi
uint8_t ppi
Definition: ffv1enc_vulkan.c:148
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
FFV1Context::num_v_slices
int num_v_slices
Definition: ffv1.h:174
VulkanEncodeFFv1Context::force_pcm
int force_pcm
Definition: ffv1enc_vulkan.c:101
FFv1VkParameters::version
uint8_t version
Definition: ffv1enc_vulkan.c:136
FF_CODEC_RECEIVE_PACKET_CB
#define FF_CODEC_RECEIVE_PACKET_CB(func)
Definition: codec_internal.h:367
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:242
av_buffer_pool_uninit
void av_buffer_pool_uninit(AVBufferPool **ppool)
Mark the pool as being available for freeing.
Definition: buffer.c:328
FFVkExecContext::had_submission
int had_submission
Definition: vulkan.h:110
FFVkBuffer::size
size_t size
Definition: vulkan.h:91
AVVulkanFramesContext::usage
VkImageUsageFlagBits usage
Defines extra usage of output frames.
Definition: hwcontext_vulkan.h:232
transfer_slices
static int transfer_slices(AVCodecContext *avctx, VkBufferCopy *buf_regions, int nb_regions, VulkanEncodeFFv1FrameData *fd, uint8_t *dst, AVBufferRef *dst_ref)
Definition: ffv1enc_vulkan.c:648
ffv1_vulkan.h
planes
static const struct @548 planes[]
VulkanEncodeFFv1Context::num_h_slices
int num_h_slices
Definition: ffv1enc_vulkan.c:99
FFVkBuffer::mapped_mem
uint8_t * mapped_mem
Definition: vulkan.h:96
FFVulkanContext
Definition: vulkan.h:270
FFv1VkParameters::planar_rgb
uint8_t planar_rgb
Definition: ffv1enc_vulkan.c:143
VulkanEncodeFFv1FrameData::duration
int64_t duration
Definition: ffv1enc_vulkan.c:52
VulkanEncodeFFv1Context
Definition: ffv1enc_vulkan.c:59
AV_CODEC_ID_FFV1
@ AV_CODEC_ID_FFV1
Definition: codec_id.h:85
f
f
Definition: af_crystalizer.c:122
VulkanEncodeFFv1Context::slice_data_pool
AVBufferPool * slice_data_pool
Definition: ffv1enc_vulkan.c:87
ff_vk_buf_barrier
#define ff_vk_buf_barrier(dst, vkb, s_stage, s_access, s_access2, d_stage, d_access, d_access2, offs, bsz)
Definition: vulkan.h:506
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:550
FFv1VkParameters::fmt_lut
int32_t fmt_lut[4]
Definition: ffv1enc_vulkan.c:123
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
VulkanEncodeFFv1Context::ctx
FFV1Context ctx
Definition: ffv1enc_vulkan.c:60
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:2919
AVPacket::size
int size
Definition: packet.h:589
FFVulkanDescriptorSetBinding
Definition: vulkan.h:74
VulkanEncodeFFv1FrameData::pts
int64_t pts
Definition: ffv1enc_vulkan.c:51
AVCodecContext::gop_size
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:1013
codec_internal.h
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:302
vulkan.h
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
AV_PIX_FMT_RGB48
#define AV_PIX_FMT_RGB48
Definition: pixfmt.h:525
AV_NUM_DATA_POINTERS
#define AV_NUM_DATA_POINTERS
Definition: frame.h:428
init_indirect
static int init_indirect(AVCodecContext *avctx, enum AVPixelFormat sw_format)
Definition: ffv1enc_vulkan.c:861
FFVulkanShader
Definition: vulkan.h:186
FFv1VkRCTSearchParameters::version
uint8_t version
Definition: ffv1enc_vulkan.c:202
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
VulkanEncodeFFv1Context::optimize_rct
int optimize_rct
Definition: ffv1enc_vulkan.c:102
AVCodecHWConfigInternal
Definition: hwconfig.h:25
FFVkBuffer::flags
VkMemoryPropertyFlagBits flags
Definition: vulkan.h:90
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:587
ff_source_common_comp
const char * ff_source_common_comp
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
VulkanEncodeFFv1FrameData::out_data_ref
AVBufferRef * out_data_ref
Definition: ffv1enc_vulkan.c:45
init_setup_shader
static int init_setup_shader(AVCodecContext *avctx, FFVkSPIRVCompiler *spv)
Definition: ffv1enc_vulkan.c:1072
AVERROR_EXTERNAL
#define AVERROR_EXTERNAL
Generic error in an external library.
Definition: error.h:59
FFVkExecContext
Definition: vulkan.h:107
init_reset_shader
static int init_reset_shader(AVCodecContext *avctx, FFVkSPIRVCompiler *spv)
Definition: ffv1enc_vulkan.c:1157
FFv1VkRCTSearchParameters::fmt_lut
int fmt_lut[4]
Definition: ffv1enc_vulkan.c:196
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:2853
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:594
FFVulkanDescriptorSetBinding::name
const char * name
Definition: vulkan.h:75
version
version
Definition: libkvazaar.c:313
VulkanEncodeFFv1Context::enc
FFVulkanShader enc
Definition: ffv1enc_vulkan.c:79
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:1562
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:221
VulkanEncodeFFv1Context::quant_buf
FFVkBuffer quant_buf
Definition: ffv1enc_vulkan.c:82
FFVkSPIRVCompiler
Definition: vulkan_spirv.h:26
VE
#define VE
Definition: ffv1enc_vulkan.c:1729
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
HW_CONFIG_ENCODER_FRAMES
#define HW_CONFIG_ENCODER_FRAMES(format, device_type_)
Definition: hwconfig.h:98
FF_VK_EXT_EXTERNAL_HOST_MEMORY
#define FF_VK_EXT_EXTERNAL_HOST_MEMORY
Definition: vulkan_functions.h:36
ff_source_ffv1_enc_comp
const char * ff_source_ffv1_enc_comp
ff_vk_exec_start
int ff_vk_exec_start(FFVulkanContext *s, FFVkExecContext *e)
Start/submit/wait an execution.
Definition: vulkan.c:563
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:581
VulkanEncodeFFv1FrameData::results_data_ref
AVBufferRef * results_data_ref
Definition: ffv1enc_vulkan.c:48
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:32
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:559
init_encode_shader
static int init_encode_shader(AVCodecContext *avctx, FFVkSPIRVCompiler *spv)
Definition: ffv1enc_vulkan.c:1245
ff_ffv1_common_init
av_cold int ff_ffv1_common_init(AVCodecContext *avctx, FFV1Context *s)
Definition: ffv1.c:36
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:2392
ffv1.h
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:496
FFVkBuffer::mem
VkDeviceMemory mem
Definition: vulkan.h:89
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:179
vulkan_spirv.h
vulkan_encode_ffv1_close
static av_cold int vulkan_encode_ffv1_close(AVCodecContext *avctx)
Definition: ffv1enc_vulkan.c:1686
FFVulkanContext::props
VkPhysicalDeviceProperties2 props
Definition: vulkan.h:276
FFVulkanContext::extensions
FFVulkanExtensions extensions
Definition: vulkan.h:275
ff_vk_free_buf
void ff_vk_free_buf(FFVulkanContext *s, FFVkBuffer *buf)
Definition: vulkan.c:1247
AVCodecContext::height
int height
Definition: avcodec.h:600
AV_FRAME_FLAG_INTERLACED
#define AV_FRAME_FLAG_INTERLACED
A flag to mark frames whose content is interlaced.
Definition: frame.h:650
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
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
FFVulkanContext::mprops
VkPhysicalDeviceMemoryProperties mprops
Definition: vulkan.h:279
ff_vk_exec_bind_shader
void ff_vk_exec_bind_shader(FFVulkanContext *s, FFVkExecContext *e, FFVulkanShader *shd)
Bind a shader.
Definition: vulkan.c:2929
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:1461
avcodec.h
AVHWFramesContext
This struct describes a set or pool of "hardware" frames (i.e.
Definition: hwcontext.h:118
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:81
ff_ffv1_encode_buffer_size
size_t ff_ffv1_encode_buffer_size(AVCodecContext *avctx)
Definition: ffv1enc.c:1685
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:265
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:1969
FFVulkanContext::vkfn
FFVulkanFunctions vkfn
Definition: vulkan.h:274
AVHWFramesContext::hwctx
void * hwctx
The format-specific data, allocated and freed automatically along with this context.
Definition: hwcontext.h:153
AVCodecContext::strict_std_compliance
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:1365
VulkanEncodeFFv1Context::exec_pool
FFVkExecPool exec_pool
Definition: ffv1enc_vulkan.c:65
FFVkExecContext::opaque
void * opaque
Definition: vulkan.h:124
FFv1VkRCTSearchParameters::padding
uint8_t padding[2]
Definition: ffv1enc_vulkan.c:204
FFVkExecPool
Definition: vulkan.h:248
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:1492
VulkanEncodeFFv1Context::intermediate_frames_ref
AVBufferRef * intermediate_frames_ref
Definition: ffv1enc_vulkan.c:97
VulkanEncodeFFv1FrameData::frame_opaque
void * frame_opaque
Definition: ffv1enc_vulkan.c:53
AVFrame::sample_aspect_ratio
AVRational sample_aspect_ratio
Sample aspect ratio for the video frame, 0/1 if unknown/unspecified.
Definition: frame.h:524
ff_vk_qf_find
AVVulkanDeviceQueueFamily * ff_vk_qf_find(FFVulkanContext *s, VkQueueFlagBits dev_family, VkVideoCodecOperationFlagBitsKHR vid_ops)
Chooses an appropriate QF.
Definition: vulkan.c:278
vulkan_encode_ffv1_options
static const AVOption vulkan_encode_ffv1_options[]
Definition: ffv1enc_vulkan.c:1730
FFVkExecContext::buf
VkCommandBuffer buf
Definition: vulkan.h:118
AVFrame::hw_frames_ctx
AVBufferRef * hw_frames_ctx
For hwaccel-format frames, this should be a reference to the AVHWFramesContext describing the frame.
Definition: frame.h:724
FFv1VkRCTSearchParameters
Definition: ffv1enc_vulkan.c:195
AVCodecContext
main external API structure.
Definition: avcodec.h:439
VulkanEncodeFFv1Context::transfer_exec_pool
FFVkExecPool transfer_exec_pool
Definition: ffv1enc_vulkan.c:68
check_support
static int check_support(AVHWFramesConstraints *constraints, enum AVPixelFormat fmt)
Definition: ffv1enc_vulkan.c:896
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
FFV1Context::context_model
int context_model
Definition: ffv1.h:163
RGB_LINECACHE
#define RGB_LINECACHE
Definition: ffv1enc_vulkan.c:41
ff_get_encode_buffer
int ff_get_encode_buffer(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int flags)
Get a buffer for a packet.
Definition: encode.c:105
VulkanEncodeFFv1Context::reset
FFVulkanShader reset
Definition: ffv1enc_vulkan.c:78
FFv1VkParameters::rct_offset
int rct_offset
Definition: ffv1enc_vulkan.c:131
GLSLF
#define GLSLF(N, S,...)
Definition: vulkan.h:53
AVRational::den
int den
Denominator.
Definition: rational.h:60
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
QTABLE_GT8BIT
@ QTABLE_GT8BIT
Definition: ffv1enc.h:31
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Underlying C type is int.
Definition: opt.h:259
VulkanEncodeFFv1Context::async_depth
int async_depth
Definition: ffv1enc_vulkan.c:73
FFv1VkParameters::context_model
uint8_t context_model
Definition: ffv1enc_vulkan.c:135
AV_CODEC_CAP_DELAY
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: codec.h:76
ffv1enc.h
vulkan_encode_ffv1_submit_frame
static int vulkan_encode_ffv1_submit_frame(AVCodecContext *avctx, FFVkExecContext *exec, const AVFrame *pict)
Definition: ffv1enc_vulkan.c:258
AVVulkanFramesContext::tiling
VkImageTiling tiling
Controls the tiling of allocated frames.
Definition: hwcontext_vulkan.h:221
FFv1VkResetParameters
Definition: ffv1_vulkan.h:51
FFv1VkParameters::colorspace
uint8_t colorspace
Definition: ffv1enc_vulkan.c:145
VulkanEncodeFFv1Context::qf
AVVulkanDeviceQueueFamily * qf
Definition: ffv1enc_vulkan.c:64
vulkan_encode_ffv1_defaults
static const FFCodecDefault vulkan_encode_ffv1_defaults[]
Definition: ffv1enc_vulkan.c:1769
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:200
FFVulkanContext::hwctx
AVVulkanDeviceContext * hwctx
Definition: vulkan.h:304
VulkanEncodeFFv1Context::buf_regions
VkBufferCopy * buf_regions
Definition: ffv1enc_vulkan.c:70
mem.h
ff_encode_get_frame
int ff_encode_get_frame(AVCodecContext *avctx, AVFrame *frame)
Called by encoders to get the next frame for encoding.
Definition: encode.c:204
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
MAX_QUANT_TABLES
#define MAX_QUANT_TABLES
Definition: ffv1.h:47
ff_ffv1_encode_init
av_cold int ff_ffv1_encode_init(AVCodecContext *avctx)
Definition: ffv1enc.c:601
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
AVVulkanDeviceContext::act_dev
VkDevice act_dev
Active device.
Definition: hwcontext_vulkan.h:84
FFV1Context
Definition: ffv1.h:122
LG_ALIGN_H
#define LG_ALIGN_H
Definition: ffv1enc_vulkan.c:38
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
FFV1Context::transparency
int transparency
Definition: ffv1.h:133
ff_vk_count_images
static int ff_vk_count_images(AVVkFrame *f)
Definition: vulkan.h:321
ff_vk_exec_discard_deps
void ff_vk_exec_discard_deps(FFVulkanContext *s, FFVkExecContext *e)
Definition: vulkan.c:595
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AVCodecContext::slices
int slices
Number of slices.
Definition: avcodec.h:1029
AVPacket
This structure stores compressed data.
Definition: packet.h:565
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:466
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Underlying C type is int.
Definition: opt.h:327
FFVkBuffer
Definition: vulkan.h:87
FFv1VkParameters::components
uint8_t components
Definition: ffv1enc_vulkan.c:140
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:600
vulkan_encode_ffv1_init
static av_cold int vulkan_encode_ffv1_init(AVCodecContext *avctx)
Definition: ffv1enc_vulkan.c:1365
int32_t
int32_t
Definition: audioconvert.c:56
ff_vk_exec_submit
int ff_vk_exec_submit(FFVulkanContext *s, FFVkExecContext *e)
Definition: vulkan.c:908
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVVulkanDeviceQueueFamily
Definition: hwcontext_vulkan.h:33
QTABLE_DEFAULT
@ QTABLE_DEFAULT
Definition: ffv1enc.h:29
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
FFVulkanContext::frames
AVHWFramesContext * frames
Definition: vulkan.h:308
FFv1VkParameters
Definition: ffv1enc_vulkan.c:118
get_supported_rgb_buffer_fmt
static enum AVPixelFormat get_supported_rgb_buffer_fmt(AVCodecContext *avctx)
Definition: ffv1enc_vulkan.c:906
OFFSET
#define OFFSET(x)
Definition: ffv1enc_vulkan.c:1728
AVCodecContext::sw_pix_fmt
enum AVPixelFormat sw_pix_fmt
Nominal unaccelerated pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:646
FFv1VkRCTSearchParameters::key_frame
uint8_t key_frame
Definition: ffv1enc_vulkan.c:200
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::chunks
uint8_t chunks
Definition: ffv1enc_vulkan.c:149
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Special option type for declaring named constants.
Definition: opt.h:299
FFv1VkParameters::context_count
uint32_t context_count
Definition: ffv1enc_vulkan.c:128
FFVulkanFunctions
Definition: vulkan_functions.h:280
FFVkExecPool::pool_size
int pool_size
Definition: vulkan.h:254
FFv1VkParameters::slice_size_max
uint32_t slice_size_max
Definition: ffv1enc_vulkan.c:130
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:1289
src
#define src
Definition: vp8dsp.c:248
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::rct_search
uint8_t rct_search
Definition: ffv1enc_vulkan.c:150
ff_source_ffv1_rct_search_comp
const char * ff_source_ffv1_rct_search_comp
FFv1VkParameters::ec
uint8_t ec
Definition: ffv1enc_vulkan.c:147
VulkanEncodeFFv1Context::out_data_pool
AVBufferPool * out_data_pool
Definition: ffv1enc_vulkan.c:91
ff_source_rangecoder_comp
const char * ff_source_rangecoder_comp
Generated on Wed Dec 31 2025 19:21:57 for FFmpeg by   doxygen 1.8.17