kazan 0.3.9+1.4.359

//! <https://registry.khronos.org/vulkan/specs/latest/man/html/VK_KHR_video_encode_h265.html>
#![allow(unused_imports)]
use crate::{vk::Result as VkResult, vk::*, *};
use core::ffi::{CStr, c_char, c_int, c_void};
use core::mem::transmute;
use core::ptr;

pub const EXTENSION_NAME: &CStr = c"VK_KHR_video_encode_h265";

pub(super) mod defs {
    #![allow(non_camel_case_types, unused_imports)]
    use crate::{vk::*, *};
    use core::ffi::{CStr, c_char, c_int, c_void};
    use core::fmt;
    use core::marker::PhantomData;
    use core::ptr;

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265CapabilitiesKHR.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct VideoEncodeH265CapabilitiesKHR<'a> {
        pub s_type: StructureType,
        pub p_next: *mut c_void,
        pub flags: VideoEncodeH265CapabilityFlagsKHR,
        pub max_level_idc: StdVideoH265LevelIdc,
        pub max_slice_segment_count: u32,
        pub max_tiles: Extent2D,
        pub ctb_sizes: VideoEncodeH265CtbSizeFlagsKHR,
        pub transform_block_sizes: VideoEncodeH265TransformBlockSizeFlagsKHR,
        pub max_p_picture_l0_reference_count: u32,
        pub max_b_picture_l0_reference_count: u32,
        pub max_l1_reference_count: u32,
        pub max_sub_layer_count: u32,
        pub expect_dyadic_temporal_sub_layer_pattern: Bool32,
        pub min_qp: i32,
        pub max_qp: i32,
        pub prefers_gop_remaining_frames: Bool32,
        pub requires_gop_remaining_frames: Bool32,
        pub std_syntax_flags: VideoEncodeH265StdFlagsKHR,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for VideoEncodeH265CapabilitiesKHR<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("VideoEncodeH265CapabilitiesKHR")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field("flags", &self.flags)
                .field("max_level_idc", &self.max_level_idc)
                .field("max_slice_segment_count", &self.max_slice_segment_count)
                .field("max_tiles", &self.max_tiles)
                .field("ctb_sizes", &self.ctb_sizes)
                .field("transform_block_sizes", &self.transform_block_sizes)
                .field(
                    "max_p_picture_l0_reference_count",
                    &self.max_p_picture_l0_reference_count,
                )
                .field(
                    "max_b_picture_l0_reference_count",
                    &self.max_b_picture_l0_reference_count,
                )
                .field("max_l1_reference_count", &self.max_l1_reference_count)
                .field("max_sub_layer_count", &self.max_sub_layer_count)
                .field(
                    "expect_dyadic_temporal_sub_layer_pattern",
                    &self.expect_dyadic_temporal_sub_layer_pattern,
                )
                .field("min_qp", &self.min_qp)
                .field("max_qp", &self.max_qp)
                .field(
                    "prefers_gop_remaining_frames",
                    &self.prefers_gop_remaining_frames,
                )
                .field(
                    "requires_gop_remaining_frames",
                    &self.requires_gop_remaining_frames,
                )
                .field("std_syntax_flags", &self.std_syntax_flags)
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for VideoEncodeH265CapabilitiesKHR<'a> {
        const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H265_CAPABILITIES_KHR;
    }

    unsafe impl Extends<VideoCapabilitiesKHR<'_>> for VideoEncodeH265CapabilitiesKHR<'_> {}

    impl Default for VideoEncodeH265CapabilitiesKHR<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null_mut(),
                flags: Default::default(),
                max_level_idc: Default::default(),
                max_slice_segment_count: Default::default(),
                max_tiles: Default::default(),
                ctb_sizes: Default::default(),
                transform_block_sizes: Default::default(),
                max_p_picture_l0_reference_count: Default::default(),
                max_b_picture_l0_reference_count: Default::default(),
                max_l1_reference_count: Default::default(),
                max_sub_layer_count: Default::default(),
                expect_dyadic_temporal_sub_layer_pattern: Default::default(),
                min_qp: Default::default(),
                max_qp: Default::default(),
                prefers_gop_remaining_frames: Default::default(),
                requires_gop_remaining_frames: Default::default(),
                std_syntax_flags: Default::default(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> VideoEncodeH265CapabilitiesKHR<'a> {
        #[inline]
        pub fn flags(mut self, flags: VideoEncodeH265CapabilityFlagsKHR) -> Self {
            self.flags = flags;
            self
        }

        #[inline]
        pub fn max_level_idc(mut self, max_level_idc: StdVideoH265LevelIdc) -> Self {
            self.max_level_idc = max_level_idc;
            self
        }

        #[inline]
        pub fn max_slice_segment_count(mut self, max_slice_segment_count: u32) -> Self {
            self.max_slice_segment_count = max_slice_segment_count;
            self
        }

        #[inline]
        pub fn max_tiles(mut self, max_tiles: Extent2D) -> Self {
            self.max_tiles = max_tiles;
            self
        }

        #[inline]
        pub fn ctb_sizes(mut self, ctb_sizes: VideoEncodeH265CtbSizeFlagsKHR) -> Self {
            self.ctb_sizes = ctb_sizes;
            self
        }

        #[inline]
        pub fn transform_block_sizes(
            mut self,
            transform_block_sizes: VideoEncodeH265TransformBlockSizeFlagsKHR,
        ) -> Self {
            self.transform_block_sizes = transform_block_sizes;
            self
        }

        #[inline]
        pub fn max_p_picture_l0_reference_count(
            mut self,
            max_p_picture_l0_reference_count: u32,
        ) -> Self {
            self.max_p_picture_l0_reference_count = max_p_picture_l0_reference_count;
            self
        }

        #[inline]
        pub fn max_b_picture_l0_reference_count(
            mut self,
            max_b_picture_l0_reference_count: u32,
        ) -> Self {
            self.max_b_picture_l0_reference_count = max_b_picture_l0_reference_count;
            self
        }

        #[inline]
        pub fn max_l1_reference_count(mut self, max_l1_reference_count: u32) -> Self {
            self.max_l1_reference_count = max_l1_reference_count;
            self
        }

        #[inline]
        pub fn max_sub_layer_count(mut self, max_sub_layer_count: u32) -> Self {
            self.max_sub_layer_count = max_sub_layer_count;
            self
        }

        #[inline]
        pub fn expect_dyadic_temporal_sub_layer_pattern(
            mut self,
            expect_dyadic_temporal_sub_layer_pattern: bool,
        ) -> Self {
            self.expect_dyadic_temporal_sub_layer_pattern =
                expect_dyadic_temporal_sub_layer_pattern.into();
            self
        }

        #[inline]
        pub fn min_qp(mut self, min_qp: i32) -> Self {
            self.min_qp = min_qp;
            self
        }

        #[inline]
        pub fn max_qp(mut self, max_qp: i32) -> Self {
            self.max_qp = max_qp;
            self
        }

        #[inline]
        pub fn prefers_gop_remaining_frames(mut self, prefers_gop_remaining_frames: bool) -> Self {
            self.prefers_gop_remaining_frames = prefers_gop_remaining_frames.into();
            self
        }

        #[inline]
        pub fn requires_gop_remaining_frames(
            mut self,
            requires_gop_remaining_frames: bool,
        ) -> Self {
            self.requires_gop_remaining_frames = requires_gop_remaining_frames.into();
            self
        }

        #[inline]
        pub fn std_syntax_flags(mut self, std_syntax_flags: VideoEncodeH265StdFlagsKHR) -> Self {
            self.std_syntax_flags = std_syntax_flags;
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265QualityLevelPropertiesKHR.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct VideoEncodeH265QualityLevelPropertiesKHR<'a> {
        pub s_type: StructureType,
        pub p_next: *mut c_void,
        pub preferred_rate_control_flags: VideoEncodeH265RateControlFlagsKHR,
        pub preferred_gop_frame_count: u32,
        pub preferred_idr_period: u32,
        pub preferred_consecutive_b_frame_count: u32,
        pub preferred_sub_layer_count: u32,
        pub preferred_constant_qp: VideoEncodeH265QpKHR,
        pub preferred_max_l0_reference_count: u32,
        pub preferred_max_l1_reference_count: u32,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for VideoEncodeH265QualityLevelPropertiesKHR<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("VideoEncodeH265QualityLevelPropertiesKHR")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field(
                    "preferred_rate_control_flags",
                    &self.preferred_rate_control_flags,
                )
                .field("preferred_gop_frame_count", &self.preferred_gop_frame_count)
                .field("preferred_idr_period", &self.preferred_idr_period)
                .field(
                    "preferred_consecutive_b_frame_count",
                    &self.preferred_consecutive_b_frame_count,
                )
                .field("preferred_sub_layer_count", &self.preferred_sub_layer_count)
                .field("preferred_constant_qp", &self.preferred_constant_qp)
                .field(
                    "preferred_max_l0_reference_count",
                    &self.preferred_max_l0_reference_count,
                )
                .field(
                    "preferred_max_l1_reference_count",
                    &self.preferred_max_l1_reference_count,
                )
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for VideoEncodeH265QualityLevelPropertiesKHR<'a> {
        const STRUCTURE_TYPE: StructureType =
            StructureType::VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR;
    }

    unsafe impl Extends<VideoEncodeQualityLevelPropertiesKHR<'_>>
        for VideoEncodeH265QualityLevelPropertiesKHR<'_>
    {
    }

    impl Default for VideoEncodeH265QualityLevelPropertiesKHR<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null_mut(),
                preferred_rate_control_flags: Default::default(),
                preferred_gop_frame_count: Default::default(),
                preferred_idr_period: Default::default(),
                preferred_consecutive_b_frame_count: Default::default(),
                preferred_sub_layer_count: Default::default(),
                preferred_constant_qp: Default::default(),
                preferred_max_l0_reference_count: Default::default(),
                preferred_max_l1_reference_count: Default::default(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> VideoEncodeH265QualityLevelPropertiesKHR<'a> {
        #[inline]
        pub fn preferred_rate_control_flags(
            mut self,
            preferred_rate_control_flags: VideoEncodeH265RateControlFlagsKHR,
        ) -> Self {
            self.preferred_rate_control_flags = preferred_rate_control_flags;
            self
        }

        #[inline]
        pub fn preferred_gop_frame_count(mut self, preferred_gop_frame_count: u32) -> Self {
            self.preferred_gop_frame_count = preferred_gop_frame_count;
            self
        }

        #[inline]
        pub fn preferred_idr_period(mut self, preferred_idr_period: u32) -> Self {
            self.preferred_idr_period = preferred_idr_period;
            self
        }

        #[inline]
        pub fn preferred_consecutive_b_frame_count(
            mut self,
            preferred_consecutive_b_frame_count: u32,
        ) -> Self {
            self.preferred_consecutive_b_frame_count = preferred_consecutive_b_frame_count;
            self
        }

        #[inline]
        pub fn preferred_sub_layer_count(mut self, preferred_sub_layer_count: u32) -> Self {
            self.preferred_sub_layer_count = preferred_sub_layer_count;
            self
        }

        #[inline]
        pub fn preferred_constant_qp(
            mut self,
            preferred_constant_qp: VideoEncodeH265QpKHR,
        ) -> Self {
            self.preferred_constant_qp = preferred_constant_qp;
            self
        }

        #[inline]
        pub fn preferred_max_l0_reference_count(
            mut self,
            preferred_max_l0_reference_count: u32,
        ) -> Self {
            self.preferred_max_l0_reference_count = preferred_max_l0_reference_count;
            self
        }

        #[inline]
        pub fn preferred_max_l1_reference_count(
            mut self,
            preferred_max_l1_reference_count: u32,
        ) -> Self {
            self.preferred_max_l1_reference_count = preferred_max_l1_reference_count;
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265SessionCreateInfoKHR.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct VideoEncodeH265SessionCreateInfoKHR<'a> {
        pub s_type: StructureType,
        pub p_next: *const c_void,
        pub use_max_level_idc: Bool32,
        pub max_level_idc: StdVideoH265LevelIdc,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for VideoEncodeH265SessionCreateInfoKHR<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("VideoEncodeH265SessionCreateInfoKHR")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field("use_max_level_idc", &self.use_max_level_idc)
                .field("max_level_idc", &self.max_level_idc)
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for VideoEncodeH265SessionCreateInfoKHR<'a> {
        const STRUCTURE_TYPE: StructureType =
            StructureType::VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR;
    }

    unsafe impl Extends<VideoSessionCreateInfoKHR<'_>> for VideoEncodeH265SessionCreateInfoKHR<'_> {}

    impl Default for VideoEncodeH265SessionCreateInfoKHR<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null(),
                use_max_level_idc: Default::default(),
                max_level_idc: Default::default(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> VideoEncodeH265SessionCreateInfoKHR<'a> {
        #[inline]
        pub fn use_max_level_idc(mut self, use_max_level_idc: bool) -> Self {
            self.use_max_level_idc = use_max_level_idc.into();
            self
        }

        #[inline]
        pub fn max_level_idc(mut self, max_level_idc: StdVideoH265LevelIdc) -> Self {
            self.max_level_idc = max_level_idc;
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265SessionParametersAddInfoKHR.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct VideoEncodeH265SessionParametersAddInfoKHR<'a> {
        pub s_type: StructureType,
        pub p_next: *const c_void,
        pub std_vps_count: u32,
        pub p_std_vp_ss: *const StdVideoH265VideoParameterSet<'a>,
        pub std_sps_count: u32,
        pub p_std_sp_ss: *const StdVideoH265SequenceParameterSet<'a>,
        pub std_pps_count: u32,
        pub p_std_pp_ss: *const StdVideoH265PictureParameterSet<'a>,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for VideoEncodeH265SessionParametersAddInfoKHR<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("VideoEncodeH265SessionParametersAddInfoKHR")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field("std_vps_count", &self.std_vps_count)
                .field("p_std_vp_ss", &self.p_std_vp_ss)
                .field("std_sps_count", &self.std_sps_count)
                .field("p_std_sp_ss", &self.p_std_sp_ss)
                .field("std_pps_count", &self.std_pps_count)
                .field("p_std_pp_ss", &self.p_std_pp_ss)
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for VideoEncodeH265SessionParametersAddInfoKHR<'a> {
        const STRUCTURE_TYPE: StructureType =
            StructureType::VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR;
    }

    unsafe impl Extends<VideoSessionParametersUpdateInfoKHR<'_>>
        for VideoEncodeH265SessionParametersAddInfoKHR<'_>
    {
    }

    impl Default for VideoEncodeH265SessionParametersAddInfoKHR<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null(),
                std_vps_count: Default::default(),
                p_std_vp_ss: ptr::null(),
                std_sps_count: Default::default(),
                p_std_sp_ss: ptr::null(),
                std_pps_count: Default::default(),
                p_std_pp_ss: ptr::null(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> VideoEncodeH265SessionParametersAddInfoKHR<'a> {
        #[inline]
        pub fn std_vp_ss(mut self, std_vp_ss: &'a [StdVideoH265VideoParameterSet<'_>]) -> Self {
            self.std_vps_count = std_vp_ss.len().try_into().unwrap();
            self.p_std_vp_ss = std_vp_ss.as_ptr() as _;
            self
        }

        #[inline]
        pub fn std_sp_ss(mut self, std_sp_ss: &'a [StdVideoH265SequenceParameterSet<'_>]) -> Self {
            self.std_sps_count = std_sp_ss.len().try_into().unwrap();
            self.p_std_sp_ss = std_sp_ss.as_ptr() as _;
            self
        }

        #[inline]
        pub fn std_pp_ss(mut self, std_pp_ss: &'a [StdVideoH265PictureParameterSet<'_>]) -> Self {
            self.std_pps_count = std_pp_ss.len().try_into().unwrap();
            self.p_std_pp_ss = std_pp_ss.as_ptr() as _;
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265SessionParametersCreateInfoKHR.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct VideoEncodeH265SessionParametersCreateInfoKHR<'a> {
        pub s_type: StructureType,
        pub p_next: *const c_void,
        pub max_std_vps_count: u32,
        pub max_std_sps_count: u32,
        pub max_std_pps_count: u32,
        pub p_parameters_add_info: *const VideoEncodeH265SessionParametersAddInfoKHR<'a>,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for VideoEncodeH265SessionParametersCreateInfoKHR<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("VideoEncodeH265SessionParametersCreateInfoKHR")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field("max_std_vps_count", &self.max_std_vps_count)
                .field("max_std_sps_count", &self.max_std_sps_count)
                .field("max_std_pps_count", &self.max_std_pps_count)
                .field("p_parameters_add_info", &self.p_parameters_add_info)
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for VideoEncodeH265SessionParametersCreateInfoKHR<'a> {
        const STRUCTURE_TYPE: StructureType =
            StructureType::VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR;
    }

    unsafe impl Extends<VideoSessionParametersCreateInfoKHR<'_>>
        for VideoEncodeH265SessionParametersCreateInfoKHR<'_>
    {
    }

    impl Default for VideoEncodeH265SessionParametersCreateInfoKHR<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null(),
                max_std_vps_count: Default::default(),
                max_std_sps_count: Default::default(),
                max_std_pps_count: Default::default(),
                p_parameters_add_info: ptr::null(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> VideoEncodeH265SessionParametersCreateInfoKHR<'a> {
        #[inline]
        pub fn max_std_vps_count(mut self, max_std_vps_count: u32) -> Self {
            self.max_std_vps_count = max_std_vps_count;
            self
        }

        #[inline]
        pub fn max_std_sps_count(mut self, max_std_sps_count: u32) -> Self {
            self.max_std_sps_count = max_std_sps_count;
            self
        }

        #[inline]
        pub fn max_std_pps_count(mut self, max_std_pps_count: u32) -> Self {
            self.max_std_pps_count = max_std_pps_count;
            self
        }

        #[inline]
        pub fn parameters_add_info(
            mut self,
            parameters_add_info: &'a VideoEncodeH265SessionParametersAddInfoKHR<'a>,
        ) -> Self {
            self.p_parameters_add_info = parameters_add_info;
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265SessionParametersGetInfoKHR.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct VideoEncodeH265SessionParametersGetInfoKHR<'a> {
        pub s_type: StructureType,
        pub p_next: *const c_void,
        pub write_std_vps: Bool32,
        pub write_std_sps: Bool32,
        pub write_std_pps: Bool32,
        pub std_vps_id: u32,
        pub std_sps_id: u32,
        pub std_pps_id: u32,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for VideoEncodeH265SessionParametersGetInfoKHR<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("VideoEncodeH265SessionParametersGetInfoKHR")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field("write_std_vps", &self.write_std_vps)
                .field("write_std_sps", &self.write_std_sps)
                .field("write_std_pps", &self.write_std_pps)
                .field("std_vps_id", &self.std_vps_id)
                .field("std_sps_id", &self.std_sps_id)
                .field("std_pps_id", &self.std_pps_id)
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for VideoEncodeH265SessionParametersGetInfoKHR<'a> {
        const STRUCTURE_TYPE: StructureType =
            StructureType::VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR;
    }

    unsafe impl Extends<VideoEncodeSessionParametersGetInfoKHR<'_>>
        for VideoEncodeH265SessionParametersGetInfoKHR<'_>
    {
    }

    impl Default for VideoEncodeH265SessionParametersGetInfoKHR<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null(),
                write_std_vps: Default::default(),
                write_std_sps: Default::default(),
                write_std_pps: Default::default(),
                std_vps_id: Default::default(),
                std_sps_id: Default::default(),
                std_pps_id: Default::default(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> VideoEncodeH265SessionParametersGetInfoKHR<'a> {
        #[inline]
        pub fn write_std_vps(mut self, write_std_vps: bool) -> Self {
            self.write_std_vps = write_std_vps.into();
            self
        }

        #[inline]
        pub fn write_std_sps(mut self, write_std_sps: bool) -> Self {
            self.write_std_sps = write_std_sps.into();
            self
        }

        #[inline]
        pub fn write_std_pps(mut self, write_std_pps: bool) -> Self {
            self.write_std_pps = write_std_pps.into();
            self
        }

        #[inline]
        pub fn std_vps_id(mut self, std_vps_id: u32) -> Self {
            self.std_vps_id = std_vps_id;
            self
        }

        #[inline]
        pub fn std_sps_id(mut self, std_sps_id: u32) -> Self {
            self.std_sps_id = std_sps_id;
            self
        }

        #[inline]
        pub fn std_pps_id(mut self, std_pps_id: u32) -> Self {
            self.std_pps_id = std_pps_id;
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265SessionParametersFeedbackInfoKHR.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct VideoEncodeH265SessionParametersFeedbackInfoKHR<'a> {
        pub s_type: StructureType,
        pub p_next: *mut c_void,
        pub has_std_vps_overrides: Bool32,
        pub has_std_sps_overrides: Bool32,
        pub has_std_pps_overrides: Bool32,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for VideoEncodeH265SessionParametersFeedbackInfoKHR<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("VideoEncodeH265SessionParametersFeedbackInfoKHR")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field("has_std_vps_overrides", &self.has_std_vps_overrides)
                .field("has_std_sps_overrides", &self.has_std_sps_overrides)
                .field("has_std_pps_overrides", &self.has_std_pps_overrides)
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for VideoEncodeH265SessionParametersFeedbackInfoKHR<'a> {
        const STRUCTURE_TYPE: StructureType =
            StructureType::VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR;
    }

    unsafe impl Extends<VideoEncodeSessionParametersFeedbackInfoKHR<'_>>
        for VideoEncodeH265SessionParametersFeedbackInfoKHR<'_>
    {
    }

    impl Default for VideoEncodeH265SessionParametersFeedbackInfoKHR<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null_mut(),
                has_std_vps_overrides: Default::default(),
                has_std_sps_overrides: Default::default(),
                has_std_pps_overrides: Default::default(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> VideoEncodeH265SessionParametersFeedbackInfoKHR<'a> {
        #[inline]
        pub fn has_std_vps_overrides(mut self, has_std_vps_overrides: bool) -> Self {
            self.has_std_vps_overrides = has_std_vps_overrides.into();
            self
        }

        #[inline]
        pub fn has_std_sps_overrides(mut self, has_std_sps_overrides: bool) -> Self {
            self.has_std_sps_overrides = has_std_sps_overrides.into();
            self
        }

        #[inline]
        pub fn has_std_pps_overrides(mut self, has_std_pps_overrides: bool) -> Self {
            self.has_std_pps_overrides = has_std_pps_overrides.into();
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265PictureInfoKHR.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct VideoEncodeH265PictureInfoKHR<'a> {
        pub s_type: StructureType,
        pub p_next: *const c_void,
        pub nalu_slice_segment_entry_count: u32,
        pub p_nalu_slice_segment_entries: *const VideoEncodeH265NaluSliceSegmentInfoKHR<'a>,
        pub p_std_picture_info: *const StdVideoEncodeH265PictureInfo<'a>,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for VideoEncodeH265PictureInfoKHR<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("VideoEncodeH265PictureInfoKHR")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field(
                    "nalu_slice_segment_entry_count",
                    &self.nalu_slice_segment_entry_count,
                )
                .field(
                    "p_nalu_slice_segment_entries",
                    &self.p_nalu_slice_segment_entries,
                )
                .field("p_std_picture_info", &self.p_std_picture_info)
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for VideoEncodeH265PictureInfoKHR<'a> {
        const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H265_PICTURE_INFO_KHR;
    }

    unsafe impl Extends<VideoEncodeInfoKHR<'_>> for VideoEncodeH265PictureInfoKHR<'_> {}

    impl Default for VideoEncodeH265PictureInfoKHR<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null(),
                nalu_slice_segment_entry_count: Default::default(),
                p_nalu_slice_segment_entries: ptr::null(),
                p_std_picture_info: ptr::null(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> VideoEncodeH265PictureInfoKHR<'a> {
        #[inline]
        pub fn nalu_slice_segment_entries(
            mut self,
            nalu_slice_segment_entries: &'a [VideoEncodeH265NaluSliceSegmentInfoKHR<'_>],
        ) -> Self {
            self.nalu_slice_segment_entry_count =
                nalu_slice_segment_entries.len().try_into().unwrap();
            self.p_nalu_slice_segment_entries = nalu_slice_segment_entries.as_ptr() as _;
            self
        }

        #[inline]
        pub fn std_picture_info(
            mut self,
            std_picture_info: &'a StdVideoEncodeH265PictureInfo<'a>,
        ) -> Self {
            self.p_std_picture_info = std_picture_info;
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265NaluSliceSegmentInfoKHR.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct VideoEncodeH265NaluSliceSegmentInfoKHR<'a> {
        pub s_type: StructureType,
        pub p_next: *const c_void,
        pub constant_qp: i32,
        pub p_std_slice_segment_header: *const StdVideoEncodeH265SliceSegmentHeader<'a>,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for VideoEncodeH265NaluSliceSegmentInfoKHR<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("VideoEncodeH265NaluSliceSegmentInfoKHR")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field("constant_qp", &self.constant_qp)
                .field(
                    "p_std_slice_segment_header",
                    &self.p_std_slice_segment_header,
                )
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for VideoEncodeH265NaluSliceSegmentInfoKHR<'a> {
        const STRUCTURE_TYPE: StructureType =
            StructureType::VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_KHR;
    }

    impl Default for VideoEncodeH265NaluSliceSegmentInfoKHR<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null(),
                constant_qp: Default::default(),
                p_std_slice_segment_header: ptr::null(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> VideoEncodeH265NaluSliceSegmentInfoKHR<'a> {
        #[inline]
        pub fn constant_qp(mut self, constant_qp: i32) -> Self {
            self.constant_qp = constant_qp;
            self
        }

        #[inline]
        pub fn std_slice_segment_header(
            mut self,
            std_slice_segment_header: &'a StdVideoEncodeH265SliceSegmentHeader<'a>,
        ) -> Self {
            self.p_std_slice_segment_header = std_slice_segment_header;
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265RateControlInfoKHR.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct VideoEncodeH265RateControlInfoKHR<'a> {
        pub s_type: StructureType,
        pub p_next: *const c_void,
        pub flags: VideoEncodeH265RateControlFlagsKHR,
        pub gop_frame_count: u32,
        pub idr_period: u32,
        pub consecutive_b_frame_count: u32,
        pub sub_layer_count: u32,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for VideoEncodeH265RateControlInfoKHR<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("VideoEncodeH265RateControlInfoKHR")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field("flags", &self.flags)
                .field("gop_frame_count", &self.gop_frame_count)
                .field("idr_period", &self.idr_period)
                .field("consecutive_b_frame_count", &self.consecutive_b_frame_count)
                .field("sub_layer_count", &self.sub_layer_count)
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for VideoEncodeH265RateControlInfoKHR<'a> {
        const STRUCTURE_TYPE: StructureType =
            StructureType::VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR;
    }

    unsafe impl Extends<VideoCodingControlInfoKHR<'_>> for VideoEncodeH265RateControlInfoKHR<'_> {}
    unsafe impl Extends<VideoBeginCodingInfoKHR<'_>> for VideoEncodeH265RateControlInfoKHR<'_> {}

    impl Default for VideoEncodeH265RateControlInfoKHR<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null(),
                flags: Default::default(),
                gop_frame_count: Default::default(),
                idr_period: Default::default(),
                consecutive_b_frame_count: Default::default(),
                sub_layer_count: Default::default(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> VideoEncodeH265RateControlInfoKHR<'a> {
        #[inline]
        pub fn flags(mut self, flags: VideoEncodeH265RateControlFlagsKHR) -> Self {
            self.flags = flags;
            self
        }

        #[inline]
        pub fn gop_frame_count(mut self, gop_frame_count: u32) -> Self {
            self.gop_frame_count = gop_frame_count;
            self
        }

        #[inline]
        pub fn idr_period(mut self, idr_period: u32) -> Self {
            self.idr_period = idr_period;
            self
        }

        #[inline]
        pub fn consecutive_b_frame_count(mut self, consecutive_b_frame_count: u32) -> Self {
            self.consecutive_b_frame_count = consecutive_b_frame_count;
            self
        }

        #[inline]
        pub fn sub_layer_count(mut self, sub_layer_count: u32) -> Self {
            self.sub_layer_count = sub_layer_count;
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265QpKHR.html>
    #[repr(C)]
    #[cfg_attr(feature = "debug", derive(Debug))]
    #[derive(Copy, Clone, Default)]
    #[must_use]
    pub struct VideoEncodeH265QpKHR {
        pub qp_i: i32,
        pub qp_p: i32,
        pub qp_b: i32,
    }

    impl VideoEncodeH265QpKHR {
        #[inline]
        pub fn qp_i(mut self, qp_i: i32) -> Self {
            self.qp_i = qp_i;
            self
        }

        #[inline]
        pub fn qp_p(mut self, qp_p: i32) -> Self {
            self.qp_p = qp_p;
            self
        }

        #[inline]
        pub fn qp_b(mut self, qp_b: i32) -> Self {
            self.qp_b = qp_b;
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265FrameSizeKHR.html>
    #[repr(C)]
    #[cfg_attr(feature = "debug", derive(Debug))]
    #[derive(Copy, Clone, Default)]
    #[must_use]
    pub struct VideoEncodeH265FrameSizeKHR {
        pub frame_i_size: u32,
        pub frame_p_size: u32,
        pub frame_b_size: u32,
    }

    impl VideoEncodeH265FrameSizeKHR {
        #[inline]
        pub fn frame_i_size(mut self, frame_i_size: u32) -> Self {
            self.frame_i_size = frame_i_size;
            self
        }

        #[inline]
        pub fn frame_p_size(mut self, frame_p_size: u32) -> Self {
            self.frame_p_size = frame_p_size;
            self
        }

        #[inline]
        pub fn frame_b_size(mut self, frame_b_size: u32) -> Self {
            self.frame_b_size = frame_b_size;
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265GopRemainingFrameInfoKHR.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct VideoEncodeH265GopRemainingFrameInfoKHR<'a> {
        pub s_type: StructureType,
        pub p_next: *const c_void,
        pub use_gop_remaining_frames: Bool32,
        pub gop_remaining_i: u32,
        pub gop_remaining_p: u32,
        pub gop_remaining_b: u32,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for VideoEncodeH265GopRemainingFrameInfoKHR<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("VideoEncodeH265GopRemainingFrameInfoKHR")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field("use_gop_remaining_frames", &self.use_gop_remaining_frames)
                .field("gop_remaining_i", &self.gop_remaining_i)
                .field("gop_remaining_p", &self.gop_remaining_p)
                .field("gop_remaining_b", &self.gop_remaining_b)
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for VideoEncodeH265GopRemainingFrameInfoKHR<'a> {
        const STRUCTURE_TYPE: StructureType =
            StructureType::VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR;
    }

    unsafe impl Extends<VideoBeginCodingInfoKHR<'_>> for VideoEncodeH265GopRemainingFrameInfoKHR<'_> {}

    impl Default for VideoEncodeH265GopRemainingFrameInfoKHR<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null(),
                use_gop_remaining_frames: Default::default(),
                gop_remaining_i: Default::default(),
                gop_remaining_p: Default::default(),
                gop_remaining_b: Default::default(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> VideoEncodeH265GopRemainingFrameInfoKHR<'a> {
        #[inline]
        pub fn use_gop_remaining_frames(mut self, use_gop_remaining_frames: bool) -> Self {
            self.use_gop_remaining_frames = use_gop_remaining_frames.into();
            self
        }

        #[inline]
        pub fn gop_remaining_i(mut self, gop_remaining_i: u32) -> Self {
            self.gop_remaining_i = gop_remaining_i;
            self
        }

        #[inline]
        pub fn gop_remaining_p(mut self, gop_remaining_p: u32) -> Self {
            self.gop_remaining_p = gop_remaining_p;
            self
        }

        #[inline]
        pub fn gop_remaining_b(mut self, gop_remaining_b: u32) -> Self {
            self.gop_remaining_b = gop_remaining_b;
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265RateControlLayerInfoKHR.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct VideoEncodeH265RateControlLayerInfoKHR<'a> {
        pub s_type: StructureType,
        pub p_next: *const c_void,
        pub use_min_qp: Bool32,
        pub min_qp: VideoEncodeH265QpKHR,
        pub use_max_qp: Bool32,
        pub max_qp: VideoEncodeH265QpKHR,
        pub use_max_frame_size: Bool32,
        pub max_frame_size: VideoEncodeH265FrameSizeKHR,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for VideoEncodeH265RateControlLayerInfoKHR<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("VideoEncodeH265RateControlLayerInfoKHR")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field("use_min_qp", &self.use_min_qp)
                .field("min_qp", &self.min_qp)
                .field("use_max_qp", &self.use_max_qp)
                .field("max_qp", &self.max_qp)
                .field("use_max_frame_size", &self.use_max_frame_size)
                .field("max_frame_size", &self.max_frame_size)
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for VideoEncodeH265RateControlLayerInfoKHR<'a> {
        const STRUCTURE_TYPE: StructureType =
            StructureType::VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR;
    }

    unsafe impl Extends<VideoEncodeRateControlLayerInfoKHR<'_>>
        for VideoEncodeH265RateControlLayerInfoKHR<'_>
    {
    }

    impl Default for VideoEncodeH265RateControlLayerInfoKHR<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null(),
                use_min_qp: Default::default(),
                min_qp: Default::default(),
                use_max_qp: Default::default(),
                max_qp: Default::default(),
                use_max_frame_size: Default::default(),
                max_frame_size: Default::default(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> VideoEncodeH265RateControlLayerInfoKHR<'a> {
        #[inline]
        pub fn use_min_qp(mut self, use_min_qp: bool) -> Self {
            self.use_min_qp = use_min_qp.into();
            self
        }

        #[inline]
        pub fn min_qp(mut self, min_qp: VideoEncodeH265QpKHR) -> Self {
            self.min_qp = min_qp;
            self
        }

        #[inline]
        pub fn use_max_qp(mut self, use_max_qp: bool) -> Self {
            self.use_max_qp = use_max_qp.into();
            self
        }

        #[inline]
        pub fn max_qp(mut self, max_qp: VideoEncodeH265QpKHR) -> Self {
            self.max_qp = max_qp;
            self
        }

        #[inline]
        pub fn use_max_frame_size(mut self, use_max_frame_size: bool) -> Self {
            self.use_max_frame_size = use_max_frame_size.into();
            self
        }

        #[inline]
        pub fn max_frame_size(mut self, max_frame_size: VideoEncodeH265FrameSizeKHR) -> Self {
            self.max_frame_size = max_frame_size;
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265ProfileInfoKHR.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct VideoEncodeH265ProfileInfoKHR<'a> {
        pub s_type: StructureType,
        pub p_next: *const c_void,
        pub std_profile_idc: StdVideoH265ProfileIdc,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for VideoEncodeH265ProfileInfoKHR<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("VideoEncodeH265ProfileInfoKHR")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field("std_profile_idc", &self.std_profile_idc)
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for VideoEncodeH265ProfileInfoKHR<'a> {
        const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H265_PROFILE_INFO_KHR;
    }

    unsafe impl Extends<VideoProfileInfoKHR<'_>> for VideoEncodeH265ProfileInfoKHR<'_> {}
    unsafe impl Extends<QueryPoolCreateInfo<'_>> for VideoEncodeH265ProfileInfoKHR<'_> {}

    impl Default for VideoEncodeH265ProfileInfoKHR<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null(),
                std_profile_idc: Default::default(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> VideoEncodeH265ProfileInfoKHR<'a> {
        #[inline]
        pub fn std_profile_idc(mut self, std_profile_idc: StdVideoH265ProfileIdc) -> Self {
            self.std_profile_idc = std_profile_idc;
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265DpbSlotInfoKHR.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct VideoEncodeH265DpbSlotInfoKHR<'a> {
        pub s_type: StructureType,
        pub p_next: *const c_void,
        pub p_std_reference_info: *const StdVideoEncodeH265ReferenceInfo,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for VideoEncodeH265DpbSlotInfoKHR<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("VideoEncodeH265DpbSlotInfoKHR")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field("p_std_reference_info", &self.p_std_reference_info)
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for VideoEncodeH265DpbSlotInfoKHR<'a> {
        const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR;
    }

    unsafe impl Extends<VideoReferenceSlotInfoKHR<'_>> for VideoEncodeH265DpbSlotInfoKHR<'_> {}

    impl Default for VideoEncodeH265DpbSlotInfoKHR<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null(),
                p_std_reference_info: ptr::null(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> VideoEncodeH265DpbSlotInfoKHR<'a> {
        #[inline]
        pub fn std_reference_info(
            mut self,
            std_reference_info: &'a StdVideoEncodeH265ReferenceInfo,
        ) -> Self {
            self.p_std_reference_info = std_reference_info;
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265CapabilityFlagsKHR.html>
    #[repr(transparent)]
    #[derive(Copy, Clone, PartialEq, Eq, Hash)]
    pub struct VideoEncodeH265CapabilityFlagsKHR(Flags);
    vk_bitflags_wrapped!(
        VideoEncodeH265CapabilityFlagsKHR,
        Flags,
        VideoEncodeH265CapabilityFlagBitsKHR
    );

    impl fmt::Debug for VideoEncodeH265CapabilityFlagsKHR {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            const KNOWN: &[(Flags, &str)] = &[
                (
                    VideoEncodeH265CapabilityFlagBitsKHR::HRD_COMPLIANCE_KHR.0,
                    "HRD_COMPLIANCE_KHR",
                ),
                (
                    VideoEncodeH265CapabilityFlagBitsKHR::PREDICTION_WEIGHT_TABLE_GENERATED_KHR.0,
                    "PREDICTION_WEIGHT_TABLE_GENERATED_KHR",
                ),
                (
                    VideoEncodeH265CapabilityFlagBitsKHR::ROW_UNALIGNED_SLICE_SEGMENT_KHR.0,
                    "ROW_UNALIGNED_SLICE_SEGMENT_KHR",
                ),
                (
                    VideoEncodeH265CapabilityFlagBitsKHR::DIFFERENT_SLICE_SEGMENT_TYPE_KHR.0,
                    "DIFFERENT_SLICE_SEGMENT_TYPE_KHR",
                ),
                (
                    VideoEncodeH265CapabilityFlagBitsKHR::B_FRAME_IN_L0_LIST_KHR.0,
                    "B_FRAME_IN_L0_LIST_KHR",
                ),
                (
                    VideoEncodeH265CapabilityFlagBitsKHR::B_FRAME_IN_L1_LIST_KHR.0,
                    "B_FRAME_IN_L1_LIST_KHR",
                ),
                (
                    VideoEncodeH265CapabilityFlagBitsKHR::PER_PICTURE_TYPE_MIN_MAX_QP_KHR.0,
                    "PER_PICTURE_TYPE_MIN_MAX_QP_KHR",
                ),
                (
                    VideoEncodeH265CapabilityFlagBitsKHR::PER_SLICE_SEGMENT_CONSTANT_QP_KHR.0,
                    "PER_SLICE_SEGMENT_CONSTANT_QP_KHR",
                ),
                (
                    VideoEncodeH265CapabilityFlagBitsKHR::MULTIPLE_TILES_PER_SLICE_SEGMENT_KHR.0,
                    "MULTIPLE_TILES_PER_SLICE_SEGMENT_KHR",
                ),
                (
                    VideoEncodeH265CapabilityFlagBitsKHR::MULTIPLE_SLICE_SEGMENTS_PER_TILE_KHR.0,
                    "MULTIPLE_SLICE_SEGMENTS_PER_TILE_KHR",
                ),
                (
                    VideoEncodeH265CapabilityFlagBitsKHR::B_PICTURE_INTRA_REFRESH_KHR.0,
                    "B_PICTURE_INTRA_REFRESH_KHR",
                ),
                (
                    VideoEncodeH265CapabilityFlagBitsKHR::CU_QP_DIFF_WRAPAROUND_KHR.0,
                    "CU_QP_DIFF_WRAPAROUND_KHR",
                ),
            ];
            debug_flags(f, KNOWN, self.0)
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265CapabilityFlagBitsKHR.html>
    #[repr(transparent)]
    #[derive(Copy, Clone, Default, PartialEq, Eq, Hash)]
    pub struct VideoEncodeH265CapabilityFlagBitsKHR(u32);

    impl VideoEncodeH265CapabilityFlagBitsKHR {
        pub const HRD_COMPLIANCE_KHR: Self = Self(1 << 0);
        pub const PREDICTION_WEIGHT_TABLE_GENERATED_KHR: Self = Self(1 << 1);
        pub const ROW_UNALIGNED_SLICE_SEGMENT_KHR: Self = Self(1 << 2);
        pub const DIFFERENT_SLICE_SEGMENT_TYPE_KHR: Self = Self(1 << 3);
        pub const B_FRAME_IN_L0_LIST_KHR: Self = Self(1 << 4);
        pub const B_FRAME_IN_L1_LIST_KHR: Self = Self(1 << 5);
        pub const PER_PICTURE_TYPE_MIN_MAX_QP_KHR: Self = Self(1 << 6);
        pub const PER_SLICE_SEGMENT_CONSTANT_QP_KHR: Self = Self(1 << 7);
        pub const MULTIPLE_TILES_PER_SLICE_SEGMENT_KHR: Self = Self(1 << 8);
        pub const MULTIPLE_SLICE_SEGMENTS_PER_TILE_KHR: Self = Self(1 << 9);
        // VK_KHR_video_encode_intra_refresh
        pub const B_PICTURE_INTRA_REFRESH_KHR: Self = Self(1 << 11);

        // VK_KHR_video_encode_quantization_map
        pub const CU_QP_DIFF_WRAPAROUND_KHR: Self = Self(1 << 10);
    }

    impl fmt::Debug for VideoEncodeH265CapabilityFlagBitsKHR {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            let name = match *self {
                Self::HRD_COMPLIANCE_KHR => Some("HRD_COMPLIANCE_KHR"),
                Self::PREDICTION_WEIGHT_TABLE_GENERATED_KHR => {
                    Some("PREDICTION_WEIGHT_TABLE_GENERATED_KHR")
                }
                Self::ROW_UNALIGNED_SLICE_SEGMENT_KHR => Some("ROW_UNALIGNED_SLICE_SEGMENT_KHR"),
                Self::DIFFERENT_SLICE_SEGMENT_TYPE_KHR => Some("DIFFERENT_SLICE_SEGMENT_TYPE_KHR"),
                Self::B_FRAME_IN_L0_LIST_KHR => Some("B_FRAME_IN_L0_LIST_KHR"),
                Self::B_FRAME_IN_L1_LIST_KHR => Some("B_FRAME_IN_L1_LIST_KHR"),
                Self::PER_PICTURE_TYPE_MIN_MAX_QP_KHR => Some("PER_PICTURE_TYPE_MIN_MAX_QP_KHR"),
                Self::PER_SLICE_SEGMENT_CONSTANT_QP_KHR => {
                    Some("PER_SLICE_SEGMENT_CONSTANT_QP_KHR")
                }
                Self::MULTIPLE_TILES_PER_SLICE_SEGMENT_KHR => {
                    Some("MULTIPLE_TILES_PER_SLICE_SEGMENT_KHR")
                }
                Self::MULTIPLE_SLICE_SEGMENTS_PER_TILE_KHR => {
                    Some("MULTIPLE_SLICE_SEGMENTS_PER_TILE_KHR")
                }
                Self::B_PICTURE_INTRA_REFRESH_KHR => Some("B_PICTURE_INTRA_REFRESH_KHR"),
                Self::CU_QP_DIFF_WRAPAROUND_KHR => Some("CU_QP_DIFF_WRAPAROUND_KHR"),
                _ => None,
            };
            if let Some(name) = name {
                f.write_str(name)
            } else {
                self.0.fmt(f)
            }
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265StdFlagsKHR.html>
    #[repr(transparent)]
    #[derive(Copy, Clone, PartialEq, Eq, Hash)]
    pub struct VideoEncodeH265StdFlagsKHR(Flags);
    vk_bitflags_wrapped!(
        VideoEncodeH265StdFlagsKHR,
        Flags,
        VideoEncodeH265StdFlagBitsKHR
    );

    impl fmt::Debug for VideoEncodeH265StdFlagsKHR {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            const KNOWN: &[(Flags, &str)] = &[
                (
                    VideoEncodeH265StdFlagBitsKHR::SEPARATE_COLOR_PLANE_FLAG_SET_KHR.0,
                    "SEPARATE_COLOR_PLANE_FLAG_SET_KHR",
                ),
                (
                    VideoEncodeH265StdFlagBitsKHR::SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET_KHR.0,
                    "SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET_KHR",
                ),
                (
                    VideoEncodeH265StdFlagBitsKHR::SCALING_LIST_DATA_PRESENT_FLAG_SET_KHR.0,
                    "SCALING_LIST_DATA_PRESENT_FLAG_SET_KHR",
                ),
                (
                    VideoEncodeH265StdFlagBitsKHR::PCM_ENABLED_FLAG_SET_KHR.0,
                    "PCM_ENABLED_FLAG_SET_KHR",
                ),
                (
                    VideoEncodeH265StdFlagBitsKHR::SPS_TEMPORAL_MVP_ENABLED_FLAG_SET_KHR.0,
                    "SPS_TEMPORAL_MVP_ENABLED_FLAG_SET_KHR",
                ),
                (
                    VideoEncodeH265StdFlagBitsKHR::INIT_QP_MINUS26_KHR.0,
                    "INIT_QP_MINUS26_KHR",
                ),
                (
                    VideoEncodeH265StdFlagBitsKHR::WEIGHTED_PRED_FLAG_SET_KHR.0,
                    "WEIGHTED_PRED_FLAG_SET_KHR",
                ),
                (
                    VideoEncodeH265StdFlagBitsKHR::WEIGHTED_BIPRED_FLAG_SET_KHR.0,
                    "WEIGHTED_BIPRED_FLAG_SET_KHR",
                ),
                (
                    VideoEncodeH265StdFlagBitsKHR::LOG2_PARALLEL_MERGE_LEVEL_MINUS2_KHR.0,
                    "LOG2_PARALLEL_MERGE_LEVEL_MINUS2_KHR",
                ),
                (
                    VideoEncodeH265StdFlagBitsKHR::SIGN_DATA_HIDING_ENABLED_FLAG_SET_KHR.0,
                    "SIGN_DATA_HIDING_ENABLED_FLAG_SET_KHR",
                ),
                (
                    VideoEncodeH265StdFlagBitsKHR::TRANSFORM_SKIP_ENABLED_FLAG_SET_KHR.0,
                    "TRANSFORM_SKIP_ENABLED_FLAG_SET_KHR",
                ),
                (
                    VideoEncodeH265StdFlagBitsKHR::TRANSFORM_SKIP_ENABLED_FLAG_UNSET_KHR.0,
                    "TRANSFORM_SKIP_ENABLED_FLAG_UNSET_KHR",
                ),
                (
                    VideoEncodeH265StdFlagBitsKHR::PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET_KHR
                        .0,
                    "PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET_KHR",
                ),
                (
                    VideoEncodeH265StdFlagBitsKHR::TRANSQUANT_BYPASS_ENABLED_FLAG_SET_KHR.0,
                    "TRANSQUANT_BYPASS_ENABLED_FLAG_SET_KHR",
                ),
                (
                    VideoEncodeH265StdFlagBitsKHR::CONSTRAINED_INTRA_PRED_FLAG_SET_KHR.0,
                    "CONSTRAINED_INTRA_PRED_FLAG_SET_KHR",
                ),
                (
                    VideoEncodeH265StdFlagBitsKHR::ENTROPY_CODING_SYNC_ENABLED_FLAG_SET_KHR.0,
                    "ENTROPY_CODING_SYNC_ENABLED_FLAG_SET_KHR",
                ),
                (
                    VideoEncodeH265StdFlagBitsKHR::DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET_KHR
                        .0,
                    "DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET_KHR",
                ),
                (
                    VideoEncodeH265StdFlagBitsKHR::DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET_KHR.0,
                    "DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET_KHR",
                ),
                (
                    VideoEncodeH265StdFlagBitsKHR::DEPENDENT_SLICE_SEGMENT_FLAG_SET_KHR.0,
                    "DEPENDENT_SLICE_SEGMENT_FLAG_SET_KHR",
                ),
                (
                    VideoEncodeH265StdFlagBitsKHR::SLICE_QP_DELTA_KHR.0,
                    "SLICE_QP_DELTA_KHR",
                ),
                (
                    VideoEncodeH265StdFlagBitsKHR::DIFFERENT_SLICE_QP_DELTA_KHR.0,
                    "DIFFERENT_SLICE_QP_DELTA_KHR",
                ),
            ];
            debug_flags(f, KNOWN, self.0)
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265StdFlagBitsKHR.html>
    #[repr(transparent)]
    #[derive(Copy, Clone, Default, PartialEq, Eq, Hash)]
    pub struct VideoEncodeH265StdFlagBitsKHR(u32);

    impl VideoEncodeH265StdFlagBitsKHR {
        pub const SEPARATE_COLOR_PLANE_FLAG_SET_KHR: Self = Self(1 << 0);
        pub const SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET_KHR: Self = Self(1 << 1);
        pub const SCALING_LIST_DATA_PRESENT_FLAG_SET_KHR: Self = Self(1 << 2);
        pub const PCM_ENABLED_FLAG_SET_KHR: Self = Self(1 << 3);
        pub const SPS_TEMPORAL_MVP_ENABLED_FLAG_SET_KHR: Self = Self(1 << 4);
        pub const INIT_QP_MINUS26_KHR: Self = Self(1 << 5);
        pub const WEIGHTED_PRED_FLAG_SET_KHR: Self = Self(1 << 6);
        pub const WEIGHTED_BIPRED_FLAG_SET_KHR: Self = Self(1 << 7);
        pub const LOG2_PARALLEL_MERGE_LEVEL_MINUS2_KHR: Self = Self(1 << 8);
        pub const SIGN_DATA_HIDING_ENABLED_FLAG_SET_KHR: Self = Self(1 << 9);
        pub const TRANSFORM_SKIP_ENABLED_FLAG_SET_KHR: Self = Self(1 << 10);
        pub const TRANSFORM_SKIP_ENABLED_FLAG_UNSET_KHR: Self = Self(1 << 11);
        pub const PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET_KHR: Self = Self(1 << 12);
        pub const TRANSQUANT_BYPASS_ENABLED_FLAG_SET_KHR: Self = Self(1 << 13);
        pub const CONSTRAINED_INTRA_PRED_FLAG_SET_KHR: Self = Self(1 << 14);
        pub const ENTROPY_CODING_SYNC_ENABLED_FLAG_SET_KHR: Self = Self(1 << 15);
        pub const DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET_KHR: Self = Self(1 << 16);
        pub const DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET_KHR: Self = Self(1 << 17);
        pub const DEPENDENT_SLICE_SEGMENT_FLAG_SET_KHR: Self = Self(1 << 18);
        pub const SLICE_QP_DELTA_KHR: Self = Self(1 << 19);
        pub const DIFFERENT_SLICE_QP_DELTA_KHR: Self = Self(1 << 20);
    }

    impl fmt::Debug for VideoEncodeH265StdFlagBitsKHR {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            let name = match *self {
                Self::SEPARATE_COLOR_PLANE_FLAG_SET_KHR => {
                    Some("SEPARATE_COLOR_PLANE_FLAG_SET_KHR")
                }
                Self::SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET_KHR => {
                    Some("SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET_KHR")
                }
                Self::SCALING_LIST_DATA_PRESENT_FLAG_SET_KHR => {
                    Some("SCALING_LIST_DATA_PRESENT_FLAG_SET_KHR")
                }
                Self::PCM_ENABLED_FLAG_SET_KHR => Some("PCM_ENABLED_FLAG_SET_KHR"),
                Self::SPS_TEMPORAL_MVP_ENABLED_FLAG_SET_KHR => {
                    Some("SPS_TEMPORAL_MVP_ENABLED_FLAG_SET_KHR")
                }
                Self::INIT_QP_MINUS26_KHR => Some("INIT_QP_MINUS26_KHR"),
                Self::WEIGHTED_PRED_FLAG_SET_KHR => Some("WEIGHTED_PRED_FLAG_SET_KHR"),
                Self::WEIGHTED_BIPRED_FLAG_SET_KHR => Some("WEIGHTED_BIPRED_FLAG_SET_KHR"),
                Self::LOG2_PARALLEL_MERGE_LEVEL_MINUS2_KHR => {
                    Some("LOG2_PARALLEL_MERGE_LEVEL_MINUS2_KHR")
                }
                Self::SIGN_DATA_HIDING_ENABLED_FLAG_SET_KHR => {
                    Some("SIGN_DATA_HIDING_ENABLED_FLAG_SET_KHR")
                }
                Self::TRANSFORM_SKIP_ENABLED_FLAG_SET_KHR => {
                    Some("TRANSFORM_SKIP_ENABLED_FLAG_SET_KHR")
                }
                Self::TRANSFORM_SKIP_ENABLED_FLAG_UNSET_KHR => {
                    Some("TRANSFORM_SKIP_ENABLED_FLAG_UNSET_KHR")
                }
                Self::PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET_KHR => {
                    Some("PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET_KHR")
                }
                Self::TRANSQUANT_BYPASS_ENABLED_FLAG_SET_KHR => {
                    Some("TRANSQUANT_BYPASS_ENABLED_FLAG_SET_KHR")
                }
                Self::CONSTRAINED_INTRA_PRED_FLAG_SET_KHR => {
                    Some("CONSTRAINED_INTRA_PRED_FLAG_SET_KHR")
                }
                Self::ENTROPY_CODING_SYNC_ENABLED_FLAG_SET_KHR => {
                    Some("ENTROPY_CODING_SYNC_ENABLED_FLAG_SET_KHR")
                }
                Self::DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET_KHR => {
                    Some("DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET_KHR")
                }
                Self::DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET_KHR => {
                    Some("DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET_KHR")
                }
                Self::DEPENDENT_SLICE_SEGMENT_FLAG_SET_KHR => {
                    Some("DEPENDENT_SLICE_SEGMENT_FLAG_SET_KHR")
                }
                Self::SLICE_QP_DELTA_KHR => Some("SLICE_QP_DELTA_KHR"),
                Self::DIFFERENT_SLICE_QP_DELTA_KHR => Some("DIFFERENT_SLICE_QP_DELTA_KHR"),
                _ => None,
            };
            if let Some(name) = name {
                f.write_str(name)
            } else {
                self.0.fmt(f)
            }
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265RateControlFlagsKHR.html>
    #[repr(transparent)]
    #[derive(Copy, Clone, PartialEq, Eq, Hash)]
    pub struct VideoEncodeH265RateControlFlagsKHR(Flags);
    vk_bitflags_wrapped!(
        VideoEncodeH265RateControlFlagsKHR,
        Flags,
        VideoEncodeH265RateControlFlagBitsKHR
    );

    impl fmt::Debug for VideoEncodeH265RateControlFlagsKHR {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            const KNOWN: &[(Flags, &str)] = &[
                (
                    VideoEncodeH265RateControlFlagBitsKHR::ATTEMPT_HRD_COMPLIANCE_KHR.0,
                    "ATTEMPT_HRD_COMPLIANCE_KHR",
                ),
                (
                    VideoEncodeH265RateControlFlagBitsKHR::REGULAR_GOP_KHR.0,
                    "REGULAR_GOP_KHR",
                ),
                (
                    VideoEncodeH265RateControlFlagBitsKHR::REFERENCE_PATTERN_FLAT_KHR.0,
                    "REFERENCE_PATTERN_FLAT_KHR",
                ),
                (
                    VideoEncodeH265RateControlFlagBitsKHR::REFERENCE_PATTERN_DYADIC_KHR.0,
                    "REFERENCE_PATTERN_DYADIC_KHR",
                ),
                (
                    VideoEncodeH265RateControlFlagBitsKHR::TEMPORAL_SUB_LAYER_PATTERN_DYADIC_KHR.0,
                    "TEMPORAL_SUB_LAYER_PATTERN_DYADIC_KHR",
                ),
            ];
            debug_flags(f, KNOWN, self.0)
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265RateControlFlagBitsKHR.html>
    #[repr(transparent)]
    #[derive(Copy, Clone, Default, PartialEq, Eq, Hash)]
    pub struct VideoEncodeH265RateControlFlagBitsKHR(u32);

    impl VideoEncodeH265RateControlFlagBitsKHR {
        pub const ATTEMPT_HRD_COMPLIANCE_KHR: Self = Self(1 << 0);
        pub const REGULAR_GOP_KHR: Self = Self(1 << 1);
        pub const REFERENCE_PATTERN_FLAT_KHR: Self = Self(1 << 2);
        pub const REFERENCE_PATTERN_DYADIC_KHR: Self = Self(1 << 3);
        pub const TEMPORAL_SUB_LAYER_PATTERN_DYADIC_KHR: Self = Self(1 << 4);
    }

    impl fmt::Debug for VideoEncodeH265RateControlFlagBitsKHR {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            let name = match *self {
                Self::ATTEMPT_HRD_COMPLIANCE_KHR => Some("ATTEMPT_HRD_COMPLIANCE_KHR"),
                Self::REGULAR_GOP_KHR => Some("REGULAR_GOP_KHR"),
                Self::REFERENCE_PATTERN_FLAT_KHR => Some("REFERENCE_PATTERN_FLAT_KHR"),
                Self::REFERENCE_PATTERN_DYADIC_KHR => Some("REFERENCE_PATTERN_DYADIC_KHR"),
                Self::TEMPORAL_SUB_LAYER_PATTERN_DYADIC_KHR => {
                    Some("TEMPORAL_SUB_LAYER_PATTERN_DYADIC_KHR")
                }
                _ => None,
            };
            if let Some(name) = name {
                f.write_str(name)
            } else {
                self.0.fmt(f)
            }
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265CtbSizeFlagsKHR.html>
    #[repr(transparent)]
    #[derive(Copy, Clone, PartialEq, Eq, Hash)]
    pub struct VideoEncodeH265CtbSizeFlagsKHR(Flags);
    vk_bitflags_wrapped!(
        VideoEncodeH265CtbSizeFlagsKHR,
        Flags,
        VideoEncodeH265CtbSizeFlagBitsKHR
    );

    impl fmt::Debug for VideoEncodeH265CtbSizeFlagsKHR {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            const KNOWN: &[(Flags, &str)] = &[
                (VideoEncodeH265CtbSizeFlagBitsKHR::_16_KHR.0, "_16_KHR"),
                (VideoEncodeH265CtbSizeFlagBitsKHR::_32_KHR.0, "_32_KHR"),
                (VideoEncodeH265CtbSizeFlagBitsKHR::_64_KHR.0, "_64_KHR"),
            ];
            debug_flags(f, KNOWN, self.0)
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265CtbSizeFlagBitsKHR.html>
    #[repr(transparent)]
    #[derive(Copy, Clone, Default, PartialEq, Eq, Hash)]
    pub struct VideoEncodeH265CtbSizeFlagBitsKHR(u32);

    impl VideoEncodeH265CtbSizeFlagBitsKHR {
        pub const _16_KHR: Self = Self(1 << 0);
        pub const _32_KHR: Self = Self(1 << 1);
        pub const _64_KHR: Self = Self(1 << 2);
    }

    impl fmt::Debug for VideoEncodeH265CtbSizeFlagBitsKHR {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            let name = match *self {
                Self::_16_KHR => Some("_16_KHR"),
                Self::_32_KHR => Some("_32_KHR"),
                Self::_64_KHR => Some("_64_KHR"),
                _ => None,
            };
            if let Some(name) = name {
                f.write_str(name)
            } else {
                self.0.fmt(f)
            }
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265TransformBlockSizeFlagsKHR.html>
    #[repr(transparent)]
    #[derive(Copy, Clone, PartialEq, Eq, Hash)]
    pub struct VideoEncodeH265TransformBlockSizeFlagsKHR(Flags);
    vk_bitflags_wrapped!(
        VideoEncodeH265TransformBlockSizeFlagsKHR,
        Flags,
        VideoEncodeH265TransformBlockSizeFlagBitsKHR
    );

    impl fmt::Debug for VideoEncodeH265TransformBlockSizeFlagsKHR {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            const KNOWN: &[(Flags, &str)] = &[
                (
                    VideoEncodeH265TransformBlockSizeFlagBitsKHR::_4_KHR.0,
                    "_4_KHR",
                ),
                (
                    VideoEncodeH265TransformBlockSizeFlagBitsKHR::_8_KHR.0,
                    "_8_KHR",
                ),
                (
                    VideoEncodeH265TransformBlockSizeFlagBitsKHR::_16_KHR.0,
                    "_16_KHR",
                ),
                (
                    VideoEncodeH265TransformBlockSizeFlagBitsKHR::_32_KHR.0,
                    "_32_KHR",
                ),
            ];
            debug_flags(f, KNOWN, self.0)
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265TransformBlockSizeFlagBitsKHR.html>
    #[repr(transparent)]
    #[derive(Copy, Clone, Default, PartialEq, Eq, Hash)]
    pub struct VideoEncodeH265TransformBlockSizeFlagBitsKHR(u32);

    impl VideoEncodeH265TransformBlockSizeFlagBitsKHR {
        pub const _4_KHR: Self = Self(1 << 0);
        pub const _8_KHR: Self = Self(1 << 1);
        pub const _16_KHR: Self = Self(1 << 2);
        pub const _32_KHR: Self = Self(1 << 3);
    }

    impl fmt::Debug for VideoEncodeH265TransformBlockSizeFlagBitsKHR {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            let name = match *self {
                Self::_4_KHR => Some("_4_KHR"),
                Self::_8_KHR => Some("_8_KHR"),
                Self::_16_KHR => Some("_16_KHR"),
                Self::_32_KHR => Some("_32_KHR"),
                _ => None,
            };
            if let Some(name) = name {
                f.write_str(name)
            } else {
                self.0.fmt(f)
            }
        }
    }
}

#[cfg(feature = "ffi")]
pub(super) mod ffi {
    #![allow(non_camel_case_types)]
    use super::defs::*;

    pub type VkVideoEncodeH265CapabilitiesKHR = VideoEncodeH265CapabilitiesKHR<'static>;
    pub type VkVideoEncodeH265QualityLevelPropertiesKHR =
        VideoEncodeH265QualityLevelPropertiesKHR<'static>;
    pub type VkVideoEncodeH265SessionCreateInfoKHR = VideoEncodeH265SessionCreateInfoKHR<'static>;
    pub type VkVideoEncodeH265SessionParametersAddInfoKHR =
        VideoEncodeH265SessionParametersAddInfoKHR<'static>;
    pub type VkVideoEncodeH265SessionParametersCreateInfoKHR =
        VideoEncodeH265SessionParametersCreateInfoKHR<'static>;
    pub type VkVideoEncodeH265SessionParametersGetInfoKHR =
        VideoEncodeH265SessionParametersGetInfoKHR<'static>;
    pub type VkVideoEncodeH265SessionParametersFeedbackInfoKHR =
        VideoEncodeH265SessionParametersFeedbackInfoKHR<'static>;
    pub type VkVideoEncodeH265PictureInfoKHR = VideoEncodeH265PictureInfoKHR<'static>;
    pub type VkVideoEncodeH265NaluSliceSegmentInfoKHR =
        VideoEncodeH265NaluSliceSegmentInfoKHR<'static>;
    pub type VkVideoEncodeH265RateControlInfoKHR = VideoEncodeH265RateControlInfoKHR<'static>;
    pub type VkVideoEncodeH265QpKHR = VideoEncodeH265QpKHR;
    pub type VkVideoEncodeH265FrameSizeKHR = VideoEncodeH265FrameSizeKHR;
    pub type VkVideoEncodeH265GopRemainingFrameInfoKHR =
        VideoEncodeH265GopRemainingFrameInfoKHR<'static>;
    pub type VkVideoEncodeH265RateControlLayerInfoKHR =
        VideoEncodeH265RateControlLayerInfoKHR<'static>;
    pub type VkVideoEncodeH265ProfileInfoKHR = VideoEncodeH265ProfileInfoKHR<'static>;
    pub type VkVideoEncodeH265DpbSlotInfoKHR = VideoEncodeH265DpbSlotInfoKHR<'static>;
    pub type VkVideoEncodeH265CapabilityFlagsKHR = VideoEncodeH265CapabilityFlagsKHR;
    pub type VkVideoEncodeH265CapabilityFlagBitsKHR = VideoEncodeH265CapabilityFlagBitsKHR;
    pub type VkVideoEncodeH265StdFlagsKHR = VideoEncodeH265StdFlagsKHR;
    pub type VkVideoEncodeH265StdFlagBitsKHR = VideoEncodeH265StdFlagBitsKHR;
    pub type VkVideoEncodeH265RateControlFlagsKHR = VideoEncodeH265RateControlFlagsKHR;
    pub type VkVideoEncodeH265RateControlFlagBitsKHR = VideoEncodeH265RateControlFlagBitsKHR;
    pub type VkVideoEncodeH265CtbSizeFlagsKHR = VideoEncodeH265CtbSizeFlagsKHR;
    pub type VkVideoEncodeH265CtbSizeFlagBitsKHR = VideoEncodeH265CtbSizeFlagBitsKHR;
    pub type VkVideoEncodeH265TransformBlockSizeFlagsKHR =
        VideoEncodeH265TransformBlockSizeFlagsKHR;
    pub type VkVideoEncodeH265TransformBlockSizeFlagBitsKHR =
        VideoEncodeH265TransformBlockSizeFlagBitsKHR;
    impl VideoEncodeH265CapabilitiesKHR<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkVideoEncodeH265CapabilitiesKHR {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl VideoEncodeH265QualityLevelPropertiesKHR<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkVideoEncodeH265QualityLevelPropertiesKHR {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl VideoEncodeH265SessionCreateInfoKHR<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkVideoEncodeH265SessionCreateInfoKHR {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl VideoEncodeH265SessionParametersAddInfoKHR<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(
            &self,
        ) -> &VkVideoEncodeH265SessionParametersAddInfoKHR {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl VideoEncodeH265SessionParametersCreateInfoKHR<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(
            &self,
        ) -> &VkVideoEncodeH265SessionParametersCreateInfoKHR {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl VideoEncodeH265SessionParametersGetInfoKHR<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(
            &self,
        ) -> &VkVideoEncodeH265SessionParametersGetInfoKHR {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl VideoEncodeH265SessionParametersFeedbackInfoKHR<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(
            &self,
        ) -> &VkVideoEncodeH265SessionParametersFeedbackInfoKHR {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl VideoEncodeH265PictureInfoKHR<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkVideoEncodeH265PictureInfoKHR {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl VideoEncodeH265NaluSliceSegmentInfoKHR<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkVideoEncodeH265NaluSliceSegmentInfoKHR {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl VideoEncodeH265RateControlInfoKHR<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkVideoEncodeH265RateControlInfoKHR {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl VideoEncodeH265GopRemainingFrameInfoKHR<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkVideoEncodeH265GopRemainingFrameInfoKHR {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl VideoEncodeH265RateControlLayerInfoKHR<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkVideoEncodeH265RateControlLayerInfoKHR {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl VideoEncodeH265ProfileInfoKHR<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkVideoEncodeH265ProfileInfoKHR {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl VideoEncodeH265DpbSlotInfoKHR<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkVideoEncodeH265DpbSlotInfoKHR {
            unsafe { core::mem::transmute(self) }
        }
    }
}