libdisplay-info-sys-0.3.0/.cargo_vcs_info.json0000644000000001610000000000100147330ustar { "git": { "sha1": "6a05eb0b56b5e9d4072479cb14c6cdbd5a83ebe6" }, "path_in_vcs": "libdisplay-info-sys" }libdisplay-info-sys-0.3.0/Cargo.lock0000644000000123220000000000100127100ustar # This file is automatically @generated by Cargo. # It is not intended for manual editing. version = 4 [[package]] name = "cfg-expr" version = "0.20.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c8d458d63f0f0f482c8da9b7c8b76c21bd885a02056cc94c6404d861ca2b8206" dependencies = [ "smallvec", "target-lexicon", ] [[package]] name = "equivalent" version = "1.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f" [[package]] name = "hashbrown" version = "0.15.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1" [[package]] name = "heck" version = "0.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" [[package]] name = "indexmap" version = "2.11.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "206a8042aec68fa4a62e8d3f7aa4ceb508177d9324faf261e1959e495b7a1921" dependencies = [ "equivalent", "hashbrown", ] [[package]] name = "libdisplay-info-sys" version = "0.3.0" dependencies = [ "semver", "system-deps", ] [[package]] name = "memchr" version = "2.7.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "32a282da65faaf38286cf3be983213fcf1d2e2a58700e808f83f4ea9a4804bc0" [[package]] name = "pkg-config" version = "0.3.32" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7edddbd0b52d732b21ad9a5fab5c704c14cd949e5e9a1ec5929a24fded1b904c" [[package]] name = "proc-macro2" version = "1.0.101" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "89ae43fd86e4158d6db51ad8e2b80f313af9cc74f5c0e03ccb87de09998732de" dependencies = [ "unicode-ident", ] [[package]] name = "quote" version = "1.0.40" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1885c039570dc00dcb4ff087a89e185fd56bae234ddc7f056a945bf36467248d" dependencies = [ "proc-macro2", ] [[package]] name = "semver" version = "1.0.26" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "56e6fa9c48d24d85fb3de5ad847117517440f6beceb7798af16b4a87d616b8d0" [[package]] name = "serde" version = "1.0.219" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5f0e2c6ed6606019b4e29e69dbaba95b11854410e5347d525002456dbbb786b6" dependencies = [ "serde_derive", ] [[package]] name = "serde_derive" version = "1.0.219" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5b0276cf7f2c73365f7157c8123c21cd9a50fbbd844757af28ca1f5925fc2a00" dependencies = [ "proc-macro2", "quote", "syn", ] [[package]] name = "serde_spanned" version = "0.6.9" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "bf41e0cfaf7226dca15e8197172c295a782857fcb97fad1808a166870dee75a3" dependencies = [ "serde", ] [[package]] name = "smallvec" version = "1.15.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03" [[package]] name = "syn" version = "2.0.106" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ede7c438028d4436d71104916910f5bb611972c5cfd7f89b8300a8186e6fada6" dependencies = [ "proc-macro2", "quote", "unicode-ident", ] [[package]] name = "system-deps" version = "7.0.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e4be53aa0cba896d2dc615bd42bbc130acdcffa239e0a2d965ea5b3b2a86ffdb" dependencies = [ "cfg-expr", "heck", "pkg-config", "toml", "version-compare", ] [[package]] name = "target-lexicon" version = "0.13.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e502f78cdbb8ba4718f566c418c52bc729126ffd16baee5baa718cf25dd5a69a" [[package]] name = "toml" version = "0.8.23" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "dc1beb996b9d83529a9e75c17a1686767d148d70663143c7854d8b4a09ced362" dependencies = [ "serde", "serde_spanned", "toml_datetime", "toml_edit", ] [[package]] name = "toml_datetime" version = "0.6.11" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "22cddaf88f4fbc13c51aebbf5f8eceb5c7c5a9da2ac40a13519eb5b0a0e8f11c" dependencies = [ "serde", ] [[package]] name = "toml_edit" version = "0.22.27" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "41fe8c660ae4257887cf66394862d21dbca4a6ddd26f04a3560410406a2f819a" dependencies = [ "indexmap", "serde", "serde_spanned", "toml_datetime", "winnow", ] [[package]] name = "unicode-ident" version = "1.0.19" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f63a545481291138910575129486daeaf8ac54aee4387fe7906919f7830c7d9d" [[package]] name = "version-compare" version = "0.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "852e951cb7832cb45cb1169900d19760cfa39b82bc0ea9c0e5a14ae88411c98b" [[package]] name = "winnow" version = "0.7.13" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "21a0236b59786fed61e2a80582dd500fe61f18b5dca67a4a067d0bc9039339cf" dependencies = [ "memchr", ] libdisplay-info-sys-0.3.0/Cargo.toml0000644000000031230000000000100127320ustar # 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" rust-version = "1.70.0" name = "libdisplay-info-sys" version = "0.3.0" 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] all-features = true rustdoc-args = [ "--cfg", "docsrs", ] [package.metadata.system-deps.libdisplay-info] name = "libdisplay-info" version = ">= 0.1.0, < 0.4.0" [package.metadata.system-deps.libdisplay-info.v0_2] version = "0.2.0" [package.metadata.system-deps.libdisplay-info.v0_3] version = "0.3.0" [features] auto = [] default = ["auto"] v0_1 = [] v0_2 = [] v0_3 = [] [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" libdisplay-info-sys-0.3.0/Cargo.toml.orig000064400000000000000000000015051046102023000164150ustar 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.3.0" keywords = ["libdisplay", "DisplayID", "EDID"] license = "MIT" name = "libdisplay-info-sys" repository = "https://github.com/Smithay/libdisplay-info-rs" readme = "README.md" rust-version = "1.70.0" [package.metadata.docs.rs] all-features = true rustdoc-args = ["--cfg", "docsrs"] [features] default = ["auto"] auto = [] v0_1 = [] v0_2 = [] v0_3 = [] [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.4.0" v0_2 = { version = "0.2.0" } v0_3 = { version = "0.3.0" } libdisplay-info-sys-0.3.0/README.md000064400000000000000000000002001046102023000147740ustar 00000000000000# libdisplay-info-sys Low-level ffi bindings for [`libdisplay-info`](https://gitlab.freedesktop.org/emersion/libdisplay-info/).libdisplay-info-sys-0.3.0/build.rs000064400000000000000000000017321046102023000151750ustar 00000000000000use system_deps::Dependencies; fn 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(); auto_detect(&deps); } #[cfg(feature = "auto")] fn auto_detect(deps: &Dependencies) { let native_lib = deps.get_by_name("libdisplay-info").unwrap(); let native_version = semver::Version::parse(&native_lib.version).unwrap(); let is_v3 = semver::VersionReq::parse(">=0.3") .unwrap() .matches(&native_version); if is_v3 { println!("cargo:rustc-cfg=feature=\"v0_3\""); return; } let is_v2 = semver::VersionReq::parse(">=0.2") .unwrap() .matches(&native_version); if is_v2 { println!("cargo:rustc-cfg=feature=\"v0_2\""); return; } println!("cargo:rustc-cfg=feature=\"v0_1\""); } #[cfg(not(feature = "auto"))] fn auto_detect(_: &Dependencies) {} libdisplay-info-sys-0.3.0/src/auto.rs000064400000000000000000000436761046102023000156520ustar 00000000000000macro_rules! auto_import { ($mod_name:ident) => { #[cfg_attr(docsrs, cfg(feature = "v0_1"))] #[cfg_attr( not(docsrs), cfg(all(feature = "v0_1", not(feature = "v0_2"), not(feature = "v0_3"))) )] pub use crate::v0_1::$mod_name::*; #[cfg_attr(docsrs, cfg(feature = "v0_2"))] #[cfg_attr(not(docsrs), cfg(all(feature = "v0_2", not(feature = "v0_3"))))] pub use crate::v0_2::$mod_name::*; #[cfg(feature = "v0_3")] pub use crate::v0_3::$mod_name::*; }; } macro_rules! auto_mod { ($mod_name:ident) => { pub mod $mod_name { auto_import!($mod_name); } }; } pub mod cta { auto_import!(cta); #[cfg(feature = "v0_3")] pub use polyfills::*; #[cfg(feature = "v0_3")] mod polyfills { use super::*; pub unsafe fn di_cta_data_block_get_sads( data_block: *const di_cta_data_block, ) -> *const *const di_cta_sad { let audio_block = di_cta_data_block_get_audio(data_block); if audio_block.is_null() { return std::ptr::null(); } (*audio_block).sads } pub type di_cta_vesa_dddb = di_cta_vesa_display_device_block; pub unsafe fn di_cta_data_block_get_vesa_dddb( block: *const di_cta_data_block, ) -> *const di_cta_vesa_dddb { di_cta_data_block_get_vesa_display_device(block) } pub unsafe fn di_cta_data_block_get_svds( block: *const di_cta_data_block, ) -> *const *const di_cta_svd { let video_block = di_cta_data_block_get_video(block); if video_block.is_null() { return std::ptr::null(); } (*video_block).svds } pub unsafe fn di_cta_data_block_get_ycbcr420_svds( block: *const di_cta_data_block, ) -> *const *const di_cta_svd { let video_block = di_cta_data_block_get_ycbcr420_video(block); if video_block.is_null() { return std::ptr::null(); } (*video_block).svds } pub unsafe fn di_cta_data_block_get_svrs( block: *const di_cta_data_block, ) -> *const *const di_cta_svr { let video_format_pref_block = di_cta_data_block_get_video_format_pref(block); if video_format_pref_block.is_null() { return std::ptr::null(); } (*video_format_pref_block).svrs } pub type di_cta_vesa_dddb_interface_type = di_cta_vesa_display_device_interface_type; pub const di_cta_vesa_dddb_interface_type_DI_CTA_VESA_DDDB_INTERFACE_VGA: di_cta_vesa_dddb_interface_type = di_cta_vesa_display_device_interface_type_DI_CTA_VESA_DISPLAY_DEVICE_INTERFACE_VGA; pub const di_cta_vesa_dddb_interface_type_DI_CTA_VESA_DDDB_INTERFACE_NAVI_V: di_cta_vesa_dddb_interface_type = di_cta_vesa_display_device_interface_type_DI_CTA_VESA_DISPLAY_DEVICE_INTERFACE_NAVI_V; pub const di_cta_vesa_dddb_interface_type_DI_CTA_VESA_DDDB_INTERFACE_NAVI_D: di_cta_vesa_dddb_interface_type = di_cta_vesa_display_device_interface_type_DI_CTA_VESA_DISPLAY_DEVICE_INTERFACE_NAVI_D; pub const di_cta_vesa_dddb_interface_type_DI_CTA_VESA_DDDB_INTERFACE_LVDS: di_cta_vesa_dddb_interface_type = di_cta_vesa_display_device_interface_type_DI_CTA_VESA_DISPLAY_DEVICE_INTERFACE_LVDS; pub const di_cta_vesa_dddb_interface_type_DI_CTA_VESA_DDDB_INTERFACE_RSDS: di_cta_vesa_dddb_interface_type = di_cta_vesa_display_device_interface_type_DI_CTA_VESA_DISPLAY_DEVICE_INTERFACE_RSDS; pub const di_cta_vesa_dddb_interface_type_DI_CTA_VESA_DDDB_INTERFACE_DVI_D: di_cta_vesa_dddb_interface_type = di_cta_vesa_display_device_interface_type_DI_CTA_VESA_DISPLAY_DEVICE_INTERFACE_DVI_D; pub const di_cta_vesa_dddb_interface_type_DI_CTA_VESA_DDDB_INTERFACE_DVI_I_ANALOG: di_cta_vesa_dddb_interface_type = di_cta_vesa_display_device_interface_type_DI_CTA_VESA_DISPLAY_DEVICE_INTERFACE_DVI_I_ANALOG; pub const di_cta_vesa_dddb_interface_type_DI_CTA_VESA_DDDB_INTERFACE_DVI_I_DIGITAL: di_cta_vesa_dddb_interface_type = di_cta_vesa_display_device_interface_type_DI_CTA_VESA_DISPLAY_DEVICE_INTERFACE_DVI_I_DIGITAL; pub const di_cta_vesa_dddb_interface_type_DI_CTA_VESA_DDDB_INTERFACE_HDMI_A: di_cta_vesa_dddb_interface_type = di_cta_vesa_display_device_interface_type_DI_CTA_VESA_DISPLAY_DEVICE_INTERFACE_HDMI_A; pub const di_cta_vesa_dddb_interface_type_DI_CTA_VESA_DDDB_INTERFACE_HDMI_B: di_cta_vesa_dddb_interface_type = di_cta_vesa_display_device_interface_type_DI_CTA_VESA_DISPLAY_DEVICE_INTERFACE_HDMI_B; pub const di_cta_vesa_dddb_interface_type_DI_CTA_VESA_DDDB_INTERFACE_MDDI: di_cta_vesa_dddb_interface_type = di_cta_vesa_display_device_interface_type_DI_CTA_VESA_DISPLAY_DEVICE_INTERFACE_MDDI; pub const di_cta_vesa_dddb_interface_type_DI_CTA_VESA_DDDB_INTERFACE_DISPLAYPORT: di_cta_vesa_dddb_interface_type = di_cta_vesa_display_device_interface_type_DI_CTA_VESA_DISPLAY_DEVICE_INTERFACE_DISPLAYPORT; pub const di_cta_vesa_dddb_interface_type_DI_CTA_VESA_DDDB_INTERFACE_IEEE_1394: di_cta_vesa_dddb_interface_type = di_cta_vesa_display_device_interface_type_DI_CTA_VESA_DISPLAY_DEVICE_INTERFACE_IEEE_1394; pub const di_cta_vesa_dddb_interface_type_DI_CTA_VESA_DDDB_INTERFACE_M1_ANALOG: di_cta_vesa_dddb_interface_type = di_cta_vesa_display_device_interface_type_DI_CTA_VESA_DISPLAY_DEVICE_INTERFACE_M1_ANALOG; pub const di_cta_vesa_dddb_interface_type_DI_CTA_VESA_DDDB_INTERFACE_M1_DIGITAL: di_cta_vesa_dddb_interface_type = di_cta_vesa_display_device_interface_type_DI_CTA_VESA_DISPLAY_DEVICE_INTERFACE_M1_DIGITAL; pub type di_cta_vesa_dddb_content_protection = di_cta_vesa_display_device_content_protection; pub const di_cta_vesa_dddb_content_protection_DI_CTA_VESA_DDDB_CONTENT_PROTECTION_NONE: di_cta_vesa_dddb_content_protection = di_cta_vesa_display_device_content_protection_DI_CTA_VESA_DISPLAY_DEVICE_CONTENT_PROTECTION_NONE; pub const di_cta_vesa_dddb_content_protection_DI_CTA_VESA_DDDB_CONTENT_PROTECTION_HDCP: di_cta_vesa_dddb_content_protection = di_cta_vesa_display_device_content_protection_DI_CTA_VESA_DISPLAY_DEVICE_CONTENT_PROTECTION_HDCP; pub const di_cta_vesa_dddb_content_protection_DI_CTA_VESA_DDDB_CONTENT_PROTECTION_DTCP: di_cta_vesa_dddb_content_protection = di_cta_vesa_display_device_content_protection_DI_CTA_VESA_DISPLAY_DEVICE_CONTENT_PROTECTION_DTCP; pub const di_cta_vesa_dddb_content_protection_DI_CTA_VESA_DDDB_CONTENT_PROTECTION_DPCP: di_cta_vesa_dddb_content_protection = di_cta_vesa_display_device_content_protection_DI_CTA_VESA_DISPLAY_DEVICE_CONTENT_PROTECTION_DPCP; pub type di_cta_vesa_dddb_default_orientation = di_cta_vesa_display_device_default_orientation; pub const di_cta_vesa_dddb_default_orientation_DI_CTA_VESA_DDDB_DEFAULT_ORIENTATION_LANDSCAPE: di_cta_vesa_dddb_default_orientation = di_cta_vesa_display_device_default_orientation_DI_CTA_VESA_DISPLAY_DEVICE_DEFAULT_ORIENTATION_LANDSCAPE; pub const di_cta_vesa_dddb_default_orientation_DI_CTA_VESA_DDDB_DEFAULT_ORIENTATION_PORTAIT: di_cta_vesa_dddb_default_orientation = di_cta_vesa_display_device_default_orientation_DI_CTA_VESA_DISPLAY_DEVICE_DEFAULT_ORIENTATION_PORTAIT; pub const di_cta_vesa_dddb_default_orientation_DI_CTA_VESA_DDDB_DEFAULT_ORIENTATION_UNFIXED: di_cta_vesa_dddb_default_orientation = di_cta_vesa_display_device_default_orientation_DI_CTA_VESA_DISPLAY_DEVICE_DEFAULT_ORIENTATION_UNFIXED; pub const di_cta_vesa_dddb_default_orientation_DI_CTA_VESA_DDDB_DEFAULT_ORIENTATION_UNDEFINED: di_cta_vesa_dddb_default_orientation = di_cta_vesa_display_device_default_orientation_DI_CTA_VESA_DISPLAY_DEVICE_DEFAULT_ORIENTATION_UNDEFINED; pub type di_cta_vesa_dddb_rotation_cap = di_cta_vesa_display_device_rotation_cap; pub const di_cta_vesa_dddb_rotation_cap_DI_CTA_VESA_DDDB_ROTATION_CAP_NONE: di_cta_vesa_dddb_rotation_cap = di_cta_vesa_display_device_rotation_cap_DI_CTA_VESA_DISPLAY_DEVICE_ROTATION_CAP_NONE; pub const di_cta_vesa_dddb_rotation_cap_DI_CTA_VESA_DDDB_ROTATION_CAP_90DEG_CLOCKWISE: di_cta_vesa_dddb_rotation_cap = di_cta_vesa_display_device_rotation_cap_DI_CTA_VESA_DISPLAY_DEVICE_ROTATION_CAP_90DEG_CLOCKWISE; pub const di_cta_vesa_dddb_rotation_cap_DI_CTA_VESA_DDDB_ROTATION_CAP_90DEG_COUNTERCLOCKWISE: di_cta_vesa_dddb_rotation_cap = di_cta_vesa_display_device_rotation_cap_DI_CTA_VESA_DISPLAY_DEVICE_ROTATION_CAP_90DEG_COUNTERCLOCKWISE; pub const di_cta_vesa_dddb_rotation_cap_DI_CTA_VESA_DDDB_ROTATION_CAP_90DEG_EITHER: di_cta_vesa_dddb_rotation_cap = di_cta_vesa_display_device_rotation_cap_DI_CTA_VESA_DISPLAY_DEVICE_ROTATION_CAP_90DEG_EITHER; pub type di_cta_vesa_dddb_zero_pixel_location = di_cta_vesa_display_device_zero_pixel_location; pub const di_cta_vesa_dddb_zero_pixel_location_DI_CTA_VESA_DDDB_ZERO_PIXEL_UPPER_LEFT: di_cta_vesa_dddb_zero_pixel_location = di_cta_vesa_display_device_zero_pixel_location_DI_CTA_VESA_DISPLAY_DEVICE_ZERO_PIXEL_UPPER_LEFT; pub const di_cta_vesa_dddb_zero_pixel_location_DI_CTA_VESA_DDDB_ZERO_PIXEL_UPPER_RIGHT: di_cta_vesa_dddb_zero_pixel_location = di_cta_vesa_display_device_zero_pixel_location_DI_CTA_VESA_DISPLAY_DEVICE_ZERO_PIXEL_UPPER_RIGHT; pub const di_cta_vesa_dddb_zero_pixel_location_DI_CTA_VESA_DDDB_ZERO_PIXEL_LOWER_LEFT: di_cta_vesa_dddb_zero_pixel_location = di_cta_vesa_display_device_zero_pixel_location_DI_CTA_VESA_DISPLAY_DEVICE_ZERO_PIXEL_LOWER_LEFT; pub const di_cta_vesa_dddb_zero_pixel_location_DI_CTA_VESA_DDDB_ZERO_PIXEL_LOWER_RIGHT: di_cta_vesa_dddb_zero_pixel_location = di_cta_vesa_display_device_zero_pixel_location_DI_CTA_VESA_DISPLAY_DEVICE_ZERO_PIXEL_LOWER_RIGHT; pub type di_cta_vesa_dddb_scan_direction = di_cta_vesa_display_device_scan_direction; pub const di_cta_vesa_dddb_scan_direction_DI_CTA_VESA_DDDB_SCAN_DIRECTION_UNDEFINED: di_cta_vesa_dddb_scan_direction = di_cta_vesa_display_device_scan_direction_DI_CTA_VESA_DISPLAY_DEVICE_SCAN_DIRECTION_UNDEFINED; pub const di_cta_vesa_dddb_scan_direction_DI_CTA_VESA_DDDB_SCAN_DIRECTION_FAST_LONG_SLOW_SHORT: di_cta_vesa_dddb_scan_direction = di_cta_vesa_display_device_scan_direction_DI_CTA_VESA_DISPLAY_DEVICE_SCAN_DIRECTION_FAST_LONG_SLOW_SHORT; pub const di_cta_vesa_dddb_scan_direction_DI_CTA_VESA_DDDB_SCAN_DIRECTION_FAST_SHORT_SLOW_LONG: di_cta_vesa_dddb_scan_direction = di_cta_vesa_display_device_scan_direction_DI_CTA_VESA_DISPLAY_DEVICE_SCAN_DIRECTION_FAST_SHORT_SLOW_LONG; pub type di_cta_vesa_dddb_subpixel_layout = di_cta_vesa_display_device_subpixel_layout; pub const di_cta_vesa_dddb_subpixel_layout_DI_CTA_VESA_DDDB_SUBPIXEL_UNDEFINED: di_cta_vesa_dddb_subpixel_layout = di_cta_vesa_display_device_subpixel_layout_DI_CTA_VESA_DISPLAY_DEVICE_SUBPIXEL_UNDEFINED; pub const di_cta_vesa_dddb_subpixel_layout_DI_CTA_VESA_DDDB_SUBPIXEL_RGB_VERT: di_cta_vesa_dddb_subpixel_layout = di_cta_vesa_display_device_subpixel_layout_DI_CTA_VESA_DISPLAY_DEVICE_SUBPIXEL_RGB_VERT; pub const di_cta_vesa_dddb_subpixel_layout_DI_CTA_VESA_DDDB_SUBPIXEL_RGB_HORIZ: di_cta_vesa_dddb_subpixel_layout = di_cta_vesa_display_device_subpixel_layout_DI_CTA_VESA_DISPLAY_DEVICE_SUBPIXEL_RGB_HORIZ; pub const di_cta_vesa_dddb_subpixel_layout_DI_CTA_VESA_DDDB_SUBPIXEL_EDID_CHROM_VERT: di_cta_vesa_dddb_subpixel_layout = di_cta_vesa_display_device_subpixel_layout_DI_CTA_VESA_DISPLAY_DEVICE_SUBPIXEL_EDID_CHROM_VERT; pub const di_cta_vesa_dddb_subpixel_layout_DI_CTA_VESA_DDDB_SUBPIXEL_EDID_CHROM_HORIZ: di_cta_vesa_dddb_subpixel_layout = di_cta_vesa_display_device_subpixel_layout_DI_CTA_VESA_DISPLAY_DEVICE_SUBPIXEL_EDID_CHROM_HORIZ; pub const di_cta_vesa_dddb_subpixel_layout_DI_CTA_VESA_DDDB_SUBPIXEL_QUAD_RGGB: di_cta_vesa_dddb_subpixel_layout = di_cta_vesa_display_device_subpixel_layout_DI_CTA_VESA_DISPLAY_DEVICE_SUBPIXEL_QUAD_RGGB; pub const di_cta_vesa_dddb_subpixel_layout_DI_CTA_VESA_DDDB_SUBPIXEL_QUAD_GBRG: di_cta_vesa_dddb_subpixel_layout = di_cta_vesa_display_device_subpixel_layout_DI_CTA_VESA_DISPLAY_DEVICE_SUBPIXEL_QUAD_GBRG; pub const di_cta_vesa_dddb_subpixel_layout_DI_CTA_VESA_DDDB_SUBPIXEL_DELTA_RGB: di_cta_vesa_dddb_subpixel_layout = di_cta_vesa_display_device_subpixel_layout_DI_CTA_VESA_DISPLAY_DEVICE_SUBPIXEL_DELTA_RGB; pub const di_cta_vesa_dddb_subpixel_layout_DI_CTA_VESA_DDDB_SUBPIXEL_MOSAIC: di_cta_vesa_dddb_subpixel_layout = di_cta_vesa_display_device_subpixel_layout_DI_CTA_VESA_DISPLAY_DEVICE_SUBPIXEL_MOSAIC; pub const di_cta_vesa_dddb_subpixel_layout_DI_CTA_VESA_DDDB_SUBPIXEL_QUAD_ANY: di_cta_vesa_dddb_subpixel_layout = di_cta_vesa_display_device_subpixel_layout_DI_CTA_VESA_DISPLAY_DEVICE_SUBPIXEL_QUAD_ANY; pub const di_cta_vesa_dddb_subpixel_layout_DI_CTA_VESA_DDDB_SUBPIXEL_FIVE: di_cta_vesa_dddb_subpixel_layout = di_cta_vesa_display_device_subpixel_layout_DI_CTA_VESA_DISPLAY_DEVICE_SUBPIXEL_FIVE; pub const di_cta_vesa_dddb_subpixel_layout_DI_CTA_VESA_DDDB_SUBPIXEL_SIX: di_cta_vesa_dddb_subpixel_layout = di_cta_vesa_display_device_subpixel_layout_DI_CTA_VESA_DISPLAY_DEVICE_SUBPIXEL_SIX; pub const di_cta_vesa_dddb_subpixel_layout_DI_CTA_VESA_DDDB_SUBPIXEL_CLAIRVOYANTE_PENTILE: di_cta_vesa_dddb_subpixel_layout = di_cta_vesa_display_device_subpixel_layout_DI_CTA_VESA_DISPLAY_DEVICE_SUBPIXEL_CLAIRVOYANTE_PENTILE; pub type di_cta_vesa_dddb_dithering_type = di_cta_vesa_display_device_dithering_type; pub const di_cta_vesa_dddb_dithering_type_DI_CTA_VESA_DDDB_DITHERING_NONE: di_cta_vesa_dddb_dithering_type = di_cta_vesa_display_device_dithering_type_DI_CTA_VESA_DISPLAY_DEVICE_DITHERING_NONE; pub const di_cta_vesa_dddb_dithering_type_DI_CTA_VESA_DDDB_DITHERING_SPACIAL: di_cta_vesa_dddb_dithering_type = di_cta_vesa_display_device_dithering_type_DI_CTA_VESA_DISPLAY_DEVICE_DITHERING_SPACIAL; pub const di_cta_vesa_dddb_dithering_type_DI_CTA_VESA_DDDB_DITHERING_TEMPORAL: di_cta_vesa_dddb_dithering_type = di_cta_vesa_display_device_dithering_type_DI_CTA_VESA_DISPLAY_DEVICE_DITHERING_TEMPORAL; pub const di_cta_vesa_dddb_dithering_type_DI_CTA_VESA_DDDB_DITHERING_SPATIAL_AND_TEMPORAL: di_cta_vesa_dddb_dithering_type = di_cta_vesa_display_device_dithering_type_DI_CTA_VESA_DISPLAY_DEVICE_DITHERING_SPATIAL_AND_TEMPORAL; pub type di_cta_vesa_dddb_additional_primary_chromaticity = di_cta_vesa_display_device_additional_primary_chromaticity; pub type di_cta_vesa_dddb_frame_rate_conversion = di_cta_vesa_display_device_frame_rate_conversion; pub const di_cta_vesa_dddb_frame_rate_conversion_DI_CTA_VESA_DDDB_FRAME_RATE_CONVERSION_NONE: di_cta_vesa_dddb_frame_rate_conversion = di_cta_vesa_display_device_frame_rate_conversion_DI_CTA_VESA_DISPLAY_DEVICE_FRAME_RATE_CONVERSION_NONE; 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 = di_cta_vesa_display_device_frame_rate_conversion_DI_CTA_VESA_DISPLAY_DEVICE_FRAME_RATE_CONVERSION_SINGLE_BUFFERING ; 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 = di_cta_vesa_display_device_frame_rate_conversion_DI_CTA_VESA_DISPLAY_DEVICE_FRAME_RATE_CONVERSION_DOUBLE_BUFFERING ; pub const di_cta_vesa_dddb_frame_rate_conversion_DI_CTA_VESA_DDDB_FRAME_RATE_CONVERSION_ADVANCED: di_cta_vesa_dddb_frame_rate_conversion = di_cta_vesa_display_device_frame_rate_conversion_DI_CTA_VESA_DISPLAY_DEVICE_FRAME_RATE_CONVERSION_ADVANCED; pub type di_cta_vesa_dddb_resp_time_transition = di_cta_vesa_display_device_resp_time_transition; 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 = di_cta_vesa_display_device_resp_time_transition_DI_CTA_VESA_DISPLAY_DEVICE_RESP_TIME_BLACK_TO_WHITE; 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 = di_cta_vesa_display_device_resp_time_transition_DI_CTA_VESA_DISPLAY_DEVICE_RESP_TIME_WHITE_TO_BLACK; pub type di_cta_hdr_static_metadata_block_eotfs = di_cta_hdr_static_metadata_eotfs; pub type di_cta_hdr_static_metadata_block_descriptors = di_cta_hdr_static_metadata_descriptors; pub type di_cta_hdr_dynamic_metadata_block_type1 = di_cta_hdr_dynamic_metadata_type1; pub type di_cta_hdr_dynamic_metadata_block_type2 = di_cta_hdr_dynamic_metadata_type2; pub type di_cta_hdr_dynamic_metadata_block_type3 = di_cta_hdr_dynamic_metadata_type3; pub type di_cta_hdr_dynamic_metadata_block_type4 = di_cta_hdr_dynamic_metadata_type4; pub type di_cta_hdr_dynamic_metadata_block_type256 = di_cta_hdr_dynamic_metadata_type256; pub type di_cta_vesa_transfer_characteristics = di_cta_vesa_transfer_characteristics_block; pub type di_cta_ycbcr420_cap_map = di_cta_ycbcr420_cap_map_block; pub type di_cta_speaker_locations = di_cta_speaker_location_descriptor; pub type di_cta_room_configuration = di_cta_room_configuration_block; } } auto_mod!(cvt); auto_mod!(displayid); pub mod displayid2 { #[cfg(feature = "v0_3")] pub use crate::v0_3::displayid2::*; } auto_mod!(dmt); auto_mod!(edid); auto_mod!(gtf); auto_mod!(info); libdisplay-info-sys-0.3.0/src/lib.rs000064400000000000000000000010571046102023000154330ustar 00000000000000#![cfg_attr(docsrs, feature(doc_auto_cfg))] #![allow(non_upper_case_globals)] #![allow(non_camel_case_types)] #![allow(non_snake_case)] #[cfg_attr(docsrs, cfg(feature = "v0_1"))] #[cfg_attr( not(docsrs), cfg(all(feature = "v0_1", not(feature = "v0_2"), not(feature = "v0_3"))) )] pub mod v0_1; #[cfg_attr(docsrs, cfg(feature = "v0_2"))] #[cfg_attr(not(docsrs), cfg(all(feature = "v0_2", not(feature = "v0_3"))))] pub mod v0_2; #[cfg(feature = "v0_3")] pub mod v0_3; #[cfg(feature = "auto")] pub mod auto; #[cfg(feature = "auto")] pub use auto::*; libdisplay-info-sys-0.3.0/src/v0_1/cta.rs000064400000000000000000002727551046102023000162200ustar 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; } 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; } #[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; } libdisplay-info-sys-0.3.0/src/v0_1/cvt.rs000064400000000000000000000175431046102023000162350ustar 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.3.0/src/v0_1/displayid.rs000064400000000000000000000731301046102023000174150ustar 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; } 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; } 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.3.0/src/v0_1/dmt.rs000064400000000000000000000126451046102023000162230ustar 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.3.0/src/v0_1/edid.rs000064400000000000000000002273501046102023000163450ustar 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) ) ); } #[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: i32, 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] 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) ) ); } 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.3.0/src/v0_1/gtf.rs000064400000000000000000000176751046102023000162270ustar 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.3.0/src/v0_1/info.rs000064400000000000000000000061571046102023000163730ustar 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; } libdisplay-info-sys-0.3.0/src/v0_1/mod.rs000064400000000000000000000001431046102023000162040ustar 00000000000000pub mod cta; pub mod cvt; pub mod displayid; pub mod dmt; pub mod edid; pub mod gtf; pub mod info; libdisplay-info-sys-0.3.0/src/v0_2/cta.rs000064400000000000000000003360061046102023000162070ustar 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; } pub const di_cta_hdmi_audio_3d_channels_DI_CTA_HDMI_AUDIO_3D_CHANNELS_UNKNOWN: di_cta_hdmi_audio_3d_channels = 0; pub const di_cta_hdmi_audio_3d_channels_DI_CTA_HDMI_AUDIO_3D_CHANNELS_10_2: di_cta_hdmi_audio_3d_channels = 1; pub const di_cta_hdmi_audio_3d_channels_DI_CTA_HDMI_AUDIO_3D_CHANNELS_22_2: di_cta_hdmi_audio_3d_channels = 2; pub const di_cta_hdmi_audio_3d_channels_DI_CTA_HDMI_AUDIO_3D_CHANNELS_30_2: di_cta_hdmi_audio_3d_channels = 3; pub type di_cta_hdmi_audio_3d_channels = ::std::os::raw::c_uint; #[doc = " HDMI 3D Audio"] #[repr(C)] #[derive(Debug, Copy, Clone)] 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] 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)] pub struct di_cta_hdmi_audio_multi_stream { pub max_streams: ::std::os::raw::c_int, pub supports_non_mixed: bool, } #[test] 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)] 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] 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) ) ); } 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)] 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] 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) ) ); } 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; } pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_FL: di_cta_speaker_placement = 0; pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_FR: di_cta_speaker_placement = 1; pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_FC: di_cta_speaker_placement = 2; pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_LFE1: di_cta_speaker_placement = 3; pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_BL: di_cta_speaker_placement = 4; pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_BR: di_cta_speaker_placement = 5; pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_FLC: di_cta_speaker_placement = 6; pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_FRC: di_cta_speaker_placement = 7; pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_BC: di_cta_speaker_placement = 8; pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_LFE2: di_cta_speaker_placement = 9; pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_SIL: di_cta_speaker_placement = 10; pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_SIR: di_cta_speaker_placement = 11; pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_TPFL: di_cta_speaker_placement = 12; pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_TPFR: di_cta_speaker_placement = 13; pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_TPFC: di_cta_speaker_placement = 14; pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_TPC: di_cta_speaker_placement = 15; pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_TPBL: di_cta_speaker_placement = 16; pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_TPBR: di_cta_speaker_placement = 17; pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_TPSIL: di_cta_speaker_placement = 18; pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_TPSIR: di_cta_speaker_placement = 19; pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_TPBC: di_cta_speaker_placement = 20; pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_BTFC: di_cta_speaker_placement = 21; pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_BTFL: di_cta_speaker_placement = 22; pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_BRFR: di_cta_speaker_placement = 23; pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_FLW: di_cta_speaker_placement = 24; pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_FRW: di_cta_speaker_placement = 25; pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_LS: di_cta_speaker_placement = 26; pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_RS: di_cta_speaker_placement = 27; 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)] 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] 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) ) ); } 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)] pub struct di_displayid_type_i_ii_vii_timing { _unused: [u8; 0], } 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; } pub const di_cta_svr_type_DI_CTA_SVR_TYPE_VIC: di_cta_svr_type = 0; pub const di_cta_svr_type_DI_CTA_SVR_TYPE_DTD_INDEX: di_cta_svr_type = 1; pub const di_cta_svr_type_DI_CTA_SVR_TYPE_T7T10VTDB: di_cta_svr_type = 2; pub const di_cta_svr_type_DI_CTA_SVR_TYPE_FIRST_T8VTDB: di_cta_svr_type = 3; 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)] 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] 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) ) ); } 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.3.0/src/v0_2/cvt.rs000064400000000000000000000175431046102023000162360ustar 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.3.0/src/v0_2/displayid.rs000064400000000000000000001024761046102023000174240ustar 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; } 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; } pub const di_displayid_type_iii_timing_algo_DI_DISPLAYID_TYPE_III_TIMING_CVT_STANDARD_BLANKING: di_displayid_type_iii_timing_algo = 0; 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."] 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)] 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] 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) ) ); } 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.3.0/src/v0_2/dmt.rs000064400000000000000000000126451046102023000162240ustar 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.3.0/src/v0_2/edid.rs000064400000000000000000002273501046102023000163460ustar 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) ) ); } #[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: i64, 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] 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.3.0/src/v0_2/gtf.rs000064400000000000000000000176751046102023000162300ustar 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.3.0/src/v0_2/info.rs000064400000000000000000000350031046102023000163640ustar 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)] 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] 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) ) ); } 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)] pub struct di_chromaticity_cie1931 { pub x: f32, pub y: f32, } #[test] 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)] 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] 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) ) ); } 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)] 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] 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) ) ); } 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; } 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.3.0/src/v0_2/mod.rs000064400000000000000000000001431046102023000162050ustar 00000000000000pub mod cta; pub mod cvt; pub mod displayid; pub mod dmt; pub mod edid; pub mod gtf; pub mod info; libdisplay-info-sys-0.3.0/src/v0_3/cta.rs000064400000000000000000005300241046102023000162040ustar 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 = " A HDMI video format, not to be confused with a CTA-861 video format."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_cta_hdmi_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 pixel_clock_hz: i64, } #[test] fn bindgen_test_layout_di_cta_hdmi_video_format() { 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_cta_hdmi_video_format)) ); assert_eq!( ::std::mem::align_of::(), 8usize, concat!("Alignment of ", stringify!(di_cta_hdmi_video_format)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).vic) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_cta_hdmi_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_hdmi_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_hdmi_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_hdmi_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_hdmi_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_hdmi_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_hdmi_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_hdmi_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_hdmi_video_format), "::", stringify!(v_back) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).pixel_clock_hz) as usize - ptr as usize }, 40usize, concat!( "Offset of field: ", stringify!(di_cta_hdmi_video_format), "::", stringify!(pixel_clock_hz) ) ); } extern "C" { #[doc = " Get a HDMI video format from a HDMI VIC.\n\n Returns NULL if the HDMI VIC is unknown."] pub fn di_cta_hdmi_video_format_from_hdmi_vic(hdmi_vic: u8) -> *const di_cta_hdmi_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; } #[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; } #[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; pub const di_cta_data_block_tag_DI_CTA_DATA_BLOCK_VENDOR_HDMI: di_cta_data_block_tag = 24; pub const di_cta_data_block_tag_DI_CTA_DATA_BLOCK_DOLBY_VIDEO: di_cta_data_block_tag = 25; pub const di_cta_data_block_tag_DI_CTA_DATA_BLOCK_HDR10PLUS: di_cta_data_block_tag = 26; pub const di_cta_data_block_tag_DI_CTA_DATA_BLOCK_VENDOR_HDMI_FORUM: di_cta_data_block_tag = 27; #[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) ) ); } #[doc = " Audio Data Block, defined in section 7.5.2."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_cta_audio_block { pub sads: *const *const di_cta_sad, } #[test] fn bindgen_test_layout_di_cta_audio_block() { 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_audio_block)) ); assert_eq!( ::std::mem::align_of::(), 8usize, concat!("Alignment of ", stringify!(di_cta_audio_block)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).sads) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_cta_audio_block), "::", stringify!(sads) ) ); } extern "C" { #[doc = " Get the audio from a CTA data block.\n\n Returns NULL if the data block tag is not DI_CTA_DATA_BLOCK_AUDIO."] pub fn di_cta_data_block_get_audio( data_block: *const di_cta_data_block, ) -> *const di_cta_audio_block; } #[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_display_device_interface_type_DI_CTA_VESA_DISPLAY_DEVICE_INTERFACE_VGA: di_cta_vesa_display_device_interface_type = 0; pub const di_cta_vesa_display_device_interface_type_DI_CTA_VESA_DISPLAY_DEVICE_INTERFACE_NAVI_V: di_cta_vesa_display_device_interface_type = 1; pub const di_cta_vesa_display_device_interface_type_DI_CTA_VESA_DISPLAY_DEVICE_INTERFACE_NAVI_D: di_cta_vesa_display_device_interface_type = 2; pub const di_cta_vesa_display_device_interface_type_DI_CTA_VESA_DISPLAY_DEVICE_INTERFACE_LVDS: di_cta_vesa_display_device_interface_type = 3; pub const di_cta_vesa_display_device_interface_type_DI_CTA_VESA_DISPLAY_DEVICE_INTERFACE_RSDS: di_cta_vesa_display_device_interface_type = 4; pub const di_cta_vesa_display_device_interface_type_DI_CTA_VESA_DISPLAY_DEVICE_INTERFACE_DVI_D: di_cta_vesa_display_device_interface_type = 5; pub const di_cta_vesa_display_device_interface_type_DI_CTA_VESA_DISPLAY_DEVICE_INTERFACE_DVI_I_ANALOG : di_cta_vesa_display_device_interface_type = 6 ; pub const di_cta_vesa_display_device_interface_type_DI_CTA_VESA_DISPLAY_DEVICE_INTERFACE_DVI_I_DIGITAL : di_cta_vesa_display_device_interface_type = 7 ; pub const di_cta_vesa_display_device_interface_type_DI_CTA_VESA_DISPLAY_DEVICE_INTERFACE_HDMI_A: di_cta_vesa_display_device_interface_type = 8; pub const di_cta_vesa_display_device_interface_type_DI_CTA_VESA_DISPLAY_DEVICE_INTERFACE_HDMI_B: di_cta_vesa_display_device_interface_type = 9; pub const di_cta_vesa_display_device_interface_type_DI_CTA_VESA_DISPLAY_DEVICE_INTERFACE_MDDI: di_cta_vesa_display_device_interface_type = 10; pub const di_cta_vesa_display_device_interface_type_DI_CTA_VESA_DISPLAY_DEVICE_INTERFACE_DISPLAYPORT : di_cta_vesa_display_device_interface_type = 11 ; pub const di_cta_vesa_display_device_interface_type_DI_CTA_VESA_DISPLAY_DEVICE_INTERFACE_IEEE_1394 : di_cta_vesa_display_device_interface_type = 12 ; pub const di_cta_vesa_display_device_interface_type_DI_CTA_VESA_DISPLAY_DEVICE_INTERFACE_M1_ANALOG : di_cta_vesa_display_device_interface_type = 13 ; pub const di_cta_vesa_display_device_interface_type_DI_CTA_VESA_DISPLAY_DEVICE_INTERFACE_M1_DIGITAL : di_cta_vesa_display_device_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_display_device_interface_type = ::std::os::raw::c_uint; pub const di_cta_vesa_display_device_content_protection_DI_CTA_VESA_DISPLAY_DEVICE_CONTENT_PROTECTION_NONE : di_cta_vesa_display_device_content_protection = 0 ; pub const di_cta_vesa_display_device_content_protection_DI_CTA_VESA_DISPLAY_DEVICE_CONTENT_PROTECTION_HDCP : di_cta_vesa_display_device_content_protection = 1 ; pub const di_cta_vesa_display_device_content_protection_DI_CTA_VESA_DISPLAY_DEVICE_CONTENT_PROTECTION_DTCP : di_cta_vesa_display_device_content_protection = 2 ; pub const di_cta_vesa_display_device_content_protection_DI_CTA_VESA_DISPLAY_DEVICE_CONTENT_PROTECTION_DPCP : di_cta_vesa_display_device_content_protection = 3 ; pub type di_cta_vesa_display_device_content_protection = ::std::os::raw::c_uint; pub const di_cta_vesa_display_device_default_orientation_DI_CTA_VESA_DISPLAY_DEVICE_DEFAULT_ORIENTATION_LANDSCAPE : di_cta_vesa_display_device_default_orientation = 0 ; pub const di_cta_vesa_display_device_default_orientation_DI_CTA_VESA_DISPLAY_DEVICE_DEFAULT_ORIENTATION_PORTAIT : di_cta_vesa_display_device_default_orientation = 1 ; pub const di_cta_vesa_display_device_default_orientation_DI_CTA_VESA_DISPLAY_DEVICE_DEFAULT_ORIENTATION_UNFIXED : di_cta_vesa_display_device_default_orientation = 2 ; pub const di_cta_vesa_display_device_default_orientation_DI_CTA_VESA_DISPLAY_DEVICE_DEFAULT_ORIENTATION_UNDEFINED : di_cta_vesa_display_device_default_orientation = 3 ; pub type di_cta_vesa_display_device_default_orientation = ::std::os::raw::c_uint; pub const di_cta_vesa_display_device_rotation_cap_DI_CTA_VESA_DISPLAY_DEVICE_ROTATION_CAP_NONE: di_cta_vesa_display_device_rotation_cap = 0; pub const di_cta_vesa_display_device_rotation_cap_DI_CTA_VESA_DISPLAY_DEVICE_ROTATION_CAP_90DEG_CLOCKWISE : di_cta_vesa_display_device_rotation_cap = 1 ; pub const di_cta_vesa_display_device_rotation_cap_DI_CTA_VESA_DISPLAY_DEVICE_ROTATION_CAP_90DEG_COUNTERCLOCKWISE : di_cta_vesa_display_device_rotation_cap = 2 ; pub const di_cta_vesa_display_device_rotation_cap_DI_CTA_VESA_DISPLAY_DEVICE_ROTATION_CAP_90DEG_EITHER : di_cta_vesa_display_device_rotation_cap = 3 ; pub type di_cta_vesa_display_device_rotation_cap = ::std::os::raw::c_uint; pub const di_cta_vesa_display_device_zero_pixel_location_DI_CTA_VESA_DISPLAY_DEVICE_ZERO_PIXEL_UPPER_LEFT : di_cta_vesa_display_device_zero_pixel_location = 0 ; pub const di_cta_vesa_display_device_zero_pixel_location_DI_CTA_VESA_DISPLAY_DEVICE_ZERO_PIXEL_UPPER_RIGHT : di_cta_vesa_display_device_zero_pixel_location = 1 ; pub const di_cta_vesa_display_device_zero_pixel_location_DI_CTA_VESA_DISPLAY_DEVICE_ZERO_PIXEL_LOWER_LEFT : di_cta_vesa_display_device_zero_pixel_location = 2 ; pub const di_cta_vesa_display_device_zero_pixel_location_DI_CTA_VESA_DISPLAY_DEVICE_ZERO_PIXEL_LOWER_RIGHT : di_cta_vesa_display_device_zero_pixel_location = 3 ; pub type di_cta_vesa_display_device_zero_pixel_location = ::std::os::raw::c_uint; pub const di_cta_vesa_display_device_scan_direction_DI_CTA_VESA_DISPLAY_DEVICE_SCAN_DIRECTION_UNDEFINED : di_cta_vesa_display_device_scan_direction = 0 ; pub const di_cta_vesa_display_device_scan_direction_DI_CTA_VESA_DISPLAY_DEVICE_SCAN_DIRECTION_FAST_LONG_SLOW_SHORT : di_cta_vesa_display_device_scan_direction = 1 ; pub const di_cta_vesa_display_device_scan_direction_DI_CTA_VESA_DISPLAY_DEVICE_SCAN_DIRECTION_FAST_SHORT_SLOW_LONG : di_cta_vesa_display_device_scan_direction = 2 ; pub type di_cta_vesa_display_device_scan_direction = ::std::os::raw::c_uint; pub const di_cta_vesa_display_device_subpixel_layout_DI_CTA_VESA_DISPLAY_DEVICE_SUBPIXEL_UNDEFINED : di_cta_vesa_display_device_subpixel_layout = 0 ; pub const di_cta_vesa_display_device_subpixel_layout_DI_CTA_VESA_DISPLAY_DEVICE_SUBPIXEL_RGB_VERT : di_cta_vesa_display_device_subpixel_layout = 1 ; pub const di_cta_vesa_display_device_subpixel_layout_DI_CTA_VESA_DISPLAY_DEVICE_SUBPIXEL_RGB_HORIZ : di_cta_vesa_display_device_subpixel_layout = 2 ; pub const di_cta_vesa_display_device_subpixel_layout_DI_CTA_VESA_DISPLAY_DEVICE_SUBPIXEL_EDID_CHROM_VERT : di_cta_vesa_display_device_subpixel_layout = 3 ; pub const di_cta_vesa_display_device_subpixel_layout_DI_CTA_VESA_DISPLAY_DEVICE_SUBPIXEL_EDID_CHROM_HORIZ : di_cta_vesa_display_device_subpixel_layout = 4 ; pub const di_cta_vesa_display_device_subpixel_layout_DI_CTA_VESA_DISPLAY_DEVICE_SUBPIXEL_QUAD_RGGB : di_cta_vesa_display_device_subpixel_layout = 5 ; pub const di_cta_vesa_display_device_subpixel_layout_DI_CTA_VESA_DISPLAY_DEVICE_SUBPIXEL_QUAD_GBRG : di_cta_vesa_display_device_subpixel_layout = 6 ; pub const di_cta_vesa_display_device_subpixel_layout_DI_CTA_VESA_DISPLAY_DEVICE_SUBPIXEL_DELTA_RGB : di_cta_vesa_display_device_subpixel_layout = 7 ; pub const di_cta_vesa_display_device_subpixel_layout_DI_CTA_VESA_DISPLAY_DEVICE_SUBPIXEL_MOSAIC: di_cta_vesa_display_device_subpixel_layout = 8; pub const di_cta_vesa_display_device_subpixel_layout_DI_CTA_VESA_DISPLAY_DEVICE_SUBPIXEL_QUAD_ANY : di_cta_vesa_display_device_subpixel_layout = 9 ; pub const di_cta_vesa_display_device_subpixel_layout_DI_CTA_VESA_DISPLAY_DEVICE_SUBPIXEL_FIVE: di_cta_vesa_display_device_subpixel_layout = 10; pub const di_cta_vesa_display_device_subpixel_layout_DI_CTA_VESA_DISPLAY_DEVICE_SUBPIXEL_SIX: di_cta_vesa_display_device_subpixel_layout = 11; pub const di_cta_vesa_display_device_subpixel_layout_DI_CTA_VESA_DISPLAY_DEVICE_SUBPIXEL_CLAIRVOYANTE_PENTILE : di_cta_vesa_display_device_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_display_device_subpixel_layout = ::std::os::raw::c_uint; pub const di_cta_vesa_display_device_dithering_type_DI_CTA_VESA_DISPLAY_DEVICE_DITHERING_NONE: di_cta_vesa_display_device_dithering_type = 0; pub const di_cta_vesa_display_device_dithering_type_DI_CTA_VESA_DISPLAY_DEVICE_DITHERING_SPACIAL: di_cta_vesa_display_device_dithering_type = 1; pub const di_cta_vesa_display_device_dithering_type_DI_CTA_VESA_DISPLAY_DEVICE_DITHERING_TEMPORAL : di_cta_vesa_display_device_dithering_type = 2 ; pub const di_cta_vesa_display_device_dithering_type_DI_CTA_VESA_DISPLAY_DEVICE_DITHERING_SPATIAL_AND_TEMPORAL : di_cta_vesa_display_device_dithering_type = 3 ; pub type di_cta_vesa_display_device_dithering_type = ::std::os::raw::c_uint; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_cta_vesa_display_device_additional_primary_chromaticity { pub x: f32, pub y: f32, } #[test] fn bindgen_test_layout_di_cta_vesa_display_device_additional_primary_chromaticity() { const UNINIT: ::std::mem::MaybeUninit< di_cta_vesa_display_device_additional_primary_chromaticity, > = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), 8usize, concat!( "Size of: ", stringify!(di_cta_vesa_display_device_additional_primary_chromaticity) ) ); assert_eq!( ::std::mem::align_of::(), 4usize, concat!( "Alignment of ", stringify!(di_cta_vesa_display_device_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_display_device_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_display_device_additional_primary_chromaticity), "::", stringify!(y) ) ); } pub const di_cta_vesa_display_device_frame_rate_conversion_DI_CTA_VESA_DISPLAY_DEVICE_FRAME_RATE_CONVERSION_NONE : di_cta_vesa_display_device_frame_rate_conversion = 0 ; pub const di_cta_vesa_display_device_frame_rate_conversion_DI_CTA_VESA_DISPLAY_DEVICE_FRAME_RATE_CONVERSION_SINGLE_BUFFERING : di_cta_vesa_display_device_frame_rate_conversion = 1 ; pub const di_cta_vesa_display_device_frame_rate_conversion_DI_CTA_VESA_DISPLAY_DEVICE_FRAME_RATE_CONVERSION_DOUBLE_BUFFERING : di_cta_vesa_display_device_frame_rate_conversion = 2 ; pub const di_cta_vesa_display_device_frame_rate_conversion_DI_CTA_VESA_DISPLAY_DEVICE_FRAME_RATE_CONVERSION_ADVANCED : di_cta_vesa_display_device_frame_rate_conversion = 3 ; pub type di_cta_vesa_display_device_frame_rate_conversion = ::std::os::raw::c_uint; pub const di_cta_vesa_display_device_resp_time_transition_DI_CTA_VESA_DISPLAY_DEVICE_RESP_TIME_BLACK_TO_WHITE : di_cta_vesa_display_device_resp_time_transition = 0 ; pub const di_cta_vesa_display_device_resp_time_transition_DI_CTA_VESA_DISPLAY_DEVICE_RESP_TIME_WHITE_TO_BLACK : di_cta_vesa_display_device_resp_time_transition = 1 ; pub type di_cta_vesa_display_device_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_display_device_block { pub interface_type: di_cta_vesa_display_device_interface_type, pub num_channels: i32, pub interface_version: i32, pub interface_release: i32, pub content_protection: di_cta_vesa_display_device_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_display_device_default_orientation, pub rotation_cap: di_cta_vesa_display_device_rotation_cap, pub zero_pixel_location: di_cta_vesa_display_device_zero_pixel_location, pub scan_direction: di_cta_vesa_display_device_scan_direction, pub subpixel_layout: di_cta_vesa_display_device_subpixel_layout, pub horiz_pitch_mm: f32, pub vert_pitch_mm: f32, pub dithering_type: di_cta_vesa_display_device_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_display_device_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_display_device_additional_primary_chromaticity; 3usize], pub resp_time_transition: di_cta_vesa_display_device_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_display_device_block() { 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_display_device_block)) ); assert_eq!( ::std::mem::align_of::(), 8usize, concat!( "Alignment of ", stringify!(di_cta_vesa_display_device_block) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).interface_type) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_cta_vesa_display_device_block), "::", 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_display_device_block), "::", 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_display_device_block), "::", 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_display_device_block), "::", 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_display_device_block), "::", 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_display_device_block), "::", 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_display_device_block), "::", 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_display_device_block), "::", 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_display_device_block), "::", 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_display_device_block), "::", 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_display_device_block), "::", 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_display_device_block), "::", 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_display_device_block), "::", 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_display_device_block), "::", 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_display_device_block), "::", 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_display_device_block), "::", 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_display_device_block), "::", 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_display_device_block), "::", 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_display_device_block), "::", 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_display_device_block), "::", 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_display_device_block), "::", 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_display_device_block), "::", 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_display_device_block), "::", 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_display_device_block), "::", 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_display_device_block), "::", 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_display_device_block), "::", 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_display_device_block), "::", 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_display_device_block), "::", 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_display_device_block), "::", 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_display_device_block), "::", 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_display_device_block), "::", 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_display_device_block), "::", 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_display_device_block), "::", 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_display_device_block), "::", 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_display_device_block), "::", 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_display_device_block), "::", 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_display_device_block), "::", 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_display_device( block: *const di_cta_data_block, ) -> *const di_cta_vesa_display_device_block; } #[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_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_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_eotfs)) ); assert_eq!( ::std::mem::align_of::(), 1usize, concat!( "Alignment of ", stringify!(di_cta_hdr_static_metadata_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_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_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_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_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_descriptors { pub type1: bool, } #[test] fn bindgen_test_layout_di_cta_hdr_static_metadata_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_descriptors) ) ); assert_eq!( ::std::mem::align_of::(), 1usize, concat!( "Alignment of ", stringify!(di_cta_hdr_static_metadata_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_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_eotfs, pub descriptors: *const di_cta_hdr_static_metadata_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_type1 { pub type_1_hdr_metadata_version: u8, } #[test] fn bindgen_test_layout_di_cta_hdr_dynamic_metadata_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_type1)) ); assert_eq!( ::std::mem::align_of::(), 1usize, concat!( "Alignment of ", stringify!(di_cta_hdr_dynamic_metadata_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_type1), "::", stringify!(type_1_hdr_metadata_version) ) ); } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_cta_hdr_dynamic_metadata_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_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_type2)) ); assert_eq!( ::std::mem::align_of::(), 1usize, concat!( "Alignment of ", stringify!(di_cta_hdr_dynamic_metadata_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_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_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_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_type2), "::", stringify!(ts_103_433_3_capable) ) ); } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_cta_hdr_dynamic_metadata_type3 { _unused: [u8; 0], } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_cta_hdr_dynamic_metadata_type4 { pub type_4_hdr_metadata_version: u8, } #[test] fn bindgen_test_layout_di_cta_hdr_dynamic_metadata_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_type4)) ); assert_eq!( ::std::mem::align_of::(), 1usize, concat!( "Alignment of ", stringify!(di_cta_hdr_dynamic_metadata_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_type4), "::", stringify!(type_4_hdr_metadata_version) ) ); } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_cta_hdr_dynamic_metadata_type256 { pub graphics_overlay_flag_version: u8, } #[test] fn bindgen_test_layout_di_cta_hdr_dynamic_metadata_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_type256)) ); assert_eq!( ::std::mem::align_of::(), 1usize, concat!( "Alignment of ", stringify!(di_cta_hdr_dynamic_metadata_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_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_type1, pub type2: *const di_cta_hdr_dynamic_metadata_type2, pub type3: *const di_cta_hdr_dynamic_metadata_type3, pub type4: *const di_cta_hdr_dynamic_metadata_type4, pub type256: *const di_cta_hdr_dynamic_metadata_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 original_index: 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::(), 3usize, 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).original_index) as usize - ptr as usize }, 1usize, concat!( "Offset of field: ", stringify!(di_cta_svd), "::", stringify!(original_index) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).native) as usize - ptr as usize }, 2usize, concat!( "Offset of field: ", stringify!(di_cta_svd), "::", stringify!(native) ) ); } #[doc = " Video Data Block, defined in section 7.5.1."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_cta_video_block { pub svds: *const *const di_cta_svd, } #[test] fn bindgen_test_layout_di_cta_video_block() { 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_video_block)) ); assert_eq!( ::std::mem::align_of::(), 8usize, concat!("Alignment of ", stringify!(di_cta_video_block)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).svds) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_cta_video_block), "::", stringify!(svds) ) ); } extern "C" { #[doc = " Get the video from a CTA data block.\n\n Returns NULL if the data block tag is not DI_CTA_DATA_BLOCK_VIDEO."] pub fn di_cta_data_block_get_video( block: *const di_cta_data_block, ) -> *const di_cta_video_block; } #[doc = " Video Data Block, defined in section 7.5.1."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_cta_ycbcr420_video_block { pub svds: *const *const di_cta_svd, } #[test] fn bindgen_test_layout_di_cta_ycbcr420_video_block() { 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_ycbcr420_video_block)) ); assert_eq!( ::std::mem::align_of::(), 8usize, concat!("Alignment of ", stringify!(di_cta_ycbcr420_video_block)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).svds) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_cta_ycbcr420_video_block), "::", stringify!(svds) ) ); } extern "C" { #[doc = " Get the YCbCr video from a CTA data block.\n\n Returns NULL if the data block tag is not DI_CTA_DATA_BLOCK_YCBCR420."] pub fn di_cta_data_block_get_ycbcr420_video( block: *const di_cta_data_block, ) -> *const di_cta_ycbcr420_video_block; } 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_block { 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_block() { 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_block) ) ); assert_eq!( ::std::mem::align_of::(), 4usize, concat!( "Alignment of ", stringify!(di_cta_vesa_transfer_characteristics_block) ) ); 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_block), "::", 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_block), "::", 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_block), "::", 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_block; } #[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_block { _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_block, 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_block; } pub const di_cta_hdmi_audio_3d_channels_DI_CTA_HDMI_AUDIO_3D_CHANNELS_UNKNOWN: di_cta_hdmi_audio_3d_channels = 0; pub const di_cta_hdmi_audio_3d_channels_DI_CTA_HDMI_AUDIO_3D_CHANNELS_10_2: di_cta_hdmi_audio_3d_channels = 1; pub const di_cta_hdmi_audio_3d_channels_DI_CTA_HDMI_AUDIO_3D_CHANNELS_22_2: di_cta_hdmi_audio_3d_channels = 2; pub const di_cta_hdmi_audio_3d_channels_DI_CTA_HDMI_AUDIO_3D_CHANNELS_30_2: di_cta_hdmi_audio_3d_channels = 3; pub type di_cta_hdmi_audio_3d_channels = ::std::os::raw::c_uint; #[doc = " HDMI 3D Audio"] #[repr(C)] #[derive(Debug, Copy, Clone)] 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] 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)] pub struct di_cta_hdmi_audio_multi_stream { pub max_streams: ::std::os::raw::c_int, pub supports_non_mixed: bool, } #[test] 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)] 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] 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) ) ); } 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; } #[doc = " HDR10+ Vendor-Specific Video Data Block"] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_cta_hdr10plus_block { pub version: ::std::os::raw::c_int, pub peak_lum: ::std::os::raw::c_int, pub ff_peak_lum: ::std::os::raw::c_int, } #[test] fn bindgen_test_layout_di_cta_hdr10plus_block() { 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_cta_hdr10plus_block)) ); assert_eq!( ::std::mem::align_of::(), 4usize, concat!("Alignment of ", stringify!(di_cta_hdr10plus_block)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).version) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_cta_hdr10plus_block), "::", stringify!(version) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).peak_lum) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", stringify!(di_cta_hdr10plus_block), "::", stringify!(peak_lum) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).ff_peak_lum) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", stringify!(di_cta_hdr10plus_block), "::", stringify!(ff_peak_lum) ) ); } extern "C" { #[doc = " Get the HDR10+ information from a CTA data block.\n\n Returns NULL if the data block tag is not DI_CTA_DATA_BLOCK_HDR10PLUS."] pub fn di_cta_data_block_get_hdr10plus( block: *const di_cta_data_block, ) -> *const di_cta_hdr10plus_block; } pub const di_cta_dolby_video_colorimetry_DI_CTA_DOLBY_VIDEO_COLORIMETRY_BT_709: di_cta_dolby_video_colorimetry = 0; pub const di_cta_dolby_video_colorimetry_DI_CTA_DOLBY_VIDEO_COLORIMETRY_P3_D65: di_cta_dolby_video_colorimetry = 1; #[doc = " Dolby Video Colorimetry"] pub type di_cta_dolby_video_colorimetry = ::std::os::raw::c_uint; pub const di_cta_dolby_video_yuv444_DI_CTA_DOLBY_VIDEO_YUV444_NONE: di_cta_dolby_video_yuv444 = 0; pub const di_cta_dolby_video_yuv444_DI_CTA_DOLBY_VIDEO_YUV444_10_BITS: di_cta_dolby_video_yuv444 = 1; pub const di_cta_dolby_video_yuv444_DI_CTA_DOLBY_VIDEO_YUV444_12_BITS: di_cta_dolby_video_yuv444 = 2; #[doc = " Dolby Video YUV 4:4:4 support"] pub type di_cta_dolby_video_yuv444 = ::std::os::raw::c_uint; #[doc = " Dolby Video Version 0 Data"] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_cta_dolby_video_block_v0 { pub yuv422_12bit: bool, pub global_dimming: bool, pub supports_2160p60: bool, pub dynamic_metadata_version_major: ::std::os::raw::c_int, pub dynamic_metadata_version_minor: ::std::os::raw::c_int, pub target_pq_12b_level_min: ::std::os::raw::c_int, pub target_pq_12b_level_max: ::std::os::raw::c_int, pub red_x: f64, pub red_y: f64, pub green_x: f64, pub green_y: f64, pub blue_x: f64, pub blue_y: f64, pub white_x: f64, pub white_y: f64, } #[test] fn bindgen_test_layout_di_cta_dolby_video_block_v0() { 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_dolby_video_block_v0)) ); assert_eq!( ::std::mem::align_of::(), 8usize, concat!("Alignment of ", stringify!(di_cta_dolby_video_block_v0)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).yuv422_12bit) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_cta_dolby_video_block_v0), "::", stringify!(yuv422_12bit) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).global_dimming) as usize - ptr as usize }, 1usize, concat!( "Offset of field: ", stringify!(di_cta_dolby_video_block_v0), "::", stringify!(global_dimming) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).supports_2160p60) as usize - ptr as usize }, 2usize, concat!( "Offset of field: ", stringify!(di_cta_dolby_video_block_v0), "::", stringify!(supports_2160p60) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).dynamic_metadata_version_major) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", stringify!(di_cta_dolby_video_block_v0), "::", stringify!(dynamic_metadata_version_major) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).dynamic_metadata_version_minor) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", stringify!(di_cta_dolby_video_block_v0), "::", stringify!(dynamic_metadata_version_minor) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).target_pq_12b_level_min) as usize - ptr as usize }, 12usize, concat!( "Offset of field: ", stringify!(di_cta_dolby_video_block_v0), "::", stringify!(target_pq_12b_level_min) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).target_pq_12b_level_max) as usize - ptr as usize }, 16usize, concat!( "Offset of field: ", stringify!(di_cta_dolby_video_block_v0), "::", stringify!(target_pq_12b_level_max) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).red_x) as usize - ptr as usize }, 24usize, concat!( "Offset of field: ", stringify!(di_cta_dolby_video_block_v0), "::", stringify!(red_x) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).red_y) as usize - ptr as usize }, 32usize, concat!( "Offset of field: ", stringify!(di_cta_dolby_video_block_v0), "::", stringify!(red_y) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).green_x) as usize - ptr as usize }, 40usize, concat!( "Offset of field: ", stringify!(di_cta_dolby_video_block_v0), "::", stringify!(green_x) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).green_y) as usize - ptr as usize }, 48usize, concat!( "Offset of field: ", stringify!(di_cta_dolby_video_block_v0), "::", stringify!(green_y) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).blue_x) as usize - ptr as usize }, 56usize, concat!( "Offset of field: ", stringify!(di_cta_dolby_video_block_v0), "::", stringify!(blue_x) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).blue_y) as usize - ptr as usize }, 64usize, concat!( "Offset of field: ", stringify!(di_cta_dolby_video_block_v0), "::", stringify!(blue_y) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).white_x) as usize - ptr as usize }, 72usize, concat!( "Offset of field: ", stringify!(di_cta_dolby_video_block_v0), "::", stringify!(white_x) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).white_y) as usize - ptr as usize }, 80usize, concat!( "Offset of field: ", stringify!(di_cta_dolby_video_block_v0), "::", stringify!(white_y) ) ); } #[doc = " Dolby Video Version 1 Data"] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_cta_dolby_video_block_v1 { pub yuv422_12bit: bool, pub global_dimming: bool, pub supports_2160p60: bool, pub dynamic_metadata_version: ::std::os::raw::c_int, pub colorimetry: di_cta_dolby_video_colorimetry, pub target_luminance_min: f64, pub target_luminance_max: f64, pub mode_low_latency: bool, pub unique_primaries: bool, pub red_x: f64, pub red_y: f64, pub green_x: f64, pub green_y: f64, pub blue_x: f64, pub blue_y: f64, } #[test] fn bindgen_test_layout_di_cta_dolby_video_block_v1() { 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_dolby_video_block_v1)) ); assert_eq!( ::std::mem::align_of::(), 8usize, concat!("Alignment of ", stringify!(di_cta_dolby_video_block_v1)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).yuv422_12bit) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_cta_dolby_video_block_v1), "::", stringify!(yuv422_12bit) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).global_dimming) as usize - ptr as usize }, 1usize, concat!( "Offset of field: ", stringify!(di_cta_dolby_video_block_v1), "::", stringify!(global_dimming) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).supports_2160p60) as usize - ptr as usize }, 2usize, concat!( "Offset of field: ", stringify!(di_cta_dolby_video_block_v1), "::", stringify!(supports_2160p60) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).dynamic_metadata_version) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", stringify!(di_cta_dolby_video_block_v1), "::", stringify!(dynamic_metadata_version) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).colorimetry) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", stringify!(di_cta_dolby_video_block_v1), "::", stringify!(colorimetry) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).target_luminance_min) as usize - ptr as usize }, 16usize, concat!( "Offset of field: ", stringify!(di_cta_dolby_video_block_v1), "::", stringify!(target_luminance_min) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).target_luminance_max) as usize - ptr as usize }, 24usize, concat!( "Offset of field: ", stringify!(di_cta_dolby_video_block_v1), "::", stringify!(target_luminance_max) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).mode_low_latency) as usize - ptr as usize }, 32usize, concat!( "Offset of field: ", stringify!(di_cta_dolby_video_block_v1), "::", stringify!(mode_low_latency) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).unique_primaries) as usize - ptr as usize }, 33usize, concat!( "Offset of field: ", stringify!(di_cta_dolby_video_block_v1), "::", stringify!(unique_primaries) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).red_x) as usize - ptr as usize }, 40usize, concat!( "Offset of field: ", stringify!(di_cta_dolby_video_block_v1), "::", stringify!(red_x) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).red_y) as usize - ptr as usize }, 48usize, concat!( "Offset of field: ", stringify!(di_cta_dolby_video_block_v1), "::", stringify!(red_y) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).green_x) as usize - ptr as usize }, 56usize, concat!( "Offset of field: ", stringify!(di_cta_dolby_video_block_v1), "::", stringify!(green_x) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).green_y) as usize - ptr as usize }, 64usize, concat!( "Offset of field: ", stringify!(di_cta_dolby_video_block_v1), "::", stringify!(green_y) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).blue_x) as usize - ptr as usize }, 72usize, concat!( "Offset of field: ", stringify!(di_cta_dolby_video_block_v1), "::", stringify!(blue_x) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).blue_y) as usize - ptr as usize }, 80usize, concat!( "Offset of field: ", stringify!(di_cta_dolby_video_block_v1), "::", stringify!(blue_y) ) ); } #[doc = " Dolby Video Version 2 Data"] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_cta_dolby_video_block_v2 { pub yuv422_12bit: bool, pub global_dimming: bool, pub dynamic_metadata_version: ::std::os::raw::c_int, pub backlight_control: bool, pub backlight_luminance_min: f64, pub mode_standard: bool, pub mode_low_latency_hdmi: bool, pub yuv444: di_cta_dolby_video_yuv444, pub target_pq_12b_level_min: ::std::os::raw::c_int, pub target_pq_12b_level_max: ::std::os::raw::c_int, pub red_x: f64, pub red_y: f64, pub green_x: f64, pub green_y: f64, pub blue_x: f64, pub blue_y: f64, } #[test] fn bindgen_test_layout_di_cta_dolby_video_block_v2() { 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_dolby_video_block_v2)) ); assert_eq!( ::std::mem::align_of::(), 8usize, concat!("Alignment of ", stringify!(di_cta_dolby_video_block_v2)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).yuv422_12bit) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_cta_dolby_video_block_v2), "::", stringify!(yuv422_12bit) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).global_dimming) as usize - ptr as usize }, 1usize, concat!( "Offset of field: ", stringify!(di_cta_dolby_video_block_v2), "::", stringify!(global_dimming) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).dynamic_metadata_version) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", stringify!(di_cta_dolby_video_block_v2), "::", stringify!(dynamic_metadata_version) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).backlight_control) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", stringify!(di_cta_dolby_video_block_v2), "::", stringify!(backlight_control) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).backlight_luminance_min) as usize - ptr as usize }, 16usize, concat!( "Offset of field: ", stringify!(di_cta_dolby_video_block_v2), "::", stringify!(backlight_luminance_min) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).mode_standard) as usize - ptr as usize }, 24usize, concat!( "Offset of field: ", stringify!(di_cta_dolby_video_block_v2), "::", stringify!(mode_standard) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).mode_low_latency_hdmi) as usize - ptr as usize }, 25usize, concat!( "Offset of field: ", stringify!(di_cta_dolby_video_block_v2), "::", stringify!(mode_low_latency_hdmi) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).yuv444) as usize - ptr as usize }, 28usize, concat!( "Offset of field: ", stringify!(di_cta_dolby_video_block_v2), "::", stringify!(yuv444) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).target_pq_12b_level_min) as usize - ptr as usize }, 32usize, concat!( "Offset of field: ", stringify!(di_cta_dolby_video_block_v2), "::", stringify!(target_pq_12b_level_min) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).target_pq_12b_level_max) as usize - ptr as usize }, 36usize, concat!( "Offset of field: ", stringify!(di_cta_dolby_video_block_v2), "::", stringify!(target_pq_12b_level_max) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).red_x) as usize - ptr as usize }, 40usize, concat!( "Offset of field: ", stringify!(di_cta_dolby_video_block_v2), "::", stringify!(red_x) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).red_y) as usize - ptr as usize }, 48usize, concat!( "Offset of field: ", stringify!(di_cta_dolby_video_block_v2), "::", stringify!(red_y) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).green_x) as usize - ptr as usize }, 56usize, concat!( "Offset of field: ", stringify!(di_cta_dolby_video_block_v2), "::", stringify!(green_x) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).green_y) as usize - ptr as usize }, 64usize, concat!( "Offset of field: ", stringify!(di_cta_dolby_video_block_v2), "::", stringify!(green_y) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).blue_x) as usize - ptr as usize }, 72usize, concat!( "Offset of field: ", stringify!(di_cta_dolby_video_block_v2), "::", stringify!(blue_x) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).blue_y) as usize - ptr as usize }, 80usize, concat!( "Offset of field: ", stringify!(di_cta_dolby_video_block_v2), "::", stringify!(blue_y) ) ); } pub const di_cta_dolby_video_version_DI_CTA_DOLBY_VIDEO_VERSION0: di_cta_dolby_video_version = 0; pub const di_cta_dolby_video_version_DI_CTA_DOLBY_VIDEO_VERSION1: di_cta_dolby_video_version = 1; pub const di_cta_dolby_video_version_DI_CTA_DOLBY_VIDEO_VERSION2: di_cta_dolby_video_version = 2; #[doc = " Dolby Video Data Block version"] pub type di_cta_dolby_video_version = ::std::os::raw::c_uint; #[doc = " Dolby Video Data Block"] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_cta_dolby_video_block { pub version: di_cta_dolby_video_version, pub v0: *const di_cta_dolby_video_block_v0, pub v1: *const di_cta_dolby_video_block_v1, pub v2: *const di_cta_dolby_video_block_v2, } #[test] fn bindgen_test_layout_di_cta_dolby_video_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_dolby_video_block)) ); assert_eq!( ::std::mem::align_of::(), 8usize, concat!("Alignment of ", stringify!(di_cta_dolby_video_block)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).version) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_cta_dolby_video_block), "::", stringify!(version) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).v0) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", stringify!(di_cta_dolby_video_block), "::", stringify!(v0) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).v1) as usize - ptr as usize }, 16usize, concat!( "Offset of field: ", stringify!(di_cta_dolby_video_block), "::", stringify!(v1) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).v2) as usize - ptr as usize }, 24usize, concat!( "Offset of field: ", stringify!(di_cta_dolby_video_block), "::", stringify!(v2) ) ); } extern "C" { #[doc = " Get the Dolby Vision information from a CTA data block.\n\n Returns NULL if the data block tag is not DI_CTA_DATA_BLOCK_DOLBY_VIDEO."] pub fn di_cta_data_block_get_dolby_video( block: *const di_cta_data_block, ) -> *const di_cta_dolby_video_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)] pub struct di_cta_room_configuration_block { 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] fn bindgen_test_layout_di_cta_room_configuration_block() { 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_block)) ); assert_eq!( ::std::mem::align_of::(), 8usize, concat!("Alignment of ", stringify!(di_cta_room_configuration_block)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).speakers) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_cta_room_configuration_block), "::", 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_block), "::", 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_block), "::", 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_block), "::", 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_block), "::", 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_block), "::", 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_block), "::", 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_block), "::", 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_block), "::", stringify!(display_z) ) ); } 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_block; } pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_FL: di_cta_speaker_placement = 0; pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_FR: di_cta_speaker_placement = 1; pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_FC: di_cta_speaker_placement = 2; pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_LFE1: di_cta_speaker_placement = 3; pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_BL: di_cta_speaker_placement = 4; pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_BR: di_cta_speaker_placement = 5; pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_FLC: di_cta_speaker_placement = 6; pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_FRC: di_cta_speaker_placement = 7; pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_BC: di_cta_speaker_placement = 8; pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_LFE2: di_cta_speaker_placement = 9; pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_SIL: di_cta_speaker_placement = 10; pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_SIR: di_cta_speaker_placement = 11; pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_TPFL: di_cta_speaker_placement = 12; pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_TPFR: di_cta_speaker_placement = 13; pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_TPFC: di_cta_speaker_placement = 14; pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_TPC: di_cta_speaker_placement = 15; pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_TPBL: di_cta_speaker_placement = 16; pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_TPBR: di_cta_speaker_placement = 17; pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_TPSIL: di_cta_speaker_placement = 18; pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_TPSIR: di_cta_speaker_placement = 19; pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_TPBC: di_cta_speaker_placement = 20; pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_BTFC: di_cta_speaker_placement = 21; pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_BTFL: di_cta_speaker_placement = 22; pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_BRFR: di_cta_speaker_placement = 23; pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_FLW: di_cta_speaker_placement = 24; pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_FRW: di_cta_speaker_placement = 25; pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_LS: di_cta_speaker_placement = 26; pub const di_cta_speaker_placement_DI_CTA_SPEAKER_PLACEMENT_RS: di_cta_speaker_placement = 27; pub type di_cta_speaker_placement = ::std::os::raw::c_uint; #[doc = " Speaker Location Descriptor, defined in section 7.5.16."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_cta_speaker_location_descriptor { 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] fn bindgen_test_layout_di_cta_speaker_location_descriptor() { 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_location_descriptor)) ); assert_eq!( ::std::mem::align_of::(), 8usize, concat!( "Alignment of ", stringify!(di_cta_speaker_location_descriptor) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).channel_index) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_cta_speaker_location_descriptor), "::", 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_location_descriptor), "::", 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_location_descriptor), "::", 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_location_descriptor), "::", 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_location_descriptor), "::", 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_location_descriptor), "::", 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_location_descriptor), "::", stringify!(speaker_id) ) ); } #[doc = " Speaker Location Data Block, defined in section 7.5.16."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_cta_speaker_location_block { pub locations: *const *const di_cta_speaker_location_descriptor, } #[test] fn bindgen_test_layout_di_cta_speaker_location_block() { 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_speaker_location_block)) ); assert_eq!( ::std::mem::align_of::(), 8usize, concat!("Alignment of ", stringify!(di_cta_speaker_location_block)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).locations) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_cta_speaker_location_block), "::", stringify!(locations) ) ); } extern "C" { #[doc = " Get the Speaker Locations from a CTA data block.\n\n Returns NULL if the data block tag is not DI_CTA_DATA_BLOCK_SPEAKER_LOCATION."] pub fn di_cta_data_block_get_speaker_locations( block: *const di_cta_data_block, ) -> *const di_cta_speaker_location_block; } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_displayid_type_i_ii_vii_timing { _unused: [u8; 0], } #[doc = " Type VII Video Timing Data Block, defined in section 7.5.17.1"] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_cta_type_vii_timing_block { pub timing: *const di_displayid_type_i_ii_vii_timing, } #[test] fn bindgen_test_layout_di_cta_type_vii_timing_block() { 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_type_vii_timing_block)) ); assert_eq!( ::std::mem::align_of::(), 8usize, concat!("Alignment of ", stringify!(di_cta_type_vii_timing_block)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).timing) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_cta_type_vii_timing_block), "::", stringify!(timing) ) ); } 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_cta_type_vii_timing_block; } #[doc = " HDMI vendor-specific data block.\n\n This block is defined in HDMI 1.4b section 8.3.2."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_cta_vendor_hdmi_block { pub source_phys_addr: u16, pub supports_ai: bool, pub supports_dc_48bit: bool, pub supports_dc_36bit: bool, pub supports_dc_30bit: bool, pub supports_dc_y444: bool, pub supports_dvi_dual: bool, pub max_tmds_clock: ::std::os::raw::c_int, pub supports_content_graphics: bool, pub supports_content_photo: bool, pub supports_content_cinema: bool, pub supports_content_game: bool, #[doc = " If !has_latency and !has_interlaced_latency, we have no latency\n information at all.\n\n If only has_latency, video/audio latency fields are valid and\n should be used for both progressive and interlaced video/audio\n formats.\n\n If both are valid, it means that video_latency and audio_latency\n should be used for progressive video/audio formats, and their\n interlaced counterpart for interlaced formats."] pub has_latency: bool, pub has_interlaced_latency: bool, pub supports_progressive_video: bool, pub supports_progressive_audio: bool, pub supports_interlaced_video: bool, pub supports_interlaced_audio: bool, pub progressive_video_latency: ::std::os::raw::c_int, pub progressive_audio_latency: ::std::os::raw::c_int, pub interlaced_video_latency: ::std::os::raw::c_int, pub interlaced_audio_latency: ::std::os::raw::c_int, pub vics_len: usize, pub vics: *const u8, } #[test] fn bindgen_test_layout_di_cta_vendor_hdmi_block() { 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_cta_vendor_hdmi_block)) ); assert_eq!( ::std::mem::align_of::(), 8usize, concat!("Alignment of ", stringify!(di_cta_vendor_hdmi_block)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).source_phys_addr) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_cta_vendor_hdmi_block), "::", stringify!(source_phys_addr) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).supports_ai) as usize - ptr as usize }, 2usize, concat!( "Offset of field: ", stringify!(di_cta_vendor_hdmi_block), "::", stringify!(supports_ai) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).supports_dc_48bit) as usize - ptr as usize }, 3usize, concat!( "Offset of field: ", stringify!(di_cta_vendor_hdmi_block), "::", stringify!(supports_dc_48bit) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).supports_dc_36bit) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", stringify!(di_cta_vendor_hdmi_block), "::", stringify!(supports_dc_36bit) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).supports_dc_30bit) as usize - ptr as usize }, 5usize, concat!( "Offset of field: ", stringify!(di_cta_vendor_hdmi_block), "::", stringify!(supports_dc_30bit) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).supports_dc_y444) as usize - ptr as usize }, 6usize, concat!( "Offset of field: ", stringify!(di_cta_vendor_hdmi_block), "::", stringify!(supports_dc_y444) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).supports_dvi_dual) as usize - ptr as usize }, 7usize, concat!( "Offset of field: ", stringify!(di_cta_vendor_hdmi_block), "::", stringify!(supports_dvi_dual) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).max_tmds_clock) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", stringify!(di_cta_vendor_hdmi_block), "::", stringify!(max_tmds_clock) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).supports_content_graphics) as usize - ptr as usize }, 12usize, concat!( "Offset of field: ", stringify!(di_cta_vendor_hdmi_block), "::", stringify!(supports_content_graphics) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).supports_content_photo) as usize - ptr as usize }, 13usize, concat!( "Offset of field: ", stringify!(di_cta_vendor_hdmi_block), "::", stringify!(supports_content_photo) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).supports_content_cinema) as usize - ptr as usize }, 14usize, concat!( "Offset of field: ", stringify!(di_cta_vendor_hdmi_block), "::", stringify!(supports_content_cinema) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).supports_content_game) as usize - ptr as usize }, 15usize, concat!( "Offset of field: ", stringify!(di_cta_vendor_hdmi_block), "::", stringify!(supports_content_game) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).has_latency) as usize - ptr as usize }, 16usize, concat!( "Offset of field: ", stringify!(di_cta_vendor_hdmi_block), "::", stringify!(has_latency) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).has_interlaced_latency) as usize - ptr as usize }, 17usize, concat!( "Offset of field: ", stringify!(di_cta_vendor_hdmi_block), "::", stringify!(has_interlaced_latency) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).supports_progressive_video) as usize - ptr as usize }, 18usize, concat!( "Offset of field: ", stringify!(di_cta_vendor_hdmi_block), "::", stringify!(supports_progressive_video) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).supports_progressive_audio) as usize - ptr as usize }, 19usize, concat!( "Offset of field: ", stringify!(di_cta_vendor_hdmi_block), "::", stringify!(supports_progressive_audio) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).supports_interlaced_video) as usize - ptr as usize }, 20usize, concat!( "Offset of field: ", stringify!(di_cta_vendor_hdmi_block), "::", stringify!(supports_interlaced_video) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).supports_interlaced_audio) as usize - ptr as usize }, 21usize, concat!( "Offset of field: ", stringify!(di_cta_vendor_hdmi_block), "::", stringify!(supports_interlaced_audio) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).progressive_video_latency) as usize - ptr as usize }, 24usize, concat!( "Offset of field: ", stringify!(di_cta_vendor_hdmi_block), "::", stringify!(progressive_video_latency) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).progressive_audio_latency) as usize - ptr as usize }, 28usize, concat!( "Offset of field: ", stringify!(di_cta_vendor_hdmi_block), "::", stringify!(progressive_audio_latency) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).interlaced_video_latency) as usize - ptr as usize }, 32usize, concat!( "Offset of field: ", stringify!(di_cta_vendor_hdmi_block), "::", stringify!(interlaced_video_latency) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).interlaced_audio_latency) as usize - ptr as usize }, 36usize, concat!( "Offset of field: ", stringify!(di_cta_vendor_hdmi_block), "::", stringify!(interlaced_audio_latency) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).vics_len) as usize - ptr as usize }, 40usize, concat!( "Offset of field: ", stringify!(di_cta_vendor_hdmi_block), "::", stringify!(vics_len) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).vics) as usize - ptr as usize }, 48usize, concat!( "Offset of field: ", stringify!(di_cta_vendor_hdmi_block), "::", stringify!(vics) ) ); } extern "C" { #[doc = " Get the vendor-specific HDMI information from a CTA data block.\n\n Note, the HDMI and HDMI Forum vendor-specific data blocks are different.\n\n Returns NULL if the data block tag is not\n DI_CTA_DATA_BLOCK_VENDOR_HDMI."] pub fn di_cta_data_block_get_vendor_hdmi( block: *const di_cta_data_block, ) -> *const di_cta_vendor_hdmi_block; } pub const di_cta_hdmi_frl_DI_CTA_HDMI_FRL_UNSUPPORTED: di_cta_hdmi_frl = 0; pub const di_cta_hdmi_frl_DI_CTA_HDMI_FRL_3GBPS_3LANES: di_cta_hdmi_frl = 1; pub const di_cta_hdmi_frl_DI_CTA_HDMI_FRL_6GBPS_3LANES: di_cta_hdmi_frl = 2; pub const di_cta_hdmi_frl_DI_CTA_HDMI_FRL_6GBPS_4LANES: di_cta_hdmi_frl = 3; pub const di_cta_hdmi_frl_DI_CTA_HDMI_FRL_8GBPS_4LANES: di_cta_hdmi_frl = 4; pub const di_cta_hdmi_frl_DI_CTA_HDMI_FRL_10GBPS_4LANES: di_cta_hdmi_frl = 5; pub const di_cta_hdmi_frl_DI_CTA_HDMI_FRL_12GBPS_4LANES: di_cta_hdmi_frl = 6; #[doc = " Fixed Rate Link (FRL) support."] pub type di_cta_hdmi_frl = ::std::os::raw::c_uint; pub const di_cta_hdmi_dsc_max_slices_DI_CTA_HDMI_DSC_MAX_SLICES_UNSUPPORTED: di_cta_hdmi_dsc_max_slices = 0; pub const di_cta_hdmi_dsc_max_slices_DI_CTA_HDMI_DSC_MAX_SLICES_1_340MHZ: di_cta_hdmi_dsc_max_slices = 1; pub const di_cta_hdmi_dsc_max_slices_DI_CTA_HDMI_DSC_MAX_SLICES_2_340MHZ: di_cta_hdmi_dsc_max_slices = 2; pub const di_cta_hdmi_dsc_max_slices_DI_CTA_HDMI_DSC_MAX_SLICES_4_340MHZ: di_cta_hdmi_dsc_max_slices = 3; pub const di_cta_hdmi_dsc_max_slices_DI_CTA_HDMI_DSC_MAX_SLICES_8_340MHZ: di_cta_hdmi_dsc_max_slices = 4; pub const di_cta_hdmi_dsc_max_slices_DI_CTA_HDMI_DSC_MAX_SLICES_8_400MHZ: di_cta_hdmi_dsc_max_slices = 5; pub const di_cta_hdmi_dsc_max_slices_DI_CTA_HDMI_DSC_MAX_SLICES_12_400MHZ: di_cta_hdmi_dsc_max_slices = 6; pub const di_cta_hdmi_dsc_max_slices_DI_CTA_HDMI_DSC_MAX_SLICES_16_400MHZ: di_cta_hdmi_dsc_max_slices = 7; pub type di_cta_hdmi_dsc_max_slices = ::std::os::raw::c_uint; #[doc = " Display Stream Compression (DSC) support."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_cta_hdmi_dsc { pub supports_10bpc: bool, pub supports_12bpc: bool, pub supports_all_bpc: bool, pub supports_native_420: bool, pub max_slices: di_cta_hdmi_dsc_max_slices, pub max_frl_rate: di_cta_hdmi_frl, pub max_total_chunk_bytes: ::std::os::raw::c_int, } #[test] fn bindgen_test_layout_di_cta_hdmi_dsc() { 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_dsc)) ); assert_eq!( ::std::mem::align_of::(), 4usize, concat!("Alignment of ", stringify!(di_cta_hdmi_dsc)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).supports_10bpc) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_cta_hdmi_dsc), "::", stringify!(supports_10bpc) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).supports_12bpc) as usize - ptr as usize }, 1usize, concat!( "Offset of field: ", stringify!(di_cta_hdmi_dsc), "::", stringify!(supports_12bpc) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).supports_all_bpc) as usize - ptr as usize }, 2usize, concat!( "Offset of field: ", stringify!(di_cta_hdmi_dsc), "::", stringify!(supports_all_bpc) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).supports_native_420) as usize - ptr as usize }, 3usize, concat!( "Offset of field: ", stringify!(di_cta_hdmi_dsc), "::", stringify!(supports_native_420) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).max_slices) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", stringify!(di_cta_hdmi_dsc), "::", stringify!(max_slices) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).max_frl_rate) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", stringify!(di_cta_hdmi_dsc), "::", stringify!(max_frl_rate) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).max_total_chunk_bytes) as usize - ptr as usize }, 12usize, concat!( "Offset of field: ", stringify!(di_cta_hdmi_dsc), "::", stringify!(max_total_chunk_bytes) ) ); } #[doc = " HDMI Sink Capability Data Structure (SCDS).\n\n This data is exposed via HDMI Forum Vendor-Specific Data Block (HF-VSDB) or\n the HDMI Forum Sink Capability Data Block (HF-SCDB)."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_cta_hdmi_scds { pub version: ::std::os::raw::c_int, pub max_tmds_char_rate_mhz: ::std::os::raw::c_int, pub supports_3d_osd_disparity: bool, pub supports_3d_dual_view: bool, pub supports_3d_independent_view: bool, pub supports_lte_340mcsc_scramble: bool, pub supports_ccbpci: bool, pub supports_cable_status: bool, pub supports_scdc_read_request: bool, pub supports_scdc: bool, pub supports_dc_30bit_420: bool, pub supports_dc_36bit_420: bool, pub supports_dc_48bit_420: bool, pub supports_uhd_vic: bool, pub max_frl_rate: di_cta_hdmi_frl, pub supports_fapa_start_location: bool, pub supports_allm: bool, pub supports_fva: bool, pub supports_neg_mvrr: bool, pub supports_cinema_vrr: bool, pub m_delta: bool, pub supports_qms: bool, pub supports_fapa_end_extended: bool, pub vrr_min_hz: ::std::os::raw::c_int, pub vrr_max_hz: ::std::os::raw::c_int, pub qms_tfr_min: bool, pub qms_tfr_max: bool, pub dsc: *const di_cta_hdmi_dsc, } #[test] fn bindgen_test_layout_di_cta_hdmi_scds() { 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_cta_hdmi_scds)) ); assert_eq!( ::std::mem::align_of::(), 8usize, concat!("Alignment of ", stringify!(di_cta_hdmi_scds)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).version) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_cta_hdmi_scds), "::", stringify!(version) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).max_tmds_char_rate_mhz) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", stringify!(di_cta_hdmi_scds), "::", stringify!(max_tmds_char_rate_mhz) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).supports_3d_osd_disparity) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", stringify!(di_cta_hdmi_scds), "::", stringify!(supports_3d_osd_disparity) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).supports_3d_dual_view) as usize - ptr as usize }, 9usize, concat!( "Offset of field: ", stringify!(di_cta_hdmi_scds), "::", stringify!(supports_3d_dual_view) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).supports_3d_independent_view) as usize - ptr as usize }, 10usize, concat!( "Offset of field: ", stringify!(di_cta_hdmi_scds), "::", stringify!(supports_3d_independent_view) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).supports_lte_340mcsc_scramble) as usize - ptr as usize }, 11usize, concat!( "Offset of field: ", stringify!(di_cta_hdmi_scds), "::", stringify!(supports_lte_340mcsc_scramble) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).supports_ccbpci) as usize - ptr as usize }, 12usize, concat!( "Offset of field: ", stringify!(di_cta_hdmi_scds), "::", stringify!(supports_ccbpci) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).supports_cable_status) as usize - ptr as usize }, 13usize, concat!( "Offset of field: ", stringify!(di_cta_hdmi_scds), "::", stringify!(supports_cable_status) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).supports_scdc_read_request) as usize - ptr as usize }, 14usize, concat!( "Offset of field: ", stringify!(di_cta_hdmi_scds), "::", stringify!(supports_scdc_read_request) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).supports_scdc) as usize - ptr as usize }, 15usize, concat!( "Offset of field: ", stringify!(di_cta_hdmi_scds), "::", stringify!(supports_scdc) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).supports_dc_30bit_420) as usize - ptr as usize }, 16usize, concat!( "Offset of field: ", stringify!(di_cta_hdmi_scds), "::", stringify!(supports_dc_30bit_420) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).supports_dc_36bit_420) as usize - ptr as usize }, 17usize, concat!( "Offset of field: ", stringify!(di_cta_hdmi_scds), "::", stringify!(supports_dc_36bit_420) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).supports_dc_48bit_420) as usize - ptr as usize }, 18usize, concat!( "Offset of field: ", stringify!(di_cta_hdmi_scds), "::", stringify!(supports_dc_48bit_420) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).supports_uhd_vic) as usize - ptr as usize }, 19usize, concat!( "Offset of field: ", stringify!(di_cta_hdmi_scds), "::", stringify!(supports_uhd_vic) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).max_frl_rate) as usize - ptr as usize }, 20usize, concat!( "Offset of field: ", stringify!(di_cta_hdmi_scds), "::", stringify!(max_frl_rate) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).supports_fapa_start_location) as usize - ptr as usize }, 24usize, concat!( "Offset of field: ", stringify!(di_cta_hdmi_scds), "::", stringify!(supports_fapa_start_location) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).supports_allm) as usize - ptr as usize }, 25usize, concat!( "Offset of field: ", stringify!(di_cta_hdmi_scds), "::", stringify!(supports_allm) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).supports_fva) as usize - ptr as usize }, 26usize, concat!( "Offset of field: ", stringify!(di_cta_hdmi_scds), "::", stringify!(supports_fva) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).supports_neg_mvrr) as usize - ptr as usize }, 27usize, concat!( "Offset of field: ", stringify!(di_cta_hdmi_scds), "::", stringify!(supports_neg_mvrr) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).supports_cinema_vrr) as usize - ptr as usize }, 28usize, concat!( "Offset of field: ", stringify!(di_cta_hdmi_scds), "::", stringify!(supports_cinema_vrr) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).m_delta) as usize - ptr as usize }, 29usize, concat!( "Offset of field: ", stringify!(di_cta_hdmi_scds), "::", stringify!(m_delta) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).supports_qms) as usize - ptr as usize }, 30usize, concat!( "Offset of field: ", stringify!(di_cta_hdmi_scds), "::", stringify!(supports_qms) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).supports_fapa_end_extended) as usize - ptr as usize }, 31usize, concat!( "Offset of field: ", stringify!(di_cta_hdmi_scds), "::", stringify!(supports_fapa_end_extended) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).vrr_min_hz) as usize - ptr as usize }, 32usize, concat!( "Offset of field: ", stringify!(di_cta_hdmi_scds), "::", stringify!(vrr_min_hz) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).vrr_max_hz) as usize - ptr as usize }, 36usize, concat!( "Offset of field: ", stringify!(di_cta_hdmi_scds), "::", stringify!(vrr_max_hz) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).qms_tfr_min) as usize - ptr as usize }, 40usize, concat!( "Offset of field: ", stringify!(di_cta_hdmi_scds), "::", stringify!(qms_tfr_min) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).qms_tfr_max) as usize - ptr as usize }, 41usize, concat!( "Offset of field: ", stringify!(di_cta_hdmi_scds), "::", stringify!(qms_tfr_max) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).dsc) as usize - ptr as usize }, 48usize, concat!( "Offset of field: ", stringify!(di_cta_hdmi_scds), "::", stringify!(dsc) ) ); } #[doc = " HDMI Forum vendor-specific data block (HF-VSDB).\n\n This block is defined in HDMI 2.1 section 10.3.2."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_cta_vendor_hdmi_forum_block { pub scds: di_cta_hdmi_scds, } #[test] fn bindgen_test_layout_di_cta_vendor_hdmi_forum_block() { 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_cta_vendor_hdmi_forum_block)) ); assert_eq!( ::std::mem::align_of::(), 8usize, concat!("Alignment of ", stringify!(di_cta_vendor_hdmi_forum_block)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).scds) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_cta_vendor_hdmi_forum_block), "::", stringify!(scds) ) ); } extern "C" { #[doc = " Get the vendor-specific HDMI Forum information from a CTA data block.\n\n Note, the HDMI and HDMI Forum vendor-specific data blocks are different.\n\n Returns NULL if the data block tag is not\n DI_CTA_DATA_BLOCK_VENDOR_HDMI_FORUM."] pub fn di_cta_data_block_get_vendor_hdmi_forum( block: *const di_cta_data_block, ) -> *const di_cta_vendor_hdmi_forum_block; } #[doc = " HDMI Forum Sink Capability Data Block (HF-SCDB).\n\n This block is defined in HDMI 2.1a"] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_cta_hdmi_forum_sink_cap { pub scds: di_cta_hdmi_scds, } #[test] fn bindgen_test_layout_di_cta_hdmi_forum_sink_cap() { 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_cta_hdmi_forum_sink_cap)) ); assert_eq!( ::std::mem::align_of::(), 8usize, concat!("Alignment of ", stringify!(di_cta_hdmi_forum_sink_cap)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).scds) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_cta_hdmi_forum_sink_cap), "::", stringify!(scds) ) ); } extern "C" { #[doc = " Get the HDMI Forum Sink Capability (HF-SCDB) from a CTA data block.\n\n Returns NULL if the data block tag is not\n DI_CTA_DATA_BLOCK_HDMI_SINK_CAP."] pub fn di_cta_data_block_get_hdmi_sink_cap( block: *const di_cta_data_block, ) -> *const di_cta_hdmi_forum_sink_cap; } pub const di_cta_svr_type_DI_CTA_SVR_TYPE_VIC: di_cta_svr_type = 0; pub const di_cta_svr_type_DI_CTA_SVR_TYPE_DTD_INDEX: di_cta_svr_type = 1; pub const di_cta_svr_type_DI_CTA_SVR_TYPE_T7T10VTDB: di_cta_svr_type = 2; pub const di_cta_svr_type_DI_CTA_SVR_TYPE_FIRST_T8VTDB: di_cta_svr_type = 3; 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)] 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] 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) ) ); } #[doc = " Video Format Preference Data Block, defined in section 7.5.12."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_cta_video_format_pref_block { pub svrs: *const *const di_cta_svr, } #[test] fn bindgen_test_layout_di_cta_video_format_pref_block() { 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_video_format_pref_block)) ); assert_eq!( ::std::mem::align_of::(), 8usize, concat!("Alignment of ", stringify!(di_cta_video_format_pref_block)) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).svrs) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", stringify!(di_cta_video_format_pref_block), "::", stringify!(svrs) ) ); } extern "C" { #[doc = " Get the Video Format Preference information from a CTA data block.\n\n Returns NULL if the data block tag is not\n DI_CTA_DATA_BLOCK_VIDEO_FORMAT_PREF."] pub fn di_cta_data_block_get_video_format_pref( block: *const di_cta_data_block, ) -> *const di_cta_video_format_pref_block; } libdisplay-info-sys-0.3.0/src/v0_3/cvt.rs000064400000000000000000000175431046102023000162370ustar 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.3.0/src/v0_3/displayid.rs000064400000000000000000001024761046102023000174250ustar 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; } 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; } pub const di_displayid_type_iii_timing_algo_DI_DISPLAYID_TYPE_III_TIMING_CVT_STANDARD_BLANKING: di_displayid_type_iii_timing_algo = 0; 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."] 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)] 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] 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) ) ); } 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.3.0/src/v0_3/displayid2.rs000064400000000000000000000037561046102023000175100ustar 00000000000000/* automatically generated by rust-bindgen 0.68.1 */ #[doc = " DisplayID v2 data structure."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_displayid2 { _unused: [u8; 0], } extern "C" { #[doc = " Get the DisplayID v2 revision."] pub fn di_displayid2_get_revision(displayid2: *const di_displayid2) -> ::std::os::raw::c_int; } pub const di_displayid2_product_primary_use_case_DI_DISPLAYID2_PRODUCT_PRIMARY_USE_CASE_EXTENSION : di_displayid2_product_primary_use_case = 0 ; pub const di_displayid2_product_primary_use_case_DI_DISPLAYID2_PRODUCT_PRIMARY_USE_CASE_TEST: di_displayid2_product_primary_use_case = 1; pub const di_displayid2_product_primary_use_case_DI_DISPLAYID2_PRODUCT_PRIMARY_USE_CASE_GENERIC: di_displayid2_product_primary_use_case = 2; pub const di_displayid2_product_primary_use_case_DI_DISPLAYID2_PRODUCT_PRIMARY_USE_CASE_TV: di_displayid2_product_primary_use_case = 3; pub const di_displayid2_product_primary_use_case_DI_DISPLAYID2_PRODUCT_PRIMARY_USE_CASE_DESKTOP_PRODUCTIVITY : di_displayid2_product_primary_use_case = 4 ; pub const di_displayid2_product_primary_use_case_DI_DISPLAYID2_PRODUCT_PRIMARY_USE_CASE_DESKTOP_GAMING : di_displayid2_product_primary_use_case = 5 ; pub const di_displayid2_product_primary_use_case_DI_DISPLAYID2_PRODUCT_PRIMARY_USE_CASE_PRESENTATION : di_displayid2_product_primary_use_case = 6 ; pub const di_displayid2_product_primary_use_case_DI_DISPLAYID2_PRODUCT_PRIMARY_USE_CASE_HMD_VR: di_displayid2_product_primary_use_case = 7; pub const di_displayid2_product_primary_use_case_DI_DISPLAYID2_PRODUCT_PRIMARY_USE_CASE_HMD_AR: di_displayid2_product_primary_use_case = 8; #[doc = " Product primary use case identifier, defined in table 2-3."] pub type di_displayid2_product_primary_use_case = ::std::os::raw::c_uint; extern "C" { #[doc = " Get the DisplayID v2 product primary use case."] pub fn di_displayid2_get_product_primary_use_case( displayid2: *const di_displayid2, ) -> di_displayid2_product_primary_use_case; } libdisplay-info-sys-0.3.0/src/v0_3/dmt.rs000064400000000000000000000126451046102023000162250ustar 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.3.0/src/v0_3/edid.rs000064400000000000000000002302451046102023000163440ustar 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) ) ); } #[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: i64, 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] 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 or if\n the block does not contain a version 1 DisplayID blob."] pub fn di_edid_ext_get_displayid(ext: *const di_edid_ext) -> *const di_displayid; } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct di_displayid2 { _unused: [u8; 0], } extern "C" { #[doc = " Get a DisplayID v2 extension block.\n\n Returns NULL if the extension block tag is not DI_EDID_EXT_DISPLAYID or if\n the block does not contain a version 2 DisplayID blob."] pub fn di_edid_ext_get_displayid2(ext: *const di_edid_ext) -> *const di_displayid2; } libdisplay-info-sys-0.3.0/src/v0_3/gtf.rs000064400000000000000000000176751046102023000162310ustar 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.3.0/src/v0_3/info.rs000064400000000000000000000350031046102023000163650ustar 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)] 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] 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) ) ); } 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)] pub struct di_chromaticity_cie1931 { pub x: f32, pub y: f32, } #[test] 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)] 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] 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) ) ); } 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)] 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] 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) ) ); } 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; } 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.3.0/src/v0_3/mod.rs000064400000000000000000000001671046102023000162140ustar 00000000000000pub mod cta; pub mod cvt; pub mod displayid; pub mod displayid2; pub mod dmt; pub mod edid; pub mod gtf; pub mod info;