FFmpeg
vulkan_encode.c
Go to the documentation of this file.
1 /*
2  * This file is part of FFmpeg.
3  *
4  * FFmpeg is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * FFmpeg is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with FFmpeg; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17  */
18 
19 #include "libavutil/mem.h"
20 #include "libavutil/avassert.h"
21 #include "vulkan_encode.h"
22 #include "config.h"
23 
25 
27  HW_CONFIG_ENCODER_FRAMES(VULKAN, VULKAN),
28  NULL,
29 };
30 
32 {
33  FFVulkanContext *s = &ctx->s;
34  FFVulkanFunctions *vk = &s->vkfn;
35 
36  /* Wait on and free execution pool */
37  ff_vk_exec_pool_free(s, &ctx->enc_pool);
38 
39  /* Destroy the session params */
40  if (ctx->session_params)
41  vk->DestroyVideoSessionParametersKHR(s->hwctx->act_dev,
42  ctx->session_params,
43  s->hwctx->alloc);
44 
46 
47  av_buffer_pool_uninit(&ctx->buf_pool);
48 
49  ff_vk_video_common_uninit(s, &ctx->common);
50 
51  ff_vk_uninit(s);
52 }
53 
55 {
56  int err;
58  FFVulkanEncodePicture *vp = pic->priv;
59 
60  AVFrame *f = pic->input_image;
61  AVHWFramesContext *hwfc = (AVHWFramesContext *)f->hw_frames_ctx->data;
62  AVVulkanFramesContext *vkfc = hwfc->hwctx;
63  AVVkFrame *vkf = (AVVkFrame *)f->data[0];
64 
65  if (ctx->codec->picture_priv_data_size > 0) {
66  pic->codec_priv = av_mallocz(ctx->codec->picture_priv_data_size);
67  if (!pic->codec_priv)
68  return AVERROR(ENOMEM);
69  }
70 
71  /* Input image view */
72  err = ff_vk_create_view(&ctx->s, &ctx->common,
73  &vp->in.view, &vp->in.aspect,
74  vkf, vkfc->format[0], 0);
75  if (err < 0)
76  return err;
77 
78  /* Reference view */
79  if (!ctx->common.layered_dpb) {
80  AVFrame *rf = pic->recon_image;
81  AVVkFrame *rvkf = (AVVkFrame *)rf->data[0];
82  err = ff_vk_create_view(&ctx->s, &ctx->common,
83  &vp->dpb.view, &vp->dpb.aspect,
84  rvkf, ctx->pic_format, 1);
85  if (err < 0)
86  return err;
87  } else {
88  vp->dpb.view = ctx->common.layered_view;
89  vp->dpb.aspect = ctx->common.layered_aspect;
90  }
91 
92  return 0;
93 }
94 
96 {
98  FFVulkanFunctions *vk = &ctx->s.vkfn;
99 
100  FFVulkanEncodePicture *vp = pic->priv;
101 
102  if (vp->in.view)
103  vk->DestroyImageView(ctx->s.hwctx->act_dev, vp->in.view,
104  ctx->s.hwctx->alloc);
105 
106  if (!ctx->common.layered_dpb && vp->dpb.view)
107  vk->DestroyImageView(ctx->s.hwctx->act_dev, vp->dpb.view,
108  ctx->s.hwctx->alloc);
109 
110  ctx->slots[vp->dpb_slot.slotIndex] = NULL;
111 
112  return 0;
113 }
114 
116  VkVideoEncodeRateControlInfoKHR *rc_info,
117  VkVideoEncodeRateControlLayerInfoKHR *rc_layer /* Goes in ^ */)
118 {
120 
121  *rc_info = (VkVideoEncodeRateControlInfoKHR) {
122  .sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR,
123  .rateControlMode = ctx->opts.rc_mode,
124  };
125 
126  if (ctx->opts.rc_mode > VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR) {
127  *rc_layer = (VkVideoEncodeRateControlLayerInfoKHR) {
128  .sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR,
129  .averageBitrate = avctx->bit_rate,
130  .maxBitrate = avctx->rc_max_rate ? avctx->rc_max_rate : avctx->bit_rate,
131  .frameRateNumerator = avctx->framerate.num,
132  .frameRateDenominator = avctx->framerate.den,
133  };
134  rc_info->layerCount++;
135  rc_info->pLayers = rc_layer;
136  }
137 
138  return ctx->codec->init_pic_rc(avctx, pic, rc_info, rc_layer);
139 }
140 
142  FFHWBaseEncodePicture *base_pic)
143 {
145  FFVulkanFunctions *vk = &ctx->s.vkfn;
146 
147  const size_t size_align = ctx->caps.minBitstreamBufferSizeAlignment;
148 
149  FFVulkanEncodePicture *vp = base_pic->priv;
150  AVFrame *src = (AVFrame *)base_pic->input_image;
151  AVVkFrame *vkf = (AVVkFrame *)src->data[0];
152 
153  int err, max_pkt_size;
154 
155  FFVkBuffer *sd_buf;
156 
157  int slot_index = -1;
158  FFVkExecContext *exec;
159  VkCommandBuffer cmd_buf;
160  VkImageMemoryBarrier2 img_bar[37];
161  int nb_img_bar = 0;
162 
163  /* Coding start/end */
164  VkVideoBeginCodingInfoKHR encode_start;
165  VkVideoEndCodingInfoKHR encode_end = {
166  .sType = VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR,
167  };
168 
169  VkVideoEncodeRateControlLayerInfoKHR rc_layer;
170  VkVideoEncodeRateControlInfoKHR rc_info;
171  VkVideoEncodeQualityLevelInfoKHR q_info;
172  VkVideoCodingControlInfoKHR encode_ctrl;
173 
174  VkVideoReferenceSlotInfoKHR ref_slot[37];
175  VkVideoEncodeInfoKHR encode_info;
176 
177  /* Create packet data buffer */
178  max_pkt_size = FFALIGN(3 * ctx->base.surface_width * ctx->base.surface_height + (1 << 16),
179  ctx->caps.minBitstreamBufferSizeAlignment);
180 
181  err = ff_vk_get_pooled_buffer(&ctx->s, &ctx->buf_pool, &vp->pkt_buf,
182  VK_BUFFER_USAGE_VIDEO_ENCODE_DST_BIT_KHR,
183  &ctx->profile_list, max_pkt_size,
184  VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
185  VK_MEMORY_PROPERTY_HOST_CACHED_BIT);
186  if (err < 0)
187  return err;
188 
189  sd_buf = (FFVkBuffer *)vp->pkt_buf->data;
190 
191  /* Setup rate control */
192  err = init_pic_rc(avctx, base_pic, &rc_info, &rc_layer);
193  if (err < 0)
194  return err;
195 
196  q_info = (VkVideoEncodeQualityLevelInfoKHR) {
197  .sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR,
198  .pNext = &rc_info,
199  .qualityLevel = ctx->opts.quality,
200  };
201  encode_ctrl = (VkVideoCodingControlInfoKHR) {
202  .sType = VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR,
203  .pNext = &q_info,
204  .flags = VK_VIDEO_CODING_CONTROL_ENCODE_QUALITY_LEVEL_BIT_KHR |
205  VK_VIDEO_CODING_CONTROL_ENCODE_RATE_CONTROL_BIT_KHR |
206  VK_VIDEO_CODING_CONTROL_RESET_BIT_KHR,
207  };
208 
209  for (int i = 0; i < ctx->caps.maxDpbSlots; i++) {
210  if (ctx->slots[i] == NULL) {
211  slot_index = i;
212  ctx->slots[i] = base_pic;
213  break;
214  }
215  }
216  av_assert0(slot_index >= 0);
217 
218  /* Current picture's ref slot */
219  vp->dpb_res = (VkVideoPictureResourceInfoKHR) {
220  .sType = VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR,
221  .pNext = NULL,
222  .codedOffset = { 0 },
223  .codedExtent = (VkExtent2D){ avctx->width, avctx->height },
224  .baseArrayLayer = ctx->common.layered_dpb ? slot_index : 0,
225  .imageViewBinding = vp->dpb.view,
226  };
227 
228  vp->dpb_slot = (VkVideoReferenceSlotInfoKHR) {
229  .sType = VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR,
230  .pNext = NULL, // Set later
231  .slotIndex = slot_index,
232  .pPictureResource = &vp->dpb_res,
233  };
234 
235  encode_info = (VkVideoEncodeInfoKHR) {
236  .sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR,
237  .pNext = NULL, // Set later
238  .flags = 0x0,
239  .srcPictureResource = (VkVideoPictureResourceInfoKHR) {
240  .sType = VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR,
241  .pNext = NULL,
242  .codedOffset = { 0, 0 },
243  .codedExtent = (VkExtent2D){ base_pic->input_image->width,
244  base_pic->input_image->height },
245  .baseArrayLayer = 0,
246  .imageViewBinding = vp->in.view,
247  },
248  .pSetupReferenceSlot = &vp->dpb_slot,
249  .referenceSlotCount = 0,
250  .pReferenceSlots = ref_slot,
251  .dstBuffer = sd_buf->buf,
252  .dstBufferOffset = 0,
253  .dstBufferRange = sd_buf->size,
254  .precedingExternallyEncodedBytes = 0,
255  };
256 
257  for (int i = 0; i < MAX_REFERENCE_LIST_NUM; i++) {
258  for (int j = 0; j < base_pic->nb_refs[i]; j++) {
259  FFHWBaseEncodePicture *ref = base_pic->refs[i][j];
260  FFVulkanEncodePicture *rvp = ref->priv;
261  ref_slot[encode_info.referenceSlotCount++] = rvp->dpb_slot;
262  }
263  }
264 
265  /* Calling vkCmdBeginVideoCodingKHR requires to declare all references
266  * being enabled upfront, including the current frame's output ref. */
267  ref_slot[encode_info.referenceSlotCount] = vp->dpb_slot;
268  ref_slot[encode_info.referenceSlotCount].slotIndex = -1;
269 
270  /* Setup picture parameters */
271  err = ctx->codec->init_pic_params(avctx, base_pic,
272  &encode_info);
273  if (err < 0)
274  return err;
275 
276  encode_start = (VkVideoBeginCodingInfoKHR) {
277  .sType = VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR,
278  .pNext = !base_pic->force_idr ? &rc_info : NULL,
279  .videoSession = ctx->common.session,
280  .videoSessionParameters = ctx->session_params,
281  .referenceSlotCount = encode_info.referenceSlotCount + 1,
282  .pReferenceSlots = ref_slot,
283  };
284 
285  /* Write header */
286  if (base_pic->type == FF_HW_PICTURE_TYPE_IDR) {
287  uint8_t *hdr_dst = sd_buf->mapped_mem + encode_info.dstBufferOffset;
288  size_t data_size = encode_info.dstBufferRange;
289  err = ctx->codec->write_sequence_headers(avctx, base_pic, hdr_dst, &data_size);
290  if (err < 0)
291  goto fail;
292  encode_info.dstBufferOffset += data_size;
293  encode_info.dstBufferRange -= data_size;
294  }
295 
296  /* Write extra units */
297  if (ctx->codec->write_extra_headers) {
298  uint8_t *hdr_dst = sd_buf->mapped_mem + encode_info.dstBufferOffset;
299  size_t data_size = encode_info.dstBufferRange;
300  err = ctx->codec->write_extra_headers(avctx, base_pic, hdr_dst, &data_size);
301  if (err < 0)
302  goto fail;
303  encode_info.dstBufferOffset += data_size;
304  encode_info.dstBufferRange -= data_size;
305  }
306 
307  /* Align buffer offset to the required value with filler units */
308  if (ctx->codec->write_filler) {
309  uint8_t *hdr_dst = sd_buf->mapped_mem + encode_info.dstBufferOffset;
310  size_t data_size = encode_info.dstBufferRange;
311 
312  uint32_t offset = encode_info.dstBufferOffset;
313  size_t offset_align = ctx->caps.minBitstreamBufferOffsetAlignment;
314 
315  uint32_t filler_data = FFALIGN(offset, offset_align) - offset;
316 
317  if (filler_data) {
318  while (filler_data < ctx->codec->filler_header_size)
319  filler_data += offset_align;
320 
321  filler_data -= ctx->codec->filler_header_size;
322 
323  err = ctx->codec->write_filler(avctx, filler_data,
324  hdr_dst, &data_size);
325  if (err < 0)
326  goto fail;
327 
328  encode_info.dstBufferOffset += data_size;
329  encode_info.dstBufferRange -= data_size;
330  }
331  }
332 
333  vp->slices_offset = encode_info.dstBufferOffset;
334 
335  /* Align buffer size to the nearest lower alignment requirement. */
336  encode_info.dstBufferRange -= size_align;
337  encode_info.dstBufferRange = FFALIGN(encode_info.dstBufferRange,
338  size_align);
339 
340  /* Start command buffer recording */
341  exec = vp->exec = ff_vk_exec_get(&ctx->s, &ctx->enc_pool);
342  ff_vk_exec_start(&ctx->s, exec);
343  cmd_buf = exec->buf;
344 
345  /* Output packet buffer */
346  err = ff_vk_exec_add_dep_buf(&ctx->s, exec, &vp->pkt_buf, 1, 1);
347  if (err < 0)
348  goto fail;
349 
350  /* Source image */
351  err = ff_vk_exec_add_dep_frame(&ctx->s, exec, src,
352  VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
353  VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR);
354  if (err < 0)
355  goto fail;
356 
357  /* Source image layout conversion */
358  img_bar[nb_img_bar] = (VkImageMemoryBarrier2) {
359  .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2,
360  .pNext = NULL,
361  .srcStageMask = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
362  .srcAccessMask = vkf->access[0],
363  .dstStageMask = VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR,
364  .dstAccessMask = VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR,
365  .oldLayout = vkf->layout[0],
366  .newLayout = VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR,
367  .srcQueueFamilyIndex = vkf->queue_family[0],
368  .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
369  .image = vkf->img[0],
370  .subresourceRange = (VkImageSubresourceRange) {
371  .aspectMask = vp->in.aspect,
372  .layerCount = 1,
373  .levelCount = 1,
374  },
375  };
376  ff_vk_exec_update_frame(&ctx->s, exec, src,
377  &img_bar[nb_img_bar], &nb_img_bar);
378 
379  if (!ctx->common.layered_dpb) {
380  /* Source image's ref slot.
381  * No need to do a layout conversion, since the frames which are allocated
382  * with a DPB usage are automatically converted. */
383  err = ff_vk_exec_add_dep_frame(&ctx->s, exec, base_pic->recon_image,
384  VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
385  VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR);
386  if (err < 0)
387  return err;
388 
389  /* All references */
390  for (int i = 0; i < MAX_REFERENCE_LIST_NUM; i++) {
391  for (int j = 0; j < base_pic->nb_refs[i]; j++) {
392  FFHWBaseEncodePicture *ref = base_pic->refs[i][j];
393  err = ff_vk_exec_add_dep_frame(&ctx->s, exec, ref->recon_image,
394  VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
395  VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR);
396  if (err < 0)
397  return err;
398  }
399  }
400  } else {
401  err = ff_vk_exec_add_dep_frame(&ctx->s, exec, ctx->common.layered_frame,
402  VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR,
403  VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR);
404  if (err < 0)
405  return err;
406  }
407 
408  /* Change image layout */
409  vk->CmdPipelineBarrier2(cmd_buf, &(VkDependencyInfo) {
410  .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
411  .pImageMemoryBarriers = img_bar,
412  .imageMemoryBarrierCount = nb_img_bar,
413  });
414 
415  /* Start, use parameters */
416  vk->CmdBeginVideoCodingKHR(cmd_buf, &encode_start);
417 
418  /* Send control data */
419  if (!ctx->session_reset) {
420  vk->CmdControlVideoCodingKHR(cmd_buf, &encode_ctrl);
421  ctx->session_reset++;
422  }
423 
424  /* Encode */
425  vk->CmdBeginQuery(cmd_buf, ctx->enc_pool.query_pool, exec->query_idx + 0, 0);
426  vk->CmdEncodeVideoKHR(cmd_buf, &encode_info);
427  vk->CmdEndQuery(cmd_buf, ctx->enc_pool.query_pool, exec->query_idx + 0);
428 
429  /* End encoding */
430  vk->CmdEndVideoCodingKHR(cmd_buf, &encode_end);
431 
432  /* End recording and submit for execution */
433  err = ff_vk_exec_submit(&ctx->s, vp->exec);
434  if (err < 0)
435  goto fail;
436 
437  /* We don't need to keep the input image any longer, its already ref'd */
438  av_frame_free(&base_pic->input_image);
439 
440  return 0;
441 
442 fail:
443  return err;
444 }
445 
447  FFHWBaseEncodePicture *base_pic)
448 {
450  FFVulkanEncodePicture *vp = base_pic->priv;
451 
452  av_assert0(base_pic->encode_issued);
453 
454  if (base_pic->encode_complete)
455  return;
456 
457  ff_vk_exec_wait(&ctx->s, vp->exec);
458  base_pic->encode_complete = 1;
459 }
460 
462  FFHWBaseEncodePicture *base_pic, AVPacket *pkt)
463 {
464  VkResult ret;
465  FFVulkanEncodePicture *vp = base_pic->priv;
467  FFVkBuffer *sd_buf = (FFVkBuffer *)vp->pkt_buf->data;
468  uint32_t *query_data;
469 
470  vulkan_encode_wait(avctx, base_pic);
471 
472  ret = ff_vk_exec_get_query(&ctx->s, vp->exec, (void **)&query_data, 0);
473  if (ret == VK_NOT_READY) {
474  av_log(avctx, AV_LOG_ERROR, "Unable to perform query: %s!\n",
475  ff_vk_ret2str(ret));
476  return AVERROR(EINVAL);
477  }
478 
479  if (ret != VK_NOT_READY && ret != VK_SUCCESS) {
480  av_log(avctx, AV_LOG_ERROR, "Unable to perform query: %s!\n",
481  ff_vk_ret2str(ret));
482  return AVERROR_EXTERNAL;
483  }
484 
485  if (query_data[2] != VK_QUERY_RESULT_STATUS_COMPLETE_KHR) {
486  av_log(avctx, AV_LOG_ERROR, "Unable to encode: %u\n", query_data[2]);
487  return AVERROR_EXTERNAL;
488  }
489 
490  /* Invalidate buffer if needed */
491  if (!(sd_buf->flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)) {
492  FFVulkanFunctions *vk = &ctx->s.vkfn;
493  VkMappedMemoryRange invalidate_buf;
494 
495  int offs = vp->slices_offset;
496  /* If the non-coherent alignment is greater than the bitstream buffer
497  * offset's alignment, and the offs value is not aligned already,
498  * align it to the previous alignment point. */
499  if (ctx->s.props.properties.limits.nonCoherentAtomSize >
500  ctx->caps.minBitstreamBufferOffsetAlignment && offs &&
501  (FFALIGN(offs, ctx->s.props.properties.limits.nonCoherentAtomSize) != offs)) {
502  offs -= ctx->s.props.properties.limits.nonCoherentAtomSize;
503  offs = FFALIGN(FFMAX(offs, 0), ctx->s.props.properties.limits.nonCoherentAtomSize);
504  }
505 
506  invalidate_buf = (VkMappedMemoryRange) {
507  .sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE,
508  .memory = sd_buf->mem,
509  .offset = offs,
510  .size = VK_WHOLE_SIZE,
511  };
512 
513  vk->FlushMappedMemoryRanges(ctx->s.hwctx->act_dev, 1, &invalidate_buf);
514  }
515 
516  pkt->data = sd_buf->mapped_mem;
517  pkt->size = vp->slices_offset + /* base offset */
518  query_data[0] /* secondary offset */ +
519  query_data[1] /* size */;
520 
521  /* Move reference */
522  pkt->buf = vp->pkt_buf;
523  vp->pkt_buf = NULL;
524 
525  av_log(avctx, AV_LOG_DEBUG, "Frame %"PRId64"/%"PRId64 " encoded\n",
526  base_pic->display_order, base_pic->encode_order);
527 
528  return ff_hw_base_encode_set_output_property(&ctx->base, avctx,
529  base_pic, pkt,
530  ctx->codec->flags & VK_ENC_FLAG_NO_DELAY);
531 }
532 
534  .priv_size = sizeof(FFVulkanEncodePicture),
536  .issue = &vulkan_encode_issue,
538  .free = &vulkan_encode_free,
539 };
540 
542 {
544  return ff_hw_base_encode_receive_packet(&ctx->base, avctx, pkt);
545 }
546 
548 {
549  int err;
550  FFHWBaseEncodeContext *base_ctx = &ctx->base;
551  AVVulkanFramesContext *hwfc;
552 
553  enum AVPixelFormat dpb_format;
554  err = ff_hw_base_get_recon_format(base_ctx, NULL, &dpb_format);
555  if (err < 0)
556  return err;
557 
558  base_ctx->recon_frames_ref = av_hwframe_ctx_alloc(base_ctx->device_ref);
559  if (!base_ctx->recon_frames_ref)
560  return AVERROR(ENOMEM);
561 
562  base_ctx->recon_frames = (AVHWFramesContext *)base_ctx->recon_frames_ref->data;
563  hwfc = (AVVulkanFramesContext *)base_ctx->recon_frames->hwctx;
564 
566  base_ctx->recon_frames->sw_format = dpb_format;
567  base_ctx->recon_frames->width = avctx->width;
568  base_ctx->recon_frames->height = avctx->height;
569 
570  hwfc->format[0] = ctx->pic_format;
571  hwfc->create_pnext = &ctx->profile_list;
572  hwfc->tiling = VK_IMAGE_TILING_OPTIMAL;
573  hwfc->usage = VK_IMAGE_USAGE_SAMPLED_BIT |
574  VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR;
575 
576  if (ctx->common.layered_dpb)
577  hwfc->nb_layers = ctx->caps.maxDpbSlots;
578 
579  err = av_hwframe_ctx_init(base_ctx->recon_frames_ref);
580  if (err < 0) {
581  av_log(avctx, AV_LOG_ERROR, "Failed to initialise DPB frame context: %s\n",
582  av_err2str(err));
583  return err;
584  }
585 
586  if (ctx->common.layered_dpb) {
587  ctx->common.layered_frame = av_frame_alloc();
588  if (!ctx->common.layered_frame)
589  return AVERROR(ENOMEM);
590 
591  err = av_hwframe_get_buffer(base_ctx->recon_frames_ref,
592  ctx->common.layered_frame, 0);
593  if (err < 0)
594  return AVERROR(ENOMEM);
595 
596  err = ff_vk_create_view(&ctx->s, &ctx->common,
597  &ctx->common.layered_view,
598  &ctx->common.layered_aspect,
599  (AVVkFrame *)ctx->common.layered_frame->data[0],
600  hwfc->format[0], 1);
601  if (err < 0)
602  return err;
603 
604  av_buffer_unref(&base_ctx->recon_frames_ref);
605  }
606 
607  return 0;
608 }
609 
611 {
612  if (ctx->opts.qp) {
613  ctx->explicit_qp = ctx->opts.qp;
614  } else if (avctx->global_quality > 0) {
615  if (avctx->flags & AV_CODEC_FLAG_QSCALE)
616  ctx->explicit_qp = avctx->global_quality / FF_QP2LAMBDA;
617  else
618  ctx->explicit_qp = avctx->global_quality;
619  }
620 
621  if (ctx->opts.rc_mode == FF_VK_RC_MODE_AUTO) {
622  if (ctx->explicit_qp >= 0) {
623  ctx->opts.rc_mode = VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR;
624  } else if (avctx->global_quality > 0) {
625  if (avctx->flags & AV_CODEC_FLAG_QSCALE)
626  ctx->explicit_qp = avctx->global_quality / FF_QP2LAMBDA;
627  else
628  ctx->explicit_qp = avctx->global_quality;
629  ctx->opts.rc_mode = VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR;
630  } else if (avctx->bit_rate) {
631  if (ctx->enc_caps.rateControlModes & VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR)
632  ctx->opts.rc_mode = VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR;
633  else if (ctx->enc_caps.rateControlModes & VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR)
634  ctx->opts.rc_mode = VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR;
635  else
636  ctx->opts.rc_mode = VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DEFAULT_KHR;
637  } else {
638  ctx->explicit_qp = 18;
639  ctx->opts.rc_mode = VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR;
640  av_log(avctx, AV_LOG_WARNING, "No rate control settings specified, using fixed QP = %i\n",
641  ctx->explicit_qp);
642  }
643  } else if (ctx->opts.rc_mode != VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR &&
644  !avctx->bit_rate) {
645  av_log(avctx, AV_LOG_WARNING, "No bitrate specified!\n");
646  return AVERROR(EINVAL);
647  }
648 
649  if (ctx->opts.rc_mode && !(ctx->enc_caps.rateControlModes & ctx->opts.rc_mode)) {
650  static const char *rc_modes[] = {
651  [VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DEFAULT_KHR] = "default",
652  [VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR] = "cqp",
653  [VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR] = "cbr",
654  [VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR] = "vbr",
655  };
656  av_log(avctx, AV_LOG_ERROR, "Unsupported rate control mode %s, supported are:\n",
657  rc_modes[FFMIN(FF_ARRAY_ELEMS(rc_modes), ctx->opts.rc_mode)]);
658  av_log(avctx, AV_LOG_ERROR, " %s\n", rc_modes[0]);
659  for (int i = VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR;
660  i <= VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR; i <<= 1) {
661  if (!(ctx->enc_caps.rateControlModes & i))
662  continue;
663  av_log(avctx, AV_LOG_ERROR, " %s\n", rc_modes[i]);
664  }
665  return AVERROR(ENOTSUP);
666  }
667 
668  return 0;
669 }
670 
673 {
674  int err;
675 
676  /* Write extradata if needed */
677  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
678  uint8_t data[4096];
679  size_t data_len = sizeof(data);
680 
681  err = ctx->codec->write_sequence_headers(avctx, NULL, data, &data_len);
682  if (err < 0) {
683  av_log(avctx, AV_LOG_ERROR, "Failed to write sequence header "
684  "for extradata: %d.\n", err);
685  return err;
686  } else {
687  avctx->extradata_size = data_len;
688  avctx->extradata = av_mallocz(avctx->extradata_size +
690  if (!avctx->extradata) {
691  err = AVERROR(ENOMEM);
692  return err;
693  }
694  memcpy(avctx->extradata, data, avctx->extradata_size);
695  }
696  }
697 
698  return 0;
699 }
700 
702  const FFVulkanEncodeDescriptor *vk_desc,
703  const FFVulkanCodec *codec,
704  void *codec_caps, void *quality_pnext)
705 {
706  int i, err;
707  VkResult ret;
708  FFVulkanFunctions *vk = &ctx->s.vkfn;
709  FFVulkanContext *s = &ctx->s;
710  FFHWBaseEncodeContext *base_ctx = &ctx->base;
711 
712  const AVPixFmtDescriptor *desc;
713 
714  VkVideoFormatPropertiesKHR *ret_info;
715  uint32_t nb_out_fmts = 0;
716 
717  VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR quality_info;
718 
719  VkQueryPoolVideoEncodeFeedbackCreateInfoKHR query_create;
720 
721  VkVideoSessionCreateInfoKHR session_create = {
722  .sType = VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR,
723  };
724  VkPhysicalDeviceVideoFormatInfoKHR fmt_info = {
725  .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR,
726  .pNext = &ctx->profile_list,
727  };
728 
729  if (!avctx->hw_frames_ctx) {
730  av_log(avctx, AV_LOG_ERROR, "A hardware frames reference is "
731  "required to associate the encoding device.\n");
732  return AVERROR(EINVAL);
733  }
734 
735  ctx->base.op = &vulkan_base_encode_ops;
736  ctx->codec = codec;
737 
738  s->frames_ref = av_buffer_ref(avctx->hw_frames_ctx);
739  s->frames = (AVHWFramesContext *)s->frames_ref->data;
740  s->hwfc = s->frames->hwctx;
741 
742  s->device = (AVHWDeviceContext *)s->frames->device_ref->data;
743  s->hwctx = s->device->hwctx;
744 
746  if (!desc)
747  return AVERROR(EINVAL);
748 
749  s->extensions = ff_vk_extensions_to_mask(s->hwctx->enabled_dev_extensions,
750  s->hwctx->nb_enabled_dev_extensions);
751 
752  if (!(s->extensions & FF_VK_EXT_VIDEO_ENCODE_QUEUE)) {
753  av_log(avctx, AV_LOG_ERROR, "Device does not support the %s extension!\n",
754  VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME);
755  return AVERROR(ENOSYS);
756  } else if (!(s->extensions & FF_VK_EXT_VIDEO_MAINTENANCE_1)) {
757  av_log(avctx, AV_LOG_ERROR, "Device does not support the %s extension!\n",
758  VK_KHR_VIDEO_MAINTENANCE_1_EXTENSION_NAME);
759  return AVERROR(ENOSYS);
760  } else if (!(s->extensions & vk_desc->encode_extension)) {
761  av_log(avctx, AV_LOG_ERROR, "Device does not support encoding %s!\n",
762  avcodec_get_name(avctx->codec_id));
763  return AVERROR(ENOSYS);
764  }
765 
766  /* Load functions */
767  err = ff_vk_load_functions(s->device, vk, s->extensions, 1, 1);
768  if (err < 0)
769  return err;
770 
771  /* Create queue context */
772  err = ff_vk_video_qf_init(s, &ctx->qf_enc,
773  VK_QUEUE_VIDEO_ENCODE_BIT_KHR,
774  vk_desc->encode_op);
775  if (err < 0) {
776  av_log(avctx, AV_LOG_ERROR, "Encoding of %s is not supported by this device\n",
777  avcodec_get_name(avctx->codec_id));
778  return err;
779  }
780 
781  /* Load all properties */
782  err = ff_vk_load_props(s);
783  if (err < 0)
784  return err;
785 
786  /* Set tuning */
787  ctx->usage_info = (VkVideoEncodeUsageInfoKHR) {
788  .sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR,
789  .videoUsageHints = ctx->opts.usage,
790  .videoContentHints = ctx->opts.content,
791  .tuningMode = ctx->opts.tune,
792  };
793 
794  /* Load up the profile now, needed for caps and to create a query pool */
795  ctx->profile.sType = VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR;
796  ctx->profile.pNext = &ctx->usage_info;
797  ctx->profile.videoCodecOperation = vk_desc->encode_op;
798  ctx->profile.chromaSubsampling = ff_vk_subsampling_from_av_desc(desc);
799  ctx->profile.lumaBitDepth = ff_vk_depth_from_av_depth(desc->comp[0].depth);
800  ctx->profile.chromaBitDepth = ctx->profile.lumaBitDepth;
801 
802  /* Setup a profile */
803  err = codec->init_profile(avctx, &ctx->profile, &ctx->usage_info);
804  if (err < 0)
805  return err;
806 
807  ctx->profile_list.sType = VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR;
808  ctx->profile_list.profileCount = 1;
809  ctx->profile_list.pProfiles = &ctx->profile;
810 
811  /* Get the capabilities of the encoder for the given profile */
812  ctx->enc_caps.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR;
813  ctx->enc_caps.pNext = codec_caps;
814  ctx->caps.sType = VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR;
815  ctx->caps.pNext = &ctx->enc_caps;
816 
817  ret = vk->GetPhysicalDeviceVideoCapabilitiesKHR(s->hwctx->phys_dev,
818  &ctx->profile,
819  &ctx->caps);
820  if (ret == VK_ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR) {
821  av_log(avctx, AV_LOG_ERROR, "Unable to initialize encoding: "
822  "%s profile \"%s\" not supported!\n",
823  avcodec_get_name(avctx->codec_id),
824  avcodec_profile_name(avctx->codec_id, avctx->profile));
825  return AVERROR(EINVAL);
826  } else if (ret == VK_ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR) {
827  av_log(avctx, AV_LOG_ERROR, "Unable to initialize encoding: "
828  "format (%s) not supported!\n",
830  return AVERROR(EINVAL);
831  } else if (ret == VK_ERROR_FEATURE_NOT_PRESENT ||
832  ret == VK_ERROR_FORMAT_NOT_SUPPORTED) {
833  return AVERROR(EINVAL);
834  } else if (ret != VK_SUCCESS) {
835  return AVERROR_EXTERNAL;
836  }
837 
838  err = init_rc(avctx, ctx);
839  if (err < 0)
840  return err;
841 
842  /* Create command and query pool */
843  query_create = (VkQueryPoolVideoEncodeFeedbackCreateInfoKHR) {
844  .sType = VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR,
845  .pNext = &ctx->profile,
846  .encodeFeedbackFlags = ctx->enc_caps.supportedEncodeFeedbackFlags &
847  (~VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_HAS_OVERRIDES_BIT_KHR),
848  };
849  err = ff_vk_exec_pool_init(s, &ctx->qf_enc, &ctx->enc_pool, base_ctx->async_depth,
850  1, VK_QUERY_TYPE_VIDEO_ENCODE_FEEDBACK_KHR, 0,
851  &query_create);
852  if (err < 0)
853  return err;
854 
855  if (ctx->opts.quality > ctx->enc_caps.maxQualityLevels) {
856  av_log(avctx, AV_LOG_ERROR, "Invalid quality level %i: allowed range is "
857  "0 to %i\n",
858  ctx->opts.quality, ctx->enc_caps.maxQualityLevels);
859  return AVERROR(EINVAL);
860  }
861 
862  /* Get quality properties for the profile and quality level */
863  quality_info = (VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR) {
864  .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR,
865  .pVideoProfile = &ctx->profile,
866  .qualityLevel = ctx->opts.quality,
867  };
868  ctx->quality_props = (VkVideoEncodeQualityLevelPropertiesKHR) {
869  .sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR,
870  .pNext = quality_pnext,
871  };
872  ret = vk->GetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR(s->hwctx->phys_dev,
873  &quality_info,
874  &ctx->quality_props);
875  if (ret != VK_SUCCESS)
876  return AVERROR_EXTERNAL;
877 
878  /* Printout informative properties */
879  av_log(avctx, AV_LOG_VERBOSE, "Encoder capabilities for %s profile \"%s\":\n",
880  avcodec_get_name(avctx->codec_id),
881  avcodec_profile_name(avctx->codec_id, avctx->profile));
882  av_log(avctx, AV_LOG_VERBOSE, " Width: from %i to %i\n",
883  ctx->caps.minCodedExtent.width, ctx->caps.maxCodedExtent.width);
884  av_log(avctx, AV_LOG_VERBOSE, " Height: from %i to %i\n",
885  ctx->caps.minCodedExtent.height, ctx->caps.maxCodedExtent.height);
886  av_log(avctx, AV_LOG_VERBOSE, " Width alignment: %i\n",
887  ctx->caps.pictureAccessGranularity.width);
888  av_log(avctx, AV_LOG_VERBOSE, " Height alignment: %i\n",
889  ctx->caps.pictureAccessGranularity.height);
890  av_log(avctx, AV_LOG_VERBOSE, " Bitstream offset alignment: %"PRIu64"\n",
891  ctx->caps.minBitstreamBufferOffsetAlignment);
892  av_log(avctx, AV_LOG_VERBOSE, " Bitstream size alignment: %"PRIu64"\n",
893  ctx->caps.minBitstreamBufferSizeAlignment);
894  av_log(avctx, AV_LOG_VERBOSE, " Maximum references: %u\n",
895  ctx->caps.maxDpbSlots);
896  av_log(avctx, AV_LOG_VERBOSE, " Maximum active references: %u\n",
897  ctx->caps.maxActiveReferencePictures);
898  av_log(avctx, AV_LOG_VERBOSE, " Codec header version: %i.%i.%i (driver), %i.%i.%i (compiled)\n",
899  CODEC_VER(ctx->caps.stdHeaderVersion.specVersion),
900  CODEC_VER(vk_desc->ext_props.specVersion));
901  av_log(avctx, AV_LOG_VERBOSE, " Encoder max quality: %i\n",
902  ctx->enc_caps.maxQualityLevels);
903  av_log(avctx, AV_LOG_VERBOSE, " Encoder image width alignment: %i\n",
904  ctx->enc_caps.encodeInputPictureGranularity.width);
905  av_log(avctx, AV_LOG_VERBOSE, " Encoder image height alignment: %i\n",
906  ctx->enc_caps.encodeInputPictureGranularity.height);
907  av_log(avctx, AV_LOG_VERBOSE, " Capability flags:%s%s%s\n",
908  ctx->caps.flags ? "" :
909  " none",
910  ctx->caps.flags & VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR ?
911  " protected" : "",
912  ctx->caps.flags & VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR ?
913  " separate_references" : "");
914 
915  /* Setup width/height alignment */
916  base_ctx->surface_width = avctx->coded_width =
917  FFALIGN(avctx->width, ctx->enc_caps.encodeInputPictureGranularity.width);
918  base_ctx->surface_height = avctx->coded_height =
919  FFALIGN(avctx->height, ctx->enc_caps.encodeInputPictureGranularity.height);
920 
921  /* Setup slice width/height */
922  base_ctx->slice_block_width = ctx->enc_caps.encodeInputPictureGranularity.width;
923  base_ctx->slice_block_height = ctx->enc_caps.encodeInputPictureGranularity.height;
924 
925  /* Check if encoding is possible with the given parameters */
926  if (avctx->coded_width < ctx->caps.minCodedExtent.width ||
927  avctx->coded_height < ctx->caps.minCodedExtent.height ||
928  avctx->coded_width > ctx->caps.maxCodedExtent.width ||
929  avctx->coded_height > ctx->caps.maxCodedExtent.height) {
930  av_log(avctx, AV_LOG_ERROR, "Input of %ix%i too large for encoder limits: %ix%i max\n",
931  avctx->coded_width, avctx->coded_height,
932  ctx->caps.minCodedExtent.width, ctx->caps.minCodedExtent.height);
933  return AVERROR(EINVAL);
934  }
935 
936  fmt_info.imageUsage = VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR |
937  VK_IMAGE_USAGE_VIDEO_ENCODE_DST_BIT_KHR;
938 
939  ctx->common.layered_dpb = !(ctx->caps.flags & VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR);
940 
941  /* Get the supported image formats */
942  ret = vk->GetPhysicalDeviceVideoFormatPropertiesKHR(s->hwctx->phys_dev,
943  &fmt_info,
944  &nb_out_fmts, NULL);
945  if (ret == VK_ERROR_FORMAT_NOT_SUPPORTED ||
946  (!nb_out_fmts && ret == VK_SUCCESS)) {
947  return AVERROR(EINVAL);
948  } else if (ret != VK_SUCCESS) {
949  av_log(avctx, AV_LOG_ERROR, "Unable to get Vulkan format properties: %s!\n",
950  ff_vk_ret2str(ret));
951  return AVERROR_EXTERNAL;
952  }
953 
954  ret_info = av_mallocz(sizeof(*ret_info)*nb_out_fmts);
955  if (!ret_info)
956  return AVERROR(ENOMEM);
957 
958  for (int i = 0; i < nb_out_fmts; i++)
959  ret_info[i].sType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR;
960 
961  ret = vk->GetPhysicalDeviceVideoFormatPropertiesKHR(s->hwctx->phys_dev,
962  &fmt_info,
963  &nb_out_fmts, ret_info);
964  if (ret == VK_ERROR_FORMAT_NOT_SUPPORTED ||
965  (!nb_out_fmts && ret == VK_SUCCESS)) {
966  av_free(ret_info);
967  return AVERROR(EINVAL);
968  } else if (ret != VK_SUCCESS) {
969  av_log(avctx, AV_LOG_ERROR, "Unable to get Vulkan format properties: %s!\n",
970  ff_vk_ret2str(ret));
971  av_free(ret_info);
972  return AVERROR_EXTERNAL;
973  }
974 
975  av_log(avctx, AV_LOG_VERBOSE, "Supported input formats:\n");
976  for (i = 0; i < nb_out_fmts; i++)
977  av_log(avctx, AV_LOG_VERBOSE, " %i: %i\n", i, ret_info[i].format);
978 
979  for (i = 0; i < nb_out_fmts; i++) {
980  if (ff_vk_pix_fmt_from_vkfmt(ret_info[i].format) == s->frames->sw_format) {
981  ctx->pic_format = ret_info[i].format;
982  break;
983  }
984  }
985 
986  av_free(ret_info);
987 
988  if (i == nb_out_fmts) {
989  av_log(avctx, AV_LOG_ERROR, "Pixel format %s of input frames not supported!\n",
990  av_get_pix_fmt_name(s->frames->sw_format));
991  return AVERROR(EINVAL);
992  }
993 
994  /* Create session */
995  session_create.pVideoProfile = &ctx->profile;
996  session_create.flags = 0x0;
997  session_create.queueFamilyIndex = ctx->qf_enc.queue_family;
998  session_create.maxCodedExtent = ctx->caps.maxCodedExtent;
999  session_create.maxDpbSlots = ctx->caps.maxDpbSlots;
1000  session_create.maxActiveReferencePictures = ctx->caps.maxActiveReferencePictures;
1001  session_create.pictureFormat = ctx->pic_format;
1002  session_create.referencePictureFormat = session_create.pictureFormat;
1003  session_create.pStdHeaderVersion = &vk_desc->ext_props;
1004 
1005  err = ff_vk_video_common_init(avctx, s, &ctx->common, &session_create);
1006  if (err < 0)
1007  return err;
1008 
1009  err = ff_hw_base_encode_init(avctx, &ctx->base);
1010  if (err < 0)
1011  return err;
1012 
1013  err = vulkan_encode_create_dpb(avctx, ctx);
1014  if (err < 0)
1015  return err;
1016 
1017  base_ctx->async_encode = 1;
1018  base_ctx->encode_fifo = av_fifo_alloc2(base_ctx->async_depth,
1019  sizeof(FFVulkanEncodePicture *), 0);
1020  if (!base_ctx->encode_fifo)
1021  return AVERROR(ENOMEM);
1022 
1023  return 0;
1024 }
1025 
1027  void *codec_params_pnext)
1028 {
1029  VkResult ret;
1030  FFVulkanFunctions *vk = &ctx->s.vkfn;
1031  FFVulkanContext *s = &ctx->s;
1032 
1033  VkVideoEncodeQualityLevelInfoKHR q_info;
1034  VkVideoSessionParametersCreateInfoKHR session_params_create;
1035 
1036  q_info = (VkVideoEncodeQualityLevelInfoKHR) {
1037  .sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR,
1038  .pNext = codec_params_pnext,
1039  .qualityLevel = ctx->opts.quality,
1040  };
1041  session_params_create = (VkVideoSessionParametersCreateInfoKHR) {
1042  .sType = VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR,
1043  .pNext = &q_info,
1044  .videoSession = ctx->common.session,
1045  .videoSessionParametersTemplate = VK_NULL_HANDLE,
1046  };
1047 
1048  /* Create session parameters */
1049  ret = vk->CreateVideoSessionParametersKHR(s->hwctx->act_dev, &session_params_create,
1050  s->hwctx->alloc, &ctx->session_params);
1051  if (ret != VK_SUCCESS) {
1052  av_log(avctx, AV_LOG_ERROR, "Unable to create Vulkan video session parameters: %s!\n",
1053  ff_vk_ret2str(ret));
1054  return AVERROR_EXTERNAL;
1055  }
1056 
1057  return 0;
1058 }
vulkan_loader.h
vulkan_encode_init
static int vulkan_encode_init(AVCodecContext *avctx, FFHWBaseEncodePicture *pic)
Definition: vulkan_encode.c:54
ff_vk_load_props
int ff_vk_load_props(FFVulkanContext *s)
Loads props/mprops/driver_props.
Definition: vulkan.c:106
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:215
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
FFHWBaseEncodeContext::recon_frames_ref
AVBufferRef * recon_frames_ref
Definition: hw_base_encode.h:156
FF_HW_PICTURE_TYPE_IDR
@ FF_HW_PICTURE_TYPE_IDR
Definition: hw_base_encode.h:39
FFVulkanEncodeDescriptor::encode_op
VkVideoCodecOperationFlagBitsKHR encode_op
Definition: vulkan_encode.h:34
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
FFVulkanEncodeDescriptor::encode_extension
FFVulkanExtensions encode_extension
Definition: vulkan_encode.h:33
FFVulkanEncodePicture::view
VkImageView view
Definition: vulkan_encode.h:45
ff_vulkan_encode_hw_configs
const AVCodecHWConfigInternal *const ff_vulkan_encode_hw_configs[]
Paperwork.
Definition: vulkan_encode.c:26
ff_vk_video_qf_init
int ff_vk_video_qf_init(FFVulkanContext *s, FFVkQueueFamilyCtx *qf, VkQueueFlagBits family, VkVideoCodecOperationFlagBitsKHR caps)
Chooses a QF and loads it into a context.
Definition: vulkan_video.c:267
FFHWBaseEncodePicture::priv
void * priv
Definition: hw_base_encode.h:63
FFHWBaseEncodePicture::codec_priv
void * codec_priv
Definition: hw_base_encode.h:65
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3025
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:90
AVHWFramesContext::format
enum AVPixelFormat format
The pixel format identifying the underlying HW surface type.
Definition: hwcontext.h:197
AV_CODEC_FLAG_QSCALE
#define AV_CODEC_FLAG_QSCALE
Use fixed qscale.
Definition: avcodec.h:224
ff_vk_exec_get_query
VkResult ff_vk_exec_get_query(FFVulkanContext *s, FFVkExecContext *e, void **data, VkQueryResultFlagBits flags)
Performs nb_queries queries and returns their results and statuses.
Definition: vulkan.c:457
output
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce output
Definition: filter_design.txt:225
vulkan_encode_free
static int vulkan_encode_free(AVCodecContext *avctx, FFHWBaseEncodePicture *pic)
Definition: vulkan_encode.c:95
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:162
ff_vk_exec_update_frame
void ff_vk_exec_update_frame(FFVulkanContext *s, FFVkExecContext *e, AVFrame *f, VkImageMemoryBarrier2 *bar, uint32_t *nb_img_bar)
Definition: vulkan.c:762
av_hwframe_ctx_init
int av_hwframe_ctx_init(AVBufferRef *ref)
Finalize the context before use.
Definition: hwcontext.c:322
ff_vk_depth_from_av_depth
VkVideoComponentBitDepthFlagBitsKHR ff_vk_depth_from_av_depth(int depth)
Get Vulkan's bit depth from an [8:12] integer.
Definition: vulkan_video.c:124
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:389
AVFrame::width
int width
Definition: frame.h:461
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:248
AVPacket::data
uint8_t * data
Definition: packet.h:539
AVVulkanFramesContext::create_pnext
void * create_pnext
Extension data for image creation.
Definition: hwcontext_vulkan.h:243
ff_hw_base_encode_init
int ff_hw_base_encode_init(AVCodecContext *avctx, FFHWBaseEncodeContext *ctx)
Definition: hw_base_encode.c:772
ff_vulkan_write_global_header
av_cold int ff_vulkan_write_global_header(AVCodecContext *avctx, FFVulkanEncodeContext *ctx)
Write out the extradata in case its needed.
Definition: vulkan_encode.c:671
data
const char data[16]
Definition: mxf.c:149
ff_vk_create_view
int ff_vk_create_view(FFVulkanContext *s, FFVkVideoCommon *common, VkImageView *view, VkImageAspectFlags *aspect, AVVkFrame *src, VkFormat vkf, int is_dpb)
Creates image views for video frames.
Definition: vulkan_video.c:281
FFHWBaseEncodePicture::recon_image
AVFrame * recon_image
Definition: hw_base_encode.h:84
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:225
ff_vk_exec_get
FFVkExecContext * ff_vk_exec_get(FFVulkanContext *s, FFVkExecPool *pool)
Retrieve an execution pool.
Definition: vulkan.c:485
FFHWBaseEncodeContext::slice_block_width
int slice_block_width
Definition: hw_base_encode.h:144
ff_vk_uninit
void ff_vk_uninit(FFVulkanContext *s)
Frees main context.
Definition: vulkan.c:2306
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
av_buffer_ref
AVBufferRef * av_buffer_ref(const AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:103
avcodec_profile_name
const char * avcodec_profile_name(enum AVCodecID codec_id, int profile)
Return a name for the specified profile, if available.
Definition: utils.c:442
FFVulkanEncodeDescriptor
Definition: vulkan_encode.h:31
AVHWFramesContext::width
int width
The allocated dimensions of the frames in this pool.
Definition: hwcontext.h:217
FFHWBaseEncodeContext::slice_block_height
int slice_block_height
Definition: hw_base_encode.h:145
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:692
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:410
FFVkBuffer::buf
VkBuffer buf
Definition: vulkan.h:88
AV_CODEC_FLAG_GLOBAL_HEADER
#define AV_CODEC_FLAG_GLOBAL_HEADER
Place global headers in extradata instead of every keyframe.
Definition: avcodec.h:338
FFHWBaseEncodeContext
Definition: hw_base_encode.h:122
ff_vk_subsampling_from_av_desc
VkVideoChromaSubsamplingFlagBitsKHR ff_vk_subsampling_from_av_desc(const AVPixFmtDescriptor *desc)
Get Vulkan's chroma subsampling from a pixfmt descriptor.
Definition: vulkan_video.c:111
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:566
FFHWBaseEncodePicture::type
int type
Definition: hw_base_encode.h:78
ff_hw_base_encode_close
int ff_hw_base_encode_close(FFHWBaseEncodeContext *ctx)
Definition: hw_base_encode.c:805
fail
#define fail()
Definition: checkasm.h:188
AVVulkanFramesContext
Allocated as AVHWFramesContext.hwctx, used to set pool-specific options.
Definition: hwcontext_vulkan.h:213
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:508
FFHWBaseEncodePicture::input_image
AVFrame * input_image
Definition: hw_base_encode.h:83
ff_vk_ret2str
const char * ff_vk_ret2str(VkResult res)
Converts Vulkan return values to strings.
Definition: vulkan.c:35
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:639
AVRational::num
int num
Numerator.
Definition: rational.h:59
AVHWDeviceContext
This struct aggregates all the (hardware/vendor-specific) "high-level" state, i.e.
Definition: hwcontext.h:60
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:150
avassert.h
ff_hw_base_get_recon_format
int ff_hw_base_get_recon_format(FFHWBaseEncodeContext *ctx, const void *hwconfig, enum AVPixelFormat *fmt)
Definition: hw_base_encode.c:714
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
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
AVHWFramesContext::height
int height
Definition: hwcontext.h:217
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:530
FFVulkanEncodeDescriptor::ext_props
VkExtensionProperties ext_props
Definition: vulkan_encode.h:36
s
#define s(width, name)
Definition: cbs_vp9.c:198
ff_vk_video_common_init
av_cold int ff_vk_video_common_init(AVCodecContext *avctx, FFVulkanContext *s, FFVkVideoCommon *common, VkVideoSessionCreateInfoKHR *session_create)
Initialize video session, allocating and binding necessary memory.
Definition: vulkan_video.c:355
AVCodecContext::global_quality
int global_quality
Global quality for codecs which cannot change it per frame.
Definition: avcodec.h:1249
AVFormatContext::flags
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1451
format
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 format(the sample packing is implied by the sample format) and sample rate. The lists are not just lists
ff_vk_load_functions
static int ff_vk_load_functions(AVHWDeviceContext *ctx, FFVulkanFunctions *vk, uint64_t extensions_mask, int has_inst, int has_dev)
Function loader.
Definition: vulkan_loader.h:105
ff_vk_exec_wait
void ff_vk_exec_wait(FFVulkanContext *s, FFVkExecContext *e)
Definition: vulkan.c:499
FFHWBaseEncodeContext::async_encode
int async_encode
Definition: hw_base_encode.h:212
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
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
FFVulkanEncodePicture::slices_offset
int slices_offset
Definition: vulkan_encode.h:59
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:570
FFVulkanEncodePicture::aspect
VkImageAspectFlags aspect
Definition: vulkan_encode.h:46
AVCodecContext::rc_max_rate
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:1302
ff_vk_exec_pool_free
void ff_vk_exec_pool_free(FFVulkanContext *s, FFVkExecPool *pool)
Definition: vulkan.c:238
FFVkExecContext::query_idx
int query_idx
Definition: vulkan.h:125
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:461
AVPacket::buf
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: packet.h:522
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:210
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
ff_vk_video_common_uninit
av_cold void ff_vk_video_common_uninit(FFVulkanContext *s, FFVkVideoCommon *common)
Free video session and required resources.
Definition: vulkan_video.c:325
FF_VK_EXT_VIDEO_ENCODE_QUEUE
#define FF_VK_EXT_VIDEO_ENCODE_QUEUE
Definition: vulkan_functions.h:61
FFVulkanEncodePicture::dpb
struct FFVulkanEncodePicture::@283 dpb
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:501
av_buffer_pool_uninit
void av_buffer_pool_uninit(AVBufferPool **ppool)
Mark the pool as being available for freeing.
Definition: buffer.c:328
FFHWEncodePictureOperation
Definition: hw_base_encode.h:109
AVVulkanFramesContext::format
VkFormat format[AV_NUM_DATA_POINTERS]
Vulkan format for each image.
Definition: hwcontext_vulkan.h:273
FFVkBuffer::size
size_t size
Definition: vulkan.h:91
AVVulkanFramesContext::usage
VkImageUsageFlagBits usage
Defines extra usage of output frames.
Definition: hwcontext_vulkan.h:232
FFVulkanEncodePicture::in
struct FFVulkanEncodePicture::@282 in
ff_vk_exec_pool_init
int ff_vk_exec_pool_init(FFVulkanContext *s, FFVkQueueFamilyCtx *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:300
FFVkBuffer::mapped_mem
uint8_t * mapped_mem
Definition: vulkan.h:99
FFVulkanContext
Definition: vulkan.h:263
VK_ENC_FLAG_NO_DELAY
#define VK_ENC_FLAG_NO_DELAY
Definition: vulkan_encode.h:97
encode_end
static av_cold int encode_end(AVCodecContext *avctx)
Definition: huffyuvenc.c:977
FFHWBaseEncodePicture::force_idr
int force_idr
Definition: hw_base_encode.h:73
FFVulkanEncodeContext
Definition: vulkan_encode.h:165
ff_hw_base_encode_set_output_property
int ff_hw_base_encode_set_output_property(FFHWBaseEncodeContext *ctx, AVCodecContext *avctx, FFHWBaseEncodePicture *pic, AVPacket *pkt, int flag_no_delay)
Definition: hw_base_encode.c:518
init_pic_rc
static int init_pic_rc(AVCodecContext *avctx, FFHWBaseEncodePicture *pic, VkVideoEncodeRateControlInfoKHR *rc_info, VkVideoEncodeRateControlLayerInfoKHR *rc_layer)
Definition: vulkan_encode.c:115
FFHWEncodePictureOperation::priv_size
size_t priv_size
Definition: hw_base_encode.h:111
FF_VK_EXT_VIDEO_MAINTENANCE_1
#define FF_VK_EXT_VIDEO_MAINTENANCE_1
Definition: vulkan_functions.h:54
f
f
Definition: af_crystalizer.c:122
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:368
init_rc
static av_cold int init_rc(AVCodecContext *avctx, FFVulkanEncodeContext *ctx)
Definition: vulkan_encode.c:610
AVPacket::size
int size
Definition: packet.h:540
AVVkFrame
Definition: hwcontext_vulkan.h:302
FFHWBaseEncodePicture::nb_refs
int nb_refs[MAX_REFERENCE_LIST_NUM]
Definition: hw_base_encode.h:97
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
ff_hw_base_encode_receive_packet
int ff_hw_base_encode_receive_packet(FFHWBaseEncodeContext *ctx, AVCodecContext *avctx, AVPacket *pkt)
Definition: hw_base_encode.c:557
AVCodecHWConfigInternal
Definition: hwconfig.h:25
FFVkBuffer::flags
VkMemoryPropertyFlagBits flags
Definition: vulkan.h:90
FFHWBaseEncodePicture::encode_order
int64_t encode_order
Definition: hw_base_encode.h:70
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:107
HW_CONFIG_ENCODER_FRAMES
#define HW_CONFIG_ENCODER_FRAMES(format, device_type_)
Definition: hwconfig.h:98
avcodec_get_name
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
Definition: utils.c:409
ff_vk_exec_start
int ff_vk_exec_start(FFVulkanContext *s, FFVkExecContext *e)
Start/submit/wait an execution.
Definition: vulkan.c:508
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:529
ff_vulkan_encode_receive_packet
int ff_vulkan_encode_receive_packet(AVCodecContext *avctx, AVPacket *pkt)
Encode.
Definition: vulkan_encode.c:541
MAX_REFERENCE_LIST_NUM
#define MAX_REFERENCE_LIST_NUM
Definition: hw_base_encode.h:30
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
FFVulkanEncodePicture::exec
FFVkExecContext * exec
Definition: vulkan_encode.h:57
FFVkBuffer::mem
VkDeviceMemory mem
Definition: vulkan.h:89
FFHWBaseEncodePicture::refs
struct FFHWBaseEncodePicture * refs[MAX_REFERENCE_LIST_NUM][MAX_PICTURE_REFERENCES]
Definition: hw_base_encode.h:98
vulkan_encode.h
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:256
vulkan_encode_issue
static int vulkan_encode_issue(AVCodecContext *avctx, FFHWBaseEncodePicture *base_pic)
Definition: vulkan_encode.c:141
vulkan_encode_create_dpb
static int vulkan_encode_create_dpb(AVCodecContext *avctx, FFVulkanEncodeContext *ctx)
Definition: vulkan_encode.c:547
AVCodecContext::height
int height
Definition: avcodec.h:624
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:1485
CODEC_VER
#define CODEC_VER(ver)
Definition: vulkan_video.h:30
AVHWFramesContext
This struct describes a set or pool of "hardware" frames (i.e.
Definition: hwcontext.h:115
ret
ret
Definition: filter_design.txt:187
FFHWBaseEncodePicture
Definition: hw_base_encode.h:61
AVHWFramesContext::hwctx
void * hwctx
The format-specific data, allocated and freed automatically along with this context.
Definition: hwcontext.h:150
FFHWBaseEncodeContext::device_ref
AVBufferRef * device_ref
Definition: hw_base_encode.h:148
FFHWBaseEncodeContext::encode_fifo
AVFifo * encode_fifo
Definition: hw_base_encode.h:215
av_fifo_alloc2
AVFifo * av_fifo_alloc2(size_t nb_elems, size_t elem_size, unsigned int flags)
Allocate and initialize an AVFifo with a given element size.
Definition: fifo.c:47
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
FFVkExecContext::buf
VkCommandBuffer buf
Definition: vulkan.h:119
FFHWBaseEncodeContext::surface_height
int surface_height
Definition: hw_base_encode.h:141
FFHWBaseEncodeContext::async_depth
int async_depth
Definition: hw_base_encode.h:217
AVCodecContext
main external API structure.
Definition: avcodec.h:451
AVFrame::height
int height
Definition: frame.h:461
AVRational::den
int den
Denominator.
Definition: rational.h:60
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1650
ff_vulkan_encode_init
av_cold int ff_vulkan_encode_init(AVCodecContext *avctx, FFVulkanEncodeContext *ctx, const FFVulkanEncodeDescriptor *vk_desc, const FFVulkanCodec *codec, void *codec_caps, void *quality_pnext)
Initialize encoder.
Definition: vulkan_encode.c:701
vulkan_base_encode_ops
static const FFHWEncodePictureOperation vulkan_base_encode_ops
Definition: vulkan_encode.c:533
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:112
vulkan_encode_output
static int vulkan_encode_output(AVCodecContext *avctx, FFHWBaseEncodePicture *base_pic, AVPacket *pkt)
Definition: vulkan_encode.c:461
FFVulkanEncodePicture::pkt_buf
AVBufferRef * pkt_buf
Definition: vulkan_encode.h:58
FFHWBaseEncodeContext::surface_width
int surface_width
Definition: hw_base_encode.h:140
AVVulkanFramesContext::tiling
VkImageTiling tiling
Controls the tiling of allocated frames.
Definition: hwcontext_vulkan.h:222
FF_VK_RC_MODE_AUTO
#define FF_VK_RC_MODE_AUTO
Definition: vulkan_encode.h:162
AVCodecContext::coded_width
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:639
desc
const char * desc
Definition: libsvtav1.c:79
AVVulkanFramesContext::nb_layers
int nb_layers
Number of layers each image will have.
Definition: hwcontext_vulkan.h:278
FFVulkanCodec::init_profile
int(* init_profile)(AVCodecContext *avctx, VkVideoProfileInfoKHR *profile, void *pnext)
Initialize codec-specific structs in a Vulkan profile.
Definition: vulkan_encode.h:112
FFHWBaseEncodePicture::encode_complete
int encode_complete
Definition: hw_base_encode.h:81
mem.h
ff_vulkan_encode_uninit
av_cold void ff_vulkan_encode_uninit(FFVulkanEncodeContext *ctx)
Uninitialize encoder.
Definition: vulkan_encode.c:31
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AVPacket
This structure stores compressed data.
Definition: packet.h:516
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:478
FFVkBuffer
Definition: vulkan.h:87
FFVulkanCodec
Definition: vulkan_encode.h:90
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:624
FFHWBaseEncodeContext::recon_frames
AVHWFramesContext * recon_frames
Definition: hw_base_encode.h:157
ff_vk_exec_submit
int ff_vk_exec_submit(FFVulkanContext *s, FFVkExecContext *e)
Definition: vulkan.c:807
ff_vk_extensions_to_mask
static uint64_t ff_vk_extensions_to_mask(const char *const *extensions, int nb_extensions)
Definition: vulkan_loader.h:36
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
ff_vk_pix_fmt_from_vkfmt
enum AVPixelFormat ff_vk_pix_fmt_from_vkfmt(VkFormat vkf)
Get pixfmt from a Vulkan format.
Definition: vulkan_video.c:95
AVCodecContext::sw_pix_fmt
enum AVPixelFormat sw_pix_fmt
Nominal unaccelerated pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:670
FFHWBaseEncodePicture::encode_issued
int encode_issued
Definition: hw_base_encode.h:80
FF_QP2LAMBDA
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
Definition: avutil.h:227
FFHWBaseEncodePicture::display_order
int64_t display_order
Definition: hw_base_encode.h:69
FFVulkanEncodePicture::dpb_slot
VkVideoReferenceSlotInfoKHR dpb_slot
Definition: vulkan_encode.h:42
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:491
FFVulkanFunctions
Definition: vulkan_functions.h:263
ff_vulkan_encode_create_session_params
int ff_vulkan_encode_create_session_params(AVCodecContext *avctx, FFVulkanEncodeContext *ctx, void *codec_params_pnext)
Create session parameters.
Definition: vulkan_encode.c:1026
FFVulkanEncodePicture
Definition: vulkan_encode.h:39
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:1171
FFVulkanEncodePicture::dpb_res
VkVideoPictureResourceInfoKHR dpb_res
Definition: vulkan_encode.h:41
src
#define src
Definition: vp8dsp.c:248
vulkan_encode_wait
static void vulkan_encode_wait(AVCodecContext *avctx, FFHWBaseEncodePicture *base_pic)
Definition: vulkan_encode.c:446
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:2945