diff --git a/Changelog.md b/Changelog.md index 0ecadd7..89085cd 100644 --- a/Changelog.md +++ b/Changelog.md @@ -14,7 +14,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ### Added -- Update Vulkan-Headers to 1.3.208 (#597) +- Update Vulkan-Headers to 1.3.209 (#597, #601) - Added `VK_EXT_headless_surface` instance extension (#589) ### Changed diff --git a/ash/Cargo.toml b/ash/Cargo.toml index d8a24b5..96814f3 100644 --- a/ash/Cargo.toml +++ b/ash/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "ash" -version = "0.36.0+1.3.208" +version = "0.36.0+1.3.209" authors = ["maik klein "] description = "Vulkan bindings for Rust" license = "MIT" diff --git a/ash/src/vk/bitflags.rs b/ash/src/vk/bitflags.rs index 5d7bf6d..f69039a 100644 --- a/ash/src/vk/bitflags.rs +++ b/ash/src/vk/bitflags.rs @@ -1299,15 +1299,6 @@ impl VideoEncodeH264OutputModeFlagsEXT { } #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -#[doc = ""] -pub struct VideoEncodeH264CreateFlagsEXT(pub(crate) Flags); -vk_bitflags_wrapped!(VideoEncodeH264CreateFlagsEXT, Flags); -impl VideoEncodeH264CreateFlagsEXT { - pub const DEFAULT: Self = Self(0); - pub const RESERVED_0: Self = Self(0b1); -} -#[repr(transparent)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[doc = ""] pub struct VideoEncodeH264RateControlStructureFlagsEXT(pub(crate) Flags); vk_bitflags_wrapped!(VideoEncodeH264RateControlStructureFlagsEXT, Flags); diff --git a/ash/src/vk/const_debugs.rs b/ash/src/vk/const_debugs.rs index 83a5f13..249f199 100644 --- a/ash/src/vk/const_debugs.rs +++ b/ash/src/vk/const_debugs.rs @@ -1926,7 +1926,7 @@ impl fmt::Debug for FormatFeatureFlags { } impl fmt::Debug for FormatFeatureFlags2 { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [(Flags64 , & str)] = & [(FormatFeatureFlags2 :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE") , (FormatFeatureFlags2 :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE") , (FormatFeatureFlags2 :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC") , (FormatFeatureFlags2 :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER") , (FormatFeatureFlags2 :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER") , (FormatFeatureFlags2 :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC") , (FormatFeatureFlags2 :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER") , (FormatFeatureFlags2 :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT") , (FormatFeatureFlags2 :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND") , (FormatFeatureFlags2 :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT") , (FormatFeatureFlags2 :: BLIT_SRC . 0 , "BLIT_SRC") , (FormatFeatureFlags2 :: BLIT_DST . 0 , "BLIT_DST") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_FILTER_CUBIC . 0 , "SAMPLED_IMAGE_FILTER_CUBIC") , (FormatFeatureFlags2 :: TRANSFER_SRC . 0 , "TRANSFER_SRC") , (FormatFeatureFlags2 :: TRANSFER_DST . 0 , "TRANSFER_DST") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_FILTER_MINMAX . 0 , "SAMPLED_IMAGE_FILTER_MINMAX") , (FormatFeatureFlags2 :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE") , (FormatFeatureFlags2 :: DISJOINT . 0 , "DISJOINT") , (FormatFeatureFlags2 :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES") , (FormatFeatureFlags2 :: STORAGE_READ_WITHOUT_FORMAT . 0 , "STORAGE_READ_WITHOUT_FORMAT") , (FormatFeatureFlags2 :: STORAGE_WRITE_WITHOUT_FORMAT . 0 , "STORAGE_WRITE_WITHOUT_FORMAT") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_DEPTH_COMPARISON . 0 , "SAMPLED_IMAGE_DEPTH_COMPARISON") , (FormatFeatureFlags2 :: VIDEO_DECODE_OUTPUT_KHR . 0 , "VIDEO_DECODE_OUTPUT_KHR") , (FormatFeatureFlags2 :: VIDEO_DECODE_DPB_KHR . 0 , "VIDEO_DECODE_DPB_KHR") , (FormatFeatureFlags2 :: ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR . 0 , "ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR") , (FormatFeatureFlags2 :: FRAGMENT_DENSITY_MAP_EXT . 0 , "FRAGMENT_DENSITY_MAP_EXT") , (FormatFeatureFlags2 :: FRAGMENT_SHADING_RATE_ATTACHMENT_KHR . 0 , "FRAGMENT_SHADING_RATE_ATTACHMENT_KHR") , (FormatFeatureFlags2 :: VIDEO_ENCODE_INPUT_KHR . 0 , "VIDEO_ENCODE_INPUT_KHR") , (FormatFeatureFlags2 :: VIDEO_ENCODE_DPB_KHR . 0 , "VIDEO_ENCODE_DPB_KHR") , (FormatFeatureFlags2 :: LINEAR_COLOR_ATTACHMENT_NV . 0 , "LINEAR_COLOR_ATTACHMENT_NV") , (FormatFeatureFlags2 :: RESERVED_34_QCOM . 0 , "RESERVED_34_QCOM") , (FormatFeatureFlags2 :: RESERVED_35_QCOM . 0 , "RESERVED_35_QCOM") , (FormatFeatureFlags2 :: RESERVED_36_QCOM . 0 , "RESERVED_36_QCOM") , (FormatFeatureFlags2 :: RESERVED_37_QCOM . 0 , "RESERVED_37_QCOM")] ; + const KNOWN : & [(Flags64 , & str)] = & [(FormatFeatureFlags2 :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE") , (FormatFeatureFlags2 :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE") , (FormatFeatureFlags2 :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC") , (FormatFeatureFlags2 :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER") , (FormatFeatureFlags2 :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER") , (FormatFeatureFlags2 :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC") , (FormatFeatureFlags2 :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER") , (FormatFeatureFlags2 :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT") , (FormatFeatureFlags2 :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND") , (FormatFeatureFlags2 :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT") , (FormatFeatureFlags2 :: BLIT_SRC . 0 , "BLIT_SRC") , (FormatFeatureFlags2 :: BLIT_DST . 0 , "BLIT_DST") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_FILTER_CUBIC . 0 , "SAMPLED_IMAGE_FILTER_CUBIC") , (FormatFeatureFlags2 :: TRANSFER_SRC . 0 , "TRANSFER_SRC") , (FormatFeatureFlags2 :: TRANSFER_DST . 0 , "TRANSFER_DST") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_FILTER_MINMAX . 0 , "SAMPLED_IMAGE_FILTER_MINMAX") , (FormatFeatureFlags2 :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE") , (FormatFeatureFlags2 :: DISJOINT . 0 , "DISJOINT") , (FormatFeatureFlags2 :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES") , (FormatFeatureFlags2 :: STORAGE_READ_WITHOUT_FORMAT . 0 , "STORAGE_READ_WITHOUT_FORMAT") , (FormatFeatureFlags2 :: STORAGE_WRITE_WITHOUT_FORMAT . 0 , "STORAGE_WRITE_WITHOUT_FORMAT") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_DEPTH_COMPARISON . 0 , "SAMPLED_IMAGE_DEPTH_COMPARISON") , (FormatFeatureFlags2 :: VIDEO_DECODE_OUTPUT_KHR . 0 , "VIDEO_DECODE_OUTPUT_KHR") , (FormatFeatureFlags2 :: VIDEO_DECODE_DPB_KHR . 0 , "VIDEO_DECODE_DPB_KHR") , (FormatFeatureFlags2 :: ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR . 0 , "ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR") , (FormatFeatureFlags2 :: FRAGMENT_DENSITY_MAP_EXT . 0 , "FRAGMENT_DENSITY_MAP_EXT") , (FormatFeatureFlags2 :: FRAGMENT_SHADING_RATE_ATTACHMENT_KHR . 0 , "FRAGMENT_SHADING_RATE_ATTACHMENT_KHR") , (FormatFeatureFlags2 :: VIDEO_ENCODE_INPUT_KHR . 0 , "VIDEO_ENCODE_INPUT_KHR") , (FormatFeatureFlags2 :: VIDEO_ENCODE_DPB_KHR . 0 , "VIDEO_ENCODE_DPB_KHR") , (FormatFeatureFlags2 :: LINEAR_COLOR_ATTACHMENT_NV . 0 , "LINEAR_COLOR_ATTACHMENT_NV") , (FormatFeatureFlags2 :: RESERVED_34_QCOM . 0 , "RESERVED_34_QCOM") , (FormatFeatureFlags2 :: RESERVED_35_QCOM . 0 , "RESERVED_35_QCOM") , (FormatFeatureFlags2 :: RESERVED_36_QCOM . 0 , "RESERVED_36_QCOM") , (FormatFeatureFlags2 :: RESERVED_37_QCOM . 0 , "RESERVED_37_QCOM") , (FormatFeatureFlags2 :: RESERVED_39_EXT . 0 , "RESERVED_39_EXT")] ; debug_flags(f, KNOWN, self.0) } } @@ -4018,9 +4018,6 @@ impl fmt::Debug for StructureType { Self::IMAGE_VIEW_HANDLE_INFO_NVX => Some("IMAGE_VIEW_HANDLE_INFO_NVX"), Self::IMAGE_VIEW_ADDRESS_PROPERTIES_NVX => Some("IMAGE_VIEW_ADDRESS_PROPERTIES_NVX"), Self::VIDEO_ENCODE_H264_CAPABILITIES_EXT => Some("VIDEO_ENCODE_H264_CAPABILITIES_EXT"), - Self::VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT => { - Some("VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT") - } Self::VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT => { Some("VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT") } @@ -4048,9 +4045,6 @@ impl fmt::Debug for StructureType { Some("VIDEO_ENCODE_H264_REFERENCE_LISTS_EXT") } Self::VIDEO_ENCODE_H265_CAPABILITIES_EXT => Some("VIDEO_ENCODE_H265_CAPABILITIES_EXT"), - Self::VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT => { - Some("VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT") - } Self::VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT => { Some("VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT") } @@ -4080,9 +4074,6 @@ impl fmt::Debug for StructureType { Some("VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT") } Self::VIDEO_DECODE_H264_CAPABILITIES_EXT => Some("VIDEO_DECODE_H264_CAPABILITIES_EXT"), - Self::VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT => { - Some("VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT") - } Self::VIDEO_DECODE_H264_PICTURE_INFO_EXT => Some("VIDEO_DECODE_H264_PICTURE_INFO_EXT"), Self::VIDEO_DECODE_H264_MVC_EXT => Some("VIDEO_DECODE_H264_MVC_EXT"), Self::VIDEO_DECODE_H264_PROFILE_EXT => Some("VIDEO_DECODE_H264_PROFILE_EXT"), @@ -4453,9 +4444,6 @@ impl fmt::Debug for StructureType { Some("PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD") } Self::VIDEO_DECODE_H265_CAPABILITIES_EXT => Some("VIDEO_DECODE_H265_CAPABILITIES_EXT"), - Self::VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT => { - Some("VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT") - } Self::VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT => { Some("VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT") } @@ -5682,12 +5670,6 @@ impl fmt::Debug for VideoDecodeFlagsKHR { debug_flags(f, KNOWN, self.0) } } -impl fmt::Debug for VideoDecodeH264CreateFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[]; - debug_flags(f, KNOWN, self.0) - } -} impl fmt::Debug for VideoDecodeH264PictureLayoutFlagsEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -5707,12 +5689,6 @@ impl fmt::Debug for VideoDecodeH264PictureLayoutFlagsEXT { debug_flags(f, KNOWN, self.0) } } -impl fmt::Debug for VideoDecodeH265CreateFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[]; - debug_flags(f, KNOWN, self.0) - } -} impl fmt::Debug for VideoEncodeCapabilityFlagsKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -5827,15 +5803,6 @@ impl fmt::Debug for VideoEncodeH264CapabilityFlagsEXT { debug_flags(f, KNOWN, self.0) } } -impl fmt::Debug for VideoEncodeH264CreateFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (VideoEncodeH264CreateFlagsEXT::DEFAULT.0, "DEFAULT"), - (VideoEncodeH264CreateFlagsEXT::RESERVED_0.0, "RESERVED_0"), - ]; - debug_flags(f, KNOWN, self.0) - } -} impl fmt::Debug for VideoEncodeH264InputModeFlagsEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -5975,12 +5942,6 @@ impl fmt::Debug for VideoEncodeH265CapabilityFlagsEXT { debug_flags(f, KNOWN, self.0) } } -impl fmt::Debug for VideoEncodeH265CreateFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[]; - debug_flags(f, KNOWN, self.0) - } -} impl fmt::Debug for VideoEncodeH265CtbSizeFlagsEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ diff --git a/ash/src/vk/definitions.rs b/ash/src/vk/definitions.rs index a70b321..9e1c2c1 100644 --- a/ash/src/vk/definitions.rs +++ b/ash/src/vk/definitions.rs @@ -56,7 +56,7 @@ pub const API_VERSION_1_1: u32 = make_api_version(0, 1, 1, 0); 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); -pub const HEADER_VERSION: u32 = 208u32; +pub const HEADER_VERSION: u32 = 209u32; #[doc = ""] pub const HEADER_VERSION_COMPLETE: u32 = make_api_version(0, 1, 3, HEADER_VERSION); #[doc = ""] @@ -301,21 +301,6 @@ vk_bitflags_wrapped!(VideoBeginCodingFlagsKHR, Flags); #[doc = ""] pub struct VideoEndCodingFlagsKHR(pub(crate) Flags); vk_bitflags_wrapped!(VideoEndCodingFlagsKHR, Flags); -#[repr(transparent)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -#[doc = ""] -pub struct VideoDecodeH264CreateFlagsEXT(pub(crate) Flags); -vk_bitflags_wrapped!(VideoDecodeH264CreateFlagsEXT, Flags); -#[repr(transparent)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -#[doc = ""] -pub struct VideoDecodeH265CreateFlagsEXT(pub(crate) Flags); -vk_bitflags_wrapped!(VideoDecodeH265CreateFlagsEXT, Flags); -#[repr(transparent)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -#[doc = ""] -pub struct VideoEncodeH265CreateFlagsEXT(pub(crate) Flags); -vk_bitflags_wrapped!(VideoEncodeH265CreateFlagsEXT, Flags); define_handle!( Instance, INSTANCE, @@ -48785,6 +48770,7 @@ pub struct VideoCapabilitiesKHR { pub max_extent: Extent2D, pub max_reference_pictures_slots_count: u32, pub max_reference_pictures_active_count: u32, + pub std_header_version: ExtensionProperties, } impl ::std::default::Default for VideoCapabilitiesKHR { fn default() -> Self { @@ -48799,6 +48785,7 @@ impl ::std::default::Default for VideoCapabilitiesKHR { max_extent: Extent2D::default(), max_reference_pictures_slots_count: u32::default(), max_reference_pictures_active_count: u32::default(), + std_header_version: ExtensionProperties::default(), } } } @@ -48875,6 +48862,10 @@ impl<'a> VideoCapabilitiesKHRBuilder<'a> { self.inner.max_reference_pictures_active_count = max_reference_pictures_active_count; self } + pub fn std_header_version(mut self, std_header_version: ExtensionProperties) -> Self { + self.inner.std_header_version = std_header_version; + self + } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] @@ -49447,7 +49438,6 @@ pub struct VideoDecodeH264CapabilitiesEXT { pub p_next: *mut c_void, pub max_level: u32, pub field_offset_granularity: Offset2D, - pub std_extension_version: ExtensionProperties, } impl ::std::default::Default for VideoDecodeH264CapabilitiesEXT { fn default() -> Self { @@ -49456,7 +49446,6 @@ impl ::std::default::Default for VideoDecodeH264CapabilitiesEXT { p_next: ::std::ptr::null_mut(), max_level: u32::default(), field_offset_granularity: Offset2D::default(), - std_extension_version: ExtensionProperties::default(), } } } @@ -49495,10 +49484,6 @@ impl<'a> VideoDecodeH264CapabilitiesEXTBuilder<'a> { self.inner.field_offset_granularity = field_offset_granularity; self } - pub fn std_extension_version(mut self, std_extension_version: ExtensionProperties) -> Self { - self.inner.std_extension_version = std_extension_version; - self - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -49509,68 +49494,6 @@ impl<'a> VideoDecodeH264CapabilitiesEXTBuilder<'a> { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct VideoDecodeH264SessionCreateInfoEXT { - pub s_type: StructureType, - pub p_next: *const c_void, - pub flags: VideoDecodeH264CreateFlagsEXT, - pub p_std_extension_version: *const ExtensionProperties, -} -impl ::std::default::Default for VideoDecodeH264SessionCreateInfoEXT { - fn default() -> Self { - Self { - s_type: StructureType::VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT, - p_next: ::std::ptr::null(), - flags: VideoDecodeH264CreateFlagsEXT::default(), - p_std_extension_version: ::std::ptr::null(), - } - } -} -impl VideoDecodeH264SessionCreateInfoEXT { - pub fn builder<'a>() -> VideoDecodeH264SessionCreateInfoEXTBuilder<'a> { - VideoDecodeH264SessionCreateInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoDecodeH264SessionCreateInfoEXTBuilder<'a> { - inner: VideoDecodeH264SessionCreateInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsVideoSessionCreateInfoKHR for VideoDecodeH264SessionCreateInfoEXTBuilder<'_> {} -unsafe impl ExtendsVideoSessionCreateInfoKHR for VideoDecodeH264SessionCreateInfoEXT {} -impl<'a> ::std::ops::Deref for VideoDecodeH264SessionCreateInfoEXTBuilder<'a> { - type Target = VideoDecodeH264SessionCreateInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoDecodeH264SessionCreateInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoDecodeH264SessionCreateInfoEXTBuilder<'a> { - pub fn flags(mut self, flags: VideoDecodeH264CreateFlagsEXT) -> Self { - self.inner.flags = flags; - self - } - pub fn std_extension_version(mut self, std_extension_version: &'a ExtensionProperties) -> Self { - self.inner.p_std_extension_version = std_extension_version; - self - } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoDecodeH264SessionCreateInfoEXT { - self.inner - } -} -#[repr(C)] -#[cfg_attr(feature = "debug", derive(Debug))] -#[derive(Copy, Clone)] #[doc = ""] pub struct VideoDecodeH264SessionParametersAddInfoEXT { pub s_type: StructureType, @@ -49988,7 +49911,6 @@ pub struct VideoDecodeH265CapabilitiesEXT { pub s_type: StructureType, pub p_next: *mut c_void, pub max_level: u32, - pub std_extension_version: ExtensionProperties, } impl ::std::default::Default for VideoDecodeH265CapabilitiesEXT { fn default() -> Self { @@ -49996,7 +49918,6 @@ impl ::std::default::Default for VideoDecodeH265CapabilitiesEXT { s_type: StructureType::VIDEO_DECODE_H265_CAPABILITIES_EXT, p_next: ::std::ptr::null_mut(), max_level: u32::default(), - std_extension_version: ExtensionProperties::default(), } } } @@ -50031,10 +49952,6 @@ impl<'a> VideoDecodeH265CapabilitiesEXTBuilder<'a> { self.inner.max_level = max_level; self } - pub fn std_extension_version(mut self, std_extension_version: ExtensionProperties) -> Self { - self.inner.std_extension_version = std_extension_version; - self - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -50045,72 +49962,12 @@ impl<'a> VideoDecodeH265CapabilitiesEXTBuilder<'a> { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct VideoDecodeH265SessionCreateInfoEXT { - pub s_type: StructureType, - pub p_next: *const c_void, - pub flags: VideoDecodeH265CreateFlagsEXT, - pub p_std_extension_version: *const ExtensionProperties, -} -impl ::std::default::Default for VideoDecodeH265SessionCreateInfoEXT { - fn default() -> Self { - Self { - s_type: StructureType::VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT, - p_next: ::std::ptr::null(), - flags: VideoDecodeH265CreateFlagsEXT::default(), - p_std_extension_version: ::std::ptr::null(), - } - } -} -impl VideoDecodeH265SessionCreateInfoEXT { - pub fn builder<'a>() -> VideoDecodeH265SessionCreateInfoEXTBuilder<'a> { - VideoDecodeH265SessionCreateInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoDecodeH265SessionCreateInfoEXTBuilder<'a> { - inner: VideoDecodeH265SessionCreateInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsVideoSessionCreateInfoKHR for VideoDecodeH265SessionCreateInfoEXTBuilder<'_> {} -unsafe impl ExtendsVideoSessionCreateInfoKHR for VideoDecodeH265SessionCreateInfoEXT {} -impl<'a> ::std::ops::Deref for VideoDecodeH265SessionCreateInfoEXTBuilder<'a> { - type Target = VideoDecodeH265SessionCreateInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoDecodeH265SessionCreateInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoDecodeH265SessionCreateInfoEXTBuilder<'a> { - pub fn flags(mut self, flags: VideoDecodeH265CreateFlagsEXT) -> Self { - self.inner.flags = flags; - self - } - pub fn std_extension_version(mut self, std_extension_version: &'a ExtensionProperties) -> Self { - self.inner.p_std_extension_version = std_extension_version; - self - } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoDecodeH265SessionCreateInfoEXT { - self.inner - } -} -#[repr(C)] -#[cfg_attr(feature = "debug", derive(Debug))] -#[derive(Copy, Clone)] #[doc = ""] pub struct VideoDecodeH265SessionParametersAddInfoEXT { pub s_type: StructureType, pub p_next: *const c_void, + pub vps_std_count: u32, + pub p_vps_std: *const StdVideoH265VideoParameterSet, pub sps_std_count: u32, pub p_sps_std: *const StdVideoH265SequenceParameterSet, pub pps_std_count: u32, @@ -50121,6 +49978,8 @@ impl ::std::default::Default for VideoDecodeH265SessionParametersAddInfoEXT { Self { s_type: StructureType::VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT, p_next: ::std::ptr::null(), + vps_std_count: u32::default(), + p_vps_std: ::std::ptr::null(), sps_std_count: u32::default(), p_sps_std: ::std::ptr::null(), pps_std_count: u32::default(), @@ -50161,6 +50020,11 @@ impl<'a> ::std::ops::DerefMut for VideoDecodeH265SessionParametersAddInfoEXTBuil } } impl<'a> VideoDecodeH265SessionParametersAddInfoEXTBuilder<'a> { + pub fn vps_std(mut self, vps_std: &'a [StdVideoH265VideoParameterSet]) -> Self { + self.inner.vps_std_count = vps_std.len() as _; + self.inner.p_vps_std = vps_std.as_ptr(); + self + } pub fn sps_std(mut self, sps_std: &'a [StdVideoH265SequenceParameterSet]) -> Self { self.inner.sps_std_count = sps_std.len() as _; self.inner.p_sps_std = sps_std.as_ptr(); @@ -50185,6 +50049,7 @@ impl<'a> VideoDecodeH265SessionParametersAddInfoEXTBuilder<'a> { pub struct VideoDecodeH265SessionParametersCreateInfoEXT { pub s_type: StructureType, pub p_next: *const c_void, + pub max_vps_std_count: u32, pub max_sps_std_count: u32, pub max_pps_std_count: u32, pub p_parameters_add_info: *const VideoDecodeH265SessionParametersAddInfoEXT, @@ -50194,6 +50059,7 @@ impl ::std::default::Default for VideoDecodeH265SessionParametersCreateInfoEXT { Self { s_type: StructureType::VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT, p_next: ::std::ptr::null(), + max_vps_std_count: u32::default(), max_sps_std_count: u32::default(), max_pps_std_count: u32::default(), p_parameters_add_info: ::std::ptr::null(), @@ -50233,6 +50099,10 @@ impl<'a> ::std::ops::DerefMut for VideoDecodeH265SessionParametersCreateInfoEXTB } } impl<'a> VideoDecodeH265SessionParametersCreateInfoEXTBuilder<'a> { + pub fn max_vps_std_count(mut self, max_vps_std_count: u32) -> Self { + self.inner.max_vps_std_count = max_vps_std_count; + self + } pub fn max_sps_std_count(mut self, max_sps_std_count: u32) -> Self { self.inner.max_sps_std_count = max_sps_std_count; self @@ -50397,6 +50267,7 @@ pub struct VideoSessionCreateInfoKHR { pub reference_pictures_format: Format, pub max_reference_pictures_slots_count: u32, pub max_reference_pictures_active_count: u32, + pub p_std_header_version: *const ExtensionProperties, } impl ::std::default::Default for VideoSessionCreateInfoKHR { fn default() -> Self { @@ -50411,6 +50282,7 @@ impl ::std::default::Default for VideoSessionCreateInfoKHR { reference_pictures_format: Format::default(), max_reference_pictures_slots_count: u32::default(), max_reference_pictures_active_count: u32::default(), + p_std_header_version: ::std::ptr::null(), } } } @@ -50427,7 +50299,6 @@ pub struct VideoSessionCreateInfoKHRBuilder<'a> { inner: VideoSessionCreateInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsVideoSessionCreateInfoKHR {} impl<'a> ::std::ops::Deref for VideoSessionCreateInfoKHRBuilder<'a> { type Target = VideoSessionCreateInfoKHR; fn deref(&self) -> &Self::Target { @@ -50478,18 +50349,8 @@ impl<'a> VideoSessionCreateInfoKHRBuilder<'a> { self.inner.max_reference_pictures_active_count = max_reference_pictures_active_count; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = <*const T>::cast(next); - let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; - } + pub fn std_header_version(mut self, std_header_version: &'a ExtensionProperties) -> Self { + self.inner.p_std_header_version = std_header_version; self } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] @@ -51312,7 +51173,6 @@ pub struct VideoEncodeH264CapabilitiesEXT { pub max_bits_per_mb_denom: u32, pub log2_max_mv_length_horizontal: u32, pub log2_max_mv_length_vertical: u32, - pub std_extension_version: ExtensionProperties, } impl ::std::default::Default for VideoEncodeH264CapabilitiesEXT { fn default() -> Self { @@ -51330,7 +51190,6 @@ impl ::std::default::Default for VideoEncodeH264CapabilitiesEXT { max_bits_per_mb_denom: u32::default(), log2_max_mv_length_horizontal: u32::default(), log2_max_mv_length_vertical: u32::default(), - std_extension_version: ExtensionProperties::default(), } } } @@ -51418,10 +51277,6 @@ impl<'a> VideoEncodeH264CapabilitiesEXTBuilder<'a> { self.inner.log2_max_mv_length_vertical = log2_max_mv_length_vertical; self } - pub fn std_extension_version(mut self, std_extension_version: ExtensionProperties) -> Self { - self.inner.std_extension_version = std_extension_version; - self - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -51432,74 +51287,6 @@ impl<'a> VideoEncodeH264CapabilitiesEXTBuilder<'a> { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct VideoEncodeH264SessionCreateInfoEXT { - pub s_type: StructureType, - pub p_next: *const c_void, - pub flags: VideoEncodeH264CreateFlagsEXT, - pub max_picture_size_in_mbs: Extent2D, - pub p_std_extension_version: *const ExtensionProperties, -} -impl ::std::default::Default for VideoEncodeH264SessionCreateInfoEXT { - fn default() -> Self { - Self { - s_type: StructureType::VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT, - p_next: ::std::ptr::null(), - flags: VideoEncodeH264CreateFlagsEXT::default(), - max_picture_size_in_mbs: Extent2D::default(), - p_std_extension_version: ::std::ptr::null(), - } - } -} -impl VideoEncodeH264SessionCreateInfoEXT { - pub fn builder<'a>() -> VideoEncodeH264SessionCreateInfoEXTBuilder<'a> { - VideoEncodeH264SessionCreateInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoEncodeH264SessionCreateInfoEXTBuilder<'a> { - inner: VideoEncodeH264SessionCreateInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsVideoSessionCreateInfoKHR for VideoEncodeH264SessionCreateInfoEXTBuilder<'_> {} -unsafe impl ExtendsVideoSessionCreateInfoKHR for VideoEncodeH264SessionCreateInfoEXT {} -impl<'a> ::std::ops::Deref for VideoEncodeH264SessionCreateInfoEXTBuilder<'a> { - type Target = VideoEncodeH264SessionCreateInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoEncodeH264SessionCreateInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoEncodeH264SessionCreateInfoEXTBuilder<'a> { - pub fn flags(mut self, flags: VideoEncodeH264CreateFlagsEXT) -> Self { - self.inner.flags = flags; - self - } - pub fn max_picture_size_in_mbs(mut self, max_picture_size_in_mbs: Extent2D) -> Self { - self.inner.max_picture_size_in_mbs = max_picture_size_in_mbs; - self - } - pub fn std_extension_version(mut self, std_extension_version: &'a ExtensionProperties) -> Self { - self.inner.p_std_extension_version = std_extension_version; - self - } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoEncodeH264SessionCreateInfoEXT { - self.inner - } -} -#[repr(C)] -#[cfg_attr(feature = "debug", derive(Debug))] -#[derive(Copy, Clone)] #[doc = ""] pub struct VideoEncodeH264SessionParametersAddInfoEXT { pub s_type: StructureType, @@ -52401,7 +52188,6 @@ pub struct VideoEncodeH265CapabilitiesEXT { pub max_diff_cu_qp_delta_depth: u8, pub min_max_num_merge_cand: u8, pub max_max_num_merge_cand: u8, - pub std_extension_version: ExtensionProperties, } impl ::std::default::Default for VideoEncodeH265CapabilitiesEXT { fn default() -> Self { @@ -52428,7 +52214,6 @@ impl ::std::default::Default for VideoEncodeH265CapabilitiesEXT { max_diff_cu_qp_delta_depth: u8::default(), min_max_num_merge_cand: u8::default(), max_max_num_merge_cand: u8::default(), - std_extension_version: ExtensionProperties::default(), } } } @@ -52583,10 +52368,6 @@ impl<'a> VideoEncodeH265CapabilitiesEXTBuilder<'a> { self.inner.max_max_num_merge_cand = max_max_num_merge_cand; self } - pub fn std_extension_version(mut self, std_extension_version: ExtensionProperties) -> Self { - self.inner.std_extension_version = std_extension_version; - self - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -52597,68 +52378,6 @@ impl<'a> VideoEncodeH265CapabilitiesEXTBuilder<'a> { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct VideoEncodeH265SessionCreateInfoEXT { - pub s_type: StructureType, - pub p_next: *const c_void, - pub flags: VideoEncodeH265CreateFlagsEXT, - pub p_std_extension_version: *const ExtensionProperties, -} -impl ::std::default::Default for VideoEncodeH265SessionCreateInfoEXT { - fn default() -> Self { - Self { - s_type: StructureType::VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT, - p_next: ::std::ptr::null(), - flags: VideoEncodeH265CreateFlagsEXT::default(), - p_std_extension_version: ::std::ptr::null(), - } - } -} -impl VideoEncodeH265SessionCreateInfoEXT { - pub fn builder<'a>() -> VideoEncodeH265SessionCreateInfoEXTBuilder<'a> { - VideoEncodeH265SessionCreateInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoEncodeH265SessionCreateInfoEXTBuilder<'a> { - inner: VideoEncodeH265SessionCreateInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsVideoSessionCreateInfoKHR for VideoEncodeH265SessionCreateInfoEXTBuilder<'_> {} -unsafe impl ExtendsVideoSessionCreateInfoKHR for VideoEncodeH265SessionCreateInfoEXT {} -impl<'a> ::std::ops::Deref for VideoEncodeH265SessionCreateInfoEXTBuilder<'a> { - type Target = VideoEncodeH265SessionCreateInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoEncodeH265SessionCreateInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoEncodeH265SessionCreateInfoEXTBuilder<'a> { - pub fn flags(mut self, flags: VideoEncodeH265CreateFlagsEXT) -> Self { - self.inner.flags = flags; - self - } - pub fn std_extension_version(mut self, std_extension_version: &'a ExtensionProperties) -> Self { - self.inner.p_std_extension_version = std_extension_version; - self - } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoEncodeH265SessionCreateInfoEXT { - self.inner - } -} -#[repr(C)] -#[cfg_attr(feature = "debug", derive(Debug))] -#[derive(Copy, Clone)] #[doc = ""] pub struct VideoEncodeH265SessionParametersAddInfoEXT { pub s_type: StructureType, diff --git a/ash/src/vk/extensions.rs b/ash/src/vk/extensions.rs index e7cf5d0..805378b 100644 --- a/ash/src/vk/extensions.rs +++ b/ash/src/vk/extensions.rs @@ -1822,7 +1822,7 @@ impl KhrVideoQueueFn { pub const fn name() -> &'static ::std::ffi::CStr { unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_video_queue\0") } } - pub const SPEC_VERSION: u32 = 2u32; + pub const SPEC_VERSION: u32 = 3u32; } #[allow(non_camel_case_types)] pub type PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR = unsafe extern "system" fn( @@ -3047,7 +3047,7 @@ impl ExtVideoEncodeH264Fn { pub const fn 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 = 5u32; + pub const SPEC_VERSION: u32 = 6u32; } #[derive(Clone)] pub struct ExtVideoEncodeH264Fn {} @@ -3064,17 +3064,16 @@ impl ExtVideoEncodeH264Fn { #[doc = "Generated from 'VK_EXT_video_encode_h264'"] impl StructureType { pub const VIDEO_ENCODE_H264_CAPABILITIES_EXT: Self = Self(1_000_038_000); - pub const VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT: Self = Self(1_000_038_001); - pub const VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: Self = Self(1_000_038_002); - pub const VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: Self = Self(1_000_038_003); - pub const VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT: Self = Self(1_000_038_004); - pub const VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT: Self = Self(1_000_038_005); - pub const VIDEO_ENCODE_H264_NALU_SLICE_EXT: Self = Self(1_000_038_006); - pub const VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT: Self = Self(1_000_038_007); - pub const VIDEO_ENCODE_H264_PROFILE_EXT: Self = Self(1_000_038_008); - pub const VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT: Self = Self(1_000_038_009); - pub const VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT: Self = Self(1_000_038_010); - pub const VIDEO_ENCODE_H264_REFERENCE_LISTS_EXT: Self = Self(1_000_038_011); + pub const VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: Self = Self(1_000_038_001); + pub const VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: Self = Self(1_000_038_002); + 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_EXT: Self = Self(1_000_038_005); + pub const VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT: Self = Self(1_000_038_006); + pub const VIDEO_ENCODE_H264_PROFILE_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_EXT: Self = Self(1_000_038_010); } #[doc = "Generated from 'VK_EXT_video_encode_h264'"] impl VideoCodecOperationFlagsKHR { @@ -3084,7 +3083,7 @@ impl ExtVideoEncodeH265Fn { pub const fn 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 = 5u32; + pub const SPEC_VERSION: u32 = 6u32; } #[derive(Clone)] pub struct ExtVideoEncodeH265Fn {} @@ -3101,17 +3100,16 @@ impl ExtVideoEncodeH265Fn { #[doc = "Generated from 'VK_EXT_video_encode_h265'"] impl StructureType { pub const VIDEO_ENCODE_H265_CAPABILITIES_EXT: Self = Self(1_000_039_000); - pub const VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT: Self = Self(1_000_039_001); - pub const VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: Self = Self(1_000_039_002); - pub const VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: Self = Self(1_000_039_003); - pub const VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT: Self = Self(1_000_039_004); - pub const VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT: Self = Self(1_000_039_005); - pub const VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_EXT: Self = Self(1_000_039_006); - pub const VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT: Self = Self(1_000_039_007); - pub const VIDEO_ENCODE_H265_PROFILE_EXT: Self = Self(1_000_039_008); - pub const VIDEO_ENCODE_H265_REFERENCE_LISTS_EXT: Self = Self(1_000_039_009); - pub const VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT: Self = Self(1_000_039_010); - pub const VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT: Self = Self(1_000_039_011); + pub const VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: Self = Self(1_000_039_001); + pub const VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: Self = Self(1_000_039_002); + 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_EXT: Self = Self(1_000_039_005); + pub const VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT: Self = Self(1_000_039_006); + pub const VIDEO_ENCODE_H265_PROFILE_EXT: Self = Self(1_000_039_007); + pub const VIDEO_ENCODE_H265_REFERENCE_LISTS_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); } #[doc = "Generated from 'VK_EXT_video_encode_h265'"] impl VideoCodecOperationFlagsKHR { @@ -3121,7 +3119,7 @@ impl ExtVideoDecodeH264Fn { pub const fn name() -> &'static ::std::ffi::CStr { unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_video_decode_h264\0") } } - pub const SPEC_VERSION: u32 = 3u32; + pub const SPEC_VERSION: u32 = 4u32; } #[derive(Clone)] pub struct ExtVideoDecodeH264Fn {} @@ -3138,13 +3136,12 @@ impl ExtVideoDecodeH264Fn { #[doc = "Generated from 'VK_EXT_video_decode_h264'"] impl StructureType { pub const VIDEO_DECODE_H264_CAPABILITIES_EXT: Self = Self(1_000_040_000); - pub const VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT: Self = Self(1_000_040_001); - pub const VIDEO_DECODE_H264_PICTURE_INFO_EXT: Self = Self(1_000_040_002); - pub const VIDEO_DECODE_H264_MVC_EXT: Self = Self(1_000_040_003); - pub const VIDEO_DECODE_H264_PROFILE_EXT: Self = Self(1_000_040_004); - pub const VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: Self = Self(1_000_040_005); - pub const VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: Self = Self(1_000_040_006); - pub const VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT: Self = Self(1_000_040_007); + pub const VIDEO_DECODE_H264_PICTURE_INFO_EXT: Self = Self(1_000_040_001); + pub const VIDEO_DECODE_H264_MVC_EXT: Self = Self(1_000_040_002); + pub const VIDEO_DECODE_H264_PROFILE_EXT: Self = Self(1_000_040_003); + pub const VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: Self = Self(1_000_040_004); + pub const VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: Self = Self(1_000_040_005); + pub const VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT: Self = Self(1_000_040_006); } #[doc = "Generated from 'VK_EXT_video_decode_h264'"] impl VideoCodecOperationFlagsKHR { @@ -11491,7 +11488,7 @@ impl ExtVideoDecodeH265Fn { pub const fn name() -> &'static ::std::ffi::CStr { unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_video_decode_h265\0") } } - pub const SPEC_VERSION: u32 = 1u32; + pub const SPEC_VERSION: u32 = 2u32; } #[derive(Clone)] pub struct ExtVideoDecodeH265Fn {} @@ -11508,12 +11505,11 @@ impl ExtVideoDecodeH265Fn { #[doc = "Generated from 'VK_EXT_video_decode_h265'"] impl StructureType { pub const VIDEO_DECODE_H265_CAPABILITIES_EXT: Self = Self(1_000_187_000); - pub const VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT: Self = Self(1_000_187_001); - pub const VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: Self = Self(1_000_187_002); - pub const VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: Self = Self(1_000_187_003); - pub const VIDEO_DECODE_H265_PROFILE_EXT: Self = Self(1_000_187_004); - pub const VIDEO_DECODE_H265_PICTURE_INFO_EXT: Self = Self(1_000_187_005); - pub const VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT: Self = Self(1_000_187_006); + pub const VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: Self = Self(1_000_187_001); + pub const VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: Self = Self(1_000_187_002); + pub const VIDEO_DECODE_H265_PROFILE_EXT: Self = Self(1_000_187_003); + pub const VIDEO_DECODE_H265_PICTURE_INFO_EXT: Self = Self(1_000_187_004); + pub const VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT: Self = Self(1_000_187_005); } #[doc = "Generated from 'VK_EXT_video_decode_h265'"] impl VideoCodecOperationFlagsKHR { @@ -21203,3 +21199,61 @@ impl ExtExtension460Fn { Self {} } } +impl ExtExtension461Fn { + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_461\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension461Fn {} +unsafe impl Send for ExtExtension461Fn {} +unsafe impl Sync for ExtExtension461Fn {} +impl ExtExtension461Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_extension_461'"] +impl FormatFeatureFlags2 { + pub const RESERVED_39_EXT: Self = Self(0b1000_0000_0000_0000_0000_0000_0000_0000_0000_0000); +} +impl ExtExtension462Fn { + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_462\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension462Fn {} +unsafe impl Send for ExtExtension462Fn {} +unsafe impl Sync for ExtExtension462Fn {} +impl ExtExtension462Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtExtension463Fn { + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_463\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension463Fn {} +unsafe impl Send for ExtExtension463Fn {} +unsafe impl Sync for ExtExtension463Fn {} +impl ExtExtension463Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} diff --git a/ash/src/vk/native.rs b/ash/src/vk/native.rs index 4555bd1..e5c52f4 100644 --- a/ash/src/vk/native.rs +++ b/ash/src/vk/native.rs @@ -620,6 +620,7 @@ fn bindgen_test_layout_StdVideoH264HrdParameters() { #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct StdVideoH264SequenceParameterSetVui { + pub flags: StdVideoH264SpsVuiFlags, pub aspect_ratio_idc: StdVideoH264AspectRatioIdc, pub sar_width: u16, pub sar_height: u16, @@ -629,10 +630,9 @@ pub struct StdVideoH264SequenceParameterSetVui { pub matrix_coefficients: u8, pub num_units_in_tick: u32, pub time_scale: u32, - pub pHrdParameters: *mut StdVideoH264HrdParameters, + pub pHrdParameters: *const StdVideoH264HrdParameters, pub max_num_reorder_frames: u8, pub max_dec_frame_buffering: u8, - pub flags: StdVideoH264SpsVuiFlags, } #[test] fn bindgen_test_layout_StdVideoH264SequenceParameterSetVui() { @@ -649,12 +649,25 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSetVui() { stringify!(StdVideoH264SequenceParameterSetVui) ) ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).flags as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSetVui), + "::", + stringify!(flags) + ) + ); assert_eq!( unsafe { &(*(::std::ptr::null::())).aspect_ratio_idc as *const _ as usize }, - 0usize, + 4usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSetVui), @@ -667,7 +680,7 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSetVui() { &(*(::std::ptr::null::())).sar_width as *const _ as usize }, - 4usize, + 8usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSetVui), @@ -680,7 +693,7 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSetVui() { &(*(::std::ptr::null::())).sar_height as *const _ as usize }, - 6usize, + 10usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSetVui), @@ -693,7 +706,7 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSetVui() { &(*(::std::ptr::null::())).video_format as *const _ as usize }, - 8usize, + 12usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSetVui), @@ -706,7 +719,7 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSetVui() { &(*(::std::ptr::null::())).color_primaries as *const _ as usize }, - 9usize, + 13usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSetVui), @@ -719,7 +732,7 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSetVui() { &(*(::std::ptr::null::())).transfer_characteristics as *const _ as usize }, - 10usize, + 14usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSetVui), @@ -732,7 +745,7 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSetVui() { &(*(::std::ptr::null::())).matrix_coefficients as *const _ as usize }, - 11usize, + 15usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSetVui), @@ -745,7 +758,7 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSetVui() { &(*(::std::ptr::null::())).num_units_in_tick as *const _ as usize }, - 12usize, + 16usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSetVui), @@ -758,7 +771,7 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSetVui() { &(*(::std::ptr::null::())).time_scale as *const _ as usize }, - 16usize, + 20usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSetVui), @@ -805,19 +818,6 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSetVui() { stringify!(max_dec_frame_buffering) ) ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).flags as *const _ - as usize - }, - 36usize, - concat!( - "Offset of field: ", - stringify!(StdVideoH264SequenceParameterSetVui), - "::", - stringify!(flags) - ) - ); } #[repr(C)] #[repr(align(4))] @@ -1186,6 +1186,7 @@ fn bindgen_test_layout_StdVideoH264ScalingLists() { #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct StdVideoH264SequenceParameterSet { + pub flags: StdVideoH264SpsFlags, pub profile_idc: StdVideoH264ProfileIdc, pub level_idc: StdVideoH264Level, pub seq_parameter_set_id: u8, @@ -1205,10 +1206,9 @@ pub struct StdVideoH264SequenceParameterSet { pub frame_crop_right_offset: u32, pub frame_crop_top_offset: u32, pub frame_crop_bottom_offset: u32, - pub flags: StdVideoH264SpsFlags, - pub pOffsetForRefFrame: *mut i32, - pub pScalingLists: *mut StdVideoH264ScalingLists, - pub pSequenceParameterSetVui: *mut StdVideoH264SequenceParameterSetVui, + pub pOffsetForRefFrame: *const i32, + pub pScalingLists: *const StdVideoH264ScalingLists, + pub pSequenceParameterSetVui: *const StdVideoH264SequenceParameterSetVui, } #[test] fn bindgen_test_layout_StdVideoH264SequenceParameterSet() { @@ -1225,12 +1225,24 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSet() { stringify!(StdVideoH264SequenceParameterSet) ) ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).flags as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSet), + "::", + stringify!(flags) + ) + ); assert_eq!( unsafe { &(*(::std::ptr::null::())).profile_idc as *const _ as usize }, - 0usize, + 4usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSet), @@ -1243,7 +1255,7 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSet() { &(*(::std::ptr::null::())).level_idc as *const _ as usize }, - 4usize, + 8usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSet), @@ -1256,7 +1268,7 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSet() { &(*(::std::ptr::null::())).seq_parameter_set_id as *const _ as usize }, - 8usize, + 12usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSet), @@ -1269,7 +1281,7 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSet() { &(*(::std::ptr::null::())).chroma_format_idc as *const _ as usize }, - 12usize, + 16usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSet), @@ -1282,7 +1294,7 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSet() { &(*(::std::ptr::null::())).bit_depth_luma_minus8 as *const _ as usize }, - 16usize, + 20usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSet), @@ -1295,7 +1307,7 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSet() { &(*(::std::ptr::null::())).bit_depth_chroma_minus8 as *const _ as usize }, - 17usize, + 21usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSet), @@ -1308,7 +1320,7 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSet() { &(*(::std::ptr::null::())).log2_max_frame_num_minus4 as *const _ as usize }, - 18usize, + 22usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSet), @@ -1321,7 +1333,7 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSet() { &(*(::std::ptr::null::())).pic_order_cnt_type as *const _ as usize }, - 20usize, + 24usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSet), @@ -1334,7 +1346,7 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSet() { &(*(::std::ptr::null::())) .log2_max_pic_order_cnt_lsb_minus4 as *const _ as usize }, - 24usize, + 28usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSet), @@ -1347,7 +1359,7 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSet() { &(*(::std::ptr::null::())).offset_for_non_ref_pic as *const _ as usize }, - 28usize, + 32usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSet), @@ -1360,7 +1372,7 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSet() { &(*(::std::ptr::null::())) .offset_for_top_to_bottom_field as *const _ as usize }, - 32usize, + 36usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSet), @@ -1373,7 +1385,7 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSet() { &(*(::std::ptr::null::())) .num_ref_frames_in_pic_order_cnt_cycle as *const _ as usize }, - 36usize, + 40usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSet), @@ -1386,7 +1398,7 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSet() { &(*(::std::ptr::null::())).max_num_ref_frames as *const _ as usize }, - 37usize, + 41usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSet), @@ -1399,7 +1411,7 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSet() { &(*(::std::ptr::null::())).pic_width_in_mbs_minus1 as *const _ as usize }, - 40usize, + 44usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSet), @@ -1412,7 +1424,7 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSet() { &(*(::std::ptr::null::())) .pic_height_in_map_units_minus1 as *const _ as usize }, - 44usize, + 48usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSet), @@ -1425,7 +1437,7 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSet() { &(*(::std::ptr::null::())).frame_crop_left_offset as *const _ as usize }, - 48usize, + 52usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSet), @@ -1438,7 +1450,7 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSet() { &(*(::std::ptr::null::())).frame_crop_right_offset as *const _ as usize }, - 52usize, + 56usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSet), @@ -1451,7 +1463,7 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSet() { &(*(::std::ptr::null::())).frame_crop_top_offset as *const _ as usize }, - 56usize, + 60usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSet), @@ -1464,24 +1476,12 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSet() { &(*(::std::ptr::null::())).frame_crop_bottom_offset as *const _ as usize }, - 60usize, - concat!( - "Offset of field: ", - stringify!(StdVideoH264SequenceParameterSet), - "::", - stringify!(frame_crop_bottom_offset) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).flags as *const _ as usize - }, 64usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSet), "::", - stringify!(flags) + stringify!(frame_crop_bottom_offset) ) ); assert_eq!( @@ -1708,6 +1708,7 @@ impl StdVideoH264PpsFlags { #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct StdVideoH264PictureParameterSet { + pub flags: StdVideoH264PpsFlags, pub seq_parameter_set_id: u8, pub pic_parameter_set_id: u8, pub num_ref_idx_l0_default_active_minus1: u8, @@ -1717,8 +1718,7 @@ pub struct StdVideoH264PictureParameterSet { pub pic_init_qs_minus26: i8, pub chroma_qp_index_offset: i8, pub second_chroma_qp_index_offset: i8, - pub flags: StdVideoH264PpsFlags, - pub pScalingLists: *mut StdVideoH264ScalingLists, + pub pScalingLists: *const StdVideoH264ScalingLists, } #[test] fn bindgen_test_layout_StdVideoH264PictureParameterSet() { @@ -1732,12 +1732,24 @@ fn bindgen_test_layout_StdVideoH264PictureParameterSet() { 8usize, concat!("Alignment of ", stringify!(StdVideoH264PictureParameterSet)) ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).flags as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264PictureParameterSet), + "::", + stringify!(flags) + ) + ); assert_eq!( unsafe { &(*(::std::ptr::null::())).seq_parameter_set_id as *const _ as usize }, - 0usize, + 4usize, concat!( "Offset of field: ", stringify!(StdVideoH264PictureParameterSet), @@ -1750,7 +1762,7 @@ fn bindgen_test_layout_StdVideoH264PictureParameterSet() { &(*(::std::ptr::null::())).pic_parameter_set_id as *const _ as usize }, - 1usize, + 5usize, concat!( "Offset of field: ", stringify!(StdVideoH264PictureParameterSet), @@ -1763,7 +1775,7 @@ fn bindgen_test_layout_StdVideoH264PictureParameterSet() { &(*(::std::ptr::null::())) .num_ref_idx_l0_default_active_minus1 as *const _ as usize }, - 2usize, + 6usize, concat!( "Offset of field: ", stringify!(StdVideoH264PictureParameterSet), @@ -1776,7 +1788,7 @@ fn bindgen_test_layout_StdVideoH264PictureParameterSet() { &(*(::std::ptr::null::())) .num_ref_idx_l1_default_active_minus1 as *const _ as usize }, - 3usize, + 7usize, concat!( "Offset of field: ", stringify!(StdVideoH264PictureParameterSet), @@ -1789,7 +1801,7 @@ fn bindgen_test_layout_StdVideoH264PictureParameterSet() { &(*(::std::ptr::null::())).weighted_bipred_idc as *const _ as usize }, - 4usize, + 8usize, concat!( "Offset of field: ", stringify!(StdVideoH264PictureParameterSet), @@ -1802,7 +1814,7 @@ fn bindgen_test_layout_StdVideoH264PictureParameterSet() { &(*(::std::ptr::null::())).pic_init_qp_minus26 as *const _ as usize }, - 8usize, + 12usize, concat!( "Offset of field: ", stringify!(StdVideoH264PictureParameterSet), @@ -1815,7 +1827,7 @@ fn bindgen_test_layout_StdVideoH264PictureParameterSet() { &(*(::std::ptr::null::())).pic_init_qs_minus26 as *const _ as usize }, - 9usize, + 13usize, concat!( "Offset of field: ", stringify!(StdVideoH264PictureParameterSet), @@ -1828,7 +1840,7 @@ fn bindgen_test_layout_StdVideoH264PictureParameterSet() { &(*(::std::ptr::null::())).chroma_qp_index_offset as *const _ as usize }, - 10usize, + 14usize, concat!( "Offset of field: ", stringify!(StdVideoH264PictureParameterSet), @@ -1841,7 +1853,7 @@ fn bindgen_test_layout_StdVideoH264PictureParameterSet() { &(*(::std::ptr::null::())) .second_chroma_qp_index_offset as *const _ as usize }, - 11usize, + 15usize, concat!( "Offset of field: ", stringify!(StdVideoH264PictureParameterSet), @@ -1849,18 +1861,6 @@ fn bindgen_test_layout_StdVideoH264PictureParameterSet() { stringify!(second_chroma_qp_index_offset) ) ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).flags as *const _ as usize - }, - 12usize, - concat!( - "Offset of field: ", - stringify!(StdVideoH264PictureParameterSet), - "::", - stringify!(flags) - ) - ); assert_eq!( unsafe { &(*(::std::ptr::null::())).pScalingLists as *const _ @@ -2007,13 +2007,13 @@ impl StdVideoDecodeH264PictureInfoFlags { #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct StdVideoDecodeH264PictureInfo { + pub flags: StdVideoDecodeH264PictureInfoFlags, pub seq_parameter_set_id: u8, pub pic_parameter_set_id: u8, pub reserved: u16, pub frame_num: u16, pub idr_pic_id: u16, pub PicOrderCnt: [i32; 2usize], - pub flags: StdVideoDecodeH264PictureInfoFlags, } #[test] fn bindgen_test_layout_StdVideoDecodeH264PictureInfo() { @@ -2027,12 +2027,24 @@ fn bindgen_test_layout_StdVideoDecodeH264PictureInfo() { 4usize, concat!("Alignment of ", stringify!(StdVideoDecodeH264PictureInfo)) ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).flags as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoDecodeH264PictureInfo), + "::", + stringify!(flags) + ) + ); assert_eq!( unsafe { &(*(::std::ptr::null::())).seq_parameter_set_id as *const _ as usize }, - 0usize, + 4usize, concat!( "Offset of field: ", stringify!(StdVideoDecodeH264PictureInfo), @@ -2045,7 +2057,7 @@ fn bindgen_test_layout_StdVideoDecodeH264PictureInfo() { &(*(::std::ptr::null::())).pic_parameter_set_id as *const _ as usize }, - 1usize, + 5usize, concat!( "Offset of field: ", stringify!(StdVideoDecodeH264PictureInfo), @@ -2057,7 +2069,7 @@ fn bindgen_test_layout_StdVideoDecodeH264PictureInfo() { unsafe { &(*(::std::ptr::null::())).reserved as *const _ as usize }, - 2usize, + 6usize, concat!( "Offset of field: ", stringify!(StdVideoDecodeH264PictureInfo), @@ -2069,7 +2081,7 @@ fn bindgen_test_layout_StdVideoDecodeH264PictureInfo() { unsafe { &(*(::std::ptr::null::())).frame_num as *const _ as usize }, - 4usize, + 8usize, concat!( "Offset of field: ", stringify!(StdVideoDecodeH264PictureInfo), @@ -2082,7 +2094,7 @@ fn bindgen_test_layout_StdVideoDecodeH264PictureInfo() { &(*(::std::ptr::null::())).idr_pic_id as *const _ as usize }, - 6usize, + 10usize, concat!( "Offset of field: ", stringify!(StdVideoDecodeH264PictureInfo), @@ -2095,7 +2107,7 @@ fn bindgen_test_layout_StdVideoDecodeH264PictureInfo() { &(*(::std::ptr::null::())).PicOrderCnt as *const _ as usize }, - 8usize, + 12usize, concat!( "Offset of field: ", stringify!(StdVideoDecodeH264PictureInfo), @@ -2103,18 +2115,6 @@ fn bindgen_test_layout_StdVideoDecodeH264PictureInfo() { stringify!(PicOrderCnt) ) ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).flags as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(StdVideoDecodeH264PictureInfo), - "::", - stringify!(flags) - ) - ); } #[repr(C)] #[repr(align(4))] @@ -2167,11 +2167,11 @@ impl StdVideoDecodeH264ReferenceInfoFlags { } } #[inline] - pub fn is_long_term(&self) -> u32 { + pub fn used_for_long_term_reference(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } } #[inline] - pub fn set_is_long_term(&mut self, val: u32) { + pub fn set_used_for_long_term_reference(&mut self, val: u32) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(2usize, 1u8, val as u64) @@ -2192,7 +2192,7 @@ impl StdVideoDecodeH264ReferenceInfoFlags { pub fn new_bitfield_1( top_field_flag: u32, bottom_field_flag: u32, - is_long_term: u32, + used_for_long_term_reference: u32, is_non_existing: u32, ) -> __BindgenBitfieldUnit<[u8; 1usize]> { let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); @@ -2205,8 +2205,9 @@ impl StdVideoDecodeH264ReferenceInfoFlags { bottom_field_flag as u64 }); __bindgen_bitfield_unit.set(2usize, 1u8, { - let is_long_term: u32 = unsafe { ::std::mem::transmute(is_long_term) }; - is_long_term as u64 + let used_for_long_term_reference: u32 = + unsafe { ::std::mem::transmute(used_for_long_term_reference) }; + used_for_long_term_reference as u64 }); __bindgen_bitfield_unit.set(3usize, 1u8, { let is_non_existing: u32 = unsafe { ::std::mem::transmute(is_non_existing) }; @@ -2218,10 +2219,10 @@ impl StdVideoDecodeH264ReferenceInfoFlags { #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct StdVideoDecodeH264ReferenceInfo { + pub flags: StdVideoDecodeH264ReferenceInfoFlags, pub FrameNum: u16, pub reserved: u16, pub PicOrderCnt: [i32; 2usize], - pub flags: StdVideoDecodeH264ReferenceInfoFlags, } #[test] fn bindgen_test_layout_StdVideoDecodeH264ReferenceInfo() { @@ -2235,12 +2236,24 @@ fn bindgen_test_layout_StdVideoDecodeH264ReferenceInfo() { 4usize, concat!("Alignment of ", stringify!(StdVideoDecodeH264ReferenceInfo)) ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).flags as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoDecodeH264ReferenceInfo), + "::", + stringify!(flags) + ) + ); assert_eq!( unsafe { &(*(::std::ptr::null::())).FrameNum as *const _ as usize }, - 0usize, + 4usize, concat!( "Offset of field: ", stringify!(StdVideoDecodeH264ReferenceInfo), @@ -2253,7 +2266,7 @@ fn bindgen_test_layout_StdVideoDecodeH264ReferenceInfo() { &(*(::std::ptr::null::())).reserved as *const _ as usize }, - 2usize, + 6usize, concat!( "Offset of field: ", stringify!(StdVideoDecodeH264ReferenceInfo), @@ -2266,7 +2279,7 @@ fn bindgen_test_layout_StdVideoDecodeH264ReferenceInfo() { &(*(::std::ptr::null::())).PicOrderCnt as *const _ as usize }, - 4usize, + 8usize, concat!( "Offset of field: ", stringify!(StdVideoDecodeH264ReferenceInfo), @@ -2274,18 +2287,6 @@ fn bindgen_test_layout_StdVideoDecodeH264ReferenceInfo() { stringify!(PicOrderCnt) ) ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).flags as *const _ as usize - }, - 12usize, - concat!( - "Offset of field: ", - stringify!(StdVideoDecodeH264ReferenceInfo), - "::", - stringify!(flags) - ) - ); } #[repr(C)] #[repr(align(4))] @@ -2567,7 +2568,7 @@ fn bindgen_test_layout_StdVideoDecodeH264MvcElement() { pub struct StdVideoDecodeH264Mvc { pub viewId0: u32, pub mvcElementCount: u32, - pub pMvcElements: *mut StdVideoDecodeH264MvcElement, + pub pMvcElements: *const StdVideoDecodeH264MvcElement, } #[test] fn bindgen_test_layout_StdVideoDecodeH264Mvc() { @@ -2953,6 +2954,7 @@ impl StdVideoH265HrdFlags { #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct StdVideoH265HrdParameters { + pub flags: StdVideoH265HrdFlags, pub tick_divisor_minus2: u8, pub du_cpb_removal_delay_increment_length_minus1: u8, pub dpb_output_delay_du_length_minus1: u8, @@ -2964,9 +2966,8 @@ pub struct StdVideoH265HrdParameters { pub dpb_output_delay_length_minus1: u8, pub cpb_cnt_minus1: [u8; 7usize], pub elemental_duration_in_tc_minus1: [u16; 7usize], - pub pSubLayerHrdParametersNal: [*mut StdVideoH265SubLayerHrdParameters; 7usize], - pub pSubLayerHrdParametersVcl: [*mut StdVideoH265SubLayerHrdParameters; 7usize], - pub flags: StdVideoH265HrdFlags, + pub pSubLayerHrdParametersNal: [*const StdVideoH265SubLayerHrdParameters; 7usize], + pub pSubLayerHrdParametersVcl: [*const StdVideoH265SubLayerHrdParameters; 7usize], } #[test] fn bindgen_test_layout_StdVideoH265HrdParameters() { @@ -2980,12 +2981,22 @@ fn bindgen_test_layout_StdVideoH265HrdParameters() { 8usize, concat!("Alignment of ", stringify!(StdVideoH265HrdParameters)) ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).flags as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265HrdParameters), + "::", + stringify!(flags) + ) + ); assert_eq!( unsafe { &(*(::std::ptr::null::())).tick_divisor_minus2 as *const _ as usize }, - 0usize, + 4usize, concat!( "Offset of field: ", stringify!(StdVideoH265HrdParameters), @@ -2998,7 +3009,7 @@ fn bindgen_test_layout_StdVideoH265HrdParameters() { &(*(::std::ptr::null::())) .du_cpb_removal_delay_increment_length_minus1 as *const _ as usize }, - 1usize, + 5usize, concat!( "Offset of field: ", stringify!(StdVideoH265HrdParameters), @@ -3011,7 +3022,7 @@ fn bindgen_test_layout_StdVideoH265HrdParameters() { &(*(::std::ptr::null::())).dpb_output_delay_du_length_minus1 as *const _ as usize }, - 2usize, + 6usize, concat!( "Offset of field: ", stringify!(StdVideoH265HrdParameters), @@ -3024,7 +3035,7 @@ fn bindgen_test_layout_StdVideoH265HrdParameters() { &(*(::std::ptr::null::())).bit_rate_scale as *const _ as usize }, - 3usize, + 7usize, concat!( "Offset of field: ", stringify!(StdVideoH265HrdParameters), @@ -3037,7 +3048,7 @@ fn bindgen_test_layout_StdVideoH265HrdParameters() { &(*(::std::ptr::null::())).cpb_size_scale as *const _ as usize }, - 4usize, + 8usize, concat!( "Offset of field: ", stringify!(StdVideoH265HrdParameters), @@ -3050,7 +3061,7 @@ fn bindgen_test_layout_StdVideoH265HrdParameters() { &(*(::std::ptr::null::())).cpb_size_du_scale as *const _ as usize }, - 5usize, + 9usize, concat!( "Offset of field: ", stringify!(StdVideoH265HrdParameters), @@ -3063,7 +3074,7 @@ fn bindgen_test_layout_StdVideoH265HrdParameters() { &(*(::std::ptr::null::())) .initial_cpb_removal_delay_length_minus1 as *const _ as usize }, - 6usize, + 10usize, concat!( "Offset of field: ", stringify!(StdVideoH265HrdParameters), @@ -3076,7 +3087,7 @@ fn bindgen_test_layout_StdVideoH265HrdParameters() { &(*(::std::ptr::null::())).au_cpb_removal_delay_length_minus1 as *const _ as usize }, - 7usize, + 11usize, concat!( "Offset of field: ", stringify!(StdVideoH265HrdParameters), @@ -3089,7 +3100,7 @@ fn bindgen_test_layout_StdVideoH265HrdParameters() { &(*(::std::ptr::null::())).dpb_output_delay_length_minus1 as *const _ as usize }, - 8usize, + 12usize, concat!( "Offset of field: ", stringify!(StdVideoH265HrdParameters), @@ -3102,7 +3113,7 @@ fn bindgen_test_layout_StdVideoH265HrdParameters() { &(*(::std::ptr::null::())).cpb_cnt_minus1 as *const _ as usize }, - 9usize, + 13usize, concat!( "Offset of field: ", stringify!(StdVideoH265HrdParameters), @@ -3115,7 +3126,7 @@ fn bindgen_test_layout_StdVideoH265HrdParameters() { &(*(::std::ptr::null::())).elemental_duration_in_tc_minus1 as *const _ as usize }, - 16usize, + 20usize, concat!( "Offset of field: ", stringify!(StdVideoH265HrdParameters), @@ -3128,7 +3139,7 @@ fn bindgen_test_layout_StdVideoH265HrdParameters() { &(*(::std::ptr::null::())).pSubLayerHrdParametersNal as *const _ as usize }, - 32usize, + 40usize, concat!( "Offset of field: ", stringify!(StdVideoH265HrdParameters), @@ -3141,7 +3152,7 @@ fn bindgen_test_layout_StdVideoH265HrdParameters() { &(*(::std::ptr::null::())).pSubLayerHrdParametersVcl as *const _ as usize }, - 88usize, + 96usize, concat!( "Offset of field: ", stringify!(StdVideoH265HrdParameters), @@ -3149,16 +3160,6 @@ fn bindgen_test_layout_StdVideoH265HrdParameters() { stringify!(pSubLayerHrdParametersVcl) ) ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).flags as *const _ as usize }, - 144usize, - concat!( - "Offset of field: ", - stringify!(StdVideoH265HrdParameters), - "::", - stringify!(flags) - ) - ); } #[repr(C)] #[repr(align(4))] @@ -3260,14 +3261,14 @@ impl StdVideoH265VpsFlags { #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct StdVideoH265VideoParameterSet { + pub flags: StdVideoH265VpsFlags, pub vps_video_parameter_set_id: u8, pub vps_max_sub_layers_minus1: u8, pub vps_num_units_in_tick: u32, pub vps_time_scale: u32, pub vps_num_ticks_poc_diff_one_minus1: u32, - pub pDecPicBufMgr: *mut StdVideoH265DecPicBufMgr, - pub pHrdParameters: *mut StdVideoH265HrdParameters, - pub flags: StdVideoH265VpsFlags, + pub pDecPicBufMgr: *const StdVideoH265DecPicBufMgr, + pub pHrdParameters: *const StdVideoH265HrdParameters, } #[test] fn bindgen_test_layout_StdVideoH265VideoParameterSet() { @@ -3281,12 +3282,24 @@ fn bindgen_test_layout_StdVideoH265VideoParameterSet() { 8usize, concat!("Alignment of ", stringify!(StdVideoH265VideoParameterSet)) ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).flags as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265VideoParameterSet), + "::", + stringify!(flags) + ) + ); assert_eq!( unsafe { &(*(::std::ptr::null::())).vps_video_parameter_set_id as *const _ as usize }, - 0usize, + 4usize, concat!( "Offset of field: ", stringify!(StdVideoH265VideoParameterSet), @@ -3299,7 +3312,7 @@ fn bindgen_test_layout_StdVideoH265VideoParameterSet() { &(*(::std::ptr::null::())).vps_max_sub_layers_minus1 as *const _ as usize }, - 1usize, + 5usize, concat!( "Offset of field: ", stringify!(StdVideoH265VideoParameterSet), @@ -3312,7 +3325,7 @@ fn bindgen_test_layout_StdVideoH265VideoParameterSet() { &(*(::std::ptr::null::())).vps_num_units_in_tick as *const _ as usize }, - 4usize, + 8usize, concat!( "Offset of field: ", stringify!(StdVideoH265VideoParameterSet), @@ -3325,7 +3338,7 @@ fn bindgen_test_layout_StdVideoH265VideoParameterSet() { &(*(::std::ptr::null::())).vps_time_scale as *const _ as usize }, - 8usize, + 12usize, concat!( "Offset of field: ", stringify!(StdVideoH265VideoParameterSet), @@ -3338,7 +3351,7 @@ fn bindgen_test_layout_StdVideoH265VideoParameterSet() { &(*(::std::ptr::null::())) .vps_num_ticks_poc_diff_one_minus1 as *const _ as usize }, - 12usize, + 16usize, concat!( "Offset of field: ", stringify!(StdVideoH265VideoParameterSet), @@ -3351,7 +3364,7 @@ fn bindgen_test_layout_StdVideoH265VideoParameterSet() { &(*(::std::ptr::null::())).pDecPicBufMgr as *const _ as usize }, - 16usize, + 24usize, concat!( "Offset of field: ", stringify!(StdVideoH265VideoParameterSet), @@ -3364,24 +3377,12 @@ fn bindgen_test_layout_StdVideoH265VideoParameterSet() { &(*(::std::ptr::null::())).pHrdParameters as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(StdVideoH265VideoParameterSet), - "::", - stringify!(pHrdParameters) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).flags as *const _ as usize - }, 32usize, concat!( "Offset of field: ", stringify!(StdVideoH265VideoParameterSet), "::", - stringify!(flags) + stringify!(pHrdParameters) ) ); } @@ -3821,6 +3822,7 @@ impl StdVideoH265SpsVuiFlags { #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct StdVideoH265SequenceParameterSetVui { + pub flags: StdVideoH265SpsVuiFlags, pub aspect_ratio_idc: u8, pub sar_width: u16, pub sar_height: u16, @@ -3837,13 +3839,12 @@ pub struct StdVideoH265SequenceParameterSetVui { pub vui_num_units_in_tick: u32, pub vui_time_scale: u32, pub vui_num_ticks_poc_diff_one_minus1: u32, - pub pHrdParameters: *mut StdVideoH265HrdParameters, + pub pHrdParameters: *const StdVideoH265HrdParameters, pub min_spatial_segmentation_idc: u16, pub max_bytes_per_pic_denom: u8, pub max_bits_per_min_cu_denom: u8, pub log2_max_mv_length_horizontal: u8, pub log2_max_mv_length_vertical: u8, - pub flags: StdVideoH265SpsVuiFlags, } #[test] fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() { @@ -3860,12 +3861,25 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() { stringify!(StdVideoH265SequenceParameterSetVui) ) ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).flags as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSetVui), + "::", + stringify!(flags) + ) + ); assert_eq!( unsafe { &(*(::std::ptr::null::())).aspect_ratio_idc as *const _ as usize }, - 0usize, + 4usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSetVui), @@ -3878,7 +3892,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() { &(*(::std::ptr::null::())).sar_width as *const _ as usize }, - 2usize, + 6usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSetVui), @@ -3891,7 +3905,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() { &(*(::std::ptr::null::())).sar_height as *const _ as usize }, - 4usize, + 8usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSetVui), @@ -3904,7 +3918,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() { &(*(::std::ptr::null::())).video_format as *const _ as usize }, - 6usize, + 10usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSetVui), @@ -3917,7 +3931,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() { &(*(::std::ptr::null::())).colour_primaries as *const _ as usize }, - 7usize, + 11usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSetVui), @@ -3930,7 +3944,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() { &(*(::std::ptr::null::())).transfer_characteristics as *const _ as usize }, - 8usize, + 12usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSetVui), @@ -3943,7 +3957,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() { &(*(::std::ptr::null::())).matrix_coeffs as *const _ as usize }, - 9usize, + 13usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSetVui), @@ -3956,7 +3970,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() { &(*(::std::ptr::null::())) .chroma_sample_loc_type_top_field as *const _ as usize }, - 10usize, + 14usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSetVui), @@ -3969,7 +3983,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() { &(*(::std::ptr::null::())) .chroma_sample_loc_type_bottom_field as *const _ as usize }, - 11usize, + 15usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSetVui), @@ -3982,7 +3996,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() { &(*(::std::ptr::null::())).def_disp_win_left_offset as *const _ as usize }, - 12usize, + 16usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSetVui), @@ -3995,7 +4009,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() { &(*(::std::ptr::null::())) .def_disp_win_right_offset as *const _ as usize }, - 14usize, + 18usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSetVui), @@ -4008,7 +4022,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() { &(*(::std::ptr::null::())).def_disp_win_top_offset as *const _ as usize }, - 16usize, + 20usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSetVui), @@ -4021,7 +4035,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() { &(*(::std::ptr::null::())) .def_disp_win_bottom_offset as *const _ as usize }, - 18usize, + 22usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSetVui), @@ -4034,7 +4048,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() { &(*(::std::ptr::null::())).vui_num_units_in_tick as *const _ as usize }, - 20usize, + 24usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSetVui), @@ -4047,7 +4061,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() { &(*(::std::ptr::null::())).vui_time_scale as *const _ as usize }, - 24usize, + 28usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSetVui), @@ -4060,7 +4074,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() { &(*(::std::ptr::null::())) .vui_num_ticks_poc_diff_one_minus1 as *const _ as usize }, - 28usize, + 32usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSetVui), @@ -4073,7 +4087,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() { &(*(::std::ptr::null::())).pHrdParameters as *const _ as usize }, - 32usize, + 40usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSetVui), @@ -4086,7 +4100,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() { &(*(::std::ptr::null::())) .min_spatial_segmentation_idc as *const _ as usize }, - 40usize, + 48usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSetVui), @@ -4099,7 +4113,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() { &(*(::std::ptr::null::())).max_bytes_per_pic_denom as *const _ as usize }, - 42usize, + 50usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSetVui), @@ -4112,7 +4126,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() { &(*(::std::ptr::null::())) .max_bits_per_min_cu_denom as *const _ as usize }, - 43usize, + 51usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSetVui), @@ -4125,7 +4139,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() { &(*(::std::ptr::null::())) .log2_max_mv_length_horizontal as *const _ as usize }, - 44usize, + 52usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSetVui), @@ -4138,7 +4152,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() { &(*(::std::ptr::null::())) .log2_max_mv_length_vertical as *const _ as usize }, - 45usize, + 53usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSetVui), @@ -4146,19 +4160,6 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() { stringify!(log2_max_mv_length_vertical) ) ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).flags as *const _ - as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(StdVideoH265SequenceParameterSetVui), - "::", - stringify!(flags) - ) - ); } #[repr(C)] #[derive(Copy, Clone)] @@ -4469,47 +4470,58 @@ impl StdVideoH265SpsFlags { } } #[inline] - pub fn sps_curr_pic_ref_enabled_flag(&self) -> u32 { + pub fn sps_scc_extension_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u32) } } #[inline] - pub fn set_sps_curr_pic_ref_enabled_flag(&mut self, val: u32) { + pub fn set_sps_scc_extension_flag(&mut self, val: u32) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(23usize, 1u8, val as u64) } } #[inline] - pub fn palette_mode_enabled_flag(&self) -> u32 { + pub fn sps_curr_pic_ref_enabled_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 1u8) as u32) } } #[inline] - pub fn set_palette_mode_enabled_flag(&mut self, val: u32) { + pub fn set_sps_curr_pic_ref_enabled_flag(&mut self, val: u32) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(24usize, 1u8, val as u64) } } #[inline] - pub fn sps_palette_predictor_initializer_present_flag(&self) -> u32 { + pub fn palette_mode_enabled_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(25usize, 1u8) as u32) } } #[inline] - pub fn set_sps_palette_predictor_initializer_present_flag(&mut self, val: u32) { + pub fn set_palette_mode_enabled_flag(&mut self, val: u32) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(25usize, 1u8, val as u64) } } #[inline] - pub fn intra_boundary_filtering_disabled_flag(&self) -> u32 { + pub fn sps_palette_predictor_initializer_present_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u32) } } #[inline] + pub fn set_sps_palette_predictor_initializer_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(26usize, 1u8, val as u64) + } + } + #[inline] + pub fn intra_boundary_filtering_disabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(27usize, 1u8) as u32) } + } + #[inline] pub fn set_intra_boundary_filtering_disabled_flag(&mut self, val: u32) { unsafe { let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(26usize, 1u8, val as u64) + self._bitfield_1.set(27usize, 1u8, val as u64) } } #[inline] @@ -4537,6 +4549,7 @@ impl StdVideoH265SpsFlags { high_precision_offsets_enabled_flag: u32, persistent_rice_adaptation_enabled_flag: u32, cabac_bypass_alignment_enabled_flag: u32, + sps_scc_extension_flag: u32, sps_curr_pic_ref_enabled_flag: u32, palette_mode_enabled_flag: u32, sps_palette_predictor_initializer_present_flag: u32, @@ -4657,21 +4670,26 @@ impl StdVideoH265SpsFlags { cabac_bypass_alignment_enabled_flag as u64 }); __bindgen_bitfield_unit.set(23usize, 1u8, { + let sps_scc_extension_flag: u32 = + unsafe { ::std::mem::transmute(sps_scc_extension_flag) }; + sps_scc_extension_flag as u64 + }); + __bindgen_bitfield_unit.set(24usize, 1u8, { let sps_curr_pic_ref_enabled_flag: u32 = unsafe { ::std::mem::transmute(sps_curr_pic_ref_enabled_flag) }; sps_curr_pic_ref_enabled_flag as u64 }); - __bindgen_bitfield_unit.set(24usize, 1u8, { + __bindgen_bitfield_unit.set(25usize, 1u8, { let palette_mode_enabled_flag: u32 = unsafe { ::std::mem::transmute(palette_mode_enabled_flag) }; palette_mode_enabled_flag as u64 }); - __bindgen_bitfield_unit.set(25usize, 1u8, { + __bindgen_bitfield_unit.set(26usize, 1u8, { let sps_palette_predictor_initializer_present_flag: u32 = unsafe { ::std::mem::transmute(sps_palette_predictor_initializer_present_flag) }; sps_palette_predictor_initializer_present_flag as u64 }); - __bindgen_bitfield_unit.set(26usize, 1u8, { + __bindgen_bitfield_unit.set(27usize, 1u8, { let intra_boundary_filtering_disabled_flag: u32 = unsafe { ::std::mem::transmute(intra_boundary_filtering_disabled_flag) }; intra_boundary_filtering_disabled_flag as u64 @@ -4682,6 +4700,7 @@ impl StdVideoH265SpsFlags { #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct StdVideoH265SequenceParameterSet { + pub flags: StdVideoH265SpsFlags, pub profile_idc: StdVideoH265ProfileIdc, pub level_idc: StdVideoH265Level, pub pic_width_in_luma_samples: u32, @@ -4693,7 +4712,7 @@ pub struct StdVideoH265SequenceParameterSet { pub bit_depth_luma_minus8: u8, pub bit_depth_chroma_minus8: u8, pub log2_max_pic_order_cnt_lsb_minus4: u8, - pub sps_max_dec_pic_buffering_minus1: u8, + pub sps_max_dec_pic_buffering_minus1: [u8; 8usize], pub log2_min_luma_coding_block_size_minus3: u8, pub log2_diff_max_min_luma_coding_block_size: u8, pub log2_min_luma_transform_block_size_minus2: u8, @@ -4710,15 +4729,14 @@ pub struct StdVideoH265SequenceParameterSet { pub conf_win_right_offset: u32, pub conf_win_top_offset: u32, pub conf_win_bottom_offset: u32, - pub pDecPicBufMgr: *mut StdVideoH265DecPicBufMgr, - pub flags: StdVideoH265SpsFlags, - pub pScalingLists: *mut StdVideoH265ScalingLists, - pub pSequenceParameterSetVui: *mut StdVideoH265SequenceParameterSetVui, + pub pDecPicBufMgr: *const StdVideoH265DecPicBufMgr, + pub pScalingLists: *const StdVideoH265ScalingLists, + pub pSequenceParameterSetVui: *const StdVideoH265SequenceParameterSetVui, pub palette_max_size: u8, pub delta_palette_max_predictor_size: u8, pub motion_vector_resolution_control_idc: u8, pub sps_num_palette_predictor_initializer_minus1: u8, - pub pPredictorPaletteEntries: *mut StdVideoH265PredictorPaletteEntries, + pub pPredictorPaletteEntries: *const StdVideoH265PredictorPaletteEntries, } #[test] fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { @@ -4735,12 +4753,24 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { stringify!(StdVideoH265SequenceParameterSet) ) ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).flags as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(flags) + ) + ); assert_eq!( unsafe { &(*(::std::ptr::null::())).profile_idc as *const _ as usize }, - 0usize, + 4usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -4753,7 +4783,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { &(*(::std::ptr::null::())).level_idc as *const _ as usize }, - 4usize, + 8usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -4766,7 +4796,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { &(*(::std::ptr::null::())).pic_width_in_luma_samples as *const _ as usize }, - 8usize, + 12usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -4779,7 +4809,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { &(*(::std::ptr::null::())).pic_height_in_luma_samples as *const _ as usize }, - 12usize, + 16usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -4792,7 +4822,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { &(*(::std::ptr::null::())).sps_video_parameter_set_id as *const _ as usize }, - 16usize, + 20usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -4805,7 +4835,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { &(*(::std::ptr::null::())).sps_max_sub_layers_minus1 as *const _ as usize }, - 17usize, + 21usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -4818,7 +4848,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { &(*(::std::ptr::null::())).sps_seq_parameter_set_id as *const _ as usize }, - 18usize, + 22usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -4831,7 +4861,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { &(*(::std::ptr::null::())).chroma_format_idc as *const _ as usize }, - 19usize, + 23usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -4844,7 +4874,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { &(*(::std::ptr::null::())).bit_depth_luma_minus8 as *const _ as usize }, - 20usize, + 24usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -4857,7 +4887,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { &(*(::std::ptr::null::())).bit_depth_chroma_minus8 as *const _ as usize }, - 21usize, + 25usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -4870,7 +4900,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { &(*(::std::ptr::null::())) .log2_max_pic_order_cnt_lsb_minus4 as *const _ as usize }, - 22usize, + 26usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -4883,7 +4913,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { &(*(::std::ptr::null::())) .sps_max_dec_pic_buffering_minus1 as *const _ as usize }, - 23usize, + 27usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -4896,7 +4926,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { &(*(::std::ptr::null::())) .log2_min_luma_coding_block_size_minus3 as *const _ as usize }, - 24usize, + 35usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -4909,7 +4939,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { &(*(::std::ptr::null::())) .log2_diff_max_min_luma_coding_block_size as *const _ as usize }, - 25usize, + 36usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -4922,7 +4952,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { &(*(::std::ptr::null::())) .log2_min_luma_transform_block_size_minus2 as *const _ as usize }, - 26usize, + 37usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -4935,7 +4965,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { &(*(::std::ptr::null::())) .log2_diff_max_min_luma_transform_block_size as *const _ as usize }, - 27usize, + 38usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -4948,7 +4978,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { &(*(::std::ptr::null::())) .max_transform_hierarchy_depth_inter as *const _ as usize }, - 28usize, + 39usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -4961,7 +4991,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { &(*(::std::ptr::null::())) .max_transform_hierarchy_depth_intra as *const _ as usize }, - 29usize, + 40usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -4974,7 +5004,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { &(*(::std::ptr::null::())).num_short_term_ref_pic_sets as *const _ as usize }, - 30usize, + 41usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -4987,7 +5017,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { &(*(::std::ptr::null::())).num_long_term_ref_pics_sps as *const _ as usize }, - 31usize, + 42usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -5000,7 +5030,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { &(*(::std::ptr::null::())) .pcm_sample_bit_depth_luma_minus1 as *const _ as usize }, - 32usize, + 43usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -5013,7 +5043,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { &(*(::std::ptr::null::())) .pcm_sample_bit_depth_chroma_minus1 as *const _ as usize }, - 33usize, + 44usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -5026,7 +5056,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { &(*(::std::ptr::null::())) .log2_min_pcm_luma_coding_block_size_minus3 as *const _ as usize }, - 34usize, + 45usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -5039,7 +5069,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { &(*(::std::ptr::null::())) .log2_diff_max_min_pcm_luma_coding_block_size as *const _ as usize }, - 35usize, + 46usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -5052,7 +5082,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { &(*(::std::ptr::null::())).conf_win_left_offset as *const _ as usize }, - 36usize, + 48usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -5065,7 +5095,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { &(*(::std::ptr::null::())).conf_win_right_offset as *const _ as usize }, - 40usize, + 52usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -5078,7 +5108,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { &(*(::std::ptr::null::())).conf_win_top_offset as *const _ as usize }, - 44usize, + 56usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -5091,7 +5121,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { &(*(::std::ptr::null::())).conf_win_bottom_offset as *const _ as usize }, - 48usize, + 60usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -5104,24 +5134,12 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { &(*(::std::ptr::null::())).pDecPicBufMgr as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(StdVideoH265SequenceParameterSet), - "::", - stringify!(pDecPicBufMgr) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).flags as *const _ as usize - }, 64usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), "::", - stringify!(flags) + stringify!(pDecPicBufMgr) ) ); assert_eq!( @@ -5770,6 +5788,7 @@ impl StdVideoH265PpsFlags { #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct StdVideoH265PictureParameterSet { + pub flags: StdVideoH265PpsFlags, pub pps_pic_parameter_set_id: u8, pub pps_seq_parameter_set_id: u8, pub num_extra_slice_header_bits: u8, @@ -5786,8 +5805,7 @@ pub struct StdVideoH265PictureParameterSet { pub pps_beta_offset_div2: i8, pub pps_tc_offset_div2: i8, pub log2_parallel_merge_level_minus2: u8, - pub flags: StdVideoH265PpsFlags, - pub pScalingLists: *mut StdVideoH265ScalingLists, + pub pScalingLists: *const StdVideoH265ScalingLists, pub log2_max_transform_skip_block_size_minus2: u8, pub diff_cu_chroma_qp_offset_depth: u8, pub chroma_qp_offset_list_len_minus1: u8, @@ -5801,7 +5819,7 @@ pub struct StdVideoH265PictureParameterSet { pub pps_num_palette_predictor_initializer: u8, pub luma_bit_depth_entry_minus8: u8, pub chroma_bit_depth_entry_minus8: u8, - pub pPredictorPaletteEntries: *mut StdVideoH265PredictorPaletteEntries, + pub pPredictorPaletteEntries: *const StdVideoH265PredictorPaletteEntries, } #[test] fn bindgen_test_layout_StdVideoH265PictureParameterSet() { @@ -5815,12 +5833,24 @@ fn bindgen_test_layout_StdVideoH265PictureParameterSet() { 8usize, concat!("Alignment of ", stringify!(StdVideoH265PictureParameterSet)) ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).flags as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(flags) + ) + ); assert_eq!( unsafe { &(*(::std::ptr::null::())).pps_pic_parameter_set_id as *const _ as usize }, - 0usize, + 4usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), @@ -5833,7 +5863,7 @@ fn bindgen_test_layout_StdVideoH265PictureParameterSet() { &(*(::std::ptr::null::())).pps_seq_parameter_set_id as *const _ as usize }, - 1usize, + 5usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), @@ -5846,7 +5876,7 @@ fn bindgen_test_layout_StdVideoH265PictureParameterSet() { &(*(::std::ptr::null::())).num_extra_slice_header_bits as *const _ as usize }, - 2usize, + 6usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), @@ -5859,7 +5889,7 @@ fn bindgen_test_layout_StdVideoH265PictureParameterSet() { &(*(::std::ptr::null::())) .num_ref_idx_l0_default_active_minus1 as *const _ as usize }, - 3usize, + 7usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), @@ -5872,7 +5902,7 @@ fn bindgen_test_layout_StdVideoH265PictureParameterSet() { &(*(::std::ptr::null::())) .num_ref_idx_l1_default_active_minus1 as *const _ as usize }, - 4usize, + 8usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), @@ -5885,7 +5915,7 @@ fn bindgen_test_layout_StdVideoH265PictureParameterSet() { &(*(::std::ptr::null::())).init_qp_minus26 as *const _ as usize }, - 5usize, + 9usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), @@ -5898,7 +5928,7 @@ fn bindgen_test_layout_StdVideoH265PictureParameterSet() { &(*(::std::ptr::null::())).diff_cu_qp_delta_depth as *const _ as usize }, - 6usize, + 10usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), @@ -5911,7 +5941,7 @@ fn bindgen_test_layout_StdVideoH265PictureParameterSet() { &(*(::std::ptr::null::())).pps_cb_qp_offset as *const _ as usize }, - 7usize, + 11usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), @@ -5924,7 +5954,7 @@ fn bindgen_test_layout_StdVideoH265PictureParameterSet() { &(*(::std::ptr::null::())).pps_cr_qp_offset as *const _ as usize }, - 8usize, + 12usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), @@ -5937,7 +5967,7 @@ fn bindgen_test_layout_StdVideoH265PictureParameterSet() { &(*(::std::ptr::null::())).num_tile_columns_minus1 as *const _ as usize }, - 9usize, + 13usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), @@ -5950,7 +5980,7 @@ fn bindgen_test_layout_StdVideoH265PictureParameterSet() { &(*(::std::ptr::null::())).num_tile_rows_minus1 as *const _ as usize }, - 10usize, + 14usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), @@ -5963,7 +5993,7 @@ fn bindgen_test_layout_StdVideoH265PictureParameterSet() { &(*(::std::ptr::null::())).column_width_minus1 as *const _ as usize }, - 12usize, + 16usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), @@ -5976,7 +6006,7 @@ fn bindgen_test_layout_StdVideoH265PictureParameterSet() { &(*(::std::ptr::null::())).row_height_minus1 as *const _ as usize }, - 50usize, + 54usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), @@ -5989,7 +6019,7 @@ fn bindgen_test_layout_StdVideoH265PictureParameterSet() { &(*(::std::ptr::null::())).pps_beta_offset_div2 as *const _ as usize }, - 92usize, + 96usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), @@ -6002,7 +6032,7 @@ fn bindgen_test_layout_StdVideoH265PictureParameterSet() { &(*(::std::ptr::null::())).pps_tc_offset_div2 as *const _ as usize }, - 93usize, + 97usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), @@ -6015,7 +6045,7 @@ fn bindgen_test_layout_StdVideoH265PictureParameterSet() { &(*(::std::ptr::null::())) .log2_parallel_merge_level_minus2 as *const _ as usize }, - 94usize, + 98usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), @@ -6023,18 +6053,6 @@ fn bindgen_test_layout_StdVideoH265PictureParameterSet() { stringify!(log2_parallel_merge_level_minus2) ) ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).flags as *const _ as usize - }, - 96usize, - concat!( - "Offset of field: ", - stringify!(StdVideoH265PictureParameterSet), - "::", - stringify!(flags) - ) - ); assert_eq!( unsafe { &(*(::std::ptr::null::())).pScalingLists as *const _ @@ -6331,8 +6349,9 @@ impl StdVideoDecodeH265PictureInfoFlags { #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct StdVideoDecodeH265PictureInfo { - pub vps_video_parameter_set_id: u8, - pub sps_seq_parameter_set_id: u8, + pub flags: StdVideoDecodeH265PictureInfoFlags, + pub sps_video_parameter_set_id: u8, + pub pps_seq_parameter_set_id: u8, pub pps_pic_parameter_set_id: u8, pub num_short_term_ref_pic_sets: u8, pub PicOrderCntVal: i32, @@ -6341,7 +6360,6 @@ pub struct StdVideoDecodeH265PictureInfo { pub RefPicSetStCurrBefore: [u8; 8usize], pub RefPicSetStCurrAfter: [u8; 8usize], pub RefPicSetLtCurr: [u8; 8usize], - pub flags: StdVideoDecodeH265PictureInfoFlags, } #[test] fn bindgen_test_layout_StdVideoDecodeH265PictureInfo() { @@ -6357,28 +6375,40 @@ fn bindgen_test_layout_StdVideoDecodeH265PictureInfo() { ); assert_eq!( unsafe { - &(*(::std::ptr::null::())).vps_video_parameter_set_id - as *const _ as usize + &(*(::std::ptr::null::())).flags as *const _ as usize }, 0usize, concat!( "Offset of field: ", stringify!(StdVideoDecodeH265PictureInfo), "::", - stringify!(vps_video_parameter_set_id) + stringify!(flags) ) ); assert_eq!( unsafe { - &(*(::std::ptr::null::())).sps_seq_parameter_set_id + &(*(::std::ptr::null::())).sps_video_parameter_set_id as *const _ as usize }, - 1usize, + 4usize, concat!( "Offset of field: ", stringify!(StdVideoDecodeH265PictureInfo), "::", - stringify!(sps_seq_parameter_set_id) + stringify!(sps_video_parameter_set_id) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).pps_seq_parameter_set_id + as *const _ as usize + }, + 5usize, + concat!( + "Offset of field: ", + stringify!(StdVideoDecodeH265PictureInfo), + "::", + stringify!(pps_seq_parameter_set_id) ) ); assert_eq!( @@ -6386,7 +6416,7 @@ fn bindgen_test_layout_StdVideoDecodeH265PictureInfo() { &(*(::std::ptr::null::())).pps_pic_parameter_set_id as *const _ as usize }, - 2usize, + 6usize, concat!( "Offset of field: ", stringify!(StdVideoDecodeH265PictureInfo), @@ -6399,7 +6429,7 @@ fn bindgen_test_layout_StdVideoDecodeH265PictureInfo() { &(*(::std::ptr::null::())).num_short_term_ref_pic_sets as *const _ as usize }, - 3usize, + 7usize, concat!( "Offset of field: ", stringify!(StdVideoDecodeH265PictureInfo), @@ -6412,7 +6442,7 @@ fn bindgen_test_layout_StdVideoDecodeH265PictureInfo() { &(*(::std::ptr::null::())).PicOrderCntVal as *const _ as usize }, - 4usize, + 8usize, concat!( "Offset of field: ", stringify!(StdVideoDecodeH265PictureInfo), @@ -6425,7 +6455,7 @@ fn bindgen_test_layout_StdVideoDecodeH265PictureInfo() { &(*(::std::ptr::null::())).NumBitsForSTRefPicSetInSlice as *const _ as usize }, - 8usize, + 12usize, concat!( "Offset of field: ", stringify!(StdVideoDecodeH265PictureInfo), @@ -6438,7 +6468,7 @@ fn bindgen_test_layout_StdVideoDecodeH265PictureInfo() { &(*(::std::ptr::null::())).NumDeltaPocsOfRefRpsIdx as *const _ as usize }, - 10usize, + 14usize, concat!( "Offset of field: ", stringify!(StdVideoDecodeH265PictureInfo), @@ -6451,7 +6481,7 @@ fn bindgen_test_layout_StdVideoDecodeH265PictureInfo() { &(*(::std::ptr::null::())).RefPicSetStCurrBefore as *const _ as usize }, - 11usize, + 15usize, concat!( "Offset of field: ", stringify!(StdVideoDecodeH265PictureInfo), @@ -6464,7 +6494,7 @@ fn bindgen_test_layout_StdVideoDecodeH265PictureInfo() { &(*(::std::ptr::null::())).RefPicSetStCurrAfter as *const _ as usize }, - 19usize, + 23usize, concat!( "Offset of field: ", stringify!(StdVideoDecodeH265PictureInfo), @@ -6477,7 +6507,7 @@ fn bindgen_test_layout_StdVideoDecodeH265PictureInfo() { &(*(::std::ptr::null::())).RefPicSetLtCurr as *const _ as usize }, - 27usize, + 31usize, concat!( "Offset of field: ", stringify!(StdVideoDecodeH265PictureInfo), @@ -6485,18 +6515,6 @@ fn bindgen_test_layout_StdVideoDecodeH265PictureInfo() { stringify!(RefPicSetLtCurr) ) ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).flags as *const _ as usize - }, - 36usize, - concat!( - "Offset of field: ", - stringify!(StdVideoDecodeH265PictureInfo), - "::", - stringify!(flags) - ) - ); } #[repr(C)] #[repr(align(4))] @@ -6527,38 +6545,55 @@ fn bindgen_test_layout_StdVideoDecodeH265ReferenceInfoFlags() { } impl StdVideoDecodeH265ReferenceInfoFlags { #[inline] - pub fn is_long_term(&self) -> u32 { + pub fn used_for_long_term_reference(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } } #[inline] - pub fn set_is_long_term(&mut self, val: u32) { + pub fn set_used_for_long_term_reference(&mut self, val: u32) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(0usize, 1u8, val as u64) } } #[inline] - pub fn is_non_existing(&self) -> u32 { + pub fn unused_for_reference(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } } #[inline] - pub fn set_is_non_existing(&mut self, val: u32) { + pub fn set_unused_for_reference(&mut self, val: u32) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(1usize, 1u8, val as u64) } } #[inline] + pub fn is_non_existing(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_is_non_existing(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] pub fn new_bitfield_1( - is_long_term: u32, + used_for_long_term_reference: u32, + unused_for_reference: u32, is_non_existing: u32, ) -> __BindgenBitfieldUnit<[u8; 1usize]> { let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); __bindgen_bitfield_unit.set(0usize, 1u8, { - let is_long_term: u32 = unsafe { ::std::mem::transmute(is_long_term) }; - is_long_term as u64 + let used_for_long_term_reference: u32 = + unsafe { ::std::mem::transmute(used_for_long_term_reference) }; + used_for_long_term_reference as u64 }); __bindgen_bitfield_unit.set(1usize, 1u8, { + let unused_for_reference: u32 = unsafe { ::std::mem::transmute(unused_for_reference) }; + unused_for_reference as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { let is_non_existing: u32 = unsafe { ::std::mem::transmute(is_non_existing) }; is_non_existing as u64 }); @@ -6568,8 +6603,8 @@ impl StdVideoDecodeH265ReferenceInfoFlags { #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct StdVideoDecodeH265ReferenceInfo { - pub PicOrderCntVal: i32, pub flags: StdVideoDecodeH265ReferenceInfoFlags, + pub PicOrderCntVal: i32, } #[test] fn bindgen_test_layout_StdVideoDecodeH265ReferenceInfo() { @@ -6583,12 +6618,24 @@ fn bindgen_test_layout_StdVideoDecodeH265ReferenceInfo() { 4usize, concat!("Alignment of ", stringify!(StdVideoDecodeH265ReferenceInfo)) ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).flags as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoDecodeH265ReferenceInfo), + "::", + stringify!(flags) + ) + ); assert_eq!( unsafe { &(*(::std::ptr::null::())).PicOrderCntVal as *const _ as usize }, - 0usize, + 4usize, concat!( "Offset of field: ", stringify!(StdVideoDecodeH265ReferenceInfo), @@ -6596,18 +6643,252 @@ fn bindgen_test_layout_StdVideoDecodeH265ReferenceInfo() { stringify!(PicOrderCntVal) ) ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH264WeightTableFlags { + pub luma_weight_l0_flag: u32, + pub chroma_weight_l0_flag: u32, + pub luma_weight_l1_flag: u32, + pub chroma_weight_l1_flag: u32, +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH264WeightTableFlags() { + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(StdVideoEncodeH264WeightTableFlags)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(StdVideoEncodeH264WeightTableFlags) + ) + ); assert_eq!( unsafe { - &(*(::std::ptr::null::())).flags as *const _ as usize + &(*(::std::ptr::null::())).luma_weight_l0_flag + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264WeightTableFlags), + "::", + stringify!(luma_weight_l0_flag) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).chroma_weight_l0_flag + as *const _ as usize }, 4usize, concat!( "Offset of field: ", - stringify!(StdVideoDecodeH265ReferenceInfo), + stringify!(StdVideoEncodeH264WeightTableFlags), + "::", + stringify!(chroma_weight_l0_flag) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).luma_weight_l1_flag + as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264WeightTableFlags), + "::", + stringify!(luma_weight_l1_flag) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).chroma_weight_l1_flag + as *const _ as usize + }, + 12usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264WeightTableFlags), + "::", + stringify!(chroma_weight_l1_flag) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH264WeightTable { + pub flags: StdVideoEncodeH264WeightTableFlags, + pub luma_log2_weight_denom: u8, + pub chroma_log2_weight_denom: u8, + pub luma_weight_l0: [i8; 32usize], + pub luma_offset_l0: [i8; 32usize], + pub chroma_weight_l0: [[i8; 2usize]; 32usize], + pub chroma_offset_l0: [[i8; 2usize]; 32usize], + pub luma_weight_l1: [i8; 32usize], + pub luma_offset_l1: [i8; 32usize], + pub chroma_weight_l1: [[i8; 2usize]; 32usize], + pub chroma_offset_l1: [[i8; 2usize]; 32usize], +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH264WeightTable() { + assert_eq!( + ::std::mem::size_of::(), + 404usize, + concat!("Size of: ", stringify!(StdVideoEncodeH264WeightTable)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(StdVideoEncodeH264WeightTable)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).flags as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264WeightTable), "::", stringify!(flags) ) ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).luma_log2_weight_denom + as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264WeightTable), + "::", + stringify!(luma_log2_weight_denom) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).chroma_log2_weight_denom + as *const _ as usize + }, + 17usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264WeightTable), + "::", + stringify!(chroma_log2_weight_denom) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).luma_weight_l0 as *const _ + as usize + }, + 18usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264WeightTable), + "::", + stringify!(luma_weight_l0) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).luma_offset_l0 as *const _ + as usize + }, + 50usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264WeightTable), + "::", + stringify!(luma_offset_l0) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).chroma_weight_l0 as *const _ + as usize + }, + 82usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264WeightTable), + "::", + stringify!(chroma_weight_l0) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).chroma_offset_l0 as *const _ + as usize + }, + 146usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264WeightTable), + "::", + stringify!(chroma_offset_l0) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).luma_weight_l1 as *const _ + as usize + }, + 210usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264WeightTable), + "::", + stringify!(luma_weight_l1) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).luma_offset_l1 as *const _ + as usize + }, + 242usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264WeightTable), + "::", + stringify!(luma_offset_l1) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).chroma_weight_l1 as *const _ + as usize + }, + 274usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264WeightTable), + "::", + stringify!(chroma_weight_l1) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).chroma_offset_l1 as *const _ + as usize + }, + 338usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264WeightTable), + "::", + stringify!(chroma_offset_l1) + ) + ); } #[repr(C)] #[repr(align(4))] @@ -6774,11 +7055,11 @@ impl StdVideoEncodeH264PictureInfoFlags { } } #[inline] - pub fn long_term_reference_flag(&self) -> u32 { + pub fn used_for_long_term_reference(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } } #[inline] - pub fn set_long_term_reference_flag(&mut self, val: u32) { + pub fn set_used_for_long_term_reference(&mut self, val: u32) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(2usize, 1u8, val as u64) @@ -6788,7 +7069,7 @@ impl StdVideoEncodeH264PictureInfoFlags { pub fn new_bitfield_1( idr_flag: u32, is_reference_flag: u32, - long_term_reference_flag: u32, + used_for_long_term_reference: u32, ) -> __BindgenBitfieldUnit<[u8; 1usize]> { let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); __bindgen_bitfield_unit.set(0usize, 1u8, { @@ -6800,9 +7081,9 @@ impl StdVideoEncodeH264PictureInfoFlags { is_reference_flag as u64 }); __bindgen_bitfield_unit.set(2usize, 1u8, { - let long_term_reference_flag: u32 = - unsafe { ::std::mem::transmute(long_term_reference_flag) }; - long_term_reference_flag as u64 + let used_for_long_term_reference: u32 = + unsafe { ::std::mem::transmute(used_for_long_term_reference) }; + used_for_long_term_reference as u64 }); __bindgen_bitfield_unit } @@ -6836,22 +7117,25 @@ fn bindgen_test_layout_StdVideoEncodeH264ReferenceInfoFlags() { } impl StdVideoEncodeH264ReferenceInfoFlags { #[inline] - pub fn is_long_term(&self) -> u32 { + pub fn used_for_long_term_reference(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } } #[inline] - pub fn set_is_long_term(&mut self, val: u32) { + pub fn set_used_for_long_term_reference(&mut self, val: u32) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(0usize, 1u8, val as u64) } } #[inline] - pub fn new_bitfield_1(is_long_term: u32) -> __BindgenBitfieldUnit<[u8; 1usize]> { + pub fn new_bitfield_1( + used_for_long_term_reference: u32, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); __bindgen_bitfield_unit.set(0usize, 1u8, { - let is_long_term: u32 = unsafe { ::std::mem::transmute(is_long_term) }; - is_long_term as u64 + let used_for_long_term_reference: u32 = + unsafe { ::std::mem::transmute(used_for_long_term_reference) }; + used_for_long_term_reference as u64 }); __bindgen_bitfield_unit } @@ -7079,11 +7363,11 @@ fn bindgen_test_layout_StdVideoEncodeH264RefPicMarkingEntry() { pub struct StdVideoEncodeH264RefMemMgmtCtrlOperations { pub flags: StdVideoEncodeH264RefMgmtFlags, pub refList0ModOpCount: u8, - pub pRefList0ModOperations: *mut StdVideoEncodeH264RefListModEntry, + pub pRefList0ModOperations: *const StdVideoEncodeH264RefListModEntry, pub refList1ModOpCount: u8, - pub pRefList1ModOperations: *mut StdVideoEncodeH264RefListModEntry, + pub pRefList1ModOperations: *const StdVideoEncodeH264RefListModEntry, pub refPicMarkingOpCount: u8, - pub pRefPicMarkingOperations: *mut StdVideoEncodeH264RefPicMarkingEntry, + pub pRefPicMarkingOperations: *const StdVideoEncodeH264RefPicMarkingEntry, } #[test] fn bindgen_test_layout_StdVideoEncodeH264RefMemMgmtCtrlOperations() { @@ -7199,6 +7483,8 @@ fn bindgen_test_layout_StdVideoEncodeH264RefMemMgmtCtrlOperations() { #[derive(Debug, Copy, Clone)] pub struct StdVideoEncodeH264PictureInfo { pub flags: StdVideoEncodeH264PictureInfoFlags, + pub seq_parameter_set_id: u8, + pub pic_parameter_set_id: u8, pub pictureType: StdVideoH264PictureType, pub frame_num: u32, pub PicOrderCnt: i32, @@ -7207,7 +7493,7 @@ pub struct StdVideoEncodeH264PictureInfo { fn bindgen_test_layout_StdVideoEncodeH264PictureInfo() { assert_eq!( ::std::mem::size_of::(), - 16usize, + 20usize, concat!("Size of: ", stringify!(StdVideoEncodeH264PictureInfo)) ); assert_eq!( @@ -7227,12 +7513,38 @@ fn bindgen_test_layout_StdVideoEncodeH264PictureInfo() { stringify!(flags) ) ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).seq_parameter_set_id + as *const _ as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264PictureInfo), + "::", + stringify!(seq_parameter_set_id) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).pic_parameter_set_id + as *const _ as usize + }, + 5usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264PictureInfo), + "::", + stringify!(pic_parameter_set_id) + ) + ); assert_eq!( unsafe { &(*(::std::ptr::null::())).pictureType as *const _ as usize }, - 4usize, + 8usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH264PictureInfo), @@ -7244,7 +7556,7 @@ fn bindgen_test_layout_StdVideoEncodeH264PictureInfo() { unsafe { &(*(::std::ptr::null::())).frame_num as *const _ as usize }, - 8usize, + 12usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH264PictureInfo), @@ -7257,7 +7569,7 @@ fn bindgen_test_layout_StdVideoEncodeH264PictureInfo() { &(*(::std::ptr::null::())).PicOrderCnt as *const _ as usize }, - 12usize, + 16usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH264PictureInfo), @@ -7358,8 +7670,6 @@ pub struct StdVideoEncodeH264SliceHeader { pub flags: StdVideoEncodeH264SliceHeaderFlags, pub first_mb_in_slice: u32, pub slice_type: StdVideoH264SliceType, - pub seq_parameter_set_id: u8, - pub pic_parameter_set_id: u8, pub idr_pic_id: u16, pub num_ref_idx_l0_active_minus1: u8, pub num_ref_idx_l1_active_minus1: u8, @@ -7367,17 +7677,18 @@ pub struct StdVideoEncodeH264SliceHeader { pub disable_deblocking_filter_idc: StdVideoH264DisableDeblockingFilterIdc, pub slice_alpha_c0_offset_div2: i8, pub slice_beta_offset_div2: i8, + pub pWeightTable: *const StdVideoEncodeH264WeightTable, } #[test] fn bindgen_test_layout_StdVideoEncodeH264SliceHeader() { assert_eq!( ::std::mem::size_of::(), - 32usize, + 40usize, concat!("Size of: ", stringify!(StdVideoEncodeH264SliceHeader)) ); assert_eq!( ::std::mem::align_of::(), - 4usize, + 8usize, concat!("Alignment of ", stringify!(StdVideoEncodeH264SliceHeader)) ); assert_eq!( @@ -7418,38 +7729,12 @@ fn bindgen_test_layout_StdVideoEncodeH264SliceHeader() { stringify!(slice_type) ) ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).seq_parameter_set_id - as *const _ as usize - }, - 12usize, - concat!( - "Offset of field: ", - stringify!(StdVideoEncodeH264SliceHeader), - "::", - stringify!(seq_parameter_set_id) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).pic_parameter_set_id - as *const _ as usize - }, - 13usize, - concat!( - "Offset of field: ", - stringify!(StdVideoEncodeH264SliceHeader), - "::", - stringify!(pic_parameter_set_id) - ) - ); assert_eq!( unsafe { &(*(::std::ptr::null::())).idr_pic_id as *const _ as usize }, - 14usize, + 12usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH264SliceHeader), @@ -7462,7 +7747,7 @@ fn bindgen_test_layout_StdVideoEncodeH264SliceHeader() { &(*(::std::ptr::null::())).num_ref_idx_l0_active_minus1 as *const _ as usize }, - 16usize, + 14usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH264SliceHeader), @@ -7475,7 +7760,7 @@ fn bindgen_test_layout_StdVideoEncodeH264SliceHeader() { &(*(::std::ptr::null::())).num_ref_idx_l1_active_minus1 as *const _ as usize }, - 17usize, + 15usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH264SliceHeader), @@ -7488,7 +7773,7 @@ fn bindgen_test_layout_StdVideoEncodeH264SliceHeader() { &(*(::std::ptr::null::())).cabac_init_idc as *const _ as usize }, - 20usize, + 16usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH264SliceHeader), @@ -7501,7 +7786,7 @@ fn bindgen_test_layout_StdVideoEncodeH264SliceHeader() { &(*(::std::ptr::null::())).disable_deblocking_filter_idc as *const _ as usize }, - 24usize, + 20usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH264SliceHeader), @@ -7514,7 +7799,7 @@ fn bindgen_test_layout_StdVideoEncodeH264SliceHeader() { &(*(::std::ptr::null::())).slice_alpha_c0_offset_div2 as *const _ as usize }, - 28usize, + 24usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH264SliceHeader), @@ -7527,7 +7812,7 @@ fn bindgen_test_layout_StdVideoEncodeH264SliceHeader() { &(*(::std::ptr::null::())).slice_beta_offset_div2 as *const _ as usize }, - 29usize, + 25usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH264SliceHeader), @@ -7535,23 +7820,279 @@ fn bindgen_test_layout_StdVideoEncodeH264SliceHeader() { stringify!(slice_beta_offset_div2) ) ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).pWeightTable as *const _ + as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264SliceHeader), + "::", + stringify!(pWeightTable) + ) + ); } #[repr(C)] -#[repr(align(4))] #[derive(Debug, Copy, Clone)] -pub struct StdVideoEncodeH265SliceSegmentHeaderFlags { - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +pub struct StdVideoEncodeH265WeightTableFlags { pub luma_weight_l0_flag: u16, pub chroma_weight_l0_flag: u16, pub luma_weight_l1_flag: u16, pub chroma_weight_l1_flag: u16, } #[test] +fn bindgen_test_layout_StdVideoEncodeH265WeightTableFlags() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(StdVideoEncodeH265WeightTableFlags)) + ); + assert_eq!( + ::std::mem::align_of::(), + 2usize, + concat!( + "Alignment of ", + stringify!(StdVideoEncodeH265WeightTableFlags) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).luma_weight_l0_flag + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265WeightTableFlags), + "::", + stringify!(luma_weight_l0_flag) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).chroma_weight_l0_flag + as *const _ as usize + }, + 2usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265WeightTableFlags), + "::", + stringify!(chroma_weight_l0_flag) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).luma_weight_l1_flag + as *const _ as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265WeightTableFlags), + "::", + stringify!(luma_weight_l1_flag) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).chroma_weight_l1_flag + as *const _ as usize + }, + 6usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265WeightTableFlags), + "::", + stringify!(chroma_weight_l1_flag) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH265WeightTable { + pub flags: StdVideoEncodeH265WeightTableFlags, + pub luma_log2_weight_denom: u8, + pub delta_chroma_log2_weight_denom: i8, + pub delta_luma_weight_l0: [i8; 15usize], + pub luma_offset_l0: [i8; 15usize], + pub delta_chroma_weight_l0: [[i8; 2usize]; 15usize], + pub delta_chroma_offset_l0: [[i8; 2usize]; 15usize], + pub delta_luma_weight_l1: [i8; 15usize], + pub luma_offset_l1: [i8; 15usize], + pub delta_chroma_weight_l1: [[i8; 2usize]; 15usize], + pub delta_chroma_offset_l1: [[i8; 2usize]; 15usize], +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH265WeightTable() { + assert_eq!( + ::std::mem::size_of::(), + 190usize, + concat!("Size of: ", stringify!(StdVideoEncodeH265WeightTable)) + ); + assert_eq!( + ::std::mem::align_of::(), + 2usize, + concat!("Alignment of ", stringify!(StdVideoEncodeH265WeightTable)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).flags as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265WeightTable), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).luma_log2_weight_denom + as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265WeightTable), + "::", + stringify!(luma_log2_weight_denom) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).delta_chroma_log2_weight_denom + as *const _ as usize + }, + 9usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265WeightTable), + "::", + stringify!(delta_chroma_log2_weight_denom) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).delta_luma_weight_l0 + as *const _ as usize + }, + 10usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265WeightTable), + "::", + stringify!(delta_luma_weight_l0) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).luma_offset_l0 as *const _ + as usize + }, + 25usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265WeightTable), + "::", + stringify!(luma_offset_l0) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).delta_chroma_weight_l0 + as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265WeightTable), + "::", + stringify!(delta_chroma_weight_l0) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).delta_chroma_offset_l0 + as *const _ as usize + }, + 70usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265WeightTable), + "::", + stringify!(delta_chroma_offset_l0) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).delta_luma_weight_l1 + as *const _ as usize + }, + 100usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265WeightTable), + "::", + stringify!(delta_luma_weight_l1) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).luma_offset_l1 as *const _ + as usize + }, + 115usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265WeightTable), + "::", + stringify!(luma_offset_l1) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).delta_chroma_weight_l1 + as *const _ as usize + }, + 130usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265WeightTable), + "::", + stringify!(delta_chroma_weight_l1) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).delta_chroma_offset_l1 + as *const _ as usize + }, + 160usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265WeightTable), + "::", + stringify!(delta_chroma_offset_l1) + ) + ); +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH265SliceSegmentHeaderFlags { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>, + pub __bindgen_padding_0: u16, +} +#[test] fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeaderFlags() { assert_eq!( ::std::mem::size_of::(), - 12usize, + 4usize, concat!( "Size of: ", stringify!(StdVideoEncodeH265SliceSegmentHeaderFlags) @@ -7565,58 +8106,6 @@ fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeaderFlags() { stringify!(StdVideoEncodeH265SliceSegmentHeaderFlags) ) ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())) - .luma_weight_l0_flag as *const _ as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(StdVideoEncodeH265SliceSegmentHeaderFlags), - "::", - stringify!(luma_weight_l0_flag) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())) - .chroma_weight_l0_flag as *const _ as usize - }, - 6usize, - concat!( - "Offset of field: ", - stringify!(StdVideoEncodeH265SliceSegmentHeaderFlags), - "::", - stringify!(chroma_weight_l0_flag) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())) - .luma_weight_l1_flag as *const _ as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(StdVideoEncodeH265SliceSegmentHeaderFlags), - "::", - stringify!(luma_weight_l1_flag) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())) - .chroma_weight_l1_flag as *const _ as usize - }, - 10usize, - concat!( - "Offset of field: ", - stringify!(StdVideoEncodeH265SliceSegmentHeaderFlags), - "::", - stringify!(chroma_weight_l1_flag) - ) - ); } impl StdVideoEncodeH265SliceSegmentHeaderFlags { #[inline] @@ -7653,142 +8142,132 @@ impl StdVideoEncodeH265SliceSegmentHeaderFlags { } } #[inline] - pub fn short_term_ref_pic_set_sps_flag(&self) -> u32 { + pub fn pic_output_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } } #[inline] - pub fn set_short_term_ref_pic_set_sps_flag(&mut self, val: u32) { + pub fn set_pic_output_flag(&mut self, val: u32) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(3usize, 1u8, val as u64) } } #[inline] - pub fn slice_temporal_mvp_enable_flag(&self) -> u32 { + pub fn short_term_ref_pic_set_sps_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } } #[inline] - pub fn set_slice_temporal_mvp_enable_flag(&mut self, val: u32) { + pub fn set_short_term_ref_pic_set_sps_flag(&mut self, val: u32) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(4usize, 1u8, val as u64) } } #[inline] - pub fn slice_sao_luma_flag(&self) -> u32 { + pub fn slice_temporal_mvp_enable_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } } #[inline] - pub fn set_slice_sao_luma_flag(&mut self, val: u32) { + pub fn set_slice_temporal_mvp_enable_flag(&mut self, val: u32) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(5usize, 1u8, val as u64) } } #[inline] - pub fn slice_sao_chroma_flag(&self) -> u32 { + pub fn slice_sao_luma_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } } #[inline] - pub fn set_slice_sao_chroma_flag(&mut self, val: u32) { + pub fn set_slice_sao_luma_flag(&mut self, val: u32) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(6usize, 1u8, val as u64) } } #[inline] - pub fn num_ref_idx_active_override_flag(&self) -> u32 { + pub fn slice_sao_chroma_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } } #[inline] - pub fn set_num_ref_idx_active_override_flag(&mut self, val: u32) { + pub fn set_slice_sao_chroma_flag(&mut self, val: u32) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(7usize, 1u8, val as u64) } } #[inline] - pub fn mvd_l1_zero_flag(&self) -> u32 { + pub fn num_ref_idx_active_override_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) } } #[inline] - pub fn set_mvd_l1_zero_flag(&mut self, val: u32) { + pub fn set_num_ref_idx_active_override_flag(&mut self, val: u32) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(8usize, 1u8, val as u64) } } #[inline] - pub fn cabac_init_flag(&self) -> u32 { + pub fn mvd_l1_zero_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) } } #[inline] - pub fn set_cabac_init_flag(&mut self, val: u32) { + pub fn set_mvd_l1_zero_flag(&mut self, val: u32) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(9usize, 1u8, val as u64) } } #[inline] - pub fn slice_deblocking_filter_disable_flag(&self) -> u32 { + pub fn cabac_init_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) } } #[inline] - pub fn set_slice_deblocking_filter_disable_flag(&mut self, val: u32) { + pub fn set_cabac_init_flag(&mut self, val: u32) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(10usize, 1u8, val as u64) } } #[inline] - pub fn collocated_from_l0_flag(&self) -> u32 { + pub fn slice_deblocking_filter_disable_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) } } #[inline] - pub fn set_collocated_from_l0_flag(&mut self, val: u32) { + pub fn set_slice_deblocking_filter_disable_flag(&mut self, val: u32) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(11usize, 1u8, val as u64) } } #[inline] - pub fn slice_loop_filter_across_slices_enabled_flag(&self) -> u32 { + pub fn collocated_from_l0_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) } } #[inline] - pub fn set_slice_loop_filter_across_slices_enabled_flag(&mut self, val: u32) { + pub fn set_collocated_from_l0_flag(&mut self, val: u32) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(12usize, 1u8, val as u64) } } #[inline] - pub fn bLastSliceInPic(&self) -> u32 { + pub fn slice_loop_filter_across_slices_enabled_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) } } #[inline] - pub fn set_bLastSliceInPic(&mut self, val: u32) { + pub fn set_slice_loop_filter_across_slices_enabled_flag(&mut self, val: u32) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(13usize, 1u8, val as u64) } } #[inline] - pub fn reservedBits(&self) -> u32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 18u8) as u32) } - } - #[inline] - pub fn set_reservedBits(&mut self, val: u32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(14usize, 18u8, val as u64) - } - } - #[inline] pub fn new_bitfield_1( first_slice_segment_in_pic_flag: u32, no_output_of_prior_pics_flag: u32, dependent_slice_segment_flag: u32, + pic_output_flag: u32, short_term_ref_pic_set_sps_flag: u32, slice_temporal_mvp_enable_flag: u32, slice_sao_luma_flag: u32, @@ -7799,10 +8278,8 @@ impl StdVideoEncodeH265SliceSegmentHeaderFlags { slice_deblocking_filter_disable_flag: u32, collocated_from_l0_flag: u32, slice_loop_filter_across_slices_enabled_flag: u32, - bLastSliceInPic: u32, - reservedBits: u32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + ) -> __BindgenBitfieldUnit<[u8; 2usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default(); __bindgen_bitfield_unit.set(0usize, 1u8, { let first_slice_segment_in_pic_flag: u32 = unsafe { ::std::mem::transmute(first_slice_segment_in_pic_flag) }; @@ -7819,68 +8296,64 @@ impl StdVideoEncodeH265SliceSegmentHeaderFlags { dependent_slice_segment_flag as u64 }); __bindgen_bitfield_unit.set(3usize, 1u8, { + let pic_output_flag: u32 = unsafe { ::std::mem::transmute(pic_output_flag) }; + pic_output_flag as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { let short_term_ref_pic_set_sps_flag: u32 = unsafe { ::std::mem::transmute(short_term_ref_pic_set_sps_flag) }; short_term_ref_pic_set_sps_flag as u64 }); - __bindgen_bitfield_unit.set(4usize, 1u8, { + __bindgen_bitfield_unit.set(5usize, 1u8, { let slice_temporal_mvp_enable_flag: u32 = unsafe { ::std::mem::transmute(slice_temporal_mvp_enable_flag) }; slice_temporal_mvp_enable_flag as u64 }); - __bindgen_bitfield_unit.set(5usize, 1u8, { + __bindgen_bitfield_unit.set(6usize, 1u8, { let slice_sao_luma_flag: u32 = unsafe { ::std::mem::transmute(slice_sao_luma_flag) }; slice_sao_luma_flag as u64 }); - __bindgen_bitfield_unit.set(6usize, 1u8, { + __bindgen_bitfield_unit.set(7usize, 1u8, { let slice_sao_chroma_flag: u32 = unsafe { ::std::mem::transmute(slice_sao_chroma_flag) }; slice_sao_chroma_flag as u64 }); - __bindgen_bitfield_unit.set(7usize, 1u8, { + __bindgen_bitfield_unit.set(8usize, 1u8, { let num_ref_idx_active_override_flag: u32 = unsafe { ::std::mem::transmute(num_ref_idx_active_override_flag) }; num_ref_idx_active_override_flag as u64 }); - __bindgen_bitfield_unit.set(8usize, 1u8, { + __bindgen_bitfield_unit.set(9usize, 1u8, { let mvd_l1_zero_flag: u32 = unsafe { ::std::mem::transmute(mvd_l1_zero_flag) }; mvd_l1_zero_flag as u64 }); - __bindgen_bitfield_unit.set(9usize, 1u8, { + __bindgen_bitfield_unit.set(10usize, 1u8, { let cabac_init_flag: u32 = unsafe { ::std::mem::transmute(cabac_init_flag) }; cabac_init_flag as u64 }); - __bindgen_bitfield_unit.set(10usize, 1u8, { + __bindgen_bitfield_unit.set(11usize, 1u8, { let slice_deblocking_filter_disable_flag: u32 = unsafe { ::std::mem::transmute(slice_deblocking_filter_disable_flag) }; slice_deblocking_filter_disable_flag as u64 }); - __bindgen_bitfield_unit.set(11usize, 1u8, { + __bindgen_bitfield_unit.set(12usize, 1u8, { let collocated_from_l0_flag: u32 = unsafe { ::std::mem::transmute(collocated_from_l0_flag) }; collocated_from_l0_flag as u64 }); - __bindgen_bitfield_unit.set(12usize, 1u8, { + __bindgen_bitfield_unit.set(13usize, 1u8, { let slice_loop_filter_across_slices_enabled_flag: u32 = unsafe { ::std::mem::transmute(slice_loop_filter_across_slices_enabled_flag) }; slice_loop_filter_across_slices_enabled_flag as u64 }); - __bindgen_bitfield_unit.set(13usize, 1u8, { - let bLastSliceInPic: u32 = unsafe { ::std::mem::transmute(bLastSliceInPic) }; - bLastSliceInPic as u64 - }); - __bindgen_bitfield_unit.set(14usize, 18u8, { - let reservedBits: u32 = unsafe { ::std::mem::transmute(reservedBits) }; - reservedBits as u64 - }); __bindgen_bitfield_unit } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct StdVideoEncodeH265SliceSegmentHeader { + pub flags: StdVideoEncodeH265SliceSegmentHeaderFlags, pub slice_type: StdVideoH265SliceType, - pub slice_pic_parameter_set_id: u8, pub num_short_term_ref_pic_sets: u8, pub slice_segment_address: u32, pub short_term_ref_pic_set_idx: u8, @@ -7889,16 +8362,6 @@ pub struct StdVideoEncodeH265SliceSegmentHeader { pub collocated_ref_idx: u8, pub num_ref_idx_l0_active_minus1: u8, pub num_ref_idx_l1_active_minus1: u8, - pub luma_log2_weight_denom: u8, - pub delta_chroma_log2_weight_denom: i8, - pub delta_luma_weight_l0: [i8; 15usize], - pub luma_offset_l0: [i8; 15usize], - pub delta_chroma_weight_l0: [[i8; 2usize]; 15usize], - pub delta_chroma_offset_l0: [[i8; 2usize]; 15usize], - pub delta_luma_weight_l1: [i8; 15usize], - pub luma_offset_l1: [i8; 15usize], - pub delta_chroma_weight_l1: [[i8; 2usize]; 15usize], - pub delta_chroma_offset_l1: [[i8; 2usize]; 15usize], pub MaxNumMergeCand: u8, pub slice_cb_qp_offset: i8, pub slice_cr_qp_offset: i8, @@ -7907,13 +8370,13 @@ pub struct StdVideoEncodeH265SliceSegmentHeader { pub slice_act_y_qp_offset: i8, pub slice_act_cb_qp_offset: i8, pub slice_act_cr_qp_offset: i8, - pub flags: StdVideoEncodeH265SliceSegmentHeaderFlags, + pub pWeightTable: *const StdVideoEncodeH265WeightTable, } #[test] fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeader() { assert_eq!( ::std::mem::size_of::(), - 220usize, + 40usize, concat!( "Size of: ", stringify!(StdVideoEncodeH265SliceSegmentHeader) @@ -7921,7 +8384,7 @@ fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeader() { ); assert_eq!( ::std::mem::align_of::(), - 4usize, + 8usize, concat!( "Alignment of ", stringify!(StdVideoEncodeH265SliceSegmentHeader) @@ -7929,10 +8392,23 @@ fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeader() { ); assert_eq!( unsafe { - &(*(::std::ptr::null::())).slice_type as *const _ + &(*(::std::ptr::null::())).flags as *const _ as usize }, 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentHeader), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).slice_type as *const _ + as usize + }, + 4usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265SliceSegmentHeader), @@ -7940,25 +8416,12 @@ fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeader() { stringify!(slice_type) ) ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())) - .slice_pic_parameter_set_id as *const _ as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(StdVideoEncodeH265SliceSegmentHeader), - "::", - stringify!(slice_pic_parameter_set_id) - ) - ); assert_eq!( unsafe { &(*(::std::ptr::null::())) .num_short_term_ref_pic_sets as *const _ as usize }, - 5usize, + 8usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265SliceSegmentHeader), @@ -7971,7 +8434,7 @@ fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeader() { &(*(::std::ptr::null::())).slice_segment_address as *const _ as usize }, - 8usize, + 12usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265SliceSegmentHeader), @@ -7984,7 +8447,7 @@ fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeader() { &(*(::std::ptr::null::())) .short_term_ref_pic_set_idx as *const _ as usize }, - 12usize, + 16usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265SliceSegmentHeader), @@ -7997,7 +8460,7 @@ fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeader() { &(*(::std::ptr::null::())).num_long_term_sps as *const _ as usize }, - 13usize, + 17usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265SliceSegmentHeader), @@ -8010,7 +8473,7 @@ fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeader() { &(*(::std::ptr::null::())).num_long_term_pics as *const _ as usize }, - 14usize, + 18usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265SliceSegmentHeader), @@ -8023,7 +8486,7 @@ fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeader() { &(*(::std::ptr::null::())).collocated_ref_idx as *const _ as usize }, - 15usize, + 19usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265SliceSegmentHeader), @@ -8036,7 +8499,7 @@ fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeader() { &(*(::std::ptr::null::())) .num_ref_idx_l0_active_minus1 as *const _ as usize }, - 16usize, + 20usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265SliceSegmentHeader), @@ -8049,7 +8512,7 @@ fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeader() { &(*(::std::ptr::null::())) .num_ref_idx_l1_active_minus1 as *const _ as usize }, - 17usize, + 21usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265SliceSegmentHeader), @@ -8057,142 +8520,12 @@ fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeader() { stringify!(num_ref_idx_l1_active_minus1) ) ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).luma_log2_weight_denom - as *const _ as usize - }, - 18usize, - concat!( - "Offset of field: ", - stringify!(StdVideoEncodeH265SliceSegmentHeader), - "::", - stringify!(luma_log2_weight_denom) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())) - .delta_chroma_log2_weight_denom as *const _ as usize - }, - 19usize, - concat!( - "Offset of field: ", - stringify!(StdVideoEncodeH265SliceSegmentHeader), - "::", - stringify!(delta_chroma_log2_weight_denom) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).delta_luma_weight_l0 - as *const _ as usize - }, - 20usize, - concat!( - "Offset of field: ", - stringify!(StdVideoEncodeH265SliceSegmentHeader), - "::", - stringify!(delta_luma_weight_l0) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).luma_offset_l0 - as *const _ as usize - }, - 35usize, - concat!( - "Offset of field: ", - stringify!(StdVideoEncodeH265SliceSegmentHeader), - "::", - stringify!(luma_offset_l0) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).delta_chroma_weight_l0 - as *const _ as usize - }, - 50usize, - concat!( - "Offset of field: ", - stringify!(StdVideoEncodeH265SliceSegmentHeader), - "::", - stringify!(delta_chroma_weight_l0) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).delta_chroma_offset_l0 - as *const _ as usize - }, - 80usize, - concat!( - "Offset of field: ", - stringify!(StdVideoEncodeH265SliceSegmentHeader), - "::", - stringify!(delta_chroma_offset_l0) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).delta_luma_weight_l1 - as *const _ as usize - }, - 110usize, - concat!( - "Offset of field: ", - stringify!(StdVideoEncodeH265SliceSegmentHeader), - "::", - stringify!(delta_luma_weight_l1) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).luma_offset_l1 - as *const _ as usize - }, - 125usize, - concat!( - "Offset of field: ", - stringify!(StdVideoEncodeH265SliceSegmentHeader), - "::", - stringify!(luma_offset_l1) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).delta_chroma_weight_l1 - as *const _ as usize - }, - 140usize, - concat!( - "Offset of field: ", - stringify!(StdVideoEncodeH265SliceSegmentHeader), - "::", - stringify!(delta_chroma_weight_l1) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).delta_chroma_offset_l1 - as *const _ as usize - }, - 170usize, - concat!( - "Offset of field: ", - stringify!(StdVideoEncodeH265SliceSegmentHeader), - "::", - stringify!(delta_chroma_offset_l1) - ) - ); assert_eq!( unsafe { &(*(::std::ptr::null::())).MaxNumMergeCand as *const _ as usize }, - 200usize, + 22usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265SliceSegmentHeader), @@ -8205,7 +8538,7 @@ fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeader() { &(*(::std::ptr::null::())).slice_cb_qp_offset as *const _ as usize }, - 201usize, + 23usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265SliceSegmentHeader), @@ -8218,7 +8551,7 @@ fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeader() { &(*(::std::ptr::null::())).slice_cr_qp_offset as *const _ as usize }, - 202usize, + 24usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265SliceSegmentHeader), @@ -8231,7 +8564,7 @@ fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeader() { &(*(::std::ptr::null::())).slice_beta_offset_div2 as *const _ as usize }, - 203usize, + 25usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265SliceSegmentHeader), @@ -8244,7 +8577,7 @@ fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeader() { &(*(::std::ptr::null::())).slice_tc_offset_div2 as *const _ as usize }, - 204usize, + 26usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265SliceSegmentHeader), @@ -8257,7 +8590,7 @@ fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeader() { &(*(::std::ptr::null::())).slice_act_y_qp_offset as *const _ as usize }, - 205usize, + 27usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265SliceSegmentHeader), @@ -8270,7 +8603,7 @@ fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeader() { &(*(::std::ptr::null::())).slice_act_cb_qp_offset as *const _ as usize }, - 206usize, + 28usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265SliceSegmentHeader), @@ -8283,7 +8616,7 @@ fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeader() { &(*(::std::ptr::null::())).slice_act_cr_qp_offset as *const _ as usize }, - 207usize, + 29usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265SliceSegmentHeader), @@ -8293,15 +8626,15 @@ fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeader() { ); assert_eq!( unsafe { - &(*(::std::ptr::null::())).flags as *const _ - as usize + &(*(::std::ptr::null::())).pWeightTable + as *const _ as usize }, - 208usize, + 32usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265SliceSegmentHeader), "::", - stringify!(flags) + stringify!(pWeightTable) ) ); } @@ -8379,9 +8712,9 @@ impl StdVideoEncodeH265ReferenceModificationFlags { pub struct StdVideoEncodeH265ReferenceModifications { pub flags: StdVideoEncodeH265ReferenceModificationFlags, pub referenceList0ModificationsCount: u8, - pub pReferenceList0Modifications: *mut u8, + pub pReferenceList0Modifications: *const u8, pub referenceList1ModificationsCount: u8, - pub pReferenceList1Modifications: *mut u8, + pub pReferenceList1Modifications: *const u8, } #[test] fn bindgen_test_layout_StdVideoEncodeH265ReferenceModifications() { @@ -8526,10 +8859,34 @@ impl StdVideoEncodeH265PictureInfoFlags { } } #[inline] + pub fn discardable_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_discardable_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub fn cross_layer_bla_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_cross_layer_bla_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] pub fn new_bitfield_1( is_reference_flag: u32, IrapPicFlag: u32, long_term_flag: u32, + discardable_flag: u32, + cross_layer_bla_flag: u32, ) -> __BindgenBitfieldUnit<[u8; 1usize]> { let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); __bindgen_bitfield_unit.set(0usize, 1u8, { @@ -8544,18 +8901,27 @@ impl StdVideoEncodeH265PictureInfoFlags { let long_term_flag: u32 = unsafe { ::std::mem::transmute(long_term_flag) }; long_term_flag as u64 }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let discardable_flag: u32 = unsafe { ::std::mem::transmute(discardable_flag) }; + discardable_flag as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let cross_layer_bla_flag: u32 = unsafe { ::std::mem::transmute(cross_layer_bla_flag) }; + cross_layer_bla_flag as u64 + }); __bindgen_bitfield_unit } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct StdVideoEncodeH265PictureInfo { + pub flags: StdVideoEncodeH265PictureInfoFlags, pub PictureType: StdVideoH265PictureType, 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 flags: StdVideoEncodeH265PictureInfoFlags, } #[test] fn bindgen_test_layout_StdVideoEncodeH265PictureInfo() { @@ -8569,12 +8935,24 @@ fn bindgen_test_layout_StdVideoEncodeH265PictureInfo() { 4usize, concat!("Alignment of ", stringify!(StdVideoEncodeH265PictureInfo)) ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).flags as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265PictureInfo), + "::", + stringify!(flags) + ) + ); assert_eq!( unsafe { &(*(::std::ptr::null::())).PictureType as *const _ as usize }, - 0usize, + 4usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265PictureInfo), @@ -8587,7 +8965,7 @@ fn bindgen_test_layout_StdVideoEncodeH265PictureInfo() { &(*(::std::ptr::null::())).sps_video_parameter_set_id as *const _ as usize }, - 4usize, + 8usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265PictureInfo), @@ -8600,7 +8978,7 @@ fn bindgen_test_layout_StdVideoEncodeH265PictureInfo() { &(*(::std::ptr::null::())).pps_seq_parameter_set_id as *const _ as usize }, - 5usize, + 9usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265PictureInfo), @@ -8608,12 +8986,25 @@ fn bindgen_test_layout_StdVideoEncodeH265PictureInfo() { stringify!(pps_seq_parameter_set_id) ) ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).pps_pic_parameter_set_id + as *const _ as usize + }, + 10usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265PictureInfo), + "::", + stringify!(pps_pic_parameter_set_id) + ) + ); assert_eq!( unsafe { &(*(::std::ptr::null::())).PicOrderCntVal as *const _ as usize }, - 8usize, + 12usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265PictureInfo), @@ -8626,24 +9017,12 @@ fn bindgen_test_layout_StdVideoEncodeH265PictureInfo() { &(*(::std::ptr::null::())).TemporalId as *const _ as usize }, - 12usize, - concat!( - "Offset of field: ", - stringify!(StdVideoEncodeH265PictureInfo), - "::", - stringify!(TemporalId) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).flags as *const _ as usize - }, 16usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265PictureInfo), "::", - stringify!(flags) + stringify!(TemporalId) ) ); } @@ -8676,22 +9055,22 @@ fn bindgen_test_layout_StdVideoEncodeH265ReferenceInfoFlags() { } impl StdVideoEncodeH265ReferenceInfoFlags { #[inline] - pub fn is_long_term(&self) -> u32 { + pub fn used_for_long_term_reference(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } } #[inline] - pub fn set_is_long_term(&mut self, val: u32) { + pub fn set_used_for_long_term_reference(&mut self, val: u32) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(0usize, 1u8, val as u64) } } #[inline] - pub fn isUsedFlag(&self) -> u32 { + pub fn unused_for_reference(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } } #[inline] - pub fn set_isUsedFlag(&mut self, val: u32) { + pub fn set_unused_for_reference(&mut self, val: u32) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(1usize, 1u8, val as u64) @@ -8699,17 +9078,18 @@ impl StdVideoEncodeH265ReferenceInfoFlags { } #[inline] pub fn new_bitfield_1( - is_long_term: u32, - isUsedFlag: u32, + used_for_long_term_reference: u32, + unused_for_reference: u32, ) -> __BindgenBitfieldUnit<[u8; 1usize]> { let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); __bindgen_bitfield_unit.set(0usize, 1u8, { - let is_long_term: u32 = unsafe { ::std::mem::transmute(is_long_term) }; - is_long_term as u64 + let used_for_long_term_reference: u32 = + unsafe { ::std::mem::transmute(used_for_long_term_reference) }; + used_for_long_term_reference as u64 }); __bindgen_bitfield_unit.set(1usize, 1u8, { - let isUsedFlag: u32 = unsafe { ::std::mem::transmute(isUsedFlag) }; - isUsedFlag as u64 + let unused_for_reference: u32 = unsafe { ::std::mem::transmute(unused_for_reference) }; + unused_for_reference as u64 }); __bindgen_bitfield_unit } @@ -8717,9 +9097,9 @@ impl StdVideoEncodeH265ReferenceInfoFlags { #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct StdVideoEncodeH265ReferenceInfo { + pub flags: StdVideoEncodeH265ReferenceInfoFlags, pub PicOrderCntVal: i32, pub TemporalId: u8, - pub flags: StdVideoEncodeH265ReferenceInfoFlags, } #[test] fn bindgen_test_layout_StdVideoEncodeH265ReferenceInfo() { @@ -8733,12 +9113,24 @@ fn bindgen_test_layout_StdVideoEncodeH265ReferenceInfo() { 4usize, concat!("Alignment of ", stringify!(StdVideoEncodeH265ReferenceInfo)) ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).flags as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265ReferenceInfo), + "::", + stringify!(flags) + ) + ); assert_eq!( unsafe { &(*(::std::ptr::null::())).PicOrderCntVal as *const _ as usize }, - 0usize, + 4usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265ReferenceInfo), @@ -8751,7 +9143,7 @@ fn bindgen_test_layout_StdVideoEncodeH265ReferenceInfo() { &(*(::std::ptr::null::())).TemporalId as *const _ as usize }, - 4usize, + 8usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265ReferenceInfo), @@ -8759,16 +9151,4 @@ fn bindgen_test_layout_StdVideoEncodeH265ReferenceInfo() { stringify!(TemporalId) ) ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).flags as *const _ as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(StdVideoEncodeH265ReferenceInfo), - "::", - stringify!(flags) - ) - ); } diff --git a/generator/Vulkan-Headers b/generator/Vulkan-Headers index 384881c..7ad5775 160000 --- a/generator/Vulkan-Headers +++ b/generator/Vulkan-Headers @@ -1 +1 @@ -Subproject commit 384881cc90fe243b4d29bfbc359f59752c2be995 +Subproject commit 7ad5775f8ab8d8db906fa6ebc72f14b6e9594a88