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