libdisplay-info-sys-0.2.2/.cargo_vcs_info.json0000644000000001610000000000100147340ustar { "git": { "sha1": "6d1489cf25892baa2cf1569ced43d1c69fc949bd" }, "path_in_vcs": "libdisplay-info-sys" }libdisplay-info-sys-0.2.2/Cargo.toml0000644000000027030000000000100127360ustar # THIS FILE IS AUTOMATICALLY GENERATED BY CARGO # # When uploading crates to the registry Cargo will automatically # "normalize" Cargo.toml files for maximal compatibility # with all versions of Cargo and also rewrite `path` dependencies # to registry (e.g., crates.io) dependencies. # # If you are reading this file be aware that the original Cargo.toml # will likely look very different (and much more reasonable). # See Cargo.toml.orig for the original contents. [package] edition = "2021" name = "libdisplay-info-sys" version = "0.2.2" authors = ["Christian Meissl "] build = "build.rs" autolib = false autobins = false autoexamples = false autotests = false autobenches = false description = "Low-level bindings for libdisplay-info." documentation = "https://docs.rs/libdisplay-info-sys/" readme = "README.md" keywords = [ "libdisplay", "DisplayID", "EDID", ] categories = ["api-bindings"] license = "MIT" repository = "https://github.com/Smithay/libdisplay-info-rs" [package.metadata.docs.rs] features = ["v0_2"] rustdoc-args = [ "--cfg", "docsrs", ] [package.metadata.system-deps.libdisplay-info] name = "libdisplay-info" version = ">= 0.1.0, < 0.3.0" [package.metadata.system-deps.libdisplay-info.v0_2] version = "0.2.0" [lib] name = "libdisplay_info_sys" path = "src/lib.rs" [dependencies] [build-dependencies.semver] version = "1.0.24" [build-dependencies.system-deps] version = "7.0.3" [features] v0_2 = [] libdisplay-info-sys-0.2.2/Cargo.toml.orig000064400000000000000000000013371046102023000164210ustar 00000000000000[package] authors = ["Christian Meissl "] categories = ["api-bindings"] description = "Low-level bindings for libdisplay-info." documentation = "https://docs.rs/libdisplay-info-sys/" edition = "2021" version = "0.2.2" keywords = ["libdisplay", "DisplayID", "EDID"] license = "MIT" name = "libdisplay-info-sys" repository = "https://github.com/Smithay/libdisplay-info-rs" readme = "README.md" [package.metadata.docs.rs] features = ["v0_2"] rustdoc-args = ["--cfg", "docsrs"] [features] v0_2 = [] [build-dependencies] system-deps = "7.0.3" semver = "1.0.24" [dependencies] [package.metadata.system-deps.libdisplay-info] name = "libdisplay-info" version = ">= 0.1.0, < 0.3.0" v0_2 = { version = "0.2.0" } libdisplay-info-sys-0.2.2/README.md000064400000000000000000000002001046102023000147750ustar 00000000000000# libdisplay-info-sys Low-level ffi bindings for [`libdisplay-info`](https://gitlab.freedesktop.org/emersion/libdisplay-info/).libdisplay-info-sys-0.2.2/build.rs000064400000000000000000000010301046102023000151650ustar 00000000000000fn main() { if std::env::var("DOCS_RS").is_ok() { // don't link against unavailable native lib in doc.rs builds return; } let deps = system_deps::Config::new().probe().unwrap(); let native_lib = deps.get_by_name("libdisplay-info").unwrap(); let native_version = semver::Version::parse(&native_lib.version).unwrap(); let has_v2 = semver::VersionReq::parse(">=0.2") .unwrap() .matches(&native_version); if has_v2 { println!("cargo:rustc-cfg=feature=\"v0_2\""); } } libdisplay-info-sys-0.2.2/src/cta.rs000064400000000000000000003406271046102023000154460ustar 00000000000000/* automatically generated by rust-bindgen 0.68.1 */ pub const di_cta_video_format_picture_aspect_ratio_DI_CTA_VIDEO_FORMAT_PICTURE_ASPECT_RATIO_4_3: di_cta_video_format_picture_aspect_ratio = 0; pub const di_cta_video_format_picture_aspect_ratio_DI_CTA_VIDEO_FORMAT_PICTURE_ASPECT_RATIO_16_9: di_cta_video_format_picture_aspect_ratio = 1; pub const di_cta_video_format_picture_aspect_ratio_DI_CTA_VIDEO_FORMAT_PICTURE_ASPECT_RATIO_64_27 : di_cta_video_format_picture_aspect_ratio = 2 ; pub const di_cta_video_format_picture_aspect_ratio_DI_CTA_VIDEO_FORMAT_PICTURE_ASPECT_RATIO_256_135 : di_cta_video_format_picture_aspect_ratio = 3 ; #[doc = " CTA video format picture aspect ratio."] pub type di_cta_video_format_picture_aspect_ratio = ::std::os::raw::c_uint; pub const di_cta_video_format_sync_polarity_DI_CTA_VIDEO_FORMAT_SYNC_NEGATIVE: di_cta_video_format_sync_polarity = 0; pub const di_cta_video_format_sync_polarity_DI_CTA_VIDEO_FORMAT_SYNC_POSITIVE: di_cta_video_format_sync_polarity = 1; #[doc = " CTA video format sync pulse polarity."] pub type di_cta_video_format_sync_polarity = ::std::os::raw::c_uint; #[doc = " A CTA-861 video format, defined in section 4."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_cta_video_format { pub vic: u8, pub h_active: i32, pub v_active: i32, pub h_front: i32, pub v_front: i32, pub h_sync: i32, pub v_sync: i32, pub h_back: i32, pub v_back: i32, pub h_sync_polarity: di_cta_video_format_sync_polarity, pub v_sync_polarity: di_cta_video_format_sync_polarity, pub pixel_clock_hz: i64, pub interlaced: bool, pub picture_aspect_ratio: di_cta_video_format_picture_aspect_ratio, } #[test] fn bindgen_test_layout_di_cta_video_format() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 64usize, concat!("Size of: ", stringify!(di_cta_video_format)) ); assert_eq!( ::std::mem::align_of::(), 8usize, concat!("Alignment of ", stringify!(di_cta_video_format)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).vic) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_cta_video_format), "::", stringify!(vic) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).h_active) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", stringify!(di_cta_video_format), "::", stringify!(h_active) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).v_active) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", stringify!(di_cta_video_format), "::", stringify!(v_active) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).h_front) as usize - ptr as usize }, 12usize, concat!( "Offset of field: ", stringify!(di_cta_video_format), "::", stringify!(h_front) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).v_front) as usize - ptr as usize }, 16usize, concat!( "Offset of field: ", stringify!(di_cta_video_format), "::", stringify!(v_front) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).h_sync) as usize - ptr as usize }, 20usize, concat!( "Offset of field: ", stringify!(di_cta_video_format), "::", stringify!(h_sync) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).v_sync) as usize - ptr as usize }, 24usize, concat!( "Offset of field: ", stringify!(di_cta_video_format), "::", stringify!(v_sync) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).h_back) as usize - ptr as usize }, 28usize, concat!( "Offset of field: ", stringify!(di_cta_video_format), "::", stringify!(h_back) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).v_back) as usize - ptr as usize }, 32usize, concat!( "Offset of field: ", stringify!(di_cta_video_format), "::", stringify!(v_back) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).h_sync_polarity) as usize - ptr as usize }, 36usize, concat!( "Offset of field: ", stringify!(di_cta_video_format), "::", stringify!(h_sync_polarity) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).v_sync_polarity) as usize - ptr as usize }, 40usize, concat!( "Offset of field: ", stringify!(di_cta_video_format), "::", stringify!(v_sync_polarity) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).pixel_clock_hz) as usize - ptr as usize }, 48usize, concat!( "Offset of field: ", stringify!(di_cta_video_format), "::", stringify!(pixel_clock_hz) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).interlaced) as usize - ptr as usize }, 56usize, concat!( "Offset of field: ", stringify!(di_cta_video_format), "::", stringify!(interlaced) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).picture_aspect_ratio) as usize - ptr as usize }, 60usize, concat!( "Offset of field: ", stringify!(di_cta_video_format), "::", stringify!(picture_aspect_ratio) ) ); } extern "C" { #[doc = " Get a CTA-861 video format from a VIC.\n\n Returns NULL if the VIC is unknown."] pub fn di_cta_video_format_from_vic(vic: u8) -> *const di_cta_video_format; } #[doc = " EDID CTA-861 extension block."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_edid_cta { _unused: [u8; 0], } extern "C" { #[doc = " Get the CTA extension revision (also referred to as \"version\" by the\n specification)."] pub fn di_edid_cta_get_revision(cta: *const di_edid_cta) -> ::std::os::raw::c_int; } #[doc = " Miscellaneous EDID CTA flags, defined in section 7.3.3.\n\n For CTA revision 1, all of the fields are zero."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_edid_cta_flags { pub it_underscan: bool, pub basic_audio: bool, pub ycc444: bool, pub ycc422: bool, pub native_dtds: ::std::os::raw::c_int, } #[test] fn bindgen_test_layout_di_edid_cta_flags() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 8usize, concat!("Size of: ", stringify!(di_edid_cta_flags)) ); assert_eq!( ::std::mem::align_of::(), 4usize, concat!("Alignment of ", stringify!(di_edid_cta_flags)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).it_underscan) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_edid_cta_flags), "::", stringify!(it_underscan) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).basic_audio) as usize - ptr as usize }, 1usize, concat!( "Offset of field: ", stringify!(di_edid_cta_flags), "::", stringify!(basic_audio) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).ycc444) as usize - ptr as usize }, 2usize, concat!( "Offset of field: ", stringify!(di_edid_cta_flags), "::", stringify!(ycc444) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).ycc422) as usize - ptr as usize }, 3usize, concat!( "Offset of field: ", stringify!(di_edid_cta_flags), "::", stringify!(ycc422) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).native_dtds) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", stringify!(di_edid_cta_flags), "::", stringify!(native_dtds) ) ); } extern "C" { #[doc = " Get miscellaneous CTA flags."] pub fn di_edid_cta_get_flags(cta: *const di_edid_cta) -> *const di_edid_cta_flags; } #[doc = " CTA data block, defined in section 7.4."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_cta_data_block { _unused: [u8; 0], } extern "C" { #[doc = " Get CTA data blocks.\n\n The returned array is NULL-terminated."] pub fn di_edid_cta_get_data_blocks(cta: *const di_edid_cta) -> *const *const di_cta_data_block; } pub const di_cta_data_block_tag_DI_CTA_DATA_BLOCK_AUDIO: di_cta_data_block_tag = 1; pub const di_cta_data_block_tag_DI_CTA_DATA_BLOCK_VIDEO: di_cta_data_block_tag = 2; pub const di_cta_data_block_tag_DI_CTA_DATA_BLOCK_SPEAKER_ALLOC: di_cta_data_block_tag = 3; pub const di_cta_data_block_tag_DI_CTA_DATA_BLOCK_VESA_DISPLAY_TRANSFER_CHARACTERISTIC: di_cta_data_block_tag = 4; pub const di_cta_data_block_tag_DI_CTA_DATA_BLOCK_VIDEO_FORMAT: di_cta_data_block_tag = 5; pub const di_cta_data_block_tag_DI_CTA_DATA_BLOCK_VIDEO_CAP: di_cta_data_block_tag = 6; pub const di_cta_data_block_tag_DI_CTA_DATA_BLOCK_VESA_DISPLAY_DEVICE: di_cta_data_block_tag = 7; pub const di_cta_data_block_tag_DI_CTA_DATA_BLOCK_COLORIMETRY: di_cta_data_block_tag = 8; pub const di_cta_data_block_tag_DI_CTA_DATA_BLOCK_HDR_STATIC_METADATA: di_cta_data_block_tag = 9; pub const di_cta_data_block_tag_DI_CTA_DATA_BLOCK_HDR_DYNAMIC_METADATA: di_cta_data_block_tag = 10; pub const di_cta_data_block_tag_DI_CTA_DATA_BLOCK_NATIVE_VIDEO_RESOLUTION: di_cta_data_block_tag = 11; pub const di_cta_data_block_tag_DI_CTA_DATA_BLOCK_VIDEO_FORMAT_PREF: di_cta_data_block_tag = 12; pub const di_cta_data_block_tag_DI_CTA_DATA_BLOCK_YCBCR420: di_cta_data_block_tag = 13; pub const di_cta_data_block_tag_DI_CTA_DATA_BLOCK_YCBCR420_CAP_MAP: di_cta_data_block_tag = 14; pub const di_cta_data_block_tag_DI_CTA_DATA_BLOCK_HDMI_AUDIO: di_cta_data_block_tag = 15; pub const di_cta_data_block_tag_DI_CTA_DATA_BLOCK_ROOM_CONFIG: di_cta_data_block_tag = 16; pub const di_cta_data_block_tag_DI_CTA_DATA_BLOCK_SPEAKER_LOCATION: di_cta_data_block_tag = 17; pub const di_cta_data_block_tag_DI_CTA_DATA_BLOCK_INFOFRAME: di_cta_data_block_tag = 18; pub const di_cta_data_block_tag_DI_CTA_DATA_BLOCK_DISPLAYID_VIDEO_TIMING_VII: di_cta_data_block_tag = 19; pub const di_cta_data_block_tag_DI_CTA_DATA_BLOCK_DISPLAYID_VIDEO_TIMING_VIII: di_cta_data_block_tag = 20; pub const di_cta_data_block_tag_DI_CTA_DATA_BLOCK_DISPLAYID_VIDEO_TIMING_X: di_cta_data_block_tag = 21; pub const di_cta_data_block_tag_DI_CTA_DATA_BLOCK_HDMI_EDID_EXT_OVERRIDE: di_cta_data_block_tag = 22; pub const di_cta_data_block_tag_DI_CTA_DATA_BLOCK_HDMI_SINK_CAP: di_cta_data_block_tag = 23; #[doc = " CTA data block tag.\n\n Note, the enum values don't match the specification."] pub type di_cta_data_block_tag = ::std::os::raw::c_uint; extern "C" { #[doc = " Get the tag of the CTA data block."] pub fn di_cta_data_block_get_tag(block: *const di_cta_data_block) -> di_cta_data_block_tag; } pub const di_cta_audio_format_DI_CTA_AUDIO_FORMAT_LPCM: di_cta_audio_format = 1; pub const di_cta_audio_format_DI_CTA_AUDIO_FORMAT_AC3: di_cta_audio_format = 2; pub const di_cta_audio_format_DI_CTA_AUDIO_FORMAT_MPEG1: di_cta_audio_format = 3; pub const di_cta_audio_format_DI_CTA_AUDIO_FORMAT_MP3: di_cta_audio_format = 4; pub const di_cta_audio_format_DI_CTA_AUDIO_FORMAT_MPEG2: di_cta_audio_format = 5; pub const di_cta_audio_format_DI_CTA_AUDIO_FORMAT_AAC_LC: di_cta_audio_format = 6; pub const di_cta_audio_format_DI_CTA_AUDIO_FORMAT_DTS: di_cta_audio_format = 7; pub const di_cta_audio_format_DI_CTA_AUDIO_FORMAT_ATRAC: di_cta_audio_format = 8; pub const di_cta_audio_format_DI_CTA_AUDIO_FORMAT_ONE_BIT_AUDIO: di_cta_audio_format = 9; pub const di_cta_audio_format_DI_CTA_AUDIO_FORMAT_ENHANCED_AC3: di_cta_audio_format = 10; pub const di_cta_audio_format_DI_CTA_AUDIO_FORMAT_DTS_HD: di_cta_audio_format = 11; pub const di_cta_audio_format_DI_CTA_AUDIO_FORMAT_MAT: di_cta_audio_format = 12; pub const di_cta_audio_format_DI_CTA_AUDIO_FORMAT_DST: di_cta_audio_format = 13; pub const di_cta_audio_format_DI_CTA_AUDIO_FORMAT_WMA_PRO: di_cta_audio_format = 14; pub const di_cta_audio_format_DI_CTA_AUDIO_FORMAT_MPEG4_HE_AAC: di_cta_audio_format = 15; pub const di_cta_audio_format_DI_CTA_AUDIO_FORMAT_MPEG4_HE_AAC_V2: di_cta_audio_format = 16; pub const di_cta_audio_format_DI_CTA_AUDIO_FORMAT_MPEG4_AAC_LC: di_cta_audio_format = 17; pub const di_cta_audio_format_DI_CTA_AUDIO_FORMAT_DRA: di_cta_audio_format = 18; pub const di_cta_audio_format_DI_CTA_AUDIO_FORMAT_MPEG4_HE_AAC_MPEG_SURROUND: di_cta_audio_format = 19; pub const di_cta_audio_format_DI_CTA_AUDIO_FORMAT_MPEG4_AAC_LC_MPEG_SURROUND: di_cta_audio_format = 20; pub const di_cta_audio_format_DI_CTA_AUDIO_FORMAT_MPEGH_3D: di_cta_audio_format = 21; pub const di_cta_audio_format_DI_CTA_AUDIO_FORMAT_AC4: di_cta_audio_format = 22; pub const di_cta_audio_format_DI_CTA_AUDIO_FORMAT_LPCM_3D: di_cta_audio_format = 23; #[doc = " Audio formats, defined in tables 37 and 39.\n\n Note, the enum values don't match the specification."] pub type di_cta_audio_format = ::std::os::raw::c_uint; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_cta_sad_sample_rates { pub has_192_khz: bool, pub has_176_4_khz: bool, pub has_96_khz: bool, pub has_88_2_khz: bool, pub has_48_khz: bool, pub has_44_1_khz: bool, pub has_32_khz: bool, } #[test] fn bindgen_test_layout_di_cta_sad_sample_rates() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 7usize, concat!("Size of: ", stringify!(di_cta_sad_sample_rates)) ); assert_eq!( ::std::mem::align_of::(), 1usize, concat!("Alignment of ", stringify!(di_cta_sad_sample_rates)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).has_192_khz) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_cta_sad_sample_rates), "::", stringify!(has_192_khz) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).has_176_4_khz) as usize - ptr as usize }, 1usize, concat!( "Offset of field: ", stringify!(di_cta_sad_sample_rates), "::", stringify!(has_176_4_khz) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).has_96_khz) as usize - ptr as usize }, 2usize, concat!( "Offset of field: ", stringify!(di_cta_sad_sample_rates), "::", stringify!(has_96_khz) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).has_88_2_khz) as usize - ptr as usize }, 3usize, concat!( "Offset of field: ", stringify!(di_cta_sad_sample_rates), "::", stringify!(has_88_2_khz) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).has_48_khz) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", stringify!(di_cta_sad_sample_rates), "::", stringify!(has_48_khz) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).has_44_1_khz) as usize - ptr as usize }, 5usize, concat!( "Offset of field: ", stringify!(di_cta_sad_sample_rates), "::", stringify!(has_44_1_khz) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).has_32_khz) as usize - ptr as usize }, 6usize, concat!( "Offset of field: ", stringify!(di_cta_sad_sample_rates), "::", stringify!(has_32_khz) ) ); } pub const di_cta_sad_mpegh_3d_level_DI_CTA_SAD_MPEGH_3D_LEVEL_UNSPECIFIED: di_cta_sad_mpegh_3d_level = 0; pub const di_cta_sad_mpegh_3d_level_DI_CTA_SAD_MPEGH_3D_LEVEL_1: di_cta_sad_mpegh_3d_level = 1; pub const di_cta_sad_mpegh_3d_level_DI_CTA_SAD_MPEGH_3D_LEVEL_2: di_cta_sad_mpegh_3d_level = 2; pub const di_cta_sad_mpegh_3d_level_DI_CTA_SAD_MPEGH_3D_LEVEL_3: di_cta_sad_mpegh_3d_level = 3; pub const di_cta_sad_mpegh_3d_level_DI_CTA_SAD_MPEGH_3D_LEVEL_4: di_cta_sad_mpegh_3d_level = 4; pub const di_cta_sad_mpegh_3d_level_DI_CTA_SAD_MPEGH_3D_LEVEL_5: di_cta_sad_mpegh_3d_level = 5; pub type di_cta_sad_mpegh_3d_level = ::std::os::raw::c_uint; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_cta_sad_mpegh_3d { pub level: di_cta_sad_mpegh_3d_level, pub low_complexity_profile: bool, pub baseline_profile: bool, } #[test] fn bindgen_test_layout_di_cta_sad_mpegh_3d() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 8usize, concat!("Size of: ", stringify!(di_cta_sad_mpegh_3d)) ); assert_eq!( ::std::mem::align_of::(), 4usize, concat!("Alignment of ", stringify!(di_cta_sad_mpegh_3d)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).level) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_cta_sad_mpegh_3d), "::", stringify!(level) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).low_complexity_profile) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", stringify!(di_cta_sad_mpegh_3d), "::", stringify!(low_complexity_profile) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).baseline_profile) as usize - ptr as usize }, 5usize, concat!( "Offset of field: ", stringify!(di_cta_sad_mpegh_3d), "::", stringify!(baseline_profile) ) ); } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_cta_sad_mpeg_aac { pub has_frame_length_960: bool, pub has_frame_length_1024: bool, } #[test] fn bindgen_test_layout_di_cta_sad_mpeg_aac() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 2usize, concat!("Size of: ", stringify!(di_cta_sad_mpeg_aac)) ); assert_eq!( ::std::mem::align_of::(), 1usize, concat!("Alignment of ", stringify!(di_cta_sad_mpeg_aac)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).has_frame_length_960) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_cta_sad_mpeg_aac), "::", stringify!(has_frame_length_960) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).has_frame_length_1024) as usize - ptr as usize }, 1usize, concat!( "Offset of field: ", stringify!(di_cta_sad_mpeg_aac), "::", stringify!(has_frame_length_1024) ) ); } pub const di_cta_sad_mpeg_surround_signaling_DI_CTA_SAD_MPEG_SURROUND_SIGNALING_IMPLICIT: di_cta_sad_mpeg_surround_signaling = 0; pub const di_cta_sad_mpeg_surround_signaling_DI_CTA_SAD_MPEG_SURROUND_SIGNALING_IMPLICIT_AND_EXPLICIT : di_cta_sad_mpeg_surround_signaling = 1 ; pub type di_cta_sad_mpeg_surround_signaling = ::std::os::raw::c_uint; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_cta_sad_mpeg_surround { pub signaling: di_cta_sad_mpeg_surround_signaling, } #[test] fn bindgen_test_layout_di_cta_sad_mpeg_surround() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 4usize, concat!("Size of: ", stringify!(di_cta_sad_mpeg_surround)) ); assert_eq!( ::std::mem::align_of::(), 4usize, concat!("Alignment of ", stringify!(di_cta_sad_mpeg_surround)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).signaling) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_cta_sad_mpeg_surround), "::", stringify!(signaling) ) ); } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_cta_sad_mpeg_aac_le { pub supports_multichannel_sound: bool, } #[test] fn bindgen_test_layout_di_cta_sad_mpeg_aac_le() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 1usize, concat!("Size of: ", stringify!(di_cta_sad_mpeg_aac_le)) ); assert_eq!( ::std::mem::align_of::(), 1usize, concat!("Alignment of ", stringify!(di_cta_sad_mpeg_aac_le)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).supports_multichannel_sound) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_cta_sad_mpeg_aac_le), "::", stringify!(supports_multichannel_sound) ) ); } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_cta_sad_lpcm { pub has_sample_size_24_bits: bool, pub has_sample_size_20_bits: bool, pub has_sample_size_16_bits: bool, } #[test] fn bindgen_test_layout_di_cta_sad_lpcm() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 3usize, concat!("Size of: ", stringify!(di_cta_sad_lpcm)) ); assert_eq!( ::std::mem::align_of::(), 1usize, concat!("Alignment of ", stringify!(di_cta_sad_lpcm)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).has_sample_size_24_bits) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_cta_sad_lpcm), "::", stringify!(has_sample_size_24_bits) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).has_sample_size_20_bits) as usize - ptr as usize }, 1usize, concat!( "Offset of field: ", stringify!(di_cta_sad_lpcm), "::", stringify!(has_sample_size_20_bits) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).has_sample_size_16_bits) as usize - ptr as usize }, 2usize, concat!( "Offset of field: ", stringify!(di_cta_sad_lpcm), "::", stringify!(has_sample_size_16_bits) ) ); } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_cta_sad_enhanced_ac3 { pub supports_joint_object_coding: bool, pub supports_joint_object_coding_ACMOD28: bool, } #[test] fn bindgen_test_layout_di_cta_sad_enhanced_ac3() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 2usize, concat!("Size of: ", stringify!(di_cta_sad_enhanced_ac3)) ); assert_eq!( ::std::mem::align_of::(), 1usize, concat!("Alignment of ", stringify!(di_cta_sad_enhanced_ac3)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).supports_joint_object_coding) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_cta_sad_enhanced_ac3), "::", stringify!(supports_joint_object_coding) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).supports_joint_object_coding_ACMOD28) as usize - ptr as usize }, 1usize, concat!( "Offset of field: ", stringify!(di_cta_sad_enhanced_ac3), "::", stringify!(supports_joint_object_coding_ACMOD28) ) ); } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_cta_sad_mat { pub supports_object_audio_and_channel_based: bool, pub requires_hash_calculation: bool, } #[test] fn bindgen_test_layout_di_cta_sad_mat() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 2usize, concat!("Size of: ", stringify!(di_cta_sad_mat)) ); assert_eq!( ::std::mem::align_of::(), 1usize, concat!("Alignment of ", stringify!(di_cta_sad_mat)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).supports_object_audio_and_channel_based) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_cta_sad_mat), "::", stringify!(supports_object_audio_and_channel_based) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).requires_hash_calculation) as usize - ptr as usize }, 1usize, concat!( "Offset of field: ", stringify!(di_cta_sad_mat), "::", stringify!(requires_hash_calculation) ) ); } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_cta_sad_wma_pro { pub profile: ::std::os::raw::c_int, } #[test] fn bindgen_test_layout_di_cta_sad_wma_pro() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 4usize, concat!("Size of: ", stringify!(di_cta_sad_wma_pro)) ); assert_eq!( ::std::mem::align_of::(), 4usize, concat!("Alignment of ", stringify!(di_cta_sad_wma_pro)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).profile) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_cta_sad_wma_pro), "::", stringify!(profile) ) ); } #[doc = " A CTA short audio descriptor (SAD), defined in section 7.5.2."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_cta_sad { pub format: di_cta_audio_format, pub max_channels: i32, pub supported_sample_rates: *const di_cta_sad_sample_rates, pub max_bitrate_kbs: i32, pub lpcm: *const di_cta_sad_lpcm, pub mpegh_3d: *const di_cta_sad_mpegh_3d, pub mpeg_aac: *const di_cta_sad_mpeg_aac, pub mpeg_surround: *const di_cta_sad_mpeg_surround, pub mpeg_aac_le: *const di_cta_sad_mpeg_aac_le, pub enhanced_ac3: *const di_cta_sad_enhanced_ac3, pub mat: *const di_cta_sad_mat, pub wma_pro: *const di_cta_sad_wma_pro, } #[test] fn bindgen_test_layout_di_cta_sad() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 88usize, concat!("Size of: ", stringify!(di_cta_sad)) ); assert_eq!( ::std::mem::align_of::(), 8usize, concat!("Alignment of ", stringify!(di_cta_sad)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).format) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_cta_sad), "::", stringify!(format) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).max_channels) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", stringify!(di_cta_sad), "::", stringify!(max_channels) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).supported_sample_rates) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", stringify!(di_cta_sad), "::", stringify!(supported_sample_rates) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).max_bitrate_kbs) as usize - ptr as usize }, 16usize, concat!( "Offset of field: ", stringify!(di_cta_sad), "::", stringify!(max_bitrate_kbs) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).lpcm) as usize - ptr as usize }, 24usize, concat!( "Offset of field: ", stringify!(di_cta_sad), "::", stringify!(lpcm) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).mpegh_3d) as usize - ptr as usize }, 32usize, concat!( "Offset of field: ", stringify!(di_cta_sad), "::", stringify!(mpegh_3d) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).mpeg_aac) as usize - ptr as usize }, 40usize, concat!( "Offset of field: ", stringify!(di_cta_sad), "::", stringify!(mpeg_aac) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).mpeg_surround) as usize - ptr as usize }, 48usize, concat!( "Offset of field: ", stringify!(di_cta_sad), "::", stringify!(mpeg_surround) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).mpeg_aac_le) as usize - ptr as usize }, 56usize, concat!( "Offset of field: ", stringify!(di_cta_sad), "::", stringify!(mpeg_aac_le) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).enhanced_ac3) as usize - ptr as usize }, 64usize, concat!( "Offset of field: ", stringify!(di_cta_sad), "::", stringify!(enhanced_ac3) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).mat) as usize - ptr as usize }, 72usize, concat!( "Offset of field: ", stringify!(di_cta_sad), "::", stringify!(mat) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).wma_pro) as usize - ptr as usize }, 80usize, concat!( "Offset of field: ", stringify!(di_cta_sad), "::", stringify!(wma_pro) ) ); } extern "C" { #[doc = " Get an array of short audio descriptors from a CTA data block.\n\n Returns NULL if the data block tag is not DI_CTA_DATA_BLOCK_AUDIO.\n\n The returned array is NULL-terminated."] pub fn di_cta_data_block_get_sads( data_block: *const di_cta_data_block, ) -> *const *const di_cta_sad; } #[doc = " Indicates which speakers are present. See figure 6 for the meaning of the\n fields."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_cta_speaker_allocation { pub flw_frw: bool, pub flc_frc: bool, pub bc: bool, pub bl_br: bool, pub fc: bool, pub lfe1: bool, pub fl_fr: bool, pub tpsil_tpsir: bool, pub sil_sir: bool, pub tpbc: bool, pub lfe2: bool, pub ls_rs: bool, pub tpfc: bool, pub tpc: bool, pub tpfl_tpfr: bool, pub btfl_btfr: bool, pub btfc: bool, pub tpbl_tpbr: bool, } #[test] fn bindgen_test_layout_di_cta_speaker_allocation() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 18usize, concat!("Size of: ", stringify!(di_cta_speaker_allocation)) ); assert_eq!( ::std::mem::align_of::(), 1usize, concat!("Alignment of ", stringify!(di_cta_speaker_allocation)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).flw_frw) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_cta_speaker_allocation), "::", stringify!(flw_frw) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).flc_frc) as usize - ptr as usize }, 1usize, concat!( "Offset of field: ", stringify!(di_cta_speaker_allocation), "::", stringify!(flc_frc) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).bc) as usize - ptr as usize }, 2usize, concat!( "Offset of field: ", stringify!(di_cta_speaker_allocation), "::", stringify!(bc) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).bl_br) as usize - ptr as usize }, 3usize, concat!( "Offset of field: ", stringify!(di_cta_speaker_allocation), "::", stringify!(bl_br) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).fc) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", stringify!(di_cta_speaker_allocation), "::", stringify!(fc) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).lfe1) as usize - ptr as usize }, 5usize, concat!( "Offset of field: ", stringify!(di_cta_speaker_allocation), "::", stringify!(lfe1) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).fl_fr) as usize - ptr as usize }, 6usize, concat!( "Offset of field: ", stringify!(di_cta_speaker_allocation), "::", stringify!(fl_fr) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).tpsil_tpsir) as usize - ptr as usize }, 7usize, concat!( "Offset of field: ", stringify!(di_cta_speaker_allocation), "::", stringify!(tpsil_tpsir) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).sil_sir) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", stringify!(di_cta_speaker_allocation), "::", stringify!(sil_sir) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).tpbc) as usize - ptr as usize }, 9usize, concat!( "Offset of field: ", stringify!(di_cta_speaker_allocation), "::", stringify!(tpbc) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).lfe2) as usize - ptr as usize }, 10usize, concat!( "Offset of field: ", stringify!(di_cta_speaker_allocation), "::", stringify!(lfe2) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).ls_rs) as usize - ptr as usize }, 11usize, concat!( "Offset of field: ", stringify!(di_cta_speaker_allocation), "::", stringify!(ls_rs) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).tpfc) as usize - ptr as usize }, 12usize, concat!( "Offset of field: ", stringify!(di_cta_speaker_allocation), "::", stringify!(tpfc) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).tpc) as usize - ptr as usize }, 13usize, concat!( "Offset of field: ", stringify!(di_cta_speaker_allocation), "::", stringify!(tpc) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).tpfl_tpfr) as usize - ptr as usize }, 14usize, concat!( "Offset of field: ", stringify!(di_cta_speaker_allocation), "::", stringify!(tpfl_tpfr) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).btfl_btfr) as usize - ptr as usize }, 15usize, concat!( "Offset of field: ", stringify!(di_cta_speaker_allocation), "::", stringify!(btfl_btfr) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).btfc) as usize - ptr as usize }, 16usize, concat!( "Offset of field: ", stringify!(di_cta_speaker_allocation), "::", stringify!(btfc) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).tpbl_tpbr) as usize - ptr as usize }, 17usize, concat!( "Offset of field: ", stringify!(di_cta_speaker_allocation), "::", stringify!(tpbl_tpbr) ) ); } #[doc = " Speaker allocation data block (SADB), defined in section 7.5.3."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_cta_speaker_alloc_block { pub speakers: di_cta_speaker_allocation, } #[test] fn bindgen_test_layout_di_cta_speaker_alloc_block() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 18usize, concat!("Size of: ", stringify!(di_cta_speaker_alloc_block)) ); assert_eq!( ::std::mem::align_of::(), 1usize, concat!("Alignment of ", stringify!(di_cta_speaker_alloc_block)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).speakers) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_cta_speaker_alloc_block), "::", stringify!(speakers) ) ); } extern "C" { #[doc = " Get the speaker allocation from a CTA data block.\n\n Returns NULL if the data block tag is not DI_CTA_DATA_BLOCK_SPEAKER_ALLOC."] pub fn di_cta_data_block_get_speaker_alloc( block: *const di_cta_data_block, ) -> *const di_cta_speaker_alloc_block; } pub const di_cta_video_cap_over_underscan_DI_CTA_VIDEO_CAP_UNKNOWN_OVER_UNDERSCAN: di_cta_video_cap_over_underscan = 0; pub const di_cta_video_cap_over_underscan_DI_CTA_VIDEO_CAP_ALWAYS_OVERSCAN: di_cta_video_cap_over_underscan = 1; pub const di_cta_video_cap_over_underscan_DI_CTA_VIDEO_CAP_ALWAYS_UNDERSCAN: di_cta_video_cap_over_underscan = 2; pub const di_cta_video_cap_over_underscan_DI_CTA_VIDEO_CAP_BOTH_OVER_UNDERSCAN: di_cta_video_cap_over_underscan = 3; #[doc = " Over- and underscan capability."] pub type di_cta_video_cap_over_underscan = ::std::os::raw::c_uint; #[doc = " Video capability data block (VCDB), defined in section 7.5.6."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_cta_video_cap_block { pub selectable_ycc_quantization_range: bool, pub selectable_rgb_quantization_range: bool, pub pt_over_underscan: di_cta_video_cap_over_underscan, pub it_over_underscan: di_cta_video_cap_over_underscan, pub ce_over_underscan: di_cta_video_cap_over_underscan, } #[test] fn bindgen_test_layout_di_cta_video_cap_block() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 16usize, concat!("Size of: ", stringify!(di_cta_video_cap_block)) ); assert_eq!( ::std::mem::align_of::(), 4usize, concat!("Alignment of ", stringify!(di_cta_video_cap_block)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).selectable_ycc_quantization_range) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_cta_video_cap_block), "::", stringify!(selectable_ycc_quantization_range) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).selectable_rgb_quantization_range) as usize - ptr as usize }, 1usize, concat!( "Offset of field: ", stringify!(di_cta_video_cap_block), "::", stringify!(selectable_rgb_quantization_range) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).pt_over_underscan) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", stringify!(di_cta_video_cap_block), "::", stringify!(pt_over_underscan) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).it_over_underscan) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", stringify!(di_cta_video_cap_block), "::", stringify!(it_over_underscan) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).ce_over_underscan) as usize - ptr as usize }, 12usize, concat!( "Offset of field: ", stringify!(di_cta_video_cap_block), "::", stringify!(ce_over_underscan) ) ); } extern "C" { #[doc = " Get the video capabilities from a CTA data block.\n\n Returns NULL if the data block tag is not DI_CTA_DATA_BLOCK_VIDEO_CAP."] pub fn di_cta_data_block_get_video_cap( block: *const di_cta_data_block, ) -> *const di_cta_video_cap_block; } pub const di_cta_vesa_dddb_interface_type_DI_CTA_VESA_DDDB_INTERFACE_VGA: di_cta_vesa_dddb_interface_type = 0; pub const di_cta_vesa_dddb_interface_type_DI_CTA_VESA_DDDB_INTERFACE_NAVI_V: di_cta_vesa_dddb_interface_type = 1; pub const di_cta_vesa_dddb_interface_type_DI_CTA_VESA_DDDB_INTERFACE_NAVI_D: di_cta_vesa_dddb_interface_type = 2; pub const di_cta_vesa_dddb_interface_type_DI_CTA_VESA_DDDB_INTERFACE_LVDS: di_cta_vesa_dddb_interface_type = 3; pub const di_cta_vesa_dddb_interface_type_DI_CTA_VESA_DDDB_INTERFACE_RSDS: di_cta_vesa_dddb_interface_type = 4; pub const di_cta_vesa_dddb_interface_type_DI_CTA_VESA_DDDB_INTERFACE_DVI_D: di_cta_vesa_dddb_interface_type = 5; pub const di_cta_vesa_dddb_interface_type_DI_CTA_VESA_DDDB_INTERFACE_DVI_I_ANALOG: di_cta_vesa_dddb_interface_type = 6; pub const di_cta_vesa_dddb_interface_type_DI_CTA_VESA_DDDB_INTERFACE_DVI_I_DIGITAL: di_cta_vesa_dddb_interface_type = 7; pub const di_cta_vesa_dddb_interface_type_DI_CTA_VESA_DDDB_INTERFACE_HDMI_A: di_cta_vesa_dddb_interface_type = 8; pub const di_cta_vesa_dddb_interface_type_DI_CTA_VESA_DDDB_INTERFACE_HDMI_B: di_cta_vesa_dddb_interface_type = 9; pub const di_cta_vesa_dddb_interface_type_DI_CTA_VESA_DDDB_INTERFACE_MDDI: di_cta_vesa_dddb_interface_type = 10; pub const di_cta_vesa_dddb_interface_type_DI_CTA_VESA_DDDB_INTERFACE_DISPLAYPORT: di_cta_vesa_dddb_interface_type = 11; pub const di_cta_vesa_dddb_interface_type_DI_CTA_VESA_DDDB_INTERFACE_IEEE_1394: di_cta_vesa_dddb_interface_type = 12; pub const di_cta_vesa_dddb_interface_type_DI_CTA_VESA_DDDB_INTERFACE_M1_ANALOG: di_cta_vesa_dddb_interface_type = 13; pub const di_cta_vesa_dddb_interface_type_DI_CTA_VESA_DDDB_INTERFACE_M1_DIGITAL: di_cta_vesa_dddb_interface_type = 14; #[doc = " Interface types, defined in VESA DDDB section 2.3.1 and 2.3.2.\n\n Note, the enum values don't match the specification."] pub type di_cta_vesa_dddb_interface_type = ::std::os::raw::c_uint; pub const di_cta_vesa_dddb_content_protection_DI_CTA_VESA_DDDB_CONTENT_PROTECTION_NONE: di_cta_vesa_dddb_content_protection = 0; pub const di_cta_vesa_dddb_content_protection_DI_CTA_VESA_DDDB_CONTENT_PROTECTION_HDCP: di_cta_vesa_dddb_content_protection = 1; pub const di_cta_vesa_dddb_content_protection_DI_CTA_VESA_DDDB_CONTENT_PROTECTION_DTCP: di_cta_vesa_dddb_content_protection = 2; pub const di_cta_vesa_dddb_content_protection_DI_CTA_VESA_DDDB_CONTENT_PROTECTION_DPCP: di_cta_vesa_dddb_content_protection = 3; pub type di_cta_vesa_dddb_content_protection = ::std::os::raw::c_uint; pub const di_cta_vesa_dddb_default_orientation_DI_CTA_VESA_DDDB_DEFAULT_ORIENTATION_LANDSCAPE: di_cta_vesa_dddb_default_orientation = 0; pub const di_cta_vesa_dddb_default_orientation_DI_CTA_VESA_DDDB_DEFAULT_ORIENTATION_PORTAIT: di_cta_vesa_dddb_default_orientation = 1; pub const di_cta_vesa_dddb_default_orientation_DI_CTA_VESA_DDDB_DEFAULT_ORIENTATION_UNFIXED: di_cta_vesa_dddb_default_orientation = 2; pub const di_cta_vesa_dddb_default_orientation_DI_CTA_VESA_DDDB_DEFAULT_ORIENTATION_UNDEFINED: di_cta_vesa_dddb_default_orientation = 3; pub type di_cta_vesa_dddb_default_orientation = ::std::os::raw::c_uint; pub const di_cta_vesa_dddb_rotation_cap_DI_CTA_VESA_DDDB_ROTATION_CAP_NONE: di_cta_vesa_dddb_rotation_cap = 0; pub const di_cta_vesa_dddb_rotation_cap_DI_CTA_VESA_DDDB_ROTATION_CAP_90DEG_CLOCKWISE: di_cta_vesa_dddb_rotation_cap = 1; pub const di_cta_vesa_dddb_rotation_cap_DI_CTA_VESA_DDDB_ROTATION_CAP_90DEG_COUNTERCLOCKWISE: di_cta_vesa_dddb_rotation_cap = 2; pub const di_cta_vesa_dddb_rotation_cap_DI_CTA_VESA_DDDB_ROTATION_CAP_90DEG_EITHER: di_cta_vesa_dddb_rotation_cap = 3; pub type di_cta_vesa_dddb_rotation_cap = ::std::os::raw::c_uint; pub const di_cta_vesa_dddb_zero_pixel_location_DI_CTA_VESA_DDDB_ZERO_PIXEL_UPPER_LEFT: di_cta_vesa_dddb_zero_pixel_location = 0; pub const di_cta_vesa_dddb_zero_pixel_location_DI_CTA_VESA_DDDB_ZERO_PIXEL_UPPER_RIGHT: di_cta_vesa_dddb_zero_pixel_location = 1; pub const di_cta_vesa_dddb_zero_pixel_location_DI_CTA_VESA_DDDB_ZERO_PIXEL_LOWER_LEFT: di_cta_vesa_dddb_zero_pixel_location = 2; pub const di_cta_vesa_dddb_zero_pixel_location_DI_CTA_VESA_DDDB_ZERO_PIXEL_LOWER_RIGHT: di_cta_vesa_dddb_zero_pixel_location = 3; pub type di_cta_vesa_dddb_zero_pixel_location = ::std::os::raw::c_uint; pub const di_cta_vesa_dddb_scan_direction_DI_CTA_VESA_DDDB_SCAN_DIRECTION_UNDEFINED: di_cta_vesa_dddb_scan_direction = 0; pub const di_cta_vesa_dddb_scan_direction_DI_CTA_VESA_DDDB_SCAN_DIRECTION_FAST_LONG_SLOW_SHORT: di_cta_vesa_dddb_scan_direction = 1; pub const di_cta_vesa_dddb_scan_direction_DI_CTA_VESA_DDDB_SCAN_DIRECTION_FAST_SHORT_SLOW_LONG: di_cta_vesa_dddb_scan_direction = 2; pub type di_cta_vesa_dddb_scan_direction = ::std::os::raw::c_uint; pub const di_cta_vesa_dddb_subpixel_layout_DI_CTA_VESA_DDDB_SUBPIXEL_UNDEFINED: di_cta_vesa_dddb_subpixel_layout = 0; pub const di_cta_vesa_dddb_subpixel_layout_DI_CTA_VESA_DDDB_SUBPIXEL_RGB_VERT: di_cta_vesa_dddb_subpixel_layout = 1; pub const di_cta_vesa_dddb_subpixel_layout_DI_CTA_VESA_DDDB_SUBPIXEL_RGB_HORIZ: di_cta_vesa_dddb_subpixel_layout = 2; pub const di_cta_vesa_dddb_subpixel_layout_DI_CTA_VESA_DDDB_SUBPIXEL_EDID_CHROM_VERT: di_cta_vesa_dddb_subpixel_layout = 3; pub const di_cta_vesa_dddb_subpixel_layout_DI_CTA_VESA_DDDB_SUBPIXEL_EDID_CHROM_HORIZ: di_cta_vesa_dddb_subpixel_layout = 4; pub const di_cta_vesa_dddb_subpixel_layout_DI_CTA_VESA_DDDB_SUBPIXEL_QUAD_RGGB: di_cta_vesa_dddb_subpixel_layout = 5; pub const di_cta_vesa_dddb_subpixel_layout_DI_CTA_VESA_DDDB_SUBPIXEL_QUAD_GBRG: di_cta_vesa_dddb_subpixel_layout = 6; pub const di_cta_vesa_dddb_subpixel_layout_DI_CTA_VESA_DDDB_SUBPIXEL_DELTA_RGB: di_cta_vesa_dddb_subpixel_layout = 7; pub const di_cta_vesa_dddb_subpixel_layout_DI_CTA_VESA_DDDB_SUBPIXEL_MOSAIC: di_cta_vesa_dddb_subpixel_layout = 8; pub const di_cta_vesa_dddb_subpixel_layout_DI_CTA_VESA_DDDB_SUBPIXEL_QUAD_ANY: di_cta_vesa_dddb_subpixel_layout = 9; pub const di_cta_vesa_dddb_subpixel_layout_DI_CTA_VESA_DDDB_SUBPIXEL_FIVE: di_cta_vesa_dddb_subpixel_layout = 10; pub const di_cta_vesa_dddb_subpixel_layout_DI_CTA_VESA_DDDB_SUBPIXEL_SIX: di_cta_vesa_dddb_subpixel_layout = 11; pub const di_cta_vesa_dddb_subpixel_layout_DI_CTA_VESA_DDDB_SUBPIXEL_CLAIRVOYANTE_PENTILE: di_cta_vesa_dddb_subpixel_layout = 12; #[doc = " Subpixel layout, defined in VESA DDDB section 2.9.\n\n For layouts with more than 3 subpixels, the color coordinates of the\n additional subpixels are defined in the additional primary chromaticities."] pub type di_cta_vesa_dddb_subpixel_layout = ::std::os::raw::c_uint; pub const di_cta_vesa_dddb_dithering_type_DI_CTA_VESA_DDDB_DITHERING_NONE: di_cta_vesa_dddb_dithering_type = 0; pub const di_cta_vesa_dddb_dithering_type_DI_CTA_VESA_DDDB_DITHERING_SPACIAL: di_cta_vesa_dddb_dithering_type = 1; pub const di_cta_vesa_dddb_dithering_type_DI_CTA_VESA_DDDB_DITHERING_TEMPORAL: di_cta_vesa_dddb_dithering_type = 2; pub const di_cta_vesa_dddb_dithering_type_DI_CTA_VESA_DDDB_DITHERING_SPATIAL_AND_TEMPORAL: di_cta_vesa_dddb_dithering_type = 3; pub type di_cta_vesa_dddb_dithering_type = ::std::os::raw::c_uint; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_cta_vesa_dddb_additional_primary_chromaticity { pub x: f32, pub y: f32, } #[test] fn bindgen_test_layout_di_cta_vesa_dddb_additional_primary_chromaticity() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 8usize, concat!( "Size of: ", stringify!(di_cta_vesa_dddb_additional_primary_chromaticity) ) ); assert_eq!( ::std::mem::align_of::(), 4usize, concat!( "Alignment of ", stringify!(di_cta_vesa_dddb_additional_primary_chromaticity) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_cta_vesa_dddb_additional_primary_chromaticity), "::", stringify!(x) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", stringify!(di_cta_vesa_dddb_additional_primary_chromaticity), "::", stringify!(y) ) ); } pub const di_cta_vesa_dddb_frame_rate_conversion_DI_CTA_VESA_DDDB_FRAME_RATE_CONVERSION_NONE: di_cta_vesa_dddb_frame_rate_conversion = 0; pub const di_cta_vesa_dddb_frame_rate_conversion_DI_CTA_VESA_DDDB_FRAME_RATE_CONVERSION_SINGLE_BUFFERING : di_cta_vesa_dddb_frame_rate_conversion = 1 ; pub const di_cta_vesa_dddb_frame_rate_conversion_DI_CTA_VESA_DDDB_FRAME_RATE_CONVERSION_DOUBLE_BUFFERING : di_cta_vesa_dddb_frame_rate_conversion = 2 ; pub const di_cta_vesa_dddb_frame_rate_conversion_DI_CTA_VESA_DDDB_FRAME_RATE_CONVERSION_ADVANCED: di_cta_vesa_dddb_frame_rate_conversion = 3; pub type di_cta_vesa_dddb_frame_rate_conversion = ::std::os::raw::c_uint; pub const di_cta_vesa_dddb_resp_time_transition_DI_CTA_VESA_DDDB_RESP_TIME_BLACK_TO_WHITE: di_cta_vesa_dddb_resp_time_transition = 0; pub const di_cta_vesa_dddb_resp_time_transition_DI_CTA_VESA_DDDB_RESP_TIME_WHITE_TO_BLACK: di_cta_vesa_dddb_resp_time_transition = 1; pub type di_cta_vesa_dddb_resp_time_transition = ::std::os::raw::c_uint; #[doc = " VESA Display Device Data Block (DDDB), defined in VESA Display Device Data\n Block (DDDB) Standard version 1."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_cta_vesa_dddb { pub interface_type: di_cta_vesa_dddb_interface_type, pub num_channels: i32, pub interface_version: i32, pub interface_release: i32, pub content_protection: di_cta_vesa_dddb_content_protection, pub min_clock_freq_mhz: i32, pub max_clock_freq_mhz: i32, pub native_horiz_pixels: i32, pub native_vert_pixels: i32, pub aspect_ratio: f32, pub default_orientation: di_cta_vesa_dddb_default_orientation, pub rotation_cap: di_cta_vesa_dddb_rotation_cap, pub zero_pixel_location: di_cta_vesa_dddb_zero_pixel_location, pub scan_direction: di_cta_vesa_dddb_scan_direction, pub subpixel_layout: di_cta_vesa_dddb_subpixel_layout, pub horiz_pitch_mm: f32, pub vert_pitch_mm: f32, pub dithering_type: di_cta_vesa_dddb_dithering_type, pub direct_drive: bool, pub overdrive_not_recommended: bool, pub deinterlacing: bool, pub audio_support: bool, pub separate_audio_inputs: bool, pub audio_input_override: bool, pub audio_delay_provided: bool, pub audio_delay_ms: i32, pub frame_rate_conversion: di_cta_vesa_dddb_frame_rate_conversion, pub frame_rate_range_hz: i32, pub frame_rate_native_hz: i32, pub bit_depth_interface: i32, pub bit_depth_display: i32, pub additional_primary_chromaticities_len: usize, pub additional_primary_chromaticities: [di_cta_vesa_dddb_additional_primary_chromaticity; 3usize], pub resp_time_transition: di_cta_vesa_dddb_resp_time_transition, pub resp_time_ms: i32, pub overscan_horiz_pct: i32, pub overscan_vert_pct: i32, } #[test] fn bindgen_test_layout_di_cta_vesa_dddb() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 152usize, concat!("Size of: ", stringify!(di_cta_vesa_dddb)) ); assert_eq!( ::std::mem::align_of::(), 8usize, concat!("Alignment of ", stringify!(di_cta_vesa_dddb)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).interface_type) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_cta_vesa_dddb), "::", stringify!(interface_type) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).num_channels) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", stringify!(di_cta_vesa_dddb), "::", stringify!(num_channels) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).interface_version) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", stringify!(di_cta_vesa_dddb), "::", stringify!(interface_version) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).interface_release) as usize - ptr as usize }, 12usize, concat!( "Offset of field: ", stringify!(di_cta_vesa_dddb), "::", stringify!(interface_release) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).content_protection) as usize - ptr as usize }, 16usize, concat!( "Offset of field: ", stringify!(di_cta_vesa_dddb), "::", stringify!(content_protection) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).min_clock_freq_mhz) as usize - ptr as usize }, 20usize, concat!( "Offset of field: ", stringify!(di_cta_vesa_dddb), "::", stringify!(min_clock_freq_mhz) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).max_clock_freq_mhz) as usize - ptr as usize }, 24usize, concat!( "Offset of field: ", stringify!(di_cta_vesa_dddb), "::", stringify!(max_clock_freq_mhz) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).native_horiz_pixels) as usize - ptr as usize }, 28usize, concat!( "Offset of field: ", stringify!(di_cta_vesa_dddb), "::", stringify!(native_horiz_pixels) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).native_vert_pixels) as usize - ptr as usize }, 32usize, concat!( "Offset of field: ", stringify!(di_cta_vesa_dddb), "::", stringify!(native_vert_pixels) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).aspect_ratio) as usize - ptr as usize }, 36usize, concat!( "Offset of field: ", stringify!(di_cta_vesa_dddb), "::", stringify!(aspect_ratio) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).default_orientation) as usize - ptr as usize }, 40usize, concat!( "Offset of field: ", stringify!(di_cta_vesa_dddb), "::", stringify!(default_orientation) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).rotation_cap) as usize - ptr as usize }, 44usize, concat!( "Offset of field: ", stringify!(di_cta_vesa_dddb), "::", stringify!(rotation_cap) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).zero_pixel_location) as usize - ptr as usize }, 48usize, concat!( "Offset of field: ", stringify!(di_cta_vesa_dddb), "::", stringify!(zero_pixel_location) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).scan_direction) as usize - ptr as usize }, 52usize, concat!( "Offset of field: ", stringify!(di_cta_vesa_dddb), "::", stringify!(scan_direction) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).subpixel_layout) as usize - ptr as usize }, 56usize, concat!( "Offset of field: ", stringify!(di_cta_vesa_dddb), "::", stringify!(subpixel_layout) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).horiz_pitch_mm) as usize - ptr as usize }, 60usize, concat!( "Offset of field: ", stringify!(di_cta_vesa_dddb), "::", stringify!(horiz_pitch_mm) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).vert_pitch_mm) as usize - ptr as usize }, 64usize, concat!( "Offset of field: ", stringify!(di_cta_vesa_dddb), "::", stringify!(vert_pitch_mm) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).dithering_type) as usize - ptr as usize }, 68usize, concat!( "Offset of field: ", stringify!(di_cta_vesa_dddb), "::", stringify!(dithering_type) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).direct_drive) as usize - ptr as usize }, 72usize, concat!( "Offset of field: ", stringify!(di_cta_vesa_dddb), "::", stringify!(direct_drive) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).overdrive_not_recommended) as usize - ptr as usize }, 73usize, concat!( "Offset of field: ", stringify!(di_cta_vesa_dddb), "::", stringify!(overdrive_not_recommended) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).deinterlacing) as usize - ptr as usize }, 74usize, concat!( "Offset of field: ", stringify!(di_cta_vesa_dddb), "::", stringify!(deinterlacing) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).audio_support) as usize - ptr as usize }, 75usize, concat!( "Offset of field: ", stringify!(di_cta_vesa_dddb), "::", stringify!(audio_support) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).separate_audio_inputs) as usize - ptr as usize }, 76usize, concat!( "Offset of field: ", stringify!(di_cta_vesa_dddb), "::", stringify!(separate_audio_inputs) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).audio_input_override) as usize - ptr as usize }, 77usize, concat!( "Offset of field: ", stringify!(di_cta_vesa_dddb), "::", stringify!(audio_input_override) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).audio_delay_provided) as usize - ptr as usize }, 78usize, concat!( "Offset of field: ", stringify!(di_cta_vesa_dddb), "::", stringify!(audio_delay_provided) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).audio_delay_ms) as usize - ptr as usize }, 80usize, concat!( "Offset of field: ", stringify!(di_cta_vesa_dddb), "::", stringify!(audio_delay_ms) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).frame_rate_conversion) as usize - ptr as usize }, 84usize, concat!( "Offset of field: ", stringify!(di_cta_vesa_dddb), "::", stringify!(frame_rate_conversion) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).frame_rate_range_hz) as usize - ptr as usize }, 88usize, concat!( "Offset of field: ", stringify!(di_cta_vesa_dddb), "::", stringify!(frame_rate_range_hz) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).frame_rate_native_hz) as usize - ptr as usize }, 92usize, concat!( "Offset of field: ", stringify!(di_cta_vesa_dddb), "::", stringify!(frame_rate_native_hz) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).bit_depth_interface) as usize - ptr as usize }, 96usize, concat!( "Offset of field: ", stringify!(di_cta_vesa_dddb), "::", stringify!(bit_depth_interface) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).bit_depth_display) as usize - ptr as usize }, 100usize, concat!( "Offset of field: ", stringify!(di_cta_vesa_dddb), "::", stringify!(bit_depth_display) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).additional_primary_chromaticities_len) as usize - ptr as usize }, 104usize, concat!( "Offset of field: ", stringify!(di_cta_vesa_dddb), "::", stringify!(additional_primary_chromaticities_len) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).additional_primary_chromaticities) as usize - ptr as usize }, 112usize, concat!( "Offset of field: ", stringify!(di_cta_vesa_dddb), "::", stringify!(additional_primary_chromaticities) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).resp_time_transition) as usize - ptr as usize }, 136usize, concat!( "Offset of field: ", stringify!(di_cta_vesa_dddb), "::", stringify!(resp_time_transition) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).resp_time_ms) as usize - ptr as usize }, 140usize, concat!( "Offset of field: ", stringify!(di_cta_vesa_dddb), "::", stringify!(resp_time_ms) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).overscan_horiz_pct) as usize - ptr as usize }, 144usize, concat!( "Offset of field: ", stringify!(di_cta_vesa_dddb), "::", stringify!(overscan_horiz_pct) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).overscan_vert_pct) as usize - ptr as usize }, 148usize, concat!( "Offset of field: ", stringify!(di_cta_vesa_dddb), "::", stringify!(overscan_vert_pct) ) ); } extern "C" { #[doc = " Get the VESA Display Device Data Block (DDDB) from a CTA data block.\n\n Returns NULL if the data block tag is not\n DI_CTA_DATA_BLOCK_VESA_DISPLAY_DEVICE."] pub fn di_cta_data_block_get_vesa_dddb( block: *const di_cta_data_block, ) -> *const di_cta_vesa_dddb; } #[doc = " CTA colorimetry data block, defined in section 7.5.5."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_cta_colorimetry_block { pub xvycc_601: bool, pub xvycc_709: bool, pub sycc_601: bool, pub opycc_601: bool, pub oprgb: bool, pub bt2020_cycc: bool, pub bt2020_ycc: bool, pub bt2020_rgb: bool, pub st2113_rgb: bool, pub ictcp: bool, } #[test] fn bindgen_test_layout_di_cta_colorimetry_block() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 10usize, concat!("Size of: ", stringify!(di_cta_colorimetry_block)) ); assert_eq!( ::std::mem::align_of::(), 1usize, concat!("Alignment of ", stringify!(di_cta_colorimetry_block)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).xvycc_601) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_cta_colorimetry_block), "::", stringify!(xvycc_601) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).xvycc_709) as usize - ptr as usize }, 1usize, concat!( "Offset of field: ", stringify!(di_cta_colorimetry_block), "::", stringify!(xvycc_709) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).sycc_601) as usize - ptr as usize }, 2usize, concat!( "Offset of field: ", stringify!(di_cta_colorimetry_block), "::", stringify!(sycc_601) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).opycc_601) as usize - ptr as usize }, 3usize, concat!( "Offset of field: ", stringify!(di_cta_colorimetry_block), "::", stringify!(opycc_601) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).oprgb) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", stringify!(di_cta_colorimetry_block), "::", stringify!(oprgb) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).bt2020_cycc) as usize - ptr as usize }, 5usize, concat!( "Offset of field: ", stringify!(di_cta_colorimetry_block), "::", stringify!(bt2020_cycc) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).bt2020_ycc) as usize - ptr as usize }, 6usize, concat!( "Offset of field: ", stringify!(di_cta_colorimetry_block), "::", stringify!(bt2020_ycc) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).bt2020_rgb) as usize - ptr as usize }, 7usize, concat!( "Offset of field: ", stringify!(di_cta_colorimetry_block), "::", stringify!(bt2020_rgb) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).st2113_rgb) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", stringify!(di_cta_colorimetry_block), "::", stringify!(st2113_rgb) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).ictcp) as usize - ptr as usize }, 9usize, concat!( "Offset of field: ", stringify!(di_cta_colorimetry_block), "::", stringify!(ictcp) ) ); } extern "C" { #[doc = " Get the colorimetry data from a CTA data block.\n\n Returns NULL if the data block tag is not DI_CTA_DATA_BLOCK_COLORIMETRY."] pub fn di_cta_data_block_get_colorimetry( block: *const di_cta_data_block, ) -> *const di_cta_colorimetry_block; } #[doc = " Supported Electro-Optical Transfer Functions for a CTA HDR static metadata\n block."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_cta_hdr_static_metadata_block_eotfs { pub traditional_sdr: bool, pub traditional_hdr: bool, pub pq: bool, pub hlg: bool, } #[test] fn bindgen_test_layout_di_cta_hdr_static_metadata_block_eotfs() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 4usize, concat!( "Size of: ", stringify!(di_cta_hdr_static_metadata_block_eotfs) ) ); assert_eq!( ::std::mem::align_of::(), 1usize, concat!( "Alignment of ", stringify!(di_cta_hdr_static_metadata_block_eotfs) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).traditional_sdr) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_cta_hdr_static_metadata_block_eotfs), "::", stringify!(traditional_sdr) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).traditional_hdr) as usize - ptr as usize }, 1usize, concat!( "Offset of field: ", stringify!(di_cta_hdr_static_metadata_block_eotfs), "::", stringify!(traditional_hdr) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).pq) as usize - ptr as usize }, 2usize, concat!( "Offset of field: ", stringify!(di_cta_hdr_static_metadata_block_eotfs), "::", stringify!(pq) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).hlg) as usize - ptr as usize }, 3usize, concat!( "Offset of field: ", stringify!(di_cta_hdr_static_metadata_block_eotfs), "::", stringify!(hlg) ) ); } #[doc = " Supported static metadata descriptors for a CTA HDR static metadata block."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_cta_hdr_static_metadata_block_descriptors { pub type1: bool, } #[test] fn bindgen_test_layout_di_cta_hdr_static_metadata_block_descriptors() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 1usize, concat!( "Size of: ", stringify!(di_cta_hdr_static_metadata_block_descriptors) ) ); assert_eq!( ::std::mem::align_of::(), 1usize, concat!( "Alignment of ", stringify!(di_cta_hdr_static_metadata_block_descriptors) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).type1) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_cta_hdr_static_metadata_block_descriptors), "::", stringify!(type1) ) ); } #[doc = " CTA HDR static metadata block, defined in section 7.5.13."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_cta_hdr_static_metadata_block { pub desired_content_max_luminance: f32, pub desired_content_max_frame_avg_luminance: f32, pub desired_content_min_luminance: f32, pub eotfs: *const di_cta_hdr_static_metadata_block_eotfs, pub descriptors: *const di_cta_hdr_static_metadata_block_descriptors, } #[test] fn bindgen_test_layout_di_cta_hdr_static_metadata_block() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 32usize, concat!("Size of: ", stringify!(di_cta_hdr_static_metadata_block)) ); assert_eq!( ::std::mem::align_of::(), 8usize, concat!( "Alignment of ", stringify!(di_cta_hdr_static_metadata_block) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).desired_content_max_luminance) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_cta_hdr_static_metadata_block), "::", stringify!(desired_content_max_luminance) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).desired_content_max_frame_avg_luminance) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", stringify!(di_cta_hdr_static_metadata_block), "::", stringify!(desired_content_max_frame_avg_luminance) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).desired_content_min_luminance) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", stringify!(di_cta_hdr_static_metadata_block), "::", stringify!(desired_content_min_luminance) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).eotfs) as usize - ptr as usize }, 16usize, concat!( "Offset of field: ", stringify!(di_cta_hdr_static_metadata_block), "::", stringify!(eotfs) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).descriptors) as usize - ptr as usize }, 24usize, concat!( "Offset of field: ", stringify!(di_cta_hdr_static_metadata_block), "::", stringify!(descriptors) ) ); } extern "C" { #[doc = " Get the HDR static metadata from a CTA data block.\n\n Returns NULL if the data block tag is not\n DI_CTA_DATA_BLOCK_HDR_STATIC_METADATA."] pub fn di_cta_data_block_get_hdr_static_metadata( block: *const di_cta_data_block, ) -> *const di_cta_hdr_static_metadata_block; } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_cta_hdr_dynamic_metadata_block_type1 { pub type_1_hdr_metadata_version: u8, } #[test] fn bindgen_test_layout_di_cta_hdr_dynamic_metadata_block_type1() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 1usize, concat!( "Size of: ", stringify!(di_cta_hdr_dynamic_metadata_block_type1) ) ); assert_eq!( ::std::mem::align_of::(), 1usize, concat!( "Alignment of ", stringify!(di_cta_hdr_dynamic_metadata_block_type1) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).type_1_hdr_metadata_version) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_cta_hdr_dynamic_metadata_block_type1), "::", stringify!(type_1_hdr_metadata_version) ) ); } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_cta_hdr_dynamic_metadata_block_type2 { pub ts_103_433_spec_version: u8, pub ts_103_433_1_capable: bool, pub ts_103_433_2_capable: bool, pub ts_103_433_3_capable: bool, } #[test] fn bindgen_test_layout_di_cta_hdr_dynamic_metadata_block_type2() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 4usize, concat!( "Size of: ", stringify!(di_cta_hdr_dynamic_metadata_block_type2) ) ); assert_eq!( ::std::mem::align_of::(), 1usize, concat!( "Alignment of ", stringify!(di_cta_hdr_dynamic_metadata_block_type2) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).ts_103_433_spec_version) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_cta_hdr_dynamic_metadata_block_type2), "::", stringify!(ts_103_433_spec_version) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).ts_103_433_1_capable) as usize - ptr as usize }, 1usize, concat!( "Offset of field: ", stringify!(di_cta_hdr_dynamic_metadata_block_type2), "::", stringify!(ts_103_433_1_capable) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).ts_103_433_2_capable) as usize - ptr as usize }, 2usize, concat!( "Offset of field: ", stringify!(di_cta_hdr_dynamic_metadata_block_type2), "::", stringify!(ts_103_433_2_capable) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).ts_103_433_3_capable) as usize - ptr as usize }, 3usize, concat!( "Offset of field: ", stringify!(di_cta_hdr_dynamic_metadata_block_type2), "::", stringify!(ts_103_433_3_capable) ) ); } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_cta_hdr_dynamic_metadata_block_type3 { _unused: [u8; 0], } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_cta_hdr_dynamic_metadata_block_type4 { pub type_4_hdr_metadata_version: u8, } #[test] fn bindgen_test_layout_di_cta_hdr_dynamic_metadata_block_type4() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 1usize, concat!( "Size of: ", stringify!(di_cta_hdr_dynamic_metadata_block_type4) ) ); assert_eq!( ::std::mem::align_of::(), 1usize, concat!( "Alignment of ", stringify!(di_cta_hdr_dynamic_metadata_block_type4) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).type_4_hdr_metadata_version) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_cta_hdr_dynamic_metadata_block_type4), "::", stringify!(type_4_hdr_metadata_version) ) ); } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_cta_hdr_dynamic_metadata_block_type256 { pub graphics_overlay_flag_version: u8, } #[test] fn bindgen_test_layout_di_cta_hdr_dynamic_metadata_block_type256() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 1usize, concat!( "Size of: ", stringify!(di_cta_hdr_dynamic_metadata_block_type256) ) ); assert_eq!( ::std::mem::align_of::(), 1usize, concat!( "Alignment of ", stringify!(di_cta_hdr_dynamic_metadata_block_type256) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).graphics_overlay_flag_version) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_cta_hdr_dynamic_metadata_block_type256), "::", stringify!(graphics_overlay_flag_version) ) ); } #[doc = " CTA HDR dynamic metadata block, defined in section 7.5.14."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_cta_hdr_dynamic_metadata_block { pub type1: *const di_cta_hdr_dynamic_metadata_block_type1, pub type2: *const di_cta_hdr_dynamic_metadata_block_type2, pub type3: *const di_cta_hdr_dynamic_metadata_block_type3, pub type4: *const di_cta_hdr_dynamic_metadata_block_type4, pub type256: *const di_cta_hdr_dynamic_metadata_block_type256, } #[test] fn bindgen_test_layout_di_cta_hdr_dynamic_metadata_block() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 40usize, concat!("Size of: ", stringify!(di_cta_hdr_dynamic_metadata_block)) ); assert_eq!( ::std::mem::align_of::(), 8usize, concat!( "Alignment of ", stringify!(di_cta_hdr_dynamic_metadata_block) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).type1) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_cta_hdr_dynamic_metadata_block), "::", stringify!(type1) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).type2) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", stringify!(di_cta_hdr_dynamic_metadata_block), "::", stringify!(type2) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).type3) as usize - ptr as usize }, 16usize, concat!( "Offset of field: ", stringify!(di_cta_hdr_dynamic_metadata_block), "::", stringify!(type3) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).type4) as usize - ptr as usize }, 24usize, concat!( "Offset of field: ", stringify!(di_cta_hdr_dynamic_metadata_block), "::", stringify!(type4) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).type256) as usize - ptr as usize }, 32usize, concat!( "Offset of field: ", stringify!(di_cta_hdr_dynamic_metadata_block), "::", stringify!(type256) ) ); } extern "C" { #[doc = " Get the HDR dynamic metadata from a CTA data block.\n\n Returns NULL if the data block tag is not\n DI_CTA_DATA_BLOCK_HDR_DYNAMIC_METADATA."] pub fn di_cta_data_block_get_hdr_dynamic_metadata( block: *const di_cta_data_block, ) -> *const di_cta_hdr_dynamic_metadata_block; } #[doc = " A Short Video Descriptor (SVD)."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_cta_svd { pub vic: u8, pub native: bool, } #[test] fn bindgen_test_layout_di_cta_svd() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 2usize, concat!("Size of: ", stringify!(di_cta_svd)) ); assert_eq!( ::std::mem::align_of::(), 1usize, concat!("Alignment of ", stringify!(di_cta_svd)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).vic) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_cta_svd), "::", stringify!(vic) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).native) as usize - ptr as usize }, 1usize, concat!( "Offset of field: ", stringify!(di_cta_svd), "::", stringify!(native) ) ); } extern "C" { #[doc = " Get an array of short video descriptors from a CTA data block.\n\n Returns NULL if the data block tag is not DI_CTA_DATA_BLOCK_VIDEO.\n\n The returned array is NULL-terminated."] pub fn di_cta_data_block_get_svds(block: *const di_cta_data_block) -> *const *const di_cta_svd; } extern "C" { #[doc = " Get an array of short video descriptors which only allow YCbCr 4:2:0 sampling\n mode from a CTA data block.\n\n Returns NULL if the data block tag is not DI_CTA_DATA_BLOCK_YCBCR420.\n\n The returned array is NULL-terminated."] pub fn di_cta_data_block_get_ycbcr420_svds( block: *const di_cta_data_block, ) -> *const *const di_cta_svd; } pub const di_cta_vesa_transfer_characteristics_usage_DI_CTA_VESA_TRANSFER_CHARACTERISTIC_USAGE_WHITE : di_cta_vesa_transfer_characteristics_usage = 0 ; pub const di_cta_vesa_transfer_characteristics_usage_DI_CTA_VESA_TRANSFER_CHARACTERISTIC_USAGE_RED : di_cta_vesa_transfer_characteristics_usage = 1 ; pub const di_cta_vesa_transfer_characteristics_usage_DI_CTA_VESA_TRANSFER_CHARACTERISTIC_USAGE_GREEN : di_cta_vesa_transfer_characteristics_usage = 2 ; pub const di_cta_vesa_transfer_characteristics_usage_DI_CTA_VESA_TRANSFER_CHARACTERISTIC_USAGE_BLUE : di_cta_vesa_transfer_characteristics_usage = 3 ; pub type di_cta_vesa_transfer_characteristics_usage = ::std::os::raw::c_uint; #[doc = " VESA Display Transfer Characteristic Data Block, defined in VESA Display\n Transfer Characteristics Data Block Standard Version 1.0\n\n Contains 8, 16 or 32 evenly distributed points on the input axis describing\n the normalized relative luminance at that input. The first value includes the\n relative black level luminance."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_cta_vesa_transfer_characteristics { pub usage: di_cta_vesa_transfer_characteristics_usage, pub points_len: u8, pub points: [f32; 32usize], } #[test] fn bindgen_test_layout_di_cta_vesa_transfer_characteristics() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 136usize, concat!( "Size of: ", stringify!(di_cta_vesa_transfer_characteristics) ) ); assert_eq!( ::std::mem::align_of::(), 4usize, concat!( "Alignment of ", stringify!(di_cta_vesa_transfer_characteristics) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).usage) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_cta_vesa_transfer_characteristics), "::", stringify!(usage) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).points_len) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", stringify!(di_cta_vesa_transfer_characteristics), "::", stringify!(points_len) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).points) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", stringify!(di_cta_vesa_transfer_characteristics), "::", stringify!(points) ) ); } extern "C" { #[doc = " Get the Display Transfer Characteristic from a CTA data block.\n\n Returns NULL if the data block tag is not\n DI_CTA_DATA_BLOCK_VESA_DISPLAY_TRANSFER_CHARACTERISTIC.\n\n Upstream is not aware of any EDID blob containing a Display Transfer\n Characteristic data block.\n If such a blob is found, please share it with upstream!"] pub fn di_cta_data_block_get_vesa_transfer_characteristics( block: *const di_cta_data_block, ) -> *const di_cta_vesa_transfer_characteristics; } #[doc = " CTA YCbCr 4:2:0 Capability Map block, defined in section 7.5.11."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_cta_ycbcr420_cap_map { _unused: [u8; 0], } extern "C" { #[doc = " Returns true if the SVD in regular Video Data Blocks at index `svd_index`\n supports YCbCr 4:2:0 subsampling."] pub fn di_cta_ycbcr420_cap_map_supported( cap_map: *const di_cta_ycbcr420_cap_map, svd_index: usize, ) -> bool; } extern "C" { #[doc = " Get the YCbCr 4:2:0 Capability Map from a CTA data block.\n\n Returns NULL if the data block tag is not DI_CTA_DATA_BLOCK_YCBCR420_CAP_MAP."] pub fn di_cta_data_block_get_ycbcr420_cap_map( block: *const di_cta_data_block, ) -> *const di_cta_ycbcr420_cap_map; } #[cfg(feature = "v0_2")] pub const di_cta_hdmi_audio_3d_channels_DI_CTA_HDMI_AUDIO_3D_CHANNELS_UNKNOWN: di_cta_hdmi_audio_3d_channels = 0; #[cfg(feature = "v0_2")] pub const di_cta_hdmi_audio_3d_channels_DI_CTA_HDMI_AUDIO_3D_CHANNELS_10_2: di_cta_hdmi_audio_3d_channels = 1; #[cfg(feature = "v0_2")] pub const di_cta_hdmi_audio_3d_channels_DI_CTA_HDMI_AUDIO_3D_CHANNELS_22_2: di_cta_hdmi_audio_3d_channels = 2; #[cfg(feature = "v0_2")] pub const di_cta_hdmi_audio_3d_channels_DI_CTA_HDMI_AUDIO_3D_CHANNELS_30_2: di_cta_hdmi_audio_3d_channels = 3; #[cfg(feature = "v0_2")] pub type di_cta_hdmi_audio_3d_channels = ::std::os::raw::c_uint; #[doc = " HDMI 3D Audio"] #[repr(C)] #[derive(Debug, Copy, Clone)] #[cfg(feature = "v0_2")] pub struct di_cta_hdmi_audio_3d { pub sads: *const *const di_cta_sad, pub channels: di_cta_hdmi_audio_3d_channels, pub speakers: di_cta_speaker_allocation, } #[test] #[cfg(feature = "v0_2")] fn bindgen_test_layout_di_cta_hdmi_audio_3d() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 32usize, concat!("Size of: ", stringify!(di_cta_hdmi_audio_3d)) ); assert_eq!( ::std::mem::align_of::(), 8usize, concat!("Alignment of ", stringify!(di_cta_hdmi_audio_3d)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).sads) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_cta_hdmi_audio_3d), "::", stringify!(sads) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).channels) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", stringify!(di_cta_hdmi_audio_3d), "::", stringify!(channels) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).speakers) as usize - ptr as usize }, 12usize, concat!( "Offset of field: ", stringify!(di_cta_hdmi_audio_3d), "::", stringify!(speakers) ) ); } #[doc = " HDMI Multi-Stream Audio"] #[repr(C)] #[derive(Debug, Copy, Clone)] #[cfg(feature = "v0_2")] pub struct di_cta_hdmi_audio_multi_stream { pub max_streams: ::std::os::raw::c_int, pub supports_non_mixed: bool, } #[test] #[cfg(feature = "v0_2")] fn bindgen_test_layout_di_cta_hdmi_audio_multi_stream() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 8usize, concat!("Size of: ", stringify!(di_cta_hdmi_audio_multi_stream)) ); assert_eq!( ::std::mem::align_of::(), 4usize, concat!("Alignment of ", stringify!(di_cta_hdmi_audio_multi_stream)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).max_streams) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_cta_hdmi_audio_multi_stream), "::", stringify!(max_streams) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).supports_non_mixed) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", stringify!(di_cta_hdmi_audio_multi_stream), "::", stringify!(supports_non_mixed) ) ); } #[doc = " HDMI Audio"] #[repr(C)] #[derive(Debug, Copy, Clone)] #[cfg(feature = "v0_2")] pub struct di_cta_hdmi_audio_block { pub multi_stream: *const di_cta_hdmi_audio_multi_stream, pub audio_3d: *const di_cta_hdmi_audio_3d, } #[test] #[cfg(feature = "v0_2")] fn bindgen_test_layout_di_cta_hdmi_audio_block() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 16usize, concat!("Size of: ", stringify!(di_cta_hdmi_audio_block)) ); assert_eq!( ::std::mem::align_of::(), 8usize, concat!("Alignment of ", stringify!(di_cta_hdmi_audio_block)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).multi_stream) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_cta_hdmi_audio_block), "::", stringify!(multi_stream) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).audio_3d) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", stringify!(di_cta_hdmi_audio_block), "::", stringify!(audio_3d) ) ); } #[cfg(feature = "v0_2")] extern "C" { #[doc = " Get the HDMI Audio information from a CTA data block.\n\n Returns NULL if the data block tag is not DI_CTA_DATA_BLOCK_HDMI_AUDIO."] pub fn di_cta_data_block_get_hdmi_audio( block: *const di_cta_data_block, ) -> *const di_cta_hdmi_audio_block; } pub const di_cta_infoframe_type_DI_CTA_INFOFRAME_TYPE_AUXILIARY_VIDEO_INFORMATION: di_cta_infoframe_type = 0; pub const di_cta_infoframe_type_DI_CTA_INFOFRAME_TYPE_SOURCE_PRODUCT_DESCRIPTION: di_cta_infoframe_type = 1; pub const di_cta_infoframe_type_DI_CTA_INFOFRAME_TYPE_AUDIO: di_cta_infoframe_type = 2; pub const di_cta_infoframe_type_DI_CTA_INFOFRAME_TYPE_MPEG_SOURCE: di_cta_infoframe_type = 3; pub const di_cta_infoframe_type_DI_CTA_INFOFRAME_TYPE_NTSC_VBI: di_cta_infoframe_type = 4; pub const di_cta_infoframe_type_DI_CTA_INFOFRAME_TYPE_DYNAMIC_RANGE_AND_MASTERING: di_cta_infoframe_type = 5; #[doc = " InfoFrame types, defined in table 7.\n\n Note, the enum values don't match the specification."] pub type di_cta_infoframe_type = ::std::os::raw::c_uint; #[doc = " CTA InfoFrame descriptor, defined in section 7.5.9."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_cta_infoframe_descriptor { pub type_: di_cta_infoframe_type, } #[test] fn bindgen_test_layout_di_cta_infoframe_descriptor() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 4usize, concat!("Size of: ", stringify!(di_cta_infoframe_descriptor)) ); assert_eq!( ::std::mem::align_of::(), 4usize, concat!("Alignment of ", stringify!(di_cta_infoframe_descriptor)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_cta_infoframe_descriptor), "::", stringify!(type_) ) ); } #[doc = " CTA InfoFrame processing, defined in section 7.5.9."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_cta_infoframe_block { pub num_simultaneous_vsifs: ::std::os::raw::c_int, pub infoframes: *const *const di_cta_infoframe_descriptor, } #[test] fn bindgen_test_layout_di_cta_infoframe_block() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 16usize, concat!("Size of: ", stringify!(di_cta_infoframe_block)) ); assert_eq!( ::std::mem::align_of::(), 8usize, concat!("Alignment of ", stringify!(di_cta_infoframe_block)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).num_simultaneous_vsifs) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_cta_infoframe_block), "::", stringify!(num_simultaneous_vsifs) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).infoframes) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", stringify!(di_cta_infoframe_block), "::", stringify!(infoframes) ) ); } extern "C" { #[doc = " Get the InfoFrame information from a CTA data block.\n\n Returns NULL if the data block tag is not DI_CTA_DATA_BLOCK_INFOFRAME."] pub fn di_cta_data_block_get_infoframe( block: *const di_cta_data_block, ) -> *const di_cta_infoframe_block; } #[doc = " Room Configuration Data Block, defined in section 7.5.15."] #[repr(C)] #[derive(Debug, Copy, Clone)] #[cfg(feature = "v0_2")] pub struct di_cta_room_configuration { pub speakers: di_cta_speaker_allocation, pub speaker_count: ::std::os::raw::c_int, pub has_speaker_location_descriptors: bool, pub max_x: ::std::os::raw::c_int, pub max_y: ::std::os::raw::c_int, pub max_z: ::std::os::raw::c_int, pub display_x: f64, pub display_y: f64, pub display_z: f64, } #[test] #[cfg(feature = "v0_2")] fn bindgen_test_layout_di_cta_room_configuration() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 64usize, concat!("Size of: ", stringify!(di_cta_room_configuration)) ); assert_eq!( ::std::mem::align_of::(), 8usize, concat!("Alignment of ", stringify!(di_cta_room_configuration)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).speakers) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_cta_room_configuration), "::", stringify!(speakers) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).speaker_count) as usize - ptr as usize }, 20usize, concat!( "Offset of field: ", stringify!(di_cta_room_configuration), "::", stringify!(speaker_count) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).has_speaker_location_descriptors) as usize - ptr as usize }, 24usize, concat!( "Offset of field: ", stringify!(di_cta_room_configuration), "::", stringify!(has_speaker_location_descriptors) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).max_x) as usize - ptr as usize }, 28usize, concat!( "Offset of field: ", stringify!(di_cta_room_configuration), "::", stringify!(max_x) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).max_y) as usize - ptr as usize }, 32usize, concat!( "Offset of field: ", stringify!(di_cta_room_configuration), "::", stringify!(max_y) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).max_z) as usize - ptr as usize }, 36usize, concat!( "Offset of field: ", stringify!(di_cta_room_configuration), "::", stringify!(max_z) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).display_x) as usize - ptr as usize }, 40usize, concat!( "Offset of field: ", stringify!(di_cta_room_configuration), "::", stringify!(display_x) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).display_y) as usize - ptr as usize }, 48usize, concat!( "Offset of field: ", stringify!(di_cta_room_configuration), "::", stringify!(display_y) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).display_z) as usize - ptr as usize }, 56usize, concat!( "Offset of field: ", stringify!(di_cta_room_configuration), "::", stringify!(display_z) ) ); } #[cfg(feature = "v0_2")] extern "C" { #[doc = " Get the Room Configuration from a CTA data block.\n\n Returns NULL if the data block tag is not DI_CTA_DATA_BLOCK_ROOM_CONFIG."] pub fn di_cta_data_block_get_room_configuration( block: *const di_cta_data_block, ) -> *const di_cta_room_configuration; } #[cfg(feature = "v0_2")] pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_FL: di_cta_speaker_placement = 0; #[cfg(feature = "v0_2")] pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_FR: di_cta_speaker_placement = 1; #[cfg(feature = "v0_2")] pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_FC: di_cta_speaker_placement = 2; #[cfg(feature = "v0_2")] pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_LFE1: di_cta_speaker_placement = 3; #[cfg(feature = "v0_2")] pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_BL: di_cta_speaker_placement = 4; #[cfg(feature = "v0_2")] pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_BR: di_cta_speaker_placement = 5; #[cfg(feature = "v0_2")] pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_FLC: di_cta_speaker_placement = 6; #[cfg(feature = "v0_2")] pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_FRC: di_cta_speaker_placement = 7; #[cfg(feature = "v0_2")] pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_BC: di_cta_speaker_placement = 8; #[cfg(feature = "v0_2")] pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_LFE2: di_cta_speaker_placement = 9; #[cfg(feature = "v0_2")] pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_SIL: di_cta_speaker_placement = 10; #[cfg(feature = "v0_2")] pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_SIR: di_cta_speaker_placement = 11; #[cfg(feature = "v0_2")] pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_TPFL: di_cta_speaker_placement = 12; #[cfg(feature = "v0_2")] pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_TPFR: di_cta_speaker_placement = 13; #[cfg(feature = "v0_2")] pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_TPFC: di_cta_speaker_placement = 14; #[cfg(feature = "v0_2")] pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_TPC: di_cta_speaker_placement = 15; #[cfg(feature = "v0_2")] pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_TPBL: di_cta_speaker_placement = 16; #[cfg(feature = "v0_2")] pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_TPBR: di_cta_speaker_placement = 17; #[cfg(feature = "v0_2")] pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_TPSIL: di_cta_speaker_placement = 18; #[cfg(feature = "v0_2")] pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_TPSIR: di_cta_speaker_placement = 19; #[cfg(feature = "v0_2")] pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_TPBC: di_cta_speaker_placement = 20; #[cfg(feature = "v0_2")] pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_BTFC: di_cta_speaker_placement = 21; #[cfg(feature = "v0_2")] pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_BTFL: di_cta_speaker_placement = 22; #[cfg(feature = "v0_2")] pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_BRFR: di_cta_speaker_placement = 23; #[cfg(feature = "v0_2")] pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_FLW: di_cta_speaker_placement = 24; #[cfg(feature = "v0_2")] pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_FRW: di_cta_speaker_placement = 25; #[cfg(feature = "v0_2")] pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_LS: di_cta_speaker_placement = 26; #[cfg(feature = "v0_2")] pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_RS: di_cta_speaker_placement = 27; #[cfg(feature = "v0_2")] pub type di_cta_speaker_placement = ::std::os::raw::c_uint; #[doc = " Speaker Location Data Block, defined in section 7.5.16."] #[repr(C)] #[derive(Debug, Copy, Clone)] #[cfg(feature = "v0_2")] pub struct di_cta_speaker_locations { pub channel_index: ::std::os::raw::c_int, pub is_active: bool, pub has_coords: bool, pub x: f64, pub y: f64, pub z: f64, pub speaker_id: di_cta_speaker_placement, } #[test] #[cfg(feature = "v0_2")] fn bindgen_test_layout_di_cta_speaker_locations() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 40usize, concat!("Size of: ", stringify!(di_cta_speaker_locations)) ); assert_eq!( ::std::mem::align_of::(), 8usize, concat!("Alignment of ", stringify!(di_cta_speaker_locations)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).channel_index) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_cta_speaker_locations), "::", stringify!(channel_index) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).is_active) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", stringify!(di_cta_speaker_locations), "::", stringify!(is_active) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).has_coords) as usize - ptr as usize }, 5usize, concat!( "Offset of field: ", stringify!(di_cta_speaker_locations), "::", stringify!(has_coords) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", stringify!(di_cta_speaker_locations), "::", stringify!(x) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize }, 16usize, concat!( "Offset of field: ", stringify!(di_cta_speaker_locations), "::", stringify!(y) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).z) as usize - ptr as usize }, 24usize, concat!( "Offset of field: ", stringify!(di_cta_speaker_locations), "::", stringify!(z) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).speaker_id) as usize - ptr as usize }, 32usize, concat!( "Offset of field: ", stringify!(di_cta_speaker_locations), "::", stringify!(speaker_id) ) ); } #[cfg(feature = "v0_2")] extern "C" { #[doc = " Get an array of Speaker Locations.\n\n Returns NULL if the data block tag is not DI_CTA_DATA_BLOCK_SPEAKER_LOCATION.\n\n The returned array is NULL-terminated."] pub fn di_cta_data_block_get_speaker_locations( block: *const di_cta_data_block, ) -> *const *const di_cta_speaker_locations; } #[repr(C)] #[derive(Debug, Copy, Clone)] #[cfg(feature = "v0_2")] pub struct di_displayid_type_i_ii_vii_timing { _unused: [u8; 0], } #[cfg(feature = "v0_2")] extern "C" { #[doc = " Get the DisplayID Type VII Video Timing from a CTA data block.\n\n Returns NULL if the data block tag is not\n DI_CTA_DATA_BLOCK_DISPLAYID_VIDEO_TIMING_VII."] pub fn di_cta_data_block_get_did_type_vii_timing( block: *const di_cta_data_block, ) -> *const di_displayid_type_i_ii_vii_timing; } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_edid_detailed_timing_def { _unused: [u8; 0], } extern "C" { #[doc = " Get a list of EDID detailed timing definitions.\n\n The returned array is NULL-terminated."] pub fn di_edid_cta_get_detailed_timing_defs( cta: *const di_edid_cta, ) -> *const *const di_edid_detailed_timing_def; } #[cfg(feature = "v0_2")] pub const di_cta_svr_type_DI_CTA_SVR_TYPE_VIC: di_cta_svr_type = 0; #[cfg(feature = "v0_2")] pub const di_cta_svr_type_DI_CTA_SVR_TYPE_DTD_INDEX: di_cta_svr_type = 1; #[cfg(feature = "v0_2")] pub const di_cta_svr_type_DI_CTA_SVR_TYPE_T7T10VTDB: di_cta_svr_type = 2; #[cfg(feature = "v0_2")] pub const di_cta_svr_type_DI_CTA_SVR_TYPE_FIRST_T8VTDB: di_cta_svr_type = 3; #[cfg(feature = "v0_2")] pub type di_cta_svr_type = ::std::os::raw::c_uint; #[doc = " Short Video Reference, defined in section 7.5.12."] #[repr(C)] #[derive(Debug, Copy, Clone)] #[cfg(feature = "v0_2")] pub struct di_cta_svr { pub type_: di_cta_svr_type, pub vic: u8, pub dtd_index: u8, pub t7_t10_vtdb_index: u8, } #[test] #[cfg(feature = "v0_2")] fn bindgen_test_layout_di_cta_svr() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 8usize, concat!("Size of: ", stringify!(di_cta_svr)) ); assert_eq!( ::std::mem::align_of::(), 4usize, concat!("Alignment of ", stringify!(di_cta_svr)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_cta_svr), "::", stringify!(type_) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).vic) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", stringify!(di_cta_svr), "::", stringify!(vic) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).dtd_index) as usize - ptr as usize }, 5usize, concat!( "Offset of field: ", stringify!(di_cta_svr), "::", stringify!(dtd_index) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).t7_t10_vtdb_index) as usize - ptr as usize }, 6usize, concat!( "Offset of field: ", stringify!(di_cta_svr), "::", stringify!(t7_t10_vtdb_index) ) ); } #[cfg(feature = "v0_2")] extern "C" { #[doc = " Get an array of Short Video References (SVRs) from a CTA data block. The\n first SVR refers to the most-preferred Video Format, while the next SVRs\n are listed in order of decreasing preference.\n\n Returns NULL if the data block tag is not\n DI_CTA_DATA_BLOCK_VIDEO_FORMAT_PREF.\n\n The returned array is NULL-terminated."] pub fn di_cta_data_block_get_svrs(block: *const di_cta_data_block) -> *const *const di_cta_svr; } libdisplay-info-sys-0.2.2/src/cvt.rs000064400000000000000000000175431046102023000154710ustar 00000000000000/* automatically generated by rust-bindgen 0.68.1 */ pub const di_cvt_reduced_blanking_version_DI_CVT_REDUCED_BLANKING_NONE: di_cvt_reduced_blanking_version = 0; pub const di_cvt_reduced_blanking_version_DI_CVT_REDUCED_BLANKING_V1: di_cvt_reduced_blanking_version = 1; pub const di_cvt_reduced_blanking_version_DI_CVT_REDUCED_BLANKING_V2: di_cvt_reduced_blanking_version = 2; pub const di_cvt_reduced_blanking_version_DI_CVT_REDUCED_BLANKING_V3: di_cvt_reduced_blanking_version = 3; pub type di_cvt_reduced_blanking_version = ::std::os::raw::c_uint; #[doc = " Input parameters, defined in table 3-1."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_cvt_options { pub red_blank_ver: di_cvt_reduced_blanking_version, pub h_pixels: i32, pub v_lines: i32, pub ip_freq_rqd: f64, pub video_opt: bool, pub vblank: f64, pub additional_hblank: i32, pub early_vsync_rqd: bool, pub int_rqd: bool, pub margins_rqd: bool, } #[test] fn bindgen_test_layout_di_cvt_options() { 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!(di_cvt_options)) ); assert_eq!( ::std::mem::align_of::(), 8usize, concat!("Alignment of ", stringify!(di_cvt_options)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).red_blank_ver) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_cvt_options), "::", stringify!(red_blank_ver) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).h_pixels) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", stringify!(di_cvt_options), "::", stringify!(h_pixels) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).v_lines) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", stringify!(di_cvt_options), "::", stringify!(v_lines) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).ip_freq_rqd) as usize - ptr as usize }, 16usize, concat!( "Offset of field: ", stringify!(di_cvt_options), "::", stringify!(ip_freq_rqd) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).video_opt) as usize - ptr as usize }, 24usize, concat!( "Offset of field: ", stringify!(di_cvt_options), "::", stringify!(video_opt) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).vblank) as usize - ptr as usize }, 32usize, concat!( "Offset of field: ", stringify!(di_cvt_options), "::", stringify!(vblank) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).additional_hblank) as usize - ptr as usize }, 40usize, concat!( "Offset of field: ", stringify!(di_cvt_options), "::", stringify!(additional_hblank) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).early_vsync_rqd) as usize - ptr as usize }, 44usize, concat!( "Offset of field: ", stringify!(di_cvt_options), "::", stringify!(early_vsync_rqd) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).int_rqd) as usize - ptr as usize }, 45usize, concat!( "Offset of field: ", stringify!(di_cvt_options), "::", stringify!(int_rqd) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).margins_rqd) as usize - ptr as usize }, 46usize, concat!( "Offset of field: ", stringify!(di_cvt_options), "::", stringify!(margins_rqd) ) ); } #[doc = " Output parameters, defined in table 3-4."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_cvt_timing { pub act_pixel_freq: f64, pub total_active_pixels: f64, pub v_lines_rnd: f64, pub h_front_porch: f64, pub h_sync: f64, pub h_back_porch: f64, pub v_front_porch: f64, pub v_sync: f64, pub v_back_porch: f64, pub act_frame_rate: f64, } #[test] fn bindgen_test_layout_di_cvt_timing() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 80usize, concat!("Size of: ", stringify!(di_cvt_timing)) ); assert_eq!( ::std::mem::align_of::(), 8usize, concat!("Alignment of ", stringify!(di_cvt_timing)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).act_pixel_freq) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_cvt_timing), "::", stringify!(act_pixel_freq) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).total_active_pixels) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", stringify!(di_cvt_timing), "::", stringify!(total_active_pixels) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).v_lines_rnd) as usize - ptr as usize }, 16usize, concat!( "Offset of field: ", stringify!(di_cvt_timing), "::", stringify!(v_lines_rnd) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).h_front_porch) as usize - ptr as usize }, 24usize, concat!( "Offset of field: ", stringify!(di_cvt_timing), "::", stringify!(h_front_porch) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).h_sync) as usize - ptr as usize }, 32usize, concat!( "Offset of field: ", stringify!(di_cvt_timing), "::", stringify!(h_sync) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).h_back_porch) as usize - ptr as usize }, 40usize, concat!( "Offset of field: ", stringify!(di_cvt_timing), "::", stringify!(h_back_porch) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).v_front_porch) as usize - ptr as usize }, 48usize, concat!( "Offset of field: ", stringify!(di_cvt_timing), "::", stringify!(v_front_porch) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).v_sync) as usize - ptr as usize }, 56usize, concat!( "Offset of field: ", stringify!(di_cvt_timing), "::", stringify!(v_sync) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).v_back_porch) as usize - ptr as usize }, 64usize, concat!( "Offset of field: ", stringify!(di_cvt_timing), "::", stringify!(v_back_porch) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).act_frame_rate) as usize - ptr as usize }, 72usize, concat!( "Offset of field: ", stringify!(di_cvt_timing), "::", stringify!(act_frame_rate) ) ); } extern "C" { #[doc = " Compute a timing via the CVT formula."] pub fn di_cvt_compute(t: *mut di_cvt_timing, options: *const di_cvt_options); } libdisplay-info-sys-0.2.2/src/displayid.rs000064400000000000000000001027551046102023000166570ustar 00000000000000/* automatically generated by rust-bindgen 0.68.1 */ #[doc = " DisplayID data structure."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_displayid { _unused: [u8; 0], } extern "C" { #[doc = " Get the DisplayID version."] pub fn di_displayid_get_version(displayid: *const di_displayid) -> ::std::os::raw::c_int; } extern "C" { #[doc = " Get the DisplayID revision."] pub fn di_displayid_get_revision(displayid: *const di_displayid) -> ::std::os::raw::c_int; } pub const di_displayid_product_type_DI_DISPLAYID_PRODUCT_TYPE_EXTENSION: di_displayid_product_type = 0; pub const di_displayid_product_type_DI_DISPLAYID_PRODUCT_TYPE_TEST: di_displayid_product_type = 1; pub const di_displayid_product_type_DI_DISPLAYID_PRODUCT_TYPE_DISPLAY_PANEL: di_displayid_product_type = 2; pub const di_displayid_product_type_DI_DISPLAYID_PRODUCT_TYPE_STANDALONE_DISPLAY: di_displayid_product_type = 3; pub const di_displayid_product_type_DI_DISPLAYID_PRODUCT_TYPE_TV_RECEIVER: di_displayid_product_type = 4; pub const di_displayid_product_type_DI_DISPLAYID_PRODUCT_TYPE_REPEATER: di_displayid_product_type = 5; pub const di_displayid_product_type_DI_DISPLAYID_PRODUCT_TYPE_DIRECT_DRIVE: di_displayid_product_type = 6; #[doc = " Product type identifier, defined in section 2.3."] pub type di_displayid_product_type = ::std::os::raw::c_uint; extern "C" { #[doc = " Get the DisplayID product type."] pub fn di_displayid_get_product_type( displayid: *const di_displayid, ) -> di_displayid_product_type; } pub const di_displayid_data_block_tag_DI_DISPLAYID_DATA_BLOCK_PRODUCT_ID: di_displayid_data_block_tag = 0; pub const di_displayid_data_block_tag_DI_DISPLAYID_DATA_BLOCK_DISPLAY_PARAMS: di_displayid_data_block_tag = 1; pub const di_displayid_data_block_tag_DI_DISPLAYID_DATA_BLOCK_COLOR_CHARACT: di_displayid_data_block_tag = 2; pub const di_displayid_data_block_tag_DI_DISPLAYID_DATA_BLOCK_TYPE_I_TIMING: di_displayid_data_block_tag = 3; pub const di_displayid_data_block_tag_DI_DISPLAYID_DATA_BLOCK_TYPE_II_TIMING: di_displayid_data_block_tag = 4; pub const di_displayid_data_block_tag_DI_DISPLAYID_DATA_BLOCK_TYPE_III_TIMING: di_displayid_data_block_tag = 5; pub const di_displayid_data_block_tag_DI_DISPLAYID_DATA_BLOCK_TYPE_IV_TIMING: di_displayid_data_block_tag = 6; pub const di_displayid_data_block_tag_DI_DISPLAYID_DATA_BLOCK_VESA_TIMING: di_displayid_data_block_tag = 7; pub const di_displayid_data_block_tag_DI_DISPLAYID_DATA_BLOCK_CEA_TIMING: di_displayid_data_block_tag = 8; pub const di_displayid_data_block_tag_DI_DISPLAYID_DATA_BLOCK_TIMING_RANGE_LIMITS: di_displayid_data_block_tag = 9; pub const di_displayid_data_block_tag_DI_DISPLAYID_DATA_BLOCK_PRODUCT_SERIAL: di_displayid_data_block_tag = 10; pub const di_displayid_data_block_tag_DI_DISPLAYID_DATA_BLOCK_ASCII_STRING: di_displayid_data_block_tag = 11; pub const di_displayid_data_block_tag_DI_DISPLAYID_DATA_BLOCK_DISPLAY_DEVICE_DATA: di_displayid_data_block_tag = 12; pub const di_displayid_data_block_tag_DI_DISPLAYID_DATA_BLOCK_INTERFACE_POWER_SEQ: di_displayid_data_block_tag = 13; pub const di_displayid_data_block_tag_DI_DISPLAYID_DATA_BLOCK_TRANSFER_CHARACT: di_displayid_data_block_tag = 14; pub const di_displayid_data_block_tag_DI_DISPLAYID_DATA_BLOCK_DISPLAY_INTERFACE: di_displayid_data_block_tag = 15; pub const di_displayid_data_block_tag_DI_DISPLAYID_DATA_BLOCK_STEREO_DISPLAY_INTERFACE: di_displayid_data_block_tag = 16; pub const di_displayid_data_block_tag_DI_DISPLAYID_DATA_BLOCK_TYPE_V_TIMING: di_displayid_data_block_tag = 17; pub const di_displayid_data_block_tag_DI_DISPLAYID_DATA_BLOCK_TILED_DISPLAY_TOPO: di_displayid_data_block_tag = 18; pub const di_displayid_data_block_tag_DI_DISPLAYID_DATA_BLOCK_TYPE_VI_TIMING: di_displayid_data_block_tag = 19; #[doc = " DisplayID data block tag."] pub type di_displayid_data_block_tag = ::std::os::raw::c_uint; #[doc = " A DisplayID data block."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_displayid_data_block { _unused: [u8; 0], } extern "C" { #[doc = " Get a DisplayID data block tag."] pub fn di_displayid_data_block_get_tag( data_block: *const di_displayid_data_block, ) -> di_displayid_data_block_tag; } #[doc = " Display parameters feature support flags, defined in section 4.2.3."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_displayid_display_params_features { pub audio: bool, pub separate_audio_inputs: bool, pub audio_input_override: bool, pub power_management: bool, pub fixed_timing: bool, pub fixed_pixel_format: bool, pub ai: bool, pub deinterlacing: bool, } #[test] fn bindgen_test_layout_di_displayid_display_params_features() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 8usize, concat!( "Size of: ", stringify!(di_displayid_display_params_features) ) ); assert_eq!( ::std::mem::align_of::(), 1usize, concat!( "Alignment of ", stringify!(di_displayid_display_params_features) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).audio) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_displayid_display_params_features), "::", stringify!(audio) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).separate_audio_inputs) as usize - ptr as usize }, 1usize, concat!( "Offset of field: ", stringify!(di_displayid_display_params_features), "::", stringify!(separate_audio_inputs) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).audio_input_override) as usize - ptr as usize }, 2usize, concat!( "Offset of field: ", stringify!(di_displayid_display_params_features), "::", stringify!(audio_input_override) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).power_management) as usize - ptr as usize }, 3usize, concat!( "Offset of field: ", stringify!(di_displayid_display_params_features), "::", stringify!(power_management) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).fixed_timing) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", stringify!(di_displayid_display_params_features), "::", stringify!(fixed_timing) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).fixed_pixel_format) as usize - ptr as usize }, 5usize, concat!( "Offset of field: ", stringify!(di_displayid_display_params_features), "::", stringify!(fixed_pixel_format) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).ai) as usize - ptr as usize }, 6usize, concat!( "Offset of field: ", stringify!(di_displayid_display_params_features), "::", stringify!(ai) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).deinterlacing) as usize - ptr as usize }, 7usize, concat!( "Offset of field: ", stringify!(di_displayid_display_params_features), "::", stringify!(deinterlacing) ) ); } #[doc = " Display parameters data block, defined in section 4.2."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_displayid_display_params { pub horiz_image_mm: f32, pub vert_image_mm: f32, pub horiz_pixels: i32, pub vert_pixels: i32, pub features: *const di_displayid_display_params_features, pub gamma: f32, pub aspect_ratio: f32, pub bits_per_color_overall: i32, pub bits_per_color_native: i32, } #[test] fn bindgen_test_layout_di_displayid_display_params() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 40usize, concat!("Size of: ", stringify!(di_displayid_display_params)) ); assert_eq!( ::std::mem::align_of::(), 8usize, concat!("Alignment of ", stringify!(di_displayid_display_params)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).horiz_image_mm) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_displayid_display_params), "::", stringify!(horiz_image_mm) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).vert_image_mm) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", stringify!(di_displayid_display_params), "::", stringify!(vert_image_mm) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).horiz_pixels) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", stringify!(di_displayid_display_params), "::", stringify!(horiz_pixels) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).vert_pixels) as usize - ptr as usize }, 12usize, concat!( "Offset of field: ", stringify!(di_displayid_display_params), "::", stringify!(vert_pixels) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).features) as usize - ptr as usize }, 16usize, concat!( "Offset of field: ", stringify!(di_displayid_display_params), "::", stringify!(features) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).gamma) as usize - ptr as usize }, 24usize, concat!( "Offset of field: ", stringify!(di_displayid_display_params), "::", stringify!(gamma) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).aspect_ratio) as usize - ptr as usize }, 28usize, concat!( "Offset of field: ", stringify!(di_displayid_display_params), "::", stringify!(aspect_ratio) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).bits_per_color_overall) as usize - ptr as usize }, 32usize, concat!( "Offset of field: ", stringify!(di_displayid_display_params), "::", stringify!(bits_per_color_overall) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).bits_per_color_native) as usize - ptr as usize }, 36usize, concat!( "Offset of field: ", stringify!(di_displayid_display_params), "::", stringify!(bits_per_color_native) ) ); } extern "C" { #[doc = " Get display parameters from a DisplayID data block.\n\n Returns NULL if the data block tag isn't\n DI_DISPLAYID_DATA_BLOCK_DISPLAY_PARAMS."] pub fn di_displayid_data_block_get_display_params( data_block: *const di_displayid_data_block, ) -> *const di_displayid_display_params; } pub const di_displayid_type_i_ii_vii_timing_stereo_3d_DI_DISPLAYID_TYPE_I_II_VII_TIMING_STEREO_3D_NEVER : di_displayid_type_i_ii_vii_timing_stereo_3d = 0 ; pub const di_displayid_type_i_ii_vii_timing_stereo_3d_DI_DISPLAYID_TYPE_I_II_VII_TIMING_STEREO_3D_ALWAYS : di_displayid_type_i_ii_vii_timing_stereo_3d = 1 ; pub const di_displayid_type_i_ii_vii_timing_stereo_3d_DI_DISPLAYID_TYPE_I_II_VII_TIMING_STEREO_3D_USER : di_displayid_type_i_ii_vii_timing_stereo_3d = 2 ; pub type di_displayid_type_i_ii_vii_timing_stereo_3d = ::std::os::raw::c_uint; pub const di_displayid_timing_aspect_ratio_DI_DISPLAYID_TIMING_ASPECT_RATIO_1_1: di_displayid_timing_aspect_ratio = 0; pub const di_displayid_timing_aspect_ratio_DI_DISPLAYID_TIMING_ASPECT_RATIO_5_4: di_displayid_timing_aspect_ratio = 1; pub const di_displayid_timing_aspect_ratio_DI_DISPLAYID_TIMING_ASPECT_RATIO_4_3: di_displayid_timing_aspect_ratio = 2; pub const di_displayid_timing_aspect_ratio_DI_DISPLAYID_TIMING_ASPECT_RATIO_15_9: di_displayid_timing_aspect_ratio = 3; pub const di_displayid_timing_aspect_ratio_DI_DISPLAYID_TIMING_ASPECT_RATIO_16_9: di_displayid_timing_aspect_ratio = 4; pub const di_displayid_timing_aspect_ratio_DI_DISPLAYID_TIMING_ASPECT_RATIO_16_10: di_displayid_timing_aspect_ratio = 5; pub const di_displayid_timing_aspect_ratio_DI_DISPLAYID_TIMING_ASPECT_RATIO_64_27: di_displayid_timing_aspect_ratio = 6; pub const di_displayid_timing_aspect_ratio_DI_DISPLAYID_TIMING_ASPECT_RATIO_256_135: di_displayid_timing_aspect_ratio = 7; pub const di_displayid_timing_aspect_ratio_DI_DISPLAYID_TIMING_ASPECT_RATIO_UNDEFINED: di_displayid_timing_aspect_ratio = 8; pub type di_displayid_timing_aspect_ratio = ::std::os::raw::c_uint; pub const di_displayid_type_i_ii_vii_timing_sync_polarity_DI_DISPLAYID_TYPE_I_II_VII_TIMING_SYNC_NEGATIVE : di_displayid_type_i_ii_vii_timing_sync_polarity = 0 ; pub const di_displayid_type_i_ii_vii_timing_sync_polarity_DI_DISPLAYID_TYPE_I_II_VII_TIMING_SYNC_POSITIVE : di_displayid_type_i_ii_vii_timing_sync_polarity = 1 ; pub type di_displayid_type_i_ii_vii_timing_sync_polarity = ::std::os::raw::c_uint; #[doc = " Type I timing, defined in DisplayID 1.3 section 4.4.1 and\n Type II timing, defined in DisplayID 1.3 section 4.4.2 and\n Type VII timing, defined in DisplayID 2.0 section 4.3.1."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_displayid_type_i_ii_vii_timing { pub pixel_clock_mhz: f64, pub preferred: bool, pub stereo_3d: di_displayid_type_i_ii_vii_timing_stereo_3d, pub interlaced: bool, pub aspect_ratio: di_displayid_timing_aspect_ratio, pub horiz_active: i32, pub vert_active: i32, pub horiz_blank: i32, pub vert_blank: i32, pub horiz_offset: i32, pub vert_offset: i32, pub horiz_sync_width: i32, pub vert_sync_width: i32, pub horiz_sync_polarity: di_displayid_type_i_ii_vii_timing_sync_polarity, pub vert_sync_polarity: di_displayid_type_i_ii_vii_timing_sync_polarity, } #[test] fn bindgen_test_layout_di_displayid_type_i_ii_vii_timing() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 64usize, concat!("Size of: ", stringify!(di_displayid_type_i_ii_vii_timing)) ); assert_eq!( ::std::mem::align_of::(), 8usize, concat!( "Alignment of ", stringify!(di_displayid_type_i_ii_vii_timing) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).pixel_clock_mhz) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_displayid_type_i_ii_vii_timing), "::", stringify!(pixel_clock_mhz) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).preferred) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", stringify!(di_displayid_type_i_ii_vii_timing), "::", stringify!(preferred) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).stereo_3d) as usize - ptr as usize }, 12usize, concat!( "Offset of field: ", stringify!(di_displayid_type_i_ii_vii_timing), "::", stringify!(stereo_3d) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).interlaced) as usize - ptr as usize }, 16usize, concat!( "Offset of field: ", stringify!(di_displayid_type_i_ii_vii_timing), "::", stringify!(interlaced) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).aspect_ratio) as usize - ptr as usize }, 20usize, concat!( "Offset of field: ", stringify!(di_displayid_type_i_ii_vii_timing), "::", stringify!(aspect_ratio) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).horiz_active) as usize - ptr as usize }, 24usize, concat!( "Offset of field: ", stringify!(di_displayid_type_i_ii_vii_timing), "::", stringify!(horiz_active) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).vert_active) as usize - ptr as usize }, 28usize, concat!( "Offset of field: ", stringify!(di_displayid_type_i_ii_vii_timing), "::", stringify!(vert_active) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).horiz_blank) as usize - ptr as usize }, 32usize, concat!( "Offset of field: ", stringify!(di_displayid_type_i_ii_vii_timing), "::", stringify!(horiz_blank) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).vert_blank) as usize - ptr as usize }, 36usize, concat!( "Offset of field: ", stringify!(di_displayid_type_i_ii_vii_timing), "::", stringify!(vert_blank) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).horiz_offset) as usize - ptr as usize }, 40usize, concat!( "Offset of field: ", stringify!(di_displayid_type_i_ii_vii_timing), "::", stringify!(horiz_offset) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).vert_offset) as usize - ptr as usize }, 44usize, concat!( "Offset of field: ", stringify!(di_displayid_type_i_ii_vii_timing), "::", stringify!(vert_offset) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).horiz_sync_width) as usize - ptr as usize }, 48usize, concat!( "Offset of field: ", stringify!(di_displayid_type_i_ii_vii_timing), "::", stringify!(horiz_sync_width) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).vert_sync_width) as usize - ptr as usize }, 52usize, concat!( "Offset of field: ", stringify!(di_displayid_type_i_ii_vii_timing), "::", stringify!(vert_sync_width) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).horiz_sync_polarity) as usize - ptr as usize }, 56usize, concat!( "Offset of field: ", stringify!(di_displayid_type_i_ii_vii_timing), "::", stringify!(horiz_sync_polarity) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).vert_sync_polarity) as usize - ptr as usize }, 60usize, concat!( "Offset of field: ", stringify!(di_displayid_type_i_ii_vii_timing), "::", stringify!(vert_sync_polarity) ) ); } extern "C" { #[doc = " Get type I timings from a DisplayID data block.\n\n The returned array is NULL-terminated.\n\n Returns NULL if the data block tag isn't\n DI_DISPLAYID_DATA_BLOCK_TYPE_I_TIMING."] pub fn di_displayid_data_block_get_type_i_timings( data_block: *const di_displayid_data_block, ) -> *const *const di_displayid_type_i_ii_vii_timing; } #[cfg(feature = "v0_2")] extern "C" { #[doc = " Get type II timings from a DisplayID data block.\n\n The returned array is NULL-terminated.\n\n Returns NULL if the data block tag isn't\n DI_DISPLAYID_DATA_BLOCK_TYPE_II_TIMING."] pub fn di_displayid_data_block_get_type_ii_timings( data_block: *const di_displayid_data_block, ) -> *const *const di_displayid_type_i_ii_vii_timing; } pub const di_displayid_tiled_topo_missing_recv_behavior_DI_DISPLAYID_TILED_TOPO_MISSING_RECV_UNDEF : di_displayid_tiled_topo_missing_recv_behavior = 0 ; pub const di_displayid_tiled_topo_missing_recv_behavior_DI_DISPLAYID_TILED_TOPO_MISSING_RECV_TILE_ONLY : di_displayid_tiled_topo_missing_recv_behavior = 1 ; #[doc = " Behavior when more than 1 tile and less than total number of tiles are driven\n by the source."] pub type di_displayid_tiled_topo_missing_recv_behavior = ::std::os::raw::c_uint; pub const di_displayid_tiled_topo_single_recv_behavior_DI_DISPLAYID_TILED_TOPO_SINGLE_RECV_UNDEF: di_displayid_tiled_topo_single_recv_behavior = 0; pub const di_displayid_tiled_topo_single_recv_behavior_DI_DISPLAYID_TILED_TOPO_SINGLE_RECV_TILE_ONLY : di_displayid_tiled_topo_single_recv_behavior = 1 ; pub const di_displayid_tiled_topo_single_recv_behavior_DI_DISPLAYID_TILED_TOPO_SINGLE_RECV_SCALED : di_displayid_tiled_topo_single_recv_behavior = 2 ; pub const di_displayid_tiled_topo_single_recv_behavior_DI_DISPLAYID_TILED_TOPO_SINGLE_RECV_CLONED : di_displayid_tiled_topo_single_recv_behavior = 3 ; #[doc = " Behavior of this tile when it is the only tile receiving an image from the\n source."] pub type di_displayid_tiled_topo_single_recv_behavior = ::std::os::raw::c_uint; #[doc = " Tiled display capabilities."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_displayid_tiled_topo_caps { pub single_enclosure: bool, pub missing_recv_behavior: di_displayid_tiled_topo_missing_recv_behavior, pub single_recv_behavior: di_displayid_tiled_topo_single_recv_behavior, } #[test] fn bindgen_test_layout_di_displayid_tiled_topo_caps() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 12usize, concat!("Size of: ", stringify!(di_displayid_tiled_topo_caps)) ); assert_eq!( ::std::mem::align_of::(), 4usize, concat!("Alignment of ", stringify!(di_displayid_tiled_topo_caps)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).single_enclosure) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_displayid_tiled_topo_caps), "::", stringify!(single_enclosure) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).missing_recv_behavior) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", stringify!(di_displayid_tiled_topo_caps), "::", stringify!(missing_recv_behavior) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).single_recv_behavior) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", stringify!(di_displayid_tiled_topo_caps), "::", stringify!(single_recv_behavior) ) ); } #[doc = " Tiled display bezel information.\n\n The lengths are measured in pixels, accurate to the tenths place."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_displayid_tiled_topo_bezel { pub top_px: f32, pub bottom_px: f32, pub right_px: f32, pub left_px: f32, } #[test] fn bindgen_test_layout_di_displayid_tiled_topo_bezel() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 16usize, concat!("Size of: ", stringify!(di_displayid_tiled_topo_bezel)) ); assert_eq!( ::std::mem::align_of::(), 4usize, concat!("Alignment of ", stringify!(di_displayid_tiled_topo_bezel)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).top_px) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_displayid_tiled_topo_bezel), "::", stringify!(top_px) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).bottom_px) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", stringify!(di_displayid_tiled_topo_bezel), "::", stringify!(bottom_px) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).right_px) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", stringify!(di_displayid_tiled_topo_bezel), "::", stringify!(right_px) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).left_px) as usize - ptr as usize }, 12usize, concat!( "Offset of field: ", stringify!(di_displayid_tiled_topo_bezel), "::", stringify!(left_px) ) ); } #[doc = " Tiled display topology, defined in section 4.14."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_displayid_tiled_topo { pub caps: *const di_displayid_tiled_topo_caps, pub total_horiz_tiles: i32, pub total_vert_tiles: i32, pub horiz_tile_location: i32, pub vert_tile_location: i32, pub horiz_tile_pixels: i32, pub vert_tile_lines: i32, pub bezel: *const di_displayid_tiled_topo_bezel, pub vendor_id: [::std::os::raw::c_char; 3usize], pub product_code: u16, pub serial_number: u32, } #[test] fn bindgen_test_layout_di_displayid_tiled_topo() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 56usize, concat!("Size of: ", stringify!(di_displayid_tiled_topo)) ); assert_eq!( ::std::mem::align_of::(), 8usize, concat!("Alignment of ", stringify!(di_displayid_tiled_topo)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).caps) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_displayid_tiled_topo), "::", stringify!(caps) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).total_horiz_tiles) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", stringify!(di_displayid_tiled_topo), "::", stringify!(total_horiz_tiles) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).total_vert_tiles) as usize - ptr as usize }, 12usize, concat!( "Offset of field: ", stringify!(di_displayid_tiled_topo), "::", stringify!(total_vert_tiles) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).horiz_tile_location) as usize - ptr as usize }, 16usize, concat!( "Offset of field: ", stringify!(di_displayid_tiled_topo), "::", stringify!(horiz_tile_location) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).vert_tile_location) as usize - ptr as usize }, 20usize, concat!( "Offset of field: ", stringify!(di_displayid_tiled_topo), "::", stringify!(vert_tile_location) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).horiz_tile_pixels) as usize - ptr as usize }, 24usize, concat!( "Offset of field: ", stringify!(di_displayid_tiled_topo), "::", stringify!(horiz_tile_pixels) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).vert_tile_lines) as usize - ptr as usize }, 28usize, concat!( "Offset of field: ", stringify!(di_displayid_tiled_topo), "::", stringify!(vert_tile_lines) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).bezel) as usize - ptr as usize }, 32usize, concat!( "Offset of field: ", stringify!(di_displayid_tiled_topo), "::", stringify!(bezel) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).vendor_id) as usize - ptr as usize }, 40usize, concat!( "Offset of field: ", stringify!(di_displayid_tiled_topo), "::", stringify!(vendor_id) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).product_code) as usize - ptr as usize }, 44usize, concat!( "Offset of field: ", stringify!(di_displayid_tiled_topo), "::", stringify!(product_code) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).serial_number) as usize - ptr as usize }, 48usize, concat!( "Offset of field: ", stringify!(di_displayid_tiled_topo), "::", stringify!(serial_number) ) ); } extern "C" { #[doc = " Get tiled display topology from a DisplayID data block.\n\n Returns NULL if the data block tag isn't\n DI_DISPLAYID_DATA_BLOCK_TILED_DISPLAY_TOPO."] pub fn di_displayid_data_block_get_tiled_topo( data_block: *const di_displayid_data_block, ) -> *const di_displayid_tiled_topo; } #[cfg(feature = "v0_2")] pub const di_displayid_type_iii_timing_algo_DI_DISPLAYID_TYPE_III_TIMING_CVT_STANDARD_BLANKING: di_displayid_type_iii_timing_algo = 0; #[cfg(feature = "v0_2")] pub const di_displayid_type_iii_timing_algo_DI_DISPLAYID_TYPE_III_TIMING_CVT_REDUCED_BLANKING: di_displayid_type_iii_timing_algo = 1; #[doc = " Formula/algorithm for type III timings."] #[cfg(feature = "v0_2")] pub type di_displayid_type_iii_timing_algo = ::std::os::raw::c_uint; #[doc = " Type III timing, defined in section 4.4.3."] #[repr(C)] #[derive(Debug, Copy, Clone)] #[cfg(feature = "v0_2")] pub struct di_displayid_type_iii_timing { pub preferred: bool, pub algo: di_displayid_type_iii_timing_algo, pub aspect_ratio: di_displayid_timing_aspect_ratio, pub horiz_active: i32, pub interlaced: bool, pub refresh_rate_hz: i32, } #[test] #[cfg(feature = "v0_2")] fn bindgen_test_layout_di_displayid_type_iii_timing() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 24usize, concat!("Size of: ", stringify!(di_displayid_type_iii_timing)) ); assert_eq!( ::std::mem::align_of::(), 4usize, concat!("Alignment of ", stringify!(di_displayid_type_iii_timing)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).preferred) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_displayid_type_iii_timing), "::", stringify!(preferred) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).algo) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", stringify!(di_displayid_type_iii_timing), "::", stringify!(algo) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).aspect_ratio) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", stringify!(di_displayid_type_iii_timing), "::", stringify!(aspect_ratio) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).horiz_active) as usize - ptr as usize }, 12usize, concat!( "Offset of field: ", stringify!(di_displayid_type_iii_timing), "::", stringify!(horiz_active) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).interlaced) as usize - ptr as usize }, 16usize, concat!( "Offset of field: ", stringify!(di_displayid_type_iii_timing), "::", stringify!(interlaced) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).refresh_rate_hz) as usize - ptr as usize }, 20usize, concat!( "Offset of field: ", stringify!(di_displayid_type_iii_timing), "::", stringify!(refresh_rate_hz) ) ); } #[cfg(feature = "v0_2")] extern "C" { #[doc = " Get type III timings from a DisplayID data block.\n\n The returned array is NULL-terminated.\n\n Returns NULL if the data block tag isn't\n DI_DISPLAYID_DATA_BLOCK_TYPE_III_TIMING."] pub fn di_displayid_data_block_get_type_iii_timings( data_block: *const di_displayid_data_block, ) -> *const *const di_displayid_type_iii_timing; } extern "C" { #[doc = " Get DisplayID data blocks.\n\n The returned array is NULL-terminated."] pub fn di_displayid_get_data_blocks( displayid: *const di_displayid, ) -> *const *const di_displayid_data_block; } libdisplay-info-sys-0.2.2/src/dmt.rs000064400000000000000000000126451046102023000154570ustar 00000000000000/* automatically generated by rust-bindgen 0.68.1 */ #[doc = " A DMT timing."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_dmt_timing { pub dmt_id: u8, pub edid_std_id: u16, pub cvt_id: u32, pub horiz_video: i32, pub vert_video: i32, pub refresh_rate_hz: f32, pub pixel_clock_hz: i32, pub horiz_blank: i32, pub vert_blank: i32, pub horiz_front_porch: i32, pub vert_front_porch: i32, pub horiz_sync_pulse: i32, pub vert_sync_pulse: i32, pub horiz_border: i32, pub vert_border: i32, pub reduced_blanking: bool, } #[test] fn bindgen_test_layout_di_dmt_timing() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 60usize, concat!("Size of: ", stringify!(di_dmt_timing)) ); assert_eq!( ::std::mem::align_of::(), 4usize, concat!("Alignment of ", stringify!(di_dmt_timing)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).dmt_id) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_dmt_timing), "::", stringify!(dmt_id) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).edid_std_id) as usize - ptr as usize }, 2usize, concat!( "Offset of field: ", stringify!(di_dmt_timing), "::", stringify!(edid_std_id) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).cvt_id) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", stringify!(di_dmt_timing), "::", stringify!(cvt_id) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).horiz_video) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", stringify!(di_dmt_timing), "::", stringify!(horiz_video) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).vert_video) as usize - ptr as usize }, 12usize, concat!( "Offset of field: ", stringify!(di_dmt_timing), "::", stringify!(vert_video) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).refresh_rate_hz) as usize - ptr as usize }, 16usize, concat!( "Offset of field: ", stringify!(di_dmt_timing), "::", stringify!(refresh_rate_hz) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).pixel_clock_hz) as usize - ptr as usize }, 20usize, concat!( "Offset of field: ", stringify!(di_dmt_timing), "::", stringify!(pixel_clock_hz) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).horiz_blank) as usize - ptr as usize }, 24usize, concat!( "Offset of field: ", stringify!(di_dmt_timing), "::", stringify!(horiz_blank) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).vert_blank) as usize - ptr as usize }, 28usize, concat!( "Offset of field: ", stringify!(di_dmt_timing), "::", stringify!(vert_blank) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).horiz_front_porch) as usize - ptr as usize }, 32usize, concat!( "Offset of field: ", stringify!(di_dmt_timing), "::", stringify!(horiz_front_porch) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).vert_front_porch) as usize - ptr as usize }, 36usize, concat!( "Offset of field: ", stringify!(di_dmt_timing), "::", stringify!(vert_front_porch) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).horiz_sync_pulse) as usize - ptr as usize }, 40usize, concat!( "Offset of field: ", stringify!(di_dmt_timing), "::", stringify!(horiz_sync_pulse) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).vert_sync_pulse) as usize - ptr as usize }, 44usize, concat!( "Offset of field: ", stringify!(di_dmt_timing), "::", stringify!(vert_sync_pulse) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).horiz_border) as usize - ptr as usize }, 48usize, concat!( "Offset of field: ", stringify!(di_dmt_timing), "::", stringify!(horiz_border) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).vert_border) as usize - ptr as usize }, 52usize, concat!( "Offset of field: ", stringify!(di_dmt_timing), "::", stringify!(vert_border) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).reduced_blanking) as usize - ptr as usize }, 56usize, concat!( "Offset of field: ", stringify!(di_dmt_timing), "::", stringify!(reduced_blanking) ) ); } libdisplay-info-sys-0.2.2/src/edid.rs000064400000000000000000002355771046102023000156130ustar 00000000000000/* automatically generated by rust-bindgen 0.68.1 */ #[doc = " EDID data structure."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_edid { _unused: [u8; 0], } extern "C" { #[doc = " Get the EDID version."] pub fn di_edid_get_version(edid: *const di_edid) -> ::std::os::raw::c_int; } extern "C" { #[doc = " Get the EDID revision."] pub fn di_edid_get_revision(edid: *const di_edid) -> ::std::os::raw::c_int; } #[doc = " EDID vendor & product identification."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_edid_vendor_product { pub manufacturer: [::std::os::raw::c_char; 3usize], pub product: u16, pub serial: u32, pub manufacture_week: ::std::os::raw::c_int, pub manufacture_year: ::std::os::raw::c_int, pub model_year: ::std::os::raw::c_int, } #[test] fn bindgen_test_layout_di_edid_vendor_product() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 24usize, concat!("Size of: ", stringify!(di_edid_vendor_product)) ); assert_eq!( ::std::mem::align_of::(), 4usize, concat!("Alignment of ", stringify!(di_edid_vendor_product)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).manufacturer) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_edid_vendor_product), "::", stringify!(manufacturer) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).product) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", stringify!(di_edid_vendor_product), "::", stringify!(product) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).serial) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", stringify!(di_edid_vendor_product), "::", stringify!(serial) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).manufacture_week) as usize - ptr as usize }, 12usize, concat!( "Offset of field: ", stringify!(di_edid_vendor_product), "::", stringify!(manufacture_week) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).manufacture_year) as usize - ptr as usize }, 16usize, concat!( "Offset of field: ", stringify!(di_edid_vendor_product), "::", stringify!(manufacture_year) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).model_year) as usize - ptr as usize }, 20usize, concat!( "Offset of field: ", stringify!(di_edid_vendor_product), "::", stringify!(model_year) ) ); } extern "C" { pub fn di_edid_get_vendor_product(edid: *const di_edid) -> *const di_edid_vendor_product; } pub const di_edid_video_input_analog_signal_level_std_DI_EDID_VIDEO_INPUT_ANALOG_SIGNAL_LEVEL_0: di_edid_video_input_analog_signal_level_std = 0; pub const di_edid_video_input_analog_signal_level_std_DI_EDID_VIDEO_INPUT_ANALOG_SIGNAL_LEVEL_1: di_edid_video_input_analog_signal_level_std = 1; pub const di_edid_video_input_analog_signal_level_std_DI_EDID_VIDEO_INPUT_ANALOG_SIGNAL_LEVEL_2: di_edid_video_input_analog_signal_level_std = 2; pub const di_edid_video_input_analog_signal_level_std_DI_EDID_VIDEO_INPUT_ANALOG_SIGNAL_LEVEL_3: di_edid_video_input_analog_signal_level_std = 3; #[doc = " EDID analog signal level standard."] pub type di_edid_video_input_analog_signal_level_std = ::std::os::raw::c_uint; pub const di_edid_video_input_analog_video_setup_DI_EDID_VIDEO_INPUT_ANALOG_BLANK_LEVEL_EQ_BLACK: di_edid_video_input_analog_video_setup = 0; pub const di_edid_video_input_analog_video_setup_DI_EDID_VIDEO_INPUT_ANALOG_BLANK_TO_BLACK_SETUP_PEDESTAL : di_edid_video_input_analog_video_setup = 1 ; #[doc = " EDID analog video setup."] pub type di_edid_video_input_analog_video_setup = ::std::os::raw::c_uint; #[doc = " EDID analog video input basic information, defined in section 3.6.1."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_edid_video_input_analog { pub signal_level_std: di_edid_video_input_analog_signal_level_std, pub video_setup: di_edid_video_input_analog_video_setup, pub sync_separate: bool, pub sync_composite: bool, pub sync_on_green: bool, pub sync_serrations: bool, } #[test] fn bindgen_test_layout_di_edid_video_input_analog() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 12usize, concat!("Size of: ", stringify!(di_edid_video_input_analog)) ); assert_eq!( ::std::mem::align_of::(), 4usize, concat!("Alignment of ", stringify!(di_edid_video_input_analog)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).signal_level_std) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_edid_video_input_analog), "::", stringify!(signal_level_std) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).video_setup) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", stringify!(di_edid_video_input_analog), "::", stringify!(video_setup) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).sync_separate) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", stringify!(di_edid_video_input_analog), "::", stringify!(sync_separate) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).sync_composite) as usize - ptr as usize }, 9usize, concat!( "Offset of field: ", stringify!(di_edid_video_input_analog), "::", stringify!(sync_composite) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).sync_on_green) as usize - ptr as usize }, 10usize, concat!( "Offset of field: ", stringify!(di_edid_video_input_analog), "::", stringify!(sync_on_green) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).sync_serrations) as usize - ptr as usize }, 11usize, concat!( "Offset of field: ", stringify!(di_edid_video_input_analog), "::", stringify!(sync_serrations) ) ); } extern "C" { #[doc = " Get the analog video input basic information.\n\n Returns NULL if this isn't an analog display."] pub fn di_edid_get_video_input_analog( edid: *const di_edid, ) -> *const di_edid_video_input_analog; } pub const di_edid_video_input_digital_interface_DI_EDID_VIDEO_INPUT_DIGITAL_UNDEFINED: di_edid_video_input_digital_interface = 0; pub const di_edid_video_input_digital_interface_DI_EDID_VIDEO_INPUT_DIGITAL_DVI: di_edid_video_input_digital_interface = 1; pub const di_edid_video_input_digital_interface_DI_EDID_VIDEO_INPUT_DIGITAL_HDMI_A: di_edid_video_input_digital_interface = 2; pub const di_edid_video_input_digital_interface_DI_EDID_VIDEO_INPUT_DIGITAL_HDMI_B: di_edid_video_input_digital_interface = 3; pub const di_edid_video_input_digital_interface_DI_EDID_VIDEO_INPUT_DIGITAL_MDDI: di_edid_video_input_digital_interface = 4; pub const di_edid_video_input_digital_interface_DI_EDID_VIDEO_INPUT_DIGITAL_DISPLAYPORT: di_edid_video_input_digital_interface = 5; #[doc = " Digital video input interface standard."] pub type di_edid_video_input_digital_interface = ::std::os::raw::c_uint; #[doc = " EDID digital video input basic information, defined in section 3.6.1."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_edid_video_input_digital { pub dfp1: bool, pub color_bit_depth: ::std::os::raw::c_int, pub interface: di_edid_video_input_digital_interface, } #[test] fn bindgen_test_layout_di_edid_video_input_digital() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 12usize, concat!("Size of: ", stringify!(di_edid_video_input_digital)) ); assert_eq!( ::std::mem::align_of::(), 4usize, concat!("Alignment of ", stringify!(di_edid_video_input_digital)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).dfp1) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_edid_video_input_digital), "::", stringify!(dfp1) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).color_bit_depth) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", stringify!(di_edid_video_input_digital), "::", stringify!(color_bit_depth) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).interface) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", stringify!(di_edid_video_input_digital), "::", stringify!(interface) ) ); } extern "C" { #[doc = " Get the digital video input basic information.\n\n Returns NULL if this isn't a digital display."] pub fn di_edid_get_video_input_digital( edid: *const di_edid, ) -> *const di_edid_video_input_digital; } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_edid_screen_size { pub width_cm: ::std::os::raw::c_int, pub height_cm: ::std::os::raw::c_int, pub landscape_aspect_ratio: f32, pub portait_aspect_ratio: f32, } #[test] fn bindgen_test_layout_di_edid_screen_size() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 16usize, concat!("Size of: ", stringify!(di_edid_screen_size)) ); assert_eq!( ::std::mem::align_of::(), 4usize, concat!("Alignment of ", stringify!(di_edid_screen_size)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).width_cm) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_edid_screen_size), "::", stringify!(width_cm) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).height_cm) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", stringify!(di_edid_screen_size), "::", stringify!(height_cm) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).landscape_aspect_ratio) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", stringify!(di_edid_screen_size), "::", stringify!(landscape_aspect_ratio) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).portait_aspect_ratio) as usize - ptr as usize }, 12usize, concat!( "Offset of field: ", stringify!(di_edid_screen_size), "::", stringify!(portait_aspect_ratio) ) ); } extern "C" { #[doc = " Get the screen size."] pub fn di_edid_get_screen_size(edid: *const di_edid) -> *const di_edid_screen_size; } extern "C" { #[doc = " Get the display transfer characteristics from the basic EDID parameters, also\n known as \"gamma\".\n\n Returns 0 if unset (ie, stored in an extension block)."] pub fn di_edid_get_basic_gamma(edid: *const di_edid) -> f32; } #[doc = " Supported legacy Display Power Management Signaling (DPMS) states, defined in\n section 3.6.4.\n\n Display Power Management (DPM) compliant displays only support \"off\"."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_edid_dpms { pub standby: bool, pub suspend: bool, pub off: bool, } #[test] fn bindgen_test_layout_di_edid_dpms() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 3usize, concat!("Size of: ", stringify!(di_edid_dpms)) ); assert_eq!( ::std::mem::align_of::(), 1usize, concat!("Alignment of ", stringify!(di_edid_dpms)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).standby) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_edid_dpms), "::", stringify!(standby) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).suspend) as usize - ptr as usize }, 1usize, concat!( "Offset of field: ", stringify!(di_edid_dpms), "::", stringify!(suspend) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).off) as usize - ptr as usize }, 2usize, concat!( "Offset of field: ", stringify!(di_edid_dpms), "::", stringify!(off) ) ); } extern "C" { #[doc = " Get the set of supported legacy DPMS states."] pub fn di_edid_get_dpms(edid: *const di_edid) -> *const di_edid_dpms; } pub const di_edid_display_color_type_DI_EDID_DISPLAY_COLOR_MONOCHROME: di_edid_display_color_type = 0; pub const di_edid_display_color_type_DI_EDID_DISPLAY_COLOR_RGB: di_edid_display_color_type = 1; pub const di_edid_display_color_type_DI_EDID_DISPLAY_COLOR_NON_RGB: di_edid_display_color_type = 2; pub const di_edid_display_color_type_DI_EDID_DISPLAY_COLOR_UNDEFINED: di_edid_display_color_type = 3; #[doc = " Display color type."] pub type di_edid_display_color_type = ::std::os::raw::c_uint; extern "C" { #[doc = " Get the display color type.\n\n For digital displays using EDID 1.4 and later, DI_EDID_DISPLAY_COLOR_UNDEFINED\n is always returned."] pub fn di_edid_get_display_color_type(edid: *const di_edid) -> di_edid_display_color_type; } #[doc = " Basic color encoding formats, defined in section 3.6.4."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_edid_color_encoding_formats { pub rgb444: bool, pub ycrcb444: bool, pub ycrcb422: bool, } #[test] fn bindgen_test_layout_di_edid_color_encoding_formats() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 3usize, concat!("Size of: ", stringify!(di_edid_color_encoding_formats)) ); assert_eq!( ::std::mem::align_of::(), 1usize, concat!("Alignment of ", stringify!(di_edid_color_encoding_formats)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).rgb444) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_edid_color_encoding_formats), "::", stringify!(rgb444) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).ycrcb444) as usize - ptr as usize }, 1usize, concat!( "Offset of field: ", stringify!(di_edid_color_encoding_formats), "::", stringify!(ycrcb444) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).ycrcb422) as usize - ptr as usize }, 2usize, concat!( "Offset of field: ", stringify!(di_edid_color_encoding_formats), "::", stringify!(ycrcb422) ) ); } extern "C" { #[doc = " Get the set of supported color encoding formats.\n\n Returns NULL if the display is analog or if the color encoding formats are\n not specified."] pub fn di_edid_get_color_encoding_formats( edid: *const di_edid, ) -> *const di_edid_color_encoding_formats; } #[doc = " Miscellaneous basic features, defined in section 3.6.4.\n\n Note, the enum values don't match the specification."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_edid_misc_features { #[doc = " First detailed timing is the preferred timing.\n\n Always set for EDID 1.4 and later."] pub has_preferred_timing: bool, #[doc = " GTF using the default parameters is supported.\n\n Never set for EDID 1.4 and later."] pub default_gtf: bool, #[doc = " sRGB standard default color space is primary color space."] pub srgb_is_primary: bool, #[doc = " Preferred timing mode includes native pixel format and rate.\n\n Never set for EDID 1.3 and earlier."] pub preferred_timing_is_native: bool, #[doc = " GTF or CVT generated timings within the display's range limits are\n accepted.\n\n Never set for EDID 1.3 and earlier."] pub continuous_freq: bool, } #[test] fn bindgen_test_layout_di_edid_misc_features() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 5usize, concat!("Size of: ", stringify!(di_edid_misc_features)) ); assert_eq!( ::std::mem::align_of::(), 1usize, concat!("Alignment of ", stringify!(di_edid_misc_features)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).has_preferred_timing) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_edid_misc_features), "::", stringify!(has_preferred_timing) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).default_gtf) as usize - ptr as usize }, 1usize, concat!( "Offset of field: ", stringify!(di_edid_misc_features), "::", stringify!(default_gtf) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).srgb_is_primary) as usize - ptr as usize }, 2usize, concat!( "Offset of field: ", stringify!(di_edid_misc_features), "::", stringify!(srgb_is_primary) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).preferred_timing_is_native) as usize - ptr as usize }, 3usize, concat!( "Offset of field: ", stringify!(di_edid_misc_features), "::", stringify!(preferred_timing_is_native) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).continuous_freq) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", stringify!(di_edid_misc_features), "::", stringify!(continuous_freq) ) ); } extern "C" { #[doc = " Get the set of miscellaneous basic features."] pub fn di_edid_get_misc_features(edid: *const di_edid) -> *const di_edid_misc_features; } #[doc = " EDID display chromaticity coordinates, defined in section 3.7.\n\n The values are accurate to the thousandth place. The red, green and blue\n values are zero for monochrome displays."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_edid_chromaticity_coords { pub red_x: f32, pub red_y: f32, pub green_x: f32, pub green_y: f32, pub blue_x: f32, pub blue_y: f32, pub white_x: f32, pub white_y: f32, } #[test] fn bindgen_test_layout_di_edid_chromaticity_coords() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 32usize, concat!("Size of: ", stringify!(di_edid_chromaticity_coords)) ); assert_eq!( ::std::mem::align_of::(), 4usize, concat!("Alignment of ", stringify!(di_edid_chromaticity_coords)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).red_x) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_edid_chromaticity_coords), "::", stringify!(red_x) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).red_y) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", stringify!(di_edid_chromaticity_coords), "::", stringify!(red_y) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).green_x) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", stringify!(di_edid_chromaticity_coords), "::", stringify!(green_x) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).green_y) as usize - ptr as usize }, 12usize, concat!( "Offset of field: ", stringify!(di_edid_chromaticity_coords), "::", stringify!(green_y) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).blue_x) as usize - ptr as usize }, 16usize, concat!( "Offset of field: ", stringify!(di_edid_chromaticity_coords), "::", stringify!(blue_x) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).blue_y) as usize - ptr as usize }, 20usize, concat!( "Offset of field: ", stringify!(di_edid_chromaticity_coords), "::", stringify!(blue_y) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).white_x) as usize - ptr as usize }, 24usize, concat!( "Offset of field: ", stringify!(di_edid_chromaticity_coords), "::", stringify!(white_x) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).white_y) as usize - ptr as usize }, 28usize, concat!( "Offset of field: ", stringify!(di_edid_chromaticity_coords), "::", stringify!(white_y) ) ); } extern "C" { #[doc = " Get chromaticity coordinates."] pub fn di_edid_get_chromaticity_coords( edid: *const di_edid, ) -> *const di_edid_chromaticity_coords; } #[doc = " Established timings I and II, defined in section 3.8."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_edid_established_timings_i_ii { pub has_720x400_70hz: bool, pub has_720x400_88hz: bool, pub has_640x480_60hz: bool, pub has_640x480_67hz: bool, pub has_640x480_72hz: bool, pub has_640x480_75hz: bool, pub has_800x600_56hz: bool, pub has_800x600_60hz: bool, pub has_800x600_72hz: bool, pub has_800x600_75hz: bool, pub has_832x624_75hz: bool, pub has_1024x768_87hz_interlaced: bool, pub has_1024x768_60hz: bool, pub has_1024x768_70hz: bool, pub has_1024x768_75hz: bool, pub has_1280x1024_75hz: bool, pub has_1152x870_75hz: bool, } #[test] fn bindgen_test_layout_di_edid_established_timings_i_ii() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 17usize, concat!("Size of: ", stringify!(di_edid_established_timings_i_ii)) ); assert_eq!( ::std::mem::align_of::(), 1usize, concat!( "Alignment of ", stringify!(di_edid_established_timings_i_ii) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).has_720x400_70hz) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_edid_established_timings_i_ii), "::", stringify!(has_720x400_70hz) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).has_720x400_88hz) as usize - ptr as usize }, 1usize, concat!( "Offset of field: ", stringify!(di_edid_established_timings_i_ii), "::", stringify!(has_720x400_88hz) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).has_640x480_60hz) as usize - ptr as usize }, 2usize, concat!( "Offset of field: ", stringify!(di_edid_established_timings_i_ii), "::", stringify!(has_640x480_60hz) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).has_640x480_67hz) as usize - ptr as usize }, 3usize, concat!( "Offset of field: ", stringify!(di_edid_established_timings_i_ii), "::", stringify!(has_640x480_67hz) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).has_640x480_72hz) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", stringify!(di_edid_established_timings_i_ii), "::", stringify!(has_640x480_72hz) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).has_640x480_75hz) as usize - ptr as usize }, 5usize, concat!( "Offset of field: ", stringify!(di_edid_established_timings_i_ii), "::", stringify!(has_640x480_75hz) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).has_800x600_56hz) as usize - ptr as usize }, 6usize, concat!( "Offset of field: ", stringify!(di_edid_established_timings_i_ii), "::", stringify!(has_800x600_56hz) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).has_800x600_60hz) as usize - ptr as usize }, 7usize, concat!( "Offset of field: ", stringify!(di_edid_established_timings_i_ii), "::", stringify!(has_800x600_60hz) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).has_800x600_72hz) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", stringify!(di_edid_established_timings_i_ii), "::", stringify!(has_800x600_72hz) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).has_800x600_75hz) as usize - ptr as usize }, 9usize, concat!( "Offset of field: ", stringify!(di_edid_established_timings_i_ii), "::", stringify!(has_800x600_75hz) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).has_832x624_75hz) as usize - ptr as usize }, 10usize, concat!( "Offset of field: ", stringify!(di_edid_established_timings_i_ii), "::", stringify!(has_832x624_75hz) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).has_1024x768_87hz_interlaced) as usize - ptr as usize }, 11usize, concat!( "Offset of field: ", stringify!(di_edid_established_timings_i_ii), "::", stringify!(has_1024x768_87hz_interlaced) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).has_1024x768_60hz) as usize - ptr as usize }, 12usize, concat!( "Offset of field: ", stringify!(di_edid_established_timings_i_ii), "::", stringify!(has_1024x768_60hz) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).has_1024x768_70hz) as usize - ptr as usize }, 13usize, concat!( "Offset of field: ", stringify!(di_edid_established_timings_i_ii), "::", stringify!(has_1024x768_70hz) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).has_1024x768_75hz) as usize - ptr as usize }, 14usize, concat!( "Offset of field: ", stringify!(di_edid_established_timings_i_ii), "::", stringify!(has_1024x768_75hz) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).has_1280x1024_75hz) as usize - ptr as usize }, 15usize, concat!( "Offset of field: ", stringify!(di_edid_established_timings_i_ii), "::", stringify!(has_1280x1024_75hz) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).has_1152x870_75hz) as usize - ptr as usize }, 16usize, concat!( "Offset of field: ", stringify!(di_edid_established_timings_i_ii), "::", stringify!(has_1152x870_75hz) ) ); } extern "C" { #[doc = " Get established timings I and II."] pub fn di_edid_get_established_timings_i_ii( edid: *const di_edid, ) -> *const di_edid_established_timings_i_ii; } pub const di_edid_standard_timing_aspect_ratio_DI_EDID_STANDARD_TIMING_16_10: di_edid_standard_timing_aspect_ratio = 0; pub const di_edid_standard_timing_aspect_ratio_DI_EDID_STANDARD_TIMING_4_3: di_edid_standard_timing_aspect_ratio = 1; pub const di_edid_standard_timing_aspect_ratio_DI_EDID_STANDARD_TIMING_5_4: di_edid_standard_timing_aspect_ratio = 2; pub const di_edid_standard_timing_aspect_ratio_DI_EDID_STANDARD_TIMING_16_9: di_edid_standard_timing_aspect_ratio = 3; #[doc = " Aspect ratio for an EDID standard timing."] pub type di_edid_standard_timing_aspect_ratio = ::std::os::raw::c_uint; #[doc = " EDID standard timing, defined in section 3.9."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_edid_standard_timing { pub horiz_video: i32, pub aspect_ratio: di_edid_standard_timing_aspect_ratio, pub refresh_rate_hz: i32, } #[test] fn bindgen_test_layout_di_edid_standard_timing() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 12usize, concat!("Size of: ", stringify!(di_edid_standard_timing)) ); assert_eq!( ::std::mem::align_of::(), 4usize, concat!("Alignment of ", stringify!(di_edid_standard_timing)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).horiz_video) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_edid_standard_timing), "::", stringify!(horiz_video) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).aspect_ratio) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", stringify!(di_edid_standard_timing), "::", stringify!(aspect_ratio) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).refresh_rate_hz) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", stringify!(di_edid_standard_timing), "::", stringify!(refresh_rate_hz) ) ); } extern "C" { #[doc = " Get the vertical addressable line count of an EDID standard timing."] pub fn di_edid_standard_timing_get_vert_video(t: *const di_edid_standard_timing) -> i32; } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_dmt_timing { _unused: [u8; 0], } extern "C" { #[doc = " Get the VESA Display Monitor Timing (DMT), if any.\n\n NULL is returned if the standard timing doesn't have a DMT."] pub fn di_edid_standard_timing_get_dmt( t: *const di_edid_standard_timing, ) -> *const di_dmt_timing; } extern "C" { #[doc = " Get a list of EDID standard timings.\n\n The returned array is NULL-terminated."] pub fn di_edid_get_standard_timings( edid: *const di_edid, ) -> *const *const di_edid_standard_timing; } pub const di_edid_detailed_timing_def_stereo_DI_EDID_DETAILED_TIMING_DEF_STEREO_NONE: di_edid_detailed_timing_def_stereo = 0; pub const di_edid_detailed_timing_def_stereo_DI_EDID_DETAILED_TIMING_DEF_STEREO_FIELD_SEQ_RIGHT: di_edid_detailed_timing_def_stereo = 1; pub const di_edid_detailed_timing_def_stereo_DI_EDID_DETAILED_TIMING_DEF_STEREO_FIELD_SEQ_LEFT: di_edid_detailed_timing_def_stereo = 2; pub const di_edid_detailed_timing_def_stereo_DI_EDID_DETAILED_TIMING_DEF_STEREO_2_WAY_INTERLEAVED_RIGHT : di_edid_detailed_timing_def_stereo = 3 ; pub const di_edid_detailed_timing_def_stereo_DI_EDID_DETAILED_TIMING_DEF_STEREO_2_WAY_INTERLEAVED_LEFT : di_edid_detailed_timing_def_stereo = 4 ; pub const di_edid_detailed_timing_def_stereo_DI_EDID_DETAILED_TIMING_DEF_STEREO_4_WAY_INTERLEAVED : di_edid_detailed_timing_def_stereo = 5 ; pub const di_edid_detailed_timing_def_stereo_DI_EDID_DETAILED_TIMING_DEF_STEREO_SIDE_BY_SIDE_INTERLEAVED : di_edid_detailed_timing_def_stereo = 6 ; #[doc = " Stereo viewing support."] pub type di_edid_detailed_timing_def_stereo = ::std::os::raw::c_uint; pub const di_edid_detailed_timing_def_signal_type_DI_EDID_DETAILED_TIMING_DEF_SIGNAL_ANALOG_COMPOSITE : di_edid_detailed_timing_def_signal_type = 0 ; pub const di_edid_detailed_timing_def_signal_type_DI_EDID_DETAILED_TIMING_DEF_SIGNAL_BIPOLAR_ANALOG_COMPOSITE : di_edid_detailed_timing_def_signal_type = 1 ; pub const di_edid_detailed_timing_def_signal_type_DI_EDID_DETAILED_TIMING_DEF_SIGNAL_DIGITAL_COMPOSITE : di_edid_detailed_timing_def_signal_type = 2 ; pub const di_edid_detailed_timing_def_signal_type_DI_EDID_DETAILED_TIMING_DEF_SIGNAL_DIGITAL_SEPARATE : di_edid_detailed_timing_def_signal_type = 3 ; #[doc = " Signal definitions for EDID detailed timings, defined in notes for table 3.22."] pub type di_edid_detailed_timing_def_signal_type = ::std::os::raw::c_uint; pub const di_edid_detailed_timing_def_sync_polarity_DI_EDID_DETAILED_TIMING_DEF_SYNC_NEGATIVE: di_edid_detailed_timing_def_sync_polarity = 0; pub const di_edid_detailed_timing_def_sync_polarity_DI_EDID_DETAILED_TIMING_DEF_SYNC_POSITIVE: di_edid_detailed_timing_def_sync_polarity = 1; #[doc = " Digital separate sync polarity for EDID detailed timings."] pub type di_edid_detailed_timing_def_sync_polarity = ::std::os::raw::c_uint; #[doc = " Flags for ANALOG_COMPOSITE signals"] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_edid_detailed_timing_analog_composite { pub sync_serrations: bool, pub sync_on_green: bool, } #[test] fn bindgen_test_layout_di_edid_detailed_timing_analog_composite() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 2usize, concat!( "Size of: ", stringify!(di_edid_detailed_timing_analog_composite) ) ); assert_eq!( ::std::mem::align_of::(), 1usize, concat!( "Alignment of ", stringify!(di_edid_detailed_timing_analog_composite) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).sync_serrations) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_edid_detailed_timing_analog_composite), "::", stringify!(sync_serrations) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).sync_on_green) as usize - ptr as usize }, 1usize, concat!( "Offset of field: ", stringify!(di_edid_detailed_timing_analog_composite), "::", stringify!(sync_on_green) ) ); } #[doc = " Flags for BIPOLAR_ANALOG_COMPOSITE signals"] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_edid_detailed_timing_bipolar_analog_composite { pub sync_serrations: bool, pub sync_on_green: bool, } #[test] fn bindgen_test_layout_di_edid_detailed_timing_bipolar_analog_composite() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 2usize, concat!( "Size of: ", stringify!(di_edid_detailed_timing_bipolar_analog_composite) ) ); assert_eq!( ::std::mem::align_of::(), 1usize, concat!( "Alignment of ", stringify!(di_edid_detailed_timing_bipolar_analog_composite) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).sync_serrations) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_edid_detailed_timing_bipolar_analog_composite), "::", stringify!(sync_serrations) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).sync_on_green) as usize - ptr as usize }, 1usize, concat!( "Offset of field: ", stringify!(di_edid_detailed_timing_bipolar_analog_composite), "::", stringify!(sync_on_green) ) ); } #[doc = " Flags for DIGITAL_COMPOSITE signals"] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_edid_detailed_timing_digital_composite { pub sync_serrations: bool, pub sync_horiz_polarity: di_edid_detailed_timing_def_sync_polarity, } #[test] fn bindgen_test_layout_di_edid_detailed_timing_digital_composite() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 8usize, concat!( "Size of: ", stringify!(di_edid_detailed_timing_digital_composite) ) ); assert_eq!( ::std::mem::align_of::(), 4usize, concat!( "Alignment of ", stringify!(di_edid_detailed_timing_digital_composite) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).sync_serrations) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_edid_detailed_timing_digital_composite), "::", stringify!(sync_serrations) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).sync_horiz_polarity) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", stringify!(di_edid_detailed_timing_digital_composite), "::", stringify!(sync_horiz_polarity) ) ); } #[doc = " Flags for DIGITAL_SEPARATE signals"] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_edid_detailed_timing_digital_separate { pub sync_vert_polarity: di_edid_detailed_timing_def_sync_polarity, pub sync_horiz_polarity: di_edid_detailed_timing_def_sync_polarity, } #[test] fn bindgen_test_layout_di_edid_detailed_timing_digital_separate() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 8usize, concat!( "Size of: ", stringify!(di_edid_detailed_timing_digital_separate) ) ); assert_eq!( ::std::mem::align_of::(), 4usize, concat!( "Alignment of ", stringify!(di_edid_detailed_timing_digital_separate) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).sync_vert_polarity) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_edid_detailed_timing_digital_separate), "::", stringify!(sync_vert_polarity) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).sync_horiz_polarity) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", stringify!(di_edid_detailed_timing_digital_separate), "::", stringify!(sync_horiz_polarity) ) ); } #[doc = " EDID detailed timing definition, defined in section 3.10.2."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_edid_detailed_timing_def { pub pixel_clock_hz: i32, pub horiz_video: i32, pub vert_video: i32, pub horiz_blank: i32, pub vert_blank: i32, pub horiz_front_porch: i32, pub vert_front_porch: i32, pub horiz_sync_pulse: i32, pub vert_sync_pulse: i32, pub horiz_image_mm: i32, pub vert_image_mm: i32, pub horiz_border: i32, pub vert_border: i32, pub interlaced: bool, pub stereo: di_edid_detailed_timing_def_stereo, pub signal_type: di_edid_detailed_timing_def_signal_type, pub analog_composite: *const di_edid_detailed_timing_analog_composite, pub bipolar_analog_composite: *const di_edid_detailed_timing_bipolar_analog_composite, pub digital_composite: *const di_edid_detailed_timing_digital_composite, pub digital_separate: *const di_edid_detailed_timing_digital_separate, } #[test] fn bindgen_test_layout_di_edid_detailed_timing_def() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 96usize, concat!("Size of: ", stringify!(di_edid_detailed_timing_def)) ); assert_eq!( ::std::mem::align_of::(), 8usize, concat!("Alignment of ", stringify!(di_edid_detailed_timing_def)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).pixel_clock_hz) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_edid_detailed_timing_def), "::", stringify!(pixel_clock_hz) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).horiz_video) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", stringify!(di_edid_detailed_timing_def), "::", stringify!(horiz_video) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).vert_video) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", stringify!(di_edid_detailed_timing_def), "::", stringify!(vert_video) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).horiz_blank) as usize - ptr as usize }, 12usize, concat!( "Offset of field: ", stringify!(di_edid_detailed_timing_def), "::", stringify!(horiz_blank) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).vert_blank) as usize - ptr as usize }, 16usize, concat!( "Offset of field: ", stringify!(di_edid_detailed_timing_def), "::", stringify!(vert_blank) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).horiz_front_porch) as usize - ptr as usize }, 20usize, concat!( "Offset of field: ", stringify!(di_edid_detailed_timing_def), "::", stringify!(horiz_front_porch) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).vert_front_porch) as usize - ptr as usize }, 24usize, concat!( "Offset of field: ", stringify!(di_edid_detailed_timing_def), "::", stringify!(vert_front_porch) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).horiz_sync_pulse) as usize - ptr as usize }, 28usize, concat!( "Offset of field: ", stringify!(di_edid_detailed_timing_def), "::", stringify!(horiz_sync_pulse) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).vert_sync_pulse) as usize - ptr as usize }, 32usize, concat!( "Offset of field: ", stringify!(di_edid_detailed_timing_def), "::", stringify!(vert_sync_pulse) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).horiz_image_mm) as usize - ptr as usize }, 36usize, concat!( "Offset of field: ", stringify!(di_edid_detailed_timing_def), "::", stringify!(horiz_image_mm) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).vert_image_mm) as usize - ptr as usize }, 40usize, concat!( "Offset of field: ", stringify!(di_edid_detailed_timing_def), "::", stringify!(vert_image_mm) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).horiz_border) as usize - ptr as usize }, 44usize, concat!( "Offset of field: ", stringify!(di_edid_detailed_timing_def), "::", stringify!(horiz_border) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).vert_border) as usize - ptr as usize }, 48usize, concat!( "Offset of field: ", stringify!(di_edid_detailed_timing_def), "::", stringify!(vert_border) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).interlaced) as usize - ptr as usize }, 52usize, concat!( "Offset of field: ", stringify!(di_edid_detailed_timing_def), "::", stringify!(interlaced) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).stereo) as usize - ptr as usize }, 56usize, concat!( "Offset of field: ", stringify!(di_edid_detailed_timing_def), "::", stringify!(stereo) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).signal_type) as usize - ptr as usize }, 60usize, concat!( "Offset of field: ", stringify!(di_edid_detailed_timing_def), "::", stringify!(signal_type) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).analog_composite) as usize - ptr as usize }, 64usize, concat!( "Offset of field: ", stringify!(di_edid_detailed_timing_def), "::", stringify!(analog_composite) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).bipolar_analog_composite) as usize - ptr as usize }, 72usize, concat!( "Offset of field: ", stringify!(di_edid_detailed_timing_def), "::", stringify!(bipolar_analog_composite) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).digital_composite) as usize - ptr as usize }, 80usize, concat!( "Offset of field: ", stringify!(di_edid_detailed_timing_def), "::", stringify!(digital_composite) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).digital_separate) as usize - ptr as usize }, 88usize, concat!( "Offset of field: ", stringify!(di_edid_detailed_timing_def), "::", stringify!(digital_separate) ) ); } extern "C" { #[doc = " Get a list of EDID detailed timing definitions.\n\n The returned array is NULL-terminated."] pub fn di_edid_get_detailed_timing_defs( edid: *const di_edid, ) -> *const *const di_edid_detailed_timing_def; } #[doc = " EDID display descriptor."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_edid_display_descriptor { _unused: [u8; 0], } extern "C" { #[doc = " Get a list of EDID display descriptors.\n\n The returned array is NULL-terminated."] pub fn di_edid_get_display_descriptors( edid: *const di_edid, ) -> *const *const di_edid_display_descriptor; } pub const di_edid_display_descriptor_tag_DI_EDID_DISPLAY_DESCRIPTOR_PRODUCT_SERIAL: di_edid_display_descriptor_tag = 255; pub const di_edid_display_descriptor_tag_DI_EDID_DISPLAY_DESCRIPTOR_DATA_STRING: di_edid_display_descriptor_tag = 254; pub const di_edid_display_descriptor_tag_DI_EDID_DISPLAY_DESCRIPTOR_RANGE_LIMITS: di_edid_display_descriptor_tag = 253; pub const di_edid_display_descriptor_tag_DI_EDID_DISPLAY_DESCRIPTOR_PRODUCT_NAME: di_edid_display_descriptor_tag = 252; pub const di_edid_display_descriptor_tag_DI_EDID_DISPLAY_DESCRIPTOR_COLOR_POINT: di_edid_display_descriptor_tag = 251; pub const di_edid_display_descriptor_tag_DI_EDID_DISPLAY_DESCRIPTOR_STD_TIMING_IDS: di_edid_display_descriptor_tag = 250; pub const di_edid_display_descriptor_tag_DI_EDID_DISPLAY_DESCRIPTOR_DCM_DATA: di_edid_display_descriptor_tag = 249; pub const di_edid_display_descriptor_tag_DI_EDID_DISPLAY_DESCRIPTOR_CVT_TIMING_CODES: di_edid_display_descriptor_tag = 248; pub const di_edid_display_descriptor_tag_DI_EDID_DISPLAY_DESCRIPTOR_ESTABLISHED_TIMINGS_III: di_edid_display_descriptor_tag = 247; pub const di_edid_display_descriptor_tag_DI_EDID_DISPLAY_DESCRIPTOR_DUMMY: di_edid_display_descriptor_tag = 16; #[doc = " EDID display descriptor tag, defined in section 3.10.3."] pub type di_edid_display_descriptor_tag = ::std::os::raw::c_uint; extern "C" { #[doc = " Get the tag of an EDID display descriptor."] pub fn di_edid_display_descriptor_get_tag( desc: *const di_edid_display_descriptor, ) -> di_edid_display_descriptor_tag; } extern "C" { #[doc = " Get the contents of a product serial number, a data string, or a product name\n display descriptor.\n\n Returns NULL if the display descriptor tag isn't either\n DI_EDID_DISPLAY_DESCRIPTOR_PRODUCT_SERIAL_NUMBER,\n DI_EDID_DISPLAY_DESCRIPTOR_DATA_STRING or\n DI_EDID_DISPLAY_DESCRIPTOR_PRODUCT_NAME."] pub fn di_edid_display_descriptor_get_string( desc: *const di_edid_display_descriptor, ) -> *const ::std::os::raw::c_char; } pub const di_edid_display_range_limits_type_DI_EDID_DISPLAY_RANGE_LIMITS_BARE: di_edid_display_range_limits_type = 0; pub const di_edid_display_range_limits_type_DI_EDID_DISPLAY_RANGE_LIMITS_DEFAULT_GTF: di_edid_display_range_limits_type = 1; pub const di_edid_display_range_limits_type_DI_EDID_DISPLAY_RANGE_LIMITS_SECONDARY_GTF: di_edid_display_range_limits_type = 2; pub const di_edid_display_range_limits_type_DI_EDID_DISPLAY_RANGE_LIMITS_CVT: di_edid_display_range_limits_type = 3; #[doc = " EDID display range limits type.\n\n The values do not match the EDID specification.\n\n The CVT entry was introduced in EDID 1.4."] pub type di_edid_display_range_limits_type = ::std::os::raw::c_uint; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_edid_display_range_limits_secondary_gtf { pub start_freq_hz: ::std::os::raw::c_int, pub c: f32, pub m: f32, pub k: f32, pub j: f32, } #[test] fn bindgen_test_layout_di_edid_display_range_limits_secondary_gtf() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 20usize, concat!( "Size of: ", stringify!(di_edid_display_range_limits_secondary_gtf) ) ); assert_eq!( ::std::mem::align_of::(), 4usize, concat!( "Alignment of ", stringify!(di_edid_display_range_limits_secondary_gtf) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).start_freq_hz) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_edid_display_range_limits_secondary_gtf), "::", stringify!(start_freq_hz) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).c) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", stringify!(di_edid_display_range_limits_secondary_gtf), "::", stringify!(c) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).m) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", stringify!(di_edid_display_range_limits_secondary_gtf), "::", stringify!(m) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).k) as usize - ptr as usize }, 12usize, concat!( "Offset of field: ", stringify!(di_edid_display_range_limits_secondary_gtf), "::", stringify!(k) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).j) as usize - ptr as usize }, 16usize, concat!( "Offset of field: ", stringify!(di_edid_display_range_limits_secondary_gtf), "::", stringify!(j) ) ); } pub const di_edid_cvt_aspect_ratio_DI_EDID_CVT_ASPECT_RATIO_4_3: di_edid_cvt_aspect_ratio = 128; pub const di_edid_cvt_aspect_ratio_DI_EDID_CVT_ASPECT_RATIO_16_9: di_edid_cvt_aspect_ratio = 64; pub const di_edid_cvt_aspect_ratio_DI_EDID_CVT_ASPECT_RATIO_16_10: di_edid_cvt_aspect_ratio = 32; pub const di_edid_cvt_aspect_ratio_DI_EDID_CVT_ASPECT_RATIO_5_4: di_edid_cvt_aspect_ratio = 16; pub const di_edid_cvt_aspect_ratio_DI_EDID_CVT_ASPECT_RATIO_15_9: di_edid_cvt_aspect_ratio = 8; pub type di_edid_cvt_aspect_ratio = ::std::os::raw::c_uint; pub const di_edid_cvt_scaling_DI_EDID_CVT_SCALING_HORIZ_SHRINK: di_edid_cvt_scaling = 128; pub const di_edid_cvt_scaling_DI_EDID_CVT_SCALING_HORIZ_STRETCH: di_edid_cvt_scaling = 64; pub const di_edid_cvt_scaling_DI_EDID_CVT_SCALING_VERT_SHRINK: di_edid_cvt_scaling = 32; pub const di_edid_cvt_scaling_DI_EDID_CVT_SCALING_VERT_STRETCH: di_edid_cvt_scaling = 16; pub type di_edid_cvt_scaling = ::std::os::raw::c_uint; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_edid_display_range_limits_cvt { pub version: i32, pub revision: i32, pub max_horiz_px: i32, pub supported_aspect_ratio: u32, pub preferred_aspect_ratio: di_edid_cvt_aspect_ratio, pub standard_blanking: bool, pub reduced_blanking: bool, pub supported_scaling: u32, pub preferred_vert_refresh_hz: i32, } #[test] fn bindgen_test_layout_di_edid_display_range_limits_cvt() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 32usize, concat!("Size of: ", stringify!(di_edid_display_range_limits_cvt)) ); assert_eq!( ::std::mem::align_of::(), 4usize, concat!( "Alignment of ", stringify!(di_edid_display_range_limits_cvt) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).version) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_edid_display_range_limits_cvt), "::", stringify!(version) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).revision) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", stringify!(di_edid_display_range_limits_cvt), "::", stringify!(revision) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).max_horiz_px) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", stringify!(di_edid_display_range_limits_cvt), "::", stringify!(max_horiz_px) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).supported_aspect_ratio) as usize - ptr as usize }, 12usize, concat!( "Offset of field: ", stringify!(di_edid_display_range_limits_cvt), "::", stringify!(supported_aspect_ratio) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).preferred_aspect_ratio) as usize - ptr as usize }, 16usize, concat!( "Offset of field: ", stringify!(di_edid_display_range_limits_cvt), "::", stringify!(preferred_aspect_ratio) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).standard_blanking) as usize - ptr as usize }, 20usize, concat!( "Offset of field: ", stringify!(di_edid_display_range_limits_cvt), "::", stringify!(standard_blanking) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).reduced_blanking) as usize - ptr as usize }, 21usize, concat!( "Offset of field: ", stringify!(di_edid_display_range_limits_cvt), "::", stringify!(reduced_blanking) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).supported_scaling) as usize - ptr as usize }, 24usize, concat!( "Offset of field: ", stringify!(di_edid_display_range_limits_cvt), "::", stringify!(supported_scaling) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).preferred_vert_refresh_hz) as usize - ptr as usize }, 28usize, concat!( "Offset of field: ", stringify!(di_edid_display_range_limits_cvt), "::", stringify!(preferred_vert_refresh_hz) ) ); } #[cfg(not(feature = "v0_2"))] pub type di_edid_display_range_limits_max_pixel_clock_hz = i32; #[cfg(feature = "v0_2")] pub type di_edid_display_range_limits_max_pixel_clock_hz = i64; #[doc = " EDID display range limits, defined in section 3.10.3.3.1."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_edid_display_range_limits { pub min_vert_rate_hz: i32, pub max_vert_rate_hz: i32, pub min_horiz_rate_hz: i32, pub max_horiz_rate_hz: i32, pub max_pixel_clock_hz: di_edid_display_range_limits_max_pixel_clock_hz, pub type_: di_edid_display_range_limits_type, pub secondary_gtf: *const di_edid_display_range_limits_secondary_gtf, pub cvt: *const di_edid_display_range_limits_cvt, } #[test] #[cfg(not(feature = "v0_2"))] fn bindgen_test_layout_di_edid_display_range_limits() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 40usize, concat!("Size of: ", stringify!(di_edid_display_range_limits)) ); assert_eq!( ::std::mem::align_of::(), 8usize, concat!("Alignment of ", stringify!(di_edid_display_range_limits)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).min_vert_rate_hz) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_edid_display_range_limits), "::", stringify!(min_vert_rate_hz) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).max_vert_rate_hz) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", stringify!(di_edid_display_range_limits), "::", stringify!(max_vert_rate_hz) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).min_horiz_rate_hz) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", stringify!(di_edid_display_range_limits), "::", stringify!(min_horiz_rate_hz) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).max_horiz_rate_hz) as usize - ptr as usize }, 12usize, concat!( "Offset of field: ", stringify!(di_edid_display_range_limits), "::", stringify!(max_horiz_rate_hz) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).max_pixel_clock_hz) as usize - ptr as usize }, 16usize, concat!( "Offset of field: ", stringify!(di_edid_display_range_limits), "::", stringify!(max_pixel_clock_hz) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize }, 20usize, concat!( "Offset of field: ", stringify!(di_edid_display_range_limits), "::", stringify!(type_) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).secondary_gtf) as usize - ptr as usize }, 24usize, concat!( "Offset of field: ", stringify!(di_edid_display_range_limits), "::", stringify!(secondary_gtf) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).cvt) as usize - ptr as usize }, 32usize, concat!( "Offset of field: ", stringify!(di_edid_display_range_limits), "::", stringify!(cvt) ) ); } #[test] #[cfg(feature = "v0_2")] fn bindgen_test_layout_di_edid_display_range_limits() { 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!(di_edid_display_range_limits)) ); assert_eq!( ::std::mem::align_of::(), 8usize, concat!("Alignment of ", stringify!(di_edid_display_range_limits)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).min_vert_rate_hz) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_edid_display_range_limits), "::", stringify!(min_vert_rate_hz) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).max_vert_rate_hz) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", stringify!(di_edid_display_range_limits), "::", stringify!(max_vert_rate_hz) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).min_horiz_rate_hz) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", stringify!(di_edid_display_range_limits), "::", stringify!(min_horiz_rate_hz) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).max_horiz_rate_hz) as usize - ptr as usize }, 12usize, concat!( "Offset of field: ", stringify!(di_edid_display_range_limits), "::", stringify!(max_horiz_rate_hz) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).max_pixel_clock_hz) as usize - ptr as usize }, 16usize, concat!( "Offset of field: ", stringify!(di_edid_display_range_limits), "::", stringify!(max_pixel_clock_hz) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize }, 24usize, concat!( "Offset of field: ", stringify!(di_edid_display_range_limits), "::", stringify!(type_) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).secondary_gtf) as usize - ptr as usize }, 32usize, concat!( "Offset of field: ", stringify!(di_edid_display_range_limits), "::", stringify!(secondary_gtf) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).cvt) as usize - ptr as usize }, 40usize, concat!( "Offset of field: ", stringify!(di_edid_display_range_limits), "::", stringify!(cvt) ) ); } extern "C" { #[doc = " Get the contents of a display range limits descriptor.\n\n Returns NULL if the display descriptor tag isn't\n DI_EDID_DISPLAY_DESCRIPTOR_RANGE_LIMITS."] pub fn di_edid_display_descriptor_get_range_limits( desc: *const di_edid_display_descriptor, ) -> *const di_edid_display_range_limits; } extern "C" { #[doc = " Get a standard timing list from an EDID display descriptor.\n\n The returned array is NULL-terminated.\n\n Returns NULL if the display descriptor tag isn't\n DI_EDID_DISPLAY_DESCRIPTOR_STD_TIMING_IDS."] pub fn di_edid_display_descriptor_get_standard_timings( desc: *const di_edid_display_descriptor, ) -> *const *const di_edid_standard_timing; } #[doc = " EDID Color Points, defined in section 3.10.3.5."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_edid_color_point { pub index: ::std::os::raw::c_int, pub white_x: f32, pub white_y: f32, pub gamma: f32, } #[test] fn bindgen_test_layout_di_edid_color_point() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 16usize, concat!("Size of: ", stringify!(di_edid_color_point)) ); assert_eq!( ::std::mem::align_of::(), 4usize, concat!("Alignment of ", stringify!(di_edid_color_point)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).index) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_edid_color_point), "::", stringify!(index) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).white_x) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", stringify!(di_edid_color_point), "::", stringify!(white_x) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).white_y) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", stringify!(di_edid_color_point), "::", stringify!(white_y) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).gamma) as usize - ptr as usize }, 12usize, concat!( "Offset of field: ", stringify!(di_edid_color_point), "::", stringify!(gamma) ) ); } extern "C" { #[doc = " Get a color point list from an EDID display descriptor.\n\n The returned array is NULL-terminated.\n\n Returns NULL if the display descriptor tag isn't\n DI_EDID_DISPLAY_DESCRIPTOR_COLOR_POINT.\n\n Upstream is not aware of any EDID blob containing Color Point Descriptors.\n If such a blob is found, please share it with upstream!"] pub fn di_edid_display_descriptor_get_color_points( desc: *const di_edid_display_descriptor, ) -> *const *const di_edid_color_point; } extern "C" { #[doc = " Get a list of established timings III from an EDID display descriptor.\n\n The returned array is NULL-terminated.\n\n Returns NULL if the display descriptor tag isn't\n DI_EDID_DISPLAY_DESCRIPTOR_ESTABLISHED_TIMINGS_III."] pub fn di_edid_display_descriptor_get_established_timings_iii( desc: *const di_edid_display_descriptor, ) -> *const *const di_dmt_timing; } #[doc = " EDID display Color Management Data, defined in section 3.10.3.7\n\n Contains the coefficients for the function `L = a₃ × v³ + a₂ × v²`\n describing the luminance response L to some voltage v [0, 0.7] for each color\n channel.\n\n For more information see VESA DCM Standard, Version 1; January 6, 2003"] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_edid_color_management_data { pub version: ::std::os::raw::c_int, pub red_a3: f32, pub red_a2: f32, pub green_a3: f32, pub green_a2: f32, pub blue_a3: f32, pub blue_a2: f32, } #[test] fn bindgen_test_layout_di_edid_color_management_data() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 28usize, concat!("Size of: ", stringify!(di_edid_color_management_data)) ); assert_eq!( ::std::mem::align_of::(), 4usize, concat!("Alignment of ", stringify!(di_edid_color_management_data)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).version) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_edid_color_management_data), "::", stringify!(version) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).red_a3) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", stringify!(di_edid_color_management_data), "::", stringify!(red_a3) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).red_a2) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", stringify!(di_edid_color_management_data), "::", stringify!(red_a2) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).green_a3) as usize - ptr as usize }, 12usize, concat!( "Offset of field: ", stringify!(di_edid_color_management_data), "::", stringify!(green_a3) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).green_a2) as usize - ptr as usize }, 16usize, concat!( "Offset of field: ", stringify!(di_edid_color_management_data), "::", stringify!(green_a2) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).blue_a3) as usize - ptr as usize }, 20usize, concat!( "Offset of field: ", stringify!(di_edid_color_management_data), "::", stringify!(blue_a3) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).blue_a2) as usize - ptr as usize }, 24usize, concat!( "Offset of field: ", stringify!(di_edid_color_management_data), "::", stringify!(blue_a2) ) ); } extern "C" { #[doc = " Get the contents of a Display Color Management (DCM) Data descriptor.\n\n Returns NULL if the display descriptor tag isn't\n DI_EDID_DISPLAY_DESCRIPTOR_DCM_DATA.\n\n Upstream is not aware of any EDID blob containing DCM Data descriptors.\n If such a blob is found, please share it with upstream!"] pub fn di_edid_display_descriptor_get_color_management_data( desc: *const di_edid_display_descriptor, ) -> *const di_edid_color_management_data; } pub const di_edid_cvt_timing_code_aspect_ratio_DI_EDID_CVT_TIMING_CODE_4_3: di_edid_cvt_timing_code_aspect_ratio = 0; pub const di_edid_cvt_timing_code_aspect_ratio_DI_EDID_CVT_TIMING_CODE_16_9: di_edid_cvt_timing_code_aspect_ratio = 1; pub const di_edid_cvt_timing_code_aspect_ratio_DI_EDID_CVT_TIMING_CODE_16_10: di_edid_cvt_timing_code_aspect_ratio = 2; pub const di_edid_cvt_timing_code_aspect_ratio_DI_EDID_CVT_TIMING_CODE_15_9: di_edid_cvt_timing_code_aspect_ratio = 3; #[doc = " Aspect ratio for an EDID CVT Timing Code."] pub type di_edid_cvt_timing_code_aspect_ratio = ::std::os::raw::c_uint; pub const di_edid_cvt_timing_code_preferred_vrate_DI_EDID_CVT_TIMING_CODE_PREFERRED_VRATE_50HZ: di_edid_cvt_timing_code_preferred_vrate = 0; pub const di_edid_cvt_timing_code_preferred_vrate_DI_EDID_CVT_TIMING_CODE_PREFERRED_VRATE_60HZ: di_edid_cvt_timing_code_preferred_vrate = 1; pub const di_edid_cvt_timing_code_preferred_vrate_DI_EDID_CVT_TIMING_CODE_PREFERRED_VRATE_75HZ: di_edid_cvt_timing_code_preferred_vrate = 2; pub const di_edid_cvt_timing_code_preferred_vrate_DI_EDID_CVT_TIMING_CODE_PREFERRED_VRATE_85HZ: di_edid_cvt_timing_code_preferred_vrate = 3; #[doc = " Preferred Vertical Rate for an EDID CVT Timing Code."] pub type di_edid_cvt_timing_code_preferred_vrate = ::std::os::raw::c_uint; #[doc = " EDID CVT Timing Code, defined in section 3.10.3.8\n\n For more information see VESA Coordinated Video Timings (CVT) Standard."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_edid_cvt_timing_code { pub addressable_lines_per_field: i32, pub aspect_ratio: di_edid_cvt_timing_code_aspect_ratio, pub supports_50hz_sb: bool, pub supports_60hz_sb: bool, pub supports_75hz_sb: bool, pub supports_85hz_sb: bool, pub supports_60hz_rb: bool, pub preferred_vertical_rate: di_edid_cvt_timing_code_preferred_vrate, } #[test] fn bindgen_test_layout_di_edid_cvt_timing_code() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 20usize, concat!("Size of: ", stringify!(di_edid_cvt_timing_code)) ); assert_eq!( ::std::mem::align_of::(), 4usize, concat!("Alignment of ", stringify!(di_edid_cvt_timing_code)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).addressable_lines_per_field) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_edid_cvt_timing_code), "::", stringify!(addressable_lines_per_field) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).aspect_ratio) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", stringify!(di_edid_cvt_timing_code), "::", stringify!(aspect_ratio) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).supports_50hz_sb) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", stringify!(di_edid_cvt_timing_code), "::", stringify!(supports_50hz_sb) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).supports_60hz_sb) as usize - ptr as usize }, 9usize, concat!( "Offset of field: ", stringify!(di_edid_cvt_timing_code), "::", stringify!(supports_60hz_sb) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).supports_75hz_sb) as usize - ptr as usize }, 10usize, concat!( "Offset of field: ", stringify!(di_edid_cvt_timing_code), "::", stringify!(supports_75hz_sb) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).supports_85hz_sb) as usize - ptr as usize }, 11usize, concat!( "Offset of field: ", stringify!(di_edid_cvt_timing_code), "::", stringify!(supports_85hz_sb) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).supports_60hz_rb) as usize - ptr as usize }, 12usize, concat!( "Offset of field: ", stringify!(di_edid_cvt_timing_code), "::", stringify!(supports_60hz_rb) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).preferred_vertical_rate) as usize - ptr as usize }, 16usize, concat!( "Offset of field: ", stringify!(di_edid_cvt_timing_code), "::", stringify!(preferred_vertical_rate) ) ); } extern "C" { #[doc = " Get a list of CVT timing codes from an EDID display descriptor.\n The highest priority code comes first, the lowest priority code last.\n\n The returned array is NULL-terminated.\n\n Returns NULL if the display descriptor tag isn't\n DI_EDID_DISPLAY_DESCRIPTOR_CVT_TIMING_CODES."] pub fn di_edid_display_descriptor_get_cvt_timing_codes( desc: *const di_edid_display_descriptor, ) -> *const *const di_edid_cvt_timing_code; } #[doc = " EDID extension block."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_edid_ext { _unused: [u8; 0], } extern "C" { #[doc = " Get a list of EDID extensions.\n\n The returned array is NULL-terminated."] pub fn di_edid_get_extensions(edid: *const di_edid) -> *const *const di_edid_ext; } pub const di_edid_ext_tag_DI_EDID_EXT_CEA: di_edid_ext_tag = 2; pub const di_edid_ext_tag_DI_EDID_EXT_VTB: di_edid_ext_tag = 16; pub const di_edid_ext_tag_DI_EDID_EXT_DI: di_edid_ext_tag = 64; pub const di_edid_ext_tag_DI_EDID_EXT_LS: di_edid_ext_tag = 80; pub const di_edid_ext_tag_DI_EDID_EXT_DPVL: di_edid_ext_tag = 96; pub const di_edid_ext_tag_DI_EDID_EXT_BLOCK_MAP: di_edid_ext_tag = 240; pub const di_edid_ext_tag_DI_EDID_EXT_VENDOR: di_edid_ext_tag = 255; pub const di_edid_ext_tag_DI_EDID_EXT_DISPLAYID: di_edid_ext_tag = 112; #[doc = " EDID extension block tags, defined in section 2.2.4."] pub type di_edid_ext_tag = ::std::os::raw::c_uint; extern "C" { #[doc = " Get the tag of an EDID extension block."] pub fn di_edid_ext_get_tag(ext: *const di_edid_ext) -> di_edid_ext_tag; } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_edid_cta { _unused: [u8; 0], } extern "C" { #[doc = " Get a CTA-861 extension block.\n\n Returns NULL if the extension block tag is not DI_EDID_EXT_CEA."] pub fn di_edid_ext_get_cta(ext: *const di_edid_ext) -> *const di_edid_cta; } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_displayid { _unused: [u8; 0], } extern "C" { #[doc = " Get a DisplayID extension block.\n\n Returns NULL if the extension block tag is not DI_EDID_EXT_DISPLAYID."] pub fn di_edid_ext_get_displayid(ext: *const di_edid_ext) -> *const di_displayid; } libdisplay-info-sys-0.2.2/src/gtf.rs000064400000000000000000000176751046102023000154630ustar 00000000000000/* automatically generated by rust-bindgen 0.68.1 */ pub const di_gtf_ip_param_DI_GTF_IP_PARAM_V_FRAME_RATE: di_gtf_ip_param = 0; pub const di_gtf_ip_param_DI_GTF_IP_PARAM_H_FREQ: di_gtf_ip_param = 1; pub const di_gtf_ip_param_DI_GTF_IP_PARAM_H_PIXELS: di_gtf_ip_param = 2; #[doc = " Type of frequency parameter used in di_gtf_options.ip_freq_rqd."] pub type di_gtf_ip_param = ::std::os::raw::c_uint; #[doc = " Input options for GTF."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_gtf_options { pub h_pixels: ::std::os::raw::c_int, pub v_lines: ::std::os::raw::c_int, pub margins_rqd: bool, pub ip_param: di_gtf_ip_param, pub ip_freq_rqd: f64, pub int_rqd: bool, pub m: f64, pub c: f64, pub k: f64, pub j: f64, } #[test] fn bindgen_test_layout_di_gtf_options() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 64usize, concat!("Size of: ", stringify!(di_gtf_options)) ); assert_eq!( ::std::mem::align_of::(), 8usize, concat!("Alignment of ", stringify!(di_gtf_options)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).h_pixels) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_gtf_options), "::", stringify!(h_pixels) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).v_lines) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", stringify!(di_gtf_options), "::", stringify!(v_lines) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).margins_rqd) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", stringify!(di_gtf_options), "::", stringify!(margins_rqd) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).ip_param) as usize - ptr as usize }, 12usize, concat!( "Offset of field: ", stringify!(di_gtf_options), "::", stringify!(ip_param) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).ip_freq_rqd) as usize - ptr as usize }, 16usize, concat!( "Offset of field: ", stringify!(di_gtf_options), "::", stringify!(ip_freq_rqd) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).int_rqd) as usize - ptr as usize }, 24usize, concat!( "Offset of field: ", stringify!(di_gtf_options), "::", stringify!(int_rqd) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).m) as usize - ptr as usize }, 32usize, concat!( "Offset of field: ", stringify!(di_gtf_options), "::", stringify!(m) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).c) as usize - ptr as usize }, 40usize, concat!( "Offset of field: ", stringify!(di_gtf_options), "::", stringify!(c) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).k) as usize - ptr as usize }, 48usize, concat!( "Offset of field: ", stringify!(di_gtf_options), "::", stringify!(k) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).j) as usize - ptr as usize }, 56usize, concat!( "Offset of field: ", stringify!(di_gtf_options), "::", stringify!(j) ) ); } #[doc = " Output timing data for GTF."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_gtf_timing { pub h_pixels: ::std::os::raw::c_int, pub v_lines: ::std::os::raw::c_int, pub h_sync: ::std::os::raw::c_int, pub v_sync: ::std::os::raw::c_int, pub h_front_porch: ::std::os::raw::c_int, pub h_back_porch: ::std::os::raw::c_int, pub v_front_porch: ::std::os::raw::c_int, pub v_back_porch: ::std::os::raw::c_int, pub h_border: ::std::os::raw::c_int, pub v_border: ::std::os::raw::c_int, pub pixel_freq_mhz: f64, } #[test] fn bindgen_test_layout_di_gtf_timing() { 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!(di_gtf_timing)) ); assert_eq!( ::std::mem::align_of::(), 8usize, concat!("Alignment of ", stringify!(di_gtf_timing)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).h_pixels) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_gtf_timing), "::", stringify!(h_pixels) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).v_lines) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", stringify!(di_gtf_timing), "::", stringify!(v_lines) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).h_sync) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", stringify!(di_gtf_timing), "::", stringify!(h_sync) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).v_sync) as usize - ptr as usize }, 12usize, concat!( "Offset of field: ", stringify!(di_gtf_timing), "::", stringify!(v_sync) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).h_front_porch) as usize - ptr as usize }, 16usize, concat!( "Offset of field: ", stringify!(di_gtf_timing), "::", stringify!(h_front_porch) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).h_back_porch) as usize - ptr as usize }, 20usize, concat!( "Offset of field: ", stringify!(di_gtf_timing), "::", stringify!(h_back_porch) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).v_front_porch) as usize - ptr as usize }, 24usize, concat!( "Offset of field: ", stringify!(di_gtf_timing), "::", stringify!(v_front_porch) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).v_back_porch) as usize - ptr as usize }, 28usize, concat!( "Offset of field: ", stringify!(di_gtf_timing), "::", stringify!(v_back_porch) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).h_border) as usize - ptr as usize }, 32usize, concat!( "Offset of field: ", stringify!(di_gtf_timing), "::", stringify!(h_border) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).v_border) as usize - ptr as usize }, 36usize, concat!( "Offset of field: ", stringify!(di_gtf_timing), "::", stringify!(v_border) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).pixel_freq_mhz) as usize - ptr as usize }, 40usize, concat!( "Offset of field: ", stringify!(di_gtf_timing), "::", stringify!(pixel_freq_mhz) ) ); } extern "C" { #[doc = " Compute a timing via the GTF formula."] pub fn di_gtf_compute(t: *mut di_gtf_timing, options: *const di_gtf_options); } libdisplay-info-sys-0.2.2/src/info.rs000064400000000000000000000354571046102023000156340ustar 00000000000000/* automatically generated by rust-bindgen 0.68.1 */ #[doc = " Information about a display device.\n\n This includes at least one EDID or DisplayID blob.\n\n Use di_info_parse_edid() to create a struct di_info from an EDID blob.\n DisplayID blobs are not yet supported."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_info { _unused: [u8; 0], } extern "C" { #[doc = " Parse an EDID blob.\n\n Callers do not need to keep the provided data pointer valid after calling\n this function. Callers should destroy the returned pointer via\n di_info_destroy()."] pub fn di_info_parse_edid(data: *const ::std::os::raw::c_void, size: usize) -> *mut di_info; } extern "C" { #[doc = " Destroy a display device information structure."] pub fn di_info_destroy(info: *mut di_info); } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_edid { _unused: [u8; 0], } extern "C" { #[doc = " Returns the EDID the display device information was constructed with.\n\n The returned struct di_edid can be used to query low-level EDID information,\n see . Users should prefer the high-level API if\n possible.\n\n NULL is returned if the struct di_info doesn't contain an EDID. The returned\n struct di_edid is valid until di_info_destroy()."] pub fn di_info_get_edid(info: *const di_info) -> *const di_edid; } extern "C" { #[doc = " Get the failure messages for this blob.\n\n NULL is returned if the blob conforms to the relevant specifications."] pub fn di_info_get_failure_msg(info: *const di_info) -> *const ::std::os::raw::c_char; } extern "C" { #[doc = " Get the make of the display device.\n\n This is the manufacturer name, either company name or PNP ID.\n This string is informational and not meant to be used in programmatic\n decisions, configuration keys, etc.\n\n The string is in UTF-8 and may contain any characters except ASCII control\n codes.\n\n The caller is responsible for free'ing the returned string.\n NULL is returned if the information is not available."] pub fn di_info_get_make(info: *const di_info) -> *mut ::std::os::raw::c_char; } extern "C" { #[doc = " Get the model of the display device.\n\n This is the product name/model string or product number.\n This string is informational and not meant to be used in programmatic\n decisions, configuration keys, etc.\n\n The string is in UTF-8 and may contain any characters except ASCII control\n codes.\n\n The caller is responsible for free'ing the returned string.\n NULL is returned if the information is not available."] pub fn di_info_get_model(info: *const di_info) -> *mut ::std::os::raw::c_char; } extern "C" { #[doc = " Get the serial of the display device.\n\n This is the product serial string or the serial number.\n This string is informational and not meant to be used in programmatic\n decisions, configuration keys, etc.\n\n The string is in UTF-8 and may contain any characters except ASCII control\n codes.\n\n The caller is responsible for free'ing the returned string.\n NULL is returned if the information is not available."] pub fn di_info_get_serial(info: *const di_info) -> *mut ::std::os::raw::c_char; } #[doc = " Display HDR static metadata"] #[repr(C)] #[derive(Debug, Copy, Clone)] #[cfg(feature = "v0_2")] pub struct di_hdr_static_metadata { pub desired_content_max_luminance: f32, pub desired_content_max_frame_avg_luminance: f32, pub desired_content_min_luminance: f32, pub type1: bool, pub traditional_sdr: bool, pub traditional_hdr: bool, pub pq: bool, pub hlg: bool, } #[test] #[cfg(feature = "v0_2")] fn bindgen_test_layout_di_hdr_static_metadata() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 20usize, concat!("Size of: ", stringify!(di_hdr_static_metadata)) ); assert_eq!( ::std::mem::align_of::(), 4usize, concat!("Alignment of ", stringify!(di_hdr_static_metadata)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).desired_content_max_luminance) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_hdr_static_metadata), "::", stringify!(desired_content_max_luminance) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).desired_content_max_frame_avg_luminance) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", stringify!(di_hdr_static_metadata), "::", stringify!(desired_content_max_frame_avg_luminance) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).desired_content_min_luminance) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", stringify!(di_hdr_static_metadata), "::", stringify!(desired_content_min_luminance) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).type1) as usize - ptr as usize }, 12usize, concat!( "Offset of field: ", stringify!(di_hdr_static_metadata), "::", stringify!(type1) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).traditional_sdr) as usize - ptr as usize }, 13usize, concat!( "Offset of field: ", stringify!(di_hdr_static_metadata), "::", stringify!(traditional_sdr) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).traditional_hdr) as usize - ptr as usize }, 14usize, concat!( "Offset of field: ", stringify!(di_hdr_static_metadata), "::", stringify!(traditional_hdr) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).pq) as usize - ptr as usize }, 15usize, concat!( "Offset of field: ", stringify!(di_hdr_static_metadata), "::", stringify!(pq) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).hlg) as usize - ptr as usize }, 16usize, concat!( "Offset of field: ", stringify!(di_hdr_static_metadata), "::", stringify!(hlg) ) ); } #[cfg(feature = "v0_2")] extern "C" { #[doc = " Get HDR static metadata support information as defined in ANSI/CTA-861-H\n as HDR Static Metadata Data Block.\n\n The returned pointer is owned by the struct di_info passed in. It remains\n valid only as long as the di_info exists, and must not be freed by the\n caller.\n\n This function does not return NULL. When HDR static metadata does not exist,\n all luminance fields are zero and only traditional_sdr is flagged as\n supported."] pub fn di_info_get_hdr_static_metadata(info: *const di_info) -> *const di_hdr_static_metadata; } #[doc = " CIE 1931 2-degree observer chromaticity coordinates"] #[repr(C)] #[derive(Debug, Copy, Clone)] #[cfg(feature = "v0_2")] pub struct di_chromaticity_cie1931 { pub x: f32, pub y: f32, } #[test] #[cfg(feature = "v0_2")] fn bindgen_test_layout_di_chromaticity_cie1931() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 8usize, concat!("Size of: ", stringify!(di_chromaticity_cie1931)) ); assert_eq!( ::std::mem::align_of::(), 4usize, concat!("Alignment of ", stringify!(di_chromaticity_cie1931)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_chromaticity_cie1931), "::", stringify!(x) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", stringify!(di_chromaticity_cie1931), "::", stringify!(y) ) ); } #[doc = " Display color primaries and default white point"] #[repr(C)] #[derive(Debug, Copy, Clone)] #[cfg(feature = "v0_2")] pub struct di_color_primaries { pub has_primaries: bool, pub has_default_white_point: bool, pub primary: [di_chromaticity_cie1931; 3usize], pub default_white: di_chromaticity_cie1931, } #[test] #[cfg(feature = "v0_2")] fn bindgen_test_layout_di_color_primaries() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 36usize, concat!("Size of: ", stringify!(di_color_primaries)) ); assert_eq!( ::std::mem::align_of::(), 4usize, concat!("Alignment of ", stringify!(di_color_primaries)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).has_primaries) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_color_primaries), "::", stringify!(has_primaries) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).has_default_white_point) as usize - ptr as usize }, 1usize, concat!( "Offset of field: ", stringify!(di_color_primaries), "::", stringify!(has_default_white_point) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).primary) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", stringify!(di_color_primaries), "::", stringify!(primary) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).default_white) as usize - ptr as usize }, 28usize, concat!( "Offset of field: ", stringify!(di_color_primaries), "::", stringify!(default_white) ) ); } #[cfg(feature = "v0_2")] extern "C" { #[doc = " Get display color primaries and default white point\n\n Get the parameters of the default RGB colorimetry mode which is always\n supported. Primaries for monochrome displays might be all zeroes.\n\n These primaries might not be display's physical primaries, but only the\n primaries of the default RGB colorimetry signal when using IT Video Format\n (ANSI/CTA-861-H, Section 5).\n\n The returned pointer is owned by the struct di_info passed in. It remains\n valid only as long as the di_info exists, and must not be freed by the\n caller.\n\n This function does not return NULL."] pub fn di_info_get_default_color_primaries(info: *const di_info) -> *const di_color_primaries; } #[doc = " Additional signal colorimetry encodings supported by the display"] #[repr(C)] #[derive(Debug, Copy, Clone)] #[cfg(feature = "v0_2")] pub struct di_supported_signal_colorimetry { pub bt2020_cycc: bool, pub bt2020_ycc: bool, pub bt2020_rgb: bool, pub st2113_rgb: bool, pub ictcp: bool, } #[test] #[cfg(feature = "v0_2")] fn bindgen_test_layout_di_supported_signal_colorimetry() { const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 5usize, concat!("Size of: ", stringify!(di_supported_signal_colorimetry)) ); assert_eq!( ::std::mem::align_of::(), 1usize, concat!("Alignment of ", stringify!(di_supported_signal_colorimetry)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).bt2020_cycc) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_supported_signal_colorimetry), "::", stringify!(bt2020_cycc) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).bt2020_ycc) as usize - ptr as usize }, 1usize, concat!( "Offset of field: ", stringify!(di_supported_signal_colorimetry), "::", stringify!(bt2020_ycc) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).bt2020_rgb) as usize - ptr as usize }, 2usize, concat!( "Offset of field: ", stringify!(di_supported_signal_colorimetry), "::", stringify!(bt2020_rgb) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).st2113_rgb) as usize - ptr as usize }, 3usize, concat!( "Offset of field: ", stringify!(di_supported_signal_colorimetry), "::", stringify!(st2113_rgb) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).ictcp) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", stringify!(di_supported_signal_colorimetry), "::", stringify!(ictcp) ) ); } #[cfg(feature = "v0_2")] extern "C" { #[doc = " Get signal colorimetry encodings supported by the display\n\n These signal colorimetry encodings are supported in addition to the\n display's default RGB colorimetry. When you wish to use one of the additional\n encodings, they need to be explicitly enabled in the video signal. How to\n do that is specific to the signalling used, e.g. HDMI.\n\n Signal colorimetry encoding provides the color space that the signal is\n encoded for. This includes primary and white point chromaticities, and the\n YCbCr-RGB conversion if necessary. Also the transfer function is implied\n unless explicitly set otherwise, e.g. with HDR static metadata.\n See ANSI/CTA-861-H for details.\n\n The signal color volume can be considerably larger than the physically\n displayable color volume.\n\n The returned pointer is owned by the struct di_info passed in. It remains\n valid only as long as the di_info exists, and must not be freed by the\n caller.\n\n This function does not return NULL."] pub fn di_info_get_supported_signal_colorimetry( info: *const di_info, ) -> *const di_supported_signal_colorimetry; } #[cfg(feature = "v0_2")] extern "C" { #[doc = " Get display default transfer characteristic exponent (gamma)\n\n This should be the display gamma value when the display has been reset to\n its factory defaults, and it is driven with the default RGB colorimetry.\n The value is zero when unknown."] pub fn di_info_get_default_gamma(info: *const di_info) -> f32; } libdisplay-info-sys-0.2.2/src/lib.rs000064400000000000000000000003541046102023000154330ustar 00000000000000#![cfg_attr(docsrs, feature(doc_auto_cfg))] #![allow(non_upper_case_globals)] #![allow(non_camel_case_types)] #![allow(non_snake_case)] pub mod cta; pub mod cvt; pub mod displayid; pub mod dmt; pub mod edid; pub mod gtf; pub mod info;