All Downloads are FREE. Search and download functionalities are using the official Maven repository.

org.lwjgl.vulkan.KHRVideoQueue Maven / Gradle / Ivy

Go to download

A new generation graphics and compute API that provides high-efficiency, cross-platform access to modern GPUs used in a wide variety of devices from PCs and consoles to mobile phones and embedded platforms.

There is a newer version: 3.3.4
Show newest version
/*
 * Copyright LWJGL. All rights reserved.
 * License terms: https://www.lwjgl.org/license
 * MACHINE GENERATED FILE, DO NOT EDIT
 */
package org.lwjgl.vulkan;

import javax.annotation.*;

import java.nio.*;

import org.lwjgl.system.*;

import static org.lwjgl.system.Checks.*;
import static org.lwjgl.system.JNI.*;
import static org.lwjgl.system.MemoryUtil.*;

/**
 * 
    
 * 
  • {@code VkVideoSessionKHR}
    • 
 * 
  • {@code VkVideoSessionParametersKHR}
    • 
 * 

 * 
 * 
VK_KHR_video_queue

 * 
 * 

 * 
Name String

 * 
{@code VK_KHR_video_queue}

 * 
Extension Type

 * 
Device extension

 * 
Registered Extension Number

 * 
24

 * 
Revision

 * 
2

 * 
Extension and Version Dependencies

 * 
    
 * 
  • Requires Vulkan 1.0
    • 
 * 
  • Requires {@link KHRGetPhysicalDeviceProperties2 VK_KHR_get_physical_device_properties2}
    • 
 * 
  • Requires {@link KHRSamplerYcbcrConversion VK_KHR_sampler_ycbcr_conversion}
    • 
 * 
  • This is a provisional extension and must be used with caution. See the description of provisional header files for enablement and stability details.
    • 
 * 

 * 
Contact

 * 

 * 

 * 
 * 
Other Extension Metadata

 * 
 * 

 * 
Last Modified Date

 * 
2021-03-29

 * 
IP Status

 * 
No known IP claims.

 * 
Contributors

 * 
    
 * 
  • Ahmed Abdelkhalek, AMD
    • 
 * 
  • George Hao, AMD
    • 
 * 
  • Jake Beju, AMD
    • 
 * 
  • Piers Daniell, NVIDIA
    • 
 * 
  • Srinath Kumarapuram, NVIDIA
    • 
 * 
  • Tobias Hector, AMD
    • 
 * 
  • Tony Zlatinski, NVIDIA
    • 
 * 

 * 

 */
public class KHRVideoQueue {

    /** The extension specification version. */
    public static final int VK_KHR_VIDEO_QUEUE_SPEC_VERSION = 2;

    /** The extension name. */
    public static final String VK_KHR_VIDEO_QUEUE_EXTENSION_NAME = "VK_KHR_video_queue";

    /**
     * Extends {@code VkStructureType}.
     * 
     * 
Enum values:

     * 
     * 
    
     * 
  • {@link #VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR STRUCTURE_TYPE_VIDEO_PROFILE_KHR}
    • 
     * 
  • {@link #VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR}
    • 
     * 
  • {@link #VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_KHR STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_KHR}
    • 
     * 
  • {@link #VK_STRUCTURE_TYPE_VIDEO_GET_MEMORY_PROPERTIES_KHR STRUCTURE_TYPE_VIDEO_GET_MEMORY_PROPERTIES_KHR}
    • 
     * 
  • {@link #VK_STRUCTURE_TYPE_VIDEO_BIND_MEMORY_KHR STRUCTURE_TYPE_VIDEO_BIND_MEMORY_KHR}
    • 
     * 
  • {@link #VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR}
    • 
     * 
  • {@link #VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR}
    • 
     * 
  • {@link #VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR}
    • 
     * 
  • {@link #VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR}
    • 
     * 
  • {@link #VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR}
    • 
     * 
  • {@link #VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR}
    • 
     * 
  • {@link #VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_KHR STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_KHR}
    • 
     * 
  • {@link #VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR}
    • 
     * 
  • {@link #VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR STRUCTURE_TYPE_VIDEO_PROFILES_KHR}
    • 
     * 
  • {@link #VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR}
    • 
     * 
  • {@link #VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR}
    • 
     * 

     */
    public static final int
        VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR                        = 1000023000,
        VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR                   = 1000023001,
        VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_KHR               = 1000023002,
        VK_STRUCTURE_TYPE_VIDEO_GET_MEMORY_PROPERTIES_KHR          = 1000023003,
        VK_STRUCTURE_TYPE_VIDEO_BIND_MEMORY_KHR                    = 1000023004,
        VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR            = 1000023005,
        VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000023006,
        VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR = 1000023007,
        VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR              = 1000023008,
        VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR                = 1000023009,
        VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR            = 1000023010,
        VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_KHR                 = 1000023011,
        VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR      = 1000023012,
        VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR                       = 1000023013,
        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR    = 1000023014,
        VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR              = 1000023015;

    /**
     * Extends {@code VkObjectType}.
     * 
     * 
Enum values:

     * 
     * 
    
     * 
  • {@link #VK_OBJECT_TYPE_VIDEO_SESSION_KHR OBJECT_TYPE_VIDEO_SESSION_KHR}
    • 
     * 
  • {@link #VK_OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR}
    • 
     * 

     */
    public static final int
        VK_OBJECT_TYPE_VIDEO_SESSION_KHR            = 1000023000,
        VK_OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR = 1000023001;

    /** Extends {@code VkQueryType}. */
    public static final int VK_QUERY_TYPE_RESULT_STATUS_ONLY_KHR = 1000023000;

    /** Extends {@code VkQueryResultFlagBits}. */
    public static final int VK_QUERY_RESULT_WITH_STATUS_BIT_KHR = 0x10;

    /**
     * VkVideoCodecOperationFlagBitsKHR - Video codec operation types
     * 
     * 
Description

     * 
     * 
Each decode or encode codec-specific extension extends this enumeration with the appropriate bit corresponding to the extension’s codec operation:

     * 
     * 
    
     * 
  • {@link #VK_VIDEO_CODEC_OPERATION_INVALID_BIT_KHR VIDEO_CODEC_OPERATION_INVALID_BIT_KHR} - No video operations are supported for this queue family.
    • 
     * 
  • {@link EXTVideoEncodeH264#VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_EXT VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_EXT} - H.264 video encode operations are supported by this queue family.
    • 
     * 
  • {@link EXTVideoDecodeH264#VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_EXT VIDEO_CODEC_OPERATION_DECODE_H264_BIT_EXT} - H.264 video decode operations are supported by this queue family.
    • 
     * 
  • {@link EXTVideoDecodeH265#VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_EXT VIDEO_CODEC_OPERATION_DECODE_H265_BIT_EXT} - H.265 video decode operations are supported by this queue family.
    • 
     * 

     * 
     * 
See Also

     * 
     * 
{@link VkVideoProfileKHR}

     */
    public static final int VK_VIDEO_CODEC_OPERATION_INVALID_BIT_KHR = 0;

    /**
     * VkVideoChromaSubsamplingFlagBitsKHR - Video chroma subsampling
     * 
     * 
Description

     * 
     * 
    
     * 
  • {@link #VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR} - the format is monochrome.
    • 
     * 
  • {@link #VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR} - the format is 4:2:0 chroma subsampled. The two chroma components are each subsampled at a factor of 2 both horizontally and vertically.
    • 
     * 
  • {@link #VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR} - the format is 4:2:2 chroma subsampled. The two chroma components are sampled at half the sample rate of luma. The horizontal chroma resolution is halved.
    • 
     * 
  • {@link #VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR} - the format is 4:4:4 chroma sampled. Each of the three YCbCr components have the same sample rate, thus there is no chroma subsampling.
    • 
     * 

     * 
     * 
Enum values:

     * 
     * 
    
     * 
  • {@link #VK_VIDEO_CHROMA_SUBSAMPLING_INVALID_BIT_KHR VIDEO_CHROMA_SUBSAMPLING_INVALID_BIT_KHR}
    • 
     * 

     */
    public static final int
        VK_VIDEO_CHROMA_SUBSAMPLING_INVALID_BIT_KHR    = 0,
        VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR = 0x1,
        VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR        = 0x2,
        VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR        = 0x4,
        VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR        = 0x8;

    /**
     * VkVideoComponentBitDepthFlagBitsKHR - Video component bit depth
     * 
     * 
Description

     * 
     * 
    
     * 
  • {@link #VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR} - the format component bit depth is 8 bits.
    • 
     * 
  • {@link #VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR} - the format component bit depth is 10 bits.
    • 
     * 
  • {@link #VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR} - the format component bit depth is 12 bits.
    • 
     * 

     * 
     * 
Enum values:

     * 
     * 
    
     * 
  • {@link #VK_VIDEO_COMPONENT_BIT_DEPTH_INVALID_KHR VIDEO_COMPONENT_BIT_DEPTH_INVALID_KHR}
    • 
     * 

     */
    public static final int
        VK_VIDEO_COMPONENT_BIT_DEPTH_INVALID_KHR = 0,
        VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR   = 0x1,
        VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR  = 0x4,
        VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR  = 0x10;

    /**
     * VkVideoCapabilityFlagBitsKHR - Video Decode and Encode Capability Flags
     * 
     * 
Description

     * 
     * 
    
     * 
  • {@link #VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR} - the decode or encode session supports protected content.
    • 
     * 
  • {@link #VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR} - the DPB or Reconstructed Video Picture Resources for the video session may be created as a separate {@code VkImage} for each DPB picture. If not supported, the DPB must be created as single multi-layered image where each layer represents one of the DPB Video Picture Resources.
    • 
     * 

     */
    public static final int
        VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR         = 0x1,
        VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR = 0x2;

    /**
     * VkVideoSessionCreateFlagBitsKHR - Video decode or encode video session creation flags
     * 
     * 
Description

     * 
     * 
    
     * 
  • {@link #VK_VIDEO_SESSION_CREATE_PROTECTED_CONTENT_BIT_KHR VIDEO_SESSION_CREATE_PROTECTED_CONTENT_BIT_KHR} - create the video session for use with protected video content
    • 
     * 

     * 
     * 
Enum values:

     * 
     * 
    
     * 
  • {@link #VK_VIDEO_SESSION_CREATE_DEFAULT_KHR VIDEO_SESSION_CREATE_DEFAULT_KHR}
    • 
     * 

     */
    public static final int
        VK_VIDEO_SESSION_CREATE_DEFAULT_KHR               = 0,
        VK_VIDEO_SESSION_CREATE_PROTECTED_CONTENT_BIT_KHR = 0x1;

    /**
     * VkVideoCodingControlFlagBitsKHR - Video Coding Control Command Flags
     * 
     * 
Description

     * 
     * 
    
     * 
  • {@link #VK_VIDEO_CODING_CONTROL_DEFAULT_KHR VIDEO_CODING_CONTROL_DEFAULT_KHR} indicates a request for the coding control paramaters to be applied to the current state of the bound video session.
    • 
     * 
  • {@link #VK_VIDEO_CODING_CONTROL_RESET_BIT_KHR VIDEO_CODING_CONTROL_RESET_BIT_KHR} indicates a request for the bound video session state to be reset before the coding control parameters are applied. The state after reset is identical to the state immediately after video session creation.
    • 
     * 

     */
    public static final int
        VK_VIDEO_CODING_CONTROL_DEFAULT_KHR   = 0,
        VK_VIDEO_CODING_CONTROL_RESET_BIT_KHR = 0x1;

    /**
     * VkVideoCodingQualityPresetFlagBitsKHR - Video codec profile types
     * 
     * 
Description

     * 
     * 
    
     * 
  • {@link #VK_VIDEO_CODING_QUALITY_PRESET_NORMAL_BIT_KHR VIDEO_CODING_QUALITY_PRESET_NORMAL_BIT_KHR} defines normal decode case.
    • 
     * 
  • {@link #VK_VIDEO_CODING_QUALITY_PRESET_POWER_BIT_KHR VIDEO_CODING_QUALITY_PRESET_POWER_BIT_KHR} defines power efficient case.
    • 
     * 
  • {@link #VK_VIDEO_CODING_QUALITY_PRESET_QUALITY_BIT_KHR VIDEO_CODING_QUALITY_PRESET_QUALITY_BIT_KHR} defines quality focus case.
    • 
     * 

     */
    public static final int
        VK_VIDEO_CODING_QUALITY_PRESET_NORMAL_BIT_KHR  = 0x1,
        VK_VIDEO_CODING_QUALITY_PRESET_POWER_BIT_KHR   = 0x2,
        VK_VIDEO_CODING_QUALITY_PRESET_QUALITY_BIT_KHR = 0x4;

    /**
     * VkQueryResultStatusKHR - Specific status codes for operations
     * 
     * 
Description

     * 
     * 
    
     * 
  • {@link #VK_QUERY_RESULT_STATUS_NOT_READY_KHR QUERY_RESULT_STATUS_NOT_READY_KHR} specifies that the query result is not yet available.
    • 
     * 
  • {@link #VK_QUERY_RESULT_STATUS_ERROR_KHR QUERY_RESULT_STATUS_ERROR_KHR} specifies that operations did not complete successfully.
    • 
     * 
  • {@link #VK_QUERY_RESULT_STATUS_COMPLETE_KHR QUERY_RESULT_STATUS_COMPLETE_KHR} specifies that operations completed successfully and the query result is available.
    • 
     * 

     */
    public static final int
        VK_QUERY_RESULT_STATUS_ERROR_KHR     = -1,
        VK_QUERY_RESULT_STATUS_NOT_READY_KHR = 0,
        VK_QUERY_RESULT_STATUS_COMPLETE_KHR  = 1;

    protected KHRVideoQueue() {
        throw new UnsupportedOperationException();
    }

    // --- [ vkGetPhysicalDeviceVideoCapabilitiesKHR ] ---

    /** Unsafe version of: {@link #vkGetPhysicalDeviceVideoCapabilitiesKHR GetPhysicalDeviceVideoCapabilitiesKHR} */
    public static int nvkGetPhysicalDeviceVideoCapabilitiesKHR(VkPhysicalDevice physicalDevice, long pVideoProfile, long pCapabilities) {
        long __functionAddress = physicalDevice.getCapabilities().vkGetPhysicalDeviceVideoCapabilitiesKHR;
        if (CHECKS) {
            check(__functionAddress);
        }
        return callPPPI(physicalDevice.address(), pVideoProfile, pCapabilities, __functionAddress);
    }

    /**
     * Query video decode or encode capabilities.
     * 
     * 
C Specification

     * 
     * 
To query video decode or encode capabilities for a specific codec, call:

     * 
     * 

     * VkResult vkGetPhysicalDeviceVideoCapabilitiesKHR(
     *     VkPhysicalDevice                            physicalDevice,
     *     const VkVideoProfileKHR*                    pVideoProfile,
     *     VkVideoCapabilitiesKHR*                     pCapabilities);

     * 
     * 
Valid Usage (Implicit)

     * 
     * 
    
     * 
  • {@code physicalDevice} must be a valid {@code VkPhysicalDevice} handle
    • 
     * 
  • {@code pVideoProfile} must be a valid pointer to a valid {@link VkVideoProfileKHR} structure
    • 
     * 
  • {@code pCapabilities} must be a valid pointer to a {@link VkVideoCapabilitiesKHR} structure
    • 
     * 

     * 
     * 
Return Codes

     * 
     * 

     * 
On success, this command returns

     * 
    
     * 
  • {@link VK10#VK_SUCCESS SUCCESS}
    • 
     * 

     * 
On failure, this command returns

     * 
    
     * 
  • {@link VK10#VK_ERROR_EXTENSION_NOT_PRESENT ERROR_EXTENSION_NOT_PRESENT}
    • 
     * 
  • {@link VK10#VK_ERROR_INITIALIZATION_FAILED ERROR_INITIALIZATION_FAILED}
    • 
     * 
  • {@link VK10#VK_ERROR_FEATURE_NOT_PRESENT ERROR_FEATURE_NOT_PRESENT}
    • 
     * 
  • {@link VK10#VK_ERROR_FORMAT_NOT_SUPPORTED ERROR_FORMAT_NOT_SUPPORTED}
    • 
     * 

     * 

     * 
     * 
See Also

     * 
     * 
{@link VkVideoCapabilitiesKHR}, {@link VkVideoProfileKHR}

     *
     * @param physicalDevice the physical device whose video decode or encode capabilities will be queried.
     * @param pVideoProfile  a pointer to a {@link VkVideoProfileKHR} structure with a chained codec-operation specific video profile structure.
     * @param pCapabilities  a pointer to a {@link VkVideoCapabilitiesKHR} structure in which the capabilities are returned.
     */
    @NativeType("VkResult")
    public static int vkGetPhysicalDeviceVideoCapabilitiesKHR(VkPhysicalDevice physicalDevice, @NativeType("VkVideoProfileKHR const *") VkVideoProfileKHR pVideoProfile, @NativeType("VkVideoCapabilitiesKHR *") VkVideoCapabilitiesKHR pCapabilities) {
        return nvkGetPhysicalDeviceVideoCapabilitiesKHR(physicalDevice, pVideoProfile.address(), pCapabilities.address());
    }

    // --- [ vkGetPhysicalDeviceVideoFormatPropertiesKHR ] ---

    /**
     * Unsafe version of: {@link #vkGetPhysicalDeviceVideoFormatPropertiesKHR GetPhysicalDeviceVideoFormatPropertiesKHR}
     *
     * @param pVideoFormatPropertyCount a pointer to an integer related to the number of video format properties available or queried, as described below.
     */
    public static int nvkGetPhysicalDeviceVideoFormatPropertiesKHR(VkPhysicalDevice physicalDevice, long pVideoFormatInfo, long pVideoFormatPropertyCount, long pVideoFormatProperties) {
        long __functionAddress = physicalDevice.getCapabilities().vkGetPhysicalDeviceVideoFormatPropertiesKHR;
        if (CHECKS) {
            check(__functionAddress);
        }
        return callPPPPI(physicalDevice.address(), pVideoFormatInfo, pVideoFormatPropertyCount, pVideoFormatProperties, __functionAddress);
    }

    /**
     * Query supported Video Decode and Encode image formats.
     * 
     * 
C Specification

     * 
     * 
To enumerate the supported output, input and DPB image formats for a specific codec operation and video profile, call:

     * 
     * 

     * VkResult vkGetPhysicalDeviceVideoFormatPropertiesKHR(
     *     VkPhysicalDevice                            physicalDevice,
     *     const VkPhysicalDeviceVideoFormatInfoKHR*   pVideoFormatInfo,
     *     uint32_t*                                   pVideoFormatPropertyCount,
     *     VkVideoFormatPropertiesKHR*                 pVideoFormatProperties);

     * 
     * 
Description

     * 
     * 
If {@code pVideoFormatProperties} is {@code NULL}, then the number of video format properties supported for the given {@code physicalDevice} is returned in {@code pVideoFormatPropertyCount}. Otherwise, {@code pVideoFormatPropertyCount} must point to a variable set by the user to the number of elements in the {@code pVideoFormatProperties} array, and on return the variable is overwritten with the number of values actually written to {@code pVideoFormatProperties}. If the value of {@code pVideoFormatPropertyCount} is less than the number of video format properties supported, at most {@code pVideoFormatPropertyCount} values will be written to {@code pVideoFormatProperties}, and {@link VK10#VK_INCOMPLETE INCOMPLETE} will be returned instead of {@link VK10#VK_SUCCESS SUCCESS}, to indicate that not all the available values were returned.

     * 
     * 
Valid Usage

     * 
     * 
    
     * 
  • The {@code imageUsage} enum of {@link VkPhysicalDeviceVideoFormatInfoKHR} must contain at least one of the following video image usage bit(s): {@link KHRVideoDecodeQueue#VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR}, {@link KHRVideoDecodeQueue#VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR}, {@link KHRVideoEncodeQueue#VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR}, or {@link KHRVideoEncodeQueue#VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR}
    • 
     * 

     * 
     * 
Note:

     * 
     * 
For most use cases, only decode or encode related usage flags are going to be specified. For a use case such as transcode, if the image were to be shared between decode and encode session(s), then both decode and encode related usage flags can be set.

     * 

     * 
     * 
Valid Usage (Implicit)

     * 
     * 
    
     * 
  • {@code physicalDevice} must be a valid {@code VkPhysicalDevice} handle
    • 
     * 
  • {@code pVideoFormatInfo} must be a valid pointer to a valid {@link VkPhysicalDeviceVideoFormatInfoKHR} structure
    • 
     * 
  • {@code pVideoFormatPropertyCount} must be a valid pointer to a {@code uint32_t} value
    • 
     * 
  • If the value referenced by {@code pVideoFormatPropertyCount} is not 0, and {@code pVideoFormatProperties} is not {@code NULL}, {@code pVideoFormatProperties} must be a valid pointer to an array of {@code pVideoFormatPropertyCount} {@link VkVideoFormatPropertiesKHR} structures
    • 
     * 

     * 
     * 
Return Codes

     * 
     * 

     * 
On success, this command returns

     * 
    
     * 
  • {@link VK10#VK_SUCCESS SUCCESS}
    • 
     * 
  • {@link VK10#VK_INCOMPLETE INCOMPLETE}
    • 
     * 

     * 
On failure, this command returns

     * 
    
     * 
  • {@link VK10#VK_ERROR_EXTENSION_NOT_PRESENT ERROR_EXTENSION_NOT_PRESENT}
    • 
     * 
  • {@link VK10#VK_ERROR_INITIALIZATION_FAILED ERROR_INITIALIZATION_FAILED}
    • 
     * 
  • {@link VK10#VK_ERROR_FORMAT_NOT_SUPPORTED ERROR_FORMAT_NOT_SUPPORTED}
    • 
     * 

     * 

     * 
     * 
See Also

     * 
     * 
{@link VkPhysicalDeviceVideoFormatInfoKHR}, {@link VkVideoFormatPropertiesKHR}

     *
     * @param physicalDevice            the physical device being queried.
     * @param pVideoFormatInfo          a pointer to a {@link VkPhysicalDeviceVideoFormatInfoKHR} structure specifying the codec and video profile for which information is returned.
     * @param pVideoFormatPropertyCount a pointer to an integer related to the number of video format properties available or queried, as described below.
     * @param pVideoFormatProperties    a pointer to an array of {@link VkVideoFormatPropertiesKHR} structures in which supported formats are returned.
     */
    @NativeType("VkResult")
    public static int vkGetPhysicalDeviceVideoFormatPropertiesKHR(VkPhysicalDevice physicalDevice, @NativeType("VkPhysicalDeviceVideoFormatInfoKHR const *") VkPhysicalDeviceVideoFormatInfoKHR pVideoFormatInfo, @NativeType("uint32_t *") IntBuffer pVideoFormatPropertyCount, @Nullable @NativeType("VkVideoFormatPropertiesKHR *") VkVideoFormatPropertiesKHR.Buffer pVideoFormatProperties) {
        if (CHECKS) {
            check(pVideoFormatPropertyCount, 1);
            checkSafe(pVideoFormatProperties, pVideoFormatPropertyCount.get(pVideoFormatPropertyCount.position()));
        }
        return nvkGetPhysicalDeviceVideoFormatPropertiesKHR(physicalDevice, pVideoFormatInfo.address(), memAddress(pVideoFormatPropertyCount), memAddressSafe(pVideoFormatProperties));
    }

    // --- [ vkCreateVideoSessionKHR ] ---

    /** Unsafe version of: {@link #vkCreateVideoSessionKHR CreateVideoSessionKHR} */
    public static int nvkCreateVideoSessionKHR(VkDevice device, long pCreateInfo, long pAllocator, long pVideoSession) {
        long __functionAddress = device.getCapabilities().vkCreateVideoSessionKHR;
        if (CHECKS) {
            check(__functionAddress);
            VkVideoSessionCreateInfoKHR.validate(pCreateInfo);
            if (pAllocator != NULL) { VkAllocationCallbacks.validate(pAllocator); }
        }
        return callPPPPI(device.address(), pCreateInfo, pAllocator, pVideoSession, __functionAddress);
    }

    /**
     * Creates a video session object.
     * 
     * 
C Specification

     * 
     * 
To create a video session object, call:

     * 
     * 

     * VkResult vkCreateVideoSessionKHR(
     *     VkDevice                                    device,
     *     const VkVideoSessionCreateInfoKHR*          pCreateInfo,
     *     const VkAllocationCallbacks*                pAllocator,
     *     VkVideoSessionKHR*                          pVideoSession);

     * 
     * 
Valid Usage (Implicit)

     * 
     * 
    
     * 
  • {@code device} must be a valid {@code VkDevice} handle
    • 
     * 
  • {@code pCreateInfo} must be a valid pointer to a valid {@link VkVideoSessionCreateInfoKHR} structure
    • 
     * 
  • If {@code pAllocator} is not {@code NULL}, {@code pAllocator} must be a valid pointer to a valid {@link VkAllocationCallbacks} structure
    • 
     * 
  • {@code pVideoSession} must be a valid pointer to a {@code VkVideoSessionKHR} handle
    • 
     * 

     * 
     * 
Return Codes

     * 
     * 

     * 
On success, this command returns

     * 
    
     * 
  • {@link VK10#VK_SUCCESS SUCCESS}
    • 
     * 

     * 
On failure, this command returns

     * 
    
     * 
  • {@link VK10#VK_ERROR_OUT_OF_HOST_MEMORY ERROR_OUT_OF_HOST_MEMORY}
    • 
     * 
  • {@link VK10#VK_ERROR_OUT_OF_DEVICE_MEMORY ERROR_OUT_OF_DEVICE_MEMORY}
    • 
     * 
  • {@link VK10#VK_ERROR_INITIALIZATION_FAILED ERROR_INITIALIZATION_FAILED}
    • 
     * 
  • {@link VK10#VK_ERROR_INCOMPATIBLE_DRIVER ERROR_INCOMPATIBLE_DRIVER}
    • 
     * 
  • {@link VK10#VK_ERROR_FEATURE_NOT_PRESENT ERROR_FEATURE_NOT_PRESENT}
    • 
     * 

     * 

     * 
     * 
See Also

     * 
     * 
{@link VkAllocationCallbacks}, {@link VkVideoSessionCreateInfoKHR}

     *
     * @param device        the logical device that creates the decode or encode session object.
     * @param pCreateInfo   a pointer to a {@link VkVideoSessionCreateInfoKHR} structure containing parameters specifying the creation of the decode or encode session.
     * @param pAllocator    controls host memory allocation as described in the Memory Allocation chapter.
     * @param pVideoSession a pointer to a {@code VkVideoSessionKHR} structure specifying the decode or encode video session object which will be created by this function when it returns {@link VK10#VK_SUCCESS SUCCESS}
     */
    @NativeType("VkResult")
    public static int vkCreateVideoSessionKHR(VkDevice device, @NativeType("VkVideoSessionCreateInfoKHR const *") VkVideoSessionCreateInfoKHR pCreateInfo, @Nullable @NativeType("VkAllocationCallbacks const *") VkAllocationCallbacks pAllocator, @NativeType("VkVideoSessionKHR *") LongBuffer pVideoSession) {
        if (CHECKS) {
            check(pVideoSession, 1);
        }
        return nvkCreateVideoSessionKHR(device, pCreateInfo.address(), memAddressSafe(pAllocator), memAddress(pVideoSession));
    }

    // --- [ vkDestroyVideoSessionKHR ] ---

    /** Unsafe version of: {@link #vkDestroyVideoSessionKHR DestroyVideoSessionKHR} */
    public static void nvkDestroyVideoSessionKHR(VkDevice device, long videoSession, long pAllocator) {
        long __functionAddress = device.getCapabilities().vkDestroyVideoSessionKHR;
        if (CHECKS) {
            check(__functionAddress);
            if (pAllocator != NULL) { VkAllocationCallbacks.validate(pAllocator); }
        }
        callPJPV(device.address(), videoSession, pAllocator, __functionAddress);
    }

    /**
     * Destroy decode session object.
     * 
     * 
C Specification

     * 
     * 
To destroy a decode session object, call:

     * 
     * 

     * void vkDestroyVideoSessionKHR(
     *     VkDevice                                    device,
     *     VkVideoSessionKHR                           videoSession,
     *     const VkAllocationCallbacks*                pAllocator);

     * 
     * 
Valid Usage (Implicit)

     * 
     * 
    
     * 
  • {@code device} must be a valid {@code VkDevice} handle
    • 
     * 
  • {@code videoSession} must be a valid {@code VkVideoSessionKHR} handle
    • 
     * 
  • If {@code pAllocator} is not {@code NULL}, {@code pAllocator} must be a valid pointer to a valid {@link VkAllocationCallbacks} structure
    • 
     * 
  • {@code videoSession} must have been created, allocated, or retrieved from {@code device}
    • 
     * 

     * 
     * 
See Also

     * 
     * 
{@link VkAllocationCallbacks}

     *
     * @param device       the device that was used for the creation of the video session.
     * @param videoSession the decode or encode video session to be destroyed.
     * @param pAllocator   controls host memory allocation as described in the Memory Allocation chapter.
     */
    public static void vkDestroyVideoSessionKHR(VkDevice device, @NativeType("VkVideoSessionKHR") long videoSession, @Nullable @NativeType("VkAllocationCallbacks const *") VkAllocationCallbacks pAllocator) {
        nvkDestroyVideoSessionKHR(device, videoSession, memAddressSafe(pAllocator));
    }

    // --- [ vkGetVideoSessionMemoryRequirementsKHR ] ---

    /**
     * Unsafe version of: {@link #vkGetVideoSessionMemoryRequirementsKHR GetVideoSessionMemoryRequirementsKHR}
     *
     * @param pVideoSessionMemoryRequirementsCount a pointer to an integer related to the number of memory heap requirements available or queried, as described below.
     */
    public static int nvkGetVideoSessionMemoryRequirementsKHR(VkDevice device, long videoSession, long pVideoSessionMemoryRequirementsCount, long pVideoSessionMemoryRequirements) {
        long __functionAddress = device.getCapabilities().vkGetVideoSessionMemoryRequirementsKHR;
        if (CHECKS) {
            check(__functionAddress);
        }
        return callPJPPI(device.address(), videoSession, pVideoSessionMemoryRequirementsCount, pVideoSessionMemoryRequirements, __functionAddress);
    }

    /**
     * Get Memory Requirements.
     * 
     * 
C Specification

     * 
     * 
To get memory requirements for a video session, call:

     * 
     * 

     * VkResult vkGetVideoSessionMemoryRequirementsKHR(
     *     VkDevice                                    device,
     *     VkVideoSessionKHR                           videoSession,
     *     uint32_t*                                   pVideoSessionMemoryRequirementsCount,
     *     VkVideoGetMemoryPropertiesKHR*              pVideoSessionMemoryRequirements);

     * 
     * 
Description

     * 
     * 
If {@code pVideoSessionMemoryRequirements} is {@code NULL}, then the number of memory heap types required for the video session is returned in {@code pVideoSessionMemoryRequirementsCount}. Otherwise, {@code pVideoSessionMemoryRequirementsCount} must point to a variable set by the user with the number of elements in the {@code pVideoSessionMemoryRequirements} array, and on return the variable is overwritten with the number of formats actually written to {@code pVideoSessionMemoryRequirements}. If {@code pVideoSessionMemoryRequirementsCount} is less than the number of memory heap types required for the video session, then at most {@code pVideoSessionMemoryRequirementsCount} elements will be written to {@code pVideoSessionMemoryRequirements}, and {@link VK10#VK_INCOMPLETE INCOMPLETE} will be returned, instead of {@link VK10#VK_SUCCESS SUCCESS}, to indicate that not all required memory heap types were returned.

     * 
     * 
Valid Usage (Implicit)

     * 
     * 
    
     * 
  • {@code device} must be a valid {@code VkDevice} handle
    • 
     * 
  • {@code videoSession} must be a valid {@code VkVideoSessionKHR} handle
    • 
     * 
  • {@code pVideoSessionMemoryRequirementsCount} must be a valid pointer to a {@code uint32_t} value
    • 
     * 
  • If the value referenced by {@code pVideoSessionMemoryRequirementsCount} is not 0, and {@code pVideoSessionMemoryRequirements} is not {@code NULL}, {@code pVideoSessionMemoryRequirements} must be a valid pointer to an array of {@code pVideoSessionMemoryRequirementsCount} {@link VkVideoGetMemoryPropertiesKHR} structures
    • 
     * 
  • {@code videoSession} must have been created, allocated, or retrieved from {@code device}
    • 
     * 

     * 
     * 
Return Codes

     * 
     * 

     * 
On success, this command returns

     * 
    
     * 
  • {@link VK10#VK_SUCCESS SUCCESS}
    • 
     * 
  • {@link VK10#VK_INCOMPLETE INCOMPLETE}
    • 
     * 

     * 
On failure, this command returns

     * 
    
     * 
  • {@link VK10#VK_ERROR_INITIALIZATION_FAILED ERROR_INITIALIZATION_FAILED}
    • 
     * 

     * 

     * 
     * 
See Also

     * 
     * 
{@link VkVideoGetMemoryPropertiesKHR}

     *
     * @param device                               the logical device that owns the video session.
     * @param videoSession                         the video session to query.
     * @param pVideoSessionMemoryRequirementsCount a pointer to an integer related to the number of memory heap requirements available or queried, as described below.
     * @param pVideoSessionMemoryRequirements      {@code NULL} or a pointer to an array of {@link VkVideoGetMemoryPropertiesKHR} structures in which the memory heap requirements of the video session are returned.
     */
    @NativeType("VkResult")
    public static int vkGetVideoSessionMemoryRequirementsKHR(VkDevice device, @NativeType("VkVideoSessionKHR") long videoSession, @NativeType("uint32_t *") IntBuffer pVideoSessionMemoryRequirementsCount, @Nullable @NativeType("VkVideoGetMemoryPropertiesKHR *") VkVideoGetMemoryPropertiesKHR.Buffer pVideoSessionMemoryRequirements) {
        if (CHECKS) {
            check(pVideoSessionMemoryRequirementsCount, 1);
            checkSafe(pVideoSessionMemoryRequirements, pVideoSessionMemoryRequirementsCount.get(pVideoSessionMemoryRequirementsCount.position()));
        }
        return nvkGetVideoSessionMemoryRequirementsKHR(device, videoSession, memAddress(pVideoSessionMemoryRequirementsCount), memAddressSafe(pVideoSessionMemoryRequirements));
    }

    // --- [ vkBindVideoSessionMemoryKHR ] ---

    /**
     * Unsafe version of: {@link #vkBindVideoSessionMemoryKHR BindVideoSessionMemoryKHR}
     *
     * @param videoSessionBindMemoryCount the number of {@code pVideoSessionBindMemories} to be bound.
     */
    public static int nvkBindVideoSessionMemoryKHR(VkDevice device, long videoSession, int videoSessionBindMemoryCount, long pVideoSessionBindMemories) {
        long __functionAddress = device.getCapabilities().vkBindVideoSessionMemoryKHR;
        if (CHECKS) {
            check(__functionAddress);
        }
        return callPJPI(device.address(), videoSession, videoSessionBindMemoryCount, pVideoSessionBindMemories, __functionAddress);
    }

    /**
     * Bind Video Memory.
     * 
     * 
C Specification

     * 
     * 
To attach memory to a video session object, call:

     * 
     * 

     * VkResult vkBindVideoSessionMemoryKHR(
     *     VkDevice                                    device,
     *     VkVideoSessionKHR                           videoSession,
     *     uint32_t                                    videoSessionBindMemoryCount,
     *     const VkVideoBindMemoryKHR*                 pVideoSessionBindMemories);

     * 
     * 
Valid Usage (Implicit)

     * 
     * 
    
     * 
  • {@code device} must be a valid {@code VkDevice} handle
    • 
     * 
  • {@code videoSession} must be a valid {@code VkVideoSessionKHR} handle
    • 
     * 
  • {@code pVideoSessionBindMemories} must be a valid pointer to an array of {@code videoSessionBindMemoryCount} valid {@link VkVideoBindMemoryKHR} structures
    • 
     * 
  • {@code videoSessionBindMemoryCount} must be greater than 0
    • 
     * 
  • {@code videoSession} must have been created, allocated, or retrieved from {@code device}
    • 
     * 

     * 
     * 
Return Codes

     * 
     * 

     * 
On success, this command returns

     * 
    
     * 
  • {@link VK10#VK_SUCCESS SUCCESS}
    • 
     * 

     * 
On failure, this command returns

     * 
    
     * 
  • {@link VK10#VK_ERROR_OUT_OF_HOST_MEMORY ERROR_OUT_OF_HOST_MEMORY}
    • 
     * 
  • {@link VK10#VK_ERROR_OUT_OF_DEVICE_MEMORY ERROR_OUT_OF_DEVICE_MEMORY}
    • 
     * 
  • {@link VK10#VK_ERROR_INITIALIZATION_FAILED ERROR_INITIALIZATION_FAILED}
    • 
     * 

     * 

     * 
     * 
See Also

     * 
     * 
{@link VkVideoBindMemoryKHR}

     *
     * @param device                    the logical device that owns the video session’s memory.
     * @param videoSession              the video session to be bound with device memory.
     * @param pVideoSessionBindMemories a pointer to an array of {@link VkVideoBindMemoryKHR} structures specifying memory regions to be bound to a device memory heap.
     */
    @NativeType("VkResult")
    public static int vkBindVideoSessionMemoryKHR(VkDevice device, @NativeType("VkVideoSessionKHR") long videoSession, @NativeType("VkVideoBindMemoryKHR const *") VkVideoBindMemoryKHR.Buffer pVideoSessionBindMemories) {
        return nvkBindVideoSessionMemoryKHR(device, videoSession, pVideoSessionBindMemories.remaining(), pVideoSessionBindMemories.address());
    }

    // --- [ vkCreateVideoSessionParametersKHR ] ---

    /** Unsafe version of: {@link #vkCreateVideoSessionParametersKHR CreateVideoSessionParametersKHR} */
    public static int nvkCreateVideoSessionParametersKHR(VkDevice device, long pCreateInfo, long pAllocator, long pVideoSessionParameters) {
        long __functionAddress = device.getCapabilities().vkCreateVideoSessionParametersKHR;
        if (CHECKS) {
            check(__functionAddress);
            if (pAllocator != NULL) { VkAllocationCallbacks.validate(pAllocator); }
        }
        return callPPPPI(device.address(), pCreateInfo, pAllocator, pVideoSessionParameters, __functionAddress);
    }

    /**
     * Creates video session video session parameter object.
     * 
     * 
C Specification

     * 
     * 
To create a video session parameters object, call:

     * 
     * 

     * VkResult vkCreateVideoSessionParametersKHR(
     *     VkDevice                                    device,
     *     const VkVideoSessionParametersCreateInfoKHR* pCreateInfo,
     *     const VkAllocationCallbacks*                pAllocator,
     *     VkVideoSessionParametersKHR*                pVideoSessionParameters);

     * 
     * 
Valid Usage (Implicit)

     * 
     * 
    
     * 
  • {@code device} must be a valid {@code VkDevice} handle
    • 
     * 
  • {@code pCreateInfo} must be a valid pointer to a valid {@link VkVideoSessionParametersCreateInfoKHR} structure
    • 
     * 
  • If {@code pAllocator} is not {@code NULL}, {@code pAllocator} must be a valid pointer to a valid {@link VkAllocationCallbacks} structure
    • 
     * 
  • {@code pVideoSessionParameters} must be a valid pointer to a {@code VkVideoSessionParametersKHR} handle
    • 
     * 

     * 
     * 
Return Codes

     * 
     * 

     * 
On success, this command returns

     * 
    
     * 
  • {@link VK10#VK_SUCCESS SUCCESS}
    • 
     * 

     * 
On failure, this command returns

     * 
    
     * 
  • {@link VK10#VK_ERROR_INITIALIZATION_FAILED ERROR_INITIALIZATION_FAILED}
    • 
     * 
  • {@link VK10#VK_ERROR_OUT_OF_HOST_MEMORY ERROR_OUT_OF_HOST_MEMORY}
    • 
     * 
  • {@link VK10#VK_ERROR_OUT_OF_DEVICE_MEMORY ERROR_OUT_OF_DEVICE_MEMORY}
    • 
     * 
  • {@link VK10#VK_ERROR_TOO_MANY_OBJECTS ERROR_TOO_MANY_OBJECTS}
    • 
     * 

     * 

     * 
     * 
See Also

     * 
     * 
{@link VkAllocationCallbacks}, {@link VkVideoSessionParametersCreateInfoKHR}

     *
     * @param device                  the logical device that was used for the creation of the video session object.
     * @param pCreateInfo             a pointer to {@link VkVideoSessionParametersCreateInfoKHR} structure specifying the video session parameters.
     * @param pAllocator              controls host memory allocation as described in the Memory Allocation chapter.
     * @param pVideoSessionParameters a pointer to a {@code VkVideoSessionParametersKHR} handle in which the video session parameters object is returned.
     */
    @NativeType("VkResult")
    public static int vkCreateVideoSessionParametersKHR(VkDevice device, @NativeType("VkVideoSessionParametersCreateInfoKHR const *") VkVideoSessionParametersCreateInfoKHR pCreateInfo, @Nullable @NativeType("VkAllocationCallbacks const *") VkAllocationCallbacks pAllocator, @NativeType("VkVideoSessionParametersKHR *") LongBuffer pVideoSessionParameters) {
        if (CHECKS) {
            check(pVideoSessionParameters, 1);
        }
        return nvkCreateVideoSessionParametersKHR(device, pCreateInfo.address(), memAddressSafe(pAllocator), memAddress(pVideoSessionParameters));
    }

    // --- [ vkUpdateVideoSessionParametersKHR ] ---

    /** Unsafe version of: {@link #vkUpdateVideoSessionParametersKHR UpdateVideoSessionParametersKHR} */
    public static int nvkUpdateVideoSessionParametersKHR(VkDevice device, long videoSessionParameters, long pUpdateInfo) {
        long __functionAddress = device.getCapabilities().vkUpdateVideoSessionParametersKHR;
        if (CHECKS) {
            check(__functionAddress);
        }
        return callPJPI(device.address(), videoSessionParameters, pUpdateInfo, __functionAddress);
    }

    /**
     * Update video session video session parameter object.
     * 
     * 
C Specification

     * 
     * 
To update, add, or remove video session parameters state, call:

     * 
     * 

     * VkResult vkUpdateVideoSessionParametersKHR(
     *     VkDevice                                    device,
     *     VkVideoSessionParametersKHR                 videoSessionParameters,
     *     const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo);

     * 
     * 
Valid Usage (Implicit)

     * 
     * 
    
     * 
  • {@code device} must be a valid {@code VkDevice} handle
    • 
     * 
  • {@code videoSessionParameters} must be a valid {@code VkVideoSessionParametersKHR} handle
    • 
     * 
  • {@code pUpdateInfo} must be a valid pointer to a valid {@link VkVideoSessionParametersUpdateInfoKHR} structure
    • 
     * 

     * 
     * 
Return Codes

     * 
     * 

     * 
On success, this command returns

     * 
    
     * 
  • {@link VK10#VK_SUCCESS SUCCESS}
    • 
     * 

     * 
On failure, this command returns

     * 
    
     * 
  • {@link VK10#VK_ERROR_INITIALIZATION_FAILED ERROR_INITIALIZATION_FAILED}
    • 
     * 
  • {@link VK10#VK_ERROR_TOO_MANY_OBJECTS ERROR_TOO_MANY_OBJECTS}
    • 
     * 

     * 

     * 
     * 
See Also

     * 
     * 
{@link VkVideoSessionParametersUpdateInfoKHR}

     *
     * @param device                 the logical device that was used for the creation of the video session object.
     * @param videoSessionParameters the video session object that is going to be updated.
     * @param pUpdateInfo            a pointer to a {@link VkVideoSessionParametersUpdateInfoKHR} structure containing the session parameters update information.
     */
    @NativeType("VkResult")
    public static int vkUpdateVideoSessionParametersKHR(VkDevice device, @NativeType("VkVideoSessionParametersKHR") long videoSessionParameters, @NativeType("VkVideoSessionParametersUpdateInfoKHR const *") VkVideoSessionParametersUpdateInfoKHR pUpdateInfo) {
        return nvkUpdateVideoSessionParametersKHR(device, videoSessionParameters, pUpdateInfo.address());
    }

    // --- [ vkDestroyVideoSessionParametersKHR ] ---

    /** Unsafe version of: {@link #vkDestroyVideoSessionParametersKHR DestroyVideoSessionParametersKHR} */
    public static void nvkDestroyVideoSessionParametersKHR(VkDevice device, long videoSessionParameters, long pAllocator) {
        long __functionAddress = device.getCapabilities().vkDestroyVideoSessionParametersKHR;
        if (CHECKS) {
            check(__functionAddress);
            if (pAllocator != NULL) { VkAllocationCallbacks.validate(pAllocator); }
        }
        callPJPV(device.address(), videoSessionParameters, pAllocator, __functionAddress);
    }

    /**
     * Destroy video session parameters object.
     * 
     * 
C Specification

     * 
     * 
To destroy a video session object, call:

     * 
     * 

     * void vkDestroyVideoSessionParametersKHR(
     *     VkDevice                                    device,
     *     VkVideoSessionParametersKHR                 videoSessionParameters,
     *     const VkAllocationCallbacks*                pAllocator);

     * 
     * 
Valid Usage (Implicit)

     * 
     * 
    
     * 
  • {@code device} must be a valid {@code VkDevice} handle
    • 
     * 
  • {@code videoSessionParameters} must be a valid {@code VkVideoSessionParametersKHR} handle
    • 
     * 
  • If {@code pAllocator} is not {@code NULL}, {@code pAllocator} must be a valid pointer to a valid {@link VkAllocationCallbacks} structure
    • 
     * 

     * 
     * 
See Also

     * 
     * 
{@link VkAllocationCallbacks}

     *
     * @param device                 the device the video session was created with.
     * @param videoSessionParameters the video session parameters object to be destroyed.
     * @param pAllocator             controls host memory allocation as described in the Memory Allocation chapter.
     */
    public static void vkDestroyVideoSessionParametersKHR(VkDevice device, @NativeType("VkVideoSessionParametersKHR") long videoSessionParameters, @Nullable @NativeType("VkAllocationCallbacks const *") VkAllocationCallbacks pAllocator) {
        nvkDestroyVideoSessionParametersKHR(device, videoSessionParameters, memAddressSafe(pAllocator));
    }

    // --- [ vkCmdBeginVideoCodingKHR ] ---

    /** Unsafe version of: {@link #vkCmdBeginVideoCodingKHR CmdBeginVideoCodingKHR} */
    public static void nvkCmdBeginVideoCodingKHR(VkCommandBuffer commandBuffer, long pBeginInfo) {
        long __functionAddress = commandBuffer.getCapabilities().vkCmdBeginVideoCodingKHR;
        if (CHECKS) {
            check(__functionAddress);
            VkVideoBeginCodingInfoKHR.validate(pBeginInfo);
        }
        callPPV(commandBuffer.address(), pBeginInfo, __functionAddress);
    }

    /**
     * Start decode jobs.
     * 
     * 
C Specification

     * 
     * 
To start video decode or encode operations, call:

     * 
     * 

     * void vkCmdBeginVideoCodingKHR(
     *     VkCommandBuffer                             commandBuffer,
     *     const VkVideoBeginCodingInfoKHR*            pBeginInfo);

     * 
     * 
Valid Usage (Implicit)

     * 
     * 
    
     * 
  • {@code commandBuffer} must be a valid {@code VkCommandBuffer} handle
    • 
     * 
  • {@code pBeginInfo} must be a valid pointer to a valid {@link VkVideoBeginCodingInfoKHR} structure
    • 
     * 
  • {@code commandBuffer} must be in the recording state
    • 
     * 
  • The {@code VkCommandPool} that {@code commandBuffer} was allocated from must support decode, or encode operations
    • 
     * 
  • This command must only be called outside of a render pass instance
    • 
     * 
  • {@code commandBuffer} must be a primary {@code VkCommandBuffer}
    • 
     * 

     * 
     * 
Host Synchronization

     * 
     * 
    
     * 
  • Host access to the {@code VkCommandPool} that {@code commandBuffer} was allocated from must be externally synchronized
    • 
     * 

     * 
     * 
Command Properties

     * 
     * 
     * 
     * 
     * 
Command Buffer LevelsRender Pass ScopeSupported Queue Types
PrimaryOutsideDecode Encode

     * 
     * 
See Also

     * 
     * 
{@link VkVideoBeginCodingInfoKHR}

     *
     * @param commandBuffer the command buffer to be used when recording commands for the video decode or encode operations.
     * @param pBeginInfo    a pointer to a {@link VkVideoBeginCodingInfoKHR} structure.
     */
    public static void vkCmdBeginVideoCodingKHR(VkCommandBuffer commandBuffer, @NativeType("VkVideoBeginCodingInfoKHR const *") VkVideoBeginCodingInfoKHR pBeginInfo) {
        nvkCmdBeginVideoCodingKHR(commandBuffer, pBeginInfo.address());
    }

    // --- [ vkCmdEndVideoCodingKHR ] ---

    /** Unsafe version of: {@link #vkCmdEndVideoCodingKHR CmdEndVideoCodingKHR} */
    public static void nvkCmdEndVideoCodingKHR(VkCommandBuffer commandBuffer, long pEndCodingInfo) {
        long __functionAddress = commandBuffer.getCapabilities().vkCmdEndVideoCodingKHR;
        if (CHECKS) {
            check(__functionAddress);
        }
        callPPV(commandBuffer.address(), pEndCodingInfo, __functionAddress);
    }

    /**
     * End decode jobs.
     * 
     * 
C Specification

     * 
     * 
To end video decode or encode operations, call:

     * 
     * 

     * void vkCmdEndVideoCodingKHR(
     *     VkCommandBuffer                             commandBuffer,
     *     const VkVideoEndCodingInfoKHR*              pEndCodingInfo);

     * 
     * 
Valid Usage (Implicit)

     * 
     * 
    
     * 
  • {@code commandBuffer} must be a valid {@code VkCommandBuffer} handle
    • 
     * 
  • {@code pEndCodingInfo} must be a valid pointer to a valid {@link VkVideoEndCodingInfoKHR} structure
    • 
     * 
  • {@code commandBuffer} must be in the recording state
    • 
     * 
  • The {@code VkCommandPool} that {@code commandBuffer} was allocated from must support decode, or encode operations
    • 
     * 
  • This command must only be called outside of a render pass instance
    • 
     * 
  • {@code commandBuffer} must be a primary {@code VkCommandBuffer}
    • 
     * 

     * 
     * 
Host Synchronization

     * 
     * 
    
     * 
  • Host access to the {@code VkCommandPool} that {@code commandBuffer} was allocated from must be externally synchronized
    • 
     * 

     * 
     * 
Command Properties

     * 
     * 
     * 
     * 
     * 
Command Buffer LevelsRender Pass ScopeSupported Queue Types
PrimaryOutsideDecode Encode

     * 
     * 
See Also

     * 
     * 
{@link VkVideoEndCodingInfoKHR}

     *
     * @param commandBuffer  the command buffer to be filled by this function.
     * @param pEndCodingInfo a pointer to a {@link VkVideoEndCodingInfoKHR} structure.
     */
    public static void vkCmdEndVideoCodingKHR(VkCommandBuffer commandBuffer, @NativeType("VkVideoEndCodingInfoKHR const *") VkVideoEndCodingInfoKHR pEndCodingInfo) {
        nvkCmdEndVideoCodingKHR(commandBuffer, pEndCodingInfo.address());
    }

    // --- [ vkCmdControlVideoCodingKHR ] ---

    /** Unsafe version of: {@link #vkCmdControlVideoCodingKHR CmdControlVideoCodingKHR} */
    public static void nvkCmdControlVideoCodingKHR(VkCommandBuffer commandBuffer, long pCodingControlInfo) {
        long __functionAddress = commandBuffer.getCapabilities().vkCmdControlVideoCodingKHR;
        if (CHECKS) {
            check(__functionAddress);
        }
        callPPV(commandBuffer.address(), pCodingControlInfo, __functionAddress);
    }

    /**
     * Set encode rate control parameters.
     * 
     * 
C Specification

     * 
     * 
To apply dynamic controls to video decode or video operations, call:

     * 
     * 

     * void vkCmdControlVideoCodingKHR(
     *     VkCommandBuffer                             commandBuffer,
     *     const VkVideoCodingControlInfoKHR*          pCodingControlInfo);

     * 
     * 
Valid Usage (Implicit)

     * 
     * 
    
     * 
  • {@code commandBuffer} must be a valid {@code VkCommandBuffer} handle
    • 
     * 
  • {@code pCodingControlInfo} must be a valid pointer to a valid {@link VkVideoCodingControlInfoKHR} structure
    • 
     * 
  • {@code commandBuffer} must be in the recording state
    • 
     * 
  • The {@code VkCommandPool} that {@code commandBuffer} was allocated from must support decode, or encode operations
    • 
     * 
  • This command must only be called outside of a render pass instance
    • 
     * 
  • {@code commandBuffer} must be a primary {@code VkCommandBuffer}
    • 
     * 

     * 
     * 
Host Synchronization

     * 
     * 
    
     * 
  • Host access to the {@code VkCommandPool} that {@code commandBuffer} was allocated from must be externally synchronized
    • 
     * 

     * 
     * 
Command Properties

     * 
     * 
     * 
     * 
     * 
Command Buffer LevelsRender Pass ScopeSupported Queue Types
PrimaryOutsideDecode Encode

     * 
     * 
See Also

     * 
     * 
{@link VkVideoCodingControlInfoKHR}

     *
     * @param commandBuffer      the command buffer to be filled by this function for setting encode rate control parameters.
     * @param pCodingControlInfo a pointer to a {@link VkVideoCodingControlInfoKHR} structure.
     */
    public static void vkCmdControlVideoCodingKHR(VkCommandBuffer commandBuffer, @NativeType("VkVideoCodingControlInfoKHR const *") VkVideoCodingControlInfoKHR pCodingControlInfo) {
        nvkCmdControlVideoCodingKHR(commandBuffer, pCodingControlInfo.address());
    }

    /** Array version of: {@link #vkGetPhysicalDeviceVideoFormatPropertiesKHR GetPhysicalDeviceVideoFormatPropertiesKHR} */
    @NativeType("VkResult")
    public static int vkGetPhysicalDeviceVideoFormatPropertiesKHR(VkPhysicalDevice physicalDevice, @NativeType("VkPhysicalDeviceVideoFormatInfoKHR const *") VkPhysicalDeviceVideoFormatInfoKHR pVideoFormatInfo, @NativeType("uint32_t *") int[] pVideoFormatPropertyCount, @Nullable @NativeType("VkVideoFormatPropertiesKHR *") VkVideoFormatPropertiesKHR.Buffer pVideoFormatProperties) {
        long __functionAddress = physicalDevice.getCapabilities().vkGetPhysicalDeviceVideoFormatPropertiesKHR;
        if (CHECKS) {
            check(__functionAddress);
            check(pVideoFormatPropertyCount, 1);
            checkSafe(pVideoFormatProperties, pVideoFormatPropertyCount[0]);
        }
        return callPPPPI(physicalDevice.address(), pVideoFormatInfo.address(), pVideoFormatPropertyCount, memAddressSafe(pVideoFormatProperties), __functionAddress);
    }

    /** Array version of: {@link #vkCreateVideoSessionKHR CreateVideoSessionKHR} */
    @NativeType("VkResult")
    public static int vkCreateVideoSessionKHR(VkDevice device, @NativeType("VkVideoSessionCreateInfoKHR const *") VkVideoSessionCreateInfoKHR pCreateInfo, @Nullable @NativeType("VkAllocationCallbacks const *") VkAllocationCallbacks pAllocator, @NativeType("VkVideoSessionKHR *") long[] pVideoSession) {
        long __functionAddress = device.getCapabilities().vkCreateVideoSessionKHR;
        if (CHECKS) {
            check(__functionAddress);
            check(pVideoSession, 1);
            VkVideoSessionCreateInfoKHR.validate(pCreateInfo.address());
            if (pAllocator != null) { VkAllocationCallbacks.validate(pAllocator.address()); }
        }
        return callPPPPI(device.address(), pCreateInfo.address(), memAddressSafe(pAllocator), pVideoSession, __functionAddress);
    }

    /** Array version of: {@link #vkGetVideoSessionMemoryRequirementsKHR GetVideoSessionMemoryRequirementsKHR} */
    @NativeType("VkResult")
    public static int vkGetVideoSessionMemoryRequirementsKHR(VkDevice device, @NativeType("VkVideoSessionKHR") long videoSession, @NativeType("uint32_t *") int[] pVideoSessionMemoryRequirementsCount, @Nullable @NativeType("VkVideoGetMemoryPropertiesKHR *") VkVideoGetMemoryPropertiesKHR.Buffer pVideoSessionMemoryRequirements) {
        long __functionAddress = device.getCapabilities().vkGetVideoSessionMemoryRequirementsKHR;
        if (CHECKS) {
            check(__functionAddress);
            check(pVideoSessionMemoryRequirementsCount, 1);
            checkSafe(pVideoSessionMemoryRequirements, pVideoSessionMemoryRequirementsCount[0]);
        }
        return callPJPPI(device.address(), videoSession, pVideoSessionMemoryRequirementsCount, memAddressSafe(pVideoSessionMemoryRequirements), __functionAddress);
    }

    /** Array version of: {@link #vkCreateVideoSessionParametersKHR CreateVideoSessionParametersKHR} */
    @NativeType("VkResult")
    public static int vkCreateVideoSessionParametersKHR(VkDevice device, @NativeType("VkVideoSessionParametersCreateInfoKHR const *") VkVideoSessionParametersCreateInfoKHR pCreateInfo, @Nullable @NativeType("VkAllocationCallbacks const *") VkAllocationCallbacks pAllocator, @NativeType("VkVideoSessionParametersKHR *") long[] pVideoSessionParameters) {
        long __functionAddress = device.getCapabilities().vkCreateVideoSessionParametersKHR;
        if (CHECKS) {
            check(__functionAddress);
            check(pVideoSessionParameters, 1);
            if (pAllocator != null) { VkAllocationCallbacks.validate(pAllocator.address()); }
        }
        return callPPPPI(device.address(), pCreateInfo.address(), memAddressSafe(pAllocator), pVideoSessionParameters, __functionAddress);
    }

}




© 2015 - 2024 Weber Informatics LLC | Privacy Policy