Author: The Khronos® Vulkan Working Group

# Vulkan® 1.3.253 - A Specification (with all registered extensions)

The Khronos® Vulkan Working Group
version 1.3.253, 2023-06-11 11:28:02Z
from git branch: Git branch not available commit: Git commit not available

Loading… please wait.

Search:

## Appendix I: Lexicon

This appendix defines terms, abbreviations, and API prefixes used in the Specification.

### Glossary

The terms defined in this section are used consistently throughout the Specification and may be used with or without capitalization.

Accessible (Descriptor Binding)

  A descriptor binding is accessible to a shader stage if that stage is included in the `stageFlags` of the descriptor binding. Descriptors using that binding can only be used by stages in which they are accessible.

Acquire Operation (Resource)

  An operation that acquires ownership of an image subresource or buffer range.

Active (Descriptor Type)

  When a descriptor with mutable type is updated with vkUpdateDescriptorSets, the active descriptor type changes. When the descriptor is consumed by shaders, it is the active descriptor type which determines validity, i.e. `VkDescriptorSetLayoutBinding`::`descriptorType` is replaced with the active descriptor type. A mismatch in active descriptor type and consumption by shader is considered an undefined descriptor.

Active (Transform Feedback)

  Transform feedback is made active after vkCmdBeginTransformFeedbackEXT executes and remains active until vkCmdEndTransformFeedbackEXT executes. While transform feedback is active, data written to variables in the output interface of the last pre-rasterization shader stage of the graphics pipeline are captured to the bound transform feedback buffers if those variables are decorated for transform feedback.

Adjacent Vertex

  A vertex in an adjacency primitive topology that is not part of a given primitive, but is accessible in geometry shaders.

Active Object (Ray Tracing)

  A primitive or instance in a ray tracing acceleration structure which has a corresponding ID, and is not inactive (meaning that it is visible to rays).

Advanced Blend Operation

  Blending performed using one of the blend operation enums introduced by the `VK_EXT_blend_operation_advanced` extension. See Advanced Blending Operations.

Alias (API type/command)

  An identical definition of another API type/command with the same behavior but a different name.

Aliased Range (Memory)

  A range of a device memory allocation that is bound to multiple resources simultaneously.

Allocation Scope

  An association of a host memory allocation to a parent object or command, where the allocation’s lifetime ends before or at the same time as the parent object is freed or destroyed, or during the parent command.

Aspect (Image)

  Some image types contain multiple kinds (called “aspects”) of data for each pixel, where each aspect is used in a particular way by the pipeline and may be stored differently or separately from other aspects. For example, the color components of an image format make up the color aspect of the image, and can be used as a framebuffer color attachment. Some operations, like depth testing, operate only on specific aspects of an image.

Attachment (Render Pass)

  A zero-based integer index name used in render pass creation to refer to a framebuffer attachment that is accessed by one or more subpasses. The index also refers to an attachment description which includes information about the properties of the image view that will later be attached.

Availability Operation

  An operation that causes the values generated by specified memory write accesses to become available for future access.

Available

  A state of values written to memory that allows them to be made visible.

Axis-aligned Bounding Box

  A box bounding a region in space defined by extents along each axis and thus representing a box where each edge is aligned to one of the major axes.

Back-Facing

  See Facingness.

Batch

  A single structure submitted to a queue as part of a queue submission command, describing a set of queue operations to execute.

Backwards Compatibility

  A given version of the API is backwards compatible with an earlier version if an application, relying only on valid behavior and functionality defined by the earlier specification, is able to correctly run against each version without any modification. This assumes no active attempt by that application to not run when it detects a different version.

Binary Semaphore

  A semaphore with a boolean payload indicating whether the semaphore is signaled or unsignaled. Represented by a VkSemaphore object created with a semaphore type of `VK_SEMAPHORE_TYPE_BINARY` .

Binding (Memory)

  An association established between a range of a resource object and a range of a memory object. These associations determine the memory locations affected by operations performed on elements of a resource object. Memory bindings are established using the vkBindBufferMemory command for non-sparse buffer objects, using the vkBindImageMemory command for non-sparse image objects , and using the vkQueueBindSparse command for sparse resources .

Blend Constant

  Four floating point (RGBA) values used as an input to blending.

Blending

  Arithmetic operations between a fragment color value and a value in a color attachment that produce a final color value to be written to the attachment.

Buffer

  A resource that represents a linear array of data in device memory. Represented by a VkBuffer object.

Buffer Device Address

  A 64-bit value used in a shader to access buffer memory through the `PhysicalStorageBuffer` storage class.

Buffer View

  An object that represents a range of a specific buffer, and state controlling how the contents are interpreted. Represented by a VkBufferView object.

Built-In Variable

  A variable decorated in a shader, where the decoration makes the variable take values provided by the execution environment or values that are generated by fixed-function pipeline stages.

Built-In Interface Block

  A block defined in a shader containing only variables decorated with built-in decorations, and is used to match against other shader stages.

Clip Coordinates

  The homogeneous coordinate space in which vertex positions (`Position` decoration) are written by pre-rasterization shader stages.

Clip Distance

  A built-in output from pre-rasterization shader stages defining a clip half-space against which the primitive is clipped.

Clip Volume

  The intersection of the view volume with all clip half-spaces.

Color Attachment

  A subpass attachment point, or image view, that is the target of fragment color outputs and blending.

Color Fragment

  A unique color value within a pixel of a multisampled color image. The fragment mask will contain indices to the color fragment.

Color Renderable Format

  A VkFormat where `VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT` is set in one of the following, depending on the image’s tiling:

  - VkFormatProperties::`linearTilingFeatures`

  - VkFormatProperties::`optimalTilingFeatures` or a VkFormat where `VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV` is set in VkFormatProperties::`linearTilingFeatures`

  - VkDrmFormatModifierPropertiesEXT::`drmFormatModifierTilingFeatures`

Combined Image Sampler

  A descriptor type that includes both a sampled image and a sampler.

Command Buffer

  An object that records commands to be submitted to a queue. Represented by a VkCommandBuffer object.

Command Pool

  An object that command buffer memory is allocated from, and that owns that memory. Command pools aid multithreaded performance by enabling different threads to use different allocators, without internal synchronization on each use. Represented by a VkCommandPool object.

Compatible Allocator

  When allocators are compatible, allocations from each allocator can be freed by the other allocator.

Compatible Image Formats

  When formats are compatible, images created with one of the formats can have image views created from it using any of the compatible formats. Also see Size-Compatible Image Formats.

Compatible Queues

  Queues within a queue family. Compatible queues have identical properties.

Complete Mipmap Chain

  The entire set of miplevels that can be provided for an image, from the largest application specified miplevel size down to the minimum miplevel size. See Image Miplevel Sizing.

Completed Operation

  A deferred operation whose corresponding command has been executed to completion. See Deferred Host Operations

Component (Format)

  A distinct part of a format. Color components are represented with `R`, `G`, `B`, and `A`. Depth and stencil components are represented with `D` and `S`. Formats can have multiple instances of the same component. Some formats have other notations such as `E` or `X` which are not considered a component of the format.

Compressed Texel Block

  An element of an image having a block-compressed format, comprising a rectangular block of texel values that are encoded as a single value in memory. Compressed texel blocks of a particular block-compressed format have a corresponding width, height, and depth defining the dimensions of these elements in units of texels, and a size in bytes of the encoding in memory.

Constant Integral Expressions

  A SPIR-V constant instruction whose type is `OpTypeInt`. See Constant Instruction in section 2.2.1 “Instructions” of the Khronos SPIR-V Specification.

Cooperative Matrix

  A SPIR-V type where the storage for and computations performed on the matrix are spread across a set of invocations such as a subgroup.

Corner-Sampled Image

  A VkImage where unnormalized texel coordinates are centered on integer values instead of half-integer values. Specified by setting the `VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV` bit on VkImageCreateInfo::`flags` at image creation.

Coverage Index

  The index of a sample in the coverage mask.

Coverage Mask

  A bitfield associated with a fragment representing the samples that were determined to be covered based on the result of rasterization, and then subsequently modified by fragment operations or the fragment shader.

Cull Distance

  A built-in output from pre-rasterization shader stages defining a cull half-space where the primitive is rejected if all vertices have a negative value for the same cull distance.

Cull Volume

  The intersection of the view volume with all cull half-spaces.

Decode Output Picture

  A video picture resource used to store the result of a video decode operation.

Decoded Picture Buffer

  An indexed set of reference pictures used by a video session. Abbreviated as DPB.

Decoded Picture Buffer Slot

  An entry within a DPB that can be associated with a particular reference picture.

Decoded Picture Buffer Slot Index

  The index of a DPB slot within its encompassing DPB.

Decoration (SPIR-V)

  Auxiliary information such as built-in variables, stream numbers, invariance, interpolation type, relaxed precision, etc., added to variables or structure-type members through decorations.

Deferrable Command

  A command which allows deferred execution of host-side work. See Deferred Host Operations.

Deferrable Operation

  A single logical item of host-side work which can be deferred. Represented by the VkDeferredOperationKHR object. See Deferred Host Operations.

Deprecated (feature)

  A feature is deprecated if it is no longer recommended as the correct or best way to achieve its intended purpose.

Depth/Stencil Attachment

  A subpass attachment point, or image view, that is the target of depth and/or stencil test operations and writes.

Depth/Stencil Format

  A VkFormat that includes depth and/or stencil components.

Depth/Stencil Image (or ImageView)

  A VkImage (or VkImageView) with a depth/stencil format.

Depth/Stencil Resolve Attachment

  A subpass attachment point, or image view, that is the target of a multisample resolve operation from the corresponding depth/stencil attachment at the end of the subpass.

Derivative Group

  A set of fragment or compute shader invocations that cooperate to compute derivatives, including implicit derivatives for sampled image operations.

Descriptor

  Information about a resource or resource view written into a descriptor set that is used to access the resource or view from a shader.

Descriptor Binding

  An entry in a descriptor set layout corresponding to zero or more descriptors of a single descriptor type in a set. Defined by a VkDescriptorSetLayoutBinding structure.

Descriptor Pool

  An object that descriptor sets are allocated from, and that owns the storage of those descriptor sets. Descriptor pools aid multithreaded performance by enabling different threads to use different allocators, without internal synchronization on each use. Represented by a VkDescriptorPool object.

Descriptor Set

  An object that resource descriptors are written into via the API, and that can be bound to a command buffer such that the descriptors contained within it can be accessed from shaders. Represented by a VkDescriptorSet object.

Descriptor Set Layout

  An object defining the set of resources (types and counts) and their relative arrangement (in the binding namespace) within a descriptor set. Used when allocating descriptor sets and when creating pipeline layouts. Represented by a VkDescriptorSetLayout object.

Device

  The processor(s) and execution environment that perform tasks requested by the application via the Vulkan API.

Device Group

  A set of physical devices that support accessing each other’s memory and recording a single command buffer that can be executed on all the physical devices.

Device Index

  A zero-based integer that identifies one physical device from a logical device. A device index is valid if it is less than the number of physical devices in the logical device.

Device Mask

  A bitmask where each bit represents one device index. A device mask value is valid if every bit that is set in the mask is at a bit position that is less than the number of physical devices in the logical device.

Device Memory

  Memory accessible to the device. Represented by a VkDeviceMemory object.

Device-Level Command

  Any command that is dispatched from a logical device, or from a child object of a logical device.

Device-Level Functionality

  All device-level commands and objects, and their structures, enumerated types, and enumerants. Additionally, physical-device-level functionality defined by a device extension is also considered device-level functionality.

Device-Level Object

  Logical device objects and their child objects. For example, VkDevice, VkQueue, and VkCommandBuffer objects are device-level objects.

Device-Local Memory

  Memory that is connected to the device, and may be more performant for device access than host-local memory.

Direct Drawing Commands

  Drawing commands that take all their parameters as direct arguments to the command (and not sourced via structures in buffer memory as the indirect drawing commands). Includes vkCmdDrawMultiIndexedEXT, vkCmdDrawMultiEXT, vkCmdDrawMeshTasksNV, vkCmdDrawMeshTasksEXT, vkCmdDraw, and vkCmdDrawIndexed.

Disjoint

  Disjoint planes are image planes to which memory is bound independently.
  A disjoint image consists of multiple disjoint planes, and is created with the `VK_IMAGE_CREATE_DISJOINT_BIT` bit set.

Dispatchable Command

  A non-global command. The first argument to each dispatchable command is a dispatchable handle type.

Dispatchable Handle

  A handle of a pointer handle type which may be used by layers as part of intercepting API commands.

Dispatching Commands

  Commands that provoke work using a compute pipeline. Includes vkCmdDispatch and vkCmdDispatchIndirect.

Drawing Commands

  Commands that provoke work using a graphics pipeline. Includes vkCmdDraw, vkCmdDrawIndexed, vkCmdDrawIndirectCount, vkCmdDrawIndexedIndirectCount, vkCmdDrawIndirectCountKHR, vkCmdDrawIndexedIndirectCountKHR, vkCmdDrawIndirectCountAMD, vkCmdDrawIndexedIndirectCountAMD, vkCmdDrawMultiIndexedEXT, vkCmdDrawMultiEXT, vkCmdDrawMeshTasksNV, vkCmdDrawMeshTasksIndirectNV, vkCmdDrawMeshTasksIndirectCountNV, vkCmdDrawMeshTasksEXT, vkCmdDrawMeshTasksIndirectEXT, vkCmdDrawMeshTasksIndirectCountEXT, vkCmdDrawIndirect, and vkCmdDrawIndexedIndirect.

Duration (Command)

  The duration of a Vulkan command refers to the interval between calling the command and its return to the caller.

Dynamic Storage Buffer

  A storage buffer whose offset is specified each time the storage buffer is bound to a command buffer via a descriptor set.

Dynamic Uniform Buffer

  A uniform buffer whose offset is specified each time the uniform buffer is bound to a command buffer via a descriptor set.

Dynamically Uniform

  See Dynamically Uniform in section 2.2 “Terms” of the Khronos SPIR-V Specification.

Encode Input Picture

  A video picture resource used as the input of a video encode operation.

Element

  Arrays are composed of multiple elements, where each element exists at a unique index within that array. Used primarily to describe data passed to or returned from the Vulkan API.

Explicitly-Enabled Layer

  A layer enabled by the application by adding it to the enabled layer list in vkCreateInstance or vkCreateDevice.

Event

  A synchronization primitive that is signaled when execution of previous commands completes through a specified set of pipeline stages. Events can be waited on by the device and polled by the host. Represented by a VkEvent object.

Executable State (Command Buffer)

  A command buffer that has ended recording commands and can be executed. See also Initial State and Recording State.

Execution Dependency

  A dependency that guarantees that certain pipeline stages’ work for a first set of commands has completed execution before certain pipeline stages’ work for a second set of commands begins execution. This is accomplished via pipeline barriers, subpass dependencies, events, or implicit ordering operations.

Execution Dependency Chain

  A sequence of execution dependencies that transitively act as a single execution dependency.

Explicit chroma reconstruction

  An implementation of sampler Y′CBCR conversion which reconstructs reduced-resolution chroma samples to luma resolution and then separately performs texture sample interpolation. This is distinct from an implicit implementation, which incorporates chroma sample reconstruction into texture sample interpolation.

Extension Scope

  The set of objects and commands that can be affected by an extension. Extensions are either device scope or instance scope.

Extending Structure

  A structure type which may appear in the `pNext` chain of another structure, extending the functionality of the other structure. Extending structures may be defined by either core API versions or extensions.

External Handle

  A resource handle which has meaning outside of a specific Vulkan device or its parent instance. External handles may be used to share resources between multiple Vulkan devices in different instances, or between Vulkan and other APIs. Some external handle types correspond to platform-defined handles, in which case the resource may outlive any particular Vulkan device or instance and may be transferred between processes, or otherwise manipulated via functionality defined by the platform for that handle type.

External synchronization

  A type of synchronization required of the application, where parameters defined to be externally synchronized must not be used simultaneously in multiple threads.

Facingness (Polygon)

  A classification of a polygon as either front-facing or back-facing, depending on the orientation (winding order) of its vertices.

Facingness (Fragment)

  A fragment is either front-facing or back-facing, depending on the primitive it was generated from. If the primitive was a polygon (regardless of polygon mode), the fragment inherits the facingness of the polygon. All other fragments are front-facing.

Fence

  A synchronization primitive that is signaled when a set of batches or sparse binding operations complete execution on a queue. Fences can be waited on by the host. Represented by a VkFence object.

Flat Shading

  A property of a vertex attribute that causes the value from a single vertex (the provoking vertex) to be used for all vertices in a primitive, and for interpolation of that attribute to return that single value unaltered.

Format Features

  A set of features from VkFormatFeatureFlagBits that a VkFormat is capable of using for various commands. The list is determined by factors such as VkImageTiling.

Fragment

  A rectangular framebuffer region with associated data produced by rasterization and processed by fragment operations including the fragment shader.

Fragment Area

  The width and height, in pixels, of a fragment.

Fragment Density

  The ratio of fragments per framebuffer area in the x and y direction.

Fragment Density Texel Size

  The (w,h) framebuffer region in pixels that each texel in a fragment density map applies to.

Fragment Input Attachment Interface

  Variables with `UniformConstant` storage class and a decoration of `InputAttachmentIndex` that are statically used by a fragment shader’s entry point, which receive values from input attachments.

Fragment Mask

  A lookup table that associates color samples with color fragment values.

Fragment Output Interface

  A fragment shader entry point’s variables with `Output` storage class, which output to color and/or depth/stencil attachments.

Frame (Video)

  A multi-dimensional array of luma samples and an optional multi-dimensional array of chroma samples.

Fragment Tile Image Interface

  A fragment shader entry point’s variables with `TileImageEXT` storage class and a decoration of `Location`, which are used to read values from color attachments.

Framebuffer

  A collection of image views and a set of dimensions that, in conjunction with a render pass, define the inputs and outputs used by drawing commands. Represented by a VkFramebuffer object.

Framebuffer Attachment

  One of the image views used in a framebuffer.

Framebuffer Coordinates

  A coordinate system in which adjacent pixels’ coordinates differ by 1 in x and/or y, with (0,0) in the upper left corner and pixel centers at half-integers.

Framebuffer-Space

  Operating with respect to framebuffer coordinates.

Framebuffer-Local

  A framebuffer-local dependency guarantees that only for a single framebuffer region, the first set of operations happens-before the second set of operations.

Framebuffer-Global

  A framebuffer-global dependency guarantees that for all framebuffer regions, the first set of operations happens-before the second set of operations.

Framebuffer Region

  A framebuffer region is a set of sample (x, y, layer, sample) coordinates that is a subset of the entire framebuffer.

Front-Facing

  See Facingness.

Full Compatibility

  A given version of the API is fully compatible with another version if an application, relying only on valid behavior and functionality defined by either of those specifications, is able to correctly run against each version without any modification. This assumes no active attempt by that application to not run when it detects a different version.

Global Command

  A Vulkan command for which the first argument is not a dispatchable handle type.

Global Workgroup

  A collection of local workgroups dispatched by a single dispatching or single mesh task drawing command.

Handle

  An opaque integer or pointer value used to refer to a Vulkan object. Each object type has a unique handle type.

Happen-after, happens-after

  A transitive, irreflexive and antisymmetric ordering relation between operations. An execution dependency with a source of A and a destination of B enforces that B happens-after A. The inverse relation of happens-before.

Happen-before, happens-before

  A transitive, irreflexive and antisymmetric ordering relation between operations. An execution dependency with a source of A and a destination of B enforces that A happens-before B. The inverse relation of happens-after.

Helper Invocation

  A fragment shader invocation that is created solely for the purposes of evaluating derivatives for use in non-helper fragment shader invocations, and which does not have side effects.

Host

  The processor(s) and execution environment that the application runs on, and that the Vulkan API is exposed on.

Host Mapped Device Memory

  Device memory that is mapped for host access using vkMapMemory.

Host Mapped Foreign Memory

  Memory owned by a foreign device that is mapped for host access.

Host Memory

  Memory not accessible to the device, used to store implementation data structures.

Host-Accessible Subresource

  A buffer, or a linear image subresource in either the `VK_IMAGE_LAYOUT_PREINITIALIZED` or `VK_IMAGE_LAYOUT_GENERAL` layout. Host-accessible subresources have a well-defined addressing scheme which can be used by the host.

Host-Local Memory

  Memory that is not local to the device, and may be less performant for device access than device-local memory.

Host-Visible Memory

  Device memory that can be mapped on the host and can be read and written by the host.

ICD

  Installable Client Driver. An ICD is represented as a VkPhysicalDevice.

Identically Defined Objects

  Objects of the same type where all arguments to their creation or allocation functions, with the exception of `pAllocator`, are

  1. Vulkan handles which refer to the same object or

  2. identical scalar or enumeration values or

  3. Host pointers which point to an array of values or structures which also satisfy these three constraints.

Image

  A resource that represents a multi-dimensional formatted interpretation of device memory. Represented by a VkImage object.

Image Subresource

  A specific mipmap level, layer, and set of aspects of an image.

Image Subresource Range

  A set of image subresources that are contiguous mipmap levels and layers.

Image View

  An object that represents an image subresource range of a specific image, and state controlling how the contents are interpreted. Represented by a VkImageView object.

Immutable Sampler

  A sampler descriptor provided at descriptor set layout creation time for a specific binding. This sampler is then used for that binding in all descriptor sets allocated with the layout, and it cannot be changed.

Implicit chroma reconstruction

  An implementation of sampler Y′CBCR conversion which reconstructs the reduced-resolution chroma samples directly at the sample point, as part of the normal texture sampling operation. This is distinct from an explicit chroma reconstruction implementation, which reconstructs the reduced-resolution chroma samples to the resolution of the luma samples, then filters the result as part of texture sample interpolation.

Implicitly-Enabled Layer

  A layer enabled by a loader-defined mechanism outside the Vulkan API, rather than explicitly by the application during instance or device creation.

Inactive Object (Ray Tracing)

  A primitive or instance in a ray tracing acceleration structure which has a corresponding ID, but which will never report an intersection with any ray.

Index Buffer

  A buffer bound via vkCmdBindIndexBuffer which is the source of index values used to fetch vertex attributes for a vkCmdDrawIndexed or vkCmdDrawIndexedIndirect command.

Indexed Drawing Commands

  Drawing commands which use an index buffer as the source of index values used to fetch vertex attributes for a drawing command. Includes vkCmdDrawIndexed, vkCmdDrawIndexedIndirectCount, vkCmdDrawIndexedIndirectCountKHR, vkCmdDrawIndexedIndirectCountAMD, vkCmdDrawMultiIndexedEXT, and vkCmdDrawIndexedIndirect.

Indirect Commands

  Drawing or dispatching commands that source some of their parameters from structures in buffer memory. Includes vkCmdDrawIndirect, vkCmdDrawIndexedIndirect, vkCmdDrawIndirectCount, vkCmdDrawIndexedIndirectCount, vkCmdDrawIndirectCountKHR, vkCmdDrawIndexedIndirectCountKHR, vkCmdDrawIndirectCountAMD, vkCmdDrawIndexedIndirectCountAMD, vkCmdDrawMeshTasksIndirectNV, vkCmdDrawMeshTasksIndirectCountNV, vkCmdDrawMeshTasksIndirectEXT, vkCmdDrawMeshTasksIndirectCountEXT, and vkCmdDispatchIndirect.

Indirect Commands Layout

  A definition of a sequence of commands, that are generated on the device via vkCmdPreprocessGeneratedCommandsNV and vkCmdExecuteGeneratedCommandsNV. Each sequence is comprised of multiple VkIndirectCommandsTokenTypeNV, which represent a subset of traditional command buffer commands. Represented as VkIndirectCommandsLayoutNV.

Indirect Drawing Commands

  Drawing commands that source some of their parameters from structures in buffer memory. Includes vkCmdDrawIndirect, vkCmdDrawIndirectCount, vkCmdDrawIndexedIndirectCount, vkCmdDrawIndirectCountKHR, vkCmdDrawIndexedIndirectCountKHR, vkCmdDrawIndirectCountAMD, vkCmdDrawIndexedIndirectCountAMD, vkCmdDrawMeshTasksIndirectNV, vkCmdDrawMeshTasksIndirectCountNV, vkCmdDrawMeshTasksIndirectEXT, vkCmdDrawMeshTasksIndirectCountEXT, and vkCmdDrawIndexedIndirect.

Initial State (Command Buffer)

  A command buffer that has not begun recording commands. See also Recording State and Executable State.

Inline Uniform Block

  A descriptor type that represents uniform data stored directly in descriptor sets, and supports read-only access in a shader.

Input Attachment

  A descriptor type that represents an image view, and supports unfiltered read-only access in a shader, only at the fragment’s location in the view.

Instance

  The top-level Vulkan object, which represents the application’s connection to the implementation. Represented by a VkInstance object.

Instance-Level Command

  Any command that is dispatched from an instance, or from a child object of an instance, except for physical devices and their children.

Instance-Level Functionality

  All instance-level commands and objects, and their structures, enumerated types, and enumerants.

Instance-Level Object

  High-level Vulkan objects, which are not physical devices, nor children of physical devices. For example, VkInstance is an instance-level object.

Instance (Memory)

  In a logical device representing more than one physical device, some device memory allocations have the requested amount of memory allocated multiple times, once for each physical device in a device mask. Each such replicated allocation is an instance of the device memory.

Instance (Resource)

  In a logical device representing more than one physical device, buffer and image resources exist on all physical devices but can be bound to memory differently on each. Each such replicated resource is an instance of the resource.

Internal Synchronization

  A type of synchronization required of the implementation, where parameters not defined to be externally synchronized may require internal mutexing to avoid multithreaded race conditions.

Invocation (Shader)

  A single execution of an entry point in a SPIR-V module. For example, a single vertex’s execution of a vertex shader or a single fragment’s execution of a fragment shader.

Invocation Group

  A set of shader invocations that are executed in parallel and that must execute the same control flow path in order for control flow to be considered dynamically uniform.

Invocation Repack Instruction

  A ray tracing shader call instruction where the implementation may change the set of invocations that are executing.

Join (Deferred Host Operations)

  The act of instructing a thread to participate in the execution of a deferred operation. See Deferred Host Operations.

Linear Color Attachment

  A color attachment with linear tiling

Linear Resource

  A resource is linear if it is one of the following:

  - a VkBuffer

  - a VkImage created with `VK_IMAGE_TILING_LINEAR`

  - a VkImage created with `VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT` and whose Linux DRM format modifier is `DRM_FORMAT_MOD_LINEAR`

  - a VkAccelerationStructureNV

  Because a VkAccelerationStructureKHR resource does not have memory bound to it directly, it is considered neither linear nor non-linear. However, the VkBuffer on which a VkAccelerationStructureKHR resource is placed is a linear resource.

  A resource is non-linear if it is one of the following:

  - a VkImage created with `VK_IMAGE_TILING_OPTIMAL`

  - a VkImage created with `VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT` and whose Linux DRM format modifier is not `DRM_FORMAT_MOD_LINEAR`

Linux DRM Format Modifier

  A 64-bit, vendor-prefixed, semi-opaque unsigned integer describing vendor-specific details of an image’s memory layout. In Linux graphics APIs, modifiers are commonly used to specify the memory layout of externally shared images. An image has a modifier if and only if it is created with `tiling` equal to `VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT`. For more details, refer to the appendix for extension `VK_EXT_image_drm_format_modifier`.

Local Workgroup

  A collection of compute shader invocations invoked by a single dispatching command, which share data via `WorkgroupLocal` variables and can synchronize with each other.

Logical Device

  An object that represents the application’s interface to the physical device. The logical device is the parent of most Vulkan objects. Represented by a VkDevice object.

Logical Operation

  Bitwise operations between a fragment color value and a value in a color attachment, that produce a final color value to be written to the attachment.

Lost Device

  A state that a logical device may be in as a result of unrecoverable implementation errors, or other exceptional conditions.

Mappable

  See Host-Visible Memory.

Memory Dependency

  A memory dependency is an execution dependency which includes availability and visibility operations such that:

  - The first set of operations happens-before the availability operation

  - The availability operation happens-before the visibility operation

  - The visibility operation happens-before the second set of operations

Memory Domain

  A memory domain is an abstract place to which memory writes are made available by availability operations and memory domain operations. The memory domains correspond to the set of agents that the write can then be made visible to. The memory domains are host, device, shader, workgroup instance (for workgroup instance there is a unique domain for each compute workgroup) and subgroup instance (for subgroup instance there is a unique domain for each subgroup).

Memory Domain Operation

  An operation that makes the writes that are available to one memory domain available to another memory domain.

Memory Heap

  A region of memory from which device memory allocations can be made.

Memory Type

  An index used to select a set of memory properties (e.g. mappable, cached) for a device memory allocation.

Mesh Shading Pipeline

  A graphics pipeline where the primitives are assembled explicitly in the shader stages. In contrast to the primitive shading pipeline where input primitives are assembled by fixed function processing.

Mesh Tasks Drawing Commands

  Drawing commands which create shader invocations organized in workgroups for drawing mesh tasks. Includes vkCmdDrawMeshTasksNV, vkCmdDrawMeshTasksIndirectNV, and vkCmdDrawMeshTasksIndirectCountNV, vkCmdDrawMeshTasksEXT, vkCmdDrawMeshTasksIndirectEXT, and vkCmdDrawMeshTasksIndirectCountEXT .

Minimum Miplevel Size

  The smallest size that is permitted for a miplevel. For conventional images this is 1x1x1. For corner-sampled images, this is 2x2x2. See Image Miplevel Sizing.

Mip Tail Region

  The set of mipmap levels of a sparse residency texture that are too small to fill a sparse block, and that must all be bound to memory collectively and opaquely.

Multi-planar

  A multi-planar format (or “planar format”) is an image format consisting of more than one plane, identifiable with a `_2PLANE` or `_3PLANE` component to the format name and listed in Formats requiring sampler Y′CBCR conversion for `VK_IMAGE_ASPECT_COLOR_BIT` image views. A multi-planar image (or “planar image”) is an image of a multi-planar format.

Non-Dispatchable Handle

  A handle of an integer handle type. Handle values may not be unique, even for two objects of the same type.

Non-Indexed Drawing Commands

  Drawing commands for which the vertex attributes are sourced in linear order from the vertex input attributes for a drawing command (i.e. they do not use an index buffer). Includes vkCmdDraw, vkCmdDrawIndirectCount, vkCmdDrawIndirectCountKHR, vkCmdDrawIndirectCountAMD, vkCmdDrawMultiEXT, and vkCmdDrawIndirect.

Normalized

  A value that is interpreted as being in the range [0,1] as a result of being implicitly divided by some other value.

Normalized Device Coordinates

  A coordinate space after perspective division is applied to clip coordinates, and before the viewport transformation converts them to framebuffer coordinates.

Obsoleted (feature)

  A feature is obsolete if it can no longer be used.

Opaque Capture Address

  A 64-bit value representing the device address of a buffer or memory object that is expected to be used by trace capture/replay tools in combination with the `bufferDeviceAddress` feature.

Overlapped Range (Aliased Range)

  The aliased range of a device memory allocation that intersects a given image subresource of an image or range of a buffer.

Ownership (Resource)

  If an entity (e.g. a queue family) has ownership of a resource, access to that resource is well-defined for access by that entity.

Packed Format

  A format whose components are stored as a single texel block in memory, with their relative locations defined within that element.

Passthrough Geometry Shader

  A geometry shader which uses the `PassthroughNV` decoration on a variable in its input interface. Output primitives in a passthrough geometry shader always have the same topology as the input primitive and are not produced by emitting vertices.

Payload

  Importable or exportable reference to the internal data of an object in Vulkan.

Per-View

  A variable that has an array of values which are output, one for each view that is being generated. A mesh shader which uses the `PerViewNV` decoration on a variable in its output interface.

Peer Memory

  An instance of memory corresponding to a different physical device than the physical device performing the memory access, in a logical device that represents multiple physical devices.

Physical Device

  An object that represents a single device in the system. Represented by a VkPhysicalDevice object.

Physical-Device-Level Command

  Any command that is dispatched from a physical device.

Physical-Device-Level Functionality

  All physical-device-level commands and objects, and their structures, enumerated types, and enumerants.

Physical-Device-Level Object

  Physical device objects. For example, VkPhysicalDevice is a physical-device-level object.

Pipeline

  An object controlling how graphics or compute work is executed on the device. A pipeline includes one or more shaders, as well as state controlling any non-programmable stages of the pipeline. Represented by a VkPipeline object.

Pipeline Barrier

  An execution and/or memory dependency recorded as an explicit command in a command buffer, that forms a dependency between the previous and subsequent commands.

Pipeline Cache

  An object that can be used to collect and retrieve information from pipelines as they are created, and can be populated with previously retrieved information in order to accelerate pipeline creation. Represented by a VkPipelineCache object.

Pipeline Layout

  An object defining the set of resources (via a collection of descriptor set layouts) and push constants used by pipelines that are created using the layout. Used when creating a pipeline and when binding descriptor sets and setting push constant values. Represented by a VkPipelineLayout object.

Pipeline Library

  A pipeline that cannot be directly used, instead defining a set of shaders and shader groups which will be linked into other pipelines.

Pipeline Stage

  A logically independent execution unit that performs some of the operations defined by an action command.

Pipeline Trace Ray Instruction

  A ray tracing instruction which traces a ray into an acceleration structure when using ray tracing pipelines. One of `OpTraceNV`, `OpTraceRayMotionNV`, `OpTraceMotionNV`, `OpTraceRayKHR` .

`pNext` Chain

  A set of structures chained together through their `pNext` members.

Planar

  See multi-planar.

Plane

  An image plane is part of the representation of an image, containing a subset of the color components necessary to represent the texels in the image and with a contiguous mapping of coordinates to bound memory. Most images consist only of a single plane, but some formats spread the components across multiple image planes. The host-accessible properties of each image plane are accessible for a linear layout using vkGetImageSubresourceLayout. If a multi-planar image is created with the `VK_IMAGE_CREATE_DISJOINT_BIT` bit set, the image is described as disjoint, and its planes are therefore bound to memory independently.

Point Sampling (Rasterization)

  A rule that determines whether a fragment sample location is covered by a polygon primitive by testing whether the sample location is in the interior of the polygon in framebuffer-space, or on the boundary of the polygon according to the tie-breaking rules.

Potential Format Features

  The union of all VkFormatFeatureFlagBits that the implementation supports for a specified VkFormat, over all supported image tilings. For external formats the VkFormatFeatureFlagBits is provided by the implementation.

Pre-rasterization

  Operations that execute before rasterization, and any state associated with those operations.

Presentable image

  A `VkImage` object obtained from a `VkSwapchainKHR` used to present to a `VkSurfaceKHR` object.

Preserve Attachment

  One of a list of attachments in a subpass description that is not read or written by the subpass, but that is read or written on earlier and later subpasses and whose contents must be preserved through this subpass.

Primary Command Buffer

  A command buffer that can execute secondary command buffers, and can be submitted directly to a queue.

Primitive Shading Pipeline

  A graphics pipeline where input primitives are assembled by fixed function processing. It is the counterpart to mesh shading.

Primitive Topology

  State controlling how vertices are assembled into primitives, e.g. as lists of triangles, strips of lines, etc.

Promoted (feature)

  A feature from an older extension is considered promoted if it is made available as part of a new core version or newer extension with wider support.

Protected Buffer

  A buffer to which protected device memory can be bound.

Protected-capable Device Queue

  A device queue to which protected command buffers can be submitted.

Protected Command Buffer

  A command buffer which can be submitted to a protected-capable device queue.

Protected Device Memory

  Device memory which can be visible to the device but must not be visible to the host.

Protected Image

  An image to which protected device memory can be bound.

Provisional

  A feature is released provisionally in order to get wider feedback on the functionality before it is finalized. Provisional features may change in ways that break backwards compatibility, and thus are not recommended for use in production applications.

Provoking Vertex

  The vertex in a primitive from which flat shaded attribute values are taken. This is generally the “first” vertex in the primitive, and depends on the primitive topology.

Push Constants

  A small bank of values writable via the API and accessible in shaders. Push constants allow the application to set values used in shaders without creating buffers or modifying and binding descriptor sets for each update.

Push Constant Interface

  The set of variables with `PushConstant` storage class that are statically used by a shader entry point, and which receive values from push constant commands.

Push Descriptors

  Descriptors that are written directly into a command buffer rather than into a descriptor set. Push descriptors allow the application to set descriptors used in shaders without allocating or modifying descriptor sets for each update.

Descriptor Update Template

  An object specifying a mapping from descriptor update information in host memory to elements in a descriptor set, which helps enable more efficient descriptor set updates.

Query Pool

  An object containing a number of query entries and their associated state and results. Represented by a VkQueryPool object.

Queue

  An object that executes command buffers and sparse binding operations on a device. Represented by a VkQueue object.

Queue Family

  A set of queues that have common properties and support the same functionality, as advertised in VkQueueFamilyProperties.

Queue Operation

  A unit of work to be executed by a specific queue on a device, submitted via a queue submission command. Each queue submission command details the specific queue operations that occur as a result of calling that command. Queue operations typically include work that is specific to each command, and synchronization tasks.

Queue Submission

  Zero or more batches and an optional fence to be signaled, passed to a command for execution on a queue. See the Devices and Queues chapter for more information.

Ray Tracing Command

  Commands that provoke work using a ray tracing pipeline. Includes vkCmdTraceRaysNV, vkCmdTraceRaysKHR, and vkCmdTraceRaysIndirectKHR .

Reconstructed Picture

  A video picture resource reconstructed from a compressed bitstream using video decode or encode operations that can be used as a reference picture by future video decode or encode operations with the same video session.

Recording State (Command Buffer)

  A command buffer that is ready to record commands. See also Initial State and Executable State.

Reference Picture

  A video picture resource used by video decode and encode operations to provide predictions of the values of samples in the subsequently decoded or encoded pictures.

Reference Picture Metadata

  Opaque state associated with a DPB slot, maintained by a video session.

Release Operation (Resource)

  An operation that releases ownership of an image subresource or buffer range.

Render Pass

  An object that represents a set of framebuffer attachments and phases of rendering using those attachments. Represented by a VkRenderPass object.

Render Pass Instance

  A use of a render pass in a command buffer.

Required Extensions

  Extensions that must be enabled alongside extensions dependent on them (see Extension Dependencies).

Reset (Command Buffer)

  Resetting a command buffer discards any previously recorded commands and puts a command buffer in the initial state.

Residency Code

  An integer value returned by sparse image instructions, indicating whether any sparse unbound texels were accessed.

Resolve Attachment

  A subpass attachment point, or image view, that is the target of a multisample resolve operation from the corresponding color attachment at the end of the subpass.

Retired Swapchain

  A swapchain that has been used as the `oldSwapchain` parameter to vkCreateSwapchainKHR. Images cannot be acquired from a retired swapchain, however images that were acquired (but not presented) before the swapchain was retired can be presented.

Sample Index

  The index of a sample within a single set of samples.

Sample Shading

  Invoking the fragment shader multiple times per fragment, with the covered samples partitioned among the invocations.

Sampled Image

  A descriptor type that represents an image view, and supports filtered (sampled) and unfiltered read-only access in a shader.

Sampler

  An object containing state controlling how sampled image data is sampled (or filtered) when accessed in a shader. Also a descriptor type describing the object. Represented by a VkSampler object.

Secondary Command Buffer

  A command buffer that can be executed by a primary command buffer, and must not be submitted directly to a queue.

Self-Dependency

  A subpass dependency from a subpass to itself, i.e. with `srcSubpass` equal to `dstSubpass`. A self-dependency is not automatically performed during a render pass instance, rather a subset of it can be performed via vkCmdPipelineBarrier during the subpass.

Semaphore

  A synchronization primitive that supports signal and wait operations, and can be used to synchronize operations within a queue or across queues. Represented by a VkSemaphore object.

Shader

  Instructions selected (via an entry point) from a shader module, which are executed in a shader stage.

Shader Call

  An instruction which may cause execution to continue in a different shader stage.

Shader Code

  A stream of instructions used to describe the operation of a shader.

Shader Group

  A set of Shader Stages that are part of a VkPipeline containing multiple of such sets. This allows the device to make use of all the shader groups from the bound pipeline independently.

Shader Module

  A collection of shader code, potentially including several functions and entry points, that is used to create shaders in pipelines. Represented by a VkShaderModule object.

Shader Stage

  A stage of the graphics or compute pipeline that executes shader code.

Shading Rate

  The ratio of the number of fragment shader invocations generated in a fully covered framebuffer region to the size (in pixels) of that region.

Shading Rate Image

  An image used to establish the shading rate for a framebuffer region, where each pixel controls the shading rate for a corresponding framebuffer region.

Shared presentable image

  A presentable image created from a swapchain with VkPresentModeKHR set to either `VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR` or `VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR`.

Side Effect

  A store to memory or atomic operation on memory from a shader invocation.

Single-plane format

  A format that is not multi-planar.

Size-Compatible Image Formats

  When a compressed image format and an uncompressed image format are size-compatible, it means that the texel block size of the uncompressed format must equal the texel block size of the compressed format.

Sparse Block

  An element of a sparse resource that can be independently bound to memory. Sparse blocks of a particular sparse resource have a corresponding size in bytes that they use in the bound memory.

Sparse Image Block

  A sparse block in a sparse partially-resident image. In addition to the sparse block size in bytes, sparse image blocks have a corresponding width, height, and depth defining the dimensions of these elements in units of texels or compressed texel blocks, the latter being used in case of sparse images having a block-compressed format.

Sparse Unbound Texel

  A texel read from a region of a sparse texture that does not have memory bound to it.

SRT

  A decomposition of a spatial transform separating out scale, rotation, and translation which has better linear interpolation properties for representing motion.

Static Use

  An object in a shader is statically used by a shader entry point if any function in the entry point’s call tree contains an instruction using the object. A reference in the entry point’s interface list does not constitute a static use. Static use is used to constrain the set of descriptors used by a shader entry point.

Storage Buffer

  A descriptor type that represents a buffer, and supports reads, writes, and atomics in a shader.

Storage Image

  A descriptor type that represents an image view, and supports unfiltered loads, stores, and atomics in a shader.

Storage Texel Buffer

  A descriptor type that represents a buffer view, and supports unfiltered, formatted reads, writes, and atomics in a shader.

Subgroup

  A set of shader invocations that can synchronize and share data with each other efficiently. In compute shaders, the local workgroup is a superset of the subgroup.

Subgroup Mask

  A bitmask for all invocations in the current subgroup with one bit per invocation, starting with the least significant bit in the first vector component, continuing to the last bit (less than `SubgroupSize`) in the last required vector component.

Subpass

  A phase of rendering within a render pass, that reads and writes a subset of the attachments.

Subpass Dependency

  An execution and/or memory dependency between two subpasses described as part of render pass creation, and automatically performed between subpasses in a render pass instance. A subpass dependency limits the overlap of execution of the pair of subpasses, and can provide guarantees of memory coherence between accesses in the subpasses.

Subpass Description

  Lists of attachment indices for input attachments, color attachments, depth/stencil attachment, resolve attachments, depth/stencil resolve, and preserve attachments used by the subpass in a render pass.

Subset (Self-Dependency)

  A subset of a self-dependency is a pipeline barrier performed during the subpass of the self-dependency, and whose stage masks and access masks each contain a subset of the bits set in the identically named mask in the self-dependency.

Texel Block

  A single addressable element of an image with an uncompressed VkFormat, or a single compressed block of an image with a compressed VkFormat.

Texel Block Size

  The size (in bytes) used to store a texel block of a compressed or uncompressed image.

Texel Coordinate System

  One of three coordinate systems (normalized, unnormalized, integer) defining how texel coordinates are interpreted in an image or a specific mipmap level of an image.

Tile Image

  A per-tile view of a framebuffer attachment. If the `VK_EXT_shader_tile_image` extension is enabled, the framebuffer is considered to be divided into tiles.

Timeline Semaphore

  A semaphore with a strictly increasing 64-bit unsigned integer payload indicating whether the semaphore is signaled with respect to a particular reference value. Represented by a VkSemaphore object created with a semaphore type of `VK_SEMAPHORE_TYPE_TIMELINE`.

Uniform Texel Buffer

  A descriptor type that represents a buffer view, and supports unfiltered, formatted, read-only access in a shader.

Uniform Buffer

  A descriptor type that represents a buffer, and supports read-only access in a shader.

Units in the Last Place (ULP)

  A measure of floating-point error loosely defined as the smallest representable step in a floating-point format near a given value. For the precise definition see Precision and Operation of SPIR-V instructions or Jean-Michel Muller, “On the definition of ulp(x)”, RR-5504, INRIA. Other sources may also use the term “unit of least precision”.

Unnormalized

  A value that is interpreted according to its conventional interpretation, and is not normalized.

Unprotected Buffer

  A buffer to which unprotected device memory can be bound.

Unprotected Command Buffer

  A command buffer which can be submitted to an unprotected device queue or a protected-capable device queue.

Unprotected Device Memory

  Device memory which can be visible to the device and can be visible to the host.

Unprotected Image

  An image to which unprotected device memory can be bound.

User-Defined Variable Interface

  A shader entry point’s variables with `Input` or `Output` storage class that are not built-in variables.

Vertex Input Attribute

  A graphics pipeline resource that produces input values for the vertex shader by reading data from a vertex input binding and converting it to the attribute’s format.

Vertex Stream

  A vertex stream is where the last pre-rasterization shader stages outputs vertex data, which then goes to the rasterizer, is captured to a transform feedback buffer, or both. Geometry shaders can emit primitives to multiple independent vertex streams. Each vertex emitted by the geometry shader is directed at one of the vertex streams.

Validation Cache

  An object that can be used to collect and retrieve validation results from the validation layers, and can be populated with previously retrieved results in order to accelerate the validation process. Represented by a VkValidationCacheEXT object.

Variable-Sized Descriptor Binding

  A descriptor binding whose size will be specified when a descriptor set is allocated using this layout.

Vertex Input Binding

  A graphics pipeline resource that is bound to a buffer and includes state that affects addressing calculations within that buffer.

Vertex Input Interface

  A vertex shader entry point’s variables with `Input` storage class, which receive values from vertex input attributes.

Video Bitstream Buffer

  A resource that represents a linear array of data in device memory storing encoded video data. Represented by a VkBuffer object.

Video Coding Scope

  A series of subsequent commands recorded into a command buffer starting with a vkCmdBeginVideoCodingKHR command and ending with a vkCmdEndVideoCodingKHR command that encompasses a set of video decode or encode operations.

Video Coding Operations

  Any operations recorded into a command buffer within a video coding scope, including video decode and encode operations.

Video Decode Operation

  An operation consuming data from a video bitstream buffer and zero or more reference pictures, and producing data to a decode output picture and an optional reconstructed picture.

Video Encode Operation

  An operation consuming data from an encode input picture and zero or more reference pictures, and producing data to a video bitstream buffer and an optional reconstructed picture.

Video Picture Resource

  A resource that represents a multi-dimensional formatted interpretation of device memory to be used with a video session as a decode output picture, encode input picture, reconstructed picture, and/or reference picture. It may contain metadata associated with a particular video session it is used with. Represented by a VkImage object and referred to using VkImageView objects created from it.

Video Session

  A resource that represents and maintains the state needed to perform video decode or encode operations. Represented by a VkVideoSessionKHR object.

Video Session Parameters

  A resource that stores preprocessed codec-specific parameters used with a compatible video session in video codec operations. Represented by a VkVideoSessionParametersKHR object.

Video Transcoding

  The process of using the outputs of video decoding operations as inputs in video encoding operations.

View Mask

  When multiview is enabled, a view mask is a property of a subpass controlling which views the rendering commands are broadcast to.

View Volume

  A subspace in homogeneous coordinates, corresponding to post-projection x and y values between -1 and +1, and z values between 0 and +1.

Viewport Transformation

  A transformation from normalized device coordinates to framebuffer coordinates, based on a viewport rectangle and depth range.

Visibility Operation

  An operation that causes available values to become visible to specified memory accesses.

Visible

  A state of values written to memory that allows them to be accessed by a set of operations.

### Common Abbreviations

The abbreviations and acronyms defined in this section are sometimes used in the Specification and the API where they are considered clear and commonplace.

Src

  Source

Dst

  Destination

Min

  Minimum

Max

  Maximum

Rect

  Rectangle

Info

  Information

LOD

  Level of Detail

Log

  Logarithm

ID

  Identifier

UUID

  Universally Unique Identifier

Op

  Operation

R

  Red color component

G

  Green color component

B

  Blue color component

A

  Alpha color component

RTZ

  Round towards zero

RTE

  Round to nearest even

### Video-Specific Abbreviations

The following abbreviations and acronyms are used in the context of video decode and encode operations to refer to commonly used video compression terms in their usual abbreviated form:

AVC

  Advanced Video Coding

Bipred

  Bidirectional Prediction

CABAC

  Context-Adaptive Binary Arithmetic Coding

CAVLC

  Context-Adaptive Variable-Length Coding

CBR

  Constant Bit Rate

CTB

  Coding Tree Block

Diff

  Difference

DPB

  Decoded Picture Buffer

GOP

  Group Of Pictures

HDR

  High Dynamic Range

HEVC

  High Efficiency Video Coding

HRD

  Hypothetical Reference Decoder

IDC

  Indicator

IDR

  Instantaneous Decoder Refresh

MB

  Macroblock

MV

  Motion Vector

NALU

  Network Abstraction Layer Unit

PCM

  Pulse-Code Modulation

Pic

  Picture

Pred

  Prediction

PPS

  Picture Parameter Set

QP

  Quantization Parameter

RC

  Rate Control

SPS

  Sequence Parameter Set

Std

  Standard

VBR

  Variable Bit Rate

VCL

  Video Coding Layer

VPS

  Video Parameter Set

### Prefixes

Prefixes are used in the API to denote specific semantic meaning of Vulkan names, or as a label to avoid name clashes, and are explained here:

VK/Vk/vk

  Vulkan namespace
  All types, commands, enumerants and defines in this specification are prefixed with these two characters.

PFN/pfn

  Function Pointer
  Denotes that a type is a function pointer, or that a variable is of a pointer type.

p

  Pointer
  Variable is a pointer.

vkCmd

  Commands that record commands in command buffers
  These API commands do not result in immediate processing on the device. Instead, they record the requested action in a command buffer for execution when the command buffer is submitted to a queue.

s

  Structure
  Used to denote the `VK_STRUCTURE_TYPE*` member of each structure in `sType`