erupt 0.23.0+213

// DO NOT EDIT: @generated by erupt's generator
//! ## Versioning Warning ⚠️
//!
//! This is a Vulkan **provisional/beta** extension and **must** be used with
//! caution. Its API/behaviour has not been finalized yet and _may_ therefore
//! change in ways that break backwards compatibility between revisions, and
//! before final release of a non-provisional version of this extension.
///<s>Vulkan Manual Page</s> · Constant
#[doc(alias = "VK_KHR_VIDEO_QUEUE_SPEC_VERSION")]
pub const KHR_VIDEO_QUEUE_SPEC_VERSION: u32 = 3;
///<s>Vulkan Manual Page</s> · Constant
#[doc(alias = "VK_KHR_VIDEO_QUEUE_EXTENSION_NAME")]
pub const KHR_VIDEO_QUEUE_EXTENSION_NAME: *const std::os::raw::c_char = crate::cstr!(
    "VK_KHR_video_queue"
);
///<s>Vulkan Manual Page</s> · Constant
pub const FN_GET_PHYSICAL_DEVICE_VIDEO_CAPABILITIES_KHR: *const std::os::raw::c_char = crate::cstr!(
    "vkGetPhysicalDeviceVideoCapabilitiesKHR"
);
///<s>Vulkan Manual Page</s> · Constant
pub const FN_GET_PHYSICAL_DEVICE_VIDEO_FORMAT_PROPERTIES_KHR: *const std::os::raw::c_char = crate::cstr!(
    "vkGetPhysicalDeviceVideoFormatPropertiesKHR"
);
///<s>Vulkan Manual Page</s> · Constant
pub const FN_CREATE_VIDEO_SESSION_KHR: *const std::os::raw::c_char = crate::cstr!(
    "vkCreateVideoSessionKHR"
);
///<s>Vulkan Manual Page</s> · Constant
pub const FN_DESTROY_VIDEO_SESSION_KHR: *const std::os::raw::c_char = crate::cstr!(
    "vkDestroyVideoSessionKHR"
);
///<s>Vulkan Manual Page</s> · Constant
pub const FN_CREATE_VIDEO_SESSION_PARAMETERS_KHR: *const std::os::raw::c_char = crate::cstr!(
    "vkCreateVideoSessionParametersKHR"
);
///<s>Vulkan Manual Page</s> · Constant
pub const FN_UPDATE_VIDEO_SESSION_PARAMETERS_KHR: *const std::os::raw::c_char = crate::cstr!(
    "vkUpdateVideoSessionParametersKHR"
);
///<s>Vulkan Manual Page</s> · Constant
pub const FN_DESTROY_VIDEO_SESSION_PARAMETERS_KHR: *const std::os::raw::c_char = crate::cstr!(
    "vkDestroyVideoSessionParametersKHR"
);
///<s>Vulkan Manual Page</s> · Constant
pub const FN_GET_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR: *const std::os::raw::c_char = crate::cstr!(
    "vkGetVideoSessionMemoryRequirementsKHR"
);
///<s>Vulkan Manual Page</s> · Constant
pub const FN_BIND_VIDEO_SESSION_MEMORY_KHR: *const std::os::raw::c_char = crate::cstr!(
    "vkBindVideoSessionMemoryKHR"
);
///<s>Vulkan Manual Page</s> · Constant
pub const FN_CMD_BEGIN_VIDEO_CODING_KHR: *const std::os::raw::c_char = crate::cstr!(
    "vkCmdBeginVideoCodingKHR"
);
///<s>Vulkan Manual Page</s> · Constant
pub const FN_CMD_CONTROL_VIDEO_CODING_KHR: *const std::os::raw::c_char = crate::cstr!(
    "vkCmdControlVideoCodingKHR"
);
///<s>Vulkan Manual Page</s> · Constant
pub const FN_CMD_END_VIDEO_CODING_KHR: *const std::os::raw::c_char = crate::cstr!(
    "vkCmdEndVideoCodingKHR"
);
crate::non_dispatchable_handle!(
    VideoSessionKHR, VIDEO_SESSION_KHR,
    "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoSessionKHR.html) · Non-dispatchable Handle",
    "VkVideoSessionKHR"
);
crate::non_dispatchable_handle!(
    VideoSessionParametersKHR, VIDEO_SESSION_PARAMETERS_KHR,
    "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoSessionParametersKHR.html) · Non-dispatchable Handle",
    "VkVideoSessionParametersKHR"
);
bitflags::bitflags! {
    #[doc =
    "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoBeginCodingFlagsKHR.html) · Bitmask of [`VideoBeginCodingFlagBitsKHR`]"]
    #[doc(alias = "VkVideoBeginCodingFlagsKHR")] #[derive(Default)] #[repr(transparent)]
    pub struct VideoBeginCodingFlagsKHR : u32 { #[cfg(empty_bitflag_workaround)] const
    EMPTY_BITFLAG_WORKAROUND = 0; }
}
///<s>Vulkan Manual Page</s> · Bits enum of [`VideoBeginCodingFlagsKHR`]
#[doc(alias = "VkVideoBeginCodingFlagBitsKHR")]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
#[repr(transparent)]
pub struct VideoBeginCodingFlagBitsKHR(pub u32);
impl VideoBeginCodingFlagBitsKHR {
    #[inline]
    ///Converts this enum variant to the corresponding bitmask
    pub const fn bitmask(&self) -> VideoBeginCodingFlagsKHR {
        VideoBeginCodingFlagsKHR::from_bits_truncate(self.0)
    }
}
impl std::fmt::Debug for VideoBeginCodingFlagBitsKHR {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.write_str(
            match self {
                _ => "(unknown variant)",
            },
        )
    }
}
bitflags::bitflags! {
    #[doc =
    "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEndCodingFlagsKHR.html) · Bitmask of [`VideoEndCodingFlagBitsKHR`]"]
    #[doc(alias = "VkVideoEndCodingFlagsKHR")] #[derive(Default)] #[repr(transparent)]
    pub struct VideoEndCodingFlagsKHR : u32 { #[cfg(empty_bitflag_workaround)] const
    EMPTY_BITFLAG_WORKAROUND = 0; }
}
///<s>Vulkan Manual Page</s> · Bits enum of [`VideoEndCodingFlagsKHR`]
#[doc(alias = "VkVideoEndCodingFlagBitsKHR")]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
#[repr(transparent)]
pub struct VideoEndCodingFlagBitsKHR(pub u32);
impl VideoEndCodingFlagBitsKHR {
    #[inline]
    ///Converts this enum variant to the corresponding bitmask
    pub const fn bitmask(&self) -> VideoEndCodingFlagsKHR {
        VideoEndCodingFlagsKHR::from_bits_truncate(self.0)
    }
}
impl std::fmt::Debug for VideoEndCodingFlagBitsKHR {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.write_str(
            match self {
                _ => "(unknown variant)",
            },
        )
    }
}
///Provided by [`crate::extensions::khr_video_queue`]
impl crate::vk1_0::QueryResultFlagBits {
    pub const WITH_STATUS_KHR: Self = Self(16);
}
///Provided by [`crate::extensions::khr_video_queue`]
impl crate::vk1_0::QueryType {
    pub const RESULT_STATUS_ONLY_KHR: Self = Self(1000023000);
}
///Provided by [`crate::extensions::khr_video_queue`]
impl crate::vk1_0::StructureType {
    pub const VIDEO_PROFILE_KHR: Self = Self(1000023000);
    pub const VIDEO_CAPABILITIES_KHR: Self = Self(1000023001);
    pub const VIDEO_PICTURE_RESOURCE_KHR: Self = Self(1000023002);
    pub const VIDEO_GET_MEMORY_PROPERTIES_KHR: Self = Self(1000023003);
    pub const VIDEO_BIND_MEMORY_KHR: Self = Self(1000023004);
    pub const VIDEO_SESSION_CREATE_INFO_KHR: Self = Self(1000023005);
    pub const VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR: Self = Self(1000023006);
    pub const VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR: Self = Self(1000023007);
    pub const VIDEO_BEGIN_CODING_INFO_KHR: Self = Self(1000023008);
    pub const VIDEO_END_CODING_INFO_KHR: Self = Self(1000023009);
    pub const VIDEO_CODING_CONTROL_INFO_KHR: Self = Self(1000023010);
    pub const VIDEO_REFERENCE_SLOT_KHR: Self = Self(1000023011);
    pub const VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR: Self = Self(1000023012);
    pub const VIDEO_PROFILES_KHR: Self = Self(1000023013);
    pub const PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR: Self = Self(1000023014);
    pub const VIDEO_FORMAT_PROPERTIES_KHR: Self = Self(1000023015);
    pub const QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_2_KHR: Self = Self(1000023016);
}
///Provided by [`crate::extensions::khr_video_queue`]
impl crate::vk1_0::ObjectType {
    pub const VIDEO_SESSION_KHR: Self = Self(1000023000);
    pub const VIDEO_SESSION_PARAMETERS_KHR: Self = Self(1000023001);
}
bitflags::bitflags! {
    #[doc =
    "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoCodecOperationFlagsKHR.html) · Bitmask of [`VideoCodecOperationFlagBitsKHR`]"]
    #[doc(alias = "VkVideoCodecOperationFlagsKHR")] #[derive(Default)]
    #[repr(transparent)] pub struct VideoCodecOperationFlagsKHR : u32 { const INVALID_KHR
    = VideoCodecOperationFlagBitsKHR::INVALID_KHR.0; const ENCODE_H264_EXT =
    VideoCodecOperationFlagBitsKHR::ENCODE_H264_EXT.0; const ENCODE_H265_EXT =
    VideoCodecOperationFlagBitsKHR::ENCODE_H265_EXT.0; const DECODE_H264_EXT =
    VideoCodecOperationFlagBitsKHR::DECODE_H264_EXT.0; const DECODE_H265_EXT =
    VideoCodecOperationFlagBitsKHR::DECODE_H265_EXT.0; }
}
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoCodecOperationFlagBitsKHR.html) · Bits enum of [`VideoCodecOperationFlagsKHR`]
#[doc(alias = "VkVideoCodecOperationFlagBitsKHR")]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
#[repr(transparent)]
pub struct VideoCodecOperationFlagBitsKHR(pub u32);
impl VideoCodecOperationFlagBitsKHR {
    #[inline]
    ///Converts this enum variant to the corresponding bitmask
    pub const fn bitmask(&self) -> VideoCodecOperationFlagsKHR {
        VideoCodecOperationFlagsKHR::from_bits_truncate(self.0)
    }
}
impl std::fmt::Debug for VideoCodecOperationFlagBitsKHR {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.write_str(
            match self {
                &Self::INVALID_KHR => "INVALID_KHR",
                &Self::ENCODE_H264_EXT => "ENCODE_H264_EXT",
                &Self::ENCODE_H265_EXT => "ENCODE_H265_EXT",
                &Self::DECODE_H264_EXT => "DECODE_H264_EXT",
                &Self::DECODE_H265_EXT => "DECODE_H265_EXT",
                _ => "(unknown variant)",
            },
        )
    }
}
///Provided by [`crate::extensions::khr_video_queue`]
impl crate::extensions::khr_video_queue::VideoCodecOperationFlagBitsKHR {
    pub const INVALID_KHR: Self = Self(0);
}
bitflags::bitflags! {
    #[doc =
    "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoChromaSubsamplingFlagsKHR.html) · Bitmask of [`VideoChromaSubsamplingFlagBitsKHR`]"]
    #[doc(alias = "VkVideoChromaSubsamplingFlagsKHR")] #[derive(Default)]
    #[repr(transparent)] pub struct VideoChromaSubsamplingFlagsKHR : u32 { const
    INVALID_KHR = VideoChromaSubsamplingFlagBitsKHR::INVALID_KHR.0; const MONOCHROME_KHR
    = VideoChromaSubsamplingFlagBitsKHR::MONOCHROME_KHR.0; const _420_KHR =
    VideoChromaSubsamplingFlagBitsKHR::_420_KHR.0; const _422_KHR =
    VideoChromaSubsamplingFlagBitsKHR::_422_KHR.0; const _444_KHR =
    VideoChromaSubsamplingFlagBitsKHR::_444_KHR.0; }
}
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoChromaSubsamplingFlagBitsKHR.html) · Bits enum of [`VideoChromaSubsamplingFlagsKHR`]
#[doc(alias = "VkVideoChromaSubsamplingFlagBitsKHR")]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
#[repr(transparent)]
pub struct VideoChromaSubsamplingFlagBitsKHR(pub u32);
impl VideoChromaSubsamplingFlagBitsKHR {
    #[inline]
    ///Converts this enum variant to the corresponding bitmask
    pub const fn bitmask(&self) -> VideoChromaSubsamplingFlagsKHR {
        VideoChromaSubsamplingFlagsKHR::from_bits_truncate(self.0)
    }
}
impl std::fmt::Debug for VideoChromaSubsamplingFlagBitsKHR {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.write_str(
            match self {
                &Self::INVALID_KHR => "INVALID_KHR",
                &Self::MONOCHROME_KHR => "MONOCHROME_KHR",
                &Self::_420_KHR => "420_KHR",
                &Self::_422_KHR => "422_KHR",
                &Self::_444_KHR => "444_KHR",
                _ => "(unknown variant)",
            },
        )
    }
}
///Provided by [`crate::extensions::khr_video_queue`]
impl crate::extensions::khr_video_queue::VideoChromaSubsamplingFlagBitsKHR {
    pub const INVALID_KHR: Self = Self(0);
    pub const MONOCHROME_KHR: Self = Self(1);
    pub const _420_KHR: Self = Self(2);
    pub const _422_KHR: Self = Self(4);
    pub const _444_KHR: Self = Self(8);
}
bitflags::bitflags! {
    #[doc =
    "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoComponentBitDepthFlagsKHR.html) · Bitmask of [`VideoComponentBitDepthFlagBitsKHR`]"]
    #[doc(alias = "VkVideoComponentBitDepthFlagsKHR")] #[derive(Default)]
    #[repr(transparent)] pub struct VideoComponentBitDepthFlagsKHR : u32 { const
    INVALID_KHR = VideoComponentBitDepthFlagBitsKHR::INVALID_KHR.0; const _8_KHR =
    VideoComponentBitDepthFlagBitsKHR::_8_KHR.0; const _10_KHR =
    VideoComponentBitDepthFlagBitsKHR::_10_KHR.0; const _12_KHR =
    VideoComponentBitDepthFlagBitsKHR::_12_KHR.0; }
}
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoComponentBitDepthFlagBitsKHR.html) · Bits enum of [`VideoComponentBitDepthFlagsKHR`]
#[doc(alias = "VkVideoComponentBitDepthFlagBitsKHR")]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
#[repr(transparent)]
pub struct VideoComponentBitDepthFlagBitsKHR(pub u32);
impl VideoComponentBitDepthFlagBitsKHR {
    #[inline]
    ///Converts this enum variant to the corresponding bitmask
    pub const fn bitmask(&self) -> VideoComponentBitDepthFlagsKHR {
        VideoComponentBitDepthFlagsKHR::from_bits_truncate(self.0)
    }
}
impl std::fmt::Debug for VideoComponentBitDepthFlagBitsKHR {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.write_str(
            match self {
                &Self::INVALID_KHR => "INVALID_KHR",
                &Self::_8_KHR => "8_KHR",
                &Self::_10_KHR => "10_KHR",
                &Self::_12_KHR => "12_KHR",
                _ => "(unknown variant)",
            },
        )
    }
}
///Provided by [`crate::extensions::khr_video_queue`]
impl crate::extensions::khr_video_queue::VideoComponentBitDepthFlagBitsKHR {
    pub const INVALID_KHR: Self = Self(0);
    pub const _8_KHR: Self = Self(1);
    pub const _10_KHR: Self = Self(4);
    pub const _12_KHR: Self = Self(16);
}
bitflags::bitflags! {
    #[doc =
    "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoCapabilityFlagsKHR.html) · Bitmask of [`VideoCapabilityFlagBitsKHR`]"]
    #[doc(alias = "VkVideoCapabilityFlagsKHR")] #[derive(Default)] #[repr(transparent)]
    pub struct VideoCapabilityFlagsKHR : u32 { const PROTECTED_CONTENT_KHR =
    VideoCapabilityFlagBitsKHR::PROTECTED_CONTENT_KHR.0; const
    SEPARATE_REFERENCE_IMAGES_KHR =
    VideoCapabilityFlagBitsKHR::SEPARATE_REFERENCE_IMAGES_KHR.0; }
}
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoCapabilityFlagBitsKHR.html) · Bits enum of [`VideoCapabilityFlagsKHR`]
#[doc(alias = "VkVideoCapabilityFlagBitsKHR")]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
#[repr(transparent)]
pub struct VideoCapabilityFlagBitsKHR(pub u32);
impl VideoCapabilityFlagBitsKHR {
    #[inline]
    ///Converts this enum variant to the corresponding bitmask
    pub const fn bitmask(&self) -> VideoCapabilityFlagsKHR {
        VideoCapabilityFlagsKHR::from_bits_truncate(self.0)
    }
}
impl std::fmt::Debug for VideoCapabilityFlagBitsKHR {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.write_str(
            match self {
                &Self::PROTECTED_CONTENT_KHR => "PROTECTED_CONTENT_KHR",
                &Self::SEPARATE_REFERENCE_IMAGES_KHR => "SEPARATE_REFERENCE_IMAGES_KHR",
                _ => "(unknown variant)",
            },
        )
    }
}
///Provided by [`crate::extensions::khr_video_queue`]
impl crate::extensions::khr_video_queue::VideoCapabilityFlagBitsKHR {
    pub const PROTECTED_CONTENT_KHR: Self = Self(1);
    pub const SEPARATE_REFERENCE_IMAGES_KHR: Self = Self(2);
}
bitflags::bitflags! {
    #[doc =
    "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoSessionCreateFlagsKHR.html) · Bitmask of [`VideoSessionCreateFlagBitsKHR`]"]
    #[doc(alias = "VkVideoSessionCreateFlagsKHR")] #[derive(Default)]
    #[repr(transparent)] pub struct VideoSessionCreateFlagsKHR : u32 { const DEFAULT_KHR
    = VideoSessionCreateFlagBitsKHR::DEFAULT_KHR.0; const PROTECTED_CONTENT_KHR =
    VideoSessionCreateFlagBitsKHR::PROTECTED_CONTENT_KHR.0; }
}
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoSessionCreateFlagBitsKHR.html) · Bits enum of [`VideoSessionCreateFlagsKHR`]
#[doc(alias = "VkVideoSessionCreateFlagBitsKHR")]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
#[repr(transparent)]
pub struct VideoSessionCreateFlagBitsKHR(pub u32);
impl VideoSessionCreateFlagBitsKHR {
    #[inline]
    ///Converts this enum variant to the corresponding bitmask
    pub const fn bitmask(&self) -> VideoSessionCreateFlagsKHR {
        VideoSessionCreateFlagsKHR::from_bits_truncate(self.0)
    }
}
impl std::fmt::Debug for VideoSessionCreateFlagBitsKHR {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.write_str(
            match self {
                &Self::DEFAULT_KHR => "DEFAULT_KHR",
                &Self::PROTECTED_CONTENT_KHR => "PROTECTED_CONTENT_KHR",
                _ => "(unknown variant)",
            },
        )
    }
}
///Provided by [`crate::extensions::khr_video_queue`]
impl crate::extensions::khr_video_queue::VideoSessionCreateFlagBitsKHR {
    pub const DEFAULT_KHR: Self = Self(0);
    pub const PROTECTED_CONTENT_KHR: Self = Self(1);
}
bitflags::bitflags! {
    #[doc =
    "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoCodingQualityPresetFlagsKHR.html) · Bitmask of [`VideoCodingQualityPresetFlagBitsKHR`]"]
    #[doc(alias = "VkVideoCodingQualityPresetFlagsKHR")] #[derive(Default)]
    #[repr(transparent)] pub struct VideoCodingQualityPresetFlagsKHR : u32 { const
    NORMAL_KHR = VideoCodingQualityPresetFlagBitsKHR::NORMAL_KHR.0; const POWER_KHR =
    VideoCodingQualityPresetFlagBitsKHR::POWER_KHR.0; const QUALITY_KHR =
    VideoCodingQualityPresetFlagBitsKHR::QUALITY_KHR.0; }
}
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoCodingQualityPresetFlagBitsKHR.html) · Bits enum of [`VideoCodingQualityPresetFlagsKHR`]
#[doc(alias = "VkVideoCodingQualityPresetFlagBitsKHR")]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
#[repr(transparent)]
pub struct VideoCodingQualityPresetFlagBitsKHR(pub u32);
impl VideoCodingQualityPresetFlagBitsKHR {
    #[inline]
    ///Converts this enum variant to the corresponding bitmask
    pub const fn bitmask(&self) -> VideoCodingQualityPresetFlagsKHR {
        VideoCodingQualityPresetFlagsKHR::from_bits_truncate(self.0)
    }
}
impl std::fmt::Debug for VideoCodingQualityPresetFlagBitsKHR {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.write_str(
            match self {
                &Self::NORMAL_KHR => "NORMAL_KHR",
                &Self::POWER_KHR => "POWER_KHR",
                &Self::QUALITY_KHR => "QUALITY_KHR",
                _ => "(unknown variant)",
            },
        )
    }
}
///Provided by [`crate::extensions::khr_video_queue`]
impl crate::extensions::khr_video_queue::VideoCodingQualityPresetFlagBitsKHR {
    pub const NORMAL_KHR: Self = Self(1);
    pub const POWER_KHR: Self = Self(2);
    pub const QUALITY_KHR: Self = Self(4);
}
bitflags::bitflags! {
    #[doc =
    "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoCodingControlFlagsKHR.html) · Bitmask of [`VideoCodingControlFlagBitsKHR`]"]
    #[doc(alias = "VkVideoCodingControlFlagsKHR")] #[derive(Default)]
    #[repr(transparent)] pub struct VideoCodingControlFlagsKHR : u32 { const DEFAULT_KHR
    = VideoCodingControlFlagBitsKHR::DEFAULT_KHR.0; const RESET_KHR =
    VideoCodingControlFlagBitsKHR::RESET_KHR.0; }
}
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoCodingControlFlagBitsKHR.html) · Bits enum of [`VideoCodingControlFlagsKHR`]
#[doc(alias = "VkVideoCodingControlFlagBitsKHR")]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
#[repr(transparent)]
pub struct VideoCodingControlFlagBitsKHR(pub u32);
impl VideoCodingControlFlagBitsKHR {
    #[inline]
    ///Converts this enum variant to the corresponding bitmask
    pub const fn bitmask(&self) -> VideoCodingControlFlagsKHR {
        VideoCodingControlFlagsKHR::from_bits_truncate(self.0)
    }
}
impl std::fmt::Debug for VideoCodingControlFlagBitsKHR {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.write_str(
            match self {
                &Self::DEFAULT_KHR => "DEFAULT_KHR",
                &Self::RESET_KHR => "RESET_KHR",
                _ => "(unknown variant)",
            },
        )
    }
}
///Provided by [`crate::extensions::khr_video_queue`]
impl crate::extensions::khr_video_queue::VideoCodingControlFlagBitsKHR {
    pub const DEFAULT_KHR: Self = Self(0);
    pub const RESET_KHR: Self = Self(1);
}
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueryResultStatusKHR.html) · Enum
#[doc(alias = "VkQueryResultStatusKHR")]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
#[repr(transparent)]
pub struct QueryResultStatusKHR(pub i32);
impl std::fmt::Debug for QueryResultStatusKHR {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.write_str(
            match self {
                &Self::ERROR_KHR => "ERROR_KHR",
                &Self::NOT_READY_KHR => "NOT_READY_KHR",
                &Self::COMPLETE_KHR => "COMPLETE_KHR",
                _ => "(unknown variant)",
            },
        )
    }
}
///Provided by [`crate::extensions::khr_video_queue`]
impl crate::extensions::khr_video_queue::QueryResultStatusKHR {
    pub const ERROR_KHR: Self = Self(-1);
    pub const NOT_READY_KHR: Self = Self(0);
    pub const COMPLETE_KHR: Self = Self(1);
}
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceVideoCapabilitiesKHR.html) · Function
#[allow(non_camel_case_types)]
pub type PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR = unsafe extern "system" fn(
    physical_device: crate::vk1_0::PhysicalDevice,
    p_video_profile: *const crate::extensions::khr_video_queue::VideoProfileKHR,
    p_capabilities: *mut crate::extensions::khr_video_queue::VideoCapabilitiesKHR,
) -> crate::vk1_0::Result;
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceVideoFormatPropertiesKHR.html) · Function
#[allow(non_camel_case_types)]
pub type PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR = unsafe extern "system" fn(
    physical_device: crate::vk1_0::PhysicalDevice,
    p_video_format_info: *const crate::extensions::khr_video_queue::PhysicalDeviceVideoFormatInfoKHR,
    p_video_format_property_count: *mut u32,
    p_video_format_properties: *mut crate::extensions::khr_video_queue::VideoFormatPropertiesKHR,
) -> crate::vk1_0::Result;
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateVideoSessionKHR.html) · Function
#[allow(non_camel_case_types)]
pub type PFN_vkCreateVideoSessionKHR = unsafe extern "system" fn(
    device: crate::vk1_0::Device,
    p_create_info: *const crate::extensions::khr_video_queue::VideoSessionCreateInfoKHR,
    p_allocator: *const crate::vk1_0::AllocationCallbacks,
    p_video_session: *mut crate::extensions::khr_video_queue::VideoSessionKHR,
) -> crate::vk1_0::Result;
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkDestroyVideoSessionKHR.html) · Function
#[allow(non_camel_case_types)]
pub type PFN_vkDestroyVideoSessionKHR = unsafe extern "system" fn(
    device: crate::vk1_0::Device,
    video_session: crate::extensions::khr_video_queue::VideoSessionKHR,
    p_allocator: *const crate::vk1_0::AllocationCallbacks,
) -> ();
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateVideoSessionParametersKHR.html) · Function
#[allow(non_camel_case_types)]
pub type PFN_vkCreateVideoSessionParametersKHR = unsafe extern "system" fn(
    device: crate::vk1_0::Device,
    p_create_info: *const crate::extensions::khr_video_queue::VideoSessionParametersCreateInfoKHR,
    p_allocator: *const crate::vk1_0::AllocationCallbacks,
    p_video_session_parameters: *mut crate::extensions::khr_video_queue::VideoSessionParametersKHR,
) -> crate::vk1_0::Result;
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkUpdateVideoSessionParametersKHR.html) · Function
#[allow(non_camel_case_types)]
pub type PFN_vkUpdateVideoSessionParametersKHR = unsafe extern "system" fn(
    device: crate::vk1_0::Device,
    video_session_parameters: crate::extensions::khr_video_queue::VideoSessionParametersKHR,
    p_update_info: *const crate::extensions::khr_video_queue::VideoSessionParametersUpdateInfoKHR,
) -> crate::vk1_0::Result;
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkDestroyVideoSessionParametersKHR.html) · Function
#[allow(non_camel_case_types)]
pub type PFN_vkDestroyVideoSessionParametersKHR = unsafe extern "system" fn(
    device: crate::vk1_0::Device,
    video_session_parameters: crate::extensions::khr_video_queue::VideoSessionParametersKHR,
    p_allocator: *const crate::vk1_0::AllocationCallbacks,
) -> ();
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetVideoSessionMemoryRequirementsKHR.html) · Function
#[allow(non_camel_case_types)]
pub type PFN_vkGetVideoSessionMemoryRequirementsKHR = unsafe extern "system" fn(
    device: crate::vk1_0::Device,
    video_session: crate::extensions::khr_video_queue::VideoSessionKHR,
    p_video_session_memory_requirements_count: *mut u32,
    p_video_session_memory_requirements: *mut crate::extensions::khr_video_queue::VideoGetMemoryPropertiesKHR,
) -> crate::vk1_0::Result;
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkBindVideoSessionMemoryKHR.html) · Function
#[allow(non_camel_case_types)]
pub type PFN_vkBindVideoSessionMemoryKHR = unsafe extern "system" fn(
    device: crate::vk1_0::Device,
    video_session: crate::extensions::khr_video_queue::VideoSessionKHR,
    video_session_bind_memory_count: u32,
    p_video_session_bind_memories: *const crate::extensions::khr_video_queue::VideoBindMemoryKHR,
) -> crate::vk1_0::Result;
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdBeginVideoCodingKHR.html) · Function
#[allow(non_camel_case_types)]
pub type PFN_vkCmdBeginVideoCodingKHR = unsafe extern "system" fn(
    command_buffer: crate::vk1_0::CommandBuffer,
    p_begin_info: *const crate::extensions::khr_video_queue::VideoBeginCodingInfoKHR,
) -> ();
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdControlVideoCodingKHR.html) · Function
#[allow(non_camel_case_types)]
pub type PFN_vkCmdControlVideoCodingKHR = unsafe extern "system" fn(
    command_buffer: crate::vk1_0::CommandBuffer,
    p_coding_control_info: *const crate::extensions::khr_video_queue::VideoCodingControlInfoKHR,
) -> ();
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdEndVideoCodingKHR.html) · Function
#[allow(non_camel_case_types)]
pub type PFN_vkCmdEndVideoCodingKHR = unsafe extern "system" fn(
    command_buffer: crate::vk1_0::CommandBuffer,
    p_end_coding_info: *const crate::extensions::khr_video_queue::VideoEndCodingInfoKHR,
) -> ();
impl<'a> crate::ExtendableFrom<'a, VideoProfilesKHR>
for crate::vk1_0::BufferCreateInfoBuilder<'a> {}
impl<'a> crate::ExtendableFrom<'a, VideoProfilesKHRBuilder<'_>>
for crate::vk1_0::BufferCreateInfoBuilder<'a> {}
impl<'a> crate::ExtendableFrom<'a, VideoProfileKHR>
for crate::vk1_0::BufferCreateInfoBuilder<'a> {}
impl<'a> crate::ExtendableFrom<'a, VideoProfileKHRBuilder<'_>>
for crate::vk1_0::BufferCreateInfoBuilder<'a> {}
impl<'a> crate::ExtendableFrom<'a, VideoProfilesKHR>
for crate::vk1_0::ImageCreateInfoBuilder<'a> {}
impl<'a> crate::ExtendableFrom<'a, VideoProfilesKHRBuilder<'_>>
for crate::vk1_0::ImageCreateInfoBuilder<'a> {}
impl<'a> crate::ExtendableFrom<'a, VideoProfileKHR>
for crate::vk1_0::ImageCreateInfoBuilder<'a> {}
impl<'a> crate::ExtendableFrom<'a, VideoProfileKHRBuilder<'_>>
for crate::vk1_0::ImageCreateInfoBuilder<'a> {}
impl<'a> crate::ExtendableFrom<'a, VideoProfilesKHR>
for crate::vk1_0::ImageViewCreateInfoBuilder<'a> {}
impl<'a> crate::ExtendableFrom<'a, VideoProfilesKHRBuilder<'_>>
for crate::vk1_0::ImageViewCreateInfoBuilder<'a> {}
impl<'a> crate::ExtendableFrom<'a, VideoProfileKHR>
for crate::vk1_0::ImageViewCreateInfoBuilder<'a> {}
impl<'a> crate::ExtendableFrom<'a, VideoProfileKHRBuilder<'_>>
for crate::vk1_0::ImageViewCreateInfoBuilder<'a> {}
impl<'a> crate::ExtendableFrom<'a, VideoProfileKHR>
for crate::vk1_0::QueryPoolCreateInfoBuilder<'a> {}
impl<'a> crate::ExtendableFrom<'a, VideoProfileKHRBuilder<'_>>
for crate::vk1_0::QueryPoolCreateInfoBuilder<'a> {}
impl<'a> crate::ExtendableFrom<'a, VideoProfilesKHR>
for crate::vk1_1::FormatProperties2Builder<'a> {}
impl<'a> crate::ExtendableFrom<'a, VideoProfilesKHRBuilder<'_>>
for crate::vk1_1::FormatProperties2Builder<'a> {}
impl<'a> crate::ExtendableFrom<'a, VideoProfileKHR>
for crate::vk1_1::FormatProperties2Builder<'a> {}
impl<'a> crate::ExtendableFrom<'a, VideoProfileKHRBuilder<'_>>
for crate::vk1_1::FormatProperties2Builder<'a> {}
impl<'a> crate::ExtendableFrom<'a, VideoQueueFamilyProperties2KHR>
for crate::vk1_1::QueueFamilyProperties2Builder<'a> {}
impl<'a> crate::ExtendableFrom<'a, VideoQueueFamilyProperties2KHRBuilder<'_>>
for crate::vk1_1::QueueFamilyProperties2Builder<'a> {}
impl<'a> crate::ExtendableFrom<'a, QueueFamilyQueryResultStatusProperties2KHR>
for crate::vk1_1::QueueFamilyProperties2Builder<'a> {}
impl<'a> crate::ExtendableFrom<'a, QueueFamilyQueryResultStatusProperties2KHRBuilder<'_>>
for crate::vk1_1::QueueFamilyProperties2Builder<'a> {}
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoQueueFamilyProperties2KHR.html) · Structure
#[doc(alias = "VkVideoQueueFamilyProperties2KHR")]
#[derive(Copy, Clone)]
#[repr(C)]
pub struct VideoQueueFamilyProperties2KHR {
    pub s_type: crate::vk1_0::StructureType,
    pub p_next: *mut std::ffi::c_void,
    pub video_codec_operations: crate::extensions::khr_video_queue::VideoCodecOperationFlagsKHR,
}
impl VideoQueueFamilyProperties2KHR {
    pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR;
}
impl Default for VideoQueueFamilyProperties2KHR {
    fn default() -> Self {
        Self {
            s_type: Self::STRUCTURE_TYPE,
            p_next: std::ptr::null_mut(),
            video_codec_operations: Default::default(),
        }
    }
}
impl std::fmt::Debug for VideoQueueFamilyProperties2KHR {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.debug_struct("VideoQueueFamilyProperties2KHR")
            .field("s_type", &self.s_type)
            .field("p_next", &self.p_next)
            .field("video_codec_operations", &self.video_codec_operations)
            .finish()
    }
}
impl VideoQueueFamilyProperties2KHR {
    #[inline]
    pub fn into_builder<'a>(self) -> VideoQueueFamilyProperties2KHRBuilder<'a> {
        VideoQueueFamilyProperties2KHRBuilder(self, std::marker::PhantomData)
    }
}
#[derive(Copy, Clone)]
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoQueueFamilyProperties2KHR.html) · Builder of [`VideoQueueFamilyProperties2KHR`]
#[repr(transparent)]
pub struct VideoQueueFamilyProperties2KHRBuilder<'a>(
    VideoQueueFamilyProperties2KHR,
    std::marker::PhantomData<&'a ()>,
);
impl<'a> VideoQueueFamilyProperties2KHRBuilder<'a> {
    #[inline]
    pub fn new() -> VideoQueueFamilyProperties2KHRBuilder<'a> {
        VideoQueueFamilyProperties2KHRBuilder(
            Default::default(),
            std::marker::PhantomData,
        )
    }
    #[inline]
    #[must_use]
    pub fn video_codec_operations(
        mut self,
        video_codec_operations: crate::extensions::khr_video_queue::VideoCodecOperationFlagsKHR,
    ) -> Self {
        self.0.video_codec_operations = video_codec_operations as _;
        self
    }
    #[inline]
    /// Discards all lifetime information.
    /// Use the `Deref` and `DerefMut` implementations if possible.
    pub fn build_dangling(self) -> VideoQueueFamilyProperties2KHR {
        self.0
    }
}
impl<'a> std::default::Default for VideoQueueFamilyProperties2KHRBuilder<'a> {
    fn default() -> VideoQueueFamilyProperties2KHRBuilder<'a> {
        Self::new()
    }
}
impl<'a> std::fmt::Debug for VideoQueueFamilyProperties2KHRBuilder<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        std::fmt::Debug::fmt(&self.0, f)
    }
}
impl<'a> std::ops::Deref for VideoQueueFamilyProperties2KHRBuilder<'a> {
    type Target = VideoQueueFamilyProperties2KHR;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl<'a> std::ops::DerefMut for VideoQueueFamilyProperties2KHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueueFamilyQueryResultStatusProperties2KHR.html) · Structure
#[doc(alias = "VkQueueFamilyQueryResultStatusProperties2KHR")]
#[derive(Copy, Clone)]
#[repr(C)]
pub struct QueueFamilyQueryResultStatusProperties2KHR {
    pub s_type: crate::vk1_0::StructureType,
    pub p_next: *mut std::ffi::c_void,
    pub supported: crate::vk1_0::Bool32,
}
impl QueueFamilyQueryResultStatusProperties2KHR {
    pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_2_KHR;
}
impl Default for QueueFamilyQueryResultStatusProperties2KHR {
    fn default() -> Self {
        Self {
            s_type: Self::STRUCTURE_TYPE,
            p_next: std::ptr::null_mut(),
            supported: Default::default(),
        }
    }
}
impl std::fmt::Debug for QueueFamilyQueryResultStatusProperties2KHR {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.debug_struct("QueueFamilyQueryResultStatusProperties2KHR")
            .field("s_type", &self.s_type)
            .field("p_next", &self.p_next)
            .field("supported", &(self.supported != 0))
            .finish()
    }
}
impl QueueFamilyQueryResultStatusProperties2KHR {
    #[inline]
    pub fn into_builder<'a>(
        self,
    ) -> QueueFamilyQueryResultStatusProperties2KHRBuilder<'a> {
        QueueFamilyQueryResultStatusProperties2KHRBuilder(self, std::marker::PhantomData)
    }
}
#[derive(Copy, Clone)]
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueueFamilyQueryResultStatusProperties2KHR.html) · Builder of [`QueueFamilyQueryResultStatusProperties2KHR`]
#[repr(transparent)]
pub struct QueueFamilyQueryResultStatusProperties2KHRBuilder<'a>(
    QueueFamilyQueryResultStatusProperties2KHR,
    std::marker::PhantomData<&'a ()>,
);
impl<'a> QueueFamilyQueryResultStatusProperties2KHRBuilder<'a> {
    #[inline]
    pub fn new() -> QueueFamilyQueryResultStatusProperties2KHRBuilder<'a> {
        QueueFamilyQueryResultStatusProperties2KHRBuilder(
            Default::default(),
            std::marker::PhantomData,
        )
    }
    #[inline]
    #[must_use]
    pub fn supported(mut self, supported: bool) -> Self {
        self.0.supported = supported as _;
        self
    }
    #[inline]
    /// Discards all lifetime information.
    /// Use the `Deref` and `DerefMut` implementations if possible.
    pub fn build_dangling(self) -> QueueFamilyQueryResultStatusProperties2KHR {
        self.0
    }
}
impl<'a> std::default::Default
for QueueFamilyQueryResultStatusProperties2KHRBuilder<'a> {
    fn default() -> QueueFamilyQueryResultStatusProperties2KHRBuilder<'a> {
        Self::new()
    }
}
impl<'a> std::fmt::Debug for QueueFamilyQueryResultStatusProperties2KHRBuilder<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        std::fmt::Debug::fmt(&self.0, f)
    }
}
impl<'a> std::ops::Deref for QueueFamilyQueryResultStatusProperties2KHRBuilder<'a> {
    type Target = QueueFamilyQueryResultStatusProperties2KHR;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl<'a> std::ops::DerefMut for QueueFamilyQueryResultStatusProperties2KHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoProfilesKHR.html) · Structure
#[doc(alias = "VkVideoProfilesKHR")]
#[derive(Copy, Clone)]
#[repr(C)]
pub struct VideoProfilesKHR {
    pub s_type: crate::vk1_0::StructureType,
    pub p_next: *mut std::ffi::c_void,
    pub profile_count: u32,
    pub p_profiles: *const crate::extensions::khr_video_queue::VideoProfileKHR,
}
impl VideoProfilesKHR {
    pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::VIDEO_PROFILES_KHR;
}
impl Default for VideoProfilesKHR {
    fn default() -> Self {
        Self {
            s_type: Self::STRUCTURE_TYPE,
            p_next: std::ptr::null_mut(),
            profile_count: Default::default(),
            p_profiles: std::ptr::null(),
        }
    }
}
impl std::fmt::Debug for VideoProfilesKHR {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.debug_struct("VideoProfilesKHR")
            .field("s_type", &self.s_type)
            .field("p_next", &self.p_next)
            .field("profile_count", &self.profile_count)
            .field("p_profiles", &self.p_profiles)
            .finish()
    }
}
impl VideoProfilesKHR {
    #[inline]
    pub fn into_builder<'a>(self) -> VideoProfilesKHRBuilder<'a> {
        VideoProfilesKHRBuilder(self, std::marker::PhantomData)
    }
}
#[derive(Copy, Clone)]
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoProfilesKHR.html) · Builder of [`VideoProfilesKHR`]
#[repr(transparent)]
pub struct VideoProfilesKHRBuilder<'a>(
    VideoProfilesKHR,
    std::marker::PhantomData<&'a ()>,
);
impl<'a> VideoProfilesKHRBuilder<'a> {
    #[inline]
    pub fn new() -> VideoProfilesKHRBuilder<'a> {
        VideoProfilesKHRBuilder(Default::default(), std::marker::PhantomData)
    }
    #[inline]
    #[must_use]
    pub fn profiles(
        mut self,
        profiles: &'a [crate::extensions::khr_video_queue::VideoProfileKHRBuilder],
    ) -> Self {
        self.0.p_profiles = profiles.as_ptr() as _;
        self.0.profile_count = profiles.len() as _;
        self
    }
    #[inline]
    /// Discards all lifetime information.
    /// Use the `Deref` and `DerefMut` implementations if possible.
    pub fn build_dangling(self) -> VideoProfilesKHR {
        self.0
    }
}
impl<'a> std::default::Default for VideoProfilesKHRBuilder<'a> {
    fn default() -> VideoProfilesKHRBuilder<'a> {
        Self::new()
    }
}
impl<'a> std::fmt::Debug for VideoProfilesKHRBuilder<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        std::fmt::Debug::fmt(&self.0, f)
    }
}
impl<'a> std::ops::Deref for VideoProfilesKHRBuilder<'a> {
    type Target = VideoProfilesKHR;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl<'a> std::ops::DerefMut for VideoProfilesKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVideoFormatInfoKHR.html) · Structure
#[doc(alias = "VkPhysicalDeviceVideoFormatInfoKHR")]
#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhysicalDeviceVideoFormatInfoKHR {
    pub s_type: crate::vk1_0::StructureType,
    pub p_next: *mut std::ffi::c_void,
    pub image_usage: crate::vk1_0::ImageUsageFlags,
    pub p_video_profiles: *const crate::extensions::khr_video_queue::VideoProfilesKHR,
}
impl PhysicalDeviceVideoFormatInfoKHR {
    pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR;
}
impl Default for PhysicalDeviceVideoFormatInfoKHR {
    fn default() -> Self {
        Self {
            s_type: Self::STRUCTURE_TYPE,
            p_next: std::ptr::null_mut(),
            image_usage: Default::default(),
            p_video_profiles: std::ptr::null(),
        }
    }
}
impl std::fmt::Debug for PhysicalDeviceVideoFormatInfoKHR {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.debug_struct("PhysicalDeviceVideoFormatInfoKHR")
            .field("s_type", &self.s_type)
            .field("p_next", &self.p_next)
            .field("image_usage", &self.image_usage)
            .field("p_video_profiles", &self.p_video_profiles)
            .finish()
    }
}
impl PhysicalDeviceVideoFormatInfoKHR {
    #[inline]
    pub fn into_builder<'a>(self) -> PhysicalDeviceVideoFormatInfoKHRBuilder<'a> {
        PhysicalDeviceVideoFormatInfoKHRBuilder(self, std::marker::PhantomData)
    }
}
#[derive(Copy, Clone)]
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVideoFormatInfoKHR.html) · Builder of [`PhysicalDeviceVideoFormatInfoKHR`]
#[repr(transparent)]
pub struct PhysicalDeviceVideoFormatInfoKHRBuilder<'a>(
    PhysicalDeviceVideoFormatInfoKHR,
    std::marker::PhantomData<&'a ()>,
);
impl<'a> PhysicalDeviceVideoFormatInfoKHRBuilder<'a> {
    #[inline]
    pub fn new() -> PhysicalDeviceVideoFormatInfoKHRBuilder<'a> {
        PhysicalDeviceVideoFormatInfoKHRBuilder(
            Default::default(),
            std::marker::PhantomData,
        )
    }
    #[inline]
    #[must_use]
    pub fn image_usage(mut self, image_usage: crate::vk1_0::ImageUsageFlags) -> Self {
        self.0.image_usage = image_usage as _;
        self
    }
    #[inline]
    #[must_use]
    pub fn video_profiles(
        mut self,
        video_profiles: &'a crate::extensions::khr_video_queue::VideoProfilesKHR,
    ) -> Self {
        self.0.p_video_profiles = video_profiles as _;
        self
    }
    #[inline]
    /// Discards all lifetime information.
    /// Use the `Deref` and `DerefMut` implementations if possible.
    pub fn build_dangling(self) -> PhysicalDeviceVideoFormatInfoKHR {
        self.0
    }
}
impl<'a> std::default::Default for PhysicalDeviceVideoFormatInfoKHRBuilder<'a> {
    fn default() -> PhysicalDeviceVideoFormatInfoKHRBuilder<'a> {
        Self::new()
    }
}
impl<'a> std::fmt::Debug for PhysicalDeviceVideoFormatInfoKHRBuilder<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        std::fmt::Debug::fmt(&self.0, f)
    }
}
impl<'a> std::ops::Deref for PhysicalDeviceVideoFormatInfoKHRBuilder<'a> {
    type Target = PhysicalDeviceVideoFormatInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl<'a> std::ops::DerefMut for PhysicalDeviceVideoFormatInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoFormatPropertiesKHR.html) · Structure
#[doc(alias = "VkVideoFormatPropertiesKHR")]
#[derive(Copy, Clone)]
#[repr(C)]
pub struct VideoFormatPropertiesKHR {
    pub s_type: crate::vk1_0::StructureType,
    pub p_next: *mut std::ffi::c_void,
    pub format: crate::vk1_0::Format,
}
impl VideoFormatPropertiesKHR {
    pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::VIDEO_FORMAT_PROPERTIES_KHR;
}
impl Default for VideoFormatPropertiesKHR {
    fn default() -> Self {
        Self {
            s_type: Self::STRUCTURE_TYPE,
            p_next: std::ptr::null_mut(),
            format: Default::default(),
        }
    }
}
impl std::fmt::Debug for VideoFormatPropertiesKHR {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.debug_struct("VideoFormatPropertiesKHR")
            .field("s_type", &self.s_type)
            .field("p_next", &self.p_next)
            .field("format", &self.format)
            .finish()
    }
}
impl VideoFormatPropertiesKHR {
    #[inline]
    pub fn into_builder<'a>(self) -> VideoFormatPropertiesKHRBuilder<'a> {
        VideoFormatPropertiesKHRBuilder(self, std::marker::PhantomData)
    }
}
#[derive(Copy, Clone)]
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoFormatPropertiesKHR.html) · Builder of [`VideoFormatPropertiesKHR`]
#[repr(transparent)]
pub struct VideoFormatPropertiesKHRBuilder<'a>(
    VideoFormatPropertiesKHR,
    std::marker::PhantomData<&'a ()>,
);
impl<'a> VideoFormatPropertiesKHRBuilder<'a> {
    #[inline]
    pub fn new() -> VideoFormatPropertiesKHRBuilder<'a> {
        VideoFormatPropertiesKHRBuilder(Default::default(), std::marker::PhantomData)
    }
    #[inline]
    #[must_use]
    pub fn format(mut self, format: crate::vk1_0::Format) -> Self {
        self.0.format = format as _;
        self
    }
    #[inline]
    /// Discards all lifetime information.
    /// Use the `Deref` and `DerefMut` implementations if possible.
    pub fn build_dangling(self) -> VideoFormatPropertiesKHR {
        self.0
    }
}
impl<'a> std::default::Default for VideoFormatPropertiesKHRBuilder<'a> {
    fn default() -> VideoFormatPropertiesKHRBuilder<'a> {
        Self::new()
    }
}
impl<'a> std::fmt::Debug for VideoFormatPropertiesKHRBuilder<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        std::fmt::Debug::fmt(&self.0, f)
    }
}
impl<'a> std::ops::Deref for VideoFormatPropertiesKHRBuilder<'a> {
    type Target = VideoFormatPropertiesKHR;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl<'a> std::ops::DerefMut for VideoFormatPropertiesKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoProfileKHR.html) · Structure
#[doc(alias = "VkVideoProfileKHR")]
#[derive(Copy, Clone)]
#[repr(C)]
pub struct VideoProfileKHR {
    pub s_type: crate::vk1_0::StructureType,
    pub p_next: *mut std::ffi::c_void,
    pub video_codec_operation: crate::extensions::khr_video_queue::VideoCodecOperationFlagBitsKHR,
    pub chroma_subsampling: crate::extensions::khr_video_queue::VideoChromaSubsamplingFlagsKHR,
    pub luma_bit_depth: crate::extensions::khr_video_queue::VideoComponentBitDepthFlagsKHR,
    pub chroma_bit_depth: crate::extensions::khr_video_queue::VideoComponentBitDepthFlagsKHR,
}
impl VideoProfileKHR {
    pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::VIDEO_PROFILE_KHR;
}
impl Default for VideoProfileKHR {
    fn default() -> Self {
        Self {
            s_type: Self::STRUCTURE_TYPE,
            p_next: std::ptr::null_mut(),
            video_codec_operation: Default::default(),
            chroma_subsampling: Default::default(),
            luma_bit_depth: Default::default(),
            chroma_bit_depth: Default::default(),
        }
    }
}
impl std::fmt::Debug for VideoProfileKHR {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.debug_struct("VideoProfileKHR")
            .field("s_type", &self.s_type)
            .field("p_next", &self.p_next)
            .field("video_codec_operation", &self.video_codec_operation)
            .field("chroma_subsampling", &self.chroma_subsampling)
            .field("luma_bit_depth", &self.luma_bit_depth)
            .field("chroma_bit_depth", &self.chroma_bit_depth)
            .finish()
    }
}
impl VideoProfileKHR {
    #[inline]
    pub fn into_builder<'a>(self) -> VideoProfileKHRBuilder<'a> {
        VideoProfileKHRBuilder(self, std::marker::PhantomData)
    }
}
#[derive(Copy, Clone)]
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoProfileKHR.html) · Builder of [`VideoProfileKHR`]
#[repr(transparent)]
pub struct VideoProfileKHRBuilder<'a>(VideoProfileKHR, std::marker::PhantomData<&'a ()>);
impl<'a> VideoProfileKHRBuilder<'a> {
    #[inline]
    pub fn new() -> VideoProfileKHRBuilder<'a> {
        VideoProfileKHRBuilder(Default::default(), std::marker::PhantomData)
    }
    #[inline]
    #[must_use]
    pub fn video_codec_operation(
        mut self,
        video_codec_operation: crate::extensions::khr_video_queue::VideoCodecOperationFlagBitsKHR,
    ) -> Self {
        self.0.video_codec_operation = video_codec_operation as _;
        self
    }
    #[inline]
    #[must_use]
    pub fn chroma_subsampling(
        mut self,
        chroma_subsampling: crate::extensions::khr_video_queue::VideoChromaSubsamplingFlagsKHR,
    ) -> Self {
        self.0.chroma_subsampling = chroma_subsampling as _;
        self
    }
    #[inline]
    #[must_use]
    pub fn luma_bit_depth(
        mut self,
        luma_bit_depth: crate::extensions::khr_video_queue::VideoComponentBitDepthFlagsKHR,
    ) -> Self {
        self.0.luma_bit_depth = luma_bit_depth as _;
        self
    }
    #[inline]
    #[must_use]
    pub fn chroma_bit_depth(
        mut self,
        chroma_bit_depth: crate::extensions::khr_video_queue::VideoComponentBitDepthFlagsKHR,
    ) -> Self {
        self.0.chroma_bit_depth = chroma_bit_depth as _;
        self
    }
    #[inline]
    /// Discards all lifetime information.
    /// Use the `Deref` and `DerefMut` implementations if possible.
    pub fn build_dangling(self) -> VideoProfileKHR {
        self.0
    }
}
impl<'a> std::default::Default for VideoProfileKHRBuilder<'a> {
    fn default() -> VideoProfileKHRBuilder<'a> {
        Self::new()
    }
}
impl<'a> std::fmt::Debug for VideoProfileKHRBuilder<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        std::fmt::Debug::fmt(&self.0, f)
    }
}
impl<'a> std::ops::Deref for VideoProfileKHRBuilder<'a> {
    type Target = VideoProfileKHR;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl<'a> std::ops::DerefMut for VideoProfileKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoCapabilitiesKHR.html) · Structure
#[doc(alias = "VkVideoCapabilitiesKHR")]
#[derive(Copy, Clone)]
#[repr(C)]
pub struct VideoCapabilitiesKHR {
    pub s_type: crate::vk1_0::StructureType,
    pub p_next: *mut std::ffi::c_void,
    pub capability_flags: crate::extensions::khr_video_queue::VideoCapabilityFlagsKHR,
    pub min_bitstream_buffer_offset_alignment: crate::vk1_0::DeviceSize,
    pub min_bitstream_buffer_size_alignment: crate::vk1_0::DeviceSize,
    pub video_picture_extent_granularity: crate::vk1_0::Extent2D,
    pub min_extent: crate::vk1_0::Extent2D,
    pub max_extent: crate::vk1_0::Extent2D,
    pub max_reference_pictures_slots_count: u32,
    pub max_reference_pictures_active_count: u32,
    pub std_header_version: crate::vk1_0::ExtensionProperties,
}
impl VideoCapabilitiesKHR {
    pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::VIDEO_CAPABILITIES_KHR;
}
impl Default for VideoCapabilitiesKHR {
    fn default() -> Self {
        Self {
            s_type: Self::STRUCTURE_TYPE,
            p_next: std::ptr::null_mut(),
            capability_flags: Default::default(),
            min_bitstream_buffer_offset_alignment: Default::default(),
            min_bitstream_buffer_size_alignment: Default::default(),
            video_picture_extent_granularity: Default::default(),
            min_extent: Default::default(),
            max_extent: Default::default(),
            max_reference_pictures_slots_count: Default::default(),
            max_reference_pictures_active_count: Default::default(),
            std_header_version: Default::default(),
        }
    }
}
impl std::fmt::Debug for VideoCapabilitiesKHR {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.debug_struct("VideoCapabilitiesKHR")
            .field("s_type", &self.s_type)
            .field("p_next", &self.p_next)
            .field("capability_flags", &self.capability_flags)
            .field(
                "min_bitstream_buffer_offset_alignment",
                &self.min_bitstream_buffer_offset_alignment,
            )
            .field(
                "min_bitstream_buffer_size_alignment",
                &self.min_bitstream_buffer_size_alignment,
            )
            .field(
                "video_picture_extent_granularity",
                &self.video_picture_extent_granularity,
            )
            .field("min_extent", &self.min_extent)
            .field("max_extent", &self.max_extent)
            .field(
                "max_reference_pictures_slots_count",
                &self.max_reference_pictures_slots_count,
            )
            .field(
                "max_reference_pictures_active_count",
                &self.max_reference_pictures_active_count,
            )
            .field("std_header_version", &self.std_header_version)
            .finish()
    }
}
impl VideoCapabilitiesKHR {
    #[inline]
    pub fn into_builder<'a>(self) -> VideoCapabilitiesKHRBuilder<'a> {
        VideoCapabilitiesKHRBuilder(self, std::marker::PhantomData)
    }
}
#[derive(Copy, Clone)]
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoCapabilitiesKHR.html) · Builder of [`VideoCapabilitiesKHR`]
#[repr(transparent)]
pub struct VideoCapabilitiesKHRBuilder<'a>(
    VideoCapabilitiesKHR,
    std::marker::PhantomData<&'a ()>,
);
impl<'a> VideoCapabilitiesKHRBuilder<'a> {
    #[inline]
    pub fn new() -> VideoCapabilitiesKHRBuilder<'a> {
        VideoCapabilitiesKHRBuilder(Default::default(), std::marker::PhantomData)
    }
    #[inline]
    #[must_use]
    pub fn capability_flags(
        mut self,
        capability_flags: crate::extensions::khr_video_queue::VideoCapabilityFlagsKHR,
    ) -> Self {
        self.0.capability_flags = capability_flags as _;
        self
    }
    #[inline]
    #[must_use]
    pub fn min_bitstream_buffer_offset_alignment(
        mut self,
        min_bitstream_buffer_offset_alignment: crate::vk1_0::DeviceSize,
    ) -> Self {
        self
            .0
            .min_bitstream_buffer_offset_alignment = min_bitstream_buffer_offset_alignment
            as _;
        self
    }
    #[inline]
    #[must_use]
    pub fn min_bitstream_buffer_size_alignment(
        mut self,
        min_bitstream_buffer_size_alignment: crate::vk1_0::DeviceSize,
    ) -> Self {
        self
            .0
            .min_bitstream_buffer_size_alignment = min_bitstream_buffer_size_alignment
            as _;
        self
    }
    #[inline]
    #[must_use]
    pub fn video_picture_extent_granularity(
        mut self,
        video_picture_extent_granularity: crate::vk1_0::Extent2D,
    ) -> Self {
        self.0.video_picture_extent_granularity = video_picture_extent_granularity as _;
        self
    }
    #[inline]
    #[must_use]
    pub fn min_extent(mut self, min_extent: crate::vk1_0::Extent2D) -> Self {
        self.0.min_extent = min_extent as _;
        self
    }
    #[inline]
    #[must_use]
    pub fn max_extent(mut self, max_extent: crate::vk1_0::Extent2D) -> Self {
        self.0.max_extent = max_extent as _;
        self
    }
    #[inline]
    #[must_use]
    pub fn max_reference_pictures_slots_count(
        mut self,
        max_reference_pictures_slots_count: u32,
    ) -> Self {
        self
            .0
            .max_reference_pictures_slots_count = max_reference_pictures_slots_count
            as _;
        self
    }
    #[inline]
    #[must_use]
    pub fn max_reference_pictures_active_count(
        mut self,
        max_reference_pictures_active_count: u32,
    ) -> Self {
        self
            .0
            .max_reference_pictures_active_count = max_reference_pictures_active_count
            as _;
        self
    }
    #[inline]
    #[must_use]
    pub fn std_header_version(
        mut self,
        std_header_version: crate::vk1_0::ExtensionProperties,
    ) -> Self {
        self.0.std_header_version = std_header_version as _;
        self
    }
    #[inline]
    /// Discards all lifetime information.
    /// Use the `Deref` and `DerefMut` implementations if possible.
    pub fn build_dangling(self) -> VideoCapabilitiesKHR {
        self.0
    }
}
impl<'a> std::default::Default for VideoCapabilitiesKHRBuilder<'a> {
    fn default() -> VideoCapabilitiesKHRBuilder<'a> {
        Self::new()
    }
}
impl<'a> std::fmt::Debug for VideoCapabilitiesKHRBuilder<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        std::fmt::Debug::fmt(&self.0, f)
    }
}
impl<'a> std::ops::Deref for VideoCapabilitiesKHRBuilder<'a> {
    type Target = VideoCapabilitiesKHR;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl<'a> std::ops::DerefMut for VideoCapabilitiesKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoGetMemoryPropertiesKHR.html) · Structure
#[doc(alias = "VkVideoGetMemoryPropertiesKHR")]
#[derive(Copy, Clone)]
#[repr(C)]
pub struct VideoGetMemoryPropertiesKHR {
    pub s_type: crate::vk1_0::StructureType,
    pub p_next: *const std::ffi::c_void,
    pub memory_bind_index: u32,
    pub p_memory_requirements: *mut crate::vk1_1::MemoryRequirements2,
}
impl VideoGetMemoryPropertiesKHR {
    pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::VIDEO_GET_MEMORY_PROPERTIES_KHR;
}
impl Default for VideoGetMemoryPropertiesKHR {
    fn default() -> Self {
        Self {
            s_type: Self::STRUCTURE_TYPE,
            p_next: std::ptr::null(),
            memory_bind_index: Default::default(),
            p_memory_requirements: std::ptr::null_mut(),
        }
    }
}
impl std::fmt::Debug for VideoGetMemoryPropertiesKHR {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.debug_struct("VideoGetMemoryPropertiesKHR")
            .field("s_type", &self.s_type)
            .field("p_next", &self.p_next)
            .field("memory_bind_index", &self.memory_bind_index)
            .field("p_memory_requirements", &self.p_memory_requirements)
            .finish()
    }
}
impl VideoGetMemoryPropertiesKHR {
    #[inline]
    pub fn into_builder<'a>(self) -> VideoGetMemoryPropertiesKHRBuilder<'a> {
        VideoGetMemoryPropertiesKHRBuilder(self, std::marker::PhantomData)
    }
}
#[derive(Copy, Clone)]
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoGetMemoryPropertiesKHR.html) · Builder of [`VideoGetMemoryPropertiesKHR`]
#[repr(transparent)]
pub struct VideoGetMemoryPropertiesKHRBuilder<'a>(
    VideoGetMemoryPropertiesKHR,
    std::marker::PhantomData<&'a ()>,
);
impl<'a> VideoGetMemoryPropertiesKHRBuilder<'a> {
    #[inline]
    pub fn new() -> VideoGetMemoryPropertiesKHRBuilder<'a> {
        VideoGetMemoryPropertiesKHRBuilder(Default::default(), std::marker::PhantomData)
    }
    #[inline]
    #[must_use]
    pub fn memory_bind_index(mut self, memory_bind_index: u32) -> Self {
        self.0.memory_bind_index = memory_bind_index as _;
        self
    }
    #[inline]
    #[must_use]
    pub fn memory_requirements(
        mut self,
        memory_requirements: &'a mut crate::vk1_1::MemoryRequirements2,
    ) -> Self {
        self.0.p_memory_requirements = memory_requirements as _;
        self
    }
    #[inline]
    /// Discards all lifetime information.
    /// Use the `Deref` and `DerefMut` implementations if possible.
    pub fn build_dangling(self) -> VideoGetMemoryPropertiesKHR {
        self.0
    }
}
impl<'a> std::default::Default for VideoGetMemoryPropertiesKHRBuilder<'a> {
    fn default() -> VideoGetMemoryPropertiesKHRBuilder<'a> {
        Self::new()
    }
}
impl<'a> std::fmt::Debug for VideoGetMemoryPropertiesKHRBuilder<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        std::fmt::Debug::fmt(&self.0, f)
    }
}
impl<'a> std::ops::Deref for VideoGetMemoryPropertiesKHRBuilder<'a> {
    type Target = VideoGetMemoryPropertiesKHR;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl<'a> std::ops::DerefMut for VideoGetMemoryPropertiesKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoBindMemoryKHR.html) · Structure
#[doc(alias = "VkVideoBindMemoryKHR")]
#[derive(Copy, Clone)]
#[repr(C)]
pub struct VideoBindMemoryKHR {
    pub s_type: crate::vk1_0::StructureType,
    pub p_next: *const std::ffi::c_void,
    pub memory_bind_index: u32,
    pub memory: crate::vk1_0::DeviceMemory,
    pub memory_offset: crate::vk1_0::DeviceSize,
    pub memory_size: crate::vk1_0::DeviceSize,
}
impl VideoBindMemoryKHR {
    pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::VIDEO_BIND_MEMORY_KHR;
}
impl Default for VideoBindMemoryKHR {
    fn default() -> Self {
        Self {
            s_type: Self::STRUCTURE_TYPE,
            p_next: std::ptr::null(),
            memory_bind_index: Default::default(),
            memory: Default::default(),
            memory_offset: Default::default(),
            memory_size: Default::default(),
        }
    }
}
impl std::fmt::Debug for VideoBindMemoryKHR {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.debug_struct("VideoBindMemoryKHR")
            .field("s_type", &self.s_type)
            .field("p_next", &self.p_next)
            .field("memory_bind_index", &self.memory_bind_index)
            .field("memory", &self.memory)
            .field("memory_offset", &self.memory_offset)
            .field("memory_size", &self.memory_size)
            .finish()
    }
}
impl VideoBindMemoryKHR {
    #[inline]
    pub fn into_builder<'a>(self) -> VideoBindMemoryKHRBuilder<'a> {
        VideoBindMemoryKHRBuilder(self, std::marker::PhantomData)
    }
}
#[derive(Copy, Clone)]
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoBindMemoryKHR.html) · Builder of [`VideoBindMemoryKHR`]
#[repr(transparent)]
pub struct VideoBindMemoryKHRBuilder<'a>(
    VideoBindMemoryKHR,
    std::marker::PhantomData<&'a ()>,
);
impl<'a> VideoBindMemoryKHRBuilder<'a> {
    #[inline]
    pub fn new() -> VideoBindMemoryKHRBuilder<'a> {
        VideoBindMemoryKHRBuilder(Default::default(), std::marker::PhantomData)
    }
    #[inline]
    #[must_use]
    pub fn memory_bind_index(mut self, memory_bind_index: u32) -> Self {
        self.0.memory_bind_index = memory_bind_index as _;
        self
    }
    #[inline]
    #[must_use]
    pub fn memory(mut self, memory: crate::vk1_0::DeviceMemory) -> Self {
        self.0.memory = memory as _;
        self
    }
    #[inline]
    #[must_use]
    pub fn memory_offset(mut self, memory_offset: crate::vk1_0::DeviceSize) -> Self {
        self.0.memory_offset = memory_offset as _;
        self
    }
    #[inline]
    #[must_use]
    pub fn memory_size(mut self, memory_size: crate::vk1_0::DeviceSize) -> Self {
        self.0.memory_size = memory_size as _;
        self
    }
    #[inline]
    /// Discards all lifetime information.
    /// Use the `Deref` and `DerefMut` implementations if possible.
    pub fn build_dangling(self) -> VideoBindMemoryKHR {
        self.0
    }
}
impl<'a> std::default::Default for VideoBindMemoryKHRBuilder<'a> {
    fn default() -> VideoBindMemoryKHRBuilder<'a> {
        Self::new()
    }
}
impl<'a> std::fmt::Debug for VideoBindMemoryKHRBuilder<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        std::fmt::Debug::fmt(&self.0, f)
    }
}
impl<'a> std::ops::Deref for VideoBindMemoryKHRBuilder<'a> {
    type Target = VideoBindMemoryKHR;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl<'a> std::ops::DerefMut for VideoBindMemoryKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoPictureResourceKHR.html) · Structure
#[doc(alias = "VkVideoPictureResourceKHR")]
#[derive(Copy, Clone)]
#[repr(C)]
pub struct VideoPictureResourceKHR {
    pub s_type: crate::vk1_0::StructureType,
    pub p_next: *const std::ffi::c_void,
    pub coded_offset: crate::vk1_0::Offset2D,
    pub coded_extent: crate::vk1_0::Extent2D,
    pub base_array_layer: u32,
    pub image_view_binding: crate::vk1_0::ImageView,
}
impl VideoPictureResourceKHR {
    pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::VIDEO_PICTURE_RESOURCE_KHR;
}
impl Default for VideoPictureResourceKHR {
    fn default() -> Self {
        Self {
            s_type: Self::STRUCTURE_TYPE,
            p_next: std::ptr::null(),
            coded_offset: Default::default(),
            coded_extent: Default::default(),
            base_array_layer: Default::default(),
            image_view_binding: Default::default(),
        }
    }
}
impl std::fmt::Debug for VideoPictureResourceKHR {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.debug_struct("VideoPictureResourceKHR")
            .field("s_type", &self.s_type)
            .field("p_next", &self.p_next)
            .field("coded_offset", &self.coded_offset)
            .field("coded_extent", &self.coded_extent)
            .field("base_array_layer", &self.base_array_layer)
            .field("image_view_binding", &self.image_view_binding)
            .finish()
    }
}
impl VideoPictureResourceKHR {
    #[inline]
    pub fn into_builder<'a>(self) -> VideoPictureResourceKHRBuilder<'a> {
        VideoPictureResourceKHRBuilder(self, std::marker::PhantomData)
    }
}
#[derive(Copy, Clone)]
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoPictureResourceKHR.html) · Builder of [`VideoPictureResourceKHR`]
#[repr(transparent)]
pub struct VideoPictureResourceKHRBuilder<'a>(
    VideoPictureResourceKHR,
    std::marker::PhantomData<&'a ()>,
);
impl<'a> VideoPictureResourceKHRBuilder<'a> {
    #[inline]
    pub fn new() -> VideoPictureResourceKHRBuilder<'a> {
        VideoPictureResourceKHRBuilder(Default::default(), std::marker::PhantomData)
    }
    #[inline]
    #[must_use]
    pub fn coded_offset(mut self, coded_offset: crate::vk1_0::Offset2D) -> Self {
        self.0.coded_offset = coded_offset as _;
        self
    }
    #[inline]
    #[must_use]
    pub fn coded_extent(mut self, coded_extent: crate::vk1_0::Extent2D) -> Self {
        self.0.coded_extent = coded_extent as _;
        self
    }
    #[inline]
    #[must_use]
    pub fn base_array_layer(mut self, base_array_layer: u32) -> Self {
        self.0.base_array_layer = base_array_layer as _;
        self
    }
    #[inline]
    #[must_use]
    pub fn image_view_binding(
        mut self,
        image_view_binding: crate::vk1_0::ImageView,
    ) -> Self {
        self.0.image_view_binding = image_view_binding as _;
        self
    }
    #[inline]
    /// Discards all lifetime information.
    /// Use the `Deref` and `DerefMut` implementations if possible.
    pub fn build_dangling(self) -> VideoPictureResourceKHR {
        self.0
    }
}
impl<'a> std::default::Default for VideoPictureResourceKHRBuilder<'a> {
    fn default() -> VideoPictureResourceKHRBuilder<'a> {
        Self::new()
    }
}
impl<'a> std::fmt::Debug for VideoPictureResourceKHRBuilder<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        std::fmt::Debug::fmt(&self.0, f)
    }
}
impl<'a> std::ops::Deref for VideoPictureResourceKHRBuilder<'a> {
    type Target = VideoPictureResourceKHR;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl<'a> std::ops::DerefMut for VideoPictureResourceKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoReferenceSlotKHR.html) · Structure
#[doc(alias = "VkVideoReferenceSlotKHR")]
#[derive(Copy, Clone)]
#[repr(C)]
pub struct VideoReferenceSlotKHR {
    pub s_type: crate::vk1_0::StructureType,
    pub p_next: *const std::ffi::c_void,
    pub slot_index: i8,
    pub p_picture_resource: *const crate::extensions::khr_video_queue::VideoPictureResourceKHR,
}
impl VideoReferenceSlotKHR {
    pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::VIDEO_REFERENCE_SLOT_KHR;
}
impl Default for VideoReferenceSlotKHR {
    fn default() -> Self {
        Self {
            s_type: Self::STRUCTURE_TYPE,
            p_next: std::ptr::null(),
            slot_index: Default::default(),
            p_picture_resource: std::ptr::null(),
        }
    }
}
impl std::fmt::Debug for VideoReferenceSlotKHR {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.debug_struct("VideoReferenceSlotKHR")
            .field("s_type", &self.s_type)
            .field("p_next", &self.p_next)
            .field("slot_index", &self.slot_index)
            .field("p_picture_resource", &self.p_picture_resource)
            .finish()
    }
}
impl VideoReferenceSlotKHR {
    #[inline]
    pub fn into_builder<'a>(self) -> VideoReferenceSlotKHRBuilder<'a> {
        VideoReferenceSlotKHRBuilder(self, std::marker::PhantomData)
    }
}
#[derive(Copy, Clone)]
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoReferenceSlotKHR.html) · Builder of [`VideoReferenceSlotKHR`]
#[repr(transparent)]
pub struct VideoReferenceSlotKHRBuilder<'a>(
    VideoReferenceSlotKHR,
    std::marker::PhantomData<&'a ()>,
);
impl<'a> VideoReferenceSlotKHRBuilder<'a> {
    #[inline]
    pub fn new() -> VideoReferenceSlotKHRBuilder<'a> {
        VideoReferenceSlotKHRBuilder(Default::default(), std::marker::PhantomData)
    }
    #[inline]
    #[must_use]
    pub fn slot_index(mut self, slot_index: i8) -> Self {
        self.0.slot_index = slot_index as _;
        self
    }
    #[inline]
    #[must_use]
    pub fn picture_resource(
        mut self,
        picture_resource: &'a crate::extensions::khr_video_queue::VideoPictureResourceKHR,
    ) -> Self {
        self.0.p_picture_resource = picture_resource as _;
        self
    }
    #[inline]
    /// Discards all lifetime information.
    /// Use the `Deref` and `DerefMut` implementations if possible.
    pub fn build_dangling(self) -> VideoReferenceSlotKHR {
        self.0
    }
}
impl<'a> std::default::Default for VideoReferenceSlotKHRBuilder<'a> {
    fn default() -> VideoReferenceSlotKHRBuilder<'a> {
        Self::new()
    }
}
impl<'a> std::fmt::Debug for VideoReferenceSlotKHRBuilder<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        std::fmt::Debug::fmt(&self.0, f)
    }
}
impl<'a> std::ops::Deref for VideoReferenceSlotKHRBuilder<'a> {
    type Target = VideoReferenceSlotKHR;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl<'a> std::ops::DerefMut for VideoReferenceSlotKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoSessionCreateInfoKHR.html) · Structure
#[doc(alias = "VkVideoSessionCreateInfoKHR")]
#[derive(Copy, Clone)]
#[repr(C)]
pub struct VideoSessionCreateInfoKHR {
    pub s_type: crate::vk1_0::StructureType,
    pub p_next: *const std::ffi::c_void,
    pub queue_family_index: u32,
    pub flags: crate::extensions::khr_video_queue::VideoSessionCreateFlagsKHR,
    pub p_video_profile: *const crate::extensions::khr_video_queue::VideoProfileKHR,
    pub picture_format: crate::vk1_0::Format,
    pub max_coded_extent: crate::vk1_0::Extent2D,
    pub reference_pictures_format: crate::vk1_0::Format,
    pub max_reference_pictures_slots_count: u32,
    pub max_reference_pictures_active_count: u32,
    pub p_std_header_version: *const crate::vk1_0::ExtensionProperties,
}
impl VideoSessionCreateInfoKHR {
    pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::VIDEO_SESSION_CREATE_INFO_KHR;
}
impl Default for VideoSessionCreateInfoKHR {
    fn default() -> Self {
        Self {
            s_type: Self::STRUCTURE_TYPE,
            p_next: std::ptr::null(),
            queue_family_index: Default::default(),
            flags: Default::default(),
            p_video_profile: std::ptr::null(),
            picture_format: Default::default(),
            max_coded_extent: Default::default(),
            reference_pictures_format: Default::default(),
            max_reference_pictures_slots_count: Default::default(),
            max_reference_pictures_active_count: Default::default(),
            p_std_header_version: std::ptr::null(),
        }
    }
}
impl std::fmt::Debug for VideoSessionCreateInfoKHR {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.debug_struct("VideoSessionCreateInfoKHR")
            .field("s_type", &self.s_type)
            .field("p_next", &self.p_next)
            .field("queue_family_index", &self.queue_family_index)
            .field("flags", &self.flags)
            .field("p_video_profile", &self.p_video_profile)
            .field("picture_format", &self.picture_format)
            .field("max_coded_extent", &self.max_coded_extent)
            .field("reference_pictures_format", &self.reference_pictures_format)
            .field(
                "max_reference_pictures_slots_count",
                &self.max_reference_pictures_slots_count,
            )
            .field(
                "max_reference_pictures_active_count",
                &self.max_reference_pictures_active_count,
            )
            .field("p_std_header_version", &self.p_std_header_version)
            .finish()
    }
}
impl VideoSessionCreateInfoKHR {
    #[inline]
    pub fn into_builder<'a>(self) -> VideoSessionCreateInfoKHRBuilder<'a> {
        VideoSessionCreateInfoKHRBuilder(self, std::marker::PhantomData)
    }
}
#[derive(Copy, Clone)]
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoSessionCreateInfoKHR.html) · Builder of [`VideoSessionCreateInfoKHR`]
#[repr(transparent)]
pub struct VideoSessionCreateInfoKHRBuilder<'a>(
    VideoSessionCreateInfoKHR,
    std::marker::PhantomData<&'a ()>,
);
impl<'a> VideoSessionCreateInfoKHRBuilder<'a> {
    #[inline]
    pub fn new() -> VideoSessionCreateInfoKHRBuilder<'a> {
        VideoSessionCreateInfoKHRBuilder(Default::default(), std::marker::PhantomData)
    }
    #[inline]
    #[must_use]
    pub fn queue_family_index(mut self, queue_family_index: u32) -> Self {
        self.0.queue_family_index = queue_family_index as _;
        self
    }
    #[inline]
    #[must_use]
    pub fn flags(
        mut self,
        flags: crate::extensions::khr_video_queue::VideoSessionCreateFlagsKHR,
    ) -> Self {
        self.0.flags = flags as _;
        self
    }
    #[inline]
    #[must_use]
    pub fn video_profile(
        mut self,
        video_profile: &'a crate::extensions::khr_video_queue::VideoProfileKHR,
    ) -> Self {
        self.0.p_video_profile = video_profile as _;
        self
    }
    #[inline]
    #[must_use]
    pub fn picture_format(mut self, picture_format: crate::vk1_0::Format) -> Self {
        self.0.picture_format = picture_format as _;
        self
    }
    #[inline]
    #[must_use]
    pub fn max_coded_extent(mut self, max_coded_extent: crate::vk1_0::Extent2D) -> Self {
        self.0.max_coded_extent = max_coded_extent as _;
        self
    }
    #[inline]
    #[must_use]
    pub fn reference_pictures_format(
        mut self,
        reference_pictures_format: crate::vk1_0::Format,
    ) -> Self {
        self.0.reference_pictures_format = reference_pictures_format as _;
        self
    }
    #[inline]
    #[must_use]
    pub fn max_reference_pictures_slots_count(
        mut self,
        max_reference_pictures_slots_count: u32,
    ) -> Self {
        self
            .0
            .max_reference_pictures_slots_count = max_reference_pictures_slots_count
            as _;
        self
    }
    #[inline]
    #[must_use]
    pub fn max_reference_pictures_active_count(
        mut self,
        max_reference_pictures_active_count: u32,
    ) -> Self {
        self
            .0
            .max_reference_pictures_active_count = max_reference_pictures_active_count
            as _;
        self
    }
    #[inline]
    #[must_use]
    pub fn std_header_version(
        mut self,
        std_header_version: &'a crate::vk1_0::ExtensionProperties,
    ) -> Self {
        self.0.p_std_header_version = std_header_version as _;
        self
    }
    #[inline]
    /// Discards all lifetime information.
    /// Use the `Deref` and `DerefMut` implementations if possible.
    pub fn build_dangling(self) -> VideoSessionCreateInfoKHR {
        self.0
    }
}
impl<'a> std::default::Default for VideoSessionCreateInfoKHRBuilder<'a> {
    fn default() -> VideoSessionCreateInfoKHRBuilder<'a> {
        Self::new()
    }
}
impl<'a> std::fmt::Debug for VideoSessionCreateInfoKHRBuilder<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        std::fmt::Debug::fmt(&self.0, f)
    }
}
impl<'a> std::ops::Deref for VideoSessionCreateInfoKHRBuilder<'a> {
    type Target = VideoSessionCreateInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl<'a> std::ops::DerefMut for VideoSessionCreateInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoSessionParametersCreateInfoKHR.html) · Structure
#[doc(alias = "VkVideoSessionParametersCreateInfoKHR")]
#[derive(Copy, Clone)]
#[repr(C)]
pub struct VideoSessionParametersCreateInfoKHR {
    pub s_type: crate::vk1_0::StructureType,
    pub p_next: *const std::ffi::c_void,
    pub video_session_parameters_template: crate::extensions::khr_video_queue::VideoSessionParametersKHR,
    pub video_session: crate::extensions::khr_video_queue::VideoSessionKHR,
}
impl VideoSessionParametersCreateInfoKHR {
    pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR;
}
impl Default for VideoSessionParametersCreateInfoKHR {
    fn default() -> Self {
        Self {
            s_type: Self::STRUCTURE_TYPE,
            p_next: std::ptr::null(),
            video_session_parameters_template: Default::default(),
            video_session: Default::default(),
        }
    }
}
impl std::fmt::Debug for VideoSessionParametersCreateInfoKHR {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.debug_struct("VideoSessionParametersCreateInfoKHR")
            .field("s_type", &self.s_type)
            .field("p_next", &self.p_next)
            .field(
                "video_session_parameters_template",
                &self.video_session_parameters_template,
            )
            .field("video_session", &self.video_session)
            .finish()
    }
}
impl VideoSessionParametersCreateInfoKHR {
    #[inline]
    pub fn into_builder<'a>(self) -> VideoSessionParametersCreateInfoKHRBuilder<'a> {
        VideoSessionParametersCreateInfoKHRBuilder(self, std::marker::PhantomData)
    }
}
#[derive(Copy, Clone)]
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoSessionParametersCreateInfoKHR.html) · Builder of [`VideoSessionParametersCreateInfoKHR`]
#[repr(transparent)]
pub struct VideoSessionParametersCreateInfoKHRBuilder<'a>(
    VideoSessionParametersCreateInfoKHR,
    std::marker::PhantomData<&'a ()>,
);
impl<'a> VideoSessionParametersCreateInfoKHRBuilder<'a> {
    #[inline]
    pub fn new() -> VideoSessionParametersCreateInfoKHRBuilder<'a> {
        VideoSessionParametersCreateInfoKHRBuilder(
            Default::default(),
            std::marker::PhantomData,
        )
    }
    #[inline]
    #[must_use]
    pub fn video_session_parameters_template(
        mut self,
        video_session_parameters_template: crate::extensions::khr_video_queue::VideoSessionParametersKHR,
    ) -> Self {
        self
            .0
            .video_session_parameters_template = video_session_parameters_template as _;
        self
    }
    #[inline]
    #[must_use]
    pub fn video_session(
        mut self,
        video_session: crate::extensions::khr_video_queue::VideoSessionKHR,
    ) -> Self {
        self.0.video_session = video_session as _;
        self
    }
    #[inline]
    /// Discards all lifetime information.
    /// Use the `Deref` and `DerefMut` implementations if possible.
    pub fn build_dangling(self) -> VideoSessionParametersCreateInfoKHR {
        self.0
    }
}
impl<'a> std::default::Default for VideoSessionParametersCreateInfoKHRBuilder<'a> {
    fn default() -> VideoSessionParametersCreateInfoKHRBuilder<'a> {
        Self::new()
    }
}
impl<'a> std::fmt::Debug for VideoSessionParametersCreateInfoKHRBuilder<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        std::fmt::Debug::fmt(&self.0, f)
    }
}
impl<'a> std::ops::Deref for VideoSessionParametersCreateInfoKHRBuilder<'a> {
    type Target = VideoSessionParametersCreateInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl<'a> std::ops::DerefMut for VideoSessionParametersCreateInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoSessionParametersUpdateInfoKHR.html) · Structure
#[doc(alias = "VkVideoSessionParametersUpdateInfoKHR")]
#[derive(Copy, Clone)]
#[repr(C)]
pub struct VideoSessionParametersUpdateInfoKHR {
    pub s_type: crate::vk1_0::StructureType,
    pub p_next: *const std::ffi::c_void,
    pub update_sequence_count: u32,
}
impl VideoSessionParametersUpdateInfoKHR {
    pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR;
}
impl Default for VideoSessionParametersUpdateInfoKHR {
    fn default() -> Self {
        Self {
            s_type: Self::STRUCTURE_TYPE,
            p_next: std::ptr::null(),
            update_sequence_count: Default::default(),
        }
    }
}
impl std::fmt::Debug for VideoSessionParametersUpdateInfoKHR {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.debug_struct("VideoSessionParametersUpdateInfoKHR")
            .field("s_type", &self.s_type)
            .field("p_next", &self.p_next)
            .field("update_sequence_count", &self.update_sequence_count)
            .finish()
    }
}
impl VideoSessionParametersUpdateInfoKHR {
    #[inline]
    pub fn into_builder<'a>(self) -> VideoSessionParametersUpdateInfoKHRBuilder<'a> {
        VideoSessionParametersUpdateInfoKHRBuilder(self, std::marker::PhantomData)
    }
}
#[derive(Copy, Clone)]
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoSessionParametersUpdateInfoKHR.html) · Builder of [`VideoSessionParametersUpdateInfoKHR`]
#[repr(transparent)]
pub struct VideoSessionParametersUpdateInfoKHRBuilder<'a>(
    VideoSessionParametersUpdateInfoKHR,
    std::marker::PhantomData<&'a ()>,
);
impl<'a> VideoSessionParametersUpdateInfoKHRBuilder<'a> {
    #[inline]
    pub fn new() -> VideoSessionParametersUpdateInfoKHRBuilder<'a> {
        VideoSessionParametersUpdateInfoKHRBuilder(
            Default::default(),
            std::marker::PhantomData,
        )
    }
    #[inline]
    #[must_use]
    pub fn update_sequence_count(mut self, update_sequence_count: u32) -> Self {
        self.0.update_sequence_count = update_sequence_count as _;
        self
    }
    #[inline]
    /// Discards all lifetime information.
    /// Use the `Deref` and `DerefMut` implementations if possible.
    pub fn build_dangling(self) -> VideoSessionParametersUpdateInfoKHR {
        self.0
    }
}
impl<'a> std::default::Default for VideoSessionParametersUpdateInfoKHRBuilder<'a> {
    fn default() -> VideoSessionParametersUpdateInfoKHRBuilder<'a> {
        Self::new()
    }
}
impl<'a> std::fmt::Debug for VideoSessionParametersUpdateInfoKHRBuilder<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        std::fmt::Debug::fmt(&self.0, f)
    }
}
impl<'a> std::ops::Deref for VideoSessionParametersUpdateInfoKHRBuilder<'a> {
    type Target = VideoSessionParametersUpdateInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl<'a> std::ops::DerefMut for VideoSessionParametersUpdateInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoBeginCodingInfoKHR.html) · Structure
#[doc(alias = "VkVideoBeginCodingInfoKHR")]
#[derive(Copy, Clone)]
#[repr(C)]
pub struct VideoBeginCodingInfoKHR {
    pub s_type: crate::vk1_0::StructureType,
    pub p_next: *const std::ffi::c_void,
    pub flags: crate::extensions::khr_video_queue::VideoBeginCodingFlagsKHR,
    pub codec_quality_preset: crate::extensions::khr_video_queue::VideoCodingQualityPresetFlagsKHR,
    pub video_session: crate::extensions::khr_video_queue::VideoSessionKHR,
    pub video_session_parameters: crate::extensions::khr_video_queue::VideoSessionParametersKHR,
    pub reference_slot_count: u32,
    pub p_reference_slots: *const crate::extensions::khr_video_queue::VideoReferenceSlotKHR,
}
impl VideoBeginCodingInfoKHR {
    pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::VIDEO_BEGIN_CODING_INFO_KHR;
}
impl Default for VideoBeginCodingInfoKHR {
    fn default() -> Self {
        Self {
            s_type: Self::STRUCTURE_TYPE,
            p_next: std::ptr::null(),
            flags: Default::default(),
            codec_quality_preset: Default::default(),
            video_session: Default::default(),
            video_session_parameters: Default::default(),
            reference_slot_count: Default::default(),
            p_reference_slots: std::ptr::null(),
        }
    }
}
impl std::fmt::Debug for VideoBeginCodingInfoKHR {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.debug_struct("VideoBeginCodingInfoKHR")
            .field("s_type", &self.s_type)
            .field("p_next", &self.p_next)
            .field("flags", &self.flags)
            .field("codec_quality_preset", &self.codec_quality_preset)
            .field("video_session", &self.video_session)
            .field("video_session_parameters", &self.video_session_parameters)
            .field("reference_slot_count", &self.reference_slot_count)
            .field("p_reference_slots", &self.p_reference_slots)
            .finish()
    }
}
impl VideoBeginCodingInfoKHR {
    #[inline]
    pub fn into_builder<'a>(self) -> VideoBeginCodingInfoKHRBuilder<'a> {
        VideoBeginCodingInfoKHRBuilder(self, std::marker::PhantomData)
    }
}
#[derive(Copy, Clone)]
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoBeginCodingInfoKHR.html) · Builder of [`VideoBeginCodingInfoKHR`]
#[repr(transparent)]
pub struct VideoBeginCodingInfoKHRBuilder<'a>(
    VideoBeginCodingInfoKHR,
    std::marker::PhantomData<&'a ()>,
);
impl<'a> VideoBeginCodingInfoKHRBuilder<'a> {
    #[inline]
    pub fn new() -> VideoBeginCodingInfoKHRBuilder<'a> {
        VideoBeginCodingInfoKHRBuilder(Default::default(), std::marker::PhantomData)
    }
    #[inline]
    #[must_use]
    pub fn flags(
        mut self,
        flags: crate::extensions::khr_video_queue::VideoBeginCodingFlagsKHR,
    ) -> Self {
        self.0.flags = flags as _;
        self
    }
    #[inline]
    #[must_use]
    pub fn codec_quality_preset(
        mut self,
        codec_quality_preset: crate::extensions::khr_video_queue::VideoCodingQualityPresetFlagsKHR,
    ) -> Self {
        self.0.codec_quality_preset = codec_quality_preset as _;
        self
    }
    #[inline]
    #[must_use]
    pub fn video_session(
        mut self,
        video_session: crate::extensions::khr_video_queue::VideoSessionKHR,
    ) -> Self {
        self.0.video_session = video_session as _;
        self
    }
    #[inline]
    #[must_use]
    pub fn video_session_parameters(
        mut self,
        video_session_parameters: crate::extensions::khr_video_queue::VideoSessionParametersKHR,
    ) -> Self {
        self.0.video_session_parameters = video_session_parameters as _;
        self
    }
    #[inline]
    #[must_use]
    pub fn reference_slots(
        mut self,
        reference_slots: &'a [crate::extensions::khr_video_queue::VideoReferenceSlotKHRBuilder],
    ) -> Self {
        self.0.p_reference_slots = reference_slots.as_ptr() as _;
        self.0.reference_slot_count = reference_slots.len() as _;
        self
    }
    #[inline]
    /// Discards all lifetime information.
    /// Use the `Deref` and `DerefMut` implementations if possible.
    pub fn build_dangling(self) -> VideoBeginCodingInfoKHR {
        self.0
    }
}
impl<'a> std::default::Default for VideoBeginCodingInfoKHRBuilder<'a> {
    fn default() -> VideoBeginCodingInfoKHRBuilder<'a> {
        Self::new()
    }
}
impl<'a> std::fmt::Debug for VideoBeginCodingInfoKHRBuilder<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        std::fmt::Debug::fmt(&self.0, f)
    }
}
impl<'a> std::ops::Deref for VideoBeginCodingInfoKHRBuilder<'a> {
    type Target = VideoBeginCodingInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl<'a> std::ops::DerefMut for VideoBeginCodingInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEndCodingInfoKHR.html) · Structure
#[doc(alias = "VkVideoEndCodingInfoKHR")]
#[derive(Copy, Clone)]
#[repr(C)]
pub struct VideoEndCodingInfoKHR {
    pub s_type: crate::vk1_0::StructureType,
    pub p_next: *const std::ffi::c_void,
    pub flags: crate::extensions::khr_video_queue::VideoEndCodingFlagsKHR,
}
impl VideoEndCodingInfoKHR {
    pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::VIDEO_END_CODING_INFO_KHR;
}
impl Default for VideoEndCodingInfoKHR {
    fn default() -> Self {
        Self {
            s_type: Self::STRUCTURE_TYPE,
            p_next: std::ptr::null(),
            flags: Default::default(),
        }
    }
}
impl std::fmt::Debug for VideoEndCodingInfoKHR {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.debug_struct("VideoEndCodingInfoKHR")
            .field("s_type", &self.s_type)
            .field("p_next", &self.p_next)
            .field("flags", &self.flags)
            .finish()
    }
}
impl VideoEndCodingInfoKHR {
    #[inline]
    pub fn into_builder<'a>(self) -> VideoEndCodingInfoKHRBuilder<'a> {
        VideoEndCodingInfoKHRBuilder(self, std::marker::PhantomData)
    }
}
#[derive(Copy, Clone)]
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEndCodingInfoKHR.html) · Builder of [`VideoEndCodingInfoKHR`]
#[repr(transparent)]
pub struct VideoEndCodingInfoKHRBuilder<'a>(
    VideoEndCodingInfoKHR,
    std::marker::PhantomData<&'a ()>,
);
impl<'a> VideoEndCodingInfoKHRBuilder<'a> {
    #[inline]
    pub fn new() -> VideoEndCodingInfoKHRBuilder<'a> {
        VideoEndCodingInfoKHRBuilder(Default::default(), std::marker::PhantomData)
    }
    #[inline]
    #[must_use]
    pub fn flags(
        mut self,
        flags: crate::extensions::khr_video_queue::VideoEndCodingFlagsKHR,
    ) -> Self {
        self.0.flags = flags as _;
        self
    }
    #[inline]
    /// Discards all lifetime information.
    /// Use the `Deref` and `DerefMut` implementations if possible.
    pub fn build_dangling(self) -> VideoEndCodingInfoKHR {
        self.0
    }
}
impl<'a> std::default::Default for VideoEndCodingInfoKHRBuilder<'a> {
    fn default() -> VideoEndCodingInfoKHRBuilder<'a> {
        Self::new()
    }
}
impl<'a> std::fmt::Debug for VideoEndCodingInfoKHRBuilder<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        std::fmt::Debug::fmt(&self.0, f)
    }
}
impl<'a> std::ops::Deref for VideoEndCodingInfoKHRBuilder<'a> {
    type Target = VideoEndCodingInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl<'a> std::ops::DerefMut for VideoEndCodingInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoCodingControlInfoKHR.html) · Structure
#[doc(alias = "VkVideoCodingControlInfoKHR")]
#[derive(Copy, Clone)]
#[repr(C)]
pub struct VideoCodingControlInfoKHR {
    pub s_type: crate::vk1_0::StructureType,
    pub p_next: *const std::ffi::c_void,
    pub flags: crate::extensions::khr_video_queue::VideoCodingControlFlagsKHR,
}
impl VideoCodingControlInfoKHR {
    pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::VIDEO_CODING_CONTROL_INFO_KHR;
}
impl Default for VideoCodingControlInfoKHR {
    fn default() -> Self {
        Self {
            s_type: Self::STRUCTURE_TYPE,
            p_next: std::ptr::null(),
            flags: Default::default(),
        }
    }
}
impl std::fmt::Debug for VideoCodingControlInfoKHR {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.debug_struct("VideoCodingControlInfoKHR")
            .field("s_type", &self.s_type)
            .field("p_next", &self.p_next)
            .field("flags", &self.flags)
            .finish()
    }
}
impl VideoCodingControlInfoKHR {
    #[inline]
    pub fn into_builder<'a>(self) -> VideoCodingControlInfoKHRBuilder<'a> {
        VideoCodingControlInfoKHRBuilder(self, std::marker::PhantomData)
    }
}
#[derive(Copy, Clone)]
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoCodingControlInfoKHR.html) · Builder of [`VideoCodingControlInfoKHR`]
#[repr(transparent)]
pub struct VideoCodingControlInfoKHRBuilder<'a>(
    VideoCodingControlInfoKHR,
    std::marker::PhantomData<&'a ()>,
);
impl<'a> VideoCodingControlInfoKHRBuilder<'a> {
    #[inline]
    pub fn new() -> VideoCodingControlInfoKHRBuilder<'a> {
        VideoCodingControlInfoKHRBuilder(Default::default(), std::marker::PhantomData)
    }
    #[inline]
    #[must_use]
    pub fn flags(
        mut self,
        flags: crate::extensions::khr_video_queue::VideoCodingControlFlagsKHR,
    ) -> Self {
        self.0.flags = flags as _;
        self
    }
    #[inline]
    /// Discards all lifetime information.
    /// Use the `Deref` and `DerefMut` implementations if possible.
    pub fn build_dangling(self) -> VideoCodingControlInfoKHR {
        self.0
    }
}
impl<'a> std::default::Default for VideoCodingControlInfoKHRBuilder<'a> {
    fn default() -> VideoCodingControlInfoKHRBuilder<'a> {
        Self::new()
    }
}
impl<'a> std::fmt::Debug for VideoCodingControlInfoKHRBuilder<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        std::fmt::Debug::fmt(&self.0, f)
    }
}
impl<'a> std::ops::Deref for VideoCodingControlInfoKHRBuilder<'a> {
    type Target = VideoCodingControlInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl<'a> std::ops::DerefMut for VideoCodingControlInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}
///Provided by [`crate::extensions::khr_video_queue`]
impl crate::InstanceLoader {
    #[inline]
    #[track_caller]
    ///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceVideoCapabilitiesKHR.html) · Function
    #[doc(alias = "vkGetPhysicalDeviceVideoCapabilitiesKHR")]
    pub unsafe fn get_physical_device_video_capabilities_khr(
        &self,
        physical_device: crate::vk1_0::PhysicalDevice,
        video_profile: &crate::extensions::khr_video_queue::VideoProfileKHR,
        capabilities: &mut crate::extensions::khr_video_queue::VideoCapabilitiesKHR,
    ) -> crate::utils::VulkanResult<()> {
        let _function = self
            .get_physical_device_video_capabilities_khr
            .expect(crate::NOT_LOADED_MESSAGE);
        let _return = _function(
            physical_device as _,
            video_profile as _,
            capabilities as _,
        );
        crate::utils::VulkanResult::new(_return, ())
    }
    #[inline]
    #[track_caller]
    ///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceVideoFormatPropertiesKHR.html) · Function
    #[doc(alias = "vkGetPhysicalDeviceVideoFormatPropertiesKHR")]
    pub unsafe fn get_physical_device_video_format_properties_khr(
        &self,
        physical_device: crate::vk1_0::PhysicalDevice,
        video_format_info: &crate::extensions::khr_video_queue::PhysicalDeviceVideoFormatInfoKHR,
        video_format_property_count: Option<u32>,
        video_format_properties_callback: impl FnMut(
            &mut crate::SmallVec<
                crate::extensions::khr_video_queue::VideoFormatPropertiesKHR,
            >,
        ) -> (),
    ) -> crate::utils::VulkanResult<
            crate::SmallVec<crate::extensions::khr_video_queue::VideoFormatPropertiesKHR>,
        > {
        let _function = self
            .get_physical_device_video_format_properties_khr
            .expect(crate::NOT_LOADED_MESSAGE);
        let mut video_format_property_count = match video_format_property_count {
            Some(v) => v,
            None => {
                let mut v = Default::default();
                _function(
                    physical_device as _,
                    video_format_info as _,
                    &mut v,
                    std::ptr::null_mut(),
                );
                v
            }
        };
        let mut video_format_properties = crate::SmallVec::from_elem(
            Default::default(),
            video_format_property_count as _,
        );
        let mut _callback = video_format_properties_callback;
        _callback(&mut video_format_properties);
        let _return = _function(
            physical_device as _,
            video_format_info as _,
            &mut video_format_property_count,
            video_format_properties.as_mut_ptr(),
        );
        crate::utils::VulkanResult::new(_return, video_format_properties)
    }
}
///Provided by [`crate::extensions::khr_video_queue`]
impl crate::DeviceLoader {
    #[inline]
    #[track_caller]
    ///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateVideoSessionKHR.html) · Function
    #[doc(alias = "vkCreateVideoSessionKHR")]
    pub unsafe fn create_video_session_khr(
        &self,
        create_info: &crate::extensions::khr_video_queue::VideoSessionCreateInfoKHR,
        allocator: Option<&crate::vk1_0::AllocationCallbacks>,
    ) -> crate::utils::VulkanResult<
            crate::extensions::khr_video_queue::VideoSessionKHR,
        > {
        let _function = self.create_video_session_khr.expect(crate::NOT_LOADED_MESSAGE);
        let mut video_session = Default::default();
        let _return = _function(
            self.handle,
            create_info as _,
            match allocator {
                Some(v) => v,
                None => std::ptr::null(),
            },
            &mut video_session,
        );
        crate::utils::VulkanResult::new(_return, video_session)
    }
    #[inline]
    #[track_caller]
    ///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkDestroyVideoSessionKHR.html) · Function
    #[doc(alias = "vkDestroyVideoSessionKHR")]
    pub unsafe fn destroy_video_session_khr(
        &self,
        video_session: crate::extensions::khr_video_queue::VideoSessionKHR,
        allocator: Option<&crate::vk1_0::AllocationCallbacks>,
    ) -> () {
        let _function = self.destroy_video_session_khr.expect(crate::NOT_LOADED_MESSAGE);
        let _return = _function(
            self.handle,
            video_session as _,
            match allocator {
                Some(v) => v,
                None => std::ptr::null(),
            },
        );
        ()
    }
    #[inline]
    #[track_caller]
    ///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateVideoSessionParametersKHR.html) · Function
    #[doc(alias = "vkCreateVideoSessionParametersKHR")]
    pub unsafe fn create_video_session_parameters_khr(
        &self,
        create_info: &crate::extensions::khr_video_queue::VideoSessionParametersCreateInfoKHR,
        allocator: Option<&crate::vk1_0::AllocationCallbacks>,
    ) -> crate::utils::VulkanResult<
            crate::extensions::khr_video_queue::VideoSessionParametersKHR,
        > {
        let _function = self
            .create_video_session_parameters_khr
            .expect(crate::NOT_LOADED_MESSAGE);
        let mut video_session_parameters = Default::default();
        let _return = _function(
            self.handle,
            create_info as _,
            match allocator {
                Some(v) => v,
                None => std::ptr::null(),
            },
            &mut video_session_parameters,
        );
        crate::utils::VulkanResult::new(_return, video_session_parameters)
    }
    #[inline]
    #[track_caller]
    ///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkUpdateVideoSessionParametersKHR.html) · Function
    #[doc(alias = "vkUpdateVideoSessionParametersKHR")]
    pub unsafe fn update_video_session_parameters_khr(
        &self,
        video_session_parameters: crate::extensions::khr_video_queue::VideoSessionParametersKHR,
        update_info: &crate::extensions::khr_video_queue::VideoSessionParametersUpdateInfoKHR,
    ) -> crate::utils::VulkanResult<()> {
        let _function = self
            .update_video_session_parameters_khr
            .expect(crate::NOT_LOADED_MESSAGE);
        let _return = _function(
            self.handle,
            video_session_parameters as _,
            update_info as _,
        );
        crate::utils::VulkanResult::new(_return, ())
    }
    #[inline]
    #[track_caller]
    ///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkDestroyVideoSessionParametersKHR.html) · Function
    #[doc(alias = "vkDestroyVideoSessionParametersKHR")]
    pub unsafe fn destroy_video_session_parameters_khr(
        &self,
        video_session_parameters: crate::extensions::khr_video_queue::VideoSessionParametersKHR,
        allocator: Option<&crate::vk1_0::AllocationCallbacks>,
    ) -> () {
        let _function = self
            .destroy_video_session_parameters_khr
            .expect(crate::NOT_LOADED_MESSAGE);
        let _return = _function(
            self.handle,
            video_session_parameters as _,
            match allocator {
                Some(v) => v,
                None => std::ptr::null(),
            },
        );
        ()
    }
    #[inline]
    #[track_caller]
    ///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetVideoSessionMemoryRequirementsKHR.html) · Function
    #[doc(alias = "vkGetVideoSessionMemoryRequirementsKHR")]
    pub unsafe fn get_video_session_memory_requirements_khr(
        &self,
        video_session: crate::extensions::khr_video_queue::VideoSessionKHR,
        video_session_memory_requirements_count: Option<u32>,
        video_session_memory_requirements_callback: impl FnMut(
            &mut crate::SmallVec<
                crate::extensions::khr_video_queue::VideoGetMemoryPropertiesKHR,
            >,
        ) -> (),
    ) -> crate::utils::VulkanResult<
            crate::SmallVec<
                crate::extensions::khr_video_queue::VideoGetMemoryPropertiesKHR,
            >,
        > {
        let _function = self
            .get_video_session_memory_requirements_khr
            .expect(crate::NOT_LOADED_MESSAGE);
        let mut video_session_memory_requirements_count = match video_session_memory_requirements_count {
            Some(v) => v,
            None => {
                let mut v = Default::default();
                _function(self.handle, video_session as _, &mut v, std::ptr::null_mut());
                v
            }
        };
        let mut video_session_memory_requirements = crate::SmallVec::from_elem(
            Default::default(),
            video_session_memory_requirements_count as _,
        );
        let mut _callback = video_session_memory_requirements_callback;
        _callback(&mut video_session_memory_requirements);
        let _return = _function(
            self.handle,
            video_session as _,
            &mut video_session_memory_requirements_count,
            video_session_memory_requirements.as_mut_ptr(),
        );
        crate::utils::VulkanResult::new(_return, video_session_memory_requirements)
    }
    #[inline]
    #[track_caller]
    ///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkBindVideoSessionMemoryKHR.html) · Function
    #[doc(alias = "vkBindVideoSessionMemoryKHR")]
    pub unsafe fn bind_video_session_memory_khr(
        &self,
        video_session: crate::extensions::khr_video_queue::VideoSessionKHR,
        video_session_bind_memories: &[crate::extensions::khr_video_queue::VideoBindMemoryKHRBuilder],
    ) -> crate::utils::VulkanResult<()> {
        let _function = self
            .bind_video_session_memory_khr
            .expect(crate::NOT_LOADED_MESSAGE);
        let video_session_bind_memory_count = video_session_bind_memories.len();
        let _return = _function(
            self.handle,
            video_session as _,
            video_session_bind_memory_count as _,
            video_session_bind_memories.as_ptr() as _,
        );
        crate::utils::VulkanResult::new(_return, ())
    }
    #[inline]
    #[track_caller]
    ///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdBeginVideoCodingKHR.html) · Function
    #[doc(alias = "vkCmdBeginVideoCodingKHR")]
    pub unsafe fn cmd_begin_video_coding_khr(
        &self,
        command_buffer: crate::vk1_0::CommandBuffer,
        begin_info: &crate::extensions::khr_video_queue::VideoBeginCodingInfoKHR,
    ) -> () {
        let _function = self
            .cmd_begin_video_coding_khr
            .expect(crate::NOT_LOADED_MESSAGE);
        let _return = _function(command_buffer as _, begin_info as _);
        ()
    }
    #[inline]
    #[track_caller]
    ///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdControlVideoCodingKHR.html) · Function
    #[doc(alias = "vkCmdControlVideoCodingKHR")]
    pub unsafe fn cmd_control_video_coding_khr(
        &self,
        command_buffer: crate::vk1_0::CommandBuffer,
        coding_control_info: &crate::extensions::khr_video_queue::VideoCodingControlInfoKHR,
    ) -> () {
        let _function = self
            .cmd_control_video_coding_khr
            .expect(crate::NOT_LOADED_MESSAGE);
        let _return = _function(command_buffer as _, coding_control_info as _);
        ()
    }
    #[inline]
    #[track_caller]
    ///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdEndVideoCodingKHR.html) · Function
    #[doc(alias = "vkCmdEndVideoCodingKHR")]
    pub unsafe fn cmd_end_video_coding_khr(
        &self,
        command_buffer: crate::vk1_0::CommandBuffer,
        end_coding_info: &crate::extensions::khr_video_queue::VideoEndCodingInfoKHR,
    ) -> () {
        let _function = self.cmd_end_video_coding_khr.expect(crate::NOT_LOADED_MESSAGE);
        let _return = _function(command_buffer as _, end_coding_info as _);
        ()
    }
}