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