Graphics.Vulkan.Core11.Promoted_from_VK_KHR_sampler_ycbcr_conversion

Documentation

newtype VkSamplerYcbcrModelConversion

VkSamplerYcbcrModelConversion - Color model component of a color space

Description

• VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY specifies that the input values to the conversion are unmodified.

• VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY specifies no model conversion but the inputs are range expanded as for Y’CBCR.
• VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709 specifies the color model conversion from Y’CBCR to R’G’B' defined in BT.709 and described in the “BT.709 Y’CBCR conversion” section of the Khronos Data Format Specification.
• VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601 specifies the color model conversion from Y’CBCR to R’G’B' defined in BT.601 and described in the “BT.601 Y’CBCR conversion” section of the Khronos Data Format Specification.
• VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020 specifies the color model conversion from Y’CBCR to R’G’B' defined in BT.2020 and described in the “BT.2020 Y’CBCR conversion” section of the Khronos Data Format Specification.

In the VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_* color models, for the input to the sampler Y’CBCR range expansion and model conversion:

• the Y (Y' luma) channel corresponds to the G channel of an RGB image.
• the CB (CB or “U” blue color difference) channel corresponds to the B channel of an RGB image.
• the CR (CR or “V” red color difference) channel corresponds to the R channel of an RGB image.
• the alpha channel, if present, is not modified by color model conversion.

These rules reflect the mapping of channels after the channel swizzle operation (controlled by VkSamplerYcbcrConversionCreateInfo::components).

Note

For example, an “YUVA” 32-bit format comprising four 8-bit channels can be implemented as VK_FORMAT_R8G8B8A8_UNORM with a component mapping:

• components.a = VK_COMPONENT_SWIZZLE_IDENTITY
• components.r = VK_COMPONENT_SWIZZLE_B
• components.g = VK_COMPONENT_SWIZZLE_R
• components.b = VK_COMPONENT_SWIZZLE_G

See Also

VkAndroidHardwareBufferFormatPropertiesANDROID, VkSamplerYcbcrConversionCreateInfo

Constructors

VkSamplerYcbcrModelConversion Int32

Instances

Eq VkSamplerYcbcrModelConversion

Methods

(==) :: VkSamplerYcbcrModelConversion -> VkSamplerYcbcrModelConversion -> Bool

(/=) :: VkSamplerYcbcrModelConversion -> VkSamplerYcbcrModelConversion -> Bool

Ord VkSamplerYcbcrModelConversion

Methods

compare :: VkSamplerYcbcrModelConversion -> VkSamplerYcbcrModelConversion -> Ordering

(<) :: VkSamplerYcbcrModelConversion -> VkSamplerYcbcrModelConversion -> Bool

(<=) :: VkSamplerYcbcrModelConversion -> VkSamplerYcbcrModelConversion -> Bool

(>) :: VkSamplerYcbcrModelConversion -> VkSamplerYcbcrModelConversion -> Bool

(>=) :: VkSamplerYcbcrModelConversion -> VkSamplerYcbcrModelConversion -> Bool

max :: VkSamplerYcbcrModelConversion -> VkSamplerYcbcrModelConversion -> VkSamplerYcbcrModelConversion

min :: VkSamplerYcbcrModelConversion -> VkSamplerYcbcrModelConversion -> VkSamplerYcbcrModelConversion

Read VkSamplerYcbcrModelConversion

Methods

readsPrec :: Int -> ReadS VkSamplerYcbcrModelConversion

readList :: ReadS [VkSamplerYcbcrModelConversion]

readPrec :: ReadPrec VkSamplerYcbcrModelConversion

readListPrec :: ReadPrec [VkSamplerYcbcrModelConversion]

Show VkSamplerYcbcrModelConversion

Methods

showsPrec :: Int -> VkSamplerYcbcrModelConversion -> ShowS

show :: VkSamplerYcbcrModelConversion -> String

showList :: [VkSamplerYcbcrModelConversion] -> ShowS

Storable VkSamplerYcbcrModelConversion

Methods

sizeOf :: VkSamplerYcbcrModelConversion -> Int

alignment :: VkSamplerYcbcrModelConversion -> Int

peekElemOff :: Ptr VkSamplerYcbcrModelConversion -> Int -> IO VkSamplerYcbcrModelConversion

pokeElemOff :: Ptr VkSamplerYcbcrModelConversion -> Int -> VkSamplerYcbcrModelConversion -> IO ()

peekByteOff :: Ptr b -> Int -> IO VkSamplerYcbcrModelConversion

pokeByteOff :: Ptr b -> Int -> VkSamplerYcbcrModelConversion -> IO ()

peek :: Ptr VkSamplerYcbcrModelConversion -> IO VkSamplerYcbcrModelConversion

poke :: Ptr VkSamplerYcbcrModelConversion -> VkSamplerYcbcrModelConversion -> IO ()

pattern VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY :: VkSamplerYcbcrModelConversion

pattern VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY :: VkSamplerYcbcrModelConversion

pattern VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709 :: VkSamplerYcbcrModelConversion

pattern VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601 :: VkSamplerYcbcrModelConversion

pattern VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020 :: VkSamplerYcbcrModelConversion

newtype VkSamplerYcbcrRange

VkSamplerYcbcrRange - Range of encoded values in a color space

Description

• VK_SAMPLER_YCBCR_RANGE_ITU_FULL specifies that the full range of the encoded values are valid and interpreted according to the ITU “full range” quantization rules.

• VK_SAMPLER_YCBCR_RANGE_ITU_NARROW specifies that headroom and foot room are reserved in the numerical range of encoded values, and the remaining values are expanded according to the ITU “narrow range” quantization rules.

The formulae for these conversions is described in the Sampler Y’CBCR Range Expansion section of the Image Operations chapter.

No range modification takes place if ycbcrModel is VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY; the ycbcrRange field of VkSamplerYcbcrConversionCreateInfo is ignored in this case.

See Also

VkAndroidHardwareBufferFormatPropertiesANDROID, VkSamplerYcbcrConversionCreateInfo

Constructors

VkSamplerYcbcrRange Int32

Instances

Eq VkSamplerYcbcrRange

Methods

(==) :: VkSamplerYcbcrRange -> VkSamplerYcbcrRange -> Bool

(/=) :: VkSamplerYcbcrRange -> VkSamplerYcbcrRange -> Bool

Ord VkSamplerYcbcrRange

Methods

compare :: VkSamplerYcbcrRange -> VkSamplerYcbcrRange -> Ordering

(<) :: VkSamplerYcbcrRange -> VkSamplerYcbcrRange -> Bool

(<=) :: VkSamplerYcbcrRange -> VkSamplerYcbcrRange -> Bool

(>) :: VkSamplerYcbcrRange -> VkSamplerYcbcrRange -> Bool

(>=) :: VkSamplerYcbcrRange -> VkSamplerYcbcrRange -> Bool

max :: VkSamplerYcbcrRange -> VkSamplerYcbcrRange -> VkSamplerYcbcrRange

min :: VkSamplerYcbcrRange -> VkSamplerYcbcrRange -> VkSamplerYcbcrRange

Read VkSamplerYcbcrRange

Methods

readsPrec :: Int -> ReadS VkSamplerYcbcrRange

readList :: ReadS [VkSamplerYcbcrRange]

readPrec :: ReadPrec VkSamplerYcbcrRange

readListPrec :: ReadPrec [VkSamplerYcbcrRange]

Show VkSamplerYcbcrRange

Methods

showsPrec :: Int -> VkSamplerYcbcrRange -> ShowS

show :: VkSamplerYcbcrRange -> String

showList :: [VkSamplerYcbcrRange] -> ShowS

Storable VkSamplerYcbcrRange

Methods

sizeOf :: VkSamplerYcbcrRange -> Int

alignment :: VkSamplerYcbcrRange -> Int

peekElemOff :: Ptr VkSamplerYcbcrRange -> Int -> IO VkSamplerYcbcrRange

pokeElemOff :: Ptr VkSamplerYcbcrRange -> Int -> VkSamplerYcbcrRange -> IO ()

peekByteOff :: Ptr b -> Int -> IO VkSamplerYcbcrRange

pokeByteOff :: Ptr b -> Int -> VkSamplerYcbcrRange -> IO ()

peek :: Ptr VkSamplerYcbcrRange -> IO VkSamplerYcbcrRange

poke :: Ptr VkSamplerYcbcrRange -> VkSamplerYcbcrRange -> IO ()

pattern VK_SAMPLER_YCBCR_RANGE_ITU_FULL :: VkSamplerYcbcrRange

pattern VK_SAMPLER_YCBCR_RANGE_ITU_NARROW :: VkSamplerYcbcrRange

newtype VkChromaLocation

VkChromaLocation - Position of downsampled chroma samples

See Also

VkAndroidHardwareBufferFormatPropertiesANDROID, VkSamplerYcbcrConversionCreateInfo

Constructors

VkChromaLocation Int32

Instances

Eq VkChromaLocation

Methods

(==) :: VkChromaLocation -> VkChromaLocation -> Bool

(/=) :: VkChromaLocation -> VkChromaLocation -> Bool

Ord VkChromaLocation

Methods

compare :: VkChromaLocation -> VkChromaLocation -> Ordering

(<) :: VkChromaLocation -> VkChromaLocation -> Bool

(<=) :: VkChromaLocation -> VkChromaLocation -> Bool

(>) :: VkChromaLocation -> VkChromaLocation -> Bool

(>=) :: VkChromaLocation -> VkChromaLocation -> Bool

max :: VkChromaLocation -> VkChromaLocation -> VkChromaLocation

min :: VkChromaLocation -> VkChromaLocation -> VkChromaLocation

Read VkChromaLocation

Methods

readsPrec :: Int -> ReadS VkChromaLocation

readList :: ReadS [VkChromaLocation]

readPrec :: ReadPrec VkChromaLocation

readListPrec :: ReadPrec [VkChromaLocation]

Show VkChromaLocation

Methods

showsPrec :: Int -> VkChromaLocation -> ShowS

show :: VkChromaLocation -> String

showList :: [VkChromaLocation] -> ShowS

Storable VkChromaLocation

Methods

sizeOf :: VkChromaLocation -> Int

alignment :: VkChromaLocation -> Int

peekElemOff :: Ptr VkChromaLocation -> Int -> IO VkChromaLocation

pokeElemOff :: Ptr VkChromaLocation -> Int -> VkChromaLocation -> IO ()

peekByteOff :: Ptr b -> Int -> IO VkChromaLocation

pokeByteOff :: Ptr b -> Int -> VkChromaLocation -> IO ()

peek :: Ptr VkChromaLocation -> IO VkChromaLocation

poke :: Ptr VkChromaLocation -> VkChromaLocation -> IO ()

pattern VK_CHROMA_LOCATION_COSITED_EVEN :: VkChromaLocation

VK_CHROMA_LOCATION_COSITED_EVEN specifies that downsampled chroma samples are aligned with luma samples with even coordinates.

pattern VK_CHROMA_LOCATION_MIDPOINT :: VkChromaLocation

VK_CHROMA_LOCATION_MIDPOINT specifies that downsampled chroma samples are located half way between each even luma sample and the nearest higher odd luma sample.

pattern VK_FORMAT_G8B8G8R8_422_UNORM :: VkFormat

VK_FORMAT_G8B8G8R8_422_UNORM specifies a four-component, 32-bit format containing a pair of G components, an R component, and a B component, collectively encoding a 2×1 rectangle of unsigned normalized RGB texel data. One G value is present at each i coordinate, with the B and R values shared across both G values and thus recorded at half the horizontal resolution of the image. This format has an 8-bit G component for the even i coordinate in byte 0, an 8-bit B component in byte 1, an 8-bit G component for the odd i coordinate in byte 2, and an 8-bit R component in byte 3. Images in this format must be defined with a width that is a multiple of two. For the purposes of the constraints on copy extents, this format is treated as a compressed format with a 2×1 compressed texel block.

pattern VK_FORMAT_B8G8R8G8_422_UNORM :: VkFormat

VK_FORMAT_B8G8R8G8_422_UNORM specifies a four-component, 32-bit format containing a pair of G components, an R component, and a B component, collectively encoding a 2×1 rectangle of unsigned normalized RGB texel data. One G value is present at each i coordinate, with the B and R values shared across both G values and thus recorded at half the horizontal resolution of the image. This format has an 8-bit B component in byte 0, an 8-bit G component for the even i coordinate in byte 1, an 8-bit R component in byte 2, and an 8-bit G component for the odd i coordinate in byte 3. Images in this format must be defined with a width that is a multiple of two. For the purposes of the constraints on copy extents, this format is treated as a compressed format with a 2×1 compressed texel block.

pattern VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM :: VkFormat

VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM specifies a unsigned normalized multi-planar format that has an 8-bit G component in plane 0, an 8-bit B component in plane 1, and an 8-bit R component in plane 2. The horizontal and vertical dimensions of the R and B planes are halved relative to the image dimensions, and each R and B component is shared with the G components for which (\lfloor i_G \times 0.5 \rfloor = i_B = i_R) and (\lfloor j_G \times 0.5 \rfloor = j_B = j_R). The location of each plane when this image is in linear layout can be determined via vkGetImageSubresourceLayout, using VK_IMAGE_ASPECT_PLANE_0_BIT for the G plane, VK_IMAGE_ASPECT_PLANE_1_BIT for the B plane, and VK_IMAGE_ASPECT_PLANE_2_BIT for the R plane. Images in this format must be defined with a width and height that is a multiple of two.

pattern VK_FORMAT_G8_B8R8_2PLANE_420_UNORM :: VkFormat

VK_FORMAT_G8_B8R8_2PLANE_420_UNORM specifies a unsigned normalized multi-planar format that has an 8-bit G component in plane 0, and a two-component, 16-bit BR plane 1 consisting of an 8-bit B component in byte 0 and an 8-bit R component in byte 1. The horizontal and vertical dimensions of the BR plane is halved relative to the image dimensions, and each R and B value is shared with the G components for which (\lfloor i_G \times 0.5 \rfloor = i_B = i_R) and \(\\lfloor j_G \\times 0.5 \\rfloor = j_B = j_R\). The location of each plane when this image is in linear layout can be determined via vkGetImageSubresourceLayout, using VK_IMAGE_ASPECT_PLANE_0_BIT for the G plane, and VK_IMAGE_ASPECT_PLANE_1_BIT for the BR plane. Images in this format must be defined with a width and height that is a multiple of two.

pattern VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM :: VkFormat

VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM specifies a unsigned normalized multi-planar format that has an 8-bit G component in plane 0, an 8-bit B component in plane 1, and an 8-bit R component in plane 2. The horizontal dimension of the R and B plane is halved relative to the image dimensions, and each R and B value is shared with the G components for which \(\\lfloor i_G \\times 0.5 \\rfloor = i_B = i_R\). The location of each plane when this image is in linear layout can be determined via vkGetImageSubresourceLayout, using VK_IMAGE_ASPECT_PLANE_0_BIT for the G plane, VK_IMAGE_ASPECT_PLANE_1_BIT for the B plane, and VK_IMAGE_ASPECT_PLANE_2_BIT for the R plane. Images in this format must be defined with a width that is a multiple of two.

pattern VK_FORMAT_G8_B8R8_2PLANE_422_UNORM :: VkFormat

VK_FORMAT_G8_B8R8_2PLANE_422_UNORM specifies a unsigned normalized multi-planar format that has an 8-bit G component in plane 0, and a two-component, 16-bit BR plane 1 consisting of an 8-bit B component in byte 0 and an 8-bit R component in byte 1. The horizontal dimensions of the BR plane is halved relative to the image dimensions, and each R and B value is shared with the G components for which \(\\lfloor i_G \\times 0.5 \\rfloor = i_B = i_R\). The location of each plane when this image is in linear layout can be determined via vkGetImageSubresourceLayout, using VK_IMAGE_ASPECT_PLANE_0_BIT for the G plane, and VK_IMAGE_ASPECT_PLANE_1_BIT for the BR plane. Images in this format must be defined with a width that is a multiple of two.

pattern VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM :: VkFormat

VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM specifies a unsigned normalized multi-planar format that has an 8-bit G component in plane 0, an 8-bit B component in plane 1, and an 8-bit R component in plane 2. Each plane has the same dimensions and each R, G and B component contributes to a single texel. The location of each plane when this image is in linear layout can be determined via vkGetImageSubresourceLayout, using VK_IMAGE_ASPECT_PLANE_0_BIT for the G plane, VK_IMAGE_ASPECT_PLANE_1_BIT for the B plane, and VK_IMAGE_ASPECT_PLANE_2_BIT for the R plane.

pattern VK_FORMAT_R10X6_UNORM_PACK16 :: VkFormat

VK_FORMAT_R10X6_UNORM_PACK16 specifies a one-component, 16-bit unsigned normalized format that has a single 10-bit R component in the top 10 bits of a 16-bit word, with the bottom 6 bits set to 0.

pattern VK_FORMAT_R10X6G10X6_UNORM_2PACK16 :: VkFormat

VK_FORMAT_R10X6G10X6_UNORM_2PACK16 specifies a two-component, 32-bit unsigned normalized format that has a 10-bit R component in the top 10 bits of the word in bytes 0..1, and a 10-bit G component in the top 10 bits of the word in bytes 2..3, with the bottom 6 bits of each word set to 0.

pattern VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16 :: VkFormat

VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16 specifies a four-component, 64-bit unsigned normalized format that has a 10-bit R component in the top 10 bits of the word in bytes 0..1, a 10-bit G component in the top 10 bits of the word in bytes 2..3, a 10-bit B component in the top 10 bits of the word in bytes 4..5, and a 10-bit A component in the top 10 bits of the word in bytes 6..7, with the bottom 6 bits of each word set to 0.

pattern VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 :: VkFormat

VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 specifies a four-component, 64-bit format containing a pair of G components, an R component, and a B component, collectively encoding a 2×1 rectangle of unsigned normalized RGB texel data. One G value is present at each i coordinate, with the B and R values shared across both G values and thus recorded at half the horizontal resolution of the image. This format has a 10-bit G component for the even i coordinate in the top 10 bits of the word in bytes 0..1, a 10-bit B component in the top 10 bits of the word in bytes 2..3, a 10-bit G component for the odd i coordinate in the top 10 bits of the word in bytes 4..5, and a 10-bit R component in the top 10 bits of the word in bytes 6..7, with the bottom 6 bits of each word set to 0. Images in this format must be defined with a width that is a multiple of two. For the purposes of the constraints on copy extents, this format is treated as a compressed format with a 2×1 compressed texel block.

pattern VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 :: VkFormat

VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 specifies a four-component, 64-bit format containing a pair of G components, an R component, and a B component, collectively encoding a 2×1 rectangle of unsigned normalized RGB texel data. One G value is present at each i coordinate, with the B and R values shared across both G values and thus recorded at half the horizontal resolution of the image. This format has a 10-bit B component in the top 10 bits of the word in bytes 0..1, a 10-bit G component for the even i coordinate in the top 10 bits of the word in bytes 2..3, a 10-bit R component in the top 10 bits of the word in bytes 4..5, and a 10-bit G component for the odd i coordinate in the top 10 bits of the word in bytes 6..7, with the bottom 6 bits of each word set to 0. Images in this format must be defined with a width that is a multiple of two. For the purposes of the constraints on copy extents, this format is treated as a compressed format with a 2×1 compressed texel block.

pattern VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 :: VkFormat

VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 specifies a unsigned normalized multi-planar format that has a 10-bit G component in the top 10 bits of each 16-bit word of plane 0, a 10-bit B component in the top 10 bits of each 16-bit word of plane 1, and a 10-bit R component in the top 10 bits of each 16-bit word of plane 2, with the bottom 6 bits of each word set to 0. The horizontal and vertical dimensions of the R and B planes are halved relative to the image dimensions, and each R and B component is shared with the G components for which (\lfloor i_G \times 0.5 \rfloor = i_B = i_R) and (\lfloor j_G \times 0.5 \rfloor = j_B = j_R). The location of each plane when this image is in linear layout can be determined via vkGetImageSubresourceLayout, using VK_IMAGE_ASPECT_PLANE_0_BIT for the G plane, VK_IMAGE_ASPECT_PLANE_1_BIT for the B plane, and VK_IMAGE_ASPECT_PLANE_2_BIT for the R plane. Images in this format must be defined with a width and height that is a multiple of two.

pattern VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 :: VkFormat

VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 specifies a unsigned normalized multi-planar format that has a 10-bit G component in the top 10 bits of each 16-bit word of plane 0, and a two-component, 32-bit BR plane 1 consisting of a 10-bit B component in the top 10 bits of the word in bytes 0..1, and a 10-bit R component in the top 10 bits of the word in bytes 2..3, the bottom 6 bits of each word set to 0. The horizontal and vertical dimensions of the BR plane is halved relative to the image dimensions, and each R and B value is shared with the G components for which (\lfloor i_G \times 0.5 \rfloor = i_B = i_R) and \(\\lfloor j_G \\times 0.5 \\rfloor = j_B = j_R\). The location of each plane when this image is in linear layout can be determined via vkGetImageSubresourceLayout, using VK_IMAGE_ASPECT_PLANE_0_BIT for the G plane, and VK_IMAGE_ASPECT_PLANE_1_BIT for the BR plane. Images in this format must be defined with a width and height that is a multiple of two.

pattern VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 :: VkFormat

VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 specifies a unsigned normalized multi-planar format that has a 10-bit G component in the top 10 bits of each 16-bit word of plane 0, a 10-bit B component in the top 10 bits of each 16-bit word of plane 1, and a 10-bit R component in the top 10 bits of each 16-bit word of plane 2, with the bottom 6 bits of each word set to 0. The horizontal dimension of the R and B plane is halved relative to the image dimensions, and each R and B value is shared with the G components for which \(\\lfloor i_G \\times 0.5 \\rfloor = i_B = i_R\). The location of each plane when this image is in linear layout can be determined via vkGetImageSubresourceLayout, using VK_IMAGE_ASPECT_PLANE_0_BIT for the G plane, VK_IMAGE_ASPECT_PLANE_1_BIT for the B plane, and VK_IMAGE_ASPECT_PLANE_2_BIT for the R plane. Images in this format must be defined with a width that is a multiple of two.

pattern VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 :: VkFormat

VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 specifies a unsigned normalized multi-planar format that has a 10-bit G component in the top 10 bits of each 16-bit word of plane 0, and a two-component, 32-bit BR plane 1 consisting of a 10-bit B component in the top 10 bits of the word in bytes 0..1, and a 10-bit R component in the top 10 bits of the word in bytes 2..3, the bottom 6 bits of each word set to 0. The horizontal dimensions of the BR plane is halved relative to the image dimensions, and each R and B value is shared with the G components for which \(\\lfloor i_G \\times 0.5 \\rfloor = i_B = i_R\). The location of each plane when this image is in linear layout can be determined via vkGetImageSubresourceLayout, using VK_IMAGE_ASPECT_PLANE_0_BIT for the G plane, and VK_IMAGE_ASPECT_PLANE_1_BIT for the BR plane. Images in this format must be defined with a width that is a multiple of two.

pattern VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 :: VkFormat

VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 specifies a unsigned normalized multi-planar format that has a 10-bit G component in the top 10 bits of each 16-bit word of plane 0, a 10-bit B component in the top 10 bits of each 16-bit word of plane 1, and a 10-bit R component in the top 10 bits of each 16-bit word of plane 2, with the bottom 6 bits of each word set to 0. Each plane has the same dimensions and each R, G and B component contributes to a single texel. The location of each plane when this image is in linear layout can be determined via vkGetImageSubresourceLayout, using VK_IMAGE_ASPECT_PLANE_0_BIT for the G plane, VK_IMAGE_ASPECT_PLANE_1_BIT for the B plane, and VK_IMAGE_ASPECT_PLANE_2_BIT for the R plane.

pattern VK_FORMAT_R12X4_UNORM_PACK16 :: VkFormat

VK_FORMAT_R12X4_UNORM_PACK16 specifies a one-component, 16-bit unsigned normalized format that has a single 12-bit R component in the top 12 bits of a 16-bit word, with the bottom 4 bits set to 0.

pattern VK_FORMAT_R12X4G12X4_UNORM_2PACK16 :: VkFormat

VK_FORMAT_R12X4G12X4_UNORM_2PACK16 specifies a two-component, 32-bit unsigned normalized format that has a 12-bit R component in the top 12 bits of the word in bytes 0..1, and a 12-bit G component in the top 12 bits of the word in bytes 2..3, with the bottom 4 bits of each word set to 0.

pattern VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16 :: VkFormat

VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16 specifies a four-component, 64-bit unsigned normalized format that has a 12-bit R component in the top 12 bits of the word in bytes 0..1, a 12-bit G component in the top 12 bits of the word in bytes 2..3, a 12-bit B component in the top 12 bits of the word in bytes 4..5, and a 12-bit A component in the top 12 bits of the word in bytes 6..7, with the bottom 4 bits of each word set to 0.

pattern VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 :: VkFormat

VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 specifies a four-component, 64-bit format containing a pair of G components, an R component, and a B component, collectively encoding a 2×1 rectangle of unsigned normalized RGB texel data. One G value is present at each i coordinate, with the B and R values shared across both G values and thus recorded at half the horizontal resolution of the image. This format has a 12-bit G component for the even i coordinate in the top 12 bits of the word in bytes 0..1, a 12-bit B component in the top 12 bits of the word in bytes 2..3, a 12-bit G component for the odd i coordinate in the top 12 bits of the word in bytes 4..5, and a 12-bit R component in the top 12 bits of the word in bytes 6..7, with the bottom 4 bits of each word set to 0. Images in this format must be defined with a width that is a multiple of two. For the purposes of the constraints on copy extents, this format is treated as a compressed format with a 2×1 compressed texel block.

pattern VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 :: VkFormat

VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 specifies a four-component, 64-bit format containing a pair of G components, an R component, and a B component, collectively encoding a 2×1 rectangle of unsigned normalized RGB texel data. One G value is present at each i coordinate, with the B and R values shared across both G values and thus recorded at half the horizontal resolution of the image. This format has a 12-bit B component in the top 12 bits of the word in bytes 0..1, a 12-bit G component for the even i coordinate in the top 12 bits of the word in bytes 2..3, a 12-bit R component in the top 12 bits of the word in bytes 4..5, and a 12-bit G component for the odd i coordinate in the top 12 bits of the word in bytes 6..7, with the bottom 4 bits of each word set to 0. Images in this format must be defined with a width that is a multiple of two. For the purposes of the constraints on copy extents, this format is treated as a compressed format with a 2×1 compressed texel block.

pattern VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 :: VkFormat

VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 specifies a unsigned normalized multi-planar format that has a 12-bit G component in the top 12 bits of each 16-bit word of plane 0, a 12-bit B component in the top 12 bits of each 16-bit word of plane 1, and a 12-bit R component in the top 12 bits of each 16-bit word of plane 2, with the bottom 4 bits of each word set to 0. The horizontal and vertical dimensions of the R and B planes are halved relative to the image dimensions, and each R and B component is shared with the G components for which (\lfloor i_G \times 0.5 \rfloor = i_B = i_R) and (\lfloor j_G \times 0.5 \rfloor = j_B = j_R). The location of each plane when this image is in linear layout can be determined via vkGetImageSubresourceLayout, using VK_IMAGE_ASPECT_PLANE_0_BIT for the G plane, VK_IMAGE_ASPECT_PLANE_1_BIT for the B plane, and VK_IMAGE_ASPECT_PLANE_2_BIT for the R plane. Images in this format must be defined with a width and height that is a multiple of two.

pattern VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 :: VkFormat

VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 specifies a unsigned normalized multi-planar format that has a 12-bit G component in the top 12 bits of each 16-bit word of plane 0, and a two-component, 32-bit BR plane 1 consisting of a 12-bit B component in the top 12 bits of the word in bytes 0..1, and a 12-bit R component in the top 12 bits of the word in bytes 2..3, the bottom 4 bits of each word set to 0. The horizontal and vertical dimensions of the BR plane is halved relative to the image dimensions, and each R and B value is shared with the G components for which (\lfloor i_G \times 0.5 \rfloor = i_B = i_R) and \(\\lfloor j_G \\times 0.5 \\rfloor = j_B = j_R\). The location of each plane when this image is in linear layout can be determined via vkGetImageSubresourceLayout, using VK_IMAGE_ASPECT_PLANE_0_BIT for the G plane, and VK_IMAGE_ASPECT_PLANE_1_BIT for the BR plane. Images in this format must be defined with a width and height that is a multiple of two.

pattern VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 :: VkFormat

VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 specifies a unsigned normalized multi-planar format that has a 12-bit G component in the top 12 bits of each 16-bit word of plane 0, a 12-bit B component in the top 12 bits of each 16-bit word of plane 1, and a 12-bit R component in the top 12 bits of each 16-bit word of plane 2, with the bottom 4 bits of each word set to 0. The horizontal dimension of the R and B plane is halved relative to the image dimensions, and each R and B value is shared with the G components for which \(\\lfloor i_G \\times 0.5 \\rfloor = i_B = i_R\). The location of each plane when this image is in linear layout can be determined via vkGetImageSubresourceLayout, using VK_IMAGE_ASPECT_PLANE_0_BIT for the G plane, VK_IMAGE_ASPECT_PLANE_1_BIT for the B plane, and VK_IMAGE_ASPECT_PLANE_2_BIT for the R plane. Images in this format must be defined with a width that is a multiple of two.

pattern VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 :: VkFormat

VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 specifies a unsigned normalized multi-planar format that has a 12-bit G component in the top 12 bits of each 16-bit word of plane 0, and a two-component, 32-bit BR plane 1 consisting of a 12-bit B component in the top 12 bits of the word in bytes 0..1, and a 12-bit R component in the top 12 bits of the word in bytes 2..3, the bottom 4 bits of each word set to 0. The horizontal dimensions of the BR plane is halved relative to the image dimensions, and each R and B value is shared with the G components for which \(\\lfloor i_G \\times 0.5 \\rfloor = i_B = i_R\). The location of each plane when this image is in linear layout can be determined via vkGetImageSubresourceLayout, using VK_IMAGE_ASPECT_PLANE_0_BIT for the G plane, and VK_IMAGE_ASPECT_PLANE_1_BIT for the BR plane. Images in this format must be defined with a width that is a multiple of two.

pattern VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 :: VkFormat

VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 specifies a unsigned normalized multi-planar format that has a 12-bit G component in the top 12 bits of each 16-bit word of plane 0, a 12-bit B component in the top 12 bits of each 16-bit word of plane 1, and a 12-bit R component in the top 12 bits of each 16-bit word of plane 2, with the bottom 4 bits of each word set to 0. Each plane has the same dimensions and each R, G and B component contributes to a single texel. The location of each plane when this image is in linear layout can be determined via vkGetImageSubresourceLayout, using VK_IMAGE_ASPECT_PLANE_0_BIT for the G plane, VK_IMAGE_ASPECT_PLANE_1_BIT for the B plane, and VK_IMAGE_ASPECT_PLANE_2_BIT for the R plane.

pattern VK_FORMAT_G16B16G16R16_422_UNORM :: VkFormat

VK_FORMAT_G16B16G16R16_422_UNORM specifies a four-component, 64-bit format containing a pair of G components, an R component, and a B component, collectively encoding a 2×1 rectangle of unsigned normalized RGB texel data. One G value is present at each i coordinate, with the B and R values shared across both G values and thus recorded at half the horizontal resolution of the image. This format has a 16-bit G component for the even i coordinate in the word in bytes 0..1, a 16-bit B component in the word in bytes 2..3, a 16-bit G component for the odd i coordinate in the word in bytes 4..5, and a 16-bit R component in the word in bytes 6..7. Images in this format must be defined with a width that is a multiple of two. For the purposes of the constraints on copy extents, this format is treated as a compressed format with a 2×1 compressed texel block.

pattern VK_FORMAT_B16G16R16G16_422_UNORM :: VkFormat

VK_FORMAT_B16G16R16G16_422_UNORM specifies a four-component, 64-bit format containing a pair of G components, an R component, and a B component, collectively encoding a 2×1 rectangle of unsigned normalized RGB texel data. One G value is present at each i coordinate, with the B and R values shared across both G values and thus recorded at half the horizontal resolution of the image. This format has a 16-bit B component in the word in bytes 0..1, a 16-bit G component for the even i coordinate in the word in bytes 2..3, a 16-bit R component in the word in bytes 4..5, and a 16-bit G component for the odd i coordinate in the word in bytes 6..7. Images in this format must be defined with a width that is a multiple of two. For the purposes of the constraints on copy extents, this format is treated as a compressed format with a 2×1 compressed texel block.

pattern VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM :: VkFormat

VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM specifies a unsigned normalized multi-planar format that has a 16-bit G component in each 16-bit word of plane 0, a 16-bit B component in each 16-bit word of plane 1, and a 16-bit R component in each 16-bit word of plane 2. The horizontal and vertical dimensions of the R and B planes are halved relative to the image dimensions, and each R and B component is shared with the G components for which (\lfloor i_G \times 0.5 \rfloor = i_B = i_R) and (\lfloor j_G \times 0.5 \rfloor = j_B = j_R). The location of each plane when this image is in linear layout can be determined via vkGetImageSubresourceLayout, using VK_IMAGE_ASPECT_PLANE_0_BIT for the G plane, VK_IMAGE_ASPECT_PLANE_1_BIT for the B plane, and VK_IMAGE_ASPECT_PLANE_2_BIT for the R plane. Images in this format must be defined with a width and height that is a multiple of two.

pattern VK_FORMAT_G16_B16R16_2PLANE_420_UNORM :: VkFormat

VK_FORMAT_G16_B16R16_2PLANE_420_UNORM specifies a unsigned normalized multi-planar format that has a 16-bit G component in each 16-bit word of plane 0, and a two-component, 32-bit BR plane 1 consisting of a 16-bit B component in the word in bytes 0..1, and a 16-bit R component in the word in bytes 2..3. The horizontal and vertical dimensions of the BR plane is halved relative to the image dimensions, and each R and B value is shared with the G components for which (\lfloor i_G \times 0.5 \rfloor = i_B = i_R) and \(\\lfloor j_G \\times 0.5 \\rfloor = j_B = j_R\). The location of each plane when this image is in linear layout can be determined via vkGetImageSubresourceLayout, using VK_IMAGE_ASPECT_PLANE_0_BIT for the G plane, and VK_IMAGE_ASPECT_PLANE_1_BIT for the BR plane. Images in this format must be defined with a width and height that is a multiple of two.

pattern VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM :: VkFormat

VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM specifies a unsigned normalized multi-planar format that has a 16-bit G component in each 16-bit word of plane 0, a 16-bit B component in each 16-bit word of plane 1, and a 16-bit R component in each 16-bit word of plane 2. The horizontal dimension of the R and B plane is halved relative to the image dimensions, and each R and B value is shared with the G components for which \(\\lfloor i_G \\times 0.5 \\rfloor = i_B = i_R\). The location of each plane when this image is in linear layout can be determined via vkGetImageSubresourceLayout, using VK_IMAGE_ASPECT_PLANE_0_BIT for the G plane, VK_IMAGE_ASPECT_PLANE_1_BIT for the B plane, and VK_IMAGE_ASPECT_PLANE_2_BIT for the R plane. Images in this format must be defined with a width that is a multiple of two.

pattern VK_FORMAT_G16_B16R16_2PLANE_422_UNORM :: VkFormat

VK_FORMAT_G16_B16R16_2PLANE_422_UNORM specifies a unsigned normalized multi-planar format that has a 16-bit G component in each 16-bit word of plane 0, and a two-component, 32-bit BR plane 1 consisting of a 16-bit B component in the word in bytes 0..1, and a 16-bit R component in the word in bytes 2..3. The horizontal dimensions of the BR plane is halved relative to the image dimensions, and each R and B value is shared with the G components for which \(\\lfloor i_G \\times 0.5 \\rfloor = i_B = i_R\). The location of each plane when this image is in linear layout can be determined via vkGetImageSubresourceLayout, using VK_IMAGE_ASPECT_PLANE_0_BIT for the G plane, and VK_IMAGE_ASPECT_PLANE_1_BIT for the BR plane. Images in this format must be defined with a width that is a multiple of two.

pattern VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM :: VkFormat

VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM specifies a unsigned normalized multi-planar format that has a 16-bit G component in each 16-bit word of plane 0, a 16-bit B component in each 16-bit word of plane 1, and a 16-bit R component in each 16-bit word of plane 2. Each plane has the same dimensions and each R, G and B component contributes to a single texel. The location of each plane when this image is in linear layout can be determined via vkGetImageSubresourceLayout, using VK_IMAGE_ASPECT_PLANE_0_BIT for the G plane, VK_IMAGE_ASPECT_PLANE_1_BIT for the B plane, and VK_IMAGE_ASPECT_PLANE_2_BIT for the R plane.

pattern VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO :: VkStructureType

pattern VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO :: VkStructureType

pattern VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO :: VkStructureType

pattern VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO :: VkStructureType

pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES :: VkStructureType

pattern VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES :: VkStructureType

pattern VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION :: VkObjectType

pattern VK_IMAGE_CREATE_DISJOINT_BIT :: VkImageCreateFlagBits

pattern VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT :: VkFormatFeatureFlagBits

pattern VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT :: VkFormatFeatureFlagBits

pattern VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT :: VkFormatFeatureFlagBits

pattern VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT :: VkFormatFeatureFlagBits

pattern VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT :: VkFormatFeatureFlagBits

pattern VK_FORMAT_FEATURE_DISJOINT_BIT :: VkFormatFeatureFlagBits

pattern VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT :: VkFormatFeatureFlagBits

pattern VK_IMAGE_ASPECT_PLANE_0_BIT :: VkImageAspectFlagBits

pattern VK_IMAGE_ASPECT_PLANE_1_BIT :: VkImageAspectFlagBits

pattern VK_IMAGE_ASPECT_PLANE_2_BIT :: VkImageAspectFlagBits

type VkSamplerYcbcrConversion = Ptr VkSamplerYcbcrConversion_T

VkSamplerYcbcrConversion - NO SHORT DESCRIPTION PROVIDED

Description

See Also

VkSamplerYcbcrConversionInfo, vkCreateSamplerYcbcrConversion, vkCreateSamplerYcbcrConversionKHR, vkDestroySamplerYcbcrConversion, vkDestroySamplerYcbcrConversionKHR

vkCreateSamplerYcbcrConversion :: ("device" ::: VkDevice) -> ("pCreateInfo" ::: Ptr VkSamplerYcbcrConversionCreateInfo) -> ("pAllocator" ::: Ptr VkAllocationCallbacks) -> ("pYcbcrConversion" ::: Ptr VkSamplerYcbcrConversion) -> IO VkResult

vkCreateSamplerYcbcrConversion - Create a new Ycbcr conversion

Parameters

• device is the logical device that creates the sampler Y’CBCR conversion.

• pCreateInfo is a pointer to an instance of the VkSamplerYcbcrConversionCreateInfo specifying the requested sampler Y’CBCR conversion.
• pAllocator controls host memory allocation as described in the Memory Allocation chapter.
• pYcbcrConversion points to a VkSamplerYcbcrConversion handle in which the resulting sampler Y’CBCR conversion is returned.

Description

The interpretation of the configured sampler Y’CBCR conversion is described in more detail in the description of sampler Y’CBCR conversion in the Image Operations chapter.

Valid Usage

• The sampler Y’CBCR conversion feature must be enabled

Valid Usage (Implicit)

• device must be a valid VkDevice handle

• pCreateInfo must be a valid pointer to a valid VkSamplerYcbcrConversionCreateInfo structure
• If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
• pYcbcrConversion must be a valid pointer to a VkSamplerYcbcrConversion handle

Return Codes

Success

- VK_SUCCESS

Failure

- VK_ERROR_OUT_OF_HOST_MEMORY

• VK_ERROR_OUT_OF_DEVICE_MEMORY

See Also

VkAllocationCallbacks, VkDevice, VkSamplerYcbcrConversion, VkSamplerYcbcrConversionCreateInfo

vkDestroySamplerYcbcrConversion :: ("device" ::: VkDevice) -> ("ycbcrConversion" ::: VkSamplerYcbcrConversion) -> ("pAllocator" ::: Ptr VkAllocationCallbacks) -> IO ()

vkDestroySamplerYcbcrConversion - Destroy a created Y’CbCr conversion

Parameters

• device is the logical device that destroys the Y’CBCR conversion.

• ycbcrConversion is the conversion to destroy.
• pAllocator controls host memory allocation as described in the Memory Allocation chapter.

Description

Valid Usage (Implicit)

• device must be a valid VkDevice handle

• If ycbcrConversion is not VK_NULL_HANDLE, ycbcrConversion must be a valid VkSamplerYcbcrConversion handle
• If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
• If ycbcrConversion is a valid handle, it must have been created, allocated, or retrieved from device

Host Synchronization

• Host access to ycbcrConversion must be externally synchronized

See Also

VkAllocationCallbacks, VkDevice, VkSamplerYcbcrConversion

data VkSamplerYcbcrConversionInfo

VkSamplerYcbcrConversionInfo - Structure specifying Y’CbCr conversion to a sampler or image view

Description

Valid Usage (Implicit)

• sType must be VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO

• conversion must be a valid VkSamplerYcbcrConversion handle

See Also

VkSamplerYcbcrConversion, VkStructureType

Constructors

VkSamplerYcbcrConversionInfo

Fields

• vkSType :: VkStructureType

  sType is the type of this structure.

• vkPNext :: Ptr ()

  pNext is NULL or a pointer to an extension-specific structure.

• vkConversion :: VkSamplerYcbcrConversion

  conversion is a VkSamplerYcbcrConversion handle created with vkCreateSamplerYcbcrConversion.

Instances

Eq VkSamplerYcbcrConversionInfo

Methods

(==) :: VkSamplerYcbcrConversionInfo -> VkSamplerYcbcrConversionInfo -> Bool

(/=) :: VkSamplerYcbcrConversionInfo -> VkSamplerYcbcrConversionInfo -> Bool

Show VkSamplerYcbcrConversionInfo

Methods

showsPrec :: Int -> VkSamplerYcbcrConversionInfo -> ShowS

show :: VkSamplerYcbcrConversionInfo -> String

showList :: [VkSamplerYcbcrConversionInfo] -> ShowS

Storable VkSamplerYcbcrConversionInfo

Methods

sizeOf :: VkSamplerYcbcrConversionInfo -> Int

alignment :: VkSamplerYcbcrConversionInfo -> Int

peekElemOff :: Ptr VkSamplerYcbcrConversionInfo -> Int -> IO VkSamplerYcbcrConversionInfo

pokeElemOff :: Ptr VkSamplerYcbcrConversionInfo -> Int -> VkSamplerYcbcrConversionInfo -> IO ()

peekByteOff :: Ptr b -> Int -> IO VkSamplerYcbcrConversionInfo

pokeByteOff :: Ptr b -> Int -> VkSamplerYcbcrConversionInfo -> IO ()

peek :: Ptr VkSamplerYcbcrConversionInfo -> IO VkSamplerYcbcrConversionInfo

poke :: Ptr VkSamplerYcbcrConversionInfo -> VkSamplerYcbcrConversionInfo -> IO ()

data VkSamplerYcbcrConversionCreateInfo

VkSamplerYcbcrConversionCreateInfo - Structure specifying the parameters of the newly created conversion

Description

Note

Setting forceExplicitReconstruction to VK_TRUE may have a performance penalty on implementations where explicit reconstruction is not the default mode of operation.

If the pNext chain has an instance of VkExternalFormatANDROID with non-zero externalFormat member, the sampler Y’CBCR conversion object represents an external format conversion, and format must be VK_FORMAT_UNDEFINED. Such conversions must only be used to sample image views with a matching external format. When creating an external format conversion, the value of components is ignored.

Valid Usage

• If an external format conversion is being created, format must be VK_FORMAT_UNDEFINED, otherwise it must not be VK_FORMAT_UNDEFINED.

• format must support VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT or VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT
• If the format does not support VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT, xChromaOffset and yChromaOffset must not be VK_CHROMA_LOCATION_COSITED_EVEN
• If the format does not support VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT, xChromaOffset and yChromaOffset must not be VK_CHROMA_LOCATION_MIDPOINT
• format must represent unsigned normalized values (i.e. the format must be a UNORM format)

• If the format has a _422 or _420 suffix:

  • components.g must be VK_COMPONENT_SWIZZLE_IDENTITY
  • components.a must be VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_ONE, or VK_COMPONENT_SWIZZLE_ZERO
  • components.r must be VK_COMPONENT_SWIZZLE_IDENTITY or VK_COMPONENT_SWIZZLE_B
  • components.b must be VK_COMPONENT_SWIZZLE_IDENTITY or VK_COMPONENT_SWIZZLE_R
  • If either components.r or components.b is VK_COMPONENT_SWIZZLE_IDENTITY, both values must be VK_COMPONENT_SWIZZLE_IDENTITY
• If ycbcrModel is not VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY, then components.r, components.g, and components.b must correspond to channels of the format; that is, components.r, components.g, and components.b must not be VK_COMPONENT_SWIZZLE_ZERO or VK_COMPONENT_SWIZZLE_ONE, and must not correspond to a channel which contains zero or one as a consequence of conversion to RGBA
• If the format does not support VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT, forceExplicitReconstruction must be FALSE
• If the format does not support VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT, chromaFilter must be VK_FILTER_NEAREST

Valid Usage (Implicit)

• sType must be VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO

• pNext must be NULL or a pointer to a valid instance of VkExternalFormatANDROID
• format must be a valid VkFormat value
• ycbcrModel must be a valid VkSamplerYcbcrModelConversion value
• ycbcrRange must be a valid VkSamplerYcbcrRange value
• components must be a valid VkComponentMapping structure
• xChromaOffset must be a valid VkChromaLocation value
• yChromaOffset must be a valid VkChromaLocation value
• chromaFilter must be a valid VkFilter value

If chromaFilter is VK_FILTER_NEAREST, chroma samples are reconstructed to luma channel resolution using nearest-neighbour sampling. Otherwise, chroma samples are reconstructed using interpolation. More details can be found in the description of sampler Y’CBCR conversion in the Image Operations chapter.

See Also

VkBool32, VkChromaLocation, VkComponentMapping, VkFilter, VkFormat, VkSamplerYcbcrModelConversion, VkSamplerYcbcrRange, VkStructureType, vkCreateSamplerYcbcrConversion, vkCreateSamplerYcbcrConversionKHR

Constructors

VkSamplerYcbcrConversionCreateInfo

Fields

• vkSType :: VkStructureType

  sType is the type of this structure.

• vkPNext :: Ptr ()

  pNext is NULL or a pointer to an extension-specific structure.

• vkFormat :: VkFormat

  format is the format of the image from which color information will be retrieved.

• vkYcbcrModel :: VkSamplerYcbcrModelConversion

  ycbcrModel describes the color matrix for conversion between color models.

• vkYcbcrRange :: VkSamplerYcbcrRange

  ycbcrRange describes whether the encoded values have headroom and foot room, or whether the encoding uses the full numerical range.

• vkComponents :: VkComponentMapping

  components applies a swizzle based on VkComponentSwizzle enums prior to range expansion and color model conversion.

• vkXChromaOffset :: VkChromaLocation

  xChromaOffset describes the sample location associated with downsampled chroma channels in the x dimension. xChromaOffset has no effect for formats in which chroma channels are the same resolution as the luma channel.

• vkYChromaOffset :: VkChromaLocation

  yChromaOffset describes the sample location associated with downsampled chroma channels in the y dimension. yChromaOffset has no effect for formats in which the chroma channels are not downsampled vertically.

• vkChromaFilter :: VkFilter

  chromaFilter is the filter for chroma reconstruction.

• vkForceExplicitReconstruction :: VkBool32

  forceExplicitReconstruction can be used to ensure that reconstruction is done explicitly, if supported.

Instances

Eq VkSamplerYcbcrConversionCreateInfo

Methods

(==) :: VkSamplerYcbcrConversionCreateInfo -> VkSamplerYcbcrConversionCreateInfo -> Bool

(/=) :: VkSamplerYcbcrConversionCreateInfo -> VkSamplerYcbcrConversionCreateInfo -> Bool

Show VkSamplerYcbcrConversionCreateInfo

Methods

showsPrec :: Int -> VkSamplerYcbcrConversionCreateInfo -> ShowS

show :: VkSamplerYcbcrConversionCreateInfo -> String

showList :: [VkSamplerYcbcrConversionCreateInfo] -> ShowS

Storable VkSamplerYcbcrConversionCreateInfo

Methods

sizeOf :: VkSamplerYcbcrConversionCreateInfo -> Int

alignment :: VkSamplerYcbcrConversionCreateInfo -> Int

peekElemOff :: Ptr VkSamplerYcbcrConversionCreateInfo -> Int -> IO VkSamplerYcbcrConversionCreateInfo

pokeElemOff :: Ptr VkSamplerYcbcrConversionCreateInfo -> Int -> VkSamplerYcbcrConversionCreateInfo -> IO ()

peekByteOff :: Ptr b -> Int -> IO VkSamplerYcbcrConversionCreateInfo

pokeByteOff :: Ptr b -> Int -> VkSamplerYcbcrConversionCreateInfo -> IO ()

peek :: Ptr VkSamplerYcbcrConversionCreateInfo -> IO VkSamplerYcbcrConversionCreateInfo

poke :: Ptr VkSamplerYcbcrConversionCreateInfo -> VkSamplerYcbcrConversionCreateInfo -> IO ()

data VkBindImagePlaneMemoryInfo

VkBindImagePlaneMemoryInfo - Structure specifying how to bind an image plane to memory

Description

Valid Usage

• planeAspect must be a single valid plane aspect for the image format (that is, planeAspect must be VK_IMAGE_ASPECT_PLANE_0_BIT or VK_IMAGE_ASPECT_PLANE_1_BIT for “_2PLANE” formats and planeAspect must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT for “_3PLANE” formats)

• A single call to vkBindImageMemory2 must bind all or none of the planes of an image (i.e. bindings to all planes of an image must be made in a single vkBindImageMemory2 call), as separate bindings

Valid Usage (Implicit)

• sType must be VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO

• planeAspect must be a valid VkImageAspectFlagBits value

See Also

VkImageAspectFlagBits, VkStructureType

Constructors

VkBindImagePlaneMemoryInfo

Fields

• vkSType :: VkStructureType

  sType is the type of this structure.

• vkPNext :: Ptr ()

  pNext is NULL or a pointer to an extension-specific structure.

• vkPlaneAspect :: VkImageAspectFlagBits

  planeAspect is the aspect of the disjoint image plane to bind.

Instances

Eq VkBindImagePlaneMemoryInfo

Methods

(==) :: VkBindImagePlaneMemoryInfo -> VkBindImagePlaneMemoryInfo -> Bool

(/=) :: VkBindImagePlaneMemoryInfo -> VkBindImagePlaneMemoryInfo -> Bool

Show VkBindImagePlaneMemoryInfo

Methods

showsPrec :: Int -> VkBindImagePlaneMemoryInfo -> ShowS

show :: VkBindImagePlaneMemoryInfo -> String

showList :: [VkBindImagePlaneMemoryInfo] -> ShowS

Storable VkBindImagePlaneMemoryInfo

Methods

sizeOf :: VkBindImagePlaneMemoryInfo -> Int

alignment :: VkBindImagePlaneMemoryInfo -> Int

peekElemOff :: Ptr VkBindImagePlaneMemoryInfo -> Int -> IO VkBindImagePlaneMemoryInfo

pokeElemOff :: Ptr VkBindImagePlaneMemoryInfo -> Int -> VkBindImagePlaneMemoryInfo -> IO ()

peekByteOff :: Ptr b -> Int -> IO VkBindImagePlaneMemoryInfo

pokeByteOff :: Ptr b -> Int -> VkBindImagePlaneMemoryInfo -> IO ()

peek :: Ptr VkBindImagePlaneMemoryInfo -> IO VkBindImagePlaneMemoryInfo

poke :: Ptr VkBindImagePlaneMemoryInfo -> VkBindImagePlaneMemoryInfo -> IO ()

data VkImagePlaneMemoryRequirementsInfo

VkImagePlaneMemoryRequirementsInfo - Structure specifying image plane for memory requirements

Description

Valid Usage

• planeAspect must be an aspect that exists in the format; that is, for a two-plane image planeAspect must be VK_IMAGE_ASPECT_PLANE_0_BIT or VK_IMAGE_ASPECT_PLANE_1_BIT, and for a three-plane image planeAspect must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT or VK_IMAGE_ASPECT_PLANE_2_BIT

Valid Usage (Implicit)

• sType must be VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO

• planeAspect must be a valid VkImageAspectFlagBits value

See Also

VkImageAspectFlagBits, VkStructureType

Constructors

VkImagePlaneMemoryRequirementsInfo

Fields

• vkSType :: VkStructureType

  sType is the type of this structure.

• vkPNext :: Ptr ()

  pNext is NULL or a pointer to an extension-specific structure.

• vkPlaneAspect :: VkImageAspectFlagBits

  planeAspect is the aspect corresponding to the image plane to query.

Instances

Eq VkImagePlaneMemoryRequirementsInfo

Methods

(==) :: VkImagePlaneMemoryRequirementsInfo -> VkImagePlaneMemoryRequirementsInfo -> Bool

(/=) :: VkImagePlaneMemoryRequirementsInfo -> VkImagePlaneMemoryRequirementsInfo -> Bool

Show VkImagePlaneMemoryRequirementsInfo

Methods

showsPrec :: Int -> VkImagePlaneMemoryRequirementsInfo -> ShowS

show :: VkImagePlaneMemoryRequirementsInfo -> String

showList :: [VkImagePlaneMemoryRequirementsInfo] -> ShowS

Storable VkImagePlaneMemoryRequirementsInfo

Methods

sizeOf :: VkImagePlaneMemoryRequirementsInfo -> Int

alignment :: VkImagePlaneMemoryRequirementsInfo -> Int

peekElemOff :: Ptr VkImagePlaneMemoryRequirementsInfo -> Int -> IO VkImagePlaneMemoryRequirementsInfo

pokeElemOff :: Ptr VkImagePlaneMemoryRequirementsInfo -> Int -> VkImagePlaneMemoryRequirementsInfo -> IO ()

peekByteOff :: Ptr b -> Int -> IO VkImagePlaneMemoryRequirementsInfo

pokeByteOff :: Ptr b -> Int -> VkImagePlaneMemoryRequirementsInfo -> IO ()

peek :: Ptr VkImagePlaneMemoryRequirementsInfo -> IO VkImagePlaneMemoryRequirementsInfo

poke :: Ptr VkImagePlaneMemoryRequirementsInfo -> VkImagePlaneMemoryRequirementsInfo -> IO ()

data VkPhysicalDeviceSamplerYcbcrConversionFeatures

VkPhysicalDeviceSamplerYcbcrConversionFeatures - Structure describing Y’CbCr conversion features that can be supported by an implementation

Members

The members of the VkPhysicalDeviceSamplerYcbcrConversionFeatures structure describe the following feature:

Description

• samplerYcbcrConversion specifies whether the implementation supports sampler Y’CBCR conversion. If samplerYcbcrConversion is VK_FALSE, sampler Y’CBCR conversion is not supported, and samplers using sampler Y’CBCR conversion must not be used.

Valid Usage (Implicit)

• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES

See Also

VkBool32, VkStructureType

Constructors

VkPhysicalDeviceSamplerYcbcrConversionFeatures

Fields

• vkSType :: VkStructureType
• vkPNext :: Ptr ()
• vkSamplerYcbcrConversion :: VkBool32

Instances

Eq VkPhysicalDeviceSamplerYcbcrConversionFeatures

Methods

(==) :: VkPhysicalDeviceSamplerYcbcrConversionFeatures -> VkPhysicalDeviceSamplerYcbcrConversionFeatures -> Bool

(/=) :: VkPhysicalDeviceSamplerYcbcrConversionFeatures -> VkPhysicalDeviceSamplerYcbcrConversionFeatures -> Bool

Show VkPhysicalDeviceSamplerYcbcrConversionFeatures

Methods

showsPrec :: Int -> VkPhysicalDeviceSamplerYcbcrConversionFeatures -> ShowS

show :: VkPhysicalDeviceSamplerYcbcrConversionFeatures -> String

showList :: [VkPhysicalDeviceSamplerYcbcrConversionFeatures] -> ShowS

Storable VkPhysicalDeviceSamplerYcbcrConversionFeatures

Methods

sizeOf :: VkPhysicalDeviceSamplerYcbcrConversionFeatures -> Int

alignment :: VkPhysicalDeviceSamplerYcbcrConversionFeatures -> Int

peekElemOff :: Ptr VkPhysicalDeviceSamplerYcbcrConversionFeatures -> Int -> IO VkPhysicalDeviceSamplerYcbcrConversionFeatures

pokeElemOff :: Ptr VkPhysicalDeviceSamplerYcbcrConversionFeatures -> Int -> VkPhysicalDeviceSamplerYcbcrConversionFeatures -> IO ()

peekByteOff :: Ptr b -> Int -> IO VkPhysicalDeviceSamplerYcbcrConversionFeatures

pokeByteOff :: Ptr b -> Int -> VkPhysicalDeviceSamplerYcbcrConversionFeatures -> IO ()

peek :: Ptr VkPhysicalDeviceSamplerYcbcrConversionFeatures -> IO VkPhysicalDeviceSamplerYcbcrConversionFeatures

poke :: Ptr VkPhysicalDeviceSamplerYcbcrConversionFeatures -> VkPhysicalDeviceSamplerYcbcrConversionFeatures -> IO ()

data VkSamplerYcbcrConversionImageFormatProperties

VkSamplerYcbcrConversionImageFormatProperties - Structure specifying combined image sampler descriptor count for multi-planar images

Description

Valid Usage (Implicit)

• sType must be VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES

See Also

VkStructureType

Constructors

VkSamplerYcbcrConversionImageFormatProperties

Fields

• vkSType :: VkStructureType

  sType is the type of this structure.

• vkPNext :: Ptr ()

  pNext is NULL or a pointer to an extension-specific structure.

• vkCombinedImageSamplerDescriptorCount :: Word32

  combinedImageSamplerDescriptorCount is the number of combined image sampler descriptors that the implementation uses to access the format.

Instances

Eq VkSamplerYcbcrConversionImageFormatProperties

Methods

(==) :: VkSamplerYcbcrConversionImageFormatProperties -> VkSamplerYcbcrConversionImageFormatProperties -> Bool

(/=) :: VkSamplerYcbcrConversionImageFormatProperties -> VkSamplerYcbcrConversionImageFormatProperties -> Bool

Show VkSamplerYcbcrConversionImageFormatProperties

Methods

showsPrec :: Int -> VkSamplerYcbcrConversionImageFormatProperties -> ShowS

show :: VkSamplerYcbcrConversionImageFormatProperties -> String

showList :: [VkSamplerYcbcrConversionImageFormatProperties] -> ShowS

Storable VkSamplerYcbcrConversionImageFormatProperties

Methods

sizeOf :: VkSamplerYcbcrConversionImageFormatProperties -> Int

alignment :: VkSamplerYcbcrConversionImageFormatProperties -> Int

peekElemOff :: Ptr VkSamplerYcbcrConversionImageFormatProperties -> Int -> IO VkSamplerYcbcrConversionImageFormatProperties

pokeElemOff :: Ptr VkSamplerYcbcrConversionImageFormatProperties -> Int -> VkSamplerYcbcrConversionImageFormatProperties -> IO ()

peekByteOff :: Ptr b -> Int -> IO VkSamplerYcbcrConversionImageFormatProperties

pokeByteOff :: Ptr b -> Int -> VkSamplerYcbcrConversionImageFormatProperties -> IO ()

peek :: Ptr VkSamplerYcbcrConversionImageFormatProperties -> IO VkSamplerYcbcrConversionImageFormatProperties

poke :: Ptr VkSamplerYcbcrConversionImageFormatProperties -> VkSamplerYcbcrConversionImageFormatProperties -> IO ()