b445b30e0ff6606d06c21f4ef13e240ef2f63e72
[mesa.git] / src / amd / vulkan / radv_android.c
1 /*
2 * Copyright © 2017, Google Inc.
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 #ifdef ANDROID
25 #include <hardware/gralloc.h>
26 #include <hardware/hardware.h>
27 #include <hardware/hwvulkan.h>
28 #include <vulkan/vk_android_native_buffer.h>
29 #include <vulkan/vk_icd.h>
30 #include <libsync.h>
31
32 #if ANDROID_API_LEVEL >= 26
33 #include <hardware/gralloc1.h>
34 #include <vndk/hardware_buffer.h>
35 #endif
36 #endif
37
38 #include "util/os_file.h"
39
40 #include "radv_private.h"
41 #include "vk_util.h"
42
43 #ifdef ANDROID
44
45 static int radv_hal_open(const struct hw_module_t* mod, const char* id, struct hw_device_t** dev);
46 static int radv_hal_close(struct hw_device_t *dev);
47
48 static void UNUSED
49 static_asserts(void)
50 {
51 STATIC_ASSERT(HWVULKAN_DISPATCH_MAGIC == ICD_LOADER_MAGIC);
52 }
53
54 PUBLIC struct hwvulkan_module_t HAL_MODULE_INFO_SYM = {
55 .common = {
56 .tag = HARDWARE_MODULE_TAG,
57 .module_api_version = HWVULKAN_MODULE_API_VERSION_0_1,
58 .hal_api_version = HARDWARE_MAKE_API_VERSION(1, 0),
59 .id = HWVULKAN_HARDWARE_MODULE_ID,
60 .name = "AMD Vulkan HAL",
61 .author = "Google",
62 .methods = &(hw_module_methods_t) {
63 .open = radv_hal_open,
64 },
65 },
66 };
67
68 /* If any bits in test_mask are set, then unset them and return true. */
69 static inline bool
70 unmask32(uint32_t *inout_mask, uint32_t test_mask)
71 {
72 uint32_t orig_mask = *inout_mask;
73 *inout_mask &= ~test_mask;
74 return *inout_mask != orig_mask;
75 }
76
77 static int
78 radv_hal_open(const struct hw_module_t* mod, const char* id,
79 struct hw_device_t** dev)
80 {
81 assert(mod == &HAL_MODULE_INFO_SYM.common);
82 assert(strcmp(id, HWVULKAN_DEVICE_0) == 0);
83
84 hwvulkan_device_t *hal_dev = malloc(sizeof(*hal_dev));
85 if (!hal_dev)
86 return -1;
87
88 *hal_dev = (hwvulkan_device_t) {
89 .common = {
90 .tag = HARDWARE_DEVICE_TAG,
91 .version = HWVULKAN_DEVICE_API_VERSION_0_1,
92 .module = &HAL_MODULE_INFO_SYM.common,
93 .close = radv_hal_close,
94 },
95 .EnumerateInstanceExtensionProperties = radv_EnumerateInstanceExtensionProperties,
96 .CreateInstance = radv_CreateInstance,
97 .GetInstanceProcAddr = radv_GetInstanceProcAddr,
98 };
99
100 *dev = &hal_dev->common;
101 return 0;
102 }
103
104 static int
105 radv_hal_close(struct hw_device_t *dev)
106 {
107 /* hwvulkan.h claims that hw_device_t::close() is never called. */
108 return -1;
109 }
110
111 VkResult
112 radv_image_from_gralloc(VkDevice device_h,
113 const VkImageCreateInfo *base_info,
114 const VkNativeBufferANDROID *gralloc_info,
115 const VkAllocationCallbacks *alloc,
116 VkImage *out_image_h)
117
118 {
119 RADV_FROM_HANDLE(radv_device, device, device_h);
120 VkImage image_h = VK_NULL_HANDLE;
121 struct radv_image *image = NULL;
122 struct radv_bo *bo = NULL;
123 VkResult result;
124
125 if (gralloc_info->handle->numFds != 1) {
126 return vk_errorf(device->instance, VK_ERROR_INVALID_EXTERNAL_HANDLE,
127 "VkNativeBufferANDROID::handle::numFds is %d, "
128 "expected 1", gralloc_info->handle->numFds);
129 }
130
131 /* Do not close the gralloc handle's dma_buf. The lifetime of the dma_buf
132 * must exceed that of the gralloc handle, and we do not own the gralloc
133 * handle.
134 */
135 int dma_buf = gralloc_info->handle->data[0];
136
137 VkDeviceMemory memory_h;
138
139 const VkImportMemoryFdInfoKHR import_info = {
140 .sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR,
141 .handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT,
142 .fd = os_dupfd_cloexec(dma_buf),
143 };
144
145 /* Find the first VRAM memory type, or GART for PRIME images. */
146 int memory_type_index = -1;
147 for (int i = 0; i < device->physical_device->memory_properties.memoryTypeCount; ++i) {
148 bool is_local = !!(device->physical_device->memory_properties.memoryTypes[i].propertyFlags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
149 if (is_local) {
150 memory_type_index = i;
151 break;
152 }
153 }
154
155 /* fallback */
156 if (memory_type_index == -1)
157 memory_type_index = 0;
158
159 result = radv_AllocateMemory(device_h,
160 &(VkMemoryAllocateInfo) {
161 .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
162 .pNext = &import_info,
163 /* Max buffer size, unused for imports */
164 .allocationSize = 0x7FFFFFFF,
165 .memoryTypeIndex = memory_type_index,
166 },
167 alloc,
168 &memory_h);
169 if (result != VK_SUCCESS)
170 return result;
171
172 struct radeon_bo_metadata md;
173 device->ws->buffer_get_metadata(radv_device_memory_from_handle(memory_h)->bo, &md);
174
175 VkImageCreateInfo updated_base_info = *base_info;
176
177 VkExternalMemoryImageCreateInfo external_memory_info = {
178 .sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO,
179 .pNext = updated_base_info.pNext,
180 .handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT,
181 };
182
183 updated_base_info.pNext = &external_memory_info;
184
185 result = radv_image_create(device_h,
186 &(struct radv_image_create_info) {
187 .vk_info = &updated_base_info,
188 .no_metadata_planes = true,
189 .bo_metadata = &md,
190 },
191 alloc,
192 &image_h);
193
194 if (result != VK_SUCCESS)
195 goto fail_create_image;
196
197 image = radv_image_from_handle(image_h);
198
199 radv_image_override_offset_stride(device, image, 0, gralloc_info->stride);
200
201 radv_BindImageMemory(device_h, image_h, memory_h, 0);
202
203 image->owned_memory = memory_h;
204 /* Don't clobber the out-parameter until success is certain. */
205 *out_image_h = image_h;
206
207 return VK_SUCCESS;
208
209 fail_create_image:
210 radv_FreeMemory(device_h, memory_h, alloc);
211 return result;
212 }
213
214 VkResult radv_GetSwapchainGrallocUsageANDROID(
215 VkDevice device_h,
216 VkFormat format,
217 VkImageUsageFlags imageUsage,
218 int* grallocUsage)
219 {
220 RADV_FROM_HANDLE(radv_device, device, device_h);
221 struct radv_physical_device *phys_dev = device->physical_device;
222 VkPhysicalDevice phys_dev_h = radv_physical_device_to_handle(phys_dev);
223 VkResult result;
224
225 *grallocUsage = 0;
226
227 /* WARNING: Android Nougat's libvulkan.so hardcodes the VkImageUsageFlags
228 * returned to applications via VkSurfaceCapabilitiesKHR::supportedUsageFlags.
229 * The relevant code in libvulkan/swapchain.cpp contains this fun comment:
230 *
231 * TODO(jessehall): I think these are right, but haven't thought hard
232 * about it. Do we need to query the driver for support of any of
233 * these?
234 *
235 * Any disagreement between this function and the hardcoded
236 * VkSurfaceCapabilitiesKHR:supportedUsageFlags causes tests
237 * dEQP-VK.wsi.android.swapchain.*.image_usage to fail.
238 */
239
240 const VkPhysicalDeviceImageFormatInfo2 image_format_info = {
241 .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2,
242 .format = format,
243 .type = VK_IMAGE_TYPE_2D,
244 .tiling = VK_IMAGE_TILING_OPTIMAL,
245 .usage = imageUsage,
246 };
247
248 VkImageFormatProperties2 image_format_props = {
249 .sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2,
250 };
251
252 /* Check that requested format and usage are supported. */
253 result = radv_GetPhysicalDeviceImageFormatProperties2(phys_dev_h,
254 &image_format_info, &image_format_props);
255 if (result != VK_SUCCESS) {
256 return vk_errorf(device->instance, result,
257 "radv_GetPhysicalDeviceImageFormatProperties2 failed "
258 "inside %s", __func__);
259 }
260
261 if (unmask32(&imageUsage, VK_IMAGE_USAGE_TRANSFER_DST_BIT |
262 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT))
263 *grallocUsage |= GRALLOC_USAGE_HW_RENDER;
264
265 if (unmask32(&imageUsage, VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
266 VK_IMAGE_USAGE_SAMPLED_BIT |
267 VK_IMAGE_USAGE_STORAGE_BIT |
268 VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT))
269 *grallocUsage |= GRALLOC_USAGE_HW_TEXTURE;
270
271 /* All VkImageUsageFlags not explicitly checked here are unsupported for
272 * gralloc swapchains.
273 */
274 if (imageUsage != 0) {
275 return vk_errorf(device->instance, VK_ERROR_FORMAT_NOT_SUPPORTED,
276 "unsupported VkImageUsageFlags(0x%x) for gralloc "
277 "swapchain", imageUsage);
278 }
279
280 /*
281 * FINISHME: Advertise all display-supported formats. Mostly
282 * DRM_FORMAT_ARGB2101010 and DRM_FORMAT_ABGR2101010, but need to check
283 * what we need for 30-bit colors.
284 */
285 if (format == VK_FORMAT_B8G8R8A8_UNORM ||
286 format == VK_FORMAT_B5G6R5_UNORM_PACK16) {
287 *grallocUsage |= GRALLOC_USAGE_HW_FB |
288 GRALLOC_USAGE_HW_COMPOSER |
289 GRALLOC_USAGE_EXTERNAL_DISP;
290 }
291
292 if (*grallocUsage == 0)
293 return VK_ERROR_FORMAT_NOT_SUPPORTED;
294
295 return VK_SUCCESS;
296 }
297
298 VkResult radv_GetSwapchainGrallocUsage2ANDROID(
299 VkDevice device_h,
300 VkFormat format,
301 VkImageUsageFlags imageUsage,
302 VkSwapchainImageUsageFlagsANDROID swapchainImageUsage,
303 uint64_t* grallocConsumerUsage,
304 uint64_t* grallocProducerUsage)
305 {
306 /* Before level 26 (Android 8.0/Oreo) the loader uses
307 * vkGetSwapchainGrallocUsageANDROID. */
308 #if ANDROID_API_LEVEL >= 26
309 RADV_FROM_HANDLE(radv_device, device, device_h);
310 struct radv_physical_device *phys_dev = device->physical_device;
311 VkPhysicalDevice phys_dev_h = radv_physical_device_to_handle(phys_dev);
312 VkResult result;
313
314 *grallocConsumerUsage = 0;
315 *grallocProducerUsage = 0;
316
317 if (swapchainImageUsage & VK_SWAPCHAIN_IMAGE_USAGE_SHARED_BIT_ANDROID)
318 return vk_errorf(device->instance, VK_ERROR_FORMAT_NOT_SUPPORTED,
319 "The Vulkan loader tried to query shared presentable image support");
320
321 const VkPhysicalDeviceImageFormatInfo2 image_format_info = {
322 .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2,
323 .format = format,
324 .type = VK_IMAGE_TYPE_2D,
325 .tiling = VK_IMAGE_TILING_OPTIMAL,
326 .usage = imageUsage,
327 };
328
329 VkImageFormatProperties2 image_format_props = {
330 .sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2,
331 };
332
333 /* Check that requested format and usage are supported. */
334 result = radv_GetPhysicalDeviceImageFormatProperties2(phys_dev_h,
335 &image_format_info, &image_format_props);
336 if (result != VK_SUCCESS) {
337 return vk_errorf(device->instance, result,
338 "radv_GetPhysicalDeviceImageFormatProperties2 failed "
339 "inside %s", __func__);
340 }
341
342 if (unmask32(&imageUsage, VK_IMAGE_USAGE_TRANSFER_DST_BIT |
343 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT)) {
344 *grallocProducerUsage |= GRALLOC1_PRODUCER_USAGE_GPU_RENDER_TARGET;
345 *grallocConsumerUsage |= GRALLOC1_CONSUMER_USAGE_CLIENT_TARGET;
346 }
347
348 if (unmask32(&imageUsage, VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
349 VK_IMAGE_USAGE_SAMPLED_BIT |
350 VK_IMAGE_USAGE_STORAGE_BIT |
351 VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT)) {
352 *grallocConsumerUsage |= GRALLOC1_CONSUMER_USAGE_GPU_TEXTURE;
353 }
354
355 if (imageUsage != 0) {
356 return vk_errorf(device->instance, VK_ERROR_FORMAT_NOT_SUPPORTED,
357 "unsupported VkImageUsageFlags(0x%x) for gralloc "
358 "swapchain", imageUsage);
359 }
360
361 /*
362 * FINISHME: Advertise all display-supported formats. Mostly
363 * DRM_FORMAT_ARGB2101010 and DRM_FORMAT_ABGR2101010, but need to check
364 * what we need for 30-bit colors.
365 */
366 if (format == VK_FORMAT_B8G8R8A8_UNORM ||
367 format == VK_FORMAT_B5G6R5_UNORM_PACK16) {
368 *grallocProducerUsage |= GRALLOC1_PRODUCER_USAGE_GPU_RENDER_TARGET;
369 *grallocConsumerUsage |= GRALLOC1_CONSUMER_USAGE_HWCOMPOSER;
370 }
371
372 if (!*grallocProducerUsage && !*grallocConsumerUsage)
373 return VK_ERROR_FORMAT_NOT_SUPPORTED;
374
375 return VK_SUCCESS;
376 #else
377 *grallocConsumerUsage = 0;
378 *grallocProducerUsage = 0;
379 return VK_ERROR_FORMAT_NOT_SUPPORTED;
380 #endif
381 }
382
383 VkResult
384 radv_AcquireImageANDROID(
385 VkDevice device,
386 VkImage image_h,
387 int nativeFenceFd,
388 VkSemaphore semaphore,
389 VkFence fence)
390 {
391 VkResult semaphore_result = VK_SUCCESS, fence_result = VK_SUCCESS;
392
393 if (semaphore != VK_NULL_HANDLE) {
394 int semaphore_fd = nativeFenceFd >= 0 ? os_dupfd_cloexec(nativeFenceFd) : nativeFenceFd;
395 semaphore_result = radv_ImportSemaphoreFdKHR(device,
396 &(VkImportSemaphoreFdInfoKHR) {
397 .sType = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR,
398 .flags = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT,
399 .fd = semaphore_fd,
400 .semaphore = semaphore,
401 .handleType = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT,
402 });
403 }
404
405 if (fence != VK_NULL_HANDLE) {
406 int fence_fd = nativeFenceFd >= 0 ? os_dupfd_cloexec(nativeFenceFd) : nativeFenceFd;
407 fence_result = radv_ImportFenceFdKHR(device,
408 &(VkImportFenceFdInfoKHR) {
409 .sType = VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR,
410 .flags = VK_FENCE_IMPORT_TEMPORARY_BIT,
411 .fd = fence_fd,
412 .fence = fence,
413 .handleType = VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT,
414 });
415 }
416
417 close(nativeFenceFd);
418
419 if (semaphore_result != VK_SUCCESS)
420 return semaphore_result;
421 return fence_result;
422 }
423
424 VkResult
425 radv_QueueSignalReleaseImageANDROID(
426 VkQueue _queue,
427 uint32_t waitSemaphoreCount,
428 const VkSemaphore* pWaitSemaphores,
429 VkImage image,
430 int* pNativeFenceFd)
431 {
432 RADV_FROM_HANDLE(radv_queue, queue, _queue);
433 VkResult result = VK_SUCCESS;
434
435 if (waitSemaphoreCount == 0) {
436 if (pNativeFenceFd)
437 *pNativeFenceFd = -1;
438 return VK_SUCCESS;
439 }
440
441 int fd = -1;
442
443 for (uint32_t i = 0; i < waitSemaphoreCount; ++i) {
444 int tmp_fd;
445 result = radv_GetSemaphoreFdKHR(radv_device_to_handle(queue->device),
446 &(VkSemaphoreGetFdInfoKHR) {
447 .sType = VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR,
448 .handleType = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT,
449 .semaphore = pWaitSemaphores[i],
450 }, &tmp_fd);
451 if (result != VK_SUCCESS) {
452 if (fd >= 0)
453 close (fd);
454 return result;
455 }
456
457 if (fd < 0)
458 fd = tmp_fd;
459 else if (tmp_fd >= 0) {
460 sync_accumulate("radv", &fd, tmp_fd);
461 close(tmp_fd);
462 }
463 }
464
465 if (pNativeFenceFd) {
466 *pNativeFenceFd = fd;
467 } else if (fd >= 0) {
468 close(fd);
469 /* We still need to do the exports, to reset the semaphores, but
470 * otherwise we don't wait on them. */
471 }
472 return VK_SUCCESS;
473 }
474 #endif
475
476 #if RADV_SUPPORT_ANDROID_HARDWARE_BUFFER
477
478 enum {
479 /* Usage bit equal to GRALLOC_USAGE_HW_CAMERA_MASK */
480 AHARDWAREBUFFER_USAGE_CAMERA_MASK = 0x00060000U,
481 };
482
483 static inline VkFormat
484 vk_format_from_android(unsigned android_format, unsigned android_usage)
485 {
486 switch (android_format) {
487 case AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM:
488 case AHARDWAREBUFFER_FORMAT_R8G8B8X8_UNORM:
489 return VK_FORMAT_R8G8B8A8_UNORM;
490 case AHARDWAREBUFFER_FORMAT_R8G8B8_UNORM:
491 return VK_FORMAT_R8G8B8_UNORM;
492 case AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM:
493 return VK_FORMAT_R5G6B5_UNORM_PACK16;
494 case AHARDWAREBUFFER_FORMAT_R16G16B16A16_FLOAT:
495 return VK_FORMAT_R16G16B16A16_SFLOAT;
496 case AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM:
497 return VK_FORMAT_A2B10G10R10_UNORM_PACK32;
498 case AHARDWAREBUFFER_FORMAT_Y8Cb8Cr8_420:
499 return VK_FORMAT_G8_B8R8_2PLANE_420_UNORM;
500 case AHARDWAREBUFFER_FORMAT_IMPLEMENTATION_DEFINED:
501 if (android_usage & AHARDWAREBUFFER_USAGE_CAMERA_MASK)
502 return VK_FORMAT_G8_B8R8_2PLANE_420_UNORM;
503 else
504 return VK_FORMAT_R8G8B8_UNORM;
505 case AHARDWAREBUFFER_FORMAT_BLOB:
506 default:
507 return VK_FORMAT_UNDEFINED;
508 }
509 }
510
511 static inline unsigned
512 android_format_from_vk(unsigned vk_format)
513 {
514 switch (vk_format) {
515 case VK_FORMAT_R8G8B8A8_UNORM:
516 return AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM;
517 case VK_FORMAT_R8G8B8_UNORM:
518 return AHARDWAREBUFFER_FORMAT_R8G8B8_UNORM;
519 case VK_FORMAT_R5G6B5_UNORM_PACK16:
520 return AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM;
521 case VK_FORMAT_R16G16B16A16_SFLOAT:
522 return AHARDWAREBUFFER_FORMAT_R16G16B16A16_FLOAT;
523 case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
524 return AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM;
525 case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
526 return AHARDWAREBUFFER_FORMAT_Y8Cb8Cr8_420;
527 default:
528 return AHARDWAREBUFFER_FORMAT_BLOB;
529 }
530 }
531
532 uint64_t
533 radv_ahb_usage_from_vk_usage(const VkImageCreateFlags vk_create,
534 const VkImageUsageFlags vk_usage)
535 {
536 uint64_t ahb_usage = 0;
537 if (vk_usage & VK_IMAGE_USAGE_SAMPLED_BIT)
538 ahb_usage |= AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE;
539
540 if (vk_usage & VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT)
541 ahb_usage |= AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE;
542
543 if (vk_usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT)
544 ahb_usage |= AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT;
545
546 if (vk_create & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT)
547 ahb_usage |= AHARDWAREBUFFER_USAGE_GPU_CUBE_MAP;
548
549 if (vk_create & VK_IMAGE_CREATE_PROTECTED_BIT)
550 ahb_usage |= AHARDWAREBUFFER_USAGE_PROTECTED_CONTENT;
551
552 /* No usage bits set - set at least one GPU usage. */
553 if (ahb_usage == 0)
554 ahb_usage = AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE;
555 return ahb_usage;
556 }
557
558 static VkResult
559 get_ahb_buffer_format_properties(
560 VkDevice device_h,
561 const struct AHardwareBuffer *buffer,
562 VkAndroidHardwareBufferFormatPropertiesANDROID *pProperties)
563 {
564 RADV_FROM_HANDLE(radv_device, device, device_h);
565
566 /* Get a description of buffer contents . */
567 AHardwareBuffer_Desc desc;
568 AHardwareBuffer_describe(buffer, &desc);
569
570 /* Verify description. */
571 const uint64_t gpu_usage =
572 AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE |
573 AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT |
574 AHARDWAREBUFFER_USAGE_GPU_DATA_BUFFER;
575
576 /* "Buffer must be a valid Android hardware buffer object with at least
577 * one of the AHARDWAREBUFFER_USAGE_GPU_* usage flags."
578 */
579 if (!(desc.usage & (gpu_usage)))
580 return VK_ERROR_INVALID_EXTERNAL_HANDLE;
581
582 /* Fill properties fields based on description. */
583 VkAndroidHardwareBufferFormatPropertiesANDROID *p = pProperties;
584
585 p->format = vk_format_from_android(desc.format, desc.usage);
586 p->externalFormat = (uint64_t) (uintptr_t) p->format;
587
588 VkFormatProperties format_properties;
589 radv_GetPhysicalDeviceFormatProperties(
590 radv_physical_device_to_handle(device->physical_device),
591 p->format, &format_properties);
592
593 if (desc.usage & AHARDWAREBUFFER_USAGE_GPU_DATA_BUFFER)
594 p->formatFeatures = format_properties.linearTilingFeatures;
595 else
596 p->formatFeatures = format_properties.optimalTilingFeatures;
597
598 /* "Images can be created with an external format even if the Android hardware
599 * buffer has a format which has an equivalent Vulkan format to enable
600 * consistent handling of images from sources that might use either category
601 * of format. However, all images created with an external format are subject
602 * to the valid usage requirements associated with external formats, even if
603 * the Android hardware buffer’s format has a Vulkan equivalent."
604 *
605 * "The formatFeatures member *must* include
606 * VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT and at least one of
607 * VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT or
608 * VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT"
609 */
610 assert(p->formatFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT);
611
612 p->formatFeatures |= VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT;
613
614 /* "Implementations may not always be able to determine the color model,
615 * numerical range, or chroma offsets of the image contents, so the values
616 * in VkAndroidHardwareBufferFormatPropertiesANDROID are only suggestions.
617 * Applications should treat these values as sensible defaults to use in
618 * the absence of more reliable information obtained through some other
619 * means."
620 */
621 p->samplerYcbcrConversionComponents.r = VK_COMPONENT_SWIZZLE_IDENTITY;
622 p->samplerYcbcrConversionComponents.g = VK_COMPONENT_SWIZZLE_IDENTITY;
623 p->samplerYcbcrConversionComponents.b = VK_COMPONENT_SWIZZLE_IDENTITY;
624 p->samplerYcbcrConversionComponents.a = VK_COMPONENT_SWIZZLE_IDENTITY;
625
626 p->suggestedYcbcrModel = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601;
627 p->suggestedYcbcrRange = VK_SAMPLER_YCBCR_RANGE_ITU_FULL;
628
629 p->suggestedXChromaOffset = VK_CHROMA_LOCATION_MIDPOINT;
630 p->suggestedYChromaOffset = VK_CHROMA_LOCATION_MIDPOINT;
631
632 return VK_SUCCESS;
633 }
634
635 VkResult
636 radv_GetAndroidHardwareBufferPropertiesANDROID(
637 VkDevice device_h,
638 const struct AHardwareBuffer *buffer,
639 VkAndroidHardwareBufferPropertiesANDROID *pProperties)
640 {
641 RADV_FROM_HANDLE(radv_device, dev, device_h);
642 struct radv_physical_device *pdevice = dev->physical_device;
643
644 VkAndroidHardwareBufferFormatPropertiesANDROID *format_prop =
645 vk_find_struct(pProperties->pNext,
646 ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID);
647
648 /* Fill format properties of an Android hardware buffer. */
649 if (format_prop)
650 get_ahb_buffer_format_properties(device_h, buffer, format_prop);
651
652 /* NOTE - We support buffers with only one handle but do not error on
653 * multiple handle case. Reason is that we want to support YUV formats
654 * where we have many logical planes but they all point to the same
655 * buffer, like is the case with VK_FORMAT_G8_B8R8_2PLANE_420_UNORM.
656 */
657 const native_handle_t *handle =
658 AHardwareBuffer_getNativeHandle(buffer);
659 int dma_buf = (handle && handle->numFds) ? handle->data[0] : -1;
660 if (dma_buf < 0)
661 return VK_ERROR_INVALID_EXTERNAL_HANDLE;
662
663 /* All memory types. */
664 uint32_t memory_types = (1u << pdevice->memory_properties.memoryTypeCount) - 1;
665
666 pProperties->allocationSize = lseek(dma_buf, 0, SEEK_END);
667 pProperties->memoryTypeBits = memory_types;
668
669 return VK_SUCCESS;
670 }
671
672 VkResult
673 radv_GetMemoryAndroidHardwareBufferANDROID(
674 VkDevice device_h,
675 const VkMemoryGetAndroidHardwareBufferInfoANDROID *pInfo,
676 struct AHardwareBuffer **pBuffer)
677 {
678 RADV_FROM_HANDLE(radv_device_memory, mem, pInfo->memory);
679
680 /* This should always be set due to the export handle types being set on
681 * allocation. */
682 assert(mem->android_hardware_buffer);
683
684 /* Some quotes from Vulkan spec:
685 *
686 * "If the device memory was created by importing an Android hardware
687 * buffer, vkGetMemoryAndroidHardwareBufferANDROID must return that same
688 * Android hardware buffer object."
689 *
690 * "VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID must
691 * have been included in VkExportMemoryAllocateInfo::handleTypes when
692 * memory was created."
693 */
694 *pBuffer = mem->android_hardware_buffer;
695 /* Increase refcount. */
696 AHardwareBuffer_acquire(mem->android_hardware_buffer);
697 return VK_SUCCESS;
698 }
699
700 #endif
701
702 VkFormat
703 radv_select_android_external_format(const void *next, VkFormat default_format)
704 {
705 #if RADV_SUPPORT_ANDROID_HARDWARE_BUFFER
706 const VkExternalFormatANDROID *android_format =
707 vk_find_struct_const(next, EXTERNAL_FORMAT_ANDROID);
708
709 if (android_format && android_format->externalFormat) {
710 return (VkFormat)android_format->externalFormat;
711 }
712 #endif
713
714 return default_format;
715 }
716
717
718 VkResult
719 radv_import_ahb_memory(struct radv_device *device,
720 struct radv_device_memory *mem,
721 unsigned priority,
722 const VkImportAndroidHardwareBufferInfoANDROID *info)
723 {
724 #if RADV_SUPPORT_ANDROID_HARDWARE_BUFFER
725 /* Import from AHardwareBuffer to radv_device_memory. */
726 const native_handle_t *handle =
727 AHardwareBuffer_getNativeHandle(info->buffer);
728
729 /* NOTE - We support buffers with only one handle but do not error on
730 * multiple handle case. Reason is that we want to support YUV formats
731 * where we have many logical planes but they all point to the same
732 * buffer, like is the case with VK_FORMAT_G8_B8R8_2PLANE_420_UNORM.
733 */
734 int dma_buf = (handle && handle->numFds) ? handle->data[0] : -1;
735 if (dma_buf < 0)
736 return VK_ERROR_INVALID_EXTERNAL_HANDLE;
737
738 uint64_t alloc_size = 0;
739 mem->bo = device->ws->buffer_from_fd(device->ws, dma_buf,
740 priority, &alloc_size);
741 if (!mem->bo)
742 return VK_ERROR_OUT_OF_HOST_MEMORY;
743
744 if (mem->image) {
745 struct radeon_bo_metadata metadata;
746 device->ws->buffer_get_metadata(mem->bo, &metadata);
747
748 struct radv_image_create_info create_info = {
749 .no_metadata_planes = true,
750 .bo_metadata = &metadata
751 };
752
753 VkResult result = radv_image_create_layout(device, create_info, mem->image);
754 if (result != VK_SUCCESS) {
755 device->ws->buffer_destroy(mem->bo);
756 mem->bo = NULL;
757 return result;
758 }
759
760 if (alloc_size < mem->image->size) {
761 device->ws->buffer_destroy(mem->bo);
762 mem->bo = NULL;
763 return VK_ERROR_INVALID_EXTERNAL_HANDLE;
764 }
765 } else if (mem->buffer) {
766 if (alloc_size < mem->buffer->size) {
767 device->ws->buffer_destroy(mem->bo);
768 mem->bo = NULL;
769 return VK_ERROR_INVALID_EXTERNAL_HANDLE;
770 }
771 }
772
773 /* "If the vkAllocateMemory command succeeds, the implementation must
774 * acquire a reference to the imported hardware buffer, which it must
775 * release when the device memory object is freed. If the command fails,
776 * the implementation must not retain a reference."
777 */
778 AHardwareBuffer_acquire(info->buffer);
779 mem->android_hardware_buffer = info->buffer;
780
781 return VK_SUCCESS;
782 #else /* RADV_SUPPORT_ANDROID_HARDWARE_BUFFER */
783 return VK_ERROR_EXTENSION_NOT_PRESENT;
784 #endif
785 }
786
787 VkResult
788 radv_create_ahb_memory(struct radv_device *device,
789 struct radv_device_memory *mem,
790 unsigned priority,
791 const VkMemoryAllocateInfo *pAllocateInfo)
792 {
793 #if RADV_SUPPORT_ANDROID_HARDWARE_BUFFER
794 const VkMemoryDedicatedAllocateInfo *dedicated_info =
795 vk_find_struct_const(pAllocateInfo->pNext,
796 MEMORY_DEDICATED_ALLOCATE_INFO);
797
798 uint32_t w = 0;
799 uint32_t h = 1;
800 uint32_t layers = 1;
801 uint32_t format = 0;
802 uint64_t usage = 0;
803
804 /* If caller passed dedicated information. */
805 if (dedicated_info && dedicated_info->image) {
806 RADV_FROM_HANDLE(radv_image, image, dedicated_info->image);
807 w = image->info.width;
808 h = image->info.height;
809 layers = image->info.array_size;
810 format = android_format_from_vk(image->vk_format);
811 usage = radv_ahb_usage_from_vk_usage(image->flags, image->usage);
812 } else if (dedicated_info && dedicated_info->buffer) {
813 RADV_FROM_HANDLE(radv_buffer, buffer, dedicated_info->buffer);
814 w = buffer->size;
815 format = AHARDWAREBUFFER_FORMAT_BLOB;
816 usage = AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN |
817 AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN;
818 } else {
819 w = pAllocateInfo->allocationSize;
820 format = AHARDWAREBUFFER_FORMAT_BLOB;
821 usage = AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN |
822 AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN;
823 }
824
825 struct AHardwareBuffer *android_hardware_buffer = NULL;
826 struct AHardwareBuffer_Desc desc = {
827 .width = w,
828 .height = h,
829 .layers = layers,
830 .format = format,
831 .usage = usage,
832 };
833
834 if (AHardwareBuffer_allocate(&desc, &android_hardware_buffer) != 0)
835 return VK_ERROR_OUT_OF_HOST_MEMORY;
836
837 mem->android_hardware_buffer = android_hardware_buffer;
838
839 const struct VkImportAndroidHardwareBufferInfoANDROID import_info = {
840 .buffer = mem->android_hardware_buffer,
841 };
842
843 VkResult result = radv_import_ahb_memory(device, mem, priority, &import_info);
844 if (result != VK_SUCCESS)
845 AHardwareBuffer_release(mem->android_hardware_buffer);
846 return result;
847 #else /* RADV_SUPPORT_ANDROID_HARDWARE_BUFFER */
848 return VK_ERROR_EXTENSION_NOT_PRESENT;
849 #endif
850 }
851
852 bool radv_android_gralloc_supports_format(VkFormat format, VkImageUsageFlagBits usage) {
853 #if RADV_SUPPORT_ANDROID_HARDWARE_BUFFER
854 /* Ideally we check Gralloc for what it supports and then merge that with the radv
855 format support, but there is no easy gralloc query besides just creating an image.
856 That seems a bit on the expensive side, so just hardcode for now. */
857 /* TODO: Add multi-plane formats after confirming everything works between radeonsi
858 and radv. */
859 switch(format) {
860 case VK_FORMAT_R8G8B8A8_UNORM:
861 case VK_FORMAT_R5G6B5_UNORM_PACK16:
862 return true;
863 case VK_FORMAT_R8_UNORM:
864 case VK_FORMAT_R8G8_UNORM:
865 return !(usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT);
866 default:
867 return false;
868 }
869 #else
870 (void)format;
871 (void)usage;
872 return false;
873 #endif
874 }