diff --git a/Changelog.md b/Changelog.md index 903f4e609..7742bdefd 100644 --- a/Changelog.md +++ b/Changelog.md @@ -11,6 +11,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - Added `Handle::is_null()` to allow checking if a handle is a `NULL` value (#694) - Allow building `Entry`/`Instance`/`Device` from handle+fns (see their `from_parts_1_x()` associated functions) (#748) +- Update Vulkan-Headers to 1.3.254 (#760) ### Changed diff --git a/ash/Cargo.toml b/ash/Cargo.toml index 504fa36f1..9fe28c69f 100644 --- a/ash/Cargo.toml +++ b/ash/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "ash" -version = "0.37.0+1.3.251" +version = "0.37.0+1.3.254" authors = [ "Maik Klein ", "Benjamin Saunders ", diff --git a/ash/src/vk/bitflags.rs b/ash/src/vk/bitflags.rs index b3a5af920..f99830ec8 100644 --- a/ash/src/vk/bitflags.rs +++ b/ash/src/vk/bitflags.rs @@ -1286,6 +1286,7 @@ vk_bitflags_wrapped!(VideoEncodeFeedbackFlagsKHR, Flags); impl VideoEncodeFeedbackFlagsKHR { pub const BITSTREAM_BUFFER_OFFSET: Self = Self(0b1); pub const BITSTREAM_BYTES_WRITTEN: Self = Self(0b10); + pub const BITSTREAM_HAS_OVERRIDES: Self = Self(0b100); } #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] @@ -1304,32 +1305,52 @@ impl VideoEncodeRateControlModeFlagsKHR { pub struct VideoEncodeH264CapabilityFlagsEXT(pub(crate) Flags); vk_bitflags_wrapped!(VideoEncodeH264CapabilityFlagsEXT, Flags); impl VideoEncodeH264CapabilityFlagsEXT { - pub const DIRECT_8X8_INFERENCE_ENABLED: Self = Self(0b1); - pub const DIRECT_8X8_INFERENCE_DISABLED: Self = Self(0b10); - pub const SEPARATE_COLOUR_PLANE: Self = Self(0b100); - pub const QPPRIME_Y_ZERO_TRANSFORM_BYPASS: Self = Self(0b1000); - pub const SCALING_LISTS: Self = Self(0b1_0000); - pub const HRD_COMPLIANCE: Self = Self(0b10_0000); - pub const CHROMA_QP_OFFSET: Self = Self(0b100_0000); - pub const SECOND_CHROMA_QP_OFFSET: Self = Self(0b1000_0000); - pub const PIC_INIT_QP_MINUS26: Self = Self(0b1_0000_0000); - pub const WEIGHTED_PRED: Self = Self(0b10_0000_0000); - pub const WEIGHTED_BIPRED_EXPLICIT: Self = Self(0b100_0000_0000); - pub const WEIGHTED_BIPRED_IMPLICIT: Self = Self(0b1000_0000_0000); - pub const WEIGHTED_PRED_NO_TABLE: Self = Self(0b1_0000_0000_0000); - pub const TRANSFORM_8X8: Self = Self(0b10_0000_0000_0000); - pub const CABAC: Self = Self(0b100_0000_0000_0000); - pub const CAVLC: Self = Self(0b1000_0000_0000_0000); - pub const DEBLOCKING_FILTER_DISABLED: Self = Self(0b1_0000_0000_0000_0000); - pub const DEBLOCKING_FILTER_ENABLED: Self = Self(0b10_0000_0000_0000_0000); - pub const DEBLOCKING_FILTER_PARTIAL: Self = Self(0b100_0000_0000_0000_0000); - pub const DISABLE_DIRECT_SPATIAL_MV_PRED: Self = Self(0b1000_0000_0000_0000_0000); - pub const MULTIPLE_SLICE_PER_FRAME: Self = Self(0b1_0000_0000_0000_0000_0000); - pub const SLICE_MB_COUNT: Self = Self(0b10_0000_0000_0000_0000_0000); - pub const ROW_UNALIGNED_SLICE: Self = Self(0b100_0000_0000_0000_0000_0000); - pub const DIFFERENT_SLICE_TYPE: Self = Self(0b1000_0000_0000_0000_0000_0000); - pub const B_FRAME_IN_L1_LIST: Self = Self(0b1_0000_0000_0000_0000_0000_0000); - pub const DIFFERENT_REFERENCE_FINAL_LISTS: Self = Self(0b10_0000_0000_0000_0000_0000_0000); + pub const HRD_COMPLIANCE: Self = Self(0b1); + pub const PREDICTION_WEIGHT_TABLE_GENERATED: Self = Self(0b10); + pub const ROW_UNALIGNED_SLICE: Self = Self(0b100); + pub const DIFFERENT_SLICE_TYPE: Self = Self(0b1000); + pub const B_FRAME_IN_L0_LIST: Self = Self(0b1_0000); + pub const B_FRAME_IN_L1_LIST: Self = Self(0b10_0000); + pub const PER_PICTURE_TYPE_MIN_MAX_QP: Self = Self(0b100_0000); + pub const PER_SLICE_CONSTANT_QP: Self = Self(0b1000_0000); + pub const GENERATE_PREFIX_NALU: Self = Self(0b1_0000_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoEncodeH264StdFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(VideoEncodeH264StdFlagsEXT, Flags); +impl VideoEncodeH264StdFlagsEXT { + pub const SEPARATE_COLOR_PLANE_FLAG_SET: Self = Self(0b1); + pub const QPPRIME_Y_ZERO_TRANSFORM_BYPASS_FLAG_SET: Self = Self(0b10); + pub const SCALING_MATRIX_PRESENT_FLAG_SET: Self = Self(0b100); + pub const CHROMA_QP_INDEX_OFFSET: Self = Self(0b1000); + pub const SECOND_CHROMA_QP_INDEX_OFFSET: Self = Self(0b1_0000); + pub const PIC_INIT_QP_MINUS26: Self = Self(0b10_0000); + pub const WEIGHTED_PRED_FLAG_SET: Self = Self(0b100_0000); + pub const WEIGHTED_BIPRED_IDC_EXPLICIT: Self = Self(0b1000_0000); + pub const WEIGHTED_BIPRED_IDC_IMPLICIT: Self = Self(0b1_0000_0000); + pub const TRANSFORM_8X8_MODE_FLAG_SET: Self = Self(0b10_0000_0000); + pub const DIRECT_SPATIAL_MV_PRED_FLAG_UNSET: Self = Self(0b100_0000_0000); + pub const ENTROPY_CODING_MODE_FLAG_UNSET: Self = Self(0b1000_0000_0000); + pub const ENTROPY_CODING_MODE_FLAG_SET: Self = Self(0b1_0000_0000_0000); + pub const DIRECT_8X8_INFERENCE_FLAG_UNSET: Self = Self(0b10_0000_0000_0000); + pub const CONSTRAINED_INTRA_PRED_FLAG_SET: Self = Self(0b100_0000_0000_0000); + pub const DEBLOCKING_FILTER_DISABLED: Self = Self(0b1000_0000_0000_0000); + pub const DEBLOCKING_FILTER_ENABLED: Self = Self(0b1_0000_0000_0000_0000); + pub const DEBLOCKING_FILTER_PARTIAL: Self = Self(0b10_0000_0000_0000_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoEncodeH264RateControlFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(VideoEncodeH264RateControlFlagsEXT, Flags); +impl VideoEncodeH264RateControlFlagsEXT { + pub const ATTEMPT_HRD_COMPLIANCE: Self = Self(0b1); + pub const REGULAR_GOP: Self = Self(0b10); + pub const REFERENCE_PATTERN_FLAT: Self = Self(0b100); + pub const REFERENCE_PATTERN_DYADIC: Self = Self(0b1000); + pub const TEMPORAL_LAYER_PATTERN_DYADIC: Self = Self(0b1_0000); } #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] @@ -1439,33 +1460,54 @@ impl RenderingFlags { pub struct VideoEncodeH265CapabilityFlagsEXT(pub(crate) Flags); vk_bitflags_wrapped!(VideoEncodeH265CapabilityFlagsEXT, Flags); impl VideoEncodeH265CapabilityFlagsEXT { - pub const SEPARATE_COLOUR_PLANE: Self = Self(0b1); - pub const SCALING_LISTS: Self = Self(0b10); - pub const SAMPLE_ADAPTIVE_OFFSET_ENABLED: Self = Self(0b100); - pub const PCM_ENABLE: Self = Self(0b1000); - pub const SPS_TEMPORAL_MVP_ENABLED: Self = Self(0b1_0000); - pub const HRD_COMPLIANCE: Self = Self(0b10_0000); - pub const INIT_QP_MINUS26: Self = Self(0b100_0000); - pub const LOG2_PARALLEL_MERGE_LEVEL_MINUS2: Self = Self(0b1000_0000); - pub const SIGN_DATA_HIDING_ENABLED: Self = Self(0b1_0000_0000); - pub const TRANSFORM_SKIP_ENABLED: Self = Self(0b10_0000_0000); - pub const TRANSFORM_SKIP_DISABLED: Self = Self(0b100_0000_0000); - pub const PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT: Self = Self(0b1000_0000_0000); - pub const WEIGHTED_PRED: Self = Self(0b1_0000_0000_0000); - pub const WEIGHTED_BIPRED: Self = Self(0b10_0000_0000_0000); - pub const WEIGHTED_PRED_NO_TABLE: Self = Self(0b100_0000_0000_0000); - pub const TRANSQUANT_BYPASS_ENABLED: Self = Self(0b1000_0000_0000_0000); - pub const ENTROPY_CODING_SYNC_ENABLED: Self = Self(0b1_0000_0000_0000_0000); - pub const DEBLOCKING_FILTER_OVERRIDE_ENABLED: Self = Self(0b10_0000_0000_0000_0000); - pub const MULTIPLE_TILE_PER_FRAME: Self = Self(0b100_0000_0000_0000_0000); - pub const MULTIPLE_SLICE_PER_TILE: Self = Self(0b1000_0000_0000_0000_0000); - pub const MULTIPLE_TILE_PER_SLICE: Self = Self(0b1_0000_0000_0000_0000_0000); - pub const SLICE_SEGMENT_CTB_COUNT: Self = Self(0b10_0000_0000_0000_0000_0000); - pub const ROW_UNALIGNED_SLICE_SEGMENT: Self = Self(0b100_0000_0000_0000_0000_0000); - pub const DEPENDENT_SLICE_SEGMENT: Self = Self(0b1000_0000_0000_0000_0000_0000); - pub const DIFFERENT_SLICE_TYPE: Self = Self(0b1_0000_0000_0000_0000_0000_0000); - pub const B_FRAME_IN_L1_LIST: Self = Self(0b10_0000_0000_0000_0000_0000_0000); - pub const DIFFERENT_REFERENCE_FINAL_LISTS: Self = Self(0b100_0000_0000_0000_0000_0000_0000); + pub const HRD_COMPLIANCE: Self = Self(0b1); + pub const PREDICTION_WEIGHT_TABLE_GENERATED: Self = Self(0b10); + pub const ROW_UNALIGNED_SLICE_SEGMENT: Self = Self(0b100); + pub const DIFFERENT_SLICE_SEGMENT_TYPE: Self = Self(0b1000); + pub const B_FRAME_IN_L0_LIST: Self = Self(0b1_0000); + pub const B_FRAME_IN_L1_LIST: Self = Self(0b10_0000); + pub const PER_PICTURE_TYPE_MIN_MAX_QP: Self = Self(0b100_0000); + pub const PER_SLICE_SEGMENT_CONSTANT_QP: Self = Self(0b1000_0000); + pub const MULTIPLE_TILES_PER_SLICE_SEGMENT: Self = Self(0b1_0000_0000); + pub const MULTIPLE_SLICE_SEGMENTS_PER_TILE: Self = Self(0b10_0000_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoEncodeH265StdFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(VideoEncodeH265StdFlagsEXT, Flags); +impl VideoEncodeH265StdFlagsEXT { + pub const SEPARATE_COLOR_PLANE_FLAG_SET: Self = Self(0b1); + pub const SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET: Self = Self(0b10); + pub const SCALING_LIST_DATA_PRESENT_FLAG_SET: Self = Self(0b100); + pub const PCM_ENABLED_FLAG_SET: Self = Self(0b1000); + pub const SPS_TEMPORAL_MVP_ENABLED_FLAG_SET: Self = Self(0b1_0000); + pub const INIT_QP_MINUS26: Self = Self(0b10_0000); + pub const WEIGHTED_PRED_FLAG_SET: Self = Self(0b100_0000); + pub const WEIGHTED_BIPRED_FLAG_SET: Self = Self(0b1000_0000); + pub const LOG2_PARALLEL_MERGE_LEVEL_MINUS2: Self = Self(0b1_0000_0000); + pub const SIGN_DATA_HIDING_ENABLED_FLAG_SET: Self = Self(0b10_0000_0000); + pub const TRANSFORM_SKIP_ENABLED_FLAG_SET: Self = Self(0b100_0000_0000); + pub const TRANSFORM_SKIP_ENABLED_FLAG_UNSET: Self = Self(0b1000_0000_0000); + pub const PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET: Self = Self(0b1_0000_0000_0000); + pub const TRANSQUANT_BYPASS_ENABLED_FLAG_SET: Self = Self(0b10_0000_0000_0000); + pub const CONSTRAINED_INTRA_PRED_FLAG_SET: Self = Self(0b100_0000_0000_0000); + pub const ENTROPY_CODING_SYNC_ENABLED_FLAG_SET: Self = Self(0b1000_0000_0000_0000); + pub const DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET: Self = Self(0b1_0000_0000_0000_0000); + pub const DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET: Self = Self(0b10_0000_0000_0000_0000); + pub const DEPENDENT_SLICE_SEGMENT_FLAG_SET: Self = Self(0b100_0000_0000_0000_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoEncodeH265RateControlFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(VideoEncodeH265RateControlFlagsEXT, Flags); +impl VideoEncodeH265RateControlFlagsEXT { + pub const ATTEMPT_HRD_COMPLIANCE: Self = Self(0b1); + pub const REGULAR_GOP: Self = Self(0b10); + pub const REFERENCE_PATTERN_FLAT: Self = Self(0b100); + pub const REFERENCE_PATTERN_DYADIC: Self = Self(0b1000); + pub const TEMPORAL_SUB_LAYER_PATTERN_DYADIC: Self = Self(0b1_0000); } #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] diff --git a/ash/src/vk/const_debugs.rs b/ash/src/vk/const_debugs.rs index 6e108f052..4bbc5bd42 100644 --- a/ash/src/vk/const_debugs.rs +++ b/ash/src/vk/const_debugs.rs @@ -1129,6 +1129,23 @@ impl fmt::Debug for DependencyFlags { debug_flags(f, KNOWN, self.0) } } +impl fmt::Debug for DepthBiasRepresentationEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::LEAST_REPRESENTABLE_VALUE_FORMAT => Some("LEAST_REPRESENTABLE_VALUE_FORMAT"), + Self::LEAST_REPRESENTABLE_VALUE_FORCE_UNORM => { + Some("LEAST_REPRESENTABLE_VALUE_FORCE_UNORM") + } + Self::FLOAT => Some("FLOAT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} impl fmt::Debug for DescriptorBindingFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -1761,6 +1778,10 @@ impl fmt::Debug for ExternalMemoryHandleTypeFlags { ExternalMemoryHandleTypeFlags::RDMA_ADDRESS_NV.0, "RDMA_ADDRESS_NV", ), + ( + ExternalMemoryHandleTypeFlags::SCREEN_BUFFER_QNX.0, + "SCREEN_BUFFER_QNX", + ), ]; debug_flags(f, KNOWN, self.0) } @@ -4723,15 +4744,16 @@ impl fmt::Debug for StructureType { Self::VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT => { Some("VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT") } - Self::VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT => { - Some("VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT") - } + Self::VIDEO_ENCODE_H264_PICTURE_INFO_EXT => Some("VIDEO_ENCODE_H264_PICTURE_INFO_EXT"), Self::VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT => { Some("VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT") } Self::VIDEO_ENCODE_H264_NALU_SLICE_INFO_EXT => { Some("VIDEO_ENCODE_H264_NALU_SLICE_INFO_EXT") } + Self::VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_EXT => { + Some("VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_EXT") + } Self::VIDEO_ENCODE_H264_PROFILE_INFO_EXT => Some("VIDEO_ENCODE_H264_PROFILE_INFO_EXT"), Self::VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT => { Some("VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT") @@ -4739,6 +4761,18 @@ impl fmt::Debug for StructureType { Self::VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT => { Some("VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT") } + Self::VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT => { + Some("VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT") + } + Self::VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_EXT => { + Some("VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_EXT") + } + Self::VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_EXT => { + Some("VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_EXT") + } + Self::VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_EXT => { + Some("VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_EXT") + } Self::VIDEO_ENCODE_H265_CAPABILITIES_EXT => Some("VIDEO_ENCODE_H265_CAPABILITIES_EXT"), Self::VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT => { Some("VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT") @@ -4746,15 +4780,16 @@ impl fmt::Debug for StructureType { Self::VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT => { Some("VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT") } - Self::VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT => { - Some("VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT") - } + Self::VIDEO_ENCODE_H265_PICTURE_INFO_EXT => Some("VIDEO_ENCODE_H265_PICTURE_INFO_EXT"), Self::VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT => { Some("VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT") } Self::VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_EXT => { Some("VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_EXT") } + Self::VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_EXT => { + Some("VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_EXT") + } Self::VIDEO_ENCODE_H265_PROFILE_INFO_EXT => Some("VIDEO_ENCODE_H265_PROFILE_INFO_EXT"), Self::VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT => { Some("VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT") @@ -4762,6 +4797,18 @@ impl fmt::Debug for StructureType { Self::VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT => { Some("VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT") } + Self::VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT => { + Some("VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT") + } + Self::VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_EXT => { + Some("VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_EXT") + } + Self::VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_EXT => { + Some("VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_EXT") + } + Self::VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_EXT => { + Some("VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_EXT") + } Self::VIDEO_DECODE_H264_CAPABILITIES_KHR => Some("VIDEO_DECODE_H264_CAPABILITIES_KHR"), Self::VIDEO_DECODE_H264_PICTURE_INFO_KHR => Some("VIDEO_DECODE_H264_PICTURE_INFO_KHR"), Self::VIDEO_DECODE_H264_PROFILE_INFO_KHR => Some("VIDEO_DECODE_H264_PROFILE_INFO_KHR"), @@ -5408,6 +5455,11 @@ impl fmt::Debug for StructureType { Self::RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM => { Some("RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM") } + Self::PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT") + } + Self::DEPTH_BIAS_INFO_EXT => Some("DEPTH_BIAS_INFO_EXT"), + Self::DEPTH_BIAS_REPRESENTATION_INFO_EXT => Some("DEPTH_BIAS_REPRESENTATION_INFO_EXT"), Self::PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT => { Some("PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT") } @@ -5456,6 +5508,21 @@ impl fmt::Debug for StructureType { Self::QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR => { Some("QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR") } + Self::PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR => { + Some("PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR") + } + Self::VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR => { + Some("VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR") + } + Self::VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR => { + Some("VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR") + } + Self::VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR => { + Some("VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR") + } + Self::VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR => { + Some("VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR") + } Self::PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV => { Some("PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV") } @@ -5820,6 +5887,9 @@ impl fmt::Debug for StructureType { Self::IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM => { Some("IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM") } + Self::EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT => { + Some("EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT") + } Self::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT => { Some("PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT") } @@ -5928,6 +5998,15 @@ impl fmt::Debug for StructureType { Self::PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT => { Some("PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT") } + Self::SCREEN_BUFFER_PROPERTIES_QNX => Some("SCREEN_BUFFER_PROPERTIES_QNX"), + Self::SCREEN_BUFFER_FORMAT_PROPERTIES_QNX => { + Some("SCREEN_BUFFER_FORMAT_PROPERTIES_QNX") + } + Self::IMPORT_SCREEN_BUFFER_INFO_QNX => Some("IMPORT_SCREEN_BUFFER_INFO_QNX"), + Self::EXTERNAL_FORMAT_QNX => Some("EXTERNAL_FORMAT_QNX"), + Self::PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX => { + Some("PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX") + } Self::PHYSICAL_DEVICE_SUBGROUP_PROPERTIES => { Some("PHYSICAL_DEVICE_SUBGROUP_PROPERTIES") } @@ -6672,8 +6751,8 @@ impl fmt::Debug for VideoCodingControlFlagsKHR { "ENCODE_RATE_CONTROL", ), ( - VideoCodingControlFlagsKHR::ENCODE_RATE_CONTROL_LAYER.0, - "ENCODE_RATE_CONTROL_LAYER", + VideoCodingControlFlagsKHR::ENCODE_QUALITY_LEVEL.0, + "ENCODE_QUALITY_LEVEL", ), ]; debug_flags(f, KNOWN, self.0) @@ -6772,6 +6851,10 @@ impl fmt::Debug for VideoEncodeFeedbackFlagsKHR { VideoEncodeFeedbackFlagsKHR::BITSTREAM_BYTES_WRITTEN.0, "BITSTREAM_BYTES_WRITTEN", ), + ( + VideoEncodeFeedbackFlagsKHR::BITSTREAM_HAS_OVERRIDES.0, + "BITSTREAM_HAS_OVERRIDES", + ), ]; debug_flags(f, KNOWN, self.0) } @@ -6786,262 +6869,318 @@ impl fmt::Debug for VideoEncodeH264CapabilityFlagsEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ ( - VideoEncodeH264CapabilityFlagsEXT::DIRECT_8X8_INFERENCE_ENABLED.0, - "DIRECT_8X8_INFERENCE_ENABLED", + VideoEncodeH264CapabilityFlagsEXT::HRD_COMPLIANCE.0, + "HRD_COMPLIANCE", ), ( - VideoEncodeH264CapabilityFlagsEXT::DIRECT_8X8_INFERENCE_DISABLED.0, - "DIRECT_8X8_INFERENCE_DISABLED", + VideoEncodeH264CapabilityFlagsEXT::PREDICTION_WEIGHT_TABLE_GENERATED.0, + "PREDICTION_WEIGHT_TABLE_GENERATED", ), ( - VideoEncodeH264CapabilityFlagsEXT::SEPARATE_COLOUR_PLANE.0, - "SEPARATE_COLOUR_PLANE", + VideoEncodeH264CapabilityFlagsEXT::ROW_UNALIGNED_SLICE.0, + "ROW_UNALIGNED_SLICE", ), ( - VideoEncodeH264CapabilityFlagsEXT::QPPRIME_Y_ZERO_TRANSFORM_BYPASS.0, - "QPPRIME_Y_ZERO_TRANSFORM_BYPASS", + VideoEncodeH264CapabilityFlagsEXT::DIFFERENT_SLICE_TYPE.0, + "DIFFERENT_SLICE_TYPE", ), ( - VideoEncodeH264CapabilityFlagsEXT::SCALING_LISTS.0, - "SCALING_LISTS", + VideoEncodeH264CapabilityFlagsEXT::B_FRAME_IN_L0_LIST.0, + "B_FRAME_IN_L0_LIST", ), ( - VideoEncodeH264CapabilityFlagsEXT::HRD_COMPLIANCE.0, - "HRD_COMPLIANCE", + VideoEncodeH264CapabilityFlagsEXT::B_FRAME_IN_L1_LIST.0, + "B_FRAME_IN_L1_LIST", + ), + ( + VideoEncodeH264CapabilityFlagsEXT::PER_PICTURE_TYPE_MIN_MAX_QP.0, + "PER_PICTURE_TYPE_MIN_MAX_QP", + ), + ( + VideoEncodeH264CapabilityFlagsEXT::PER_SLICE_CONSTANT_QP.0, + "PER_SLICE_CONSTANT_QP", + ), + ( + VideoEncodeH264CapabilityFlagsEXT::GENERATE_PREFIX_NALU.0, + "GENERATE_PREFIX_NALU", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoEncodeH264RateControlFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + VideoEncodeH264RateControlFlagsEXT::ATTEMPT_HRD_COMPLIANCE.0, + "ATTEMPT_HRD_COMPLIANCE", + ), + ( + VideoEncodeH264RateControlFlagsEXT::REGULAR_GOP.0, + "REGULAR_GOP", + ), + ( + VideoEncodeH264RateControlFlagsEXT::REFERENCE_PATTERN_FLAT.0, + "REFERENCE_PATTERN_FLAT", + ), + ( + VideoEncodeH264RateControlFlagsEXT::REFERENCE_PATTERN_DYADIC.0, + "REFERENCE_PATTERN_DYADIC", + ), + ( + VideoEncodeH264RateControlFlagsEXT::TEMPORAL_LAYER_PATTERN_DYADIC.0, + "TEMPORAL_LAYER_PATTERN_DYADIC", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoEncodeH264StdFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + VideoEncodeH264StdFlagsEXT::SEPARATE_COLOR_PLANE_FLAG_SET.0, + "SEPARATE_COLOR_PLANE_FLAG_SET", ), ( - VideoEncodeH264CapabilityFlagsEXT::CHROMA_QP_OFFSET.0, - "CHROMA_QP_OFFSET", + VideoEncodeH264StdFlagsEXT::QPPRIME_Y_ZERO_TRANSFORM_BYPASS_FLAG_SET.0, + "QPPRIME_Y_ZERO_TRANSFORM_BYPASS_FLAG_SET", ), ( - VideoEncodeH264CapabilityFlagsEXT::SECOND_CHROMA_QP_OFFSET.0, - "SECOND_CHROMA_QP_OFFSET", + VideoEncodeH264StdFlagsEXT::SCALING_MATRIX_PRESENT_FLAG_SET.0, + "SCALING_MATRIX_PRESENT_FLAG_SET", ), ( - VideoEncodeH264CapabilityFlagsEXT::PIC_INIT_QP_MINUS26.0, + VideoEncodeH264StdFlagsEXT::CHROMA_QP_INDEX_OFFSET.0, + "CHROMA_QP_INDEX_OFFSET", + ), + ( + VideoEncodeH264StdFlagsEXT::SECOND_CHROMA_QP_INDEX_OFFSET.0, + "SECOND_CHROMA_QP_INDEX_OFFSET", + ), + ( + VideoEncodeH264StdFlagsEXT::PIC_INIT_QP_MINUS26.0, "PIC_INIT_QP_MINUS26", ), ( - VideoEncodeH264CapabilityFlagsEXT::WEIGHTED_PRED.0, - "WEIGHTED_PRED", + VideoEncodeH264StdFlagsEXT::WEIGHTED_PRED_FLAG_SET.0, + "WEIGHTED_PRED_FLAG_SET", + ), + ( + VideoEncodeH264StdFlagsEXT::WEIGHTED_BIPRED_IDC_EXPLICIT.0, + "WEIGHTED_BIPRED_IDC_EXPLICIT", ), ( - VideoEncodeH264CapabilityFlagsEXT::WEIGHTED_BIPRED_EXPLICIT.0, - "WEIGHTED_BIPRED_EXPLICIT", + VideoEncodeH264StdFlagsEXT::WEIGHTED_BIPRED_IDC_IMPLICIT.0, + "WEIGHTED_BIPRED_IDC_IMPLICIT", ), ( - VideoEncodeH264CapabilityFlagsEXT::WEIGHTED_BIPRED_IMPLICIT.0, - "WEIGHTED_BIPRED_IMPLICIT", + VideoEncodeH264StdFlagsEXT::TRANSFORM_8X8_MODE_FLAG_SET.0, + "TRANSFORM_8X8_MODE_FLAG_SET", ), ( - VideoEncodeH264CapabilityFlagsEXT::WEIGHTED_PRED_NO_TABLE.0, - "WEIGHTED_PRED_NO_TABLE", + VideoEncodeH264StdFlagsEXT::DIRECT_SPATIAL_MV_PRED_FLAG_UNSET.0, + "DIRECT_SPATIAL_MV_PRED_FLAG_UNSET", ), ( - VideoEncodeH264CapabilityFlagsEXT::TRANSFORM_8X8.0, - "TRANSFORM_8X8", + VideoEncodeH264StdFlagsEXT::ENTROPY_CODING_MODE_FLAG_UNSET.0, + "ENTROPY_CODING_MODE_FLAG_UNSET", ), - (VideoEncodeH264CapabilityFlagsEXT::CABAC.0, "CABAC"), - (VideoEncodeH264CapabilityFlagsEXT::CAVLC.0, "CAVLC"), ( - VideoEncodeH264CapabilityFlagsEXT::DEBLOCKING_FILTER_DISABLED.0, + VideoEncodeH264StdFlagsEXT::ENTROPY_CODING_MODE_FLAG_SET.0, + "ENTROPY_CODING_MODE_FLAG_SET", + ), + ( + VideoEncodeH264StdFlagsEXT::DIRECT_8X8_INFERENCE_FLAG_UNSET.0, + "DIRECT_8X8_INFERENCE_FLAG_UNSET", + ), + ( + VideoEncodeH264StdFlagsEXT::CONSTRAINED_INTRA_PRED_FLAG_SET.0, + "CONSTRAINED_INTRA_PRED_FLAG_SET", + ), + ( + VideoEncodeH264StdFlagsEXT::DEBLOCKING_FILTER_DISABLED.0, "DEBLOCKING_FILTER_DISABLED", ), ( - VideoEncodeH264CapabilityFlagsEXT::DEBLOCKING_FILTER_ENABLED.0, + VideoEncodeH264StdFlagsEXT::DEBLOCKING_FILTER_ENABLED.0, "DEBLOCKING_FILTER_ENABLED", ), ( - VideoEncodeH264CapabilityFlagsEXT::DEBLOCKING_FILTER_PARTIAL.0, + VideoEncodeH264StdFlagsEXT::DEBLOCKING_FILTER_PARTIAL.0, "DEBLOCKING_FILTER_PARTIAL", ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoEncodeH265CapabilityFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ ( - VideoEncodeH264CapabilityFlagsEXT::DISABLE_DIRECT_SPATIAL_MV_PRED.0, - "DISABLE_DIRECT_SPATIAL_MV_PRED", + VideoEncodeH265CapabilityFlagsEXT::HRD_COMPLIANCE.0, + "HRD_COMPLIANCE", ), ( - VideoEncodeH264CapabilityFlagsEXT::MULTIPLE_SLICE_PER_FRAME.0, - "MULTIPLE_SLICE_PER_FRAME", + VideoEncodeH265CapabilityFlagsEXT::PREDICTION_WEIGHT_TABLE_GENERATED.0, + "PREDICTION_WEIGHT_TABLE_GENERATED", ), ( - VideoEncodeH264CapabilityFlagsEXT::SLICE_MB_COUNT.0, - "SLICE_MB_COUNT", + VideoEncodeH265CapabilityFlagsEXT::ROW_UNALIGNED_SLICE_SEGMENT.0, + "ROW_UNALIGNED_SLICE_SEGMENT", ), ( - VideoEncodeH264CapabilityFlagsEXT::ROW_UNALIGNED_SLICE.0, - "ROW_UNALIGNED_SLICE", + VideoEncodeH265CapabilityFlagsEXT::DIFFERENT_SLICE_SEGMENT_TYPE.0, + "DIFFERENT_SLICE_SEGMENT_TYPE", ), ( - VideoEncodeH264CapabilityFlagsEXT::DIFFERENT_SLICE_TYPE.0, - "DIFFERENT_SLICE_TYPE", + VideoEncodeH265CapabilityFlagsEXT::B_FRAME_IN_L0_LIST.0, + "B_FRAME_IN_L0_LIST", ), ( - VideoEncodeH264CapabilityFlagsEXT::B_FRAME_IN_L1_LIST.0, + VideoEncodeH265CapabilityFlagsEXT::B_FRAME_IN_L1_LIST.0, "B_FRAME_IN_L1_LIST", ), ( - VideoEncodeH264CapabilityFlagsEXT::DIFFERENT_REFERENCE_FINAL_LISTS.0, - "DIFFERENT_REFERENCE_FINAL_LISTS", + VideoEncodeH265CapabilityFlagsEXT::PER_PICTURE_TYPE_MIN_MAX_QP.0, + "PER_PICTURE_TYPE_MIN_MAX_QP", + ), + ( + VideoEncodeH265CapabilityFlagsEXT::PER_SLICE_SEGMENT_CONSTANT_QP.0, + "PER_SLICE_SEGMENT_CONSTANT_QP", + ), + ( + VideoEncodeH265CapabilityFlagsEXT::MULTIPLE_TILES_PER_SLICE_SEGMENT.0, + "MULTIPLE_TILES_PER_SLICE_SEGMENT", + ), + ( + VideoEncodeH265CapabilityFlagsEXT::MULTIPLE_SLICE_SEGMENTS_PER_TILE.0, + "MULTIPLE_SLICE_SEGMENTS_PER_TILE", ), ]; debug_flags(f, KNOWN, self.0) } } -impl fmt::Debug for VideoEncodeH264RateControlStructureEXT { +impl fmt::Debug for VideoEncodeH265CtbSizeFlagsEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNKNOWN => Some("UNKNOWN"), - Self::FLAT => Some("FLAT"), - Self::DYADIC => Some("DYADIC"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - self.0.fmt(f) - } + const KNOWN: &[(Flags, &str)] = &[ + (VideoEncodeH265CtbSizeFlagsEXT::TYPE_16.0, "TYPE_16"), + (VideoEncodeH265CtbSizeFlagsEXT::TYPE_32.0, "TYPE_32"), + (VideoEncodeH265CtbSizeFlagsEXT::TYPE_64.0, "TYPE_64"), + ]; + debug_flags(f, KNOWN, self.0) } } -impl fmt::Debug for VideoEncodeH265CapabilityFlagsEXT { +impl fmt::Debug for VideoEncodeH265RateControlFlagsEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ ( - VideoEncodeH265CapabilityFlagsEXT::SEPARATE_COLOUR_PLANE.0, - "SEPARATE_COLOUR_PLANE", + VideoEncodeH265RateControlFlagsEXT::ATTEMPT_HRD_COMPLIANCE.0, + "ATTEMPT_HRD_COMPLIANCE", ), ( - VideoEncodeH265CapabilityFlagsEXT::SCALING_LISTS.0, - "SCALING_LISTS", + VideoEncodeH265RateControlFlagsEXT::REGULAR_GOP.0, + "REGULAR_GOP", ), ( - VideoEncodeH265CapabilityFlagsEXT::SAMPLE_ADAPTIVE_OFFSET_ENABLED.0, - "SAMPLE_ADAPTIVE_OFFSET_ENABLED", - ), - ( - VideoEncodeH265CapabilityFlagsEXT::PCM_ENABLE.0, - "PCM_ENABLE", - ), - ( - VideoEncodeH265CapabilityFlagsEXT::SPS_TEMPORAL_MVP_ENABLED.0, - "SPS_TEMPORAL_MVP_ENABLED", - ), - ( - VideoEncodeH265CapabilityFlagsEXT::HRD_COMPLIANCE.0, - "HRD_COMPLIANCE", + VideoEncodeH265RateControlFlagsEXT::REFERENCE_PATTERN_FLAT.0, + "REFERENCE_PATTERN_FLAT", ), ( - VideoEncodeH265CapabilityFlagsEXT::INIT_QP_MINUS26.0, - "INIT_QP_MINUS26", + VideoEncodeH265RateControlFlagsEXT::REFERENCE_PATTERN_DYADIC.0, + "REFERENCE_PATTERN_DYADIC", ), ( - VideoEncodeH265CapabilityFlagsEXT::LOG2_PARALLEL_MERGE_LEVEL_MINUS2.0, - "LOG2_PARALLEL_MERGE_LEVEL_MINUS2", + VideoEncodeH265RateControlFlagsEXT::TEMPORAL_SUB_LAYER_PATTERN_DYADIC.0, + "TEMPORAL_SUB_LAYER_PATTERN_DYADIC", ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoEncodeH265StdFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ ( - VideoEncodeH265CapabilityFlagsEXT::SIGN_DATA_HIDING_ENABLED.0, - "SIGN_DATA_HIDING_ENABLED", + VideoEncodeH265StdFlagsEXT::SEPARATE_COLOR_PLANE_FLAG_SET.0, + "SEPARATE_COLOR_PLANE_FLAG_SET", ), ( - VideoEncodeH265CapabilityFlagsEXT::TRANSFORM_SKIP_ENABLED.0, - "TRANSFORM_SKIP_ENABLED", + VideoEncodeH265StdFlagsEXT::SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET.0, + "SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET", ), ( - VideoEncodeH265CapabilityFlagsEXT::TRANSFORM_SKIP_DISABLED.0, - "TRANSFORM_SKIP_DISABLED", + VideoEncodeH265StdFlagsEXT::SCALING_LIST_DATA_PRESENT_FLAG_SET.0, + "SCALING_LIST_DATA_PRESENT_FLAG_SET", ), ( - VideoEncodeH265CapabilityFlagsEXT::PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT.0, - "PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT", + VideoEncodeH265StdFlagsEXT::PCM_ENABLED_FLAG_SET.0, + "PCM_ENABLED_FLAG_SET", ), ( - VideoEncodeH265CapabilityFlagsEXT::WEIGHTED_PRED.0, - "WEIGHTED_PRED", + VideoEncodeH265StdFlagsEXT::SPS_TEMPORAL_MVP_ENABLED_FLAG_SET.0, + "SPS_TEMPORAL_MVP_ENABLED_FLAG_SET", ), ( - VideoEncodeH265CapabilityFlagsEXT::WEIGHTED_BIPRED.0, - "WEIGHTED_BIPRED", + VideoEncodeH265StdFlagsEXT::INIT_QP_MINUS26.0, + "INIT_QP_MINUS26", ), ( - VideoEncodeH265CapabilityFlagsEXT::WEIGHTED_PRED_NO_TABLE.0, - "WEIGHTED_PRED_NO_TABLE", + VideoEncodeH265StdFlagsEXT::WEIGHTED_PRED_FLAG_SET.0, + "WEIGHTED_PRED_FLAG_SET", ), ( - VideoEncodeH265CapabilityFlagsEXT::TRANSQUANT_BYPASS_ENABLED.0, - "TRANSQUANT_BYPASS_ENABLED", + VideoEncodeH265StdFlagsEXT::WEIGHTED_BIPRED_FLAG_SET.0, + "WEIGHTED_BIPRED_FLAG_SET", ), ( - VideoEncodeH265CapabilityFlagsEXT::ENTROPY_CODING_SYNC_ENABLED.0, - "ENTROPY_CODING_SYNC_ENABLED", + VideoEncodeH265StdFlagsEXT::LOG2_PARALLEL_MERGE_LEVEL_MINUS2.0, + "LOG2_PARALLEL_MERGE_LEVEL_MINUS2", ), ( - VideoEncodeH265CapabilityFlagsEXT::DEBLOCKING_FILTER_OVERRIDE_ENABLED.0, - "DEBLOCKING_FILTER_OVERRIDE_ENABLED", + VideoEncodeH265StdFlagsEXT::SIGN_DATA_HIDING_ENABLED_FLAG_SET.0, + "SIGN_DATA_HIDING_ENABLED_FLAG_SET", ), ( - VideoEncodeH265CapabilityFlagsEXT::MULTIPLE_TILE_PER_FRAME.0, - "MULTIPLE_TILE_PER_FRAME", + VideoEncodeH265StdFlagsEXT::TRANSFORM_SKIP_ENABLED_FLAG_SET.0, + "TRANSFORM_SKIP_ENABLED_FLAG_SET", ), ( - VideoEncodeH265CapabilityFlagsEXT::MULTIPLE_SLICE_PER_TILE.0, - "MULTIPLE_SLICE_PER_TILE", + VideoEncodeH265StdFlagsEXT::TRANSFORM_SKIP_ENABLED_FLAG_UNSET.0, + "TRANSFORM_SKIP_ENABLED_FLAG_UNSET", ), ( - VideoEncodeH265CapabilityFlagsEXT::MULTIPLE_TILE_PER_SLICE.0, - "MULTIPLE_TILE_PER_SLICE", + VideoEncodeH265StdFlagsEXT::PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET.0, + "PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET", ), ( - VideoEncodeH265CapabilityFlagsEXT::SLICE_SEGMENT_CTB_COUNT.0, - "SLICE_SEGMENT_CTB_COUNT", + VideoEncodeH265StdFlagsEXT::TRANSQUANT_BYPASS_ENABLED_FLAG_SET.0, + "TRANSQUANT_BYPASS_ENABLED_FLAG_SET", ), ( - VideoEncodeH265CapabilityFlagsEXT::ROW_UNALIGNED_SLICE_SEGMENT.0, - "ROW_UNALIGNED_SLICE_SEGMENT", + VideoEncodeH265StdFlagsEXT::CONSTRAINED_INTRA_PRED_FLAG_SET.0, + "CONSTRAINED_INTRA_PRED_FLAG_SET", ), ( - VideoEncodeH265CapabilityFlagsEXT::DEPENDENT_SLICE_SEGMENT.0, - "DEPENDENT_SLICE_SEGMENT", + VideoEncodeH265StdFlagsEXT::ENTROPY_CODING_SYNC_ENABLED_FLAG_SET.0, + "ENTROPY_CODING_SYNC_ENABLED_FLAG_SET", ), ( - VideoEncodeH265CapabilityFlagsEXT::DIFFERENT_SLICE_TYPE.0, - "DIFFERENT_SLICE_TYPE", + VideoEncodeH265StdFlagsEXT::DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET.0, + "DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET", ), ( - VideoEncodeH265CapabilityFlagsEXT::B_FRAME_IN_L1_LIST.0, - "B_FRAME_IN_L1_LIST", + VideoEncodeH265StdFlagsEXT::DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET.0, + "DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET", ), ( - VideoEncodeH265CapabilityFlagsEXT::DIFFERENT_REFERENCE_FINAL_LISTS.0, - "DIFFERENT_REFERENCE_FINAL_LISTS", + VideoEncodeH265StdFlagsEXT::DEPENDENT_SLICE_SEGMENT_FLAG_SET.0, + "DEPENDENT_SLICE_SEGMENT_FLAG_SET", ), ]; debug_flags(f, KNOWN, self.0) } } -impl fmt::Debug for VideoEncodeH265CtbSizeFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (VideoEncodeH265CtbSizeFlagsEXT::TYPE_16.0, "TYPE_16"), - (VideoEncodeH265CtbSizeFlagsEXT::TYPE_32.0, "TYPE_32"), - (VideoEncodeH265CtbSizeFlagsEXT::TYPE_64.0, "TYPE_64"), - ]; - debug_flags(f, KNOWN, self.0) - } -} -impl fmt::Debug for VideoEncodeH265RateControlStructureEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNKNOWN => Some("UNKNOWN"), - Self::FLAT => Some("FLAT"), - Self::DYADIC => Some("DYADIC"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - self.0.fmt(f) - } - } -} impl fmt::Debug for VideoEncodeH265TransformBlockSizeFlagsEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -7119,10 +7258,16 @@ impl fmt::Debug for VideoEndCodingFlagsKHR { } impl fmt::Debug for VideoSessionCreateFlagsKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - VideoSessionCreateFlagsKHR::PROTECTED_CONTENT.0, - "PROTECTED_CONTENT", - )]; + const KNOWN: &[(Flags, &str)] = &[ + ( + VideoSessionCreateFlagsKHR::PROTECTED_CONTENT.0, + "PROTECTED_CONTENT", + ), + ( + VideoSessionCreateFlagsKHR::ALLOW_ENCODE_PARAMETER_OPTIMIZATIONS.0, + "ALLOW_ENCODE_PARAMETER_OPTIMIZATIONS", + ), + ]; debug_flags(f, KNOWN, self.0) } } diff --git a/ash/src/vk/definitions.rs b/ash/src/vk/definitions.rs index 08e688011..3c70a9f21 100644 --- a/ash/src/vk/definitions.rs +++ b/ash/src/vk/definitions.rs @@ -58,7 +58,7 @@ pub const API_VERSION_1_2: u32 = make_api_version(0, 1, 2, 0); #[doc = ""] pub const API_VERSION_1_3: u32 = make_api_version(0, 1, 3, 0); #[doc = ""] -pub const HEADER_VERSION: u32 = 251; +pub const HEADER_VERSION: u32 = 254; #[doc = ""] pub const HEADER_VERSION_COMPLETE: u32 = make_api_version(0, 1, 3, HEADER_VERSION); #[doc = ""] @@ -130,6 +130,11 @@ pub struct MemoryMapFlags(pub(crate) Flags); vk_bitflags_wrapped!(MemoryMapFlags, Flags); #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct MemoryUnmapFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(MemoryUnmapFlagsKHR, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[doc = ""] pub struct DescriptorPoolResetFlags(pub(crate) Flags); vk_bitflags_wrapped!(DescriptorPoolResetFlags, Flags); @@ -328,11 +333,6 @@ vk_bitflags_wrapped!(VideoEncodeFlagsKHR, Flags); #[doc = ""] pub struct VideoEncodeRateControlFlagsKHR(pub(crate) Flags); vk_bitflags_wrapped!(VideoEncodeRateControlFlagsKHR, Flags); -#[repr(transparent)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -#[doc = ""] -pub struct MemoryUnmapFlagsKHR(pub(crate) Flags); -vk_bitflags_wrapped!(MemoryUnmapFlagsKHR, Flags); define_handle!( Instance, INSTANCE, @@ -2263,6 +2263,7 @@ impl ::std::default::Default for BufferMemoryBarrier<'_> { unsafe impl<'a> TaggedStructure for BufferMemoryBarrier<'a> { const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_MEMORY_BARRIER; } +pub unsafe trait ExtendsBufferMemoryBarrier {} impl<'a> BufferMemoryBarrier<'a> { #[inline] pub fn src_access_mask(mut self, src_access_mask: AccessFlags) -> Self { @@ -2299,6 +2300,20 @@ impl<'a> BufferMemoryBarrier<'a> { self.size = size; 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 `x.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.p_next as _; + self.p_next = next_ptr; + } + self + } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -35316,6 +35331,7 @@ impl ::std::default::Default for BufferMemoryBarrier2<'_> { unsafe impl<'a> TaggedStructure for BufferMemoryBarrier2<'a> { const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_MEMORY_BARRIER_2; } +pub unsafe trait ExtendsBufferMemoryBarrier2 {} impl<'a> BufferMemoryBarrier2<'a> { #[inline] pub fn src_stage_mask(mut self, src_stage_mask: PipelineStageFlags2) -> Self { @@ -35362,6 +35378,20 @@ impl<'a> BufferMemoryBarrier2<'a> { self.size = size; 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 `x.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.p_next as _; + self.p_next = next_ptr; + } + self + } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -37280,6 +37310,7 @@ impl ::std::default::Default for VideoSessionCreateInfoKHR<'_> { unsafe impl<'a> TaggedStructure for VideoSessionCreateInfoKHR<'a> { const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_SESSION_CREATE_INFO_KHR; } +pub unsafe trait ExtendsVideoSessionCreateInfoKHR {} impl<'a> VideoSessionCreateInfoKHR<'a> { #[inline] pub fn queue_family_index(mut self, queue_family_index: u32) -> Self { @@ -37326,6 +37357,20 @@ impl<'a> VideoSessionCreateInfoKHR<'a> { self.p_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."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.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.p_next as _; + self.p_next = next_ptr; + } + self + } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -37445,6 +37490,109 @@ impl<'a> VideoSessionParametersUpdateInfoKHR<'a> { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeSessionParametersGetInfoKHR<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub video_session_parameters: VideoSessionParametersKHR, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for VideoEncodeSessionParametersGetInfoKHR<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + video_session_parameters: VideoSessionParametersKHR::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for VideoEncodeSessionParametersGetInfoKHR<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR; +} +pub unsafe trait ExtendsVideoEncodeSessionParametersGetInfoKHR {} +impl<'a> VideoEncodeSessionParametersGetInfoKHR<'a> { + #[inline] + pub fn video_session_parameters( + mut self, + video_session_parameters: VideoSessionParametersKHR, + ) -> Self { + self.video_session_parameters = video_session_parameters; + 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 `x.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.p_next as _; + self.p_next = next_ptr; + } + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeSessionParametersFeedbackInfoKHR<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub has_overrides: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for VideoEncodeSessionParametersFeedbackInfoKHR<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + has_overrides: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for VideoEncodeSessionParametersFeedbackInfoKHR<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR; +} +pub unsafe trait ExtendsVideoEncodeSessionParametersFeedbackInfoKHR {} +impl<'a> VideoEncodeSessionParametersFeedbackInfoKHR<'a> { + #[inline] + pub fn has_overrides(mut self, has_overrides: bool) -> Self { + self.has_overrides = has_overrides.into(); + 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 `x.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 = <*mut T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; + } + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] #[doc = ""] pub struct VideoBeginCodingInfoKHR<'a> { pub s_type: StructureType, @@ -37474,6 +37622,7 @@ impl ::std::default::Default for VideoBeginCodingInfoKHR<'_> { unsafe impl<'a> TaggedStructure for VideoBeginCodingInfoKHR<'a> { const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_BEGIN_CODING_INFO_KHR; } +pub unsafe trait ExtendsVideoBeginCodingInfoKHR {} impl<'a> VideoBeginCodingInfoKHR<'a> { #[inline] pub fn flags(mut self, flags: VideoBeginCodingFlagsKHR) -> Self { @@ -37499,6 +37648,20 @@ impl<'a> VideoBeginCodingInfoKHR<'a> { self.p_reference_slots = reference_slots.as_ptr(); 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 `x.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.p_next as _; + self.p_next = next_ptr; + } + self + } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -37632,7 +37795,6 @@ pub struct VideoEncodeInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: VideoEncodeFlagsKHR, - pub quality_level: u32, pub dst_buffer: Buffer, pub dst_buffer_offset: DeviceSize, pub dst_buffer_range: DeviceSize, @@ -37650,7 +37812,6 @@ impl ::std::default::Default for VideoEncodeInfoKHR<'_> { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null(), flags: VideoEncodeFlagsKHR::default(), - quality_level: u32::default(), dst_buffer: Buffer::default(), dst_buffer_offset: DeviceSize::default(), dst_buffer_range: DeviceSize::default(), @@ -37674,11 +37835,6 @@ impl<'a> VideoEncodeInfoKHR<'a> { self } #[inline] - pub fn quality_level(mut self, quality_level: u32) -> Self { - self.quality_level = quality_level; - self - } - #[inline] pub fn dst_buffer(mut self, dst_buffer: Buffer) -> Self { self.dst_buffer = dst_buffer; self @@ -37777,6 +37933,140 @@ impl<'a> QueryPoolVideoEncodeFeedbackCreateInfoKHR<'a> { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeQualityLevelInfoKHR<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub quality_level: u32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for VideoEncodeQualityLevelInfoKHR<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + quality_level: u32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for VideoEncodeQualityLevelInfoKHR<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR; +} +unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeQualityLevelInfoKHR<'_> {} +unsafe impl ExtendsVideoSessionParametersCreateInfoKHR for VideoEncodeQualityLevelInfoKHR<'_> {} +impl<'a> VideoEncodeQualityLevelInfoKHR<'a> { + #[inline] + pub fn quality_level(mut self, quality_level: u32) -> Self { + self.quality_level = quality_level; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceVideoEncodeQualityLevelInfoKHR<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_video_profile: *const VideoProfileInfoKHR<'a>, + pub quality_level: u32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceVideoEncodeQualityLevelInfoKHR<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + p_video_profile: ::std::ptr::null(), + quality_level: u32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceVideoEncodeQualityLevelInfoKHR<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR; +} +impl<'a> PhysicalDeviceVideoEncodeQualityLevelInfoKHR<'a> { + #[inline] + pub fn video_profile(mut self, video_profile: &'a VideoProfileInfoKHR<'a>) -> Self { + self.p_video_profile = video_profile; + self + } + #[inline] + pub fn quality_level(mut self, quality_level: u32) -> Self { + self.quality_level = quality_level; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeQualityLevelPropertiesKHR<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub preferred_rate_control_mode: VideoEncodeRateControlModeFlagsKHR, + pub preferred_rate_control_layer_count: u32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for VideoEncodeQualityLevelPropertiesKHR<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + preferred_rate_control_mode: VideoEncodeRateControlModeFlagsKHR::default(), + preferred_rate_control_layer_count: u32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for VideoEncodeQualityLevelPropertiesKHR<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR; +} +pub unsafe trait ExtendsVideoEncodeQualityLevelPropertiesKHR {} +impl<'a> VideoEncodeQualityLevelPropertiesKHR<'a> { + #[inline] + pub fn preferred_rate_control_mode( + mut self, + preferred_rate_control_mode: VideoEncodeRateControlModeFlagsKHR, + ) -> Self { + self.preferred_rate_control_mode = preferred_rate_control_mode; + self + } + #[inline] + pub fn preferred_rate_control_layer_count( + mut self, + preferred_rate_control_layer_count: u32, + ) -> Self { + self.preferred_rate_control_layer_count = preferred_rate_control_layer_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 `x.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 = <*mut T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; + } + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] #[doc = ""] pub struct VideoEncodeRateControlInfoKHR<'a> { pub s_type: StructureType, @@ -37785,6 +38075,8 @@ pub struct VideoEncodeRateControlInfoKHR<'a> { pub rate_control_mode: VideoEncodeRateControlModeFlagsKHR, pub layer_count: u32, pub p_layers: *const VideoEncodeRateControlLayerInfoKHR<'a>, + pub virtual_buffer_size_in_ms: u32, + pub initial_virtual_buffer_size_in_ms: u32, pub _marker: PhantomData<&'a ()>, } impl ::std::default::Default for VideoEncodeRateControlInfoKHR<'_> { @@ -37797,6 +38089,8 @@ impl ::std::default::Default for VideoEncodeRateControlInfoKHR<'_> { rate_control_mode: VideoEncodeRateControlModeFlagsKHR::default(), layer_count: u32::default(), p_layers: ::std::ptr::null(), + virtual_buffer_size_in_ms: u32::default(), + initial_virtual_buffer_size_in_ms: u32::default(), _marker: PhantomData, } } @@ -37805,6 +38099,7 @@ unsafe impl<'a> TaggedStructure for VideoEncodeRateControlInfoKHR<'a> { const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_RATE_CONTROL_INFO_KHR; } unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeRateControlInfoKHR<'_> {} +unsafe impl ExtendsVideoBeginCodingInfoKHR for VideoEncodeRateControlInfoKHR<'_> {} impl<'a> VideoEncodeRateControlInfoKHR<'a> { #[inline] pub fn flags(mut self, flags: VideoEncodeRateControlFlagsKHR) -> Self { @@ -37825,6 +38120,19 @@ impl<'a> VideoEncodeRateControlInfoKHR<'a> { self.p_layers = layers.as_ptr(); self } + #[inline] + pub fn virtual_buffer_size_in_ms(mut self, virtual_buffer_size_in_ms: u32) -> Self { + self.virtual_buffer_size_in_ms = virtual_buffer_size_in_ms; + self + } + #[inline] + pub fn initial_virtual_buffer_size_in_ms( + mut self, + initial_virtual_buffer_size_in_ms: u32, + ) -> Self { + self.initial_virtual_buffer_size_in_ms = initial_virtual_buffer_size_in_ms; + self + } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -37837,8 +38145,6 @@ pub struct VideoEncodeRateControlLayerInfoKHR<'a> { pub max_bitrate: u64, pub frame_rate_numerator: u32, pub frame_rate_denominator: u32, - pub virtual_buffer_size_in_ms: u32, - pub initial_virtual_buffer_size_in_ms: u32, pub _marker: PhantomData<&'a ()>, } impl ::std::default::Default for VideoEncodeRateControlLayerInfoKHR<'_> { @@ -37851,8 +38157,6 @@ impl ::std::default::Default for VideoEncodeRateControlLayerInfoKHR<'_> { max_bitrate: u64::default(), frame_rate_numerator: u32::default(), frame_rate_denominator: u32::default(), - virtual_buffer_size_in_ms: u32::default(), - initial_virtual_buffer_size_in_ms: u32::default(), _marker: PhantomData, } } @@ -37860,7 +38164,6 @@ impl ::std::default::Default for VideoEncodeRateControlLayerInfoKHR<'_> { unsafe impl<'a> TaggedStructure for VideoEncodeRateControlLayerInfoKHR<'a> { const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR; } -unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeRateControlLayerInfoKHR<'_> {} pub unsafe trait ExtendsVideoEncodeRateControlLayerInfoKHR {} impl<'a> VideoEncodeRateControlLayerInfoKHR<'a> { #[inline] @@ -37883,19 +38186,6 @@ impl<'a> VideoEncodeRateControlLayerInfoKHR<'a> { self.frame_rate_denominator = frame_rate_denominator; self } - #[inline] - pub fn virtual_buffer_size_in_ms(mut self, virtual_buffer_size_in_ms: u32) -> Self { - self.virtual_buffer_size_in_ms = virtual_buffer_size_in_ms; - self - } - #[inline] - pub fn initial_virtual_buffer_size_in_ms( - mut self, - initial_virtual_buffer_size_in_ms: u32, - ) -> Self { - self.initial_virtual_buffer_size_in_ms = initial_virtual_buffer_size_in_ms; - 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."] @@ -37924,8 +38214,9 @@ pub struct VideoEncodeCapabilitiesKHR<'a> { pub flags: VideoEncodeCapabilityFlagsKHR, pub rate_control_modes: VideoEncodeRateControlModeFlagsKHR, pub max_rate_control_layers: u32, + pub max_bitrate: u64, pub max_quality_levels: u32, - pub input_image_data_fill_alignment: Extent2D, + pub encode_input_picture_granularity: Extent2D, pub supported_encode_feedback_flags: VideoEncodeFeedbackFlagsKHR, pub _marker: PhantomData<&'a ()>, } @@ -37938,8 +38229,9 @@ impl ::std::default::Default for VideoEncodeCapabilitiesKHR<'_> { flags: VideoEncodeCapabilityFlagsKHR::default(), rate_control_modes: VideoEncodeRateControlModeFlagsKHR::default(), max_rate_control_layers: u32::default(), + max_bitrate: u64::default(), max_quality_levels: u32::default(), - input_image_data_fill_alignment: Extent2D::default(), + encode_input_picture_granularity: Extent2D::default(), supported_encode_feedback_flags: VideoEncodeFeedbackFlagsKHR::default(), _marker: PhantomData, } @@ -37969,16 +38261,21 @@ impl<'a> VideoEncodeCapabilitiesKHR<'a> { self } #[inline] + pub fn max_bitrate(mut self, max_bitrate: u64) -> Self { + self.max_bitrate = max_bitrate; + self + } + #[inline] pub fn max_quality_levels(mut self, max_quality_levels: u32) -> Self { self.max_quality_levels = max_quality_levels; self } #[inline] - pub fn input_image_data_fill_alignment( + pub fn encode_input_picture_granularity( mut self, - input_image_data_fill_alignment: Extent2D, + encode_input_picture_granularity: Extent2D, ) -> Self { - self.input_image_data_fill_alignment = input_image_data_fill_alignment; + self.encode_input_picture_granularity = encode_input_picture_granularity; self } #[inline] @@ -37998,14 +38295,18 @@ pub struct VideoEncodeH264CapabilitiesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub flags: VideoEncodeH264CapabilityFlagsEXT, + pub max_level_idc: StdVideoH264LevelIdc, + pub max_slice_count: u32, pub max_p_picture_l0_reference_count: u32, pub max_b_picture_l0_reference_count: u32, pub max_l1_reference_count: u32, - pub motion_vectors_over_pic_boundaries_flag: Bool32, - pub max_bytes_per_pic_denom: u32, - pub max_bits_per_mb_denom: u32, - pub log2_max_mv_length_horizontal: u32, - pub log2_max_mv_length_vertical: u32, + pub max_temporal_layer_count: u32, + pub expect_dyadic_temporal_layer_pattern: Bool32, + pub min_qp: i32, + pub max_qp: i32, + pub prefers_gop_remaining_frames: Bool32, + pub requires_gop_remaining_frames: Bool32, + pub std_syntax_flags: VideoEncodeH264StdFlagsEXT, pub _marker: PhantomData<&'a ()>, } impl ::std::default::Default for VideoEncodeH264CapabilitiesEXT<'_> { @@ -38015,14 +38316,18 @@ impl ::std::default::Default for VideoEncodeH264CapabilitiesEXT<'_> { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null_mut(), flags: VideoEncodeH264CapabilityFlagsEXT::default(), + max_level_idc: StdVideoH264LevelIdc::default(), + max_slice_count: u32::default(), max_p_picture_l0_reference_count: u32::default(), max_b_picture_l0_reference_count: u32::default(), max_l1_reference_count: u32::default(), - motion_vectors_over_pic_boundaries_flag: Bool32::default(), - max_bytes_per_pic_denom: u32::default(), - max_bits_per_mb_denom: u32::default(), - log2_max_mv_length_horizontal: u32::default(), - log2_max_mv_length_vertical: u32::default(), + max_temporal_layer_count: u32::default(), + expect_dyadic_temporal_layer_pattern: Bool32::default(), + min_qp: i32::default(), + max_qp: i32::default(), + prefers_gop_remaining_frames: Bool32::default(), + requires_gop_remaining_frames: Bool32::default(), + std_syntax_flags: VideoEncodeH264StdFlagsEXT::default(), _marker: PhantomData, } } @@ -38038,6 +38343,16 @@ impl<'a> VideoEncodeH264CapabilitiesEXT<'a> { self } #[inline] + pub fn max_level_idc(mut self, max_level_idc: StdVideoH264LevelIdc) -> Self { + self.max_level_idc = max_level_idc; + self + } + #[inline] + pub fn max_slice_count(mut self, max_slice_count: u32) -> Self { + self.max_slice_count = max_slice_count; + self + } + #[inline] pub fn max_p_picture_l0_reference_count( mut self, max_p_picture_l0_reference_count: u32, @@ -38059,32 +38374,187 @@ impl<'a> VideoEncodeH264CapabilitiesEXT<'a> { self } #[inline] - pub fn motion_vectors_over_pic_boundaries_flag( + pub fn max_temporal_layer_count(mut self, max_temporal_layer_count: u32) -> Self { + self.max_temporal_layer_count = max_temporal_layer_count; + self + } + #[inline] + pub fn expect_dyadic_temporal_layer_pattern( + mut self, + expect_dyadic_temporal_layer_pattern: bool, + ) -> Self { + self.expect_dyadic_temporal_layer_pattern = expect_dyadic_temporal_layer_pattern.into(); + self + } + #[inline] + pub fn min_qp(mut self, min_qp: i32) -> Self { + self.min_qp = min_qp; + self + } + #[inline] + pub fn max_qp(mut self, max_qp: i32) -> Self { + self.max_qp = max_qp; + self + } + #[inline] + pub fn prefers_gop_remaining_frames(mut self, prefers_gop_remaining_frames: bool) -> Self { + self.prefers_gop_remaining_frames = prefers_gop_remaining_frames.into(); + self + } + #[inline] + pub fn requires_gop_remaining_frames(mut self, requires_gop_remaining_frames: bool) -> Self { + self.requires_gop_remaining_frames = requires_gop_remaining_frames.into(); + self + } + #[inline] + pub fn std_syntax_flags(mut self, std_syntax_flags: VideoEncodeH264StdFlagsEXT) -> Self { + self.std_syntax_flags = std_syntax_flags; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeH264QualityLevelPropertiesEXT<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub preferred_rate_control_flags: VideoEncodeH264RateControlFlagsEXT, + pub preferred_gop_frame_count: u32, + pub preferred_idr_period: u32, + pub preferred_consecutive_b_frame_count: u32, + pub preferred_temporal_layer_count: u32, + pub preferred_constant_qp: VideoEncodeH264QpEXT, + pub preferred_max_l0_reference_count: u32, + pub preferred_max_l1_reference_count: u32, + pub preferred_std_entropy_coding_mode_flag: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for VideoEncodeH264QualityLevelPropertiesEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + preferred_rate_control_flags: VideoEncodeH264RateControlFlagsEXT::default(), + preferred_gop_frame_count: u32::default(), + preferred_idr_period: u32::default(), + preferred_consecutive_b_frame_count: u32::default(), + preferred_temporal_layer_count: u32::default(), + preferred_constant_qp: VideoEncodeH264QpEXT::default(), + preferred_max_l0_reference_count: u32::default(), + preferred_max_l1_reference_count: u32::default(), + preferred_std_entropy_coding_mode_flag: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for VideoEncodeH264QualityLevelPropertiesEXT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_EXT; +} +unsafe impl ExtendsVideoEncodeQualityLevelPropertiesKHR + for VideoEncodeH264QualityLevelPropertiesEXT<'_> +{ +} +impl<'a> VideoEncodeH264QualityLevelPropertiesEXT<'a> { + #[inline] + pub fn preferred_rate_control_flags( + mut self, + preferred_rate_control_flags: VideoEncodeH264RateControlFlagsEXT, + ) -> Self { + self.preferred_rate_control_flags = preferred_rate_control_flags; + self + } + #[inline] + pub fn preferred_gop_frame_count(mut self, preferred_gop_frame_count: u32) -> Self { + self.preferred_gop_frame_count = preferred_gop_frame_count; + self + } + #[inline] + pub fn preferred_idr_period(mut self, preferred_idr_period: u32) -> Self { + self.preferred_idr_period = preferred_idr_period; + self + } + #[inline] + pub fn preferred_consecutive_b_frame_count( mut self, - motion_vectors_over_pic_boundaries_flag: bool, + preferred_consecutive_b_frame_count: u32, ) -> Self { - self.motion_vectors_over_pic_boundaries_flag = - motion_vectors_over_pic_boundaries_flag.into(); + self.preferred_consecutive_b_frame_count = preferred_consecutive_b_frame_count; self } #[inline] - pub fn max_bytes_per_pic_denom(mut self, max_bytes_per_pic_denom: u32) -> Self { - self.max_bytes_per_pic_denom = max_bytes_per_pic_denom; + pub fn preferred_temporal_layer_count(mut self, preferred_temporal_layer_count: u32) -> Self { + self.preferred_temporal_layer_count = preferred_temporal_layer_count; self } #[inline] - pub fn max_bits_per_mb_denom(mut self, max_bits_per_mb_denom: u32) -> Self { - self.max_bits_per_mb_denom = max_bits_per_mb_denom; + pub fn preferred_constant_qp(mut self, preferred_constant_qp: VideoEncodeH264QpEXT) -> Self { + self.preferred_constant_qp = preferred_constant_qp; self } #[inline] - pub fn log2_max_mv_length_horizontal(mut self, log2_max_mv_length_horizontal: u32) -> Self { - self.log2_max_mv_length_horizontal = log2_max_mv_length_horizontal; + pub fn preferred_max_l0_reference_count( + mut self, + preferred_max_l0_reference_count: u32, + ) -> Self { + self.preferred_max_l0_reference_count = preferred_max_l0_reference_count; self } #[inline] - pub fn log2_max_mv_length_vertical(mut self, log2_max_mv_length_vertical: u32) -> Self { - self.log2_max_mv_length_vertical = log2_max_mv_length_vertical; + pub fn preferred_max_l1_reference_count( + mut self, + preferred_max_l1_reference_count: u32, + ) -> Self { + self.preferred_max_l1_reference_count = preferred_max_l1_reference_count; + self + } + #[inline] + pub fn preferred_std_entropy_coding_mode_flag( + mut self, + preferred_std_entropy_coding_mode_flag: bool, + ) -> Self { + self.preferred_std_entropy_coding_mode_flag = preferred_std_entropy_coding_mode_flag.into(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeH264SessionCreateInfoEXT<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub use_max_level_idc: Bool32, + pub max_level_idc: StdVideoH264LevelIdc, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for VideoEncodeH264SessionCreateInfoEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + use_max_level_idc: Bool32::default(), + max_level_idc: StdVideoH264LevelIdc::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for VideoEncodeH264SessionCreateInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT; +} +unsafe impl ExtendsVideoSessionCreateInfoKHR for VideoEncodeH264SessionCreateInfoEXT<'_> {} +impl<'a> VideoEncodeH264SessionCreateInfoEXT<'a> { + #[inline] + pub fn use_max_level_idc(mut self, use_max_level_idc: bool) -> Self { + self.use_max_level_idc = use_max_level_idc.into(); + self + } + #[inline] + pub fn max_level_idc(mut self, max_level_idc: StdVideoH264LevelIdc) -> Self { + self.max_level_idc = max_level_idc; self } } @@ -38193,6 +38663,106 @@ impl<'a> VideoEncodeH264SessionParametersCreateInfoEXT<'a> { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeH264SessionParametersGetInfoEXT<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub write_std_sps: Bool32, + pub write_std_pps: Bool32, + pub std_sps_id: u32, + pub std_pps_id: u32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for VideoEncodeH264SessionParametersGetInfoEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + write_std_sps: Bool32::default(), + write_std_pps: Bool32::default(), + std_sps_id: u32::default(), + std_pps_id: u32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for VideoEncodeH264SessionParametersGetInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_EXT; +} +unsafe impl ExtendsVideoEncodeSessionParametersGetInfoKHR + for VideoEncodeH264SessionParametersGetInfoEXT<'_> +{ +} +impl<'a> VideoEncodeH264SessionParametersGetInfoEXT<'a> { + #[inline] + pub fn write_std_sps(mut self, write_std_sps: bool) -> Self { + self.write_std_sps = write_std_sps.into(); + self + } + #[inline] + pub fn write_std_pps(mut self, write_std_pps: bool) -> Self { + self.write_std_pps = write_std_pps.into(); + self + } + #[inline] + pub fn std_sps_id(mut self, std_sps_id: u32) -> Self { + self.std_sps_id = std_sps_id; + self + } + #[inline] + pub fn std_pps_id(mut self, std_pps_id: u32) -> Self { + self.std_pps_id = std_pps_id; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeH264SessionParametersFeedbackInfoEXT<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub has_std_sps_overrides: Bool32, + pub has_std_pps_overrides: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for VideoEncodeH264SessionParametersFeedbackInfoEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + has_std_sps_overrides: Bool32::default(), + has_std_pps_overrides: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for VideoEncodeH264SessionParametersFeedbackInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_EXT; +} +unsafe impl ExtendsVideoEncodeSessionParametersFeedbackInfoKHR + for VideoEncodeH264SessionParametersFeedbackInfoEXT<'_> +{ +} +impl<'a> VideoEncodeH264SessionParametersFeedbackInfoEXT<'a> { + #[inline] + pub fn has_std_sps_overrides(mut self, has_std_sps_overrides: bool) -> Self { + self.has_std_sps_overrides = has_std_sps_overrides.into(); + self + } + #[inline] + pub fn has_std_pps_overrides(mut self, has_std_pps_overrides: bool) -> Self { + self.has_std_pps_overrides = has_std_pps_overrides.into(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] #[doc = ""] pub struct VideoEncodeH264DpbSlotInfoEXT<'a> { pub s_type: StructureType, @@ -38228,43 +38798,35 @@ impl<'a> VideoEncodeH264DpbSlotInfoEXT<'a> { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct VideoEncodeH264VclFrameInfoEXT<'a> { +#[doc = ""] +pub struct VideoEncodeH264PictureInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, - pub p_std_reference_final_lists: *const StdVideoEncodeH264ReferenceListsInfo, pub nalu_slice_entry_count: u32, pub p_nalu_slice_entries: *const VideoEncodeH264NaluSliceInfoEXT<'a>, pub p_std_picture_info: *const StdVideoEncodeH264PictureInfo, + pub generate_prefix_nalu: Bool32, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoEncodeH264VclFrameInfoEXT<'_> { +impl ::std::default::Default for VideoEncodeH264PictureInfoEXT<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null(), - p_std_reference_final_lists: ::std::ptr::null(), nalu_slice_entry_count: u32::default(), p_nalu_slice_entries: ::std::ptr::null(), p_std_picture_info: ::std::ptr::null(), + generate_prefix_nalu: Bool32::default(), _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for VideoEncodeH264VclFrameInfoEXT<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT; +unsafe impl<'a> TaggedStructure for VideoEncodeH264PictureInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H264_PICTURE_INFO_EXT; } -unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH264VclFrameInfoEXT<'_> {} -impl<'a> VideoEncodeH264VclFrameInfoEXT<'a> { - #[inline] - pub fn std_reference_final_lists( - mut self, - std_reference_final_lists: &'a StdVideoEncodeH264ReferenceListsInfo, - ) -> Self { - self.p_std_reference_final_lists = std_reference_final_lists; - self - } +unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH264PictureInfoEXT<'_> {} +impl<'a> VideoEncodeH264PictureInfoEXT<'a> { #[inline] pub fn nalu_slice_entries( mut self, @@ -38279,6 +38841,11 @@ impl<'a> VideoEncodeH264VclFrameInfoEXT<'a> { self.p_std_picture_info = std_picture_info; self } + #[inline] + pub fn generate_prefix_nalu(mut self, generate_prefix_nalu: bool) -> Self { + self.generate_prefix_nalu = generate_prefix_nalu.into(); + self + } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -38320,8 +38887,7 @@ impl<'a> VideoEncodeH264ProfileInfoEXT<'a> { pub struct VideoEncodeH264NaluSliceInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, - pub mb_count: u32, - pub p_std_reference_final_lists: *const StdVideoEncodeH264ReferenceListsInfo, + pub constant_qp: i32, pub p_std_slice_header: *const StdVideoEncodeH264SliceHeader, pub _marker: PhantomData<&'a ()>, } @@ -38331,8 +38897,7 @@ impl ::std::default::Default for VideoEncodeH264NaluSliceInfoEXT<'_> { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null(), - mb_count: u32::default(), - p_std_reference_final_lists: ::std::ptr::null(), + constant_qp: i32::default(), p_std_slice_header: ::std::ptr::null(), _marker: PhantomData, } @@ -38343,16 +38908,8 @@ unsafe impl<'a> TaggedStructure for VideoEncodeH264NaluSliceInfoEXT<'a> { } impl<'a> VideoEncodeH264NaluSliceInfoEXT<'a> { #[inline] - pub fn mb_count(mut self, mb_count: u32) -> Self { - self.mb_count = mb_count; - self - } - #[inline] - pub fn std_reference_final_lists( - mut self, - std_reference_final_lists: &'a StdVideoEncodeH264ReferenceListsInfo, - ) -> Self { - self.p_std_reference_final_lists = std_reference_final_lists; + pub fn constant_qp(mut self, constant_qp: i32) -> Self { + self.constant_qp = constant_qp; self } #[inline] @@ -38368,10 +38925,10 @@ impl<'a> VideoEncodeH264NaluSliceInfoEXT<'a> { pub struct VideoEncodeH264RateControlInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, + pub flags: VideoEncodeH264RateControlFlagsEXT, pub gop_frame_count: u32, pub idr_period: u32, pub consecutive_b_frame_count: u32, - pub rate_control_structure: VideoEncodeH264RateControlStructureEXT, pub temporal_layer_count: u32, pub _marker: PhantomData<&'a ()>, } @@ -38381,10 +38938,10 @@ impl ::std::default::Default for VideoEncodeH264RateControlInfoEXT<'_> { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null(), + flags: VideoEncodeH264RateControlFlagsEXT::default(), gop_frame_count: u32::default(), idr_period: u32::default(), consecutive_b_frame_count: u32::default(), - rate_control_structure: VideoEncodeH264RateControlStructureEXT::default(), temporal_layer_count: u32::default(), _marker: PhantomData, } @@ -38394,7 +38951,13 @@ unsafe impl<'a> TaggedStructure for VideoEncodeH264RateControlInfoEXT<'a> { const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT; } unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeH264RateControlInfoEXT<'_> {} +unsafe impl ExtendsVideoBeginCodingInfoKHR for VideoEncodeH264RateControlInfoEXT<'_> {} impl<'a> VideoEncodeH264RateControlInfoEXT<'a> { + #[inline] + pub fn flags(mut self, flags: VideoEncodeH264RateControlFlagsEXT) -> Self { + self.flags = flags; + self + } #[inline] pub fn gop_frame_count(mut self, gop_frame_count: u32) -> Self { self.gop_frame_count = gop_frame_count; @@ -38411,14 +38974,6 @@ impl<'a> VideoEncodeH264RateControlInfoEXT<'a> { self } #[inline] - pub fn rate_control_structure( - mut self, - rate_control_structure: VideoEncodeH264RateControlStructureEXT, - ) -> Self { - self.rate_control_structure = rate_control_structure; - self - } - #[inline] pub fn temporal_layer_count(mut self, temporal_layer_count: u32) -> Self { self.temporal_layer_count = temporal_layer_count; self @@ -38479,13 +39034,64 @@ impl VideoEncodeH264FrameSizeEXT { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeH264GopRemainingFrameInfoEXT<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub use_gop_remaining_frames: Bool32, + pub gop_remaining_i: u32, + pub gop_remaining_p: u32, + pub gop_remaining_b: u32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for VideoEncodeH264GopRemainingFrameInfoEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + use_gop_remaining_frames: Bool32::default(), + gop_remaining_i: u32::default(), + gop_remaining_p: u32::default(), + gop_remaining_b: u32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for VideoEncodeH264GopRemainingFrameInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_EXT; +} +unsafe impl ExtendsVideoBeginCodingInfoKHR for VideoEncodeH264GopRemainingFrameInfoEXT<'_> {} +impl<'a> VideoEncodeH264GopRemainingFrameInfoEXT<'a> { + #[inline] + pub fn use_gop_remaining_frames(mut self, use_gop_remaining_frames: bool) -> Self { + self.use_gop_remaining_frames = use_gop_remaining_frames.into(); + self + } + #[inline] + pub fn gop_remaining_i(mut self, gop_remaining_i: u32) -> Self { + self.gop_remaining_i = gop_remaining_i; + self + } + #[inline] + pub fn gop_remaining_p(mut self, gop_remaining_p: u32) -> Self { + self.gop_remaining_p = gop_remaining_p; + self + } + #[inline] + pub fn gop_remaining_b(mut self, gop_remaining_b: u32) -> Self { + self.gop_remaining_b = gop_remaining_b; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] #[doc = ""] pub struct VideoEncodeH264RateControlLayerInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, - pub temporal_layer_id: u32, - pub use_initial_rc_qp: Bool32, - pub initial_rc_qp: VideoEncodeH264QpEXT, pub use_min_qp: Bool32, pub min_qp: VideoEncodeH264QpEXT, pub use_max_qp: Bool32, @@ -38500,9 +39106,6 @@ impl ::std::default::Default for VideoEncodeH264RateControlLayerInfoEXT<'_> { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null(), - temporal_layer_id: u32::default(), - use_initial_rc_qp: Bool32::default(), - initial_rc_qp: VideoEncodeH264QpEXT::default(), use_min_qp: Bool32::default(), min_qp: VideoEncodeH264QpEXT::default(), use_max_qp: Bool32::default(), @@ -38517,27 +39120,11 @@ unsafe impl<'a> TaggedStructure for VideoEncodeH264RateControlLayerInfoEXT<'a> { const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT; } -unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeH264RateControlLayerInfoEXT<'_> {} unsafe impl ExtendsVideoEncodeRateControlLayerInfoKHR for VideoEncodeH264RateControlLayerInfoEXT<'_> { } impl<'a> VideoEncodeH264RateControlLayerInfoEXT<'a> { - #[inline] - pub fn temporal_layer_id(mut self, temporal_layer_id: u32) -> Self { - self.temporal_layer_id = temporal_layer_id; - self - } - #[inline] - pub fn use_initial_rc_qp(mut self, use_initial_rc_qp: bool) -> Self { - self.use_initial_rc_qp = use_initial_rc_qp.into(); - self - } - #[inline] - pub fn initial_rc_qp(mut self, initial_rc_qp: VideoEncodeH264QpEXT) -> Self { - self.initial_rc_qp = initial_rc_qp; - self - } #[inline] pub fn use_min_qp(mut self, use_min_qp: bool) -> Self { self.use_min_qp = use_min_qp.into(); @@ -38577,23 +39164,21 @@ pub struct VideoEncodeH265CapabilitiesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub flags: VideoEncodeH265CapabilityFlagsEXT, + pub max_level_idc: StdVideoH265LevelIdc, + pub max_slice_segment_count: u32, + pub max_tiles: Extent2D, pub ctb_sizes: VideoEncodeH265CtbSizeFlagsEXT, pub transform_block_sizes: VideoEncodeH265TransformBlockSizeFlagsEXT, pub max_p_picture_l0_reference_count: u32, pub max_b_picture_l0_reference_count: u32, pub max_l1_reference_count: u32, - pub max_sub_layers_count: u32, - pub min_log2_min_luma_coding_block_size_minus3: u32, - pub max_log2_min_luma_coding_block_size_minus3: u32, - pub min_log2_min_luma_transform_block_size_minus2: u32, - pub max_log2_min_luma_transform_block_size_minus2: u32, - pub min_max_transform_hierarchy_depth_inter: u32, - pub max_max_transform_hierarchy_depth_inter: u32, - pub min_max_transform_hierarchy_depth_intra: u32, - pub max_max_transform_hierarchy_depth_intra: u32, - pub max_diff_cu_qp_delta_depth: u32, - pub min_max_num_merge_cand: u32, - pub max_max_num_merge_cand: u32, + pub max_sub_layer_count: u32, + pub expect_dyadic_temporal_sub_layer_pattern: Bool32, + pub min_qp: i32, + pub max_qp: i32, + pub prefers_gop_remaining_frames: Bool32, + pub requires_gop_remaining_frames: Bool32, + pub std_syntax_flags: VideoEncodeH265StdFlagsEXT, pub _marker: PhantomData<&'a ()>, } impl ::std::default::Default for VideoEncodeH265CapabilitiesEXT<'_> { @@ -38603,23 +39188,21 @@ impl ::std::default::Default for VideoEncodeH265CapabilitiesEXT<'_> { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null_mut(), flags: VideoEncodeH265CapabilityFlagsEXT::default(), + max_level_idc: StdVideoH265LevelIdc::default(), + max_slice_segment_count: u32::default(), + max_tiles: Extent2D::default(), ctb_sizes: VideoEncodeH265CtbSizeFlagsEXT::default(), transform_block_sizes: VideoEncodeH265TransformBlockSizeFlagsEXT::default(), max_p_picture_l0_reference_count: u32::default(), max_b_picture_l0_reference_count: u32::default(), max_l1_reference_count: u32::default(), - max_sub_layers_count: u32::default(), - min_log2_min_luma_coding_block_size_minus3: u32::default(), - max_log2_min_luma_coding_block_size_minus3: u32::default(), - min_log2_min_luma_transform_block_size_minus2: u32::default(), - max_log2_min_luma_transform_block_size_minus2: u32::default(), - min_max_transform_hierarchy_depth_inter: u32::default(), - max_max_transform_hierarchy_depth_inter: u32::default(), - min_max_transform_hierarchy_depth_intra: u32::default(), - max_max_transform_hierarchy_depth_intra: u32::default(), - max_diff_cu_qp_delta_depth: u32::default(), - min_max_num_merge_cand: u32::default(), - max_max_num_merge_cand: u32::default(), + max_sub_layer_count: u32::default(), + expect_dyadic_temporal_sub_layer_pattern: Bool32::default(), + min_qp: i32::default(), + max_qp: i32::default(), + prefers_gop_remaining_frames: Bool32::default(), + requires_gop_remaining_frames: Bool32::default(), + std_syntax_flags: VideoEncodeH265StdFlagsEXT::default(), _marker: PhantomData, } } @@ -38635,6 +39218,21 @@ impl<'a> VideoEncodeH265CapabilitiesEXT<'a> { self } #[inline] + pub fn max_level_idc(mut self, max_level_idc: StdVideoH265LevelIdc) -> Self { + self.max_level_idc = max_level_idc; + self + } + #[inline] + pub fn max_slice_segment_count(mut self, max_slice_segment_count: u32) -> Self { + self.max_slice_segment_count = max_slice_segment_count; + self + } + #[inline] + pub fn max_tiles(mut self, max_tiles: Extent2D) -> Self { + self.max_tiles = max_tiles; + self + } + #[inline] pub fn ctb_sizes(mut self, ctb_sizes: VideoEncodeH265CtbSizeFlagsEXT) -> Self { self.ctb_sizes = ctb_sizes; self @@ -38669,91 +39267,178 @@ impl<'a> VideoEncodeH265CapabilitiesEXT<'a> { self } #[inline] - pub fn max_sub_layers_count(mut self, max_sub_layers_count: u32) -> Self { - self.max_sub_layers_count = max_sub_layers_count; + pub fn max_sub_layer_count(mut self, max_sub_layer_count: u32) -> Self { + self.max_sub_layer_count = max_sub_layer_count; self } #[inline] - pub fn min_log2_min_luma_coding_block_size_minus3( + pub fn expect_dyadic_temporal_sub_layer_pattern( mut self, - min_log2_min_luma_coding_block_size_minus3: u32, + expect_dyadic_temporal_sub_layer_pattern: bool, ) -> Self { - self.min_log2_min_luma_coding_block_size_minus3 = - min_log2_min_luma_coding_block_size_minus3; + self.expect_dyadic_temporal_sub_layer_pattern = + expect_dyadic_temporal_sub_layer_pattern.into(); self } #[inline] - pub fn max_log2_min_luma_coding_block_size_minus3( - mut self, - max_log2_min_luma_coding_block_size_minus3: u32, - ) -> Self { - self.max_log2_min_luma_coding_block_size_minus3 = - max_log2_min_luma_coding_block_size_minus3; + pub fn min_qp(mut self, min_qp: i32) -> Self { + self.min_qp = min_qp; self } #[inline] - pub fn min_log2_min_luma_transform_block_size_minus2( - mut self, - min_log2_min_luma_transform_block_size_minus2: u32, - ) -> Self { - self.min_log2_min_luma_transform_block_size_minus2 = - min_log2_min_luma_transform_block_size_minus2; + pub fn max_qp(mut self, max_qp: i32) -> Self { + self.max_qp = max_qp; self } #[inline] - pub fn max_log2_min_luma_transform_block_size_minus2( - mut self, - max_log2_min_luma_transform_block_size_minus2: u32, - ) -> Self { - self.max_log2_min_luma_transform_block_size_minus2 = - max_log2_min_luma_transform_block_size_minus2; + pub fn prefers_gop_remaining_frames(mut self, prefers_gop_remaining_frames: bool) -> Self { + self.prefers_gop_remaining_frames = prefers_gop_remaining_frames.into(); self } #[inline] - pub fn min_max_transform_hierarchy_depth_inter( + pub fn requires_gop_remaining_frames(mut self, requires_gop_remaining_frames: bool) -> Self { + self.requires_gop_remaining_frames = requires_gop_remaining_frames.into(); + self + } + #[inline] + pub fn std_syntax_flags(mut self, std_syntax_flags: VideoEncodeH265StdFlagsEXT) -> Self { + self.std_syntax_flags = std_syntax_flags; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeH265QualityLevelPropertiesEXT<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub preferred_rate_control_flags: VideoEncodeH265RateControlFlagsEXT, + pub preferred_gop_frame_count: u32, + pub preferred_idr_period: u32, + pub preferred_consecutive_b_frame_count: u32, + pub preferred_sub_layer_count: u32, + pub preferred_constant_qp: VideoEncodeH265QpEXT, + pub preferred_max_l0_reference_count: u32, + pub preferred_max_l1_reference_count: u32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for VideoEncodeH265QualityLevelPropertiesEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + preferred_rate_control_flags: VideoEncodeH265RateControlFlagsEXT::default(), + preferred_gop_frame_count: u32::default(), + preferred_idr_period: u32::default(), + preferred_consecutive_b_frame_count: u32::default(), + preferred_sub_layer_count: u32::default(), + preferred_constant_qp: VideoEncodeH265QpEXT::default(), + preferred_max_l0_reference_count: u32::default(), + preferred_max_l1_reference_count: u32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for VideoEncodeH265QualityLevelPropertiesEXT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_EXT; +} +unsafe impl ExtendsVideoEncodeQualityLevelPropertiesKHR + for VideoEncodeH265QualityLevelPropertiesEXT<'_> +{ +} +impl<'a> VideoEncodeH265QualityLevelPropertiesEXT<'a> { + #[inline] + pub fn preferred_rate_control_flags( mut self, - min_max_transform_hierarchy_depth_inter: u32, + preferred_rate_control_flags: VideoEncodeH265RateControlFlagsEXT, ) -> Self { - self.min_max_transform_hierarchy_depth_inter = min_max_transform_hierarchy_depth_inter; + self.preferred_rate_control_flags = preferred_rate_control_flags; + self + } + #[inline] + pub fn preferred_gop_frame_count(mut self, preferred_gop_frame_count: u32) -> Self { + self.preferred_gop_frame_count = preferred_gop_frame_count; self } #[inline] - pub fn max_max_transform_hierarchy_depth_inter( + pub fn preferred_idr_period(mut self, preferred_idr_period: u32) -> Self { + self.preferred_idr_period = preferred_idr_period; + self + } + #[inline] + pub fn preferred_consecutive_b_frame_count( mut self, - max_max_transform_hierarchy_depth_inter: u32, + preferred_consecutive_b_frame_count: u32, ) -> Self { - self.max_max_transform_hierarchy_depth_inter = max_max_transform_hierarchy_depth_inter; + self.preferred_consecutive_b_frame_count = preferred_consecutive_b_frame_count; + self + } + #[inline] + pub fn preferred_sub_layer_count(mut self, preferred_sub_layer_count: u32) -> Self { + self.preferred_sub_layer_count = preferred_sub_layer_count; + self + } + #[inline] + pub fn preferred_constant_qp(mut self, preferred_constant_qp: VideoEncodeH265QpEXT) -> Self { + self.preferred_constant_qp = preferred_constant_qp; self } #[inline] - pub fn min_max_transform_hierarchy_depth_intra( + pub fn preferred_max_l0_reference_count( mut self, - min_max_transform_hierarchy_depth_intra: u32, + preferred_max_l0_reference_count: u32, ) -> Self { - self.min_max_transform_hierarchy_depth_intra = min_max_transform_hierarchy_depth_intra; + self.preferred_max_l0_reference_count = preferred_max_l0_reference_count; self } #[inline] - pub fn max_max_transform_hierarchy_depth_intra( + pub fn preferred_max_l1_reference_count( mut self, - max_max_transform_hierarchy_depth_intra: u32, + preferred_max_l1_reference_count: u32, ) -> Self { - self.max_max_transform_hierarchy_depth_intra = max_max_transform_hierarchy_depth_intra; + self.preferred_max_l1_reference_count = preferred_max_l1_reference_count; self } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeH265SessionCreateInfoEXT<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub use_max_level_idc: Bool32, + pub max_level_idc: StdVideoH265LevelIdc, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for VideoEncodeH265SessionCreateInfoEXT<'_> { #[inline] - pub fn max_diff_cu_qp_delta_depth(mut self, max_diff_cu_qp_delta_depth: u32) -> Self { - self.max_diff_cu_qp_delta_depth = max_diff_cu_qp_delta_depth; - self + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + use_max_level_idc: Bool32::default(), + max_level_idc: StdVideoH265LevelIdc::default(), + _marker: PhantomData, + } } +} +unsafe impl<'a> TaggedStructure for VideoEncodeH265SessionCreateInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT; +} +unsafe impl ExtendsVideoSessionCreateInfoKHR for VideoEncodeH265SessionCreateInfoEXT<'_> {} +impl<'a> VideoEncodeH265SessionCreateInfoEXT<'a> { #[inline] - pub fn min_max_num_merge_cand(mut self, min_max_num_merge_cand: u32) -> Self { - self.min_max_num_merge_cand = min_max_num_merge_cand; + pub fn use_max_level_idc(mut self, use_max_level_idc: bool) -> Self { + self.use_max_level_idc = use_max_level_idc.into(); self } #[inline] - pub fn max_max_num_merge_cand(mut self, max_max_num_merge_cand: u32) -> Self { - self.max_max_num_merge_cand = max_max_num_merge_cand; + pub fn max_level_idc(mut self, max_level_idc: StdVideoH265LevelIdc) -> Self { + self.max_level_idc = max_level_idc; self } } @@ -38879,23 +39564,142 @@ impl<'a> VideoEncodeH265SessionParametersCreateInfoEXT<'a> { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct VideoEncodeH265VclFrameInfoEXT<'a> { +#[doc = ""] +pub struct VideoEncodeH265SessionParametersGetInfoEXT<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub write_std_vps: Bool32, + pub write_std_sps: Bool32, + pub write_std_pps: Bool32, + pub std_vps_id: u32, + pub std_sps_id: u32, + pub std_pps_id: u32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for VideoEncodeH265SessionParametersGetInfoEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + write_std_vps: Bool32::default(), + write_std_sps: Bool32::default(), + write_std_pps: Bool32::default(), + std_vps_id: u32::default(), + std_sps_id: u32::default(), + std_pps_id: u32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for VideoEncodeH265SessionParametersGetInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_EXT; +} +unsafe impl ExtendsVideoEncodeSessionParametersGetInfoKHR + for VideoEncodeH265SessionParametersGetInfoEXT<'_> +{ +} +impl<'a> VideoEncodeH265SessionParametersGetInfoEXT<'a> { + #[inline] + pub fn write_std_vps(mut self, write_std_vps: bool) -> Self { + self.write_std_vps = write_std_vps.into(); + self + } + #[inline] + pub fn write_std_sps(mut self, write_std_sps: bool) -> Self { + self.write_std_sps = write_std_sps.into(); + self + } + #[inline] + pub fn write_std_pps(mut self, write_std_pps: bool) -> Self { + self.write_std_pps = write_std_pps.into(); + self + } + #[inline] + pub fn std_vps_id(mut self, std_vps_id: u32) -> Self { + self.std_vps_id = std_vps_id; + self + } + #[inline] + pub fn std_sps_id(mut self, std_sps_id: u32) -> Self { + self.std_sps_id = std_sps_id; + self + } + #[inline] + pub fn std_pps_id(mut self, std_pps_id: u32) -> Self { + self.std_pps_id = std_pps_id; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeH265SessionParametersFeedbackInfoEXT<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub has_std_vps_overrides: Bool32, + pub has_std_sps_overrides: Bool32, + pub has_std_pps_overrides: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for VideoEncodeH265SessionParametersFeedbackInfoEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + has_std_vps_overrides: Bool32::default(), + has_std_sps_overrides: Bool32::default(), + has_std_pps_overrides: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for VideoEncodeH265SessionParametersFeedbackInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_EXT; +} +unsafe impl ExtendsVideoEncodeSessionParametersFeedbackInfoKHR + for VideoEncodeH265SessionParametersFeedbackInfoEXT<'_> +{ +} +impl<'a> VideoEncodeH265SessionParametersFeedbackInfoEXT<'a> { + #[inline] + pub fn has_std_vps_overrides(mut self, has_std_vps_overrides: bool) -> Self { + self.has_std_vps_overrides = has_std_vps_overrides.into(); + self + } + #[inline] + pub fn has_std_sps_overrides(mut self, has_std_sps_overrides: bool) -> Self { + self.has_std_sps_overrides = has_std_sps_overrides.into(); + self + } + #[inline] + pub fn has_std_pps_overrides(mut self, has_std_pps_overrides: bool) -> Self { + self.has_std_pps_overrides = has_std_pps_overrides.into(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeH265PictureInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, - pub p_std_reference_final_lists: *const StdVideoEncodeH265ReferenceListsInfo, pub nalu_slice_segment_entry_count: u32, pub p_nalu_slice_segment_entries: *const VideoEncodeH265NaluSliceSegmentInfoEXT<'a>, pub p_std_picture_info: *const StdVideoEncodeH265PictureInfo, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoEncodeH265VclFrameInfoEXT<'_> { +impl ::std::default::Default for VideoEncodeH265PictureInfoEXT<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null(), - p_std_reference_final_lists: ::std::ptr::null(), nalu_slice_segment_entry_count: u32::default(), p_nalu_slice_segment_entries: ::std::ptr::null(), p_std_picture_info: ::std::ptr::null(), @@ -38903,19 +39707,11 @@ impl ::std::default::Default for VideoEncodeH265VclFrameInfoEXT<'_> { } } } -unsafe impl<'a> TaggedStructure for VideoEncodeH265VclFrameInfoEXT<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT; +unsafe impl<'a> TaggedStructure for VideoEncodeH265PictureInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H265_PICTURE_INFO_EXT; } -unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH265VclFrameInfoEXT<'_> {} -impl<'a> VideoEncodeH265VclFrameInfoEXT<'a> { - #[inline] - pub fn std_reference_final_lists( - mut self, - std_reference_final_lists: &'a StdVideoEncodeH265ReferenceListsInfo, - ) -> Self { - self.p_std_reference_final_lists = std_reference_final_lists; - self - } +unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH265PictureInfoEXT<'_> {} +impl<'a> VideoEncodeH265PictureInfoEXT<'a> { #[inline] pub fn nalu_slice_segment_entries( mut self, @@ -38938,8 +39734,7 @@ impl<'a> VideoEncodeH265VclFrameInfoEXT<'a> { pub struct VideoEncodeH265NaluSliceSegmentInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, - pub ctb_count: u32, - pub p_std_reference_final_lists: *const StdVideoEncodeH265ReferenceListsInfo, + pub constant_qp: i32, pub p_std_slice_segment_header: *const StdVideoEncodeH265SliceSegmentHeader, pub _marker: PhantomData<&'a ()>, } @@ -38949,8 +39744,7 @@ impl ::std::default::Default for VideoEncodeH265NaluSliceSegmentInfoEXT<'_> { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null(), - ctb_count: u32::default(), - p_std_reference_final_lists: ::std::ptr::null(), + constant_qp: i32::default(), p_std_slice_segment_header: ::std::ptr::null(), _marker: PhantomData, } @@ -38962,16 +39756,8 @@ unsafe impl<'a> TaggedStructure for VideoEncodeH265NaluSliceSegmentInfoEXT<'a> { } impl<'a> VideoEncodeH265NaluSliceSegmentInfoEXT<'a> { #[inline] - pub fn ctb_count(mut self, ctb_count: u32) -> Self { - self.ctb_count = ctb_count; - self - } - #[inline] - pub fn std_reference_final_lists( - mut self, - std_reference_final_lists: &'a StdVideoEncodeH265ReferenceListsInfo, - ) -> Self { - self.p_std_reference_final_lists = std_reference_final_lists; + pub fn constant_qp(mut self, constant_qp: i32) -> Self { + self.constant_qp = constant_qp; self } #[inline] @@ -38990,10 +39776,10 @@ impl<'a> VideoEncodeH265NaluSliceSegmentInfoEXT<'a> { pub struct VideoEncodeH265RateControlInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, + pub flags: VideoEncodeH265RateControlFlagsEXT, pub gop_frame_count: u32, pub idr_period: u32, pub consecutive_b_frame_count: u32, - pub rate_control_structure: VideoEncodeH265RateControlStructureEXT, pub sub_layer_count: u32, pub _marker: PhantomData<&'a ()>, } @@ -39003,10 +39789,10 @@ impl ::std::default::Default for VideoEncodeH265RateControlInfoEXT<'_> { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null(), + flags: VideoEncodeH265RateControlFlagsEXT::default(), gop_frame_count: u32::default(), idr_period: u32::default(), consecutive_b_frame_count: u32::default(), - rate_control_structure: VideoEncodeH265RateControlStructureEXT::default(), sub_layer_count: u32::default(), _marker: PhantomData, } @@ -39016,7 +39802,13 @@ unsafe impl<'a> TaggedStructure for VideoEncodeH265RateControlInfoEXT<'a> { const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT; } unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeH265RateControlInfoEXT<'_> {} +unsafe impl ExtendsVideoBeginCodingInfoKHR for VideoEncodeH265RateControlInfoEXT<'_> {} impl<'a> VideoEncodeH265RateControlInfoEXT<'a> { + #[inline] + pub fn flags(mut self, flags: VideoEncodeH265RateControlFlagsEXT) -> Self { + self.flags = flags; + self + } #[inline] pub fn gop_frame_count(mut self, gop_frame_count: u32) -> Self { self.gop_frame_count = gop_frame_count; @@ -39033,14 +39825,6 @@ impl<'a> VideoEncodeH265RateControlInfoEXT<'a> { self } #[inline] - pub fn rate_control_structure( - mut self, - rate_control_structure: VideoEncodeH265RateControlStructureEXT, - ) -> Self { - self.rate_control_structure = rate_control_structure; - self - } - #[inline] pub fn sub_layer_count(mut self, sub_layer_count: u32) -> Self { self.sub_layer_count = sub_layer_count; self @@ -39101,13 +39885,64 @@ impl VideoEncodeH265FrameSizeEXT { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeH265GopRemainingFrameInfoEXT<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub use_gop_remaining_frames: Bool32, + pub gop_remaining_i: u32, + pub gop_remaining_p: u32, + pub gop_remaining_b: u32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for VideoEncodeH265GopRemainingFrameInfoEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + use_gop_remaining_frames: Bool32::default(), + gop_remaining_i: u32::default(), + gop_remaining_p: u32::default(), + gop_remaining_b: u32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for VideoEncodeH265GopRemainingFrameInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_EXT; +} +unsafe impl ExtendsVideoBeginCodingInfoKHR for VideoEncodeH265GopRemainingFrameInfoEXT<'_> {} +impl<'a> VideoEncodeH265GopRemainingFrameInfoEXT<'a> { + #[inline] + pub fn use_gop_remaining_frames(mut self, use_gop_remaining_frames: bool) -> Self { + self.use_gop_remaining_frames = use_gop_remaining_frames.into(); + self + } + #[inline] + pub fn gop_remaining_i(mut self, gop_remaining_i: u32) -> Self { + self.gop_remaining_i = gop_remaining_i; + self + } + #[inline] + pub fn gop_remaining_p(mut self, gop_remaining_p: u32) -> Self { + self.gop_remaining_p = gop_remaining_p; + self + } + #[inline] + pub fn gop_remaining_b(mut self, gop_remaining_b: u32) -> Self { + self.gop_remaining_b = gop_remaining_b; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] #[doc = ""] pub struct VideoEncodeH265RateControlLayerInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, - pub temporal_id: u32, - pub use_initial_rc_qp: Bool32, - pub initial_rc_qp: VideoEncodeH265QpEXT, pub use_min_qp: Bool32, pub min_qp: VideoEncodeH265QpEXT, pub use_max_qp: Bool32, @@ -39122,9 +39957,6 @@ impl ::std::default::Default for VideoEncodeH265RateControlLayerInfoEXT<'_> { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null(), - temporal_id: u32::default(), - use_initial_rc_qp: Bool32::default(), - initial_rc_qp: VideoEncodeH265QpEXT::default(), use_min_qp: Bool32::default(), min_qp: VideoEncodeH265QpEXT::default(), use_max_qp: Bool32::default(), @@ -39139,27 +39971,11 @@ unsafe impl<'a> TaggedStructure for VideoEncodeH265RateControlLayerInfoEXT<'a> { const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT; } -unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeH265RateControlLayerInfoEXT<'_> {} unsafe impl ExtendsVideoEncodeRateControlLayerInfoKHR for VideoEncodeH265RateControlLayerInfoEXT<'_> { } impl<'a> VideoEncodeH265RateControlLayerInfoEXT<'a> { - #[inline] - pub fn temporal_id(mut self, temporal_id: u32) -> Self { - self.temporal_id = temporal_id; - self - } - #[inline] - pub fn use_initial_rc_qp(mut self, use_initial_rc_qp: bool) -> Self { - self.use_initial_rc_qp = use_initial_rc_qp.into(); - self - } - #[inline] - pub fn initial_rc_qp(mut self, initial_rc_qp: VideoEncodeH265QpEXT) -> Self { - self.initial_rc_qp = initial_rc_qp; - self - } #[inline] pub fn use_min_qp(mut self, use_min_qp: bool) -> Self { self.use_min_qp = use_min_qp.into(); @@ -44737,6 +45553,41 @@ impl<'a> PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD<'a> { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] +#[doc = ""] +pub struct ExternalMemoryAcquireUnmodifiedEXT<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub acquire_unmodified_memory: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for ExternalMemoryAcquireUnmodifiedEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + acquire_unmodified_memory: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for ExternalMemoryAcquireUnmodifiedEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT; +} +unsafe impl ExtendsBufferMemoryBarrier for ExternalMemoryAcquireUnmodifiedEXT<'_> {} +unsafe impl ExtendsBufferMemoryBarrier2 for ExternalMemoryAcquireUnmodifiedEXT<'_> {} +unsafe impl ExtendsImageMemoryBarrier for ExternalMemoryAcquireUnmodifiedEXT<'_> {} +unsafe impl ExtendsImageMemoryBarrier2 for ExternalMemoryAcquireUnmodifiedEXT<'_> {} +impl<'a> ExternalMemoryAcquireUnmodifiedEXT<'a> { + #[inline] + pub fn acquire_unmodified_memory(mut self, acquire_unmodified_memory: bool) -> Self { + self.acquire_unmodified_memory = acquire_unmodified_memory.into(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] #[doc = ""] pub struct ExportMetalObjectCreateInfoEXT<'a> { pub s_type: StructureType, @@ -46609,6 +47460,109 @@ impl<'a> PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT<'a> { } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DepthBiasInfoEXT<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub depth_bias_constant_factor: f32, + pub depth_bias_clamp: f32, + pub depth_bias_slope_factor: f32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for DepthBiasInfoEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + depth_bias_constant_factor: f32::default(), + depth_bias_clamp: f32::default(), + depth_bias_slope_factor: f32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for DepthBiasInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::DEPTH_BIAS_INFO_EXT; +} +pub unsafe trait ExtendsDepthBiasInfoEXT {} +impl<'a> DepthBiasInfoEXT<'a> { + #[inline] + pub fn depth_bias_constant_factor(mut self, depth_bias_constant_factor: f32) -> Self { + self.depth_bias_constant_factor = depth_bias_constant_factor; + self + } + #[inline] + pub fn depth_bias_clamp(mut self, depth_bias_clamp: f32) -> Self { + self.depth_bias_clamp = depth_bias_clamp; + self + } + #[inline] + pub fn depth_bias_slope_factor(mut self, depth_bias_slope_factor: f32) -> Self { + self.depth_bias_slope_factor = depth_bias_slope_factor; + 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 `x.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.p_next as _; + self.p_next = next_ptr; + } + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DepthBiasRepresentationInfoEXT<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub depth_bias_representation: DepthBiasRepresentationEXT, + pub depth_bias_exact: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for DepthBiasRepresentationInfoEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + depth_bias_representation: DepthBiasRepresentationEXT::default(), + depth_bias_exact: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for DepthBiasRepresentationInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::DEPTH_BIAS_REPRESENTATION_INFO_EXT; +} +unsafe impl ExtendsDepthBiasInfoEXT for DepthBiasRepresentationInfoEXT<'_> {} +unsafe impl ExtendsPipelineRasterizationStateCreateInfo for DepthBiasRepresentationInfoEXT<'_> {} +impl<'a> DepthBiasRepresentationInfoEXT<'a> { + #[inline] + pub fn depth_bias_representation( + mut self, + depth_bias_representation: DepthBiasRepresentationEXT, + ) -> Self { + self.depth_bias_representation = depth_bias_representation; + self + } + #[inline] + pub fn depth_bias_exact(mut self, depth_bias_exact: bool) -> Self { + self.depth_bias_exact = depth_bias_exact.into(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone, Default)] #[doc = ""] pub struct DecompressMemoryRegionNV { @@ -47137,6 +48091,65 @@ impl<'a> ReleaseSwapchainImagesInfoEXT<'a> { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceDepthBiasControlFeaturesEXT<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub depth_bias_control: Bool32, + pub least_representable_value_force_unorm_representation: Bool32, + pub float_representation: Bool32, + pub depth_bias_exact: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceDepthBiasControlFeaturesEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + depth_bias_control: Bool32::default(), + least_representable_value_force_unorm_representation: Bool32::default(), + float_representation: Bool32::default(), + depth_bias_exact: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceDepthBiasControlFeaturesEXT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT; +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDepthBiasControlFeaturesEXT<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDepthBiasControlFeaturesEXT<'_> {} +impl<'a> PhysicalDeviceDepthBiasControlFeaturesEXT<'a> { + #[inline] + pub fn depth_bias_control(mut self, depth_bias_control: bool) -> Self { + self.depth_bias_control = depth_bias_control.into(); + self + } + #[inline] + pub fn least_representable_value_force_unorm_representation( + mut self, + least_representable_value_force_unorm_representation: bool, + ) -> Self { + self.least_representable_value_force_unorm_representation = + least_representable_value_force_unorm_representation.into(); + self + } + #[inline] + pub fn float_representation(mut self, float_representation: bool) -> Self { + self.float_representation = float_representation.into(); + self + } + #[inline] + pub fn depth_bias_exact(mut self, depth_bias_exact: bool) -> Self { + self.depth_bias_exact = depth_bias_exact.into(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] #[doc = ""] pub struct PhysicalDeviceRayTracingInvocationReorderFeaturesNV<'a> { pub s_type: StructureType, @@ -47927,3 +48940,252 @@ impl<'a> PhysicalDeviceShaderTileImagePropertiesEXT<'a> { self } } +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImportScreenBufferInfoQNX<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub buffer: *mut _screen_buffer, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for ImportScreenBufferInfoQNX<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + buffer: ::std::ptr::null_mut(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for ImportScreenBufferInfoQNX<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_SCREEN_BUFFER_INFO_QNX; +} +unsafe impl ExtendsMemoryAllocateInfo for ImportScreenBufferInfoQNX<'_> {} +impl<'a> ImportScreenBufferInfoQNX<'a> { + #[inline] + pub fn buffer(mut self, buffer: &'a mut _screen_buffer) -> Self { + self.buffer = buffer; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ScreenBufferPropertiesQNX<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub allocation_size: DeviceSize, + pub memory_type_bits: u32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for ScreenBufferPropertiesQNX<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + allocation_size: DeviceSize::default(), + memory_type_bits: u32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for ScreenBufferPropertiesQNX<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::SCREEN_BUFFER_PROPERTIES_QNX; +} +pub unsafe trait ExtendsScreenBufferPropertiesQNX {} +impl<'a> ScreenBufferPropertiesQNX<'a> { + #[inline] + pub fn allocation_size(mut self, allocation_size: DeviceSize) -> Self { + self.allocation_size = allocation_size; + self + } + #[inline] + pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self { + self.memory_type_bits = memory_type_bits; + 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 `x.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 = <*mut T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; + } + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ScreenBufferFormatPropertiesQNX<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub format: Format, + pub external_format: u64, + pub screen_usage: u64, + pub format_features: FormatFeatureFlags, + pub sampler_ycbcr_conversion_components: ComponentMapping, + pub suggested_ycbcr_model: SamplerYcbcrModelConversion, + pub suggested_ycbcr_range: SamplerYcbcrRange, + pub suggested_x_chroma_offset: ChromaLocation, + pub suggested_y_chroma_offset: ChromaLocation, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for ScreenBufferFormatPropertiesQNX<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + format: Format::default(), + external_format: u64::default(), + screen_usage: u64::default(), + format_features: FormatFeatureFlags::default(), + sampler_ycbcr_conversion_components: ComponentMapping::default(), + suggested_ycbcr_model: SamplerYcbcrModelConversion::default(), + suggested_ycbcr_range: SamplerYcbcrRange::default(), + suggested_x_chroma_offset: ChromaLocation::default(), + suggested_y_chroma_offset: ChromaLocation::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for ScreenBufferFormatPropertiesQNX<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::SCREEN_BUFFER_FORMAT_PROPERTIES_QNX; +} +unsafe impl ExtendsScreenBufferPropertiesQNX for ScreenBufferFormatPropertiesQNX<'_> {} +impl<'a> ScreenBufferFormatPropertiesQNX<'a> { + #[inline] + pub fn format(mut self, format: Format) -> Self { + self.format = format; + self + } + #[inline] + pub fn external_format(mut self, external_format: u64) -> Self { + self.external_format = external_format; + self + } + #[inline] + pub fn screen_usage(mut self, screen_usage: u64) -> Self { + self.screen_usage = screen_usage; + self + } + #[inline] + pub fn format_features(mut self, format_features: FormatFeatureFlags) -> Self { + self.format_features = format_features; + self + } + #[inline] + pub fn sampler_ycbcr_conversion_components( + mut self, + sampler_ycbcr_conversion_components: ComponentMapping, + ) -> Self { + self.sampler_ycbcr_conversion_components = sampler_ycbcr_conversion_components; + self + } + #[inline] + pub fn suggested_ycbcr_model( + mut self, + suggested_ycbcr_model: SamplerYcbcrModelConversion, + ) -> Self { + self.suggested_ycbcr_model = suggested_ycbcr_model; + self + } + #[inline] + pub fn suggested_ycbcr_range(mut self, suggested_ycbcr_range: SamplerYcbcrRange) -> Self { + self.suggested_ycbcr_range = suggested_ycbcr_range; + self + } + #[inline] + pub fn suggested_x_chroma_offset(mut self, suggested_x_chroma_offset: ChromaLocation) -> Self { + self.suggested_x_chroma_offset = suggested_x_chroma_offset; + self + } + #[inline] + pub fn suggested_y_chroma_offset(mut self, suggested_y_chroma_offset: ChromaLocation) -> Self { + self.suggested_y_chroma_offset = suggested_y_chroma_offset; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExternalFormatQNX<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub external_format: u64, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for ExternalFormatQNX<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + external_format: u64::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for ExternalFormatQNX<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::EXTERNAL_FORMAT_QNX; +} +unsafe impl ExtendsImageCreateInfo for ExternalFormatQNX<'_> {} +unsafe impl ExtendsSamplerYcbcrConversionCreateInfo for ExternalFormatQNX<'_> {} +impl<'a> ExternalFormatQNX<'a> { + #[inline] + pub fn external_format(mut self, external_format: u64) -> Self { + self.external_format = external_format; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub screen_buffer_import: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + screen_buffer_import: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX; +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX<'_> {} +impl<'a> PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX<'a> { + #[inline] + pub fn screen_buffer_import(mut self, screen_buffer_import: bool) -> Self { + self.screen_buffer_import = screen_buffer_import.into(); + self + } +} diff --git a/ash/src/vk/enums.rs b/ash/src/vk/enums.rs index 620120971..f49b223ef 100644 --- a/ash/src/vk/enums.rs +++ b/ash/src/vk/enums.rs @@ -2530,44 +2530,6 @@ impl VideoEncodeTuningModeKHR { } #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] -#[doc = ""] -pub struct VideoEncodeH264RateControlStructureEXT(pub(crate) i32); -impl VideoEncodeH264RateControlStructureEXT { - #[inline] - pub const fn from_raw(x: i32) -> Self { - Self(x) - } - #[inline] - pub const fn as_raw(self) -> i32 { - self.0 - } -} -impl VideoEncodeH264RateControlStructureEXT { - pub const UNKNOWN: Self = Self(0); - pub const FLAT: Self = Self(1); - pub const DYADIC: Self = Self(2); -} -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(transparent)] -#[doc = ""] -pub struct VideoEncodeH265RateControlStructureEXT(pub(crate) i32); -impl VideoEncodeH265RateControlStructureEXT { - #[inline] - pub const fn from_raw(x: i32) -> Self { - Self(x) - } - #[inline] - pub const fn as_raw(self) -> i32 { - self.0 - } -} -impl VideoEncodeH265RateControlStructureEXT { - pub const UNKNOWN: Self = Self(0); - pub const FLAT: Self = Self(1); - pub const DYADIC: Self = Self(2); -} -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(transparent)] #[doc = ""] pub struct PipelineRobustnessBufferBehaviorEXT(pub(crate) i32); impl PipelineRobustnessBufferBehaviorEXT { @@ -2745,6 +2707,25 @@ impl OpacityMicromapSpecialIndexEXT { } #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] +#[doc = ""] +pub struct DepthBiasRepresentationEXT(pub(crate) i32); +impl DepthBiasRepresentationEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl DepthBiasRepresentationEXT { + pub const LEAST_REPRESENTABLE_VALUE_FORMAT: Self = Self(0); + pub const LEAST_REPRESENTABLE_VALUE_FORCE_UNORM: Self = Self(1); + pub const FLOAT: Self = Self(2); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] #[doc = ""] pub struct DeviceFaultAddressTypeEXT(pub(crate) i32); impl DeviceFaultAddressTypeEXT { diff --git a/ash/src/vk/extensions.rs b/ash/src/vk/extensions.rs index 1772dd094..a5734bed3 100644 --- a/ash/src/vk/extensions.rs +++ b/ash/src/vk/extensions.rs @@ -2752,7 +2752,7 @@ pub struct AmdShaderBallotFn; impl ExtVideoEncodeH264Fn { pub const NAME: &'static ::std::ffi::CStr = unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_video_encode_h264\0") }; - pub const SPEC_VERSION: u32 = 10u32; + pub const SPEC_VERSION: u32 = 11u32; } #[derive(Clone)] pub struct ExtVideoEncodeH264Fn; @@ -2761,12 +2761,17 @@ impl StructureType { pub const VIDEO_ENCODE_H264_CAPABILITIES_EXT: Self = Self(1_000_038_000); 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_PICTURE_INFO_EXT: Self = Self(1_000_038_003); pub const VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT: Self = Self(1_000_038_004); pub const VIDEO_ENCODE_H264_NALU_SLICE_INFO_EXT: Self = Self(1_000_038_005); + pub const VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_EXT: Self = Self(1_000_038_006); pub const VIDEO_ENCODE_H264_PROFILE_INFO_EXT: Self = Self(1_000_038_007); pub const VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT: Self = Self(1_000_038_008); pub const VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT: Self = Self(1_000_038_009); + pub const VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT: Self = Self(1_000_038_010); + pub const VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_EXT: Self = Self(1_000_038_011); + pub const VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_EXT: Self = Self(1_000_038_012); + pub const VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_EXT: Self = Self(1_000_038_013); } #[doc = "Generated from 'VK_EXT_video_encode_h264'"] impl VideoCodecOperationFlagsKHR { @@ -2775,7 +2780,7 @@ impl VideoCodecOperationFlagsKHR { impl ExtVideoEncodeH265Fn { pub const NAME: &'static ::std::ffi::CStr = unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_video_encode_h265\0") }; - pub const SPEC_VERSION: u32 = 10u32; + pub const SPEC_VERSION: u32 = 11u32; } #[derive(Clone)] pub struct ExtVideoEncodeH265Fn; @@ -2784,12 +2789,17 @@ impl StructureType { pub const VIDEO_ENCODE_H265_CAPABILITIES_EXT: Self = Self(1_000_039_000); 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_PICTURE_INFO_EXT: Self = Self(1_000_039_003); pub const VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT: Self = Self(1_000_039_004); pub const VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_EXT: Self = Self(1_000_039_005); + pub const VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_EXT: Self = Self(1_000_039_006); pub const VIDEO_ENCODE_H265_PROFILE_INFO_EXT: Self = Self(1_000_039_007); pub const VIDEO_ENCODE_H265_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); + pub const VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT: Self = Self(1_000_039_011); + pub const VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_EXT: Self = Self(1_000_039_012); + pub const VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_EXT: Self = Self(1_000_039_013); + pub const VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_EXT: Self = Self(1_000_039_014); } #[doc = "Generated from 'VK_EXT_video_encode_h265'"] impl VideoCodecOperationFlagsKHR { @@ -13195,6 +13205,56 @@ impl StructureType { Self(1_000_282_000); pub const RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM: Self = Self(1_000_282_001); } +impl ExtDepthBiasControlFn { + pub const NAME: &'static ::std::ffi::CStr = + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_depth_bias_control\0") }; + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetDepthBias2EXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_depth_bias_info: *const DepthBiasInfoEXT, +); +#[derive(Clone)] +pub struct ExtDepthBiasControlFn { + pub cmd_set_depth_bias2_ext: PFN_vkCmdSetDepthBias2EXT, +} +unsafe impl Send for ExtDepthBiasControlFn {} +unsafe impl Sync for ExtDepthBiasControlFn {} +impl ExtDepthBiasControlFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_set_depth_bias2_ext: unsafe { + unsafe extern "system" fn cmd_set_depth_bias2_ext( + _command_buffer: CommandBuffer, + _p_depth_bias_info: *const DepthBiasInfoEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_depth_bias2_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthBias2EXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_depth_bias2_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_depth_bias_control'"] +impl StructureType { + pub const PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT: Self = Self(1_000_283_000); + pub const DEPTH_BIAS_INFO_EXT: Self = Self(1_000_283_001); + pub const DEPTH_BIAS_REPRESENTATION_INFO_EXT: Self = Self(1_000_283_002); +} impl ExtDeviceMemoryReportFn { pub const NAME: &'static ::std::ffi::CStr = unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_device_memory_report\0") @@ -13540,15 +13600,33 @@ impl StructureType { impl KhrVideoEncodeQueueFn { pub const NAME: &'static ::std::ffi::CStr = unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_video_encode_queue\0") }; - pub const SPEC_VERSION: u32 = 8u32; + pub const SPEC_VERSION: u32 = 9u32; } #[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR = + unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_quality_level_info: *const PhysicalDeviceVideoEncodeQualityLevelInfoKHR, + p_quality_level_properties: *mut VideoEncodeQualityLevelPropertiesKHR, + ) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetEncodedVideoSessionParametersKHR = unsafe extern "system" fn( + device: Device, + p_video_session_parameters_info: *const VideoEncodeSessionParametersGetInfoKHR, + p_feedback_info: *mut VideoEncodeSessionParametersFeedbackInfoKHR, + p_data_size: *mut usize, + p_data: *mut c_void, +) -> Result; +#[allow(non_camel_case_types)] pub type PFN_vkCmdEncodeVideoKHR = unsafe extern "system" fn( command_buffer: CommandBuffer, p_encode_info: *const VideoEncodeInfoKHR, ); #[derive(Clone)] pub struct KhrVideoEncodeQueueFn { + pub get_physical_device_video_encode_quality_level_properties_khr: + PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR, + pub get_encoded_video_session_parameters_khr: PFN_vkGetEncodedVideoSessionParametersKHR, pub cmd_encode_video_khr: PFN_vkCmdEncodeVideoKHR, } unsafe impl Send for KhrVideoEncodeQueueFn {} @@ -13559,6 +13637,50 @@ impl KhrVideoEncodeQueueFn { F: FnMut(&::std::ffi::CStr) -> *const c_void, { Self { + get_physical_device_video_encode_quality_level_properties_khr: unsafe { + unsafe extern "system" fn get_physical_device_video_encode_quality_level_properties_khr( + _physical_device: PhysicalDevice, + _p_quality_level_info: *const PhysicalDeviceVideoEncodeQualityLevelInfoKHR, + _p_quality_level_properties: *mut VideoEncodeQualityLevelPropertiesKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_video_encode_quality_level_properties_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_video_encode_quality_level_properties_khr + } else { + ::std::mem::transmute(val) + } + }, + get_encoded_video_session_parameters_khr: unsafe { + unsafe extern "system" fn get_encoded_video_session_parameters_khr( + _device: Device, + _p_video_session_parameters_info: *const VideoEncodeSessionParametersGetInfoKHR, + _p_feedback_info: *mut VideoEncodeSessionParametersFeedbackInfoKHR, + _p_data_size: *mut usize, + _p_data: *mut c_void, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_encoded_video_session_parameters_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetEncodedVideoSessionParametersKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_encoded_video_session_parameters_khr + } else { + ::std::mem::transmute(val) + } + }, cmd_encode_video_khr: unsafe { unsafe extern "system" fn cmd_encode_video_khr( _command_buffer: CommandBuffer, @@ -13635,11 +13757,20 @@ impl StructureType { pub const VIDEO_ENCODE_CAPABILITIES_KHR: Self = Self(1_000_299_003); pub const VIDEO_ENCODE_USAGE_INFO_KHR: Self = Self(1_000_299_004); pub const QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR: Self = Self(1_000_299_005); + pub const PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR: Self = Self(1_000_299_006); + pub const VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR: Self = Self(1_000_299_007); + pub const VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR: Self = Self(1_000_299_008); + pub const VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR: Self = Self(1_000_299_009); + pub const VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR: Self = Self(1_000_299_010); } #[doc = "Generated from 'VK_KHR_video_encode_queue'"] impl VideoCodingControlFlagsKHR { pub const ENCODE_RATE_CONTROL: Self = Self(0b10); - pub const ENCODE_RATE_CONTROL_LAYER: Self = Self(0b100); + pub const ENCODE_QUALITY_LEVEL: Self = Self(0b100); +} +#[doc = "Generated from 'VK_KHR_video_encode_queue'"] +impl VideoSessionCreateFlagsKHR { + pub const ALLOW_ENCODE_PARAMETER_OPTIMIZATIONS: Self = Self(0b10); } impl NvDeviceDiagnosticsConfigFn { pub const NAME: &'static ::std::ffi::CStr = unsafe { @@ -17854,6 +17985,20 @@ impl StructureType { pub const PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM: Self = Self(1_000_440_001); pub const IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM: Self = Self(1_000_440_002); } +impl ExtExternalMemoryAcquireUnmodifiedFn { + pub const NAME: &'static ::std::ffi::CStr = unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_EXT_external_memory_acquire_unmodified\0", + ) + }; + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtExternalMemoryAcquireUnmodifiedFn; +#[doc = "Generated from 'VK_EXT_external_memory_acquire_unmodified'"] +impl StructureType { + pub const EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT: Self = Self(1_000_453_000); +} impl ExtExtendedDynamicState3Fn { pub const NAME: &'static ::std::ffi::CStr = unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extended_dynamic_state3\0") @@ -20571,3 +20716,64 @@ impl StructureType { pub const PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT: Self = Self(1_000_524_000); } +impl QnxExternalMemoryScreenBufferFn { + pub const NAME: &'static ::std::ffi::CStr = unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QNX_external_memory_screen_buffer\0") + }; + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetScreenBufferPropertiesQNX = unsafe extern "system" fn( + device: Device, + buffer: *const _screen_buffer, + p_properties: *mut ScreenBufferPropertiesQNX, +) -> Result; +#[derive(Clone)] +pub struct QnxExternalMemoryScreenBufferFn { + pub get_screen_buffer_properties_qnx: PFN_vkGetScreenBufferPropertiesQNX, +} +unsafe impl Send for QnxExternalMemoryScreenBufferFn {} +unsafe impl Sync for QnxExternalMemoryScreenBufferFn {} +impl QnxExternalMemoryScreenBufferFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_screen_buffer_properties_qnx: unsafe { + unsafe extern "system" fn get_screen_buffer_properties_qnx( + _device: Device, + _buffer: *const _screen_buffer, + _p_properties: *mut ScreenBufferPropertiesQNX, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_screen_buffer_properties_qnx) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetScreenBufferPropertiesQNX\0", + ); + let val = _f(cname); + if val.is_null() { + get_screen_buffer_properties_qnx + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_QNX_external_memory_screen_buffer'"] +impl ExternalMemoryHandleTypeFlags { + pub const SCREEN_BUFFER_QNX: Self = Self(0b100_0000_0000_0000); +} +#[doc = "Generated from 'VK_QNX_external_memory_screen_buffer'"] +impl StructureType { + pub const SCREEN_BUFFER_PROPERTIES_QNX: Self = Self(1_000_529_000); + pub const SCREEN_BUFFER_FORMAT_PROPERTIES_QNX: Self = Self(1_000_529_001); + pub const IMPORT_SCREEN_BUFFER_INFO_QNX: Self = Self(1_000_529_002); + pub const EXTERNAL_FORMAT_QNX: Self = Self(1_000_529_003); + pub const PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX: Self = + Self(1_000_529_004); +} diff --git a/ash/src/vk/native.rs b/ash/src/vk/native.rs index 03e0ad526..859237786 100644 --- a/ash/src/vk/native.rs +++ b/ash/src/vk/native.rs @@ -6801,9 +6801,8 @@ fn bindgen_test_layout_StdVideoEncodeH264WeightTable() { #[repr(align(4))] #[derive(Debug, Copy, Clone)] pub struct StdVideoEncodeH264SliceHeaderFlags { - pub _bitfield_align_1: [u8; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, - pub __bindgen_padding_0: [u8; 3usize], + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, } #[test] fn bindgen_test_layout_StdVideoEncodeH264SliceHeaderFlags() { @@ -6845,47 +6844,23 @@ impl StdVideoEncodeH264SliceHeaderFlags { } } #[inline] - pub fn no_output_of_prior_pics_flag(&self) -> u32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } - } - #[inline] - pub fn set_no_output_of_prior_pics_flag(&mut self, val: u32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub fn adaptive_ref_pic_marking_mode_flag(&self) -> u32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } - } - #[inline] - pub fn set_adaptive_ref_pic_marking_mode_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 no_prior_references_available_flag(&self) -> u32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + pub fn reserved(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } } #[inline] - pub fn set_no_prior_references_available_flag(&mut self, val: u32) { + pub fn set_reserved(&mut self, val: u32) { unsafe { let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 1u8, val as u64) + self._bitfield_1.set(2usize, 30u8, val as u64) } } #[inline] pub fn new_bitfield_1( direct_spatial_mv_pred_flag: u32, num_ref_idx_active_override_flag: u32, - no_output_of_prior_pics_flag: u32, - adaptive_ref_pic_marking_mode_flag: u32, - no_prior_references_available_flag: u32, - ) -> __BindgenBitfieldUnit<[u8; 1usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + reserved: u32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); __bindgen_bitfield_unit.set(0usize, 1u8, { let direct_spatial_mv_pred_flag: u32 = unsafe { ::std::mem::transmute(direct_spatial_mv_pred_flag) }; @@ -6896,20 +6871,9 @@ impl StdVideoEncodeH264SliceHeaderFlags { unsafe { ::std::mem::transmute(num_ref_idx_active_override_flag) }; num_ref_idx_active_override_flag as u64 }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let no_output_of_prior_pics_flag: u32 = - unsafe { ::std::mem::transmute(no_output_of_prior_pics_flag) }; - no_output_of_prior_pics_flag as u64 - }); - __bindgen_bitfield_unit.set(3usize, 1u8, { - let adaptive_ref_pic_marking_mode_flag: u32 = - unsafe { ::std::mem::transmute(adaptive_ref_pic_marking_mode_flag) }; - adaptive_ref_pic_marking_mode_flag as u64 - }); - __bindgen_bitfield_unit.set(4usize, 1u8, { - let no_prior_references_available_flag: u32 = - unsafe { ::std::mem::transmute(no_prior_references_available_flag) }; - no_prior_references_available_flag as u64 + __bindgen_bitfield_unit.set(2usize, 30u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 }); __bindgen_bitfield_unit } @@ -6918,9 +6882,8 @@ impl StdVideoEncodeH264SliceHeaderFlags { #[repr(align(4))] #[derive(Debug, Copy, Clone)] pub struct StdVideoEncodeH264PictureInfoFlags { - pub _bitfield_align_1: [u8; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, - pub __bindgen_padding_0: [u8; 3usize], + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, } #[test] fn bindgen_test_layout_StdVideoEncodeH264PictureInfoFlags() { @@ -6940,57 +6903,107 @@ fn bindgen_test_layout_StdVideoEncodeH264PictureInfoFlags() { } impl StdVideoEncodeH264PictureInfoFlags { #[inline] - pub fn idr_flag(&self) -> u32 { + pub fn IdrPicFlag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } } #[inline] - pub fn set_idr_flag(&mut self, val: u32) { + pub fn set_IdrPicFlag(&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_reference_flag(&self) -> u32 { + pub fn is_reference(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } } #[inline] - pub fn set_is_reference_flag(&mut self, val: u32) { + pub fn set_is_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 used_for_long_term_reference(&self) -> u32 { + pub fn no_output_of_prior_pics_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } } #[inline] - pub fn set_used_for_long_term_reference(&mut self, val: u32) { + pub fn set_no_output_of_prior_pics_flag(&mut self, val: u32) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(2usize, 1u8, val as u64) } } #[inline] + pub fn long_term_reference_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_long_term_reference_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 adaptive_ref_pic_marking_mode_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_adaptive_ref_pic_marking_mode_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 reserved(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 27u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 27u8, val as u64) + } + } + #[inline] pub fn new_bitfield_1( - idr_flag: u32, - is_reference_flag: u32, - used_for_long_term_reference: u32, - ) -> __BindgenBitfieldUnit<[u8; 1usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + IdrPicFlag: u32, + is_reference: u32, + no_output_of_prior_pics_flag: u32, + long_term_reference_flag: u32, + adaptive_ref_pic_marking_mode_flag: u32, + reserved: u32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); __bindgen_bitfield_unit.set(0usize, 1u8, { - let idr_flag: u32 = unsafe { ::std::mem::transmute(idr_flag) }; - idr_flag as u64 + let IdrPicFlag: u32 = unsafe { ::std::mem::transmute(IdrPicFlag) }; + IdrPicFlag as u64 }); __bindgen_bitfield_unit.set(1usize, 1u8, { - let is_reference_flag: u32 = unsafe { ::std::mem::transmute(is_reference_flag) }; - is_reference_flag as u64 + let is_reference: u32 = unsafe { ::std::mem::transmute(is_reference) }; + is_reference as u64 }); __bindgen_bitfield_unit.set(2usize, 1u8, { - let used_for_long_term_reference: u32 = - unsafe { ::std::mem::transmute(used_for_long_term_reference) }; - used_for_long_term_reference as u64 + let no_output_of_prior_pics_flag: u32 = + unsafe { ::std::mem::transmute(no_output_of_prior_pics_flag) }; + no_output_of_prior_pics_flag as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let long_term_reference_flag: u32 = + unsafe { ::std::mem::transmute(long_term_reference_flag) }; + long_term_reference_flag as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let adaptive_ref_pic_marking_mode_flag: u32 = + unsafe { ::std::mem::transmute(adaptive_ref_pic_marking_mode_flag) }; + adaptive_ref_pic_marking_mode_flag as u64 + }); + __bindgen_bitfield_unit.set(5usize, 27u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 }); __bindgen_bitfield_unit } @@ -6999,9 +7012,8 @@ impl StdVideoEncodeH264PictureInfoFlags { #[repr(align(4))] #[derive(Debug, Copy, Clone)] pub struct StdVideoEncodeH264ReferenceInfoFlags { - pub _bitfield_align_1: [u8; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, - pub __bindgen_padding_0: [u8; 3usize], + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, } #[test] fn bindgen_test_layout_StdVideoEncodeH264ReferenceInfoFlags() { @@ -7035,15 +7047,31 @@ impl StdVideoEncodeH264ReferenceInfoFlags { } } #[inline] + pub fn reserved(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] pub fn new_bitfield_1( used_for_long_term_reference: u32, - ) -> __BindgenBitfieldUnit<[u8; 1usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + reserved: u32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); __bindgen_bitfield_unit.set(0usize, 1u8, { 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, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); __bindgen_bitfield_unit } } @@ -7051,9 +7079,8 @@ impl StdVideoEncodeH264ReferenceInfoFlags { #[repr(align(4))] #[derive(Debug, Copy, Clone)] pub struct StdVideoEncodeH264ReferenceListsInfoFlags { - pub _bitfield_align_1: [u8; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, - pub __bindgen_padding_0: [u8; 3usize], + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, } #[test] fn bindgen_test_layout_StdVideoEncodeH264ReferenceListsInfoFlags() { @@ -7098,11 +7125,23 @@ impl StdVideoEncodeH264ReferenceListsInfoFlags { } } #[inline] + pub fn reserved(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 30u8, val as u64) + } + } + #[inline] pub fn new_bitfield_1( ref_pic_list_modification_flag_l0: u32, ref_pic_list_modification_flag_l1: u32, - ) -> __BindgenBitfieldUnit<[u8; 1usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + reserved: u32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); __bindgen_bitfield_unit.set(0usize, 1u8, { let ref_pic_list_modification_flag_l0: u32 = unsafe { ::std::mem::transmute(ref_pic_list_modification_flag_l0) }; @@ -7113,6 +7152,10 @@ impl StdVideoEncodeH264ReferenceListsInfoFlags { unsafe { ::std::mem::transmute(ref_pic_list_modification_flag_l1) }; ref_pic_list_modification_flag_l1 as u64 }); + __bindgen_bitfield_unit.set(2usize, 30u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); __bindgen_bitfield_unit } } @@ -7263,14 +7306,14 @@ fn bindgen_test_layout_StdVideoEncodeH264RefPicMarkingEntry() { #[derive(Debug, Copy, Clone)] pub struct StdVideoEncodeH264ReferenceListsInfo { pub flags: StdVideoEncodeH264ReferenceListsInfoFlags, - pub refPicList0EntryCount: u8, - pub refPicList1EntryCount: u8, + pub num_ref_idx_l0_active_minus1: u8, + pub num_ref_idx_l1_active_minus1: u8, + pub RefPicList0: [u8; 32usize], + pub RefPicList1: [u8; 32usize], pub refList0ModOpCount: u8, pub refList1ModOpCount: u8, pub refPicMarkingOpCount: u8, pub reserved1: [u8; 7usize], - pub pRefPicList0Entries: *const u8, - pub pRefPicList1Entries: *const u8, pub pRefList0ModOperations: *const StdVideoEncodeH264RefListModEntry, pub pRefList1ModOperations: *const StdVideoEncodeH264RefListModEntry, pub pRefPicMarkingOperations: *const StdVideoEncodeH264RefPicMarkingEntry, @@ -7282,7 +7325,7 @@ fn bindgen_test_layout_StdVideoEncodeH264ReferenceListsInfo() { let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), - 56usize, + 104usize, concat!( "Size of: ", stringify!(StdVideoEncodeH264ReferenceListsInfo) @@ -7307,88 +7350,92 @@ fn bindgen_test_layout_StdVideoEncodeH264ReferenceListsInfo() { ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).refPicList0EntryCount) as usize - ptr as usize }, + unsafe { + ::std::ptr::addr_of!((*ptr).num_ref_idx_l0_active_minus1) as usize - ptr as usize + }, 4usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH264ReferenceListsInfo), "::", - stringify!(refPicList0EntryCount) + stringify!(num_ref_idx_l0_active_minus1) ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).refPicList1EntryCount) as usize - ptr as usize }, + unsafe { + ::std::ptr::addr_of!((*ptr).num_ref_idx_l1_active_minus1) as usize - ptr as usize + }, 5usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH264ReferenceListsInfo), "::", - stringify!(refPicList1EntryCount) + stringify!(num_ref_idx_l1_active_minus1) ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).refList0ModOpCount) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).RefPicList0) as usize - ptr as usize }, 6usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH264ReferenceListsInfo), "::", - stringify!(refList0ModOpCount) + stringify!(RefPicList0) ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).refList1ModOpCount) as usize - ptr as usize }, - 7usize, + unsafe { ::std::ptr::addr_of!((*ptr).RefPicList1) as usize - ptr as usize }, + 38usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH264ReferenceListsInfo), "::", - stringify!(refList1ModOpCount) + stringify!(RefPicList1) ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).refPicMarkingOpCount) as usize - ptr as usize }, - 8usize, + unsafe { ::std::ptr::addr_of!((*ptr).refList0ModOpCount) as usize - ptr as usize }, + 70usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH264ReferenceListsInfo), "::", - stringify!(refPicMarkingOpCount) + stringify!(refList0ModOpCount) ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize }, - 9usize, + unsafe { ::std::ptr::addr_of!((*ptr).refList1ModOpCount) as usize - ptr as usize }, + 71usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH264ReferenceListsInfo), "::", - stringify!(reserved1) + stringify!(refList1ModOpCount) ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pRefPicList0Entries) as usize - ptr as usize }, - 16usize, + unsafe { ::std::ptr::addr_of!((*ptr).refPicMarkingOpCount) as usize - ptr as usize }, + 72usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH264ReferenceListsInfo), "::", - stringify!(pRefPicList0Entries) + stringify!(refPicMarkingOpCount) ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pRefPicList1Entries) as usize - ptr as usize }, - 24usize, + unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize }, + 73usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH264ReferenceListsInfo), "::", - stringify!(pRefPicList1Entries) + stringify!(reserved1) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).pRefList0ModOperations) as usize - ptr as usize }, - 32usize, + 80usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH264ReferenceListsInfo), @@ -7398,7 +7445,7 @@ fn bindgen_test_layout_StdVideoEncodeH264ReferenceListsInfo() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).pRefList1ModOperations) as usize - ptr as usize }, - 40usize, + 88usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH264ReferenceListsInfo), @@ -7408,7 +7455,7 @@ fn bindgen_test_layout_StdVideoEncodeH264ReferenceListsInfo() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).pRefPicMarkingOperations) as usize - ptr as usize }, - 48usize, + 96usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH264ReferenceListsInfo), @@ -7423,10 +7470,13 @@ pub struct StdVideoEncodeH264PictureInfo { pub flags: StdVideoEncodeH264PictureInfoFlags, pub seq_parameter_set_id: u8, pub pic_parameter_set_id: u8, - pub reserved1: u16, - pub pictureType: StdVideoH264PictureType, + pub idr_pic_id: u16, + pub primary_pic_type: StdVideoH264PictureType, pub frame_num: u32, pub PicOrderCnt: i32, + pub temporal_id: u8, + pub reserved1: [u8; 3usize], + pub pRefLists: *const StdVideoEncodeH264ReferenceListsInfo, } #[test] fn bindgen_test_layout_StdVideoEncodeH264PictureInfo() { @@ -7435,12 +7485,12 @@ fn bindgen_test_layout_StdVideoEncodeH264PictureInfo() { let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), - 20usize, + 32usize, concat!("Size of: ", stringify!(StdVideoEncodeH264PictureInfo)) ); assert_eq!( ::std::mem::align_of::(), - 4usize, + 8usize, concat!("Alignment of ", stringify!(StdVideoEncodeH264PictureInfo)) ); assert_eq!( @@ -7474,23 +7524,23 @@ fn bindgen_test_layout_StdVideoEncodeH264PictureInfo() { ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).idr_pic_id) as usize - ptr as usize }, 6usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH264PictureInfo), "::", - stringify!(reserved1) + stringify!(idr_pic_id) ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pictureType) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).primary_pic_type) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH264PictureInfo), "::", - stringify!(pictureType) + stringify!(primary_pic_type) ) ); assert_eq!( @@ -7513,16 +7563,47 @@ fn bindgen_test_layout_StdVideoEncodeH264PictureInfo() { stringify!(PicOrderCnt) ) ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).temporal_id) as usize - ptr as usize }, + 20usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264PictureInfo), + "::", + stringify!(temporal_id) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize }, + 21usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264PictureInfo), + "::", + stringify!(reserved1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pRefLists) as usize - ptr as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264PictureInfo), + "::", + stringify!(pRefLists) + ) + ); } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct StdVideoEncodeH264ReferenceInfo { pub flags: StdVideoEncodeH264ReferenceInfoFlags, - pub pictureType: StdVideoH264PictureType, + pub primary_pic_type: StdVideoH264PictureType, pub FrameNum: u32, pub PicOrderCnt: i32, pub long_term_pic_num: u16, pub long_term_frame_idx: u16, + pub temporal_id: u8, } #[test] fn bindgen_test_layout_StdVideoEncodeH264ReferenceInfo() { @@ -7531,7 +7612,7 @@ fn bindgen_test_layout_StdVideoEncodeH264ReferenceInfo() { let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), - 20usize, + 24usize, concat!("Size of: ", stringify!(StdVideoEncodeH264ReferenceInfo)) ); assert_eq!( @@ -7550,13 +7631,13 @@ fn bindgen_test_layout_StdVideoEncodeH264ReferenceInfo() { ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pictureType) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).primary_pic_type) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH264ReferenceInfo), "::", - stringify!(pictureType) + stringify!(primary_pic_type) ) ); assert_eq!( @@ -7599,6 +7680,16 @@ fn bindgen_test_layout_StdVideoEncodeH264ReferenceInfo() { stringify!(long_term_frame_idx) ) ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).temporal_id) as usize - ptr as usize }, + 20usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264ReferenceInfo), + "::", + stringify!(temporal_id) + ) + ); } #[repr(C)] #[derive(Debug, Copy, Clone)] @@ -7606,15 +7697,11 @@ pub struct StdVideoEncodeH264SliceHeader { pub flags: StdVideoEncodeH264SliceHeaderFlags, pub first_mb_in_slice: u32, pub slice_type: StdVideoH264SliceType, - pub idr_pic_id: u16, - pub num_ref_idx_l0_active_minus1: u8, - pub num_ref_idx_l1_active_minus1: u8, - pub cabac_init_idc: StdVideoH264CabacInitIdc, - pub disable_deblocking_filter_idc: StdVideoH264DisableDeblockingFilterIdc, pub slice_alpha_c0_offset_div2: i8, pub slice_beta_offset_div2: i8, pub reserved1: u16, - pub reserved2: u32, + pub cabac_init_idc: StdVideoH264CabacInitIdc, + pub disable_deblocking_filter_idc: StdVideoH264DisableDeblockingFilterIdc, pub pWeightTable: *const StdVideoEncodeH264WeightTable, } #[test] @@ -7624,7 +7711,7 @@ fn bindgen_test_layout_StdVideoEncodeH264SliceHeader() { let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), - 40usize, + 32usize, concat!("Size of: ", stringify!(StdVideoEncodeH264SliceHeader)) ); assert_eq!( @@ -7663,37 +7750,33 @@ fn bindgen_test_layout_StdVideoEncodeH264SliceHeader() { ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).idr_pic_id) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).slice_alpha_c0_offset_div2) as usize - ptr as usize }, 12usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH264SliceHeader), "::", - stringify!(idr_pic_id) + stringify!(slice_alpha_c0_offset_div2) ) ); assert_eq!( - unsafe { - ::std::ptr::addr_of!((*ptr).num_ref_idx_l0_active_minus1) as usize - ptr as usize - }, - 14usize, + unsafe { ::std::ptr::addr_of!((*ptr).slice_beta_offset_div2) as usize - ptr as usize }, + 13usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH264SliceHeader), "::", - stringify!(num_ref_idx_l0_active_minus1) + stringify!(slice_beta_offset_div2) ) ); assert_eq!( - unsafe { - ::std::ptr::addr_of!((*ptr).num_ref_idx_l1_active_minus1) as usize - ptr as usize - }, - 15usize, + unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize }, + 14usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH264SliceHeader), "::", - stringify!(num_ref_idx_l1_active_minus1) + stringify!(reserved1) ) ); assert_eq!( @@ -7718,49 +7801,9 @@ fn bindgen_test_layout_StdVideoEncodeH264SliceHeader() { stringify!(disable_deblocking_filter_idc) ) ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).slice_alpha_c0_offset_div2) as usize - ptr as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(StdVideoEncodeH264SliceHeader), - "::", - stringify!(slice_alpha_c0_offset_div2) - ) - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).slice_beta_offset_div2) as usize - ptr as usize }, - 25usize, - concat!( - "Offset of field: ", - stringify!(StdVideoEncodeH264SliceHeader), - "::", - stringify!(slice_beta_offset_div2) - ) - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize }, - 26usize, - concat!( - "Offset of field: ", - stringify!(StdVideoEncodeH264SliceHeader), - "::", - stringify!(reserved1) - ) - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).reserved2) as usize - ptr as usize }, - 28usize, - concat!( - "Offset of field: ", - stringify!(StdVideoEncodeH264SliceHeader), - "::", - stringify!(reserved2) - ) - ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).pWeightTable) as usize - ptr as usize }, - 32usize, + 24usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH264SliceHeader), @@ -7983,9 +8026,8 @@ fn bindgen_test_layout_StdVideoEncodeH265WeightTable() { #[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, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, } #[test] fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeaderFlags() { @@ -8019,178 +8061,141 @@ impl StdVideoEncodeH265SliceSegmentHeaderFlags { } } #[inline] - pub fn no_output_of_prior_pics_flag(&self) -> u32 { + pub fn dependent_slice_segment_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } } #[inline] - pub fn set_no_output_of_prior_pics_flag(&mut self, val: u32) { + pub fn set_dependent_slice_segment_flag(&mut self, val: u32) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(1usize, 1u8, val as u64) } } #[inline] - pub fn dependent_slice_segment_flag(&self) -> u32 { + pub fn slice_sao_luma_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } } #[inline] - pub fn set_dependent_slice_segment_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(2usize, 1u8, val as u64) } } #[inline] - pub fn pic_output_flag(&self) -> u32 { + pub fn slice_sao_chroma_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } } #[inline] - pub fn set_pic_output_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(3usize, 1u8, val as u64) } } #[inline] - pub fn short_term_ref_pic_set_sps_flag(&self) -> u32 { + pub fn num_ref_idx_active_override_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } } #[inline] - pub fn set_short_term_ref_pic_set_sps_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(4usize, 1u8, val as u64) } } #[inline] - pub fn slice_temporal_mvp_enable_flag(&self) -> u32 { + pub fn mvd_l1_zero_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } } #[inline] - pub fn set_slice_temporal_mvp_enable_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(5usize, 1u8, val as u64) } } #[inline] - pub fn slice_sao_luma_flag(&self) -> u32 { + pub fn cabac_init_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } } #[inline] - pub fn set_slice_sao_luma_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(6usize, 1u8, val as u64) } } #[inline] - pub fn slice_sao_chroma_flag(&self) -> u32 { + pub fn cu_chroma_qp_offset_enabled_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } } #[inline] - pub fn set_slice_sao_chroma_flag(&mut self, val: u32) { + pub fn set_cu_chroma_qp_offset_enabled_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 num_ref_idx_active_override_flag(&self) -> u32 { + pub fn deblocking_filter_override_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) } } #[inline] - pub fn set_num_ref_idx_active_override_flag(&mut self, val: u32) { + pub fn set_deblocking_filter_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 mvd_l1_zero_flag(&self) -> u32 { + pub fn slice_deblocking_filter_disabled_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) } } #[inline] - pub fn set_mvd_l1_zero_flag(&mut self, val: u32) { + pub fn set_slice_deblocking_filter_disabled_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 cabac_init_flag(&self) -> u32 { + pub fn collocated_from_l0_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) } } #[inline] - pub fn set_cabac_init_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(10usize, 1u8, val as u64) } } #[inline] - pub fn cu_chroma_qp_offset_enabled_flag(&self) -> u32 { + pub fn slice_loop_filter_across_slices_enabled_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) } } #[inline] - pub fn set_cu_chroma_qp_offset_enabled_flag(&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(11usize, 1u8, val as u64) } } #[inline] - pub fn deblocking_filter_override_flag(&self) -> u32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) } - } - #[inline] - pub fn set_deblocking_filter_override_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 slice_deblocking_filter_disabled_flag(&self) -> u32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) } - } - #[inline] - pub fn set_slice_deblocking_filter_disabled_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 collocated_from_l0_flag(&self) -> u32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) } - } - #[inline] - pub fn set_collocated_from_l0_flag(&mut self, val: u32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(14usize, 1u8, val as u64) - } - } - #[inline] - pub fn slice_loop_filter_across_slices_enabled_flag(&self) -> u32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) } + pub fn reserved(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 20u8) as u32) } } #[inline] - pub fn set_slice_loop_filter_across_slices_enabled_flag(&mut self, val: u32) { + pub fn set_reserved(&mut self, val: u32) { unsafe { let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(15usize, 1u8, val as u64) + self._bitfield_1.set(12usize, 20u8, 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, slice_sao_chroma_flag: u32, num_ref_idx_active_override_flag: u32, @@ -8201,330 +8206,175 @@ impl StdVideoEncodeH265SliceSegmentHeaderFlags { slice_deblocking_filter_disabled_flag: u32, collocated_from_l0_flag: u32, slice_loop_filter_across_slices_enabled_flag: u32, - ) -> __BindgenBitfieldUnit<[u8; 2usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default(); + reserved: u32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = 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) }; first_slice_segment_in_pic_flag as u64 }); __bindgen_bitfield_unit.set(1usize, 1u8, { - let no_output_of_prior_pics_flag: u32 = - unsafe { ::std::mem::transmute(no_output_of_prior_pics_flag) }; - no_output_of_prior_pics_flag as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { let dependent_slice_segment_flag: u32 = unsafe { ::std::mem::transmute(dependent_slice_segment_flag) }; 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(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(6usize, 1u8, { + __bindgen_bitfield_unit.set(2usize, 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(7usize, 1u8, { + __bindgen_bitfield_unit.set(3usize, 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(8usize, 1u8, { + __bindgen_bitfield_unit.set(4usize, 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(9usize, 1u8, { + __bindgen_bitfield_unit.set(5usize, 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(10usize, 1u8, { + __bindgen_bitfield_unit.set(6usize, 1u8, { let cabac_init_flag: u32 = unsafe { ::std::mem::transmute(cabac_init_flag) }; cabac_init_flag as u64 }); - __bindgen_bitfield_unit.set(11usize, 1u8, { + __bindgen_bitfield_unit.set(7usize, 1u8, { let cu_chroma_qp_offset_enabled_flag: u32 = unsafe { ::std::mem::transmute(cu_chroma_qp_offset_enabled_flag) }; cu_chroma_qp_offset_enabled_flag as u64 }); - __bindgen_bitfield_unit.set(12usize, 1u8, { + __bindgen_bitfield_unit.set(8usize, 1u8, { let deblocking_filter_override_flag: u32 = unsafe { ::std::mem::transmute(deblocking_filter_override_flag) }; deblocking_filter_override_flag as u64 }); - __bindgen_bitfield_unit.set(13usize, 1u8, { + __bindgen_bitfield_unit.set(9usize, 1u8, { let slice_deblocking_filter_disabled_flag: u32 = unsafe { ::std::mem::transmute(slice_deblocking_filter_disabled_flag) }; slice_deblocking_filter_disabled_flag as u64 }); - __bindgen_bitfield_unit.set(14usize, 1u8, { + __bindgen_bitfield_unit.set(10usize, 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(15usize, 1u8, { + __bindgen_bitfield_unit.set(11usize, 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(12usize, 20u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); __bindgen_bitfield_unit } } #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct StdVideoEncodeH265SliceSegmentLongTermRefPics { - pub num_long_term_sps: u8, - pub num_long_term_pics: u8, - pub lt_idx_sps: [u8; 32usize], - pub poc_lsb_lt: [u8; 16usize], - pub used_by_curr_pic_lt_flag: u16, - pub delta_poc_msb_present_flag: [u8; 48usize], - pub delta_poc_msb_cycle_lt: [u8; 48usize], +pub struct StdVideoEncodeH265SliceSegmentHeader { + pub flags: StdVideoEncodeH265SliceSegmentHeaderFlags, + pub slice_type: StdVideoH265SliceType, + pub slice_segment_address: u32, + pub collocated_ref_idx: u8, + pub MaxNumMergeCand: u8, + pub slice_cb_qp_offset: i8, + pub slice_cr_qp_offset: i8, + pub slice_beta_offset_div2: i8, + pub slice_tc_offset_div2: i8, + pub slice_act_y_qp_offset: i8, + pub slice_act_cb_qp_offset: i8, + pub slice_act_cr_qp_offset: i8, + pub reserved1: [u8; 3usize], + pub pWeightTable: *const StdVideoEncodeH265WeightTable, } #[test] -fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentLongTermRefPics() { - const UNINIT: ::std::mem::MaybeUninit = +fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeader() { + const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( - ::std::mem::size_of::(), - 148usize, + ::std::mem::size_of::(), + 32usize, concat!( "Size of: ", - stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics) + stringify!(StdVideoEncodeH265SliceSegmentHeader) ) ); assert_eq!( - ::std::mem::align_of::(), - 2usize, + ::std::mem::align_of::(), + 8usize, concat!( "Alignment of ", - stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics) + stringify!(StdVideoEncodeH265SliceSegmentHeader) ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).num_long_term_sps) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics), + stringify!(StdVideoEncodeH265SliceSegmentHeader), "::", - stringify!(num_long_term_sps) + stringify!(flags) ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).num_long_term_pics) as usize - ptr as usize }, - 1usize, + unsafe { ::std::ptr::addr_of!((*ptr).slice_type) as usize - ptr as usize }, + 4usize, concat!( "Offset of field: ", - stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics), + stringify!(StdVideoEncodeH265SliceSegmentHeader), "::", - stringify!(num_long_term_pics) + stringify!(slice_type) ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).lt_idx_sps) as usize - ptr as usize }, - 2usize, + unsafe { ::std::ptr::addr_of!((*ptr).slice_segment_address) as usize - ptr as usize }, + 8usize, concat!( "Offset of field: ", - stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics), + stringify!(StdVideoEncodeH265SliceSegmentHeader), "::", - stringify!(lt_idx_sps) + stringify!(slice_segment_address) ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).poc_lsb_lt) as usize - ptr as usize }, - 34usize, + unsafe { ::std::ptr::addr_of!((*ptr).collocated_ref_idx) as usize - ptr as usize }, + 12usize, concat!( "Offset of field: ", - stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics), + stringify!(StdVideoEncodeH265SliceSegmentHeader), "::", - stringify!(poc_lsb_lt) + stringify!(collocated_ref_idx) ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).used_by_curr_pic_lt_flag) as usize - ptr as usize }, - 50usize, + unsafe { ::std::ptr::addr_of!((*ptr).MaxNumMergeCand) as usize - ptr as usize }, + 13usize, concat!( "Offset of field: ", - stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics), + stringify!(StdVideoEncodeH265SliceSegmentHeader), "::", - stringify!(used_by_curr_pic_lt_flag) + stringify!(MaxNumMergeCand) ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).delta_poc_msb_present_flag) as usize - ptr as usize }, - 52usize, + unsafe { ::std::ptr::addr_of!((*ptr).slice_cb_qp_offset) as usize - ptr as usize }, + 14usize, concat!( "Offset of field: ", - stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics), - "::", - stringify!(delta_poc_msb_present_flag) - ) - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).delta_poc_msb_cycle_lt) as usize - ptr as usize }, - 100usize, - concat!( - "Offset of field: ", - stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics), - "::", - stringify!(delta_poc_msb_cycle_lt) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct StdVideoEncodeH265SliceSegmentHeader { - pub flags: StdVideoEncodeH265SliceSegmentHeaderFlags, - pub slice_type: StdVideoH265SliceType, - pub slice_segment_address: u32, - pub short_term_ref_pic_set_idx: u8, - pub collocated_ref_idx: u8, - pub num_ref_idx_l0_active_minus1: u8, - pub num_ref_idx_l1_active_minus1: u8, - pub MaxNumMergeCand: u8, - pub slice_cb_qp_offset: i8, - pub slice_cr_qp_offset: i8, - pub slice_beta_offset_div2: i8, - pub slice_tc_offset_div2: i8, - pub slice_act_y_qp_offset: i8, - pub slice_act_cb_qp_offset: i8, - pub slice_act_cr_qp_offset: i8, - pub pShortTermRefPicSet: *const StdVideoH265ShortTermRefPicSet, - pub pLongTermRefPics: *const StdVideoEncodeH265SliceSegmentLongTermRefPics, - pub pWeightTable: *const StdVideoEncodeH265WeightTable, -} -#[test] -fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeader() { - const UNINIT: ::std::mem::MaybeUninit = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::(), - 48usize, - concat!( - "Size of: ", - stringify!(StdVideoEncodeH265SliceSegmentHeader) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!( - "Alignment of ", - stringify!(StdVideoEncodeH265SliceSegmentHeader) - ) - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(StdVideoEncodeH265SliceSegmentHeader), - "::", - stringify!(flags) - ) - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).slice_type) as usize - ptr as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(StdVideoEncodeH265SliceSegmentHeader), - "::", - stringify!(slice_type) - ) - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).slice_segment_address) as usize - ptr as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(StdVideoEncodeH265SliceSegmentHeader), - "::", - stringify!(slice_segment_address) - ) - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).short_term_ref_pic_set_idx) as usize - ptr as usize }, - 12usize, - concat!( - "Offset of field: ", - stringify!(StdVideoEncodeH265SliceSegmentHeader), - "::", - stringify!(short_term_ref_pic_set_idx) - ) - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).collocated_ref_idx) as usize - ptr as usize }, - 13usize, - concat!( - "Offset of field: ", - stringify!(StdVideoEncodeH265SliceSegmentHeader), - "::", - stringify!(collocated_ref_idx) - ) - ); - assert_eq!( - unsafe { - ::std::ptr::addr_of!((*ptr).num_ref_idx_l0_active_minus1) as usize - ptr as usize - }, - 14usize, - concat!( - "Offset of field: ", - stringify!(StdVideoEncodeH265SliceSegmentHeader), - "::", - stringify!(num_ref_idx_l0_active_minus1) - ) - ); - assert_eq!( - unsafe { - ::std::ptr::addr_of!((*ptr).num_ref_idx_l1_active_minus1) as usize - ptr as usize - }, - 15usize, - concat!( - "Offset of field: ", - stringify!(StdVideoEncodeH265SliceSegmentHeader), - "::", - stringify!(num_ref_idx_l1_active_minus1) - ) - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).MaxNumMergeCand) as usize - ptr as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(StdVideoEncodeH265SliceSegmentHeader), - "::", - stringify!(MaxNumMergeCand) - ) - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).slice_cb_qp_offset) as usize - ptr as usize }, - 17usize, - concat!( - "Offset of field: ", - stringify!(StdVideoEncodeH265SliceSegmentHeader), + stringify!(StdVideoEncodeH265SliceSegmentHeader), "::", stringify!(slice_cb_qp_offset) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).slice_cr_qp_offset) as usize - ptr as usize }, - 18usize, + 15usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265SliceSegmentHeader), @@ -8534,7 +8384,7 @@ fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeader() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).slice_beta_offset_div2) as usize - ptr as usize }, - 19usize, + 16usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265SliceSegmentHeader), @@ -8544,7 +8394,7 @@ fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeader() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).slice_tc_offset_div2) as usize - ptr as usize }, - 20usize, + 17usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265SliceSegmentHeader), @@ -8554,7 +8404,7 @@ fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeader() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).slice_act_y_qp_offset) as usize - ptr as usize }, - 21usize, + 18usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265SliceSegmentHeader), @@ -8564,7 +8414,7 @@ fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeader() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).slice_act_cb_qp_offset) as usize - ptr as usize }, - 22usize, + 19usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265SliceSegmentHeader), @@ -8574,7 +8424,7 @@ fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeader() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).slice_act_cr_qp_offset) as usize - ptr as usize }, - 23usize, + 20usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265SliceSegmentHeader), @@ -8583,28 +8433,18 @@ fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeader() { ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pShortTermRefPicSet) as usize - ptr as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(StdVideoEncodeH265SliceSegmentHeader), - "::", - stringify!(pShortTermRefPicSet) - ) - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pLongTermRefPics) as usize - ptr as usize }, - 32usize, + unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize }, + 21usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265SliceSegmentHeader), "::", - stringify!(pLongTermRefPics) + stringify!(reserved1) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).pWeightTable) as usize - ptr as usize }, - 40usize, + 24usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265SliceSegmentHeader), @@ -8617,9 +8457,8 @@ fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeader() { #[repr(align(4))] #[derive(Debug, Copy, Clone)] pub struct StdVideoEncodeH265ReferenceListsInfoFlags { - pub _bitfield_align_1: [u8; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, - pub __bindgen_padding_0: [u8; 3usize], + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, } #[test] fn bindgen_test_layout_StdVideoEncodeH265ReferenceListsInfoFlags() { @@ -8664,11 +8503,23 @@ impl StdVideoEncodeH265ReferenceListsInfoFlags { } } #[inline] + pub fn reserved(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 30u8, val as u64) + } + } + #[inline] pub fn new_bitfield_1( ref_pic_list_modification_flag_l0: u32, ref_pic_list_modification_flag_l1: u32, - ) -> __BindgenBitfieldUnit<[u8; 1usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + reserved: u32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); __bindgen_bitfield_unit.set(0usize, 1u8, { let ref_pic_list_modification_flag_l0: u32 = unsafe { ::std::mem::transmute(ref_pic_list_modification_flag_l0) }; @@ -8679,6 +8530,10 @@ impl StdVideoEncodeH265ReferenceListsInfoFlags { unsafe { ::std::mem::transmute(ref_pic_list_modification_flag_l1) }; ref_pic_list_modification_flag_l1 as u64 }); + __bindgen_bitfield_unit.set(2usize, 30u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); __bindgen_bitfield_unit } } @@ -8688,11 +8543,10 @@ pub struct StdVideoEncodeH265ReferenceListsInfo { pub flags: StdVideoEncodeH265ReferenceListsInfoFlags, pub num_ref_idx_l0_active_minus1: u8, pub num_ref_idx_l1_active_minus1: u8, - pub reserved1: u16, - pub pRefPicList0Entries: *const u8, - pub pRefPicList1Entries: *const u8, - pub pRefList0Modifications: *const u8, - pub pRefList1Modifications: *const u8, + pub RefPicList0: [u8; 15usize], + pub RefPicList1: [u8; 15usize], + pub list_entry_l0: [u8; 15usize], + pub list_entry_l1: [u8; 15usize], } #[test] fn bindgen_test_layout_StdVideoEncodeH265ReferenceListsInfo() { @@ -8701,7 +8555,7 @@ fn bindgen_test_layout_StdVideoEncodeH265ReferenceListsInfo() { let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), - 40usize, + 68usize, concat!( "Size of: ", stringify!(StdVideoEncodeH265ReferenceListsInfo) @@ -8709,7 +8563,7 @@ fn bindgen_test_layout_StdVideoEncodeH265ReferenceListsInfo() { ); assert_eq!( ::std::mem::align_of::(), - 8usize, + 4usize, concat!( "Alignment of ", stringify!(StdVideoEncodeH265ReferenceListsInfo) @@ -8750,53 +8604,43 @@ fn bindgen_test_layout_StdVideoEncodeH265ReferenceListsInfo() { ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).RefPicList0) as usize - ptr as usize }, 6usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265ReferenceListsInfo), "::", - stringify!(reserved1) + stringify!(RefPicList0) ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pRefPicList0Entries) as usize - ptr as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(StdVideoEncodeH265ReferenceListsInfo), - "::", - stringify!(pRefPicList0Entries) - ) - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pRefPicList1Entries) as usize - ptr as usize }, - 16usize, + unsafe { ::std::ptr::addr_of!((*ptr).RefPicList1) as usize - ptr as usize }, + 21usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265ReferenceListsInfo), "::", - stringify!(pRefPicList1Entries) + stringify!(RefPicList1) ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pRefList0Modifications) as usize - ptr as usize }, - 24usize, + unsafe { ::std::ptr::addr_of!((*ptr).list_entry_l0) as usize - ptr as usize }, + 36usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265ReferenceListsInfo), "::", - stringify!(pRefList0Modifications) + stringify!(list_entry_l0) ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pRefList1Modifications) as usize - ptr as usize }, - 32usize, + unsafe { ::std::ptr::addr_of!((*ptr).list_entry_l1) as usize - ptr as usize }, + 51usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265ReferenceListsInfo), "::", - stringify!(pRefList1Modifications) + stringify!(list_entry_l1) ) ); } @@ -8804,9 +8648,8 @@ fn bindgen_test_layout_StdVideoEncodeH265ReferenceListsInfo() { #[repr(align(4))] #[derive(Debug, Copy, Clone)] pub struct StdVideoEncodeH265PictureInfoFlags { - pub _bitfield_align_1: [u8; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, - pub __bindgen_padding_0: [u8; 3usize], + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, } #[test] fn bindgen_test_layout_StdVideoEncodeH265PictureInfoFlags() { @@ -8826,11 +8669,11 @@ fn bindgen_test_layout_StdVideoEncodeH265PictureInfoFlags() { } impl StdVideoEncodeH265PictureInfoFlags { #[inline] - pub fn is_reference_flag(&self) -> u32 { + pub fn is_reference(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } } #[inline] - pub fn set_is_reference_flag(&mut self, val: u32) { + pub fn set_is_reference(&mut self, val: u32) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(0usize, 1u8, val as u64) @@ -8848,11 +8691,11 @@ impl StdVideoEncodeH265PictureInfoFlags { } } #[inline] - pub fn long_term_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_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) @@ -8881,25 +8724,86 @@ impl StdVideoEncodeH265PictureInfoFlags { } } #[inline] + pub fn pic_output_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } + } + #[inline] + pub fn set_pic_output_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 no_output_of_prior_pics_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } + } + #[inline] + pub fn set_no_output_of_prior_pics_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 short_term_ref_pic_set_sps_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } + } + #[inline] + 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(7usize, 1u8, val as u64) + } + } + #[inline] + pub fn slice_temporal_mvp_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) } + } + #[inline] + pub fn set_slice_temporal_mvp_enabled_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 reserved(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 23u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(9usize, 23u8, val as u64) + } + } + #[inline] pub fn new_bitfield_1( - is_reference_flag: u32, + is_reference: u32, IrapPicFlag: u32, - long_term_flag: u32, + used_for_long_term_reference: u32, discardable_flag: u32, cross_layer_bla_flag: u32, - ) -> __BindgenBitfieldUnit<[u8; 1usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + pic_output_flag: u32, + no_output_of_prior_pics_flag: u32, + short_term_ref_pic_set_sps_flag: u32, + slice_temporal_mvp_enabled_flag: u32, + reserved: u32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); __bindgen_bitfield_unit.set(0usize, 1u8, { - let is_reference_flag: u32 = unsafe { ::std::mem::transmute(is_reference_flag) }; - is_reference_flag as u64 + let is_reference: u32 = unsafe { ::std::mem::transmute(is_reference) }; + is_reference as u64 }); __bindgen_bitfield_unit.set(1usize, 1u8, { let IrapPicFlag: u32 = unsafe { ::std::mem::transmute(IrapPicFlag) }; IrapPicFlag as u64 }); __bindgen_bitfield_unit.set(2usize, 1u8, { - let long_term_flag: u32 = unsafe { ::std::mem::transmute(long_term_flag) }; - long_term_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.set(3usize, 1u8, { let discardable_flag: u32 = unsafe { ::std::mem::transmute(discardable_flag) }; @@ -8909,19 +8813,150 @@ impl StdVideoEncodeH265PictureInfoFlags { let cross_layer_bla_flag: u32 = unsafe { ::std::mem::transmute(cross_layer_bla_flag) }; cross_layer_bla_flag as u64 }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let pic_output_flag: u32 = unsafe { ::std::mem::transmute(pic_output_flag) }; + pic_output_flag as u64 + }); + __bindgen_bitfield_unit.set(6usize, 1u8, { + let no_output_of_prior_pics_flag: u32 = + unsafe { ::std::mem::transmute(no_output_of_prior_pics_flag) }; + no_output_of_prior_pics_flag as u64 + }); + __bindgen_bitfield_unit.set(7usize, 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(8usize, 1u8, { + let slice_temporal_mvp_enabled_flag: u32 = + unsafe { ::std::mem::transmute(slice_temporal_mvp_enabled_flag) }; + slice_temporal_mvp_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(9usize, 23u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); __bindgen_bitfield_unit } } #[repr(C)] #[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH265SliceSegmentLongTermRefPics { + pub num_long_term_sps: u8, + pub num_long_term_pics: u8, + pub lt_idx_sps: [u8; 32usize], + pub poc_lsb_lt: [u8; 16usize], + pub used_by_curr_pic_lt_flag: u16, + pub delta_poc_msb_present_flag: [u8; 48usize], + pub delta_poc_msb_cycle_lt: [u8; 48usize], +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentLongTermRefPics() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 148usize, + concat!( + "Size of: ", + stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 2usize, + concat!( + "Alignment of ", + stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).num_long_term_sps) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics), + "::", + stringify!(num_long_term_sps) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).num_long_term_pics) as usize - ptr as usize }, + 1usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics), + "::", + stringify!(num_long_term_pics) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).lt_idx_sps) as usize - ptr as usize }, + 2usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics), + "::", + stringify!(lt_idx_sps) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).poc_lsb_lt) as usize - ptr as usize }, + 34usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics), + "::", + stringify!(poc_lsb_lt) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).used_by_curr_pic_lt_flag) as usize - ptr as usize }, + 50usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics), + "::", + stringify!(used_by_curr_pic_lt_flag) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).delta_poc_msb_present_flag) as usize - ptr as usize }, + 52usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics), + "::", + stringify!(delta_poc_msb_present_flag) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).delta_poc_msb_cycle_lt) as usize - ptr as usize }, + 100usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics), + "::", + stringify!(delta_poc_msb_cycle_lt) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] pub struct StdVideoEncodeH265PictureInfo { pub flags: StdVideoEncodeH265PictureInfoFlags, - pub PictureType: StdVideoH265PictureType, + pub pic_type: StdVideoH265PictureType, pub sps_video_parameter_set_id: u8, pub pps_seq_parameter_set_id: u8, pub pps_pic_parameter_set_id: u8, - pub TemporalId: u8, + pub short_term_ref_pic_set_idx: u8, pub PicOrderCntVal: i32, + pub TemporalId: u8, + pub reserved1: [u8; 7usize], + pub pRefLists: *const StdVideoEncodeH265ReferenceListsInfo, + pub pShortTermRefPicSet: *const StdVideoH265ShortTermRefPicSet, + pub pLongTermRefPics: *const StdVideoEncodeH265SliceSegmentLongTermRefPics, } #[test] fn bindgen_test_layout_StdVideoEncodeH265PictureInfo() { @@ -8930,12 +8965,12 @@ fn bindgen_test_layout_StdVideoEncodeH265PictureInfo() { let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), - 16usize, + 48usize, concat!("Size of: ", stringify!(StdVideoEncodeH265PictureInfo)) ); assert_eq!( ::std::mem::align_of::(), - 4usize, + 8usize, concat!("Alignment of ", stringify!(StdVideoEncodeH265PictureInfo)) ); assert_eq!( @@ -8949,13 +8984,13 @@ fn bindgen_test_layout_StdVideoEncodeH265PictureInfo() { ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).PictureType) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).pic_type) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265PictureInfo), "::", - stringify!(PictureType) + stringify!(pic_type) ) ); assert_eq!( @@ -8989,13 +9024,13 @@ fn bindgen_test_layout_StdVideoEncodeH265PictureInfo() { ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).TemporalId) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).short_term_ref_pic_set_idx) as usize - ptr as usize }, 11usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265PictureInfo), "::", - stringify!(TemporalId) + stringify!(short_term_ref_pic_set_idx) ) ); assert_eq!( @@ -9008,14 +9043,63 @@ fn bindgen_test_layout_StdVideoEncodeH265PictureInfo() { stringify!(PicOrderCntVal) ) ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).TemporalId) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265PictureInfo), + "::", + stringify!(TemporalId) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize }, + 17usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265PictureInfo), + "::", + stringify!(reserved1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pRefLists) as usize - ptr as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265PictureInfo), + "::", + stringify!(pRefLists) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pShortTermRefPicSet) as usize - ptr as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265PictureInfo), + "::", + stringify!(pShortTermRefPicSet) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pLongTermRefPics) as usize - ptr as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265PictureInfo), + "::", + stringify!(pLongTermRefPics) + ) + ); } #[repr(C)] #[repr(align(4))] #[derive(Debug, Copy, Clone)] pub struct StdVideoEncodeH265ReferenceInfoFlags { - pub _bitfield_align_1: [u8; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, - pub __bindgen_padding_0: [u8; 3usize], + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, } #[test] fn bindgen_test_layout_StdVideoEncodeH265ReferenceInfoFlags() { @@ -9060,11 +9144,23 @@ impl StdVideoEncodeH265ReferenceInfoFlags { } } #[inline] + pub fn reserved(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 30u8, val as u64) + } + } + #[inline] pub fn new_bitfield_1( used_for_long_term_reference: u32, unused_for_reference: u32, - ) -> __BindgenBitfieldUnit<[u8; 1usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + reserved: u32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); __bindgen_bitfield_unit.set(0usize, 1u8, { let used_for_long_term_reference: u32 = unsafe { ::std::mem::transmute(used_for_long_term_reference) }; @@ -9074,6 +9170,10 @@ impl StdVideoEncodeH265ReferenceInfoFlags { let unused_for_reference: u32 = unsafe { ::std::mem::transmute(unused_for_reference) }; unused_for_reference as u64 }); + __bindgen_bitfield_unit.set(2usize, 30u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); __bindgen_bitfield_unit } } @@ -9081,7 +9181,7 @@ impl StdVideoEncodeH265ReferenceInfoFlags { #[derive(Debug, Copy, Clone)] pub struct StdVideoEncodeH265ReferenceInfo { pub flags: StdVideoEncodeH265ReferenceInfoFlags, - pub PictureType: StdVideoH265PictureType, + pub pic_type: StdVideoH265PictureType, pub PicOrderCntVal: i32, pub TemporalId: u8, } @@ -9111,13 +9211,13 @@ fn bindgen_test_layout_StdVideoEncodeH265ReferenceInfo() { ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).PictureType) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).pic_type) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265ReferenceInfo), "::", - stringify!(PictureType) + stringify!(pic_type) ) ); assert_eq!( diff --git a/ash/src/vk/platform_types.rs b/ash/src/vk/platform_types.rs index a5f618006..d1b4aa3d2 100644 --- a/ash/src/vk/platform_types.rs +++ b/ash/src/vk/platform_types.rs @@ -19,6 +19,7 @@ pub type HMONITOR = HANDLE; pub type DWORD = c_ulong; pub type LPCWSTR = *const u16; pub type zx_handle_t = u32; +pub type _screen_buffer = c_void; pub type _screen_context = c_void; pub type _screen_window = c_void; pub type SECURITY_ATTRIBUTES = c_void; diff --git a/generator/Vulkan-Headers b/generator/Vulkan-Headers index 3df77fb3e..c1a8560c5 160000 --- a/generator/Vulkan-Headers +++ b/generator/Vulkan-Headers @@ -1 +1 @@ -Subproject commit 3df77fb3e4e0961f7f01de9a9ae20dfdcfc4910a +Subproject commit c1a8560c5cf5e7bd6dbc71fe69b1a317411c36b8