*/
#include "anv_private.h"
-#include "drm_fourcc.h"
+#include "drm-uapi/drm_fourcc.h"
#include "vk_enum_to_str.h"
#include "vk_format_info.h"
#include "vk_util.h"
.aspect = VK_IMAGE_ASPECT_COLOR_BIT, \
}, \
}, \
+ .vk_format = __vk_fmt, \
.n_planes = 1, \
}
.aspect = VK_IMAGE_ASPECT_DEPTH_BIT, \
}, \
}, \
+ .vk_format = __vk_fmt, \
.n_planes = 1, \
}
.aspect = VK_IMAGE_ASPECT_STENCIL_BIT, \
}, \
}, \
+ .vk_format = __vk_fmt, \
.n_planes = 1, \
}
.aspect = VK_IMAGE_ASPECT_STENCIL_BIT, \
}, \
}, \
+ .vk_format = __vk_fmt, \
.n_planes = 2, \
}
.planes = { \
{ .isl_format = ISL_FORMAT_UNSUPPORTED, }, \
}, \
+ .vk_format = VK_FORMAT_UNDEFINED, \
}
#define y_plane(__plane, __hw_fmt, __swizzle, __ycbcr_swizzle, dhs, dvs) \
.planes = { \
__VA_ARGS__, \
}, \
+ .vk_format = __vk_fmt, \
.n_planes = __n_planes, \
.can_ycbcr = true, \
}
const struct isl_format_layout *isl_layout =
isl_format_get_layout(plane_format.isl_format);
+ /* On Ivy Bridge we don't even have enough 24 and 48-bit formats that we
+ * can reliably do texture upload with BLORP so just don't claim support
+ * for any of them.
+ */
+ if (devinfo->gen == 7 && !devinfo->is_haswell &&
+ (isl_layout->bpb == 24 || isl_layout->bpb == 48))
+ return unsupported;
+
if (tiling == VK_IMAGE_TILING_OPTIMAL &&
!util_is_power_of_two_or_zero(isl_layout->bpb)) {
/* Tiled formats *must* be power-of-two because we need up upload
if (vk_tiling == VK_IMAGE_TILING_LINEAR)
return 0;
- flags |= VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT;
-
- if (aspects == VK_IMAGE_ASPECT_DEPTH_BIT || devinfo->gen >= 8)
- flags |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT;
+ flags |= VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT |
+ VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT |
+ VK_FORMAT_FEATURE_BLIT_SRC_BIT |
+ VK_FORMAT_FEATURE_BLIT_DST_BIT |
+ VK_FORMAT_FEATURE_TRANSFER_SRC_BIT |
+ VK_FORMAT_FEATURE_TRANSFER_DST_BIT;
if ((aspects & VK_IMAGE_ASPECT_DEPTH_BIT) && devinfo->gen >= 9)
flags |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT;
- flags |= VK_FORMAT_FEATURE_BLIT_SRC_BIT |
- VK_FORMAT_FEATURE_BLIT_DST_BIT |
- VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR |
- VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR;
-
return flags;
}
struct anv_physical_device *physical_device,
const VkPhysicalDeviceImageFormatInfo2 *info,
VkImageFormatProperties *pImageFormatProperties,
- VkSamplerYcbcrConversionImageFormatPropertiesKHR *pYcbcrImageFormatProperties)
+ VkSamplerYcbcrConversionImageFormatProperties *pYcbcrImageFormatProperties)
{
VkFormatFeatureFlags format_feature_flags;
VkExtent3D maxExtent;
if (format == NULL)
goto unsupported;
+ assert(format->vk_format == info->format);
format_feature_flags = anv_get_image_format_features(devinfo, info->format,
format, info->tiling);
VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT,
};
+static const VkExternalMemoryProperties userptr_props = {
+ .externalMemoryFeatures = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT,
+ .exportFromImportedHandleTypes = 0,
+ .compatibleHandleTypes =
+ VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT,
+};
+
static const VkExternalMemoryProperties android_buffer_props = {
.externalMemoryFeatures = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT |
VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT,
{
ANV_FROM_HANDLE(anv_physical_device, physical_device, physicalDevice);
const VkPhysicalDeviceExternalImageFormatInfo *external_info = NULL;
- VkExternalImageFormatPropertiesKHR *external_props = NULL;
+ VkExternalImageFormatProperties *external_props = NULL;
VkSamplerYcbcrConversionImageFormatProperties *ycbcr_props = NULL;
struct VkAndroidHardwareBufferUsageANDROID *android_usage = NULL;
VkResult result;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
external_info = (const void *) s;
break;
+ case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO_EXT:
+ /* Ignore but don't warn */
+ break;
default:
anv_debug_ignored_stype(s->sType);
break;
if (result != VK_SUCCESS)
goto fail;
- if (android_usage) {
+ bool ahw_supported =
+ physical_device->supported_extensions.ANDROID_external_memory_android_hardware_buffer;
+
+ if (ahw_supported && android_usage) {
android_usage->androidHardwareBufferUsage =
anv_ahw_usage_from_vk_usage(base_info->flags,
base_info->usage);
if (external_props)
external_props->externalMemoryProperties = prime_fd_props;
break;
- case VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID:
+ case VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT:
if (external_props)
- external_props->externalMemoryProperties = android_image_props;
+ external_props->externalMemoryProperties = userptr_props;
break;
+ case VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID:
+ if (ahw_supported && external_props) {
+ external_props->externalMemoryProperties = android_image_props;
+ break;
+ }
+ /* fallthrough if ahw not supported */
default:
/* From the Vulkan 1.0.42 spec:
*
if (pExternalBufferInfo->flags)
goto unsupported;
+ ANV_FROM_HANDLE(anv_physical_device, physical_device, physicalDevice);
+
switch (pExternalBufferInfo->handleType) {
case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT:
case VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT:
pExternalBufferProperties->externalMemoryProperties = prime_fd_props;
return;
- case VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID:
- pExternalBufferProperties->externalMemoryProperties =
- android_buffer_props;
+ case VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT:
+ pExternalBufferProperties->externalMemoryProperties = userptr_props;
return;
+ case VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID:
+ if (physical_device->supported_extensions.ANDROID_external_memory_android_hardware_buffer) {
+ pExternalBufferProperties->externalMemoryProperties = android_buffer_props;
+ return;
+ }
+ /* fallthrough if ahw not supported */
default:
goto unsupported;
}
unsupported:
+ /* From the Vulkan 1.1.113 spec:
+ *
+ * compatibleHandleTypes must include at least handleType.
+ */
pExternalBufferProperties->externalMemoryProperties =
- (VkExternalMemoryProperties) {0};
+ (VkExternalMemoryProperties) {
+ .compatibleHandleTypes = pExternalBufferInfo->handleType,
+ };
}
VkResult anv_CreateSamplerYcbcrConversion(
ANV_FROM_HANDLE(anv_device, device, _device);
struct anv_ycbcr_conversion *conversion;
+ /* Search for VkExternalFormatANDROID and resolve the format. */
+ struct anv_format *ext_format = NULL;
+ const struct VkExternalFormatANDROID *ext_info =
+ vk_find_struct_const(pCreateInfo->pNext, EXTERNAL_FORMAT_ANDROID);
+
+ uint64_t format = ext_info ? ext_info->externalFormat : 0;
+ if (format) {
+ assert(pCreateInfo->format == VK_FORMAT_UNDEFINED);
+ ext_format = (struct anv_format *) (uintptr_t) format;
+ }
+
assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO);
conversion = vk_alloc2(&device->alloc, pAllocator, sizeof(*conversion), 8,
conversion->format = anv_get_format(pCreateInfo->format);
conversion->ycbcr_model = pCreateInfo->ycbcrModel;
conversion->ycbcr_range = pCreateInfo->ycbcrRange;
- conversion->mapping[0] = pCreateInfo->components.r;
- conversion->mapping[1] = pCreateInfo->components.g;
- conversion->mapping[2] = pCreateInfo->components.b;
- conversion->mapping[3] = pCreateInfo->components.a;
+
+ /* The Vulkan 1.1.95 spec says "When creating an external format conversion,
+ * the value of components if ignored."
+ */
+ if (!ext_format) {
+ conversion->mapping[0] = pCreateInfo->components.r;
+ conversion->mapping[1] = pCreateInfo->components.g;
+ conversion->mapping[2] = pCreateInfo->components.b;
+ conversion->mapping[3] = pCreateInfo->components.a;
+ }
+
conversion->chroma_offsets[0] = pCreateInfo->xChromaOffset;
conversion->chroma_offsets[1] = pCreateInfo->yChromaOffset;
conversion->chroma_filter = pCreateInfo->chromaFilter;
+ /* Setup external format. */
+ if (ext_format)
+ conversion->format = ext_format;
+
bool has_chroma_subsampled = false;
for (uint32_t p = 0; p < conversion->format->n_planes; p++) {
if (conversion->format->planes[p].has_chroma &&
projects / mesa.git / blobdiff