1 /*
2 * Copyright © 2019 Red Hat.
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
13 * Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
21 * IN THE SOFTWARE.
22 */
23
24 #include "lvp_private.h"
25 #include "util/format/u_format.h"
26 #include "util/u_inlines.h"
27 #include "pipe/p_state.h"
28
29 static VkResult
lvp_image_create(VkDevice _device,const VkImageCreateInfo * pCreateInfo,const VkAllocationCallbacks * alloc,VkImage * pImage)30 lvp_image_create(VkDevice _device,
31 const VkImageCreateInfo *pCreateInfo,
32 const VkAllocationCallbacks* alloc,
33 VkImage *pImage)
34 {
35 LVP_FROM_HANDLE(lvp_device, device, _device);
36 struct lvp_image *image;
37
38 assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO);
39
40 image = vk_image_create(&device->vk, pCreateInfo, alloc, sizeof(*image));
41 if (image == NULL)
42 return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
43
44 image->alignment = 16;
45 {
46 struct pipe_resource template;
47
48 memset(&template, 0, sizeof(template));
49
50 template.screen = device->pscreen;
51 switch (pCreateInfo->imageType) {
52 case VK_IMAGE_TYPE_1D:
53 template.target = pCreateInfo->arrayLayers > 1 ? PIPE_TEXTURE_1D_ARRAY : PIPE_TEXTURE_1D;
54 break;
55 default:
56 case VK_IMAGE_TYPE_2D:
57 template.target = pCreateInfo->arrayLayers > 1 ? PIPE_TEXTURE_2D_ARRAY : PIPE_TEXTURE_2D;
58 break;
59 case VK_IMAGE_TYPE_3D:
60 template.target = PIPE_TEXTURE_3D;
61 break;
62 }
63
64 template.format = lvp_vk_format_to_pipe_format(pCreateInfo->format);
65
66 bool is_ds = util_format_is_depth_or_stencil(template.format);
67
68 if (pCreateInfo->usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT) {
69 template.bind |= PIPE_BIND_RENDER_TARGET;
70 /* sampler view is needed for resolve blits */
71 if (pCreateInfo->samples > 1)
72 template.bind |= PIPE_BIND_SAMPLER_VIEW;
73 }
74
75 if (pCreateInfo->usage & VK_IMAGE_USAGE_TRANSFER_DST_BIT) {
76 if (!is_ds)
77 template.bind |= PIPE_BIND_RENDER_TARGET;
78 else
79 template.bind |= PIPE_BIND_DEPTH_STENCIL;
80 }
81
82 if (pCreateInfo->usage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT)
83 template.bind |= PIPE_BIND_DEPTH_STENCIL;
84
85 if (pCreateInfo->usage & (VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
86 VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT))
87 template.bind |= PIPE_BIND_SAMPLER_VIEW;
88
89 if (pCreateInfo->usage & VK_IMAGE_USAGE_STORAGE_BIT)
90 template.bind |= PIPE_BIND_SHADER_IMAGE;
91
92 template.width0 = pCreateInfo->extent.width;
93 template.height0 = pCreateInfo->extent.height;
94 template.depth0 = pCreateInfo->extent.depth;
95 template.array_size = pCreateInfo->arrayLayers;
96 template.last_level = pCreateInfo->mipLevels - 1;
97 template.nr_samples = pCreateInfo->samples;
98 template.nr_storage_samples = pCreateInfo->samples;
99 image->bo = device->pscreen->resource_create_unbacked(device->pscreen,
100 &template,
101 &image->size);
102 if (!image->bo)
103 return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
104 }
105 *pImage = lvp_image_to_handle(image);
106
107 return VK_SUCCESS;
108 }
109
110 struct lvp_image *
lvp_swapchain_get_image(VkSwapchainKHR swapchain,uint32_t index)111 lvp_swapchain_get_image(VkSwapchainKHR swapchain,
112 uint32_t index)
113 {
114 VkImage image = wsi_common_get_image(swapchain, index);
115 return lvp_image_from_handle(image);
116 }
117
118 static VkResult
lvp_image_from_swapchain(VkDevice device,const VkImageCreateInfo * pCreateInfo,const VkImageSwapchainCreateInfoKHR * swapchain_info,const VkAllocationCallbacks * pAllocator,VkImage * pImage)119 lvp_image_from_swapchain(VkDevice device,
120 const VkImageCreateInfo *pCreateInfo,
121 const VkImageSwapchainCreateInfoKHR *swapchain_info,
122 const VkAllocationCallbacks *pAllocator,
123 VkImage *pImage)
124 {
125 ASSERTED struct lvp_image *swapchain_image = lvp_swapchain_get_image(swapchain_info->swapchain, 0);
126 assert(swapchain_image);
127
128 assert(swapchain_image->vk.image_type == pCreateInfo->imageType);
129
130 VkImageCreateInfo local_create_info;
131 local_create_info = *pCreateInfo;
132 local_create_info.pNext = NULL;
133 /* The following parameters are implictly selected by the wsi code. */
134 local_create_info.tiling = VK_IMAGE_TILING_OPTIMAL;
135 local_create_info.samples = VK_SAMPLE_COUNT_1_BIT;
136 local_create_info.usage |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
137
138 assert(!(local_create_info.usage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT));
139 return lvp_image_create(device, &local_create_info, pAllocator,
140 pImage);
141 }
142
143 VKAPI_ATTR VkResult VKAPI_CALL
lvp_CreateImage(VkDevice device,const VkImageCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkImage * pImage)144 lvp_CreateImage(VkDevice device,
145 const VkImageCreateInfo *pCreateInfo,
146 const VkAllocationCallbacks *pAllocator,
147 VkImage *pImage)
148 {
149 const VkImageSwapchainCreateInfoKHR *swapchain_info =
150 vk_find_struct_const(pCreateInfo->pNext, IMAGE_SWAPCHAIN_CREATE_INFO_KHR);
151 if (swapchain_info && swapchain_info->swapchain != VK_NULL_HANDLE)
152 return lvp_image_from_swapchain(device, pCreateInfo, swapchain_info,
153 pAllocator, pImage);
154 return lvp_image_create(device, pCreateInfo, pAllocator,
155 pImage);
156 }
157
158 VKAPI_ATTR void VKAPI_CALL
lvp_DestroyImage(VkDevice _device,VkImage _image,const VkAllocationCallbacks * pAllocator)159 lvp_DestroyImage(VkDevice _device, VkImage _image,
160 const VkAllocationCallbacks *pAllocator)
161 {
162 LVP_FROM_HANDLE(lvp_device, device, _device);
163 LVP_FROM_HANDLE(lvp_image, image, _image);
164
165 if (!_image)
166 return;
167 pipe_resource_reference(&image->bo, NULL);
168 vk_image_destroy(&device->vk, pAllocator, &image->vk);
169 }
170
171 VKAPI_ATTR VkResult VKAPI_CALL
lvp_CreateImageView(VkDevice _device,const VkImageViewCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkImageView * pView)172 lvp_CreateImageView(VkDevice _device,
173 const VkImageViewCreateInfo *pCreateInfo,
174 const VkAllocationCallbacks *pAllocator,
175 VkImageView *pView)
176 {
177 LVP_FROM_HANDLE(lvp_device, device, _device);
178 LVP_FROM_HANDLE(lvp_image, image, pCreateInfo->image);
179 struct lvp_image_view *view;
180
181 view = vk_image_view_create(&device->vk, pCreateInfo, pAllocator, sizeof(*view));
182 if (view == NULL)
183 return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
184
185 view->pformat = lvp_vk_format_to_pipe_format(view->vk.format);
186 view->image = image;
187 view->surface = NULL;
188 *pView = lvp_image_view_to_handle(view);
189
190 return VK_SUCCESS;
191 }
192
193 VKAPI_ATTR void VKAPI_CALL
lvp_DestroyImageView(VkDevice _device,VkImageView _iview,const VkAllocationCallbacks * pAllocator)194 lvp_DestroyImageView(VkDevice _device, VkImageView _iview,
195 const VkAllocationCallbacks *pAllocator)
196 {
197 LVP_FROM_HANDLE(lvp_device, device, _device);
198 LVP_FROM_HANDLE(lvp_image_view, iview, _iview);
199
200 if (!_iview)
201 return;
202
203 pipe_surface_reference(&iview->surface, NULL);
204 vk_image_view_destroy(&device->vk, pAllocator, &iview->vk);
205 }
206
lvp_GetImageSubresourceLayout(VkDevice _device,VkImage _image,const VkImageSubresource * pSubresource,VkSubresourceLayout * pLayout)207 VKAPI_ATTR void VKAPI_CALL lvp_GetImageSubresourceLayout(
208 VkDevice _device,
209 VkImage _image,
210 const VkImageSubresource* pSubresource,
211 VkSubresourceLayout* pLayout)
212 {
213 LVP_FROM_HANDLE(lvp_device, device, _device);
214 LVP_FROM_HANDLE(lvp_image, image, _image);
215 uint64_t value;
216
217 device->pscreen->resource_get_param(device->pscreen,
218 NULL,
219 image->bo,
220 0,
221 pSubresource->arrayLayer,
222 pSubresource->mipLevel,
223 PIPE_RESOURCE_PARAM_STRIDE,
224 0, &value);
225
226 pLayout->rowPitch = value;
227
228 device->pscreen->resource_get_param(device->pscreen,
229 NULL,
230 image->bo,
231 0,
232 pSubresource->arrayLayer,
233 pSubresource->mipLevel,
234 PIPE_RESOURCE_PARAM_OFFSET,
235 0, &value);
236
237 pLayout->offset = value;
238
239 device->pscreen->resource_get_param(device->pscreen,
240 NULL,
241 image->bo,
242 0,
243 pSubresource->arrayLayer,
244 pSubresource->mipLevel,
245 PIPE_RESOURCE_PARAM_LAYER_STRIDE,
246 0, &value);
247
248 if (image->bo->target == PIPE_TEXTURE_3D) {
249 pLayout->depthPitch = value;
250 pLayout->arrayPitch = 0;
251 } else {
252 pLayout->depthPitch = 0;
253 pLayout->arrayPitch = value;
254 }
255 pLayout->size = image->size;
256
257 switch (pSubresource->aspectMask) {
258 case VK_IMAGE_ASPECT_COLOR_BIT:
259 break;
260 case VK_IMAGE_ASPECT_DEPTH_BIT:
261 break;
262 case VK_IMAGE_ASPECT_STENCIL_BIT:
263 break;
264 default:
265 assert(!"Invalid image aspect");
266 }
267 }
268
lvp_CreateBuffer(VkDevice _device,const VkBufferCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkBuffer * pBuffer)269 VKAPI_ATTR VkResult VKAPI_CALL lvp_CreateBuffer(
270 VkDevice _device,
271 const VkBufferCreateInfo* pCreateInfo,
272 const VkAllocationCallbacks* pAllocator,
273 VkBuffer* pBuffer)
274 {
275 LVP_FROM_HANDLE(lvp_device, device, _device);
276 struct lvp_buffer *buffer;
277
278 assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO);
279
280 /* gallium has max 32-bit buffer sizes */
281 if (pCreateInfo->size > UINT32_MAX)
282 return VK_ERROR_OUT_OF_DEVICE_MEMORY;
283
284 buffer = vk_alloc2(&device->vk.alloc, pAllocator, sizeof(*buffer), 8,
285 VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
286 if (buffer == NULL)
287 return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
288
289 vk_object_base_init(&device->vk, &buffer->base, VK_OBJECT_TYPE_BUFFER);
290 buffer->size = pCreateInfo->size;
291 buffer->usage = pCreateInfo->usage;
292 buffer->offset = 0;
293
294 {
295 struct pipe_resource template;
296 memset(&template, 0, sizeof(struct pipe_resource));
297
298 if (pCreateInfo->usage & VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT)
299 template.bind |= PIPE_BIND_CONSTANT_BUFFER;
300
301 template.screen = device->pscreen;
302 template.target = PIPE_BUFFER;
303 template.format = PIPE_FORMAT_R8_UNORM;
304 template.width0 = buffer->size;
305 template.height0 = 1;
306 template.depth0 = 1;
307 template.array_size = 1;
308 if (buffer->usage & VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT)
309 template.bind |= PIPE_BIND_SAMPLER_VIEW;
310 if (buffer->usage & VK_BUFFER_USAGE_STORAGE_BUFFER_BIT)
311 template.bind |= PIPE_BIND_SHADER_BUFFER;
312 if (buffer->usage & VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT)
313 template.bind |= PIPE_BIND_SHADER_IMAGE;
314 template.flags = PIPE_RESOURCE_FLAG_DONT_OVER_ALLOCATE;
315 buffer->bo = device->pscreen->resource_create_unbacked(device->pscreen,
316 &template,
317 &buffer->total_size);
318 if (!buffer->bo) {
319 vk_free2(&device->vk.alloc, pAllocator, buffer);
320 return vk_error(device, VK_ERROR_OUT_OF_DEVICE_MEMORY);
321 }
322 }
323 *pBuffer = lvp_buffer_to_handle(buffer);
324
325 return VK_SUCCESS;
326 }
327
lvp_DestroyBuffer(VkDevice _device,VkBuffer _buffer,const VkAllocationCallbacks * pAllocator)328 VKAPI_ATTR void VKAPI_CALL lvp_DestroyBuffer(
329 VkDevice _device,
330 VkBuffer _buffer,
331 const VkAllocationCallbacks* pAllocator)
332 {
333 LVP_FROM_HANDLE(lvp_device, device, _device);
334 LVP_FROM_HANDLE(lvp_buffer, buffer, _buffer);
335
336 if (!_buffer)
337 return;
338
339 pipe_resource_reference(&buffer->bo, NULL);
340 vk_object_base_finish(&buffer->base);
341 vk_free2(&device->vk.alloc, pAllocator, buffer);
342 }
343
lvp_GetBufferDeviceAddress(VkDevice device,const VkBufferDeviceAddressInfoKHR * pInfo)344 VKAPI_ATTR VkDeviceAddress VKAPI_CALL lvp_GetBufferDeviceAddress(
345 VkDevice device,
346 const VkBufferDeviceAddressInfoKHR* pInfo)
347 {
348 LVP_FROM_HANDLE(lvp_buffer, buffer, pInfo->buffer);
349
350 return (VkDeviceAddress)(uintptr_t)buffer->pmem;
351 }
352
lvp_GetBufferOpaqueCaptureAddress(VkDevice device,const VkBufferDeviceAddressInfoKHR * pInfo)353 VKAPI_ATTR uint64_t VKAPI_CALL lvp_GetBufferOpaqueCaptureAddress(
354 VkDevice device,
355 const VkBufferDeviceAddressInfoKHR* pInfo)
356 {
357 return 0;
358 }
359
lvp_GetDeviceMemoryOpaqueCaptureAddress(VkDevice device,const VkDeviceMemoryOpaqueCaptureAddressInfoKHR * pInfo)360 VKAPI_ATTR uint64_t VKAPI_CALL lvp_GetDeviceMemoryOpaqueCaptureAddress(
361 VkDevice device,
362 const VkDeviceMemoryOpaqueCaptureAddressInfoKHR* pInfo)
363 {
364 return 0;
365 }
366
367 VKAPI_ATTR VkResult VKAPI_CALL
lvp_CreateBufferView(VkDevice _device,const VkBufferViewCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkBufferView * pView)368 lvp_CreateBufferView(VkDevice _device,
369 const VkBufferViewCreateInfo *pCreateInfo,
370 const VkAllocationCallbacks *pAllocator,
371 VkBufferView *pView)
372 {
373 LVP_FROM_HANDLE(lvp_device, device, _device);
374 LVP_FROM_HANDLE(lvp_buffer, buffer, pCreateInfo->buffer);
375 struct lvp_buffer_view *view;
376 view = vk_alloc2(&device->vk.alloc, pAllocator, sizeof(*view), 8,
377 VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
378 if (!view)
379 return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
380
381 vk_object_base_init(&device->vk, &view->base,
382 VK_OBJECT_TYPE_BUFFER_VIEW);
383 view->buffer = buffer;
384 view->format = pCreateInfo->format;
385 view->pformat = lvp_vk_format_to_pipe_format(pCreateInfo->format);
386 view->offset = pCreateInfo->offset;
387 view->range = pCreateInfo->range;
388 *pView = lvp_buffer_view_to_handle(view);
389
390 return VK_SUCCESS;
391 }
392
393 VKAPI_ATTR void VKAPI_CALL
lvp_DestroyBufferView(VkDevice _device,VkBufferView bufferView,const VkAllocationCallbacks * pAllocator)394 lvp_DestroyBufferView(VkDevice _device, VkBufferView bufferView,
395 const VkAllocationCallbacks *pAllocator)
396 {
397 LVP_FROM_HANDLE(lvp_device, device, _device);
398 LVP_FROM_HANDLE(lvp_buffer_view, view, bufferView);
399
400 if (!bufferView)
401 return;
402 vk_object_base_finish(&view->base);
403 vk_free2(&device->vk.alloc, pAllocator, view);
404 }
405