[Mesa-dev] [PATCH] anv: Implement VK_ANDROID_native_buffer (v8.1)
Chad Versace
chad at kiwitree.net
Fri Sep 29 23:54:10 UTC 2017
This implementation is correct (afaict), but takes two shortcuts
regarding the import/export of Android sync fds.
Shortcut 1. When Android calls vkAcquireImageANDROID to import a sync
fd into a VkSemaphore or VkFence, the driver instead simply blocks on
the sync fd, then puts the VkSemaphore or VkFence into the signalled
state. Thanks to implicit sync, this produces correct behavior (with
extra latency overhead, perhaps) despite its ugliness.
Shortcut 2. When Android calls vkQueueSignalReleaseImageANDROID to export
a collection of wait semaphores as a sync fd, the driver instead
submits the semaphores to the queue, then returns sync fd -1, which
informs the caller that no additional synchronization is needed.
Again, thanks to implicit sync, this produces correct behavior (with
extra batch submission overhead) despite its ugliness.
I chose to take the shortcuts instead of properly importing/exporting
the sync fds for two reasons:
Reason 1. I've already tested this patch with dEQP and with demos
apps. It works. I wanted to get the tested patches into the tree now,
and polish the implementation afterwards.
Reason 2. I want to run this on a 3.18 kernel (gasp!). In 3.18, i915
supports neither Android's sync_fence, nor upstream's sync_file, nor
drm_syncobj. Again, I tested these patches on Android with a 3.18
kernel and they work.
I plan to quickly follow-up with patches that remove the shortcuts and
properly import/export the sync fds.
Non-Testing
===========
I did not test at all using the Android.mk buildsystem. I probably
broke it. Please test and review that.
Testing
=======
I tested with 64-bit ARC++ on a Skylake Chromebook and a 3.18 kernel.
The following pass (as of patchset v7):
a little spinning cube demo APK
dEQP-VK.info.*
dEQP-VK.api.smoke.*
dEQP-VK.api.info.instance.*
dEQP-VK.api.info.device.*
dEQP-VK.api.wsi.android.*
except dEQP-VK.api.wsi.android.swapchain.*.image_usage, because
dEQP wants to create swapchains with VK_IMAGE_USAGE_STORAGE_BIT.
v2:
- Reject VkNativeBufferANDROID if the dma-buf's size is too small for
the VkImage.
- Stop abusing VkNativeBufferANDROID by passing it to vkAllocateMemory
during vkCreateImage. Instead, directly import its dma-buf during
vkCreateImage with anv_bo_cache_import(). [for jekstrand]
- Rebase onto Tapani's VK_EXT_debug_report changes.
- Drop `CPPFLAGS += $(top_srcdir)/include/android`. The dir does not
exist.
v3:
- Delete duplicate #include "anv_private.h". [per Tapani]
- Try to fix the Android-IA build in Android.vulkan.mk by following
Tapani's example.
v4:
- Unset EXEC_OBJECT_ASYNC and set EXEC_OBJECT_WRITE on the imported
gralloc buffer, just as we do for all other winsys buffers in
anv_wsi.c. [found by Tapani]
v5:
- Really fix the Android-IA build by ensuring that Android.vulkan.mk
uses Mesa' vulkan.h and not Android's. Insert -I$(MESA_TOP)/include
before -Iframeworks/native/vulkan/include. [for Tapani]
- In vkAcquireImageANDROID, submit signal operations to the
VkSemaphore and VkFence. [for zhou]
v6:
- Drop copy-paste duplication in vkGetSwapchainGrallocUsageANDROID().
[found by zhou]
- Improve comments in vkGetSwapchainGrallocUsageANDROID().
v7:
- Fix vkGetSwapchainGrallocUsageANDROID() to inspect its
VkImageUsageFlags parameter. [for tfiga]
- This fix regresses dEQP-VK.api.wsi.android.swapchain.*.image_usage
because dEQP wants to create swapchains with
VK_IMAGE_USAGE_STORAGE_BIT.
v8:
- Drop unneeded goto in vkAcquireImageANDROID. [for tfiga]
v8.1: (minor changes)
- Drop errant hunks added by rerere in anv_device.c.
- Drop explicit mention of VK_ANDROID_native_buffer in
anv_entrypoints_gen.py. [for jekstrand]
Reviewed-by: Tapani Pälli <tapani.palli at intel.com> (v5)
Cc: Jason Ekstrand <jason at jlekstrand.net>
Cc: zhoucm1 <david1.zhou at amd.com>
Cc: Tomasz Figa <tfiga at chromium.org>
---
src/intel/Android.vulkan.mk | 7 +-
src/intel/Makefile.sources | 3 +
src/intel/Makefile.vulkan.am | 2 +
src/intel/vulkan/anv_android.c | 300 ++++++++++++++++++++++++++++++++
src/intel/vulkan/anv_entrypoints_gen.py | 4 +-
src/intel/vulkan/anv_extensions.py | 1 +
src/intel/vulkan/anv_image.c | 147 ++++++++++++++--
src/intel/vulkan/anv_private.h | 1 +
8 files changed, 452 insertions(+), 13 deletions(-)
create mode 100644 src/intel/vulkan/anv_android.c
diff --git a/src/intel/Android.vulkan.mk b/src/intel/Android.vulkan.mk
index e20b32b87c5..b2d7d4e46c5 100644
--- a/src/intel/Android.vulkan.mk
+++ b/src/intel/Android.vulkan.mk
@@ -28,6 +28,7 @@ VK_ENTRYPOINTS_SCRIPT := $(MESA_PYTHON2) $(LOCAL_PATH)/vulkan/anv_entrypoints_ge
VK_EXTENSIONS_SCRIPT := $(MESA_PYTHON2) $(LOCAL_PATH)/vulkan/anv_extensions.py
VULKAN_COMMON_INCLUDES := \
+ $(MESA_TOP)/include \
$(MESA_TOP)/src/mapi \
$(MESA_TOP)/src/gallium/auxiliary \
$(MESA_TOP)/src/gallium/include \
@@ -36,7 +37,8 @@ VULKAN_COMMON_INCLUDES := \
$(MESA_TOP)/src/vulkan/util \
$(MESA_TOP)/src/intel \
$(MESA_TOP)/include/drm-uapi \
- $(MESA_TOP)/src/intel/vulkan
+ $(MESA_TOP)/src/intel/vulkan \
+ frameworks/native/vulkan/include
# libmesa_anv_entrypoints with header and dummy.c
#
@@ -254,7 +256,8 @@ LOCAL_CFLAGS := -DLOG_TAG=\"INTEL-MESA\"
LOCAL_LDFLAGS += -Wl,--build-id=sha1
LOCAL_SRC_FILES := \
- $(VULKAN_GEM_FILES)
+ $(VULKAN_GEM_FILES) \
+ $(VULKAN_ANDROID_FILES)
LOCAL_C_INCLUDES := \
$(VULKAN_COMMON_INCLUDES) \
diff --git a/src/intel/Makefile.sources b/src/intel/Makefile.sources
index 64a2dfe10e7..a625e96df79 100644
--- a/src/intel/Makefile.sources
+++ b/src/intel/Makefile.sources
@@ -230,6 +230,9 @@ VULKAN_FILES := \
vulkan/anv_wsi.c \
vulkan/vk_format_info.h
+VULKAN_ANDROID_FILES := \
+ vulkan/anv_android.c
+
VULKAN_WSI_WAYLAND_FILES := \
vulkan/anv_wsi_wayland.c
diff --git a/src/intel/Makefile.vulkan.am b/src/intel/Makefile.vulkan.am
index 0f488fc9f63..811faab556e 100644
--- a/src/intel/Makefile.vulkan.am
+++ b/src/intel/Makefile.vulkan.am
@@ -147,8 +147,10 @@ VULKAN_LIB_DEPS = \
-lm
if HAVE_PLATFORM_ANDROID
+VULKAN_CPPFLAGS += $(ANDROID_CPPFLAGS)
VULKAN_CFLAGS += $(ANDROID_CFLAGS)
VULKAN_LIB_DEPS += $(ANDROID_LIBS)
+VULKAN_SOURCES += $(VULKAN_ANDROID_FILES)
endif
if HAVE_PLATFORM_X11
diff --git a/src/intel/vulkan/anv_android.c b/src/intel/vulkan/anv_android.c
new file mode 100644
index 00000000000..092d27ded91
--- /dev/null
+++ b/src/intel/vulkan/anv_android.c
@@ -0,0 +1,300 @@
+/*
+ * Copyright 2017 Google
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#include <hardware/gralloc.h>
+#include <hardware/hardware.h>
+#include <hardware/hwvulkan.h>
+#include <vulkan/vk_android_native_buffer.h>
+#include <vulkan/vk_icd.h>
+#include <sync/sync.h>
+
+#include "anv_private.h"
+
+static int anv_hal_open(const struct hw_module_t* mod, const char* id, struct hw_device_t** dev);
+static int anv_hal_close(struct hw_device_t *dev);
+
+static void UNUSED
+static_asserts(void)
+{
+ STATIC_ASSERT(HWVULKAN_DISPATCH_MAGIC == ICD_LOADER_MAGIC);
+}
+
+PUBLIC struct hwvulkan_module_t HAL_MODULE_INFO_SYM = {
+ .common = {
+ .tag = HARDWARE_MODULE_TAG,
+ .module_api_version = HWVULKAN_MODULE_API_VERSION_0_1,
+ .hal_api_version = HARDWARE_MAKE_API_VERSION(1, 0),
+ .id = HWVULKAN_HARDWARE_MODULE_ID,
+ .name = "Intel Vulkan HAL",
+ .author = "Intel",
+ .methods = &(hw_module_methods_t) {
+ .open = anv_hal_open,
+ },
+ },
+};
+
+static int
+anv_hal_open(const struct hw_module_t* mod, const char* id,
+ struct hw_device_t** dev)
+{
+ assert(mod == &HAL_MODULE_INFO_SYM.common);
+ assert(strcmp(id, HWVULKAN_DEVICE_0) == 0);
+
+ hwvulkan_device_t *vkdev = malloc(sizeof(*vkdev));
+ if (!vkdev)
+ return -1;
+
+ *vkdev = (hwvulkan_device_t) {
+ .common = {
+ .tag = HARDWARE_DEVICE_TAG,
+ .version = HWVULKAN_DEVICE_API_VERSION_0_1,
+ .module = &HAL_MODULE_INFO_SYM.common,
+ .close = anv_hal_close,
+ },
+ .EnumerateInstanceExtensionProperties = anv_EnumerateInstanceExtensionProperties,
+ .CreateInstance = anv_CreateInstance,
+ .GetInstanceProcAddr = anv_GetInstanceProcAddr,
+ };
+
+ *dev = &vkdev->common;
+ return 0;
+}
+
+static int
+anv_hal_close(struct hw_device_t *dev)
+{
+ /* hwvulkan.h claims that hw_device_t::close() is never called. */
+ return -1;
+}
+
+/* If any bits in test_mask are set, then unset them and return true. */
+static inline bool
+unmask32(uint32_t *inout_mask, uint32_t test_mask)
+{
+ uint32_t orig_mask = *inout_mask;
+ *inout_mask &= ~test_mask;
+ return *inout_mask != orig_mask;
+}
+
+VkResult anv_GetSwapchainGrallocUsageANDROID(
+ VkDevice device_h,
+ VkFormat format,
+ VkImageUsageFlags imageUsage,
+ int* grallocUsage)
+{
+ ANV_FROM_HANDLE(anv_device, device, device_h);
+ struct anv_physical_device *phys_dev = &device->instance->physicalDevice;
+ VkPhysicalDevice phys_dev_h = anv_physical_device_to_handle(phys_dev);
+ VkResult result;
+
+ *grallocUsage = 0;
+ intel_logd("%s: format=%d, usage=0x%x", __func__, format, imageUsage);
+
+ /* WARNING: Android Nougat's libvulkan.so hardcodes the VkImageUsageFlags
+ * returned to applications via VkSurfaceCapabilitiesKHR::supportedUsageFlags.
+ * The relevant code in libvulkan/swapchain.cpp contains this fun comment:
+ *
+ * TODO(jessehall): I think these are right, but haven't thought hard
+ * about it. Do we need to query the driver for support of any of
+ * these?
+ *
+ * Yes, Jesse. You should query the driver ;)
+ *
+ * Any disagreement between this function and the hardcoded
+ * VkSurfaceCapabilitiesKHR:supportedUsageFlags causes tests
+ * dEQP-VK.wsi.android.swapchain.*.image_usage to fail.
+ */
+
+ const VkPhysicalDeviceImageFormatInfo2KHR image_format_info = {
+ .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR,
+ .format = format,
+ .type = VK_IMAGE_TYPE_2D,
+ .tiling = VK_IMAGE_TILING_OPTIMAL,
+ .usage = imageUsage,
+ };
+
+ VkImageFormatProperties2KHR image_format_props = {
+ .sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR,
+ };
+
+ /* Check that requested format and usage are supported. */
+ result = anv_GetPhysicalDeviceImageFormatProperties2KHR(phys_dev_h,
+ &image_format_info, &image_format_props);
+ if (result != VK_SUCCESS) {
+ intel_loge("anv_GetPhysicalDeviceImageFormatProperties2KHR failed "
+ "inside %s", __func__);
+ return result;
+ }
+
+ /* Reject STORAGE here to avoid complexity elsewhere. */
+ if (imageUsage & VK_IMAGE_USAGE_STORAGE_BIT) {
+ return vk_errorf(device->instance, device, VK_ERROR_FORMAT_NOT_SUPPORTED,
+ "VK_IMAGE_USAGE_STORAGE_BIT unsupported for gralloc "
+ "swapchain");
+ }
+
+ if (unmask32(&imageUsage, VK_IMAGE_USAGE_TRANSFER_DST_BIT |
+ VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT))
+ *grallocUsage |= GRALLOC_USAGE_HW_RENDER;
+
+ if (unmask32(&imageUsage, VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
+ VK_IMAGE_USAGE_SAMPLED_BIT |
+ VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT))
+ *grallocUsage |= GRALLOC_USAGE_HW_TEXTURE;
+
+ /* All VkImageUsageFlags not explicitly checked here are unsupported for
+ * gralloc swapchains.
+ */
+ if (imageUsage != 0) {
+ return vk_errorf(device->instance, device, VK_ERROR_FORMAT_NOT_SUPPORTED,
+ "unsupported VkImageUsageFlags(0x%x) for gralloc "
+ "swapchain", imageUsage);
+ }
+
+ /* The below formats support GRALLOC_USAGE_HW_FB (that is, display
+ * scanout). This short list of formats is univserally supported on Intel
+ * but is incomplete. The full set of supported formats is dependent on
+ * kernel and hardware.
+ *
+ * FINISHME: Advertise all display-supported formats.
+ */
+ if (format == VK_FORMAT_B8G8R8A8_UNORM ||
+ format == VK_FORMAT_B5G6R5_UNORM_PACK16) {
+ *grallocUsage |= GRALLOC_USAGE_HW_FB |
+ GRALLOC_USAGE_HW_COMPOSER |
+ GRALLOC_USAGE_EXTERNAL_DISP;
+ }
+
+ if (*grallocUsage == 0)
+ return VK_ERROR_FORMAT_NOT_SUPPORTED;
+
+ return VK_SUCCESS;
+}
+
+VkResult
+anv_AcquireImageANDROID(
+ VkDevice device_h,
+ VkImage image_h,
+ int nativeFenceFd,
+ VkSemaphore semaphore_h,
+ VkFence fence_h)
+{
+ ANV_FROM_HANDLE(anv_device, device, device_h);
+ VkResult result = VK_SUCCESS;
+
+ if (nativeFenceFd != -1) {
+ /* As a simple, firstpass implementation of VK_ANDROID_native_buffer, we
+ * block on the nativeFenceFd. This may introduce latency and is
+ * definitiely inefficient, yet it's correct.
+ *
+ * FINISHME(chadv): Import the nativeFenceFd into the VkSemaphore and
+ * VkFence.
+ */
+ if (sync_wait(nativeFenceFd, /*timeout*/ -1) < 0) {
+ result = vk_errorf(device->instance, device, VK_ERROR_DEVICE_LOST,
+ "%s: failed to wait on nativeFenceFd=%d",
+ __func__, nativeFenceFd);
+ }
+
+ /* From VK_ANDROID_native_buffer's pseudo spec
+ * (https://source.android.com/devices/graphics/implement-vulkan):
+ *
+ * The driver takes ownership of the fence fd and is responsible for
+ * closing it [...] even if vkAcquireImageANDROID fails and returns
+ * an error.
+ */
+ close(nativeFenceFd);
+
+ if (result != VK_SUCCESS)
+ return result;
+ }
+
+ if (semaphore_h || fence_h) {
+ /* Thanks to implicit sync, the image is ready for GPU access. But we
+ * must still put the semaphore into the "submit" state; otherwise the
+ * client may get unexpected behavior if the client later uses it as
+ * a wait semaphore.
+ *
+ * Because we blocked above on the nativeFenceFd, the image is also
+ * ready for foreign-device access (including CPU access). But we must
+ * still signal the fence; otherwise the client may get unexpected
+ * behavior if the client later waits on it.
+ *
+ * For some values of anv_semaphore_type, we must submit the semaphore
+ * to execbuf in order to signal it. Likewise for anv_fence_type.
+ * Instead of open-coding here the signal operation for each
+ * anv_semaphore_type and anv_fence_type, we piggy-back on
+ * vkQueueSubmit.
+ */
+ const VkSubmitInfo submit = {
+ .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
+ .waitSemaphoreCount = 0,
+ .commandBufferCount = 0,
+ .signalSemaphoreCount = (semaphore_h ? 1 : 0),
+ .pSignalSemaphores = &semaphore_h,
+ };
+
+ result = anv_QueueSubmit(anv_queue_to_handle(&device->queue), 1,
+ &submit, fence_h);
+ if (result != VK_SUCCESS) {
+ intel_loge("anv_QueueSubmit failed inside %s", __func__);
+ return result;
+ }
+ }
+
+ return VK_SUCCESS;
+}
+
+VkResult
+anv_QueueSignalReleaseImageANDROID(
+ VkQueue queue,
+ uint32_t waitSemaphoreCount,
+ const VkSemaphore* pWaitSemaphores,
+ VkImage image,
+ int* pNativeFenceFd)
+{
+ VkResult result;
+
+ if (waitSemaphoreCount == 0)
+ goto done;
+
+ result = anv_QueueSubmit(queue, 1,
+ &(VkSubmitInfo) {
+ .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
+ .waitSemaphoreCount = 1,
+ .pWaitSemaphores = pWaitSemaphores,
+ },
+ (VkFence) VK_NULL_HANDLE);
+ if (result != VK_SUCCESS)
+ return result;
+
+ done:
+ if (pNativeFenceFd) {
+ /* We can rely implicit on sync because above we submitted all
+ * semaphores to the queue.
+ */
+ *pNativeFenceFd = -1;
+ }
+
+ return VK_SUCCESS;
+}
diff --git a/src/intel/vulkan/anv_entrypoints_gen.py b/src/intel/vulkan/anv_entrypoints_gen.py
index bf376a881f4..334b6de54b9 100644
--- a/src/intel/vulkan/anv_entrypoints_gen.py
+++ b/src/intel/vulkan/anv_entrypoints_gen.py
@@ -270,7 +270,9 @@ def get_entrypoints(doc, entrypoints_to_defines, start_index):
if extension.attrib['name'] not in supported:
continue
- assert extension.attrib['supported'] == 'vulkan'
+ if extension.attrib['supported'] != 'vulkan':
+ continue
+
for command in extension.findall('./require/command'):
enabled_commands.add(command.attrib['name'])
diff --git a/src/intel/vulkan/anv_extensions.py b/src/intel/vulkan/anv_extensions.py
index 491e7086838..18f4b0b03db 100644
--- a/src/intel/vulkan/anv_extensions.py
+++ b/src/intel/vulkan/anv_extensions.py
@@ -50,6 +50,7 @@ class Extension:
# the those extension strings, then tests dEQP-VK.api.info.instance.extensions
# and dEQP-VK.api.info.device fail due to the duplicated strings.
EXTENSIONS = [
+ Extension('VK_ANDROID_native_buffer', 5, 'ANDROID'),
Extension('VK_KHR_bind_memory2', 1, True),
Extension('VK_KHR_dedicated_allocation', 1, True),
Extension('VK_KHR_descriptor_update_template', 1, True),
diff --git a/src/intel/vulkan/anv_image.c b/src/intel/vulkan/anv_image.c
index 36ba0ca15ce..c31070f44fd 100644
--- a/src/intel/vulkan/anv_image.c
+++ b/src/intel/vulkan/anv_image.c
@@ -111,8 +111,10 @@ get_surface(struct anv_image *image, VkImageAspectFlags aspect)
}
}
-static VkResult
-choose_isl_tiling_flags(const struct anv_image_create_info *anv_info,
+ static VkResult
+choose_isl_tiling_flags(struct anv_device *device,
+ const struct anv_image_create_info *anv_info,
+ const VkNativeBufferANDROID *gralloc_info,
bool needs_shadow,
isl_tiling_flags_t *restrict flags)
{
@@ -127,6 +129,44 @@ choose_isl_tiling_flags(const struct anv_image_create_info *anv_info,
if (anv_info->vk_info->tiling == VK_IMAGE_TILING_LINEAR)
*flags = ISL_TILING_LINEAR_BIT;
+#ifdef ANDROID
+ if (gralloc_info) {
+ int dma_buf = gralloc_info->handle->data[0];
+
+ uint32_t gem_handle = anv_gem_fd_to_handle(device, dma_buf);
+ if (gem_handle == 0) {
+ return vk_errorf(device->instance, device,
+ VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR,
+ "DRM_IOCTL_PRIME_FD_TO_HANDLE failed for "
+ "VkNativeBufferANDROID");
+ }
+
+ int i915_tiling = anv_gem_get_tiling(device, gem_handle);
+ switch (i915_tiling) {
+ case I915_TILING_NONE:
+ *flags &= ISL_TILING_LINEAR_BIT;
+ break;
+ case I915_TILING_X:
+ *flags &= ISL_TILING_X_BIT;
+ break;
+ case I915_TILING_Y:
+ *flags &= ISL_TILING_Y0_BIT;
+ break;
+ case -1:
+ return vk_errorf(device->instance, device,
+ VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR,
+ "DRM_IOCTL_I915_GEM_GET_TILING failed for "
+ "VkNativeBufferANDROID");
+ default:
+ return vk_errorf(device->instance, device,
+ VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR,
+ "DRM_IOCTL_I915_GEM_GET_TILING returned unknown "
+ "tiling %d for VkNativeBufferANDROID", i915_tiling);
+
+ }
+ }
+#endif
+
/* Only invalid Vulkan usage can filter out all tiling formats. */
assert(*flags != 0);
@@ -279,9 +319,14 @@ try_make_mcs_surface(const struct anv_device *dev,
static VkResult
try_make_aux_surface(const struct anv_device *dev,
const VkImageCreateInfo *base_info,
+ const VkNativeBufferANDROID *gralloc_info,
VkImageAspectFlags aspect,
struct anv_image *image)
{
+ /* We don't support aux surfaces for Android winsys images. */
+ if (gralloc_info)
+ return VK_SUCCESS;
+
if (aspect == VK_IMAGE_ASPECT_DEPTH_BIT) {
try_make_hiz_surface(dev, base_info, image);
} else if (aspect == VK_IMAGE_ASPECT_COLOR_BIT && base_info->samples == 1) {
@@ -376,8 +421,9 @@ add_fast_clear_state_buffer(struct anv_image *image,
* Exactly one bit must be set in \a aspect.
*/
static VkResult
-make_main_surface(const struct anv_device *dev,
+make_main_surface(struct anv_device *dev,
const struct anv_image_create_info *anv_info,
+ const VkNativeBufferANDROID *gralloc_info,
VkImageAspectFlags aspect,
struct anv_image *image)
{
@@ -400,6 +446,17 @@ make_main_surface(const struct anv_device *dev,
aspect, base_info->tiling);
assert(format != ISL_FORMAT_UNSUPPORTED);
+ uint32_t row_pitch = anv_info->stride;
+ if (gralloc_info) {
+ row_pitch = gralloc_info->stride *
+ (isl_format_get_layout(format)->bpb / 8);
+ }
+
+ isl_surf_usage_flags_t usage =
+ choose_isl_surf_usage(base_info->flags, image->usage, aspect);
+ if (gralloc_info)
+ usage |= ISL_SURF_USAGE_DISABLE_AUX_BIT;
+
/* If an image is created as BLOCK_TEXEL_VIEW_COMPATIBLE, then we need to
* fall back to linear on Broadwell and earlier because we aren't
* guaranteed that we can handle offsets correctly. On Sky Lake, the
@@ -415,7 +472,8 @@ make_main_surface(const struct anv_device *dev,
}
isl_tiling_flags_t tiling_flags;
- result = choose_isl_tiling_flags(anv_info, needs_shadow, &tiling_flags);
+ result = choose_isl_tiling_flags(dev, anv_info, gralloc_info, needs_shadow,
+ &tiling_flags);
if (result != VK_SUCCESS)
return result;
@@ -429,8 +487,8 @@ make_main_surface(const struct anv_device *dev,
.array_len = base_info->arrayLayers,
.samples = base_info->samples,
.min_alignment = 0,
- .row_pitch = anv_info->stride,
- .usage = choose_isl_surf_usage(base_info->flags, image->usage, aspect),
+ .row_pitch = row_pitch,
+ .usage = usage,
.tiling_flags = tiling_flags);
/* isl_surf_init() will fail only if provided invalid input. Invalid input
@@ -440,11 +498,15 @@ make_main_surface(const struct anv_device *dev,
add_surface(image, anv_surf);
+ if (gralloc_info)
+ assert(anv_surf->offset == 0);
+
/* If an image is created as BLOCK_TEXEL_VIEW_COMPATIBLE, then we need to
* create an identical tiled shadow surface for use while texturing so we
* don't get garbage performance.
*/
if (needs_shadow) {
+ assert(!gralloc_info);
assert(aspect == VK_IMAGE_ASPECT_COLOR_BIT);
assert(tiling_flags == ISL_TILING_LINEAR_BIT);
@@ -458,8 +520,8 @@ make_main_surface(const struct anv_device *dev,
.array_len = base_info->arrayLayers,
.samples = base_info->samples,
.min_alignment = 0,
- .row_pitch = anv_info->stride,
- .usage = choose_isl_surf_usage(image->usage, image->usage, aspect),
+ .row_pitch = row_pitch,
+ .usage = usage,
.tiling_flags = ISL_TILING_ANY_MASK);
/* isl_surf_init() will fail only if provided invalid input. Invalid input
@@ -473,6 +535,61 @@ make_main_surface(const struct anv_device *dev,
return VK_SUCCESS;
}
+#ifdef ANDROID
+static VkResult
+import_gralloc(struct anv_device *device,
+ struct anv_image *image,
+ const VkNativeBufferANDROID *gralloc_info)
+{
+ VkResult result;
+
+
+ if (gralloc_info->handle->numFds != 1) {
+ return vk_errorf(device->instance, device,
+ VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR,
+ "VkNativeBufferANDROID::handle::numFds is %d, "
+ "expected 1", gralloc_info->handle->numFds);
+ }
+
+ int dma_buf = gralloc_info->handle->data[0];
+
+ /* Do not close the gralloc handle's dma_buf. The lifetime of the dma_buf
+ * must exceed that of the gralloc handle, and we do not own the gralloc
+ * handle.
+ */
+ result = anv_bo_cache_import(device, &device->bo_cache, dma_buf, &image->bo);
+ if (result != VK_SUCCESS)
+ return result;
+
+ /* To validate the dma_buf's size, we must have already calculated the
+ * image's layout.
+ */
+ assert(image->size > 0);
+
+ if (image->bo->size < image->size) {
+ result = vk_errorf(device->instance, device,
+ VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR,
+ "VkNativeBufferANDROID's dma_buf is too small for "
+ "the VkImage: %lluB < %lluB",
+ image->bo->size, image->size);
+ anv_bo_cache_release(device, &device->bo_cache, image->bo);
+ image->bo = NULL;
+ return result;
+ }
+
+ image->bo_is_owned = true;
+
+ /* We need to set the WRITE flag on window system buffers so that GEM will
+ * know we're writing to them and synchronize uses on other rings (eg if
+ * the display server uses the blitter ring).
+ */
+ image->bo->flags &= ~EXEC_OBJECT_ASYNC;
+ image->bo->flags |= EXEC_OBJECT_WRITE;
+
+ return VK_SUCCESS;
+}
+#endif
+
VkResult
anv_image_create(VkDevice _device,
const struct anv_image_create_info *anv_info,
@@ -481,6 +598,8 @@ anv_image_create(VkDevice _device,
{
ANV_FROM_HANDLE(anv_device, device, _device);
const VkImageCreateInfo *base_info = anv_info->vk_info;
+ const VkNativeBufferANDROID *gralloc_info =
+ vk_find_struct_const(base_info->pNext, NATIVE_BUFFER_ANDROID);
struct anv_image *image = NULL;
VkResult r;
@@ -513,15 +632,23 @@ anv_image_create(VkDevice _device,
for_each_bit(b, image->aspects) {
VkImageAspectFlagBits aspect = 1 << b;
- r = make_main_surface(device, anv_info, aspect, image);
+ r = make_main_surface(device, anv_info, gralloc_info,aspect, image);
if (r != VK_SUCCESS)
goto fail;
- r = try_make_aux_surface(device, base_info, aspect, image);
+ r = try_make_aux_surface(device, base_info, gralloc_info, aspect, image);
if (r != VK_SUCCESS)
goto fail;
}
+#ifdef ANDROID
+ if (gralloc_info) {
+ r = import_gralloc(device, image, gralloc_info);
+ if (r != VK_SUCCESS)
+ goto fail;
+ }
+#endif
+
*pImage = anv_image_to_handle(image);
return VK_SUCCESS;
diff --git a/src/intel/vulkan/anv_private.h b/src/intel/vulkan/anv_private.h
index b5a0aee6057..7efff7b2ad6 100644
--- a/src/intel/vulkan/anv_private.h
+++ b/src/intel/vulkan/anv_private.h
@@ -69,6 +69,7 @@ struct gen_l3_config;
#include <vulkan/vulkan.h>
#include <vulkan/vulkan_intel.h>
#include <vulkan/vk_icd.h>
+#include <vulkan/vk_android_native_buffer.h>
#include "anv_entrypoints.h"
#include "isl/isl.h"
--
2.13.5
More information about the mesa-dev
mailing list