diff --git a/appendices/VK_QNX_external_memory_screen_buffer.adoc b/appendices/VK_QNX_external_memory_screen_buffer.adoc new file mode 100644 index 0000000000..5a6ee3bd97 --- /dev/null +++ b/appendices/VK_QNX_external_memory_screen_buffer.adoc @@ -0,0 +1,40 @@ +// Copyright (c) 2023 Blackberry Limited +// +// SPDX-License-Identifier: CC-BY-4.0 + +include::{generated}/meta/{refprefix}VK_QNX_external_memory_screen_buffer.adoc[] + +=== Other Extension Metadata + +*Last Modified Date*:: + 2023-05-17 +*IP Status*:: + No known IP claims. +*Contributors*:: + - Mike Gorchak, QNX / Blackberry Limited + - Aaron Ruby, QNX / Blackberry Limited + +=== Description + +This extension enables an application to import QNX Screen +code:_screen_buffer objects created outside of the Vulkan device into +Vulkan memory objects, where they can be bound to images and buffers. + +Some code:_screen_buffer images have implementation-defined _external +formats_ that may: not correspond to Vulkan formats. Sampler {YCbCr} +conversion can: be used to sample from these images and convert them to a +known color space. + +code:_screen_buffer is strongly typed, so naming the handle type is +redundant. The internal layout and therefore size of a code:_screen_buffer +image may depend on native usage flags that do not have corresponding Vulkan +counterparts. + +include::{generated}/interfaces/VK_QNX_external_memory_screen_buffer.adoc[] + +=== Issues + +=== Version History + + * Revision 1, 2023-05-17 (Mike Gorchak) + ** Initial version diff --git a/appendices/glossary.adoc b/appendices/glossary.adoc index 1dc4b21064..b61a506dec 100644 --- a/appendices/glossary.adoc +++ b/appendices/glossary.adoc @@ -1356,10 +1356,15 @@ Potential Format Features:: supports for a specified elink:VkFormat, over all supported image tilings. ifdef::VK_ANDROID_external_memory_android_hardware_buffer[] - For <> the elink:VkFormatFeatureFlagBits is provided by the implementation. endif::VK_ANDROID_external_memory_android_hardware_buffer[] +ifdef::VK_QNX_external_memory_screen_buffer[] + For <> the elink:VkFormatFeatureFlagBits is provided by the + implementation. +endif::VK_QNX_external_memory_screen_buffer[] Pre-rasterization:: Operations that execute before <>, and any diff --git a/chapters/VK_QNX_external_memory_screen_buffer/device_memory.adoc b/chapters/VK_QNX_external_memory_screen_buffer/device_memory.adoc new file mode 100644 index 0000000000..237f2b3da8 --- /dev/null +++ b/chapters/VK_QNX_external_memory_screen_buffer/device_memory.adoc @@ -0,0 +1,123 @@ +// Copyright 2023 QNX Software Systems +// +// SPDX-License-Identifier: CC-BY-4.0 + +[[qnx-screen-buffer-external-memory]] +=== QNX Screen Buffer External Memory + +[open,refpage='VkImportScreenBufferInfoQNX',desc='Import memory from a QNX Screen buffer',type='structs'] +-- +To import memory created outside of the current Vulkan instance from a QNX +Screen buffer, add a sname:VkImportScreenBufferInfoQNX structure to the +pname:pNext chain of the slink:VkMemoryAllocateInfo structure. +The sname:VkImportScreenBufferInfoQNX structure is defined as: + +include::{generated}/api/structs/VkImportScreenBufferInfoQNX.adoc[] + + * pname:sType is the type of this structure. + * pname:pNext is `NULL` or a pointer to a structure extending this + structure. + * pname:buffer is a pointer to a code:struct code:_screen_buffer, the QNX Screen buffer to import + +The implementation may: not acquire a reference to the imported Screen +buffer. +Therefore, the application must: ensure that the object referred to by +pname:buffer stays valid as long as the device memory to which it is +imported is being used. + +.Valid Usage +**** + * If pname:buffer is not `NULL`, QNX Screen Buffers must: be supported for + import, as reported by slink:VkExternalImageFormatProperties or + slink:VkExternalBufferProperties + * pname:buffer is not `NULL`, it must: be a pointer to + <> + +**** + +include::{generated}/validity/structs/VkImportScreenBufferInfoQNX.adoc[] +-- + +[open,refpage='vkGetScreenBufferPropertiesQNX',desc='Get Properties of External Memory QNX Screen Buffers',type='protos'] +-- +To determine the memory parameters to use when importing a QNX Screen +buffer, call: + +include::{generated}/api/protos/vkGetScreenBufferPropertiesQNX.adoc[] + + * pname:device is the logical device that will be importing pname:buffer. + * pname:buffer is the QNX Screen buffer which will be imported. + * pname:pProperties is a pointer to a slink:VkScreenBufferPropertiesQNX + structure in which the properties of pname:buffer are returned. + +.Valid Usage +**** + * pname:buffer must: be a <> +**** + +include::{generated}/validity/protos/vkGetScreenBufferPropertiesQNX.adoc[] +-- + +[open,refpage='VkScreenBufferPropertiesQNX',desc='Properties of External Memory QNX Screen Buffers',type='structs'] +-- +The sname:VkScreenBufferPropertiesQNX structure returned is defined as: + +include::{generated}/api/structs/VkScreenBufferPropertiesQNX.adoc[] + + * pname:sType is the type of this structure. + * pname:pNext is `NULL` or a pointer to a structure extending this + structure. + * pname:allocationSize is the size of the external memory. + * pname:memoryTypeBits is a bitmask containing one bit set for every + memory type which the specified Screen buffer can: be imported as. + +include::{generated}/validity/structs/VkScreenBufferPropertiesQNX.adoc[] +-- + +[open,refpage='VkScreenBufferFormatPropertiesQNX',desc='Structure describing the image format properties of a QNX Screen buffer',type='structs'] +-- +To obtain format properties of a QNX Screen buffer, include a +sname:VkScreenBufferFormatPropertiesQNX structure in the pname:pNext chain +of the slink:VkScreenBufferPropertiesQNX structure passed to +flink:vkGetScreenBufferPropertiesQNX. +This structure is defined as: + +include::{generated}/api/structs/VkScreenBufferFormatPropertiesQNX.adoc[] + + * pname:sType is the type of this structure. + * pname:pNext is `NULL` or a pointer to a structure extending this + structure. + * pname:format is the Vulkan format corresponding to the Screen buffer's + format or ename:VK_FORMAT_UNDEFINED if there is not an equivalent Vulkan + format. + * pname:externalFormat is an implementation-defined external format + identifier for use with slink:VkExternalFormatQNX. + It must: not be zero. + * pname:screenUsage is an implementation-defined external usage identifier for + the QNX Screen buffer. + * pname:formatFeatures describes the capabilities of this external format + when used with an image bound to memory imported from pname:buffer. + * pname:samplerYcbcrConversionComponents is the component swizzle that + should: be used in slink:VkSamplerYcbcrConversionCreateInfo. + * pname:suggestedYcbcrModel is a suggested color model to use in the + slink:VkSamplerYcbcrConversionCreateInfo. + * pname:suggestedYcbcrRange is a suggested numerical value range to use in + slink:VkSamplerYcbcrConversionCreateInfo. + * pname:suggestedXChromaOffset is a suggested X chroma offset to use in + slink:VkSamplerYcbcrConversionCreateInfo. + * pname:suggestedYChromaOffset is a suggested Y chroma offset to use in + slink:VkSamplerYcbcrConversionCreateInfo. + +If the QNX Screen buffer has one of the formats listed in the +<>, then pname:format must: have the equivalent Vulkan format listed in +the table. +Otherwise, pname:format may: be ename:VK_FORMAT_UNDEFINED, indicating the +QNX Screen buffer can: only be used with an external format. +The pname:formatFeatures member must: include +ename:VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT and should: include +ename:VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT and +ename:VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT. + +include::{generated}/validity/structs/VkScreenBufferFormatPropertiesQNX.adoc[] +-- diff --git a/chapters/VK_QNX_external_memory_screen_buffer/qnx_screen_buffer.adoc b/chapters/VK_QNX_external_memory_screen_buffer/qnx_screen_buffer.adoc new file mode 100644 index 0000000000..98a92ccbd1 --- /dev/null +++ b/chapters/VK_QNX_external_memory_screen_buffer/qnx_screen_buffer.adoc @@ -0,0 +1,121 @@ +// Copyright 2023 QNX Software Systems +// +// SPDX-License-Identifier: CC-BY-4.0 + +[[memory-external-qnx-screen-buffer]] +==== QNX Screen Buffer + +The QNX SDP defines code:_screen_buffer objects, which represent +a buffer that the QNX Screen graphics subsystem can use directly +in its windowing system APIs. More specifically, a Screen buffer is an area of memory that +stores pixel data. It can be attached to Screen windows, streams, or pixmaps. +These QNX Screen buffer objects may: be imported into +slink:VkDeviceMemory objects for access via Vulkan. +An slink:VkImage or slink:VkBuffer can: be bound to the imported +slink:VkDeviceMemory object if it is created with +ename:VK_EXTERNAL_MEMORY_HANDLE_TYPE_SCREEN_BUFFER_BIT_QNX. + +-- +code:struct code:_screen_buffer is strongly typed, so naming the handle type is +redundant. The internal layout and therefore size of a code:struct code:_screen_buffer +image may depend on native usage flags that do not have corresponding Vulkan +counterparts. +-- + +[[memory-external-screen-buffer-validity]] +===== QNX Screen Buffer Validity +The design of Screen in the QNX SDP makes it difficult to determine the validity of objects from outside of Screen. Therefore, applications must: ensure that QNX Screen buffer objects provided used in various Vulkan +interfaces are ones created explicitly with QNX Screen APIs. See QNX SDP documentation for more information. + +A slink:VkDeviceMemory imported from a QNX Screen buffer has no way to acquire +a reference to its code:_screen_buffer object. Therefore, during the host +execution of a Vulkan command that has a QNX Screen buffer as a parameter +(including indirect parameters via pname:pNext chains), the application must: +ensure that the QNX Screen buffer resource remains valid. + +Generally, for a code:_screen_buffer object to be valid for use within a Vulkan implementation, the buffer object +should: have a code:_screen_buffer::code:SCREEN_PROPERTY_USAGE that includes at least one of: +code:SCREEN_USAGE_VULKAN, code:SCREEN_USAGE_OPENGL_ES2, code:SCREEN_USAGE_OPENGL_ES3, or code:SCREEN_USAGE_NATIVE. +The exact Screen-native usage flags required depends on the Vulkan implementation, and QNX Screen itself will not necessarily enforce these requirements. Note that Screen-native usage flags are in no way related to usage flags in the Vulkan specification. + +[[memory-external-screen-buffer-external-formats]] +===== QNX Screen Buffer External Formats + +QNX Screen buffers may: represent images using implementation-specific +formats, layouts, color models, etc., which do not have Vulkan equivalents. +Such _external formats_ are commonly used by external image sources such as +video decoders or cameras. +Vulkan can: import QNX Screen buffers that have external formats, but +since the image contents are in an undiscoverable and possibly proprietary +representation, images with external formats must: only be used as sampled +images, must: only be sampled with a sampler that has {YCbCr} conversion +enabled, and must: have optimal tiling. + +Images that will be backed by a QNX Screen buffer can: use an +external format by setting slink:VkImageCreateInfo::pname:format to +ename:VK_FORMAT_UNDEFINED and including a slink:VkExternalFormatQNX +structure in the pname:pNext chain. +Images can: be created with an external format even if the QNX Screen +buffer has a format which has an +<> +to enable consistent handling of images from sources that might use either +category of format. +The external format of a QNX Screen buffer can: be obtained by +passing a slink:VkScreenBufferFormatPropertiesQNX structure to +flink:vkGetScreenBufferPropertiesQNX. + + +[[memory-external-qnx-screen-buffer-image-resources]] +===== QNX Screen Buffer Image Resources + +QNX Screen buffers have intrinsic width, height, format, and usage +properties, so Vulkan images bound to memory imported from a QNX Screen +buffer must: use dedicated allocations: +sname:VkMemoryDedicatedRequirements::pname:requiresDedicatedAllocation must: +be ename:VK_TRUE for images created with +slink:VkExternalMemoryImageCreateInfo::pname:handleTypes that includes +ename:VK_EXTERNAL_MEMORY_HANDLE_TYPE_SCREEN_BUFFER_BIT_QNX. +When creating an image that will be bound to an imported QNX Screen buffer, +the image creation parameters must: be equivalent to the +code:_screen_buffer properties as described by the valid usage of +slink:VkMemoryAllocateInfo. + +[[memory-external-qnx-screen-buffer-formats]] +.QNX Screen Buffer Format Equivalence +[width="100%",options="header"] +|==== +| QNX Screen Format | Vulkan Format +| code:SCREEN_FORMAT_RGBA8888 | ename:VK_FORMAT_B8G8R8A8_UNORM +| code:SCREEN_FORMAT_RGBX8888 ^1^ | ename:VK_FORMAT_B8G8R8A8_UNORM +| code:SCREEN_FORMAT_BGRA8888 | ename:VK_FORMAT_R8G8B8A8_UNORM +| code:SCREEN_FORMAT_BGRX8888 ^1^ | ename:VK_FORMAT_R8G8B8A8_UNORM +| code:SCREEN_FORMAT_RGBA1010102 | ename:VK_FORMAT_A2R10G10B10_UNORM_PACK32 +| code:SCREEN_FORMAT_RGBX1010102 ^1^ | ename:VK_FORMAT_A2R10G10B10_UNORM_PACK32 +| code:SCREEN_FORMAT_BGRA1010102 | ename:VK_FORMAT_A2B10G10R10_UNORM_PACK32 +| code:SCREEN_FORMAT_BGRX1010102 ^1^ | ename:VK_FORMAT_A2B10G10R10_UNORM_PACK32 +| code:SCREEN_FORMAT_RGBA5551 | ename:VK_FORMAT_A1R5G5B5_UNORM_PACK16 +| code:SCREEN_FORMAT_RGBX5551 ^1^ | ename:VK_FORMAT_A1R5G5B5_UNORM_PACK16 +| code:SCREEN_FORMAT_RGB565 | ename:VK_FORMAT_R5G6B5_UNORM_PACK16 +| code:SCREEN_FORMAT_RGB888 | ename:VK_FORMAT_R8G8B8_UNORM +|==== + + +1:: + Vulkan does not differentiate between + code:SCREEN_FORMAT_RGBA8888 and + code:SCREEN_FORMAT_RGBX8888: they both behave as + ename:VK_FORMAT_R8G8B8A8_UNORM. + After an external entity writes to a + code:SCREEN_FORMAT_RGBX8888 QNX Screen buffer, the + values read by Vulkan from the X/A component are undefined:. + To emulate the traditional behavior of the X component during sampling + or blending, applications should: use ename:VK_COMPONENT_SWIZZLE_ONE in + image view component mappings and ename:VK_BLEND_FACTOR_ONE in color + blend factors. + There is no way to avoid copying these undefined: values when copying + from such an image to another image or buffer. + The same behavior applies to the following pairs: code:SCREEN_FORMAT_BGRA8888 and + code:SCREEN_FORMAT_BGRX8888, code:SCREEN_FORMAT_RGBA1010102 and + code:SCREEN_FORMAT_RGBX1010102, code:SCREEN_FORMAT_BGRA1010102 and + code:SCREEN_FORMAT_BGRX1010102, code:SCREEN_FORMAT_RGBA5551 and + code:SCREEN_FORMAT_RGBX5551 diff --git a/chapters/capabilities.adoc b/chapters/capabilities.adoc index f38c6ca33e..c17ca08982 100644 --- a/chapters/capabilities.adoc +++ b/chapters/capabilities.adoc @@ -505,6 +505,12 @@ ifdef::VK_NV_external_memory_sci_buf[] software (intra-process and inter-process) and hardware (system memory) operating domains. endif::VK_NV_external_memory_sci_buf[] +ifdef::VK_QNX_external_memory_screen_buffer[] + * ename:VK_EXTERNAL_MEMORY_HANDLE_TYPE_SCREEN_BUFFER_BIT_QNX + specifies a code:_screen_buffer object defined by the QNX SDP. + See <> + for more details of this handle type. +endif::VK_QNX_external_memory_screen_buffer[] <<< @@ -542,6 +548,9 @@ endif::VK_NV_external_memory_rdma[] ifdef::VK_NV_external_memory_sci_buf[] | ename:VK_EXTERNAL_MEMORY_HANDLE_TYPE_SCI_BUF_BIT_NV | No restriction | No restriction endif::VK_NV_external_memory_sci_buf[] +ifdef::VK_QNX_external_memory_screen_buffer[] +| ename:VK_EXTERNAL_MEMORY_HANDLE_TYPE_SCREEN_BUFFER_BIT_QNX | No restriction | No restriction +endif::VK_QNX_external_memory_screen_buffer[] |==== ifdef::VK_EXT_external_memory_host[] @@ -679,6 +688,10 @@ ifdef::VK_ANDROID_external_memory_android_hardware_buffer[] * ename:VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID for images only endif::VK_ANDROID_external_memory_android_hardware_buffer[] +ifdef::VK_QNX_external_memory_screen_buffer[] + * ename:VK_EXTERNAL_MEMORY_HANDLE_TYPE_SCREEN_BUFFER_BIT_QNX + for images only +endif::VK_QNX_external_memory_screen_buffer[] ifdef::VK_ANDROID_external_memory_android_hardware_buffer[] Implementations must: not report @@ -686,6 +699,12 @@ ename:VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT for buffers with external handle type ename:VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID. endif::VK_ANDROID_external_memory_android_hardware_buffer[] +ifdef::VK_QNX_external_memory_screen_buffer[] +Implementations must: not report +ename:VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT for buffers with +external handle type +ename:VK_EXTERNAL_MEMORY_HANDLE_TYPE_SCREEN_BUFFER_BIT_QNX. +endif::VK_QNX_external_memory_screen_buffer[] ifdef::VK_EXT_external_memory_host[] Implementations must: not report ename:VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT for images or buffers diff --git a/chapters/features.adoc b/chapters/features.adoc index ec6403931c..0728b91846 100644 --- a/chapters/features.adoc +++ b/chapters/features.adoc @@ -3473,6 +3473,51 @@ include::{generated}/validity/structs/VkPhysicalDeviceExternalMemorySciBufFeatur -- endif::VK_NV_external_memory_sci_buf[] +ifdef::VK_QNX_external_memory_screen_buffer[] +[open,refpage='VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX',desc='Structure describing QNX Screen Buffer features that can be supported by an implementation',type='structs'] +-- +The sname:VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX structure is +defined as: + +include::{generated}/api/structs/VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX.adoc[] + +The members of the sname:VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX +structure describe the following features: + + * [[features-screenBufferImport]] pname:screenBufferImport indicates whether + QNX Screen buffer import functionality is supported. + If pname:screenBufferImport is set to ename:VK_TRUE, slink:VkDeviceMemory + supports importing code:_screen_buffer from applications. + In this case, the application is responsible for the resource management + of the code:_screen_buffer. + +[[features-externalscreenbuffer-table]] +.Functionality supported for QNX Screen Buffer features +|===== +| Features | Functionality +| pname:screenBufferImport | slink:VkImportScreenBufferInfoQNX +| Always supported^1^ | flink:vkGetScreenBufferPropertiesQNX, slink:VkScreenBufferPropertiesQNX, slink:VkScreenBufferFormatPropertiesQNX, +slink:VkExternalFormatQNX +|===== + +1:: + Functionality in this row is always available. + +The <> table summarizes the functionality enabled by the +sname:VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX structure. +Each entry in the body of the table summarizes the functionality that can: +be used when the given features are supported and enabled. +This summarizes Valid Usage statements that are added elsewhere in this +specification. + +:refpage: VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX +include::{chapters}/features.adoc[tag=features] + +include::{generated}/validity/structs/VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX.adoc[] +-- +endif::VK_QNX_external_memory_screen_buffer[] + ifdef::VK_EXT_index_type_uint8[] [open,refpage='VkPhysicalDeviceIndexTypeUint8FeaturesEXT',desc='Structure describing whether uint8 index type can be used',type='structs'] -- diff --git a/chapters/formats.adoc b/chapters/formats.adoc index 531033dc56..2907f168b3 100644 --- a/chapters/formats.adoc +++ b/chapters/formats.adoc @@ -2679,8 +2679,10 @@ ifdef::VK_EXT_image_drm_format_modifier[] , ename:VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT, endif::VK_EXT_image_drm_format_modifier[] or ename:VK_IMAGE_TILING_LINEAR -ifdef::VK_ANDROID_external_memory_android_hardware_buffer[] +ifdef::VK_ANDROID_external_memory_android_hardware_buffer,VK_QNX_external_memory_screen_buffer[] if elink:VkFormat is not ename:VK_FORMAT_UNDEFINED +endif::VK_ANDROID_external_memory_android_hardware_buffer,VK_QNX_external_memory_screen_buffer[] +ifdef::VK_ANDROID_external_memory_android_hardware_buffer[] * slink:VkAndroidHardwareBufferFormatPropertiesANDROID::pname:formatFeatures ifdef::VK_VERSION_1_3,VK_KHR_format_feature_flags2[] and @@ -2689,6 +2691,11 @@ endif::VK_VERSION_1_3,VK_KHR_format_feature_flags2[] of a valid external format if elink:VkFormat is ename:VK_FORMAT_UNDEFINED endif::VK_ANDROID_external_memory_android_hardware_buffer[] +ifdef::VK_QNX_external_memory_screen_buffer[] + * slink:VkScreenBufferFormatPropertiesQNX::pname:formatFeatures + of a valid external format if elink:VkFormat is + ename:VK_FORMAT_UNDEFINED +endif::VK_QNX_external_memory_screen_buffer[] [[features-required-format-support]] diff --git a/chapters/memory.adoc b/chapters/memory.adoc index 0de55e22c0..77158d5861 100644 --- a/chapters/memory.adoc +++ b/chapters/memory.adoc @@ -1209,7 +1209,7 @@ include::{generated}/api/structs/VkMemoryAllocateInfo.adoc[] The internal data of an allocated device memory object must: include a reference to implementation-specific resources, referred to as the memory object's _payload_. -ifdef::VK_KHR_external_memory_win32,VK_KHR_external_memory_fd,VK_EXT_external_memory_host,VK_ANDROID_external_memory_android_hardware_buffer,VK_FUCHSIA_external_memory,VK_NV_external_memory_sci_buf[] +ifdef::VK_KHR_external_memory_win32,VK_KHR_external_memory_fd,VK_EXT_external_memory_host,VK_ANDROID_external_memory_android_hardware_buffer,VK_FUCHSIA_external_memory,VK_NV_external_memory_sci_buf,VK_QNX_external_memory_screen_buffer[] Applications can: also import and export that internal data to and from device memory objects to share data between Vulkan instances and other compatible APIs. @@ -1242,6 +1242,9 @@ endif::VK_FUCHSIA_buffer_collection[] ifdef::VK_NV_external_memory_sci_buf[] * slink:VkImportMemorySciBufInfoNV with a non-zero pname:handleType value endif::VK_NV_external_memory_sci_buf[] +ifdef::VK_QNX_external_memory_screen_buffer[] + * slink:VkImportScreenBufferInfoQNX with a non-`NULL` pname:buffer value +endif::VK_QNX_external_memory_screen_buffer[] ifdef::VK_KHR_external_memory_win32[] If the parameters define an import operation and the external handle type is @@ -1315,15 +1318,15 @@ This is because for an export operation, there is currently no way for the client to know the memory type index before allocating. endif::VK_ANDROID_external_memory_android_hardware_buffer[] -endif::VK_KHR_external_memory_win32,VK_KHR_external_memory_fd,VK_EXT_external_memory_host,VK_ANDROID_external_memory_android_hardware_buffer,VK_FUCHSIA_external_memory,VK_NV_external_memory_sci_buf[] +endif::VK_KHR_external_memory_win32,VK_KHR_external_memory_fd,VK_EXT_external_memory_host,VK_ANDROID_external_memory_android_hardware_buffer,VK_FUCHSIA_external_memory,VK_NV_external_memory_sci_buf,VK_QNX_external_memory_screen_buffer[] .Valid Usage **** -ifndef::VK_KHR_external_memory_win32,VK_KHR_external_memory_fd,VK_EXT_external_memory_host,VK_ANDROID_external_memory_android_hardware_buffer,VK_FUCHSIA_external_memory,VK_NV_external_memory_sci_buf[] +ifndef::VK_KHR_external_memory_win32,VK_KHR_external_memory_fd,VK_EXT_external_memory_host,VK_ANDROID_external_memory_android_hardware_buffer,VK_FUCHSIA_external_memory,VK_NV_external_memory_sci_buf,VK_QNX_external_memory_screen_buffer[] * [[VUID-VkMemoryAllocateInfo-allocationSize-00638]] pname:allocationSize must: be greater than `0` -endif::VK_KHR_external_memory_win32,VK_KHR_external_memory_fd,VK_EXT_external_memory_host,VK_ANDROID_external_memory_android_hardware_buffer,VK_FUCHSIA_external_memory,VK_NV_external_memory_sci_buf[] -ifdef::VK_KHR_external_memory_win32,VK_KHR_external_memory_fd,VK_EXT_external_memory_host,VK_ANDROID_external_memory_android_hardware_buffer,VK_FUCHSIA_external_memory,VK_NV_external_memory_sci_buf[] +endif::VK_KHR_external_memory_win32,VK_KHR_external_memory_fd,VK_EXT_external_memory_host,VK_ANDROID_external_memory_android_hardware_buffer,VK_FUCHSIA_external_memory,VK_NV_external_memory_sci_buf,VK_QNX_external_memory_screen_buffer[] +ifdef::VK_KHR_external_memory_win32,VK_KHR_external_memory_fd,VK_EXT_external_memory_host,VK_ANDROID_external_memory_android_hardware_buffer,VK_FUCHSIA_external_memory,VK_NV_external_memory_sci_buf,VK_QNX_external_memory_screen_buffer[] * [[VUID-VkMemoryAllocateInfo-None-06657]] The parameters must: not define more than one <> @@ -1341,7 +1344,7 @@ ifdef::VK_ANDROID_external_memory_android_hardware_buffer[] ename:VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID, pname:allocationSize must: be greater than `0` endif::VK_ANDROID_external_memory_android_hardware_buffer[] -endif::VK_KHR_external_memory_win32,VK_KHR_external_memory_fd,VK_EXT_external_memory_host,VK_ANDROID_external_memory_android_hardware_buffer,VK_FUCHSIA_external_memory,VK_NV_external_memory_sci_buf[] +endif::VK_KHR_external_memory_win32,VK_KHR_external_memory_fd,VK_EXT_external_memory_host,VK_ANDROID_external_memory_android_hardware_buffer,VK_FUCHSIA_external_memory,VK_NV_external_memory_sci_buf,VK_QNX_external_memory_screen_buffer[] ifdef::VK_FUCHSIA_buffer_collection[] * [[VUID-VkMemoryAllocateInfo-buffer-06380]] If the parameters define an import operation from an @@ -1609,6 +1612,41 @@ ifdef::VK_ANDROID_external_memory_android_hardware_buffer[] code:AHARDWAREBUFFER_USAGE bit listed that bit must: be included in the Android hardware buffer's code:AHardwareBuffer_Desc::code:usage endif::VK_ANDROID_external_memory_android_hardware_buffer[] +ifdef::VK_QNX_external_memory_screen_buffer[] + * If the parameters define an import operation and the external handle + type is + ename:VK_EXTERNAL_MEMORY_HANDLE_TYPE_SCREEN_BUFFER_BIT_QNX, + slink:VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX::pname:screenBufferImport + must: be enabled + * If the parameters define an import operation and the external handle + type is + ename:VK_EXTERNAL_MEMORY_HANDLE_TYPE_SCREEN_BUFFER_BIT_QNX, + pname:allocationSize must: be the size returned by + flink:vkGetScreenBufferPropertiesQNX for the QNX Screen buffer + * If the parameters define an import operation and the external handle + type is + ename:VK_EXTERNAL_MEMORY_HANDLE_TYPE_SCREEN_BUFFER_BIT_QNX, + pname:memoryTypeIndex must: be one of those returned by + flink:vkGetScreenBufferPropertiesQNX for the QNX Screen buffer + * If the parameters define an import operation, the external handle is a + QNX Screen buffer, and the pname:pNext chain includes a + slink:VkMemoryDedicatedAllocateInfo with pname:image that is not + dlink:VK_NULL_HANDLE, the QNX Screen's buffer must be a + <> + * If the parameters define an import operation, the external handle is an + QNX Screen buffer, and the pname:pNext chain includes a + slink:VkMemoryDedicatedAllocateInfo with pname:image that is not + dlink:VK_NULL_HANDLE, the format of pname:image must: be + ename:VK_FORMAT_UNDEFINED or the format returned by + flink:vkGetScreenBufferPropertiesQNX in + slink:VkScreenBufferFormatPropertiesQNX::pname:format for + the QNX Screen buffer + * If the parameters define an import operation, the external handle is a + QNX Screen buffer, and the pname:pNext chain includes a + slink:VkMemoryDedicatedAllocateInfo structure with pname:image that is + not dlink:VK_NULL_HANDLE, the width, height, and array layer dimensions + of pname:image and the QNX Screen buffer's code:_screen_buffer must be identical +endif::VK_QNX_external_memory_screen_buffer[] ifdef::VK_VERSION_1_2,VK_KHR_buffer_device_address[] * [[VUID-VkMemoryAllocateInfo-opaqueCaptureAddress-03329]] If @@ -1715,36 +1753,36 @@ endif::VK_KHR_dedicated_allocation[] * [[VUID-VkMemoryDedicatedAllocateInfo-image-01432]] At least one of pname:image and pname:buffer must: be dlink:VK_NULL_HANDLE -ifndef::VK_ANDROID_external_memory_android_hardware_buffer[] +ifndef::VK_ANDROID_external_memory_android_hardware_buffer,VK_QNX_external_memory_screen_buffer[] * [[VUID-VkMemoryDedicatedAllocateInfo-image-01433]] If pname:image is not dlink:VK_NULL_HANDLE, sname:VkMemoryAllocateInfo::pname:allocationSize must: equal the sname:VkMemoryRequirements::pname:size of the image -endif::VK_ANDROID_external_memory_android_hardware_buffer[] -ifdef::VK_ANDROID_external_memory_android_hardware_buffer[] +endif::VK_ANDROID_external_memory_android_hardware_buffer,VK_QNX_external_memory_screen_buffer[] +ifdef::VK_ANDROID_external_memory_android_hardware_buffer,VK_QNX_external_memory_screen_buffer[] * [[VUID-VkMemoryDedicatedAllocateInfo-image-02964]] If pname:image is not dlink:VK_NULL_HANDLE and the memory is not an - imported Android Hardware Buffer, + imported Android Hardware Buffer or an imported QNX Screen buffer, sname:VkMemoryAllocateInfo::pname:allocationSize must: equal the sname:VkMemoryRequirements::pname:size of the image -endif::VK_ANDROID_external_memory_android_hardware_buffer[] +endif::VK_ANDROID_external_memory_android_hardware_buffer,VK_QNX_external_memory_screen_buffer[] * [[VUID-VkMemoryDedicatedAllocateInfo-image-01434]] If pname:image is not dlink:VK_NULL_HANDLE, pname:image must: have been created without ename:VK_IMAGE_CREATE_SPARSE_BINDING_BIT set in slink:VkImageCreateInfo::pname:flags -ifndef::VK_ANDROID_external_memory_android_hardware_buffer[] +ifndef::VK_ANDROID_external_memory_android_hardware_buffer,VK_QNX_external_memory_screen_buffer[] * [[VUID-VkMemoryDedicatedAllocateInfo-buffer-01435]] If pname:buffer is not dlink:VK_NULL_HANDLE, sname:VkMemoryAllocateInfo::pname:allocationSize must: equal the sname:VkMemoryRequirements::pname:size of the buffer -endif::VK_ANDROID_external_memory_android_hardware_buffer[] -ifdef::VK_ANDROID_external_memory_android_hardware_buffer[] +endif::VK_ANDROID_external_memory_android_hardware_buffer,VK_QNX_external_memory_screen_buffer[] +ifdef::VK_ANDROID_external_memory_android_hardware_buffer,VK_QNX_external_memory_screen_buffer[] * [[VUID-VkMemoryDedicatedAllocateInfo-buffer-02965]] If pname:buffer is not dlink:VK_NULL_HANDLE and the memory is not an - imported Android Hardware Buffer, + imported Android Hardware Buffer or an imported QNX Screen buffer, sname:VkMemoryAllocateInfo::pname:allocationSize must: equal the sname:VkMemoryRequirements::pname:size of the buffer -endif::VK_ANDROID_external_memory_android_hardware_buffer[] +endif::VK_ANDROID_external_memory_android_hardware_buffer,VK_QNX_external_memory_screen_buffer[] * [[VUID-VkMemoryDedicatedAllocateInfo-buffer-01436]] If pname:buffer is not dlink:VK_NULL_HANDLE, pname:buffer must: have been created without ename:VK_BUFFER_CREATE_SPARSE_BINDING_BIT set in @@ -3158,6 +3196,10 @@ include::{generated}/validity/structs/VkMemorySciBufPropertiesNV.adoc[] -- endif::VK_NV_external_memory_sci_buf[] +ifdef::VK_QNX_external_memory_screen_buffer[] +include::{chapters}/VK_QNX_external_memory_screen_buffer/device_memory.adoc[] +endif::VK_QNX_external_memory_screen_buffer[] + ifdef::VK_VERSION_1_1,VK_KHR_device_group[] === Device Group Memory Allocations @@ -4266,6 +4308,14 @@ code:AHARDWAREBUFFER_USAGE_GPU_DATA_BUFFER, code:width must: equal the device memory allocation size, and code:height and code:layers must: be `1`. endif::VK_KHR_external_memory_capabilities+VK_ANDROID_external_memory_android_hardware_buffer[] +ifdef::VK_QNX_external_memory_screen_buffer[] +ifndef::VK_ANDROID_external_memory_android_hardware_buffer[] +[[memory-external-handle-types]] +=== External Memory Handle Types +endif::VK_ANDROID_external_memory_android_hardware_buffer[] + +include::{chapters}/VK_QNX_external_memory_screen_buffer/qnx_screen_buffer.adoc[] +endif::VK_QNX_external_memory_screen_buffer[] ifdef::VK_VERSION_1_1,VK_KHR_device_group[] [[memory-peer-memory-features]] diff --git a/chapters/resources.adoc b/chapters/resources.adoc index b4f41a2e18..78d9dcec41 100644 --- a/chapters/resources.adoc +++ b/chapters/resources.adoc @@ -1138,10 +1138,19 @@ endif::VK_EXT_image_drm_format_modifier[] flink:vkGetPhysicalDeviceFormatProperties with parameter pname:format equal to slink:VkImageCreateInfo::pname:format. ** If pname:tiling is ename:VK_IMAGE_TILING_OPTIMAL, +ifdef::VK_ANDROID_external_memory_android_hardware_buffer,VK_QNX_external_memory_screen_buffer[] + and if the pname:pNext chain includes no ifdef::VK_ANDROID_external_memory_android_hardware_buffer[] - and if the pname:pNext chain includes no slink:VkExternalFormatANDROID - structure with non-zero pname:externalFormat, + slink:VkExternalFormatANDROID +endif::VK_ANDROID_external_memory_android_hardware_buffer[] +ifdef::VK_QNX_external_memory_screen_buffer[] +ifdef::VK_ANDROID_external_memory_android_hardware_buffer[] + or endif::VK_ANDROID_external_memory_android_hardware_buffer[] + slink:VkExternalFormatQNX +endif::VK_QNX_external_memory_screen_buffer[] + structure with non-zero pname:externalFormat, +endif::VK_ANDROID_external_memory_android_hardware_buffer,VK_QNX_external_memory_screen_buffer[] then pname:imageCreateFormatFeatures is the value of slink:VkFormatProperties::pname:optimalTilingFeatures found by calling flink:vkGetPhysicalDeviceFormatProperties with parameter pname:format @@ -1155,6 +1164,15 @@ ifdef::VK_ANDROID_external_memory_android_hardware_buffer[] obtained by flink:vkGetAndroidHardwareBufferPropertiesANDROID with a matching pname:externalFormat value. endif::VK_ANDROID_external_memory_android_hardware_buffer[] +ifdef::VK_QNX_external_memory_screen_buffer[] + ** If pname:tiling is ename:VK_IMAGE_TILING_OPTIMAL, and if the + pname:pNext chain includes a slink:VkExternalFormatQNX structure + with non-zero pname:externalFormat, then + pname:imageCreateFormatFeatures is the value of + slink:VkScreenBufferFormatPropertiesQNX::pname:formatFeatures + obtained by flink:vkGetScreenBufferPropertiesQNX with a + matching pname:externalFormat value. +endif::VK_QNX_external_memory_screen_buffer[] ifdef::VK_FUCHSIA_buffer_collection[] ** If the pname:pNext chain includes a slink:VkBufferCollectionImageCreateInfoFUCHSIA structure, then @@ -1183,13 +1201,21 @@ endif::VK_EXT_image_drm_format_modifier[] ifdef::VK_VERSION_1_1,VK_KHR_external_memory[] * Let `VkImageFormatProperties2 imageCreateImageFormatPropertiesList[]` be -ifdef::VK_ANDROID_external_memory_android_hardware_buffer[] +ifdef::VK_ANDROID_external_memory_android_hardware_buffer,VK_QNX_external_memory_screen_buffer[] defined as follows. ** If slink:VkImageCreateInfo::pname:pNext contains no - slink:VkExternalFormatANDROID structure with non-zero - pname:externalFormat, then pname:imageCreateImageFormatPropertiesList - is +ifdef::VK_ANDROID_external_memory_android_hardware_buffer[] + slink:VkExternalFormatANDROID +endif::VK_ANDROID_external_memory_android_hardware_buffer[] +ifdef::VK_QNX_external_memory_screen_buffer[] +ifdef::VK_ANDROID_external_memory_android_hardware_buffer[] + or endif::VK_ANDROID_external_memory_android_hardware_buffer[] + slink:VkExternalFormatQNX +endif::VK_QNX_external_memory_screen_buffer[] + structure with non-zero pname:externalFormat, then pname:imageCreateImageFormatPropertiesList + is +endif::VK_ANDROID_external_memory_android_hardware_buffer,VK_QNX_external_memory_screen_buffer[] the list of structures obtained by calling flink:vkGetPhysicalDeviceImageFormatProperties2, possibly multiple times, as follows: @@ -1775,6 +1801,29 @@ ifdef::VK_ANDROID_external_memory_android_hardware_buffer[] structure whose pname:externalFormat member is not `0`, pname:tiling must: be ename:VK_IMAGE_TILING_OPTIMAL endif::VK_ANDROID_external_memory_android_hardware_buffer[] +ifdef::VK_QNX_external_memory_screen_buffer[] + * If the pname:pNext chain includes a + slink:VkExternalMemoryImageCreateInfo structure whose pname:handleTypes + member includes + ename:VK_EXTERNAL_MEMORY_HANDLE_TYPE_SCREEN_BUFFER_BIT_QNX, + pname:imageType must: be ename:VK_IMAGE_TYPE_2D + * If the pname:pNext chain includes a + slink:VkExternalMemoryImageCreateInfo structure whose pname:handleTypes + member includes + ename:VK_EXTERNAL_MEMORY_HANDLE_TYPE_SCREEN_BUFFER_BIT_QNX, + pname:mipLevels must: either be `1` or equal to the number of levels in + the complete mipmap chain based on [eq]#pname:extent.width#, + [eq]#pname:extent.height#, and [eq]#pname:extent.depth# + * If the pname:pNext chain includes a slink:VkExternalFormatQNX + structure whose pname:externalFormat member is not `0`, pname:flags + must: not include ename:VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT + * If the pname:pNext chain includes a slink:VkExternalFormatQNX + structure whose pname:externalFormat member is not `0`, pname:usage + must: not include any usages except ename:VK_IMAGE_USAGE_SAMPLED_BIT + * If the pname:pNext chain includes a slink:VkExternalFormatQNX + structure whose pname:externalFormat member is not `0`, pname:tiling + must: be ename:VK_IMAGE_TILING_OPTIMAL +endif::VK_QNX_external_memory_screen_buffer[] ifdef::VK_VERSION_1_2,VK_EXT_separate_stencil_usage[] * [[VUID-VkImageCreateInfo-format-02795]] If pname:format is a depth-stencil format, pname:usage includes @@ -2246,6 +2295,39 @@ include::{generated}/validity/structs/VkExternalFormatANDROID.adoc[] -- endif::VK_ANDROID_external_memory_android_hardware_buffer[] +ifdef::VK_QNX_external_memory_screen_buffer[] +[open,refpage='VkExternalFormatQNX',desc='Structure containing a QNX Screen buffer external format',type='structs'] +-- +To create an image with an +<>, add a sname:VkExternalFormatQNX structure in the pname:pNext +chain of slink:VkImageCreateInfo. +sname:VkExternalFormatQNX is defined as: + +include::{generated}/api/structs/VkExternalFormatQNX.adoc[] + + * pname:sType is the type of this structure. + * pname:pNext is `NULL` or a pointer to a structure extending this + structure. + * pname:externalFormat is an implementation-defined identifier for the + external format + +If pname:externalFormat is zero, the effect is as if the +sname:VkExternalFormatQNX structure was not present. +Otherwise, the pname:image will have the specified external format. + +.Valid Usage +**** + * pname:externalFormat must: be `0` or a value returned in the + pname:externalFormat member of + slink:VkScreenBufferFormatPropertiesQNX by an earlier call + to flink:vkGetScreenBufferPropertiesQNX +**** + +include::{generated}/validity/structs/VkExternalFormatQNX.adoc[] +-- +endif::VK_QNX_external_memory_screen_buffer[] + ifdef::VK_VERSION_1_1,VK_KHR_device_group[] ifdef::VK_KHR_swapchain[] [open,refpage='VkImageSwapchainCreateInfoKHR',desc='Specify that an image will be bound to swapchain memory',type='structs'] @@ -3052,12 +3134,12 @@ endif::VK_EXT_image_drm_format_modifier[] fname:vkGetImageSubresourceLayout is invariant for the lifetime of a single image. -ifdef::VK_ANDROID_external_memory_android_hardware_buffer[] -However, the subresource layout of images in Android hardware buffer +ifdef::VK_ANDROID_external_memory_android_hardware_buffer,VK_QNX_external_memory_screen_buffer[] +However, the subresource layout of images in Android hardware buffer or QNX Screen buffer external memory is not known until the image has been bound to memory, so applications must: not call flink:vkGetImageSubresourceLayout for such an image before it has been bound. -endif::VK_ANDROID_external_memory_android_hardware_buffer[] +endif::VK_ANDROID_external_memory_android_hardware_buffer,VK_QNX_external_memory_screen_buffer[] .Valid Usage **** @@ -3396,6 +3478,16 @@ ifdef::VK_ANDROID_external_memory_android_hardware_buffer[] <>, endif::VK_ANDROID_external_memory_android_hardware_buffer[] +ifdef::VK_QNX_external_memory_screen_buffer[] +ifndef::VK_ANDROID_external_memory_android_hardware_buffer[] + but without a +endif::VK_ANDROID_external_memory_android_hardware_buffer[] +ifdef::VK_ANDROID_external_memory_android_hardware_buffer[] + or a +endif::VK_ANDROID_external_memory_android_hardware_buffer[] + <> +endif::VK_QNX_external_memory_screen_buffer[] ifdef::VK_FUCHSIA_buffer_collection[] ifndef::VK_ANDROID_external_memory_android_hardware_buffer[] but without an @@ -3419,6 +3511,16 @@ ifdef::VK_ANDROID_external_memory_android_hardware_buffer[] the Android hardware buffer that was imported to the slink:VkDeviceMemory to which the image is bound. endif::VK_ANDROID_external_memory_android_hardware_buffer[] +ifdef::VK_QNX_external_memory_screen_buffer[] + * If the image was created with an + <>, then its set of _format features_ is + the value of + slink:VkScreenBufferFormatPropertiesQNX::pname:formatFeatures + found by calling flink:vkGetScreenBufferPropertiesQNX on + the QNX Screen buffer that was imported to the + slink:VkDeviceMemory to which the image is bound. +endif::VK_QNX_external_memory_screen_buffer[] ifdef::VK_EXT_image_drm_format_modifier[] * If the image was created with ename:VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT, then: @@ -4465,20 +4567,34 @@ endif::VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion[] ifdef::VK_ANDROID_external_memory_android_hardware_buffer[] * [[VUID-VkImageViewCreateInfo-image-02399]] If pname:image has an - <>, pname:format must: be ename:VK_FORMAT_UNDEFINED * [[VUID-VkImageViewCreateInfo-image-02400]] If pname:image has an - <>, the pname:pNext chain must: include a slink:VkSamplerYcbcrConversionInfo structure with a pname:conversion object created with the same external format as pname:image * [[VUID-VkImageViewCreateInfo-image-02401]] If pname:image has an - <>, all members of pname:components must: be the <> endif::VK_ANDROID_external_memory_android_hardware_buffer[] +ifdef::VK_QNX_external_memory_screen_buffer[] + * If pname:image has an + <>, pname:format must: be ename:VK_FORMAT_UNDEFINED + * If pname:image has an + <>, the pname:pNext chain must: include a + slink:VkSamplerYcbcrConversionInfo structure with a pname:conversion + object created with the same external format as pname:image + * If pname:image has an + <>, all members of pname:components must: be the + <> +endif::VK_QNX_external_memory_screen_buffer[] ifdef::VK_KHR_fragment_shading_rate,VK_NV_shading_rate_image[] * [[VUID-VkImageViewCreateInfo-image-02086]] If pname:image was created with pname:usage containing @@ -5384,6 +5500,11 @@ ifdef::VK_ANDROID_external_memory_android_hardware_buffer[] <>, endif::VK_ANDROID_external_memory_android_hardware_buffer[] +ifdef::VK_QNX_external_memory_screen_buffer[] + or a + <>, +endif::VK_QNX_external_memory_screen_buffer[] then the image view's set of _format features_ is the value of slink:VkFormatProperties::pname:optimalTilingFeatures found by calling flink:vkGetPhysicalDeviceFormatProperties on the same pname:format as @@ -5398,6 +5519,10 @@ ifdef::VK_ANDROID_external_memory_android_hardware_buffer[] <>, endif::VK_ANDROID_external_memory_android_hardware_buffer[] +ifdef::VK_QNX_external_memory_screen_buffer[] + or a <>, +endif::VK_QNX_external_memory_screen_buffer[] then the image view's set of _format features_ is the value of slink:VkFormatProperties::pname:optimalTilingFeatures or slink:VkFormatProperties3::pname:optimalTilingFeatures found by calling @@ -5413,6 +5538,10 @@ ifdef::VK_ANDROID_external_memory_android_hardware_buffer[] <>, endif::VK_ANDROID_external_memory_android_hardware_buffer[] +ifdef::VK_QNX_external_memory_screen_buffer[] + or a <>, +endif::VK_QNX_external_memory_screen_buffer[] then the image view's set of _format features_ is the union of the value of slink:VkFormatProperties::pname:optimalTilingFeatures found by calling flink:vkGetPhysicalDeviceFormatProperties on the same @@ -5440,6 +5569,17 @@ ifdef::VK_ANDROID_external_memory_android_hardware_buffer[] slink:VkDeviceMemory to which the slink:VkImageViewCreateInfo::pname:image is bound. endif::VK_ANDROID_external_memory_android_hardware_buffer[] +ifdef::VK_QNX_external_memory_screen_buffer[] + * If slink:VkImageViewCreateInfo::pname:image was created with a + <>, then the image views's set of _format + features_ is the value of + slink:VkScreenBufferFormatPropertiesQNX::pname:formatFeatures + found by calling flink:vkGetScreenBufferPropertiesQNX on + the QNX Screen buffer that was imported to the + slink:VkDeviceMemory to which the + slink:VkImageViewCreateInfo::pname:image is bound. +endif::VK_QNX_external_memory_screen_buffer[] ifdef::VK_FUCHSIA_buffer_collection[] * If slink:VkImageViewCreateInfo::pname:image was created with a chained slink:VkBufferCollectionImageCreateInfoFUCHSIA, then the image view's @@ -7258,6 +7398,11 @@ ifdef::VK_ANDROID_external_memory_android_hardware_buffer[] ename:VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID external memory handle type, then pname:image must: be bound to memory endif::VK_ANDROID_external_memory_android_hardware_buffer[] +ifdef::VK_QNX_external_memory_screen_buffer[] + * If pname:image was created with the + ename:VK_EXTERNAL_MEMORY_HANDLE_TYPE_SCREEN_BUFFER_BIT_QNX + external memory handle type, then pname:image must: be bound to memory +endif::VK_QNX_external_memory_screen_buffer[] **** include::{generated}/validity/protos/vkGetImageMemoryRequirements.adoc[] @@ -7695,6 +7840,11 @@ ifdef::VK_ANDROID_external_memory_android_hardware_buffer[] ename:VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID external memory handle type, then pname:image must: be bound to memory endif::VK_ANDROID_external_memory_android_hardware_buffer[] +ifdef::VK_QNX_external_memory_screen_buffer[] + * If pname:image was created with the + ename:VK_EXTERNAL_MEMORY_HANDLE_TYPE_SCREEN_BUFFER_BIT_QNX + external memory handle type, then pname:image must: be bound to memory +endif::VK_QNX_external_memory_screen_buffer[] **** endif::VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion[] @@ -7749,6 +7899,14 @@ ifdef::VK_VERSION_1_3,VK_KHR_maintenance4[] structure with non-zero pname:externalFormat endif::VK_VERSION_1_3,VK_KHR_maintenance4[] endif::VK_ANDROID_external_memory_android_hardware_buffer[] +ifdef::VK_QNX_external_memory_screen_buffer[] +ifdef::VK_VERSION_1_3,VK_KHR_maintenance4[] + * Applications also must: not call + flink:vkGetDeviceImageMemoryRequirements with a slink:VkImageCreateInfo + whose pname:pNext chain includes a slink:VkExternalFormatQNX + structure with non-zero pname:externalFormat +endif::VK_VERSION_1_3,VK_KHR_maintenance4[] +endif::VK_QNX_external_memory_screen_buffer[] * [[VUID-VkDeviceImageMemoryRequirementsKHR-pCreateInfo-06417]] If pname:pCreateInfo::pname:format specifies a _multi-planar_ format and pname:pCreateInfo::pname:flags has ename:VK_IMAGE_CREATE_DISJOINT_BIT diff --git a/scripts/genvk.py b/scripts/genvk.py index 98618c124d..e4bfe09065 100755 --- a/scripts/genvk.py +++ b/scripts/genvk.py @@ -435,7 +435,8 @@ def makeGenOpts(args): [ 'vulkan_xlib_xrandr.h', [ 'VK_EXT_acquire_xlib_display' ], commonSuppressExtensions ], [ 'vulkan_metal.h', [ 'VK_EXT_metal_surface', 'VK_EXT_metal_objects' ], commonSuppressExtensions ], - [ 'vulkan_screen.h', [ 'VK_QNX_screen_surface' ], commonSuppressExtensions ], + [ 'vulkan_screen.h', [ 'VK_QNX_screen_surface', + 'VK_QNX_external_memory_screen_buffer' ], commonSuppressExtensions ], [ 'vulkan_sci.h', [ 'VK_NV_external_sci_sync', 'VK_NV_external_sci_sync2', 'VK_NV_external_memory_sci_buf'], commonSuppressExtensions ], diff --git a/tests/screen/screen.h b/tests/screen/screen.h index 4f73f08090..028deca153 100644 --- a/tests/screen/screen.h +++ b/tests/screen/screen.h @@ -6,3 +6,4 @@ struct _screen_context; struct _screen_window; +struct _screen_buffer; diff --git a/xml/vk.xml b/xml/vk.xml index f5300a330a..5399c2bc0f 100644 --- a/xml/vk.xml +++ b/xml/vk.xml @@ -71,7 +71,7 @@ branch of the member gitlab server. - + @@ -134,6 +134,7 @@ branch of the member gitlab server. + @@ -8195,6 +8196,40 @@ typedef void* MTLSharedEvent_id; VkBool32 shaderTileImageReadSampleFromPixelRateInvocation VkBool32 shaderTileImageReadFromHelperInvocation + + VkStructureType sType + const void* pNext + struct _screen_buffer* buffer + + + VkStructureType sType + void* pNext + VkDeviceSize allocationSize + uint32_t memoryTypeBits + + + VkStructureType sType + void* pNext + VkFormat format + uint64_t externalFormat + uint64_t screenUsage + VkFormatFeatureFlags formatFeatures + VkComponentMapping samplerYcbcrConversionComponents + VkSamplerYcbcrModelConversion suggestedYcbcrModel + VkSamplerYcbcrRange suggestedYcbcrRange + VkChromaLocation suggestedXChromaOffset + VkChromaLocation suggestedYChromaOffset + + + VkStructureType sType + void* pNext + uint64_t externalFormat + + + VkStructureType sType + void* pNext + VkBool32 screenBufferImport + @@ -14110,6 +14145,12 @@ typedef void* MTLSharedEvent_id; const VkShaderStageFlagBits* pStages const VkShaderEXT* pShaders + + VkResult vkGetScreenBufferPropertiesQNX + VkDevice device + const struct _screen_buffer* buffer + VkScreenBufferPropertiesQNX* pProperties + @@ -22189,11 +22230,22 @@ typedef void* MTLSharedEvent_id; - - - - - + + + + + + + + + + + + + + + +