• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 #ifndef AVUTIL_HWCONTEXT_VULKAN_H
20 #define AVUTIL_HWCONTEXT_VULKAN_H
21 
22 #if defined(_WIN32) && !defined(VK_USE_PLATFORM_WIN32_KHR)
23 #define VK_USE_PLATFORM_WIN32_KHR
24 #endif
25 #include <vulkan/vulkan.h>
26 
27 #include "pixfmt.h"
28 #include "frame.h"
29 
30 /**
31  * @file
32  * API-specific header for AV_HWDEVICE_TYPE_VULKAN.
33  *
34  * For user-allocated pools, AVHWFramesContext.pool must return AVBufferRefs
35  * with the data pointer set to an AVVkFrame.
36  */
37 
38 /**
39  * Main Vulkan context, allocated as AVHWDeviceContext.hwctx.
40  * All of these can be set before init to change what the context uses
41  */
42 typedef struct AVVulkanDeviceContext {
43     /**
44      * Custom memory allocator, else NULL
45      */
46     const VkAllocationCallbacks *alloc;
47 
48     /**
49      * Pointer to the instance-provided vkGetInstanceProcAddr loading function.
50      * If NULL, will pick either libvulkan or libvolk, depending on libavutil's
51      * compilation settings, and set this field.
52      */
53     PFN_vkGetInstanceProcAddr get_proc_addr;
54 
55     /**
56      * Vulkan instance. Must be at least version 1.2.
57      */
58     VkInstance inst;
59 
60     /**
61      * Physical device
62      */
63     VkPhysicalDevice phys_dev;
64 
65     /**
66      * Active device
67      */
68     VkDevice act_dev;
69 
70     /**
71      * This structure should be set to the set of features that present and enabled
72      * during device creation. When a device is created by FFmpeg, it will default to
73      * enabling all that are present of the shaderImageGatherExtended,
74      * fragmentStoresAndAtomics, shaderInt64 and vertexPipelineStoresAndAtomics features.
75      */
76     VkPhysicalDeviceFeatures2 device_features;
77 
78     /**
79      * Enabled instance extensions.
80      * If supplying your own device context, set this to an array of strings, with
81      * each entry containing the specified Vulkan extension string to enable.
82      * Duplicates are possible and accepted.
83      * If no extensions are enabled, set these fields to NULL, and 0 respectively.
84      */
85     const char * const *enabled_inst_extensions;
86     int nb_enabled_inst_extensions;
87 
88     /**
89      * Enabled device extensions. By default, VK_KHR_external_memory_fd,
90      * VK_EXT_external_memory_dma_buf, VK_EXT_image_drm_format_modifier,
91      * VK_KHR_external_semaphore_fd and VK_EXT_external_memory_host are enabled if found.
92      * If supplying your own device context, these fields takes the same format as
93      * the above fields, with the same conditions that duplicates are possible
94      * and accepted, and that NULL and 0 respectively means no extensions are enabled.
95      */
96     const char * const *enabled_dev_extensions;
97     int nb_enabled_dev_extensions;
98 
99     /**
100      * Queue family index for graphics operations, and the number of queues
101      * enabled for it. If unavaiable, will be set to -1. Not required.
102      * av_hwdevice_create() will attempt to find a dedicated queue for each
103      * queue family, or pick the one with the least unrelated flags set.
104      * Queue indices here may overlap if a queue has to share capabilities.
105      */
106     int queue_family_index;
107     int nb_graphics_queues;
108 
109     /**
110      * Queue family index for transfer operations and the number of queues
111      * enabled. Required.
112      */
113     int queue_family_tx_index;
114     int nb_tx_queues;
115 
116     /**
117      * Queue family index for compute operations and the number of queues
118      * enabled. Required.
119      */
120     int queue_family_comp_index;
121     int nb_comp_queues;
122 
123     /**
124      * Queue family index for video encode ops, and the amount of queues enabled.
125      * If the device doesn't support such, queue_family_encode_index will be -1.
126      * Not required.
127      */
128     int queue_family_encode_index;
129     int nb_encode_queues;
130 
131     /**
132      * Queue family index for video decode ops, and the amount of queues enabled.
133      * If the device doesn't support such, queue_family_decode_index will be -1.
134      * Not required.
135      */
136     int queue_family_decode_index;
137     int nb_decode_queues;
138 } AVVulkanDeviceContext;
139 
140 /**
141  * Defines the behaviour of frame allocation.
142  */
143 typedef enum AVVkFrameFlags {
144     /* Unless this flag is set, autodetected flags will be OR'd based on the
145      * device and tiling during av_hwframe_ctx_init(). */
146     AV_VK_FRAME_FLAG_NONE              = (1ULL << 0),
147 
148     /* Image planes will be allocated in a single VkDeviceMemory, rather
149      * than as per-plane VkDeviceMemory allocations. Required for exporting
150      * to VAAPI on Intel devices. */
151     AV_VK_FRAME_FLAG_CONTIGUOUS_MEMORY = (1ULL << 1),
152 } AVVkFrameFlags;
153 
154 /**
155  * Allocated as AVHWFramesContext.hwctx, used to set pool-specific options
156  */
157 typedef struct AVVulkanFramesContext {
158     /**
159      * Controls the tiling of allocated frames. If left as optimal tiling,
160      * then during av_hwframe_ctx_init() will decide based on whether the device
161      * supports DRM modifiers, or if the linear_images flag is set, otherwise
162      * will allocate optimally-tiled images.
163      */
164     VkImageTiling tiling;
165 
166     /**
167      * Defines extra usage of output frames. If left as 0, the following bits
168      * are set: TRANSFER_SRC, TRANSFER_DST. SAMPLED and STORAGE.
169      */
170     VkImageUsageFlagBits usage;
171 
172     /**
173      * Extension data for image creation.
174      * If VkImageDrmFormatModifierListCreateInfoEXT is present in the chain,
175      * and the device supports DRM modifiers, then images will be allocated
176      * with the specific requested DRM modifiers.
177      * Additional structures may be added at av_hwframe_ctx_init() time,
178      * which will be freed automatically on uninit(), so users need only free
179      * any structures they've allocated themselves.
180      */
181     void *create_pnext;
182 
183     /**
184      * Extension data for memory allocation. Must have as many entries as
185      * the number of planes of the sw_format.
186      * This will be chained to VkExportMemoryAllocateInfo, which is used
187      * to make all pool images exportable to other APIs if the necessary
188      * extensions are present in enabled_dev_extensions.
189      */
190     void *alloc_pnext[AV_NUM_DATA_POINTERS];
191 
192     /**
193      * A combination of AVVkFrameFlags. Unless AV_VK_FRAME_FLAG_NONE is set,
194      * autodetected flags will be OR'd based on the device and tiling during
195      * av_hwframe_ctx_init().
196      */
197     AVVkFrameFlags flags;
198 } AVVulkanFramesContext;
199 
200 /*
201  * Frame structure, the VkFormat of the image will always match
202  * the pool's sw_format.
203  * All frames, imported or allocated, will be created with the
204  * VK_IMAGE_CREATE_ALIAS_BIT flag set, so the memory may be aliased if needed.
205  *
206  * If all queue family indices in the device context are the same,
207  * images will be created with the EXCLUSIVE sharing mode. Otherwise, all images
208  * will be created using the CONCURRENT sharing mode.
209  *
210  * @note the size of this structure is not part of the ABI, to allocate
211  * you must use @av_vk_frame_alloc().
212  */
213 typedef struct AVVkFrame {
214     /**
215      * Vulkan images to which the memory is bound to.
216      */
217     VkImage img[AV_NUM_DATA_POINTERS];
218 
219     /**
220      * The same tiling must be used for all images in the frame.
221      */
222     VkImageTiling tiling;
223 
224     /**
225      * Memory backing the images. Could be less than the amount of planes,
226      * in which case the offset value will indicate the binding offset of
227      * each plane in the memory.
228      */
229     VkDeviceMemory mem[AV_NUM_DATA_POINTERS];
230     size_t size[AV_NUM_DATA_POINTERS];
231 
232     /**
233      * OR'd flags for all memory allocated
234      */
235     VkMemoryPropertyFlagBits flags;
236 
237     /**
238      * Updated after every barrier
239      */
240     VkAccessFlagBits access[AV_NUM_DATA_POINTERS];
241     VkImageLayout layout[AV_NUM_DATA_POINTERS];
242 
243     /**
244      * Synchronization timeline semaphores, one for each sw_format plane.
245      * Must not be freed manually. Must be waited on at every submission using
246      * the value in sem_value, and must be signalled at every submission,
247      * using an incremented value.
248      */
249     VkSemaphore sem[AV_NUM_DATA_POINTERS];
250 
251     /**
252      * Up to date semaphore value at which each image becomes accessible.
253      * Clients must wait on this value when submitting a command queue,
254      * and increment it when signalling.
255      */
256     uint64_t sem_value[AV_NUM_DATA_POINTERS];
257 
258     /**
259      * Internal data.
260      */
261     struct AVVkFrameInternal *internal;
262 
263     /**
264      * Describes the binding offset of each plane to the VkDeviceMemory.
265      */
266     ptrdiff_t offset[AV_NUM_DATA_POINTERS];
267 } AVVkFrame;
268 
269 /**
270  * Allocates a single AVVkFrame and initializes everything as 0.
271  * @note Must be freed via av_free()
272  */
273 AVVkFrame *av_vk_frame_alloc(void);
274 
275 /**
276  * Returns the format of each image up to the number of planes for a given sw_format.
277  * Returns NULL on unsupported formats.
278  */
279 const VkFormat *av_vkfmt_from_pixfmt(enum AVPixelFormat p);
280 
281 #endif /* AVUTIL_HWCONTEXT_VULKAN_H */
282