FFmpeg
vulkan_video.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 "vulkan_video.h"
21 
22 #define ASPECT_2PLANE (VK_IMAGE_ASPECT_PLANE_0_BIT | VK_IMAGE_ASPECT_PLANE_1_BIT)
23 #define ASPECT_3PLANE (VK_IMAGE_ASPECT_PLANE_0_BIT | VK_IMAGE_ASPECT_PLANE_1_BIT | VK_IMAGE_ASPECT_PLANE_2_BIT)
24 
25 static const struct FFVkFormatMapEntry {
28  VkImageAspectFlags aspect;
29 } vk_format_map[] = {
30  /* Gray formats */
31  { VK_FORMAT_R8_UNORM, AV_PIX_FMT_GRAY8, VK_IMAGE_ASPECT_COLOR_BIT },
32  { VK_FORMAT_R16_UNORM, AV_PIX_FMT_GRAY16, VK_IMAGE_ASPECT_COLOR_BIT },
33  { VK_FORMAT_R32_SFLOAT, AV_PIX_FMT_GRAYF32, VK_IMAGE_ASPECT_COLOR_BIT },
34 
35  /* RGB formats */
36  { VK_FORMAT_R16G16B16A16_UNORM, AV_PIX_FMT_XV36, VK_IMAGE_ASPECT_COLOR_BIT },
37  { VK_FORMAT_B8G8R8A8_UNORM, AV_PIX_FMT_BGRA, VK_IMAGE_ASPECT_COLOR_BIT },
38  { VK_FORMAT_R8G8B8A8_UNORM, AV_PIX_FMT_RGBA, VK_IMAGE_ASPECT_COLOR_BIT },
39  { VK_FORMAT_R8G8B8_UNORM, AV_PIX_FMT_RGB24, VK_IMAGE_ASPECT_COLOR_BIT },
40  { VK_FORMAT_B8G8R8_UNORM, AV_PIX_FMT_BGR24, VK_IMAGE_ASPECT_COLOR_BIT },
41  { VK_FORMAT_R16G16B16_UNORM, AV_PIX_FMT_RGB48, VK_IMAGE_ASPECT_COLOR_BIT },
42  { VK_FORMAT_R16G16B16A16_UNORM, AV_PIX_FMT_RGBA64, VK_IMAGE_ASPECT_COLOR_BIT },
43  { VK_FORMAT_R5G6B5_UNORM_PACK16, AV_PIX_FMT_RGB565, VK_IMAGE_ASPECT_COLOR_BIT },
44  { VK_FORMAT_B5G6R5_UNORM_PACK16, AV_PIX_FMT_BGR565, VK_IMAGE_ASPECT_COLOR_BIT },
45  { VK_FORMAT_B8G8R8A8_UNORM, AV_PIX_FMT_BGR0, VK_IMAGE_ASPECT_COLOR_BIT },
46  { VK_FORMAT_R8G8B8A8_UNORM, AV_PIX_FMT_RGB0, VK_IMAGE_ASPECT_COLOR_BIT },
47  { VK_FORMAT_A2R10G10B10_UNORM_PACK32, AV_PIX_FMT_X2RGB10, VK_IMAGE_ASPECT_COLOR_BIT },
48 
49  /* Planar RGB */
50  { VK_FORMAT_R8_UNORM, AV_PIX_FMT_GBRAP, VK_IMAGE_ASPECT_COLOR_BIT },
51  { VK_FORMAT_R16_UNORM, AV_PIX_FMT_GBRAP16, VK_IMAGE_ASPECT_COLOR_BIT },
52  { VK_FORMAT_R32_SFLOAT, AV_PIX_FMT_GBRPF32, VK_IMAGE_ASPECT_COLOR_BIT },
53  { VK_FORMAT_R32_SFLOAT, AV_PIX_FMT_GBRAPF32, VK_IMAGE_ASPECT_COLOR_BIT },
54 
55  /* Two-plane 420 YUV at 8, 10, 12 and 16 bits */
56  { VK_FORMAT_G8_B8R8_2PLANE_420_UNORM, AV_PIX_FMT_NV12, ASPECT_2PLANE },
57  { VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16, AV_PIX_FMT_P010, ASPECT_2PLANE },
58  { VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16, AV_PIX_FMT_P012, ASPECT_2PLANE },
59  { VK_FORMAT_G16_B16R16_2PLANE_420_UNORM, AV_PIX_FMT_P016, ASPECT_2PLANE },
60 
61  /* Two-plane 422 YUV at 8, 10 and 16 bits */
62  { VK_FORMAT_G8_B8R8_2PLANE_422_UNORM, AV_PIX_FMT_NV16, ASPECT_2PLANE },
63  { VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16, AV_PIX_FMT_P210, ASPECT_2PLANE },
64  { VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16, AV_PIX_FMT_P212, ASPECT_2PLANE },
65  { VK_FORMAT_G16_B16R16_2PLANE_422_UNORM, AV_PIX_FMT_P216, ASPECT_2PLANE },
66 
67  /* Two-plane 444 YUV at 8, 10 and 16 bits */
68  { VK_FORMAT_G8_B8R8_2PLANE_444_UNORM, AV_PIX_FMT_NV24, ASPECT_2PLANE },
69  { VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16, AV_PIX_FMT_P410, ASPECT_2PLANE },
70  { VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16, AV_PIX_FMT_P412, ASPECT_2PLANE },
71  { VK_FORMAT_G16_B16R16_2PLANE_444_UNORM, AV_PIX_FMT_P416, ASPECT_2PLANE },
72 
73  /* Three-plane 420, 422, 444 at 8, 10, 12 and 16 bits */
74  { VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM, AV_PIX_FMT_YUV420P, ASPECT_3PLANE },
75  { VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, AV_PIX_FMT_YUV420P10, ASPECT_3PLANE },
76  { VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, AV_PIX_FMT_YUV420P12, ASPECT_3PLANE },
77  { VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, AV_PIX_FMT_YUV420P16, ASPECT_3PLANE },
78  { VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM, AV_PIX_FMT_YUV422P, ASPECT_3PLANE },
79  { VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM, AV_PIX_FMT_YUV422P10, ASPECT_3PLANE },
80  { VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM, AV_PIX_FMT_YUV422P12, ASPECT_3PLANE },
81  { VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM, AV_PIX_FMT_YUV422P16, ASPECT_3PLANE },
82  { VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM, AV_PIX_FMT_YUV444P, ASPECT_3PLANE },
83  { VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM, AV_PIX_FMT_YUV444P10, ASPECT_3PLANE },
84  { VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM, AV_PIX_FMT_YUV444P12, ASPECT_3PLANE },
85  { VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM, AV_PIX_FMT_YUV444P16, ASPECT_3PLANE },
86 
87  /* Single plane 422 at 8, 10 and 12 bits */
88  { VK_FORMAT_G8B8G8R8_422_UNORM, AV_PIX_FMT_YUYV422, VK_IMAGE_ASPECT_COLOR_BIT },
89  { VK_FORMAT_B8G8R8G8_422_UNORM, AV_PIX_FMT_UYVY422, VK_IMAGE_ASPECT_COLOR_BIT },
90  { VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16, AV_PIX_FMT_Y210, VK_IMAGE_ASPECT_COLOR_BIT },
91  { VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16, AV_PIX_FMT_Y212, VK_IMAGE_ASPECT_COLOR_BIT },
92 };
94 
96 {
97  for (int i = 0; i < nb_vk_format_map; i++)
98  if (vk_format_map[i].vkf == vkf)
99  return vk_format_map[i].pixfmt;
100  return AV_PIX_FMT_NONE;
101 }
102 
103 VkImageAspectFlags ff_vk_aspect_bits_from_vkfmt(VkFormat vkf)
104 {
105  for (int i = 0; i < nb_vk_format_map; i++)
106  if (vk_format_map[i].vkf == vkf)
107  return vk_format_map[i].aspect;
108  return VK_IMAGE_ASPECT_NONE;
109 }
110 
111 VkVideoChromaSubsamplingFlagBitsKHR ff_vk_subsampling_from_av_desc(const AVPixFmtDescriptor *desc)
112 {
113  if (desc->nb_components == 1)
114  return VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR;
115  else if (!desc->log2_chroma_w && !desc->log2_chroma_h)
116  return VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR;
117  else if (!desc->log2_chroma_w && desc->log2_chroma_h == 1)
118  return VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR;
119  else if (desc->log2_chroma_w == 1 && desc->log2_chroma_h == 1)
120  return VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR;
121  return VK_VIDEO_CHROMA_SUBSAMPLING_INVALID_KHR;
122 }
123 
124 VkVideoComponentBitDepthFlagBitsKHR ff_vk_depth_from_av_depth(int depth)
125 {
126  switch (depth) {
127  case 8: return VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR;
128  case 10: return VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR;
129  case 12: return VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR;
130  default: break;
131  }
132  return VK_VIDEO_COMPONENT_BIT_DEPTH_INVALID_KHR;
133 }
134 
135 int ff_vk_h264_level_to_av(StdVideoH264LevelIdc level)
136 {
137  switch (level) {
138  case STD_VIDEO_H264_LEVEL_IDC_1_0: return 10;
139  case STD_VIDEO_H264_LEVEL_IDC_1_1: return 11;
140  case STD_VIDEO_H264_LEVEL_IDC_1_2: return 12;
141  case STD_VIDEO_H264_LEVEL_IDC_1_3: return 13;
142  case STD_VIDEO_H264_LEVEL_IDC_2_0: return 20;
143  case STD_VIDEO_H264_LEVEL_IDC_2_1: return 21;
144  case STD_VIDEO_H264_LEVEL_IDC_2_2: return 22;
145  case STD_VIDEO_H264_LEVEL_IDC_3_0: return 30;
146  case STD_VIDEO_H264_LEVEL_IDC_3_1: return 31;
147  case STD_VIDEO_H264_LEVEL_IDC_3_2: return 32;
148  case STD_VIDEO_H264_LEVEL_IDC_4_0: return 40;
149  case STD_VIDEO_H264_LEVEL_IDC_4_1: return 41;
150  case STD_VIDEO_H264_LEVEL_IDC_4_2: return 42;
151  case STD_VIDEO_H264_LEVEL_IDC_5_0: return 50;
152  case STD_VIDEO_H264_LEVEL_IDC_5_1: return 51;
153  case STD_VIDEO_H264_LEVEL_IDC_5_2: return 52;
154  case STD_VIDEO_H264_LEVEL_IDC_6_0: return 60;
155  case STD_VIDEO_H264_LEVEL_IDC_6_1: return 61;
156  default:
157  case STD_VIDEO_H264_LEVEL_IDC_6_2: return 62;
158  }
159 }
160 
161 int ff_vk_h265_level_to_av(StdVideoH265LevelIdc level)
162 {
163  switch (level) {
164  case STD_VIDEO_H265_LEVEL_IDC_1_0: return 10;
165  case STD_VIDEO_H265_LEVEL_IDC_2_0: return 20;
166  case STD_VIDEO_H265_LEVEL_IDC_2_1: return 21;
167  case STD_VIDEO_H265_LEVEL_IDC_3_0: return 30;
168  case STD_VIDEO_H265_LEVEL_IDC_3_1: return 31;
169  case STD_VIDEO_H265_LEVEL_IDC_4_0: return 40;
170  case STD_VIDEO_H265_LEVEL_IDC_4_1: return 41;
171  case STD_VIDEO_H265_LEVEL_IDC_5_0: return 50;
172  case STD_VIDEO_H265_LEVEL_IDC_5_1: return 51;
173  case STD_VIDEO_H265_LEVEL_IDC_6_0: return 60;
174  case STD_VIDEO_H265_LEVEL_IDC_6_1: return 61;
175  default:
176  case STD_VIDEO_H265_LEVEL_IDC_6_2: return 62;
177  }
178 }
179 
180 static void free_data_buf(void *opaque, uint8_t *data)
181 {
182  FFVulkanContext *ctx = opaque;
184  ff_vk_unmap_buffer(ctx, &buf->buf, 0);
185  ff_vk_free_buf(ctx, &buf->buf);
186  av_free(data);
187 }
188 
189 static AVBufferRef *alloc_data_buf(void *opaque, size_t size)
190 {
191  AVBufferRef *ref;
192  uint8_t *buf = av_mallocz(size);
193  if (!buf)
194  return NULL;
195 
196  ref = av_buffer_create(buf, size, free_data_buf, opaque, 0);
197  if (!ref)
198  av_free(buf);
199  return ref;
200 }
201 
203  AVBufferRef **buf, VkBufferUsageFlags usage,
204  void *create_pNext, size_t size)
205 {
206  int err;
207  AVBufferRef *ref;
209 
210  if (!s->buf_pool) {
211  s->buf_pool = av_buffer_pool_init2(sizeof(FFVkVideoBuffer), ctx,
213  if (!s->buf_pool)
214  return AVERROR(ENOMEM);
215  }
216 
217  *buf = ref = av_buffer_pool_get(s->buf_pool);
218  if (!ref)
219  return AVERROR(ENOMEM);
220 
221  data = (FFVkVideoBuffer *)ref->data;
222 
223  if (data->buf.size >= size)
224  return 0;
225 
226  /* No point in requesting anything smaller. */
227  size = FFMAX(size, 1024*1024);
228 
229  /* Align buffer to nearest power of two. Makes fragmentation management
230  * easier, and gives us ample headroom. */
231  size--;
232  size |= size >> 1;
233  size |= size >> 2;
234  size |= size >> 4;
235  size |= size >> 8;
236  size |= size >> 16;
237  size++;
238 
239  ff_vk_free_buf(ctx, &data->buf);
240  memset(data, 0, sizeof(FFVkVideoBuffer));
241 
242  err = ff_vk_create_buf(ctx, &data->buf, size,
243  create_pNext, NULL, usage,
244  VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
245  if (err < 0) {
247  return err;
248  }
249 
250  /* Map the buffer */
251  err = ff_vk_map_buffer(ctx, &data->buf, &data->mem, 0);
252  if (err < 0) {
254  return err;
255  }
256 
257  return 0;
258 }
259 
261  FFVkVideoCommon *common)
262 {
263  FFVulkanFunctions *vk = &s->vkfn;
264 
265  if (common->session) {
266  vk->DestroyVideoSessionKHR(s->hwctx->act_dev, common->session,
267  s->hwctx->alloc);
268  common->session = VK_NULL_HANDLE;
269  }
270 
271  if (common->nb_mem && common->mem)
272  for (int i = 0; i < common->nb_mem; i++)
273  vk->FreeMemory(s->hwctx->act_dev, common->mem[i], s->hwctx->alloc);
274 
275  av_freep(&common->mem);
276 
277  av_buffer_pool_uninit(&common->buf_pool);
278 }
279 
281  FFVkVideoCommon *common,
282  VkVideoSessionCreateInfoKHR *session_create)
283 {
284  int err;
285  VkResult ret;
286  FFVulkanFunctions *vk = &s->vkfn;
287  VkVideoSessionMemoryRequirementsKHR *mem = NULL;
288  VkBindVideoSessionMemoryInfoKHR *bind_mem = NULL;
289 
290  /* Create session */
291  ret = vk->CreateVideoSessionKHR(s->hwctx->act_dev, session_create,
292  s->hwctx->alloc, &common->session);
293  if (ret != VK_SUCCESS)
294  return AVERROR_EXTERNAL;
295 
296  /* Get memory requirements */
297  ret = vk->GetVideoSessionMemoryRequirementsKHR(s->hwctx->act_dev,
298  common->session,
299  &common->nb_mem,
300  NULL);
301  if (ret != VK_SUCCESS) {
302  err = AVERROR_EXTERNAL;
303  goto fail;
304  }
305 
306  /* Allocate all memory needed to actually allocate memory */
307  common->mem = av_mallocz(sizeof(*common->mem)*common->nb_mem);
308  if (!common->mem) {
309  err = AVERROR(ENOMEM);
310  goto fail;
311  }
312  mem = av_mallocz(sizeof(*mem)*common->nb_mem);
313  if (!mem) {
314  err = AVERROR(ENOMEM);
315  goto fail;
316  }
317  bind_mem = av_mallocz(sizeof(*bind_mem)*common->nb_mem);
318  if (!bind_mem) {
319  err = AVERROR(ENOMEM);
320  goto fail;
321  }
322 
323  /* Set the needed fields to get the memory requirements */
324  for (int i = 0; i < common->nb_mem; i++) {
325  mem[i] = (VkVideoSessionMemoryRequirementsKHR) {
326  .sType = VK_STRUCTURE_TYPE_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR,
327  };
328  }
329 
330  /* Finally get the memory requirements */
331  ret = vk->GetVideoSessionMemoryRequirementsKHR(s->hwctx->act_dev,
332  common->session, &common->nb_mem,
333  mem);
334  if (ret != VK_SUCCESS) {
335  err = AVERROR_EXTERNAL;
336  goto fail;
337  }
338 
339  /* Now allocate each requested memory.
340  * For ricing, could pool together memory that ends up in the same index. */
341  for (int i = 0; i < common->nb_mem; i++) {
342  err = ff_vk_alloc_mem(s, &mem[i].memoryRequirements,
343  UINT32_MAX, NULL, NULL, &common->mem[i]);
344  if (err < 0)
345  goto fail;
346 
347  bind_mem[i] = (VkBindVideoSessionMemoryInfoKHR) {
348  .sType = VK_STRUCTURE_TYPE_BIND_VIDEO_SESSION_MEMORY_INFO_KHR,
349  .memory = common->mem[i],
350  .memoryBindIndex = mem[i].memoryBindIndex,
351  .memoryOffset = 0,
352  .memorySize = mem[i].memoryRequirements.size,
353  };
354 
355  av_log(log, AV_LOG_VERBOSE, "Allocating %"PRIu64" bytes in bind index %i for video session\n",
356  bind_mem[i].memorySize, bind_mem[i].memoryBindIndex);
357  }
358 
359  /* Bind the allocated memory */
360  ret = vk->BindVideoSessionMemoryKHR(s->hwctx->act_dev, common->session,
361  common->nb_mem, bind_mem);
362  if (ret != VK_SUCCESS) {
363  err = AVERROR_EXTERNAL;
364  goto fail;
365  }
366 
367  av_freep(&mem);
368  av_freep(&bind_mem);
369 
370  return 0;
371 
372 fail:
373  av_freep(&mem);
374  av_freep(&bind_mem);
375 
376  ff_vk_video_common_uninit(s, common);
377  return err;
378 }
AV_PIX_FMT_GBRAP16
#define AV_PIX_FMT_GBRAP16
Definition: pixfmt.h:501
ff_vk_create_buf
int ff_vk_create_buf(FFVulkanContext *s, FFVkBuffer *buf, size_t size, void *pNext, void *alloc_pNext, VkBufferUsageFlags usage, VkMemoryPropertyFlagBits flags)
Definition: vulkan.c:848
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
level
uint8_t level
Definition: svq3.c:205
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
FFVkVideoBuffer
Definition: vulkan_video.h:66
normalize.log
log
Definition: normalize.py:21
FFVkVideoBuffer::buf
FFVkBuffer buf
Definition: vulkan_video.h:67
ff_vk_video_common_init
av_cold int ff_vk_video_common_init(void *log, FFVulkanContext *s, FFVkVideoCommon *common, VkVideoSessionCreateInfoKHR *session_create)
Initialize video session, allocating and binding necessary memory.
Definition: vulkan_video.c:280
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
data
const char data[16]
Definition: mxf.c:148
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:478
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
AV_PIX_FMT_BGR24
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:76
AV_PIX_FMT_BGRA
@ AV_PIX_FMT_BGRA
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
Definition: pixfmt.h:102
FFVkFormatMapEntry::vkf
VkFormat vkf
Definition: vulkan_video.c:26
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
alloc_data_buf
static AVBufferRef * alloc_data_buf(void *opaque, size_t size)
Definition: vulkan_video.c:189
AV_PIX_FMT_P212
#define AV_PIX_FMT_P212
Definition: pixfmt.h:541
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
ASPECT_3PLANE
#define ASPECT_3PLANE
Definition: vulkan_video.c:23
AV_PIX_FMT_GBRAP
@ AV_PIX_FMT_GBRAP
planar GBRA 4:4:4:4 32bpp
Definition: pixfmt.h:212
fail
#define fail()
Definition: checkasm.h:186
av_buffer_pool_init2
AVBufferPool * av_buffer_pool_init2(size_t size, void *opaque, AVBufferRef *(*alloc)(void *opaque, size_t size), void(*pool_free)(void *opaque))
Allocate and initialize a buffer pool with a more complex allocator.
Definition: buffer.c:259
AV_PIX_FMT_GRAY16
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:462
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:481
AV_PIX_FMT_Y210
#define AV_PIX_FMT_Y210
Definition: pixfmt.h:532
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
AV_PIX_FMT_YUV422P16
#define AV_PIX_FMT_YUV422P16
Definition: pixfmt.h:490
av_buffer_pool_get
AVBufferRef * av_buffer_pool_get(AVBufferPool *pool)
Allocate a new AVBuffer, reusing an old buffer from the pool when available.
Definition: buffer.c:384
s
#define s(width, name)
Definition: cbs_vp9.c:198
FFVkFormatMapEntry::pixfmt
enum AVPixelFormat pixfmt
Definition: vulkan_video.c:27
AV_PIX_FMT_YUV444P16
#define AV_PIX_FMT_YUV444P16
Definition: pixfmt.h:491
AV_PIX_FMT_YUV420P16
#define AV_PIX_FMT_YUV420P16
Definition: pixfmt.h:489
ctx
AVFormatContext * ctx
Definition: movenc.c:49
ff_vk_unmap_buffer
static int ff_vk_unmap_buffer(FFVulkanContext *s, FFVkBuffer *buf, int flush)
Definition: vulkan.h:418
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:73
AV_PIX_FMT_GRAYF32
#define AV_PIX_FMT_GRAYF32
Definition: pixfmt.h:511
AV_PIX_FMT_RGBA
@ AV_PIX_FMT_RGBA
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
Definition: pixfmt.h:100
free_data_buf
static void free_data_buf(void *opaque, uint8_t *data)
Definition: vulkan_video.c:180
if
if(ret)
Definition: filter_design.txt:179
AV_PIX_FMT_RGBA64
#define AV_PIX_FMT_RGBA64
Definition: pixfmt.h:468
ff_vk_alloc_mem
int ff_vk_alloc_mem(FFVulkanContext *s, VkMemoryRequirements *req, VkMemoryPropertyFlagBits req_flags, void *alloc_extension, VkMemoryPropertyFlagBits *mem_flags, VkDeviceMemory *mem)
Memory/buffer/image allocation helpers.
Definition: vulkan.c:790
NULL
#define NULL
Definition: coverity.c:32
ASPECT_2PLANE
#define ASPECT_2PLANE
Definition: vulkan_video.c:22
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:260
AV_PIX_FMT_YUYV422
@ AV_PIX_FMT_YUYV422
packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr
Definition: pixfmt.h:74
AV_PIX_FMT_P410
#define AV_PIX_FMT_P410
Definition: pixfmt.h:540
av_buffer_pool_uninit
void av_buffer_pool_uninit(AVBufferPool **ppool)
Mark the pool as being available for freeing.
Definition: buffer.c:322
AV_PIX_FMT_BGR0
@ AV_PIX_FMT_BGR0
packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined
Definition: pixfmt.h:265
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:479
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:81
FFVulkanContext
Definition: vulkan.h:229
av_buffer_create
AVBufferRef * av_buffer_create(uint8_t *data, size_t size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)
Create an AVBuffer from an existing array.
Definition: buffer.c:55
usage
const char * usage
Definition: floatimg_cmp.c:60
vk_format_map
static const struct FFVkFormatMapEntry vk_format_map[]
ff_vk_h265_level_to_av
int ff_vk_h265_level_to_av(StdVideoH265LevelIdc level)
Definition: vulkan_video.c:161
AV_PIX_FMT_RGB24
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:75
AV_PIX_FMT_P012
#define AV_PIX_FMT_P012
Definition: pixfmt.h:529
AV_PIX_FMT_GBRPF32
#define AV_PIX_FMT_GBRPF32
Definition: pixfmt.h:508
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:483
AV_PIX_FMT_RGB48
#define AV_PIX_FMT_RGB48
Definition: pixfmt.h:464
size
int size
Definition: twinvq_data.h:10344
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:485
AV_PIX_FMT_NV16
@ AV_PIX_FMT_NV16
interleaved chroma YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:198
AV_PIX_FMT_Y212
#define AV_PIX_FMT_Y212
Definition: pixfmt.h:533
AVERROR_EXTERNAL
#define AVERROR_EXTERNAL
Generic error in an external library.
Definition: error.h:59
AV_PIX_FMT_RGB0
@ AV_PIX_FMT_RGB0
packed RGB 8:8:8, 32bpp, RGBXRGBX... X=unused/undefined
Definition: pixfmt.h:263
AV_PIX_FMT_P216
#define AV_PIX_FMT_P216
Definition: pixfmt.h:543
AV_PIX_FMT_P210
#define AV_PIX_FMT_P210
Definition: pixfmt.h:539
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
FFVkFormatMapEntry::aspect
VkImageAspectFlags aspect
Definition: vulkan_video.c:28
VkFormat
enum VkFormat VkFormat
Definition: hwcontext_stub.c:25
AV_PIX_FMT_NV24
@ AV_PIX_FMT_NV24
planar YUV 4:4:4, 24bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (firs...
Definition: pixfmt.h:371
ff_vk_h264_level_to_av
int ff_vk_h264_level_to_av(StdVideoH264LevelIdc level)
Convert level from Vulkan to AV.
Definition: vulkan_video.c:135
AV_PIX_FMT_X2RGB10
#define AV_PIX_FMT_X2RGB10
Definition: pixfmt.h:536
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
AV_PIX_FMT_BGR565
#define AV_PIX_FMT_BGR565
Definition: pixfmt.h:470
ff_vk_free_buf
void ff_vk_free_buf(FFVulkanContext *s, FFVkBuffer *buf)
Definition: vulkan.c:1055
AV_PIX_FMT_P016
#define AV_PIX_FMT_P016
Definition: pixfmt.h:530
AV_PIX_FMT_RGB565
#define AV_PIX_FMT_RGB565
Definition: pixfmt.h:465
FFVkFormatMapEntry
Definition: vulkan_video.c:25
ret
ret
Definition: filter_design.txt:187
ff_vk_map_buffer
static int ff_vk_map_buffer(FFVulkanContext *s, FFVkBuffer *buf, uint8_t **mem, int invalidate)
Definition: vulkan.h:411
AV_PIX_FMT_NV12
@ AV_PIX_FMT_NV12
planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (firs...
Definition: pixfmt.h:96
AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:482
AV_PIX_FMT_UYVY422
@ AV_PIX_FMT_UYVY422
packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1
Definition: pixfmt.h:88
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
AV_PIX_FMT_GBRAPF32
#define AV_PIX_FMT_GBRAPF32
Definition: pixfmt.h:509
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:112
ff_vk_video_get_buffer
int ff_vk_video_get_buffer(FFVulkanContext *ctx, FFVkVideoCommon *s, AVBufferRef **buf, VkBufferUsageFlags usage, void *create_pNext, size_t size)
Get a mapped FFVkPooledBuffer with a specific guaranteed minimum size from a pool.
Definition: vulkan_video.c:202
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:78
nb_vk_format_map
static const int nb_vk_format_map
Definition: vulkan_video.c:93
AV_PIX_FMT_P010
#define AV_PIX_FMT_P010
Definition: pixfmt.h:528
vulkan_video.h
desc
const char * desc
Definition: libsvtav1.c:79
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:77
mem.h
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
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
AV_PIX_FMT_P416
#define AV_PIX_FMT_P416
Definition: pixfmt.h:544
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
AV_PIX_FMT_XV36
#define AV_PIX_FMT_XV36
Definition: pixfmt.h:535
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AV_PIX_FMT_P412
#define AV_PIX_FMT_P412
Definition: pixfmt.h:542
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
ff_vk_aspect_bits_from_vkfmt
VkImageAspectFlags ff_vk_aspect_bits_from_vkfmt(VkFormat vkf)
Get aspect bits which include all planes from a VkFormat.
Definition: vulkan_video.c:103
FFVulkanFunctions
Definition: vulkan_functions.h:226