From 7692663e913122801c42dc8ffaf00f33d265a0ed Mon Sep 17 00:00:00 2001 From: Marijn Suijten Date: Sun, 12 Mar 2023 20:01:32 +0100 Subject: [PATCH] Update Vulkan-Headers to 1.3.243 --- Changelog.md | 2 +- ash/Cargo.toml | 2 +- ash/src/vk/bitflags.rs | 58 +--- ash/src/vk/const_debugs.rs | 92 ++---- ash/src/vk/definitions.rs | 638 ++++++++++++------------------------- ash/src/vk/enums.rs | 5 + ash/src/vk/extensions.rs | 17 +- ash/src/vk/native.rs | 345 ++++++++++++++------ generator/Vulkan-Headers | 2 +- 9 files changed, 508 insertions(+), 653 deletions(-) diff --git a/Changelog.md b/Changelog.md index 96e5c4a30..fe32bc72c 100644 --- a/Changelog.md +++ b/Changelog.md @@ -8,7 +8,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ### Added -- Update Vulkan-Headers to 1.3.242 (#697) +- Update Vulkan-Headers to 1.3.243 (#697) ### Changed diff --git a/ash/Cargo.toml b/ash/Cargo.toml index f02ce204d..603c673dc 100644 --- a/ash/Cargo.toml +++ b/ash/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "ash" -version = "0.37.0+1.3.242" +version = "0.37.0+1.3.243" authors = [ "Maik Klein ", "Benjamin Saunders ", diff --git a/ash/src/vk/bitflags.rs b/ash/src/vk/bitflags.rs index 66699d721..2f48e7dea 100644 --- a/ash/src/vk/bitflags.rs +++ b/ash/src/vk/bitflags.rs @@ -1280,13 +1280,23 @@ impl VideoEncodeCapabilityFlagsKHR { } #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoEncodeFeedbackFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(VideoEncodeFeedbackFlagsKHR, Flags); +impl VideoEncodeFeedbackFlagsKHR { + pub const BITSTREAM_BUFFER_OFFSET: Self = Self(0b1); + pub const BITSTREAM_BYTES_WRITTEN: Self = Self(0b10); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[doc = ""] pub struct VideoEncodeRateControlModeFlagsKHR(pub(crate) Flags); vk_bitflags_wrapped!(VideoEncodeRateControlModeFlagsKHR, Flags); impl VideoEncodeRateControlModeFlagsKHR { - pub const NONE: Self = Self(0); - pub const CBR: Self = Self(1); - pub const VBR: Self = Self(2); + pub const DEFAULT: Self = Self(0); + pub const DISABLED: Self = Self(0b1); + pub const CBR: Self = Self(0b10); + pub const VBR: Self = Self(0b100); } #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] @@ -1319,26 +1329,7 @@ impl VideoEncodeH264CapabilityFlagsEXT { pub const ROW_UNALIGNED_SLICE: Self = Self(0b100_0000_0000_0000_0000_0000); pub const DIFFERENT_SLICE_TYPE: Self = Self(0b1000_0000_0000_0000_0000_0000); pub const B_FRAME_IN_L1_LIST: Self = Self(0b1_0000_0000_0000_0000_0000_0000); -} -#[repr(transparent)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -#[doc = ""] -pub struct VideoEncodeH264InputModeFlagsEXT(pub(crate) Flags); -vk_bitflags_wrapped!(VideoEncodeH264InputModeFlagsEXT, Flags); -impl VideoEncodeH264InputModeFlagsEXT { - pub const FRAME: Self = Self(0b1); - pub const SLICE: Self = Self(0b10); - pub const NON_VCL: Self = Self(0b100); -} -#[repr(transparent)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -#[doc = ""] -pub struct VideoEncodeH264OutputModeFlagsEXT(pub(crate) Flags); -vk_bitflags_wrapped!(VideoEncodeH264OutputModeFlagsEXT, Flags); -impl VideoEncodeH264OutputModeFlagsEXT { - pub const FRAME: Self = Self(0b1); - pub const SLICE: Self = Self(0b10); - pub const NON_VCL: Self = Self(0b100); + pub const DIFFERENT_REFERENCE_FINAL_LISTS: Self = Self(0b10_0000_0000_0000_0000_0000_0000); } #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] @@ -1474,26 +1465,7 @@ impl VideoEncodeH265CapabilityFlagsEXT { pub const DEPENDENT_SLICE_SEGMENT: Self = Self(0b1000_0000_0000_0000_0000_0000); pub const DIFFERENT_SLICE_TYPE: Self = Self(0b1_0000_0000_0000_0000_0000_0000); pub const B_FRAME_IN_L1_LIST: Self = Self(0b10_0000_0000_0000_0000_0000_0000); -} -#[repr(transparent)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -#[doc = ""] -pub struct VideoEncodeH265InputModeFlagsEXT(pub(crate) Flags); -vk_bitflags_wrapped!(VideoEncodeH265InputModeFlagsEXT, Flags); -impl VideoEncodeH265InputModeFlagsEXT { - pub const FRAME: Self = Self(0b1); - pub const SLICE_SEGMENT: Self = Self(0b10); - pub const NON_VCL: Self = Self(0b100); -} -#[repr(transparent)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -#[doc = ""] -pub struct VideoEncodeH265OutputModeFlagsEXT(pub(crate) Flags); -vk_bitflags_wrapped!(VideoEncodeH265OutputModeFlagsEXT, Flags); -impl VideoEncodeH265OutputModeFlagsEXT { - pub const FRAME: Self = Self(0b1); - pub const SLICE_SEGMENT: Self = Self(0b10); - pub const NON_VCL: Self = Self(0b100); + pub const DIFFERENT_REFERENCE_FINAL_LISTS: Self = Self(0b100_0000_0000_0000_0000_0000_0000); } #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] diff --git a/ash/src/vk/const_debugs.rs b/ash/src/vk/const_debugs.rs index c4b60e0cc..6052c9ed4 100644 --- a/ash/src/vk/const_debugs.rs +++ b/ash/src/vk/const_debugs.rs @@ -3992,9 +3992,7 @@ impl fmt::Debug for QueryType { Some("ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV") } Self::PERFORMANCE_QUERY_INTEL => Some("PERFORMANCE_QUERY_INTEL"), - Self::VIDEO_ENCODESTREAM_BUFFER_RANGE_KHR => { - Some("VIDEO_ENCODESTREAM_BUFFER_RANGE_KHR") - } + Self::VIDEO_ENCODE_FEEDBACK_KHR => Some("VIDEO_ENCODE_FEEDBACK_KHR"), Self::MESH_PRIMITIVES_GENERATED_EXT => Some("MESH_PRIMITIVES_GENERATED_EXT"), Self::PRIMITIVES_GENERATED_EXT => Some("PRIMITIVES_GENERATED_EXT"), Self::ACCELERATION_STRUCTURE_SERIALIZATION_BOTTOM_LEVEL_POINTERS_KHR => { @@ -4657,9 +4655,6 @@ impl fmt::Debug for StructureType { Self::VIDEO_ENCODE_H264_NALU_SLICE_INFO_EXT => { Some("VIDEO_ENCODE_H264_NALU_SLICE_INFO_EXT") } - Self::VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_INFO_EXT => { - Some("VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_INFO_EXT") - } Self::VIDEO_ENCODE_H264_PROFILE_INFO_EXT => Some("VIDEO_ENCODE_H264_PROFILE_INFO_EXT"), Self::VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT => { Some("VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT") @@ -4667,9 +4662,6 @@ impl fmt::Debug for StructureType { Self::VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT => { Some("VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT") } - Self::VIDEO_ENCODE_H264_REFERENCE_LISTS_INFO_EXT => { - Some("VIDEO_ENCODE_H264_REFERENCE_LISTS_INFO_EXT") - } Self::VIDEO_ENCODE_H265_CAPABILITIES_EXT => Some("VIDEO_ENCODE_H265_CAPABILITIES_EXT"), Self::VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT => { Some("VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT") @@ -4686,13 +4678,7 @@ impl fmt::Debug for StructureType { Self::VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_EXT => { Some("VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_EXT") } - Self::VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_INFO_EXT => { - Some("VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_INFO_EXT") - } Self::VIDEO_ENCODE_H265_PROFILE_INFO_EXT => Some("VIDEO_ENCODE_H265_PROFILE_INFO_EXT"), - Self::VIDEO_ENCODE_H265_REFERENCE_LISTS_INFO_EXT => { - Some("VIDEO_ENCODE_H265_REFERENCE_LISTS_INFO_EXT") - } Self::VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT => { Some("VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT") } @@ -5388,6 +5374,9 @@ impl fmt::Debug for StructureType { } Self::VIDEO_ENCODE_CAPABILITIES_KHR => Some("VIDEO_ENCODE_CAPABILITIES_KHR"), Self::VIDEO_ENCODE_USAGE_INFO_KHR => Some("VIDEO_ENCODE_USAGE_INFO_KHR"), + Self::QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR => { + Some("QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR") + } Self::PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV => { Some("PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV") } @@ -6483,6 +6472,7 @@ impl fmt::Debug for VendorId { Self::CODEPLAY => Some("CODEPLAY"), Self::MESA => Some("MESA"), Self::POCL => Some("POCL"), + Self::MOBILEYE => Some("MOBILEYE"), _ => None, }; if let Some(x) = name { @@ -6661,6 +6651,21 @@ impl fmt::Debug for VideoEncodeContentFlagsKHR { debug_flags(f, KNOWN, self.0) } } +impl fmt::Debug for VideoEncodeFeedbackFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + VideoEncodeFeedbackFlagsKHR::BITSTREAM_BUFFER_OFFSET.0, + "BITSTREAM_BUFFER_OFFSET", + ), + ( + VideoEncodeFeedbackFlagsKHR::BITSTREAM_BYTES_WRITTEN.0, + "BITSTREAM_BYTES_WRITTEN", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} impl fmt::Debug for VideoEncodeFlagsKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[]; @@ -6764,26 +6769,10 @@ impl fmt::Debug for VideoEncodeH264CapabilityFlagsEXT { VideoEncodeH264CapabilityFlagsEXT::B_FRAME_IN_L1_LIST.0, "B_FRAME_IN_L1_LIST", ), - ]; - debug_flags(f, KNOWN, self.0) - } -} -impl fmt::Debug for VideoEncodeH264InputModeFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (VideoEncodeH264InputModeFlagsEXT::FRAME.0, "FRAME"), - (VideoEncodeH264InputModeFlagsEXT::SLICE.0, "SLICE"), - (VideoEncodeH264InputModeFlagsEXT::NON_VCL.0, "NON_VCL"), - ]; - debug_flags(f, KNOWN, self.0) - } -} -impl fmt::Debug for VideoEncodeH264OutputModeFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (VideoEncodeH264OutputModeFlagsEXT::FRAME.0, "FRAME"), - (VideoEncodeH264OutputModeFlagsEXT::SLICE.0, "SLICE"), - (VideoEncodeH264OutputModeFlagsEXT::NON_VCL.0, "NON_VCL"), + ( + VideoEncodeH264CapabilityFlagsEXT::DIFFERENT_REFERENCE_FINAL_LISTS.0, + "DIFFERENT_REFERENCE_FINAL_LISTS", + ), ]; debug_flags(f, KNOWN, self.0) } @@ -6910,6 +6899,10 @@ impl fmt::Debug for VideoEncodeH265CapabilityFlagsEXT { VideoEncodeH265CapabilityFlagsEXT::B_FRAME_IN_L1_LIST.0, "B_FRAME_IN_L1_LIST", ), + ( + VideoEncodeH265CapabilityFlagsEXT::DIFFERENT_REFERENCE_FINAL_LISTS.0, + "DIFFERENT_REFERENCE_FINAL_LISTS", + ), ]; debug_flags(f, KNOWN, self.0) } @@ -6924,32 +6917,6 @@ impl fmt::Debug for VideoEncodeH265CtbSizeFlagsEXT { debug_flags(f, KNOWN, self.0) } } -impl fmt::Debug for VideoEncodeH265InputModeFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (VideoEncodeH265InputModeFlagsEXT::FRAME.0, "FRAME"), - ( - VideoEncodeH265InputModeFlagsEXT::SLICE_SEGMENT.0, - "SLICE_SEGMENT", - ), - (VideoEncodeH265InputModeFlagsEXT::NON_VCL.0, "NON_VCL"), - ]; - debug_flags(f, KNOWN, self.0) - } -} -impl fmt::Debug for VideoEncodeH265OutputModeFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (VideoEncodeH265OutputModeFlagsEXT::FRAME.0, "FRAME"), - ( - VideoEncodeH265OutputModeFlagsEXT::SLICE_SEGMENT.0, - "SLICE_SEGMENT", - ), - (VideoEncodeH265OutputModeFlagsEXT::NON_VCL.0, "NON_VCL"), - ]; - debug_flags(f, KNOWN, self.0) - } -} impl fmt::Debug for VideoEncodeH265RateControlStructureEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -6997,7 +6964,8 @@ impl fmt::Debug for VideoEncodeRateControlFlagsKHR { impl fmt::Debug for VideoEncodeRateControlModeFlagsKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (VideoEncodeRateControlModeFlagsKHR::NONE.0, "NONE"), + (VideoEncodeRateControlModeFlagsKHR::DEFAULT.0, "DEFAULT"), + (VideoEncodeRateControlModeFlagsKHR::DISABLED.0, "DISABLED"), (VideoEncodeRateControlModeFlagsKHR::CBR.0, "CBR"), (VideoEncodeRateControlModeFlagsKHR::VBR.0, "VBR"), ]; diff --git a/ash/src/vk/definitions.rs b/ash/src/vk/definitions.rs index 61611a12a..a0c447052 100644 --- a/ash/src/vk/definitions.rs +++ b/ash/src/vk/definitions.rs @@ -58,7 +58,7 @@ pub const API_VERSION_1_2: u32 = make_api_version(0, 1, 2, 0); #[doc = ""] pub const API_VERSION_1_3: u32 = make_api_version(0, 1, 3, 0); #[doc = ""] -pub const HEADER_VERSION: u32 = 242; +pub const HEADER_VERSION: u32 = 243; #[doc = ""] pub const HEADER_VERSION_COMPLETE: u32 = make_api_version(0, 1, 3, HEADER_VERSION); #[doc = ""] @@ -28304,6 +28304,7 @@ pub struct PhysicalDeviceClusterCullingShaderPropertiesHUAWEI<'a> { pub max_work_group_count: [u32; 3], pub max_work_group_size: [u32; 3], pub max_output_cluster_count: u32, + pub indirect_buffer_offset_alignment: DeviceSize, pub _marker: PhantomData<&'a ()>, } impl ::std::default::Default for PhysicalDeviceClusterCullingShaderPropertiesHUAWEI<'_> { @@ -28315,6 +28316,7 @@ impl ::std::default::Default for PhysicalDeviceClusterCullingShaderPropertiesHUA max_work_group_count: unsafe { ::std::mem::zeroed() }, max_work_group_size: unsafe { ::std::mem::zeroed() }, max_output_cluster_count: u32::default(), + indirect_buffer_offset_alignment: DeviceSize::default(), _marker: PhantomData, } } @@ -28343,6 +28345,14 @@ impl<'a> PhysicalDeviceClusterCullingShaderPropertiesHUAWEI<'a> { self.max_output_cluster_count = max_output_cluster_count; self } + #[inline] + pub fn indirect_buffer_offset_alignment( + mut self, + indirect_buffer_offset_alignment: DeviceSize, + ) -> Self { + self.indirect_buffer_offset_alignment = indirect_buffer_offset_alignment; + self + } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -37576,9 +37586,9 @@ pub struct VideoEncodeInfoKHR<'a> { pub p_next: *const c_void, pub flags: VideoEncodeFlagsKHR, pub quality_level: u32, - pub dst_bitstream_buffer: Buffer, - pub dst_bitstream_buffer_offset: DeviceSize, - pub dst_bitstream_buffer_max_range: DeviceSize, + pub dst_buffer: Buffer, + pub dst_buffer_offset: DeviceSize, + pub dst_buffer_range: DeviceSize, pub src_picture_resource: VideoPictureResourceInfoKHR<'a>, pub p_setup_reference_slot: *const VideoReferenceSlotInfoKHR<'a>, pub reference_slot_count: u32, @@ -37594,9 +37604,9 @@ impl ::std::default::Default for VideoEncodeInfoKHR<'_> { p_next: ::std::ptr::null(), flags: VideoEncodeFlagsKHR::default(), quality_level: u32::default(), - dst_bitstream_buffer: Buffer::default(), - dst_bitstream_buffer_offset: DeviceSize::default(), - dst_bitstream_buffer_max_range: DeviceSize::default(), + dst_buffer: Buffer::default(), + dst_buffer_offset: DeviceSize::default(), + dst_buffer_range: DeviceSize::default(), src_picture_resource: VideoPictureResourceInfoKHR::default(), p_setup_reference_slot: ::std::ptr::null(), reference_slot_count: u32::default(), @@ -37622,21 +37632,18 @@ impl<'a> VideoEncodeInfoKHR<'a> { self } #[inline] - pub fn dst_bitstream_buffer(mut self, dst_bitstream_buffer: Buffer) -> Self { - self.dst_bitstream_buffer = dst_bitstream_buffer; + pub fn dst_buffer(mut self, dst_buffer: Buffer) -> Self { + self.dst_buffer = dst_buffer; self } #[inline] - pub fn dst_bitstream_buffer_offset(mut self, dst_bitstream_buffer_offset: DeviceSize) -> Self { - self.dst_bitstream_buffer_offset = dst_bitstream_buffer_offset; + pub fn dst_buffer_offset(mut self, dst_buffer_offset: DeviceSize) -> Self { + self.dst_buffer_offset = dst_buffer_offset; self } #[inline] - pub fn dst_bitstream_buffer_max_range( - mut self, - dst_bitstream_buffer_max_range: DeviceSize, - ) -> Self { - self.dst_bitstream_buffer_max_range = dst_bitstream_buffer_max_range; + pub fn dst_buffer_range(mut self, dst_buffer_range: DeviceSize) -> Self { + self.dst_buffer_range = dst_buffer_range; self } #[inline] @@ -37687,14 +37694,50 @@ impl<'a> VideoEncodeInfoKHR<'a> { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] +#[doc = ""] +pub struct QueryPoolVideoEncodeFeedbackCreateInfoKHR<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub encode_feedback_flags: VideoEncodeFeedbackFlagsKHR, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for QueryPoolVideoEncodeFeedbackCreateInfoKHR<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + encode_feedback_flags: VideoEncodeFeedbackFlagsKHR::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for QueryPoolVideoEncodeFeedbackCreateInfoKHR<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR; +} +unsafe impl ExtendsQueryPoolCreateInfo for QueryPoolVideoEncodeFeedbackCreateInfoKHR<'_> {} +impl<'a> QueryPoolVideoEncodeFeedbackCreateInfoKHR<'a> { + #[inline] + pub fn encode_feedback_flags( + mut self, + encode_feedback_flags: VideoEncodeFeedbackFlagsKHR, + ) -> Self { + self.encode_feedback_flags = encode_feedback_flags; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] #[doc = ""] pub struct VideoEncodeRateControlInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: VideoEncodeRateControlFlagsKHR, pub rate_control_mode: VideoEncodeRateControlModeFlagsKHR, - pub layer_count: u8, - pub p_layer_configs: *const VideoEncodeRateControlLayerInfoKHR<'a>, + pub layer_count: u32, + pub p_layers: *const VideoEncodeRateControlLayerInfoKHR<'a>, pub _marker: PhantomData<&'a ()>, } impl ::std::default::Default for VideoEncodeRateControlInfoKHR<'_> { @@ -37705,8 +37748,8 @@ impl ::std::default::Default for VideoEncodeRateControlInfoKHR<'_> { p_next: ::std::ptr::null(), flags: VideoEncodeRateControlFlagsKHR::default(), rate_control_mode: VideoEncodeRateControlModeFlagsKHR::default(), - layer_count: u8::default(), - p_layer_configs: ::std::ptr::null(), + layer_count: u32::default(), + p_layers: ::std::ptr::null(), _marker: PhantomData, } } @@ -37730,12 +37773,9 @@ impl<'a> VideoEncodeRateControlInfoKHR<'a> { self } #[inline] - pub fn layer_configs( - mut self, - layer_configs: &'a [VideoEncodeRateControlLayerInfoKHR], - ) -> Self { - self.layer_count = layer_configs.len() as _; - self.p_layer_configs = layer_configs.as_ptr(); + pub fn layers(mut self, layers: &'a [VideoEncodeRateControlLayerInfoKHR]) -> Self { + self.layer_count = layers.len() as _; + self.p_layers = layers.as_ptr(); self } } @@ -37746,8 +37786,8 @@ impl<'a> VideoEncodeRateControlInfoKHR<'a> { pub struct VideoEncodeRateControlLayerInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, - pub average_bitrate: u32, - pub max_bitrate: u32, + pub average_bitrate: u64, + pub max_bitrate: u64, pub frame_rate_numerator: u32, pub frame_rate_denominator: u32, pub virtual_buffer_size_in_ms: u32, @@ -37760,8 +37800,8 @@ impl ::std::default::Default for VideoEncodeRateControlLayerInfoKHR<'_> { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null(), - average_bitrate: u32::default(), - max_bitrate: u32::default(), + average_bitrate: u64::default(), + max_bitrate: u64::default(), frame_rate_numerator: u32::default(), frame_rate_denominator: u32::default(), virtual_buffer_size_in_ms: u32::default(), @@ -37777,12 +37817,12 @@ unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeRateControlLayerInfo pub unsafe trait ExtendsVideoEncodeRateControlLayerInfoKHR {} impl<'a> VideoEncodeRateControlLayerInfoKHR<'a> { #[inline] - pub fn average_bitrate(mut self, average_bitrate: u32) -> Self { + pub fn average_bitrate(mut self, average_bitrate: u64) -> Self { self.average_bitrate = average_bitrate; self } #[inline] - pub fn max_bitrate(mut self, max_bitrate: u32) -> Self { + pub fn max_bitrate(mut self, max_bitrate: u64) -> Self { self.max_bitrate = max_bitrate; self } @@ -37836,9 +37876,10 @@ pub struct VideoEncodeCapabilitiesKHR<'a> { pub p_next: *mut c_void, pub flags: VideoEncodeCapabilityFlagsKHR, pub rate_control_modes: VideoEncodeRateControlModeFlagsKHR, - pub rate_control_layer_count: u8, - pub quality_level_count: u8, + pub max_rate_control_layers: u32, + pub max_quality_levels: u32, pub input_image_data_fill_alignment: Extent2D, + pub supported_encode_feedback_flags: VideoEncodeFeedbackFlagsKHR, pub _marker: PhantomData<&'a ()>, } impl ::std::default::Default for VideoEncodeCapabilitiesKHR<'_> { @@ -37849,9 +37890,10 @@ impl ::std::default::Default for VideoEncodeCapabilitiesKHR<'_> { p_next: ::std::ptr::null_mut(), flags: VideoEncodeCapabilityFlagsKHR::default(), rate_control_modes: VideoEncodeRateControlModeFlagsKHR::default(), - rate_control_layer_count: u8::default(), - quality_level_count: u8::default(), + max_rate_control_layers: u32::default(), + max_quality_levels: u32::default(), input_image_data_fill_alignment: Extent2D::default(), + supported_encode_feedback_flags: VideoEncodeFeedbackFlagsKHR::default(), _marker: PhantomData, } } @@ -37875,13 +37917,13 @@ impl<'a> VideoEncodeCapabilitiesKHR<'a> { self } #[inline] - pub fn rate_control_layer_count(mut self, rate_control_layer_count: u8) -> Self { - self.rate_control_layer_count = rate_control_layer_count; + pub fn max_rate_control_layers(mut self, max_rate_control_layers: u32) -> Self { + self.max_rate_control_layers = max_rate_control_layers; self } #[inline] - pub fn quality_level_count(mut self, quality_level_count: u8) -> Self { - self.quality_level_count = quality_level_count; + pub fn max_quality_levels(mut self, max_quality_levels: u32) -> Self { + self.max_quality_levels = max_quality_levels; self } #[inline] @@ -37892,6 +37934,14 @@ impl<'a> VideoEncodeCapabilitiesKHR<'a> { self.input_image_data_fill_alignment = input_image_data_fill_alignment; self } + #[inline] + pub fn supported_encode_feedback_flags( + mut self, + supported_encode_feedback_flags: VideoEncodeFeedbackFlagsKHR, + ) -> Self { + self.supported_encode_feedback_flags = supported_encode_feedback_flags; + self + } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -37901,11 +37951,9 @@ pub struct VideoEncodeH264CapabilitiesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub flags: VideoEncodeH264CapabilityFlagsEXT, - pub input_mode_flags: VideoEncodeH264InputModeFlagsEXT, - pub output_mode_flags: VideoEncodeH264OutputModeFlagsEXT, - pub max_p_picture_l0_reference_count: u8, - pub max_b_picture_l0_reference_count: u8, - pub max_l1_reference_count: u8, + pub max_p_picture_l0_reference_count: u32, + pub max_b_picture_l0_reference_count: u32, + pub max_l1_reference_count: u32, pub motion_vectors_over_pic_boundaries_flag: Bool32, pub max_bytes_per_pic_denom: u32, pub max_bits_per_mb_denom: u32, @@ -37920,11 +37968,9 @@ impl ::std::default::Default for VideoEncodeH264CapabilitiesEXT<'_> { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null_mut(), flags: VideoEncodeH264CapabilityFlagsEXT::default(), - input_mode_flags: VideoEncodeH264InputModeFlagsEXT::default(), - output_mode_flags: VideoEncodeH264OutputModeFlagsEXT::default(), - max_p_picture_l0_reference_count: u8::default(), - max_b_picture_l0_reference_count: u8::default(), - max_l1_reference_count: u8::default(), + max_p_picture_l0_reference_count: u32::default(), + max_b_picture_l0_reference_count: u32::default(), + max_l1_reference_count: u32::default(), motion_vectors_over_pic_boundaries_flag: Bool32::default(), max_bytes_per_pic_denom: u32::default(), max_bits_per_mb_denom: u32::default(), @@ -37945,22 +37991,9 @@ impl<'a> VideoEncodeH264CapabilitiesEXT<'a> { self } #[inline] - pub fn input_mode_flags(mut self, input_mode_flags: VideoEncodeH264InputModeFlagsEXT) -> Self { - self.input_mode_flags = input_mode_flags; - self - } - #[inline] - pub fn output_mode_flags( - mut self, - output_mode_flags: VideoEncodeH264OutputModeFlagsEXT, - ) -> Self { - self.output_mode_flags = output_mode_flags; - self - } - #[inline] pub fn max_p_picture_l0_reference_count( mut self, - max_p_picture_l0_reference_count: u8, + max_p_picture_l0_reference_count: u32, ) -> Self { self.max_p_picture_l0_reference_count = max_p_picture_l0_reference_count; self @@ -37968,13 +38001,13 @@ impl<'a> VideoEncodeH264CapabilitiesEXT<'a> { #[inline] pub fn max_b_picture_l0_reference_count( mut self, - max_b_picture_l0_reference_count: u8, + 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: u8) -> Self { + pub fn max_l1_reference_count(mut self, max_l1_reference_count: u32) -> Self { self.max_l1_reference_count = max_l1_reference_count; self } @@ -38117,7 +38150,6 @@ impl<'a> VideoEncodeH264SessionParametersCreateInfoEXT<'a> { pub struct VideoEncodeH264DpbSlotInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, - pub slot_index: i8, pub p_std_reference_info: *const StdVideoEncodeH264ReferenceInfo, pub _marker: PhantomData<&'a ()>, } @@ -38127,7 +38159,6 @@ impl ::std::default::Default for VideoEncodeH264DpbSlotInfoEXT<'_> { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null(), - slot_index: i8::default(), p_std_reference_info: ::std::ptr::null(), _marker: PhantomData, } @@ -38136,12 +38167,8 @@ impl ::std::default::Default for VideoEncodeH264DpbSlotInfoEXT<'_> { unsafe impl<'a> TaggedStructure for VideoEncodeH264DpbSlotInfoEXT<'a> { const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT; } +unsafe impl ExtendsVideoReferenceSlotInfoKHR for VideoEncodeH264DpbSlotInfoEXT<'_> {} impl<'a> VideoEncodeH264DpbSlotInfoEXT<'a> { - #[inline] - pub fn slot_index(mut self, slot_index: i8) -> Self { - self.slot_index = slot_index; - self - } #[inline] pub fn std_reference_info( mut self, @@ -38158,10 +38185,10 @@ impl<'a> VideoEncodeH264DpbSlotInfoEXT<'a> { pub struct VideoEncodeH264VclFrameInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, - pub p_reference_final_lists: *const VideoEncodeH264ReferenceListsInfoEXT<'a>, + pub p_std_reference_final_lists: *const StdVideoEncodeH264ReferenceListsInfo, pub nalu_slice_entry_count: u32, pub p_nalu_slice_entries: *const VideoEncodeH264NaluSliceInfoEXT<'a>, - pub p_current_picture_info: *const StdVideoEncodeH264PictureInfo, + pub p_std_picture_info: *const StdVideoEncodeH264PictureInfo, pub _marker: PhantomData<&'a ()>, } impl ::std::default::Default for VideoEncodeH264VclFrameInfoEXT<'_> { @@ -38170,10 +38197,10 @@ impl ::std::default::Default for VideoEncodeH264VclFrameInfoEXT<'_> { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null(), - p_reference_final_lists: ::std::ptr::null(), + p_std_reference_final_lists: ::std::ptr::null(), nalu_slice_entry_count: u32::default(), p_nalu_slice_entries: ::std::ptr::null(), - p_current_picture_info: ::std::ptr::null(), + p_std_picture_info: ::std::ptr::null(), _marker: PhantomData, } } @@ -38184,11 +38211,11 @@ unsafe impl<'a> TaggedStructure for VideoEncodeH264VclFrameInfoEXT<'a> { unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH264VclFrameInfoEXT<'_> {} impl<'a> VideoEncodeH264VclFrameInfoEXT<'a> { #[inline] - pub fn reference_final_lists( + pub fn std_reference_final_lists( mut self, - reference_final_lists: &'a VideoEncodeH264ReferenceListsInfoEXT<'a>, + std_reference_final_lists: &'a StdVideoEncodeH264ReferenceListsInfo, ) -> Self { - self.p_reference_final_lists = reference_final_lists; + self.p_std_reference_final_lists = std_reference_final_lists; self } #[inline] @@ -38201,121 +38228,8 @@ impl<'a> VideoEncodeH264VclFrameInfoEXT<'a> { self } #[inline] - pub fn current_picture_info( - mut self, - current_picture_info: &'a StdVideoEncodeH264PictureInfo, - ) -> Self { - self.p_current_picture_info = current_picture_info; - self - } -} -#[repr(C)] -#[cfg_attr(feature = "debug", derive(Debug))] -#[derive(Copy, Clone)] -#[doc = ""] -pub struct VideoEncodeH264ReferenceListsInfoEXT<'a> { - pub s_type: StructureType, - pub p_next: *const c_void, - pub reference_list0_entry_count: u8, - pub p_reference_list0_entries: *const VideoEncodeH264DpbSlotInfoEXT<'a>, - pub reference_list1_entry_count: u8, - pub p_reference_list1_entries: *const VideoEncodeH264DpbSlotInfoEXT<'a>, - pub p_mem_mgmt_ctrl_operations: *const StdVideoEncodeH264RefMemMgmtCtrlOperations, - pub _marker: PhantomData<&'a ()>, -} -impl ::std::default::Default for VideoEncodeH264ReferenceListsInfoEXT<'_> { - #[inline] - fn default() -> Self { - Self { - s_type: Self::STRUCTURE_TYPE, - p_next: ::std::ptr::null(), - reference_list0_entry_count: u8::default(), - p_reference_list0_entries: ::std::ptr::null(), - reference_list1_entry_count: u8::default(), - p_reference_list1_entries: ::std::ptr::null(), - p_mem_mgmt_ctrl_operations: ::std::ptr::null(), - _marker: PhantomData, - } - } -} -unsafe impl<'a> TaggedStructure for VideoEncodeH264ReferenceListsInfoEXT<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H264_REFERENCE_LISTS_INFO_EXT; -} -impl<'a> VideoEncodeH264ReferenceListsInfoEXT<'a> { - #[inline] - pub fn reference_list0_entries( - mut self, - reference_list0_entries: &'a [VideoEncodeH264DpbSlotInfoEXT], - ) -> Self { - self.reference_list0_entry_count = reference_list0_entries.len() as _; - self.p_reference_list0_entries = reference_list0_entries.as_ptr(); - self - } - #[inline] - pub fn reference_list1_entries( - mut self, - reference_list1_entries: &'a [VideoEncodeH264DpbSlotInfoEXT], - ) -> Self { - self.reference_list1_entry_count = reference_list1_entries.len() as _; - self.p_reference_list1_entries = reference_list1_entries.as_ptr(); - self - } - #[inline] - pub fn mem_mgmt_ctrl_operations( - mut self, - mem_mgmt_ctrl_operations: &'a StdVideoEncodeH264RefMemMgmtCtrlOperations, - ) -> Self { - self.p_mem_mgmt_ctrl_operations = mem_mgmt_ctrl_operations; - self - } -} -#[repr(C)] -#[cfg_attr(feature = "debug", derive(Debug))] -#[derive(Copy, Clone)] -#[doc = ""] -pub struct VideoEncodeH264EmitPictureParametersInfoEXT<'a> { - pub s_type: StructureType, - pub p_next: *const c_void, - pub sps_id: u8, - pub emit_sps_enable: Bool32, - pub pps_id_entry_count: u32, - pub pps_id_entries: *const u8, - pub _marker: PhantomData<&'a ()>, -} -impl ::std::default::Default for VideoEncodeH264EmitPictureParametersInfoEXT<'_> { - #[inline] - fn default() -> Self { - Self { - s_type: Self::STRUCTURE_TYPE, - p_next: ::std::ptr::null(), - sps_id: u8::default(), - emit_sps_enable: Bool32::default(), - pps_id_entry_count: u32::default(), - pps_id_entries: ::std::ptr::null(), - _marker: PhantomData, - } - } -} -unsafe impl<'a> TaggedStructure for VideoEncodeH264EmitPictureParametersInfoEXT<'a> { - const STRUCTURE_TYPE: StructureType = - StructureType::VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_INFO_EXT; -} -unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH264EmitPictureParametersInfoEXT<'_> {} -impl<'a> VideoEncodeH264EmitPictureParametersInfoEXT<'a> { - #[inline] - pub fn sps_id(mut self, sps_id: u8) -> Self { - self.sps_id = sps_id; - self - } - #[inline] - pub fn emit_sps_enable(mut self, emit_sps_enable: bool) -> Self { - self.emit_sps_enable = emit_sps_enable.into(); - self - } - #[inline] - pub fn pps_id_entries(mut self, pps_id_entries: &'a [u8]) -> Self { - self.pps_id_entry_count = pps_id_entries.len() as _; - self.pps_id_entries = pps_id_entries.as_ptr(); + pub fn std_picture_info(mut self, std_picture_info: &'a StdVideoEncodeH264PictureInfo) -> Self { + self.p_std_picture_info = std_picture_info; self } } @@ -38360,8 +38274,8 @@ pub struct VideoEncodeH264NaluSliceInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub mb_count: u32, - pub p_reference_final_lists: *const VideoEncodeH264ReferenceListsInfoEXT<'a>, - pub p_slice_header_std: *const StdVideoEncodeH264SliceHeader, + pub p_std_reference_final_lists: *const StdVideoEncodeH264ReferenceListsInfo, + pub p_std_slice_header: *const StdVideoEncodeH264SliceHeader, pub _marker: PhantomData<&'a ()>, } impl ::std::default::Default for VideoEncodeH264NaluSliceInfoEXT<'_> { @@ -38371,8 +38285,8 @@ impl ::std::default::Default for VideoEncodeH264NaluSliceInfoEXT<'_> { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null(), mb_count: u32::default(), - p_reference_final_lists: ::std::ptr::null(), - p_slice_header_std: ::std::ptr::null(), + p_std_reference_final_lists: ::std::ptr::null(), + p_std_slice_header: ::std::ptr::null(), _marker: PhantomData, } } @@ -38387,16 +38301,16 @@ impl<'a> VideoEncodeH264NaluSliceInfoEXT<'a> { self } #[inline] - pub fn reference_final_lists( + pub fn std_reference_final_lists( mut self, - reference_final_lists: &'a VideoEncodeH264ReferenceListsInfoEXT<'a>, + std_reference_final_lists: &'a StdVideoEncodeH264ReferenceListsInfo, ) -> Self { - self.p_reference_final_lists = reference_final_lists; + self.p_std_reference_final_lists = std_reference_final_lists; self } #[inline] - pub fn slice_header_std(mut self, slice_header_std: &'a StdVideoEncodeH264SliceHeader) -> Self { - self.p_slice_header_std = slice_header_std; + pub fn std_slice_header(mut self, std_slice_header: &'a StdVideoEncodeH264SliceHeader) -> Self { + self.p_std_slice_header = std_slice_header; self } } @@ -38411,7 +38325,7 @@ pub struct VideoEncodeH264RateControlInfoEXT<'a> { pub idr_period: u32, pub consecutive_b_frame_count: u32, pub rate_control_structure: VideoEncodeH264RateControlStructureEXT, - pub temporal_layer_count: u8, + pub temporal_layer_count: u32, pub _marker: PhantomData<&'a ()>, } impl ::std::default::Default for VideoEncodeH264RateControlInfoEXT<'_> { @@ -38424,7 +38338,7 @@ impl ::std::default::Default for VideoEncodeH264RateControlInfoEXT<'_> { idr_period: u32::default(), consecutive_b_frame_count: u32::default(), rate_control_structure: VideoEncodeH264RateControlStructureEXT::default(), - temporal_layer_count: u8::default(), + temporal_layer_count: u32::default(), _marker: PhantomData, } } @@ -38458,7 +38372,7 @@ impl<'a> VideoEncodeH264RateControlInfoEXT<'a> { self } #[inline] - pub fn temporal_layer_count(mut self, temporal_layer_count: u8) -> Self { + pub fn temporal_layer_count(mut self, temporal_layer_count: u32) -> Self { self.temporal_layer_count = temporal_layer_count; self } @@ -38522,7 +38436,7 @@ impl VideoEncodeH264FrameSizeEXT { pub struct VideoEncodeH264RateControlLayerInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, - pub temporal_layer_id: u8, + pub temporal_layer_id: u32, pub use_initial_rc_qp: Bool32, pub initial_rc_qp: VideoEncodeH264QpEXT, pub use_min_qp: Bool32, @@ -38539,7 +38453,7 @@ impl ::std::default::Default for VideoEncodeH264RateControlLayerInfoEXT<'_> { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null(), - temporal_layer_id: u8::default(), + temporal_layer_id: u32::default(), use_initial_rc_qp: Bool32::default(), initial_rc_qp: VideoEncodeH264QpEXT::default(), use_min_qp: Bool32::default(), @@ -38563,7 +38477,7 @@ unsafe impl ExtendsVideoEncodeRateControlLayerInfoKHR } impl<'a> VideoEncodeH264RateControlLayerInfoEXT<'a> { #[inline] - pub fn temporal_layer_id(mut self, temporal_layer_id: u8) -> Self { + pub fn temporal_layer_id(mut self, temporal_layer_id: u32) -> Self { self.temporal_layer_id = temporal_layer_id; self } @@ -38616,25 +38530,23 @@ pub struct VideoEncodeH265CapabilitiesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub flags: VideoEncodeH265CapabilityFlagsEXT, - pub input_mode_flags: VideoEncodeH265InputModeFlagsEXT, - pub output_mode_flags: VideoEncodeH265OutputModeFlagsEXT, pub ctb_sizes: VideoEncodeH265CtbSizeFlagsEXT, pub transform_block_sizes: VideoEncodeH265TransformBlockSizeFlagsEXT, - pub max_p_picture_l0_reference_count: u8, - pub max_b_picture_l0_reference_count: u8, - pub max_l1_reference_count: u8, - pub max_sub_layers_count: u8, - pub min_log2_min_luma_coding_block_size_minus3: u8, - pub max_log2_min_luma_coding_block_size_minus3: u8, - pub min_log2_min_luma_transform_block_size_minus2: u8, - pub max_log2_min_luma_transform_block_size_minus2: u8, - pub min_max_transform_hierarchy_depth_inter: u8, - pub max_max_transform_hierarchy_depth_inter: u8, - pub min_max_transform_hierarchy_depth_intra: u8, - pub max_max_transform_hierarchy_depth_intra: u8, - pub max_diff_cu_qp_delta_depth: u8, - pub min_max_num_merge_cand: u8, - pub max_max_num_merge_cand: u8, + 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_layers_count: u32, + pub min_log2_min_luma_coding_block_size_minus3: u32, + pub max_log2_min_luma_coding_block_size_minus3: u32, + pub min_log2_min_luma_transform_block_size_minus2: u32, + pub max_log2_min_luma_transform_block_size_minus2: u32, + pub min_max_transform_hierarchy_depth_inter: u32, + pub max_max_transform_hierarchy_depth_inter: u32, + pub min_max_transform_hierarchy_depth_intra: u32, + pub max_max_transform_hierarchy_depth_intra: u32, + pub max_diff_cu_qp_delta_depth: u32, + pub min_max_num_merge_cand: u32, + pub max_max_num_merge_cand: u32, pub _marker: PhantomData<&'a ()>, } impl ::std::default::Default for VideoEncodeH265CapabilitiesEXT<'_> { @@ -38644,25 +38556,23 @@ impl ::std::default::Default for VideoEncodeH265CapabilitiesEXT<'_> { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null_mut(), flags: VideoEncodeH265CapabilityFlagsEXT::default(), - input_mode_flags: VideoEncodeH265InputModeFlagsEXT::default(), - output_mode_flags: VideoEncodeH265OutputModeFlagsEXT::default(), ctb_sizes: VideoEncodeH265CtbSizeFlagsEXT::default(), transform_block_sizes: VideoEncodeH265TransformBlockSizeFlagsEXT::default(), - max_p_picture_l0_reference_count: u8::default(), - max_b_picture_l0_reference_count: u8::default(), - max_l1_reference_count: u8::default(), - max_sub_layers_count: u8::default(), - min_log2_min_luma_coding_block_size_minus3: u8::default(), - max_log2_min_luma_coding_block_size_minus3: u8::default(), - min_log2_min_luma_transform_block_size_minus2: u8::default(), - max_log2_min_luma_transform_block_size_minus2: u8::default(), - min_max_transform_hierarchy_depth_inter: u8::default(), - max_max_transform_hierarchy_depth_inter: u8::default(), - min_max_transform_hierarchy_depth_intra: u8::default(), - max_max_transform_hierarchy_depth_intra: u8::default(), - max_diff_cu_qp_delta_depth: u8::default(), - min_max_num_merge_cand: u8::default(), - max_max_num_merge_cand: u8::default(), + max_p_picture_l0_reference_count: u32::default(), + max_b_picture_l0_reference_count: u32::default(), + max_l1_reference_count: u32::default(), + max_sub_layers_count: u32::default(), + min_log2_min_luma_coding_block_size_minus3: u32::default(), + max_log2_min_luma_coding_block_size_minus3: u32::default(), + min_log2_min_luma_transform_block_size_minus2: u32::default(), + max_log2_min_luma_transform_block_size_minus2: u32::default(), + min_max_transform_hierarchy_depth_inter: u32::default(), + max_max_transform_hierarchy_depth_inter: u32::default(), + min_max_transform_hierarchy_depth_intra: u32::default(), + max_max_transform_hierarchy_depth_intra: u32::default(), + max_diff_cu_qp_delta_depth: u32::default(), + min_max_num_merge_cand: u32::default(), + max_max_num_merge_cand: u32::default(), _marker: PhantomData, } } @@ -38678,19 +38588,6 @@ impl<'a> VideoEncodeH265CapabilitiesEXT<'a> { self } #[inline] - pub fn input_mode_flags(mut self, input_mode_flags: VideoEncodeH265InputModeFlagsEXT) -> Self { - self.input_mode_flags = input_mode_flags; - self - } - #[inline] - pub fn output_mode_flags( - mut self, - output_mode_flags: VideoEncodeH265OutputModeFlagsEXT, - ) -> Self { - self.output_mode_flags = output_mode_flags; - self - } - #[inline] pub fn ctb_sizes(mut self, ctb_sizes: VideoEncodeH265CtbSizeFlagsEXT) -> Self { self.ctb_sizes = ctb_sizes; self @@ -38706,7 +38603,7 @@ impl<'a> VideoEncodeH265CapabilitiesEXT<'a> { #[inline] pub fn max_p_picture_l0_reference_count( mut self, - max_p_picture_l0_reference_count: u8, + max_p_picture_l0_reference_count: u32, ) -> Self { self.max_p_picture_l0_reference_count = max_p_picture_l0_reference_count; self @@ -38714,25 +38611,25 @@ impl<'a> VideoEncodeH265CapabilitiesEXT<'a> { #[inline] pub fn max_b_picture_l0_reference_count( mut self, - max_b_picture_l0_reference_count: u8, + 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: u8) -> Self { + 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_layers_count(mut self, max_sub_layers_count: u8) -> Self { + pub fn max_sub_layers_count(mut self, max_sub_layers_count: u32) -> Self { self.max_sub_layers_count = max_sub_layers_count; self } #[inline] pub fn min_log2_min_luma_coding_block_size_minus3( mut self, - min_log2_min_luma_coding_block_size_minus3: u8, + min_log2_min_luma_coding_block_size_minus3: u32, ) -> Self { self.min_log2_min_luma_coding_block_size_minus3 = min_log2_min_luma_coding_block_size_minus3; @@ -38741,7 +38638,7 @@ impl<'a> VideoEncodeH265CapabilitiesEXT<'a> { #[inline] pub fn max_log2_min_luma_coding_block_size_minus3( mut self, - max_log2_min_luma_coding_block_size_minus3: u8, + max_log2_min_luma_coding_block_size_minus3: u32, ) -> Self { self.max_log2_min_luma_coding_block_size_minus3 = max_log2_min_luma_coding_block_size_minus3; @@ -38750,7 +38647,7 @@ impl<'a> VideoEncodeH265CapabilitiesEXT<'a> { #[inline] pub fn min_log2_min_luma_transform_block_size_minus2( mut self, - min_log2_min_luma_transform_block_size_minus2: u8, + min_log2_min_luma_transform_block_size_minus2: u32, ) -> Self { self.min_log2_min_luma_transform_block_size_minus2 = min_log2_min_luma_transform_block_size_minus2; @@ -38759,7 +38656,7 @@ impl<'a> VideoEncodeH265CapabilitiesEXT<'a> { #[inline] pub fn max_log2_min_luma_transform_block_size_minus2( mut self, - max_log2_min_luma_transform_block_size_minus2: u8, + max_log2_min_luma_transform_block_size_minus2: u32, ) -> Self { self.max_log2_min_luma_transform_block_size_minus2 = max_log2_min_luma_transform_block_size_minus2; @@ -38768,7 +38665,7 @@ impl<'a> VideoEncodeH265CapabilitiesEXT<'a> { #[inline] pub fn min_max_transform_hierarchy_depth_inter( mut self, - min_max_transform_hierarchy_depth_inter: u8, + min_max_transform_hierarchy_depth_inter: u32, ) -> Self { self.min_max_transform_hierarchy_depth_inter = min_max_transform_hierarchy_depth_inter; self @@ -38776,7 +38673,7 @@ impl<'a> VideoEncodeH265CapabilitiesEXT<'a> { #[inline] pub fn max_max_transform_hierarchy_depth_inter( mut self, - max_max_transform_hierarchy_depth_inter: u8, + max_max_transform_hierarchy_depth_inter: u32, ) -> Self { self.max_max_transform_hierarchy_depth_inter = max_max_transform_hierarchy_depth_inter; self @@ -38784,7 +38681,7 @@ impl<'a> VideoEncodeH265CapabilitiesEXT<'a> { #[inline] pub fn min_max_transform_hierarchy_depth_intra( mut self, - min_max_transform_hierarchy_depth_intra: u8, + min_max_transform_hierarchy_depth_intra: u32, ) -> Self { self.min_max_transform_hierarchy_depth_intra = min_max_transform_hierarchy_depth_intra; self @@ -38792,23 +38689,23 @@ impl<'a> VideoEncodeH265CapabilitiesEXT<'a> { #[inline] pub fn max_max_transform_hierarchy_depth_intra( mut self, - max_max_transform_hierarchy_depth_intra: u8, + max_max_transform_hierarchy_depth_intra: u32, ) -> Self { self.max_max_transform_hierarchy_depth_intra = max_max_transform_hierarchy_depth_intra; self } #[inline] - pub fn max_diff_cu_qp_delta_depth(mut self, max_diff_cu_qp_delta_depth: u8) -> Self { + pub fn max_diff_cu_qp_delta_depth(mut self, max_diff_cu_qp_delta_depth: u32) -> Self { self.max_diff_cu_qp_delta_depth = max_diff_cu_qp_delta_depth; self } #[inline] - pub fn min_max_num_merge_cand(mut self, min_max_num_merge_cand: u8) -> Self { + pub fn min_max_num_merge_cand(mut self, min_max_num_merge_cand: u32) -> Self { self.min_max_num_merge_cand = min_max_num_merge_cand; self } #[inline] - pub fn max_max_num_merge_cand(mut self, max_max_num_merge_cand: u8) -> Self { + pub fn max_max_num_merge_cand(mut self, max_max_num_merge_cand: u32) -> Self { self.max_max_num_merge_cand = max_max_num_merge_cand; self } @@ -38939,10 +38836,10 @@ impl<'a> VideoEncodeH265SessionParametersCreateInfoEXT<'a> { pub struct VideoEncodeH265VclFrameInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, - pub p_reference_final_lists: *const VideoEncodeH265ReferenceListsInfoEXT<'a>, + pub p_std_reference_final_lists: *const StdVideoEncodeH265ReferenceListsInfo, pub nalu_slice_segment_entry_count: u32, pub p_nalu_slice_segment_entries: *const VideoEncodeH265NaluSliceSegmentInfoEXT<'a>, - pub p_current_picture_info: *const StdVideoEncodeH265PictureInfo, + pub p_std_picture_info: *const StdVideoEncodeH265PictureInfo, pub _marker: PhantomData<&'a ()>, } impl ::std::default::Default for VideoEncodeH265VclFrameInfoEXT<'_> { @@ -38951,10 +38848,10 @@ impl ::std::default::Default for VideoEncodeH265VclFrameInfoEXT<'_> { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null(), - p_reference_final_lists: ::std::ptr::null(), + p_std_reference_final_lists: ::std::ptr::null(), nalu_slice_segment_entry_count: u32::default(), p_nalu_slice_segment_entries: ::std::ptr::null(), - p_current_picture_info: ::std::ptr::null(), + p_std_picture_info: ::std::ptr::null(), _marker: PhantomData, } } @@ -38965,11 +38862,11 @@ unsafe impl<'a> TaggedStructure for VideoEncodeH265VclFrameInfoEXT<'a> { unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH265VclFrameInfoEXT<'_> {} impl<'a> VideoEncodeH265VclFrameInfoEXT<'a> { #[inline] - pub fn reference_final_lists( + pub fn std_reference_final_lists( mut self, - reference_final_lists: &'a VideoEncodeH265ReferenceListsInfoEXT<'a>, + std_reference_final_lists: &'a StdVideoEncodeH265ReferenceListsInfo, ) -> Self { - self.p_reference_final_lists = reference_final_lists; + self.p_std_reference_final_lists = std_reference_final_lists; self } #[inline] @@ -38982,75 +38879,8 @@ impl<'a> VideoEncodeH265VclFrameInfoEXT<'a> { self } #[inline] - pub fn current_picture_info( - mut self, - current_picture_info: &'a StdVideoEncodeH265PictureInfo, - ) -> Self { - self.p_current_picture_info = current_picture_info; - self - } -} -#[repr(C)] -#[cfg_attr(feature = "debug", derive(Debug))] -#[derive(Copy, Clone)] -#[doc = ""] -pub struct VideoEncodeH265EmitPictureParametersInfoEXT<'a> { - pub s_type: StructureType, - pub p_next: *const c_void, - pub vps_id: u8, - pub sps_id: u8, - pub emit_vps_enable: Bool32, - pub emit_sps_enable: Bool32, - pub pps_id_entry_count: u32, - pub pps_id_entries: *const u8, - pub _marker: PhantomData<&'a ()>, -} -impl ::std::default::Default for VideoEncodeH265EmitPictureParametersInfoEXT<'_> { - #[inline] - fn default() -> Self { - Self { - s_type: Self::STRUCTURE_TYPE, - p_next: ::std::ptr::null(), - vps_id: u8::default(), - sps_id: u8::default(), - emit_vps_enable: Bool32::default(), - emit_sps_enable: Bool32::default(), - pps_id_entry_count: u32::default(), - pps_id_entries: ::std::ptr::null(), - _marker: PhantomData, - } - } -} -unsafe impl<'a> TaggedStructure for VideoEncodeH265EmitPictureParametersInfoEXT<'a> { - const STRUCTURE_TYPE: StructureType = - StructureType::VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_INFO_EXT; -} -unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH265EmitPictureParametersInfoEXT<'_> {} -impl<'a> VideoEncodeH265EmitPictureParametersInfoEXT<'a> { - #[inline] - pub fn vps_id(mut self, vps_id: u8) -> Self { - self.vps_id = vps_id; - self - } - #[inline] - pub fn sps_id(mut self, sps_id: u8) -> Self { - self.sps_id = sps_id; - self - } - #[inline] - pub fn emit_vps_enable(mut self, emit_vps_enable: bool) -> Self { - self.emit_vps_enable = emit_vps_enable.into(); - self - } - #[inline] - pub fn emit_sps_enable(mut self, emit_sps_enable: bool) -> Self { - self.emit_sps_enable = emit_sps_enable.into(); - self - } - #[inline] - pub fn pps_id_entries(mut self, pps_id_entries: &'a [u8]) -> Self { - self.pps_id_entry_count = pps_id_entries.len() as _; - self.pps_id_entries = pps_id_entries.as_ptr(); + pub fn std_picture_info(mut self, std_picture_info: &'a StdVideoEncodeH265PictureInfo) -> Self { + self.p_std_picture_info = std_picture_info; self } } @@ -39062,8 +38892,8 @@ pub struct VideoEncodeH265NaluSliceSegmentInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub ctb_count: u32, - pub p_reference_final_lists: *const VideoEncodeH265ReferenceListsInfoEXT<'a>, - pub p_slice_segment_header_std: *const StdVideoEncodeH265SliceSegmentHeader, + pub p_std_reference_final_lists: *const StdVideoEncodeH265ReferenceListsInfo, + pub p_std_slice_segment_header: *const StdVideoEncodeH265SliceSegmentHeader, pub _marker: PhantomData<&'a ()>, } impl ::std::default::Default for VideoEncodeH265NaluSliceSegmentInfoEXT<'_> { @@ -39073,8 +38903,8 @@ impl ::std::default::Default for VideoEncodeH265NaluSliceSegmentInfoEXT<'_> { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null(), ctb_count: u32::default(), - p_reference_final_lists: ::std::ptr::null(), - p_slice_segment_header_std: ::std::ptr::null(), + p_std_reference_final_lists: ::std::ptr::null(), + p_std_slice_segment_header: ::std::ptr::null(), _marker: PhantomData, } } @@ -39090,19 +38920,19 @@ impl<'a> VideoEncodeH265NaluSliceSegmentInfoEXT<'a> { self } #[inline] - pub fn reference_final_lists( + pub fn std_reference_final_lists( mut self, - reference_final_lists: &'a VideoEncodeH265ReferenceListsInfoEXT<'a>, + std_reference_final_lists: &'a StdVideoEncodeH265ReferenceListsInfo, ) -> Self { - self.p_reference_final_lists = reference_final_lists; + self.p_std_reference_final_lists = std_reference_final_lists; self } #[inline] - pub fn slice_segment_header_std( + pub fn std_slice_segment_header( mut self, - slice_segment_header_std: &'a StdVideoEncodeH265SliceSegmentHeader, + std_slice_segment_header: &'a StdVideoEncodeH265SliceSegmentHeader, ) -> Self { - self.p_slice_segment_header_std = slice_segment_header_std; + self.p_std_slice_segment_header = std_slice_segment_header; self } } @@ -39117,7 +38947,7 @@ pub struct VideoEncodeH265RateControlInfoEXT<'a> { pub idr_period: u32, pub consecutive_b_frame_count: u32, pub rate_control_structure: VideoEncodeH265RateControlStructureEXT, - pub sub_layer_count: u8, + pub sub_layer_count: u32, pub _marker: PhantomData<&'a ()>, } impl ::std::default::Default for VideoEncodeH265RateControlInfoEXT<'_> { @@ -39130,7 +38960,7 @@ impl ::std::default::Default for VideoEncodeH265RateControlInfoEXT<'_> { idr_period: u32::default(), consecutive_b_frame_count: u32::default(), rate_control_structure: VideoEncodeH265RateControlStructureEXT::default(), - sub_layer_count: u8::default(), + sub_layer_count: u32::default(), _marker: PhantomData, } } @@ -39164,7 +38994,7 @@ impl<'a> VideoEncodeH265RateControlInfoEXT<'a> { self } #[inline] - pub fn sub_layer_count(mut self, sub_layer_count: u8) -> Self { + pub fn sub_layer_count(mut self, sub_layer_count: u32) -> Self { self.sub_layer_count = sub_layer_count; self } @@ -39228,7 +39058,7 @@ impl VideoEncodeH265FrameSizeEXT { pub struct VideoEncodeH265RateControlLayerInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, - pub temporal_id: u8, + pub temporal_id: u32, pub use_initial_rc_qp: Bool32, pub initial_rc_qp: VideoEncodeH265QpEXT, pub use_min_qp: Bool32, @@ -39245,7 +39075,7 @@ impl ::std::default::Default for VideoEncodeH265RateControlLayerInfoEXT<'_> { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null(), - temporal_id: u8::default(), + temporal_id: u32::default(), use_initial_rc_qp: Bool32::default(), initial_rc_qp: VideoEncodeH265QpEXT::default(), use_min_qp: Bool32::default(), @@ -39269,7 +39099,7 @@ unsafe impl ExtendsVideoEncodeRateControlLayerInfoKHR } impl<'a> VideoEncodeH265RateControlLayerInfoEXT<'a> { #[inline] - pub fn temporal_id(mut self, temporal_id: u8) -> Self { + pub fn temporal_id(mut self, temporal_id: u32) -> Self { self.temporal_id = temporal_id; self } @@ -39354,7 +39184,6 @@ impl<'a> VideoEncodeH265ProfileInfoEXT<'a> { pub struct VideoEncodeH265DpbSlotInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, - pub slot_index: i8, pub p_std_reference_info: *const StdVideoEncodeH265ReferenceInfo, pub _marker: PhantomData<&'a ()>, } @@ -39364,7 +39193,6 @@ impl ::std::default::Default for VideoEncodeH265DpbSlotInfoEXT<'_> { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null(), - slot_index: i8::default(), p_std_reference_info: ::std::ptr::null(), _marker: PhantomData, } @@ -39373,12 +39201,8 @@ impl ::std::default::Default for VideoEncodeH265DpbSlotInfoEXT<'_> { unsafe impl<'a> TaggedStructure for VideoEncodeH265DpbSlotInfoEXT<'a> { const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT; } +unsafe impl ExtendsVideoReferenceSlotInfoKHR for VideoEncodeH265DpbSlotInfoEXT<'_> {} impl<'a> VideoEncodeH265DpbSlotInfoEXT<'a> { - #[inline] - pub fn slot_index(mut self, slot_index: i8) -> Self { - self.slot_index = slot_index; - self - } #[inline] pub fn std_reference_info( mut self, @@ -39391,66 +39215,6 @@ impl<'a> VideoEncodeH265DpbSlotInfoEXT<'a> { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct VideoEncodeH265ReferenceListsInfoEXT<'a> { - pub s_type: StructureType, - pub p_next: *const c_void, - pub reference_list0_entry_count: u8, - pub p_reference_list0_entries: *const VideoEncodeH265DpbSlotInfoEXT<'a>, - pub reference_list1_entry_count: u8, - pub p_reference_list1_entries: *const VideoEncodeH265DpbSlotInfoEXT<'a>, - pub p_reference_modifications: *const StdVideoEncodeH265ReferenceModifications, - pub _marker: PhantomData<&'a ()>, -} -impl ::std::default::Default for VideoEncodeH265ReferenceListsInfoEXT<'_> { - #[inline] - fn default() -> Self { - Self { - s_type: Self::STRUCTURE_TYPE, - p_next: ::std::ptr::null(), - reference_list0_entry_count: u8::default(), - p_reference_list0_entries: ::std::ptr::null(), - reference_list1_entry_count: u8::default(), - p_reference_list1_entries: ::std::ptr::null(), - p_reference_modifications: ::std::ptr::null(), - _marker: PhantomData, - } - } -} -unsafe impl<'a> TaggedStructure for VideoEncodeH265ReferenceListsInfoEXT<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H265_REFERENCE_LISTS_INFO_EXT; -} -impl<'a> VideoEncodeH265ReferenceListsInfoEXT<'a> { - #[inline] - pub fn reference_list0_entries( - mut self, - reference_list0_entries: &'a [VideoEncodeH265DpbSlotInfoEXT], - ) -> Self { - self.reference_list0_entry_count = reference_list0_entries.len() as _; - self.p_reference_list0_entries = reference_list0_entries.as_ptr(); - self - } - #[inline] - pub fn reference_list1_entries( - mut self, - reference_list1_entries: &'a [VideoEncodeH265DpbSlotInfoEXT], - ) -> Self { - self.reference_list1_entry_count = reference_list1_entries.len() as _; - self.p_reference_list1_entries = reference_list1_entries.as_ptr(); - self - } - #[inline] - pub fn reference_modifications( - mut self, - reference_modifications: &'a StdVideoEncodeH265ReferenceModifications, - ) -> Self { - self.p_reference_modifications = reference_modifications; - self - } -} -#[repr(C)] -#[cfg_attr(feature = "debug", derive(Debug))] -#[derive(Copy, Clone)] #[doc = ""] pub struct PhysicalDeviceInheritedViewportScissorFeaturesNV<'a> { pub s_type: StructureType, @@ -46811,7 +46575,7 @@ impl<'a> PhysicalDeviceSwapchainMaintenance1FeaturesEXT<'a> { #[doc = ""] pub struct SwapchainPresentFenceInfoEXT<'a> { pub s_type: StructureType, - pub p_next: *mut c_void, + pub p_next: *const c_void, pub swapchain_count: u32, pub p_fences: *const Fence, pub _marker: PhantomData<&'a ()>, @@ -46821,7 +46585,7 @@ impl ::std::default::Default for SwapchainPresentFenceInfoEXT<'_> { fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, - p_next: ::std::ptr::null_mut(), + p_next: ::std::ptr::null(), swapchain_count: u32::default(), p_fences: ::std::ptr::null(), _marker: PhantomData, @@ -46846,7 +46610,7 @@ impl<'a> SwapchainPresentFenceInfoEXT<'a> { #[doc = ""] pub struct SwapchainPresentModesCreateInfoEXT<'a> { pub s_type: StructureType, - pub p_next: *mut c_void, + pub p_next: *const c_void, pub present_mode_count: u32, pub p_present_modes: *const PresentModeKHR, pub _marker: PhantomData<&'a ()>, @@ -46856,7 +46620,7 @@ impl ::std::default::Default for SwapchainPresentModesCreateInfoEXT<'_> { fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, - p_next: ::std::ptr::null_mut(), + p_next: ::std::ptr::null(), present_mode_count: u32::default(), p_present_modes: ::std::ptr::null(), _marker: PhantomData, @@ -46881,7 +46645,7 @@ impl<'a> SwapchainPresentModesCreateInfoEXT<'a> { #[doc = ""] pub struct SwapchainPresentModeInfoEXT<'a> { pub s_type: StructureType, - pub p_next: *mut c_void, + pub p_next: *const c_void, pub swapchain_count: u32, pub p_present_modes: *const PresentModeKHR, pub _marker: PhantomData<&'a ()>, @@ -46891,7 +46655,7 @@ impl ::std::default::Default for SwapchainPresentModeInfoEXT<'_> { fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, - p_next: ::std::ptr::null_mut(), + p_next: ::std::ptr::null(), swapchain_count: u32::default(), p_present_modes: ::std::ptr::null(), _marker: PhantomData, diff --git a/ash/src/vk/enums.rs b/ash/src/vk/enums.rs index de2d35ea1..289b6219f 100644 --- a/ash/src/vk/enums.rs +++ b/ash/src/vk/enums.rs @@ -1744,6 +1744,8 @@ impl VendorId { pub const MESA: Self = Self(0x1_0005); #[doc = "PoCL vendor ID"] pub const POCL: Self = Self(0x1_0006); + #[doc = "Mobileye vendor ID"] + pub const MOBILEYE: Self = Self(0x1_0007); } #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] @@ -2900,6 +2902,9 @@ impl fmt::Debug for Result { Self::THREAD_DONE_KHR => Some("THREAD_DONE_KHR"), Self::OPERATION_DEFERRED_KHR => Some("OPERATION_DEFERRED_KHR"), Self::OPERATION_NOT_DEFERRED_KHR => Some("OPERATION_NOT_DEFERRED_KHR"), + Self::ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR => { + Some("ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR") + } Self::ERROR_COMPRESSION_EXHAUSTED_EXT => Some("ERROR_COMPRESSION_EXHAUSTED_EXT"), Self::ERROR_OUT_OF_POOL_MEMORY => Some("ERROR_OUT_OF_POOL_MEMORY"), Self::ERROR_INVALID_EXTERNAL_HANDLE => Some("ERROR_INVALID_EXTERNAL_HANDLE"), diff --git a/ash/src/vk/extensions.rs b/ash/src/vk/extensions.rs index f06ae2241..609b85bc4 100644 --- a/ash/src/vk/extensions.rs +++ b/ash/src/vk/extensions.rs @@ -2872,7 +2872,7 @@ impl AmdShaderBallotFn { impl ExtVideoEncodeH264Fn { pub const NAME: &'static ::std::ffi::CStr = unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_video_encode_h264\0") }; - pub const SPEC_VERSION: u32 = 9u32; + pub const SPEC_VERSION: u32 = 10u32; } #[derive(Clone)] pub struct ExtVideoEncodeH264Fn {} @@ -2894,11 +2894,9 @@ impl StructureType { pub const VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT: Self = Self(1_000_038_003); pub const VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT: Self = Self(1_000_038_004); pub const VIDEO_ENCODE_H264_NALU_SLICE_INFO_EXT: Self = Self(1_000_038_005); - pub const VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_INFO_EXT: Self = Self(1_000_038_006); pub const VIDEO_ENCODE_H264_PROFILE_INFO_EXT: Self = Self(1_000_038_007); pub const VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT: Self = Self(1_000_038_008); pub const VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT: Self = Self(1_000_038_009); - pub const VIDEO_ENCODE_H264_REFERENCE_LISTS_INFO_EXT: Self = Self(1_000_038_010); } #[doc = "Generated from 'VK_EXT_video_encode_h264'"] impl VideoCodecOperationFlagsKHR { @@ -2907,7 +2905,7 @@ impl VideoCodecOperationFlagsKHR { impl ExtVideoEncodeH265Fn { pub const NAME: &'static ::std::ffi::CStr = unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_video_encode_h265\0") }; - pub const SPEC_VERSION: u32 = 9u32; + pub const SPEC_VERSION: u32 = 10u32; } #[derive(Clone)] pub struct ExtVideoEncodeH265Fn {} @@ -2929,9 +2927,7 @@ impl StructureType { pub const VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT: Self = Self(1_000_039_003); pub const VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT: Self = Self(1_000_039_004); pub const VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_EXT: Self = Self(1_000_039_005); - pub const VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_INFO_EXT: Self = Self(1_000_039_006); pub const VIDEO_ENCODE_H265_PROFILE_INFO_EXT: Self = Self(1_000_039_007); - pub const VIDEO_ENCODE_H265_REFERENCE_LISTS_INFO_EXT: Self = Self(1_000_039_008); pub const VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT: Self = Self(1_000_039_009); pub const VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT: Self = Self(1_000_039_010); } @@ -14826,7 +14822,7 @@ impl StructureType { impl KhrVideoEncodeQueueFn { pub const NAME: &'static ::std::ffi::CStr = unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_video_encode_queue\0") }; - pub const SPEC_VERSION: u32 = 7u32; + pub const SPEC_VERSION: u32 = 8u32; } #[allow(non_camel_case_types)] pub type PFN_vkCmdEncodeVideoKHR = unsafe extern "system" fn( @@ -14903,19 +14899,24 @@ impl PipelineStageFlags2 { } #[doc = "Generated from 'VK_KHR_video_encode_queue'"] impl QueryType { - pub const VIDEO_ENCODESTREAM_BUFFER_RANGE_KHR: Self = Self(1_000_299_000); + pub const VIDEO_ENCODE_FEEDBACK_KHR: Self = Self(1_000_299_000); } #[doc = "Generated from 'VK_KHR_video_encode_queue'"] impl QueueFlags { pub const VIDEO_ENCODE_KHR: Self = Self(0b100_0000); } #[doc = "Generated from 'VK_KHR_video_encode_queue'"] +impl Result { + pub const ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR: Self = Self(-1_000_299_000); +} +#[doc = "Generated from 'VK_KHR_video_encode_queue'"] impl StructureType { pub const VIDEO_ENCODE_INFO_KHR: Self = Self(1_000_299_000); pub const VIDEO_ENCODE_RATE_CONTROL_INFO_KHR: Self = Self(1_000_299_001); pub const VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR: Self = Self(1_000_299_002); pub const VIDEO_ENCODE_CAPABILITIES_KHR: Self = Self(1_000_299_003); pub const VIDEO_ENCODE_USAGE_INFO_KHR: Self = Self(1_000_299_004); + pub const QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR: Self = Self(1_000_299_005); } #[doc = "Generated from 'VK_KHR_video_encode_queue'"] impl VideoCodingControlFlagsKHR { diff --git a/ash/src/vk/native.rs b/ash/src/vk/native.rs index dc799d9fd..1a6b58d96 100644 --- a/ash/src/vk/native.rs +++ b/ash/src/vk/native.rs @@ -7050,42 +7050,48 @@ impl StdVideoEncodeH264ReferenceInfoFlags { #[repr(C)] #[repr(align(4))] #[derive(Debug, Copy, Clone)] -pub struct StdVideoEncodeH264RefMgmtFlags { +pub struct StdVideoEncodeH264ReferenceListsInfoFlags { pub _bitfield_align_1: [u8; 0], pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, pub __bindgen_padding_0: [u8; 3usize], } #[test] -fn bindgen_test_layout_StdVideoEncodeH264RefMgmtFlags() { +fn bindgen_test_layout_StdVideoEncodeH264ReferenceListsInfoFlags() { assert_eq!( - ::std::mem::size_of::(), + ::std::mem::size_of::(), 4usize, - concat!("Size of: ", stringify!(StdVideoEncodeH264RefMgmtFlags)) + concat!( + "Size of: ", + stringify!(StdVideoEncodeH264ReferenceListsInfoFlags) + ) ); assert_eq!( - ::std::mem::align_of::(), + ::std::mem::align_of::(), 4usize, - concat!("Alignment of ", stringify!(StdVideoEncodeH264RefMgmtFlags)) + concat!( + "Alignment of ", + stringify!(StdVideoEncodeH264ReferenceListsInfoFlags) + ) ); } -impl StdVideoEncodeH264RefMgmtFlags { +impl StdVideoEncodeH264ReferenceListsInfoFlags { #[inline] - pub fn ref_pic_list_modification_l0_flag(&self) -> u32 { + pub fn ref_pic_list_modification_flag_l0(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } } #[inline] - pub fn set_ref_pic_list_modification_l0_flag(&mut self, val: u32) { + pub fn set_ref_pic_list_modification_flag_l0(&mut self, val: u32) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(0usize, 1u8, val as u64) } } #[inline] - pub fn ref_pic_list_modification_l1_flag(&self) -> u32 { + pub fn ref_pic_list_modification_flag_l1(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } } #[inline] - pub fn set_ref_pic_list_modification_l1_flag(&mut self, val: u32) { + pub fn set_ref_pic_list_modification_flag_l1(&mut self, val: u32) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(1usize, 1u8, val as u64) @@ -7093,19 +7099,19 @@ impl StdVideoEncodeH264RefMgmtFlags { } #[inline] pub fn new_bitfield_1( - ref_pic_list_modification_l0_flag: u32, - ref_pic_list_modification_l1_flag: u32, + ref_pic_list_modification_flag_l0: u32, + ref_pic_list_modification_flag_l1: u32, ) -> __BindgenBitfieldUnit<[u8; 1usize]> { let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); __bindgen_bitfield_unit.set(0usize, 1u8, { - let ref_pic_list_modification_l0_flag: u32 = - unsafe { ::std::mem::transmute(ref_pic_list_modification_l0_flag) }; - ref_pic_list_modification_l0_flag as u64 + let ref_pic_list_modification_flag_l0: u32 = + unsafe { ::std::mem::transmute(ref_pic_list_modification_flag_l0) }; + ref_pic_list_modification_flag_l0 as u64 }); __bindgen_bitfield_unit.set(1usize, 1u8, { - let ref_pic_list_modification_l1_flag: u32 = - unsafe { ::std::mem::transmute(ref_pic_list_modification_l1_flag) }; - ref_pic_list_modification_l1_flag as u64 + let ref_pic_list_modification_flag_l1: u32 = + unsafe { ::std::mem::transmute(ref_pic_list_modification_flag_l1) }; + ref_pic_list_modification_flag_l1 as u64 }); __bindgen_bitfield_unit } @@ -7255,34 +7261,39 @@ fn bindgen_test_layout_StdVideoEncodeH264RefPicMarkingEntry() { } #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct StdVideoEncodeH264RefMemMgmtCtrlOperations { - pub flags: StdVideoEncodeH264RefMgmtFlags, +pub struct StdVideoEncodeH264ReferenceListsInfo { + pub flags: StdVideoEncodeH264ReferenceListsInfoFlags, + pub refPicList0EntryCount: u8, + pub refPicList1EntryCount: u8, pub refList0ModOpCount: u8, - pub pRefList0ModOperations: *const StdVideoEncodeH264RefListModEntry, pub refList1ModOpCount: u8, - pub pRefList1ModOperations: *const StdVideoEncodeH264RefListModEntry, pub refPicMarkingOpCount: u8, + pub reserved1: [u8; 7usize], + pub pRefPicList0Entries: *const u8, + pub pRefPicList1Entries: *const u8, + pub pRefList0ModOperations: *const StdVideoEncodeH264RefListModEntry, + pub pRefList1ModOperations: *const StdVideoEncodeH264RefListModEntry, pub pRefPicMarkingOperations: *const StdVideoEncodeH264RefPicMarkingEntry, } #[test] -fn bindgen_test_layout_StdVideoEncodeH264RefMemMgmtCtrlOperations() { - const UNINIT: ::std::mem::MaybeUninit = +fn bindgen_test_layout_StdVideoEncodeH264ReferenceListsInfo() { + const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( - ::std::mem::size_of::(), - 48usize, + ::std::mem::size_of::(), + 56usize, concat!( "Size of: ", - stringify!(StdVideoEncodeH264RefMemMgmtCtrlOperations) + stringify!(StdVideoEncodeH264ReferenceListsInfo) ) ); assert_eq!( - ::std::mem::align_of::(), + ::std::mem::align_of::(), 8usize, concat!( "Alignment of ", - stringify!(StdVideoEncodeH264RefMemMgmtCtrlOperations) + stringify!(StdVideoEncodeH264ReferenceListsInfo) ) ); assert_eq!( @@ -7290,67 +7301,117 @@ fn bindgen_test_layout_StdVideoEncodeH264RefMemMgmtCtrlOperations() { 0usize, concat!( "Offset of field: ", - stringify!(StdVideoEncodeH264RefMemMgmtCtrlOperations), + stringify!(StdVideoEncodeH264ReferenceListsInfo), "::", stringify!(flags) ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).refList0ModOpCount) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).refPicList0EntryCount) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", - stringify!(StdVideoEncodeH264RefMemMgmtCtrlOperations), + stringify!(StdVideoEncodeH264ReferenceListsInfo), + "::", + stringify!(refPicList0EntryCount) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).refPicList1EntryCount) as usize - ptr as usize }, + 5usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264ReferenceListsInfo), + "::", + stringify!(refPicList1EntryCount) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).refList0ModOpCount) as usize - ptr as usize }, + 6usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264ReferenceListsInfo), "::", stringify!(refList0ModOpCount) ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pRefList0ModOperations) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).refList1ModOpCount) as usize - ptr as usize }, + 7usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264ReferenceListsInfo), + "::", + stringify!(refList1ModOpCount) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).refPicMarkingOpCount) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", - stringify!(StdVideoEncodeH264RefMemMgmtCtrlOperations), + stringify!(StdVideoEncodeH264ReferenceListsInfo), "::", - stringify!(pRefList0ModOperations) + stringify!(refPicMarkingOpCount) ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).refList1ModOpCount) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize }, + 9usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264ReferenceListsInfo), + "::", + stringify!(reserved1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pRefPicList0Entries) as usize - ptr as usize }, 16usize, concat!( "Offset of field: ", - stringify!(StdVideoEncodeH264RefMemMgmtCtrlOperations), + stringify!(StdVideoEncodeH264ReferenceListsInfo), "::", - stringify!(refList1ModOpCount) + stringify!(pRefPicList0Entries) ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pRefList1ModOperations) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).pRefPicList1Entries) as usize - ptr as usize }, 24usize, concat!( "Offset of field: ", - stringify!(StdVideoEncodeH264RefMemMgmtCtrlOperations), + stringify!(StdVideoEncodeH264ReferenceListsInfo), "::", - stringify!(pRefList1ModOperations) + stringify!(pRefPicList1Entries) ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).refPicMarkingOpCount) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).pRefList0ModOperations) as usize - ptr as usize }, 32usize, concat!( "Offset of field: ", - stringify!(StdVideoEncodeH264RefMemMgmtCtrlOperations), + stringify!(StdVideoEncodeH264ReferenceListsInfo), "::", - stringify!(refPicMarkingOpCount) + stringify!(pRefList0ModOperations) ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pRefPicMarkingOperations) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).pRefList1ModOperations) as usize - ptr as usize }, 40usize, concat!( "Offset of field: ", - stringify!(StdVideoEncodeH264RefMemMgmtCtrlOperations), + stringify!(StdVideoEncodeH264ReferenceListsInfo), + "::", + stringify!(pRefList1ModOperations) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pRefPicMarkingOperations) as usize - ptr as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264ReferenceListsInfo), "::", stringify!(pRefPicMarkingOperations) ) @@ -7362,6 +7423,7 @@ pub struct StdVideoEncodeH264PictureInfo { pub flags: StdVideoEncodeH264PictureInfoFlags, pub seq_parameter_set_id: u8, pub pic_parameter_set_id: u8, + pub reserved1: u16, pub pictureType: StdVideoH264PictureType, pub frame_num: u32, pub PicOrderCnt: i32, @@ -7411,6 +7473,16 @@ fn bindgen_test_layout_StdVideoEncodeH264PictureInfo() { stringify!(pic_parameter_set_id) ) ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize }, + 6usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264PictureInfo), + "::", + stringify!(reserved1) + ) + ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).pictureType) as usize - ptr as usize }, 8usize, @@ -7446,6 +7518,7 @@ fn bindgen_test_layout_StdVideoEncodeH264PictureInfo() { #[derive(Debug, Copy, Clone)] pub struct StdVideoEncodeH264ReferenceInfo { pub flags: StdVideoEncodeH264ReferenceInfoFlags, + pub pictureType: StdVideoH264PictureType, pub FrameNum: u32, pub PicOrderCnt: i32, pub long_term_pic_num: u16, @@ -7458,7 +7531,7 @@ fn bindgen_test_layout_StdVideoEncodeH264ReferenceInfo() { let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), - 16usize, + 20usize, concat!("Size of: ", stringify!(StdVideoEncodeH264ReferenceInfo)) ); assert_eq!( @@ -7477,8 +7550,18 @@ fn bindgen_test_layout_StdVideoEncodeH264ReferenceInfo() { ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).FrameNum) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).pictureType) as usize - ptr as usize }, 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264ReferenceInfo), + "::", + stringify!(pictureType) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).FrameNum) as usize - ptr as usize }, + 8usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH264ReferenceInfo), @@ -7488,7 +7571,7 @@ fn bindgen_test_layout_StdVideoEncodeH264ReferenceInfo() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).PicOrderCnt) as usize - ptr as usize }, - 8usize, + 12usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH264ReferenceInfo), @@ -7498,7 +7581,7 @@ fn bindgen_test_layout_StdVideoEncodeH264ReferenceInfo() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).long_term_pic_num) as usize - ptr as usize }, - 12usize, + 16usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH264ReferenceInfo), @@ -7508,7 +7591,7 @@ fn bindgen_test_layout_StdVideoEncodeH264ReferenceInfo() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).long_term_frame_idx) as usize - ptr as usize }, - 14usize, + 18usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH264ReferenceInfo), @@ -7530,6 +7613,8 @@ pub struct StdVideoEncodeH264SliceHeader { pub disable_deblocking_filter_idc: StdVideoH264DisableDeblockingFilterIdc, pub slice_alpha_c0_offset_div2: i8, pub slice_beta_offset_div2: i8, + pub reserved1: u16, + pub reserved2: u32, pub pWeightTable: *const StdVideoEncodeH264WeightTable, } #[test] @@ -7653,6 +7738,26 @@ fn bindgen_test_layout_StdVideoEncodeH264SliceHeader() { stringify!(slice_beta_offset_div2) ) ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize }, + 26usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264SliceHeader), + "::", + stringify!(reserved1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved2) as usize - ptr as usize }, + 28usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264SliceHeader), + "::", + stringify!(reserved2) + ) + ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).pWeightTable) as usize - ptr as usize }, 32usize, @@ -8511,31 +8616,31 @@ fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeader() { #[repr(C)] #[repr(align(4))] #[derive(Debug, Copy, Clone)] -pub struct StdVideoEncodeH265ReferenceModificationFlags { +pub struct StdVideoEncodeH265ReferenceListsInfoFlags { pub _bitfield_align_1: [u8; 0], pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, pub __bindgen_padding_0: [u8; 3usize], } #[test] -fn bindgen_test_layout_StdVideoEncodeH265ReferenceModificationFlags() { +fn bindgen_test_layout_StdVideoEncodeH265ReferenceListsInfoFlags() { assert_eq!( - ::std::mem::size_of::(), + ::std::mem::size_of::(), 4usize, concat!( "Size of: ", - stringify!(StdVideoEncodeH265ReferenceModificationFlags) + stringify!(StdVideoEncodeH265ReferenceListsInfoFlags) ) ); assert_eq!( - ::std::mem::align_of::(), + ::std::mem::align_of::(), 4usize, concat!( "Alignment of ", - stringify!(StdVideoEncodeH265ReferenceModificationFlags) + stringify!(StdVideoEncodeH265ReferenceListsInfoFlags) ) ); } -impl StdVideoEncodeH265ReferenceModificationFlags { +impl StdVideoEncodeH265ReferenceListsInfoFlags { #[inline] pub fn ref_pic_list_modification_flag_l0(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } @@ -8579,32 +8684,35 @@ impl StdVideoEncodeH265ReferenceModificationFlags { } #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct StdVideoEncodeH265ReferenceModifications { - pub flags: StdVideoEncodeH265ReferenceModificationFlags, - pub referenceList0ModificationsCount: u8, - pub pReferenceList0Modifications: *const u8, - pub referenceList1ModificationsCount: u8, - pub pReferenceList1Modifications: *const u8, +pub struct StdVideoEncodeH265ReferenceListsInfo { + pub flags: StdVideoEncodeH265ReferenceListsInfoFlags, + pub num_ref_idx_l0_active_minus1: u8, + pub num_ref_idx_l1_active_minus1: u8, + pub reserved1: u16, + pub pRefPicList0Entries: *const u8, + pub pRefPicList1Entries: *const u8, + pub pRefList0Modifications: *const u8, + pub pRefList1Modifications: *const u8, } #[test] -fn bindgen_test_layout_StdVideoEncodeH265ReferenceModifications() { - const UNINIT: ::std::mem::MaybeUninit = +fn bindgen_test_layout_StdVideoEncodeH265ReferenceListsInfo() { + const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( - ::std::mem::size_of::(), - 32usize, + ::std::mem::size_of::(), + 40usize, concat!( "Size of: ", - stringify!(StdVideoEncodeH265ReferenceModifications) + stringify!(StdVideoEncodeH265ReferenceListsInfo) ) ); assert_eq!( - ::std::mem::align_of::(), + ::std::mem::align_of::(), 8usize, concat!( "Alignment of ", - stringify!(StdVideoEncodeH265ReferenceModifications) + stringify!(StdVideoEncodeH265ReferenceListsInfo) ) ); assert_eq!( @@ -8612,57 +8720,83 @@ fn bindgen_test_layout_StdVideoEncodeH265ReferenceModifications() { 0usize, concat!( "Offset of field: ", - stringify!(StdVideoEncodeH265ReferenceModifications), + stringify!(StdVideoEncodeH265ReferenceListsInfo), "::", stringify!(flags) ) ); assert_eq!( unsafe { - ::std::ptr::addr_of!((*ptr).referenceList0ModificationsCount) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).num_ref_idx_l0_active_minus1) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", - stringify!(StdVideoEncodeH265ReferenceModifications), + stringify!(StdVideoEncodeH265ReferenceListsInfo), "::", - stringify!(referenceList0ModificationsCount) + stringify!(num_ref_idx_l0_active_minus1) ) ); assert_eq!( unsafe { - ::std::ptr::addr_of!((*ptr).pReferenceList0Modifications) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).num_ref_idx_l1_active_minus1) as usize - ptr as usize }, + 5usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265ReferenceListsInfo), + "::", + stringify!(num_ref_idx_l1_active_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize }, + 6usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265ReferenceListsInfo), + "::", + stringify!(reserved1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pRefPicList0Entries) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", - stringify!(StdVideoEncodeH265ReferenceModifications), + stringify!(StdVideoEncodeH265ReferenceListsInfo), "::", - stringify!(pReferenceList0Modifications) + stringify!(pRefPicList0Entries) ) ); assert_eq!( - unsafe { - ::std::ptr::addr_of!((*ptr).referenceList1ModificationsCount) as usize - ptr as usize - }, + unsafe { ::std::ptr::addr_of!((*ptr).pRefPicList1Entries) as usize - ptr as usize }, 16usize, concat!( "Offset of field: ", - stringify!(StdVideoEncodeH265ReferenceModifications), + stringify!(StdVideoEncodeH265ReferenceListsInfo), "::", - stringify!(referenceList1ModificationsCount) + stringify!(pRefPicList1Entries) ) ); assert_eq!( - unsafe { - ::std::ptr::addr_of!((*ptr).pReferenceList1Modifications) as usize - ptr as usize - }, + unsafe { ::std::ptr::addr_of!((*ptr).pRefList0Modifications) as usize - ptr as usize }, 24usize, concat!( "Offset of field: ", - stringify!(StdVideoEncodeH265ReferenceModifications), + stringify!(StdVideoEncodeH265ReferenceListsInfo), + "::", + stringify!(pRefList0Modifications) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pRefList1Modifications) as usize - ptr as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265ReferenceListsInfo), "::", - stringify!(pReferenceList1Modifications) + stringify!(pRefList1Modifications) ) ); } @@ -8786,8 +8920,8 @@ pub struct StdVideoEncodeH265PictureInfo { pub sps_video_parameter_set_id: u8, pub pps_seq_parameter_set_id: u8, pub pps_pic_parameter_set_id: u8, - pub PicOrderCntVal: i32, pub TemporalId: u8, + pub PicOrderCntVal: i32, } #[test] fn bindgen_test_layout_StdVideoEncodeH265PictureInfo() { @@ -8796,7 +8930,7 @@ fn bindgen_test_layout_StdVideoEncodeH265PictureInfo() { let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), - 20usize, + 16usize, concat!("Size of: ", stringify!(StdVideoEncodeH265PictureInfo)) ); assert_eq!( @@ -8855,23 +8989,23 @@ fn bindgen_test_layout_StdVideoEncodeH265PictureInfo() { ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).PicOrderCntVal) as usize - ptr as usize }, - 12usize, + unsafe { ::std::ptr::addr_of!((*ptr).TemporalId) as usize - ptr as usize }, + 11usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265PictureInfo), "::", - stringify!(PicOrderCntVal) + stringify!(TemporalId) ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).TemporalId) as usize - ptr as usize }, - 16usize, + unsafe { ::std::ptr::addr_of!((*ptr).PicOrderCntVal) as usize - ptr as usize }, + 12usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265PictureInfo), "::", - stringify!(TemporalId) + stringify!(PicOrderCntVal) ) ); } @@ -8947,6 +9081,7 @@ impl StdVideoEncodeH265ReferenceInfoFlags { #[derive(Debug, Copy, Clone)] pub struct StdVideoEncodeH265ReferenceInfo { pub flags: StdVideoEncodeH265ReferenceInfoFlags, + pub PictureType: StdVideoH265PictureType, pub PicOrderCntVal: i32, pub TemporalId: u8, } @@ -8957,7 +9092,7 @@ fn bindgen_test_layout_StdVideoEncodeH265ReferenceInfo() { let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), - 12usize, + 16usize, concat!("Size of: ", stringify!(StdVideoEncodeH265ReferenceInfo)) ); assert_eq!( @@ -8976,8 +9111,18 @@ fn bindgen_test_layout_StdVideoEncodeH265ReferenceInfo() { ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).PicOrderCntVal) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).PictureType) as usize - ptr as usize }, 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265ReferenceInfo), + "::", + stringify!(PictureType) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).PicOrderCntVal) as usize - ptr as usize }, + 8usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265ReferenceInfo), @@ -8987,7 +9132,7 @@ fn bindgen_test_layout_StdVideoEncodeH265ReferenceInfo() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).TemporalId) as usize - ptr as usize }, - 8usize, + 12usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265ReferenceInfo), diff --git a/generator/Vulkan-Headers b/generator/Vulkan-Headers index a3dd2655a..d732b2de3 160000 --- a/generator/Vulkan-Headers +++ b/generator/Vulkan-Headers @@ -1 +1 @@ -Subproject commit a3dd2655a3a68c2a67c55a0f8b77dcb8b166ada2 +Subproject commit d732b2de303ce505169011d438178191136bfb00